1
2
3
4
5
6
7
8
9#include <linux/debugfs.h>
10#include <linux/kernel.h>
11#include <linux/math64.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/err.h>
15#include <linux/slab.h>
16#include <linux/i2c.h>
17#include <linux/hwmon.h>
18#include <linux/hwmon-sysfs.h>
19#include <linux/pmbus.h>
20#include <linux/regulator/driver.h>
21#include <linux/regulator/machine.h>
22#include <linux/of.h>
23#include <linux/thermal.h>
24#include "pmbus.h"
25
26
27
28
29
30#define PMBUS_ATTR_ALLOC_SIZE 32
31#define PMBUS_NAME_SIZE 24
32
33struct pmbus_sensor {
34 struct pmbus_sensor *next;
35 char name[PMBUS_NAME_SIZE];
36 struct device_attribute attribute;
37 u8 page;
38 u8 phase;
39 u16 reg;
40 enum pmbus_sensor_classes class;
41 bool update;
42 bool convert;
43 int data;
44
45};
46#define to_pmbus_sensor(_attr) \
47 container_of(_attr, struct pmbus_sensor, attribute)
48
49struct pmbus_boolean {
50 char name[PMBUS_NAME_SIZE];
51 struct sensor_device_attribute attribute;
52 struct pmbus_sensor *s1;
53 struct pmbus_sensor *s2;
54};
55#define to_pmbus_boolean(_attr) \
56 container_of(_attr, struct pmbus_boolean, attribute)
57
58struct pmbus_label {
59 char name[PMBUS_NAME_SIZE];
60 struct device_attribute attribute;
61 char label[PMBUS_NAME_SIZE];
62};
63#define to_pmbus_label(_attr) \
64 container_of(_attr, struct pmbus_label, attribute)
65
66
67
68#define PB_STATUS_MASK 0xffff
69#define PB_REG_SHIFT 16
70#define PB_REG_MASK 0x3ff
71#define PB_PAGE_SHIFT 26
72#define PB_PAGE_MASK 0x3f
73
74#define pb_reg_to_index(page, reg, mask) (((page) << PB_PAGE_SHIFT) | \
75 ((reg) << PB_REG_SHIFT) | (mask))
76
77#define pb_index_to_page(index) (((index) >> PB_PAGE_SHIFT) & PB_PAGE_MASK)
78#define pb_index_to_reg(index) (((index) >> PB_REG_SHIFT) & PB_REG_MASK)
79#define pb_index_to_mask(index) ((index) & PB_STATUS_MASK)
80
81struct pmbus_data {
82 struct device *dev;
83 struct device *hwmon_dev;
84
85 u32 flags;
86
87 int exponent[PMBUS_PAGES];
88
89
90 const struct pmbus_driver_info *info;
91
92 int max_attributes;
93 int num_attributes;
94 struct attribute_group group;
95 const struct attribute_group **groups;
96 struct dentry *debugfs;
97
98 struct pmbus_sensor *sensors;
99
100 struct mutex update_lock;
101
102 bool has_status_word;
103 int (*read_status)(struct i2c_client *client, int page);
104
105 s16 currpage;
106 s16 currphase;
107};
108
109struct pmbus_debugfs_entry {
110 struct i2c_client *client;
111 u8 page;
112 u8 reg;
113};
114
115static const int pmbus_fan_rpm_mask[] = {
116 PB_FAN_1_RPM,
117 PB_FAN_2_RPM,
118 PB_FAN_1_RPM,
119 PB_FAN_2_RPM,
120};
121
122static const int pmbus_fan_config_registers[] = {
123 PMBUS_FAN_CONFIG_12,
124 PMBUS_FAN_CONFIG_12,
125 PMBUS_FAN_CONFIG_34,
126 PMBUS_FAN_CONFIG_34
127};
128
129static const int pmbus_fan_command_registers[] = {
130 PMBUS_FAN_COMMAND_1,
131 PMBUS_FAN_COMMAND_2,
132 PMBUS_FAN_COMMAND_3,
133 PMBUS_FAN_COMMAND_4,
134};
135
136void pmbus_clear_cache(struct i2c_client *client)
137{
138 struct pmbus_data *data = i2c_get_clientdata(client);
139 struct pmbus_sensor *sensor;
140
141 for (sensor = data->sensors; sensor; sensor = sensor->next)
142 sensor->data = -ENODATA;
143}
144EXPORT_SYMBOL_NS_GPL(pmbus_clear_cache, PMBUS);
145
146void pmbus_set_update(struct i2c_client *client, u8 reg, bool update)
147{
148 struct pmbus_data *data = i2c_get_clientdata(client);
149 struct pmbus_sensor *sensor;
150
151 for (sensor = data->sensors; sensor; sensor = sensor->next)
152 if (sensor->reg == reg)
153 sensor->update = update;
154}
155EXPORT_SYMBOL_NS_GPL(pmbus_set_update, PMBUS);
156
157int pmbus_set_page(struct i2c_client *client, int page, int phase)
158{
159 struct pmbus_data *data = i2c_get_clientdata(client);
160 int rv;
161
162 if (page < 0)
163 return 0;
164
165 if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL) &&
166 data->info->pages > 1 && page != data->currpage) {
167 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
168 if (rv < 0)
169 return rv;
170
171 rv = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
172 if (rv < 0)
173 return rv;
174
175 if (rv != page)
176 return -EIO;
177 }
178 data->currpage = page;
179
180 if (data->info->phases[page] && data->currphase != phase &&
181 !(data->info->func[page] & PMBUS_PHASE_VIRTUAL)) {
182 rv = i2c_smbus_write_byte_data(client, PMBUS_PHASE,
183 phase);
184 if (rv)
185 return rv;
186 }
187 data->currphase = phase;
188
189 return 0;
190}
191EXPORT_SYMBOL_NS_GPL(pmbus_set_page, PMBUS);
192
193int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
194{
195 int rv;
196
197 rv = pmbus_set_page(client, page, 0xff);
198 if (rv < 0)
199 return rv;
200
201 return i2c_smbus_write_byte(client, value);
202}
203EXPORT_SYMBOL_NS_GPL(pmbus_write_byte, PMBUS);
204
205
206
207
208
209static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
210{
211 struct pmbus_data *data = i2c_get_clientdata(client);
212 const struct pmbus_driver_info *info = data->info;
213 int status;
214
215 if (info->write_byte) {
216 status = info->write_byte(client, page, value);
217 if (status != -ENODATA)
218 return status;
219 }
220 return pmbus_write_byte(client, page, value);
221}
222
223int pmbus_write_word_data(struct i2c_client *client, int page, u8 reg,
224 u16 word)
225{
226 int rv;
227
228 rv = pmbus_set_page(client, page, 0xff);
229 if (rv < 0)
230 return rv;
231
232 return i2c_smbus_write_word_data(client, reg, word);
233}
234EXPORT_SYMBOL_NS_GPL(pmbus_write_word_data, PMBUS);
235
236
237static int pmbus_write_virt_reg(struct i2c_client *client, int page, int reg,
238 u16 word)
239{
240 int bit;
241 int id;
242 int rv;
243
244 switch (reg) {
245 case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4:
246 id = reg - PMBUS_VIRT_FAN_TARGET_1;
247 bit = pmbus_fan_rpm_mask[id];
248 rv = pmbus_update_fan(client, page, id, bit, bit, word);
249 break;
250 default:
251 rv = -ENXIO;
252 break;
253 }
254
255 return rv;
256}
257
258
259
260
261
262static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
263 u16 word)
264{
265 struct pmbus_data *data = i2c_get_clientdata(client);
266 const struct pmbus_driver_info *info = data->info;
267 int status;
268
269 if (info->write_word_data) {
270 status = info->write_word_data(client, page, reg, word);
271 if (status != -ENODATA)
272 return status;
273 }
274
275 if (reg >= PMBUS_VIRT_BASE)
276 return pmbus_write_virt_reg(client, page, reg, word);
277
278 return pmbus_write_word_data(client, page, reg, word);
279}
280
281
282
283
284
285static int _pmbus_write_byte_data(struct i2c_client *client, int page, int reg, u8 value)
286{
287 struct pmbus_data *data = i2c_get_clientdata(client);
288 const struct pmbus_driver_info *info = data->info;
289 int status;
290
291 if (info->write_byte_data) {
292 status = info->write_byte_data(client, page, reg, value);
293 if (status != -ENODATA)
294 return status;
295 }
296 return pmbus_write_byte_data(client, page, reg, value);
297}
298
299
300
301
302
303static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
304{
305 struct pmbus_data *data = i2c_get_clientdata(client);
306 const struct pmbus_driver_info *info = data->info;
307 int status;
308
309 if (info->read_byte_data) {
310 status = info->read_byte_data(client, page, reg);
311 if (status != -ENODATA)
312 return status;
313 }
314 return pmbus_read_byte_data(client, page, reg);
315}
316
317int pmbus_update_fan(struct i2c_client *client, int page, int id,
318 u8 config, u8 mask, u16 command)
319{
320 int from;
321 int rv;
322 u8 to;
323
324 from = _pmbus_read_byte_data(client, page,
325 pmbus_fan_config_registers[id]);
326 if (from < 0)
327 return from;
328
329 to = (from & ~mask) | (config & mask);
330 if (to != from) {
331 rv = _pmbus_write_byte_data(client, page,
332 pmbus_fan_config_registers[id], to);
333 if (rv < 0)
334 return rv;
335 }
336
337 return _pmbus_write_word_data(client, page,
338 pmbus_fan_command_registers[id], command);
339}
340EXPORT_SYMBOL_NS_GPL(pmbus_update_fan, PMBUS);
341
342int pmbus_read_word_data(struct i2c_client *client, int page, int phase, u8 reg)
343{
344 int rv;
345
346 rv = pmbus_set_page(client, page, phase);
347 if (rv < 0)
348 return rv;
349
350 return i2c_smbus_read_word_data(client, reg);
351}
352EXPORT_SYMBOL_NS_GPL(pmbus_read_word_data, PMBUS);
353
354static int pmbus_read_virt_reg(struct i2c_client *client, int page, int reg)
355{
356 int rv;
357 int id;
358
359 switch (reg) {
360 case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4:
361 id = reg - PMBUS_VIRT_FAN_TARGET_1;
362 rv = pmbus_get_fan_rate_device(client, page, id, rpm);
363 break;
364 default:
365 rv = -ENXIO;
366 break;
367 }
368
369 return rv;
370}
371
372
373
374
375
376static int _pmbus_read_word_data(struct i2c_client *client, int page,
377 int phase, int reg)
378{
379 struct pmbus_data *data = i2c_get_clientdata(client);
380 const struct pmbus_driver_info *info = data->info;
381 int status;
382
383 if (info->read_word_data) {
384 status = info->read_word_data(client, page, phase, reg);
385 if (status != -ENODATA)
386 return status;
387 }
388
389 if (reg >= PMBUS_VIRT_BASE)
390 return pmbus_read_virt_reg(client, page, reg);
391
392 return pmbus_read_word_data(client, page, phase, reg);
393}
394
395
396static int __pmbus_read_word_data(struct i2c_client *client, int page, int reg)
397{
398 return _pmbus_read_word_data(client, page, 0xff, reg);
399}
400
401int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
402{
403 int rv;
404
405 rv = pmbus_set_page(client, page, 0xff);
406 if (rv < 0)
407 return rv;
408
409 return i2c_smbus_read_byte_data(client, reg);
410}
411EXPORT_SYMBOL_NS_GPL(pmbus_read_byte_data, PMBUS);
412
413int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg, u8 value)
414{
415 int rv;
416
417 rv = pmbus_set_page(client, page, 0xff);
418 if (rv < 0)
419 return rv;
420
421 return i2c_smbus_write_byte_data(client, reg, value);
422}
423EXPORT_SYMBOL_NS_GPL(pmbus_write_byte_data, PMBUS);
424
425int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg,
426 u8 mask, u8 value)
427{
428 unsigned int tmp;
429 int rv;
430
431 rv = _pmbus_read_byte_data(client, page, reg);
432 if (rv < 0)
433 return rv;
434
435 tmp = (rv & ~mask) | (value & mask);
436
437 if (tmp != rv)
438 rv = _pmbus_write_byte_data(client, page, reg, tmp);
439
440 return rv;
441}
442EXPORT_SYMBOL_NS_GPL(pmbus_update_byte_data, PMBUS);
443
444static struct pmbus_sensor *pmbus_find_sensor(struct pmbus_data *data, int page,
445 int reg)
446{
447 struct pmbus_sensor *sensor;
448
449 for (sensor = data->sensors; sensor; sensor = sensor->next) {
450 if (sensor->page == page && sensor->reg == reg)
451 return sensor;
452 }
453
454 return ERR_PTR(-EINVAL);
455}
456
457static int pmbus_get_fan_rate(struct i2c_client *client, int page, int id,
458 enum pmbus_fan_mode mode,
459 bool from_cache)
460{
461 struct pmbus_data *data = i2c_get_clientdata(client);
462 bool want_rpm, have_rpm;
463 struct pmbus_sensor *s;
464 int config;
465 int reg;
466
467 want_rpm = (mode == rpm);
468
469 if (from_cache) {
470 reg = want_rpm ? PMBUS_VIRT_FAN_TARGET_1 : PMBUS_VIRT_PWM_1;
471 s = pmbus_find_sensor(data, page, reg + id);
472 if (IS_ERR(s))
473 return PTR_ERR(s);
474
475 return s->data;
476 }
477
478 config = _pmbus_read_byte_data(client, page,
479 pmbus_fan_config_registers[id]);
480 if (config < 0)
481 return config;
482
483 have_rpm = !!(config & pmbus_fan_rpm_mask[id]);
484 if (want_rpm == have_rpm)
485 return pmbus_read_word_data(client, page, 0xff,
486 pmbus_fan_command_registers[id]);
487
488
489 return 0;
490}
491
492int pmbus_get_fan_rate_device(struct i2c_client *client, int page, int id,
493 enum pmbus_fan_mode mode)
494{
495 return pmbus_get_fan_rate(client, page, id, mode, false);
496}
497EXPORT_SYMBOL_NS_GPL(pmbus_get_fan_rate_device, PMBUS);
498
499int pmbus_get_fan_rate_cached(struct i2c_client *client, int page, int id,
500 enum pmbus_fan_mode mode)
501{
502 return pmbus_get_fan_rate(client, page, id, mode, true);
503}
504EXPORT_SYMBOL_NS_GPL(pmbus_get_fan_rate_cached, PMBUS);
505
506static void pmbus_clear_fault_page(struct i2c_client *client, int page)
507{
508 _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
509}
510
511void pmbus_clear_faults(struct i2c_client *client)
512{
513 struct pmbus_data *data = i2c_get_clientdata(client);
514 int i;
515
516 for (i = 0; i < data->info->pages; i++)
517 pmbus_clear_fault_page(client, i);
518}
519EXPORT_SYMBOL_NS_GPL(pmbus_clear_faults, PMBUS);
520
521static int pmbus_check_status_cml(struct i2c_client *client)
522{
523 struct pmbus_data *data = i2c_get_clientdata(client);
524 int status, status2;
525
526 status = data->read_status(client, -1);
527 if (status < 0 || (status & PB_STATUS_CML)) {
528 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
529 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
530 return -EIO;
531 }
532 return 0;
533}
534
535static bool pmbus_check_register(struct i2c_client *client,
536 int (*func)(struct i2c_client *client,
537 int page, int reg),
538 int page, int reg)
539{
540 int rv;
541 struct pmbus_data *data = i2c_get_clientdata(client);
542
543 rv = func(client, page, reg);
544 if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
545 rv = pmbus_check_status_cml(client);
546 if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK))
547 data->read_status(client, -1);
548 pmbus_clear_fault_page(client, -1);
549 return rv >= 0;
550}
551
552static bool pmbus_check_status_register(struct i2c_client *client, int page)
553{
554 int status;
555 struct pmbus_data *data = i2c_get_clientdata(client);
556
557 status = data->read_status(client, page);
558 if (status >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK) &&
559 (status & PB_STATUS_CML)) {
560 status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
561 if (status < 0 || (status & PB_CML_FAULT_INVALID_COMMAND))
562 status = -EIO;
563 }
564
565 pmbus_clear_fault_page(client, -1);
566 return status >= 0;
567}
568
569bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
570{
571 return pmbus_check_register(client, _pmbus_read_byte_data, page, reg);
572}
573EXPORT_SYMBOL_NS_GPL(pmbus_check_byte_register, PMBUS);
574
575bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
576{
577 return pmbus_check_register(client, __pmbus_read_word_data, page, reg);
578}
579EXPORT_SYMBOL_NS_GPL(pmbus_check_word_register, PMBUS);
580
581const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client)
582{
583 struct pmbus_data *data = i2c_get_clientdata(client);
584
585 return data->info;
586}
587EXPORT_SYMBOL_NS_GPL(pmbus_get_driver_info, PMBUS);
588
589static int pmbus_get_status(struct i2c_client *client, int page, int reg)
590{
591 struct pmbus_data *data = i2c_get_clientdata(client);
592 int status;
593
594 switch (reg) {
595 case PMBUS_STATUS_WORD:
596 status = data->read_status(client, page);
597 break;
598 default:
599 status = _pmbus_read_byte_data(client, page, reg);
600 break;
601 }
602 if (status < 0)
603 pmbus_clear_faults(client);
604 return status;
605}
606
607static void pmbus_update_sensor_data(struct i2c_client *client, struct pmbus_sensor *sensor)
608{
609 if (sensor->data < 0 || sensor->update)
610 sensor->data = _pmbus_read_word_data(client, sensor->page,
611 sensor->phase, sensor->reg);
612}
613
614
615
616
617
618static s64 pmbus_reg2data_linear(struct pmbus_data *data,
619 struct pmbus_sensor *sensor)
620{
621 s16 exponent;
622 s32 mantissa;
623 s64 val;
624
625 if (sensor->class == PSC_VOLTAGE_OUT) {
626 exponent = data->exponent[sensor->page];
627 mantissa = (u16) sensor->data;
628 } else {
629 exponent = ((s16)sensor->data) >> 11;
630 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
631 }
632
633 val = mantissa;
634
635
636 if (sensor->class != PSC_FAN)
637 val = val * 1000LL;
638
639
640 if (sensor->class == PSC_POWER)
641 val = val * 1000LL;
642
643 if (exponent >= 0)
644 val <<= exponent;
645 else
646 val >>= -exponent;
647
648 return val;
649}
650
651
652
653
654
655static s64 pmbus_reg2data_direct(struct pmbus_data *data,
656 struct pmbus_sensor *sensor)
657{
658 s64 b, val = (s16)sensor->data;
659 s32 m, R;
660
661 m = data->info->m[sensor->class];
662 b = data->info->b[sensor->class];
663 R = data->info->R[sensor->class];
664
665 if (m == 0)
666 return 0;
667
668
669 R = -R;
670
671 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
672 R += 3;
673 b *= 1000;
674 }
675
676
677 if (sensor->class == PSC_POWER) {
678 R += 3;
679 b *= 1000;
680 }
681
682 while (R > 0) {
683 val *= 10;
684 R--;
685 }
686 while (R < 0) {
687 val = div_s64(val + 5LL, 10L);
688 R++;
689 }
690
691 val = div_s64(val - b, m);
692 return val;
693}
694
695
696
697
698
699static s64 pmbus_reg2data_vid(struct pmbus_data *data,
700 struct pmbus_sensor *sensor)
701{
702 long val = sensor->data;
703 long rv = 0;
704
705 switch (data->info->vrm_version[sensor->page]) {
706 case vr11:
707 if (val >= 0x02 && val <= 0xb2)
708 rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
709 break;
710 case vr12:
711 if (val >= 0x01)
712 rv = 250 + (val - 1) * 5;
713 break;
714 case vr13:
715 if (val >= 0x01)
716 rv = 500 + (val - 1) * 10;
717 break;
718 case imvp9:
719 if (val >= 0x01)
720 rv = 200 + (val - 1) * 10;
721 break;
722 case amd625mv:
723 if (val >= 0x0 && val <= 0xd8)
724 rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100);
725 break;
726 }
727 return rv;
728}
729
730static s64 pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
731{
732 s64 val;
733
734 if (!sensor->convert)
735 return sensor->data;
736
737 switch (data->info->format[sensor->class]) {
738 case direct:
739 val = pmbus_reg2data_direct(data, sensor);
740 break;
741 case vid:
742 val = pmbus_reg2data_vid(data, sensor);
743 break;
744 case linear:
745 default:
746 val = pmbus_reg2data_linear(data, sensor);
747 break;
748 }
749 return val;
750}
751
752#define MAX_MANTISSA (1023 * 1000)
753#define MIN_MANTISSA (511 * 1000)
754
755static u16 pmbus_data2reg_linear(struct pmbus_data *data,
756 struct pmbus_sensor *sensor, s64 val)
757{
758 s16 exponent = 0, mantissa;
759 bool negative = false;
760
761
762 if (val == 0)
763 return 0;
764
765 if (sensor->class == PSC_VOLTAGE_OUT) {
766
767 if (val < 0)
768 return 0;
769
770
771
772
773
774 if (data->exponent[sensor->page] < 0)
775 val <<= -data->exponent[sensor->page];
776 else
777 val >>= data->exponent[sensor->page];
778 val = DIV_ROUND_CLOSEST_ULL(val, 1000);
779 return clamp_val(val, 0, 0xffff);
780 }
781
782 if (val < 0) {
783 negative = true;
784 val = -val;
785 }
786
787
788 if (sensor->class == PSC_POWER)
789 val = DIV_ROUND_CLOSEST_ULL(val, 1000);
790
791
792
793
794
795 if (sensor->class == PSC_FAN)
796 val = val * 1000LL;
797
798
799 while (val >= MAX_MANTISSA && exponent < 15) {
800 exponent++;
801 val >>= 1;
802 }
803
804 while (val < MIN_MANTISSA && exponent > -15) {
805 exponent--;
806 val <<= 1;
807 }
808
809
810 mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
811
812
813 if (negative)
814 mantissa = -mantissa;
815
816
817 return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
818}
819
820static u16 pmbus_data2reg_direct(struct pmbus_data *data,
821 struct pmbus_sensor *sensor, s64 val)
822{
823 s64 b;
824 s32 m, R;
825
826 m = data->info->m[sensor->class];
827 b = data->info->b[sensor->class];
828 R = data->info->R[sensor->class];
829
830
831 if (sensor->class == PSC_POWER) {
832 R -= 3;
833 b *= 1000;
834 }
835
836
837 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
838 R -= 3;
839 b *= 1000;
840 }
841 val = val * m + b;
842
843 while (R > 0) {
844 val *= 10;
845 R--;
846 }
847 while (R < 0) {
848 val = div_s64(val + 5LL, 10L);
849 R++;
850 }
851
852 return (u16)clamp_val(val, S16_MIN, S16_MAX);
853}
854
855static u16 pmbus_data2reg_vid(struct pmbus_data *data,
856 struct pmbus_sensor *sensor, s64 val)
857{
858 val = clamp_val(val, 500, 1600);
859
860 return 2 + DIV_ROUND_CLOSEST_ULL((1600LL - val) * 100LL, 625);
861}
862
863static u16 pmbus_data2reg(struct pmbus_data *data,
864 struct pmbus_sensor *sensor, s64 val)
865{
866 u16 regval;
867
868 if (!sensor->convert)
869 return val;
870
871 switch (data->info->format[sensor->class]) {
872 case direct:
873 regval = pmbus_data2reg_direct(data, sensor, val);
874 break;
875 case vid:
876 regval = pmbus_data2reg_vid(data, sensor, val);
877 break;
878 case linear:
879 default:
880 regval = pmbus_data2reg_linear(data, sensor, val);
881 break;
882 }
883 return regval;
884}
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909static int pmbus_get_boolean(struct i2c_client *client, struct pmbus_boolean *b,
910 int index)
911{
912 struct pmbus_data *data = i2c_get_clientdata(client);
913 struct pmbus_sensor *s1 = b->s1;
914 struct pmbus_sensor *s2 = b->s2;
915 u16 mask = pb_index_to_mask(index);
916 u8 page = pb_index_to_page(index);
917 u16 reg = pb_index_to_reg(index);
918 int ret, status;
919 u16 regval;
920
921 mutex_lock(&data->update_lock);
922 status = pmbus_get_status(client, page, reg);
923 if (status < 0) {
924 ret = status;
925 goto unlock;
926 }
927
928 if (s1)
929 pmbus_update_sensor_data(client, s1);
930 if (s2)
931 pmbus_update_sensor_data(client, s2);
932
933 regval = status & mask;
934 if (regval) {
935 ret = _pmbus_write_byte_data(client, page, reg, regval);
936 if (ret)
937 goto unlock;
938 }
939 if (s1 && s2) {
940 s64 v1, v2;
941
942 if (s1->data < 0) {
943 ret = s1->data;
944 goto unlock;
945 }
946 if (s2->data < 0) {
947 ret = s2->data;
948 goto unlock;
949 }
950
951 v1 = pmbus_reg2data(data, s1);
952 v2 = pmbus_reg2data(data, s2);
953 ret = !!(regval && v1 >= v2);
954 } else {
955 ret = !!regval;
956 }
957unlock:
958 mutex_unlock(&data->update_lock);
959 return ret;
960}
961
962static ssize_t pmbus_show_boolean(struct device *dev,
963 struct device_attribute *da, char *buf)
964{
965 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
966 struct pmbus_boolean *boolean = to_pmbus_boolean(attr);
967 struct i2c_client *client = to_i2c_client(dev->parent);
968 int val;
969
970 val = pmbus_get_boolean(client, boolean, attr->index);
971 if (val < 0)
972 return val;
973 return sysfs_emit(buf, "%d\n", val);
974}
975
976static ssize_t pmbus_show_sensor(struct device *dev,
977 struct device_attribute *devattr, char *buf)
978{
979 struct i2c_client *client = to_i2c_client(dev->parent);
980 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
981 struct pmbus_data *data = i2c_get_clientdata(client);
982 ssize_t ret;
983
984 mutex_lock(&data->update_lock);
985 pmbus_update_sensor_data(client, sensor);
986 if (sensor->data < 0)
987 ret = sensor->data;
988 else
989 ret = sysfs_emit(buf, "%lld\n", pmbus_reg2data(data, sensor));
990 mutex_unlock(&data->update_lock);
991 return ret;
992}
993
994static ssize_t pmbus_set_sensor(struct device *dev,
995 struct device_attribute *devattr,
996 const char *buf, size_t count)
997{
998 struct i2c_client *client = to_i2c_client(dev->parent);
999 struct pmbus_data *data = i2c_get_clientdata(client);
1000 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
1001 ssize_t rv = count;
1002 s64 val;
1003 int ret;
1004 u16 regval;
1005
1006 if (kstrtos64(buf, 10, &val) < 0)
1007 return -EINVAL;
1008
1009 mutex_lock(&data->update_lock);
1010 regval = pmbus_data2reg(data, sensor, val);
1011 ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
1012 if (ret < 0)
1013 rv = ret;
1014 else
1015 sensor->data = -ENODATA;
1016 mutex_unlock(&data->update_lock);
1017 return rv;
1018}
1019
1020static ssize_t pmbus_show_label(struct device *dev,
1021 struct device_attribute *da, char *buf)
1022{
1023 struct pmbus_label *label = to_pmbus_label(da);
1024
1025 return sysfs_emit(buf, "%s\n", label->label);
1026}
1027
1028static int pmbus_add_attribute(struct pmbus_data *data, struct attribute *attr)
1029{
1030 if (data->num_attributes >= data->max_attributes - 1) {
1031 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE;
1032 void *new_attrs = devm_krealloc(data->dev, data->group.attrs,
1033 new_max_attrs * sizeof(void *),
1034 GFP_KERNEL);
1035 if (!new_attrs)
1036 return -ENOMEM;
1037 data->group.attrs = new_attrs;
1038 data->max_attributes = new_max_attrs;
1039 }
1040
1041 data->group.attrs[data->num_attributes++] = attr;
1042 data->group.attrs[data->num_attributes] = NULL;
1043 return 0;
1044}
1045
1046static void pmbus_dev_attr_init(struct device_attribute *dev_attr,
1047 const char *name,
1048 umode_t mode,
1049 ssize_t (*show)(struct device *dev,
1050 struct device_attribute *attr,
1051 char *buf),
1052 ssize_t (*store)(struct device *dev,
1053 struct device_attribute *attr,
1054 const char *buf, size_t count))
1055{
1056 sysfs_attr_init(&dev_attr->attr);
1057 dev_attr->attr.name = name;
1058 dev_attr->attr.mode = mode;
1059 dev_attr->show = show;
1060 dev_attr->store = store;
1061}
1062
1063static void pmbus_attr_init(struct sensor_device_attribute *a,
1064 const char *name,
1065 umode_t mode,
1066 ssize_t (*show)(struct device *dev,
1067 struct device_attribute *attr,
1068 char *buf),
1069 ssize_t (*store)(struct device *dev,
1070 struct device_attribute *attr,
1071 const char *buf, size_t count),
1072 int idx)
1073{
1074 pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store);
1075 a->index = idx;
1076}
1077
1078static int pmbus_add_boolean(struct pmbus_data *data,
1079 const char *name, const char *type, int seq,
1080 struct pmbus_sensor *s1,
1081 struct pmbus_sensor *s2,
1082 u8 page, u16 reg, u16 mask)
1083{
1084 struct pmbus_boolean *boolean;
1085 struct sensor_device_attribute *a;
1086
1087 if (WARN((s1 && !s2) || (!s1 && s2), "Bad s1/s2 parameters\n"))
1088 return -EINVAL;
1089
1090 boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL);
1091 if (!boolean)
1092 return -ENOMEM;
1093
1094 a = &boolean->attribute;
1095
1096 snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
1097 name, seq, type);
1098 boolean->s1 = s1;
1099 boolean->s2 = s2;
1100 pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL,
1101 pb_reg_to_index(page, reg, mask));
1102
1103 return pmbus_add_attribute(data, &a->dev_attr.attr);
1104}
1105
1106
1107struct pmbus_thermal_data {
1108 struct pmbus_data *pmbus_data;
1109 struct pmbus_sensor *sensor;
1110};
1111
1112static int pmbus_thermal_get_temp(void *data, int *temp)
1113{
1114 struct pmbus_thermal_data *tdata = data;
1115 struct pmbus_sensor *sensor = tdata->sensor;
1116 struct pmbus_data *pmbus_data = tdata->pmbus_data;
1117 struct i2c_client *client = to_i2c_client(pmbus_data->dev);
1118 struct device *dev = pmbus_data->hwmon_dev;
1119 int ret = 0;
1120
1121 if (!dev) {
1122
1123 *temp = 0;
1124 return 0;
1125 }
1126
1127 mutex_lock(&pmbus_data->update_lock);
1128 pmbus_update_sensor_data(client, sensor);
1129 if (sensor->data < 0)
1130 ret = sensor->data;
1131 else
1132 *temp = (int)pmbus_reg2data(pmbus_data, sensor);
1133 mutex_unlock(&pmbus_data->update_lock);
1134
1135 return ret;
1136}
1137
1138static const struct thermal_zone_of_device_ops pmbus_thermal_ops = {
1139 .get_temp = pmbus_thermal_get_temp,
1140};
1141
1142static int pmbus_thermal_add_sensor(struct pmbus_data *pmbus_data,
1143 struct pmbus_sensor *sensor, int index)
1144{
1145 struct device *dev = pmbus_data->dev;
1146 struct pmbus_thermal_data *tdata;
1147 struct thermal_zone_device *tzd;
1148
1149 tdata = devm_kzalloc(dev, sizeof(*tdata), GFP_KERNEL);
1150 if (!tdata)
1151 return -ENOMEM;
1152
1153 tdata->sensor = sensor;
1154 tdata->pmbus_data = pmbus_data;
1155
1156 tzd = devm_thermal_zone_of_sensor_register(dev, index, tdata,
1157 &pmbus_thermal_ops);
1158
1159
1160
1161
1162 if (IS_ERR(tzd) && (PTR_ERR(tzd) != -ENODEV))
1163 return PTR_ERR(tzd);
1164
1165 return 0;
1166}
1167
1168static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data,
1169 const char *name, const char *type,
1170 int seq, int page, int phase,
1171 int reg,
1172 enum pmbus_sensor_classes class,
1173 bool update, bool readonly,
1174 bool convert)
1175{
1176 struct pmbus_sensor *sensor;
1177 struct device_attribute *a;
1178
1179 sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL);
1180 if (!sensor)
1181 return NULL;
1182 a = &sensor->attribute;
1183
1184 if (type)
1185 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
1186 name, seq, type);
1187 else
1188 snprintf(sensor->name, sizeof(sensor->name), "%s%d",
1189 name, seq);
1190
1191 if (data->flags & PMBUS_WRITE_PROTECTED)
1192 readonly = true;
1193
1194 sensor->page = page;
1195 sensor->phase = phase;
1196 sensor->reg = reg;
1197 sensor->class = class;
1198 sensor->update = update;
1199 sensor->convert = convert;
1200 sensor->data = -ENODATA;
1201 pmbus_dev_attr_init(a, sensor->name,
1202 readonly ? 0444 : 0644,
1203 pmbus_show_sensor, pmbus_set_sensor);
1204
1205 if (pmbus_add_attribute(data, &a->attr))
1206 return NULL;
1207
1208 sensor->next = data->sensors;
1209 data->sensors = sensor;
1210
1211
1212 if (class == PSC_TEMPERATURE && strcmp(type, "input") == 0)
1213 pmbus_thermal_add_sensor(data, sensor, seq);
1214
1215 return sensor;
1216}
1217
1218static int pmbus_add_label(struct pmbus_data *data,
1219 const char *name, int seq,
1220 const char *lstring, int index, int phase)
1221{
1222 struct pmbus_label *label;
1223 struct device_attribute *a;
1224
1225 label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL);
1226 if (!label)
1227 return -ENOMEM;
1228
1229 a = &label->attribute;
1230
1231 snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
1232 if (!index) {
1233 if (phase == 0xff)
1234 strncpy(label->label, lstring,
1235 sizeof(label->label) - 1);
1236 else
1237 snprintf(label->label, sizeof(label->label), "%s.%d",
1238 lstring, phase);
1239 } else {
1240 if (phase == 0xff)
1241 snprintf(label->label, sizeof(label->label), "%s%d",
1242 lstring, index);
1243 else
1244 snprintf(label->label, sizeof(label->label), "%s%d.%d",
1245 lstring, index, phase);
1246 }
1247
1248 pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL);
1249 return pmbus_add_attribute(data, &a->attr);
1250}
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260struct pmbus_limit_attr {
1261 u16 reg;
1262 u16 sbit;
1263 bool update;
1264 bool low;
1265
1266 const char *attr;
1267 const char *alarm;
1268};
1269
1270
1271
1272
1273
1274struct pmbus_sensor_attr {
1275 u16 reg;
1276 u16 gbit;
1277 u8 nlimit;
1278 enum pmbus_sensor_classes class;
1279 const char *label;
1280 bool paged;
1281 bool update;
1282 bool compare;
1283 u32 func;
1284 u32 sfunc;
1285 int sreg;
1286 const struct pmbus_limit_attr *limit;
1287};
1288
1289
1290
1291
1292
1293
1294
1295static int pmbus_add_limit_attrs(struct i2c_client *client,
1296 struct pmbus_data *data,
1297 const struct pmbus_driver_info *info,
1298 const char *name, int index, int page,
1299 struct pmbus_sensor *base,
1300 const struct pmbus_sensor_attr *attr)
1301{
1302 const struct pmbus_limit_attr *l = attr->limit;
1303 int nlimit = attr->nlimit;
1304 int have_alarm = 0;
1305 int i, ret;
1306 struct pmbus_sensor *curr;
1307
1308 for (i = 0; i < nlimit; i++) {
1309 if (pmbus_check_word_register(client, page, l->reg)) {
1310 curr = pmbus_add_sensor(data, name, l->attr, index,
1311 page, 0xff, l->reg, attr->class,
1312 attr->update || l->update,
1313 false, true);
1314 if (!curr)
1315 return -ENOMEM;
1316 if (l->sbit && (info->func[page] & attr->sfunc)) {
1317 ret = pmbus_add_boolean(data, name,
1318 l->alarm, index,
1319 attr->compare ? l->low ? curr : base
1320 : NULL,
1321 attr->compare ? l->low ? base : curr
1322 : NULL,
1323 page, attr->sreg, l->sbit);
1324 if (ret)
1325 return ret;
1326 have_alarm = 1;
1327 }
1328 }
1329 l++;
1330 }
1331 return have_alarm;
1332}
1333
1334static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
1335 struct pmbus_data *data,
1336 const struct pmbus_driver_info *info,
1337 const char *name,
1338 int index, int page, int phase,
1339 const struct pmbus_sensor_attr *attr,
1340 bool paged)
1341{
1342 struct pmbus_sensor *base;
1343 bool upper = !!(attr->gbit & 0xff00);
1344 int ret;
1345
1346 if (attr->label) {
1347 ret = pmbus_add_label(data, name, index, attr->label,
1348 paged ? page + 1 : 0, phase);
1349 if (ret)
1350 return ret;
1351 }
1352 base = pmbus_add_sensor(data, name, "input", index, page, phase,
1353 attr->reg, attr->class, true, true, true);
1354 if (!base)
1355 return -ENOMEM;
1356
1357 if (attr->sfunc && phase == 0xff) {
1358 ret = pmbus_add_limit_attrs(client, data, info, name,
1359 index, page, base, attr);
1360 if (ret < 0)
1361 return ret;
1362
1363
1364
1365
1366
1367
1368 if (!ret && attr->gbit &&
1369 (!upper || data->has_status_word) &&
1370 pmbus_check_status_register(client, page)) {
1371 ret = pmbus_add_boolean(data, name, "alarm", index,
1372 NULL, NULL,
1373 page, PMBUS_STATUS_WORD,
1374 attr->gbit);
1375 if (ret)
1376 return ret;
1377 }
1378 }
1379 return 0;
1380}
1381
1382static bool pmbus_sensor_is_paged(const struct pmbus_driver_info *info,
1383 const struct pmbus_sensor_attr *attr)
1384{
1385 int p;
1386
1387 if (attr->paged)
1388 return true;
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399 for (p = 1; p < info->pages; p++) {
1400 if (info->func[p] & attr->func)
1401 return true;
1402 }
1403 return false;
1404}
1405
1406static int pmbus_add_sensor_attrs(struct i2c_client *client,
1407 struct pmbus_data *data,
1408 const char *name,
1409 const struct pmbus_sensor_attr *attrs,
1410 int nattrs)
1411{
1412 const struct pmbus_driver_info *info = data->info;
1413 int index, i;
1414 int ret;
1415
1416 index = 1;
1417 for (i = 0; i < nattrs; i++) {
1418 int page, pages;
1419 bool paged = pmbus_sensor_is_paged(info, attrs);
1420
1421 pages = paged ? info->pages : 1;
1422 for (page = 0; page < pages; page++) {
1423 if (info->func[page] & attrs->func) {
1424 ret = pmbus_add_sensor_attrs_one(client, data, info,
1425 name, index, page,
1426 0xff, attrs, paged);
1427 if (ret)
1428 return ret;
1429 index++;
1430 }
1431 if (info->phases[page]) {
1432 int phase;
1433
1434 for (phase = 0; phase < info->phases[page];
1435 phase++) {
1436 if (!(info->pfunc[phase] & attrs->func))
1437 continue;
1438 ret = pmbus_add_sensor_attrs_one(client,
1439 data, info, name, index, page,
1440 phase, attrs, paged);
1441 if (ret)
1442 return ret;
1443 index++;
1444 }
1445 }
1446 }
1447 attrs++;
1448 }
1449 return 0;
1450}
1451
1452static const struct pmbus_limit_attr vin_limit_attrs[] = {
1453 {
1454 .reg = PMBUS_VIN_UV_WARN_LIMIT,
1455 .attr = "min",
1456 .alarm = "min_alarm",
1457 .sbit = PB_VOLTAGE_UV_WARNING,
1458 }, {
1459 .reg = PMBUS_VIN_UV_FAULT_LIMIT,
1460 .attr = "lcrit",
1461 .alarm = "lcrit_alarm",
1462 .sbit = PB_VOLTAGE_UV_FAULT | PB_VOLTAGE_VIN_OFF,
1463 }, {
1464 .reg = PMBUS_VIN_OV_WARN_LIMIT,
1465 .attr = "max",
1466 .alarm = "max_alarm",
1467 .sbit = PB_VOLTAGE_OV_WARNING,
1468 }, {
1469 .reg = PMBUS_VIN_OV_FAULT_LIMIT,
1470 .attr = "crit",
1471 .alarm = "crit_alarm",
1472 .sbit = PB_VOLTAGE_OV_FAULT,
1473 }, {
1474 .reg = PMBUS_VIRT_READ_VIN_AVG,
1475 .update = true,
1476 .attr = "average",
1477 }, {
1478 .reg = PMBUS_VIRT_READ_VIN_MIN,
1479 .update = true,
1480 .attr = "lowest",
1481 }, {
1482 .reg = PMBUS_VIRT_READ_VIN_MAX,
1483 .update = true,
1484 .attr = "highest",
1485 }, {
1486 .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1487 .attr = "reset_history",
1488 }, {
1489 .reg = PMBUS_MFR_VIN_MIN,
1490 .attr = "rated_min",
1491 }, {
1492 .reg = PMBUS_MFR_VIN_MAX,
1493 .attr = "rated_max",
1494 },
1495};
1496
1497static const struct pmbus_limit_attr vmon_limit_attrs[] = {
1498 {
1499 .reg = PMBUS_VIRT_VMON_UV_WARN_LIMIT,
1500 .attr = "min",
1501 .alarm = "min_alarm",
1502 .sbit = PB_VOLTAGE_UV_WARNING,
1503 }, {
1504 .reg = PMBUS_VIRT_VMON_UV_FAULT_LIMIT,
1505 .attr = "lcrit",
1506 .alarm = "lcrit_alarm",
1507 .sbit = PB_VOLTAGE_UV_FAULT,
1508 }, {
1509 .reg = PMBUS_VIRT_VMON_OV_WARN_LIMIT,
1510 .attr = "max",
1511 .alarm = "max_alarm",
1512 .sbit = PB_VOLTAGE_OV_WARNING,
1513 }, {
1514 .reg = PMBUS_VIRT_VMON_OV_FAULT_LIMIT,
1515 .attr = "crit",
1516 .alarm = "crit_alarm",
1517 .sbit = PB_VOLTAGE_OV_FAULT,
1518 }
1519};
1520
1521static const struct pmbus_limit_attr vout_limit_attrs[] = {
1522 {
1523 .reg = PMBUS_VOUT_UV_WARN_LIMIT,
1524 .attr = "min",
1525 .alarm = "min_alarm",
1526 .sbit = PB_VOLTAGE_UV_WARNING,
1527 }, {
1528 .reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1529 .attr = "lcrit",
1530 .alarm = "lcrit_alarm",
1531 .sbit = PB_VOLTAGE_UV_FAULT,
1532 }, {
1533 .reg = PMBUS_VOUT_OV_WARN_LIMIT,
1534 .attr = "max",
1535 .alarm = "max_alarm",
1536 .sbit = PB_VOLTAGE_OV_WARNING,
1537 }, {
1538 .reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1539 .attr = "crit",
1540 .alarm = "crit_alarm",
1541 .sbit = PB_VOLTAGE_OV_FAULT,
1542 }, {
1543 .reg = PMBUS_VIRT_READ_VOUT_AVG,
1544 .update = true,
1545 .attr = "average",
1546 }, {
1547 .reg = PMBUS_VIRT_READ_VOUT_MIN,
1548 .update = true,
1549 .attr = "lowest",
1550 }, {
1551 .reg = PMBUS_VIRT_READ_VOUT_MAX,
1552 .update = true,
1553 .attr = "highest",
1554 }, {
1555 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1556 .attr = "reset_history",
1557 }, {
1558 .reg = PMBUS_MFR_VOUT_MIN,
1559 .attr = "rated_min",
1560 }, {
1561 .reg = PMBUS_MFR_VOUT_MAX,
1562 .attr = "rated_max",
1563 },
1564};
1565
1566static const struct pmbus_sensor_attr voltage_attributes[] = {
1567 {
1568 .reg = PMBUS_READ_VIN,
1569 .class = PSC_VOLTAGE_IN,
1570 .label = "vin",
1571 .func = PMBUS_HAVE_VIN,
1572 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1573 .sreg = PMBUS_STATUS_INPUT,
1574 .gbit = PB_STATUS_VIN_UV,
1575 .limit = vin_limit_attrs,
1576 .nlimit = ARRAY_SIZE(vin_limit_attrs),
1577 }, {
1578 .reg = PMBUS_VIRT_READ_VMON,
1579 .class = PSC_VOLTAGE_IN,
1580 .label = "vmon",
1581 .func = PMBUS_HAVE_VMON,
1582 .sfunc = PMBUS_HAVE_STATUS_VMON,
1583 .sreg = PMBUS_VIRT_STATUS_VMON,
1584 .limit = vmon_limit_attrs,
1585 .nlimit = ARRAY_SIZE(vmon_limit_attrs),
1586 }, {
1587 .reg = PMBUS_READ_VCAP,
1588 .class = PSC_VOLTAGE_IN,
1589 .label = "vcap",
1590 .func = PMBUS_HAVE_VCAP,
1591 }, {
1592 .reg = PMBUS_READ_VOUT,
1593 .class = PSC_VOLTAGE_OUT,
1594 .label = "vout",
1595 .paged = true,
1596 .func = PMBUS_HAVE_VOUT,
1597 .sfunc = PMBUS_HAVE_STATUS_VOUT,
1598 .sreg = PMBUS_STATUS_VOUT,
1599 .gbit = PB_STATUS_VOUT_OV,
1600 .limit = vout_limit_attrs,
1601 .nlimit = ARRAY_SIZE(vout_limit_attrs),
1602 }
1603};
1604
1605
1606
1607static const struct pmbus_limit_attr iin_limit_attrs[] = {
1608 {
1609 .reg = PMBUS_IIN_OC_WARN_LIMIT,
1610 .attr = "max",
1611 .alarm = "max_alarm",
1612 .sbit = PB_IIN_OC_WARNING,
1613 }, {
1614 .reg = PMBUS_IIN_OC_FAULT_LIMIT,
1615 .attr = "crit",
1616 .alarm = "crit_alarm",
1617 .sbit = PB_IIN_OC_FAULT,
1618 }, {
1619 .reg = PMBUS_VIRT_READ_IIN_AVG,
1620 .update = true,
1621 .attr = "average",
1622 }, {
1623 .reg = PMBUS_VIRT_READ_IIN_MIN,
1624 .update = true,
1625 .attr = "lowest",
1626 }, {
1627 .reg = PMBUS_VIRT_READ_IIN_MAX,
1628 .update = true,
1629 .attr = "highest",
1630 }, {
1631 .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1632 .attr = "reset_history",
1633 }, {
1634 .reg = PMBUS_MFR_IIN_MAX,
1635 .attr = "rated_max",
1636 },
1637};
1638
1639static const struct pmbus_limit_attr iout_limit_attrs[] = {
1640 {
1641 .reg = PMBUS_IOUT_OC_WARN_LIMIT,
1642 .attr = "max",
1643 .alarm = "max_alarm",
1644 .sbit = PB_IOUT_OC_WARNING,
1645 }, {
1646 .reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1647 .attr = "lcrit",
1648 .alarm = "lcrit_alarm",
1649 .sbit = PB_IOUT_UC_FAULT,
1650 }, {
1651 .reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1652 .attr = "crit",
1653 .alarm = "crit_alarm",
1654 .sbit = PB_IOUT_OC_FAULT,
1655 }, {
1656 .reg = PMBUS_VIRT_READ_IOUT_AVG,
1657 .update = true,
1658 .attr = "average",
1659 }, {
1660 .reg = PMBUS_VIRT_READ_IOUT_MIN,
1661 .update = true,
1662 .attr = "lowest",
1663 }, {
1664 .reg = PMBUS_VIRT_READ_IOUT_MAX,
1665 .update = true,
1666 .attr = "highest",
1667 }, {
1668 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1669 .attr = "reset_history",
1670 }, {
1671 .reg = PMBUS_MFR_IOUT_MAX,
1672 .attr = "rated_max",
1673 },
1674};
1675
1676static const struct pmbus_sensor_attr current_attributes[] = {
1677 {
1678 .reg = PMBUS_READ_IIN,
1679 .class = PSC_CURRENT_IN,
1680 .label = "iin",
1681 .func = PMBUS_HAVE_IIN,
1682 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1683 .sreg = PMBUS_STATUS_INPUT,
1684 .gbit = PB_STATUS_INPUT,
1685 .limit = iin_limit_attrs,
1686 .nlimit = ARRAY_SIZE(iin_limit_attrs),
1687 }, {
1688 .reg = PMBUS_READ_IOUT,
1689 .class = PSC_CURRENT_OUT,
1690 .label = "iout",
1691 .paged = true,
1692 .func = PMBUS_HAVE_IOUT,
1693 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1694 .sreg = PMBUS_STATUS_IOUT,
1695 .gbit = PB_STATUS_IOUT_OC,
1696 .limit = iout_limit_attrs,
1697 .nlimit = ARRAY_SIZE(iout_limit_attrs),
1698 }
1699};
1700
1701
1702
1703static const struct pmbus_limit_attr pin_limit_attrs[] = {
1704 {
1705 .reg = PMBUS_PIN_OP_WARN_LIMIT,
1706 .attr = "max",
1707 .alarm = "alarm",
1708 .sbit = PB_PIN_OP_WARNING,
1709 }, {
1710 .reg = PMBUS_VIRT_READ_PIN_AVG,
1711 .update = true,
1712 .attr = "average",
1713 }, {
1714 .reg = PMBUS_VIRT_READ_PIN_MIN,
1715 .update = true,
1716 .attr = "input_lowest",
1717 }, {
1718 .reg = PMBUS_VIRT_READ_PIN_MAX,
1719 .update = true,
1720 .attr = "input_highest",
1721 }, {
1722 .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1723 .attr = "reset_history",
1724 }, {
1725 .reg = PMBUS_MFR_PIN_MAX,
1726 .attr = "rated_max",
1727 },
1728};
1729
1730static const struct pmbus_limit_attr pout_limit_attrs[] = {
1731 {
1732 .reg = PMBUS_POUT_MAX,
1733 .attr = "cap",
1734 .alarm = "cap_alarm",
1735 .sbit = PB_POWER_LIMITING,
1736 }, {
1737 .reg = PMBUS_POUT_OP_WARN_LIMIT,
1738 .attr = "max",
1739 .alarm = "max_alarm",
1740 .sbit = PB_POUT_OP_WARNING,
1741 }, {
1742 .reg = PMBUS_POUT_OP_FAULT_LIMIT,
1743 .attr = "crit",
1744 .alarm = "crit_alarm",
1745 .sbit = PB_POUT_OP_FAULT,
1746 }, {
1747 .reg = PMBUS_VIRT_READ_POUT_AVG,
1748 .update = true,
1749 .attr = "average",
1750 }, {
1751 .reg = PMBUS_VIRT_READ_POUT_MIN,
1752 .update = true,
1753 .attr = "input_lowest",
1754 }, {
1755 .reg = PMBUS_VIRT_READ_POUT_MAX,
1756 .update = true,
1757 .attr = "input_highest",
1758 }, {
1759 .reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1760 .attr = "reset_history",
1761 }, {
1762 .reg = PMBUS_MFR_POUT_MAX,
1763 .attr = "rated_max",
1764 },
1765};
1766
1767static const struct pmbus_sensor_attr power_attributes[] = {
1768 {
1769 .reg = PMBUS_READ_PIN,
1770 .class = PSC_POWER,
1771 .label = "pin",
1772 .func = PMBUS_HAVE_PIN,
1773 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1774 .sreg = PMBUS_STATUS_INPUT,
1775 .gbit = PB_STATUS_INPUT,
1776 .limit = pin_limit_attrs,
1777 .nlimit = ARRAY_SIZE(pin_limit_attrs),
1778 }, {
1779 .reg = PMBUS_READ_POUT,
1780 .class = PSC_POWER,
1781 .label = "pout",
1782 .paged = true,
1783 .func = PMBUS_HAVE_POUT,
1784 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1785 .sreg = PMBUS_STATUS_IOUT,
1786 .limit = pout_limit_attrs,
1787 .nlimit = ARRAY_SIZE(pout_limit_attrs),
1788 }
1789};
1790
1791
1792
1793static const struct pmbus_limit_attr temp_limit_attrs[] = {
1794 {
1795 .reg = PMBUS_UT_WARN_LIMIT,
1796 .low = true,
1797 .attr = "min",
1798 .alarm = "min_alarm",
1799 .sbit = PB_TEMP_UT_WARNING,
1800 }, {
1801 .reg = PMBUS_UT_FAULT_LIMIT,
1802 .low = true,
1803 .attr = "lcrit",
1804 .alarm = "lcrit_alarm",
1805 .sbit = PB_TEMP_UT_FAULT,
1806 }, {
1807 .reg = PMBUS_OT_WARN_LIMIT,
1808 .attr = "max",
1809 .alarm = "max_alarm",
1810 .sbit = PB_TEMP_OT_WARNING,
1811 }, {
1812 .reg = PMBUS_OT_FAULT_LIMIT,
1813 .attr = "crit",
1814 .alarm = "crit_alarm",
1815 .sbit = PB_TEMP_OT_FAULT,
1816 }, {
1817 .reg = PMBUS_VIRT_READ_TEMP_MIN,
1818 .attr = "lowest",
1819 }, {
1820 .reg = PMBUS_VIRT_READ_TEMP_AVG,
1821 .attr = "average",
1822 }, {
1823 .reg = PMBUS_VIRT_READ_TEMP_MAX,
1824 .attr = "highest",
1825 }, {
1826 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1827 .attr = "reset_history",
1828 }, {
1829 .reg = PMBUS_MFR_MAX_TEMP_1,
1830 .attr = "rated_max",
1831 },
1832};
1833
1834static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1835 {
1836 .reg = PMBUS_UT_WARN_LIMIT,
1837 .low = true,
1838 .attr = "min",
1839 .alarm = "min_alarm",
1840 .sbit = PB_TEMP_UT_WARNING,
1841 }, {
1842 .reg = PMBUS_UT_FAULT_LIMIT,
1843 .low = true,
1844 .attr = "lcrit",
1845 .alarm = "lcrit_alarm",
1846 .sbit = PB_TEMP_UT_FAULT,
1847 }, {
1848 .reg = PMBUS_OT_WARN_LIMIT,
1849 .attr = "max",
1850 .alarm = "max_alarm",
1851 .sbit = PB_TEMP_OT_WARNING,
1852 }, {
1853 .reg = PMBUS_OT_FAULT_LIMIT,
1854 .attr = "crit",
1855 .alarm = "crit_alarm",
1856 .sbit = PB_TEMP_OT_FAULT,
1857 }, {
1858 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
1859 .attr = "lowest",
1860 }, {
1861 .reg = PMBUS_VIRT_READ_TEMP2_AVG,
1862 .attr = "average",
1863 }, {
1864 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
1865 .attr = "highest",
1866 }, {
1867 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1868 .attr = "reset_history",
1869 }, {
1870 .reg = PMBUS_MFR_MAX_TEMP_2,
1871 .attr = "rated_max",
1872 },
1873};
1874
1875static const struct pmbus_limit_attr temp_limit_attrs3[] = {
1876 {
1877 .reg = PMBUS_UT_WARN_LIMIT,
1878 .low = true,
1879 .attr = "min",
1880 .alarm = "min_alarm",
1881 .sbit = PB_TEMP_UT_WARNING,
1882 }, {
1883 .reg = PMBUS_UT_FAULT_LIMIT,
1884 .low = true,
1885 .attr = "lcrit",
1886 .alarm = "lcrit_alarm",
1887 .sbit = PB_TEMP_UT_FAULT,
1888 }, {
1889 .reg = PMBUS_OT_WARN_LIMIT,
1890 .attr = "max",
1891 .alarm = "max_alarm",
1892 .sbit = PB_TEMP_OT_WARNING,
1893 }, {
1894 .reg = PMBUS_OT_FAULT_LIMIT,
1895 .attr = "crit",
1896 .alarm = "crit_alarm",
1897 .sbit = PB_TEMP_OT_FAULT,
1898 }, {
1899 .reg = PMBUS_MFR_MAX_TEMP_3,
1900 .attr = "rated_max",
1901 },
1902};
1903
1904static const struct pmbus_sensor_attr temp_attributes[] = {
1905 {
1906 .reg = PMBUS_READ_TEMPERATURE_1,
1907 .class = PSC_TEMPERATURE,
1908 .paged = true,
1909 .update = true,
1910 .compare = true,
1911 .func = PMBUS_HAVE_TEMP,
1912 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1913 .sreg = PMBUS_STATUS_TEMPERATURE,
1914 .gbit = PB_STATUS_TEMPERATURE,
1915 .limit = temp_limit_attrs,
1916 .nlimit = ARRAY_SIZE(temp_limit_attrs),
1917 }, {
1918 .reg = PMBUS_READ_TEMPERATURE_2,
1919 .class = PSC_TEMPERATURE,
1920 .paged = true,
1921 .update = true,
1922 .compare = true,
1923 .func = PMBUS_HAVE_TEMP2,
1924 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1925 .sreg = PMBUS_STATUS_TEMPERATURE,
1926 .gbit = PB_STATUS_TEMPERATURE,
1927 .limit = temp_limit_attrs2,
1928 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
1929 }, {
1930 .reg = PMBUS_READ_TEMPERATURE_3,
1931 .class = PSC_TEMPERATURE,
1932 .paged = true,
1933 .update = true,
1934 .compare = true,
1935 .func = PMBUS_HAVE_TEMP3,
1936 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1937 .sreg = PMBUS_STATUS_TEMPERATURE,
1938 .gbit = PB_STATUS_TEMPERATURE,
1939 .limit = temp_limit_attrs3,
1940 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
1941 }
1942};
1943
1944static const int pmbus_fan_registers[] = {
1945 PMBUS_READ_FAN_SPEED_1,
1946 PMBUS_READ_FAN_SPEED_2,
1947 PMBUS_READ_FAN_SPEED_3,
1948 PMBUS_READ_FAN_SPEED_4
1949};
1950
1951static const int pmbus_fan_status_registers[] = {
1952 PMBUS_STATUS_FAN_12,
1953 PMBUS_STATUS_FAN_12,
1954 PMBUS_STATUS_FAN_34,
1955 PMBUS_STATUS_FAN_34
1956};
1957
1958static const u32 pmbus_fan_flags[] = {
1959 PMBUS_HAVE_FAN12,
1960 PMBUS_HAVE_FAN12,
1961 PMBUS_HAVE_FAN34,
1962 PMBUS_HAVE_FAN34
1963};
1964
1965static const u32 pmbus_fan_status_flags[] = {
1966 PMBUS_HAVE_STATUS_FAN12,
1967 PMBUS_HAVE_STATUS_FAN12,
1968 PMBUS_HAVE_STATUS_FAN34,
1969 PMBUS_HAVE_STATUS_FAN34
1970};
1971
1972
1973
1974
1975static int pmbus_add_fan_ctrl(struct i2c_client *client,
1976 struct pmbus_data *data, int index, int page, int id,
1977 u8 config)
1978{
1979 struct pmbus_sensor *sensor;
1980
1981 sensor = pmbus_add_sensor(data, "fan", "target", index, page,
1982 0xff, PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN,
1983 false, false, true);
1984
1985 if (!sensor)
1986 return -ENOMEM;
1987
1988 if (!((data->info->func[page] & PMBUS_HAVE_PWM12) ||
1989 (data->info->func[page] & PMBUS_HAVE_PWM34)))
1990 return 0;
1991
1992 sensor = pmbus_add_sensor(data, "pwm", NULL, index, page,
1993 0xff, PMBUS_VIRT_PWM_1 + id, PSC_PWM,
1994 false, false, true);
1995
1996 if (!sensor)
1997 return -ENOMEM;
1998
1999 sensor = pmbus_add_sensor(data, "pwm", "enable", index, page,
2000 0xff, PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM,
2001 true, false, false);
2002
2003 if (!sensor)
2004 return -ENOMEM;
2005
2006 return 0;
2007}
2008
2009static int pmbus_add_fan_attributes(struct i2c_client *client,
2010 struct pmbus_data *data)
2011{
2012 const struct pmbus_driver_info *info = data->info;
2013 int index = 1;
2014 int page;
2015 int ret;
2016
2017 for (page = 0; page < info->pages; page++) {
2018 int f;
2019
2020 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
2021 int regval;
2022
2023 if (!(info->func[page] & pmbus_fan_flags[f]))
2024 break;
2025
2026 if (!pmbus_check_word_register(client, page,
2027 pmbus_fan_registers[f]))
2028 break;
2029
2030
2031
2032
2033
2034
2035 regval = _pmbus_read_byte_data(client, page,
2036 pmbus_fan_config_registers[f]);
2037 if (regval < 0 ||
2038 (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
2039 continue;
2040
2041 if (pmbus_add_sensor(data, "fan", "input", index,
2042 page, 0xff, pmbus_fan_registers[f],
2043 PSC_FAN, true, true, true) == NULL)
2044 return -ENOMEM;
2045
2046
2047 if (pmbus_check_word_register(client, page,
2048 pmbus_fan_command_registers[f])) {
2049 ret = pmbus_add_fan_ctrl(client, data, index,
2050 page, f, regval);
2051 if (ret < 0)
2052 return ret;
2053 }
2054
2055
2056
2057
2058
2059 if ((info->func[page] & pmbus_fan_status_flags[f]) &&
2060 pmbus_check_byte_register(client,
2061 page, pmbus_fan_status_registers[f])) {
2062 int reg;
2063
2064 if (f > 1)
2065 reg = PMBUS_STATUS_FAN_34;
2066 else
2067 reg = PMBUS_STATUS_FAN_12;
2068 ret = pmbus_add_boolean(data, "fan",
2069 "alarm", index, NULL, NULL, page, reg,
2070 PB_FAN_FAN1_WARNING >> (f & 1));
2071 if (ret)
2072 return ret;
2073 ret = pmbus_add_boolean(data, "fan",
2074 "fault", index, NULL, NULL, page, reg,
2075 PB_FAN_FAN1_FAULT >> (f & 1));
2076 if (ret)
2077 return ret;
2078 }
2079 index++;
2080 }
2081 }
2082 return 0;
2083}
2084
2085struct pmbus_samples_attr {
2086 int reg;
2087 char *name;
2088};
2089
2090struct pmbus_samples_reg {
2091 int page;
2092 struct pmbus_samples_attr *attr;
2093 struct device_attribute dev_attr;
2094};
2095
2096static struct pmbus_samples_attr pmbus_samples_registers[] = {
2097 {
2098 .reg = PMBUS_VIRT_SAMPLES,
2099 .name = "samples",
2100 }, {
2101 .reg = PMBUS_VIRT_IN_SAMPLES,
2102 .name = "in_samples",
2103 }, {
2104 .reg = PMBUS_VIRT_CURR_SAMPLES,
2105 .name = "curr_samples",
2106 }, {
2107 .reg = PMBUS_VIRT_POWER_SAMPLES,
2108 .name = "power_samples",
2109 }, {
2110 .reg = PMBUS_VIRT_TEMP_SAMPLES,
2111 .name = "temp_samples",
2112 }
2113};
2114
2115#define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr)
2116
2117static ssize_t pmbus_show_samples(struct device *dev,
2118 struct device_attribute *devattr, char *buf)
2119{
2120 int val;
2121 struct i2c_client *client = to_i2c_client(dev->parent);
2122 struct pmbus_samples_reg *reg = to_samples_reg(devattr);
2123 struct pmbus_data *data = i2c_get_clientdata(client);
2124
2125 mutex_lock(&data->update_lock);
2126 val = _pmbus_read_word_data(client, reg->page, 0xff, reg->attr->reg);
2127 mutex_unlock(&data->update_lock);
2128 if (val < 0)
2129 return val;
2130
2131 return sysfs_emit(buf, "%d\n", val);
2132}
2133
2134static ssize_t pmbus_set_samples(struct device *dev,
2135 struct device_attribute *devattr,
2136 const char *buf, size_t count)
2137{
2138 int ret;
2139 long val;
2140 struct i2c_client *client = to_i2c_client(dev->parent);
2141 struct pmbus_samples_reg *reg = to_samples_reg(devattr);
2142 struct pmbus_data *data = i2c_get_clientdata(client);
2143
2144 if (kstrtol(buf, 0, &val) < 0)
2145 return -EINVAL;
2146
2147 mutex_lock(&data->update_lock);
2148 ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val);
2149 mutex_unlock(&data->update_lock);
2150
2151 return ret ? : count;
2152}
2153
2154static int pmbus_add_samples_attr(struct pmbus_data *data, int page,
2155 struct pmbus_samples_attr *attr)
2156{
2157 struct pmbus_samples_reg *reg;
2158
2159 reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL);
2160 if (!reg)
2161 return -ENOMEM;
2162
2163 reg->attr = attr;
2164 reg->page = page;
2165
2166 pmbus_dev_attr_init(®->dev_attr, attr->name, 0644,
2167 pmbus_show_samples, pmbus_set_samples);
2168
2169 return pmbus_add_attribute(data, ®->dev_attr.attr);
2170}
2171
2172static int pmbus_add_samples_attributes(struct i2c_client *client,
2173 struct pmbus_data *data)
2174{
2175 const struct pmbus_driver_info *info = data->info;
2176 int s;
2177
2178 if (!(info->func[0] & PMBUS_HAVE_SAMPLES))
2179 return 0;
2180
2181 for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) {
2182 struct pmbus_samples_attr *attr;
2183 int ret;
2184
2185 attr = &pmbus_samples_registers[s];
2186 if (!pmbus_check_word_register(client, 0, attr->reg))
2187 continue;
2188
2189 ret = pmbus_add_samples_attr(data, 0, attr);
2190 if (ret)
2191 return ret;
2192 }
2193
2194 return 0;
2195}
2196
2197static int pmbus_find_attributes(struct i2c_client *client,
2198 struct pmbus_data *data)
2199{
2200 int ret;
2201
2202
2203 ret = pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
2204 ARRAY_SIZE(voltage_attributes));
2205 if (ret)
2206 return ret;
2207
2208
2209 ret = pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
2210 ARRAY_SIZE(current_attributes));
2211 if (ret)
2212 return ret;
2213
2214
2215 ret = pmbus_add_sensor_attrs(client, data, "power", power_attributes,
2216 ARRAY_SIZE(power_attributes));
2217 if (ret)
2218 return ret;
2219
2220
2221 ret = pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
2222 ARRAY_SIZE(temp_attributes));
2223 if (ret)
2224 return ret;
2225
2226
2227 ret = pmbus_add_fan_attributes(client, data);
2228 if (ret)
2229 return ret;
2230
2231 ret = pmbus_add_samples_attributes(client, data);
2232 return ret;
2233}
2234
2235
2236
2237
2238
2239struct pmbus_class_attr_map {
2240 enum pmbus_sensor_classes class;
2241 int nattr;
2242 const struct pmbus_sensor_attr *attr;
2243};
2244
2245static const struct pmbus_class_attr_map class_attr_map[] = {
2246 {
2247 .class = PSC_VOLTAGE_IN,
2248 .attr = voltage_attributes,
2249 .nattr = ARRAY_SIZE(voltage_attributes),
2250 }, {
2251 .class = PSC_VOLTAGE_OUT,
2252 .attr = voltage_attributes,
2253 .nattr = ARRAY_SIZE(voltage_attributes),
2254 }, {
2255 .class = PSC_CURRENT_IN,
2256 .attr = current_attributes,
2257 .nattr = ARRAY_SIZE(current_attributes),
2258 }, {
2259 .class = PSC_CURRENT_OUT,
2260 .attr = current_attributes,
2261 .nattr = ARRAY_SIZE(current_attributes),
2262 }, {
2263 .class = PSC_POWER,
2264 .attr = power_attributes,
2265 .nattr = ARRAY_SIZE(power_attributes),
2266 }, {
2267 .class = PSC_TEMPERATURE,
2268 .attr = temp_attributes,
2269 .nattr = ARRAY_SIZE(temp_attributes),
2270 }
2271};
2272
2273
2274
2275
2276static int pmbus_read_coefficients(struct i2c_client *client,
2277 struct pmbus_driver_info *info,
2278 const struct pmbus_sensor_attr *attr)
2279{
2280 int rv;
2281 union i2c_smbus_data data;
2282 enum pmbus_sensor_classes class = attr->class;
2283 s8 R;
2284 s16 m, b;
2285
2286 data.block[0] = 2;
2287 data.block[1] = attr->reg;
2288 data.block[2] = 0x01;
2289
2290 rv = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2291 I2C_SMBUS_WRITE, PMBUS_COEFFICIENTS,
2292 I2C_SMBUS_BLOCK_PROC_CALL, &data);
2293
2294 if (rv < 0)
2295 return rv;
2296
2297 if (data.block[0] != 5)
2298 return -EIO;
2299
2300 m = data.block[1] | (data.block[2] << 8);
2301 b = data.block[3] | (data.block[4] << 8);
2302 R = data.block[5];
2303 info->m[class] = m;
2304 info->b[class] = b;
2305 info->R[class] = R;
2306
2307 return rv;
2308}
2309
2310static int pmbus_init_coefficients(struct i2c_client *client,
2311 struct pmbus_driver_info *info)
2312{
2313 int i, n, ret = -EINVAL;
2314 const struct pmbus_class_attr_map *map;
2315 const struct pmbus_sensor_attr *attr;
2316
2317 for (i = 0; i < ARRAY_SIZE(class_attr_map); i++) {
2318 map = &class_attr_map[i];
2319 if (info->format[map->class] != direct)
2320 continue;
2321 for (n = 0; n < map->nattr; n++) {
2322 attr = &map->attr[n];
2323 if (map->class != attr->class)
2324 continue;
2325 ret = pmbus_read_coefficients(client, info, attr);
2326 if (ret >= 0)
2327 break;
2328 }
2329 if (ret < 0) {
2330 dev_err(&client->dev,
2331 "No coefficients found for sensor class %d\n",
2332 map->class);
2333 return -EINVAL;
2334 }
2335 }
2336
2337 return 0;
2338}
2339
2340
2341
2342
2343
2344static int pmbus_identify_common(struct i2c_client *client,
2345 struct pmbus_data *data, int page)
2346{
2347 int vout_mode = -1;
2348
2349 if (pmbus_check_byte_register(client, page, PMBUS_VOUT_MODE))
2350 vout_mode = _pmbus_read_byte_data(client, page,
2351 PMBUS_VOUT_MODE);
2352 if (vout_mode >= 0 && vout_mode != 0xff) {
2353
2354
2355
2356
2357 switch (vout_mode >> 5) {
2358 case 0:
2359 if (data->info->format[PSC_VOLTAGE_OUT] != linear)
2360 return -ENODEV;
2361
2362 data->exponent[page] = ((s8)(vout_mode << 3)) >> 3;
2363 break;
2364 case 1:
2365 if (data->info->format[PSC_VOLTAGE_OUT] != vid)
2366 return -ENODEV;
2367 break;
2368 case 2:
2369 if (data->info->format[PSC_VOLTAGE_OUT] != direct)
2370 return -ENODEV;
2371 break;
2372 default:
2373 return -ENODEV;
2374 }
2375 }
2376
2377 pmbus_clear_fault_page(client, page);
2378 return 0;
2379}
2380
2381static int pmbus_read_status_byte(struct i2c_client *client, int page)
2382{
2383 return _pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
2384}
2385
2386static int pmbus_read_status_word(struct i2c_client *client, int page)
2387{
2388 return _pmbus_read_word_data(client, page, 0xff, PMBUS_STATUS_WORD);
2389}
2390
2391static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
2392 struct pmbus_driver_info *info)
2393{
2394 struct device *dev = &client->dev;
2395 int page, ret;
2396
2397
2398
2399
2400
2401 client->flags &= ~I2C_CLIENT_PEC;
2402
2403
2404 if (!(data->flags & PMBUS_NO_CAPABILITY)) {
2405 ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
2406 if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK)) {
2407 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_PEC))
2408 client->flags |= I2C_CLIENT_PEC;
2409 }
2410 }
2411
2412
2413
2414
2415
2416
2417 data->read_status = pmbus_read_status_word;
2418 ret = i2c_smbus_read_word_data(client, PMBUS_STATUS_WORD);
2419 if (ret < 0 || ret == 0xffff) {
2420 data->read_status = pmbus_read_status_byte;
2421 ret = i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE);
2422 if (ret < 0 || ret == 0xff) {
2423 dev_err(dev, "PMBus status register not found\n");
2424 return -ENODEV;
2425 }
2426 } else {
2427 data->has_status_word = true;
2428 }
2429
2430
2431
2432
2433
2434
2435 if (!(data->flags & PMBUS_NO_WRITE_PROTECT)) {
2436 ret = i2c_smbus_read_byte_data(client, PMBUS_WRITE_PROTECT);
2437 if (ret > 0 && (ret & PB_WP_ANY))
2438 data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK;
2439 }
2440
2441 if (data->info->pages)
2442 pmbus_clear_faults(client);
2443 else
2444 pmbus_clear_fault_page(client, -1);
2445
2446 if (info->identify) {
2447 ret = (*info->identify)(client, info);
2448 if (ret < 0) {
2449 dev_err(dev, "Chip identification failed\n");
2450 return ret;
2451 }
2452 }
2453
2454 if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
2455 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages);
2456 return -ENODEV;
2457 }
2458
2459 for (page = 0; page < info->pages; page++) {
2460 ret = pmbus_identify_common(client, data, page);
2461 if (ret < 0) {
2462 dev_err(dev, "Failed to identify chip capabilities\n");
2463 return ret;
2464 }
2465 }
2466
2467 if (data->flags & PMBUS_USE_COEFFICIENTS_CMD) {
2468 if (!i2c_check_functionality(client->adapter,
2469 I2C_FUNC_SMBUS_BLOCK_PROC_CALL))
2470 return -ENODEV;
2471
2472 ret = pmbus_init_coefficients(client, info);
2473 if (ret < 0)
2474 return ret;
2475 }
2476
2477 return 0;
2478}
2479
2480#if IS_ENABLED(CONFIG_REGULATOR)
2481static int pmbus_regulator_is_enabled(struct regulator_dev *rdev)
2482{
2483 struct device *dev = rdev_get_dev(rdev);
2484 struct i2c_client *client = to_i2c_client(dev->parent);
2485 struct pmbus_data *data = i2c_get_clientdata(client);
2486 u8 page = rdev_get_id(rdev);
2487 int ret;
2488
2489 mutex_lock(&data->update_lock);
2490 ret = _pmbus_read_byte_data(client, page, PMBUS_OPERATION);
2491 mutex_unlock(&data->update_lock);
2492
2493 if (ret < 0)
2494 return ret;
2495
2496 return !!(ret & PB_OPERATION_CONTROL_ON);
2497}
2498
2499static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable)
2500{
2501 struct device *dev = rdev_get_dev(rdev);
2502 struct i2c_client *client = to_i2c_client(dev->parent);
2503 struct pmbus_data *data = i2c_get_clientdata(client);
2504 u8 page = rdev_get_id(rdev);
2505 int ret;
2506
2507 mutex_lock(&data->update_lock);
2508 ret = pmbus_update_byte_data(client, page, PMBUS_OPERATION,
2509 PB_OPERATION_CONTROL_ON,
2510 enable ? PB_OPERATION_CONTROL_ON : 0);
2511 mutex_unlock(&data->update_lock);
2512
2513 return ret;
2514}
2515
2516static int pmbus_regulator_enable(struct regulator_dev *rdev)
2517{
2518 return _pmbus_regulator_on_off(rdev, 1);
2519}
2520
2521static int pmbus_regulator_disable(struct regulator_dev *rdev)
2522{
2523 return _pmbus_regulator_on_off(rdev, 0);
2524}
2525
2526
2527struct pmbus_regulator_status_assoc {
2528 int pflag, rflag;
2529};
2530
2531
2532struct pmbus_regulator_status_category {
2533 int func;
2534 int reg;
2535 const struct pmbus_regulator_status_assoc *bits;
2536};
2537
2538static const struct pmbus_regulator_status_category pmbus_regulator_flag_map[] = {
2539 {
2540 .func = PMBUS_HAVE_STATUS_VOUT,
2541 .reg = PMBUS_STATUS_VOUT,
2542 .bits = (const struct pmbus_regulator_status_assoc[]) {
2543 { PB_VOLTAGE_UV_WARNING, REGULATOR_ERROR_UNDER_VOLTAGE_WARN },
2544 { PB_VOLTAGE_UV_FAULT, REGULATOR_ERROR_UNDER_VOLTAGE },
2545 { PB_VOLTAGE_OV_WARNING, REGULATOR_ERROR_OVER_VOLTAGE_WARN },
2546 { PB_VOLTAGE_OV_FAULT, REGULATOR_ERROR_REGULATION_OUT },
2547 { },
2548 },
2549 }, {
2550 .func = PMBUS_HAVE_STATUS_IOUT,
2551 .reg = PMBUS_STATUS_IOUT,
2552 .bits = (const struct pmbus_regulator_status_assoc[]) {
2553 { PB_IOUT_OC_WARNING, REGULATOR_ERROR_OVER_CURRENT_WARN },
2554 { PB_IOUT_OC_FAULT, REGULATOR_ERROR_OVER_CURRENT },
2555 { PB_IOUT_OC_LV_FAULT, REGULATOR_ERROR_OVER_CURRENT },
2556 { },
2557 },
2558 }, {
2559 .func = PMBUS_HAVE_STATUS_TEMP,
2560 .reg = PMBUS_STATUS_TEMPERATURE,
2561 .bits = (const struct pmbus_regulator_status_assoc[]) {
2562 { PB_TEMP_OT_WARNING, REGULATOR_ERROR_OVER_TEMP_WARN },
2563 { PB_TEMP_OT_FAULT, REGULATOR_ERROR_OVER_TEMP },
2564 { },
2565 },
2566 },
2567};
2568
2569static int pmbus_regulator_get_error_flags(struct regulator_dev *rdev, unsigned int *flags)
2570{
2571 int i, status;
2572 const struct pmbus_regulator_status_category *cat;
2573 const struct pmbus_regulator_status_assoc *bit;
2574 struct device *dev = rdev_get_dev(rdev);
2575 struct i2c_client *client = to_i2c_client(dev->parent);
2576 struct pmbus_data *data = i2c_get_clientdata(client);
2577 u8 page = rdev_get_id(rdev);
2578 int func = data->info->func[page];
2579
2580 *flags = 0;
2581
2582 mutex_lock(&data->update_lock);
2583
2584 for (i = 0; i < ARRAY_SIZE(pmbus_regulator_flag_map); i++) {
2585 cat = &pmbus_regulator_flag_map[i];
2586 if (!(func & cat->func))
2587 continue;
2588
2589 status = _pmbus_read_byte_data(client, page, cat->reg);
2590 if (status < 0) {
2591 mutex_unlock(&data->update_lock);
2592 return status;
2593 }
2594
2595 for (bit = cat->bits; bit->pflag; bit++) {
2596 if (status & bit->pflag)
2597 *flags |= bit->rflag;
2598 }
2599 }
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610 status = pmbus_get_status(client, page, PMBUS_STATUS_WORD);
2611 mutex_unlock(&data->update_lock);
2612 if (status < 0)
2613 return status;
2614
2615 if (pmbus_regulator_is_enabled(rdev) && (status & PB_STATUS_OFF))
2616 *flags |= REGULATOR_ERROR_FAIL;
2617
2618
2619
2620
2621
2622 if (status & PB_STATUS_IOUT_OC)
2623 *flags |= REGULATOR_ERROR_OVER_CURRENT;
2624 if (status & PB_STATUS_VOUT_OV)
2625 *flags |= REGULATOR_ERROR_REGULATION_OUT;
2626
2627
2628
2629
2630
2631
2632 if (!(*flags & (REGULATOR_ERROR_OVER_TEMP | REGULATOR_ERROR_OVER_TEMP_WARN)) &&
2633 (status & PB_STATUS_TEMPERATURE))
2634 *flags |= REGULATOR_ERROR_OVER_TEMP_WARN;
2635
2636 return 0;
2637}
2638
2639static int pmbus_regulator_get_voltage(struct regulator_dev *rdev)
2640{
2641 struct device *dev = rdev_get_dev(rdev);
2642 struct i2c_client *client = to_i2c_client(dev->parent);
2643 struct pmbus_data *data = i2c_get_clientdata(client);
2644 struct pmbus_sensor s = {
2645 .page = rdev_get_id(rdev),
2646 .class = PSC_VOLTAGE_OUT,
2647 .convert = true,
2648 };
2649
2650 s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_READ_VOUT);
2651 if (s.data < 0)
2652 return s.data;
2653
2654 return (int)pmbus_reg2data(data, &s) * 1000;
2655}
2656
2657static int pmbus_regulator_set_voltage(struct regulator_dev *rdev, int min_uv,
2658 int max_uv, unsigned int *selector)
2659{
2660 struct device *dev = rdev_get_dev(rdev);
2661 struct i2c_client *client = to_i2c_client(dev->parent);
2662 struct pmbus_data *data = i2c_get_clientdata(client);
2663 struct pmbus_sensor s = {
2664 .page = rdev_get_id(rdev),
2665 .class = PSC_VOLTAGE_OUT,
2666 .convert = true,
2667 .data = -1,
2668 };
2669 int val = DIV_ROUND_CLOSEST(min_uv, 1000);
2670 int low, high;
2671
2672 *selector = 0;
2673
2674 if (pmbus_check_word_register(client, s.page, PMBUS_MFR_VOUT_MIN))
2675 s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_MFR_VOUT_MIN);
2676 if (s.data < 0) {
2677 s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_VOUT_MARGIN_LOW);
2678 if (s.data < 0)
2679 return s.data;
2680 }
2681 low = pmbus_reg2data(data, &s);
2682
2683 s.data = -1;
2684 if (pmbus_check_word_register(client, s.page, PMBUS_MFR_VOUT_MAX))
2685 s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_MFR_VOUT_MAX);
2686 if (s.data < 0) {
2687 s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_VOUT_MARGIN_HIGH);
2688 if (s.data < 0)
2689 return s.data;
2690 }
2691 high = pmbus_reg2data(data, &s);
2692
2693
2694 if (low > val)
2695 val = low;
2696 if (high < val)
2697 val = high;
2698
2699 val = pmbus_data2reg(data, &s, val);
2700
2701 return _pmbus_write_word_data(client, s.page, PMBUS_VOUT_COMMAND, (u16)val);
2702}
2703
2704const struct regulator_ops pmbus_regulator_ops = {
2705 .enable = pmbus_regulator_enable,
2706 .disable = pmbus_regulator_disable,
2707 .is_enabled = pmbus_regulator_is_enabled,
2708 .get_error_flags = pmbus_regulator_get_error_flags,
2709 .get_voltage = pmbus_regulator_get_voltage,
2710 .set_voltage = pmbus_regulator_set_voltage,
2711};
2712EXPORT_SYMBOL_NS_GPL(pmbus_regulator_ops, PMBUS);
2713
2714static int pmbus_regulator_register(struct pmbus_data *data)
2715{
2716 struct device *dev = data->dev;
2717 const struct pmbus_driver_info *info = data->info;
2718 const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
2719 struct regulator_dev *rdev;
2720 int i;
2721
2722 for (i = 0; i < info->num_regulators; i++) {
2723 struct regulator_config config = { };
2724
2725 config.dev = dev;
2726 config.driver_data = data;
2727
2728 if (pdata && pdata->reg_init_data)
2729 config.init_data = &pdata->reg_init_data[i];
2730
2731 rdev = devm_regulator_register(dev, &info->reg_desc[i],
2732 &config);
2733 if (IS_ERR(rdev)) {
2734 dev_err(dev, "Failed to register %s regulator\n",
2735 info->reg_desc[i].name);
2736 return PTR_ERR(rdev);
2737 }
2738 }
2739
2740 return 0;
2741}
2742#else
2743static int pmbus_regulator_register(struct pmbus_data *data)
2744{
2745 return 0;
2746}
2747#endif
2748
2749static struct dentry *pmbus_debugfs_dir;
2750
2751#if IS_ENABLED(CONFIG_DEBUG_FS)
2752static int pmbus_debugfs_get(void *data, u64 *val)
2753{
2754 int rc;
2755 struct pmbus_debugfs_entry *entry = data;
2756
2757 rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg);
2758 if (rc < 0)
2759 return rc;
2760
2761 *val = rc;
2762
2763 return 0;
2764}
2765DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops, pmbus_debugfs_get, NULL,
2766 "0x%02llx\n");
2767
2768static int pmbus_debugfs_get_status(void *data, u64 *val)
2769{
2770 int rc;
2771 struct pmbus_debugfs_entry *entry = data;
2772 struct pmbus_data *pdata = i2c_get_clientdata(entry->client);
2773
2774 rc = pdata->read_status(entry->client, entry->page);
2775 if (rc < 0)
2776 return rc;
2777
2778 *val = rc;
2779
2780 return 0;
2781}
2782DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status,
2783 NULL, "0x%04llx\n");
2784
2785static int pmbus_debugfs_get_pec(void *data, u64 *val)
2786{
2787 struct i2c_client *client = data;
2788
2789 *val = !!(client->flags & I2C_CLIENT_PEC);
2790
2791 return 0;
2792}
2793
2794static int pmbus_debugfs_set_pec(void *data, u64 val)
2795{
2796 int rc;
2797 struct i2c_client *client = data;
2798
2799 if (!val) {
2800 client->flags &= ~I2C_CLIENT_PEC;
2801 return 0;
2802 }
2803
2804 if (val != 1)
2805 return -EINVAL;
2806
2807 rc = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
2808 if (rc < 0)
2809 return rc;
2810
2811 if (!(rc & PB_CAPABILITY_ERROR_CHECK))
2812 return -EOPNOTSUPP;
2813
2814 client->flags |= I2C_CLIENT_PEC;
2815
2816 return 0;
2817}
2818DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_pec, pmbus_debugfs_get_pec,
2819 pmbus_debugfs_set_pec, "%llu\n");
2820
2821static void pmbus_remove_debugfs(void *data)
2822{
2823 struct dentry *entry = data;
2824
2825 debugfs_remove_recursive(entry);
2826}
2827
2828static int pmbus_init_debugfs(struct i2c_client *client,
2829 struct pmbus_data *data)
2830{
2831 int i, idx = 0;
2832 char name[PMBUS_NAME_SIZE];
2833 struct pmbus_debugfs_entry *entries;
2834
2835 if (!pmbus_debugfs_dir)
2836 return -ENODEV;
2837
2838
2839
2840
2841
2842 data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev),
2843 pmbus_debugfs_dir);
2844 if (IS_ERR_OR_NULL(data->debugfs)) {
2845 data->debugfs = NULL;
2846 return -ENODEV;
2847 }
2848
2849
2850 entries = devm_kcalloc(data->dev,
2851 data->info->pages * 10, sizeof(*entries),
2852 GFP_KERNEL);
2853 if (!entries)
2854 return -ENOMEM;
2855
2856 debugfs_create_file("pec", 0664, data->debugfs, client,
2857 &pmbus_debugfs_ops_pec);
2858
2859 for (i = 0; i < data->info->pages; ++i) {
2860
2861 if (!i || pmbus_check_status_register(client, i)) {
2862
2863 entries[idx].client = client;
2864 entries[idx].page = i;
2865 scnprintf(name, PMBUS_NAME_SIZE, "status%d", i);
2866 debugfs_create_file(name, 0444, data->debugfs,
2867 &entries[idx++],
2868 &pmbus_debugfs_ops_status);
2869 }
2870
2871 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) {
2872 entries[idx].client = client;
2873 entries[idx].page = i;
2874 entries[idx].reg = PMBUS_STATUS_VOUT;
2875 scnprintf(name, PMBUS_NAME_SIZE, "status%d_vout", i);
2876 debugfs_create_file(name, 0444, data->debugfs,
2877 &entries[idx++],
2878 &pmbus_debugfs_ops);
2879 }
2880
2881 if (data->info->func[i] & PMBUS_HAVE_STATUS_IOUT) {
2882 entries[idx].client = client;
2883 entries[idx].page = i;
2884 entries[idx].reg = PMBUS_STATUS_IOUT;
2885 scnprintf(name, PMBUS_NAME_SIZE, "status%d_iout", i);
2886 debugfs_create_file(name, 0444, data->debugfs,
2887 &entries[idx++],
2888 &pmbus_debugfs_ops);
2889 }
2890
2891 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) {
2892 entries[idx].client = client;
2893 entries[idx].page = i;
2894 entries[idx].reg = PMBUS_STATUS_INPUT;
2895 scnprintf(name, PMBUS_NAME_SIZE, "status%d_input", i);
2896 debugfs_create_file(name, 0444, data->debugfs,
2897 &entries[idx++],
2898 &pmbus_debugfs_ops);
2899 }
2900
2901 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) {
2902 entries[idx].client = client;
2903 entries[idx].page = i;
2904 entries[idx].reg = PMBUS_STATUS_TEMPERATURE;
2905 scnprintf(name, PMBUS_NAME_SIZE, "status%d_temp", i);
2906 debugfs_create_file(name, 0444, data->debugfs,
2907 &entries[idx++],
2908 &pmbus_debugfs_ops);
2909 }
2910
2911 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_CML)) {
2912 entries[idx].client = client;
2913 entries[idx].page = i;
2914 entries[idx].reg = PMBUS_STATUS_CML;
2915 scnprintf(name, PMBUS_NAME_SIZE, "status%d_cml", i);
2916 debugfs_create_file(name, 0444, data->debugfs,
2917 &entries[idx++],
2918 &pmbus_debugfs_ops);
2919 }
2920
2921 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_OTHER)) {
2922 entries[idx].client = client;
2923 entries[idx].page = i;
2924 entries[idx].reg = PMBUS_STATUS_OTHER;
2925 scnprintf(name, PMBUS_NAME_SIZE, "status%d_other", i);
2926 debugfs_create_file(name, 0444, data->debugfs,
2927 &entries[idx++],
2928 &pmbus_debugfs_ops);
2929 }
2930
2931 if (pmbus_check_byte_register(client, i,
2932 PMBUS_STATUS_MFR_SPECIFIC)) {
2933 entries[idx].client = client;
2934 entries[idx].page = i;
2935 entries[idx].reg = PMBUS_STATUS_MFR_SPECIFIC;
2936 scnprintf(name, PMBUS_NAME_SIZE, "status%d_mfr", i);
2937 debugfs_create_file(name, 0444, data->debugfs,
2938 &entries[idx++],
2939 &pmbus_debugfs_ops);
2940 }
2941
2942 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) {
2943 entries[idx].client = client;
2944 entries[idx].page = i;
2945 entries[idx].reg = PMBUS_STATUS_FAN_12;
2946 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan12", i);
2947 debugfs_create_file(name, 0444, data->debugfs,
2948 &entries[idx++],
2949 &pmbus_debugfs_ops);
2950 }
2951
2952 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) {
2953 entries[idx].client = client;
2954 entries[idx].page = i;
2955 entries[idx].reg = PMBUS_STATUS_FAN_34;
2956 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan34", i);
2957 debugfs_create_file(name, 0444, data->debugfs,
2958 &entries[idx++],
2959 &pmbus_debugfs_ops);
2960 }
2961 }
2962
2963 return devm_add_action_or_reset(data->dev,
2964 pmbus_remove_debugfs, data->debugfs);
2965}
2966#else
2967static int pmbus_init_debugfs(struct i2c_client *client,
2968 struct pmbus_data *data)
2969{
2970 return 0;
2971}
2972#endif
2973
2974int pmbus_do_probe(struct i2c_client *client, struct pmbus_driver_info *info)
2975{
2976 struct device *dev = &client->dev;
2977 const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
2978 struct pmbus_data *data;
2979 size_t groups_num = 0;
2980 int ret;
2981 char *name;
2982
2983 if (!info)
2984 return -ENODEV;
2985
2986 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
2987 | I2C_FUNC_SMBUS_BYTE_DATA
2988 | I2C_FUNC_SMBUS_WORD_DATA))
2989 return -ENODEV;
2990
2991 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
2992 if (!data)
2993 return -ENOMEM;
2994
2995 if (info->groups)
2996 while (info->groups[groups_num])
2997 groups_num++;
2998
2999 data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *),
3000 GFP_KERNEL);
3001 if (!data->groups)
3002 return -ENOMEM;
3003
3004 i2c_set_clientdata(client, data);
3005 mutex_init(&data->update_lock);
3006 data->dev = dev;
3007
3008 if (pdata)
3009 data->flags = pdata->flags;
3010 data->info = info;
3011 data->currpage = -1;
3012 data->currphase = -1;
3013
3014 ret = pmbus_init_common(client, data, info);
3015 if (ret < 0)
3016 return ret;
3017
3018 ret = pmbus_find_attributes(client, data);
3019 if (ret)
3020 return ret;
3021
3022
3023
3024
3025
3026 if (!data->num_attributes) {
3027 dev_err(dev, "No attributes found\n");
3028 return -ENODEV;
3029 }
3030
3031 name = devm_kstrdup(dev, client->name, GFP_KERNEL);
3032 if (!name)
3033 return -ENOMEM;
3034 strreplace(name, '-', '_');
3035
3036 data->groups[0] = &data->group;
3037 memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num);
3038 data->hwmon_dev = devm_hwmon_device_register_with_groups(dev,
3039 name, data, data->groups);
3040 if (IS_ERR(data->hwmon_dev)) {
3041 dev_err(dev, "Failed to register hwmon device\n");
3042 return PTR_ERR(data->hwmon_dev);
3043 }
3044
3045 ret = pmbus_regulator_register(data);
3046 if (ret)
3047 return ret;
3048
3049 ret = pmbus_init_debugfs(client, data);
3050 if (ret)
3051 dev_warn(dev, "Failed to register debugfs\n");
3052
3053 return 0;
3054}
3055EXPORT_SYMBOL_NS_GPL(pmbus_do_probe, PMBUS);
3056
3057struct dentry *pmbus_get_debugfs_dir(struct i2c_client *client)
3058{
3059 struct pmbus_data *data = i2c_get_clientdata(client);
3060
3061 return data->debugfs;
3062}
3063EXPORT_SYMBOL_NS_GPL(pmbus_get_debugfs_dir, PMBUS);
3064
3065static int __init pmbus_core_init(void)
3066{
3067 pmbus_debugfs_dir = debugfs_create_dir("pmbus", NULL);
3068 if (IS_ERR(pmbus_debugfs_dir))
3069 pmbus_debugfs_dir = NULL;
3070
3071 return 0;
3072}
3073
3074static void __exit pmbus_core_exit(void)
3075{
3076 debugfs_remove_recursive(pmbus_debugfs_dir);
3077}
3078
3079module_init(pmbus_core_init);
3080module_exit(pmbus_core_exit);
3081
3082MODULE_AUTHOR("Guenter Roeck");
3083MODULE_DESCRIPTION("PMBus core driver");
3084MODULE_LICENSE("GPL");
3085