1 // SPDX-License-Identifier: GPL-2.0+
2 // Copyright IBM Corp 2019
4 #include <linux/device.h>
5 #include <linux/export.h>
6 #include <linux/hwmon.h>
7 #include <linux/hwmon-sysfs.h>
8 #include <linux/jiffies.h>
9 #include <linux/kernel.h>
10 #include <linux/math64.h>
11 #include <linux/module.h>
12 #include <linux/mutex.h>
13 #include <linux/sysfs.h>
14 #include <asm/unaligned.h>
18 #define EXTN_FLAG_SENSOR_ID BIT(7)
20 #define OCC_ERROR_COUNT_THRESHOLD 2 /* required by OCC spec */
22 #define OCC_STATE_SAFE 4
23 #define OCC_SAFE_TIMEOUT msecs_to_jiffies(60000) /* 1 min */
25 #define OCC_UPDATE_FREQUENCY msecs_to_jiffies(1000)
27 #define OCC_TEMP_SENSOR_FAULT 0xFF
29 #define OCC_FRU_TYPE_VRM 3
31 /* OCC sensor type and version definitions */
33 struct temp_sensor_1 {
38 struct temp_sensor_2 {
44 struct temp_sensor_10 {
52 struct freq_sensor_1 {
57 struct freq_sensor_2 {
62 struct power_sensor_1 {
69 struct power_sensor_2 {
79 struct power_sensor_data {
85 struct power_sensor_data_and_time {
92 struct power_sensor_a0 {
94 struct power_sensor_data_and_time system;
96 struct power_sensor_data_and_time proc;
97 struct power_sensor_data vdd;
98 struct power_sensor_data vdn;
101 struct caps_sensor_2 {
111 struct caps_sensor_3 {
122 struct extended_sensor {
132 static int occ_poll(struct occ *occ)
136 struct occ_poll_response_header *header;
139 cmd[0] = 0; /* sequence number */
140 cmd[1] = 0; /* cmd type */
141 cmd[2] = 0; /* data length msb */
142 cmd[3] = 1; /* data length lsb */
143 cmd[4] = occ->poll_cmd_data; /* data */
144 cmd[5] = 0; /* checksum msb */
145 cmd[6] = 0; /* checksum lsb */
147 /* mutex should already be locked if necessary */
148 rc = occ->send_cmd(occ, cmd, sizeof(cmd));
150 occ->last_error = rc;
151 if (occ->error_count++ > OCC_ERROR_COUNT_THRESHOLD)
157 /* clear error since communication was successful */
158 occ->error_count = 0;
162 /* check for safe state */
163 header = (struct occ_poll_response_header *)occ->resp.data;
164 if (header->occ_state == OCC_STATE_SAFE) {
165 if (occ->last_safe) {
166 if (time_after(jiffies,
167 occ->last_safe + OCC_SAFE_TIMEOUT))
168 occ->error = -EHOSTDOWN;
170 occ->last_safe = jiffies;
177 occ_sysfs_poll_done(occ);
181 static int occ_set_user_power_cap(struct occ *occ, u16 user_power_cap)
185 __be16 user_power_cap_be = cpu_to_be16(user_power_cap);
187 cmd[0] = 0; /* sequence number */
188 cmd[1] = 0x22; /* cmd type */
189 cmd[2] = 0; /* data length msb */
190 cmd[3] = 2; /* data length lsb */
192 memcpy(&cmd[4], &user_power_cap_be, 2);
194 cmd[6] = 0; /* checksum msb */
195 cmd[7] = 0; /* checksum lsb */
197 rc = mutex_lock_interruptible(&occ->lock);
201 rc = occ->send_cmd(occ, cmd, sizeof(cmd));
203 mutex_unlock(&occ->lock);
208 int occ_update_response(struct occ *occ)
210 int rc = mutex_lock_interruptible(&occ->lock);
215 /* limit the maximum rate of polling the OCC */
216 if (time_after(jiffies, occ->next_update)) {
218 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
220 rc = occ->last_error;
223 mutex_unlock(&occ->lock);
227 static ssize_t occ_show_temp_1(struct device *dev,
228 struct device_attribute *attr, char *buf)
232 struct temp_sensor_1 *temp;
233 struct occ *occ = dev_get_drvdata(dev);
234 struct occ_sensors *sensors = &occ->sensors;
235 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
237 rc = occ_update_response(occ);
241 temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index;
245 val = get_unaligned_be16(&temp->sensor_id);
249 * If a sensor reading has expired and couldn't be refreshed,
250 * OCC returns 0xFFFF for that sensor.
252 if (temp->value == 0xFFFF)
254 val = get_unaligned_be16(&temp->value) * 1000;
260 return sysfs_emit(buf, "%u\n", val);
263 static ssize_t occ_show_temp_2(struct device *dev,
264 struct device_attribute *attr, char *buf)
268 struct temp_sensor_2 *temp;
269 struct occ *occ = dev_get_drvdata(dev);
270 struct occ_sensors *sensors = &occ->sensors;
271 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
273 rc = occ_update_response(occ);
277 temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index;
281 val = get_unaligned_be32(&temp->sensor_id);
285 if (val == OCC_TEMP_SENSOR_FAULT)
289 * VRM doesn't return temperature, only alarm bit. This
290 * attribute maps to tempX_alarm instead of tempX_input for
293 if (temp->fru_type != OCC_FRU_TYPE_VRM) {
294 /* sensor not ready */
302 val = temp->fru_type;
305 val = temp->value == OCC_TEMP_SENSOR_FAULT;
311 return sysfs_emit(buf, "%u\n", val);
314 static ssize_t occ_show_temp_10(struct device *dev,
315 struct device_attribute *attr, char *buf)
319 struct temp_sensor_10 *temp;
320 struct occ *occ = dev_get_drvdata(dev);
321 struct occ_sensors *sensors = &occ->sensors;
322 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
324 rc = occ_update_response(occ);
328 temp = ((struct temp_sensor_10 *)sensors->temp.data) + sattr->index;
332 val = get_unaligned_be32(&temp->sensor_id);
336 if (val == OCC_TEMP_SENSOR_FAULT)
339 /* sensor not ready */
346 val = temp->fru_type;
349 val = temp->value == OCC_TEMP_SENSOR_FAULT;
352 val = temp->throttle * 1000;
358 return sysfs_emit(buf, "%u\n", val);
361 static ssize_t occ_show_freq_1(struct device *dev,
362 struct device_attribute *attr, char *buf)
366 struct freq_sensor_1 *freq;
367 struct occ *occ = dev_get_drvdata(dev);
368 struct occ_sensors *sensors = &occ->sensors;
369 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
371 rc = occ_update_response(occ);
375 freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index;
379 val = get_unaligned_be16(&freq->sensor_id);
382 val = get_unaligned_be16(&freq->value);
388 return sysfs_emit(buf, "%u\n", val);
391 static ssize_t occ_show_freq_2(struct device *dev,
392 struct device_attribute *attr, char *buf)
396 struct freq_sensor_2 *freq;
397 struct occ *occ = dev_get_drvdata(dev);
398 struct occ_sensors *sensors = &occ->sensors;
399 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
401 rc = occ_update_response(occ);
405 freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index;
409 val = get_unaligned_be32(&freq->sensor_id);
412 val = get_unaligned_be16(&freq->value);
418 return sysfs_emit(buf, "%u\n", val);
421 static ssize_t occ_show_power_1(struct device *dev,
422 struct device_attribute *attr, char *buf)
426 struct power_sensor_1 *power;
427 struct occ *occ = dev_get_drvdata(dev);
428 struct occ_sensors *sensors = &occ->sensors;
429 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
431 rc = occ_update_response(occ);
435 power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index;
439 val = get_unaligned_be16(&power->sensor_id);
442 val = get_unaligned_be32(&power->accumulator) /
443 get_unaligned_be32(&power->update_tag);
447 val = (u64)get_unaligned_be32(&power->update_tag) *
448 occ->powr_sample_time_us;
451 val = get_unaligned_be16(&power->value) * 1000000ULL;
457 return sysfs_emit(buf, "%llu\n", val);
460 static u64 occ_get_powr_avg(u64 *accum, u32 *samples)
462 u64 divisor = get_unaligned_be32(samples);
464 return (divisor == 0) ? 0 :
465 div64_u64(get_unaligned_be64(accum) * 1000000ULL, divisor);
468 static ssize_t occ_show_power_2(struct device *dev,
469 struct device_attribute *attr, char *buf)
473 struct power_sensor_2 *power;
474 struct occ *occ = dev_get_drvdata(dev);
475 struct occ_sensors *sensors = &occ->sensors;
476 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
478 rc = occ_update_response(occ);
482 power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index;
486 return sysfs_emit(buf, "%u_%u_%u\n",
487 get_unaligned_be32(&power->sensor_id),
488 power->function_id, power->apss_channel);
490 val = occ_get_powr_avg(&power->accumulator,
494 val = (u64)get_unaligned_be32(&power->update_tag) *
495 occ->powr_sample_time_us;
498 val = get_unaligned_be16(&power->value) * 1000000ULL;
504 return sysfs_emit(buf, "%llu\n", val);
507 static ssize_t occ_show_power_a0(struct device *dev,
508 struct device_attribute *attr, char *buf)
512 struct power_sensor_a0 *power;
513 struct occ *occ = dev_get_drvdata(dev);
514 struct occ_sensors *sensors = &occ->sensors;
515 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
517 rc = occ_update_response(occ);
521 power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index;
525 return sysfs_emit(buf, "%u_system\n",
526 get_unaligned_be32(&power->sensor_id));
528 val = occ_get_powr_avg(&power->system.accumulator,
529 &power->system.update_tag);
532 val = (u64)get_unaligned_be32(&power->system.update_tag) *
533 occ->powr_sample_time_us;
536 val = get_unaligned_be16(&power->system.value) * 1000000ULL;
539 return sysfs_emit(buf, "%u_proc\n",
540 get_unaligned_be32(&power->sensor_id));
542 val = occ_get_powr_avg(&power->proc.accumulator,
543 &power->proc.update_tag);
546 val = (u64)get_unaligned_be32(&power->proc.update_tag) *
547 occ->powr_sample_time_us;
550 val = get_unaligned_be16(&power->proc.value) * 1000000ULL;
553 return sysfs_emit(buf, "%u_vdd\n",
554 get_unaligned_be32(&power->sensor_id));
556 val = occ_get_powr_avg(&power->vdd.accumulator,
557 &power->vdd.update_tag);
560 val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
561 occ->powr_sample_time_us;
564 val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;
567 return sysfs_emit(buf, "%u_vdn\n",
568 get_unaligned_be32(&power->sensor_id));
570 val = occ_get_powr_avg(&power->vdn.accumulator,
571 &power->vdn.update_tag);
574 val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
575 occ->powr_sample_time_us;
578 val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;
584 return sysfs_emit(buf, "%llu\n", val);
587 static ssize_t occ_show_caps_1_2(struct device *dev,
588 struct device_attribute *attr, char *buf)
592 struct caps_sensor_2 *caps;
593 struct occ *occ = dev_get_drvdata(dev);
594 struct occ_sensors *sensors = &occ->sensors;
595 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
597 rc = occ_update_response(occ);
601 caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index;
605 return sysfs_emit(buf, "system\n");
607 val = get_unaligned_be16(&caps->cap) * 1000000ULL;
610 val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
613 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
616 val = get_unaligned_be16(&caps->max) * 1000000ULL;
619 val = get_unaligned_be16(&caps->min) * 1000000ULL;
622 val = get_unaligned_be16(&caps->user) * 1000000ULL;
625 if (occ->sensors.caps.version == 1)
628 val = caps->user_source;
634 return sysfs_emit(buf, "%llu\n", val);
637 static ssize_t occ_show_caps_3(struct device *dev,
638 struct device_attribute *attr, char *buf)
642 struct caps_sensor_3 *caps;
643 struct occ *occ = dev_get_drvdata(dev);
644 struct occ_sensors *sensors = &occ->sensors;
645 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
647 rc = occ_update_response(occ);
651 caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index;
655 return sysfs_emit(buf, "system\n");
657 val = get_unaligned_be16(&caps->cap) * 1000000ULL;
660 val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
663 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
666 val = get_unaligned_be16(&caps->max) * 1000000ULL;
669 val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;
672 val = get_unaligned_be16(&caps->user) * 1000000ULL;
675 val = caps->user_source;
678 val = get_unaligned_be16(&caps->soft_min) * 1000000ULL;
684 return sysfs_emit(buf, "%llu\n", val);
687 static ssize_t occ_store_caps_user(struct device *dev,
688 struct device_attribute *attr,
689 const char *buf, size_t count)
693 unsigned long long value;
694 struct occ *occ = dev_get_drvdata(dev);
696 rc = kstrtoull(buf, 0, &value);
700 user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */
702 rc = occ_set_user_power_cap(occ, user_power_cap);
709 static ssize_t occ_show_extended(struct device *dev,
710 struct device_attribute *attr, char *buf)
713 struct extended_sensor *extn;
714 struct occ *occ = dev_get_drvdata(dev);
715 struct occ_sensors *sensors = &occ->sensors;
716 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
718 rc = occ_update_response(occ);
722 extn = ((struct extended_sensor *)sensors->extended.data) +
727 if (extn->flags & EXTN_FLAG_SENSOR_ID) {
728 rc = sysfs_emit(buf, "%u",
729 get_unaligned_be32(&extn->sensor_id));
731 rc = sysfs_emit(buf, "%02x%02x%02x%02x\n",
732 extn->name[0], extn->name[1],
733 extn->name[2], extn->name[3]);
737 rc = sysfs_emit(buf, "%02x\n", extn->flags);
740 rc = sysfs_emit(buf, "%02x%02x%02x%02x%02x%02x\n",
741 extn->data[0], extn->data[1], extn->data[2],
742 extn->data[3], extn->data[4], extn->data[5]);
752 * Some helper macros to make it easier to define an occ_attribute. Since these
753 * are dynamically allocated, we shouldn't use the existing kernel macros which
754 * stringify the name argument.
756 #define ATTR_OCC(_name, _mode, _show, _store) { \
759 .mode = VERIFY_OCTAL_PERMISSIONS(_mode), \
765 #define SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index) { \
766 .dev_attr = ATTR_OCC(_name, _mode, _show, _store), \
771 #define OCC_INIT_ATTR(_name, _mode, _show, _store, _nr, _index) \
772 ((struct sensor_device_attribute_2) \
773 SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index))
776 * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
777 * use our own instead of the built-in hwmon attribute types.
779 static int occ_setup_sensor_attrs(struct occ *occ)
781 unsigned int i, s, num_attrs = 0;
782 struct device *dev = occ->bus_dev;
783 struct occ_sensors *sensors = &occ->sensors;
784 struct occ_attribute *attr;
785 struct temp_sensor_2 *temp;
786 ssize_t (*show_temp)(struct device *, struct device_attribute *,
787 char *) = occ_show_temp_1;
788 ssize_t (*show_freq)(struct device *, struct device_attribute *,
789 char *) = occ_show_freq_1;
790 ssize_t (*show_power)(struct device *, struct device_attribute *,
791 char *) = occ_show_power_1;
792 ssize_t (*show_caps)(struct device *, struct device_attribute *,
793 char *) = occ_show_caps_1_2;
795 switch (sensors->temp.version) {
797 num_attrs += (sensors->temp.num_sensors * 2);
800 num_attrs += (sensors->temp.num_sensors * 4);
801 show_temp = occ_show_temp_2;
804 num_attrs += (sensors->temp.num_sensors * 5);
805 show_temp = occ_show_temp_10;
808 sensors->temp.num_sensors = 0;
811 switch (sensors->freq.version) {
813 show_freq = occ_show_freq_2;
816 num_attrs += (sensors->freq.num_sensors * 2);
819 sensors->freq.num_sensors = 0;
822 switch (sensors->power.version) {
824 show_power = occ_show_power_2;
827 num_attrs += (sensors->power.num_sensors * 4);
830 num_attrs += (sensors->power.num_sensors * 16);
831 show_power = occ_show_power_a0;
834 sensors->power.num_sensors = 0;
837 switch (sensors->caps.version) {
839 num_attrs += (sensors->caps.num_sensors * 7);
842 num_attrs += (sensors->caps.num_sensors * 8);
845 show_caps = occ_show_caps_3;
846 num_attrs += (sensors->caps.num_sensors * 9);
849 sensors->caps.num_sensors = 0;
852 switch (sensors->extended.version) {
854 num_attrs += (sensors->extended.num_sensors * 3);
857 sensors->extended.num_sensors = 0;
860 occ->attrs = devm_kzalloc(dev, sizeof(*occ->attrs) * num_attrs,
865 /* null-terminated list */
866 occ->group.attrs = devm_kzalloc(dev, sizeof(*occ->group.attrs) *
867 num_attrs + 1, GFP_KERNEL);
868 if (!occ->group.attrs)
873 for (i = 0; i < sensors->temp.num_sensors; ++i) {
875 temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;
877 snprintf(attr->name, sizeof(attr->name), "temp%d_label", s);
878 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
882 if (sensors->temp.version == 2 &&
883 temp->fru_type == OCC_FRU_TYPE_VRM) {
884 snprintf(attr->name, sizeof(attr->name),
887 snprintf(attr->name, sizeof(attr->name),
891 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
895 if (sensors->temp.version > 1) {
896 snprintf(attr->name, sizeof(attr->name),
897 "temp%d_fru_type", s);
898 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
899 show_temp, NULL, 2, i);
902 snprintf(attr->name, sizeof(attr->name),
904 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
905 show_temp, NULL, 3, i);
908 if (sensors->temp.version == 0x10) {
909 snprintf(attr->name, sizeof(attr->name),
911 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
919 for (i = 0; i < sensors->freq.num_sensors; ++i) {
922 snprintf(attr->name, sizeof(attr->name), "freq%d_label", s);
923 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
927 snprintf(attr->name, sizeof(attr->name), "freq%d_input", s);
928 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
933 if (sensors->power.version == 0xA0) {
935 * Special case for many-attribute power sensor. Split it into
936 * a sensor number per power type, emulating several sensors.
938 for (i = 0; i < sensors->power.num_sensors; ++i) {
944 for (j = 0; j < 4; ++j) {
945 snprintf(attr->name, sizeof(attr->name),
947 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
952 snprintf(attr->name, sizeof(attr->name),
953 "power%d_average", s);
954 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
959 snprintf(attr->name, sizeof(attr->name),
960 "power%d_average_interval", s);
961 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
966 snprintf(attr->name, sizeof(attr->name),
968 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
977 s = (sensors->power.num_sensors * 4) + 1;
979 for (i = 0; i < sensors->power.num_sensors; ++i) {
982 snprintf(attr->name, sizeof(attr->name),
984 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
985 show_power, NULL, 0, i);
988 snprintf(attr->name, sizeof(attr->name),
989 "power%d_average", s);
990 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
991 show_power, NULL, 1, i);
994 snprintf(attr->name, sizeof(attr->name),
995 "power%d_average_interval", s);
996 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
997 show_power, NULL, 2, i);
1000 snprintf(attr->name, sizeof(attr->name),
1001 "power%d_input", s);
1002 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1003 show_power, NULL, 3, i);
1007 s = sensors->power.num_sensors + 1;
1010 if (sensors->caps.num_sensors >= 1) {
1011 snprintf(attr->name, sizeof(attr->name), "power%d_label", s);
1012 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1016 snprintf(attr->name, sizeof(attr->name), "power%d_cap", s);
1017 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1021 snprintf(attr->name, sizeof(attr->name), "power%d_input", s);
1022 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1026 snprintf(attr->name, sizeof(attr->name),
1027 "power%d_cap_not_redundant", s);
1028 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1032 snprintf(attr->name, sizeof(attr->name), "power%d_cap_max", s);
1033 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1037 snprintf(attr->name, sizeof(attr->name), "power%d_cap_min", s);
1038 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1042 snprintf(attr->name, sizeof(attr->name), "power%d_cap_user",
1044 attr->sensor = OCC_INIT_ATTR(attr->name, 0644, show_caps,
1045 occ_store_caps_user, 6, 0);
1048 if (sensors->caps.version > 1) {
1049 snprintf(attr->name, sizeof(attr->name),
1050 "power%d_cap_user_source", s);
1051 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1052 show_caps, NULL, 7, 0);
1055 if (sensors->caps.version > 2) {
1056 snprintf(attr->name, sizeof(attr->name),
1057 "power%d_cap_min_soft", s);
1058 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1066 for (i = 0; i < sensors->extended.num_sensors; ++i) {
1069 snprintf(attr->name, sizeof(attr->name), "extn%d_label", s);
1070 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1071 occ_show_extended, NULL, 0, i);
1074 snprintf(attr->name, sizeof(attr->name), "extn%d_flags", s);
1075 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1076 occ_show_extended, NULL, 1, i);
1079 snprintf(attr->name, sizeof(attr->name), "extn%d_input", s);
1080 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1081 occ_show_extended, NULL, 2, i);
1085 /* put the sensors in the group */
1086 for (i = 0; i < num_attrs; ++i) {
1087 sysfs_attr_init(&occ->attrs[i].sensor.dev_attr.attr);
1088 occ->group.attrs[i] = &occ->attrs[i].sensor.dev_attr.attr;
1094 /* only need to do this once at startup, as OCC won't change sensors on us */
1095 static void occ_parse_poll_response(struct occ *occ)
1097 unsigned int i, old_offset, offset = 0, size = 0;
1098 struct occ_sensor *sensor;
1099 struct occ_sensors *sensors = &occ->sensors;
1100 struct occ_response *resp = &occ->resp;
1101 struct occ_poll_response *poll =
1102 (struct occ_poll_response *)&resp->data[0];
1103 struct occ_poll_response_header *header = &poll->header;
1104 struct occ_sensor_data_block *block = &poll->block;
1106 dev_info(occ->bus_dev, "OCC found, code level: %.16s\n",
1107 header->occ_code_level);
1109 for (i = 0; i < header->num_sensor_data_blocks; ++i) {
1110 block = (struct occ_sensor_data_block *)((u8 *)block + offset);
1111 old_offset = offset;
1112 offset = (block->header.num_sensors *
1113 block->header.sensor_length) + sizeof(block->header);
1116 /* validate all the length/size fields */
1117 if ((size + sizeof(*header)) >= OCC_RESP_DATA_BYTES) {
1118 dev_warn(occ->bus_dev, "exceeded response buffer\n");
1122 dev_dbg(occ->bus_dev, " %04x..%04x: %.4s (%d sensors)\n",
1123 old_offset, offset - 1, block->header.eye_catcher,
1124 block->header.num_sensors);
1126 /* match sensor block type */
1127 if (strncmp(block->header.eye_catcher, "TEMP", 4) == 0)
1128 sensor = &sensors->temp;
1129 else if (strncmp(block->header.eye_catcher, "FREQ", 4) == 0)
1130 sensor = &sensors->freq;
1131 else if (strncmp(block->header.eye_catcher, "POWR", 4) == 0)
1132 sensor = &sensors->power;
1133 else if (strncmp(block->header.eye_catcher, "CAPS", 4) == 0)
1134 sensor = &sensors->caps;
1135 else if (strncmp(block->header.eye_catcher, "EXTN", 4) == 0)
1136 sensor = &sensors->extended;
1138 dev_warn(occ->bus_dev, "sensor not supported %.4s\n",
1139 block->header.eye_catcher);
1143 sensor->num_sensors = block->header.num_sensors;
1144 sensor->version = block->header.sensor_format;
1145 sensor->data = &block->data;
1148 dev_dbg(occ->bus_dev, "Max resp size: %u+%zd=%zd\n", size,
1149 sizeof(*header), size + sizeof(*header));
1152 int occ_active(struct occ *occ, bool active)
1154 int rc = mutex_lock_interruptible(&occ->lock);
1165 occ->error_count = 0;
1170 dev_err(occ->bus_dev,
1171 "failed to get OCC poll response=%02x: %d\n",
1172 occ->resp.return_status, rc);
1177 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
1178 occ_parse_poll_response(occ);
1180 rc = occ_setup_sensor_attrs(occ);
1182 dev_err(occ->bus_dev,
1183 "failed to setup sensor attrs: %d\n", rc);
1187 occ->hwmon = hwmon_device_register_with_groups(occ->bus_dev,
1190 if (IS_ERR(occ->hwmon)) {
1191 rc = PTR_ERR(occ->hwmon);
1193 dev_err(occ->bus_dev,
1194 "failed to register hwmon device: %d\n", rc);
1204 hwmon_device_unregister(occ->hwmon);
1205 occ->active = false;
1210 mutex_unlock(&occ->lock);
1214 int occ_setup(struct occ *occ)
1218 mutex_init(&occ->lock);
1219 occ->groups[0] = &occ->group;
1221 rc = occ_setup_sysfs(occ);
1223 dev_err(occ->bus_dev, "failed to setup sysfs: %d\n", rc);
1227 EXPORT_SYMBOL_GPL(occ_setup);
1229 void occ_shutdown(struct occ *occ)
1231 mutex_lock(&occ->lock);
1233 occ_shutdown_sysfs(occ);
1236 hwmon_device_unregister(occ->hwmon);
1239 mutex_unlock(&occ->lock);
1241 EXPORT_SYMBOL_GPL(occ_shutdown);
1243 MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>");
1244 MODULE_DESCRIPTION("Common OCC hwmon code");
1245 MODULE_LICENSE("GPL");