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), &occ->resp, sizeof(occ->resp));
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)
186 __be16 user_power_cap_be = cpu_to_be16(user_power_cap);
188 cmd[0] = 0; /* sequence number */
189 cmd[1] = 0x22; /* cmd type */
190 cmd[2] = 0; /* data length msb */
191 cmd[3] = 2; /* data length lsb */
193 memcpy(&cmd[4], &user_power_cap_be, 2);
195 cmd[6] = 0; /* checksum msb */
196 cmd[7] = 0; /* checksum lsb */
198 rc = mutex_lock_interruptible(&occ->lock);
202 rc = occ->send_cmd(occ, cmd, sizeof(cmd), resp, sizeof(resp));
204 mutex_unlock(&occ->lock);
209 int occ_update_response(struct occ *occ)
211 int rc = mutex_lock_interruptible(&occ->lock);
216 /* limit the maximum rate of polling the OCC */
217 if (time_after(jiffies, occ->next_update)) {
219 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
221 rc = occ->last_error;
224 mutex_unlock(&occ->lock);
228 static ssize_t occ_show_temp_1(struct device *dev,
229 struct device_attribute *attr, char *buf)
233 struct temp_sensor_1 *temp;
234 struct occ *occ = dev_get_drvdata(dev);
235 struct occ_sensors *sensors = &occ->sensors;
236 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
238 rc = occ_update_response(occ);
242 temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index;
246 val = get_unaligned_be16(&temp->sensor_id);
250 * If a sensor reading has expired and couldn't be refreshed,
251 * OCC returns 0xFFFF for that sensor.
253 if (temp->value == 0xFFFF)
255 val = get_unaligned_be16(&temp->value) * 1000;
261 return sysfs_emit(buf, "%u\n", val);
264 static ssize_t occ_show_temp_2(struct device *dev,
265 struct device_attribute *attr, char *buf)
269 struct temp_sensor_2 *temp;
270 struct occ *occ = dev_get_drvdata(dev);
271 struct occ_sensors *sensors = &occ->sensors;
272 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
274 rc = occ_update_response(occ);
278 temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index;
282 val = get_unaligned_be32(&temp->sensor_id);
286 if (val == OCC_TEMP_SENSOR_FAULT)
290 * VRM doesn't return temperature, only alarm bit. This
291 * attribute maps to tempX_alarm instead of tempX_input for
294 if (temp->fru_type != OCC_FRU_TYPE_VRM) {
295 /* sensor not ready */
303 val = temp->fru_type;
306 val = temp->value == OCC_TEMP_SENSOR_FAULT;
312 return sysfs_emit(buf, "%u\n", val);
315 static ssize_t occ_show_temp_10(struct device *dev,
316 struct device_attribute *attr, char *buf)
320 struct temp_sensor_10 *temp;
321 struct occ *occ = dev_get_drvdata(dev);
322 struct occ_sensors *sensors = &occ->sensors;
323 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
325 rc = occ_update_response(occ);
329 temp = ((struct temp_sensor_10 *)sensors->temp.data) + sattr->index;
333 val = get_unaligned_be32(&temp->sensor_id);
337 if (val == OCC_TEMP_SENSOR_FAULT)
340 /* sensor not ready */
347 val = temp->fru_type;
350 val = temp->value == OCC_TEMP_SENSOR_FAULT;
353 val = temp->throttle * 1000;
359 return sysfs_emit(buf, "%u\n", val);
362 static ssize_t occ_show_freq_1(struct device *dev,
363 struct device_attribute *attr, char *buf)
367 struct freq_sensor_1 *freq;
368 struct occ *occ = dev_get_drvdata(dev);
369 struct occ_sensors *sensors = &occ->sensors;
370 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
372 rc = occ_update_response(occ);
376 freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index;
380 val = get_unaligned_be16(&freq->sensor_id);
383 val = get_unaligned_be16(&freq->value);
389 return sysfs_emit(buf, "%u\n", val);
392 static ssize_t occ_show_freq_2(struct device *dev,
393 struct device_attribute *attr, char *buf)
397 struct freq_sensor_2 *freq;
398 struct occ *occ = dev_get_drvdata(dev);
399 struct occ_sensors *sensors = &occ->sensors;
400 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
402 rc = occ_update_response(occ);
406 freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index;
410 val = get_unaligned_be32(&freq->sensor_id);
413 val = get_unaligned_be16(&freq->value);
419 return sysfs_emit(buf, "%u\n", val);
422 static ssize_t occ_show_power_1(struct device *dev,
423 struct device_attribute *attr, char *buf)
427 struct power_sensor_1 *power;
428 struct occ *occ = dev_get_drvdata(dev);
429 struct occ_sensors *sensors = &occ->sensors;
430 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
432 rc = occ_update_response(occ);
436 power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index;
440 val = get_unaligned_be16(&power->sensor_id);
443 val = get_unaligned_be32(&power->accumulator) /
444 get_unaligned_be32(&power->update_tag);
448 val = (u64)get_unaligned_be32(&power->update_tag) *
449 occ->powr_sample_time_us;
452 val = get_unaligned_be16(&power->value) * 1000000ULL;
458 return sysfs_emit(buf, "%llu\n", val);
461 static u64 occ_get_powr_avg(u64 *accum, u32 *samples)
463 u64 divisor = get_unaligned_be32(samples);
465 return (divisor == 0) ? 0 :
466 div64_u64(get_unaligned_be64(accum) * 1000000ULL, divisor);
469 static ssize_t occ_show_power_2(struct device *dev,
470 struct device_attribute *attr, char *buf)
474 struct power_sensor_2 *power;
475 struct occ *occ = dev_get_drvdata(dev);
476 struct occ_sensors *sensors = &occ->sensors;
477 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
479 rc = occ_update_response(occ);
483 power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index;
487 return sysfs_emit(buf, "%u_%u_%u\n",
488 get_unaligned_be32(&power->sensor_id),
489 power->function_id, power->apss_channel);
491 val = occ_get_powr_avg(&power->accumulator,
495 val = (u64)get_unaligned_be32(&power->update_tag) *
496 occ->powr_sample_time_us;
499 val = get_unaligned_be16(&power->value) * 1000000ULL;
505 return sysfs_emit(buf, "%llu\n", val);
508 static ssize_t occ_show_power_a0(struct device *dev,
509 struct device_attribute *attr, char *buf)
513 struct power_sensor_a0 *power;
514 struct occ *occ = dev_get_drvdata(dev);
515 struct occ_sensors *sensors = &occ->sensors;
516 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
518 rc = occ_update_response(occ);
522 power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index;
526 return sysfs_emit(buf, "%u_system\n",
527 get_unaligned_be32(&power->sensor_id));
529 val = occ_get_powr_avg(&power->system.accumulator,
530 &power->system.update_tag);
533 val = (u64)get_unaligned_be32(&power->system.update_tag) *
534 occ->powr_sample_time_us;
537 val = get_unaligned_be16(&power->system.value) * 1000000ULL;
540 return sysfs_emit(buf, "%u_proc\n",
541 get_unaligned_be32(&power->sensor_id));
543 val = occ_get_powr_avg(&power->proc.accumulator,
544 &power->proc.update_tag);
547 val = (u64)get_unaligned_be32(&power->proc.update_tag) *
548 occ->powr_sample_time_us;
551 val = get_unaligned_be16(&power->proc.value) * 1000000ULL;
554 return sysfs_emit(buf, "%u_vdd\n",
555 get_unaligned_be32(&power->sensor_id));
557 val = occ_get_powr_avg(&power->vdd.accumulator,
558 &power->vdd.update_tag);
561 val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
562 occ->powr_sample_time_us;
565 val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;
568 return sysfs_emit(buf, "%u_vdn\n",
569 get_unaligned_be32(&power->sensor_id));
571 val = occ_get_powr_avg(&power->vdn.accumulator,
572 &power->vdn.update_tag);
575 val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
576 occ->powr_sample_time_us;
579 val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;
585 return sysfs_emit(buf, "%llu\n", val);
588 static ssize_t occ_show_caps_1_2(struct device *dev,
589 struct device_attribute *attr, char *buf)
593 struct caps_sensor_2 *caps;
594 struct occ *occ = dev_get_drvdata(dev);
595 struct occ_sensors *sensors = &occ->sensors;
596 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
598 rc = occ_update_response(occ);
602 caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index;
606 return sysfs_emit(buf, "system\n");
608 val = get_unaligned_be16(&caps->cap) * 1000000ULL;
611 val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
614 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
617 val = get_unaligned_be16(&caps->max) * 1000000ULL;
620 val = get_unaligned_be16(&caps->min) * 1000000ULL;
623 val = get_unaligned_be16(&caps->user) * 1000000ULL;
626 if (occ->sensors.caps.version == 1)
629 val = caps->user_source;
635 return sysfs_emit(buf, "%llu\n", val);
638 static ssize_t occ_show_caps_3(struct device *dev,
639 struct device_attribute *attr, char *buf)
643 struct caps_sensor_3 *caps;
644 struct occ *occ = dev_get_drvdata(dev);
645 struct occ_sensors *sensors = &occ->sensors;
646 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
648 rc = occ_update_response(occ);
652 caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index;
656 return sysfs_emit(buf, "system\n");
658 val = get_unaligned_be16(&caps->cap) * 1000000ULL;
661 val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
664 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
667 val = get_unaligned_be16(&caps->max) * 1000000ULL;
670 val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;
673 val = get_unaligned_be16(&caps->user) * 1000000ULL;
676 val = caps->user_source;
682 return sysfs_emit(buf, "%llu\n", val);
685 static ssize_t occ_store_caps_user(struct device *dev,
686 struct device_attribute *attr,
687 const char *buf, size_t count)
691 unsigned long long value;
692 struct occ *occ = dev_get_drvdata(dev);
694 rc = kstrtoull(buf, 0, &value);
698 user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */
700 rc = occ_set_user_power_cap(occ, user_power_cap);
707 static ssize_t occ_show_extended(struct device *dev,
708 struct device_attribute *attr, char *buf)
711 struct extended_sensor *extn;
712 struct occ *occ = dev_get_drvdata(dev);
713 struct occ_sensors *sensors = &occ->sensors;
714 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
716 rc = occ_update_response(occ);
720 extn = ((struct extended_sensor *)sensors->extended.data) +
725 if (extn->flags & EXTN_FLAG_SENSOR_ID) {
726 rc = sysfs_emit(buf, "%u",
727 get_unaligned_be32(&extn->sensor_id));
729 rc = sysfs_emit(buf, "%02x%02x%02x%02x\n",
730 extn->name[0], extn->name[1],
731 extn->name[2], extn->name[3]);
735 rc = sysfs_emit(buf, "%02x\n", extn->flags);
738 rc = sysfs_emit(buf, "%02x%02x%02x%02x%02x%02x\n",
739 extn->data[0], extn->data[1], extn->data[2],
740 extn->data[3], extn->data[4], extn->data[5]);
750 * Some helper macros to make it easier to define an occ_attribute. Since these
751 * are dynamically allocated, we shouldn't use the existing kernel macros which
752 * stringify the name argument.
754 #define ATTR_OCC(_name, _mode, _show, _store) { \
757 .mode = VERIFY_OCTAL_PERMISSIONS(_mode), \
763 #define SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index) { \
764 .dev_attr = ATTR_OCC(_name, _mode, _show, _store), \
769 #define OCC_INIT_ATTR(_name, _mode, _show, _store, _nr, _index) \
770 ((struct sensor_device_attribute_2) \
771 SENSOR_ATTR_OCC(_name, _mode, _show, _store, _nr, _index))
774 * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
775 * use our own instead of the built-in hwmon attribute types.
777 static int occ_setup_sensor_attrs(struct occ *occ)
779 unsigned int i, s, num_attrs = 0;
780 struct device *dev = occ->bus_dev;
781 struct occ_sensors *sensors = &occ->sensors;
782 struct occ_attribute *attr;
783 struct temp_sensor_2 *temp;
784 ssize_t (*show_temp)(struct device *, struct device_attribute *,
785 char *) = occ_show_temp_1;
786 ssize_t (*show_freq)(struct device *, struct device_attribute *,
787 char *) = occ_show_freq_1;
788 ssize_t (*show_power)(struct device *, struct device_attribute *,
789 char *) = occ_show_power_1;
790 ssize_t (*show_caps)(struct device *, struct device_attribute *,
791 char *) = occ_show_caps_1_2;
793 switch (sensors->temp.version) {
795 num_attrs += (sensors->temp.num_sensors * 2);
798 num_attrs += (sensors->temp.num_sensors * 4);
799 show_temp = occ_show_temp_2;
802 num_attrs += (sensors->temp.num_sensors * 5);
803 show_temp = occ_show_temp_10;
806 sensors->temp.num_sensors = 0;
809 switch (sensors->freq.version) {
811 show_freq = occ_show_freq_2;
814 num_attrs += (sensors->freq.num_sensors * 2);
817 sensors->freq.num_sensors = 0;
820 switch (sensors->power.version) {
822 show_power = occ_show_power_2;
825 num_attrs += (sensors->power.num_sensors * 4);
828 num_attrs += (sensors->power.num_sensors * 16);
829 show_power = occ_show_power_a0;
832 sensors->power.num_sensors = 0;
835 switch (sensors->caps.version) {
837 num_attrs += (sensors->caps.num_sensors * 7);
840 show_caps = occ_show_caps_3;
843 num_attrs += (sensors->caps.num_sensors * 8);
846 sensors->caps.num_sensors = 0;
849 switch (sensors->extended.version) {
851 num_attrs += (sensors->extended.num_sensors * 3);
854 sensors->extended.num_sensors = 0;
857 occ->attrs = devm_kzalloc(dev, sizeof(*occ->attrs) * num_attrs,
862 /* null-terminated list */
863 occ->group.attrs = devm_kzalloc(dev, sizeof(*occ->group.attrs) *
864 num_attrs + 1, GFP_KERNEL);
865 if (!occ->group.attrs)
870 for (i = 0; i < sensors->temp.num_sensors; ++i) {
872 temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;
874 snprintf(attr->name, sizeof(attr->name), "temp%d_label", s);
875 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
879 if (sensors->temp.version == 2 &&
880 temp->fru_type == OCC_FRU_TYPE_VRM) {
881 snprintf(attr->name, sizeof(attr->name),
884 snprintf(attr->name, sizeof(attr->name),
888 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_temp, NULL,
892 if (sensors->temp.version > 1) {
893 snprintf(attr->name, sizeof(attr->name),
894 "temp%d_fru_type", s);
895 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
896 show_temp, NULL, 2, i);
899 snprintf(attr->name, sizeof(attr->name),
901 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
902 show_temp, NULL, 3, i);
905 if (sensors->temp.version == 0x10) {
906 snprintf(attr->name, sizeof(attr->name),
908 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
916 for (i = 0; i < sensors->freq.num_sensors; ++i) {
919 snprintf(attr->name, sizeof(attr->name), "freq%d_label", s);
920 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
924 snprintf(attr->name, sizeof(attr->name), "freq%d_input", s);
925 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_freq, NULL,
930 if (sensors->power.version == 0xA0) {
932 * Special case for many-attribute power sensor. Split it into
933 * a sensor number per power type, emulating several sensors.
935 for (i = 0; i < sensors->power.num_sensors; ++i) {
941 for (j = 0; j < 4; ++j) {
942 snprintf(attr->name, sizeof(attr->name),
944 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
949 snprintf(attr->name, sizeof(attr->name),
950 "power%d_average", s);
951 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
956 snprintf(attr->name, sizeof(attr->name),
957 "power%d_average_interval", s);
958 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
963 snprintf(attr->name, sizeof(attr->name),
965 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
974 s = (sensors->power.num_sensors * 4) + 1;
976 for (i = 0; i < sensors->power.num_sensors; ++i) {
979 snprintf(attr->name, sizeof(attr->name),
981 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
982 show_power, NULL, 0, i);
985 snprintf(attr->name, sizeof(attr->name),
986 "power%d_average", s);
987 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
988 show_power, NULL, 1, i);
991 snprintf(attr->name, sizeof(attr->name),
992 "power%d_average_interval", s);
993 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
994 show_power, NULL, 2, i);
997 snprintf(attr->name, sizeof(attr->name),
999 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1000 show_power, NULL, 3, i);
1004 s = sensors->power.num_sensors + 1;
1007 if (sensors->caps.num_sensors >= 1) {
1008 snprintf(attr->name, sizeof(attr->name), "power%d_label", s);
1009 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1013 snprintf(attr->name, sizeof(attr->name), "power%d_cap", s);
1014 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1018 snprintf(attr->name, sizeof(attr->name), "power%d_input", s);
1019 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1023 snprintf(attr->name, sizeof(attr->name),
1024 "power%d_cap_not_redundant", s);
1025 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1029 snprintf(attr->name, sizeof(attr->name), "power%d_cap_max", s);
1030 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1034 snprintf(attr->name, sizeof(attr->name), "power%d_cap_min", s);
1035 attr->sensor = OCC_INIT_ATTR(attr->name, 0444, show_caps, NULL,
1039 snprintf(attr->name, sizeof(attr->name), "power%d_cap_user",
1041 attr->sensor = OCC_INIT_ATTR(attr->name, 0644, show_caps,
1042 occ_store_caps_user, 6, 0);
1045 if (sensors->caps.version > 1) {
1046 snprintf(attr->name, sizeof(attr->name),
1047 "power%d_cap_user_source", s);
1048 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1049 show_caps, NULL, 7, 0);
1054 for (i = 0; i < sensors->extended.num_sensors; ++i) {
1057 snprintf(attr->name, sizeof(attr->name), "extn%d_label", s);
1058 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1059 occ_show_extended, NULL, 0, i);
1062 snprintf(attr->name, sizeof(attr->name), "extn%d_flags", s);
1063 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1064 occ_show_extended, NULL, 1, i);
1067 snprintf(attr->name, sizeof(attr->name), "extn%d_input", s);
1068 attr->sensor = OCC_INIT_ATTR(attr->name, 0444,
1069 occ_show_extended, NULL, 2, i);
1073 /* put the sensors in the group */
1074 for (i = 0; i < num_attrs; ++i) {
1075 sysfs_attr_init(&occ->attrs[i].sensor.dev_attr.attr);
1076 occ->group.attrs[i] = &occ->attrs[i].sensor.dev_attr.attr;
1082 /* only need to do this once at startup, as OCC won't change sensors on us */
1083 static void occ_parse_poll_response(struct occ *occ)
1085 unsigned int i, old_offset, offset = 0, size = 0;
1086 struct occ_sensor *sensor;
1087 struct occ_sensors *sensors = &occ->sensors;
1088 struct occ_response *resp = &occ->resp;
1089 struct occ_poll_response *poll =
1090 (struct occ_poll_response *)&resp->data[0];
1091 struct occ_poll_response_header *header = &poll->header;
1092 struct occ_sensor_data_block *block = &poll->block;
1094 dev_info(occ->bus_dev, "OCC found, code level: %.16s\n",
1095 header->occ_code_level);
1097 for (i = 0; i < header->num_sensor_data_blocks; ++i) {
1098 block = (struct occ_sensor_data_block *)((u8 *)block + offset);
1099 old_offset = offset;
1100 offset = (block->header.num_sensors *
1101 block->header.sensor_length) + sizeof(block->header);
1104 /* validate all the length/size fields */
1105 if ((size + sizeof(*header)) >= OCC_RESP_DATA_BYTES) {
1106 dev_warn(occ->bus_dev, "exceeded response buffer\n");
1110 dev_dbg(occ->bus_dev, " %04x..%04x: %.4s (%d sensors)\n",
1111 old_offset, offset - 1, block->header.eye_catcher,
1112 block->header.num_sensors);
1114 /* match sensor block type */
1115 if (strncmp(block->header.eye_catcher, "TEMP", 4) == 0)
1116 sensor = &sensors->temp;
1117 else if (strncmp(block->header.eye_catcher, "FREQ", 4) == 0)
1118 sensor = &sensors->freq;
1119 else if (strncmp(block->header.eye_catcher, "POWR", 4) == 0)
1120 sensor = &sensors->power;
1121 else if (strncmp(block->header.eye_catcher, "CAPS", 4) == 0)
1122 sensor = &sensors->caps;
1123 else if (strncmp(block->header.eye_catcher, "EXTN", 4) == 0)
1124 sensor = &sensors->extended;
1126 dev_warn(occ->bus_dev, "sensor not supported %.4s\n",
1127 block->header.eye_catcher);
1131 sensor->num_sensors = block->header.num_sensors;
1132 sensor->version = block->header.sensor_format;
1133 sensor->data = &block->data;
1136 dev_dbg(occ->bus_dev, "Max resp size: %u+%zd=%zd\n", size,
1137 sizeof(*header), size + sizeof(*header));
1140 int occ_setup(struct occ *occ, const char *name)
1144 mutex_init(&occ->lock);
1145 occ->groups[0] = &occ->group;
1147 /* no need to lock */
1149 if (rc == -ESHUTDOWN) {
1150 dev_info(occ->bus_dev, "host is not ready\n");
1152 } else if (rc < 0) {
1153 dev_err(occ->bus_dev,
1154 "failed to get OCC poll response=%02x: %d\n",
1155 occ->resp.return_status, rc);
1159 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
1160 occ_parse_poll_response(occ);
1162 rc = occ_setup_sensor_attrs(occ);
1164 dev_err(occ->bus_dev, "failed to setup sensor attrs: %d\n",
1169 occ->hwmon = devm_hwmon_device_register_with_groups(occ->bus_dev, name,
1171 if (IS_ERR(occ->hwmon)) {
1172 rc = PTR_ERR(occ->hwmon);
1173 dev_err(occ->bus_dev, "failed to register hwmon device: %d\n",
1178 rc = occ_setup_sysfs(occ);
1180 dev_err(occ->bus_dev, "failed to setup sysfs: %d\n", rc);
1184 EXPORT_SYMBOL_GPL(occ_setup);
1186 MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>");
1187 MODULE_DESCRIPTION("Common OCC hwmon code");
1188 MODULE_LICENSE("GPL");