tps6586x.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Core driver for TI TPS6586x PMIC family
  4. *
  5. * Copyright (c) 2010 CompuLab Ltd.
  6. * Mike Rapoport <mike@compulab.co.il>
  7. *
  8. * Based on da903x.c.
  9. * Copyright (C) 2008 Compulab, Ltd.
  10. * Mike Rapoport <mike@compulab.co.il>
  11. * Copyright (C) 2006-2008 Marvell International Ltd.
  12. * Eric Miao <eric.miao@marvell.com>
  13. */
  14. #include <linux/interrupt.h>
  15. #include <linux/irq.h>
  16. #include <linux/irqdomain.h>
  17. #include <linux/kernel.h>
  18. #include <linux/module.h>
  19. #include <linux/mutex.h>
  20. #include <linux/slab.h>
  21. #include <linux/err.h>
  22. #include <linux/i2c.h>
  23. #include <linux/platform_device.h>
  24. #include <linux/regmap.h>
  25. #include <linux/of.h>
  26. #include <linux/mfd/core.h>
  27. #include <linux/mfd/tps6586x.h>
  28. #define TPS6586X_SUPPLYENE 0x14
  29. #define EXITSLREQ_BIT BIT(1)
  30. #define SLEEP_MODE_BIT BIT(3)
  31. /* interrupt control registers */
  32. #define TPS6586X_INT_ACK1 0xb5
  33. #define TPS6586X_INT_ACK2 0xb6
  34. #define TPS6586X_INT_ACK3 0xb7
  35. #define TPS6586X_INT_ACK4 0xb8
  36. /* interrupt mask registers */
  37. #define TPS6586X_INT_MASK1 0xb0
  38. #define TPS6586X_INT_MASK2 0xb1
  39. #define TPS6586X_INT_MASK3 0xb2
  40. #define TPS6586X_INT_MASK4 0xb3
  41. #define TPS6586X_INT_MASK5 0xb4
  42. /* device id */
  43. #define TPS6586X_VERSIONCRC 0xcd
  44. /* Maximum register */
  45. #define TPS6586X_MAX_REGISTER TPS6586X_VERSIONCRC
  46. struct tps6586x_irq_data {
  47. u8 mask_reg;
  48. u8 mask_mask;
  49. };
  50. #define TPS6586X_IRQ(_reg, _mask) \
  51. { \
  52. .mask_reg = (_reg) - TPS6586X_INT_MASK1, \
  53. .mask_mask = (_mask), \
  54. }
  55. static const struct tps6586x_irq_data tps6586x_irqs[] = {
  56. [TPS6586X_INT_PLDO_0] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 0),
  57. [TPS6586X_INT_PLDO_1] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 1),
  58. [TPS6586X_INT_PLDO_2] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 2),
  59. [TPS6586X_INT_PLDO_3] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 3),
  60. [TPS6586X_INT_PLDO_4] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 4),
  61. [TPS6586X_INT_PLDO_5] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 5),
  62. [TPS6586X_INT_PLDO_6] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 6),
  63. [TPS6586X_INT_PLDO_7] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 7),
  64. [TPS6586X_INT_COMP_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 0),
  65. [TPS6586X_INT_ADC] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 1),
  66. [TPS6586X_INT_PLDO_8] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 2),
  67. [TPS6586X_INT_PLDO_9] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 3),
  68. [TPS6586X_INT_PSM_0] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 4),
  69. [TPS6586X_INT_PSM_1] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 5),
  70. [TPS6586X_INT_PSM_2] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 6),
  71. [TPS6586X_INT_PSM_3] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 7),
  72. [TPS6586X_INT_RTC_ALM1] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 4),
  73. [TPS6586X_INT_ACUSB_OVP] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 0x03),
  74. [TPS6586X_INT_USB_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 2),
  75. [TPS6586X_INT_AC_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 3),
  76. [TPS6586X_INT_BAT_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 1 << 0),
  77. [TPS6586X_INT_CHG_STAT] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 0xfc),
  78. [TPS6586X_INT_CHG_TEMP] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0x06),
  79. [TPS6586X_INT_PP] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0xf0),
  80. [TPS6586X_INT_RESUME] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 5),
  81. [TPS6586X_INT_LOW_SYS] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 6),
  82. [TPS6586X_INT_RTC_ALM2] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 1),
  83. };
  84. static struct resource tps6586x_rtc_resources[] = {
  85. {
  86. .start = TPS6586X_INT_RTC_ALM1,
  87. .end = TPS6586X_INT_RTC_ALM1,
  88. .flags = IORESOURCE_IRQ,
  89. },
  90. };
  91. static const struct mfd_cell tps6586x_cell[] = {
  92. {
  93. .name = "tps6586x-gpio",
  94. },
  95. {
  96. .name = "tps6586x-regulator",
  97. },
  98. {
  99. .name = "tps6586x-rtc",
  100. .num_resources = ARRAY_SIZE(tps6586x_rtc_resources),
  101. .resources = &tps6586x_rtc_resources[0],
  102. },
  103. {
  104. .name = "tps6586x-onkey",
  105. },
  106. };
  107. struct tps6586x {
  108. struct device *dev;
  109. struct i2c_client *client;
  110. struct regmap *regmap;
  111. int version;
  112. int irq;
  113. struct irq_chip irq_chip;
  114. struct mutex irq_lock;
  115. int irq_base;
  116. u32 irq_en;
  117. u8 mask_reg[5];
  118. struct irq_domain *irq_domain;
  119. };
  120. static inline struct tps6586x *dev_to_tps6586x(struct device *dev)
  121. {
  122. return i2c_get_clientdata(to_i2c_client(dev));
  123. }
  124. int tps6586x_write(struct device *dev, int reg, uint8_t val)
  125. {
  126. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  127. return regmap_write(tps6586x->regmap, reg, val);
  128. }
  129. EXPORT_SYMBOL_GPL(tps6586x_write);
  130. int tps6586x_writes(struct device *dev, int reg, int len, uint8_t *val)
  131. {
  132. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  133. return regmap_bulk_write(tps6586x->regmap, reg, val, len);
  134. }
  135. EXPORT_SYMBOL_GPL(tps6586x_writes);
  136. int tps6586x_read(struct device *dev, int reg, uint8_t *val)
  137. {
  138. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  139. unsigned int rval;
  140. int ret;
  141. ret = regmap_read(tps6586x->regmap, reg, &rval);
  142. if (!ret)
  143. *val = rval;
  144. return ret;
  145. }
  146. EXPORT_SYMBOL_GPL(tps6586x_read);
  147. int tps6586x_reads(struct device *dev, int reg, int len, uint8_t *val)
  148. {
  149. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  150. return regmap_bulk_read(tps6586x->regmap, reg, val, len);
  151. }
  152. EXPORT_SYMBOL_GPL(tps6586x_reads);
  153. int tps6586x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
  154. {
  155. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  156. return regmap_update_bits(tps6586x->regmap, reg, bit_mask, bit_mask);
  157. }
  158. EXPORT_SYMBOL_GPL(tps6586x_set_bits);
  159. int tps6586x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
  160. {
  161. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  162. return regmap_update_bits(tps6586x->regmap, reg, bit_mask, 0);
  163. }
  164. EXPORT_SYMBOL_GPL(tps6586x_clr_bits);
  165. int tps6586x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
  166. {
  167. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  168. return regmap_update_bits(tps6586x->regmap, reg, mask, val);
  169. }
  170. EXPORT_SYMBOL_GPL(tps6586x_update);
  171. int tps6586x_irq_get_virq(struct device *dev, int irq)
  172. {
  173. struct tps6586x *tps6586x = dev_to_tps6586x(dev);
  174. return irq_create_mapping(tps6586x->irq_domain, irq);
  175. }
  176. EXPORT_SYMBOL_GPL(tps6586x_irq_get_virq);
  177. int tps6586x_get_version(struct device *dev)
  178. {
  179. struct tps6586x *tps6586x = dev_get_drvdata(dev);
  180. return tps6586x->version;
  181. }
  182. EXPORT_SYMBOL_GPL(tps6586x_get_version);
  183. static int __remove_subdev(struct device *dev, void *unused)
  184. {
  185. platform_device_unregister(to_platform_device(dev));
  186. return 0;
  187. }
  188. static int tps6586x_remove_subdevs(struct tps6586x *tps6586x)
  189. {
  190. return device_for_each_child(tps6586x->dev, NULL, __remove_subdev);
  191. }
  192. static void tps6586x_irq_lock(struct irq_data *data)
  193. {
  194. struct tps6586x *tps6586x = irq_data_get_irq_chip_data(data);
  195. mutex_lock(&tps6586x->irq_lock);
  196. }
  197. static void tps6586x_irq_enable(struct irq_data *irq_data)
  198. {
  199. struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
  200. unsigned int __irq = irq_data->hwirq;
  201. const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
  202. tps6586x->mask_reg[data->mask_reg] &= ~data->mask_mask;
  203. tps6586x->irq_en |= (1 << __irq);
  204. }
  205. static void tps6586x_irq_disable(struct irq_data *irq_data)
  206. {
  207. struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
  208. unsigned int __irq = irq_data->hwirq;
  209. const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
  210. tps6586x->mask_reg[data->mask_reg] |= data->mask_mask;
  211. tps6586x->irq_en &= ~(1 << __irq);
  212. }
  213. static void tps6586x_irq_sync_unlock(struct irq_data *data)
  214. {
  215. struct tps6586x *tps6586x = irq_data_get_irq_chip_data(data);
  216. int i;
  217. for (i = 0; i < ARRAY_SIZE(tps6586x->mask_reg); i++) {
  218. int ret;
  219. ret = tps6586x_write(tps6586x->dev,
  220. TPS6586X_INT_MASK1 + i,
  221. tps6586x->mask_reg[i]);
  222. WARN_ON(ret);
  223. }
  224. mutex_unlock(&tps6586x->irq_lock);
  225. }
  226. #ifdef CONFIG_PM_SLEEP
  227. static int tps6586x_irq_set_wake(struct irq_data *irq_data, unsigned int on)
  228. {
  229. struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
  230. return irq_set_irq_wake(tps6586x->irq, on);
  231. }
  232. #else
  233. #define tps6586x_irq_set_wake NULL
  234. #endif
  235. static struct irq_chip tps6586x_irq_chip = {
  236. .name = "tps6586x",
  237. .irq_bus_lock = tps6586x_irq_lock,
  238. .irq_bus_sync_unlock = tps6586x_irq_sync_unlock,
  239. .irq_disable = tps6586x_irq_disable,
  240. .irq_enable = tps6586x_irq_enable,
  241. .irq_set_wake = tps6586x_irq_set_wake,
  242. };
  243. static int tps6586x_irq_map(struct irq_domain *h, unsigned int virq,
  244. irq_hw_number_t hw)
  245. {
  246. struct tps6586x *tps6586x = h->host_data;
  247. irq_set_chip_data(virq, tps6586x);
  248. irq_set_chip_and_handler(virq, &tps6586x_irq_chip, handle_simple_irq);
  249. irq_set_nested_thread(virq, 1);
  250. irq_set_noprobe(virq);
  251. return 0;
  252. }
  253. static const struct irq_domain_ops tps6586x_domain_ops = {
  254. .map = tps6586x_irq_map,
  255. .xlate = irq_domain_xlate_twocell,
  256. };
  257. static irqreturn_t tps6586x_irq(int irq, void *data)
  258. {
  259. struct tps6586x *tps6586x = data;
  260. uint32_t acks;
  261. __le32 val;
  262. int ret = 0;
  263. ret = tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1,
  264. sizeof(acks), (uint8_t *)&val);
  265. if (ret < 0) {
  266. dev_err(tps6586x->dev, "failed to read interrupt status\n");
  267. return IRQ_NONE;
  268. }
  269. acks = le32_to_cpu(val);
  270. while (acks) {
  271. int i = __ffs(acks);
  272. if (tps6586x->irq_en & (1 << i))
  273. handle_nested_irq(
  274. irq_find_mapping(tps6586x->irq_domain, i));
  275. acks &= ~(1 << i);
  276. }
  277. return IRQ_HANDLED;
  278. }
  279. static int tps6586x_irq_init(struct tps6586x *tps6586x, int irq,
  280. int irq_base)
  281. {
  282. int i, ret;
  283. u8 tmp[4];
  284. int new_irq_base;
  285. int irq_num = ARRAY_SIZE(tps6586x_irqs);
  286. tps6586x->irq = irq;
  287. mutex_init(&tps6586x->irq_lock);
  288. for (i = 0; i < 5; i++) {
  289. tps6586x->mask_reg[i] = 0xff;
  290. tps6586x_write(tps6586x->dev, TPS6586X_INT_MASK1 + i, 0xff);
  291. }
  292. tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1, sizeof(tmp), tmp);
  293. if (irq_base > 0) {
  294. new_irq_base = irq_alloc_descs(irq_base, 0, irq_num, -1);
  295. if (new_irq_base < 0) {
  296. dev_err(tps6586x->dev,
  297. "Failed to alloc IRQs: %d\n", new_irq_base);
  298. return new_irq_base;
  299. }
  300. } else {
  301. new_irq_base = 0;
  302. }
  303. tps6586x->irq_domain = irq_domain_add_simple(tps6586x->dev->of_node,
  304. irq_num, new_irq_base, &tps6586x_domain_ops,
  305. tps6586x);
  306. if (!tps6586x->irq_domain) {
  307. dev_err(tps6586x->dev, "Failed to create IRQ domain\n");
  308. return -ENOMEM;
  309. }
  310. ret = request_threaded_irq(irq, NULL, tps6586x_irq, IRQF_ONESHOT,
  311. "tps6586x", tps6586x);
  312. if (!ret)
  313. device_init_wakeup(tps6586x->dev, 1);
  314. return ret;
  315. }
  316. static int tps6586x_add_subdevs(struct tps6586x *tps6586x,
  317. struct tps6586x_platform_data *pdata)
  318. {
  319. struct tps6586x_subdev_info *subdev;
  320. struct platform_device *pdev;
  321. int i, ret = 0;
  322. for (i = 0; i < pdata->num_subdevs; i++) {
  323. subdev = &pdata->subdevs[i];
  324. pdev = platform_device_alloc(subdev->name, subdev->id);
  325. if (!pdev) {
  326. ret = -ENOMEM;
  327. goto failed;
  328. }
  329. pdev->dev.parent = tps6586x->dev;
  330. pdev->dev.platform_data = subdev->platform_data;
  331. pdev->dev.of_node = subdev->of_node;
  332. ret = platform_device_add(pdev);
  333. if (ret) {
  334. platform_device_put(pdev);
  335. goto failed;
  336. }
  337. }
  338. return 0;
  339. failed:
  340. tps6586x_remove_subdevs(tps6586x);
  341. return ret;
  342. }
  343. #ifdef CONFIG_OF
  344. static struct tps6586x_platform_data *tps6586x_parse_dt(struct i2c_client *client)
  345. {
  346. struct device_node *np = client->dev.of_node;
  347. struct tps6586x_platform_data *pdata;
  348. pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
  349. if (!pdata)
  350. return NULL;
  351. pdata->num_subdevs = 0;
  352. pdata->subdevs = NULL;
  353. pdata->gpio_base = -1;
  354. pdata->irq_base = -1;
  355. pdata->pm_off = of_property_read_bool(np, "ti,system-power-controller");
  356. return pdata;
  357. }
  358. static const struct of_device_id tps6586x_of_match[] = {
  359. { .compatible = "ti,tps6586x", },
  360. { },
  361. };
  362. #else
  363. static struct tps6586x_platform_data *tps6586x_parse_dt(struct i2c_client *client)
  364. {
  365. return NULL;
  366. }
  367. #endif
  368. static bool is_volatile_reg(struct device *dev, unsigned int reg)
  369. {
  370. /* Cache all interrupt mask register */
  371. if ((reg >= TPS6586X_INT_MASK1) && (reg <= TPS6586X_INT_MASK5))
  372. return false;
  373. return true;
  374. }
  375. static const struct regmap_config tps6586x_regmap_config = {
  376. .reg_bits = 8,
  377. .val_bits = 8,
  378. .max_register = TPS6586X_MAX_REGISTER,
  379. .volatile_reg = is_volatile_reg,
  380. .cache_type = REGCACHE_RBTREE,
  381. };
  382. static struct device *tps6586x_dev;
  383. static void tps6586x_power_off(void)
  384. {
  385. if (tps6586x_clr_bits(tps6586x_dev, TPS6586X_SUPPLYENE, EXITSLREQ_BIT))
  386. return;
  387. tps6586x_set_bits(tps6586x_dev, TPS6586X_SUPPLYENE, SLEEP_MODE_BIT);
  388. }
  389. static void tps6586x_print_version(struct i2c_client *client, int version)
  390. {
  391. const char *name;
  392. switch (version) {
  393. case TPS658621A:
  394. name = "TPS658621A";
  395. break;
  396. case TPS658621CD:
  397. name = "TPS658621C/D";
  398. break;
  399. case TPS658623:
  400. name = "TPS658623";
  401. break;
  402. case TPS658640:
  403. case TPS658640v2:
  404. name = "TPS658640";
  405. break;
  406. case TPS658643:
  407. name = "TPS658643";
  408. break;
  409. default:
  410. name = "TPS6586X";
  411. break;
  412. }
  413. dev_info(&client->dev, "Found %s, VERSIONCRC is %02x\n", name, version);
  414. }
  415. static int tps6586x_i2c_probe(struct i2c_client *client,
  416. const struct i2c_device_id *id)
  417. {
  418. struct tps6586x_platform_data *pdata = dev_get_platdata(&client->dev);
  419. struct tps6586x *tps6586x;
  420. int ret;
  421. int version;
  422. if (!pdata && client->dev.of_node)
  423. pdata = tps6586x_parse_dt(client);
  424. if (!pdata) {
  425. dev_err(&client->dev, "tps6586x requires platform data\n");
  426. return -ENOTSUPP;
  427. }
  428. version = i2c_smbus_read_byte_data(client, TPS6586X_VERSIONCRC);
  429. if (version < 0) {
  430. dev_err(&client->dev, "Chip ID read failed: %d\n", version);
  431. return -EIO;
  432. }
  433. tps6586x = devm_kzalloc(&client->dev, sizeof(*tps6586x), GFP_KERNEL);
  434. if (!tps6586x)
  435. return -ENOMEM;
  436. tps6586x->version = version;
  437. tps6586x_print_version(client, tps6586x->version);
  438. tps6586x->client = client;
  439. tps6586x->dev = &client->dev;
  440. i2c_set_clientdata(client, tps6586x);
  441. tps6586x->regmap = devm_regmap_init_i2c(client,
  442. &tps6586x_regmap_config);
  443. if (IS_ERR(tps6586x->regmap)) {
  444. ret = PTR_ERR(tps6586x->regmap);
  445. dev_err(&client->dev, "regmap init failed: %d\n", ret);
  446. return ret;
  447. }
  448. if (client->irq) {
  449. ret = tps6586x_irq_init(tps6586x, client->irq,
  450. pdata->irq_base);
  451. if (ret) {
  452. dev_err(&client->dev, "IRQ init failed: %d\n", ret);
  453. return ret;
  454. }
  455. }
  456. ret = mfd_add_devices(tps6586x->dev, -1,
  457. tps6586x_cell, ARRAY_SIZE(tps6586x_cell),
  458. NULL, 0, tps6586x->irq_domain);
  459. if (ret < 0) {
  460. dev_err(&client->dev, "mfd_add_devices failed: %d\n", ret);
  461. goto err_mfd_add;
  462. }
  463. ret = tps6586x_add_subdevs(tps6586x, pdata);
  464. if (ret) {
  465. dev_err(&client->dev, "add devices failed: %d\n", ret);
  466. goto err_add_devs;
  467. }
  468. if (pdata->pm_off && !pm_power_off) {
  469. tps6586x_dev = &client->dev;
  470. pm_power_off = tps6586x_power_off;
  471. }
  472. return 0;
  473. err_add_devs:
  474. mfd_remove_devices(tps6586x->dev);
  475. err_mfd_add:
  476. if (client->irq)
  477. free_irq(client->irq, tps6586x);
  478. return ret;
  479. }
  480. static int tps6586x_i2c_remove(struct i2c_client *client)
  481. {
  482. struct tps6586x *tps6586x = i2c_get_clientdata(client);
  483. tps6586x_remove_subdevs(tps6586x);
  484. mfd_remove_devices(tps6586x->dev);
  485. if (client->irq)
  486. free_irq(client->irq, tps6586x);
  487. return 0;
  488. }
  489. static int __maybe_unused tps6586x_i2c_suspend(struct device *dev)
  490. {
  491. struct tps6586x *tps6586x = dev_get_drvdata(dev);
  492. if (tps6586x->client->irq)
  493. disable_irq(tps6586x->client->irq);
  494. return 0;
  495. }
  496. static int __maybe_unused tps6586x_i2c_resume(struct device *dev)
  497. {
  498. struct tps6586x *tps6586x = dev_get_drvdata(dev);
  499. if (tps6586x->client->irq)
  500. enable_irq(tps6586x->client->irq);
  501. return 0;
  502. }
  503. static SIMPLE_DEV_PM_OPS(tps6586x_pm_ops, tps6586x_i2c_suspend,
  504. tps6586x_i2c_resume);
  505. static const struct i2c_device_id tps6586x_id_table[] = {
  506. { "tps6586x", 0 },
  507. { },
  508. };
  509. MODULE_DEVICE_TABLE(i2c, tps6586x_id_table);
  510. static struct i2c_driver tps6586x_driver = {
  511. .driver = {
  512. .name = "tps6586x",
  513. .of_match_table = of_match_ptr(tps6586x_of_match),
  514. .pm = &tps6586x_pm_ops,
  515. },
  516. .probe = tps6586x_i2c_probe,
  517. .remove = tps6586x_i2c_remove,
  518. .id_table = tps6586x_id_table,
  519. };
  520. static int __init tps6586x_init(void)
  521. {
  522. return i2c_add_driver(&tps6586x_driver);
  523. }
  524. subsys_initcall(tps6586x_init);
  525. static void __exit tps6586x_exit(void)
  526. {
  527. i2c_del_driver(&tps6586x_driver);
  528. }
  529. module_exit(tps6586x_exit);
  530. MODULE_DESCRIPTION("TPS6586X core driver");
  531. MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
  532. MODULE_LICENSE("GPL");