Lines Matching refs:data
172 * 16-bit registers on the ADT7470 are low-byte first. The data sheet says
192 struct adt7470_data *data)
222 res = msleep_interruptible((data->num_temp_sensors >= 0 ?
223 data->num_temp_sensors * 200 :
241 if (data->num_temp_sensors >= 0)
245 data->temp[i] = i2c_smbus_read_byte_data(client,
247 if (data->temp[i])
248 data->num_temp_sensors = i + 1;
250 data->temperatures_probed = 1;
257 struct adt7470_data *data = i2c_get_clientdata(client);
260 mutex_lock(&data->lock);
261 adt7470_read_temperatures(client, data);
262 mutex_unlock(&data->lock);
267 schedule_timeout_interruptible(msecs_to_jiffies(data->auto_update_interval));
275 struct adt7470_data *data = dev_get_drvdata(dev);
276 struct i2c_client *client = data->client;
286 * date data.
288 if (time_before(local_jiffies, data->sensors_last_updated +
290 data->sensors_valid)
293 if (time_before(local_jiffies, data->limits_last_updated +
295 data->limits_valid)
299 return data;
301 mutex_lock(&data->lock);
305 if (!data->temperatures_probed)
306 adt7470_read_temperatures(client, data);
309 data->temp[i] = i2c_smbus_read_byte_data(client,
313 data->fan[i] = adt7470_read_word_data(client,
320 data->pwm[i] = i2c_smbus_read_byte_data(client,
330 data->pwm_automatic[i] = 1;
332 data->pwm_automatic[i] = 0;
337 data->pwm_auto_temp[i] = cfg >> 4;
339 data->pwm_auto_temp[i] = cfg & 0xF;
344 data->force_pwm_max = 1;
346 data->force_pwm_max = 0;
348 data->alarm = i2c_smbus_read_byte_data(client, ADT7470_REG_ALARM1);
349 if (data->alarm & ADT7470_OOL_ALARM)
350 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
352 data->alarms_mask = adt7470_read_word_data(client,
355 data->sensors_last_updated = local_jiffies;
356 data->sensors_valid = 1;
363 data->temp_min[i] = i2c_smbus_read_byte_data(client,
365 data->temp_max[i] = i2c_smbus_read_byte_data(client,
370 data->fan_min[i] = adt7470_read_word_data(client,
372 data->fan_max[i] = adt7470_read_word_data(client,
377 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
379 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
381 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
385 data->limits_last_updated = local_jiffies;
386 data->limits_valid = 1;
389 mutex_unlock(&data->lock);
390 return data;
397 struct adt7470_data *data = adt7470_update_device(dev);
398 return sprintf(buf, "%d\n", data->auto_update_interval);
405 struct adt7470_data *data = dev_get_drvdata(dev);
413 mutex_lock(&data->lock);
414 data->auto_update_interval = temp;
415 mutex_unlock(&data->lock);
424 struct adt7470_data *data = adt7470_update_device(dev);
425 return sprintf(buf, "%d\n", data->num_temp_sensors);
432 struct adt7470_data *data = dev_get_drvdata(dev);
440 mutex_lock(&data->lock);
441 data->num_temp_sensors = temp;
443 data->temperatures_probed = 0;
444 mutex_unlock(&data->lock);
453 struct adt7470_data *data = adt7470_update_device(dev);
454 return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]);
462 struct adt7470_data *data = dev_get_drvdata(dev);
463 struct i2c_client *client = data->client;
472 mutex_lock(&data->lock);
473 data->temp_min[attr->index] = temp;
476 mutex_unlock(&data->lock);
485 struct adt7470_data *data = adt7470_update_device(dev);
486 return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
494 struct adt7470_data *data = dev_get_drvdata(dev);
495 struct i2c_client *client = data->client;
504 mutex_lock(&data->lock);
505 data->temp_max[attr->index] = temp;
508 mutex_unlock(&data->lock);
517 struct adt7470_data *data = adt7470_update_device(dev);
518 return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
525 struct adt7470_data *data = adt7470_update_device(dev);
527 return sprintf(buf, "%x\n", data->alarms_mask);
534 struct adt7470_data *data = dev_get_drvdata(dev);
543 mutex_lock(&data->lock);
544 data->alarms_mask = mask;
545 adt7470_write_word_data(data->client, ADT7470_REG_ALARM1_MASK, mask);
546 mutex_unlock(&data->lock);
555 struct adt7470_data *data = adt7470_update_device(dev);
557 if (FAN_DATA_VALID(data->fan_max[attr->index]))
559 FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
569 struct adt7470_data *data = dev_get_drvdata(dev);
570 struct i2c_client *client = data->client;
579 mutex_lock(&data->lock);
580 data->fan_max[attr->index] = temp;
582 mutex_unlock(&data->lock);
591 struct adt7470_data *data = adt7470_update_device(dev);
593 if (FAN_DATA_VALID(data->fan_min[attr->index]))
595 FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
605 struct adt7470_data *data = dev_get_drvdata(dev);
606 struct i2c_client *client = data->client;
615 mutex_lock(&data->lock);
616 data->fan_min[attr->index] = temp;
618 mutex_unlock(&data->lock);
627 struct adt7470_data *data = adt7470_update_device(dev);
629 if (FAN_DATA_VALID(data->fan[attr->index]))
631 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
639 struct adt7470_data *data = adt7470_update_device(dev);
640 return sprintf(buf, "%d\n", data->force_pwm_max);
647 struct adt7470_data *data = dev_get_drvdata(dev);
648 struct i2c_client *client = data->client;
655 mutex_lock(&data->lock);
656 data->force_pwm_max = temp;
663 mutex_unlock(&data->lock);
672 struct adt7470_data *data = adt7470_update_device(dev);
673 return sprintf(buf, "%d\n", data->pwm[attr->index]);
680 struct adt7470_data *data = dev_get_drvdata(dev);
681 struct i2c_client *client = data->client;
689 mutex_lock(&data->lock);
690 data->pwm[attr->index] = temp;
692 mutex_unlock(&data->lock);
705 struct adt7470_data *data = adt7470_update_device(dev);
710 mutex_lock(&data->lock);
711 cfg_reg_1 = i2c_smbus_read_byte_data(data->client, ADT7470_REG_CFG);
712 cfg_reg_2 = i2c_smbus_read_byte_data(data->client, ADT7470_REG_CFG_2);
713 mutex_unlock(&data->lock);
728 struct adt7470_data *data = dev_get_drvdata(dev);
729 struct i2c_client *client = data->client;
747 mutex_lock(&data->lock);
756 mutex_unlock(&data->lock);
765 struct adt7470_data *data = adt7470_update_device(dev);
766 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
774 struct adt7470_data *data = dev_get_drvdata(dev);
775 struct i2c_client *client = data->client;
783 mutex_lock(&data->lock);
784 data->pwm_max[attr->index] = temp;
787 mutex_unlock(&data->lock);
796 struct adt7470_data *data = adt7470_update_device(dev);
797 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
805 struct adt7470_data *data = dev_get_drvdata(dev);
806 struct i2c_client *client = data->client;
814 mutex_lock(&data->lock);
815 data->pwm_min[attr->index] = temp;
818 mutex_unlock(&data->lock);
827 struct adt7470_data *data = adt7470_update_device(dev);
829 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
836 struct adt7470_data *data = adt7470_update_device(dev);
837 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
845 struct adt7470_data *data = dev_get_drvdata(dev);
846 struct i2c_client *client = data->client;
855 mutex_lock(&data->lock);
856 data->pwm_tmin[attr->index] = temp;
859 mutex_unlock(&data->lock);
868 struct adt7470_data *data = adt7470_update_device(dev);
869 return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
877 struct adt7470_data *data = dev_get_drvdata(dev);
878 struct i2c_client *client = data->client;
896 mutex_lock(&data->lock);
897 data->pwm_automatic[attr->index] = temp;
904 mutex_unlock(&data->lock);
913 struct adt7470_data *data = adt7470_update_device(dev);
914 u8 ctrl = data->pwm_auto_temp[attr->index];
936 struct adt7470_data *data = dev_get_drvdata(dev);
937 struct i2c_client *client = data->client;
949 mutex_lock(&data->lock);
950 data->pwm_automatic[attr->index] = temp;
962 mutex_unlock(&data->lock);
971 struct adt7470_data *data = adt7470_update_device(dev);
973 if (data->alarm & attr->index)
1223 struct adt7470_data *data;
1226 data = devm_kzalloc(dev, sizeof(struct adt7470_data), GFP_KERNEL);
1227 if (!data)
1230 data->num_temp_sensors = -1;
1231 data->auto_update_interval = AUTO_UPDATE_INTERVAL;
1233 i2c_set_clientdata(client, data);
1234 data->client = client;
1235 mutex_init(&data->lock);
1244 data,
1250 data->auto_update = kthread_run(adt7470_update_thread, client, "%s",
1252 if (IS_ERR(data->auto_update)) {
1253 return PTR_ERR(data->auto_update);
1261 struct adt7470_data *data = i2c_get_clientdata(client);
1263 kthread_stop(data->auto_update);