adm1266.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514
  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. #include <linux/bitfield.h>
  9. #include <linux/crc8.h>
  10. #include <linux/debugfs.h>
  11. #include <linux/gpio/driver.h>
  12. #include <linux/i2c.h>
  13. #include <linux/i2c-smbus.h>
  14. #include <linux/init.h>
  15. #include <linux/kernel.h>
  16. #include <linux/module.h>
  17. #include <linux/nvmem-consumer.h>
  18. #include <linux/nvmem-provider.h>
  19. #include "pmbus.h"
  20. #include <linux/slab.h>
  21. #include <linux/timekeeping.h>
  22. #define ADM1266_BLACKBOX_CONFIG 0xD3
  23. #define ADM1266_PDIO_CONFIG 0xD4
  24. #define ADM1266_READ_STATE 0xD9
  25. #define ADM1266_READ_BLACKBOX 0xDE
  26. #define ADM1266_SET_RTC 0xDF
  27. #define ADM1266_GPIO_CONFIG 0xE1
  28. #define ADM1266_BLACKBOX_INFO 0xE6
  29. #define ADM1266_PDIO_STATUS 0xE9
  30. #define ADM1266_GPIO_STATUS 0xEA
  31. /* ADM1266 GPIO defines */
  32. #define ADM1266_GPIO_NR 9
  33. #define ADM1266_GPIO_FUNCTIONS(x) FIELD_GET(BIT(0), x)
  34. #define ADM1266_GPIO_INPUT_EN(x) FIELD_GET(BIT(2), x)
  35. #define ADM1266_GPIO_OUTPUT_EN(x) FIELD_GET(BIT(3), x)
  36. #define ADM1266_GPIO_OPEN_DRAIN(x) FIELD_GET(BIT(4), x)
  37. /* ADM1266 PDIO defines */
  38. #define ADM1266_PDIO_NR 16
  39. #define ADM1266_PDIO_PIN_CFG(x) FIELD_GET(GENMASK(15, 13), x)
  40. #define ADM1266_PDIO_GLITCH_FILT(x) FIELD_GET(GENMASK(12, 9), x)
  41. #define ADM1266_PDIO_OUT_CFG(x) FIELD_GET(GENMASK(2, 0), x)
  42. #define ADM1266_BLACKBOX_OFFSET 0
  43. #define ADM1266_BLACKBOX_SIZE 64
  44. #define ADM1266_PMBUS_BLOCK_MAX 255
  45. struct adm1266_data {
  46. struct pmbus_driver_info info;
  47. struct gpio_chip gc;
  48. const char *gpio_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR];
  49. struct i2c_client *client;
  50. struct dentry *debugfs_dir;
  51. struct nvmem_config nvmem_config;
  52. struct nvmem_device *nvmem;
  53. u8 *dev_mem;
  54. struct mutex buf_mutex;
  55. u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned;
  56. u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned;
  57. };
  58. static const struct nvmem_cell_info adm1266_nvmem_cells[] = {
  59. {
  60. .name = "blackbox",
  61. .offset = ADM1266_BLACKBOX_OFFSET,
  62. .bytes = 2048,
  63. },
  64. };
  65. DECLARE_CRC8_TABLE(pmbus_crc_table);
  66. /*
  67. * Different from Block Read as it sends data and waits for the slave to
  68. * return a value dependent on that data. The protocol is simply a Write Block
  69. * followed by a Read Block without the Read-Block command field and the
  70. * Write-Block STOP bit.
  71. */
  72. static int adm1266_pmbus_block_xfer(struct adm1266_data *data, u8 cmd, u8 w_len, u8 *data_w,
  73. u8 *data_r)
  74. {
  75. struct i2c_client *client = data->client;
  76. struct i2c_msg msgs[2] = {
  77. {
  78. .addr = client->addr,
  79. .flags = I2C_M_DMA_SAFE,
  80. .buf = data->write_buf,
  81. .len = w_len + 2,
  82. },
  83. {
  84. .addr = client->addr,
  85. .flags = I2C_M_RD | I2C_M_DMA_SAFE,
  86. .buf = data->read_buf,
  87. .len = ADM1266_PMBUS_BLOCK_MAX + 2,
  88. }
  89. };
  90. u8 addr;
  91. u8 crc;
  92. int ret;
  93. mutex_lock(&data->buf_mutex);
  94. msgs[0].buf[0] = cmd;
  95. msgs[0].buf[1] = w_len;
  96. memcpy(&msgs[0].buf[2], data_w, w_len);
  97. ret = i2c_transfer(client->adapter, msgs, 2);
  98. if (ret != 2) {
  99. if (ret >= 0)
  100. ret = -EPROTO;
  101. mutex_unlock(&data->buf_mutex);
  102. return ret;
  103. }
  104. if (client->flags & I2C_CLIENT_PEC) {
  105. addr = i2c_8bit_addr_from_msg(&msgs[0]);
  106. crc = crc8(pmbus_crc_table, &addr, 1, 0);
  107. crc = crc8(pmbus_crc_table, msgs[0].buf, msgs[0].len, crc);
  108. addr = i2c_8bit_addr_from_msg(&msgs[1]);
  109. crc = crc8(pmbus_crc_table, &addr, 1, crc);
  110. crc = crc8(pmbus_crc_table, msgs[1].buf, msgs[1].buf[0] + 1, crc);
  111. if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) {
  112. mutex_unlock(&data->buf_mutex);
  113. return -EBADMSG;
  114. }
  115. }
  116. memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]);
  117. ret = msgs[1].buf[0];
  118. mutex_unlock(&data->buf_mutex);
  119. return ret;
  120. }
  121. static const unsigned int adm1266_gpio_mapping[ADM1266_GPIO_NR][2] = {
  122. {1, 0},
  123. {2, 1},
  124. {3, 2},
  125. {4, 8},
  126. {5, 9},
  127. {6, 10},
  128. {7, 11},
  129. {8, 6},
  130. {9, 7},
  131. };
  132. static const char *adm1266_names[ADM1266_GPIO_NR + ADM1266_PDIO_NR] = {
  133. "GPIO1", "GPIO2", "GPIO3", "GPIO4", "GPIO5", "GPIO6", "GPIO7", "GPIO8",
  134. "GPIO9", "PDIO1", "PDIO2", "PDIO3", "PDIO4", "PDIO5", "PDIO6",
  135. "PDIO7", "PDIO8", "PDIO9", "PDIO10", "PDIO11", "PDIO12", "PDIO13",
  136. "PDIO14", "PDIO15", "PDIO16",
  137. };
  138. static int adm1266_gpio_get(struct gpio_chip *chip, unsigned int offset)
  139. {
  140. struct adm1266_data *data = gpiochip_get_data(chip);
  141. u8 read_buf[I2C_SMBUS_BLOCK_MAX + 1];
  142. unsigned long pins_status;
  143. unsigned int pmbus_cmd;
  144. int ret;
  145. if (offset < ADM1266_GPIO_NR)
  146. pmbus_cmd = ADM1266_GPIO_STATUS;
  147. else
  148. pmbus_cmd = ADM1266_PDIO_STATUS;
  149. ret = i2c_smbus_read_block_data(data->client, pmbus_cmd, read_buf);
  150. if (ret < 0)
  151. return ret;
  152. pins_status = read_buf[0] + (read_buf[1] << 8);
  153. if (offset < ADM1266_GPIO_NR)
  154. return test_bit(adm1266_gpio_mapping[offset][1], &pins_status);
  155. return test_bit(offset - ADM1266_GPIO_NR, &pins_status);
  156. }
  157. static int adm1266_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask,
  158. unsigned long *bits)
  159. {
  160. struct adm1266_data *data = gpiochip_get_data(chip);
  161. u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1];
  162. unsigned long status;
  163. unsigned int gpio_nr;
  164. int ret;
  165. ret = i2c_smbus_read_block_data(data->client, ADM1266_GPIO_STATUS, read_buf);
  166. if (ret < 0)
  167. return ret;
  168. status = read_buf[0] + (read_buf[1] << 8);
  169. *bits = 0;
  170. for_each_set_bit(gpio_nr, mask, ADM1266_GPIO_NR) {
  171. if (test_bit(adm1266_gpio_mapping[gpio_nr][1], &status))
  172. set_bit(gpio_nr, bits);
  173. }
  174. ret = i2c_smbus_read_block_data(data->client, ADM1266_PDIO_STATUS, read_buf);
  175. if (ret < 0)
  176. return ret;
  177. status = read_buf[0] + (read_buf[1] << 8);
  178. *bits = 0;
  179. for_each_set_bit_from(gpio_nr, mask, ADM1266_GPIO_NR + ADM1266_PDIO_STATUS) {
  180. if (test_bit(gpio_nr - ADM1266_GPIO_NR, &status))
  181. set_bit(gpio_nr, bits);
  182. }
  183. return 0;
  184. }
  185. static void adm1266_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
  186. {
  187. struct adm1266_data *data = gpiochip_get_data(chip);
  188. u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1];
  189. unsigned long gpio_config;
  190. unsigned long pdio_config;
  191. unsigned long pin_cfg;
  192. u8 write_cmd;
  193. int ret;
  194. int i;
  195. for (i = 0; i < ADM1266_GPIO_NR; i++) {
  196. write_cmd = adm1266_gpio_mapping[i][1];
  197. ret = adm1266_pmbus_block_xfer(data, ADM1266_GPIO_CONFIG, 1, &write_cmd, read_buf);
  198. if (ret != 2)
  199. return;
  200. gpio_config = read_buf[0];
  201. seq_puts(s, adm1266_names[i]);
  202. seq_puts(s, " ( ");
  203. if (!ADM1266_GPIO_FUNCTIONS(gpio_config)) {
  204. seq_puts(s, "high-Z )\n");
  205. continue;
  206. }
  207. if (ADM1266_GPIO_INPUT_EN(gpio_config))
  208. seq_puts(s, "input ");
  209. if (ADM1266_GPIO_OUTPUT_EN(gpio_config))
  210. seq_puts(s, "output ");
  211. if (ADM1266_GPIO_OPEN_DRAIN(gpio_config))
  212. seq_puts(s, "open-drain )\n");
  213. else
  214. seq_puts(s, "push-pull )\n");
  215. }
  216. write_cmd = 0xFF;
  217. ret = adm1266_pmbus_block_xfer(data, ADM1266_PDIO_CONFIG, 1, &write_cmd, read_buf);
  218. if (ret != 32)
  219. return;
  220. for (i = 0; i < ADM1266_PDIO_NR; i++) {
  221. seq_puts(s, adm1266_names[ADM1266_GPIO_NR + i]);
  222. pdio_config = read_buf[2 * i];
  223. pdio_config += (read_buf[2 * i + 1] << 8);
  224. pin_cfg = ADM1266_PDIO_PIN_CFG(pdio_config);
  225. seq_puts(s, " ( ");
  226. if (!pin_cfg || pin_cfg > 5) {
  227. seq_puts(s, "high-Z )\n");
  228. continue;
  229. }
  230. if (pin_cfg & BIT(0))
  231. seq_puts(s, "output ");
  232. if (pin_cfg & BIT(1))
  233. seq_puts(s, "input ");
  234. seq_puts(s, ")\n");
  235. }
  236. }
  237. static int adm1266_config_gpio(struct adm1266_data *data)
  238. {
  239. const char *name = dev_name(&data->client->dev);
  240. char *gpio_name;
  241. int ret;
  242. int i;
  243. for (i = 0; i < ARRAY_SIZE(data->gpio_names); i++) {
  244. gpio_name = devm_kasprintf(&data->client->dev, GFP_KERNEL, "adm1266-%x-%s",
  245. data->client->addr, adm1266_names[i]);
  246. if (!gpio_name)
  247. return -ENOMEM;
  248. data->gpio_names[i] = gpio_name;
  249. }
  250. data->gc.label = name;
  251. data->gc.parent = &data->client->dev;
  252. data->gc.owner = THIS_MODULE;
  253. data->gc.can_sleep = true;
  254. data->gc.base = -1;
  255. data->gc.names = data->gpio_names;
  256. data->gc.ngpio = ARRAY_SIZE(data->gpio_names);
  257. data->gc.get = adm1266_gpio_get;
  258. data->gc.get_multiple = adm1266_gpio_get_multiple;
  259. data->gc.dbg_show = adm1266_gpio_dbg_show;
  260. ret = devm_gpiochip_add_data(&data->client->dev, &data->gc, data);
  261. if (ret)
  262. dev_err(&data->client->dev, "GPIO registering failed (%d)\n", ret);
  263. return ret;
  264. }
  265. static int adm1266_state_read(struct seq_file *s, void *pdata)
  266. {
  267. struct device *dev = s->private;
  268. struct i2c_client *client = to_i2c_client(dev);
  269. int ret;
  270. ret = i2c_smbus_read_word_data(client, ADM1266_READ_STATE);
  271. if (ret < 0)
  272. return ret;
  273. seq_printf(s, "%d\n", ret);
  274. return 0;
  275. }
  276. static void adm1266_init_debugfs(struct adm1266_data *data)
  277. {
  278. struct dentry *root;
  279. root = pmbus_get_debugfs_dir(data->client);
  280. if (!root)
  281. return;
  282. data->debugfs_dir = debugfs_create_dir(data->client->name, root);
  283. if (!data->debugfs_dir)
  284. return;
  285. debugfs_create_devm_seqfile(&data->client->dev, "sequencer_state", data->debugfs_dir,
  286. adm1266_state_read);
  287. }
  288. static int adm1266_nvmem_read_blackbox(struct adm1266_data *data, u8 *read_buff)
  289. {
  290. int record_count;
  291. char index;
  292. u8 buf[5];
  293. int ret;
  294. ret = i2c_smbus_read_block_data(data->client, ADM1266_BLACKBOX_INFO, buf);
  295. if (ret < 0)
  296. return ret;
  297. if (ret != 4)
  298. return -EIO;
  299. record_count = buf[3];
  300. for (index = 0; index < record_count; index++) {
  301. ret = adm1266_pmbus_block_xfer(data, ADM1266_READ_BLACKBOX, 1, &index, read_buff);
  302. if (ret < 0)
  303. return ret;
  304. if (ret != ADM1266_BLACKBOX_SIZE)
  305. return -EIO;
  306. read_buff += ADM1266_BLACKBOX_SIZE;
  307. }
  308. return 0;
  309. }
  310. static int adm1266_nvmem_read(void *priv, unsigned int offset, void *val, size_t bytes)
  311. {
  312. struct adm1266_data *data = priv;
  313. int ret;
  314. if (offset + bytes > data->nvmem_config.size)
  315. return -EINVAL;
  316. if (offset == 0) {
  317. memset(data->dev_mem, 0, data->nvmem_config.size);
  318. ret = adm1266_nvmem_read_blackbox(data, data->dev_mem);
  319. if (ret) {
  320. dev_err(&data->client->dev, "Could not read blackbox!");
  321. return ret;
  322. }
  323. }
  324. memcpy(val, data->dev_mem + offset, bytes);
  325. return 0;
  326. }
  327. static int adm1266_config_nvmem(struct adm1266_data *data)
  328. {
  329. data->nvmem_config.name = dev_name(&data->client->dev);
  330. data->nvmem_config.dev = &data->client->dev;
  331. data->nvmem_config.root_only = true;
  332. data->nvmem_config.read_only = true;
  333. data->nvmem_config.owner = THIS_MODULE;
  334. data->nvmem_config.reg_read = adm1266_nvmem_read;
  335. data->nvmem_config.cells = adm1266_nvmem_cells;
  336. data->nvmem_config.ncells = ARRAY_SIZE(adm1266_nvmem_cells);
  337. data->nvmem_config.priv = data;
  338. data->nvmem_config.stride = 1;
  339. data->nvmem_config.word_size = 1;
  340. data->nvmem_config.size = adm1266_nvmem_cells[0].bytes;
  341. data->dev_mem = devm_kzalloc(&data->client->dev, data->nvmem_config.size, GFP_KERNEL);
  342. if (!data->dev_mem)
  343. return -ENOMEM;
  344. data->nvmem = devm_nvmem_register(&data->client->dev, &data->nvmem_config);
  345. if (IS_ERR(data->nvmem)) {
  346. dev_err(&data->client->dev, "Could not register nvmem!");
  347. return PTR_ERR(data->nvmem);
  348. }
  349. return 0;
  350. }
  351. static int adm1266_set_rtc(struct adm1266_data *data)
  352. {
  353. time64_t kt;
  354. char write_buf[6];
  355. int i;
  356. kt = ktime_get_seconds();
  357. memset(write_buf, 0, sizeof(write_buf));
  358. for (i = 0; i < 4; i++)
  359. write_buf[2 + i] = (kt >> (i * 8)) & 0xFF;
  360. return i2c_smbus_write_block_data(data->client, ADM1266_SET_RTC, sizeof(write_buf),
  361. write_buf);
  362. }
  363. static int adm1266_probe(struct i2c_client *client)
  364. {
  365. struct adm1266_data *data;
  366. int ret;
  367. int i;
  368. data = devm_kzalloc(&client->dev, sizeof(struct adm1266_data), GFP_KERNEL);
  369. if (!data)
  370. return -ENOMEM;
  371. data->client = client;
  372. data->info.pages = 17;
  373. data->info.format[PSC_VOLTAGE_OUT] = linear;
  374. for (i = 0; i < data->info.pages; i++)
  375. data->info.func[i] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
  376. crc8_populate_msb(pmbus_crc_table, 0x7);
  377. mutex_init(&data->buf_mutex);
  378. ret = adm1266_config_gpio(data);
  379. if (ret < 0)
  380. return ret;
  381. ret = adm1266_set_rtc(data);
  382. if (ret < 0)
  383. return ret;
  384. ret = adm1266_config_nvmem(data);
  385. if (ret < 0)
  386. return ret;
  387. ret = pmbus_do_probe(client, &data->info);
  388. if (ret)
  389. return ret;
  390. adm1266_init_debugfs(data);
  391. return 0;
  392. }
  393. static const struct of_device_id adm1266_of_match[] = {
  394. { .compatible = "adi,adm1266" },
  395. { }
  396. };
  397. MODULE_DEVICE_TABLE(of, adm1266_of_match);
  398. static const struct i2c_device_id adm1266_id[] = {
  399. { "adm1266", 0 },
  400. { }
  401. };
  402. MODULE_DEVICE_TABLE(i2c, adm1266_id);
  403. static struct i2c_driver adm1266_driver = {
  404. .driver = {
  405. .name = "adm1266",
  406. .of_match_table = adm1266_of_match,
  407. },
  408. .probe_new = adm1266_probe,
  409. .id_table = adm1266_id,
  410. };
  411. module_i2c_driver(adm1266_driver);
  412. MODULE_AUTHOR("Alexandru Tachici <[email protected]>");
  413. MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1266");
  414. MODULE_LICENSE("GPL v2");
  415. MODULE_IMPORT_NS(PMBUS);