drivers/hwmon/pmbus/max20730.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Driver for MAX20730, MAX20734, and MAX20743 Integrated, Step-Down
   4  * Switching Regulators
   5  *
   6  * Copyright 2019 Google LLC.
   7  */
   8
   9 #include <linux/bits.h>
  10 #include <linux/err.h>
  11 #include <linux/i2c.h>
  12 #include <linux/init.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/mutex.h>
  16 #include <linux/of_device.h>
  17 #include <linux/pmbus.h>
  18 #include <linux/util_macros.h>
  19 #include "pmbus.h"
  20
  21 enum chips {
  22         max20730,
  23         max20734,
  24         max20743
  25 };
  26
  27 struct max20730_data {
  28         enum chips id;
  29         struct pmbus_driver_info info;
  30         struct mutex lock;      /* Used to protect against parallel writes */
  31         u16 mfr_devset1;
  32 };
  33
  34 #define to_max20730_data(x)  container_of(x, struct max20730_data, info)
  35
  36 #define MAX20730_MFR_DEVSET1    0xd2
  37
  38 /*
  39  * Convert discreet value to direct data format. Strictly speaking, all passed
  40  * values are constants, so we could do that calculation manually. On the
  41  * downside, that would make the driver more difficult to maintain, so lets
  42  * use this approach.
  43  */
  44 static u16 val_to_direct(int v, enum pmbus_sensor_classes class,
  45                          const struct pmbus_driver_info *info)
  46 {
  47         int R = info->R[class] - 3;     /* take milli-units into account */
  48         int b = info->b[class] * 1000;
  49         long d;
  50
  51         d = v * info->m[class] + b;
  52         /*
  53          * R < 0 is true for all callers, so we don't need to bother
  54          * about the R > 0 case.
  55          */
  56         while (R < 0) {
  57                 d = DIV_ROUND_CLOSEST(d, 10);
  58                 R++;
  59         }
  60         return (u16)d;
  61 }
  62
  63 static long direct_to_val(u16 w, enum pmbus_sensor_classes class,
  64                           const struct pmbus_driver_info *info)
  65 {
  66         int R = info->R[class] - 3;
  67         int b = info->b[class] * 1000;
  68         int m = info->m[class];
  69         long d = (s16)w;
  70
  71         if (m == 0)
  72                 return 0;
  73
  74         while (R < 0) {
  75                 d *= 10;
  76                 R++;
  77         }
  78         d = (d - b) / m;
  79         return d;
  80 }
  81
  82 static u32 max_current[][5] = {
  83         [max20730] = { 13000, 16600, 20100, 23600 },
  84         [max20734] = { 21000, 27000, 32000, 38000 },
  85         [max20743] = { 18900, 24100, 29200, 34100 },
  86 };
  87
  88 static int max20730_read_word_data(struct i2c_client *client, int page, int reg)
  89 {
  90         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
  91         const struct max20730_data *data = to_max20730_data(info);
  92         int ret = 0;
  93         u32 max_c;
  94
  95         switch (reg) {
  96         case PMBUS_OT_FAULT_LIMIT:
  97                 switch ((data->mfr_devset1 >> 11) & 0x3) {
  98                 case 0x0:
  99                         ret = val_to_direct(150000, PSC_TEMPERATURE, info);
 100                         break;
 101                 case 0x1:
 102                         ret = val_to_direct(130000, PSC_TEMPERATURE, info);
 103                         break;
 104                 default:
 105                         ret = -ENODATA;
 106                         break;
 107                 }
 108                 break;
 109         case PMBUS_IOUT_OC_FAULT_LIMIT:
 110                 max_c = max_current[data->id][(data->mfr_devset1 >> 5) & 0x3];
 111                 ret = val_to_direct(max_c, PSC_CURRENT_OUT, info);
 112                 break;
 113         default:
 114                 ret = -ENODATA;
 115                 break;
 116         }
 117         return ret;
 118 }
 119
 120 static int max20730_write_word_data(struct i2c_client *client, int page,
 121                                     int reg, u16 word)
 122 {
 123         struct pmbus_driver_info *info;
 124         struct max20730_data *data;
 125         u16 devset1;
 126         int ret = 0;
 127         int idx;
 128
 129         info = (struct pmbus_driver_info *)pmbus_get_driver_info(client);
 130         data = to_max20730_data(info);
 131
 132         mutex_lock(&data->lock);
 133         devset1 = data->mfr_devset1;
 134
 135         switch (reg) {
 136         case PMBUS_OT_FAULT_LIMIT:
 137                 devset1 &= ~(BIT(11) | BIT(12));
 138                 if (direct_to_val(word, PSC_TEMPERATURE, info) < 140000)
 139                         devset1 |= BIT(11);
 140                 break;
 141         case PMBUS_IOUT_OC_FAULT_LIMIT:
 142                 devset1 &= ~(BIT(5) | BIT(6));
 143
 144                 idx = find_closest(direct_to_val(word, PSC_CURRENT_OUT, info),
 145                                    max_current[data->id], 4);
 146                 devset1 |= (idx << 5);
 147                 break;
 148         default:
 149                 ret = -ENODATA;
 150                 break;
 151         }
 152
 153         if (!ret && devset1 != data->mfr_devset1) {
 154                 ret = i2c_smbus_write_word_data(client, MAX20730_MFR_DEVSET1,
 155                                                 devset1);
 156                 if (!ret) {
 157                         data->mfr_devset1 = devset1;
 158                         pmbus_clear_cache(client);
 159                 }
 160         }
 161         mutex_unlock(&data->lock);
 162         return ret;
 163 }
 164
 165 static const struct pmbus_driver_info max20730_info[] = {
 166         [max20730] = {
 167                 .pages = 1,
 168                 .read_word_data = max20730_read_word_data,
 169                 .write_word_data = max20730_write_word_data,
 170
 171                 /* Source : Maxim AN6042 */
 172                 .format[PSC_TEMPERATURE] = direct,
 173                 .m[PSC_TEMPERATURE] = 21,
 174                 .b[PSC_TEMPERATURE] = 5887,
 175                 .R[PSC_TEMPERATURE] = -1,
 176
 177                 .format[PSC_VOLTAGE_IN] = direct,
 178                 .m[PSC_VOLTAGE_IN] = 3609,
 179                 .b[PSC_VOLTAGE_IN] = 0,
 180                 .R[PSC_VOLTAGE_IN] = -2,
 181
 182                 /*
 183                  * Values in the datasheet are adjusted for temperature and
 184                  * for the relationship between Vin and Vout.
 185                  * Unfortunately, the data sheet suggests that Vout measurement
 186                  * may be scaled with a resistor array. This is indeed the case
 187                  * at least on the evaulation boards. As a result, any in-driver
 188                  * adjustments would either be wrong or require elaborate means
 189                  * to configure the scaling. Instead of doing that, just report
 190                  * raw values and let userspace handle adjustments.
 191                  */
 192                 .format[PSC_CURRENT_OUT] = direct,
 193                 .m[PSC_CURRENT_OUT] = 153,
 194                 .b[PSC_CURRENT_OUT] = 4976,
 195                 .R[PSC_CURRENT_OUT] = -1,
 196
 197                 .format[PSC_VOLTAGE_OUT] = linear,
 198
 199                 .func[0] = PMBUS_HAVE_VIN |
 200                         PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 201                         PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 202                         PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
 203         },
 204         [max20734] = {
 205                 .pages = 1,
 206                 .read_word_data = max20730_read_word_data,
 207                 .write_word_data = max20730_write_word_data,
 208
 209                 /* Source : Maxim AN6209 */
 210                 .format[PSC_TEMPERATURE] = direct,
 211                 .m[PSC_TEMPERATURE] = 21,
 212                 .b[PSC_TEMPERATURE] = 5887,
 213                 .R[PSC_TEMPERATURE] = -1,
 214
 215                 .format[PSC_VOLTAGE_IN] = direct,
 216                 .m[PSC_VOLTAGE_IN] = 3592,
 217                 .b[PSC_VOLTAGE_IN] = 0,
 218                 .R[PSC_VOLTAGE_IN] = -2,
 219
 220                 .format[PSC_CURRENT_OUT] = direct,
 221                 .m[PSC_CURRENT_OUT] = 111,
 222                 .b[PSC_CURRENT_OUT] = 3461,
 223                 .R[PSC_CURRENT_OUT] = -1,
 224
 225                 .format[PSC_VOLTAGE_OUT] = linear,
 226
 227                 .func[0] = PMBUS_HAVE_VIN |
 228                         PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 229                         PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 230                         PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
 231         },
 232         [max20743] = {
 233                 .pages = 1,
 234                 .read_word_data = max20730_read_word_data,
 235                 .write_word_data = max20730_write_word_data,
 236
 237                 /* Source : Maxim AN6042 */
 238                 .format[PSC_TEMPERATURE] = direct,
 239                 .m[PSC_TEMPERATURE] = 21,
 240                 .b[PSC_TEMPERATURE] = 5887,
 241                 .R[PSC_TEMPERATURE] = -1,
 242
 243                 .format[PSC_VOLTAGE_IN] = direct,
 244                 .m[PSC_VOLTAGE_IN] = 3597,
 245                 .b[PSC_VOLTAGE_IN] = 0,
 246                 .R[PSC_VOLTAGE_IN] = -2,
 247
 248                 .format[PSC_CURRENT_OUT] = direct,
 249                 .m[PSC_CURRENT_OUT] = 95,
 250                 .b[PSC_CURRENT_OUT] = 5014,
 251                 .R[PSC_CURRENT_OUT] = -1,
 252
 253                 .format[PSC_VOLTAGE_OUT] = linear,
 254
 255                 .func[0] = PMBUS_HAVE_VIN |
 256                         PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
 257                         PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
 258                         PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
 259         },
 260 };
 261
 262 static int max20730_probe(struct i2c_client *client,
 263                           const struct i2c_device_id *id)
 264 {
 265         struct device *dev = &client->dev;
 266         u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
 267         struct max20730_data *data;
 268         enum chips chip_id;
 269         int ret;
 270
 271         if (!i2c_check_functionality(client->adapter,
 272                                      I2C_FUNC_SMBUS_READ_BYTE_DATA |
 273                                      I2C_FUNC_SMBUS_READ_WORD_DATA |
 274                                      I2C_FUNC_SMBUS_BLOCK_DATA))
 275                 return -ENODEV;
 276
 277         ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
 278         if (ret < 0) {
 279                 dev_err(&client->dev, "Failed to read Manufacturer ID\n");
 280                 return ret;
 281         }
 282         if (ret != 5 || strncmp(buf, "MAXIM", 5)) {
 283                 buf[ret] = '\0';
 284                 dev_err(dev, "Unsupported Manufacturer ID '%s'\n", buf);
 285                 return -ENODEV;
 286         }
 287
 288         /*
 289          * The chips support reading PMBUS_MFR_MODEL. On both MAX20730
 290          * and MAX20734, reading it returns M20743. Presumably that is
 291          * the reason why the command is not documented. Unfortunately,
 292          * that means that there is no reliable means to detect the chip.
 293          * However, we can at least detect the chip series. Compare
 294          * the returned value against 'M20743' and bail out if there is
 295          * a mismatch. If that doesn't work for all chips, we may have
 296          * to remove this check.
 297          */
 298         ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
 299         if (ret < 0) {
 300                 dev_err(dev, "Failed to read Manufacturer Model\n");
 301                 return ret;
 302         }
 303         if (ret != 6 || strncmp(buf, "M20743", 6)) {
 304                 buf[ret] = '\0';
 305                 dev_err(dev, "Unsupported Manufacturer Model '%s'\n", buf);
 306                 return -ENODEV;
 307         }
 308
 309         ret = i2c_smbus_read_block_data(client, PMBUS_MFR_REVISION, buf);
 310         if (ret < 0) {
 311                 dev_err(dev, "Failed to read Manufacturer Revision\n");
 312                 return ret;
 313         }
 314         if (ret != 1 || buf[0] != 'F') {
 315                 buf[ret] = '\0';
 316                 dev_err(dev, "Unsupported Manufacturer Revision '%s'\n", buf);
 317                 return -ENODEV;
 318         }
 319
 320         if (client->dev.of_node)
 321                 chip_id = (enum chips)of_device_get_match_data(dev);
 322         else
 323                 chip_id = id->driver_data;
 324
 325         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 326         if (!data)
 327                 return -ENOMEM;
 328         data->id = chip_id;
 329         mutex_init(&data->lock);
 330         memcpy(&data->info, &max20730_info[chip_id], sizeof(data->info));
 331
 332         ret = i2c_smbus_read_word_data(client, MAX20730_MFR_DEVSET1);
 333         if (ret < 0)
 334                 return ret;
 335         data->mfr_devset1 = ret;
 336
 337         return pmbus_do_probe(client, id, &data->info);
 338 }
 339
 340 static const struct i2c_device_id max20730_id[] = {
 341         { "max20730", max20730 },
 342         { "max20734", max20734 },
 343         { "max20743", max20743 },
 344         { },
 345 };
 346
 347 MODULE_DEVICE_TABLE(i2c, max20730_id);
 348
 349 static const struct of_device_id max20730_of_match[] = {
 350         { .compatible = "maxim,max20730", .data = (void *)max20730 },
 351         { .compatible = "maxim,max20734", .data = (void *)max20734 },
 352         { .compatible = "maxim,max20743", .data = (void *)max20743 },
 353         { },
 354 };
 355
 356 MODULE_DEVICE_TABLE(of, max20730_of_match);
 357
 358 static struct i2c_driver max20730_driver = {
 359         .driver = {
 360                 .name = "max20730",
 361                 .of_match_table = max20730_of_match,
 362         },
 363         .probe = max20730_probe,
 364         .remove = pmbus_do_remove,
 365         .id_table = max20730_id,
 366 };
 367
 368 module_i2c_driver(max20730_driver);
 369
 370 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
 371 MODULE_DESCRIPTION("PMBus driver for Maxim MAX20730 / MAX20734 / MAX20743");
 372 MODULE_LICENSE("GPL");