1 // SPDX-License-Identifier: GPL-2.0+
2 // Copyright IBM Corp 2019
3
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/property.h>
14 #include <linux/sysfs.h>
15 #include <linux/unaligned.h>
16
17 #include "common.h"
18
19 #define EXTN_FLAG_SENSOR_ID BIT(7)
20
21 #define OCC_ERROR_COUNT_THRESHOLD 2 /* required by OCC spec */
22
23 #define OCC_STATE_SAFE 4
24 #define OCC_SAFE_TIMEOUT msecs_to_jiffies(60000) /* 1 min */
25
26 #define OCC_UPDATE_FREQUENCY msecs_to_jiffies(1000)
27
28 #define OCC_TEMP_SENSOR_FAULT 0xFF
29
30 #define OCC_FRU_TYPE_VRM 3
31
32 /* OCC sensor type and version definitions */
33
34 struct temp_sensor_1 {
35 u16 sensor_id;
36 u16 value;
37 } __packed;
38
39 struct temp_sensor_2 {
40 u32 sensor_id;
41 u8 fru_type;
42 u8 value;
43 } __packed;
44
45 struct temp_sensor_10 {
46 u32 sensor_id;
47 u8 fru_type;
48 u8 value;
49 u8 throttle;
50 u8 reserved;
51 } __packed;
52
53 struct freq_sensor_1 {
54 u16 sensor_id;
55 u16 value;
56 } __packed;
57
58 struct freq_sensor_2 {
59 u32 sensor_id;
60 u16 value;
61 } __packed;
62
63 struct power_sensor_1 {
64 u16 sensor_id;
65 u32 update_tag;
66 u32 accumulator;
67 u16 value;
68 } __packed;
69
70 struct power_sensor_2 {
71 u32 sensor_id;
72 u8 function_id;
73 u8 apss_channel;
74 u16 reserved;
75 u32 update_tag;
76 u64 accumulator;
77 u16 value;
78 } __packed;
79
80 struct power_sensor_data {
81 u16 value;
82 u32 update_tag;
83 u64 accumulator;
84 } __packed;
85
86 struct power_sensor_data_and_time {
87 u16 update_time;
88 u16 value;
89 u32 update_tag;
90 u64 accumulator;
91 } __packed;
92
93 struct power_sensor_a0 {
94 u32 sensor_id;
95 struct power_sensor_data_and_time system;
96 u32 reserved;
97 struct power_sensor_data_and_time proc;
98 struct power_sensor_data vdd;
99 struct power_sensor_data vdn;
100 } __packed;
101
102 struct caps_sensor_2 {
103 u16 cap;
104 u16 system_power;
105 u16 n_cap;
106 u16 max;
107 u16 min;
108 u16 user;
109 u8 user_source;
110 } __packed;
111
112 struct caps_sensor_3 {
113 u16 cap;
114 u16 system_power;
115 u16 n_cap;
116 u16 max;
117 u16 hard_min;
118 u16 soft_min;
119 u16 user;
120 u8 user_source;
121 } __packed;
122
123 struct extended_sensor {
124 union {
125 u8 name[4];
126 u32 sensor_id;
127 };
128 u8 flags;
129 u8 reserved;
130 u8 data[6];
131 } __packed;
132
occ_poll(struct occ * occ)133 static int occ_poll(struct occ *occ)
134 {
135 int rc;
136 u8 cmd[7];
137 struct occ_poll_response_header *header;
138
139 /* big endian */
140 cmd[0] = 0; /* sequence number */
141 cmd[1] = 0; /* cmd type */
142 cmd[2] = 0; /* data length msb */
143 cmd[3] = 1; /* data length lsb */
144 cmd[4] = occ->poll_cmd_data; /* data */
145 cmd[5] = 0; /* checksum msb */
146 cmd[6] = 0; /* checksum lsb */
147
148 /* mutex should already be locked if necessary */
149 rc = occ->send_cmd(occ, cmd, sizeof(cmd), &occ->resp, sizeof(occ->resp));
150 if (rc) {
151 occ->last_error = rc;
152 if (occ->error_count++ > OCC_ERROR_COUNT_THRESHOLD)
153 occ->error = rc;
154
155 goto done;
156 }
157
158 /* clear error since communication was successful */
159 occ->error_count = 0;
160 occ->last_error = 0;
161 occ->error = 0;
162
163 /* check for safe state */
164 header = (struct occ_poll_response_header *)occ->resp.data;
165 if (header->occ_state == OCC_STATE_SAFE) {
166 if (occ->last_safe) {
167 if (time_after(jiffies,
168 occ->last_safe + OCC_SAFE_TIMEOUT))
169 occ->error = -EHOSTDOWN;
170 } else {
171 occ->last_safe = jiffies;
172 }
173 } else {
174 occ->last_safe = 0;
175 }
176
177 done:
178 occ_sysfs_poll_done(occ);
179 return rc;
180 }
181
occ_set_user_power_cap(struct occ * occ,u16 user_power_cap)182 static int occ_set_user_power_cap(struct occ *occ, u16 user_power_cap)
183 {
184 int rc;
185 u8 cmd[8];
186 u8 resp[8];
187 __be16 user_power_cap_be = cpu_to_be16(user_power_cap);
188
189 cmd[0] = 0; /* sequence number */
190 cmd[1] = 0x22; /* cmd type */
191 cmd[2] = 0; /* data length msb */
192 cmd[3] = 2; /* data length lsb */
193
194 memcpy(&cmd[4], &user_power_cap_be, 2);
195
196 cmd[6] = 0; /* checksum msb */
197 cmd[7] = 0; /* checksum lsb */
198
199 rc = mutex_lock_interruptible(&occ->lock);
200 if (rc)
201 return rc;
202
203 rc = occ->send_cmd(occ, cmd, sizeof(cmd), resp, sizeof(resp));
204
205 mutex_unlock(&occ->lock);
206
207 return rc;
208 }
209
occ_update_response(struct occ * occ)210 int occ_update_response(struct occ *occ)
211 {
212 int rc = mutex_lock_interruptible(&occ->lock);
213
214 if (rc)
215 return rc;
216
217 if (!occ->active) {
218 rc = -ENODEV;
219 goto unlock;
220 }
221
222 /* limit the maximum rate of polling the OCC */
223 if (time_after(jiffies, occ->next_update)) {
224 rc = occ_poll(occ);
225 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
226 } else {
227 rc = occ->last_error;
228 }
229
230 unlock:
231 mutex_unlock(&occ->lock);
232 return rc;
233 }
234
occ_show_temp_1(struct device * dev,struct device_attribute * attr,char * buf)235 static ssize_t occ_show_temp_1(struct device *dev,
236 struct device_attribute *attr, char *buf)
237 {
238 int rc;
239 u32 val = 0;
240 struct temp_sensor_1 *temp;
241 struct occ *occ = dev_get_drvdata(dev);
242 struct occ_sensors *sensors = &occ->sensors;
243 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
244
245 rc = occ_update_response(occ);
246 if (rc)
247 return rc;
248
249 temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index;
250
251 switch (sattr->nr) {
252 case 0:
253 val = get_unaligned_be16(&temp->sensor_id);
254 break;
255 case 1:
256 /*
257 * If a sensor reading has expired and couldn't be refreshed,
258 * OCC returns 0xFFFF for that sensor.
259 */
260 if (temp->value == 0xFFFF)
261 return -EREMOTEIO;
262 val = get_unaligned_be16(&temp->value) * 1000;
263 break;
264 default:
265 return -EINVAL;
266 }
267
268 return sysfs_emit(buf, "%u\n", val);
269 }
270
occ_show_temp_2(struct device * dev,struct device_attribute * attr,char * buf)271 static ssize_t occ_show_temp_2(struct device *dev,
272 struct device_attribute *attr, char *buf)
273 {
274 int rc;
275 u32 val = 0;
276 struct temp_sensor_2 *temp;
277 struct occ *occ = dev_get_drvdata(dev);
278 struct occ_sensors *sensors = &occ->sensors;
279 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
280
281 rc = occ_update_response(occ);
282 if (rc)
283 return rc;
284
285 temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index;
286
287 switch (sattr->nr) {
288 case 0:
289 val = get_unaligned_be32(&temp->sensor_id);
290 break;
291 case 1:
292 val = temp->value;
293 if (val == OCC_TEMP_SENSOR_FAULT)
294 return -EREMOTEIO;
295
296 /*
297 * VRM doesn't return temperature, only alarm bit. This
298 * attribute maps to tempX_alarm instead of tempX_input for
299 * VRM
300 */
301 if (temp->fru_type != OCC_FRU_TYPE_VRM) {
302 /* sensor not ready */
303 if (val == 0)
304 return -EAGAIN;
305
306 val *= 1000;
307 }
308 break;
309 case 2:
310 val = temp->fru_type;
311 break;
312 case 3:
313 val = temp->value == OCC_TEMP_SENSOR_FAULT;
314 break;
315 default:
316 return -EINVAL;
317 }
318
319 return sysfs_emit(buf, "%u\n", val);
320 }
321
occ_show_temp_10(struct device * dev,struct device_attribute * attr,char * buf)322 static ssize_t occ_show_temp_10(struct device *dev,
323 struct device_attribute *attr, char *buf)
324 {
325 int rc;
326 u32 val = 0;
327 struct temp_sensor_10 *temp;
328 struct occ *occ = dev_get_drvdata(dev);
329 struct occ_sensors *sensors = &occ->sensors;
330 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
331
332 rc = occ_update_response(occ);
333 if (rc)
334 return rc;
335
336 temp = ((struct temp_sensor_10 *)sensors->temp.data) + sattr->index;
337
338 switch (sattr->nr) {
339 case 0:
340 val = get_unaligned_be32(&temp->sensor_id);
341 break;
342 case 1:
343 val = temp->value;
344 if (val == OCC_TEMP_SENSOR_FAULT)
345 return -EREMOTEIO;
346
347 /* sensor not ready */
348 if (val == 0)
349 return -EAGAIN;
350
351 val *= 1000;
352 break;
353 case 2:
354 val = temp->fru_type;
355 break;
356 case 3:
357 val = temp->value == OCC_TEMP_SENSOR_FAULT;
358 break;
359 case 4:
360 val = temp->throttle * 1000;
361 break;
362 default:
363 return -EINVAL;
364 }
365
366 return sysfs_emit(buf, "%u\n", val);
367 }
368
occ_show_freq_1(struct device * dev,struct device_attribute * attr,char * buf)369 static ssize_t occ_show_freq_1(struct device *dev,
370 struct device_attribute *attr, char *buf)
371 {
372 int rc;
373 u16 val = 0;
374 struct freq_sensor_1 *freq;
375 struct occ *occ = dev_get_drvdata(dev);
376 struct occ_sensors *sensors = &occ->sensors;
377 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
378
379 rc = occ_update_response(occ);
380 if (rc)
381 return rc;
382
383 freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index;
384
385 switch (sattr->nr) {
386 case 0:
387 val = get_unaligned_be16(&freq->sensor_id);
388 break;
389 case 1:
390 val = get_unaligned_be16(&freq->value);
391 break;
392 default:
393 return -EINVAL;
394 }
395
396 return sysfs_emit(buf, "%u\n", val);
397 }
398
occ_show_freq_2(struct device * dev,struct device_attribute * attr,char * buf)399 static ssize_t occ_show_freq_2(struct device *dev,
400 struct device_attribute *attr, char *buf)
401 {
402 int rc;
403 u32 val = 0;
404 struct freq_sensor_2 *freq;
405 struct occ *occ = dev_get_drvdata(dev);
406 struct occ_sensors *sensors = &occ->sensors;
407 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
408
409 rc = occ_update_response(occ);
410 if (rc)
411 return rc;
412
413 freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index;
414
415 switch (sattr->nr) {
416 case 0:
417 val = get_unaligned_be32(&freq->sensor_id);
418 break;
419 case 1:
420 val = get_unaligned_be16(&freq->value);
421 break;
422 default:
423 return -EINVAL;
424 }
425
426 return sysfs_emit(buf, "%u\n", val);
427 }
428
occ_get_powr_avg(u64 accum,u32 samples)429 static u64 occ_get_powr_avg(u64 accum, u32 samples)
430 {
431 return (samples == 0) ? 0 :
432 mul_u64_u32_div(accum, 1000000UL, samples);
433 }
434
occ_show_power_1(struct device * dev,struct device_attribute * attr,char * buf)435 static ssize_t occ_show_power_1(struct device *dev,
436 struct device_attribute *attr, char *buf)
437 {
438 int rc;
439 u64 val = 0;
440 struct power_sensor_1 *power;
441 struct occ *occ = dev_get_drvdata(dev);
442 struct occ_sensors *sensors = &occ->sensors;
443 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
444
445 rc = occ_update_response(occ);
446 if (rc)
447 return rc;
448
449 power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index;
450
451 switch (sattr->nr) {
452 case 0:
453 val = get_unaligned_be16(&power->sensor_id);
454 break;
455 case 1:
456 val = occ_get_powr_avg(get_unaligned_be32(&power->accumulator),
457 get_unaligned_be32(&power->update_tag));
458 break;
459 case 2:
460 val = (u64)get_unaligned_be32(&power->update_tag) *
461 occ->powr_sample_time_us;
462 break;
463 case 3:
464 val = get_unaligned_be16(&power->value) * 1000000ULL;
465 break;
466 default:
467 return -EINVAL;
468 }
469
470 return sysfs_emit(buf, "%llu\n", val);
471 }
472
occ_show_power_2(struct device * dev,struct device_attribute * attr,char * buf)473 static ssize_t occ_show_power_2(struct device *dev,
474 struct device_attribute *attr, char *buf)
475 {
476 int rc;
477 u64 val = 0;
478 struct power_sensor_2 *power;
479 struct occ *occ = dev_get_drvdata(dev);
480 struct occ_sensors *sensors = &occ->sensors;
481 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
482
483 rc = occ_update_response(occ);
484 if (rc)
485 return rc;
486
487 power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index;
488
489 switch (sattr->nr) {
490 case 0:
491 return sysfs_emit(buf, "%u_%u_%u\n",
492 get_unaligned_be32(&power->sensor_id),
493 power->function_id, power->apss_channel);
494 case 1:
495 val = occ_get_powr_avg(get_unaligned_be64(&power->accumulator),
496 get_unaligned_be32(&power->update_tag));
497 break;
498 case 2:
499 val = (u64)get_unaligned_be32(&power->update_tag) *
500 occ->powr_sample_time_us;
501 break;
502 case 3:
503 val = get_unaligned_be16(&power->value) * 1000000ULL;
504 break;
505 default:
506 return -EINVAL;
507 }
508
509 return sysfs_emit(buf, "%llu\n", val);
510 }
511
occ_show_power_a0(struct device * dev,struct device_attribute * attr,char * buf)512 static ssize_t occ_show_power_a0(struct device *dev,
513 struct device_attribute *attr, char *buf)
514 {
515 int rc;
516 u64 val = 0;
517 struct power_sensor_a0 *power;
518 struct occ *occ = dev_get_drvdata(dev);
519 struct occ_sensors *sensors = &occ->sensors;
520 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
521
522 rc = occ_update_response(occ);
523 if (rc)
524 return rc;
525
526 power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index;
527
528 switch (sattr->nr) {
529 case 0:
530 return sysfs_emit(buf, "%u_system\n",
531 get_unaligned_be32(&power->sensor_id));
532 case 1:
533 val = occ_get_powr_avg(get_unaligned_be64(&power->system.accumulator),
534 get_unaligned_be32(&power->system.update_tag));
535 break;
536 case 2:
537 val = (u64)get_unaligned_be32(&power->system.update_tag) *
538 occ->powr_sample_time_us;
539 break;
540 case 3:
541 val = get_unaligned_be16(&power->system.value) * 1000000ULL;
542 break;
543 case 4:
544 return sysfs_emit(buf, "%u_proc\n",
545 get_unaligned_be32(&power->sensor_id));
546 case 5:
547 val = occ_get_powr_avg(get_unaligned_be64(&power->proc.accumulator),
548 get_unaligned_be32(&power->proc.update_tag));
549 break;
550 case 6:
551 val = (u64)get_unaligned_be32(&power->proc.update_tag) *
552 occ->powr_sample_time_us;
553 break;
554 case 7:
555 val = get_unaligned_be16(&power->proc.value) * 1000000ULL;
556 break;
557 case 8:
558 return sysfs_emit(buf, "%u_vdd\n",
559 get_unaligned_be32(&power->sensor_id));
560 case 9:
561 val = occ_get_powr_avg(get_unaligned_be64(&power->vdd.accumulator),
562 get_unaligned_be32(&power->vdd.update_tag));
563 break;
564 case 10:
565 val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
566 occ->powr_sample_time_us;
567 break;
568 case 11:
569 val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;
570 break;
571 case 12:
572 return sysfs_emit(buf, "%u_vdn\n",
573 get_unaligned_be32(&power->sensor_id));
574 case 13:
575 val = occ_get_powr_avg(get_unaligned_be64(&power->vdn.accumulator),
576 get_unaligned_be32(&power->vdn.update_tag));
577 break;
578 case 14:
579 val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
580 occ->powr_sample_time_us;
581 break;
582 case 15:
583 val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;
584 break;
585 default:
586 return -EINVAL;
587 }
588
589 return sysfs_emit(buf, "%llu\n", val);
590 }
591
occ_show_caps_1_2(struct device * dev,struct device_attribute * attr,char * buf)592 static ssize_t occ_show_caps_1_2(struct device *dev,
593 struct device_attribute *attr, char *buf)
594 {
595 int rc;
596 u64 val = 0;
597 struct caps_sensor_2 *caps;
598 struct occ *occ = dev_get_drvdata(dev);
599 struct occ_sensors *sensors = &occ->sensors;
600 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
601
602 rc = occ_update_response(occ);
603 if (rc)
604 return rc;
605
606 caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index;
607
608 switch (sattr->nr) {
609 case 0:
610 return sysfs_emit(buf, "system\n");
611 case 1:
612 val = get_unaligned_be16(&caps->cap) * 1000000ULL;
613 break;
614 case 2:
615 val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
616 break;
617 case 3:
618 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
619 break;
620 case 4:
621 val = get_unaligned_be16(&caps->max) * 1000000ULL;
622 break;
623 case 5:
624 val = get_unaligned_be16(&caps->min) * 1000000ULL;
625 break;
626 case 6:
627 val = get_unaligned_be16(&caps->user) * 1000000ULL;
628 break;
629 case 7:
630 if (occ->sensors.caps.version == 1)
631 return -EINVAL;
632
633 val = caps->user_source;
634 break;
635 default:
636 return -EINVAL;
637 }
638
639 return sysfs_emit(buf, "%llu\n", val);
640 }
641
occ_show_caps_3(struct device * dev,struct device_attribute * attr,char * buf)642 static ssize_t occ_show_caps_3(struct device *dev,
643 struct device_attribute *attr, char *buf)
644 {
645 int rc;
646 u64 val = 0;
647 struct caps_sensor_3 *caps;
648 struct occ *occ = dev_get_drvdata(dev);
649 struct occ_sensors *sensors = &occ->sensors;
650 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
651
652 rc = occ_update_response(occ);
653 if (rc)
654 return rc;
655
656 caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index;
657
658 switch (sattr->nr) {
659 case 0:
660 return sysfs_emit(buf, "system\n");
661 case 1:
662 val = get_unaligned_be16(&caps->cap) * 1000000ULL;
663 break;
664 case 2:
665 val = get_unaligned_be16(&caps->system_power) * 1000000ULL;
666 break;
667 case 3:
668 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL;
669 break;
670 case 4:
671 val = get_unaligned_be16(&caps->max) * 1000000ULL;
672 break;
673 case 5:
674 val = get_unaligned_be16(&caps->hard_min) * 1000000ULL;
675 break;
676 case 6:
677 val = get_unaligned_be16(&caps->user) * 1000000ULL;
678 break;
679 case 7:
680 val = caps->user_source;
681 break;
682 case 8:
683 val = get_unaligned_be16(&caps->soft_min) * 1000000ULL;
684 break;
685 default:
686 return -EINVAL;
687 }
688
689 return sysfs_emit(buf, "%llu\n", val);
690 }
691
occ_store_caps_user(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)692 static ssize_t occ_store_caps_user(struct device *dev,
693 struct device_attribute *attr,
694 const char *buf, size_t count)
695 {
696 int rc;
697 u16 user_power_cap;
698 unsigned long long value;
699 struct occ *occ = dev_get_drvdata(dev);
700
701 rc = kstrtoull(buf, 0, &value);
702 if (rc)
703 return rc;
704
705 user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */
706
707 rc = occ_set_user_power_cap(occ, user_power_cap);
708 if (rc)
709 return rc;
710
711 return count;
712 }
713
occ_show_extended(struct device * dev,struct device_attribute * attr,char * buf)714 static ssize_t occ_show_extended(struct device *dev,
715 struct device_attribute *attr, char *buf)
716 {
717 int rc;
718 struct extended_sensor *extn;
719 struct occ *occ = dev_get_drvdata(dev);
720 struct occ_sensors *sensors = &occ->sensors;
721 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
722
723 rc = occ_update_response(occ);
724 if (rc)
725 return rc;
726
727 extn = ((struct extended_sensor *)sensors->extended.data) +
728 sattr->index;
729
730 switch (sattr->nr) {
731 case 0:
732 if (extn->flags & EXTN_FLAG_SENSOR_ID) {
733 rc = sysfs_emit(buf, "%u\n",
734 get_unaligned_be32(&extn->sensor_id));
735 } else {
736 rc = sysfs_emit(buf, "%4phN\n", extn->name);
737 }
738 break;
739 case 1:
740 rc = sysfs_emit(buf, "%02x\n", extn->flags);
741 break;
742 case 2:
743 rc = sysfs_emit(buf, "%6phN\n", extn->data);
744 break;
745 default:
746 return -EINVAL;
747 }
748
749 return rc;
750 }
751
752 /*
753 * A helper to make it easier to define an occ_attribute. Since these
754 * are dynamically allocated, we cannot use the existing kernel macros which
755 * stringify the name argument.
756 */
757 __printf(7, 8)
occ_init_attribute(struct occ_attribute * attr,int mode,ssize_t (* show)(struct device * dev,struct device_attribute * attr,char * buf),ssize_t (* store)(struct device * dev,struct device_attribute * attr,const char * buf,size_t count),int nr,int index,const char * fmt,...)758 static void occ_init_attribute(struct occ_attribute *attr, int mode,
759 ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf),
760 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
761 const char *buf, size_t count),
762 int nr, int index, const char *fmt, ...)
763 {
764 va_list args;
765
766 va_start(args, fmt);
767 vsnprintf(attr->name, sizeof(attr->name), fmt, args);
768 va_end(args);
769
770 attr->sensor.dev_attr.attr.name = attr->name;
771 attr->sensor.dev_attr.attr.mode = mode;
772 attr->sensor.dev_attr.show = show;
773 attr->sensor.dev_attr.store = store;
774 attr->sensor.index = index;
775 attr->sensor.nr = nr;
776 }
777
778 /*
779 * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to
780 * use our own instead of the built-in hwmon attribute types.
781 */
occ_setup_sensor_attrs(struct occ * occ)782 static int occ_setup_sensor_attrs(struct occ *occ)
783 {
784 unsigned int i, s, num_attrs = 0;
785 struct device *dev = occ->bus_dev;
786 struct occ_sensors *sensors = &occ->sensors;
787 struct occ_attribute *attr;
788 struct temp_sensor_2 *temp;
789 ssize_t (*show_temp)(struct device *, struct device_attribute *,
790 char *) = occ_show_temp_1;
791 ssize_t (*show_freq)(struct device *, struct device_attribute *,
792 char *) = occ_show_freq_1;
793 ssize_t (*show_power)(struct device *, struct device_attribute *,
794 char *) = occ_show_power_1;
795 ssize_t (*show_caps)(struct device *, struct device_attribute *,
796 char *) = occ_show_caps_1_2;
797
798 switch (sensors->temp.version) {
799 case 1:
800 num_attrs += (sensors->temp.num_sensors * 2);
801 break;
802 case 2:
803 num_attrs += (sensors->temp.num_sensors * 4);
804 show_temp = occ_show_temp_2;
805 break;
806 case 0x10:
807 num_attrs += (sensors->temp.num_sensors * 5);
808 show_temp = occ_show_temp_10;
809 break;
810 default:
811 sensors->temp.num_sensors = 0;
812 }
813
814 switch (sensors->freq.version) {
815 case 2:
816 show_freq = occ_show_freq_2;
817 fallthrough;
818 case 1:
819 num_attrs += (sensors->freq.num_sensors * 2);
820 break;
821 default:
822 sensors->freq.num_sensors = 0;
823 }
824
825 switch (sensors->power.version) {
826 case 2:
827 show_power = occ_show_power_2;
828 fallthrough;
829 case 1:
830 num_attrs += (sensors->power.num_sensors * 4);
831 break;
832 case 0xA0:
833 num_attrs += (sensors->power.num_sensors * 16);
834 show_power = occ_show_power_a0;
835 break;
836 default:
837 sensors->power.num_sensors = 0;
838 }
839
840 switch (sensors->caps.version) {
841 case 1:
842 num_attrs += (sensors->caps.num_sensors * 7);
843 break;
844 case 2:
845 num_attrs += (sensors->caps.num_sensors * 8);
846 break;
847 case 3:
848 show_caps = occ_show_caps_3;
849 num_attrs += (sensors->caps.num_sensors * 9);
850 break;
851 default:
852 sensors->caps.num_sensors = 0;
853 }
854
855 switch (sensors->extended.version) {
856 case 1:
857 num_attrs += (sensors->extended.num_sensors * 3);
858 break;
859 default:
860 sensors->extended.num_sensors = 0;
861 }
862
863 occ->attrs = devm_kcalloc(dev, num_attrs, sizeof(*occ->attrs),
864 GFP_KERNEL);
865 if (!occ->attrs)
866 return -ENOMEM;
867
868 /* null-terminated list */
869 occ->group.attrs = devm_kcalloc(dev, num_attrs + 1,
870 sizeof(*occ->group.attrs),
871 GFP_KERNEL);
872 if (!occ->group.attrs)
873 return -ENOMEM;
874
875 attr = occ->attrs;
876
877 for (i = 0; i < sensors->temp.num_sensors; ++i) {
878 s = i + 1;
879 temp = ((struct temp_sensor_2 *)sensors->temp.data) + i;
880
881 occ_init_attribute(attr, 0444, show_temp, NULL,
882 0, i, "temp%d_label", s);
883 attr++;
884
885 if (sensors->temp.version == 2 &&
886 temp->fru_type == OCC_FRU_TYPE_VRM) {
887 occ_init_attribute(attr, 0444, show_temp, NULL,
888 1, i, "temp%d_alarm", s);
889 } else {
890 occ_init_attribute(attr, 0444, show_temp, NULL,
891 1, i, "temp%d_input", s);
892 }
893
894 attr++;
895
896 if (sensors->temp.version > 1) {
897 occ_init_attribute(attr, 0444, show_temp, NULL,
898 2, i, "temp%d_fru_type", s);
899 attr++;
900
901 occ_init_attribute(attr, 0444, show_temp, NULL,
902 3, i, "temp%d_fault", s);
903 attr++;
904
905 if (sensors->temp.version == 0x10) {
906 occ_init_attribute(attr, 0444, show_temp, NULL,
907 4, i, "temp%d_max", s);
908 attr++;
909 }
910 }
911 }
912
913 for (i = 0; i < sensors->freq.num_sensors; ++i) {
914 s = i + 1;
915
916 occ_init_attribute(attr, 0444, show_freq, NULL,
917 0, i, "freq%d_label", s);
918 attr++;
919
920 occ_init_attribute(attr, 0444, show_freq, NULL,
921 1, i, "freq%d_input", s);
922 attr++;
923 }
924
925 if (sensors->power.version == 0xA0) {
926 /*
927 * Special case for many-attribute power sensor. Split it into
928 * a sensor number per power type, emulating several sensors.
929 */
930 for (i = 0; i < sensors->power.num_sensors; ++i) {
931 unsigned int j;
932 unsigned int nr = 0;
933
934 s = (i * 4) + 1;
935
936 for (j = 0; j < 4; ++j) {
937 occ_init_attribute(attr, 0444, show_power,
938 NULL, nr++, i,
939 "power%d_label", s);
940 attr++;
941
942 occ_init_attribute(attr, 0444, show_power,
943 NULL, nr++, i,
944 "power%d_average", s);
945 attr++;
946
947 occ_init_attribute(attr, 0444, show_power,
948 NULL, nr++, i,
949 "power%d_average_interval", s);
950 attr++;
951
952 occ_init_attribute(attr, 0444, show_power,
953 NULL, nr++, i,
954 "power%d_input", s);
955 attr++;
956
957 s++;
958 }
959 }
960
961 s = (sensors->power.num_sensors * 4) + 1;
962 } else {
963 for (i = 0; i < sensors->power.num_sensors; ++i) {
964 s = i + 1;
965
966 occ_init_attribute(attr, 0444, show_power, NULL,
967 0, i, "power%d_label", s);
968 attr++;
969
970 occ_init_attribute(attr, 0444, show_power, NULL,
971 1, i, "power%d_average", s);
972 attr++;
973
974 occ_init_attribute(attr, 0444, show_power, NULL,
975 2, i, "power%d_average_interval", s);
976 attr++;
977
978 occ_init_attribute(attr, 0444, show_power, NULL,
979 3, i, "power%d_input", s);
980 attr++;
981 }
982
983 s = sensors->power.num_sensors + 1;
984 }
985
986 if (sensors->caps.num_sensors >= 1) {
987 occ_init_attribute(attr, 0444, show_caps, NULL,
988 0, 0, "power%d_label", s);
989 attr++;
990
991 occ_init_attribute(attr, 0444, show_caps, NULL,
992 1, 0, "power%d_cap", s);
993 attr++;
994
995 occ_init_attribute(attr, 0444, show_caps, NULL,
996 2, 0, "power%d_input", s);
997 attr++;
998
999 occ_init_attribute(attr, 0444, show_caps, NULL,
1000 3, 0, "power%d_cap_not_redundant", s);
1001 attr++;
1002
1003 occ_init_attribute(attr, 0444, show_caps, NULL,
1004 4, 0, "power%d_cap_max", s);
1005 attr++;
1006
1007 occ_init_attribute(attr, 0444, show_caps, NULL,
1008 5, 0, "power%d_cap_min", s);
1009 attr++;
1010
1011 occ_init_attribute(attr, 0644, show_caps, occ_store_caps_user,
1012 6, 0, "power%d_cap_user", s);
1013 attr++;
1014
1015 if (sensors->caps.version > 1) {
1016 occ_init_attribute(attr, 0444, show_caps, NULL,
1017 7, 0, "power%d_cap_user_source", s);
1018 attr++;
1019
1020 if (sensors->caps.version > 2) {
1021 occ_init_attribute(attr, 0444, show_caps, NULL,
1022 8, 0,
1023 "power%d_cap_min_soft", s);
1024 attr++;
1025 }
1026 }
1027 }
1028
1029 for (i = 0; i < sensors->extended.num_sensors; ++i) {
1030 s = i + 1;
1031
1032 occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1033 0, i, "extn%d_label", s);
1034 attr++;
1035
1036 occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1037 1, i, "extn%d_flags", s);
1038 attr++;
1039
1040 occ_init_attribute(attr, 0444, occ_show_extended, NULL,
1041 2, i, "extn%d_input", s);
1042 attr++;
1043 }
1044
1045 /* put the sensors in the group */
1046 for (i = 0; i < num_attrs; ++i) {
1047 sysfs_attr_init(&occ->attrs[i].sensor.dev_attr.attr);
1048 occ->group.attrs[i] = &occ->attrs[i].sensor.dev_attr.attr;
1049 }
1050
1051 return 0;
1052 }
1053
1054 /* only need to do this once at startup, as OCC won't change sensors on us */
occ_parse_poll_response(struct occ * occ)1055 static int occ_parse_poll_response(struct occ *occ)
1056 {
1057 unsigned int i, old_offset, offset = 0, size = 0;
1058 u16 data_length;
1059 struct occ_sensor *sensor;
1060 struct occ_sensors parsed = {};
1061 struct occ_sensors *sensors = &parsed;
1062 struct occ_response *resp = &occ->resp;
1063 struct occ_poll_response *poll =
1064 (struct occ_poll_response *)&resp->data[0];
1065 struct occ_poll_response_header *header = &poll->header;
1066 struct occ_sensor_data_block *block = &poll->block;
1067
1068 data_length = get_unaligned_be16(&resp->data_length);
1069 if (data_length < sizeof(*header) || data_length > OCC_RESP_DATA_BYTES) {
1070 dev_err(occ->bus_dev, "invalid OCC poll response length %u\n",
1071 data_length);
1072 return -EMSGSIZE;
1073 }
1074
1075 dev_info(occ->bus_dev, "OCC found, code level: %.16s\n",
1076 header->occ_code_level);
1077
1078 for (i = 0; i < header->num_sensor_data_blocks; ++i) {
1079 block = (struct occ_sensor_data_block *)((u8 *)block + offset);
1080 if (size + sizeof(*header) + sizeof(block->header) >
1081 data_length) {
1082 dev_err(occ->bus_dev,
1083 "truncated OCC sensor block header\n");
1084 return -EMSGSIZE;
1085 }
1086
1087 old_offset = offset;
1088 offset = (block->header.num_sensors *
1089 block->header.sensor_length) + sizeof(block->header);
1090
1091 /* validate all the length/size fields */
1092 if (size + sizeof(*header) + offset > data_length) {
1093 dev_err(occ->bus_dev,
1094 "exceeded OCC poll response length\n");
1095 return -EMSGSIZE;
1096 }
1097 size += offset;
1098
1099 dev_dbg(occ->bus_dev, " %04x..%04x: %.4s (%d sensors)\n",
1100 old_offset, offset - 1, block->header.eye_catcher,
1101 block->header.num_sensors);
1102
1103 /* match sensor block type */
1104 if (strncmp(block->header.eye_catcher, "TEMP", 4) == 0)
1105 sensor = &sensors->temp;
1106 else if (strncmp(block->header.eye_catcher, "FREQ", 4) == 0)
1107 sensor = &sensors->freq;
1108 else if (strncmp(block->header.eye_catcher, "POWR", 4) == 0)
1109 sensor = &sensors->power;
1110 else if (strncmp(block->header.eye_catcher, "CAPS", 4) == 0)
1111 sensor = &sensors->caps;
1112 else if (strncmp(block->header.eye_catcher, "EXTN", 4) == 0)
1113 sensor = &sensors->extended;
1114 else {
1115 dev_warn(occ->bus_dev, "sensor not supported %.4s\n",
1116 block->header.eye_catcher);
1117 continue;
1118 }
1119
1120 sensor->num_sensors = block->header.num_sensors;
1121 sensor->version = block->header.sensor_format;
1122 sensor->data = &block->data;
1123 }
1124
1125 dev_dbg(occ->bus_dev, "Max resp size: %u+%zd=%zd\n", size,
1126 sizeof(*header), size + sizeof(*header));
1127 occ->sensors = parsed;
1128
1129 return 0;
1130 }
1131
occ_active(struct occ * occ,bool active)1132 int occ_active(struct occ *occ, bool active)
1133 {
1134 struct device *hwmon = NULL;
1135 int rc = mutex_lock_interruptible(&occ->hwmon_lock);
1136
1137 if (rc)
1138 return rc;
1139
1140 rc = mutex_lock_interruptible(&occ->lock);
1141 if (rc)
1142 goto unlock_hwmon;
1143
1144 if (active) {
1145 if (occ->active) {
1146 rc = -EALREADY;
1147 goto unlock;
1148 }
1149
1150 occ->error_count = 0;
1151 occ->last_safe = 0;
1152
1153 rc = occ_poll(occ);
1154 if (rc < 0) {
1155 dev_err(occ->bus_dev,
1156 "failed to get OCC poll response=%02x: %d\n",
1157 occ->resp.return_status, rc);
1158 goto unlock;
1159 }
1160
1161 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY;
1162 rc = occ_parse_poll_response(occ);
1163 if (rc)
1164 goto unlock;
1165
1166 occ->active = true;
1167 rc = occ_setup_sensor_attrs(occ);
1168 if (rc) {
1169 dev_err(occ->bus_dev,
1170 "failed to setup sensor attrs: %d\n", rc);
1171 goto unlock;
1172 }
1173
1174 occ->hwmon = hwmon_device_register_with_groups(occ->bus_dev,
1175 "occ", occ,
1176 occ->groups);
1177 if (IS_ERR(occ->hwmon)) {
1178 rc = PTR_ERR(occ->hwmon);
1179 occ->hwmon = NULL;
1180 dev_err(occ->bus_dev,
1181 "failed to register hwmon device: %d\n", rc);
1182 goto unlock;
1183 }
1184 } else {
1185 if (!occ->active) {
1186 rc = -EALREADY;
1187 goto unlock;
1188 }
1189
1190 hwmon = occ->hwmon;
1191 occ->active = false;
1192 occ->hwmon = NULL;
1193 }
1194
1195 unlock:
1196 mutex_unlock(&occ->lock);
1197 if (hwmon)
1198 hwmon_device_unregister(hwmon);
1199 unlock_hwmon:
1200 mutex_unlock(&occ->hwmon_lock);
1201 return rc;
1202 }
1203
occ_setup(struct occ * occ)1204 int occ_setup(struct occ *occ)
1205 {
1206 int rc;
1207
1208 mutex_init(&occ->lock);
1209 mutex_init(&occ->hwmon_lock);
1210 occ->groups[0] = &occ->group;
1211
1212 rc = occ_setup_sysfs(occ);
1213 if (rc) {
1214 dev_err(occ->bus_dev, "failed to setup sysfs: %d\n", rc);
1215 return rc;
1216 }
1217
1218 if (!device_property_read_bool(occ->bus_dev, "ibm,no-poll-on-init")) {
1219 rc = occ_active(occ, true);
1220 if (rc)
1221 occ_shutdown_sysfs(occ);
1222 }
1223
1224 return rc;
1225 }
1226 EXPORT_SYMBOL_GPL(occ_setup);
1227
occ_shutdown(struct occ * occ)1228 void occ_shutdown(struct occ *occ)
1229 {
1230 struct device *hwmon;
1231
1232 occ_shutdown_sysfs(occ);
1233
1234 mutex_lock(&occ->hwmon_lock);
1235 mutex_lock(&occ->lock);
1236
1237 hwmon = occ->hwmon;
1238 occ->active = false;
1239 occ->hwmon = NULL;
1240
1241 mutex_unlock(&occ->lock);
1242
1243 if (hwmon)
1244 hwmon_device_unregister(hwmon);
1245 mutex_unlock(&occ->hwmon_lock);
1246 }
1247 EXPORT_SYMBOL_GPL(occ_shutdown);
1248
1249 MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>");
1250 MODULE_DESCRIPTION("Common OCC hwmon code");
1251 MODULE_LICENSE("GPL");
1252