Lines Matching full:st
161 struct ltc4282_state *st = container_of(hw, struct ltc4282_state,
168 return regmap_update_bits(st->map, LTC4282_CLK_DIV, LTC4282_CLKOUT_MASK,
194 struct ltc4282_state *st = container_of(hw, struct ltc4282_state,
199 ret = regmap_read(st->map, LTC4282_CLK_DIV, &clkdiv);
214 struct ltc4282_state *st = container_of(clk_hw, struct ltc4282_state,
217 regmap_clear_bits(st->map, LTC4282_CLK_DIV, LTC4282_CLKOUT_MASK);
220 static int ltc4282_read_voltage_word(const struct ltc4282_state *st, u32 reg,
226 ret = regmap_bulk_read(st->map, reg, &in, sizeof(in));
238 static int ltc4282_read_voltage_byte_cached(const struct ltc4282_state *st,
248 ret = regmap_read(st->map, reg, &in);
257 static int ltc4282_read_voltage_byte(const struct ltc4282_state *st, u32 reg,
260 return ltc4282_read_voltage_byte_cached(st, reg, fs, val, NULL);
263 static int __ltc4282_read_alarm(struct ltc4282_state *st, u32 reg, u32 mask,
269 ret = regmap_read(st->map, reg, &alarm);
277 return regmap_clear_bits(st->map, reg, mask);
282 static int ltc4282_read_alarm(struct ltc4282_state *st, u32 reg, u32 mask,
285 guard(mutex)(&st->lock);
286 return __ltc4282_read_alarm(st, reg, mask, val);
289 static int ltc4282_vdd_source_read_in(struct ltc4282_state *st, u32 channel,
292 guard(mutex)(&st->lock);
293 if (!st->in0_1_cache[channel].en)
296 return ltc4282_read_voltage_word(st, LTC4282_VSOURCE, st->vfs_out, val);
299 static int ltc4282_vdd_source_read_hist(struct ltc4282_state *st, u32 reg,
304 guard(mutex)(&st->lock);
305 if (!st->in0_1_cache[channel].en) {
310 ret = ltc4282_read_voltage_word(st, reg, st->vfs_out, val);
318 static int ltc4282_vdd_source_read_lim(struct ltc4282_state *st, u32 reg,
321 guard(mutex)(&st->lock);
322 if (!st->in0_1_cache[channel].en)
323 return ltc4282_read_voltage_byte_cached(st, reg, st->vfs_out,
326 return ltc4282_read_voltage_byte(st, reg, st->vfs_out, val);
329 static int ltc4282_vdd_source_read_alm(struct ltc4282_state *st, u32 mask,
332 guard(mutex)(&st->lock);
333 if (!st->in0_1_cache[channel].en) {
346 return __ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG, mask, val);
349 static int ltc4282_read_in(struct ltc4282_state *st, u32 attr, long *val,
355 return ltc4282_read_voltage_word(st, LTC4282_VGPIO,
358 return ltc4282_vdd_source_read_in(st, channel, val);
361 return ltc4282_read_voltage_word(st,
365 return ltc4282_vdd_source_read_hist(st, LTC4282_VSOURCE_HIGHEST,
367 &st->in0_1_cache[channel].in_highest, val);
370 return ltc4282_read_voltage_word(st, LTC4282_VGPIO_LOWEST,
373 return ltc4282_vdd_source_read_hist(st, LTC4282_VSOURCE_LOWEST,
375 &st->in0_1_cache[channel].in_lowest, val);
378 return ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG,
382 return ltc4282_vdd_source_read_alm(st,
387 ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG,
390 return ltc4282_vdd_source_read_alm(st,
394 return ltc4282_read_alarm(st, LTC4282_STATUS_LSB,
397 return ltc4282_read_alarm(st, LTC4282_STATUS_LSB,
401 return ltc4282_read_voltage_byte(st, LTC4282_VGPIO_MAX,
404 return ltc4282_vdd_source_read_lim(st, LTC4282_VSOURCE_MAX,
406 &st->in0_1_cache[channel].in_max_raw, val);
409 return ltc4282_read_voltage_byte(st, LTC4282_VGPIO_MIN,
412 return ltc4282_vdd_source_read_lim(st, LTC4282_VSOURCE_MIN,
414 &st->in0_1_cache[channel].in_min_raw, val);
416 scoped_guard(mutex, &st->lock) {
417 *val = st->in0_1_cache[channel].en;
425 return ltc4282_read_alarm(st, LTC4282_STATUS_LSB,
432 static int ltc4282_read_current_word(const struct ltc4282_state *st, u32 reg,
442 ret = ltc4282_read_voltage_word(st, reg, DECA * 40 * MILLI, &in);
446 *val = DIV_ROUND_CLOSEST(in * MILLI, st->rsense);
451 static int ltc4282_read_current_byte(const struct ltc4282_state *st, u32 reg,
457 ret = ltc4282_read_voltage_byte(st, reg, DECA * 40 * MILLI, &in);
461 *val = DIV_ROUND_CLOSEST(in * MILLI, st->rsense);
466 static int ltc4282_read_curr(struct ltc4282_state *st, const u32 attr,
471 return ltc4282_read_current_word(st, LTC4282_VSENSE, val);
473 return ltc4282_read_current_word(st, LTC4282_VSENSE_HIGHEST,
476 return ltc4282_read_current_word(st, LTC4282_VSENSE_LOWEST,
479 return ltc4282_read_current_byte(st, LTC4282_VSENSE_MAX, val);
481 return ltc4282_read_current_byte(st, LTC4282_VSENSE_MIN, val);
483 return ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG,
486 return ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG,
489 return ltc4282_read_alarm(st, LTC4282_STATUS_LSB,
496 static int ltc4282_read_power_word(const struct ltc4282_state *st, u32 reg,
499 u64 temp = DECA * 40ULL * st->vfs_out * BIT(16), temp_2;
504 ret = regmap_bulk_read(st->map, reg, &raw, sizeof(raw));
516 U16_MAX * (u64)st->rsense);
521 st->rsense * int_pow(U16_MAX, 2));
526 static int ltc4282_read_power_byte(const struct ltc4282_state *st, u32 reg,
533 ret = regmap_read(st->map, reg, &power);
537 temp = power * 40 * DECA * st->vfs_out * BIT_ULL(8);
539 int_pow(U8_MAX, 2) * st->rsense);
544 static int ltc4282_read_energy(const struct ltc4282_state *st, u64 *val)
550 ret = regmap_bulk_read(st->map, LTC4282_ENERGY, &raw, 6);
567 if (check_mul_overflow(DECA * st->vfs_out * 40 * BIT(8), energy, &temp)) {
568 temp = DIV_ROUND_CLOSEST(DECA * st->vfs_out * 40 * BIT(8), U16_MAX);
569 *val = DIV_ROUND_CLOSEST_ULL(temp * energy, st->rsense);
573 *val = DIV64_U64_ROUND_CLOSEST(temp, U16_MAX * (u64)st->rsense);
578 static int ltc4282_read_power(struct ltc4282_state *st, const u32 attr,
583 return ltc4282_read_power_word(st, LTC4282_POWER, val);
585 return ltc4282_read_power_word(st, LTC4282_POWER_HIGHEST, val);
587 return ltc4282_read_power_word(st, LTC4282_POWER_LOWEST, val);
589 return ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG,
592 return ltc4282_read_alarm(st, LTC4282_ADC_ALERT_LOG,
595 return ltc4282_read_power_byte(st, LTC4282_POWER_MAX, val);
597 return ltc4282_read_power_byte(st, LTC4282_POWER_MIN, val);
606 struct ltc4282_state *st = dev_get_drvdata(dev);
610 return ltc4282_read_in(st, attr, val, channel);
612 return ltc4282_read_curr(st, attr, val);
614 return ltc4282_read_power(st, attr, val);
616 scoped_guard(mutex, &st->lock) {
617 *val = st->energy_en;
625 static int ltc4282_write_power_byte(const struct ltc4282_state *st, u32 reg,
631 if (val > st->power_max)
632 val = st->power_max;
634 temp = val * int_pow(U8_MAX, 2) * st->rsense;
636 MICRO * DECA * 256ULL * st->vfs_out * 40);
638 return regmap_write(st->map, reg, power);
641 static int ltc4282_write_power_word(const struct ltc4282_state *st, u32 reg,
644 u64 temp = int_pow(U16_MAX, 2) * st->rsense, temp_2;
651 40ULL * BIT(16) * st->vfs_out);
653 temp = DECA * MICRO * 40ULL * BIT(16) * st->vfs_out;
658 return regmap_bulk_write(st->map, reg, &__raw, sizeof(__raw));
661 static int __ltc4282_in_write_history(const struct ltc4282_state *st, u32 reg,
672 ret = regmap_bulk_write(st->map, reg, &__raw, 2);
680 return regmap_bulk_write(st->map, reg + 2, &__raw, 2);
683 static int ltc4282_in_write_history(struct ltc4282_state *st, u32 reg,
686 guard(mutex)(&st->lock);
687 return __ltc4282_in_write_history(st, reg, lowest, highest, fs);
690 static int ltc4282_power_reset_hist(struct ltc4282_state *st)
694 guard(mutex)(&st->lock);
696 ret = ltc4282_write_power_word(st, LTC4282_POWER_LOWEST,
697 st->power_max);
701 ret = ltc4282_write_power_word(st, LTC4282_POWER_HIGHEST, 0);
706 return regmap_clear_bits(st->map, LTC4282_FAULT_LOG,
710 static int ltc4282_write_power(struct ltc4282_state *st, u32 attr,
715 return ltc4282_write_power_byte(st, LTC4282_POWER_MAX, val);
717 return ltc4282_write_power_byte(st, LTC4282_POWER_MIN, val);
719 return ltc4282_power_reset_hist(st);
725 static int ltc4282_write_voltage_byte_cached(const struct ltc4282_state *st,
739 return regmap_write(st->map, reg, in);
742 static int ltc4282_write_voltage_byte(const struct ltc4282_state *st, u32 reg,
745 return ltc4282_write_voltage_byte_cached(st, reg, fs, val, NULL);
748 static int ltc4282_cache_history(struct ltc4282_state *st, u32 channel)
753 ret = ltc4282_read_voltage_word(st, LTC4282_VSOURCE_LOWEST, st->vfs_out,
758 st->in0_1_cache[channel].in_lowest = val;
760 ret = ltc4282_read_voltage_word(st, LTC4282_VSOURCE_HIGHEST,
761 st->vfs_out, &val);
765 st->in0_1_cache[channel].in_highest = val;
767 ret = regmap_read(st->map, LTC4282_VSOURCE_MIN,
768 &st->in0_1_cache[channel].in_min_raw);
772 return regmap_read(st->map, LTC4282_VSOURCE_MAX,
773 &st->in0_1_cache[channel].in_max_raw);
776 static int ltc4282_cache_sync(struct ltc4282_state *st, u32 channel)
780 ret = __ltc4282_in_write_history(st, LTC4282_VSOURCE_LOWEST,
781 st->in0_1_cache[channel].in_lowest,
782 st->in0_1_cache[channel].in_highest,
783 st->vfs_out);
787 ret = regmap_write(st->map, LTC4282_VSOURCE_MIN,
788 st->in0_1_cache[channel].in_min_raw);
792 return regmap_write(st->map, LTC4282_VSOURCE_MAX,
793 st->in0_1_cache[channel].in_max_raw);
796 static int ltc4282_vdd_source_write_lim(struct ltc4282_state *st, u32 reg,
801 guard(mutex)(&st->lock);
802 if (st->in0_1_cache[channel].en)
803 ret = ltc4282_write_voltage_byte(st, reg, st->vfs_out, val);
805 ret = ltc4282_write_voltage_byte_cached(st, reg, st->vfs_out,
811 static int ltc4282_vdd_source_reset_hist(struct ltc4282_state *st, int channel)
813 long lowest = st->vfs_out;
817 lowest = st->vdd;
819 guard(mutex)(&st->lock);
820 if (st->in0_1_cache[channel].en) {
821 ret = __ltc4282_in_write_history(st, LTC4282_VSOURCE_LOWEST,
822 lowest, 0, st->vfs_out);
827 st->in0_1_cache[channel].in_lowest = lowest;
828 st->in0_1_cache[channel].in_highest = 0;
839 return regmap_clear_bits(st->map, LTC4282_FAULT_LOG,
842 return regmap_clear_bits(st->map, LTC4282_FAULT_LOG,
853 static int ltc4282_vdd_source_enable(struct ltc4282_state *st, int channel,
859 guard(mutex)(&st->lock);
860 if (st->in0_1_cache[channel].en == !!val)
867 ret = regmap_update_bits(st->map, LTC4282_ILIM_ADJUST,
873 st->in0_1_cache[channel].en = !!val;
874 st->in0_1_cache[other_chan].en = !val;
876 if (st->in0_1_cache[channel].en) {
881 ret = ltc4282_cache_history(st, other_chan);
885 return ltc4282_cache_sync(st, channel);
891 ret = ltc4282_cache_history(st, channel);
895 return ltc4282_cache_sync(st, other_chan);
898 static int ltc4282_write_in(struct ltc4282_state *st, u32 attr, long val,
904 return ltc4282_write_voltage_byte(st, LTC4282_VGPIO_MAX,
907 return ltc4282_vdd_source_write_lim(st, LTC4282_VSOURCE_MAX,
909 &st->in0_1_cache[channel].in_max_raw, val);
912 return ltc4282_write_voltage_byte(st, LTC4282_VGPIO_MIN,
915 return ltc4282_vdd_source_write_lim(st, LTC4282_VSOURCE_MIN,
917 &st->in0_1_cache[channel].in_min_raw, val);
920 return ltc4282_in_write_history(st,
924 return ltc4282_vdd_source_reset_hist(st, channel);
926 return ltc4282_vdd_source_enable(st, channel, val);
932 static int ltc4282_curr_reset_hist(struct ltc4282_state *st)
936 guard(mutex)(&st->lock);
938 ret = __ltc4282_in_write_history(st, LTC4282_VSENSE_LOWEST,
939 st->vsense_max, 0, 40 * MILLI);
944 return regmap_clear_bits(st->map, LTC4282_FAULT_LOG,
948 static int ltc4282_write_curr(struct ltc4282_state *st, u32 attr,
952 u32 in = DIV_ROUND_CLOSEST_ULL((u64)val * st->rsense, DECA * MICRO);
956 return ltc4282_write_voltage_byte(st, LTC4282_VSENSE_MAX, 40,
959 return ltc4282_write_voltage_byte(st, LTC4282_VSENSE_MIN, 40,
962 return ltc4282_curr_reset_hist(st);
968 static int ltc4282_energy_enable_set(struct ltc4282_state *st, long val)
972 guard(mutex)(&st->lock);
974 ret = regmap_update_bits(st->map, LTC4282_ADC_CTRL,
980 st->energy_en = !!val;
989 struct ltc4282_state *st = dev_get_drvdata(dev);
993 return ltc4282_write_power(st, attr, val);
995 return ltc4282_write_in(st, attr, val, channel);
997 return ltc4282_write_curr(st, attr, val);
999 return ltc4282_energy_enable_set(st, val);
1005 static umode_t ltc4282_in_is_visible(const struct ltc4282_state *st, u32 attr)
1112 struct ltc4282_state *st = dev_get_drvdata(dev);
1116 guard(mutex)(&st->lock);
1117 if (!st->energy_en)
1120 ret = ltc4282_read_energy(st, &energy);
1134 static int ltc428_clk_provider_setup(struct ltc4282_state *st,
1150 st->clk_hw.init = &init;
1152 ret = devm_clk_hw_register(dev, &st->clk_hw);
1157 &st->clk_hw);
1160 static int ltc428_clks_setup(struct ltc4282_state *st, struct device *dev)
1167 ret = ltc428_clk_provider_setup(st, dev);
1191 return regmap_update_bits(st->map, LTC4282_CLK_DIV,
1200 static int ltc4282_get_defaults(struct ltc4282_state *st, u32 *vin_mode)
1205 ret = regmap_read(st->map, LTC4282_ADC_CTRL, ®_val);
1209 st->energy_en = !FIELD_GET(LTC4282_METER_HALT_MASK, reg_val);
1211 ret = regmap_read(st->map, LTC4282_CTRL_MSB, ®_val);
1217 ret = regmap_read(st->map, LTC4282_ILIM_ADJUST, ®_val);
1222 st->vsense_max = ltc4282_curr_lim_uv[ilm_adjust];
1224 st->in0_1_cache[LTC4282_CHAN_VSOURCE].en = FIELD_GET(LTC4282_VDD_MONITOR_MASK,
1226 if (!st->in0_1_cache[LTC4282_CHAN_VSOURCE].en) {
1227 st->in0_1_cache[LTC4282_CHAN_VDD].en = true;
1228 return regmap_read(st->map, LTC4282_VSOURCE_MAX,
1229 &st->in0_1_cache[LTC4282_CHAN_VSOURCE].in_max_raw);
1232 return regmap_read(st->map, LTC4282_VSOURCE_MAX,
1233 &st->in0_1_cache[LTC4282_CHAN_VDD].in_max_raw);
1246 static int ltc4282_set_max_limits(struct ltc4282_state *st)
1250 ret = ltc4282_write_voltage_byte(st, LTC4282_VSENSE_MAX, 40 * MILLI,
1251 st->vsense_max);
1256 st->power_max = DIV_ROUND_CLOSEST(st->vsense_max * DECA * MILLI, st->rsense) * st->vfs_out;
1257 ret = ltc4282_write_power_byte(st, LTC4282_POWER_MAX, st->power_max);
1261 if (st->in0_1_cache[LTC4282_CHAN_VDD].en) {
1262 st->in0_1_cache[LTC4282_CHAN_VSOURCE].in_lowest = st->vfs_out;
1263 return __ltc4282_in_write_history(st, LTC4282_VSOURCE_LOWEST,
1264 st->vdd, 0, st->vfs_out);
1267 st->in0_1_cache[LTC4282_CHAN_VDD].in_lowest = st->vdd;
1268 return __ltc4282_in_write_history(st, LTC4282_VSOURCE_LOWEST,
1269 st->vfs_out, 0, st->vfs_out);
1280 static int ltc4282_gpio_setup(struct ltc4282_state *st, struct device *dev)
1294 ret = regmap_update_bits(st->map, LTC4282_GPIO_CONFIG,
1311 ret = regmap_set_bits(st->map, LTC4282_ILIM_ADJUST,
1314 ret = regmap_update_bits(st->map, LTC4282_GPIO_CONFIG,
1330 return regmap_clear_bits(st->map, LTC4282_ILIM_ADJUST,
1350 static int ltc4282_setup(struct ltc4282_state *st, struct device *dev)
1357 ret = ltc4282_get_defaults(st, &vin_mode);
1362 &st->rsense);
1366 if (st->rsense < CENTI)
1377 st->rsense /= CENTI;
1401 ret = regmap_update_bits(st->map, LTC4282_CTRL_MSB,
1408 ret = regmap_update_bits(st->map, LTC4282_ILIM_ADJUST,
1415 st->vfs_out = ltc4282_vfs_milli[val];
1416 st->vdd = ltc4282_vdd_milli[val];
1419 &st->vsense_max);
1451 st->vsense_max);
1454 ret = regmap_update_bits(st->map, LTC4282_ILIM_ADJUST,
1461 ret = ltc4282_set_max_limits(st);
1475 ret = regmap_update_bits(st->map, LTC4282_CTRL_MSB,
1490 ret = regmap_update_bits(st->map, LTC4282_CTRL_MSB,
1496 ret = regmap_set_bits(st->map, LTC4282_CTRL_LSB,
1503 ret = regmap_clear_bits(st->map, LTC4282_CTRL_LSB,
1510 ret = regmap_clear_bits(st->map, LTC4282_CTRL_LSB,
1517 ret = regmap_set_bits(st->map, LTC4282_ADC_CTRL, LTC4282_FAULT_LOG_EN_MASK);
1529 ret = regmap_write(st->map, LTC4282_FET_BAD_FAULT_TIMEOUT, val);
1534 return ltc4282_gpio_setup(st, dev);
1617 struct ltc4282_state *st = arg;
1621 ret = ltc4282_read_alarm(st, LTC4282_FAULT_LOG, mask, &alarm);
1672 static void ltc4282_debugfs_init(struct ltc4282_state *st, struct i2c_client *i2c)
1674 debugfs_create_file_unsafe("power1_bad_fault_log", 0400, i2c->debugfs, st,
1676 debugfs_create_file_unsafe("in0_fet_short_fault_log", 0400, i2c->debugfs, st,
1678 debugfs_create_file_unsafe("in0_fet_bad_fault_log", 0400, i2c->debugfs, st,
1680 debugfs_create_file_unsafe("in1_crit_fault_log", 0400, i2c->debugfs, st,
1682 debugfs_create_file_unsafe("in1_lcrit_fault_log", 0400, i2c->debugfs, st,
1684 debugfs_create_file_unsafe("curr1_crit_fault_log", 0400, i2c->debugfs, st,
1691 struct ltc4282_state *st;
1694 st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);
1695 if (!st)
1699 st->map = devm_regmap_init_i2c(i2c, <c4282_regmap_config);
1700 if (IS_ERR(st->map))
1701 return dev_err_probe(dev, PTR_ERR(st->map),
1705 ret = regmap_set_bits(st->map, LTC4282_ADC_CTRL, LTC4282_RESET_MASK);
1712 ret = ltc428_clks_setup(st, dev);
1716 ret = ltc4282_setup(st, dev);
1720 mutex_init(&st->lock);
1721 hwmon = devm_hwmon_device_register_with_info(dev, "ltc4282", st,
1727 ltc4282_debugfs_init(st, i2c);