wm8510.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819
  1. /*
  2. * wm8510.c -- WM8510 ALSA Soc Audio driver
  3. *
  4. * Copyright 2006 Wolfson Microelectronics PLC.
  5. *
  6. * Author: Liam Girdwood <lrg@slimlogic.co.uk>
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation.
  11. */
  12. #include <linux/module.h>
  13. #include <linux/moduleparam.h>
  14. #include <linux/kernel.h>
  15. #include <linux/init.h>
  16. #include <linux/delay.h>
  17. #include <linux/pm.h>
  18. #include <linux/i2c.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/spi/spi.h>
  21. #include <linux/slab.h>
  22. #include <sound/core.h>
  23. #include <sound/pcm.h>
  24. #include <sound/pcm_params.h>
  25. #include <sound/soc.h>
  26. #include <sound/soc-dapm.h>
  27. #include <sound/initval.h>
  28. #include "wm8510.h"
  29. #define WM8510_VERSION "0.6"
  30. struct snd_soc_codec_device soc_codec_dev_wm8510;
  31. /*
  32. * wm8510 register cache
  33. * We can't read the WM8510 register space when we are
  34. * using 2 wire for device control, so we cache them instead.
  35. */
  36. static const u16 wm8510_reg[WM8510_CACHEREGNUM] = {
  37. 0x0000, 0x0000, 0x0000, 0x0000,
  38. 0x0050, 0x0000, 0x0140, 0x0000,
  39. 0x0000, 0x0000, 0x0000, 0x00ff,
  40. 0x0000, 0x0000, 0x0100, 0x00ff,
  41. 0x0000, 0x0000, 0x012c, 0x002c,
  42. 0x002c, 0x002c, 0x002c, 0x0000,
  43. 0x0032, 0x0000, 0x0000, 0x0000,
  44. 0x0000, 0x0000, 0x0000, 0x0000,
  45. 0x0038, 0x000b, 0x0032, 0x0000,
  46. 0x0008, 0x000c, 0x0093, 0x00e9,
  47. 0x0000, 0x0000, 0x0000, 0x0000,
  48. 0x0003, 0x0010, 0x0000, 0x0000,
  49. 0x0000, 0x0002, 0x0001, 0x0000,
  50. 0x0000, 0x0000, 0x0039, 0x0000,
  51. 0x0001,
  52. };
  53. #define WM8510_POWER1_BIASEN 0x08
  54. #define WM8510_POWER1_BUFIOEN 0x10
  55. #define wm8510_reset(c) snd_soc_write(c, WM8510_RESET, 0)
  56. static const char *wm8510_companding[] = { "Off", "NC", "u-law", "A-law" };
  57. static const char *wm8510_deemp[] = { "None", "32kHz", "44.1kHz", "48kHz" };
  58. static const char *wm8510_alc[] = { "ALC", "Limiter" };
  59. static const struct soc_enum wm8510_enum[] = {
  60. SOC_ENUM_SINGLE(WM8510_COMP, 1, 4, wm8510_companding), /* adc */
  61. SOC_ENUM_SINGLE(WM8510_COMP, 3, 4, wm8510_companding), /* dac */
  62. SOC_ENUM_SINGLE(WM8510_DAC, 4, 4, wm8510_deemp),
  63. SOC_ENUM_SINGLE(WM8510_ALC3, 8, 2, wm8510_alc),
  64. };
  65. static const struct snd_kcontrol_new wm8510_snd_controls[] = {
  66. SOC_SINGLE("Digital Loopback Switch", WM8510_COMP, 0, 1, 0),
  67. SOC_ENUM("DAC Companding", wm8510_enum[1]),
  68. SOC_ENUM("ADC Companding", wm8510_enum[0]),
  69. SOC_ENUM("Playback De-emphasis", wm8510_enum[2]),
  70. SOC_SINGLE("DAC Inversion Switch", WM8510_DAC, 0, 1, 0),
  71. SOC_SINGLE("Master Playback Volume", WM8510_DACVOL, 0, 127, 0),
  72. SOC_SINGLE("High Pass Filter Switch", WM8510_ADC, 8, 1, 0),
  73. SOC_SINGLE("High Pass Cut Off", WM8510_ADC, 4, 7, 0),
  74. SOC_SINGLE("ADC Inversion Switch", WM8510_COMP, 0, 1, 0),
  75. SOC_SINGLE("Capture Volume", WM8510_ADCVOL, 0, 127, 0),
  76. SOC_SINGLE("DAC Playback Limiter Switch", WM8510_DACLIM1, 8, 1, 0),
  77. SOC_SINGLE("DAC Playback Limiter Decay", WM8510_DACLIM1, 4, 15, 0),
  78. SOC_SINGLE("DAC Playback Limiter Attack", WM8510_DACLIM1, 0, 15, 0),
  79. SOC_SINGLE("DAC Playback Limiter Threshold", WM8510_DACLIM2, 4, 7, 0),
  80. SOC_SINGLE("DAC Playback Limiter Boost", WM8510_DACLIM2, 0, 15, 0),
  81. SOC_SINGLE("ALC Enable Switch", WM8510_ALC1, 8, 1, 0),
  82. SOC_SINGLE("ALC Capture Max Gain", WM8510_ALC1, 3, 7, 0),
  83. SOC_SINGLE("ALC Capture Min Gain", WM8510_ALC1, 0, 7, 0),
  84. SOC_SINGLE("ALC Capture ZC Switch", WM8510_ALC2, 8, 1, 0),
  85. SOC_SINGLE("ALC Capture Hold", WM8510_ALC2, 4, 7, 0),
  86. SOC_SINGLE("ALC Capture Target", WM8510_ALC2, 0, 15, 0),
  87. SOC_ENUM("ALC Capture Mode", wm8510_enum[3]),
  88. SOC_SINGLE("ALC Capture Decay", WM8510_ALC3, 4, 15, 0),
  89. SOC_SINGLE("ALC Capture Attack", WM8510_ALC3, 0, 15, 0),
  90. SOC_SINGLE("ALC Capture Noise Gate Switch", WM8510_NGATE, 3, 1, 0),
  91. SOC_SINGLE("ALC Capture Noise Gate Threshold", WM8510_NGATE, 0, 7, 0),
  92. SOC_SINGLE("Capture PGA ZC Switch", WM8510_INPPGA, 7, 1, 0),
  93. SOC_SINGLE("Capture PGA Volume", WM8510_INPPGA, 0, 63, 0),
  94. SOC_SINGLE("Speaker Playback ZC Switch", WM8510_SPKVOL, 7, 1, 0),
  95. SOC_SINGLE("Speaker Playback Switch", WM8510_SPKVOL, 6, 1, 1),
  96. SOC_SINGLE("Speaker Playback Volume", WM8510_SPKVOL, 0, 63, 0),
  97. SOC_SINGLE("Speaker Boost", WM8510_OUTPUT, 2, 1, 0),
  98. SOC_SINGLE("Capture Boost(+20dB)", WM8510_ADCBOOST, 8, 1, 0),
  99. SOC_SINGLE("Mono Playback Switch", WM8510_MONOMIX, 6, 1, 1),
  100. };
  101. /* Speaker Output Mixer */
  102. static const struct snd_kcontrol_new wm8510_speaker_mixer_controls[] = {
  103. SOC_DAPM_SINGLE("Line Bypass Switch", WM8510_SPKMIX, 1, 1, 0),
  104. SOC_DAPM_SINGLE("Aux Playback Switch", WM8510_SPKMIX, 5, 1, 0),
  105. SOC_DAPM_SINGLE("PCM Playback Switch", WM8510_SPKMIX, 0, 1, 0),
  106. };
  107. /* Mono Output Mixer */
  108. static const struct snd_kcontrol_new wm8510_mono_mixer_controls[] = {
  109. SOC_DAPM_SINGLE("Line Bypass Switch", WM8510_MONOMIX, 1, 1, 0),
  110. SOC_DAPM_SINGLE("Aux Playback Switch", WM8510_MONOMIX, 2, 1, 0),
  111. SOC_DAPM_SINGLE("PCM Playback Switch", WM8510_MONOMIX, 0, 1, 0),
  112. };
  113. static const struct snd_kcontrol_new wm8510_boost_controls[] = {
  114. SOC_DAPM_SINGLE("Mic PGA Switch", WM8510_INPPGA, 6, 1, 1),
  115. SOC_DAPM_SINGLE("Aux Volume", WM8510_ADCBOOST, 0, 7, 0),
  116. SOC_DAPM_SINGLE("Mic Volume", WM8510_ADCBOOST, 4, 7, 0),
  117. };
  118. static const struct snd_kcontrol_new wm8510_micpga_controls[] = {
  119. SOC_DAPM_SINGLE("MICP Switch", WM8510_INPUT, 0, 1, 0),
  120. SOC_DAPM_SINGLE("MICN Switch", WM8510_INPUT, 1, 1, 0),
  121. SOC_DAPM_SINGLE("AUX Switch", WM8510_INPUT, 2, 1, 0),
  122. };
  123. static const struct snd_soc_dapm_widget wm8510_dapm_widgets[] = {
  124. SND_SOC_DAPM_MIXER("Speaker Mixer", WM8510_POWER3, 2, 0,
  125. &wm8510_speaker_mixer_controls[0],
  126. ARRAY_SIZE(wm8510_speaker_mixer_controls)),
  127. SND_SOC_DAPM_MIXER("Mono Mixer", WM8510_POWER3, 3, 0,
  128. &wm8510_mono_mixer_controls[0],
  129. ARRAY_SIZE(wm8510_mono_mixer_controls)),
  130. SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8510_POWER3, 0, 0),
  131. SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8510_POWER2, 0, 0),
  132. SND_SOC_DAPM_PGA("Aux Input", WM8510_POWER1, 6, 0, NULL, 0),
  133. SND_SOC_DAPM_PGA("SpkN Out", WM8510_POWER3, 5, 0, NULL, 0),
  134. SND_SOC_DAPM_PGA("SpkP Out", WM8510_POWER3, 6, 0, NULL, 0),
  135. SND_SOC_DAPM_PGA("Mono Out", WM8510_POWER3, 7, 0, NULL, 0),
  136. SND_SOC_DAPM_MIXER("Mic PGA", WM8510_POWER2, 2, 0,
  137. &wm8510_micpga_controls[0],
  138. ARRAY_SIZE(wm8510_micpga_controls)),
  139. SND_SOC_DAPM_MIXER("Boost Mixer", WM8510_POWER2, 4, 0,
  140. &wm8510_boost_controls[0],
  141. ARRAY_SIZE(wm8510_boost_controls)),
  142. SND_SOC_DAPM_MICBIAS("Mic Bias", WM8510_POWER1, 4, 0),
  143. SND_SOC_DAPM_INPUT("MICN"),
  144. SND_SOC_DAPM_INPUT("MICP"),
  145. SND_SOC_DAPM_INPUT("AUX"),
  146. SND_SOC_DAPM_OUTPUT("MONOOUT"),
  147. SND_SOC_DAPM_OUTPUT("SPKOUTP"),
  148. SND_SOC_DAPM_OUTPUT("SPKOUTN"),
  149. };
  150. static const struct snd_soc_dapm_route audio_map[] = {
  151. /* Mono output mixer */
  152. {"Mono Mixer", "PCM Playback Switch", "DAC"},
  153. {"Mono Mixer", "Aux Playback Switch", "Aux Input"},
  154. {"Mono Mixer", "Line Bypass Switch", "Boost Mixer"},
  155. /* Speaker output mixer */
  156. {"Speaker Mixer", "PCM Playback Switch", "DAC"},
  157. {"Speaker Mixer", "Aux Playback Switch", "Aux Input"},
  158. {"Speaker Mixer", "Line Bypass Switch", "Boost Mixer"},
  159. /* Outputs */
  160. {"Mono Out", NULL, "Mono Mixer"},
  161. {"MONOOUT", NULL, "Mono Out"},
  162. {"SpkN Out", NULL, "Speaker Mixer"},
  163. {"SpkP Out", NULL, "Speaker Mixer"},
  164. {"SPKOUTN", NULL, "SpkN Out"},
  165. {"SPKOUTP", NULL, "SpkP Out"},
  166. /* Microphone PGA */
  167. {"Mic PGA", "MICN Switch", "MICN"},
  168. {"Mic PGA", "MICP Switch", "MICP"},
  169. { "Mic PGA", "AUX Switch", "Aux Input" },
  170. /* Boost Mixer */
  171. {"Boost Mixer", "Mic PGA Switch", "Mic PGA"},
  172. {"Boost Mixer", "Mic Volume", "MICP"},
  173. {"Boost Mixer", "Aux Volume", "Aux Input"},
  174. {"ADC", NULL, "Boost Mixer"},
  175. };
  176. static int wm8510_add_widgets(struct snd_soc_codec *codec)
  177. {
  178. snd_soc_dapm_new_controls(codec, wm8510_dapm_widgets,
  179. ARRAY_SIZE(wm8510_dapm_widgets));
  180. snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
  181. return 0;
  182. }
  183. struct pll_ {
  184. unsigned int pre_div:4; /* prescale - 1 */
  185. unsigned int n:4;
  186. unsigned int k;
  187. };
  188. static struct pll_ pll_div;
  189. /* The size in bits of the pll divide multiplied by 10
  190. * to allow rounding later */
  191. #define FIXED_PLL_SIZE ((1 << 24) * 10)
  192. static void pll_factors(unsigned int target, unsigned int source)
  193. {
  194. unsigned long long Kpart;
  195. unsigned int K, Ndiv, Nmod;
  196. Ndiv = target / source;
  197. if (Ndiv < 6) {
  198. source >>= 1;
  199. pll_div.pre_div = 1;
  200. Ndiv = target / source;
  201. } else
  202. pll_div.pre_div = 0;
  203. if ((Ndiv < 6) || (Ndiv > 12))
  204. printk(KERN_WARNING
  205. "WM8510 N value %u outwith recommended range!d\n",
  206. Ndiv);
  207. pll_div.n = Ndiv;
  208. Nmod = target % source;
  209. Kpart = FIXED_PLL_SIZE * (long long)Nmod;
  210. do_div(Kpart, source);
  211. K = Kpart & 0xFFFFFFFF;
  212. /* Check if we need to round */
  213. if ((K % 10) >= 5)
  214. K += 5;
  215. /* Move down to proper range now rounding is done */
  216. K /= 10;
  217. pll_div.k = K;
  218. }
  219. static int wm8510_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
  220. int source, unsigned int freq_in, unsigned int freq_out)
  221. {
  222. struct snd_soc_codec *codec = codec_dai->codec;
  223. u16 reg;
  224. if (freq_in == 0 || freq_out == 0) {
  225. /* Clock CODEC directly from MCLK */
  226. reg = snd_soc_read(codec, WM8510_CLOCK);
  227. snd_soc_write(codec, WM8510_CLOCK, reg & 0x0ff);
  228. /* Turn off PLL */
  229. reg = snd_soc_read(codec, WM8510_POWER1);
  230. snd_soc_write(codec, WM8510_POWER1, reg & 0x1df);
  231. return 0;
  232. }
  233. pll_factors(freq_out*4, freq_in);
  234. snd_soc_write(codec, WM8510_PLLN, (pll_div.pre_div << 4) | pll_div.n);
  235. snd_soc_write(codec, WM8510_PLLK1, pll_div.k >> 18);
  236. snd_soc_write(codec, WM8510_PLLK2, (pll_div.k >> 9) & 0x1ff);
  237. snd_soc_write(codec, WM8510_PLLK3, pll_div.k & 0x1ff);
  238. reg = snd_soc_read(codec, WM8510_POWER1);
  239. snd_soc_write(codec, WM8510_POWER1, reg | 0x020);
  240. /* Run CODEC from PLL instead of MCLK */
  241. reg = snd_soc_read(codec, WM8510_CLOCK);
  242. snd_soc_write(codec, WM8510_CLOCK, reg | 0x100);
  243. return 0;
  244. }
  245. /*
  246. * Configure WM8510 clock dividers.
  247. */
  248. static int wm8510_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
  249. int div_id, int div)
  250. {
  251. struct snd_soc_codec *codec = codec_dai->codec;
  252. u16 reg;
  253. switch (div_id) {
  254. case WM8510_OPCLKDIV:
  255. reg = snd_soc_read(codec, WM8510_GPIO) & 0x1cf;
  256. snd_soc_write(codec, WM8510_GPIO, reg | div);
  257. break;
  258. case WM8510_MCLKDIV:
  259. reg = snd_soc_read(codec, WM8510_CLOCK) & 0x11f;
  260. snd_soc_write(codec, WM8510_CLOCK, reg | div);
  261. break;
  262. case WM8510_ADCCLK:
  263. reg = snd_soc_read(codec, WM8510_ADC) & 0x1f7;
  264. snd_soc_write(codec, WM8510_ADC, reg | div);
  265. break;
  266. case WM8510_DACCLK:
  267. reg = snd_soc_read(codec, WM8510_DAC) & 0x1f7;
  268. snd_soc_write(codec, WM8510_DAC, reg | div);
  269. break;
  270. case WM8510_BCLKDIV:
  271. reg = snd_soc_read(codec, WM8510_CLOCK) & 0x1e3;
  272. snd_soc_write(codec, WM8510_CLOCK, reg | div);
  273. break;
  274. default:
  275. return -EINVAL;
  276. }
  277. return 0;
  278. }
  279. static int wm8510_set_dai_fmt(struct snd_soc_dai *codec_dai,
  280. unsigned int fmt)
  281. {
  282. struct snd_soc_codec *codec = codec_dai->codec;
  283. u16 iface = 0;
  284. u16 clk = snd_soc_read(codec, WM8510_CLOCK) & 0x1fe;
  285. /* set master/slave audio interface */
  286. switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
  287. case SND_SOC_DAIFMT_CBM_CFM:
  288. clk |= 0x0001;
  289. break;
  290. case SND_SOC_DAIFMT_CBS_CFS:
  291. break;
  292. default:
  293. return -EINVAL;
  294. }
  295. /* interface format */
  296. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  297. case SND_SOC_DAIFMT_I2S:
  298. iface |= 0x0010;
  299. break;
  300. case SND_SOC_DAIFMT_RIGHT_J:
  301. break;
  302. case SND_SOC_DAIFMT_LEFT_J:
  303. iface |= 0x0008;
  304. break;
  305. case SND_SOC_DAIFMT_DSP_A:
  306. iface |= 0x00018;
  307. break;
  308. default:
  309. return -EINVAL;
  310. }
  311. /* clock inversion */
  312. switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
  313. case SND_SOC_DAIFMT_NB_NF:
  314. break;
  315. case SND_SOC_DAIFMT_IB_IF:
  316. iface |= 0x0180;
  317. break;
  318. case SND_SOC_DAIFMT_IB_NF:
  319. iface |= 0x0100;
  320. break;
  321. case SND_SOC_DAIFMT_NB_IF:
  322. iface |= 0x0080;
  323. break;
  324. default:
  325. return -EINVAL;
  326. }
  327. snd_soc_write(codec, WM8510_IFACE, iface);
  328. snd_soc_write(codec, WM8510_CLOCK, clk);
  329. return 0;
  330. }
  331. static int wm8510_pcm_hw_params(struct snd_pcm_substream *substream,
  332. struct snd_pcm_hw_params *params,
  333. struct snd_soc_dai *dai)
  334. {
  335. struct snd_soc_pcm_runtime *rtd = substream->private_data;
  336. struct snd_soc_device *socdev = rtd->socdev;
  337. struct snd_soc_codec *codec = socdev->card->codec;
  338. u16 iface = snd_soc_read(codec, WM8510_IFACE) & 0x19f;
  339. u16 adn = snd_soc_read(codec, WM8510_ADD) & 0x1f1;
  340. /* bit size */
  341. switch (params_format(params)) {
  342. case SNDRV_PCM_FORMAT_S16_LE:
  343. break;
  344. case SNDRV_PCM_FORMAT_S20_3LE:
  345. iface |= 0x0020;
  346. break;
  347. case SNDRV_PCM_FORMAT_S24_LE:
  348. iface |= 0x0040;
  349. break;
  350. case SNDRV_PCM_FORMAT_S32_LE:
  351. iface |= 0x0060;
  352. break;
  353. }
  354. /* filter coefficient */
  355. switch (params_rate(params)) {
  356. case 8000:
  357. adn |= 0x5 << 1;
  358. break;
  359. case 11025:
  360. adn |= 0x4 << 1;
  361. break;
  362. case 16000:
  363. adn |= 0x3 << 1;
  364. break;
  365. case 22050:
  366. adn |= 0x2 << 1;
  367. break;
  368. case 32000:
  369. adn |= 0x1 << 1;
  370. break;
  371. case 44100:
  372. case 48000:
  373. break;
  374. }
  375. snd_soc_write(codec, WM8510_IFACE, iface);
  376. snd_soc_write(codec, WM8510_ADD, adn);
  377. return 0;
  378. }
  379. static int wm8510_mute(struct snd_soc_dai *dai, int mute)
  380. {
  381. struct snd_soc_codec *codec = dai->codec;
  382. u16 mute_reg = snd_soc_read(codec, WM8510_DAC) & 0xffbf;
  383. if (mute)
  384. snd_soc_write(codec, WM8510_DAC, mute_reg | 0x40);
  385. else
  386. snd_soc_write(codec, WM8510_DAC, mute_reg);
  387. return 0;
  388. }
  389. /* liam need to make this lower power with dapm */
  390. static int wm8510_set_bias_level(struct snd_soc_codec *codec,
  391. enum snd_soc_bias_level level)
  392. {
  393. u16 power1 = snd_soc_read(codec, WM8510_POWER1) & ~0x3;
  394. switch (level) {
  395. case SND_SOC_BIAS_ON:
  396. case SND_SOC_BIAS_PREPARE:
  397. power1 |= 0x1; /* VMID 50k */
  398. snd_soc_write(codec, WM8510_POWER1, power1);
  399. break;
  400. case SND_SOC_BIAS_STANDBY:
  401. power1 |= WM8510_POWER1_BIASEN | WM8510_POWER1_BUFIOEN;
  402. if (codec->bias_level == SND_SOC_BIAS_OFF) {
  403. /* Initial cap charge at VMID 5k */
  404. snd_soc_write(codec, WM8510_POWER1, power1 | 0x3);
  405. mdelay(100);
  406. }
  407. power1 |= 0x2; /* VMID 500k */
  408. snd_soc_write(codec, WM8510_POWER1, power1);
  409. break;
  410. case SND_SOC_BIAS_OFF:
  411. snd_soc_write(codec, WM8510_POWER1, 0);
  412. snd_soc_write(codec, WM8510_POWER2, 0);
  413. snd_soc_write(codec, WM8510_POWER3, 0);
  414. break;
  415. }
  416. codec->bias_level = level;
  417. return 0;
  418. }
  419. #define WM8510_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
  420. SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
  421. SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000)
  422. #define WM8510_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
  423. SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
  424. static struct snd_soc_dai_ops wm8510_dai_ops = {
  425. .hw_params = wm8510_pcm_hw_params,
  426. .digital_mute = wm8510_mute,
  427. .set_fmt = wm8510_set_dai_fmt,
  428. .set_clkdiv = wm8510_set_dai_clkdiv,
  429. .set_pll = wm8510_set_dai_pll,
  430. };
  431. struct snd_soc_dai wm8510_dai = {
  432. .name = "WM8510 HiFi",
  433. .playback = {
  434. .stream_name = "Playback",
  435. .channels_min = 2,
  436. .channels_max = 2,
  437. .rates = WM8510_RATES,
  438. .formats = WM8510_FORMATS,},
  439. .capture = {
  440. .stream_name = "Capture",
  441. .channels_min = 2,
  442. .channels_max = 2,
  443. .rates = WM8510_RATES,
  444. .formats = WM8510_FORMATS,},
  445. .ops = &wm8510_dai_ops,
  446. .symmetric_rates = 1,
  447. };
  448. EXPORT_SYMBOL_GPL(wm8510_dai);
  449. static int wm8510_suspend(struct platform_device *pdev, pm_message_t state)
  450. {
  451. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  452. struct snd_soc_codec *codec = socdev->card->codec;
  453. wm8510_set_bias_level(codec, SND_SOC_BIAS_OFF);
  454. return 0;
  455. }
  456. static int wm8510_resume(struct platform_device *pdev)
  457. {
  458. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  459. struct snd_soc_codec *codec = socdev->card->codec;
  460. int i;
  461. u8 data[2];
  462. u16 *cache = codec->reg_cache;
  463. /* Sync reg_cache with the hardware */
  464. for (i = 0; i < ARRAY_SIZE(wm8510_reg); i++) {
  465. data[0] = (i << 1) | ((cache[i] >> 8) & 0x0001);
  466. data[1] = cache[i] & 0x00ff;
  467. codec->hw_write(codec->control_data, data, 2);
  468. }
  469. wm8510_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
  470. return 0;
  471. }
  472. /*
  473. * initialise the WM8510 driver
  474. * register the mixer and dsp interfaces with the kernel
  475. */
  476. static int wm8510_init(struct snd_soc_device *socdev,
  477. enum snd_soc_control_type control)
  478. {
  479. struct snd_soc_codec *codec = socdev->card->codec;
  480. int ret = 0;
  481. codec->name = "WM8510";
  482. codec->owner = THIS_MODULE;
  483. codec->set_bias_level = wm8510_set_bias_level;
  484. codec->dai = &wm8510_dai;
  485. codec->num_dai = 1;
  486. codec->reg_cache_size = ARRAY_SIZE(wm8510_reg);
  487. codec->reg_cache = kmemdup(wm8510_reg, sizeof(wm8510_reg), GFP_KERNEL);
  488. if (codec->reg_cache == NULL)
  489. return -ENOMEM;
  490. ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
  491. if (ret < 0) {
  492. printk(KERN_ERR "wm8510: failed to set cache I/O: %d\n",
  493. ret);
  494. goto err;
  495. }
  496. wm8510_reset(codec);
  497. /* register pcms */
  498. ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
  499. if (ret < 0) {
  500. printk(KERN_ERR "wm8510: failed to create pcms\n");
  501. goto err;
  502. }
  503. /* power on device */
  504. codec->bias_level = SND_SOC_BIAS_OFF;
  505. wm8510_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
  506. snd_soc_add_controls(codec, wm8510_snd_controls,
  507. ARRAY_SIZE(wm8510_snd_controls));
  508. wm8510_add_widgets(codec);
  509. return ret;
  510. err:
  511. kfree(codec->reg_cache);
  512. return ret;
  513. }
  514. static struct snd_soc_device *wm8510_socdev;
  515. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  516. /*
  517. * WM8510 2 wire address is 0x1a
  518. */
  519. static int wm8510_i2c_probe(struct i2c_client *i2c,
  520. const struct i2c_device_id *id)
  521. {
  522. struct snd_soc_device *socdev = wm8510_socdev;
  523. struct snd_soc_codec *codec = socdev->card->codec;
  524. int ret;
  525. i2c_set_clientdata(i2c, codec);
  526. codec->control_data = i2c;
  527. ret = wm8510_init(socdev, SND_SOC_I2C);
  528. if (ret < 0)
  529. pr_err("failed to initialise WM8510\n");
  530. return ret;
  531. }
  532. static int wm8510_i2c_remove(struct i2c_client *client)
  533. {
  534. struct snd_soc_codec *codec = i2c_get_clientdata(client);
  535. kfree(codec->reg_cache);
  536. return 0;
  537. }
  538. static const struct i2c_device_id wm8510_i2c_id[] = {
  539. { "wm8510", 0 },
  540. { }
  541. };
  542. MODULE_DEVICE_TABLE(i2c, wm8510_i2c_id);
  543. static struct i2c_driver wm8510_i2c_driver = {
  544. .driver = {
  545. .name = "WM8510 I2C Codec",
  546. .owner = THIS_MODULE,
  547. },
  548. .probe = wm8510_i2c_probe,
  549. .remove = wm8510_i2c_remove,
  550. .id_table = wm8510_i2c_id,
  551. };
  552. static int wm8510_add_i2c_device(struct platform_device *pdev,
  553. const struct wm8510_setup_data *setup)
  554. {
  555. struct i2c_board_info info;
  556. struct i2c_adapter *adapter;
  557. struct i2c_client *client;
  558. int ret;
  559. ret = i2c_add_driver(&wm8510_i2c_driver);
  560. if (ret != 0) {
  561. dev_err(&pdev->dev, "can't add i2c driver\n");
  562. return ret;
  563. }
  564. memset(&info, 0, sizeof(struct i2c_board_info));
  565. info.addr = setup->i2c_address;
  566. strlcpy(info.type, "wm8510", I2C_NAME_SIZE);
  567. adapter = i2c_get_adapter(setup->i2c_bus);
  568. if (!adapter) {
  569. dev_err(&pdev->dev, "can't get i2c adapter %d\n",
  570. setup->i2c_bus);
  571. goto err_driver;
  572. }
  573. client = i2c_new_device(adapter, &info);
  574. i2c_put_adapter(adapter);
  575. if (!client) {
  576. dev_err(&pdev->dev, "can't add i2c device at 0x%x\n",
  577. (unsigned int)info.addr);
  578. goto err_driver;
  579. }
  580. return 0;
  581. err_driver:
  582. i2c_del_driver(&wm8510_i2c_driver);
  583. return -ENODEV;
  584. }
  585. #endif
  586. #if defined(CONFIG_SPI_MASTER)
  587. static int __devinit wm8510_spi_probe(struct spi_device *spi)
  588. {
  589. struct snd_soc_device *socdev = wm8510_socdev;
  590. struct snd_soc_codec *codec = socdev->card->codec;
  591. int ret;
  592. codec->control_data = spi;
  593. ret = wm8510_init(socdev, SND_SOC_SPI);
  594. if (ret < 0)
  595. dev_err(&spi->dev, "failed to initialise WM8510\n");
  596. return ret;
  597. }
  598. static int __devexit wm8510_spi_remove(struct spi_device *spi)
  599. {
  600. return 0;
  601. }
  602. static struct spi_driver wm8510_spi_driver = {
  603. .driver = {
  604. .name = "wm8510",
  605. .bus = &spi_bus_type,
  606. .owner = THIS_MODULE,
  607. },
  608. .probe = wm8510_spi_probe,
  609. .remove = __devexit_p(wm8510_spi_remove),
  610. };
  611. #endif /* CONFIG_SPI_MASTER */
  612. static int wm8510_probe(struct platform_device *pdev)
  613. {
  614. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  615. struct wm8510_setup_data *setup;
  616. struct snd_soc_codec *codec;
  617. int ret = 0;
  618. pr_info("WM8510 Audio Codec %s", WM8510_VERSION);
  619. setup = socdev->codec_data;
  620. codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
  621. if (codec == NULL)
  622. return -ENOMEM;
  623. socdev->card->codec = codec;
  624. mutex_init(&codec->mutex);
  625. INIT_LIST_HEAD(&codec->dapm_widgets);
  626. INIT_LIST_HEAD(&codec->dapm_paths);
  627. wm8510_socdev = socdev;
  628. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  629. if (setup->i2c_address) {
  630. ret = wm8510_add_i2c_device(pdev, setup);
  631. }
  632. #endif
  633. #if defined(CONFIG_SPI_MASTER)
  634. if (setup->spi) {
  635. ret = spi_register_driver(&wm8510_spi_driver);
  636. if (ret != 0)
  637. printk(KERN_ERR "can't add spi driver");
  638. }
  639. #endif
  640. if (ret != 0)
  641. kfree(codec);
  642. return ret;
  643. }
  644. /* power down chip */
  645. static int wm8510_remove(struct platform_device *pdev)
  646. {
  647. struct snd_soc_device *socdev = platform_get_drvdata(pdev);
  648. struct snd_soc_codec *codec = socdev->card->codec;
  649. if (codec->control_data)
  650. wm8510_set_bias_level(codec, SND_SOC_BIAS_OFF);
  651. snd_soc_free_pcms(socdev);
  652. snd_soc_dapm_free(socdev);
  653. #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
  654. i2c_unregister_device(codec->control_data);
  655. i2c_del_driver(&wm8510_i2c_driver);
  656. #endif
  657. #if defined(CONFIG_SPI_MASTER)
  658. spi_unregister_driver(&wm8510_spi_driver);
  659. #endif
  660. kfree(codec);
  661. return 0;
  662. }
  663. struct snd_soc_codec_device soc_codec_dev_wm8510 = {
  664. .probe = wm8510_probe,
  665. .remove = wm8510_remove,
  666. .suspend = wm8510_suspend,
  667. .resume = wm8510_resume,
  668. };
  669. EXPORT_SYMBOL_GPL(soc_codec_dev_wm8510);
  670. static int __init wm8510_modinit(void)
  671. {
  672. return snd_soc_register_dai(&wm8510_dai);
  673. }
  674. module_init(wm8510_modinit);
  675. static void __exit wm8510_exit(void)
  676. {
  677. snd_soc_unregister_dai(&wm8510_dai);
  678. }
  679. module_exit(wm8510_exit);
  680. MODULE_DESCRIPTION("ASoC WM8510 driver");
  681. MODULE_AUTHOR("Liam Girdwood");
  682. MODULE_LICENSE("GPL");