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