adt7470.c (20c7775aecea04d8ca322039969d49dcf568e0e9) adt7470.c (ad00a02e34b481396938c5fa62ee642bff7fbb08)
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * A hwmon driver for the Analog Devices ADT7470
4 * Copyright (C) 2007 IBM
5 *
6 * Author: Darrick J. Wong <darrick.wong@oracle.com>
7 */
8

--- 256 unchanged lines hidden (view full) ---

265 break;
266
267 schedule_timeout(msecs_to_jiffies(data->auto_update_interval));
268 }
269
270 return 0;
271}
272
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * A hwmon driver for the Analog Devices ADT7470
4 * Copyright (C) 2007 IBM
5 *
6 * Author: Darrick J. Wong <darrick.wong@oracle.com>
7 */
8

--- 256 unchanged lines hidden (view full) ---

265 break;
266
267 schedule_timeout(msecs_to_jiffies(data->auto_update_interval));
268 }
269
270 return 0;
271}
272
273static struct adt7470_data *adt7470_update_device(struct device *dev)
273static int adt7470_update_sensors(struct adt7470_data *data)
274{
274{
275 struct adt7470_data *data = dev_get_drvdata(dev);
276 struct i2c_client *client = data->client;
275 struct i2c_client *client = data->client;
277 unsigned long local_jiffies = jiffies;
278 u8 cfg;
279 int i;
276 u8 cfg;
277 int i;
280 int need_sensors = 1;
281 int need_limits = 1;
282
278
283 /*
284 * Figure out if we need to update the shadow registers.
285 * Lockless means that we may occasionally report out of
286 * date data.
287 */
288 if (time_before(local_jiffies, data->sensors_last_updated +
289 SENSOR_REFRESH_INTERVAL) &&
290 data->sensors_valid)
291 need_sensors = 0;
292
293 if (time_before(local_jiffies, data->limits_last_updated +
294 LIMIT_REFRESH_INTERVAL) &&
295 data->limits_valid)
296 need_limits = 0;
297
298 if (!need_sensors && !need_limits)
299 return data;
300
301 mutex_lock(&data->lock);
302 if (!need_sensors)
303 goto no_sensor_update;
304
305 if (!data->temperatures_probed)
306 adt7470_read_temperatures(client, data);
307 else
308 for (i = 0; i < ADT7470_TEMP_COUNT; i++)
309 data->temp[i] = i2c_smbus_read_byte_data(client,
310 ADT7470_TEMP_REG(i));
311
312 for (i = 0; i < ADT7470_FAN_COUNT; i++)

--- 34 unchanged lines hidden (view full) ---

347
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,
351 ADT7470_REG_ALARM2));
352 data->alarms_mask = adt7470_read_word_data(client,
353 ADT7470_REG_ALARM1_MASK);
354
279 if (!data->temperatures_probed)
280 adt7470_read_temperatures(client, data);
281 else
282 for (i = 0; i < ADT7470_TEMP_COUNT; i++)
283 data->temp[i] = i2c_smbus_read_byte_data(client,
284 ADT7470_TEMP_REG(i));
285
286 for (i = 0; i < ADT7470_FAN_COUNT; i++)

--- 34 unchanged lines hidden (view full) ---

321
322 data->alarm = i2c_smbus_read_byte_data(client, ADT7470_REG_ALARM1);
323 if (data->alarm & ADT7470_OOL_ALARM)
324 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
325 ADT7470_REG_ALARM2));
326 data->alarms_mask = adt7470_read_word_data(client,
327 ADT7470_REG_ALARM1_MASK);
328
355 data->sensors_last_updated = local_jiffies;
356 data->sensors_valid = 1;
329 return 0;
330}
357
331
358no_sensor_update:
359 if (!need_limits)
360 goto out;
332static int adt7470_update_limits(struct adt7470_data *data)
333{
334 struct i2c_client *client = data->client;
335 int i;
361
362 for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
363 data->temp_min[i] = i2c_smbus_read_byte_data(client,
364 ADT7470_TEMP_MIN_REG(i));
365 data->temp_max[i] = i2c_smbus_read_byte_data(client,
366 ADT7470_TEMP_MAX_REG(i));
367 }
368

