da9063-i2c.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /* I2C support for Dialog DA9063
  3. *
  4. * Copyright 2012 Dialog Semiconductor Ltd.
  5. * Copyright 2013 Philipp Zabel, Pengutronix
  6. *
  7. * Author: Krystian Garbaciak, Dialog Semiconductor
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/i2c.h>
  12. #include <linux/regmap.h>
  13. #include <linux/delay.h>
  14. #include <linux/slab.h>
  15. #include <linux/err.h>
  16. #include <linux/mfd/core.h>
  17. #include <linux/mfd/da9063/core.h>
  18. #include <linux/mfd/da9063/registers.h>
  19. #include <linux/of.h>
  20. #include <linux/regulator/of_regulator.h>
  21. /*
  22. * Raw I2C access required for just accessing chip and variant info before we
  23. * know which device is present. The info read from the device using this
  24. * approach is then used to select the correct regmap tables.
  25. */
  26. #define DA9063_REG_PAGE_SIZE 0x100
  27. #define DA9063_REG_PAGED_ADDR_MASK 0xFF
  28. enum da9063_page_sel_buf_fmt {
  29. DA9063_PAGE_SEL_BUF_PAGE_REG = 0,
  30. DA9063_PAGE_SEL_BUF_PAGE_VAL,
  31. DA9063_PAGE_SEL_BUF_SIZE,
  32. };
  33. enum da9063_paged_read_msgs {
  34. DA9063_PAGED_READ_MSG_PAGE_SEL = 0,
  35. DA9063_PAGED_READ_MSG_REG_SEL,
  36. DA9063_PAGED_READ_MSG_DATA,
  37. DA9063_PAGED_READ_MSG_CNT,
  38. };
  39. static int da9063_i2c_blockreg_read(struct i2c_client *client, u16 addr,
  40. u8 *buf, int count)
  41. {
  42. struct i2c_msg xfer[DA9063_PAGED_READ_MSG_CNT];
  43. u8 page_sel_buf[DA9063_PAGE_SEL_BUF_SIZE];
  44. u8 page_num, paged_addr;
  45. int ret;
  46. /* Determine page info based on register address */
  47. page_num = (addr / DA9063_REG_PAGE_SIZE);
  48. if (page_num > 1) {
  49. dev_err(&client->dev, "Invalid register address provided\n");
  50. return -EINVAL;
  51. }
  52. paged_addr = (addr % DA9063_REG_PAGE_SIZE) & DA9063_REG_PAGED_ADDR_MASK;
  53. page_sel_buf[DA9063_PAGE_SEL_BUF_PAGE_REG] = DA9063_REG_PAGE_CON;
  54. page_sel_buf[DA9063_PAGE_SEL_BUF_PAGE_VAL] =
  55. (page_num << DA9063_I2C_PAGE_SEL_SHIFT) & DA9063_REG_PAGE_MASK;
  56. /* Write reg address, page selection */
  57. xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].addr = client->addr;
  58. xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].flags = 0;
  59. xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].len = DA9063_PAGE_SEL_BUF_SIZE;
  60. xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].buf = page_sel_buf;
  61. /* Select register address */
  62. xfer[DA9063_PAGED_READ_MSG_REG_SEL].addr = client->addr;
  63. xfer[DA9063_PAGED_READ_MSG_REG_SEL].flags = 0;
  64. xfer[DA9063_PAGED_READ_MSG_REG_SEL].len = sizeof(paged_addr);
  65. xfer[DA9063_PAGED_READ_MSG_REG_SEL].buf = &paged_addr;
  66. /* Read data */
  67. xfer[DA9063_PAGED_READ_MSG_DATA].addr = client->addr;
  68. xfer[DA9063_PAGED_READ_MSG_DATA].flags = I2C_M_RD;
  69. xfer[DA9063_PAGED_READ_MSG_DATA].len = count;
  70. xfer[DA9063_PAGED_READ_MSG_DATA].buf = buf;
  71. ret = i2c_transfer(client->adapter, xfer, DA9063_PAGED_READ_MSG_CNT);
  72. if (ret < 0) {
  73. dev_err(&client->dev, "Paged block read failed: %d\n", ret);
  74. return ret;
  75. }
  76. if (ret != DA9063_PAGED_READ_MSG_CNT) {
  77. dev_err(&client->dev, "Paged block read failed to complete\n");
  78. return -EIO;
  79. }
  80. return 0;
  81. }
  82. enum {
  83. DA9063_DEV_ID_REG = 0,
  84. DA9063_VAR_ID_REG,
  85. DA9063_CHIP_ID_REGS,
  86. };
  87. static int da9063_get_device_type(struct i2c_client *i2c, struct da9063 *da9063)
  88. {
  89. u8 buf[DA9063_CHIP_ID_REGS];
  90. int ret;
  91. ret = da9063_i2c_blockreg_read(i2c, DA9063_REG_DEVICE_ID, buf,
  92. DA9063_CHIP_ID_REGS);
  93. if (ret)
  94. return ret;
  95. if (buf[DA9063_DEV_ID_REG] != PMIC_CHIP_ID_DA9063) {
  96. dev_err(da9063->dev,
  97. "Invalid chip device ID: 0x%02x\n",
  98. buf[DA9063_DEV_ID_REG]);
  99. return -ENODEV;
  100. }
  101. dev_info(da9063->dev,
  102. "Device detected (chip-ID: 0x%02X, var-ID: 0x%02X)\n",
  103. buf[DA9063_DEV_ID_REG], buf[DA9063_VAR_ID_REG]);
  104. da9063->variant_code =
  105. (buf[DA9063_VAR_ID_REG] & DA9063_VARIANT_ID_MRC_MASK)
  106. >> DA9063_VARIANT_ID_MRC_SHIFT;
  107. return 0;
  108. }
  109. /*
  110. * Variant specific regmap configs
  111. */
  112. static const struct regmap_range da9063_ad_readable_ranges[] = {
  113. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_AD_REG_SECOND_D),
  114. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  115. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  116. regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_AD_REG_GP_ID_19),
  117. regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
  118. };
  119. static const struct regmap_range da9063_ad_writeable_ranges[] = {
  120. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
  121. regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
  122. regmap_reg_range(DA9063_REG_COUNT_S, DA9063_AD_REG_ALARM_Y),
  123. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  124. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  125. regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_AD_REG_MON_REG_4),
  126. regmap_reg_range(DA9063_AD_REG_GP_ID_0, DA9063_AD_REG_GP_ID_19),
  127. };
  128. static const struct regmap_range da9063_ad_volatile_ranges[] = {
  129. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
  130. regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
  131. regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
  132. regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
  133. regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
  134. regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_AD_REG_SECOND_D),
  135. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
  136. regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
  137. regmap_reg_range(DA9063_AD_REG_MON_REG_5, DA9063_AD_REG_MON_REG_6),
  138. };
  139. static const struct regmap_access_table da9063_ad_readable_table = {
  140. .yes_ranges = da9063_ad_readable_ranges,
  141. .n_yes_ranges = ARRAY_SIZE(da9063_ad_readable_ranges),
  142. };
  143. static const struct regmap_access_table da9063_ad_writeable_table = {
  144. .yes_ranges = da9063_ad_writeable_ranges,
  145. .n_yes_ranges = ARRAY_SIZE(da9063_ad_writeable_ranges),
  146. };
  147. static const struct regmap_access_table da9063_ad_volatile_table = {
  148. .yes_ranges = da9063_ad_volatile_ranges,
  149. .n_yes_ranges = ARRAY_SIZE(da9063_ad_volatile_ranges),
  150. };
  151. static const struct regmap_range da9063_bb_readable_ranges[] = {
  152. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_BB_REG_SECOND_D),
  153. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  154. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  155. regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_19),
  156. regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
  157. };
  158. static const struct regmap_range da9063_bb_writeable_ranges[] = {
  159. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
  160. regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
  161. regmap_reg_range(DA9063_REG_COUNT_S, DA9063_BB_REG_ALARM_Y),
  162. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  163. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  164. regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
  165. regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_19),
  166. };
  167. static const struct regmap_range da9063_bb_da_volatile_ranges[] = {
  168. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
  169. regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
  170. regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
  171. regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
  172. regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
  173. regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_BB_REG_SECOND_D),
  174. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
  175. regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
  176. regmap_reg_range(DA9063_BB_REG_MON_REG_5, DA9063_BB_REG_MON_REG_6),
  177. };
  178. static const struct regmap_access_table da9063_bb_readable_table = {
  179. .yes_ranges = da9063_bb_readable_ranges,
  180. .n_yes_ranges = ARRAY_SIZE(da9063_bb_readable_ranges),
  181. };
  182. static const struct regmap_access_table da9063_bb_writeable_table = {
  183. .yes_ranges = da9063_bb_writeable_ranges,
  184. .n_yes_ranges = ARRAY_SIZE(da9063_bb_writeable_ranges),
  185. };
  186. static const struct regmap_access_table da9063_bb_da_volatile_table = {
  187. .yes_ranges = da9063_bb_da_volatile_ranges,
  188. .n_yes_ranges = ARRAY_SIZE(da9063_bb_da_volatile_ranges),
  189. };
  190. static const struct regmap_range da9063l_bb_readable_ranges[] = {
  191. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_MON_A10_RES),
  192. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  193. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  194. regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_19),
  195. regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
  196. };
  197. static const struct regmap_range da9063l_bb_writeable_ranges[] = {
  198. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
  199. regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
  200. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  201. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  202. regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
  203. regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_19),
  204. };
  205. static const struct regmap_range da9063l_bb_da_volatile_ranges[] = {
  206. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
  207. regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
  208. regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
  209. regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
  210. regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
  211. regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_REG_MON_A10_RES),
  212. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
  213. regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
  214. regmap_reg_range(DA9063_BB_REG_MON_REG_5, DA9063_BB_REG_MON_REG_6),
  215. };
  216. static const struct regmap_access_table da9063l_bb_readable_table = {
  217. .yes_ranges = da9063l_bb_readable_ranges,
  218. .n_yes_ranges = ARRAY_SIZE(da9063l_bb_readable_ranges),
  219. };
  220. static const struct regmap_access_table da9063l_bb_writeable_table = {
  221. .yes_ranges = da9063l_bb_writeable_ranges,
  222. .n_yes_ranges = ARRAY_SIZE(da9063l_bb_writeable_ranges),
  223. };
  224. static const struct regmap_access_table da9063l_bb_da_volatile_table = {
  225. .yes_ranges = da9063l_bb_da_volatile_ranges,
  226. .n_yes_ranges = ARRAY_SIZE(da9063l_bb_da_volatile_ranges),
  227. };
  228. static const struct regmap_range da9063_da_readable_ranges[] = {
  229. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_BB_REG_SECOND_D),
  230. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  231. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  232. regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_11),
  233. regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
  234. };
  235. static const struct regmap_range da9063_da_writeable_ranges[] = {
  236. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
  237. regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
  238. regmap_reg_range(DA9063_REG_COUNT_S, DA9063_BB_REG_ALARM_Y),
  239. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  240. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  241. regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
  242. regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_11),
  243. };
  244. static const struct regmap_access_table da9063_da_readable_table = {
  245. .yes_ranges = da9063_da_readable_ranges,
  246. .n_yes_ranges = ARRAY_SIZE(da9063_da_readable_ranges),
  247. };
  248. static const struct regmap_access_table da9063_da_writeable_table = {
  249. .yes_ranges = da9063_da_writeable_ranges,
  250. .n_yes_ranges = ARRAY_SIZE(da9063_da_writeable_ranges),
  251. };
  252. static const struct regmap_range da9063l_da_readable_ranges[] = {
  253. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_MON_A10_RES),
  254. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  255. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  256. regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_11),
  257. regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
  258. };
  259. static const struct regmap_range da9063l_da_writeable_ranges[] = {
  260. regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
  261. regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
  262. regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
  263. regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
  264. regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
  265. regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_11),
  266. };
  267. static const struct regmap_access_table da9063l_da_readable_table = {
  268. .yes_ranges = da9063l_da_readable_ranges,
  269. .n_yes_ranges = ARRAY_SIZE(da9063l_da_readable_ranges),
  270. };
  271. static const struct regmap_access_table da9063l_da_writeable_table = {
  272. .yes_ranges = da9063l_da_writeable_ranges,
  273. .n_yes_ranges = ARRAY_SIZE(da9063l_da_writeable_ranges),
  274. };
  275. static const struct regmap_range_cfg da9063_range_cfg[] = {
  276. {
  277. .range_min = DA9063_REG_PAGE_CON,
  278. .range_max = DA9063_REG_CONFIG_ID,
  279. .selector_reg = DA9063_REG_PAGE_CON,
  280. .selector_mask = 1 << DA9063_I2C_PAGE_SEL_SHIFT,
  281. .selector_shift = DA9063_I2C_PAGE_SEL_SHIFT,
  282. .window_start = 0,
  283. .window_len = 256,
  284. }
  285. };
  286. static struct regmap_config da9063_regmap_config = {
  287. .reg_bits = 8,
  288. .val_bits = 8,
  289. .ranges = da9063_range_cfg,
  290. .num_ranges = ARRAY_SIZE(da9063_range_cfg),
  291. .max_register = DA9063_REG_CONFIG_ID,
  292. .cache_type = REGCACHE_RBTREE,
  293. };
  294. static const struct of_device_id da9063_dt_ids[] = {
  295. { .compatible = "dlg,da9063", },
  296. { .compatible = "dlg,da9063l", },
  297. { }
  298. };
  299. MODULE_DEVICE_TABLE(of, da9063_dt_ids);
  300. static int da9063_i2c_probe(struct i2c_client *i2c,
  301. const struct i2c_device_id *id)
  302. {
  303. struct da9063 *da9063;
  304. int ret;
  305. da9063 = devm_kzalloc(&i2c->dev, sizeof(struct da9063), GFP_KERNEL);
  306. if (da9063 == NULL)
  307. return -ENOMEM;
  308. i2c_set_clientdata(i2c, da9063);
  309. da9063->dev = &i2c->dev;
  310. da9063->chip_irq = i2c->irq;
  311. da9063->type = id->driver_data;
  312. ret = da9063_get_device_type(i2c, da9063);
  313. if (ret)
  314. return ret;
  315. switch (da9063->type) {
  316. case PMIC_TYPE_DA9063:
  317. switch (da9063->variant_code) {
  318. case PMIC_DA9063_AD:
  319. da9063_regmap_config.rd_table =
  320. &da9063_ad_readable_table;
  321. da9063_regmap_config.wr_table =
  322. &da9063_ad_writeable_table;
  323. da9063_regmap_config.volatile_table =
  324. &da9063_ad_volatile_table;
  325. break;
  326. case PMIC_DA9063_BB:
  327. case PMIC_DA9063_CA:
  328. da9063_regmap_config.rd_table =
  329. &da9063_bb_readable_table;
  330. da9063_regmap_config.wr_table =
  331. &da9063_bb_writeable_table;
  332. da9063_regmap_config.volatile_table =
  333. &da9063_bb_da_volatile_table;
  334. break;
  335. case PMIC_DA9063_DA:
  336. da9063_regmap_config.rd_table =
  337. &da9063_da_readable_table;
  338. da9063_regmap_config.wr_table =
  339. &da9063_da_writeable_table;
  340. da9063_regmap_config.volatile_table =
  341. &da9063_bb_da_volatile_table;
  342. break;
  343. default:
  344. dev_err(da9063->dev,
  345. "Chip variant not supported for DA9063\n");
  346. return -ENODEV;
  347. }
  348. break;
  349. case PMIC_TYPE_DA9063L:
  350. switch (da9063->variant_code) {
  351. case PMIC_DA9063_BB:
  352. case PMIC_DA9063_CA:
  353. da9063_regmap_config.rd_table =
  354. &da9063l_bb_readable_table;
  355. da9063_regmap_config.wr_table =
  356. &da9063l_bb_writeable_table;
  357. da9063_regmap_config.volatile_table =
  358. &da9063l_bb_da_volatile_table;
  359. break;
  360. case PMIC_DA9063_DA:
  361. da9063_regmap_config.rd_table =
  362. &da9063l_da_readable_table;
  363. da9063_regmap_config.wr_table =
  364. &da9063l_da_writeable_table;
  365. da9063_regmap_config.volatile_table =
  366. &da9063l_bb_da_volatile_table;
  367. break;
  368. default:
  369. dev_err(da9063->dev,
  370. "Chip variant not supported for DA9063L\n");
  371. return -ENODEV;
  372. }
  373. break;
  374. default:
  375. dev_err(da9063->dev, "Chip type not supported\n");
  376. return -ENODEV;
  377. }
  378. da9063->regmap = devm_regmap_init_i2c(i2c, &da9063_regmap_config);
  379. if (IS_ERR(da9063->regmap)) {
  380. ret = PTR_ERR(da9063->regmap);
  381. dev_err(da9063->dev, "Failed to allocate register map: %d\n",
  382. ret);
  383. return ret;
  384. }
  385. /* If SMBus is not available and only I2C is possible, enter I2C mode */
  386. if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C)) {
  387. ret = regmap_clear_bits(da9063->regmap, DA9063_REG_CONFIG_J,
  388. DA9063_TWOWIRE_TO);
  389. if (ret < 0) {
  390. dev_err(da9063->dev, "Failed to set Two-Wire Bus Mode.\n");
  391. return -EIO;
  392. }
  393. }
  394. return da9063_device_init(da9063, i2c->irq);
  395. }
  396. static const struct i2c_device_id da9063_i2c_id[] = {
  397. { "da9063", PMIC_TYPE_DA9063 },
  398. { "da9063l", PMIC_TYPE_DA9063L },
  399. {},
  400. };
  401. MODULE_DEVICE_TABLE(i2c, da9063_i2c_id);
  402. static struct i2c_driver da9063_i2c_driver = {
  403. .driver = {
  404. .name = "da9063",
  405. .of_match_table = of_match_ptr(da9063_dt_ids),
  406. },
  407. .probe = da9063_i2c_probe,
  408. .id_table = da9063_i2c_id,
  409. };
  410. module_i2c_driver(da9063_i2c_driver);