twl6040-core.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749
  1. /*
  2. * MFD driver for TWL6040 audio device
  3. *
  4. * Authors: Misael Lopez Cruz <misael.lopez@ti.com>
  5. * Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
  6. * Peter Ujfalusi <peter.ujfalusi@ti.com>
  7. *
  8. * Copyright: (C) 2011 Texas Instruments, Inc.
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License version 2 as
  12. * published by the Free Software Foundation.
  13. *
  14. * This program is distributed in the hope that it will be useful, but
  15. * WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  22. * 02110-1301 USA
  23. *
  24. */
  25. #include <linux/module.h>
  26. #include <linux/types.h>
  27. #include <linux/slab.h>
  28. #include <linux/kernel.h>
  29. #include <linux/err.h>
  30. #include <linux/platform_device.h>
  31. #include <linux/of.h>
  32. #include <linux/of_irq.h>
  33. #include <linux/of_gpio.h>
  34. #include <linux/of_platform.h>
  35. #include <linux/gpio.h>
  36. #include <linux/delay.h>
  37. #include <linux/i2c.h>
  38. #include <linux/regmap.h>
  39. #include <linux/err.h>
  40. #include <linux/mfd/core.h>
  41. #include <linux/mfd/twl6040.h>
  42. #include <linux/regulator/consumer.h>
  43. #define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1)
  44. #define TWL6040_NUM_SUPPLIES (2)
  45. static bool twl6040_has_vibra(struct twl6040_platform_data *pdata,
  46. struct device_node *node)
  47. {
  48. if (pdata && pdata->vibra)
  49. return true;
  50. #ifdef CONFIG_OF
  51. if (of_find_node_by_name(node, "vibra"))
  52. return true;
  53. #endif
  54. return false;
  55. }
  56. int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg)
  57. {
  58. int ret;
  59. unsigned int val;
  60. /* Vibra control registers from cache */
  61. if (unlikely(reg == TWL6040_REG_VIBCTLL ||
  62. reg == TWL6040_REG_VIBCTLR)) {
  63. val = twl6040->vibra_ctrl_cache[VIBRACTRL_MEMBER(reg)];
  64. } else {
  65. ret = regmap_read(twl6040->regmap, reg, &val);
  66. if (ret < 0)
  67. return ret;
  68. }
  69. return val;
  70. }
  71. EXPORT_SYMBOL(twl6040_reg_read);
  72. int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg, u8 val)
  73. {
  74. int ret;
  75. ret = regmap_write(twl6040->regmap, reg, val);
  76. /* Cache the vibra control registers */
  77. if (reg == TWL6040_REG_VIBCTLL || reg == TWL6040_REG_VIBCTLR)
  78. twl6040->vibra_ctrl_cache[VIBRACTRL_MEMBER(reg)] = val;
  79. return ret;
  80. }
  81. EXPORT_SYMBOL(twl6040_reg_write);
  82. int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
  83. {
  84. return regmap_update_bits(twl6040->regmap, reg, mask, mask);
  85. }
  86. EXPORT_SYMBOL(twl6040_set_bits);
  87. int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
  88. {
  89. return regmap_update_bits(twl6040->regmap, reg, mask, 0);
  90. }
  91. EXPORT_SYMBOL(twl6040_clear_bits);
  92. /* twl6040 codec manual power-up sequence */
  93. static int twl6040_power_up_manual(struct twl6040 *twl6040)
  94. {
  95. u8 ldoctl, ncpctl, lppllctl;
  96. int ret;
  97. /* enable high-side LDO, reference system and internal oscillator */
  98. ldoctl = TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA;
  99. ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  100. if (ret)
  101. return ret;
  102. usleep_range(10000, 10500);
  103. /* enable negative charge pump */
  104. ncpctl = TWL6040_NCPENA;
  105. ret = twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
  106. if (ret)
  107. goto ncp_err;
  108. usleep_range(1000, 1500);
  109. /* enable low-side LDO */
  110. ldoctl |= TWL6040_LSLDOENA;
  111. ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  112. if (ret)
  113. goto lsldo_err;
  114. usleep_range(1000, 1500);
  115. /* enable low-power PLL */
  116. lppllctl = TWL6040_LPLLENA;
  117. ret = twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
  118. if (ret)
  119. goto lppll_err;
  120. usleep_range(5000, 5500);
  121. /* disable internal oscillator */
  122. ldoctl &= ~TWL6040_OSCENA;
  123. ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  124. if (ret)
  125. goto osc_err;
  126. return 0;
  127. osc_err:
  128. lppllctl &= ~TWL6040_LPLLENA;
  129. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
  130. lppll_err:
  131. ldoctl &= ~TWL6040_LSLDOENA;
  132. twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  133. lsldo_err:
  134. ncpctl &= ~TWL6040_NCPENA;
  135. twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
  136. ncp_err:
  137. ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
  138. twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  139. dev_err(twl6040->dev, "manual power-up failed\n");
  140. return ret;
  141. }
  142. /* twl6040 manual power-down sequence */
  143. static void twl6040_power_down_manual(struct twl6040 *twl6040)
  144. {
  145. u8 ncpctl, ldoctl, lppllctl;
  146. ncpctl = twl6040_reg_read(twl6040, TWL6040_REG_NCPCTL);
  147. ldoctl = twl6040_reg_read(twl6040, TWL6040_REG_LDOCTL);
  148. lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
  149. /* enable internal oscillator */
  150. ldoctl |= TWL6040_OSCENA;
  151. twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  152. usleep_range(1000, 1500);
  153. /* disable low-power PLL */
  154. lppllctl &= ~TWL6040_LPLLENA;
  155. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
  156. /* disable low-side LDO */
  157. ldoctl &= ~TWL6040_LSLDOENA;
  158. twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  159. /* disable negative charge pump */
  160. ncpctl &= ~TWL6040_NCPENA;
  161. twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
  162. /* disable high-side LDO, reference system and internal oscillator */
  163. ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
  164. twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
  165. }
  166. static irqreturn_t twl6040_readyint_handler(int irq, void *data)
  167. {
  168. struct twl6040 *twl6040 = data;
  169. complete(&twl6040->ready);
  170. return IRQ_HANDLED;
  171. }
  172. static irqreturn_t twl6040_thint_handler(int irq, void *data)
  173. {
  174. struct twl6040 *twl6040 = data;
  175. u8 status;
  176. status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS);
  177. if (status & TWL6040_TSHUTDET) {
  178. dev_warn(twl6040->dev, "Thermal shutdown, powering-off");
  179. twl6040_power(twl6040, 0);
  180. } else {
  181. dev_warn(twl6040->dev, "Leaving thermal shutdown, powering-on");
  182. twl6040_power(twl6040, 1);
  183. }
  184. return IRQ_HANDLED;
  185. }
  186. static int twl6040_power_up_automatic(struct twl6040 *twl6040)
  187. {
  188. int time_left;
  189. gpio_set_value(twl6040->audpwron, 1);
  190. time_left = wait_for_completion_timeout(&twl6040->ready,
  191. msecs_to_jiffies(144));
  192. if (!time_left) {
  193. u8 intid;
  194. dev_warn(twl6040->dev, "timeout waiting for READYINT\n");
  195. intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
  196. if (!(intid & TWL6040_READYINT)) {
  197. dev_err(twl6040->dev, "automatic power-up failed\n");
  198. gpio_set_value(twl6040->audpwron, 0);
  199. return -ETIMEDOUT;
  200. }
  201. }
  202. return 0;
  203. }
  204. int twl6040_power(struct twl6040 *twl6040, int on)
  205. {
  206. int ret = 0;
  207. mutex_lock(&twl6040->mutex);
  208. if (on) {
  209. /* already powered-up */
  210. if (twl6040->power_count++)
  211. goto out;
  212. if (gpio_is_valid(twl6040->audpwron)) {
  213. /* use automatic power-up sequence */
  214. ret = twl6040_power_up_automatic(twl6040);
  215. if (ret) {
  216. twl6040->power_count = 0;
  217. goto out;
  218. }
  219. } else {
  220. /* use manual power-up sequence */
  221. ret = twl6040_power_up_manual(twl6040);
  222. if (ret) {
  223. twl6040->power_count = 0;
  224. goto out;
  225. }
  226. }
  227. /* Default PLL configuration after power up */
  228. twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL;
  229. twl6040->sysclk = 19200000;
  230. twl6040->mclk = 32768;
  231. } else {
  232. /* already powered-down */
  233. if (!twl6040->power_count) {
  234. dev_err(twl6040->dev,
  235. "device is already powered-off\n");
  236. ret = -EPERM;
  237. goto out;
  238. }
  239. if (--twl6040->power_count)
  240. goto out;
  241. if (gpio_is_valid(twl6040->audpwron)) {
  242. /* use AUDPWRON line */
  243. gpio_set_value(twl6040->audpwron, 0);
  244. /* power-down sequence latency */
  245. usleep_range(500, 700);
  246. } else {
  247. /* use manual power-down sequence */
  248. twl6040_power_down_manual(twl6040);
  249. }
  250. twl6040->sysclk = 0;
  251. twl6040->mclk = 0;
  252. }
  253. out:
  254. mutex_unlock(&twl6040->mutex);
  255. return ret;
  256. }
  257. EXPORT_SYMBOL(twl6040_power);
  258. int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
  259. unsigned int freq_in, unsigned int freq_out)
  260. {
  261. u8 hppllctl, lppllctl;
  262. int ret = 0;
  263. mutex_lock(&twl6040->mutex);
  264. hppllctl = twl6040_reg_read(twl6040, TWL6040_REG_HPPLLCTL);
  265. lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
  266. /* Force full reconfiguration when switching between PLL */
  267. if (pll_id != twl6040->pll) {
  268. twl6040->sysclk = 0;
  269. twl6040->mclk = 0;
  270. }
  271. switch (pll_id) {
  272. case TWL6040_SYSCLK_SEL_LPPLL:
  273. /* low-power PLL divider */
  274. /* Change the sysclk configuration only if it has been canged */
  275. if (twl6040->sysclk != freq_out) {
  276. switch (freq_out) {
  277. case 17640000:
  278. lppllctl |= TWL6040_LPLLFIN;
  279. break;
  280. case 19200000:
  281. lppllctl &= ~TWL6040_LPLLFIN;
  282. break;
  283. default:
  284. dev_err(twl6040->dev,
  285. "freq_out %d not supported\n",
  286. freq_out);
  287. ret = -EINVAL;
  288. goto pll_out;
  289. }
  290. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
  291. lppllctl);
  292. }
  293. /* The PLL in use has not been change, we can exit */
  294. if (twl6040->pll == pll_id)
  295. break;
  296. switch (freq_in) {
  297. case 32768:
  298. lppllctl |= TWL6040_LPLLENA;
  299. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
  300. lppllctl);
  301. mdelay(5);
  302. lppllctl &= ~TWL6040_HPLLSEL;
  303. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
  304. lppllctl);
  305. hppllctl &= ~TWL6040_HPLLENA;
  306. twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
  307. hppllctl);
  308. break;
  309. default:
  310. dev_err(twl6040->dev,
  311. "freq_in %d not supported\n", freq_in);
  312. ret = -EINVAL;
  313. goto pll_out;
  314. }
  315. break;
  316. case TWL6040_SYSCLK_SEL_HPPLL:
  317. /* high-performance PLL can provide only 19.2 MHz */
  318. if (freq_out != 19200000) {
  319. dev_err(twl6040->dev,
  320. "freq_out %d not supported\n", freq_out);
  321. ret = -EINVAL;
  322. goto pll_out;
  323. }
  324. if (twl6040->mclk != freq_in) {
  325. hppllctl &= ~TWL6040_MCLK_MSK;
  326. switch (freq_in) {
  327. case 12000000:
  328. /* PLL enabled, active mode */
  329. hppllctl |= TWL6040_MCLK_12000KHZ |
  330. TWL6040_HPLLENA;
  331. break;
  332. case 19200000:
  333. /*
  334. * PLL disabled
  335. * (enable PLL if MCLK jitter quality
  336. * doesn't meet specification)
  337. */
  338. hppllctl |= TWL6040_MCLK_19200KHZ;
  339. break;
  340. case 26000000:
  341. /* PLL enabled, active mode */
  342. hppllctl |= TWL6040_MCLK_26000KHZ |
  343. TWL6040_HPLLENA;
  344. break;
  345. case 38400000:
  346. /* PLL enabled, active mode */
  347. hppllctl |= TWL6040_MCLK_38400KHZ |
  348. TWL6040_HPLLENA;
  349. break;
  350. default:
  351. dev_err(twl6040->dev,
  352. "freq_in %d not supported\n", freq_in);
  353. ret = -EINVAL;
  354. goto pll_out;
  355. }
  356. /*
  357. * enable clock slicer to ensure input waveform is
  358. * square
  359. */
  360. hppllctl |= TWL6040_HPLLSQRENA;
  361. twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
  362. hppllctl);
  363. usleep_range(500, 700);
  364. lppllctl |= TWL6040_HPLLSEL;
  365. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
  366. lppllctl);
  367. lppllctl &= ~TWL6040_LPLLENA;
  368. twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
  369. lppllctl);
  370. }
  371. break;
  372. default:
  373. dev_err(twl6040->dev, "unknown pll id %d\n", pll_id);
  374. ret = -EINVAL;
  375. goto pll_out;
  376. }
  377. twl6040->sysclk = freq_out;
  378. twl6040->mclk = freq_in;
  379. twl6040->pll = pll_id;
  380. pll_out:
  381. mutex_unlock(&twl6040->mutex);
  382. return ret;
  383. }
  384. EXPORT_SYMBOL(twl6040_set_pll);
  385. int twl6040_get_pll(struct twl6040 *twl6040)
  386. {
  387. if (twl6040->power_count)
  388. return twl6040->pll;
  389. else
  390. return -ENODEV;
  391. }
  392. EXPORT_SYMBOL(twl6040_get_pll);
  393. unsigned int twl6040_get_sysclk(struct twl6040 *twl6040)
  394. {
  395. return twl6040->sysclk;
  396. }
  397. EXPORT_SYMBOL(twl6040_get_sysclk);
  398. /* Get the combined status of the vibra control register */
  399. int twl6040_get_vibralr_status(struct twl6040 *twl6040)
  400. {
  401. u8 status;
  402. status = twl6040->vibra_ctrl_cache[0] | twl6040->vibra_ctrl_cache[1];
  403. status &= (TWL6040_VIBENA | TWL6040_VIBSEL);
  404. return status;
  405. }
  406. EXPORT_SYMBOL(twl6040_get_vibralr_status);
  407. static struct resource twl6040_vibra_rsrc[] = {
  408. {
  409. .flags = IORESOURCE_IRQ,
  410. },
  411. };
  412. static struct resource twl6040_codec_rsrc[] = {
  413. {
  414. .flags = IORESOURCE_IRQ,
  415. },
  416. };
  417. static bool twl6040_readable_reg(struct device *dev, unsigned int reg)
  418. {
  419. /* Register 0 is not readable */
  420. if (!reg)
  421. return false;
  422. return true;
  423. }
  424. static struct regmap_config twl6040_regmap_config = {
  425. .reg_bits = 8,
  426. .val_bits = 8,
  427. .max_register = TWL6040_REG_STATUS, /* 0x2e */
  428. .readable_reg = twl6040_readable_reg,
  429. };
  430. static const struct regmap_irq twl6040_irqs[] = {
  431. { .reg_offset = 0, .mask = TWL6040_THINT, },
  432. { .reg_offset = 0, .mask = TWL6040_PLUGINT | TWL6040_UNPLUGINT, },
  433. { .reg_offset = 0, .mask = TWL6040_HOOKINT, },
  434. { .reg_offset = 0, .mask = TWL6040_HFINT, },
  435. { .reg_offset = 0, .mask = TWL6040_VIBINT, },
  436. { .reg_offset = 0, .mask = TWL6040_READYINT, },
  437. };
  438. static struct regmap_irq_chip twl6040_irq_chip = {
  439. .name = "twl6040",
  440. .irqs = twl6040_irqs,
  441. .num_irqs = ARRAY_SIZE(twl6040_irqs),
  442. .num_regs = 1,
  443. .status_base = TWL6040_REG_INTID,
  444. .mask_base = TWL6040_REG_INTMR,
  445. };
  446. static int __devinit twl6040_probe(struct i2c_client *client,
  447. const struct i2c_device_id *id)
  448. {
  449. struct twl6040_platform_data *pdata = client->dev.platform_data;
  450. struct device_node *node = client->dev.of_node;
  451. struct twl6040 *twl6040;
  452. struct mfd_cell *cell = NULL;
  453. int irq, ret, children = 0;
  454. if (!pdata && !node) {
  455. dev_err(&client->dev, "Platform data is missing\n");
  456. return -EINVAL;
  457. }
  458. /* In order to operate correctly we need valid interrupt config */
  459. if (!client->irq) {
  460. dev_err(&client->dev, "Invalid IRQ configuration\n");
  461. return -EINVAL;
  462. }
  463. twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040),
  464. GFP_KERNEL);
  465. if (!twl6040) {
  466. ret = -ENOMEM;
  467. goto err;
  468. }
  469. twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config);
  470. if (IS_ERR(twl6040->regmap)) {
  471. ret = PTR_ERR(twl6040->regmap);
  472. goto err;
  473. }
  474. i2c_set_clientdata(client, twl6040);
  475. twl6040->supplies[0].supply = "vio";
  476. twl6040->supplies[1].supply = "v2v1";
  477. ret = regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES,
  478. twl6040->supplies);
  479. if (ret != 0) {
  480. dev_err(&client->dev, "Failed to get supplies: %d\n", ret);
  481. goto regulator_get_err;
  482. }
  483. ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
  484. if (ret != 0) {
  485. dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
  486. goto power_err;
  487. }
  488. twl6040->dev = &client->dev;
  489. twl6040->irq = client->irq;
  490. mutex_init(&twl6040->mutex);
  491. init_completion(&twl6040->ready);
  492. twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
  493. /* ERRATA: Automatic power-up is not possible in ES1.0 */
  494. if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0) {
  495. if (pdata)
  496. twl6040->audpwron = pdata->audpwron_gpio;
  497. else
  498. twl6040->audpwron = of_get_named_gpio(node,
  499. "ti,audpwron-gpio", 0);
  500. } else
  501. twl6040->audpwron = -EINVAL;
  502. if (gpio_is_valid(twl6040->audpwron)) {
  503. ret = gpio_request_one(twl6040->audpwron, GPIOF_OUT_INIT_LOW,
  504. "audpwron");
  505. if (ret)
  506. goto gpio_err;
  507. }
  508. ret = regmap_add_irq_chip(twl6040->regmap, twl6040->irq,
  509. IRQF_ONESHOT, 0, &twl6040_irq_chip,
  510. &twl6040->irq_data);
  511. if (ret < 0)
  512. goto irq_init_err;
  513. twl6040->irq_ready = regmap_irq_get_virq(twl6040->irq_data,
  514. TWL6040_IRQ_READY);
  515. twl6040->irq_th = regmap_irq_get_virq(twl6040->irq_data,
  516. TWL6040_IRQ_TH);
  517. ret = request_threaded_irq(twl6040->irq_ready, NULL,
  518. twl6040_readyint_handler, IRQF_ONESHOT,
  519. "twl6040_irq_ready", twl6040);
  520. if (ret) {
  521. dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret);
  522. goto readyirq_err;
  523. }
  524. ret = request_threaded_irq(twl6040->irq_th, NULL,
  525. twl6040_thint_handler, IRQF_ONESHOT,
  526. "twl6040_irq_th", twl6040);
  527. if (ret) {
  528. dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret);
  529. goto thirq_err;
  530. }
  531. /* dual-access registers controlled by I2C only */
  532. twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL);
  533. /*
  534. * The main functionality of twl6040 to provide audio on OMAP4+ systems.
  535. * We can add the ASoC codec child whenever this driver has been loaded.
  536. * The ASoC codec can work without pdata, pass the platform_data only if
  537. * it has been provided.
  538. */
  539. irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG);
  540. cell = &twl6040->cells[children];
  541. cell->name = "twl6040-codec";
  542. twl6040_codec_rsrc[0].start = irq;
  543. twl6040_codec_rsrc[0].end = irq;
  544. cell->resources = twl6040_codec_rsrc;
  545. cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
  546. if (pdata && pdata->codec) {
  547. cell->platform_data = pdata->codec;
  548. cell->pdata_size = sizeof(*pdata->codec);
  549. }
  550. children++;
  551. if (twl6040_has_vibra(pdata, node)) {
  552. irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB);
  553. cell = &twl6040->cells[children];
  554. cell->name = "twl6040-vibra";
  555. twl6040_vibra_rsrc[0].start = irq;
  556. twl6040_vibra_rsrc[0].end = irq;
  557. cell->resources = twl6040_vibra_rsrc;
  558. cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
  559. if (pdata && pdata->vibra) {
  560. cell->platform_data = pdata->vibra;
  561. cell->pdata_size = sizeof(*pdata->vibra);
  562. }
  563. children++;
  564. }
  565. /*
  566. * Enable the GPO driver in the following cases:
  567. * DT booted kernel or legacy boot with valid gpo platform_data
  568. */
  569. if (!pdata || (pdata && pdata->gpo)) {
  570. cell = &twl6040->cells[children];
  571. cell->name = "twl6040-gpo";
  572. if (pdata) {
  573. cell->platform_data = pdata->gpo;
  574. cell->pdata_size = sizeof(*pdata->gpo);
  575. }
  576. children++;
  577. }
  578. ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
  579. NULL, 0, NULL);
  580. if (ret)
  581. goto mfd_err;
  582. return 0;
  583. mfd_err:
  584. free_irq(twl6040->irq_th, twl6040);
  585. thirq_err:
  586. free_irq(twl6040->irq_ready, twl6040);
  587. readyirq_err:
  588. regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
  589. irq_init_err:
  590. if (gpio_is_valid(twl6040->audpwron))
  591. gpio_free(twl6040->audpwron);
  592. gpio_err:
  593. regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
  594. power_err:
  595. regulator_bulk_free(TWL6040_NUM_SUPPLIES, twl6040->supplies);
  596. regulator_get_err:
  597. i2c_set_clientdata(client, NULL);
  598. err:
  599. return ret;
  600. }
  601. static int __devexit twl6040_remove(struct i2c_client *client)
  602. {
  603. struct twl6040 *twl6040 = i2c_get_clientdata(client);
  604. if (twl6040->power_count)
  605. twl6040_power(twl6040, 0);
  606. if (gpio_is_valid(twl6040->audpwron))
  607. gpio_free(twl6040->audpwron);
  608. free_irq(twl6040->irq_ready, twl6040);
  609. free_irq(twl6040->irq_th, twl6040);
  610. regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
  611. mfd_remove_devices(&client->dev);
  612. i2c_set_clientdata(client, NULL);
  613. regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
  614. regulator_bulk_free(TWL6040_NUM_SUPPLIES, twl6040->supplies);
  615. return 0;
  616. }
  617. static const struct i2c_device_id twl6040_i2c_id[] = {
  618. { "twl6040", 0, },
  619. { "twl6041", 0, },
  620. { },
  621. };
  622. MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id);
  623. static struct i2c_driver twl6040_driver = {
  624. .driver = {
  625. .name = "twl6040",
  626. .owner = THIS_MODULE,
  627. },
  628. .probe = twl6040_probe,
  629. .remove = __devexit_p(twl6040_remove),
  630. .id_table = twl6040_i2c_id,
  631. };
  632. module_i2c_driver(twl6040_driver);
  633. MODULE_DESCRIPTION("TWL6040 MFD");
  634. MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
  635. MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
  636. MODULE_LICENSE("GPL");
  637. MODULE_ALIAS("platform:twl6040");