hwmon/pmbus/adm1266.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * ADM1266 - Cascadable Super Sequencer with Margin
0004  * Control and Fault Recording
0005  *
0006  * Copyright 2020 Analog Devices Inc.
0007  */
0008
0009 #include <linux/bitfield.h>
0010 #include <linux/crc8.h>
0011 #include <linux/debugfs.h>
0012 #include <linux/gpio/driver.h>
0013 #include <linux/i2c.h>
0014 #include <linux/i2c-smbus.h>
0015 #include <linux/init.h>
0016 #include <linux/kernel.h>
0017 #include <linux/module.h>
0018 #include <linux/nvmem-consumer.h>
0019 #include <linux/nvmem-provider.h>
0020 #include "pmbus.h"
0021 #include <linux/slab.h>
0022 #include <linux/timekeeping.h>
0023
0024 #define ADM1266_BLACKBOX_CONFIG 0xD3
0025 #define ADM1266_PDIO_CONFIG 0xD4
0026 #define ADM1266_READ_STATE  0xD9
0027 #define ADM1266_READ_BLACKBOX   0xDE
0028 #define ADM1266_SET_RTC     0xDF
0029 #define ADM1266_GPIO_CONFIG 0xE1
0030 #define ADM1266_BLACKBOX_INFO   0xE6
0031 #define ADM1266_PDIO_STATUS 0xE9
0032 #define ADM1266_GPIO_STATUS 0xEA
0033
0034 /* ADM1266 GPIO defines */
0035 #define ADM1266_GPIO_NR         9
0036 #define ADM1266_GPIO_FUNCTIONS(x)   FIELD_GET(BIT(0), x)
0037 #define ADM1266_GPIO_INPUT_EN(x)    FIELD_GET(BIT(2), x)
0038 #define ADM1266_GPIO_OUTPUT_EN(x)   FIELD_GET(BIT(3), x)
0039 #define ADM1266_GPIO_OPEN_DRAIN(x)  FIELD_GET(BIT(4), x)
0040
0041 /* ADM1266 PDIO defines */
0042 #define ADM1266_PDIO_NR         16
0043 #define ADM1266_PDIO_PIN_CFG(x)     FIELD_GET(GENMASK(15, 13), x)
0044 #define ADM1266_PDIO_GLITCH_FILT(x) FIELD_GET(GENMASK(12, 9), x)
0045 #define ADM1266_PDIO_OUT_CFG(x)     FIELD_GET(GENMASK(2, 0), x)
0046
0047 #define ADM1266_BLACKBOX_OFFSET     0
0048 #define ADM1266_BLACKBOX_SIZE       64
0049
0050 #define ADM1266_PMBUS_BLOCK_MAX     255
0051
0052 struct adm1266_data {
0053     struct pmbus_driver_info info;
0054     struct gpio_chip gc;
0055     const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
0056     struct i2c_client *client;
0057     struct dentry *debugfs_dir;
0058     struct nvmem_config nvmem_config;
0059     struct nvmem_device *nvmem;
0060     u8 *dev_mem;
0061     struct mutex buf_mutex;
0062     u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned;
0063     u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned;
0064 };
0065
0066 static const struct nvmem_cell_info adm1266_nvmem_cells[] = {
0067     {
0068         .name           = "blackbox",
0069         .offset         = ADM1266_BLACKBOX_OFFSET,
0070         .bytes          = 2048,
0071     },
0072 };
0073
0074 DECLARE_CRC8_TABLE(pmbus_crc_table);
0075
0076 /*
0077  * Different from Block Read as it sends data and waits for the slave to
0078  * return a value dependent on that data. The protocol is simply a Write Block
0079  * followed by a Read Block without the Read-Block command field and the
0080  * Write-Block STOP bit.
0081  */
0082 static int adm1266_pmbus_block_xfer(struct adm1266_data *data, u8 cmd, u8 w_len, u8 *data_w,
0083                     u8 *data_r)
0084 {
0085     struct i2c_client *client = data->client;
0086     struct i2c_msg msgs[2] = {
0087         {
0088             .addr = client->addr,
0089             .flags = I2C_M_DMA_SAFE,
0090             .buf = data->write_buf,
0091             .len = w_len + 2,
0092         },
0093         {
0094             .addr = client->addr,
0095             .flags = I2C_M_RD | I2C_M_DMA_SAFE,
0096             .buf = data->read_buf,
0097             .len = ADM1266_PMBUS_BLOCK_MAX + 2,
0098         }
0099     };
0100     u8 addr;
0101     u8 crc;
0102     int ret;
0103
0104     mutex_lock(&data->buf_mutex);
0105
0106     msgs[0].buf[0] = cmd;
0107     msgs[0].buf[1] = w_len;
0108     memcpy(&msgs[0].buf[2], data_w, w_len);
0109
0110     ret = i2c_transfer(client->adapter, msgs, 2);
0111     if (ret != 2) {
0112         if (ret >= 0)
0113             ret = -EPROTO;
0114
0115         mutex_unlock(&data->buf_mutex);
0116
0117         return ret;
0118     }
0119
0120     if (client->flags & I2C_CLIENT_PEC) {
0121         addr = i2c_8bit_addr_from_msg(&msgs[0]);
0122         crc = crc8(pmbus_crc_table, &addr, 1, 0);
0123         crc = crc8(pmbus_crc_table, msgs[0].buf,  msgs[0].len, crc);
0124
0125         addr = i2c_8bit_addr_from_msg(&msgs[1]);
0126         crc = crc8(pmbus_crc_table, &addr, 1, crc);
0127         crc = crc8(pmbus_crc_table, msgs[1].buf,  msgs[1].buf[0] + 1, crc);
0128
0129         if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) {
0130             mutex_unlock(&data->buf_mutex);
0131             return -EBADMSG;
0132         }
0133     }
0134
0135     memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]);
0136
0137     ret = msgs[1].buf[0];
0138     mutex_unlock(&data->buf_mutex);
0139
0140     return ret;
0141 }
0142
0143 static const unsigned int adm1266_gpio_mapping[ADM1266_GPIO_NR][2] = {
0144     {1, 0},
0145     {2, 1},
0146     {3, 2},
0147     {4, 8},
0148     {5, 9},
0149     {6, 10},
0150     {7, 11},
0151     {8, 6},
0152     {9, 7},
0153 };
0154
0155 static const char *adm1266_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR] = {
0156     "GPIO1", "GPIO2", "GPIO3", "GPIO4", "GPIO5", "GPIO6", "GPIO7", "GPIO8",
0157     "GPIO9", "PDIO1", "PDIO2", "PDIO3", "PDIO4", "PDIO5", "PDIO6",
0158     "PDIO7", "PDIO8", "PDIO9", "PDIO10", "PDIO11", "PDIO12", "PDIO13",
0159     "PDIO14", "PDIO15", "PDIO16",
0160 };
0161
0162 static int adm1266_gpio_get(struct gpio_chip *chip, unsigned int offset)
0163 {
0164     struct adm1266_data *data = gpiochip_get_data(chip);
0165     u8 read_buf[I2C_SMBUS_BLOCK_MAX + 1];
0166     unsigned long pins_status;
0167     unsigned int pmbus_cmd;
0168     int ret;
0169
0170     if (offset < ADM1266_GPIO_NR)
0171         pmbus_cmd = ADM1266_GPIO_STATUS;
0172     else
0173         pmbus_cmd = ADM1266_PDIO_STATUS;
0174
0175     ret = i2c_smbus_read_block_data(data->client, pmbus_cmd, read_buf);
0176     if (ret < 0)
0177         return ret;
0178
0179     pins_status = read_buf[0] + (read_buf[1] << 8);
0180     if (offset < ADM1266_GPIO_NR)
0181         return test_bit(adm1266_gpio_mapping[offset][1], &pins_status);
0182
0183     return test_bit(offset - ADM1266_GPIO_NR, &pins_status);
0184 }
0185
0186 static int adm1266_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask,
0187                      unsigned long *bits)
0188 {
0189     struct adm1266_data *data = gpiochip_get_data(chip);
0190     u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1];
0191     unsigned long status;
0192     unsigned int gpio_nr;
0193     int ret;
0194
0195     ret = i2c_smbus_read_block_data(data->client, ADM1266_GPIO_STATUS, read_buf);
0196     if (ret < 0)
0197         return ret;
0198
0199     status = read_buf[0] + (read_buf[1] << 8);
0200
0201     *bits = 0;
0202     for_each_set_bit(gpio_nr, mask, ADM1266_GPIO_NR) {
0203         if (test_bit(adm1266_gpio_mapping[gpio_nr][1], &status))
0204             set_bit(gpio_nr, bits);
0205     }
0206
0207     ret = i2c_smbus_read_block_data(data->client, ADM1266_PDIO_STATUS, read_buf);
0208     if (ret < 0)
0209         return ret;
0210
0211     status = read_buf[0] + (read_buf[1] << 8);
0212
0213     *bits = 0;
0214     for_each_set_bit_from(gpio_nr, mask, ADM1266_GPIO_NR + ADM1266_PDIO_STATUS) {
0215         if (test_bit(gpio_nr - ADM1266_GPIO_NR, &status))
0216             set_bit(gpio_nr, bits);
0217     }
0218
0219     return 0;
0220 }
0221
0222 static void adm1266_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
0223 {
0224     struct adm1266_data *data = gpiochip_get_data(chip);
0225     u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1];
0226     unsigned long gpio_config;
0227     unsigned long pdio_config;
0228     unsigned long pin_cfg;
0229     u8 write_cmd;
0230     int ret;
0231     int i;
0232
0233     for (i = 0; i < ADM1266_GPIO_NR; i++) {
0234         write_cmd = adm1266_gpio_mapping[i][1];
0235         ret = adm1266_pmbus_block_xfer(data, ADM1266_GPIO_CONFIG, 1, &write_cmd, read_buf);
0236         if (ret != 2)
0237             return;
0238
0239         gpio_config = read_buf[0];
0240         seq_puts(s, adm1266_names[i]);
0241
0242         seq_puts(s, " ( ");
0243         if (!ADM1266_GPIO_FUNCTIONS(gpio_config)) {
0244             seq_puts(s, "high-Z )\n");
0245             continue;
0246         }
0247         if (ADM1266_GPIO_INPUT_EN(gpio_config))
0248             seq_puts(s, "input ");
0249         if (ADM1266_GPIO_OUTPUT_EN(gpio_config))
0250             seq_puts(s, "output ");
0251         if (ADM1266_GPIO_OPEN_DRAIN(gpio_config))
0252             seq_puts(s, "open-drain )\n");
0253         else
0254             seq_puts(s, "push-pull )\n");
0255     }
0256
0257     write_cmd = 0xFF;
0258     ret = adm1266_pmbus_block_xfer(data, ADM1266_PDIO_CONFIG, 1, &write_cmd, read_buf);
0259     if (ret != 32)
0260         return;
0261
0262     for (i = 0; i < ADM1266_PDIO_NR; i++) {
0263         seq_puts(s, adm1266_names[ADM1266_GPIO_NR + i]);
0264
0265         pdio_config = read_buf[2 * i];
0266         pdio_config += (read_buf[2 * i + 1] << 8);
0267         pin_cfg = ADM1266_PDIO_PIN_CFG(pdio_config);
0268
0269         seq_puts(s, " ( ");
0270         if (!pin_cfg || pin_cfg > 5) {
0271             seq_puts(s, "high-Z )\n");
0272             continue;
0273         }
0274
0275         if (pin_cfg & BIT(0))
0276             seq_puts(s, "output ");
0277
0278         if (pin_cfg & BIT(1))
0279             seq_puts(s, "input ");
0280
0281         seq_puts(s, ")\n");
0282     }
0283 }
0284
0285 static int adm1266_config_gpio(struct adm1266_data *data)
0286 {
0287     const char *name = dev_name(&data->client->dev);
0288     char *gpio_name;
0289     int ret;
0290     int i;
0291
0292     for (i = 0; i < ARRAY_SIZE(data->gpio_names); i++) {
0293         gpio_name = devm_kasprintf(&data->client->dev, GFP_KERNEL, "adm1266-%x-%s",
0294                        data->client->addr, adm1266_names[i]);
0295         if (!gpio_name)
0296             return -ENOMEM;
0297
0298         data->gpio_names[i] = gpio_name;
0299     }
0300
0301     data->gc.label = name;
0302     data->gc.parent = &data->client->dev;
0303     data->gc.owner = THIS_MODULE;
0304     data->gc.base = -1;
0305     data->gc.names = data->gpio_names;
0306     data->gc.ngpio = ARRAY_SIZE(data->gpio_names);
0307     data->gc.get = adm1266_gpio_get;
0308     data->gc.get_multiple = adm1266_gpio_get_multiple;
0309     data->gc.dbg_show = adm1266_gpio_dbg_show;
0310
0311     ret = devm_gpiochip_add_data(&data->client->dev, &data->gc, data);
0312     if (ret)
0313         dev_err(&data->client->dev, "GPIO registering failed (%d)\n", ret);
0314
0315     return ret;
0316 }
0317
0318 static int adm1266_state_read(struct seq_file *s, void *pdata)
0319 {
0320     struct device *dev = s->private;
0321     struct i2c_client *client = to_i2c_client(dev);
0322     int ret;
0323
0324     ret = i2c_smbus_read_word_data(client, ADM1266_READ_STATE);
0325     if (ret < 0)
0326         return ret;
0327
0328     seq_printf(s, "%d\n", ret);
0329
0330     return 0;
0331 }
0332
0333 static void adm1266_init_debugfs(struct adm1266_data *data)
0334 {
0335     struct dentry *root;
0336
0337     root = pmbus_get_debugfs_dir(data->client);
0338     if (!root)
0339         return;
0340
0341     data->debugfs_dir = debugfs_create_dir(data->client->name, root);
0342     if (!data->debugfs_dir)
0343         return;
0344
0345     debugfs_create_devm_seqfile(&data->client->dev, "sequencer_state", data->debugfs_dir,
0346                     adm1266_state_read);
0347 }
0348
0349 static int adm1266_nvmem_read_blackbox(struct adm1266_data *data, u8 *read_buff)
0350 {
0351     int record_count;
0352     char index;
0353     u8 buf[5];
0354     int ret;
0355
0356     ret = i2c_smbus_read_block_data(data->client, ADM1266_BLACKBOX_INFO, buf);
0357     if (ret < 0)
0358         return ret;
0359
0360     if (ret != 4)
0361         return -EIO;
0362
0363     record_count = buf[3];
0364
0365     for (index = 0; index < record_count; index++) {
0366         ret = adm1266_pmbus_block_xfer(data, ADM1266_READ_BLACKBOX, 1, &index, read_buff);
0367         if (ret < 0)
0368             return ret;
0369
0370         if (ret != ADM1266_BLACKBOX_SIZE)
0371             return -EIO;
0372
0373         read_buff += ADM1266_BLACKBOX_SIZE;
0374     }
0375
0376     return 0;
0377 }
0378
0379 static int adm1266_nvmem_read(void *priv, unsigned int offset, void *val, size_t bytes)
0380 {
0381     struct adm1266_data *data = priv;
0382     int ret;
0383
0384     if (offset + bytes > data->nvmem_config.size)
0385         return -EINVAL;
0386
0387     if (offset == 0) {
0388         memset(data->dev_mem, 0, data->nvmem_config.size);
0389
0390         ret = adm1266_nvmem_read_blackbox(data, data->dev_mem);
0391         if (ret) {
0392             dev_err(&data->client->dev, "Could not read blackbox!");
0393             return ret;
0394         }
0395     }
0396
0397     memcpy(val, data->dev_mem + offset, bytes);
0398
0399     return 0;
0400 }
0401
0402 static int adm1266_config_nvmem(struct adm1266_data *data)
0403 {
0404     data->nvmem_config.name = dev_name(&data->client->dev);
0405     data->nvmem_config.dev = &data->client->dev;
0406     data->nvmem_config.root_only = true;
0407     data->nvmem_config.read_only = true;
0408     data->nvmem_config.owner = THIS_MODULE;
0409     data->nvmem_config.reg_read = adm1266_nvmem_read;
0410     data->nvmem_config.cells = adm1266_nvmem_cells;
0411     data->nvmem_config.ncells = ARRAY_SIZE(adm1266_nvmem_cells);
0412     data->nvmem_config.priv = data;
0413     data->nvmem_config.stride = 1;
0414     data->nvmem_config.word_size = 1;
0415     data->nvmem_config.size = adm1266_nvmem_cells[0].bytes;
0416
0417     data->dev_mem = devm_kzalloc(&data->client->dev, data->nvmem_config.size, GFP_KERNEL);
0418     if (!data->dev_mem)
0419         return -ENOMEM;
0420
0421     data->nvmem = devm_nvmem_register(&data->client->dev, &data->nvmem_config);
0422     if (IS_ERR(data->nvmem)) {
0423         dev_err(&data->client->dev, "Could not register nvmem!");
0424         return PTR_ERR(data->nvmem);
0425     }
0426
0427     return 0;
0428 }
0429
0430 static int adm1266_set_rtc(struct adm1266_data *data)
0431 {
0432     time64_t kt;
0433     char write_buf[6];
0434     int i;
0435
0436     kt = ktime_get_seconds();
0437
0438     memset(write_buf, 0, sizeof(write_buf));
0439
0440     for (i = 0; i < 4; i++)
0441         write_buf[2 + i] = (kt >> (i * 8)) & 0xFF;
0442
0443     return i2c_smbus_write_block_data(data->client, ADM1266_SET_RTC, sizeof(write_buf),
0444                       write_buf);
0445 }
0446
0447 static int adm1266_probe(struct i2c_client *client)
0448 {
0449     struct adm1266_data *data;
0450     int ret;
0451     int i;
0452
0453     data = devm_kzalloc(&client->dev, sizeof(struct adm1266_data), GFP_KERNEL);
0454     if (!data)
0455         return -ENOMEM;
0456
0457     data->client = client;
0458     data->info.pages = 17;
0459     data->info.format[PSC_VOLTAGE_OUT] = linear;
0460     for (i = 0; i < data->info.pages; i++)
0461         data->info.func[i] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
0462
0463     crc8_populate_msb(pmbus_crc_table, 0x7);
0464     mutex_init(&data->buf_mutex);
0465
0466     ret = adm1266_config_gpio(data);
0467     if (ret < 0)
0468         return ret;
0469
0470     ret = adm1266_set_rtc(data);
0471     if (ret < 0)
0472         return ret;
0473
0474     ret = adm1266_config_nvmem(data);
0475     if (ret < 0)
0476         return ret;
0477
0478     ret = pmbus_do_probe(client, &data->info);
0479     if (ret)
0480         return ret;
0481
0482     adm1266_init_debugfs(data);
0483
0484     return 0;
0485 }
0486
0487 static const struct of_device_id adm1266_of_match[] = {
0488     { .compatible = "adi,adm1266" },
0489     { }
0490 };
0491 MODULE_DEVICE_TABLE(of, adm1266_of_match);
0492
0493 static const struct i2c_device_id adm1266_id[] = {
0494     { "adm1266", 0 },
0495     { }
0496 };
0497 MODULE_DEVICE_TABLE(i2c, adm1266_id);
0498
0499 static struct i2c_driver adm1266_driver = {
0500     .driver = {
0501            .name = "adm1266",
0502            .of_match_table = adm1266_of_match,
0503           },
0504     .probe_new = adm1266_probe,
0505     .id_table = adm1266_id,
0506 };
0507
0508 module_i2c_driver(adm1266_driver);
0509
0510 MODULE_AUTHOR("Alexandru Tachici <alexandru.tachici@analog.com>");
0511 MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1266");
0512 MODULE_LICENSE("GPL v2");
0513 MODULE_IMPORT_NS(PMBUS);