1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ADM1266 - Cascadable Super Sequencer with Margin 4 * Control and Fault Recording 5 * 6 * Copyright 2020 Analog Devices Inc. 7 */ 8 9 #include <linux/bitfield.h> 10 #include <linux/crc8.h> 11 #include <linux/debugfs.h> 12 #include <linux/gpio/driver.h> 13 #include <linux/i2c.h> 14 #include <linux/i2c-smbus.h> 15 #include <linux/init.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/nvmem-consumer.h> 19 #include <linux/nvmem-provider.h> 20 #include "pmbus.h" 21 #include <linux/slab.h> 22 #include <linux/timekeeping.h> 23 24 #define ADM1266_IC_DEVICE_REV 0xAE 25 #define ADM1266_BLACKBOX_CONFIG 0xD3 26 #define ADM1266_PDIO_CONFIG 0xD4 27 #define ADM1266_READ_STATE 0xD9 28 #define ADM1266_READ_BLACKBOX 0xDE 29 #define ADM1266_SET_RTC 0xDF 30 #define ADM1266_GPIO_CONFIG 0xE1 31 #define ADM1266_POWERUP_COUNTER 0xE4 32 #define ADM1266_BLACKBOX_INFO 0xE6 33 #define ADM1266_PDIO_STATUS 0xE9 34 #define ADM1266_GPIO_STATUS 0xEA 35 36 /* ADM1266 GPIO defines */ 37 #define ADM1266_GPIO_NR 9 38 #define ADM1266_GPIO_FUNCTIONS(x) FIELD_GET(BIT(0), x) 39 #define ADM1266_GPIO_INPUT_EN(x) FIELD_GET(BIT(2), x) 40 #define ADM1266_GPIO_OUTPUT_EN(x) FIELD_GET(BIT(3), x) 41 #define ADM1266_GPIO_OPEN_DRAIN(x) FIELD_GET(BIT(4), x) 42 43 /* ADM1266 PDIO defines */ 44 #define ADM1266_PDIO_NR 16 45 #define ADM1266_PDIO_PIN_CFG(x) FIELD_GET(GENMASK(15, 13), x) 46 #define ADM1266_PDIO_GLITCH_FILT(x) FIELD_GET(GENMASK(12, 9), x) 47 #define ADM1266_PDIO_OUT_CFG(x) FIELD_GET(GENMASK(2, 0), x) 48 49 #define ADM1266_BLACKBOX_OFFSET 0 50 #define ADM1266_BLACKBOX_SIZE 64 51 #define ADM1266_BLACKBOX_MAX_RECORDS 32 52 53 #define ADM1266_PMBUS_BLOCK_MAX 255 54 55 struct adm1266_data { 56 struct pmbus_driver_info info; 57 struct gpio_chip gc; 58 const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR]; 59 struct i2c_client *client; 60 struct dentry *debugfs_dir; 61 struct nvmem_config nvmem_config; 62 struct nvmem_device *nvmem; 63 u8 *dev_mem; 64 struct mutex buf_mutex; 65 u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned; 66 u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 2] ____cacheline_aligned; 67 }; 68 69 static const struct nvmem_cell_info adm1266_nvmem_cells[] = { 70 { 71 .name = "blackbox", 72 .offset = ADM1266_BLACKBOX_OFFSET, 73 .bytes = 2048, 74 }, 75 }; 76 77 DECLARE_CRC8_TABLE(pmbus_crc_table); 78 79 /* 80 * Different from Block Read as it sends data and waits for the slave to 81 * return a value dependent on that data. The protocol is simply a Write Block 82 * followed by a Read Block without the Read-Block command field and the 83 * Write-Block STOP bit. 84 */ 85 static int adm1266_pmbus_block_xfer(struct adm1266_data *data, u8 cmd, u8 w_len, u8 *data_w, 86 u8 *data_r) 87 { 88 struct i2c_client *client = data->client; 89 struct i2c_msg msgs[2] = { 90 { 91 .addr = client->addr, 92 .flags = I2C_M_DMA_SAFE, 93 .buf = data->write_buf, 94 .len = w_len + 2, 95 }, 96 { 97 .addr = client->addr, 98 .flags = I2C_M_RD | I2C_M_DMA_SAFE, 99 .buf = data->read_buf, 100 .len = ADM1266_PMBUS_BLOCK_MAX + 2, 101 } 102 }; 103 u8 addr; 104 u8 crc; 105 int ret; 106 107 mutex_lock(&data->buf_mutex); 108 109 msgs[0].buf[0] = cmd; 110 msgs[0].buf[1] = w_len; 111 memcpy(&msgs[0].buf[2], data_w, w_len); 112 113 ret = i2c_transfer(client->adapter, msgs, 2); 114 if (ret != 2) { 115 if (ret >= 0) 116 ret = -EPROTO; 117 118 mutex_unlock(&data->buf_mutex); 119 120 return ret; 121 } 122 123 if (client->flags & I2C_CLIENT_PEC) { 124 addr = i2c_8bit_addr_from_msg(&msgs[0]); 125 crc = crc8(pmbus_crc_table, &addr, 1, 0); 126 crc = crc8(pmbus_crc_table, msgs[0].buf, msgs[0].len, crc); 127 128 addr = i2c_8bit_addr_from_msg(&msgs[1]); 129 crc = crc8(pmbus_crc_table, &addr, 1, crc); 130 crc = crc8(pmbus_crc_table, msgs[1].buf, msgs[1].buf[0] + 1, crc); 131 132 if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) { 133 mutex_unlock(&data->buf_mutex); 134 return -EBADMSG; 135 } 136 } 137 138 memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]); 139 140 ret = msgs[1].buf[0]; 141 mutex_unlock(&data->buf_mutex); 142 143 return ret; 144 } 145 146 static const unsigned int adm1266_gpio_mapping[ADM1266_GPIO_NR][2] = { 147 {1, 0}, 148 {2, 1}, 149 {3, 2}, 150 {4, 8}, 151 {5, 9}, 152 {6, 10}, 153 {7, 11}, 154 {8, 6}, 155 {9, 7}, 156 }; 157 158 static const char *adm1266_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR] = { 159 "GPIO1", "GPIO2", "GPIO3", "GPIO4", "GPIO5", "GPIO6", "GPIO7", "GPIO8", 160 "GPIO9", "PDIO1", "PDIO2", "PDIO3", "PDIO4", "PDIO5", "PDIO6", 161 "PDIO7", "PDIO8", "PDIO9", "PDIO10", "PDIO11", "PDIO12", "PDIO13", 162 "PDIO14", "PDIO15", "PDIO16", 163 }; 164 165 static int adm1266_gpio_get(struct gpio_chip *chip, unsigned int offset) 166 { 167 struct adm1266_data *data = gpiochip_get_data(chip); 168 u8 read_buf[I2C_SMBUS_BLOCK_MAX + 1]; 169 unsigned long pins_status; 170 unsigned int pmbus_cmd; 171 int ret; 172 173 if (offset < ADM1266_GPIO_NR) 174 pmbus_cmd = ADM1266_GPIO_STATUS; 175 else 176 pmbus_cmd = ADM1266_PDIO_STATUS; 177 178 guard(pmbus_lock)(data->client); 179 180 ret = i2c_smbus_read_block_data(data->client, pmbus_cmd, read_buf); 181 if (ret < 0) 182 return ret; 183 if (ret < 2) 184 return -EIO; 185 186 pins_status = read_buf[0] + (read_buf[1] << 8); 187 if (offset < ADM1266_GPIO_NR) 188 return test_bit(adm1266_gpio_mapping[offset][1], &pins_status); 189 190 return test_bit(offset - ADM1266_GPIO_NR, &pins_status); 191 } 192 193 static int adm1266_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask, 194 unsigned long *bits) 195 { 196 struct adm1266_data *data = gpiochip_get_data(chip); 197 u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1]; 198 unsigned long status; 199 unsigned int gpio_nr; 200 int ret; 201 202 guard(pmbus_lock)(data->client); 203 204 ret = i2c_smbus_read_block_data(data->client, ADM1266_GPIO_STATUS, read_buf); 205 if (ret < 0) 206 return ret; 207 if (ret < 2) 208 return -EIO; 209 210 status = read_buf[0] + (read_buf[1] << 8); 211 212 *bits = 0; 213 for_each_set_bit(gpio_nr, mask, ADM1266_GPIO_NR) { 214 if (test_bit(adm1266_gpio_mapping[gpio_nr][1], &status)) 215 set_bit(gpio_nr, bits); 216 } 217 218 ret = i2c_smbus_read_block_data(data->client, ADM1266_PDIO_STATUS, read_buf); 219 if (ret < 0) 220 return ret; 221 if (ret < 2) 222 return -EIO; 223 224 status = read_buf[0] + (read_buf[1] << 8); 225 226 for_each_set_bit_from(gpio_nr, mask, ADM1266_GPIO_NR + ADM1266_PDIO_NR) { 227 if (test_bit(gpio_nr - ADM1266_GPIO_NR, &status)) 228 set_bit(gpio_nr, bits); 229 } 230 231 return 0; 232 } 233 234 static void adm1266_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip) 235 { 236 struct adm1266_data *data = gpiochip_get_data(chip); 237 u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1]; 238 unsigned long gpio_config; 239 unsigned long pdio_config; 240 unsigned long pin_cfg; 241 u8 write_cmd; 242 int ret; 243 int i; 244 245 guard(pmbus_lock)(data->client); 246 247 for (i = 0; i < ADM1266_GPIO_NR; i++) { 248 write_cmd = adm1266_gpio_mapping[i][1]; 249 ret = adm1266_pmbus_block_xfer(data, ADM1266_GPIO_CONFIG, 1, &write_cmd, read_buf); 250 if (ret != 2) 251 return; 252 253 gpio_config = read_buf[0]; 254 seq_puts(s, adm1266_names[i]); 255 256 seq_puts(s, " ( "); 257 if (!ADM1266_GPIO_FUNCTIONS(gpio_config)) { 258 seq_puts(s, "high-Z )\n"); 259 continue; 260 } 261 if (ADM1266_GPIO_INPUT_EN(gpio_config)) 262 seq_puts(s, "input "); 263 if (ADM1266_GPIO_OUTPUT_EN(gpio_config)) 264 seq_puts(s, "output "); 265 if (ADM1266_GPIO_OPEN_DRAIN(gpio_config)) 266 seq_puts(s, "open-drain )\n"); 267 else 268 seq_puts(s, "push-pull )\n"); 269 } 270 271 write_cmd = 0xFF; 272 ret = adm1266_pmbus_block_xfer(data, ADM1266_PDIO_CONFIG, 1, &write_cmd, read_buf); 273 if (ret != 32) 274 return; 275 276 for (i = 0; i < ADM1266_PDIO_NR; i++) { 277 seq_puts(s, adm1266_names[ADM1266_GPIO_NR + i]); 278 279 pdio_config = read_buf[2 * i]; 280 pdio_config += (read_buf[2 * i + 1] << 8); 281 pin_cfg = ADM1266_PDIO_PIN_CFG(pdio_config); 282 283 seq_puts(s, " ( "); 284 if (!pin_cfg || pin_cfg > 5) { 285 seq_puts(s, "high-Z )\n"); 286 continue; 287 } 288 289 if (pin_cfg & BIT(0)) 290 seq_puts(s, "output "); 291 292 if (pin_cfg & BIT(1)) 293 seq_puts(s, "input "); 294 295 seq_puts(s, ")\n"); 296 } 297 } 298 299 static int adm1266_config_gpio(struct adm1266_data *data) 300 { 301 const char *name = dev_name(&data->client->dev); 302 char *gpio_name; 303 int ret; 304 int i; 305 306 for (i = 0; i < ARRAY_SIZE(data->gpio_names); i++) { 307 gpio_name = devm_kasprintf(&data->client->dev, GFP_KERNEL, "adm1266-%d-%x-%s", 308 data->client->adapter->nr, data->client->addr, 309 adm1266_names[i]); 310 if (!gpio_name) 311 return -ENOMEM; 312 313 data->gpio_names[i] = gpio_name; 314 } 315 316 data->gc.label = name; 317 data->gc.parent = &data->client->dev; 318 data->gc.owner = THIS_MODULE; 319 data->gc.can_sleep = true; 320 data->gc.base = -1; 321 data->gc.names = data->gpio_names; 322 data->gc.ngpio = ARRAY_SIZE(data->gpio_names); 323 data->gc.get = adm1266_gpio_get; 324 data->gc.get_multiple = adm1266_gpio_get_multiple; 325 data->gc.dbg_show = adm1266_gpio_dbg_show; 326 327 ret = devm_gpiochip_add_data(&data->client->dev, &data->gc, data); 328 if (ret) 329 dev_err(&data->client->dev, "GPIO registering failed (%d)\n", ret); 330 331 return ret; 332 } 333 334 static int adm1266_state_read(struct seq_file *s, void *pdata) 335 { 336 struct device *dev = s->private; 337 struct i2c_client *client = to_i2c_client(dev); 338 int ret; 339 340 guard(pmbus_lock)(client); 341 ret = i2c_smbus_read_word_data(client, ADM1266_READ_STATE); 342 if (ret < 0) 343 return ret; 344 345 seq_printf(s, "%d\n", ret); 346 347 return 0; 348 } 349 350 /* 351 * IC_DEVICE_REV (0xAE) returns an 8-byte block (datasheet Rev. D, Table 80): 352 * [2:0] firmware revision major.minor.patch 353 * [5:3] bootloader revision major.minor.patch 354 * [7:6] silicon revision two ASCII characters 355 */ 356 static int adm1266_firmware_revision_read(struct seq_file *s, void *pdata) 357 { 358 struct device *dev = s->private; 359 struct i2c_client *client = to_i2c_client(dev); 360 u8 buf[I2C_SMBUS_BLOCK_MAX]; 361 int ret; 362 363 guard(pmbus_lock)(client); 364 ret = i2c_smbus_read_block_data(client, ADM1266_IC_DEVICE_REV, buf); 365 if (ret < 0) 366 return ret; 367 if (ret < 3) 368 return -EIO; 369 370 seq_printf(s, "%u.%u.%u\n", buf[0], buf[1], buf[2]); 371 372 return 0; 373 } 374 375 /* 376 * POWERUP_COUNTER (0xE4) is a 2-byte little-endian non-volatile counter 377 * that increments on every device power cycle (datasheet Rev. D, Table 378 * 93). It saturates at 65535 and cannot be reset by the host. Each 379 * blackbox record embeds the counter value at record time, so this live 380 * read is mainly useful for matching a record back to its boot. 381 */ 382 static int adm1266_powerup_counter_read(struct seq_file *s, void *pdata) 383 { 384 struct device *dev = s->private; 385 struct i2c_client *client = to_i2c_client(dev); 386 u8 buf[I2C_SMBUS_BLOCK_MAX]; 387 int ret; 388 389 guard(pmbus_lock)(client); 390 ret = i2c_smbus_read_block_data(client, ADM1266_POWERUP_COUNTER, buf); 391 if (ret < 0) 392 return ret; 393 if (ret != 2) 394 return -EIO; 395 396 seq_printf(s, "%u\n", buf[0] | (buf[1] << 8)); 397 398 return 0; 399 } 400 401 /* 402 * Clearing the blackbox is required when the device is configured in 403 * single-recording mode (BLACKBOX_CONFIG[0] = 0): once the 32-record 404 * buffer is full the device stops recording until cleared. 405 * 406 * The clear is issued as a 2-byte block-write to READ_BLACKBOX with 407 * payload {0xFE, 0x00} per the datasheet. READ_BLACKBOX is also used 408 * by adm1266_nvmem_read_blackbox() to walk records one at a time; 409 * both paths run under pmbus_lock so the clear cannot interleave 410 * mid-iteration and corrupt the read sequence. 411 */ 412 static ssize_t adm1266_clear_blackbox_write(struct file *file, const char __user *ubuf, 413 size_t count, loff_t *ppos) 414 { 415 struct i2c_client *client = file->private_data; 416 u8 payload[2] = { 0xFE, 0x00 }; 417 int ret; 418 419 guard(pmbus_lock)(client); 420 ret = i2c_smbus_write_block_data(client, ADM1266_READ_BLACKBOX, 421 sizeof(payload), payload); 422 if (ret < 0) 423 return ret; 424 425 return count; 426 } 427 428 static const struct file_operations adm1266_clear_blackbox_fops = { 429 .owner = THIS_MODULE, 430 .open = simple_open, 431 .write = adm1266_clear_blackbox_write, 432 .llseek = noop_llseek, 433 }; 434 435 /* 436 * SET_RTC (0xDF) is a 6-byte block (datasheet Rev. D, Table 84): 437 * bytes [1:0] - fractional seconds (1/65536 s, written as zero) 438 * bytes [5:2] - seconds since 1970-01-01 UTC, little-endian 439 * 440 * The driver seeds it once at probe via adm1266_rtc_set(). Over a 441 * long uptime the chip's counter drifts away from host wall-clock, 442 * so expose it via debugfs: 443 * 444 * read -- returns the chip's current seconds counter, which lets 445 * userspace observe host-vs-chip drift. 446 * write -- the kernel re-reads ktime_get_real_seconds() and writes 447 * it to SET_RTC. The write payload is ignored; userspace 448 * does not get to supply its own timestamp value, so 449 * there is no way to push a wrong time into the chip. 450 * 451 * A small userspace agent (chrony hook, systemd-timesyncd script, 452 * or a periodic cron job) can write to this file to keep the 453 * timestamp embedded in each blackbox record aligned with 454 * wall-clock across long uptimes. 455 */ 456 static int adm1266_rtc_get(void *data, u64 *val) 457 { 458 struct i2c_client *client = data; 459 u8 buf[I2C_SMBUS_BLOCK_MAX]; 460 u32 seconds = 0; 461 int ret, i; 462 463 guard(pmbus_lock)(client); 464 ret = i2c_smbus_read_block_data(client, ADM1266_SET_RTC, buf); 465 if (ret < 0) 466 return ret; 467 if (ret < 6) 468 return -EIO; 469 470 for (i = 0; i < 4; i++) 471 seconds |= (u32)buf[2 + i] << (i * 8); 472 473 *val = seconds; 474 475 return 0; 476 } 477 478 static int adm1266_rtc_set(void *data, u64 val) 479 { 480 struct i2c_client *client = data; 481 time64_t kt = ktime_get_real_seconds(); 482 u8 write_buf[6] = { 0 }; 483 int i; 484 485 /* User-supplied @val is ignored on purpose; the kernel owns the 486 * time source so userspace cannot push a wrong value into the chip. 487 */ 488 for (i = 0; i < 4; i++) 489 write_buf[2 + i] = (kt >> (i * 8)) & 0xFF; 490 491 guard(pmbus_lock)(client); 492 return i2c_smbus_write_block_data(client, ADM1266_SET_RTC, 493 sizeof(write_buf), write_buf); 494 } 495 DEFINE_DEBUGFS_ATTRIBUTE(adm1266_rtc_fops, 496 adm1266_rtc_get, adm1266_rtc_set, "%llu\n"); 497 498 static void adm1266_init_debugfs(struct adm1266_data *data) 499 { 500 struct dentry *root; 501 502 root = pmbus_get_debugfs_dir(data->client); 503 if (!root) 504 return; 505 506 data->debugfs_dir = debugfs_create_dir(data->client->name, root); 507 508 debugfs_create_devm_seqfile(&data->client->dev, "sequencer_state", data->debugfs_dir, 509 adm1266_state_read); 510 debugfs_create_devm_seqfile(&data->client->dev, "firmware_revision", data->debugfs_dir, 511 adm1266_firmware_revision_read); 512 debugfs_create_devm_seqfile(&data->client->dev, "powerup_counter", data->debugfs_dir, 513 adm1266_powerup_counter_read); 514 debugfs_create_file("clear_blackbox", 0200, data->debugfs_dir, data->client, 515 &adm1266_clear_blackbox_fops); 516 debugfs_create_file("rtc", 0600, data->debugfs_dir, data->client, 517 &adm1266_rtc_fops); 518 } 519 520 static int adm1266_nvmem_read_blackbox(struct adm1266_data *data, u8 *read_buff) 521 { 522 u8 record[ADM1266_PMBUS_BLOCK_MAX]; 523 int record_count; 524 char index; 525 u8 buf[I2C_SMBUS_BLOCK_MAX]; 526 int ret; 527 528 ret = i2c_smbus_read_block_data(data->client, ADM1266_BLACKBOX_INFO, buf); 529 if (ret < 0) 530 return ret; 531 532 if (ret != 4) 533 return -EIO; 534 535 record_count = buf[3]; 536 if (record_count > ADM1266_BLACKBOX_MAX_RECORDS) 537 return -EIO; 538 539 for (index = 0; index < record_count; index++) { 540 ret = adm1266_pmbus_block_xfer(data, ADM1266_READ_BLACKBOX, 1, &index, record); 541 if (ret < 0) 542 return ret; 543 544 if (ret != ADM1266_BLACKBOX_SIZE) 545 return -EIO; 546 547 memcpy(read_buff, record, ADM1266_BLACKBOX_SIZE); 548 read_buff += ADM1266_BLACKBOX_SIZE; 549 } 550 551 return 0; 552 } 553 554 static int adm1266_nvmem_read(void *priv, unsigned int offset, void *val, size_t bytes) 555 { 556 struct adm1266_data *data = priv; 557 int ret; 558 559 if (offset + bytes > data->nvmem_config.size) 560 return -EINVAL; 561 562 guard(pmbus_lock)(data->client); 563 564 if (offset == 0) { 565 memset(data->dev_mem, 0, data->nvmem_config.size); 566 567 ret = adm1266_nvmem_read_blackbox(data, data->dev_mem); 568 if (ret) { 569 dev_err(&data->client->dev, "Could not read blackbox!"); 570 return ret; 571 } 572 } 573 574 memcpy(val, data->dev_mem + offset, bytes); 575 576 return 0; 577 } 578 579 static int adm1266_config_nvmem(struct adm1266_data *data) 580 { 581 data->nvmem_config.name = dev_name(&data->client->dev); 582 data->nvmem_config.dev = &data->client->dev; 583 data->nvmem_config.root_only = true; 584 data->nvmem_config.read_only = true; 585 data->nvmem_config.owner = THIS_MODULE; 586 data->nvmem_config.reg_read = adm1266_nvmem_read; 587 data->nvmem_config.cells = adm1266_nvmem_cells; 588 data->nvmem_config.ncells = ARRAY_SIZE(adm1266_nvmem_cells); 589 data->nvmem_config.priv = data; 590 data->nvmem_config.stride = 1; 591 data->nvmem_config.word_size = 1; 592 data->nvmem_config.size = adm1266_nvmem_cells[0].bytes; 593 594 data->dev_mem = devm_kzalloc(&data->client->dev, data->nvmem_config.size, GFP_KERNEL); 595 if (!data->dev_mem) 596 return -ENOMEM; 597 598 data->nvmem = devm_nvmem_register(&data->client->dev, &data->nvmem_config); 599 if (IS_ERR(data->nvmem)) { 600 dev_err(&data->client->dev, "Could not register nvmem!"); 601 return PTR_ERR(data->nvmem); 602 } 603 604 return 0; 605 } 606 607 static int adm1266_probe(struct i2c_client *client) 608 { 609 struct adm1266_data *data; 610 int ret; 611 int i; 612 613 data = devm_kzalloc(&client->dev, sizeof(struct adm1266_data), GFP_KERNEL); 614 if (!data) 615 return -ENOMEM; 616 617 data->client = client; 618 data->info.pages = 17; 619 data->info.format[PSC_VOLTAGE_OUT] = linear; 620 for (i = 0; i < data->info.pages; i++) 621 data->info.func[i] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT; 622 623 crc8_populate_msb(pmbus_crc_table, 0x7); 624 mutex_init(&data->buf_mutex); 625 626 ret = pmbus_do_probe(client, &data->info); 627 if (ret) 628 return ret; 629 630 ret = adm1266_rtc_set(client, 0); 631 if (ret < 0) 632 return ret; 633 634 ret = adm1266_config_nvmem(data); 635 if (ret < 0) 636 return ret; 637 638 ret = adm1266_config_gpio(data); 639 if (ret < 0) 640 return ret; 641 642 adm1266_init_debugfs(data); 643 644 return 0; 645 } 646 647 static const struct of_device_id adm1266_of_match[] = { 648 { .compatible = "adi,adm1266" }, 649 { } 650 }; 651 MODULE_DEVICE_TABLE(of, adm1266_of_match); 652 653 static const struct i2c_device_id adm1266_id[] = { 654 { .name = "adm1266" }, 655 { } 656 }; 657 MODULE_DEVICE_TABLE(i2c, adm1266_id); 658 659 static struct i2c_driver adm1266_driver = { 660 .driver = { 661 .name = "adm1266", 662 .of_match_table = adm1266_of_match, 663 }, 664 .probe = adm1266_probe, 665 .id_table = adm1266_id, 666 }; 667 668 module_i2c_driver(adm1266_driver); 669 670 MODULE_AUTHOR("Alexandru Tachici <alexandru.tachici@analog.com>"); 671 MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1266"); 672 MODULE_LICENSE("GPL v2"); 673 MODULE_IMPORT_NS("PMBUS"); 674