treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / hwmon / max6621.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Hardware monitoring driver for Maxim MAX6621
4  *
5  * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
6  * Copyright (c) 2017 Vadim Pasternak <vadimp@mellanox.com>
7  */
8
9 #include <linux/bitops.h>
10 #include <linux/hwmon.h>
11 #include <linux/hwmon-sysfs.h>
12 #include <linux/i2c.h>
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/of_device.h>
16 #include <linux/regmap.h>
17
18 #define MAX6621_DRV_NAME                "max6621"
19 #define MAX6621_TEMP_INPUT_REG_NUM      9
20 #define MAX6621_TEMP_INPUT_MIN          -127000
21 #define MAX6621_TEMP_INPUT_MAX          128000
22 #define MAX6621_TEMP_ALERT_CHAN_SHIFT   1
23
24 #define MAX6621_TEMP_S0D0_REG           0x00
25 #define MAX6621_TEMP_S0D1_REG           0x01
26 #define MAX6621_TEMP_S1D0_REG           0x02
27 #define MAX6621_TEMP_S1D1_REG           0x03
28 #define MAX6621_TEMP_S2D0_REG           0x04
29 #define MAX6621_TEMP_S2D1_REG           0x05
30 #define MAX6621_TEMP_S3D0_REG           0x06
31 #define MAX6621_TEMP_S3D1_REG           0x07
32 #define MAX6621_TEMP_MAX_REG            0x08
33 #define MAX6621_TEMP_MAX_ADDR_REG       0x0a
34 #define MAX6621_TEMP_ALERT_CAUSE_REG    0x0b
35 #define MAX6621_CONFIG0_REG             0x0c
36 #define MAX6621_CONFIG1_REG             0x0d
37 #define MAX6621_CONFIG2_REG             0x0e
38 #define MAX6621_CONFIG3_REG             0x0f
39 #define MAX6621_TEMP_S0_ALERT_REG       0x10
40 #define MAX6621_TEMP_S1_ALERT_REG       0x11
41 #define MAX6621_TEMP_S2_ALERT_REG       0x12
42 #define MAX6621_TEMP_S3_ALERT_REG       0x13
43 #define MAX6621_CLEAR_ALERT_REG         0x15
44 #define MAX6621_REG_MAX                 (MAX6621_CLEAR_ALERT_REG + 1)
45 #define MAX6621_REG_TEMP_SHIFT          0x06
46
47 #define MAX6621_ENABLE_TEMP_ALERTS_BIT  4
48 #define MAX6621_ENABLE_I2C_CRC_BIT      5
49 #define MAX6621_ENABLE_ALTERNATE_DATA   6
50 #define MAX6621_ENABLE_LOCKUP_TO        7
51 #define MAX6621_ENABLE_S0D0_BIT         8
52 #define MAX6621_ENABLE_S3D1_BIT         15
53 #define MAX6621_ENABLE_TEMP_ALL         GENMASK(MAX6621_ENABLE_S3D1_BIT, \
54                                                 MAX6621_ENABLE_S0D0_BIT)
55 #define MAX6621_POLL_DELAY_MASK         0x5
56 #define MAX6621_CONFIG0_INIT            (MAX6621_ENABLE_TEMP_ALL | \
57                                          BIT(MAX6621_ENABLE_LOCKUP_TO) | \
58                                          BIT(MAX6621_ENABLE_I2C_CRC_BIT) | \
59                                          MAX6621_POLL_DELAY_MASK)
60 #define MAX6621_PECI_BIT_TIME           0x2
61 #define MAX6621_PECI_RETRY_NUM          0x3
62 #define MAX6621_CONFIG1_INIT            ((MAX6621_PECI_BIT_TIME << 8) | \
63                                          MAX6621_PECI_RETRY_NUM)
64
65 /* Error codes */
66 #define MAX6621_TRAN_FAILED     0x8100  /*
67                                          * PECI transaction failed for more
68                                          * than the configured number of
69                                          * consecutive retries.
70                                          */
71 #define MAX6621_POOL_DIS        0x8101  /*
72                                          * Polling disabled for requested
73                                          * socket/domain.
74                                          */
75 #define MAX6621_POOL_UNCOMPLETE 0x8102  /*
76                                          * First poll not yet completed for
77                                          * requested socket/domain (on
78                                          * startup).
79                                          */
80 #define MAX6621_SD_DIS          0x8103  /*
81                                          * Read maximum temperature requested,
82                                          * but no sockets/domains enabled or
83                                          * all enabled sockets/domains have
84                                          * errors; or read maximum temperature
85                                          * address requested, but read maximum
86                                          * temperature was not called.
87                                          */
88 #define MAX6621_ALERT_DIS       0x8104  /*
89                                          * Get alert socket/domain requested,
90                                          * but no alert active.
91                                          */
92 #define MAX6621_PECI_ERR_MIN    0x8000  /* Intel spec PECI error min value. */
93 #define MAX6621_PECI_ERR_MAX    0x80ff  /* Intel spec PECI error max value. */
94
95 static const u32 max6621_temp_regs[] = {
96         MAX6621_TEMP_MAX_REG, MAX6621_TEMP_S0D0_REG, MAX6621_TEMP_S1D0_REG,
97         MAX6621_TEMP_S2D0_REG, MAX6621_TEMP_S3D0_REG, MAX6621_TEMP_S0D1_REG,
98         MAX6621_TEMP_S1D1_REG, MAX6621_TEMP_S2D1_REG, MAX6621_TEMP_S3D1_REG,
99 };
100
101 static const char *const max6621_temp_labels[] = {
102         "maximum",
103         "socket0_0",
104         "socket1_0",
105         "socket2_0",
106         "socket3_0",
107         "socket0_1",
108         "socket1_1",
109         "socket2_1",
110         "socket3_1",
111 };
112
113 static const int max6621_temp_alert_chan2reg[] = {
114         MAX6621_TEMP_S0_ALERT_REG,
115         MAX6621_TEMP_S1_ALERT_REG,
116         MAX6621_TEMP_S2_ALERT_REG,
117         MAX6621_TEMP_S3_ALERT_REG,
118 };
119
120 /**
121  * struct max6621_data - private data:
122  *
123  * @client: I2C client;
124  * @regmap: register map handle;
125  * @input_chan2reg: mapping from channel to register;
126  */
127 struct max6621_data {
128         struct i2c_client       *client;
129         struct regmap           *regmap;
130         int                     input_chan2reg[MAX6621_TEMP_INPUT_REG_NUM + 1];
131 };
132
133 static long max6621_temp_mc2reg(long val)
134 {
135         return (val / 1000L) << MAX6621_REG_TEMP_SHIFT;
136 }
137
138 static umode_t
139 max6621_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
140                    int channel)
141 {
142         /* Skip channels which are not physically conncted. */
143         if (((struct max6621_data *)data)->input_chan2reg[channel] < 0)
144                 return 0;
145
146         switch (type) {
147         case hwmon_temp:
148                 switch (attr) {
149                 case hwmon_temp_input:
150                 case hwmon_temp_label:
151                 case hwmon_temp_crit_alarm:
152                         return 0444;
153                 case hwmon_temp_offset:
154                 case hwmon_temp_crit:
155                         return 0644;
156                 default:
157                         break;
158                 }
159
160         default:
161                 break;
162         }
163
164         return 0;
165 }
166
167 static int max6621_verify_reg_data(struct device *dev, int regval)
168 {
169         if (regval >= MAX6621_PECI_ERR_MIN &&
170             regval <= MAX6621_PECI_ERR_MAX) {
171                 dev_dbg(dev, "PECI error code - err 0x%04x.\n",
172                         regval);
173
174                 return -EIO;
175         }
176
177         switch (regval) {
178         case MAX6621_TRAN_FAILED:
179                 dev_dbg(dev, "PECI transaction failed - err 0x%04x.\n",
180                         regval);
181                 return -EIO;
182         case MAX6621_POOL_DIS:
183                 dev_dbg(dev, "Polling disabled - err 0x%04x.\n", regval);
184                 return -EOPNOTSUPP;
185         case MAX6621_POOL_UNCOMPLETE:
186                 dev_dbg(dev, "First poll not completed on startup - err 0x%04x.\n",
187                         regval);
188                 return -EIO;
189         case MAX6621_SD_DIS:
190                 dev_dbg(dev, "Resource is disabled - err 0x%04x.\n", regval);
191                 return -EOPNOTSUPP;
192         case MAX6621_ALERT_DIS:
193                 dev_dbg(dev, "No alert active - err 0x%04x.\n", regval);
194                 return -EOPNOTSUPP;
195         default:
196                 return 0;
197         }
198 }
199
200 static int
201 max6621_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
202              int channel, long *val)
203 {
204         struct max6621_data *data = dev_get_drvdata(dev);
205         u32 regval;
206         int reg;
207         s8 temp;
208         int ret;
209
210         switch (type) {
211         case hwmon_temp:
212                 switch (attr) {
213                 case hwmon_temp_input:
214                         reg = data->input_chan2reg[channel];
215                         ret = regmap_read(data->regmap, reg, &regval);
216                         if (ret)
217                                 return ret;
218
219                         ret = max6621_verify_reg_data(dev, regval);
220                         if (ret)
221                                 return ret;
222
223                         /*
224                          * Bit MAX6621_REG_TEMP_SHIFT represents 1 degree step.
225                          * The temperature is given in two's complement and 8
226                          * bits is used for the register conversion.
227                          */
228                         temp = (regval >> MAX6621_REG_TEMP_SHIFT);
229                         *val = temp * 1000L;
230
231                         break;
232                 case hwmon_temp_offset:
233                         ret = regmap_read(data->regmap, MAX6621_CONFIG2_REG,
234                                           &regval);
235                         if (ret)
236                                 return ret;
237
238                         ret = max6621_verify_reg_data(dev, regval);
239                         if (ret)
240                                 return ret;
241
242                         *val = (regval >> MAX6621_REG_TEMP_SHIFT) *
243                                1000L;
244
245                         break;
246                 case hwmon_temp_crit:
247                         channel -= MAX6621_TEMP_ALERT_CHAN_SHIFT;
248                         reg = max6621_temp_alert_chan2reg[channel];
249                         ret = regmap_read(data->regmap, reg, &regval);
250                         if (ret)
251                                 return ret;
252
253                         ret = max6621_verify_reg_data(dev, regval);
254                         if (ret)
255                                 return ret;
256
257                         *val = regval * 1000L;
258
259                         break;
260                 case hwmon_temp_crit_alarm:
261                         /*
262                          * Set val to zero to recover the case, when reading
263                          * MAX6621_TEMP_ALERT_CAUSE_REG results in for example
264                          * MAX6621_ALERT_DIS. Reading will return with error,
265                          * but in such case alarm should be returned as 0.
266                          */
267                         *val = 0;
268                         ret = regmap_read(data->regmap,
269                                           MAX6621_TEMP_ALERT_CAUSE_REG,
270                                           &regval);
271                         if (ret)
272                                 return ret;
273
274                         ret = max6621_verify_reg_data(dev, regval);
275                         if (ret) {
276                                 /* Do not report error if alert is disabled. */
277                                 if (regval == MAX6621_ALERT_DIS)
278                                         return 0;
279                                 else
280                                         return ret;
281                         }
282
283                         /*
284                          * Clear the alert automatically, using send-byte
285                          * smbus protocol for clearing alert.
286                          */
287                         if (regval) {
288                                 ret = i2c_smbus_write_byte(data->client,
289                                                 MAX6621_CLEAR_ALERT_REG);
290                                 if (ret)
291                                         return ret;
292                         }
293
294                         *val = !!regval;
295
296                         break;
297                 default:
298                         return -EOPNOTSUPP;
299                 }
300                 break;
301
302         default:
303                 return -EOPNOTSUPP;
304         }
305
306         return 0;
307 }
308
309 static int
310 max6621_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
311               int channel, long val)
312 {
313         struct max6621_data *data = dev_get_drvdata(dev);
314         u32 reg;
315
316         switch (type) {
317         case hwmon_temp:
318                 switch (attr) {
319                 case hwmon_temp_offset:
320                         /* Clamp to allowed range to prevent overflow. */
321                         val = clamp_val(val, MAX6621_TEMP_INPUT_MIN,
322                                         MAX6621_TEMP_INPUT_MAX);
323                         val = max6621_temp_mc2reg(val);
324
325                         return regmap_write(data->regmap,
326                                             MAX6621_CONFIG2_REG, val);
327                 case hwmon_temp_crit:
328                         channel -= MAX6621_TEMP_ALERT_CHAN_SHIFT;
329                         reg = max6621_temp_alert_chan2reg[channel];
330                         /* Clamp to allowed range to prevent overflow. */
331                         val = clamp_val(val, MAX6621_TEMP_INPUT_MIN,
332                                         MAX6621_TEMP_INPUT_MAX);
333                         val = val / 1000L;
334
335                         return regmap_write(data->regmap, reg, val);
336                 default:
337                         return -EOPNOTSUPP;
338                 }
339                 break;
340
341         default:
342                 return -EOPNOTSUPP;
343         }
344
345         return -EOPNOTSUPP;
346 }
347
348 static int
349 max6621_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
350                     int channel, const char **str)
351 {
352         switch (type) {
353         case hwmon_temp:
354                 switch (attr) {
355                 case hwmon_temp_label:
356                         *str = max6621_temp_labels[channel];
357                         return 0;
358                 default:
359                         return -EOPNOTSUPP;
360                 }
361                 break;
362         default:
363                 return -EOPNOTSUPP;
364         }
365
366         return -EOPNOTSUPP;
367 }
368
369 static bool max6621_writeable_reg(struct device *dev, unsigned int reg)
370 {
371         switch (reg) {
372         case MAX6621_CONFIG0_REG:
373         case MAX6621_CONFIG1_REG:
374         case MAX6621_CONFIG2_REG:
375         case MAX6621_CONFIG3_REG:
376         case MAX6621_TEMP_S0_ALERT_REG:
377         case MAX6621_TEMP_S1_ALERT_REG:
378         case MAX6621_TEMP_S2_ALERT_REG:
379         case MAX6621_TEMP_S3_ALERT_REG:
380         case MAX6621_TEMP_ALERT_CAUSE_REG:
381                 return true;
382         }
383         return false;
384 }
385
386 static bool max6621_readable_reg(struct device *dev, unsigned int reg)
387 {
388         switch (reg) {
389         case MAX6621_TEMP_S0D0_REG:
390         case MAX6621_TEMP_S0D1_REG:
391         case MAX6621_TEMP_S1D0_REG:
392         case MAX6621_TEMP_S1D1_REG:
393         case MAX6621_TEMP_S2D0_REG:
394         case MAX6621_TEMP_S2D1_REG:
395         case MAX6621_TEMP_S3D0_REG:
396         case MAX6621_TEMP_S3D1_REG:
397         case MAX6621_TEMP_MAX_REG:
398         case MAX6621_TEMP_MAX_ADDR_REG:
399         case MAX6621_CONFIG0_REG:
400         case MAX6621_CONFIG1_REG:
401         case MAX6621_CONFIG2_REG:
402         case MAX6621_CONFIG3_REG:
403         case MAX6621_TEMP_S0_ALERT_REG:
404         case MAX6621_TEMP_S1_ALERT_REG:
405         case MAX6621_TEMP_S2_ALERT_REG:
406         case MAX6621_TEMP_S3_ALERT_REG:
407                 return true;
408         }
409         return false;
410 }
411
412 static bool max6621_volatile_reg(struct device *dev, unsigned int reg)
413 {
414         switch (reg) {
415         case MAX6621_TEMP_S0D0_REG:
416         case MAX6621_TEMP_S0D1_REG:
417         case MAX6621_TEMP_S1D0_REG:
418         case MAX6621_TEMP_S1D1_REG:
419         case MAX6621_TEMP_S2D0_REG:
420         case MAX6621_TEMP_S2D1_REG:
421         case MAX6621_TEMP_S3D0_REG:
422         case MAX6621_TEMP_S3D1_REG:
423         case MAX6621_TEMP_MAX_REG:
424         case MAX6621_TEMP_S0_ALERT_REG:
425         case MAX6621_TEMP_S1_ALERT_REG:
426         case MAX6621_TEMP_S2_ALERT_REG:
427         case MAX6621_TEMP_S3_ALERT_REG:
428         case MAX6621_TEMP_ALERT_CAUSE_REG:
429                 return true;
430         }
431         return false;
432 }
433
434 static const struct reg_default max6621_regmap_default[] = {
435         { MAX6621_CONFIG0_REG, MAX6621_CONFIG0_INIT },
436         { MAX6621_CONFIG1_REG, MAX6621_CONFIG1_INIT },
437 };
438
439 static const struct regmap_config max6621_regmap_config = {
440         .reg_bits = 8,
441         .val_bits = 16,
442         .max_register = MAX6621_REG_MAX,
443         .val_format_endian = REGMAP_ENDIAN_LITTLE,
444         .cache_type = REGCACHE_FLAT,
445         .writeable_reg = max6621_writeable_reg,
446         .readable_reg = max6621_readable_reg,
447         .volatile_reg = max6621_volatile_reg,
448         .reg_defaults = max6621_regmap_default,
449         .num_reg_defaults = ARRAY_SIZE(max6621_regmap_default),
450 };
451
452 static const struct hwmon_channel_info *max6621_info[] = {
453         HWMON_CHANNEL_INFO(chip,
454                            HWMON_C_REGISTER_TZ),
455         HWMON_CHANNEL_INFO(temp,
456                            HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
457                            HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_LABEL,
458                            HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_LABEL,
459                            HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_LABEL,
460                            HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_ALARM | HWMON_T_LABEL,
461                            HWMON_T_INPUT | HWMON_T_LABEL,
462                            HWMON_T_INPUT | HWMON_T_LABEL,
463                            HWMON_T_INPUT | HWMON_T_LABEL,
464                            HWMON_T_INPUT | HWMON_T_LABEL),
465         NULL
466 };
467
468 static const struct hwmon_ops max6621_hwmon_ops = {
469         .read = max6621_read,
470         .write = max6621_write,
471         .read_string = max6621_read_string,
472         .is_visible = max6621_is_visible,
473 };
474
475 static const struct hwmon_chip_info max6621_chip_info = {
476         .ops = &max6621_hwmon_ops,
477         .info = max6621_info,
478 };
479
480 static int max6621_probe(struct i2c_client *client,
481                          const struct i2c_device_id *id)
482 {
483         struct device *dev = &client->dev;
484         struct max6621_data *data;
485         struct device *hwmon_dev;
486         int i;
487         int ret;
488
489         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
490         if (!data)
491                 return -ENOMEM;
492
493         data->regmap = devm_regmap_init_i2c(client, &max6621_regmap_config);
494         if (IS_ERR(data->regmap))
495                 return PTR_ERR(data->regmap);
496
497         i2c_set_clientdata(client, data);
498         data->client = client;
499
500         /* Set CONFIG0 register masking temperature alerts and PEC. */
501         ret = regmap_write(data->regmap, MAX6621_CONFIG0_REG,
502                            MAX6621_CONFIG0_INIT);
503         if (ret)
504                 return ret;
505
506         /* Set CONFIG1 register for PEC access retry number. */
507         ret = regmap_write(data->regmap, MAX6621_CONFIG1_REG,
508                            MAX6621_CONFIG1_INIT);
509         if (ret)
510                 return ret;
511
512         /* Sync registers with hardware. */
513         regcache_mark_dirty(data->regmap);
514         ret = regcache_sync(data->regmap);
515         if (ret)
516                 return ret;
517
518         /* Verify which temperature input registers are enabled. */
519         for (i = 0; i < MAX6621_TEMP_INPUT_REG_NUM; i++) {
520                 ret = i2c_smbus_read_word_data(client, max6621_temp_regs[i]);
521                 if (ret < 0)
522                         return ret;
523                 ret = max6621_verify_reg_data(dev, ret);
524                 if (ret) {
525                         data->input_chan2reg[i] = -1;
526                         continue;
527                 }
528
529                 data->input_chan2reg[i] = max6621_temp_regs[i];
530         }
531
532         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
533                                                          data,
534                                                          &max6621_chip_info,
535                                                          NULL);
536
537         return PTR_ERR_OR_ZERO(hwmon_dev);
538 }
539
540 static const struct i2c_device_id max6621_id[] = {
541         { MAX6621_DRV_NAME, 0 },
542         { }
543 };
544 MODULE_DEVICE_TABLE(i2c, max6621_id);
545
546 static const struct of_device_id __maybe_unused max6621_of_match[] = {
547         { .compatible = "maxim,max6621" },
548         { }
549 };
550 MODULE_DEVICE_TABLE(of, max6621_of_match);
551
552 static struct i2c_driver max6621_driver = {
553         .class          = I2C_CLASS_HWMON,
554         .driver = {
555                 .name = MAX6621_DRV_NAME,
556                 .of_match_table = of_match_ptr(max6621_of_match),
557         },
558         .probe          = max6621_probe,
559         .id_table       = max6621_id,
560 };
561
562 module_i2c_driver(max6621_driver);
563
564 MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>");
565 MODULE_DESCRIPTION("Driver for Maxim MAX6621");
566 MODULE_LICENSE("GPL");