Lines Matching refs:data
135 * Client data (each client gets its own)
178 static inline int temp8_from_reg(struct lm63_data *data, int nr)
180 if (data->remote_unsigned)
181 return TEMP8_FROM_REG((u8)data->temp8[nr]);
182 return TEMP8_FROM_REG(data->temp8[nr]);
185 static inline int lut_temp_from_reg(struct lm63_data *data, int nr)
187 return data->temp8[nr] * (data->lut_temp_highres ? 500 : 1000);
190 static inline int lut_temp_to_reg(struct lm63_data *data, long val)
192 val -= data->temp2_offset;
193 if (data->lut_temp_highres)
203 static void lm63_update_lut(struct lm63_data *data)
205 struct i2c_client *client = data->client;
208 if (time_after(jiffies, data->lut_last_updated + 5 * HZ) ||
209 !data->lut_valid) {
210 for (i = 0; i < data->lut_size; i++) {
211 data->pwm1[1 + i] = i2c_smbus_read_byte_data(client,
213 data->temp8[3 + i] = i2c_smbus_read_byte_data(client,
216 data->lut_temp_hyst = i2c_smbus_read_byte_data(client,
219 data->lut_last_updated = jiffies;
220 data->lut_valid = 1;
226 struct lm63_data *data = dev_get_drvdata(dev);
227 struct i2c_client *client = data->client;
230 mutex_lock(&data->update_lock);
232 next_update = data->last_updated +
233 msecs_to_jiffies(data->update_interval);
234 if (time_after(jiffies, next_update) || !data->valid) {
235 if (data->config & 0x04) { /* tachometer enabled */
237 data->fan[0] = i2c_smbus_read_byte_data(client,
239 data->fan[0] |= i2c_smbus_read_byte_data(client,
241 data->fan[1] = (i2c_smbus_read_byte_data(client,
247 data->pwm1_freq = i2c_smbus_read_byte_data(client,
249 if (data->pwm1_freq == 0)
250 data->pwm1_freq = 1;
251 data->pwm1[0] = i2c_smbus_read_byte_data(client,
254 data->temp8[0] = i2c_smbus_read_byte_data(client,
256 data->temp8[1] = i2c_smbus_read_byte_data(client,
260 data->temp11[0] = i2c_smbus_read_byte_data(client,
262 data->temp11[0] |= i2c_smbus_read_byte_data(client,
264 data->temp11[1] = (i2c_smbus_read_byte_data(client,
268 data->temp11[2] = (i2c_smbus_read_byte_data(client,
272 data->temp11[3] = (i2c_smbus_read_byte_data(client,
277 if (data->kind == lm96163)
278 data->temp11u = (i2c_smbus_read_byte_data(client,
283 data->temp8[2] = i2c_smbus_read_byte_data(client,
285 data->temp2_crit_hyst = i2c_smbus_read_byte_data(client,
288 data->alarms = i2c_smbus_read_byte_data(client,
291 data->last_updated = jiffies;
292 data->valid = true;
295 lm63_update_lut(data);
297 mutex_unlock(&data->update_lock);
299 return data;
306 static int lm63_lut_looks_bad(struct device *dev, struct lm63_data *data)
310 mutex_lock(&data->update_lock);
311 lm63_update_lut(data);
313 for (i = 1; i < data->lut_size; i++) {
314 if (data->pwm1[1 + i - 1] > data->pwm1[1 + i]
315 || data->temp8[3 + i - 1] > data->temp8[3 + i]) {
322 mutex_unlock(&data->update_lock);
324 return i == data->lut_size ? 0 : 1;
335 struct lm63_data *data = lm63_update_device(dev);
336 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index]));
342 struct lm63_data *data = dev_get_drvdata(dev);
343 struct i2c_client *client = data->client;
351 mutex_lock(&data->update_lock);
352 data->fan[1] = FAN_TO_REG(val);
354 data->fan[1] & 0xFF);
356 data->fan[1] >> 8);
357 mutex_unlock(&data->update_lock);
365 struct lm63_data *data = lm63_update_device(dev);
369 if (data->pwm_highres)
370 pwm = data->pwm1[nr];
372 pwm = data->pwm1[nr] >= 2 * data->pwm1_freq ?
373 255 : (data->pwm1[nr] * 255 + data->pwm1_freq) /
374 (2 * data->pwm1_freq);
383 struct lm63_data *data = dev_get_drvdata(dev);
384 struct i2c_client *client = data->client;
390 if (!(data->config_fan & 0x20)) /* register is read-only */
400 mutex_lock(&data->update_lock);
401 data->pwm1[nr] = data->pwm_highres ? val :
402 (val * data->pwm1_freq * 2 + 127) / 255;
403 i2c_smbus_write_byte_data(client, reg, data->pwm1[nr]);
404 mutex_unlock(&data->update_lock);
411 struct lm63_data *data = lm63_update_device(dev);
412 return sprintf(buf, "%d\n", data->config_fan & 0x20 ? 1 : 2);
419 struct lm63_data *data = dev_get_drvdata(dev);
420 struct i2c_client *client = data->client;
434 if (val == 2 && lm63_lut_looks_bad(dev, data))
437 mutex_lock(&data->update_lock);
438 data->config_fan = i2c_smbus_read_byte_data(client,
441 data->config_fan |= 0x20;
443 data->config_fan &= ~0x20;
445 data->config_fan);
446 mutex_unlock(&data->update_lock);
461 struct lm63_data *data = lm63_update_device(dev);
462 return sprintf(buf, "%d\n", TEMP8_FROM_REG(data->temp8[attr->index]));
470 struct lm63_data *data = lm63_update_device(dev);
471 return sprintf(buf, "%d\n", temp8_from_reg(data, attr->index)
472 + data->temp2_offset);
480 struct lm63_data *data = lm63_update_device(dev);
481 return sprintf(buf, "%d\n", lut_temp_from_reg(data, attr->index)
482 + data->temp2_offset);
489 struct lm63_data *data = dev_get_drvdata(dev);
490 struct i2c_client *client = data->client;
501 mutex_lock(&data->update_lock);
505 if (data->remote_unsigned)
506 temp = TEMP8U_TO_REG(val - data->temp2_offset);
508 temp = TEMP8_TO_REG(val - data->temp2_offset);
516 temp = lut_temp_to_reg(data, val);
518 data->temp8[nr] = temp;
520 mutex_unlock(&data->update_lock);
528 struct lm63_data *data = lm63_update_device(dev);
537 if (data->temp11u)
538 temp = TEMP11_FROM_REG(data->temp11u);
540 temp = TEMP11_FROM_REG(data->temp11[nr]);
542 if (data->remote_unsigned && nr == 2)
543 temp = TEMP11_FROM_REG((u16)data->temp11[nr]);
545 temp = TEMP11_FROM_REG(data->temp11[nr]);
547 return sprintf(buf, "%d\n", temp + data->temp2_offset);
563 struct lm63_data *data = dev_get_drvdata(dev);
564 struct i2c_client *client = data->client;
573 mutex_lock(&data->update_lock);
574 if (data->remote_unsigned && nr == 2)
575 data->temp11[nr] = TEMP11U_TO_REG(val - data->temp2_offset);
577 data->temp11[nr] = TEMP11_TO_REG(val - data->temp2_offset);
580 data->temp11[nr] >> 8);
582 data->temp11[nr] & 0xff);
583 mutex_unlock(&data->update_lock);
594 struct lm63_data *data = lm63_update_device(dev);
595 return sprintf(buf, "%d\n", temp8_from_reg(data, 2)
596 + data->temp2_offset
597 - TEMP8_FROM_REG(data->temp2_crit_hyst));
604 struct lm63_data *data = lm63_update_device(dev);
606 return sprintf(buf, "%d\n", lut_temp_from_reg(data, attr->index)
607 + data->temp2_offset
608 - TEMP8_FROM_REG(data->lut_temp_hyst));
619 struct lm63_data *data = dev_get_drvdata(dev);
620 struct i2c_client *client = data->client;
629 mutex_lock(&data->update_lock);
630 hyst = temp8_from_reg(data, 2) + data->temp2_offset - val;
633 mutex_unlock(&data->update_lock);
641 static void lm63_set_convrate(struct lm63_data *data, unsigned int interval)
643 struct i2c_client *client = data->client;
652 / data->max_convrate_hz;
658 data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz, i);
664 struct lm63_data *data = dev_get_drvdata(dev);
666 return sprintf(buf, "%u\n", data->update_interval);
673 struct lm63_data *data = dev_get_drvdata(dev);
681 mutex_lock(&data->update_lock);
682 lm63_set_convrate(data, clamp_val(val, 0, 100000));
683 mutex_unlock(&data->update_lock);
691 struct lm63_data *data = dev_get_drvdata(dev);
693 return sprintf(buf, data->trutherm ? "1\n" : "2\n");
700 struct lm63_data *data = dev_get_drvdata(dev);
701 struct i2c_client *client = data->client;
712 mutex_lock(&data->update_lock);
713 data->trutherm = val == 1;
716 reg | (data->trutherm ? 0x02 : 0x00));
717 data->valid = false;
718 mutex_unlock(&data->update_lock);
726 struct lm63_data *data = lm63_update_device(dev);
727 return sprintf(buf, "%u\n", data->alarms);
734 struct lm63_data *data = lm63_update_device(dev);
737 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
935 struct lm63_data *data = dev_get_drvdata(dev);
938 && (data->kind == lm64 ||
939 (data->kind == lm96163 && (data->config & 0x02))))
1014 static void lm63_init_client(struct lm63_data *data)
1016 struct i2c_client *client = data->client;
1020 data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
1021 data->config_fan = i2c_smbus_read_byte_data(client,
1025 if (data->config & 0x40) { /* standby */
1027 data->config &= 0xA7;
1029 data->config);
1032 if (data->kind == lm64)
1033 data->config |= 0x04;
1035 /* We may need pwm1_freq before ever updating the client data */
1036 data->pwm1_freq = i2c_smbus_read_byte_data(client, LM63_REG_PWM_FREQ);
1037 if (data->pwm1_freq == 0)
1038 data->pwm1_freq = 1;
1040 switch (data->kind) {
1043 data->max_convrate_hz = LM63_MAX_CONVRATE_HZ;
1044 data->lut_size = 8;
1047 data->max_convrate_hz = LM96163_MAX_CONVRATE_HZ;
1048 data->lut_size = 12;
1049 data->trutherm
1057 data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz,
1064 if (data->kind == lm96163) {
1069 data->lut_temp_highres = true;
1071 && !(data->config_fan & 0x08) && data->pwm1_freq == 8)
1072 data->pwm_highres = true;
1074 data->remote_unsigned = true;
1078 if (data->kind == lm63)
1080 (data->config & 0x04) ? "tachometer input" :
1083 (data->config_fan & 0x08) ? "1.4" : "360",
1084 ((data->config_fan & 0x08) ? 700 : 180000) / data->pwm1_freq);
1086 (data->config_fan & 0x10) ? "low" : "high",
1087 (data->config_fan & 0x20) ? "manual" : "auto");
1096 struct lm63_data *data;
1099 data = devm_kzalloc(dev, sizeof(struct lm63_data), GFP_KERNEL);
1100 if (!data)
1103 data->client = client;
1104 mutex_init(&data->update_lock);
1108 data->kind = (uintptr_t)of_device_get_match_data(&client->dev);
1110 data->kind = i2c_match_id(lm63_id, client)->driver_data;
1111 if (data->kind == lm64)
1112 data->temp2_offset = 16000;
1115 lm63_init_client(data);
1118 data->groups[groups++] = &lm63_group;
1119 if (data->config & 0x04) /* tachometer enabled */
1120 data->groups[groups++] = &lm63_group_fan1;
1122 if (data->kind == lm96163) {
1123 data->groups[groups++] = &lm63_group_temp2_type;
1124 data->groups[groups++] = &lm63_group_extra_lut;
1128 data, data->groups);
1133 * Driver data (common to all clients)
1147 .data = (void *)lm63
1151 .data = (void *)lm64
1155 .data = (void *)lm96163