tps65090.c 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275
  1. /*
  2. * Core driver for TI TPS65090 PMIC family
  3. *
  4. * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms and conditions of the GNU General Public License,
  7. * version 2, as published by the Free Software Foundation.
  8. * This program is distributed in the hope it will be useful, but WITHOUT
  9. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11. * more details.
  12. * You should have received a copy of the GNU General Public License
  13. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  14. */
  15. #include <linux/interrupt.h>
  16. #include <linux/irq.h>
  17. #include <linux/kernel.h>
  18. #include <linux/module.h>
  19. #include <linux/mutex.h>
  20. #include <linux/slab.h>
  21. #include <linux/i2c.h>
  22. #include <linux/mfd/core.h>
  23. #include <linux/mfd/tps65090.h>
  24. #include <linux/of.h>
  25. #include <linux/of_device.h>
  26. #include <linux/err.h>
  27. #define NUM_INT_REG 2
  28. #define TOTAL_NUM_REG 0x18
  29. /* interrupt status registers */
  30. #define TPS65090_INT_STS 0x0
  31. #define TPS65090_INT_STS2 0x1
  32. /* interrupt mask registers */
  33. #define TPS65090_INT_MSK 0x2
  34. #define TPS65090_INT_MSK2 0x3
  35. #define TPS65090_INT1_MASK_VAC_STATUS_CHANGE 1
  36. #define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE 2
  37. #define TPS65090_INT1_MASK_BAT_STATUS_CHANGE 3
  38. #define TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE 4
  39. #define TPS65090_INT1_MASK_CHARGING_COMPLETE 5
  40. #define TPS65090_INT1_MASK_OVERLOAD_DCDC1 6
  41. #define TPS65090_INT1_MASK_OVERLOAD_DCDC2 7
  42. #define TPS65090_INT2_MASK_OVERLOAD_DCDC3 0
  43. #define TPS65090_INT2_MASK_OVERLOAD_FET1 1
  44. #define TPS65090_INT2_MASK_OVERLOAD_FET2 2
  45. #define TPS65090_INT2_MASK_OVERLOAD_FET3 3
  46. #define TPS65090_INT2_MASK_OVERLOAD_FET4 4
  47. #define TPS65090_INT2_MASK_OVERLOAD_FET5 5
  48. #define TPS65090_INT2_MASK_OVERLOAD_FET6 6
  49. #define TPS65090_INT2_MASK_OVERLOAD_FET7 7
  50. static struct resource charger_resources[] = {
  51. {
  52. .start = TPS65090_IRQ_VAC_STATUS_CHANGE,
  53. .end = TPS65090_IRQ_VAC_STATUS_CHANGE,
  54. .flags = IORESOURCE_IRQ,
  55. }
  56. };
  57. static struct mfd_cell tps65090s[] = {
  58. {
  59. .name = "tps65090-pmic",
  60. },
  61. {
  62. .name = "tps65090-charger",
  63. .num_resources = ARRAY_SIZE(charger_resources),
  64. .resources = &charger_resources[0],
  65. .of_compatible = "ti,tps65090-charger",
  66. },
  67. };
  68. static const struct regmap_irq tps65090_irqs[] = {
  69. /* INT1 IRQs*/
  70. [TPS65090_IRQ_VAC_STATUS_CHANGE] = {
  71. .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE,
  72. },
  73. [TPS65090_IRQ_VSYS_STATUS_CHANGE] = {
  74. .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE,
  75. },
  76. [TPS65090_IRQ_BAT_STATUS_CHANGE] = {
  77. .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE,
  78. },
  79. [TPS65090_IRQ_CHARGING_STATUS_CHANGE] = {
  80. .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE,
  81. },
  82. [TPS65090_IRQ_CHARGING_COMPLETE] = {
  83. .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE,
  84. },
  85. [TPS65090_IRQ_OVERLOAD_DCDC1] = {
  86. .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1,
  87. },
  88. [TPS65090_IRQ_OVERLOAD_DCDC2] = {
  89. .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2,
  90. },
  91. /* INT2 IRQs*/
  92. [TPS65090_IRQ_OVERLOAD_DCDC3] = {
  93. .reg_offset = 1,
  94. .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3,
  95. },
  96. [TPS65090_IRQ_OVERLOAD_FET1] = {
  97. .reg_offset = 1,
  98. .mask = TPS65090_INT2_MASK_OVERLOAD_FET1,
  99. },
  100. [TPS65090_IRQ_OVERLOAD_FET2] = {
  101. .reg_offset = 1,
  102. .mask = TPS65090_INT2_MASK_OVERLOAD_FET2,
  103. },
  104. [TPS65090_IRQ_OVERLOAD_FET3] = {
  105. .reg_offset = 1,
  106. .mask = TPS65090_INT2_MASK_OVERLOAD_FET3,
  107. },
  108. [TPS65090_IRQ_OVERLOAD_FET4] = {
  109. .reg_offset = 1,
  110. .mask = TPS65090_INT2_MASK_OVERLOAD_FET4,
  111. },
  112. [TPS65090_IRQ_OVERLOAD_FET5] = {
  113. .reg_offset = 1,
  114. .mask = TPS65090_INT2_MASK_OVERLOAD_FET5,
  115. },
  116. [TPS65090_IRQ_OVERLOAD_FET6] = {
  117. .reg_offset = 1,
  118. .mask = TPS65090_INT2_MASK_OVERLOAD_FET6,
  119. },
  120. [TPS65090_IRQ_OVERLOAD_FET7] = {
  121. .reg_offset = 1,
  122. .mask = TPS65090_INT2_MASK_OVERLOAD_FET7,
  123. },
  124. };
  125. static struct regmap_irq_chip tps65090_irq_chip = {
  126. .name = "tps65090",
  127. .irqs = tps65090_irqs,
  128. .num_irqs = ARRAY_SIZE(tps65090_irqs),
  129. .num_regs = NUM_INT_REG,
  130. .status_base = TPS65090_INT_STS,
  131. .mask_base = TPS65090_INT_MSK,
  132. .mask_invert = true,
  133. };
  134. static bool is_volatile_reg(struct device *dev, unsigned int reg)
  135. {
  136. if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS2))
  137. return true;
  138. else
  139. return false;
  140. }
  141. static const struct regmap_config tps65090_regmap_config = {
  142. .reg_bits = 8,
  143. .val_bits = 8,
  144. .max_register = TOTAL_NUM_REG,
  145. .num_reg_defaults_raw = TOTAL_NUM_REG,
  146. .cache_type = REGCACHE_RBTREE,
  147. .volatile_reg = is_volatile_reg,
  148. };
  149. #ifdef CONFIG_OF
  150. static const struct of_device_id tps65090_of_match[] = {
  151. { .compatible = "ti,tps65090",},
  152. {},
  153. };
  154. MODULE_DEVICE_TABLE(of, tps65090_of_match);
  155. #endif
  156. static int tps65090_i2c_probe(struct i2c_client *client,
  157. const struct i2c_device_id *id)
  158. {
  159. struct tps65090_platform_data *pdata = dev_get_platdata(&client->dev);
  160. int irq_base = 0;
  161. struct tps65090 *tps65090;
  162. int ret;
  163. if (!pdata && !client->dev.of_node) {
  164. dev_err(&client->dev,
  165. "tps65090 requires platform data or of_node\n");
  166. return -EINVAL;
  167. }
  168. if (pdata)
  169. irq_base = pdata->irq_base;
  170. tps65090 = devm_kzalloc(&client->dev, sizeof(*tps65090), GFP_KERNEL);
  171. if (!tps65090) {
  172. dev_err(&client->dev, "mem alloc for tps65090 failed\n");
  173. return -ENOMEM;
  174. }
  175. tps65090->dev = &client->dev;
  176. i2c_set_clientdata(client, tps65090);
  177. tps65090->rmap = devm_regmap_init_i2c(client, &tps65090_regmap_config);
  178. if (IS_ERR(tps65090->rmap)) {
  179. ret = PTR_ERR(tps65090->rmap);
  180. dev_err(&client->dev, "regmap_init failed with err: %d\n", ret);
  181. return ret;
  182. }
  183. if (client->irq) {
  184. ret = regmap_add_irq_chip(tps65090->rmap, client->irq,
  185. IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base,
  186. &tps65090_irq_chip, &tps65090->irq_data);
  187. if (ret) {
  188. dev_err(&client->dev,
  189. "IRQ init failed with err: %d\n", ret);
  190. return ret;
  191. }
  192. }
  193. ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
  194. ARRAY_SIZE(tps65090s), NULL,
  195. 0, regmap_irq_get_domain(tps65090->irq_data));
  196. if (ret) {
  197. dev_err(&client->dev, "add mfd devices failed with err: %d\n",
  198. ret);
  199. goto err_irq_exit;
  200. }
  201. return 0;
  202. err_irq_exit:
  203. if (client->irq)
  204. regmap_del_irq_chip(client->irq, tps65090->irq_data);
  205. return ret;
  206. }
  207. static int tps65090_i2c_remove(struct i2c_client *client)
  208. {
  209. struct tps65090 *tps65090 = i2c_get_clientdata(client);
  210. mfd_remove_devices(tps65090->dev);
  211. if (client->irq)
  212. regmap_del_irq_chip(client->irq, tps65090->irq_data);
  213. return 0;
  214. }
  215. static const struct i2c_device_id tps65090_id_table[] = {
  216. { "tps65090", 0 },
  217. { },
  218. };
  219. MODULE_DEVICE_TABLE(i2c, tps65090_id_table);
  220. static struct i2c_driver tps65090_driver = {
  221. .driver = {
  222. .name = "tps65090",
  223. .owner = THIS_MODULE,
  224. .of_match_table = of_match_ptr(tps65090_of_match),
  225. },
  226. .probe = tps65090_i2c_probe,
  227. .remove = tps65090_i2c_remove,
  228. .id_table = tps65090_id_table,
  229. };
  230. static int __init tps65090_init(void)
  231. {
  232. return i2c_add_driver(&tps65090_driver);
  233. }
  234. subsys_initcall(tps65090_init);
  235. static void __exit tps65090_exit(void)
  236. {
  237. i2c_del_driver(&tps65090_driver);
  238. }
  239. module_exit(tps65090_exit);
  240. MODULE_DESCRIPTION("TPS65090 core driver");
  241. MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
  242. MODULE_LICENSE("GPL v2");