?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / hwmon / pmbus / pmbus_core.c
blobd9c17feb7b4ac4f8367f0507cf6693ba18efbc96
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Hardware monitoring driver for PMBus devices
4 *
5 * Copyright (c) 2010, 2011 Ericsson AB.
6 * Copyright (c) 2012 Guenter Roeck
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 * Number of additional attribute pointers to allocate
27 * with each call to krealloc
28 */
29 #define PMBUS_ATTR_ALLOC_SIZE 32
30
31 /*
32 * Index into status register array, per status register group
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]; /* sysfs sensor name */
50 struct device_attribute attribute;
51 u8 page; /* page number */
52 u16 reg; /* register */
53 enum pmbus_sensor_classes class; /* sensor class */
54 bool update; /* runtime sensor update needed */
55 bool convert; /* Whether or not to apply linear/vid/direct */
56 int data; /* Sensor data.
57 Negative if there was a read error */
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]; /* sysfs boolean name */
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]; /* sysfs label name */
73 struct device_attribute attribute;
74 char label[PMBUS_NAME_SIZE]; /* label */
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; /* from platform data */
84
85 int exponent[PMBUS_PAGES];
86 /* linear mode: exponent for output voltages */
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; /* debugfs device directory */
95
96 struct pmbus_sensor *sensors;
97
98 struct mutex update_lock;
99 bool valid;
100 unsigned long last_updated; /* in jiffies */
101
102 /*
103 * A single status register covers multiple attributes,
104 * so we keep them all together.
105 */
106 u16 status[PB_NUM_STATUS_REG];
107
108 bool has_status_word; /* device uses STATUS_WORD register */
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 * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
190 * a device specific mapping function exists and calls it if necessary.
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 * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
243 * a device specific mapping function exists and calls it if necessary.
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 * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
321 * a device specific mapping function exists and calls it if necessary.
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 * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
386 * a device specific mapping function exists and calls it if necessary.
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 /* Can't sensibly map between RPM and PWM, just return zero */
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 * Convert linear sensor values to milli- or micro-units
610 * depending on sensor type.
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) { /* LINEAR16 */
620 exponent = data->exponent[sensor->page];
621 mantissa = (u16) sensor->data;
622 } else { /* LINEAR11 */
623 exponent = ((s16)sensor->data) >> 11;
624 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
625 }
626
627 val = mantissa;
628
629 /* scale result to milli-units for all sensors except fans */
630 if (sensor->class != PSC_FAN)
631 val = val * 1000L;
632
633 /* scale result to micro-units for power sensors */
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 * Convert direct sensor values to milli- or micro-units
647 * depending on sensor type.
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 /* X = 1/m * (Y * 10^-R - b) */
663 R = -R;
664 /* scale result to milli-units for everything but fans */
665 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
666 R += 3;
667 b *= 1000;
668 }
669
670 /* scale result to micro-units for power sensors */
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); /* round closest */
682 R++;
683 }
684
685 val = div_s64(val - b, m);
686 return clamp_val(val, LONG_MIN, LONG_MAX);
687 }
688
689 /*
690 * Convert VID sensor values to milli- or micro-units
691 * depending on sensor type.
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[sensor->page]) {
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 case imvp9:
713 if (val >= 0x01)
714 rv = 200 + (val - 1) * 10;
715 break;
716 case amd625mv:
717 if (val >= 0x0 && val <= 0xd8)
718 rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100);
719 break;
720 }
721 return rv;
722 }
723
724 static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
725 {
726 long val;
727
728 if (!sensor->convert)
729 return sensor->data;
730
731 switch (data->info->format[sensor->class]) {
732 case direct:
733 val = pmbus_reg2data_direct(data, sensor);
734 break;
735 case vid:
736 val = pmbus_reg2data_vid(data, sensor);
737 break;
738 case linear:
739 default:
740 val = pmbus_reg2data_linear(data, sensor);
741 break;
742 }
743 return val;
744 }
745
746 #define MAX_MANTISSA (1023 * 1000)
747 #define MIN_MANTISSA (511 * 1000)
748
749 static u16 pmbus_data2reg_linear(struct pmbus_data *data,
750 struct pmbus_sensor *sensor, long val)
751 {
752 s16 exponent = 0, mantissa;
753 bool negative = false;
754
755 /* simple case */
756 if (val == 0)
757 return 0;
758
759 if (sensor->class == PSC_VOLTAGE_OUT) {
760 /* LINEAR16 does not support negative voltages */
761 if (val < 0)
762 return 0;
763
764 /*
765 * For a static exponents, we don't have a choice
766 * but to adjust the value to it.
767 */
768 if (data->exponent[sensor->page] < 0)
769 val <<= -data->exponent[sensor->page];
770 else
771 val >>= data->exponent[sensor->page];
772 val = DIV_ROUND_CLOSEST(val, 1000);
773 return val & 0xffff;
774 }
775
776 if (val < 0) {
777 negative = true;
778 val = -val;
779 }
780
781 /* Power is in uW. Convert to mW before converting. */
782 if (sensor->class == PSC_POWER)
783 val = DIV_ROUND_CLOSEST(val, 1000L);
784
785 /*
786 * For simplicity, convert fan data to milli-units
787 * before calculating the exponent.
788 */
789 if (sensor->class == PSC_FAN)
790 val = val * 1000;
791
792 /* Reduce large mantissa until it fits into 10 bit */
793 while (val >= MAX_MANTISSA && exponent < 15) {
794 exponent++;
795 val >>= 1;
796 }
797 /* Increase small mantissa to improve precision */
798 while (val < MIN_MANTISSA && exponent > -15) {
799 exponent--;
800 val <<= 1;
801 }
802
803 /* Convert mantissa from milli-units to units */
804 mantissa = DIV_ROUND_CLOSEST(val, 1000);
805
806 /* Ensure that resulting number is within range */
807 if (mantissa > 0x3ff)
808 mantissa = 0x3ff;
809
810 /* restore sign */
811 if (negative)
812 mantissa = -mantissa;
813
814 /* Convert to 5 bit exponent, 11 bit mantissa */
815 return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
816 }
817
818 static u16 pmbus_data2reg_direct(struct pmbus_data *data,
819 struct pmbus_sensor *sensor, long val)
820 {
821 s64 b, val64 = val;
822 s32 m, R;
823
824 m = data->info->m[sensor->class];
825 b = data->info->b[sensor->class];
826 R = data->info->R[sensor->class];
827
828 /* Power is in uW. Adjust R and b. */
829 if (sensor->class == PSC_POWER) {
830 R -= 3;
831 b *= 1000;
832 }
833
834 /* Calculate Y = (m * X + b) * 10^R */
835 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
836 R -= 3; /* Adjust R and b for data in milli-units */
837 b *= 1000;
838 }
839 val64 = val64 * m + b;
840
841 while (R > 0) {
842 val64 *= 10;
843 R--;
844 }
845 while (R < 0) {
846 val64 = div_s64(val64 + 5LL, 10L); /* round closest */
847 R++;
848 }
849
850 return (u16)clamp_val(val64, S16_MIN, S16_MAX);
851 }
852
853 static u16 pmbus_data2reg_vid(struct pmbus_data *data,
854 struct pmbus_sensor *sensor, long val)
855 {
856 val = clamp_val(val, 500, 1600);
857
858 return 2 + DIV_ROUND_CLOSEST((1600 - val) * 100, 625);
859 }
860
861 static u16 pmbus_data2reg(struct pmbus_data *data,
862 struct pmbus_sensor *sensor, long val)
863 {
864 u16 regval;
865
866 if (!sensor->convert)
867 return val;
868
869 switch (data->info->format[sensor->class]) {
870 case direct:
871 regval = pmbus_data2reg_direct(data, sensor, val);
872 break;
873 case vid:
874 regval = pmbus_data2reg_vid(data, sensor, val);
875 break;
876 case linear:
877 default:
878 regval = pmbus_data2reg_linear(data, sensor, val);
879 break;
880 }
881 return regval;
882 }
883
884 /*
885 * Return boolean calculated from converted data.
886 * <index> defines a status register index and mask.
887 * The mask is in the lower 8 bits, the register index is in bits 8..23.
888 *
889 * The associated pmbus_boolean structure contains optional pointers to two
890 * sensor attributes. If specified, those attributes are compared against each
891 * other to determine if a limit has been exceeded.
892 *
893 * If the sensor attribute pointers are NULL, the function returns true if
894 * (status[reg] & mask) is true.
895 *
896 * If sensor attribute pointers are provided, a comparison against a specified
897 * limit has to be performed to determine the boolean result.
898 * In this case, the function returns true if v1 >= v2 (where v1 and v2 are
899 * sensor values referenced by sensor attribute pointers s1 and s2).
900 *
901 * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>.
902 * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>.
903 *
904 * If a negative value is stored in any of the referenced registers, this value
905 * reflects an error code which will be returned.
906 */
907 static int pmbus_get_boolean(struct pmbus_data *data, struct pmbus_boolean *b,
908 int index)
909 {
910 struct pmbus_sensor *s1 = b->s1;
911 struct pmbus_sensor *s2 = b->s2;
912 u16 reg = (index >> 16) & 0xffff;
913 u16 mask = index & 0xffff;
914 int ret, status;
915 u16 regval;
916
917 status = data->status[reg];
918 if (status < 0)
919 return status;
920
921 regval = status & mask;
922 if (!s1 && !s2) {
923 ret = !!regval;
924 } else if (!s1 || !s2) {
925 WARN(1, "Bad boolean descriptor %p: s1=%p, s2=%p\n", b, s1, s2);
926 return 0;
927 } else {
928 long v1, v2;
929
930 if (s1->data < 0)
931 return s1->data;
932 if (s2->data < 0)
933 return s2->data;
934
935 v1 = pmbus_reg2data(data, s1);
936 v2 = pmbus_reg2data(data, s2);
937 ret = !!(regval && v1 >= v2);
938 }
939 return ret;
940 }
941
942 static ssize_t pmbus_show_boolean(struct device *dev,
943 struct device_attribute *da, char *buf)
944 {
945 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
946 struct pmbus_boolean *boolean = to_pmbus_boolean(attr);
947 struct pmbus_data *data = pmbus_update_device(dev);
948 int val;
949
950 val = pmbus_get_boolean(data, boolean, attr->index);
951 if (val < 0)
952 return val;
953 return snprintf(buf, PAGE_SIZE, "%d\n", val);
954 }
955
956 static ssize_t pmbus_show_sensor(struct device *dev,
957 struct device_attribute *devattr, char *buf)
958 {
959 struct pmbus_data *data = pmbus_update_device(dev);
960 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
961
962 if (sensor->data < 0)
963 return sensor->data;
964
965 return snprintf(buf, PAGE_SIZE, "%ld\n", pmbus_reg2data(data, sensor));
966 }
967
968 static ssize_t pmbus_set_sensor(struct device *dev,
969 struct device_attribute *devattr,
970 const char *buf, size_t count)
971 {
972 struct i2c_client *client = to_i2c_client(dev->parent);
973 struct pmbus_data *data = i2c_get_clientdata(client);
974 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
975 ssize_t rv = count;
976 long val = 0;
977 int ret;
978 u16 regval;
979
980 if (kstrtol(buf, 10, &val) < 0)
981 return -EINVAL;
982
983 mutex_lock(&data->update_lock);
984 regval = pmbus_data2reg(data, sensor, val);
985 ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
986 if (ret < 0)
987 rv = ret;
988 else
989 sensor->data = regval;
990 mutex_unlock(&data->update_lock);
991 return rv;
992 }
993
994 static ssize_t pmbus_show_label(struct device *dev,
995 struct device_attribute *da, char *buf)
996 {
997 struct pmbus_label *label = to_pmbus_label(da);
998
999 return snprintf(buf, PAGE_SIZE, "%s\n", label->label);
1000 }
1001
1002 static int pmbus_add_attribute(struct pmbus_data *data, struct attribute *attr)
1003 {
1004 if (data->num_attributes >= data->max_attributes - 1) {
1005 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE;
1006 void *new_attrs = krealloc(data->group.attrs,
1007 new_max_attrs * sizeof(void *),
1008 GFP_KERNEL);
1009 if (!new_attrs)
1010 return -ENOMEM;
1011 data->group.attrs = new_attrs;
1012 data->max_attributes = new_max_attrs;
1013 }
1014
1015 data->group.attrs[data->num_attributes++] = attr;
1016 data->group.attrs[data->num_attributes] = NULL;
1017 return 0;
1018 }
1019
1020 static void pmbus_dev_attr_init(struct device_attribute *dev_attr,
1021 const char *name,
1022 umode_t mode,
1023 ssize_t (*show)(struct device *dev,
1024 struct device_attribute *attr,
1025 char *buf),
1026 ssize_t (*store)(struct device *dev,
1027 struct device_attribute *attr,
1028 const char *buf, size_t count))
1029 {
1030 sysfs_attr_init(&dev_attr->attr);
1031 dev_attr->attr.name = name;
1032 dev_attr->attr.mode = mode;
1033 dev_attr->show = show;
1034 dev_attr->store = store;
1035 }
1036
1037 static void pmbus_attr_init(struct sensor_device_attribute *a,
1038 const char *name,
1039 umode_t mode,
1040 ssize_t (*show)(struct device *dev,
1041 struct device_attribute *attr,
1042 char *buf),
1043 ssize_t (*store)(struct device *dev,
1044 struct device_attribute *attr,
1045 const char *buf, size_t count),
1046 int idx)
1047 {
1048 pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store);
1049 a->index = idx;
1050 }
1051
1052 static int pmbus_add_boolean(struct pmbus_data *data,
1053 const char *name, const char *type, int seq,
1054 struct pmbus_sensor *s1,
1055 struct pmbus_sensor *s2,
1056 u16 reg, u16 mask)
1057 {
1058 struct pmbus_boolean *boolean;
1059 struct sensor_device_attribute *a;
1060
1061 boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL);
1062 if (!boolean)
1063 return -ENOMEM;
1064
1065 a = &boolean->attribute;
1066
1067 snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
1068 name, seq, type);
1069 boolean->s1 = s1;
1070 boolean->s2 = s2;
1071 pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL,
1072 (reg << 16) | mask);
1073
1074 return pmbus_add_attribute(data, &a->dev_attr.attr);
1075 }
1076
1077 static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data,
1078 const char *name, const char *type,
1079 int seq, int page, int reg,
1080 enum pmbus_sensor_classes class,
1081 bool update, bool readonly,
1082 bool convert)
1083 {
1084 struct pmbus_sensor *sensor;
1085 struct device_attribute *a;
1086
1087 sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL);
1088 if (!sensor)
1089 return NULL;
1090 a = &sensor->attribute;
1091
1092 if (type)
1093 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
1094 name, seq, type);
1095 else
1096 snprintf(sensor->name, sizeof(sensor->name), "%s%d",
1097 name, seq);
1098
1099 if (data->flags & PMBUS_WRITE_PROTECTED)
1100 readonly = true;
1101
1102 sensor->page = page;
1103 sensor->reg = reg;
1104 sensor->class = class;
1105 sensor->update = update;
1106 sensor->convert = convert;
1107 pmbus_dev_attr_init(a, sensor->name,
1108 readonly ? 0444 : 0644,
1109 pmbus_show_sensor, pmbus_set_sensor);
1110
1111 if (pmbus_add_attribute(data, &a->attr))
1112 return NULL;
1113
1114 sensor->next = data->sensors;
1115 data->sensors = sensor;
1116
1117 return sensor;
1118 }
1119
1120 static int pmbus_add_label(struct pmbus_data *data,
1121 const char *name, int seq,
1122 const char *lstring, int index)
1123 {
1124 struct pmbus_label *label;
1125 struct device_attribute *a;
1126
1127 label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL);
1128 if (!label)
1129 return -ENOMEM;
1130
1131 a = &label->attribute;
1132
1133 snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
1134 if (!index)
1135 strncpy(label->label, lstring, sizeof(label->label) - 1);
1136 else
1137 snprintf(label->label, sizeof(label->label), "%s%d", lstring,
1138 index);
1139
1140 pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL);
1141 return pmbus_add_attribute(data, &a->attr);
1142 }
1143
1144 /*
1145 * Search for attributes. Allocate sensors, booleans, and labels as needed.
1146 */
1147
1148 /*
1149 * The pmbus_limit_attr structure describes a single limit attribute
1150 * and its associated alarm attribute.
1151 */
1152 struct pmbus_limit_attr {
1153 u16 reg; /* Limit register */
1154 u16 sbit; /* Alarm attribute status bit */
1155 bool update; /* True if register needs updates */
1156 bool low; /* True if low limit; for limits with compare
1157 functions only */
1158 const char *attr; /* Attribute name */
1159 const char *alarm; /* Alarm attribute name */
1160 };
1161
1162 /*
1163 * The pmbus_sensor_attr structure describes one sensor attribute. This
1164 * description includes a reference to the associated limit attributes.
1165 */
1166 struct pmbus_sensor_attr {
1167 u16 reg; /* sensor register */
1168 u16 gbit; /* generic status bit */
1169 u8 nlimit; /* # of limit registers */
1170 enum pmbus_sensor_classes class;/* sensor class */
1171 const char *label; /* sensor label */
1172 bool paged; /* true if paged sensor */
1173 bool update; /* true if update needed */
1174 bool compare; /* true if compare function needed */
1175 u32 func; /* sensor mask */
1176 u32 sfunc; /* sensor status mask */
1177 int sbase; /* status base register */
1178 const struct pmbus_limit_attr *limit;/* limit registers */
1179 };
1180
1181 /*
1182 * Add a set of limit attributes and, if supported, the associated
1183 * alarm attributes.
1184 * returns 0 if no alarm register found, 1 if an alarm register was found,
1185 * < 0 on errors.
1186 */
1187 static int pmbus_add_limit_attrs(struct i2c_client *client,
1188 struct pmbus_data *data,
1189 const struct pmbus_driver_info *info,
1190 const char *name, int index, int page,
1191 struct pmbus_sensor *base,
1192 const struct pmbus_sensor_attr *attr)
1193 {
1194 const struct pmbus_limit_attr *l = attr->limit;
1195 int nlimit = attr->nlimit;
1196 int have_alarm = 0;
1197 int i, ret;
1198 struct pmbus_sensor *curr;
1199
1200 for (i = 0; i < nlimit; i++) {
1201 if (pmbus_check_word_register(client, page, l->reg)) {
1202 curr = pmbus_add_sensor(data, name, l->attr, index,
1203 page, l->reg, attr->class,
1204 attr->update || l->update,
1205 false, true);
1206 if (!curr)
1207 return -ENOMEM;
1208 if (l->sbit && (info->func[page] & attr->sfunc)) {
1209 ret = pmbus_add_boolean(data, name,
1210 l->alarm, index,
1211 attr->compare ? l->low ? curr : base
1212 : NULL,
1213 attr->compare ? l->low ? base : curr
1214 : NULL,
1215 attr->sbase + page, l->sbit);
1216 if (ret)
1217 return ret;
1218 have_alarm = 1;
1219 }
1220 }
1221 l++;
1222 }
1223 return have_alarm;
1224 }
1225
1226 static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
1227 struct pmbus_data *data,
1228 const struct pmbus_driver_info *info,
1229 const char *name,
1230 int index, int page,
1231 const struct pmbus_sensor_attr *attr,
1232 bool paged)
1233 {
1234 struct pmbus_sensor *base;
1235 bool upper = !!(attr->gbit & 0xff00); /* need to check STATUS_WORD */
1236 int ret;
1237
1238 if (attr->label) {
1239 ret = pmbus_add_label(data, name, index, attr->label,
1240 paged ? page + 1 : 0);
1241 if (ret)
1242 return ret;
1243 }
1244 base = pmbus_add_sensor(data, name, "input", index, page, attr->reg,
1245 attr->class, true, true, true);
1246 if (!base)
1247 return -ENOMEM;
1248 if (attr->sfunc) {
1249 ret = pmbus_add_limit_attrs(client, data, info, name,
1250 index, page, base, attr);
1251 if (ret < 0)
1252 return ret;
1253 /*
1254 * Add generic alarm attribute only if there are no individual
1255 * alarm attributes, if there is a global alarm bit, and if
1256 * the generic status register (word or byte, depending on
1257 * which global bit is set) for this page is accessible.
1258 */
1259 if (!ret && attr->gbit &&
1260 (!upper || (upper && data->has_status_word)) &&
1261 pmbus_check_status_register(client, page)) {
1262 ret = pmbus_add_boolean(data, name, "alarm", index,
1263 NULL, NULL,
1264 PB_STATUS_BASE + page,
1265 attr->gbit);
1266 if (ret)
1267 return ret;
1268 }
1269 }
1270 return 0;
1271 }
1272
1273 static bool pmbus_sensor_is_paged(const struct pmbus_driver_info *info,
1274 const struct pmbus_sensor_attr *attr)
1275 {
1276 int p;
1277
1278 if (attr->paged)
1279 return true;
1280
1281 /*
1282 * Some attributes may be present on more than one page despite
1283 * not being marked with the paged attribute. If that is the case,
1284 * then treat the sensor as being paged and add the page suffix to the
1285 * attribute name.
1286 * We don't just add the paged attribute to all such attributes, in
1287 * order to maintain the un-suffixed labels in the case where the
1288 * attribute is only on page 0.
1289 */
1290 for (p = 1; p < info->pages; p++) {
1291 if (info->func[p] & attr->func)
1292 return true;
1293 }
1294 return false;
1295 }
1296
1297 static int pmbus_add_sensor_attrs(struct i2c_client *client,
1298 struct pmbus_data *data,
1299 const char *name,
1300 const struct pmbus_sensor_attr *attrs,
1301 int nattrs)
1302 {
1303 const struct pmbus_driver_info *info = data->info;
1304 int index, i;
1305 int ret;
1306
1307 index = 1;
1308 for (i = 0; i < nattrs; i++) {
1309 int page, pages;
1310 bool paged = pmbus_sensor_is_paged(info, attrs);
1311
1312 pages = paged ? info->pages : 1;
1313 for (page = 0; page < pages; page++) {
1314 if (!(info->func[page] & attrs->func))
1315 continue;
1316 ret = pmbus_add_sensor_attrs_one(client, data, info,
1317 name, index, page,
1318 attrs, paged);
1319 if (ret)
1320 return ret;
1321 index++;
1322 }
1323 attrs++;
1324 }
1325 return 0;
1326 }
1327
1328 static const struct pmbus_limit_attr vin_limit_attrs[] = {
1329 {
1330 .reg = PMBUS_VIN_UV_WARN_LIMIT,
1331 .attr = "min",
1332 .alarm = "min_alarm",
1333 .sbit = PB_VOLTAGE_UV_WARNING,
1334 }, {
1335 .reg = PMBUS_VIN_UV_FAULT_LIMIT,
1336 .attr = "lcrit",
1337 .alarm = "lcrit_alarm",
1338 .sbit = PB_VOLTAGE_UV_FAULT,
1339 }, {
1340 .reg = PMBUS_VIN_OV_WARN_LIMIT,
1341 .attr = "max",
1342 .alarm = "max_alarm",
1343 .sbit = PB_VOLTAGE_OV_WARNING,
1344 }, {
1345 .reg = PMBUS_VIN_OV_FAULT_LIMIT,
1346 .attr = "crit",
1347 .alarm = "crit_alarm",
1348 .sbit = PB_VOLTAGE_OV_FAULT,
1349 }, {
1350 .reg = PMBUS_VIRT_READ_VIN_AVG,
1351 .update = true,
1352 .attr = "average",
1353 }, {
1354 .reg = PMBUS_VIRT_READ_VIN_MIN,
1355 .update = true,
1356 .attr = "lowest",
1357 }, {
1358 .reg = PMBUS_VIRT_READ_VIN_MAX,
1359 .update = true,
1360 .attr = "highest",
1361 }, {
1362 .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1363 .attr = "reset_history",
1364 },
1365 };
1366
1367 static const struct pmbus_limit_attr vmon_limit_attrs[] = {
1368 {
1369 .reg = PMBUS_VIRT_VMON_UV_WARN_LIMIT,
1370 .attr = "min",
1371 .alarm = "min_alarm",
1372 .sbit = PB_VOLTAGE_UV_WARNING,
1373 }, {
1374 .reg = PMBUS_VIRT_VMON_UV_FAULT_LIMIT,
1375 .attr = "lcrit",
1376 .alarm = "lcrit_alarm",
1377 .sbit = PB_VOLTAGE_UV_FAULT,
1378 }, {
1379 .reg = PMBUS_VIRT_VMON_OV_WARN_LIMIT,
1380 .attr = "max",
1381 .alarm = "max_alarm",
1382 .sbit = PB_VOLTAGE_OV_WARNING,
1383 }, {
1384 .reg = PMBUS_VIRT_VMON_OV_FAULT_LIMIT,
1385 .attr = "crit",
1386 .alarm = "crit_alarm",
1387 .sbit = PB_VOLTAGE_OV_FAULT,
1388 }
1389 };
1390
1391 static const struct pmbus_limit_attr vout_limit_attrs[] = {
1392 {
1393 .reg = PMBUS_VOUT_UV_WARN_LIMIT,
1394 .attr = "min",
1395 .alarm = "min_alarm",
1396 .sbit = PB_VOLTAGE_UV_WARNING,
1397 }, {
1398 .reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1399 .attr = "lcrit",
1400 .alarm = "lcrit_alarm",
1401 .sbit = PB_VOLTAGE_UV_FAULT,
1402 }, {
1403 .reg = PMBUS_VOUT_OV_WARN_LIMIT,
1404 .attr = "max",
1405 .alarm = "max_alarm",
1406 .sbit = PB_VOLTAGE_OV_WARNING,
1407 }, {
1408 .reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1409 .attr = "crit",
1410 .alarm = "crit_alarm",
1411 .sbit = PB_VOLTAGE_OV_FAULT,
1412 }, {
1413 .reg = PMBUS_VIRT_READ_VOUT_AVG,
1414 .update = true,
1415 .attr = "average",
1416 }, {
1417 .reg = PMBUS_VIRT_READ_VOUT_MIN,
1418 .update = true,
1419 .attr = "lowest",
1420 }, {
1421 .reg = PMBUS_VIRT_READ_VOUT_MAX,
1422 .update = true,
1423 .attr = "highest",
1424 }, {
1425 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1426 .attr = "reset_history",
1427 }
1428 };
1429
1430 static const struct pmbus_sensor_attr voltage_attributes[] = {
1431 {
1432 .reg = PMBUS_READ_VIN,
1433 .class = PSC_VOLTAGE_IN,
1434 .label = "vin",
1435 .func = PMBUS_HAVE_VIN,
1436 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1437 .sbase = PB_STATUS_INPUT_BASE,
1438 .gbit = PB_STATUS_VIN_UV,
1439 .limit = vin_limit_attrs,
1440 .nlimit = ARRAY_SIZE(vin_limit_attrs),
1441 }, {
1442 .reg = PMBUS_VIRT_READ_VMON,
1443 .class = PSC_VOLTAGE_IN,
1444 .label = "vmon",
1445 .func = PMBUS_HAVE_VMON,
1446 .sfunc = PMBUS_HAVE_STATUS_VMON,
1447 .sbase = PB_STATUS_VMON_BASE,
1448 .limit = vmon_limit_attrs,
1449 .nlimit = ARRAY_SIZE(vmon_limit_attrs),
1450 }, {
1451 .reg = PMBUS_READ_VCAP,
1452 .class = PSC_VOLTAGE_IN,
1453 .label = "vcap",
1454 .func = PMBUS_HAVE_VCAP,
1455 }, {
1456 .reg = PMBUS_READ_VOUT,
1457 .class = PSC_VOLTAGE_OUT,
1458 .label = "vout",
1459 .paged = true,
1460 .func = PMBUS_HAVE_VOUT,
1461 .sfunc = PMBUS_HAVE_STATUS_VOUT,
1462 .sbase = PB_STATUS_VOUT_BASE,
1463 .gbit = PB_STATUS_VOUT_OV,
1464 .limit = vout_limit_attrs,
1465 .nlimit = ARRAY_SIZE(vout_limit_attrs),
1466 }
1467 };
1468
1469 /* Current attributes */
1470
1471 static const struct pmbus_limit_attr iin_limit_attrs[] = {
1472 {
1473 .reg = PMBUS_IIN_OC_WARN_LIMIT,
1474 .attr = "max",
1475 .alarm = "max_alarm",
1476 .sbit = PB_IIN_OC_WARNING,
1477 }, {
1478 .reg = PMBUS_IIN_OC_FAULT_LIMIT,
1479 .attr = "crit",
1480 .alarm = "crit_alarm",
1481 .sbit = PB_IIN_OC_FAULT,
1482 }, {
1483 .reg = PMBUS_VIRT_READ_IIN_AVG,
1484 .update = true,
1485 .attr = "average",
1486 }, {
1487 .reg = PMBUS_VIRT_READ_IIN_MIN,
1488 .update = true,
1489 .attr = "lowest",
1490 }, {
1491 .reg = PMBUS_VIRT_READ_IIN_MAX,
1492 .update = true,
1493 .attr = "highest",
1494 }, {
1495 .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1496 .attr = "reset_history",
1497 }
1498 };
1499
1500 static const struct pmbus_limit_attr iout_limit_attrs[] = {
1501 {
1502 .reg = PMBUS_IOUT_OC_WARN_LIMIT,
1503 .attr = "max",
1504 .alarm = "max_alarm",
1505 .sbit = PB_IOUT_OC_WARNING,
1506 }, {
1507 .reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1508 .attr = "lcrit",
1509 .alarm = "lcrit_alarm",
1510 .sbit = PB_IOUT_UC_FAULT,
1511 }, {
1512 .reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1513 .attr = "crit",
1514 .alarm = "crit_alarm",
1515 .sbit = PB_IOUT_OC_FAULT,
1516 }, {
1517 .reg = PMBUS_VIRT_READ_IOUT_AVG,
1518 .update = true,
1519 .attr = "average",
1520 }, {
1521 .reg = PMBUS_VIRT_READ_IOUT_MIN,
1522 .update = true,
1523 .attr = "lowest",
1524 }, {
1525 .reg = PMBUS_VIRT_READ_IOUT_MAX,
1526 .update = true,
1527 .attr = "highest",
1528 }, {
1529 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1530 .attr = "reset_history",
1531 }
1532 };
1533
1534 static const struct pmbus_sensor_attr current_attributes[] = {
1535 {
1536 .reg = PMBUS_READ_IIN,
1537 .class = PSC_CURRENT_IN,
1538 .label = "iin",
1539 .func = PMBUS_HAVE_IIN,
1540 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1541 .sbase = PB_STATUS_INPUT_BASE,
1542 .gbit = PB_STATUS_INPUT,
1543 .limit = iin_limit_attrs,
1544 .nlimit = ARRAY_SIZE(iin_limit_attrs),
1545 }, {
1546 .reg = PMBUS_READ_IOUT,
1547 .class = PSC_CURRENT_OUT,
1548 .label = "iout",
1549 .paged = true,
1550 .func = PMBUS_HAVE_IOUT,
1551 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1552 .sbase = PB_STATUS_IOUT_BASE,
1553 .gbit = PB_STATUS_IOUT_OC,
1554 .limit = iout_limit_attrs,
1555 .nlimit = ARRAY_SIZE(iout_limit_attrs),
1556 }
1557 };
1558
1559 /* Power attributes */
1560
1561 static const struct pmbus_limit_attr pin_limit_attrs[] = {
1562 {
1563 .reg = PMBUS_PIN_OP_WARN_LIMIT,
1564 .attr = "max",
1565 .alarm = "alarm",
1566 .sbit = PB_PIN_OP_WARNING,
1567 }, {
1568 .reg = PMBUS_VIRT_READ_PIN_AVG,
1569 .update = true,
1570 .attr = "average",
1571 }, {
1572 .reg = PMBUS_VIRT_READ_PIN_MIN,
1573 .update = true,
1574 .attr = "input_lowest",
1575 }, {
1576 .reg = PMBUS_VIRT_READ_PIN_MAX,
1577 .update = true,
1578 .attr = "input_highest",
1579 }, {
1580 .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1581 .attr = "reset_history",
1582 }
1583 };
1584
1585 static const struct pmbus_limit_attr pout_limit_attrs[] = {
1586 {
1587 .reg = PMBUS_POUT_MAX,
1588 .attr = "cap",
1589 .alarm = "cap_alarm",
1590 .sbit = PB_POWER_LIMITING,
1591 }, {
1592 .reg = PMBUS_POUT_OP_WARN_LIMIT,
1593 .attr = "max",
1594 .alarm = "max_alarm",
1595 .sbit = PB_POUT_OP_WARNING,
1596 }, {
1597 .reg = PMBUS_POUT_OP_FAULT_LIMIT,
1598 .attr = "crit",
1599 .alarm = "crit_alarm",
1600 .sbit = PB_POUT_OP_FAULT,
1601 }, {
1602 .reg = PMBUS_VIRT_READ_POUT_AVG,
1603 .update = true,
1604 .attr = "average",
1605 }, {
1606 .reg = PMBUS_VIRT_READ_POUT_MIN,
1607 .update = true,
1608 .attr = "input_lowest",
1609 }, {
1610 .reg = PMBUS_VIRT_READ_POUT_MAX,
1611 .update = true,
1612 .attr = "input_highest",
1613 }, {
1614 .reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1615 .attr = "reset_history",
1616 }
1617 };
1618
1619 static const struct pmbus_sensor_attr power_attributes[] = {
1620 {
1621 .reg = PMBUS_READ_PIN,
1622 .class = PSC_POWER,
1623 .label = "pin",
1624 .func = PMBUS_HAVE_PIN,
1625 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1626 .sbase = PB_STATUS_INPUT_BASE,
1627 .gbit = PB_STATUS_INPUT,
1628 .limit = pin_limit_attrs,
1629 .nlimit = ARRAY_SIZE(pin_limit_attrs),
1630 }, {
1631 .reg = PMBUS_READ_POUT,
1632 .class = PSC_POWER,
1633 .label = "pout",
1634 .paged = true,
1635 .func = PMBUS_HAVE_POUT,
1636 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1637 .sbase = PB_STATUS_IOUT_BASE,
1638 .limit = pout_limit_attrs,
1639 .nlimit = ARRAY_SIZE(pout_limit_attrs),
1640 }
1641 };
1642
1643 /* Temperature atributes */
1644
1645 static const struct pmbus_limit_attr temp_limit_attrs[] = {
1646 {
1647 .reg = PMBUS_UT_WARN_LIMIT,
1648 .low = true,
1649 .attr = "min",
1650 .alarm = "min_alarm",
1651 .sbit = PB_TEMP_UT_WARNING,
1652 }, {
1653 .reg = PMBUS_UT_FAULT_LIMIT,
1654 .low = true,
1655 .attr = "lcrit",
1656 .alarm = "lcrit_alarm",
1657 .sbit = PB_TEMP_UT_FAULT,
1658 }, {
1659 .reg = PMBUS_OT_WARN_LIMIT,
1660 .attr = "max",
1661 .alarm = "max_alarm",
1662 .sbit = PB_TEMP_OT_WARNING,
1663 }, {
1664 .reg = PMBUS_OT_FAULT_LIMIT,
1665 .attr = "crit",
1666 .alarm = "crit_alarm",
1667 .sbit = PB_TEMP_OT_FAULT,
1668 }, {
1669 .reg = PMBUS_VIRT_READ_TEMP_MIN,
1670 .attr = "lowest",
1671 }, {
1672 .reg = PMBUS_VIRT_READ_TEMP_AVG,
1673 .attr = "average",
1674 }, {
1675 .reg = PMBUS_VIRT_READ_TEMP_MAX,
1676 .attr = "highest",
1677 }, {
1678 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1679 .attr = "reset_history",
1680 }
1681 };
1682
1683 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1684 {
1685 .reg = PMBUS_UT_WARN_LIMIT,
1686 .low = true,
1687 .attr = "min",
1688 .alarm = "min_alarm",
1689 .sbit = PB_TEMP_UT_WARNING,
1690 }, {
1691 .reg = PMBUS_UT_FAULT_LIMIT,
1692 .low = true,
1693 .attr = "lcrit",
1694 .alarm = "lcrit_alarm",
1695 .sbit = PB_TEMP_UT_FAULT,
1696 }, {
1697 .reg = PMBUS_OT_WARN_LIMIT,
1698 .attr = "max",
1699 .alarm = "max_alarm",
1700 .sbit = PB_TEMP_OT_WARNING,
1701 }, {
1702 .reg = PMBUS_OT_FAULT_LIMIT,
1703 .attr = "crit",
1704 .alarm = "crit_alarm",
1705 .sbit = PB_TEMP_OT_FAULT,
1706 }, {
1707 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
1708 .attr = "lowest",
1709 }, {
1710 .reg = PMBUS_VIRT_READ_TEMP2_AVG,
1711 .attr = "average",
1712 }, {
1713 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
1714 .attr = "highest",
1715 }, {
1716 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1717 .attr = "reset_history",
1718 }
1719 };
1720
1721 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
1722 {
1723 .reg = PMBUS_UT_WARN_LIMIT,
1724 .low = true,
1725 .attr = "min",
1726 .alarm = "min_alarm",
1727 .sbit = PB_TEMP_UT_WARNING,
1728 }, {
1729 .reg = PMBUS_UT_FAULT_LIMIT,
1730 .low = true,
1731 .attr = "lcrit",
1732 .alarm = "lcrit_alarm",
1733 .sbit = PB_TEMP_UT_FAULT,
1734 }, {
1735 .reg = PMBUS_OT_WARN_LIMIT,
1736 .attr = "max",
1737 .alarm = "max_alarm",
1738 .sbit = PB_TEMP_OT_WARNING,
1739 }, {
1740 .reg = PMBUS_OT_FAULT_LIMIT,
1741 .attr = "crit",
1742 .alarm = "crit_alarm",
1743 .sbit = PB_TEMP_OT_FAULT,
1744 }
1745 };
1746
1747 static const struct pmbus_sensor_attr temp_attributes[] = {
1748 {
1749 .reg = PMBUS_READ_TEMPERATURE_1,
1750 .class = PSC_TEMPERATURE,
1751 .paged = true,
1752 .update = true,
1753 .compare = true,
1754 .func = PMBUS_HAVE_TEMP,
1755 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1756 .sbase = PB_STATUS_TEMP_BASE,
1757 .gbit = PB_STATUS_TEMPERATURE,
1758 .limit = temp_limit_attrs,
1759 .nlimit = ARRAY_SIZE(temp_limit_attrs),
1760 }, {
1761 .reg = PMBUS_READ_TEMPERATURE_2,
1762 .class = PSC_TEMPERATURE,
1763 .paged = true,
1764 .update = true,
1765 .compare = true,
1766 .func = PMBUS_HAVE_TEMP2,
1767 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1768 .sbase = PB_STATUS_TEMP_BASE,
1769 .gbit = PB_STATUS_TEMPERATURE,
1770 .limit = temp_limit_attrs2,
1771 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
1772 }, {
1773 .reg = PMBUS_READ_TEMPERATURE_3,
1774 .class = PSC_TEMPERATURE,
1775 .paged = true,
1776 .update = true,
1777 .compare = true,
1778 .func = PMBUS_HAVE_TEMP3,
1779 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1780 .sbase = PB_STATUS_TEMP_BASE,
1781 .gbit = PB_STATUS_TEMPERATURE,
1782 .limit = temp_limit_attrs3,
1783 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
1784 }
1785 };
1786
1787 static const int pmbus_fan_registers[] = {
1788 PMBUS_READ_FAN_SPEED_1,
1789 PMBUS_READ_FAN_SPEED_2,
1790 PMBUS_READ_FAN_SPEED_3,
1791 PMBUS_READ_FAN_SPEED_4
1792 };
1793
1794 static const int pmbus_fan_status_registers[] = {
1795 PMBUS_STATUS_FAN_12,
1796 PMBUS_STATUS_FAN_12,
1797 PMBUS_STATUS_FAN_34,
1798 PMBUS_STATUS_FAN_34
1799 };
1800
1801 static const u32 pmbus_fan_flags[] = {
1802 PMBUS_HAVE_FAN12,
1803 PMBUS_HAVE_FAN12,
1804 PMBUS_HAVE_FAN34,
1805 PMBUS_HAVE_FAN34
1806 };
1807
1808 static const u32 pmbus_fan_status_flags[] = {
1809 PMBUS_HAVE_STATUS_FAN12,
1810 PMBUS_HAVE_STATUS_FAN12,
1811 PMBUS_HAVE_STATUS_FAN34,
1812 PMBUS_HAVE_STATUS_FAN34
1813 };
1814
1815 /* Fans */
1816
1817 /* Precondition: FAN_CONFIG_x_y and FAN_COMMAND_x must exist for the fan ID */
1818 static int pmbus_add_fan_ctrl(struct i2c_client *client,
1819 struct pmbus_data *data, int index, int page, int id,
1820 u8 config)
1821 {
1822 struct pmbus_sensor *sensor;
1823
1824 sensor = pmbus_add_sensor(data, "fan", "target", index, page,
1825 PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN,
1826 false, false, true);
1827
1828 if (!sensor)
1829 return -ENOMEM;
1830
1831 if (!((data->info->func[page] & PMBUS_HAVE_PWM12) ||
1832 (data->info->func[page] & PMBUS_HAVE_PWM34)))
1833 return 0;
1834
1835 sensor = pmbus_add_sensor(data, "pwm", NULL, index, page,
1836 PMBUS_VIRT_PWM_1 + id, PSC_PWM,
1837 false, false, true);
1838
1839 if (!sensor)
1840 return -ENOMEM;
1841
1842 sensor = pmbus_add_sensor(data, "pwm", "enable", index, page,
1843 PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM,
1844 true, false, false);
1845
1846 if (!sensor)
1847 return -ENOMEM;
1848
1849 return 0;
1850 }
1851
1852 static int pmbus_add_fan_attributes(struct i2c_client *client,
1853 struct pmbus_data *data)
1854 {
1855 const struct pmbus_driver_info *info = data->info;
1856 int index = 1;
1857 int page;
1858 int ret;
1859
1860 for (page = 0; page < info->pages; page++) {
1861 int f;
1862
1863 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
1864 int regval;
1865
1866 if (!(info->func[page] & pmbus_fan_flags[f]))
1867 break;
1868
1869 if (!pmbus_check_word_register(client, page,
1870 pmbus_fan_registers[f]))
1871 break;
1872
1873 /*
1874 * Skip fan if not installed.
1875 * Each fan configuration register covers multiple fans,
1876 * so we have to do some magic.
1877 */
1878 regval = _pmbus_read_byte_data(client, page,
1879 pmbus_fan_config_registers[f]);
1880 if (regval < 0 ||
1881 (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
1882 continue;
1883
1884 if (pmbus_add_sensor(data, "fan", "input", index,
1885 page, pmbus_fan_registers[f],
1886 PSC_FAN, true, true, true) == NULL)
1887 return -ENOMEM;
1888
1889 /* Fan control */
1890 if (pmbus_check_word_register(client, page,
1891 pmbus_fan_command_registers[f])) {
1892 ret = pmbus_add_fan_ctrl(client, data, index,
1893 page, f, regval);
1894 if (ret < 0)
1895 return ret;
1896 }
1897
1898 /*
1899 * Each fan status register covers multiple fans,
1900 * so we have to do some magic.
1901 */
1902 if ((info->func[page] & pmbus_fan_status_flags[f]) &&
1903 pmbus_check_byte_register(client,
1904 page, pmbus_fan_status_registers[f])) {
1905 int base;
1906
1907 if (f > 1) /* fan 3, 4 */
1908 base = PB_STATUS_FAN34_BASE + page;
1909 else
1910 base = PB_STATUS_FAN_BASE + page;
1911 ret = pmbus_add_boolean(data, "fan",
1912 "alarm", index, NULL, NULL, base,
1913 PB_FAN_FAN1_WARNING >> (f & 1));
1914 if (ret)
1915 return ret;
1916 ret = pmbus_add_boolean(data, "fan",
1917 "fault", index, NULL, NULL, base,
1918 PB_FAN_FAN1_FAULT >> (f & 1));
1919 if (ret)
1920 return ret;
1921 }
1922 index++;
1923 }
1924 }
1925 return 0;
1926 }
1927
1928 struct pmbus_samples_attr {
1929 int reg;
1930 char *name;
1931 };
1932
1933 struct pmbus_samples_reg {
1934 int page;
1935 struct pmbus_samples_attr *attr;
1936 struct device_attribute dev_attr;
1937 };
1938
1939 static struct pmbus_samples_attr pmbus_samples_registers[] = {
1940 {
1941 .reg = PMBUS_VIRT_SAMPLES,
1942 .name = "samples",
1943 }, {
1944 .reg = PMBUS_VIRT_IN_SAMPLES,
1945 .name = "in_samples",
1946 }, {
1947 .reg = PMBUS_VIRT_CURR_SAMPLES,
1948 .name = "curr_samples",
1949 }, {
1950 .reg = PMBUS_VIRT_POWER_SAMPLES,
1951 .name = "power_samples",
1952 }, {
1953 .reg = PMBUS_VIRT_TEMP_SAMPLES,
1954 .name = "temp_samples",
1955 }
1956 };
1957
1958 #define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr)
1959
1960 static ssize_t pmbus_show_samples(struct device *dev,
1961 struct device_attribute *devattr, char *buf)
1962 {
1963 int val;
1964 struct i2c_client *client = to_i2c_client(dev->parent);
1965 struct pmbus_samples_reg *reg = to_samples_reg(devattr);
1966
1967 val = _pmbus_read_word_data(client, reg->page, reg->attr->reg);
1968 if (val < 0)
1969 return val;
1970
1971 return snprintf(buf, PAGE_SIZE, "%d\n", val);
1972 }
1973
1974 static ssize_t pmbus_set_samples(struct device *dev,
1975 struct device_attribute *devattr,
1976 const char *buf, size_t count)
1977 {
1978 int ret;
1979 long val;
1980 struct i2c_client *client = to_i2c_client(dev->parent);
1981 struct pmbus_samples_reg *reg = to_samples_reg(devattr);
1982 struct pmbus_data *data = i2c_get_clientdata(client);
1983
1984 if (kstrtol(buf, 0, &val) < 0)
1985 return -EINVAL;
1986
1987 mutex_lock(&data->update_lock);
1988 ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val);
1989 mutex_unlock(&data->update_lock);
1990
1991 return ret ? : count;
1992 }
1993
1994 static int pmbus_add_samples_attr(struct pmbus_data *data, int page,
1995 struct pmbus_samples_attr *attr)
1996 {
1997 struct pmbus_samples_reg *reg;
1998
1999 reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL);
2000 if (!reg)
2001 return -ENOMEM;
2002
2003 reg->attr = attr;
2004 reg->page = page;
2005
2006 pmbus_dev_attr_init(&reg->dev_attr, attr->name, 0644,
2007 pmbus_show_samples, pmbus_set_samples);
2008
2009 return pmbus_add_attribute(data, &reg->dev_attr.attr);
2010 }
2011
2012 static int pmbus_add_samples_attributes(struct i2c_client *client,
2013 struct pmbus_data *data)
2014 {
2015 const struct pmbus_driver_info *info = data->info;
2016 int s;
2017
2018 if (!(info->func[0] & PMBUS_HAVE_SAMPLES))
2019 return 0;
2020
2021 for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) {
2022 struct pmbus_samples_attr *attr;
2023 int ret;
2024
2025 attr = &pmbus_samples_registers[s];
2026 if (!pmbus_check_word_register(client, 0, attr->reg))
2027 continue;
2028
2029 ret = pmbus_add_samples_attr(data, 0, attr);
2030 if (ret)
2031 return ret;
2032 }
2033
2034 return 0;
2035 }
2036
2037 static int pmbus_find_attributes(struct i2c_client *client,
2038 struct pmbus_data *data)
2039 {
2040 int ret;
2041
2042 /* Voltage sensors */
2043 ret = pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
2044 ARRAY_SIZE(voltage_attributes));
2045 if (ret)
2046 return ret;
2047
2048 /* Current sensors */
2049 ret = pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
2050 ARRAY_SIZE(current_attributes));
2051 if (ret)
2052 return ret;
2053
2054 /* Power sensors */
2055 ret = pmbus_add_sensor_attrs(client, data, "power", power_attributes,
2056 ARRAY_SIZE(power_attributes));
2057 if (ret)
2058 return ret;
2059
2060 /* Temperature sensors */
2061 ret = pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
2062 ARRAY_SIZE(temp_attributes));
2063 if (ret)
2064 return ret;
2065
2066 /* Fans */
2067 ret = pmbus_add_fan_attributes(client, data);
2068 if (ret)
2069 return ret;
2070
2071 ret = pmbus_add_samples_attributes(client, data);
2072 return ret;
2073 }
2074
2075 /*
2076 * Identify chip parameters.
2077 * This function is called for all chips.
2078 */
2079 static int pmbus_identify_common(struct i2c_client *client,
2080 struct pmbus_data *data, int page)
2081 {
2082 int vout_mode = -1;
2083
2084 if (pmbus_check_byte_register(client, page, PMBUS_VOUT_MODE))
2085 vout_mode = _pmbus_read_byte_data(client, page,
2086 PMBUS_VOUT_MODE);
2087 if (vout_mode >= 0 && vout_mode != 0xff) {
2088 /*
2089 * Not all chips support the VOUT_MODE command,
2090 * so a failure to read it is not an error.
2091 */
2092 switch (vout_mode >> 5) {
2093 case 0: /* linear mode */
2094 if (data->info->format[PSC_VOLTAGE_OUT] != linear)
2095 return -ENODEV;
2096
2097 data->exponent[page] = ((s8)(vout_mode << 3)) >> 3;
2098 break;
2099 case 1: /* VID mode */
2100 if (data->info->format[PSC_VOLTAGE_OUT] != vid)
2101 return -ENODEV;
2102 break;
2103 case 2: /* direct mode */
2104 if (data->info->format[PSC_VOLTAGE_OUT] != direct)
2105 return -ENODEV;
2106 break;
2107 default:
2108 return -ENODEV;
2109 }
2110 }
2111
2112 pmbus_clear_fault_page(client, page);
2113 return 0;
2114 }
2115
2116 static int pmbus_read_status_byte(struct i2c_client *client, int page)
2117 {
2118 return _pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
2119 }
2120
2121 static int pmbus_read_status_word(struct i2c_client *client, int page)
2122 {
2123 return _pmbus_read_word_data(client, page, PMBUS_STATUS_WORD);
2124 }
2125
2126 static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
2127 struct pmbus_driver_info *info)
2128 {
2129 struct device *dev = &client->dev;
2130 int page, ret;
2131
2132 /*
2133 * Some PMBus chips don't support PMBUS_STATUS_WORD, so try
2134 * to use PMBUS_STATUS_BYTE instead if that is the case.
2135 * Bail out if both registers are not supported.
2136 */
2137 data->read_status = pmbus_read_status_word;
2138 ret = i2c_smbus_read_word_data(client, PMBUS_STATUS_WORD);
2139 if (ret < 0 || ret == 0xffff) {
2140 data->read_status = pmbus_read_status_byte;
2141 ret = i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE);
2142 if (ret < 0 || ret == 0xff) {
2143 dev_err(dev, "PMBus status register not found\n");
2144 return -ENODEV;
2145 }
2146 } else {
2147 data->has_status_word = true;
2148 }
2149
2150 /* Enable PEC if the controller supports it */
2151 ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
2152 if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK))
2153 client->flags |= I2C_CLIENT_PEC;
2154
2155 /*
2156 * Check if the chip is write protected. If it is, we can not clear
2157 * faults, and we should not try it. Also, in that case, writes into
2158 * limit registers need to be disabled.
2159 */
2160 ret = i2c_smbus_read_byte_data(client, PMBUS_WRITE_PROTECT);
2161 if (ret > 0 && (ret & PB_WP_ANY))
2162 data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK;
2163
2164 if (data->info->pages)
2165 pmbus_clear_faults(client);
2166 else
2167 pmbus_clear_fault_page(client, -1);
2168
2169 if (info->identify) {
2170 ret = (*info->identify)(client, info);
2171 if (ret < 0) {
2172 dev_err(dev, "Chip identification failed\n");
2173 return ret;
2174 }
2175 }
2176
2177 if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
2178 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages);
2179 return -ENODEV;
2180 }
2181
2182 for (page = 0; page < info->pages; page++) {
2183 ret = pmbus_identify_common(client, data, page);
2184 if (ret < 0) {
2185 dev_err(dev, "Failed to identify chip capabilities\n");
2186 return ret;
2187 }
2188 }
2189 return 0;
2190 }
2191
2192 #if IS_ENABLED(CONFIG_REGULATOR)
2193 static int pmbus_regulator_is_enabled(struct regulator_dev *rdev)
2194 {
2195 struct device *dev = rdev_get_dev(rdev);
2196 struct i2c_client *client = to_i2c_client(dev->parent);
2197 u8 page = rdev_get_id(rdev);
2198 int ret;
2199
2200 ret = pmbus_read_byte_data(client, page, PMBUS_OPERATION);
2201 if (ret < 0)
2202 return ret;
2203
2204 return !!(ret & PB_OPERATION_CONTROL_ON);
2205 }
2206
2207 static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable)
2208 {
2209 struct device *dev = rdev_get_dev(rdev);
2210 struct i2c_client *client = to_i2c_client(dev->parent);
2211 u8 page = rdev_get_id(rdev);
2212
2213 return pmbus_update_byte_data(client, page, PMBUS_OPERATION,
2214 PB_OPERATION_CONTROL_ON,
2215 enable ? PB_OPERATION_CONTROL_ON : 0);
2216 }
2217
2218 static int pmbus_regulator_enable(struct regulator_dev *rdev)
2219 {
2220 return _pmbus_regulator_on_off(rdev, 1);
2221 }
2222
2223 static int pmbus_regulator_disable(struct regulator_dev *rdev)
2224 {
2225 return _pmbus_regulator_on_off(rdev, 0);
2226 }
2227
2228 const struct regulator_ops pmbus_regulator_ops = {
2229 .enable = pmbus_regulator_enable,
2230 .disable = pmbus_regulator_disable,
2231 .is_enabled = pmbus_regulator_is_enabled,
2232 };
2233 EXPORT_SYMBOL_GPL(pmbus_regulator_ops);
2234
2235 static int pmbus_regulator_register(struct pmbus_data *data)
2236 {
2237 struct device *dev = data->dev;
2238 const struct pmbus_driver_info *info = data->info;
2239 const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
2240 struct regulator_dev *rdev;
2241 int i;
2242
2243 for (i = 0; i < info->num_regulators; i++) {
2244 struct regulator_config config = { };
2245
2246 config.dev = dev;
2247 config.driver_data = data;
2248
2249 if (pdata && pdata->reg_init_data)
2250 config.init_data = &pdata->reg_init_data[i];
2251
2252 rdev = devm_regulator_register(dev, &info->reg_desc[i],
2253 &config);
2254 if (IS_ERR(rdev)) {
2255 dev_err(dev, "Failed to register %s regulator\n",
2256 info->reg_desc[i].name);
2257 return PTR_ERR(rdev);
2258 }
2259 }
2260
2261 return 0;
2262 }
2263 #else
2264 static int pmbus_regulator_register(struct pmbus_data *data)
2265 {
2266 return 0;
2267 }
2268 #endif
2269
2270 static struct dentry *pmbus_debugfs_dir; /* pmbus debugfs directory */
2271
2272 #if IS_ENABLED(CONFIG_DEBUG_FS)
2273 static int pmbus_debugfs_get(void *data, u64 *val)
2274 {
2275 int rc;
2276 struct pmbus_debugfs_entry *entry = data;
2277
2278 rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg);
2279 if (rc < 0)
2280 return rc;
2281
2282 *val = rc;
2283
2284 return 0;
2285 }
2286 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops, pmbus_debugfs_get, NULL,
2287 "0x%02llx\n");
2288
2289 static int pmbus_debugfs_get_status(void *data, u64 *val)
2290 {
2291 int rc;
2292 struct pmbus_debugfs_entry *entry = data;
2293 struct pmbus_data *pdata = i2c_get_clientdata(entry->client);
2294
2295 rc = pdata->read_status(entry->client, entry->page);
2296 if (rc < 0)
2297 return rc;
2298
2299 *val = rc;
2300
2301 return 0;
2302 }
2303 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status,
2304 NULL, "0x%04llx\n");
2305
2306 static int pmbus_init_debugfs(struct i2c_client *client,
2307 struct pmbus_data *data)
2308 {
2309 int i, idx = 0;
2310 char name[PMBUS_NAME_SIZE];
2311 struct pmbus_debugfs_entry *entries;
2312
2313 if (!pmbus_debugfs_dir)
2314 return -ENODEV;
2315
2316 /*
2317 * Create the debugfs directory for this device. Use the hwmon device
2318 * name to avoid conflicts (hwmon numbers are globally unique).
2319 */
2320 data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev),
2321 pmbus_debugfs_dir);
2322 if (IS_ERR_OR_NULL(data->debugfs)) {
2323 data->debugfs = NULL;
2324 return -ENODEV;
2325 }
2326
2327 /* Allocate the max possible entries we need. */
2328 entries = devm_kcalloc(data->dev,
2329 data->info->pages * 10, sizeof(*entries),
2330 GFP_KERNEL);
2331 if (!entries)
2332 return -ENOMEM;
2333
2334 for (i = 0; i < data->info->pages; ++i) {
2335 /* Check accessibility of status register if it's not page 0 */
2336 if (!i || pmbus_check_status_register(client, i)) {
2337 /* No need to set reg as we have special read op. */
2338 entries[idx].client = client;
2339 entries[idx].page = i;
2340 scnprintf(name, PMBUS_NAME_SIZE, "status%d", i);
2341 debugfs_create_file(name, 0444, data->debugfs,
2342 &entries[idx++],
2343 &pmbus_debugfs_ops_status);
2344 }
2345
2346 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) {
2347 entries[idx].client = client;
2348 entries[idx].page = i;
2349 entries[idx].reg = PMBUS_STATUS_VOUT;
2350 scnprintf(name, PMBUS_NAME_SIZE, "status%d_vout", 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_IOUT) {
2357 entries[idx].client = client;
2358 entries[idx].page = i;
2359 entries[idx].reg = PMBUS_STATUS_IOUT;
2360 scnprintf(name, PMBUS_NAME_SIZE, "status%d_iout", i);
2361 debugfs_create_file(name, 0444, data->debugfs,
2362 &entries[idx++],
2363 &pmbus_debugfs_ops);
2364 }
2365
2366 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) {
2367 entries[idx].client = client;
2368 entries[idx].page = i;
2369 entries[idx].reg = PMBUS_STATUS_INPUT;
2370 scnprintf(name, PMBUS_NAME_SIZE, "status%d_input", i);
2371 debugfs_create_file(name, 0444, data->debugfs,
2372 &entries[idx++],
2373 &pmbus_debugfs_ops);
2374 }
2375
2376 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) {
2377 entries[idx].client = client;
2378 entries[idx].page = i;
2379 entries[idx].reg = PMBUS_STATUS_TEMPERATURE;
2380 scnprintf(name, PMBUS_NAME_SIZE, "status%d_temp", 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, PMBUS_STATUS_CML)) {
2387 entries[idx].client = client;
2388 entries[idx].page = i;
2389 entries[idx].reg = PMBUS_STATUS_CML;
2390 scnprintf(name, PMBUS_NAME_SIZE, "status%d_cml", i);
2391 debugfs_create_file(name, 0444, data->debugfs,
2392 &entries[idx++],
2393 &pmbus_debugfs_ops);
2394 }
2395
2396 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_OTHER)) {
2397 entries[idx].client = client;
2398 entries[idx].page = i;
2399 entries[idx].reg = PMBUS_STATUS_OTHER;
2400 scnprintf(name, PMBUS_NAME_SIZE, "status%d_other", i);
2401 debugfs_create_file(name, 0444, data->debugfs,
2402 &entries[idx++],
2403 &pmbus_debugfs_ops);
2404 }
2405
2406 if (pmbus_check_byte_register(client, i,
2407 PMBUS_STATUS_MFR_SPECIFIC)) {
2408 entries[idx].client = client;
2409 entries[idx].page = i;
2410 entries[idx].reg = PMBUS_STATUS_MFR_SPECIFIC;
2411 scnprintf(name, PMBUS_NAME_SIZE, "status%d_mfr", i);
2412 debugfs_create_file(name, 0444, data->debugfs,
2413 &entries[idx++],
2414 &pmbus_debugfs_ops);
2415 }
2416
2417 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) {
2418 entries[idx].client = client;
2419 entries[idx].page = i;
2420 entries[idx].reg = PMBUS_STATUS_FAN_12;
2421 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan12", i);
2422 debugfs_create_file(name, 0444, data->debugfs,
2423 &entries[idx++],
2424 &pmbus_debugfs_ops);
2425 }
2426
2427 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) {
2428 entries[idx].client = client;
2429 entries[idx].page = i;
2430 entries[idx].reg = PMBUS_STATUS_FAN_34;
2431 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan34", i);
2432 debugfs_create_file(name, 0444, data->debugfs,
2433 &entries[idx++],
2434 &pmbus_debugfs_ops);
2435 }
2436 }
2437
2438 return 0;
2439 }
2440 #else
2441 static int pmbus_init_debugfs(struct i2c_client *client,
2442 struct pmbus_data *data)
2443 {
2444 return 0;
2445 }
2446 #endif /* IS_ENABLED(CONFIG_DEBUG_FS) */
2447
2448 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
2449 struct pmbus_driver_info *info)
2450 {
2451 struct device *dev = &client->dev;
2452 const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
2453 struct pmbus_data *data;
2454 size_t groups_num = 0;
2455 int ret;
2456
2457 if (!info)
2458 return -ENODEV;
2459
2460 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
2461 | I2C_FUNC_SMBUS_BYTE_DATA
2462 | I2C_FUNC_SMBUS_WORD_DATA))
2463 return -ENODEV;
2464
2465 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
2466 if (!data)
2467 return -ENOMEM;
2468
2469 if (info->groups)
2470 while (info->groups[groups_num])
2471 groups_num++;
2472
2473 data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *),
2474 GFP_KERNEL);
2475 if (!data->groups)
2476 return -ENOMEM;
2477
2478 i2c_set_clientdata(client, data);
2479 mutex_init(&data->update_lock);
2480 data->dev = dev;
2481
2482 if (pdata)
2483 data->flags = pdata->flags;
2484 data->info = info;
2485
2486 ret = pmbus_init_common(client, data, info);
2487 if (ret < 0)
2488 return ret;
2489
2490 ret = pmbus_find_attributes(client, data);
2491 if (ret)
2492 goto out_kfree;
2493
2494 /*
2495 * If there are no attributes, something is wrong.
2496 * Bail out instead of trying to register nothing.
2497 */
2498 if (!data->num_attributes) {
2499 dev_err(dev, "No attributes found\n");
2500 ret = -ENODEV;
2501 goto out_kfree;
2502 }
2503
2504 data->groups[0] = &data->group;
2505 memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num);
2506 data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name,
2507 data, data->groups);
2508 if (IS_ERR(data->hwmon_dev)) {
2509 ret = PTR_ERR(data->hwmon_dev);
2510 dev_err(dev, "Failed to register hwmon device\n");
2511 goto out_kfree;
2512 }
2513
2514 ret = pmbus_regulator_register(data);
2515 if (ret)
2516 goto out_unregister;
2517
2518 ret = pmbus_init_debugfs(client, data);
2519 if (ret)
2520 dev_warn(dev, "Failed to register debugfs\n");
2521
2522 return 0;
2523
2524 out_unregister:
2525 hwmon_device_unregister(data->hwmon_dev);
2526 out_kfree:
2527 kfree(data->group.attrs);
2528 return ret;
2529 }
2530 EXPORT_SYMBOL_GPL(pmbus_do_probe);
2531
2532 int pmbus_do_remove(struct i2c_client *client)
2533 {
2534 struct pmbus_data *data = i2c_get_clientdata(client);
2535
2536 debugfs_remove_recursive(data->debugfs);
2537
2538 hwmon_device_unregister(data->hwmon_dev);
2539 kfree(data->group.attrs);
2540 return 0;
2541 }
2542 EXPORT_SYMBOL_GPL(pmbus_do_remove);
2543
2544 struct dentry *pmbus_get_debugfs_dir(struct i2c_client *client)
2545 {
2546 struct pmbus_data *data = i2c_get_clientdata(client);
2547
2548 return data->debugfs;
2549 }
2550 EXPORT_SYMBOL_GPL(pmbus_get_debugfs_dir);
2551
2552 static int __init pmbus_core_init(void)
2553 {
2554 pmbus_debugfs_dir = debugfs_create_dir("pmbus", NULL);
2555 if (IS_ERR(pmbus_debugfs_dir))
2556 pmbus_debugfs_dir = NULL;
2557
2558 return 0;
2559 }
2560
2561 static void __exit pmbus_core_exit(void)
2562 {
2563 debugfs_remove_recursive(pmbus_debugfs_dir);
2564 }
2565
2566 module_init(pmbus_core_init);
2567 module_exit(pmbus_core_exit);
2568
2569 MODULE_AUTHOR("Guenter Roeck");
2570 MODULE_DESCRIPTION("PMBus core driver");
2571 MODULE_LICENSE("GPL");
Linux with added FPC-III support