twl6040.c 32 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246
  1. /*
  2. * ALSA SoC TWL6040 codec driver
  3. *
  4. * Author: Misael Lopez Cruz <x0052729@ti.com>
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License
  8. * version 2 as published by the Free Software Foundation.
  9. *
  10. * This program is distributed in the hope that it will be useful, but
  11. * WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. * General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  18. * 02110-1301 USA
  19. *
  20. */
  21. #include <linux/module.h>
  22. #include <linux/moduleparam.h>
  23. #include <linux/init.h>
  24. #include <linux/delay.h>
  25. #include <linux/pm.h>
  26. #include <linux/i2c.h>
  27. #include <linux/gpio.h>
  28. #include <linux/platform_device.h>
  29. #include <linux/slab.h>
  30. #include <linux/i2c/twl.h>
  31. #include <sound/core.h>
  32. #include <sound/pcm.h>
  33. #include <sound/pcm_params.h>
  34. #include <sound/soc.h>
  35. #include <sound/soc-dapm.h>
  36. #include <sound/initval.h>
  37. #include <sound/tlv.h>
  38. #include "twl6040.h"
  39. #define TWL6040_RATES (SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
  40. #define TWL6040_FORMATS (SNDRV_PCM_FMTBIT_S32_LE)
  41. /* codec private data */
  42. struct twl6040_data {
  43. struct snd_soc_codec codec;
  44. int audpwron;
  45. int naudint;
  46. int codec_powered;
  47. int pll;
  48. int non_lp;
  49. unsigned int sysclk;
  50. struct snd_pcm_hw_constraint_list *sysclk_constraints;
  51. struct completion ready;
  52. };
  53. /*
  54. * twl6040 register cache & default register settings
  55. */
  56. static const u8 twl6040_reg[TWL6040_CACHEREGNUM] = {
  57. 0x00, /* not used 0x00 */
  58. 0x4B, /* TWL6040_ASICID (ro) 0x01 */
  59. 0x00, /* TWL6040_ASICREV (ro) 0x02 */
  60. 0x00, /* TWL6040_INTID 0x03 */
  61. 0x00, /* TWL6040_INTMR 0x04 */
  62. 0x00, /* TWL6040_NCPCTRL 0x05 */
  63. 0x00, /* TWL6040_LDOCTL 0x06 */
  64. 0x60, /* TWL6040_HPPLLCTL 0x07 */
  65. 0x00, /* TWL6040_LPPLLCTL 0x08 */
  66. 0x4A, /* TWL6040_LPPLLDIV 0x09 */
  67. 0x00, /* TWL6040_AMICBCTL 0x0A */
  68. 0x00, /* TWL6040_DMICBCTL 0x0B */
  69. 0x18, /* TWL6040_MICLCTL 0x0C - No input selected on Left Mic */
  70. 0x18, /* TWL6040_MICRCTL 0x0D - No input selected on Right Mic */
  71. 0x00, /* TWL6040_MICGAIN 0x0E */
  72. 0x1B, /* TWL6040_LINEGAIN 0x0F */
  73. 0x00, /* TWL6040_HSLCTL 0x10 */
  74. 0x00, /* TWL6040_HSRCTL 0x11 */
  75. 0x00, /* TWL6040_HSGAIN 0x12 */
  76. 0x00, /* TWL6040_EARCTL 0x13 */
  77. 0x00, /* TWL6040_HFLCTL 0x14 */
  78. 0x00, /* TWL6040_HFLGAIN 0x15 */
  79. 0x00, /* TWL6040_HFRCTL 0x16 */
  80. 0x00, /* TWL6040_HFRGAIN 0x17 */
  81. 0x00, /* TWL6040_VIBCTLL 0x18 */
  82. 0x00, /* TWL6040_VIBDATL 0x19 */
  83. 0x00, /* TWL6040_VIBCTLR 0x1A */
  84. 0x00, /* TWL6040_VIBDATR 0x1B */
  85. 0x00, /* TWL6040_HKCTL1 0x1C */
  86. 0x00, /* TWL6040_HKCTL2 0x1D */
  87. 0x00, /* TWL6040_GPOCTL 0x1E */
  88. 0x00, /* TWL6040_ALB 0x1F */
  89. 0x00, /* TWL6040_DLB 0x20 */
  90. 0x00, /* not used 0x21 */
  91. 0x00, /* not used 0x22 */
  92. 0x00, /* not used 0x23 */
  93. 0x00, /* not used 0x24 */
  94. 0x00, /* not used 0x25 */
  95. 0x00, /* not used 0x26 */
  96. 0x00, /* not used 0x27 */
  97. 0x00, /* TWL6040_TRIM1 0x28 */
  98. 0x00, /* TWL6040_TRIM2 0x29 */
  99. 0x00, /* TWL6040_TRIM3 0x2A */
  100. 0x00, /* TWL6040_HSOTRIM 0x2B */
  101. 0x00, /* TWL6040_HFOTRIM 0x2C */
  102. 0x09, /* TWL6040_ACCCTL 0x2D */
  103. 0x00, /* TWL6040_STATUS (ro) 0x2E */
  104. };
  105. /*
  106. * twl6040 vio/gnd registers:
  107. * registers under vio/gnd supply can be accessed
  108. * before the power-up sequence, after NRESPWRON goes high
  109. */
  110. static const int twl6040_vio_reg[TWL6040_VIOREGNUM] = {
  111. TWL6040_REG_ASICID,
  112. TWL6040_REG_ASICREV,
  113. TWL6040_REG_INTID,
  114. TWL6040_REG_INTMR,
  115. TWL6040_REG_NCPCTL,
  116. TWL6040_REG_LDOCTL,
  117. TWL6040_REG_AMICBCTL,
  118. TWL6040_REG_DMICBCTL,
  119. TWL6040_REG_HKCTL1,
  120. TWL6040_REG_HKCTL2,
  121. TWL6040_REG_GPOCTL,
  122. TWL6040_REG_TRIM1,
  123. TWL6040_REG_TRIM2,
  124. TWL6040_REG_TRIM3,
  125. TWL6040_REG_HSOTRIM,
  126. TWL6040_REG_HFOTRIM,
  127. TWL6040_REG_ACCCTL,
  128. TWL6040_REG_STATUS,
  129. };
  130. /*
  131. * twl6040 vdd/vss registers:
  132. * registers under vdd/vss supplies can only be accessed
  133. * after the power-up sequence
  134. */
  135. static const int twl6040_vdd_reg[TWL6040_VDDREGNUM] = {
  136. TWL6040_REG_HPPLLCTL,
  137. TWL6040_REG_LPPLLCTL,
  138. TWL6040_REG_LPPLLDIV,
  139. TWL6040_REG_MICLCTL,
  140. TWL6040_REG_MICRCTL,
  141. TWL6040_REG_MICGAIN,
  142. TWL6040_REG_LINEGAIN,
  143. TWL6040_REG_HSLCTL,
  144. TWL6040_REG_HSRCTL,
  145. TWL6040_REG_HSGAIN,
  146. TWL6040_REG_EARCTL,
  147. TWL6040_REG_HFLCTL,
  148. TWL6040_REG_HFLGAIN,
  149. TWL6040_REG_HFRCTL,
  150. TWL6040_REG_HFRGAIN,
  151. TWL6040_REG_VIBCTLL,
  152. TWL6040_REG_VIBDATL,
  153. TWL6040_REG_VIBCTLR,
  154. TWL6040_REG_VIBDATR,
  155. TWL6040_REG_ALB,
  156. TWL6040_REG_DLB,
  157. };
  158. /*
  159. * read twl6040 register cache
  160. */
  161. static inline unsigned int twl6040_read_reg_cache(struct snd_soc_codec *codec,
  162. unsigned int reg)
  163. {
  164. u8 *cache = codec->reg_cache;
  165. if (reg >= TWL6040_CACHEREGNUM)
  166. return -EIO;
  167. return cache[reg];
  168. }
  169. /*
  170. * write twl6040 register cache
  171. */
  172. static inline void twl6040_write_reg_cache(struct snd_soc_codec *codec,
  173. u8 reg, u8 value)
  174. {
  175. u8 *cache = codec->reg_cache;
  176. if (reg >= TWL6040_CACHEREGNUM)
  177. return;
  178. cache[reg] = value;
  179. }
  180. /*
  181. * read from twl6040 hardware register
  182. */
  183. static int twl6040_read_reg_volatile(struct snd_soc_codec *codec,
  184. unsigned int reg)
  185. {
  186. u8 value;
  187. if (reg >= TWL6040_CACHEREGNUM)
  188. return -EIO;
  189. twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &value, reg);
  190. twl6040_write_reg_cache(codec, reg, value);
  191. return value;
  192. }
  193. /*
  194. * write to the twl6040 register space
  195. */
  196. static int twl6040_write(struct snd_soc_codec *codec,
  197. unsigned int reg, unsigned int value)
  198. {
  199. if (reg >= TWL6040_CACHEREGNUM)
  200. return -EIO;
  201. twl6040_write_reg_cache(codec, reg, value);
  202. return twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value, reg);
  203. }
  204. static void twl6040_init_vio_regs(struct snd_soc_codec *codec)
  205. {
  206. u8 *cache = codec->reg_cache;
  207. int reg, i;
  208. /* allow registers to be accessed by i2c */
  209. twl6040_write(codec, TWL6040_REG_ACCCTL, cache[TWL6040_REG_ACCCTL]);
  210. for (i = 0; i < TWL6040_VIOREGNUM; i++) {
  211. reg = twl6040_vio_reg[i];
  212. /* skip read-only registers (ASICID, ASICREV, STATUS) */
  213. switch (reg) {
  214. case TWL6040_REG_ASICID:
  215. case TWL6040_REG_ASICREV:
  216. case TWL6040_REG_STATUS:
  217. continue;
  218. default:
  219. break;
  220. }
  221. twl6040_write(codec, reg, cache[reg]);
  222. }
  223. }
  224. static void twl6040_init_vdd_regs(struct snd_soc_codec *codec)
  225. {
  226. u8 *cache = codec->reg_cache;
  227. int reg, i;
  228. for (i = 0; i < TWL6040_VDDREGNUM; i++) {
  229. reg = twl6040_vdd_reg[i];
  230. twl6040_write(codec, reg, cache[reg]);
  231. }
  232. }
  233. /* twl6040 codec manual power-up sequence */
  234. static void twl6040_power_up(struct snd_soc_codec *codec)
  235. {
  236. u8 ncpctl, ldoctl, lppllctl, accctl;
  237. ncpctl = twl6040_read_reg_cache(codec, TWL6040_REG_NCPCTL);
  238. ldoctl = twl6040_read_reg_cache(codec, TWL6040_REG_LDOCTL);
  239. lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
  240. accctl = twl6040_read_reg_cache(codec, TWL6040_REG_ACCCTL);
  241. /* enable reference system */
  242. ldoctl |= TWL6040_REFENA;
  243. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  244. msleep(10);
  245. /* enable internal oscillator */
  246. ldoctl |= TWL6040_OSCENA;
  247. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  248. udelay(10);
  249. /* enable high-side ldo */
  250. ldoctl |= TWL6040_HSLDOENA;
  251. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  252. udelay(244);
  253. /* enable negative charge pump */
  254. ncpctl |= TWL6040_NCPENA | TWL6040_NCPOPEN;
  255. twl6040_write(codec, TWL6040_REG_NCPCTL, ncpctl);
  256. udelay(488);
  257. /* enable low-side ldo */
  258. ldoctl |= TWL6040_LSLDOENA;
  259. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  260. udelay(244);
  261. /* enable low-power pll */
  262. lppllctl |= TWL6040_LPLLENA;
  263. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  264. /* reset state machine */
  265. accctl |= TWL6040_RESETSPLIT;
  266. twl6040_write(codec, TWL6040_REG_ACCCTL, accctl);
  267. mdelay(5);
  268. accctl &= ~TWL6040_RESETSPLIT;
  269. twl6040_write(codec, TWL6040_REG_ACCCTL, accctl);
  270. /* disable internal oscillator */
  271. ldoctl &= ~TWL6040_OSCENA;
  272. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  273. }
  274. /* twl6040 codec manual power-down sequence */
  275. static void twl6040_power_down(struct snd_soc_codec *codec)
  276. {
  277. u8 ncpctl, ldoctl, lppllctl, accctl;
  278. ncpctl = twl6040_read_reg_cache(codec, TWL6040_REG_NCPCTL);
  279. ldoctl = twl6040_read_reg_cache(codec, TWL6040_REG_LDOCTL);
  280. lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
  281. accctl = twl6040_read_reg_cache(codec, TWL6040_REG_ACCCTL);
  282. /* enable internal oscillator */
  283. ldoctl |= TWL6040_OSCENA;
  284. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  285. udelay(10);
  286. /* disable low-power pll */
  287. lppllctl &= ~TWL6040_LPLLENA;
  288. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  289. /* disable low-side ldo */
  290. ldoctl &= ~TWL6040_LSLDOENA;
  291. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  292. udelay(244);
  293. /* disable negative charge pump */
  294. ncpctl &= ~(TWL6040_NCPENA | TWL6040_NCPOPEN);
  295. twl6040_write(codec, TWL6040_REG_NCPCTL, ncpctl);
  296. udelay(488);
  297. /* disable high-side ldo */
  298. ldoctl &= ~TWL6040_HSLDOENA;
  299. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  300. udelay(244);
  301. /* disable internal oscillator */
  302. ldoctl &= ~TWL6040_OSCENA;
  303. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  304. /* disable reference system */
  305. ldoctl &= ~TWL6040_REFENA;
  306. twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl);
  307. msleep(10);
  308. }
  309. /* set headset dac and driver power mode */
  310. static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
  311. {
  312. int hslctl, hsrctl;
  313. int mask = TWL6040_HSDRVMODEL | TWL6040_HSDACMODEL;
  314. hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL);
  315. hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL);
  316. if (high_perf) {
  317. hslctl &= ~mask;
  318. hsrctl &= ~mask;
  319. } else {
  320. hslctl |= mask;
  321. hsrctl |= mask;
  322. }
  323. twl6040_write(codec, TWL6040_REG_HSLCTL, hslctl);
  324. twl6040_write(codec, TWL6040_REG_HSRCTL, hsrctl);
  325. return 0;
  326. }
  327. static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
  328. struct snd_kcontrol *kcontrol, int event)
  329. {
  330. msleep(1);
  331. return 0;
  332. }
  333. static int twl6040_power_mode_event(struct snd_soc_dapm_widget *w,
  334. struct snd_kcontrol *kcontrol, int event)
  335. {
  336. struct snd_soc_codec *codec = w->codec;
  337. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  338. if (SND_SOC_DAPM_EVENT_ON(event))
  339. priv->non_lp++;
  340. else
  341. priv->non_lp--;
  342. msleep(1);
  343. return 0;
  344. }
  345. /* audio interrupt handler */
  346. static irqreturn_t twl6040_naudint_handler(int irq, void *data)
  347. {
  348. struct snd_soc_codec *codec = data;
  349. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  350. u8 intid;
  351. twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &intid, TWL6040_REG_INTID);
  352. switch (intid) {
  353. case TWL6040_THINT:
  354. dev_alert(codec->dev, "die temp over-limit detection\n");
  355. break;
  356. case TWL6040_PLUGINT:
  357. case TWL6040_UNPLUGINT:
  358. case TWL6040_HOOKINT:
  359. break;
  360. case TWL6040_HFINT:
  361. dev_alert(codec->dev, "hf drivers over current detection\n");
  362. break;
  363. case TWL6040_VIBINT:
  364. dev_alert(codec->dev, "vib drivers over current detection\n");
  365. break;
  366. case TWL6040_READYINT:
  367. complete(&priv->ready);
  368. break;
  369. default:
  370. dev_err(codec->dev, "unknown audio interrupt %d\n", intid);
  371. break;
  372. }
  373. return IRQ_HANDLED;
  374. }
  375. /*
  376. * MICATT volume control:
  377. * from -6 to 0 dB in 6 dB steps
  378. */
  379. static DECLARE_TLV_DB_SCALE(mic_preamp_tlv, -600, 600, 0);
  380. /*
  381. * MICGAIN volume control:
  382. * from 6 to 30 dB in 6 dB steps
  383. */
  384. static DECLARE_TLV_DB_SCALE(mic_amp_tlv, 600, 600, 0);
  385. /*
  386. * HSGAIN volume control:
  387. * from -30 to 0 dB in 2 dB steps
  388. */
  389. static DECLARE_TLV_DB_SCALE(hs_tlv, -3000, 200, 0);
  390. /*
  391. * HFGAIN volume control:
  392. * from -52 to 6 dB in 2 dB steps
  393. */
  394. static DECLARE_TLV_DB_SCALE(hf_tlv, -5200, 200, 0);
  395. /*
  396. * EPGAIN volume control:
  397. * from -24 to 6 dB in 2 dB steps
  398. */
  399. static DECLARE_TLV_DB_SCALE(ep_tlv, -2400, 200, 0);
  400. /* Left analog microphone selection */
  401. static const char *twl6040_amicl_texts[] =
  402. {"Headset Mic", "Main Mic", "Aux/FM Left", "Off"};
  403. /* Right analog microphone selection */
  404. static const char *twl6040_amicr_texts[] =
  405. {"Headset Mic", "Sub Mic", "Aux/FM Right", "Off"};
  406. static const struct soc_enum twl6040_enum[] = {
  407. SOC_ENUM_SINGLE(TWL6040_REG_MICLCTL, 3, 3, twl6040_amicl_texts),
  408. SOC_ENUM_SINGLE(TWL6040_REG_MICRCTL, 3, 3, twl6040_amicr_texts),
  409. };
  410. static const struct snd_kcontrol_new amicl_control =
  411. SOC_DAPM_ENUM("Route", twl6040_enum[0]);
  412. static const struct snd_kcontrol_new amicr_control =
  413. SOC_DAPM_ENUM("Route", twl6040_enum[1]);
  414. /* Headset DAC playback switches */
  415. static const struct snd_kcontrol_new hsdacl_switch_controls =
  416. SOC_DAPM_SINGLE("Switch", TWL6040_REG_HSLCTL, 5, 1, 0);
  417. static const struct snd_kcontrol_new hsdacr_switch_controls =
  418. SOC_DAPM_SINGLE("Switch", TWL6040_REG_HSRCTL, 5, 1, 0);
  419. /* Handsfree DAC playback switches */
  420. static const struct snd_kcontrol_new hfdacl_switch_controls =
  421. SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFLCTL, 2, 1, 0);
  422. static const struct snd_kcontrol_new hfdacr_switch_controls =
  423. SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFRCTL, 2, 1, 0);
  424. static const struct snd_kcontrol_new ep_driver_switch_controls =
  425. SOC_DAPM_SINGLE("Switch", TWL6040_REG_EARCTL, 0, 1, 0);
  426. static const struct snd_kcontrol_new twl6040_snd_controls[] = {
  427. /* Capture gains */
  428. SOC_DOUBLE_TLV("Capture Preamplifier Volume",
  429. TWL6040_REG_MICGAIN, 6, 7, 1, 1, mic_preamp_tlv),
  430. SOC_DOUBLE_TLV("Capture Volume",
  431. TWL6040_REG_MICGAIN, 0, 3, 4, 0, mic_amp_tlv),
  432. /* Playback gains */
  433. SOC_DOUBLE_TLV("Headset Playback Volume",
  434. TWL6040_REG_HSGAIN, 0, 4, 0xF, 1, hs_tlv),
  435. SOC_DOUBLE_R_TLV("Handsfree Playback Volume",
  436. TWL6040_REG_HFLGAIN, TWL6040_REG_HFRGAIN, 0, 0x1D, 1, hf_tlv),
  437. SOC_SINGLE_TLV("Earphone Playback Volume",
  438. TWL6040_REG_EARCTL, 1, 0xF, 1, ep_tlv),
  439. };
  440. static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
  441. /* Inputs */
  442. SND_SOC_DAPM_INPUT("MAINMIC"),
  443. SND_SOC_DAPM_INPUT("HSMIC"),
  444. SND_SOC_DAPM_INPUT("SUBMIC"),
  445. SND_SOC_DAPM_INPUT("AFML"),
  446. SND_SOC_DAPM_INPUT("AFMR"),
  447. /* Outputs */
  448. SND_SOC_DAPM_OUTPUT("HSOL"),
  449. SND_SOC_DAPM_OUTPUT("HSOR"),
  450. SND_SOC_DAPM_OUTPUT("HFL"),
  451. SND_SOC_DAPM_OUTPUT("HFR"),
  452. SND_SOC_DAPM_OUTPUT("EP"),
  453. /* Analog input muxes for the capture amplifiers */
  454. SND_SOC_DAPM_MUX("Analog Left Capture Route",
  455. SND_SOC_NOPM, 0, 0, &amicl_control),
  456. SND_SOC_DAPM_MUX("Analog Right Capture Route",
  457. SND_SOC_NOPM, 0, 0, &amicr_control),
  458. /* Analog capture PGAs */
  459. SND_SOC_DAPM_PGA("MicAmpL",
  460. TWL6040_REG_MICLCTL, 0, 0, NULL, 0),
  461. SND_SOC_DAPM_PGA("MicAmpR",
  462. TWL6040_REG_MICRCTL, 0, 0, NULL, 0),
  463. /* ADCs */
  464. SND_SOC_DAPM_ADC("ADC Left", "Left Front Capture",
  465. TWL6040_REG_MICLCTL, 2, 0),
  466. SND_SOC_DAPM_ADC("ADC Right", "Right Front Capture",
  467. TWL6040_REG_MICRCTL, 2, 0),
  468. /* Microphone bias */
  469. SND_SOC_DAPM_MICBIAS("Headset Mic Bias",
  470. TWL6040_REG_AMICBCTL, 0, 0),
  471. SND_SOC_DAPM_MICBIAS("Main Mic Bias",
  472. TWL6040_REG_AMICBCTL, 4, 0),
  473. SND_SOC_DAPM_MICBIAS("Digital Mic1 Bias",
  474. TWL6040_REG_DMICBCTL, 0, 0),
  475. SND_SOC_DAPM_MICBIAS("Digital Mic2 Bias",
  476. TWL6040_REG_DMICBCTL, 4, 0),
  477. /* DACs */
  478. SND_SOC_DAPM_DAC_E("HSDAC Left", "Headset Playback",
  479. TWL6040_REG_HSLCTL, 0, 0,
  480. twl6040_hs_dac_event,
  481. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  482. SND_SOC_DAPM_DAC_E("HSDAC Right", "Headset Playback",
  483. TWL6040_REG_HSRCTL, 0, 0,
  484. twl6040_hs_dac_event,
  485. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  486. SND_SOC_DAPM_DAC_E("HFDAC Left", "Handsfree Playback",
  487. TWL6040_REG_HFLCTL, 0, 0,
  488. twl6040_power_mode_event,
  489. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  490. SND_SOC_DAPM_DAC_E("HFDAC Right", "Handsfree Playback",
  491. TWL6040_REG_HFRCTL, 0, 0,
  492. twl6040_power_mode_event,
  493. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  494. /* Analog playback switches */
  495. SND_SOC_DAPM_SWITCH("HSDAC Left Playback",
  496. SND_SOC_NOPM, 0, 0, &hsdacl_switch_controls),
  497. SND_SOC_DAPM_SWITCH("HSDAC Right Playback",
  498. SND_SOC_NOPM, 0, 0, &hsdacr_switch_controls),
  499. SND_SOC_DAPM_SWITCH("HFDAC Left Playback",
  500. SND_SOC_NOPM, 0, 0, &hfdacl_switch_controls),
  501. SND_SOC_DAPM_SWITCH("HFDAC Right Playback",
  502. SND_SOC_NOPM, 0, 0, &hfdacr_switch_controls),
  503. /* Analog playback drivers */
  504. SND_SOC_DAPM_PGA_E("Handsfree Left Driver",
  505. TWL6040_REG_HFLCTL, 4, 0, NULL, 0,
  506. twl6040_power_mode_event,
  507. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  508. SND_SOC_DAPM_PGA_E("Handsfree Right Driver",
  509. TWL6040_REG_HFRCTL, 4, 0, NULL, 0,
  510. twl6040_power_mode_event,
  511. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  512. SND_SOC_DAPM_PGA("Headset Left Driver",
  513. TWL6040_REG_HSLCTL, 2, 0, NULL, 0),
  514. SND_SOC_DAPM_PGA("Headset Right Driver",
  515. TWL6040_REG_HSRCTL, 2, 0, NULL, 0),
  516. SND_SOC_DAPM_SWITCH_E("Earphone Driver",
  517. SND_SOC_NOPM, 0, 0, &ep_driver_switch_controls,
  518. twl6040_power_mode_event,
  519. SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
  520. /* Analog playback PGAs */
  521. SND_SOC_DAPM_PGA("HFDAC Left PGA",
  522. TWL6040_REG_HFLCTL, 1, 0, NULL, 0),
  523. SND_SOC_DAPM_PGA("HFDAC Right PGA",
  524. TWL6040_REG_HFRCTL, 1, 0, NULL, 0),
  525. };
  526. static const struct snd_soc_dapm_route intercon[] = {
  527. /* Capture path */
  528. {"Analog Left Capture Route", "Headset Mic", "HSMIC"},
  529. {"Analog Left Capture Route", "Main Mic", "MAINMIC"},
  530. {"Analog Left Capture Route", "Aux/FM Left", "AFML"},
  531. {"Analog Right Capture Route", "Headset Mic", "HSMIC"},
  532. {"Analog Right Capture Route", "Sub Mic", "SUBMIC"},
  533. {"Analog Right Capture Route", "Aux/FM Right", "AFMR"},
  534. {"MicAmpL", NULL, "Analog Left Capture Route"},
  535. {"MicAmpR", NULL, "Analog Right Capture Route"},
  536. {"ADC Left", NULL, "MicAmpL"},
  537. {"ADC Right", NULL, "MicAmpR"},
  538. /* Headset playback path */
  539. {"HSDAC Left Playback", "Switch", "HSDAC Left"},
  540. {"HSDAC Right Playback", "Switch", "HSDAC Right"},
  541. {"Headset Left Driver", NULL, "HSDAC Left Playback"},
  542. {"Headset Right Driver", NULL, "HSDAC Right Playback"},
  543. {"HSOL", NULL, "Headset Left Driver"},
  544. {"HSOR", NULL, "Headset Right Driver"},
  545. /* Earphone playback path */
  546. {"Earphone Driver", "Switch", "HSDAC Left"},
  547. {"EP", NULL, "Earphone Driver"},
  548. /* Handsfree playback path */
  549. {"HFDAC Left Playback", "Switch", "HFDAC Left"},
  550. {"HFDAC Right Playback", "Switch", "HFDAC Right"},
  551. {"HFDAC Left PGA", NULL, "HFDAC Left Playback"},
  552. {"HFDAC Right PGA", NULL, "HFDAC Right Playback"},
  553. {"Handsfree Left Driver", "Switch", "HFDAC Left PGA"},
  554. {"Handsfree Right Driver", "Switch", "HFDAC Right PGA"},
  555. {"HFL", NULL, "Handsfree Left Driver"},
  556. {"HFR", NULL, "Handsfree Right Driver"},
  557. };
  558. static int twl6040_add_widgets(struct snd_soc_codec *codec)
  559. {
  560. snd_soc_dapm_new_controls(codec, twl6040_dapm_widgets,
  561. ARRAY_SIZE(twl6040_dapm_widgets));
  562. snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
  563. snd_soc_dapm_new_widgets(codec);
  564. return 0;
  565. }
  566. static int twl6040_power_up_completion(struct snd_soc_codec *codec,
  567. int naudint)
  568. {
  569. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  570. int time_left;
  571. u8 intid;
  572. time_left = wait_for_completion_timeout(&priv->ready,
  573. msecs_to_jiffies(48));
  574. if (!time_left) {
  575. twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &intid,
  576. TWL6040_REG_INTID);
  577. if (!(intid & TWL6040_READYINT)) {
  578. dev_err(codec->dev, "timeout waiting for READYINT\n");
  579. return -ETIMEDOUT;
  580. }
  581. }
  582. priv->codec_powered = 1;
  583. return 0;
  584. }
  585. static int twl6040_set_bias_level(struct snd_soc_codec *codec,
  586. enum snd_soc_bias_level level)
  587. {
  588. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  589. int audpwron = priv->audpwron;
  590. int naudint = priv->naudint;
  591. int ret;
  592. switch (level) {
  593. case SND_SOC_BIAS_ON:
  594. break;
  595. case SND_SOC_BIAS_PREPARE:
  596. break;
  597. case SND_SOC_BIAS_STANDBY:
  598. if (priv->codec_powered)
  599. break;
  600. if (gpio_is_valid(audpwron)) {
  601. /* use AUDPWRON line */
  602. gpio_set_value(audpwron, 1);
  603. /* wait for power-up completion */
  604. ret = twl6040_power_up_completion(codec, naudint);
  605. if (ret)
  606. return ret;
  607. /* sync registers updated during power-up sequence */
  608. twl6040_read_reg_volatile(codec, TWL6040_REG_NCPCTL);
  609. twl6040_read_reg_volatile(codec, TWL6040_REG_LDOCTL);
  610. twl6040_read_reg_volatile(codec, TWL6040_REG_LPPLLCTL);
  611. } else {
  612. /* use manual power-up sequence */
  613. twl6040_power_up(codec);
  614. priv->codec_powered = 1;
  615. }
  616. /* initialize vdd/vss registers with reg_cache */
  617. twl6040_init_vdd_regs(codec);
  618. break;
  619. case SND_SOC_BIAS_OFF:
  620. if (!priv->codec_powered)
  621. break;
  622. if (gpio_is_valid(audpwron)) {
  623. /* use AUDPWRON line */
  624. gpio_set_value(audpwron, 0);
  625. /* power-down sequence latency */
  626. udelay(500);
  627. /* sync registers updated during power-down sequence */
  628. twl6040_read_reg_volatile(codec, TWL6040_REG_NCPCTL);
  629. twl6040_read_reg_volatile(codec, TWL6040_REG_LDOCTL);
  630. twl6040_write_reg_cache(codec, TWL6040_REG_LPPLLCTL,
  631. 0x00);
  632. } else {
  633. /* use manual power-down sequence */
  634. twl6040_power_down(codec);
  635. }
  636. priv->codec_powered = 0;
  637. break;
  638. }
  639. codec->bias_level = level;
  640. return 0;
  641. }
  642. /* set of rates for each pll: low-power and high-performance */
  643. static unsigned int lp_rates[] = {
  644. 88200,
  645. 96000,
  646. };
  647. static struct snd_pcm_hw_constraint_list lp_constraints = {
  648. .count = ARRAY_SIZE(lp_rates),
  649. .list = lp_rates,
  650. };
  651. static unsigned int hp_rates[] = {
  652. 96000,
  653. };
  654. static struct snd_pcm_hw_constraint_list hp_constraints = {
  655. .count = ARRAY_SIZE(hp_rates),
  656. .list = hp_rates,
  657. };
  658. static int twl6040_startup(struct snd_pcm_substream *substream,
  659. struct snd_soc_dai *dai)
  660. {
  661. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  662. struct snd_soc_device *socdev = rtd->socdev;
  663. struct snd_soc_codec *codec = socdev->card->codec;
  664. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  665. if (!priv->sysclk) {
  666. dev_err(codec->dev,
  667. "no mclk configured, call set_sysclk() on init\n");
  668. return -EINVAL;
  669. }
  670. /*
  671. * capture is not supported at 17.64 MHz,
  672. * it's reserved for headset low-power playback scenario
  673. */
  674. if ((priv->sysclk == 17640000) && substream->stream) {
  675. dev_err(codec->dev,
  676. "capture mode is not supported at %dHz\n",
  677. priv->sysclk);
  678. return -EINVAL;
  679. }
  680. snd_pcm_hw_constraint_list(substream->runtime, 0,
  681. SNDRV_PCM_HW_PARAM_RATE,
  682. priv->sysclk_constraints);
  683. return 0;
  684. }
  685. static int twl6040_hw_params(struct snd_pcm_substream *substream,
  686. struct snd_pcm_hw_params *params,
  687. struct snd_soc_dai *dai)
  688. {
  689. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  690. struct snd_soc_device *socdev = rtd->socdev;
  691. struct snd_soc_codec *codec = socdev->card->codec;
  692. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  693. u8 lppllctl;
  694. int rate;
  695. /* nothing to do for high-perf pll, it supports only 48 kHz */
  696. if (priv->pll == TWL6040_HPPLL_ID)
  697. return 0;
  698. lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
  699. rate = params_rate(params);
  700. switch (rate) {
  701. case 88200:
  702. lppllctl |= TWL6040_LPLLFIN;
  703. priv->sysclk = 17640000;
  704. break;
  705. case 96000:
  706. lppllctl &= ~TWL6040_LPLLFIN;
  707. priv->sysclk = 19200000;
  708. break;
  709. default:
  710. dev_err(codec->dev, "unsupported rate %d\n", rate);
  711. return -EINVAL;
  712. }
  713. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  714. return 0;
  715. }
  716. static int twl6040_trigger(struct snd_pcm_substream *substream,
  717. int cmd, struct snd_soc_dai *dai)
  718. {
  719. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  720. struct snd_soc_device *socdev = rtd->socdev;
  721. struct snd_soc_codec *codec = socdev->card->codec;
  722. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  723. switch (cmd) {
  724. case SNDRV_PCM_TRIGGER_START:
  725. case SNDRV_PCM_TRIGGER_RESUME:
  726. /*
  727. * low-power playback mode is restricted
  728. * for headset path only
  729. */
  730. if ((priv->sysclk == 17640000) && priv->non_lp) {
  731. dev_err(codec->dev,
  732. "some enabled paths aren't supported at %dHz\n",
  733. priv->sysclk);
  734. return -EPERM;
  735. }
  736. break;
  737. default:
  738. break;
  739. }
  740. return 0;
  741. }
  742. static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai,
  743. int clk_id, unsigned int freq, int dir)
  744. {
  745. struct snd_soc_codec *codec = codec_dai->codec;
  746. struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
  747. u8 hppllctl, lppllctl;
  748. hppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_HPPLLCTL);
  749. lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL);
  750. switch (clk_id) {
  751. case TWL6040_SYSCLK_SEL_LPPLL:
  752. switch (freq) {
  753. case 32768:
  754. /* headset dac and driver must be in low-power mode */
  755. headset_power_mode(codec, 0);
  756. /* clk32k input requires low-power pll */
  757. lppllctl |= TWL6040_LPLLENA;
  758. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  759. mdelay(5);
  760. lppllctl &= ~TWL6040_HPLLSEL;
  761. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  762. hppllctl &= ~TWL6040_HPLLENA;
  763. twl6040_write(codec, TWL6040_REG_HPPLLCTL, hppllctl);
  764. break;
  765. default:
  766. dev_err(codec->dev, "unknown mclk freq %d\n", freq);
  767. return -EINVAL;
  768. }
  769. /* lppll divider */
  770. switch (priv->sysclk) {
  771. case 17640000:
  772. lppllctl |= TWL6040_LPLLFIN;
  773. break;
  774. case 19200000:
  775. lppllctl &= ~TWL6040_LPLLFIN;
  776. break;
  777. default:
  778. /* sysclk not yet configured */
  779. lppllctl &= ~TWL6040_LPLLFIN;
  780. priv->sysclk = 19200000;
  781. break;
  782. }
  783. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  784. priv->pll = TWL6040_LPPLL_ID;
  785. priv->sysclk_constraints = &lp_constraints;
  786. break;
  787. case TWL6040_SYSCLK_SEL_HPPLL:
  788. hppllctl &= ~TWL6040_MCLK_MSK;
  789. switch (freq) {
  790. case 12000000:
  791. /* mclk input, pll enabled */
  792. hppllctl |= TWL6040_MCLK_12000KHZ |
  793. TWL6040_HPLLSQRBP |
  794. TWL6040_HPLLENA;
  795. break;
  796. case 19200000:
  797. /* mclk input, pll disabled */
  798. hppllctl |= TWL6040_MCLK_19200KHZ |
  799. TWL6040_HPLLSQRENA |
  800. TWL6040_HPLLBP;
  801. break;
  802. case 26000000:
  803. /* mclk input, pll enabled */
  804. hppllctl |= TWL6040_MCLK_26000KHZ |
  805. TWL6040_HPLLSQRBP |
  806. TWL6040_HPLLENA;
  807. break;
  808. case 38400000:
  809. /* clk slicer, pll disabled */
  810. hppllctl |= TWL6040_MCLK_38400KHZ |
  811. TWL6040_HPLLSQRENA |
  812. TWL6040_HPLLBP;
  813. break;
  814. default:
  815. dev_err(codec->dev, "unknown mclk freq %d\n", freq);
  816. return -EINVAL;
  817. }
  818. /* headset dac and driver must be in high-performance mode */
  819. headset_power_mode(codec, 1);
  820. twl6040_write(codec, TWL6040_REG_HPPLLCTL, hppllctl);
  821. udelay(500);
  822. lppllctl |= TWL6040_HPLLSEL;
  823. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  824. lppllctl &= ~TWL6040_LPLLENA;
  825. twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl);
  826. /* high-performance pll can provide only 19.2 MHz */
  827. priv->pll = TWL6040_HPPLL_ID;
  828. priv->sysclk = 19200000;
  829. priv->sysclk_constraints = &hp_constraints;
  830. break;
  831. default:
  832. dev_err(codec->dev, "unknown clk_id %d\n", clk_id);
  833. return -EINVAL;
  834. }
  835. return 0;
  836. }
  837. static struct snd_soc_dai_ops twl6040_dai_ops = {
  838. .startup = twl6040_startup,
  839. .hw_params = twl6040_hw_params,
  840. .trigger = twl6040_trigger,
  841. .set_sysclk = twl6040_set_dai_sysclk,
  842. };
  843. struct snd_soc_dai twl6040_dai = {
  844. .name = "twl6040",
  845. .playback = {
  846. .stream_name = "Playback",
  847. .channels_min = 1,
  848. .channels_max = 4,
  849. .rates = TWL6040_RATES,
  850. .formats = TWL6040_FORMATS,
  851. },
  852. .capture = {
  853. .stream_name = "Capture",
  854. .channels_min = 1,
  855. .channels_max = 2,
  856. .rates = TWL6040_RATES,
  857. .formats = TWL6040_FORMATS,
  858. },
  859. .ops = &twl6040_dai_ops,
  860. };
  861. EXPORT_SYMBOL_GPL(twl6040_dai);
  862. #ifdef CONFIG_PM
  863. static int twl6040_suspend(struct platform_device *pdev, pm_message_t state)
  864. {
  865. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  866. struct snd_soc_codec *codec = socdev->card->codec;
  867. twl6040_set_bias_level(codec, SND_SOC_BIAS_OFF);
  868. return 0;
  869. }
  870. static int twl6040_resume(struct platform_device *pdev)
  871. {
  872. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  873. struct snd_soc_codec *codec = socdev->card->codec;
  874. twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
  875. return 0;
  876. }
  877. #else
  878. #define twl6040_suspend NULL
  879. #define twl6040_resume NULL
  880. #endif
  881. static struct snd_soc_codec *twl6040_codec;
  882. static int twl6040_probe(struct platform_device *pdev)
  883. {
  884. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  885. struct snd_soc_codec *codec;
  886. int ret = 0;
  887. BUG_ON(!twl6040_codec);
  888. codec = twl6040_codec;
  889. socdev->card->codec = codec;
  890. /* register pcms */
  891. ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
  892. if (ret < 0) {
  893. dev_err(&pdev->dev, "failed to create pcms\n");
  894. return ret;
  895. }
  896. snd_soc_add_controls(codec, twl6040_snd_controls,
  897. ARRAY_SIZE(twl6040_snd_controls));
  898. twl6040_add_widgets(codec);
  899. if (ret < 0) {
  900. dev_err(&pdev->dev, "failed to register card\n");
  901. goto card_err;
  902. }
  903. return ret;
  904. card_err:
  905. snd_soc_free_pcms(socdev);
  906. snd_soc_dapm_free(socdev);
  907. return ret;
  908. }
  909. static int twl6040_remove(struct platform_device *pdev)
  910. {
  911. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  912. struct snd_soc_codec *codec = socdev->card->codec;
  913. twl6040_set_bias_level(codec, SND_SOC_BIAS_OFF);
  914. snd_soc_free_pcms(socdev);
  915. snd_soc_dapm_free(socdev);
  916. kfree(codec);
  917. return 0;
  918. }
  919. struct snd_soc_codec_device soc_codec_dev_twl6040 = {
  920. .probe = twl6040_probe,
  921. .remove = twl6040_remove,
  922. .suspend = twl6040_suspend,
  923. .resume = twl6040_resume,
  924. };
  925. EXPORT_SYMBOL_GPL(soc_codec_dev_twl6040);
  926. static int __devinit twl6040_codec_probe(struct platform_device *pdev)
  927. {
  928. struct twl4030_codec_data *twl_codec = pdev->dev.platform_data;
  929. struct snd_soc_codec *codec;
  930. struct twl6040_data *priv;
  931. int audpwron, naudint;
  932. int ret = 0;
  933. priv = kzalloc(sizeof(struct twl6040_data), GFP_KERNEL);
  934. if (priv == NULL)
  935. return -ENOMEM;
  936. if (twl_codec) {
  937. audpwron = twl_codec->audpwron_gpio;
  938. naudint = twl_codec->naudint_irq;
  939. } else {
  940. audpwron = -EINVAL;
  941. naudint = 0;
  942. }
  943. priv->audpwron = audpwron;
  944. priv->naudint = naudint;
  945. codec = &priv->codec;
  946. codec->dev = &pdev->dev;
  947. twl6040_dai.dev = &pdev->dev;
  948. codec->name = "twl6040";
  949. codec->owner = THIS_MODULE;
  950. codec->read = twl6040_read_reg_cache;
  951. codec->write = twl6040_write;
  952. codec->set_bias_level = twl6040_set_bias_level;
  953. snd_soc_codec_set_drvdata(codec, priv);
  954. codec->dai = &twl6040_dai;
  955. codec->num_dai = 1;
  956. codec->reg_cache_size = ARRAY_SIZE(twl6040_reg);
  957. codec->reg_cache = kmemdup(twl6040_reg, sizeof(twl6040_reg),
  958. GFP_KERNEL);
  959. if (codec->reg_cache == NULL) {
  960. ret = -ENOMEM;
  961. goto cache_err;
  962. }
  963. mutex_init(&codec->mutex);
  964. INIT_LIST_HEAD(&codec->dapm_widgets);
  965. INIT_LIST_HEAD(&codec->dapm_paths);
  966. init_completion(&priv->ready);
  967. if (gpio_is_valid(audpwron)) {
  968. ret = gpio_request(audpwron, "audpwron");
  969. if (ret)
  970. goto gpio1_err;
  971. ret = gpio_direction_output(audpwron, 0);
  972. if (ret)
  973. goto gpio2_err;
  974. priv->codec_powered = 0;
  975. }
  976. if (naudint) {
  977. /* audio interrupt */
  978. ret = request_threaded_irq(naudint, NULL,
  979. twl6040_naudint_handler,
  980. IRQF_TRIGGER_LOW | IRQF_ONESHOT,
  981. "twl6040_codec", codec);
  982. if (ret)
  983. goto gpio2_err;
  984. } else {
  985. if (gpio_is_valid(audpwron)) {
  986. /* enable only codec ready interrupt */
  987. twl6040_write_reg_cache(codec, TWL6040_REG_INTMR,
  988. ~TWL6040_READYMSK & TWL6040_ALLINT_MSK);
  989. } else {
  990. /* no interrupts at all */
  991. twl6040_write_reg_cache(codec, TWL6040_REG_INTMR,
  992. TWL6040_ALLINT_MSK);
  993. }
  994. }
  995. /* init vio registers */
  996. twl6040_init_vio_regs(codec);
  997. /* power on device */
  998. ret = twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
  999. if (ret)
  1000. goto irq_err;
  1001. ret = snd_soc_register_codec(codec);
  1002. if (ret)
  1003. goto reg_err;
  1004. twl6040_codec = codec;
  1005. ret = snd_soc_register_dai(&twl6040_dai);
  1006. if (ret)
  1007. goto dai_err;
  1008. return 0;
  1009. dai_err:
  1010. snd_soc_unregister_codec(codec);
  1011. twl6040_codec = NULL;
  1012. reg_err:
  1013. twl6040_set_bias_level(codec, SND_SOC_BIAS_OFF);
  1014. irq_err:
  1015. if (naudint)
  1016. free_irq(naudint, codec);
  1017. gpio2_err:
  1018. if (gpio_is_valid(audpwron))
  1019. gpio_free(audpwron);
  1020. gpio1_err:
  1021. kfree(codec->reg_cache);
  1022. cache_err:
  1023. kfree(priv);
  1024. return ret;
  1025. }
  1026. static int __devexit twl6040_codec_remove(struct platform_device *pdev)
  1027. {
  1028. struct twl6040_data *priv = snd_soc_codec_get_drvdata(twl6040_codec);
  1029. int audpwron = priv->audpwron;
  1030. int naudint = priv->naudint;
  1031. if (gpio_is_valid(audpwron))
  1032. gpio_free(audpwron);
  1033. if (naudint)
  1034. free_irq(naudint, twl6040_codec);
  1035. snd_soc_unregister_dai(&twl6040_dai);
  1036. snd_soc_unregister_codec(twl6040_codec);
  1037. kfree(twl6040_codec);
  1038. twl6040_codec = NULL;
  1039. return 0;
  1040. }
  1041. static struct platform_driver twl6040_codec_driver = {
  1042. .driver = {
  1043. .name = "twl6040_codec",
  1044. .owner = THIS_MODULE,
  1045. },
  1046. .probe = twl6040_codec_probe,
  1047. .remove = __devexit_p(twl6040_codec_remove),
  1048. };
  1049. static int __init twl6040_codec_init(void)
  1050. {
  1051. return platform_driver_register(&twl6040_codec_driver);
  1052. }
  1053. module_init(twl6040_codec_init);
  1054. static void __exit twl6040_codec_exit(void)
  1055. {
  1056. platform_driver_unregister(&twl6040_codec_driver);
  1057. }
  1058. module_exit(twl6040_codec_exit);
  1059. MODULE_DESCRIPTION("ASoC TWL6040 codec driver");
  1060. MODULE_AUTHOR("Misael Lopez Cruz");
  1061. MODULE_LICENSE("GPL");