Lines Matching +full:negative +full:- +full:phase
1 // SPDX-License-Identifier: GPL-2.0-or-later
18 #include <linux/hwmon-sysfs.h>
38 u8 phase; /* phase number, 0xff for all phases */ member
44 Negative if there was a read error */
106 s16 currpage; /* current page, -1 for unknown/unset */
107 s16 currphase; /* current phase, 0xff for all, -1 for unknown/unset */
145 for (sensor = data->sensors; sensor; sensor = sensor->next) in pmbus_clear_cache()
146 sensor->data = -ENODATA; in pmbus_clear_cache()
155 for (sensor = data->sensors; sensor; sensor = sensor->next) in pmbus_set_update()
156 if (sensor->reg == reg) in pmbus_set_update()
157 sensor->update = update; in pmbus_set_update()
161 int pmbus_set_page(struct i2c_client *client, int page, int phase) in pmbus_set_page() argument
169 if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL) && in pmbus_set_page()
170 data->info->pages > 1 && page != data->currpage) { in pmbus_set_page()
180 return -EIO; in pmbus_set_page()
182 data->currpage = page; in pmbus_set_page()
184 if (data->info->phases[page] && data->currphase != phase && in pmbus_set_page()
185 !(data->info->func[page] & PMBUS_PHASE_VIRTUAL)) { in pmbus_set_page()
187 phase); in pmbus_set_page()
191 data->currphase = phase; in pmbus_set_page()
216 const struct pmbus_driver_info *info = data->info; in _pmbus_write_byte()
219 if (info->write_byte) { in _pmbus_write_byte()
220 status = info->write_byte(client, page, value); in _pmbus_write_byte()
221 if (status != -ENODATA) in _pmbus_write_byte()
250 id = reg - PMBUS_VIRT_FAN_TARGET_1; in pmbus_write_virt_reg()
255 rv = -ENXIO; in pmbus_write_virt_reg()
270 const struct pmbus_driver_info *info = data->info; in _pmbus_write_word_data()
273 if (info->write_word_data) { in _pmbus_write_word_data()
274 status = info->write_word_data(client, page, reg, word); in _pmbus_write_word_data()
275 if (status != -ENODATA) in _pmbus_write_word_data()
292 const struct pmbus_driver_info *info = data->info; in _pmbus_write_byte_data()
295 if (info->write_byte_data) { in _pmbus_write_byte_data()
296 status = info->write_byte_data(client, page, reg, value); in _pmbus_write_byte_data()
297 if (status != -ENODATA) in _pmbus_write_byte_data()
310 const struct pmbus_driver_info *info = data->info; in _pmbus_read_byte_data()
313 if (info->read_byte_data) { in _pmbus_read_byte_data()
314 status = info->read_byte_data(client, page, reg); in _pmbus_read_byte_data()
315 if (status != -ENODATA) in _pmbus_read_byte_data()
346 int pmbus_read_word_data(struct i2c_client *client, int page, int phase, u8 reg) in pmbus_read_word_data() argument
350 rv = pmbus_set_page(client, page, phase); in pmbus_read_word_data()
365 id = reg - PMBUS_VIRT_FAN_TARGET_1; in pmbus_read_virt_reg()
369 rv = -ENXIO; in pmbus_read_virt_reg()
381 int phase, int reg) in _pmbus_read_word_data() argument
384 const struct pmbus_driver_info *info = data->info; in _pmbus_read_word_data()
387 if (info->read_word_data) { in _pmbus_read_word_data()
388 status = info->read_word_data(client, page, phase, reg); in _pmbus_read_word_data()
389 if (status != -ENODATA) in _pmbus_read_word_data()
396 return pmbus_read_word_data(client, page, phase, reg); in _pmbus_read_word_data()
399 /* Same as above, but without phase parameter, for use in check functions */
465 for (sensor = data->sensors; sensor; sensor = sensor->next) { in pmbus_find_sensor()
466 if (sensor->page == page && sensor->reg == reg) in pmbus_find_sensor()
470 return ERR_PTR(-EINVAL); in pmbus_find_sensor()
491 return s->data; in pmbus_get_fan_rate()
532 for (i = 0; i < data->info->pages; i++) in pmbus_clear_faults()
542 status = data->read_status(client, -1); in pmbus_check_status_cml()
544 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML); in pmbus_check_status_cml()
546 return -EIO; in pmbus_check_status_cml()
560 if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) in pmbus_check_register()
562 if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK)) in pmbus_check_register()
563 data->read_status(client, -1); in pmbus_check_register()
565 pmbus_clear_fault_page(client, -1); in pmbus_check_register()
574 status = data->read_status(client, page); in pmbus_check_status_register()
575 if (status >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK) && in pmbus_check_status_register()
577 status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML); in pmbus_check_status_register()
579 status = -EIO; in pmbus_check_status_register()
582 pmbus_clear_fault_page(client, -1); in pmbus_check_status_register()
606 if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) in pmbus_check_block_register()
608 if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK)) in pmbus_check_block_register()
609 data->read_status(client, -1); in pmbus_check_block_register()
610 pmbus_clear_fault_page(client, -1); in pmbus_check_block_register()
618 return data->info; in pmbus_get_driver_info()
629 status = data->read_status(client, page); in pmbus_get_status()
642 if (sensor->data < 0 || sensor->update) in pmbus_update_sensor_data()
643 sensor->data = _pmbus_read_word_data(client, sensor->page, in pmbus_update_sensor_data()
644 sensor->phase, sensor->reg); in pmbus_update_sensor_data()
648 * Convert ieee754 sensor values to milli- or micro-units
658 * v=(−1)^signbit * 2^(exponent - 15) * 1.significantbits
674 sign = sensor->data & 0x8000; in pmbus_reg2data_ieee754()
675 exponent = (sensor->data >> 10) & 0x1f; in pmbus_reg2data_ieee754()
676 val = sensor->data & 0x3ff; in pmbus_reg2data_ieee754()
679 exponent = -(14 + 10); in pmbus_reg2data_ieee754()
684 exponent -= (15 + 10); /* normal */ in pmbus_reg2data_ieee754()
688 /* scale result to milli-units for all sensors except fans */ in pmbus_reg2data_ieee754()
689 if (sensor->class != PSC_FAN) in pmbus_reg2data_ieee754()
692 /* scale result to micro-units for power sensors */ in pmbus_reg2data_ieee754()
693 if (sensor->class == PSC_POWER) in pmbus_reg2data_ieee754()
699 val >>= -exponent; in pmbus_reg2data_ieee754()
702 val = -val; in pmbus_reg2data_ieee754()
708 * Convert linear sensor values to milli- or micro-units
718 if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */ in pmbus_reg2data_linear()
719 exponent = data->exponent[sensor->page]; in pmbus_reg2data_linear()
720 mantissa = (u16) sensor->data; in pmbus_reg2data_linear()
722 exponent = ((s16)sensor->data) >> 11; in pmbus_reg2data_linear()
723 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5; in pmbus_reg2data_linear()
728 /* scale result to milli-units for all sensors except fans */ in pmbus_reg2data_linear()
729 if (sensor->class != PSC_FAN) in pmbus_reg2data_linear()
732 /* scale result to micro-units for power sensors */ in pmbus_reg2data_linear()
733 if (sensor->class == PSC_POWER) in pmbus_reg2data_linear()
739 val >>= -exponent; in pmbus_reg2data_linear()
745 * Convert direct sensor values to milli- or micro-units
751 s64 b, val = (s16)sensor->data; in pmbus_reg2data_direct()
754 m = data->info->m[sensor->class]; in pmbus_reg2data_direct()
755 b = data->info->b[sensor->class]; in pmbus_reg2data_direct()
756 R = data->info->R[sensor->class]; in pmbus_reg2data_direct()
761 /* X = 1/m * (Y * 10^-R - b) */ in pmbus_reg2data_direct()
762 R = -R; in pmbus_reg2data_direct()
763 /* scale result to milli-units for everything but fans */ in pmbus_reg2data_direct()
764 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) { in pmbus_reg2data_direct()
769 /* scale result to micro-units for power sensors */ in pmbus_reg2data_direct()
770 if (sensor->class == PSC_POWER) { in pmbus_reg2data_direct()
777 R--; in pmbus_reg2data_direct()
784 val = div_s64(val - b, m); in pmbus_reg2data_direct()
789 * Convert VID sensor values to milli- or micro-units
795 long val = sensor->data; in pmbus_reg2data_vid()
798 switch (data->info->vrm_version[sensor->page]) { in pmbus_reg2data_vid()
801 rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100); in pmbus_reg2data_vid()
805 rv = 250 + (val - 1) * 5; in pmbus_reg2data_vid()
809 rv = 500 + (val - 1) * 10; in pmbus_reg2data_vid()
813 rv = 200 + (val - 1) * 10; in pmbus_reg2data_vid()
817 rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100); in pmbus_reg2data_vid()
827 if (!sensor->convert) in pmbus_reg2data()
828 return sensor->data; in pmbus_reg2data()
830 switch (data->info->format[sensor->class]) { in pmbus_reg2data()
864 val = -val; in pmbus_data2reg_ieee754()
868 if (sensor->class == PSC_POWER) in pmbus_data2reg_ieee754()
872 * For simplicity, convert fan data to milli-units in pmbus_data2reg_ieee754()
875 if (sensor->class == PSC_FAN) in pmbus_data2reg_ieee754()
888 exponent--; in pmbus_data2reg_ieee754()
892 /* Convert mantissa from milli-units to units */ in pmbus_data2reg_ieee754()
919 bool negative = false; in pmbus_data2reg_linear() local
925 if (sensor->class == PSC_VOLTAGE_OUT) { in pmbus_data2reg_linear()
926 /* LINEAR16 does not support negative voltages */ in pmbus_data2reg_linear()
934 if (data->exponent[sensor->page] < 0) in pmbus_data2reg_linear()
935 val <<= -data->exponent[sensor->page]; in pmbus_data2reg_linear()
937 val >>= data->exponent[sensor->page]; in pmbus_data2reg_linear()
943 negative = true; in pmbus_data2reg_linear()
944 val = -val; in pmbus_data2reg_linear()
948 if (sensor->class == PSC_POWER) in pmbus_data2reg_linear()
952 * For simplicity, convert fan data to milli-units in pmbus_data2reg_linear()
955 if (sensor->class == PSC_FAN) in pmbus_data2reg_linear()
964 while (val < MIN_LIN_MANTISSA && exponent > -15) { in pmbus_data2reg_linear()
965 exponent--; in pmbus_data2reg_linear()
969 /* Convert mantissa from milli-units to units */ in pmbus_data2reg_linear()
973 if (negative) in pmbus_data2reg_linear()
974 mantissa = -mantissa; in pmbus_data2reg_linear()
986 m = data->info->m[sensor->class]; in pmbus_data2reg_direct()
987 b = data->info->b[sensor->class]; in pmbus_data2reg_direct()
988 R = data->info->R[sensor->class]; in pmbus_data2reg_direct()
991 if (sensor->class == PSC_POWER) { in pmbus_data2reg_direct()
992 R -= 3; in pmbus_data2reg_direct()
997 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) { in pmbus_data2reg_direct()
998 R -= 3; /* Adjust R and b for data in milli-units */ in pmbus_data2reg_direct()
1005 R--; in pmbus_data2reg_direct()
1020 return 2 + DIV_ROUND_CLOSEST_ULL((1600LL - val) * 100LL, 625); in pmbus_data2reg_vid()
1028 if (!sensor->convert) in pmbus_data2reg()
1031 switch (data->info->format[sensor->class]) { in pmbus_data2reg()
1069 * If a negative value is stored in any of the referenced registers, this value
1076 struct pmbus_sensor *s1 = b->s1; in pmbus_get_boolean()
1077 struct pmbus_sensor *s2 = b->s2; in pmbus_get_boolean()
1084 mutex_lock(&data->update_lock); in pmbus_get_boolean()
1105 if (s1->data < 0) { in pmbus_get_boolean()
1106 ret = s1->data; in pmbus_get_boolean()
1109 if (s2->data < 0) { in pmbus_get_boolean()
1110 ret = s2->data; in pmbus_get_boolean()
1121 mutex_unlock(&data->update_lock); in pmbus_get_boolean()
1130 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_show_boolean()
1133 val = pmbus_get_boolean(client, boolean, attr->index); in pmbus_show_boolean()
1142 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_show_sensor()
1147 mutex_lock(&data->update_lock); in pmbus_show_sensor()
1149 if (sensor->data < 0) in pmbus_show_sensor()
1150 ret = sensor->data; in pmbus_show_sensor()
1153 mutex_unlock(&data->update_lock); in pmbus_show_sensor()
1161 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_set_sensor()
1170 return -EINVAL; in pmbus_set_sensor()
1172 mutex_lock(&data->update_lock); in pmbus_set_sensor()
1174 ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval); in pmbus_set_sensor()
1178 sensor->data = -ENODATA; in pmbus_set_sensor()
1179 mutex_unlock(&data->update_lock); in pmbus_set_sensor()
1188 return sysfs_emit(buf, "%s\n", label->label); in pmbus_show_label()
1193 if (data->num_attributes >= data->max_attributes - 1) { in pmbus_add_attribute()
1194 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE; in pmbus_add_attribute()
1195 void *new_attrs = devm_krealloc_array(data->dev, data->group.attrs, in pmbus_add_attribute()
1199 return -ENOMEM; in pmbus_add_attribute()
1200 data->group.attrs = new_attrs; in pmbus_add_attribute()
1201 data->max_attributes = new_max_attrs; in pmbus_add_attribute()
1204 data->group.attrs[data->num_attributes++] = attr; in pmbus_add_attribute()
1205 data->group.attrs[data->num_attributes] = NULL; in pmbus_add_attribute()
1219 sysfs_attr_init(&dev_attr->attr); in pmbus_dev_attr_init()
1220 dev_attr->attr.name = name; in pmbus_dev_attr_init()
1221 dev_attr->attr.mode = mode; in pmbus_dev_attr_init()
1222 dev_attr->show = show; in pmbus_dev_attr_init()
1223 dev_attr->store = store; in pmbus_dev_attr_init()
1237 pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store); in pmbus_attr_init()
1238 a->index = idx; in pmbus_attr_init()
1251 return -EINVAL; in pmbus_add_boolean()
1253 boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL); in pmbus_add_boolean()
1255 return -ENOMEM; in pmbus_add_boolean()
1257 a = &boolean->attribute; in pmbus_add_boolean()
1259 snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s", in pmbus_add_boolean()
1261 boolean->s1 = s1; in pmbus_add_boolean()
1262 boolean->s2 = s2; in pmbus_add_boolean()
1263 pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL, in pmbus_add_boolean()
1266 return pmbus_add_attribute(data, &a->dev_attr.attr); in pmbus_add_boolean()
1278 struct pmbus_sensor *sensor = tdata->sensor; in pmbus_thermal_get_temp()
1279 struct pmbus_data *pmbus_data = tdata->pmbus_data; in pmbus_thermal_get_temp()
1280 struct i2c_client *client = to_i2c_client(pmbus_data->dev); in pmbus_thermal_get_temp()
1281 struct device *dev = pmbus_data->hwmon_dev; in pmbus_thermal_get_temp()
1290 mutex_lock(&pmbus_data->update_lock); in pmbus_thermal_get_temp()
1292 if (sensor->data < 0) in pmbus_thermal_get_temp()
1293 ret = sensor->data; in pmbus_thermal_get_temp()
1296 mutex_unlock(&pmbus_data->update_lock); in pmbus_thermal_get_temp()
1308 struct device *dev = pmbus_data->dev; in pmbus_thermal_add_sensor()
1314 return -ENOMEM; in pmbus_thermal_add_sensor()
1316 tdata->sensor = sensor; in pmbus_thermal_add_sensor()
1317 tdata->pmbus_data = pmbus_data; in pmbus_thermal_add_sensor()
1322 * If CONFIG_THERMAL_OF is disabled, this returns -ENODEV, in pmbus_thermal_add_sensor()
1325 if (IS_ERR(tzd) && (PTR_ERR(tzd) != -ENODEV)) in pmbus_thermal_add_sensor()
1333 int seq, int page, int phase, in pmbus_add_sensor() argument
1342 sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL); in pmbus_add_sensor()
1345 a = &sensor->attribute; in pmbus_add_sensor()
1348 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s", in pmbus_add_sensor()
1351 snprintf(sensor->name, sizeof(sensor->name), "%s%d", in pmbus_add_sensor()
1354 if (data->flags & PMBUS_WRITE_PROTECTED) in pmbus_add_sensor()
1357 sensor->page = page; in pmbus_add_sensor()
1358 sensor->phase = phase; in pmbus_add_sensor()
1359 sensor->reg = reg; in pmbus_add_sensor()
1360 sensor->class = class; in pmbus_add_sensor()
1361 sensor->update = update; in pmbus_add_sensor()
1362 sensor->convert = convert; in pmbus_add_sensor()
1363 sensor->data = -ENODATA; in pmbus_add_sensor()
1364 pmbus_dev_attr_init(a, sensor->name, in pmbus_add_sensor()
1368 if (pmbus_add_attribute(data, &a->attr)) in pmbus_add_sensor()
1371 sensor->next = data->sensors; in pmbus_add_sensor()
1372 data->sensors = sensor; in pmbus_add_sensor()
1383 const char *lstring, int index, int phase) in pmbus_add_label() argument
1388 label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL); in pmbus_add_label()
1390 return -ENOMEM; in pmbus_add_label()
1392 a = &label->attribute; in pmbus_add_label()
1394 snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq); in pmbus_add_label()
1396 if (phase == 0xff) in pmbus_add_label()
1397 strncpy(label->label, lstring, in pmbus_add_label()
1398 sizeof(label->label) - 1); in pmbus_add_label()
1400 snprintf(label->label, sizeof(label->label), "%s.%d", in pmbus_add_label()
1401 lstring, phase); in pmbus_add_label()
1403 if (phase == 0xff) in pmbus_add_label()
1404 snprintf(label->label, sizeof(label->label), "%s%d", in pmbus_add_label()
1407 snprintf(label->label, sizeof(label->label), "%s%d.%d", in pmbus_add_label()
1408 lstring, index, phase); in pmbus_add_label()
1411 pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL); in pmbus_add_label()
1412 return pmbus_add_attribute(data, &a->attr); in pmbus_add_label()
1465 const struct pmbus_limit_attr *l = attr->limit; in pmbus_add_limit_attrs()
1466 int nlimit = attr->nlimit; in pmbus_add_limit_attrs()
1472 if (pmbus_check_word_register(client, page, l->reg)) { in pmbus_add_limit_attrs()
1473 curr = pmbus_add_sensor(data, name, l->attr, index, in pmbus_add_limit_attrs()
1474 page, 0xff, l->reg, attr->class, in pmbus_add_limit_attrs()
1475 attr->update || l->update, in pmbus_add_limit_attrs()
1478 return -ENOMEM; in pmbus_add_limit_attrs()
1479 if (l->sbit && (info->func[page] & attr->sfunc)) { in pmbus_add_limit_attrs()
1481 l->alarm, index, in pmbus_add_limit_attrs()
1482 attr->compare ? l->low ? curr : base in pmbus_add_limit_attrs()
1484 attr->compare ? l->low ? base : curr in pmbus_add_limit_attrs()
1486 page, attr->sreg, l->sbit); in pmbus_add_limit_attrs()
1501 int index, int page, int phase, in pmbus_add_sensor_attrs_one() argument
1506 bool upper = !!(attr->gbit & 0xff00); /* need to check STATUS_WORD */ in pmbus_add_sensor_attrs_one()
1509 if (attr->label) { in pmbus_add_sensor_attrs_one()
1510 ret = pmbus_add_label(data, name, index, attr->label, in pmbus_add_sensor_attrs_one()
1511 paged ? page + 1 : 0, phase); in pmbus_add_sensor_attrs_one()
1515 base = pmbus_add_sensor(data, name, "input", index, page, phase, in pmbus_add_sensor_attrs_one()
1516 attr->reg, attr->class, true, true, true); in pmbus_add_sensor_attrs_one()
1518 return -ENOMEM; in pmbus_add_sensor_attrs_one()
1519 /* No limit and alarm attributes for phase specific sensors */ in pmbus_add_sensor_attrs_one()
1520 if (attr->sfunc && phase == 0xff) { in pmbus_add_sensor_attrs_one()
1531 if (!ret && attr->gbit && in pmbus_add_sensor_attrs_one()
1532 (!upper || data->has_status_word) && in pmbus_add_sensor_attrs_one()
1537 attr->gbit); in pmbus_add_sensor_attrs_one()
1550 if (attr->paged) in pmbus_sensor_is_paged()
1559 * order to maintain the un-suffixed labels in the case where the in pmbus_sensor_is_paged()
1562 for (p = 1; p < info->pages; p++) { in pmbus_sensor_is_paged()
1563 if (info->func[p] & attr->func) in pmbus_sensor_is_paged()
1575 const struct pmbus_driver_info *info = data->info; in pmbus_add_sensor_attrs()
1584 pages = paged ? info->pages : 1; in pmbus_add_sensor_attrs()
1586 if (info->func[page] & attrs->func) { in pmbus_add_sensor_attrs()
1594 if (info->phases[page]) { in pmbus_add_sensor_attrs()
1595 int phase; in pmbus_add_sensor_attrs() local
1597 for (phase = 0; phase < info->phases[page]; in pmbus_add_sensor_attrs()
1598 phase++) { in pmbus_add_sensor_attrs()
1599 if (!(info->pfunc[phase] & attrs->func)) in pmbus_add_sensor_attrs()
1603 phase, attrs, paged); in pmbus_add_sensor_attrs()
2149 return -ENOMEM; in pmbus_add_fan_ctrl()
2151 if (!((data->info->func[page] & PMBUS_HAVE_PWM12) || in pmbus_add_fan_ctrl()
2152 (data->info->func[page] & PMBUS_HAVE_PWM34))) in pmbus_add_fan_ctrl()
2160 return -ENOMEM; in pmbus_add_fan_ctrl()
2167 return -ENOMEM; in pmbus_add_fan_ctrl()
2175 const struct pmbus_driver_info *info = data->info; in pmbus_add_fan_attributes()
2180 for (page = 0; page < info->pages; page++) { in pmbus_add_fan_attributes()
2186 if (!(info->func[page] & pmbus_fan_flags[f])) in pmbus_add_fan_attributes()
2207 return -ENOMEM; in pmbus_add_fan_attributes()
2222 if ((info->func[page] & pmbus_fan_status_flags[f]) && in pmbus_add_fan_attributes()
2284 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_show_samples()
2288 mutex_lock(&data->update_lock); in pmbus_show_samples()
2289 val = _pmbus_read_word_data(client, reg->page, 0xff, reg->attr->reg); in pmbus_show_samples()
2290 mutex_unlock(&data->update_lock); in pmbus_show_samples()
2303 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_set_samples()
2308 return -EINVAL; in pmbus_set_samples()
2310 mutex_lock(&data->update_lock); in pmbus_set_samples()
2311 ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val); in pmbus_set_samples()
2312 mutex_unlock(&data->update_lock); in pmbus_set_samples()
2322 reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL); in pmbus_add_samples_attr()
2324 return -ENOMEM; in pmbus_add_samples_attr()
2326 reg->attr = attr; in pmbus_add_samples_attr()
2327 reg->page = page; in pmbus_add_samples_attr()
2329 pmbus_dev_attr_init(®->dev_attr, attr->name, 0644, in pmbus_add_samples_attr()
2332 return pmbus_add_attribute(data, ®->dev_attr.attr); in pmbus_add_samples_attr()
2338 const struct pmbus_driver_info *info = data->info; in pmbus_add_samples_attributes()
2341 if (!(info->func[0] & PMBUS_HAVE_SAMPLES)) in pmbus_add_samples_attributes()
2349 if (!pmbus_check_word_register(client, 0, attr->reg)) in pmbus_add_samples_attributes()
2445 enum pmbus_sensor_classes class = attr->class; in pmbus_read_coefficients()
2450 data.block[1] = attr->reg; in pmbus_read_coefficients()
2453 rv = i2c_smbus_xfer(client->adapter, client->addr, client->flags, in pmbus_read_coefficients()
2461 return -EIO; in pmbus_read_coefficients()
2466 info->m[class] = m; in pmbus_read_coefficients()
2467 info->b[class] = b; in pmbus_read_coefficients()
2468 info->R[class] = R; in pmbus_read_coefficients()
2476 int i, n, ret = -EINVAL; in pmbus_init_coefficients()
2482 if (info->format[map->class] != direct) in pmbus_init_coefficients()
2484 for (n = 0; n < map->nattr; n++) { in pmbus_init_coefficients()
2485 attr = &map->attr[n]; in pmbus_init_coefficients()
2486 if (map->class != attr->class) in pmbus_init_coefficients()
2493 dev_err(&client->dev, in pmbus_init_coefficients()
2495 map->class); in pmbus_init_coefficients()
2496 return -EINVAL; in pmbus_init_coefficients()
2510 int vout_mode = -1; in pmbus_identify_common()
2522 if (data->info->format[PSC_VOLTAGE_OUT] != linear) in pmbus_identify_common()
2523 return -ENODEV; in pmbus_identify_common()
2525 data->exponent[page] = ((s8)(vout_mode << 3)) >> 3; in pmbus_identify_common()
2528 if (data->info->format[PSC_VOLTAGE_OUT] != vid) in pmbus_identify_common()
2529 return -ENODEV; in pmbus_identify_common()
2532 if (data->info->format[PSC_VOLTAGE_OUT] != direct) in pmbus_identify_common()
2533 return -ENODEV; in pmbus_identify_common()
2536 if (data->info->format[PSC_VOLTAGE_OUT] != ieee754) in pmbus_identify_common()
2537 return -ENODEV; in pmbus_identify_common()
2540 return -ENODEV; in pmbus_identify_common()
2564 return sysfs_emit(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC)); in pec_show()
2579 client->flags |= I2C_CLIENT_PEC; in pec_store()
2581 client->flags &= ~I2C_CLIENT_PEC; in pec_store()
2596 struct device *dev = &client->dev; in pmbus_init_common()
2603 client->flags &= ~I2C_CLIENT_PEC; in pmbus_init_common()
2606 if (!(data->flags & PMBUS_NO_CAPABILITY)) { in pmbus_init_common()
2609 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_PEC)) in pmbus_init_common()
2610 client->flags |= I2C_CLIENT_PEC; in pmbus_init_common()
2619 data->read_status = pmbus_read_status_word; in pmbus_init_common()
2622 data->read_status = pmbus_read_status_byte; in pmbus_init_common()
2626 return -ENODEV; in pmbus_init_common()
2629 data->has_status_word = true; in pmbus_init_common()
2637 if (!(data->flags & PMBUS_NO_WRITE_PROTECT)) { in pmbus_init_common()
2640 data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK; in pmbus_init_common()
2643 if (data->info->pages) in pmbus_init_common()
2646 pmbus_clear_fault_page(client, -1); in pmbus_init_common()
2648 if (info->identify) { in pmbus_init_common()
2649 ret = (*info->identify)(client, info); in pmbus_init_common()
2656 if (info->pages <= 0 || info->pages > PMBUS_PAGES) { in pmbus_init_common()
2657 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages); in pmbus_init_common()
2658 return -ENODEV; in pmbus_init_common()
2661 for (page = 0; page < info->pages; page++) { in pmbus_init_common()
2669 if (data->flags & PMBUS_USE_COEFFICIENTS_CMD) { in pmbus_init_common()
2670 if (!i2c_check_functionality(client->adapter, in pmbus_init_common()
2672 return -ENODEV; in pmbus_init_common()
2679 if (client->flags & I2C_CLIENT_PEC) { in pmbus_init_common()
2701 /* PMBus->regulator bit mappings for a PMBus status register */
2705 const struct pmbus_status_assoc *bits; /* zero-terminated */
2765 mutex_lock(&data->update_lock); in pmbus_is_enabled()
2767 mutex_unlock(&data->update_lock); in pmbus_is_enabled()
2779 for (i = 0; i < data->num_attributes; i++) { in pmbus_notify()
2780 struct device_attribute *da = to_dev_attr(data->group.attrs[i]); in pmbus_notify()
2782 int index = attr->index; in pmbus_notify()
2788 dev_dbg(data->dev, "sysfs notify: %s", da->attr.name); in pmbus_notify()
2789 sysfs_notify(&data->dev->kobj, NULL, da->attr.name); in pmbus_notify()
2790 kobject_uevent(&data->dev->kobj, KOBJ_CHANGE); in pmbus_notify()
2805 struct device *dev = data->dev; in _pmbus_get_flags()
2807 int func = data->info->func[page]; in _pmbus_get_flags()
2814 if (!(func & cat->func)) in _pmbus_get_flags()
2817 status = _pmbus_read_byte_data(client, page, cat->reg); in _pmbus_get_flags()
2821 for (bit = cat->bits; bit->pflag; bit++) in _pmbus_get_flags()
2822 if (status & bit->pflag) { in _pmbus_get_flags()
2823 *flags |= bit->rflag; in _pmbus_get_flags()
2824 *event |= bit->eflag; in _pmbus_get_flags()
2828 pmbus_notify(data, page, cat->reg, status); in _pmbus_get_flags()
2872 * a (conservative) best-effort interpretation. in _pmbus_get_flags()
2889 mutex_lock(&data->update_lock); in pmbus_get_flags()
2891 mutex_unlock(&data->update_lock); in pmbus_get_flags()
2900 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_regulator_is_enabled()
2908 struct i2c_client *client = to_i2c_client(dev->parent); in _pmbus_regulator_on_off()
2913 mutex_lock(&data->update_lock); in _pmbus_regulator_on_off()
2917 mutex_unlock(&data->update_lock); in _pmbus_regulator_on_off()
2935 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_regulator_get_error_flags()
2945 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_regulator_get_status()
2951 mutex_lock(&data->update_lock); in pmbus_regulator_get_status()
2982 mutex_unlock(&data->update_lock); in pmbus_regulator_get_status()
2993 .data = -1, in pmbus_regulator_get_low_margin()
2996 if (data->vout_low[page] < 0) { in pmbus_regulator_get_low_margin()
3006 data->vout_low[page] = pmbus_reg2data(data, &s); in pmbus_regulator_get_low_margin()
3009 return data->vout_low[page]; in pmbus_regulator_get_low_margin()
3019 .data = -1, in pmbus_regulator_get_high_margin()
3022 if (data->vout_high[page] < 0) { in pmbus_regulator_get_high_margin()
3032 data->vout_high[page] = pmbus_reg2data(data, &s); in pmbus_regulator_get_high_margin()
3035 return data->vout_high[page]; in pmbus_regulator_get_high_margin()
3041 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_regulator_get_voltage()
3060 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_regulator_set_voltage()
3066 .data = -1, in pmbus_regulator_set_voltage()
3096 struct i2c_client *client = to_i2c_client(dev->parent); in pmbus_regulator_list_voltage()
3099 if (selector >= rdev->desc->n_voltages || in pmbus_regulator_list_voltage()
3100 selector < rdev->desc->linear_min_sel) in pmbus_regulator_list_voltage()
3101 return -EINVAL; in pmbus_regulator_list_voltage()
3103 selector -= rdev->desc->linear_min_sel; in pmbus_regulator_list_voltage()
3104 val = DIV_ROUND_CLOSEST(rdev->desc->min_uV + in pmbus_regulator_list_voltage()
3105 (rdev->desc->uV_step * selector), 1000); /* convert to mV */ in pmbus_regulator_list_voltage()
3135 struct device *dev = data->dev; in pmbus_regulator_register()
3136 const struct pmbus_driver_info *info = data->info; in pmbus_regulator_register()
3140 data->rdevs = devm_kzalloc(dev, sizeof(struct regulator_dev *) * info->num_regulators, in pmbus_regulator_register()
3142 if (!data->rdevs) in pmbus_regulator_register()
3143 return -ENOMEM; in pmbus_regulator_register()
3145 for (i = 0; i < info->num_regulators; i++) { in pmbus_regulator_register()
3151 if (pdata && pdata->reg_init_data) in pmbus_regulator_register()
3152 config.init_data = &pdata->reg_init_data[i]; in pmbus_regulator_register()
3154 data->rdevs[i] = devm_regulator_register(dev, &info->reg_desc[i], in pmbus_regulator_register()
3156 if (IS_ERR(data->rdevs[i])) in pmbus_regulator_register()
3157 return dev_err_probe(dev, PTR_ERR(data->rdevs[i]), in pmbus_regulator_register()
3159 info->reg_desc[i].name); in pmbus_regulator_register()
3169 for (j = 0; j < data->info->num_regulators; j++) { in pmbus_regulator_notify()
3170 if (page == rdev_get_id(data->rdevs[j])) { in pmbus_regulator_notify()
3171 regulator_notifier_call_chain(data->rdevs[j], event, NULL); in pmbus_regulator_notify()
3197 struct i2c_client *client = to_i2c_client(data->dev); in pmbus_fault_handler()
3200 mutex_lock(&data->update_lock); in pmbus_fault_handler()
3201 for (i = 0; i < data->info->pages; i++) { in pmbus_fault_handler()
3209 mutex_unlock(&data->update_lock); in pmbus_fault_handler()
3216 struct device *dev = &client->dev; in pmbus_irq_setup()
3226 if (!client->irq) in pmbus_irq_setup()
3229 for (i = 0; i < data->info->pages; i++) { in pmbus_irq_setup()
3230 func = data->info->func[i]; in pmbus_irq_setup()
3234 if (!(func & cat->func)) in pmbus_irq_setup()
3237 for (bit = cat->bits; bit->pflag; bit++) in pmbus_irq_setup()
3238 mask |= bit->pflag; in pmbus_irq_setup()
3240 err = pmbus_write_smbalert_mask(client, i, cat->reg, ~mask); in pmbus_irq_setup()
3243 cat->reg); in pmbus_irq_setup()
3251 err = devm_request_threaded_irq(dev, client->irq, NULL, pmbus_fault_handler, in pmbus_irq_setup()
3252 IRQF_ONESHOT, "pmbus-irq", data); in pmbus_irq_setup()
3268 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); in pmbus_debugfs_get()
3270 rc = mutex_lock_interruptible(&pdata->update_lock); in pmbus_debugfs_get()
3273 rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg); in pmbus_debugfs_get()
3274 mutex_unlock(&pdata->update_lock); in pmbus_debugfs_get()
3289 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); in pmbus_debugfs_get_status()
3291 rc = mutex_lock_interruptible(&pdata->update_lock); in pmbus_debugfs_get_status()
3294 rc = pdata->read_status(entry->client, entry->page); in pmbus_debugfs_get_status()
3295 mutex_unlock(&pdata->update_lock); in pmbus_debugfs_get_status()
3310 struct pmbus_debugfs_entry *entry = file->private_data; in pmbus_debugfs_mfr_read()
3311 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); in pmbus_debugfs_mfr_read()
3314 rc = mutex_lock_interruptible(&pdata->update_lock); in pmbus_debugfs_mfr_read()
3317 rc = pmbus_read_block_data(entry->client, entry->page, entry->reg, in pmbus_debugfs_mfr_read()
3319 mutex_unlock(&pdata->update_lock); in pmbus_debugfs_mfr_read()
3354 return -ENODEV; in pmbus_init_debugfs()
3360 data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev), in pmbus_init_debugfs()
3362 if (IS_ERR_OR_NULL(data->debugfs)) { in pmbus_init_debugfs()
3363 data->debugfs = NULL; in pmbus_init_debugfs()
3364 return -ENODEV; in pmbus_init_debugfs()
3369 * 6 entries device-specific in pmbus_init_debugfs()
3370 * 10 entries page-specific in pmbus_init_debugfs()
3372 entries = devm_kcalloc(data->dev, in pmbus_init_debugfs()
3373 6 + data->info->pages * 10, sizeof(*entries), in pmbus_init_debugfs()
3376 return -ENOMEM; in pmbus_init_debugfs()
3379 * Add device-specific entries. in pmbus_init_debugfs()
3381 * page-specific. in pmbus_init_debugfs()
3390 debugfs_create_file("mfr_id", 0444, data->debugfs, in pmbus_init_debugfs()
3399 debugfs_create_file("mfr_model", 0444, data->debugfs, in pmbus_init_debugfs()
3408 debugfs_create_file("mfr_revision", 0444, data->debugfs, in pmbus_init_debugfs()
3417 debugfs_create_file("mfr_location", 0444, data->debugfs, in pmbus_init_debugfs()
3426 debugfs_create_file("mfr_date", 0444, data->debugfs, in pmbus_init_debugfs()
3435 debugfs_create_file("mfr_serial", 0444, data->debugfs, in pmbus_init_debugfs()
3441 for (i = 0; i < data->info->pages; ++i) { in pmbus_init_debugfs()
3448 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3453 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) { in pmbus_init_debugfs()
3458 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3463 if (data->info->func[i] & PMBUS_HAVE_STATUS_IOUT) { in pmbus_init_debugfs()
3468 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3473 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) { in pmbus_init_debugfs()
3478 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3483 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) { in pmbus_init_debugfs()
3488 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3498 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3508 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3519 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3524 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) { in pmbus_init_debugfs()
3529 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3534 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) { in pmbus_init_debugfs()
3539 debugfs_create_file(name, 0444, data->debugfs, in pmbus_init_debugfs()
3545 return devm_add_action_or_reset(data->dev, in pmbus_init_debugfs()
3546 pmbus_remove_debugfs, data->debugfs); in pmbus_init_debugfs()
3558 struct device *dev = &client->dev; in pmbus_do_probe()
3567 return -ENODEV; in pmbus_do_probe()
3569 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE in pmbus_do_probe()
3572 return -ENODEV; in pmbus_do_probe()
3576 return -ENOMEM; in pmbus_do_probe()
3578 if (info->groups) in pmbus_do_probe()
3579 while (info->groups[groups_num]) in pmbus_do_probe()
3582 data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *), in pmbus_do_probe()
3584 if (!data->groups) in pmbus_do_probe()
3585 return -ENOMEM; in pmbus_do_probe()
3588 mutex_init(&data->update_lock); in pmbus_do_probe()
3589 data->dev = dev; in pmbus_do_probe()
3592 data->flags = pdata->flags; in pmbus_do_probe()
3593 data->info = info; in pmbus_do_probe()
3594 data->currpage = -1; in pmbus_do_probe()
3595 data->currphase = -1; in pmbus_do_probe()
3597 for (i = 0; i < ARRAY_SIZE(data->vout_low); i++) { in pmbus_do_probe()
3598 data->vout_low[i] = -1; in pmbus_do_probe()
3599 data->vout_high[i] = -1; in pmbus_do_probe()
3614 if (!data->num_attributes) { in pmbus_do_probe()
3616 return -ENODEV; in pmbus_do_probe()
3619 name = devm_kstrdup(dev, client->name, GFP_KERNEL); in pmbus_do_probe()
3621 return -ENOMEM; in pmbus_do_probe()
3622 strreplace(name, '-', '_'); in pmbus_do_probe()
3624 data->groups[0] = &data->group; in pmbus_do_probe()
3625 memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num); in pmbus_do_probe()
3626 data->hwmon_dev = devm_hwmon_device_register_with_groups(dev, in pmbus_do_probe()
3627 name, data, data->groups); in pmbus_do_probe()
3628 if (IS_ERR(data->hwmon_dev)) { in pmbus_do_probe()
3630 return PTR_ERR(data->hwmon_dev); in pmbus_do_probe()
3653 return data->debugfs; in pmbus_get_debugfs_dir()
3661 return mutex_lock_interruptible(&data->update_lock); in pmbus_lock_interruptible()
3669 mutex_unlock(&data->update_lock); in pmbus_unlock()