Lines Matching refs:data
65 * and extended mode. They are mostly compatible with LM90 except for a data
235 * Driver data (common to all clients)
291 .data = (void *)adm1032
295 .data = (void *)adt7461
299 .data = (void *)adt7461a
303 .data = (void *)adt7481
307 .data = (void *)g781
311 .data = (void *)lm90
315 .data = (void *)lm90
319 .data = (void *)lm90
323 .data = (void *)lm99
327 .data = (void *)max6646
331 .data = (void *)max6646
335 .data = (void *)max6646
339 .data = (void *)max6654
343 .data = (void *)max6657
347 .data = (void *)max6657
351 .data = (void *)max6659
355 .data = (void *)max6680
359 .data = (void *)max6680
363 .data = (void *)max6696
367 .data = (void *)max6696
371 .data = (void *)adt7461a
375 .data = (void *)nct72
379 .data = (void *)nct72
383 .data = (void *)nct72
387 .data = (void *)w83l771
391 .data = (void *)sa56004
395 .data = (void *)tmp451
399 .data = (void *)tmp461
682 * Client data (each client gets its own)
752 struct lm90_data *data = i2c_get_clientdata(client);
754 (data->flags & LM90_HAVE_PARTIAL_PEC);
847 static int lm90_update_confreg(struct lm90_data *data, u8 config)
849 if (data->config != config) {
852 err = lm90_write_reg(data->client, LM90_REG_CONFIG1, config);
855 data->config = config;
868 static int lm90_select_remote_channel(struct lm90_data *data, bool second)
870 u8 config = data->config & ~0x08;
875 return lm90_update_confreg(data, config);
878 static int lm90_write_convrate(struct lm90_data *data, int val)
880 u8 config = data->config;
884 if (data->flags & LM90_PAUSE_FOR_CONFIG) {
885 err = lm90_update_confreg(data, config | 0x40);
891 err = lm90_write_reg(data->client, LM90_REG_CONVRATE, val);
894 lm90_update_confreg(data, config);
904 static int lm90_set_convrate(struct i2c_client *client, struct lm90_data *data,
915 i < data->max_convrate; i++, update_interval >>= 1)
919 err = lm90_write_convrate(data, i);
920 data->update_interval = DIV_ROUND_CLOSEST(update_interval, 64);
925 struct lm90_data *data, int val)
929 if (data->faultqueue_mask) {
930 err = lm90_update_confreg(data, val <= data->faultqueue_depth / 2 ?
931 data->config & ~data->faultqueue_mask :
932 data->config | data->faultqueue_mask);
936 data->conalert = (data->conalert & 0xf1) | values[val - 1];
937 err = lm90_write_reg(data->client, TMP451_REG_CONALERT,
938 data->conalert);
946 struct lm90_data *data = dev_get_drvdata(dev);
947 struct i2c_client *client = data->client;
950 if (data->flags & LM90_HAVE_CRIT) {
954 data->temp[LOCAL_CRIT] = val << 8;
959 data->temp[REMOTE_CRIT] = val << 8;
964 data->temp_hyst = val;
966 if ((data->flags & LM90_HAVE_FAULTQUEUE) && !data->faultqueue_mask) {
970 data->conalert = val;
974 (data->flags & LM90_HAVE_REM_LIMIT_EXT) ? LM90_REG_REMOTE_LOWL : 0,
978 data->temp[REMOTE_LOW] = val;
981 (data->flags & LM90_HAVE_REM_LIMIT_EXT) ? LM90_REG_REMOTE_HIGHL : 0,
985 data->temp[REMOTE_HIGH] = val;
987 if (data->flags & LM90_HAVE_OFFSET) {
992 data->temp[REMOTE_OFFSET] = val;
995 if (data->flags & LM90_HAVE_EMERGENCY) {
999 data->temp[LOCAL_EMERG] = val << 8;
1004 data->temp[REMOTE_EMERG] = val << 8;
1007 if (data->flags & LM90_HAVE_TEMP3) {
1008 val = lm90_select_remote_channel(data, true);
1015 data->temp[REMOTE2_CRIT] = val << 8;
1017 if (data->flags & LM90_HAVE_EMERGENCY) {
1021 data->temp[REMOTE2_EMERG] = val << 8;
1027 data->temp[REMOTE2_LOW] = val << 8;
1032 data->temp[REMOTE2_HIGH] = val << 8;
1034 if (data->flags & LM90_HAVE_OFFSET) {
1039 data->temp[REMOTE2_OFFSET] = val;
1042 lm90_select_remote_channel(data, false);
1050 struct lm90_data *data = container_of(work, struct lm90_data, report_work);
1052 struct device *hwmon_dev = data->hwmon_dev;
1053 struct device *dev = &data->client->dev;
1056 current_alarms = data->current_alarms;
1057 cleared_alarms = data->reported_alarms & ~current_alarms;
1058 new_alarms = current_alarms & ~data->reported_alarms;
1111 data->reported_alarms = current_alarms;
1114 static int lm90_update_alarms_locked(struct lm90_data *data, bool force)
1116 if (force || !data->alarms_valid ||
1117 time_after(jiffies, data->alarms_updated + msecs_to_jiffies(data->update_interval))) {
1118 struct i2c_client *client = data->client;
1123 data->alarms_valid = false;
1130 if (data->reg_status2) {
1131 val = lm90_read_reg(client, data->reg_status2);
1138 * handler) and alarm data is valid, the alarms may have been
1143 if (force && data->alarms_valid)
1144 data->current_alarms |= alarms;
1146 data->current_alarms = alarms;
1147 data->alarms |= alarms;
1149 check_enable = (client->irq || !(data->config_orig & 0x80)) &&
1150 (data->config & 0x80);
1153 schedule_work(&data->report_work);
1161 if (!(data->current_alarms & data->alert_alarms)) {
1163 lm90_update_confreg(data, data->config & ~0x80);
1170 cancel_delayed_work(&data->alert_work);
1172 schedule_delayed_work(&data->alert_work,
1173 max_t(int, HZ, msecs_to_jiffies(data->update_interval)));
1176 data->alarms_updated = jiffies;
1177 data->alarms_valid = true;
1182 static int lm90_update_alarms(struct lm90_data *data, bool force)
1186 mutex_lock(&data->update_lock);
1187 err = lm90_update_alarms_locked(data, force);
1188 mutex_unlock(&data->update_lock);
1196 struct lm90_data *data = container_of(delayed_work, struct lm90_data, alert_work);
1199 if (!(data->config & 0x80))
1202 lm90_update_alarms(data, true);
1207 struct lm90_data *data = dev_get_drvdata(dev);
1208 struct i2c_client *client = data->client;
1212 if (!data->valid) {
1218 next_update = data->last_updated +
1219 msecs_to_jiffies(data->update_interval);
1220 if (time_after(jiffies, next_update) || !data->valid) {
1221 dev_dbg(&client->dev, "Updating lm90 data.\n");
1223 data->valid = false;
1228 data->temp[LOCAL_LOW] = val << 8;
1233 data->temp[LOCAL_HIGH] = val << 8;
1236 data->reg_local_ext, true);
1239 data->temp[LOCAL_TEMP] = val;
1241 data->reg_remote_ext, true);
1244 data->temp[REMOTE_TEMP] = val;
1246 if (data->flags & LM90_HAVE_TEMP3) {
1247 val = lm90_select_remote_channel(data, true);
1252 data->reg_remote_ext, true);
1254 lm90_select_remote_channel(data, false);
1257 data->temp[REMOTE2_TEMP] = val;
1259 lm90_select_remote_channel(data, false);
1262 val = lm90_update_alarms_locked(data, false);
1266 data->last_updated = jiffies;
1267 data->valid = true;
1309 static int lm90_temp_get_resolution(struct lm90_data *data, int index)
1313 if (data->reg_remote_ext)
1314 return data->resolution;
1319 return data->resolution;
1321 if (data->reg_local_ext)
1322 return data->resolution;
1328 if (data->flags & LM90_HAVE_REM_LIMIT_EXT)
1329 return data->resolution;
1350 static int lm90_get_temp(struct lm90_data *data, int index, int channel)
1352 int temp = lm90_temp_from_reg(data->flags, data->temp[index],
1353 lm90_temp_get_resolution(data, index));
1356 if (data->kind == lm99 && channel)
1381 static int lm90_set_temp(struct lm90_data *data, int index, int channel, long val)
1397 struct i2c_client *client = data->client;
1402 if (channel && (data->flags & LM90_HAVE_REM_LIMIT_EXT)) {
1410 if (data->kind == lm99 && channel) {
1416 data->temp[index] = lm90_temp_to_reg(data->flags, val,
1417 lm90_temp_get_resolution(data, index));
1420 lm90_select_remote_channel(data, true);
1422 err = lm90_write16(client, regh, regl, data->temp[index]);
1425 lm90_select_remote_channel(data, false);
1430 static int lm90_get_temphyst(struct lm90_data *data, int index, int channel)
1432 int temp = lm90_get_temp(data, index, channel);
1434 return temp - data->temp_hyst * 1000;
1437 static int lm90_set_temphyst(struct lm90_data *data, long val)
1439 int temp = lm90_get_temp(data, LOCAL_CRIT, 0);
1443 data->temp_hyst = clamp_val(DIV_ROUND_CLOSEST(temp - val, 1000), 0, 31);
1445 return lm90_write_reg(data->client, LM90_REG_TCRIT_HYST, data->temp_hyst);
1448 static int lm90_get_temp_offset(struct lm90_data *data, int index)
1450 int res = lm90_temp_get_resolution(data, index);
1452 return lm90_temp_from_reg(0, data->temp[index], res);
1455 static int lm90_set_temp_offset(struct lm90_data *data, int index, int channel, long val)
1459 val = lm90_temp_to_reg(0, val, lm90_temp_get_resolution(data, index));
1463 lm90_select_remote_channel(data, true);
1465 err = lm90_write16(data->client, LM90_REG_REMOTE_OFFSH, LM90_REG_REMOTE_OFFSL, val);
1468 lm90_select_remote_channel(data, false);
1473 data->temp[index] = val;
1511 struct lm90_data *data = dev_get_drvdata(dev);
1515 mutex_lock(&data->update_lock);
1517 mutex_unlock(&data->update_lock);
1523 *val = lm90_get_temp(data, lm90_temp_index[channel], channel);
1538 if (data->flags & LM90_HAVE_CRIT_ALRM_SWP)
1550 *val = !!(data->alarms & bit);
1551 data->alarms &= ~bit;
1552 data->alarms |= data->current_alarms;
1555 *val = lm90_get_temp(data, lm90_temp_min_index[channel], channel);
1558 *val = lm90_get_temp(data, lm90_temp_max_index[channel], channel);
1561 *val = lm90_get_temp(data, lm90_temp_crit_index[channel], channel);
1564 *val = lm90_get_temphyst(data, lm90_temp_crit_index[channel], channel);
1567 *val = lm90_get_temp(data, lm90_temp_emerg_index[channel], channel);
1570 *val = lm90_get_temphyst(data, lm90_temp_emerg_index[channel], channel);
1573 *val = lm90_get_temp_offset(data, lm90_temp_offset_index[channel]);
1583 struct lm90_data *data = dev_get_drvdata(dev);
1586 mutex_lock(&data->update_lock);
1594 err = lm90_set_temp(data, lm90_temp_min_index[channel],
1598 err = lm90_set_temp(data, lm90_temp_max_index[channel],
1602 err = lm90_set_temp(data, lm90_temp_crit_index[channel],
1606 err = lm90_set_temphyst(data, val);
1609 err = lm90_set_temp(data, lm90_temp_emerg_index[channel],
1613 err = lm90_set_temp_offset(data, lm90_temp_offset_index[channel],
1621 mutex_unlock(&data->update_lock);
1626 static umode_t lm90_temp_is_visible(const void *data, u32 attr, int channel)
1655 struct lm90_data *data = dev_get_drvdata(dev);
1658 mutex_lock(&data->update_lock);
1660 mutex_unlock(&data->update_lock);
1666 *val = data->update_interval;
1669 *val = data->alarms;
1672 if (data->faultqueue_mask) {
1673 *val = (data->config & data->faultqueue_mask) ?
1674 data->faultqueue_depth : 1;
1676 switch (data->conalert & 0x0e) {
1702 struct lm90_data *data = dev_get_drvdata(dev);
1703 struct i2c_client *client = data->client;
1706 mutex_lock(&data->update_lock);
1714 err = lm90_set_convrate(client, data,
1718 err = lm90_set_faultqueue(client, data, clamp_val(val, 1, 4));
1725 mutex_unlock(&data->update_lock);
1730 static umode_t lm90_chip_is_visible(const void *data, u32 attr, int channel)
1759 struct lm90_data *data = dev_get_drvdata(dev);
1761 *str = data->channel_label[channel];
1779 static umode_t lm90_is_visible(const void *data, enum hwmon_sensor_types type,
1784 return lm90_chip_is_visible(data, attr, channel);
1786 return lm90_temp_is_visible(data, attr, channel);
2558 struct lm90_data *data = _data;
2559 struct i2c_client *client = data->client;
2561 cancel_delayed_work_sync(&data->alert_work);
2562 cancel_work_sync(&data->report_work);
2565 if (data->flags & LM90_HAVE_CONVRATE)
2566 lm90_write_convrate(data, data->convrate_orig);
2567 lm90_write_reg(client, LM90_REG_CONFIG1, data->config_orig);
2570 static int lm90_init_client(struct i2c_client *client, struct lm90_data *data)
2575 if (data->flags & LM90_HAVE_CONVRATE) {
2579 data->convrate_orig = convrate;
2580 lm90_set_convrate(client, data, 500); /* 500ms; 2Hz conversion rate */
2582 data->update_interval = 500;
2591 data->config_orig = config;
2592 data->config = config;
2595 if (data->flags & LM90_HAVE_EXTENDED_TEMP) {
2599 data->flags &= ~LM90_HAVE_EXTENDED_TEMP;
2609 if (data->kind == max6680)
2618 if (data->kind == max6654)
2624 if (data->flags & LM90_HAVE_TEMP3)
2635 lm90_update_confreg(data, config);
2637 return devm_add_action_or_reset(&client->dev, lm90_restore_conf, data);
2642 struct lm90_data *data = i2c_get_clientdata(client);
2645 ret = lm90_update_alarms(data, true);
2649 return !!data->current_alarms;
2669 struct lm90_data *data)
2687 err = of_property_read_string(child, "label", &data->channel_label[id]);
2693 if (data->channel_label[id])
2694 data->channel_config[id] |= HWMON_T_LABEL;
2703 err = lm90_set_temp_offset(data, lm90_temp_offset_index[id], id, val);
2715 struct lm90_data *data)
2726 err = lm90_probe_channel_from_dt(client, child, data);
2749 struct lm90_data *data;
2756 data = devm_kzalloc(dev, sizeof(struct lm90_data), GFP_KERNEL);
2757 if (!data)
2760 data->client = client;
2761 i2c_set_clientdata(client, data);
2762 mutex_init(&data->update_lock);
2763 INIT_DELAYED_WORK(&data->alert_work, lm90_alert_work);
2764 INIT_WORK(&data->report_work, lm90_report_alarms);
2768 data->kind = (uintptr_t)of_device_get_match_data(&client->dev);
2770 data->kind = i2c_match_id(lm90_id, client)->driver_data;
2776 data->alert_alarms = lm90_params[data->kind].alert_alarms;
2777 data->resolution = lm90_params[data->kind].resolution ? : 11;
2780 data->flags = lm90_params[data->kind].flags;
2782 if ((data->flags & (LM90_HAVE_PEC | LM90_HAVE_PARTIAL_PEC)) &&
2784 data->flags &= ~(LM90_HAVE_PEC | LM90_HAVE_PARTIAL_PEC);
2786 if ((data->flags & LM90_HAVE_PARTIAL_PEC) &&
2788 data->flags &= ~LM90_HAVE_PARTIAL_PEC;
2790 data->chip.ops = &lm90_ops;
2791 data->chip.info = data->info;
2793 data->info[0] = &data->chip_info;
2794 info = &data->chip_info;
2796 info->config = data->chip_config;
2798 data->chip_config[0] = HWMON_C_REGISTER_TZ;
2799 if (data->flags & LM90_HAVE_ALARMS)
2800 data->chip_config[0] |= HWMON_C_ALARMS;
2801 if (data->flags & LM90_HAVE_CONVRATE)
2802 data->chip_config[0] |= HWMON_C_UPDATE_INTERVAL;
2803 if (data->flags & LM90_HAVE_FAULTQUEUE)
2804 data->chip_config[0] |= HWMON_C_TEMP_SAMPLES;
2805 data->info[1] = &data->temp_info;
2807 info = &data->temp_info;
2809 info->config = data->channel_config;
2811 data->channel_config[0] = HWMON_T_INPUT | HWMON_T_MAX |
2813 data->channel_config[1] = HWMON_T_INPUT | HWMON_T_MAX |
2816 if (data->flags & LM90_HAVE_LOW) {
2817 data->channel_config[0] |= HWMON_T_MIN | HWMON_T_MIN_ALARM;
2818 data->channel_config[1] |= HWMON_T_MIN | HWMON_T_MIN_ALARM;
2821 if (data->flags & LM90_HAVE_CRIT) {
2822 data->channel_config[0] |= HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_CRIT_HYST;
2823 data->channel_config[1] |= HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_CRIT_HYST;
2826 if (data->flags & LM90_HAVE_OFFSET)
2827 data->channel_config[1] |= HWMON_T_OFFSET;
2829 if (data->flags & LM90_HAVE_EMERGENCY) {
2830 data->channel_config[0] |= HWMON_T_EMERGENCY |
2832 data->channel_config[1] |= HWMON_T_EMERGENCY |
2836 if (data->flags & LM90_HAVE_EMERGENCY_ALARM) {
2837 data->channel_config[0] |= HWMON_T_EMERGENCY_ALARM;
2838 data->channel_config[1] |= HWMON_T_EMERGENCY_ALARM;
2841 if (data->flags & LM90_HAVE_TEMP3) {
2842 data->channel_config[2] = HWMON_T_INPUT |
2847 if (data->flags & LM90_HAVE_EMERGENCY) {
2848 data->channel_config[2] |= HWMON_T_EMERGENCY |
2851 if (data->flags & LM90_HAVE_EMERGENCY_ALARM)
2852 data->channel_config[2] |= HWMON_T_EMERGENCY_ALARM;
2853 if (data->flags & LM90_HAVE_OFFSET)
2854 data->channel_config[2] |= HWMON_T_OFFSET;
2857 data->faultqueue_mask = lm90_params[data->kind].faultqueue_mask;
2858 data->faultqueue_depth = lm90_params[data->kind].faultqueue_depth;
2859 data->reg_local_ext = lm90_params[data->kind].reg_local_ext;
2860 if (data->flags & LM90_HAVE_REMOTE_EXT)
2861 data->reg_remote_ext = LM90_REG_REMOTE_TEMPL;
2862 data->reg_status2 = lm90_params[data->kind].reg_status2;
2865 data->max_convrate = lm90_params[data->kind].max_convrate;
2869 err = lm90_parse_dt_channel_info(client, data);
2875 err = lm90_init_client(client, data);
2885 if (data->flags & (LM90_HAVE_PEC | LM90_HAVE_PARTIAL_PEC)) {
2895 data, &data->chip,
2900 data->hwmon_dev = hwmon_dev;
2928 struct lm90_data *data = i2c_get_clientdata(client);
2930 if ((data->flags & LM90_HAVE_BROKEN_ALERT) &&
2931 (data->current_alarms & data->alert_alarms)) {
2932 if (!(data->config & 0x80)) {
2934 lm90_update_confreg(data, data->config | 0x80);
2936 schedule_delayed_work(&data->alert_work,
2937 max_t(int, HZ, msecs_to_jiffies(data->update_interval)));
2946 struct lm90_data *data = dev_get_drvdata(dev);
2947 struct i2c_client *client = data->client;
2957 struct lm90_data *data = dev_get_drvdata(dev);
2958 struct i2c_client *client = data->client;