--- 8 unchanged lines hidden (view full) ---

377 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
378 ADT7470_REG_PWM_MAX(i));
379 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
380 ADT7470_REG_PWM_MIN(i));
381 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
382 ADT7470_REG_PWM_TMIN(i));
383 }
384
336
337 for (i = 0; i < ADT7470_TEMP_COUNT; i++) {
338 data->temp_min[i] = i2c_smbus_read_byte_data(client,
339 ADT7470_TEMP_MIN_REG(i));
340 data->temp_max[i] = i2c_smbus_read_byte_data(client,
341 ADT7470_TEMP_MAX_REG(i));
342 }
343

--- 8 unchanged lines hidden (view full) ---

352 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
353 ADT7470_REG_PWM_MAX(i));
354 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
355 ADT7470_REG_PWM_MIN(i));
356 data->pwm_tmin[i] = i2c_smbus_read_byte_data(client,
357 ADT7470_REG_PWM_TMIN(i));
358 }
359
385 data->limits_last_updated = local_jiffies;
386 data->limits_valid = 1;
360 return 0;
361}
387
362
363static struct adt7470_data *adt7470_update_device(struct device *dev)
364{
365 struct adt7470_data *data = dev_get_drvdata(dev);
366 unsigned long local_jiffies = jiffies;
367 int need_sensors = 1;
368 int need_limits = 1;
369 int err;
370
371 /*
372 * Figure out if we need to update the shadow registers.
373 * Lockless means that we may occasionally report out of
374 * date data.
375 */
376 if (time_before(local_jiffies, data->sensors_last_updated +
377 SENSOR_REFRESH_INTERVAL) &&
378 data->sensors_valid)
379 need_sensors = 0;
380
381 if (time_before(local_jiffies, data->limits_last_updated +
382 LIMIT_REFRESH_INTERVAL) &&
383 data->limits_valid)
384 need_limits = 0;
385
386 if (!need_sensors && !need_limits)
387 return data;
388
389 mutex_lock(&data->lock);
390 if (need_sensors) {
391 err = adt7470_update_sensors(data);
392 if (err < 0)
393 goto out;
394 data->sensors_last_updated = local_jiffies;
395 data->sensors_valid = 1;
396 }
397
398 if (need_limits) {
399 err = adt7470_update_limits(data);
400 if (err < 0)
401 goto out;
402 data->limits_last_updated = local_jiffies;
403 data->limits_valid = 1;
404 }
388out:
389 mutex_unlock(&data->lock);
405out:
406 mutex_unlock(&data->lock);
390 return data;
407
408 return err < 0 ? ERR_PTR(err) : data;
391}
392
393static ssize_t auto_update_interval_show(struct device *dev,
394 struct device_attribute *devattr,
395 char *buf)
396{
397 struct adt7470_data *data = adt7470_update_device(dev);
409}
410
411static ssize_t auto_update_interval_show(struct device *dev,
412 struct device_attribute *devattr,
413 char *buf)
414{
415 struct adt7470_data *data = adt7470_update_device(dev);
416
417 if (IS_ERR(data))
418 return PTR_ERR(data);
419
398 return sprintf(buf, "%d\n", data->auto_update_interval);
399}
400
401static ssize_t auto_update_interval_store(struct device *dev,
402 struct device_attribute *devattr,
403 const char *buf, size_t count)
404{
405 struct adt7470_data *data = dev_get_drvdata(dev);

--- 11 unchanged lines hidden (view full) ---

417 return count;
418}
419
420static ssize_t num_temp_sensors_show(struct device *dev,
421 struct device_attribute *devattr,
422 char *buf)
423{
424 struct adt7470_data *data = adt7470_update_device(dev);
420 return sprintf(buf, "%d\n", data->auto_update_interval);
421}
422
423static ssize_t auto_update_interval_store(struct device *dev,
424 struct device_attribute *devattr,
425 const char *buf, size_t count)
426{
427 struct adt7470_data *data = dev_get_drvdata(dev);

--- 11 unchanged lines hidden (view full) ---

439 return count;
440}
441
442static ssize_t num_temp_sensors_show(struct device *dev,
443 struct device_attribute *devattr,
444 char *buf)
445{
446 struct adt7470_data *data = adt7470_update_device(dev);
447
448 if (IS_ERR(data))
449 return PTR_ERR(data);
450
425 return sprintf(buf, "%d\n", data->num_temp_sensors);
426}
427
428static ssize_t num_temp_sensors_store(struct device *dev,
429 struct device_attribute *devattr,
430 const char *buf, size_t count)
431{
432 struct adt7470_data *data = dev_get_drvdata(dev);

--- 13 unchanged lines hidden (view full) ---

446 return count;
447}
448
449static ssize_t temp_min_show(struct device *dev,
450 struct device_attribute *devattr, char *buf)
451{
452 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
453 struct adt7470_data *data = adt7470_update_device(dev);
451 return sprintf(buf, "%d\n", data->num_temp_sensors);
452}
453
454static ssize_t num_temp_sensors_store(struct device *dev,
455 struct device_attribute *devattr,
456 const char *buf, size_t count)
457{
458 struct adt7470_data *data = dev_get_drvdata(dev);

--- 13 unchanged lines hidden (view full) ---

472 return count;
473}
474
475static ssize_t temp_min_show(struct device *dev,
476 struct device_attribute *devattr, char *buf)
477{
478 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
479 struct adt7470_data *data = adt7470_update_device(dev);
480
481 if (IS_ERR(data))
482 return PTR_ERR(data);
483
454 return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]);
455}
456
457static ssize_t temp_min_store(struct device *dev,
458 struct device_attribute *devattr,
459 const char *buf, size_t count)
460{
461 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 16 unchanged lines hidden (view full) ---

478 return count;
479}
480
481static ssize_t temp_max_show(struct device *dev,
482 struct device_attribute *devattr, char *buf)
483{
484 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
485 struct adt7470_data *data = adt7470_update_device(dev);
484 return sprintf(buf, "%d\n", 1000 * data->temp_min[attr->index]);
485}
486
487static ssize_t temp_min_store(struct device *dev,
488 struct device_attribute *devattr,
489 const char *buf, size_t count)
490{
491 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 16 unchanged lines hidden (view full) ---

508 return count;
509}
510
511static ssize_t temp_max_show(struct device *dev,
512 struct device_attribute *devattr, char *buf)
513{
514 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
515 struct adt7470_data *data = adt7470_update_device(dev);
516
517 if (IS_ERR(data))
518 return PTR_ERR(data);
519
486 return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
487}
488
489static ssize_t temp_max_store(struct device *dev,
490 struct device_attribute *devattr,
491 const char *buf, size_t count)
492{
493 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 16 unchanged lines hidden (view full) ---

510 return count;
511}
512
513static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
514 char *buf)
515{
516 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
517 struct adt7470_data *data = adt7470_update_device(dev);
520 return sprintf(buf, "%d\n", 1000 * data->temp_max[attr->index]);
521}
522
523static ssize_t temp_max_store(struct device *dev,
524 struct device_attribute *devattr,
525 const char *buf, size_t count)
526{
527 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 16 unchanged lines hidden (view full) ---

544 return count;
545}
546
547static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
548 char *buf)
549{
550 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
551 struct adt7470_data *data = adt7470_update_device(dev);
552
553 if (IS_ERR(data))
554 return PTR_ERR(data);
555
518 return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
519}
520
521static ssize_t alarm_mask_show(struct device *dev,
522 struct device_attribute *devattr,
523 char *buf)
524{
525 struct adt7470_data *data = adt7470_update_device(dev);
526
556 return sprintf(buf, "%d\n", 1000 * data->temp[attr->index]);
557}
558
559static ssize_t alarm_mask_show(struct device *dev,
560 struct device_attribute *devattr,
561 char *buf)
562{
563 struct adt7470_data *data = adt7470_update_device(dev);
564
565 if (IS_ERR(data))
566 return PTR_ERR(data);
567
527 return sprintf(buf, "%x\n", data->alarms_mask);
528}
529
530static ssize_t alarm_mask_store(struct device *dev,
531 struct device_attribute *devattr,
532 const char *buf, size_t count)
533{
534 struct adt7470_data *data = dev_get_drvdata(dev);

--- 14 unchanged lines hidden (view full) ---

549}
550
551static ssize_t fan_max_show(struct device *dev,
552 struct device_attribute *devattr, char *buf)
553{
554 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
555 struct adt7470_data *data = adt7470_update_device(dev);
556
568 return sprintf(buf, "%x\n", data->alarms_mask);
569}
570
571static ssize_t alarm_mask_store(struct device *dev,
572 struct device_attribute *devattr,
573 const char *buf, size_t count)
574{
575 struct adt7470_data *data = dev_get_drvdata(dev);

--- 14 unchanged lines hidden (view full) ---

590}
591
592static ssize_t fan_max_show(struct device *dev,
593 struct device_attribute *devattr, char *buf)
594{
595 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
596 struct adt7470_data *data = adt7470_update_device(dev);
597
598 if (IS_ERR(data))
599 return PTR_ERR(data);
600
557 if (FAN_DATA_VALID(data->fan_max[attr->index]))
558 return sprintf(buf, "%d\n",
559 FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
560 else
561 return sprintf(buf, "0\n");
562}
563
564static ssize_t fan_max_store(struct device *dev,

--- 20 unchanged lines hidden (view full) ---

585}
586
587static ssize_t fan_min_show(struct device *dev,
588 struct device_attribute *devattr, char *buf)
589{
590 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
591 struct adt7470_data *data = adt7470_update_device(dev);
592
601 if (FAN_DATA_VALID(data->fan_max[attr->index]))
602 return sprintf(buf, "%d\n",
603 FAN_PERIOD_TO_RPM(data->fan_max[attr->index]));
604 else
605 return sprintf(buf, "0\n");
606}
607
608static ssize_t fan_max_store(struct device *dev,

--- 20 unchanged lines hidden (view full) ---

629}
630
631static ssize_t fan_min_show(struct device *dev,
632 struct device_attribute *devattr, char *buf)
633{
634 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
635 struct adt7470_data *data = adt7470_update_device(dev);
636
637 if (IS_ERR(data))
638 return PTR_ERR(data);
639
593 if (FAN_DATA_VALID(data->fan_min[attr->index]))
594 return sprintf(buf, "%d\n",
595 FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
596 else
597 return sprintf(buf, "0\n");
598}
599
600static ssize_t fan_min_store(struct device *dev,

--- 20 unchanged lines hidden (view full) ---

621}
622
623static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
624 char *buf)
625{
626 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
627 struct adt7470_data *data = adt7470_update_device(dev);
628
640 if (FAN_DATA_VALID(data->fan_min[attr->index]))
641 return sprintf(buf, "%d\n",
642 FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
643 else
644 return sprintf(buf, "0\n");
645}
646
647static ssize_t fan_min_store(struct device *dev,

--- 20 unchanged lines hidden (view full) ---

668}
669
670static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
671 char *buf)
672{
673 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
674 struct adt7470_data *data = adt7470_update_device(dev);
675
676 if (IS_ERR(data))
677 return PTR_ERR(data);
678
629 if (FAN_DATA_VALID(data->fan[attr->index]))
630 return sprintf(buf, "%d\n",
631 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
632 else
633 return sprintf(buf, "0\n");
634}
635
636static ssize_t force_pwm_max_show(struct device *dev,
637 struct device_attribute *devattr, char *buf)
638{
639 struct adt7470_data *data = adt7470_update_device(dev);
679 if (FAN_DATA_VALID(data->fan[attr->index]))
680 return sprintf(buf, "%d\n",
681 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
682 else
683 return sprintf(buf, "0\n");
684}
685
686static ssize_t force_pwm_max_show(struct device *dev,
687 struct device_attribute *devattr, char *buf)
688{
689 struct adt7470_data *data = adt7470_update_device(dev);
690
691 if (IS_ERR(data))
692 return PTR_ERR(data);
693
640 return sprintf(buf, "%d\n", data->force_pwm_max);
641}
642
643static ssize_t force_pwm_max_store(struct device *dev,
644 struct device_attribute *devattr,
645 const char *buf, size_t count)
646{
647 struct adt7470_data *data = dev_get_drvdata(dev);

--- 17 unchanged lines hidden (view full) ---

665 return count;
666}
667
668static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
669 char *buf)
670{
671 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
672 struct adt7470_data *data = adt7470_update_device(dev);
694 return sprintf(buf, "%d\n", data->force_pwm_max);
695}
696
697static ssize_t force_pwm_max_store(struct device *dev,
698 struct device_attribute *devattr,
699 const char *buf, size_t count)
700{
701 struct adt7470_data *data = dev_get_drvdata(dev);

--- 17 unchanged lines hidden (view full) ---

719 return count;
720}
721
722static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
723 char *buf)
724{
725 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
726 struct adt7470_data *data = adt7470_update_device(dev);
727
728 if (IS_ERR(data))
729 return PTR_ERR(data);
730
673 return sprintf(buf, "%d\n", data->pwm[attr->index]);
674}
675
676static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
677 const char *buf, size_t count)
678{
679 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
680 struct adt7470_data *data = dev_get_drvdata(dev);

--- 77 unchanged lines hidden (view full) ---

758 return count;
759}
760
761static ssize_t pwm_max_show(struct device *dev,
762 struct device_attribute *devattr, char *buf)
763{
764 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
765 struct adt7470_data *data = adt7470_update_device(dev);
731 return sprintf(buf, "%d\n", data->pwm[attr->index]);
732}
733
734static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
735 const char *buf, size_t count)
736{
737 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
738 struct adt7470_data *data = dev_get_drvdata(dev);

--- 77 unchanged lines hidden (view full) ---

816 return count;
817}
818
819static ssize_t pwm_max_show(struct device *dev,
820 struct device_attribute *devattr, char *buf)
821{
822 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
823 struct adt7470_data *data = adt7470_update_device(dev);
824
825 if (IS_ERR(data))
826 return PTR_ERR(data);
827
766 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
767}
768
769static ssize_t pwm_max_store(struct device *dev,
770 struct device_attribute *devattr,
771 const char *buf, size_t count)
772{
773 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 15 unchanged lines hidden (view full) ---

789 return count;
790}
791
792static ssize_t pwm_min_show(struct device *dev,
793 struct device_attribute *devattr, char *buf)
794{
795 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
796 struct adt7470_data *data = adt7470_update_device(dev);
828 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
829}
830
831static ssize_t pwm_max_store(struct device *dev,
832 struct device_attribute *devattr,
833 const char *buf, size_t count)
834{
835 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 15 unchanged lines hidden (view full) ---

851 return count;
852}
853
854static ssize_t pwm_min_show(struct device *dev,
855 struct device_attribute *devattr, char *buf)
856{
857 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
858 struct adt7470_data *data = adt7470_update_device(dev);
859
860 if (IS_ERR(data))
861 return PTR_ERR(data);
862
797 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
798}
799
800static ssize_t pwm_min_store(struct device *dev,
801 struct device_attribute *devattr,
802 const char *buf, size_t count)
803{
804 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 15 unchanged lines hidden (view full) ---

820 return count;
821}
822
823static ssize_t pwm_tmax_show(struct device *dev,
824 struct device_attribute *devattr, char *buf)
825{
826 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
827 struct adt7470_data *data = adt7470_update_device(dev);
863 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
864}
865
866static ssize_t pwm_min_store(struct device *dev,
867 struct device_attribute *devattr,
868 const char *buf, size_t count)
869{
870 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 15 unchanged lines hidden (view full) ---

886 return count;
887}
888
889static ssize_t pwm_tmax_show(struct device *dev,
890 struct device_attribute *devattr, char *buf)
891{
892 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
893 struct adt7470_data *data = adt7470_update_device(dev);
894
895 if (IS_ERR(data))
896 return PTR_ERR(data);
897
828 /* the datasheet says that tmax = tmin + 20C */
829 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
830}
831
832static ssize_t pwm_tmin_show(struct device *dev,
833 struct device_attribute *devattr, char *buf)
834{
835 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
836 struct adt7470_data *data = adt7470_update_device(dev);
898 /* the datasheet says that tmax = tmin + 20C */
899 return sprintf(buf, "%d\n", 1000 * (20 + data->pwm_tmin[attr->index]));
900}
901
902static ssize_t pwm_tmin_show(struct device *dev,
903 struct device_attribute *devattr, char *buf)
904{
905 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
906 struct adt7470_data *data = adt7470_update_device(dev);
907
908 if (IS_ERR(data))
909 return PTR_ERR(data);
910
837 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
838}
839
840static ssize_t pwm_tmin_store(struct device *dev,
841 struct device_attribute *devattr,
842 const char *buf, size_t count)
843{
844 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 16 unchanged lines hidden (view full) ---

861 return count;
862}
863
864static ssize_t pwm_auto_show(struct device *dev,
865 struct device_attribute *devattr, char *buf)
866{
867 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
868 struct adt7470_data *data = adt7470_update_device(dev);
911 return sprintf(buf, "%d\n", 1000 * data->pwm_tmin[attr->index]);
912}
913
914static ssize_t pwm_tmin_store(struct device *dev,
915 struct device_attribute *devattr,
916 const char *buf, size_t count)
917{
918 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 16 unchanged lines hidden (view full) ---

935 return count;
936}
937
938static ssize_t pwm_auto_show(struct device *dev,
939 struct device_attribute *devattr, char *buf)
940{
941 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
942 struct adt7470_data *data = adt7470_update_device(dev);
943
944 if (IS_ERR(data))
945 return PTR_ERR(data);
946
869 return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
870}
871
872static ssize_t pwm_auto_store(struct device *dev,
873 struct device_attribute *devattr,
874 const char *buf, size_t count)
875{
876 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 29 unchanged lines hidden (view full) ---

906 return count;
907}
908
909static ssize_t pwm_auto_temp_show(struct device *dev,
910 struct device_attribute *devattr, char *buf)
911{
912 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
913 struct adt7470_data *data = adt7470_update_device(dev);
947 return sprintf(buf, "%d\n", 1 + data->pwm_automatic[attr->index]);
948}
949
950static ssize_t pwm_auto_store(struct device *dev,
951 struct device_attribute *devattr,
952 const char *buf, size_t count)
953{
954 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);

--- 29 unchanged lines hidden (view full) ---

984 return count;
985}
986
987static ssize_t pwm_auto_temp_show(struct device *dev,
988 struct device_attribute *devattr, char *buf)
989{
990 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
991 struct adt7470_data *data = adt7470_update_device(dev);
914 u8 ctrl = data->pwm_auto_temp[attr->index];
992 u8 ctrl;
915
993
994 if (IS_ERR(data))
995 return PTR_ERR(data);
996
997 ctrl = data->pwm_auto_temp[attr->index];
916 if (ctrl)
917 return sprintf(buf, "%d\n", 1 << (ctrl - 1));
918 else
919 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
920}
921
922static int cvt_auto_temp(int input)
923{

--- 366 unchanged lines hidden --- 		998 if (ctrl)
999 return sprintf(buf, "%d\n", 1 << (ctrl - 1));
1000 else
1001 return sprintf(buf, "%d\n", ADT7470_PWM_ALL_TEMPS);
1002}
1003
1004static int cvt_auto_temp(int input)
1005{

--- 366 unchanged lines hidden ---