da903x.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Base driver for Dialog Semiconductor DA9030/DA9034
  4. *
  5. * Copyright (C) 2008 Compulab, Ltd.
  6. * Mike Rapoport <[email protected]>
  7. *
  8. * Copyright (C) 2006-2008 Marvell International Ltd.
  9. * Eric Miao <[email protected]>
  10. */
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/platform_device.h>
  15. #include <linux/i2c.h>
  16. #include <linux/mfd/da903x.h>
  17. #include <linux/slab.h>
  18. #define DA9030_CHIP_ID 0x00
  19. #define DA9030_EVENT_A 0x01
  20. #define DA9030_EVENT_B 0x02
  21. #define DA9030_EVENT_C 0x03
  22. #define DA9030_STATUS 0x04
  23. #define DA9030_IRQ_MASK_A 0x05
  24. #define DA9030_IRQ_MASK_B 0x06
  25. #define DA9030_IRQ_MASK_C 0x07
  26. #define DA9030_SYS_CTRL_A 0x08
  27. #define DA9030_SYS_CTRL_B 0x09
  28. #define DA9030_FAULT_LOG 0x0a
  29. #define DA9034_CHIP_ID 0x00
  30. #define DA9034_EVENT_A 0x01
  31. #define DA9034_EVENT_B 0x02
  32. #define DA9034_EVENT_C 0x03
  33. #define DA9034_EVENT_D 0x04
  34. #define DA9034_STATUS_A 0x05
  35. #define DA9034_STATUS_B 0x06
  36. #define DA9034_IRQ_MASK_A 0x07
  37. #define DA9034_IRQ_MASK_B 0x08
  38. #define DA9034_IRQ_MASK_C 0x09
  39. #define DA9034_IRQ_MASK_D 0x0a
  40. #define DA9034_SYS_CTRL_A 0x0b
  41. #define DA9034_SYS_CTRL_B 0x0c
  42. #define DA9034_FAULT_LOG 0x0d
  43. struct da903x_chip;
  44. struct da903x_chip_ops {
  45. int (*init_chip)(struct da903x_chip *);
  46. int (*unmask_events)(struct da903x_chip *, unsigned int events);
  47. int (*mask_events)(struct da903x_chip *, unsigned int events);
  48. int (*read_events)(struct da903x_chip *, unsigned int *events);
  49. int (*read_status)(struct da903x_chip *, unsigned int *status);
  50. };
  51. struct da903x_chip {
  52. struct i2c_client *client;
  53. struct device *dev;
  54. const struct da903x_chip_ops *ops;
  55. int type;
  56. uint32_t events_mask;
  57. struct mutex lock;
  58. struct work_struct irq_work;
  59. struct blocking_notifier_head notifier_list;
  60. };
  61. static inline int __da903x_read(struct i2c_client *client,
  62. int reg, uint8_t *val)
  63. {
  64. int ret;
  65. ret = i2c_smbus_read_byte_data(client, reg);
  66. if (ret < 0) {
  67. dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
  68. return ret;
  69. }
  70. *val = (uint8_t)ret;
  71. return 0;
  72. }
  73. static inline int __da903x_reads(struct i2c_client *client, int reg,
  74. int len, uint8_t *val)
  75. {
  76. int ret;
  77. ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
  78. if (ret < 0) {
  79. dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
  80. return ret;
  81. }
  82. return 0;
  83. }
  84. static inline int __da903x_write(struct i2c_client *client,
  85. int reg, uint8_t val)
  86. {
  87. int ret;
  88. ret = i2c_smbus_write_byte_data(client, reg, val);
  89. if (ret < 0) {
  90. dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
  91. val, reg);
  92. return ret;
  93. }
  94. return 0;
  95. }
  96. static inline int __da903x_writes(struct i2c_client *client, int reg,
  97. int len, uint8_t *val)
  98. {
  99. int ret;
  100. ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
  101. if (ret < 0) {
  102. dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
  103. return ret;
  104. }
  105. return 0;
  106. }
  107. int da903x_register_notifier(struct device *dev, struct notifier_block *nb,
  108. unsigned int events)
  109. {
  110. struct da903x_chip *chip = dev_get_drvdata(dev);
  111. chip->ops->unmask_events(chip, events);
  112. return blocking_notifier_chain_register(&chip->notifier_list, nb);
  113. }
  114. EXPORT_SYMBOL_GPL(da903x_register_notifier);
  115. int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb,
  116. unsigned int events)
  117. {
  118. struct da903x_chip *chip = dev_get_drvdata(dev);
  119. chip->ops->mask_events(chip, events);
  120. return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
  121. }
  122. EXPORT_SYMBOL_GPL(da903x_unregister_notifier);
  123. int da903x_write(struct device *dev, int reg, uint8_t val)
  124. {
  125. return __da903x_write(to_i2c_client(dev), reg, val);
  126. }
  127. EXPORT_SYMBOL_GPL(da903x_write);
  128. int da903x_writes(struct device *dev, int reg, int len, uint8_t *val)
  129. {
  130. return __da903x_writes(to_i2c_client(dev), reg, len, val);
  131. }
  132. EXPORT_SYMBOL_GPL(da903x_writes);
  133. int da903x_read(struct device *dev, int reg, uint8_t *val)
  134. {
  135. return __da903x_read(to_i2c_client(dev), reg, val);
  136. }
  137. EXPORT_SYMBOL_GPL(da903x_read);
  138. int da903x_reads(struct device *dev, int reg, int len, uint8_t *val)
  139. {
  140. return __da903x_reads(to_i2c_client(dev), reg, len, val);
  141. }
  142. EXPORT_SYMBOL_GPL(da903x_reads);
  143. int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
  144. {
  145. struct da903x_chip *chip = dev_get_drvdata(dev);
  146. uint8_t reg_val;
  147. int ret = 0;
  148. mutex_lock(&chip->lock);
  149. ret = __da903x_read(chip->client, reg, &reg_val);
  150. if (ret)
  151. goto out;
  152. if ((reg_val & bit_mask) != bit_mask) {
  153. reg_val |= bit_mask;
  154. ret = __da903x_write(chip->client, reg, reg_val);
  155. }
  156. out:
  157. mutex_unlock(&chip->lock);
  158. return ret;
  159. }
  160. EXPORT_SYMBOL_GPL(da903x_set_bits);
  161. int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
  162. {
  163. struct da903x_chip *chip = dev_get_drvdata(dev);
  164. uint8_t reg_val;
  165. int ret = 0;
  166. mutex_lock(&chip->lock);
  167. ret = __da903x_read(chip->client, reg, &reg_val);
  168. if (ret)
  169. goto out;
  170. if (reg_val & bit_mask) {
  171. reg_val &= ~bit_mask;
  172. ret = __da903x_write(chip->client, reg, reg_val);
  173. }
  174. out:
  175. mutex_unlock(&chip->lock);
  176. return ret;
  177. }
  178. EXPORT_SYMBOL_GPL(da903x_clr_bits);
  179. int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
  180. {
  181. struct da903x_chip *chip = dev_get_drvdata(dev);
  182. uint8_t reg_val;
  183. int ret = 0;
  184. mutex_lock(&chip->lock);
  185. ret = __da903x_read(chip->client, reg, &reg_val);
  186. if (ret)
  187. goto out;
  188. if ((reg_val & mask) != val) {
  189. reg_val = (reg_val & ~mask) | val;
  190. ret = __da903x_write(chip->client, reg, reg_val);
  191. }
  192. out:
  193. mutex_unlock(&chip->lock);
  194. return ret;
  195. }
  196. EXPORT_SYMBOL_GPL(da903x_update);
  197. int da903x_query_status(struct device *dev, unsigned int sbits)
  198. {
  199. struct da903x_chip *chip = dev_get_drvdata(dev);
  200. unsigned int status = 0;
  201. chip->ops->read_status(chip, &status);
  202. return ((status & sbits) == sbits);
  203. }
  204. EXPORT_SYMBOL(da903x_query_status);
  205. static int da9030_init_chip(struct da903x_chip *chip)
  206. {
  207. uint8_t chip_id;
  208. int err;
  209. err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id);
  210. if (err)
  211. return err;
  212. err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8);
  213. if (err)
  214. return err;
  215. dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id);
  216. return 0;
  217. }
  218. static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events)
  219. {
  220. uint8_t v[3];
  221. chip->events_mask &= ~events;
  222. v[0] = (chip->events_mask & 0xff);
  223. v[1] = (chip->events_mask >> 8) & 0xff;
  224. v[2] = (chip->events_mask >> 16) & 0xff;
  225. return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
  226. }
  227. static int da9030_mask_events(struct da903x_chip *chip, unsigned int events)
  228. {
  229. uint8_t v[3];
  230. chip->events_mask |= events;
  231. v[0] = (chip->events_mask & 0xff);
  232. v[1] = (chip->events_mask >> 8) & 0xff;
  233. v[2] = (chip->events_mask >> 16) & 0xff;
  234. return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
  235. }
  236. static int da9030_read_events(struct da903x_chip *chip, unsigned int *events)
  237. {
  238. uint8_t v[3] = {0, 0, 0};
  239. int ret;
  240. ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v);
  241. if (ret < 0)
  242. return ret;
  243. *events = (v[2] << 16) | (v[1] << 8) | v[0];
  244. return 0;
  245. }
  246. static int da9030_read_status(struct da903x_chip *chip, unsigned int *status)
  247. {
  248. return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status);
  249. }
  250. static int da9034_init_chip(struct da903x_chip *chip)
  251. {
  252. uint8_t chip_id;
  253. int err;
  254. err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id);
  255. if (err)
  256. return err;
  257. err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8);
  258. if (err)
  259. return err;
  260. /* avoid SRAM power off during sleep*/
  261. __da903x_write(chip->client, 0x10, 0x07);
  262. __da903x_write(chip->client, 0x11, 0xff);
  263. __da903x_write(chip->client, 0x12, 0xff);
  264. /* Enable the ONKEY power down functionality */
  265. __da903x_write(chip->client, DA9034_SYS_CTRL_B, 0x20);
  266. __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0x60);
  267. /* workaround to make LEDs work */
  268. __da903x_write(chip->client, 0x90, 0x01);
  269. __da903x_write(chip->client, 0xB0, 0x08);
  270. /* make ADTV1 and SDTV1 effective */
  271. __da903x_write(chip->client, 0x20, 0x00);
  272. dev_info(chip->dev, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id);
  273. return 0;
  274. }
  275. static int da9034_unmask_events(struct da903x_chip *chip, unsigned int events)
  276. {
  277. uint8_t v[4];
  278. chip->events_mask &= ~events;
  279. v[0] = (chip->events_mask & 0xff);
  280. v[1] = (chip->events_mask >> 8) & 0xff;
  281. v[2] = (chip->events_mask >> 16) & 0xff;
  282. v[3] = (chip->events_mask >> 24) & 0xff;
  283. return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
  284. }
  285. static int da9034_mask_events(struct da903x_chip *chip, unsigned int events)
  286. {
  287. uint8_t v[4];
  288. chip->events_mask |= events;
  289. v[0] = (chip->events_mask & 0xff);
  290. v[1] = (chip->events_mask >> 8) & 0xff;
  291. v[2] = (chip->events_mask >> 16) & 0xff;
  292. v[3] = (chip->events_mask >> 24) & 0xff;
  293. return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
  294. }
  295. static int da9034_read_events(struct da903x_chip *chip, unsigned int *events)
  296. {
  297. uint8_t v[4] = {0, 0, 0, 0};
  298. int ret;
  299. ret = __da903x_reads(chip->client, DA9034_EVENT_A, 4, v);
  300. if (ret < 0)
  301. return ret;
  302. *events = (v[3] << 24) | (v[2] << 16) | (v[1] << 8) | v[0];
  303. return 0;
  304. }
  305. static int da9034_read_status(struct da903x_chip *chip, unsigned int *status)
  306. {
  307. uint8_t v[2] = {0, 0};
  308. int ret = 0;
  309. ret = __da903x_reads(chip->client, DA9034_STATUS_A, 2, v);
  310. if (ret)
  311. return ret;
  312. *status = (v[1] << 8) | v[0];
  313. return 0;
  314. }
  315. static void da903x_irq_work(struct work_struct *work)
  316. {
  317. struct da903x_chip *chip =
  318. container_of(work, struct da903x_chip, irq_work);
  319. unsigned int events = 0;
  320. while (1) {
  321. if (chip->ops->read_events(chip, &events))
  322. break;
  323. events &= ~chip->events_mask;
  324. if (events == 0)
  325. break;
  326. blocking_notifier_call_chain(
  327. &chip->notifier_list, events, NULL);
  328. }
  329. enable_irq(chip->client->irq);
  330. }
  331. static irqreturn_t da903x_irq_handler(int irq, void *data)
  332. {
  333. struct da903x_chip *chip = data;
  334. disable_irq_nosync(irq);
  335. (void)schedule_work(&chip->irq_work);
  336. return IRQ_HANDLED;
  337. }
  338. static const struct da903x_chip_ops da903x_ops[] = {
  339. [0] = {
  340. .init_chip = da9030_init_chip,
  341. .unmask_events = da9030_unmask_events,
  342. .mask_events = da9030_mask_events,
  343. .read_events = da9030_read_events,
  344. .read_status = da9030_read_status,
  345. },
  346. [1] = {
  347. .init_chip = da9034_init_chip,
  348. .unmask_events = da9034_unmask_events,
  349. .mask_events = da9034_mask_events,
  350. .read_events = da9034_read_events,
  351. .read_status = da9034_read_status,
  352. }
  353. };
  354. static const struct i2c_device_id da903x_id_table[] = {
  355. { "da9030", 0 },
  356. { "da9034", 1 },
  357. { },
  358. };
  359. MODULE_DEVICE_TABLE(i2c, da903x_id_table);
  360. static int __remove_subdev(struct device *dev, void *unused)
  361. {
  362. platform_device_unregister(to_platform_device(dev));
  363. return 0;
  364. }
  365. static int da903x_remove_subdevs(struct da903x_chip *chip)
  366. {
  367. return device_for_each_child(chip->dev, NULL, __remove_subdev);
  368. }
  369. static int da903x_add_subdevs(struct da903x_chip *chip,
  370. struct da903x_platform_data *pdata)
  371. {
  372. struct da903x_subdev_info *subdev;
  373. struct platform_device *pdev;
  374. int i, ret = 0;
  375. for (i = 0; i < pdata->num_subdevs; i++) {
  376. subdev = &pdata->subdevs[i];
  377. pdev = platform_device_alloc(subdev->name, subdev->id);
  378. if (!pdev) {
  379. ret = -ENOMEM;
  380. goto failed;
  381. }
  382. pdev->dev.parent = chip->dev;
  383. pdev->dev.platform_data = subdev->platform_data;
  384. ret = platform_device_add(pdev);
  385. if (ret) {
  386. platform_device_put(pdev);
  387. goto failed;
  388. }
  389. }
  390. return 0;
  391. failed:
  392. da903x_remove_subdevs(chip);
  393. return ret;
  394. }
  395. static int da903x_probe(struct i2c_client *client,
  396. const struct i2c_device_id *id)
  397. {
  398. struct da903x_platform_data *pdata = dev_get_platdata(&client->dev);
  399. struct da903x_chip *chip;
  400. unsigned int tmp;
  401. int ret;
  402. chip = devm_kzalloc(&client->dev, sizeof(struct da903x_chip),
  403. GFP_KERNEL);
  404. if (chip == NULL)
  405. return -ENOMEM;
  406. chip->client = client;
  407. chip->dev = &client->dev;
  408. chip->ops = &da903x_ops[id->driver_data];
  409. mutex_init(&chip->lock);
  410. INIT_WORK(&chip->irq_work, da903x_irq_work);
  411. BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);
  412. i2c_set_clientdata(client, chip);
  413. ret = chip->ops->init_chip(chip);
  414. if (ret)
  415. return ret;
  416. /* mask and clear all IRQs */
  417. chip->events_mask = 0xffffffff;
  418. chip->ops->mask_events(chip, chip->events_mask);
  419. chip->ops->read_events(chip, &tmp);
  420. ret = devm_request_irq(&client->dev, client->irq, da903x_irq_handler,
  421. IRQF_TRIGGER_FALLING,
  422. "da903x", chip);
  423. if (ret) {
  424. dev_err(&client->dev, "failed to request irq %d\n",
  425. client->irq);
  426. return ret;
  427. }
  428. return da903x_add_subdevs(chip, pdata);
  429. }
  430. static void da903x_remove(struct i2c_client *client)
  431. {
  432. struct da903x_chip *chip = i2c_get_clientdata(client);
  433. da903x_remove_subdevs(chip);
  434. }
  435. static struct i2c_driver da903x_driver = {
  436. .driver = {
  437. .name = "da903x",
  438. },
  439. .probe = da903x_probe,
  440. .remove = da903x_remove,
  441. .id_table = da903x_id_table,
  442. };
  443. static int __init da903x_init(void)
  444. {
  445. return i2c_add_driver(&da903x_driver);
  446. }
  447. subsys_initcall(da903x_init);
  448. static void __exit da903x_exit(void)
  449. {
  450. i2c_del_driver(&da903x_driver);
  451. }
  452. module_exit(da903x_exit);
  453. MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
  454. MODULE_AUTHOR("Eric Miao <[email protected]>");
  455. MODULE_AUTHOR("Mike Rapoport <[email protected]>");
  456. MODULE_LICENSE("GPL v2");