wm8974.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * wm8974.c -- WM8974 ALSA Soc Audio driver
  4. *
  5. * Copyright 2006-2009 Wolfson Microelectronics PLC.
  6. *
  7. * Author: Liam Girdwood <Liam.Girdwood@wolfsonmicro.com>
  8. */
  9. #include <linux/module.h>
  10. #include <linux/kernel.h>
  11. #include <linux/init.h>
  12. #include <linux/delay.h>
  13. #include <linux/pm.h>
  14. #include <linux/i2c.h>
  15. #include <linux/regmap.h>
  16. #include <linux/slab.h>
  17. #include <sound/core.h>
  18. #include <sound/pcm.h>
  19. #include <sound/pcm_params.h>
  20. #include <sound/soc.h>
  21. #include <sound/initval.h>
  22. #include <sound/tlv.h>
  23. #include "wm8974.h"
  24. struct wm8974_priv {
  25. unsigned int mclk;
  26. unsigned int fs;
  27. };
  28. static const struct reg_default wm8974_reg_defaults[] = {
  29. { 0, 0x0000 }, { 1, 0x0000 }, { 2, 0x0000 }, { 3, 0x0000 },
  30. { 4, 0x0050 }, { 5, 0x0000 }, { 6, 0x0140 }, { 7, 0x0000 },
  31. { 8, 0x0000 }, { 9, 0x0000 }, { 10, 0x0000 }, { 11, 0x00ff },
  32. { 12, 0x0000 }, { 13, 0x0000 }, { 14, 0x0100 }, { 15, 0x00ff },
  33. { 16, 0x0000 }, { 17, 0x0000 }, { 18, 0x012c }, { 19, 0x002c },
  34. { 20, 0x002c }, { 21, 0x002c }, { 22, 0x002c }, { 23, 0x0000 },
  35. { 24, 0x0032 }, { 25, 0x0000 }, { 26, 0x0000 }, { 27, 0x0000 },
  36. { 28, 0x0000 }, { 29, 0x0000 }, { 30, 0x0000 }, { 31, 0x0000 },
  37. { 32, 0x0038 }, { 33, 0x000b }, { 34, 0x0032 }, { 35, 0x0000 },
  38. { 36, 0x0008 }, { 37, 0x000c }, { 38, 0x0093 }, { 39, 0x00e9 },
  39. { 40, 0x0000 }, { 41, 0x0000 }, { 42, 0x0000 }, { 43, 0x0000 },
  40. { 44, 0x0003 }, { 45, 0x0010 }, { 46, 0x0000 }, { 47, 0x0000 },
  41. { 48, 0x0000 }, { 49, 0x0002 }, { 50, 0x0000 }, { 51, 0x0000 },
  42. { 52, 0x0000 }, { 53, 0x0000 }, { 54, 0x0039 }, { 55, 0x0000 },
  43. { 56, 0x0000 },
  44. };
  45. #define WM8974_POWER1_BIASEN 0x08
  46. #define WM8974_POWER1_BUFIOEN 0x04
  47. #define wm8974_reset(c) snd_soc_component_write(c, WM8974_RESET, 0)
  48. static const char *wm8974_companding[] = {"Off", "NC", "u-law", "A-law" };
  49. static const char *wm8974_deemp[] = {"None", "32kHz", "44.1kHz", "48kHz" };
  50. static const char *wm8974_eqmode[] = {"Capture", "Playback" };
  51. static const char *wm8974_bw[] = {"Narrow", "Wide" };
  52. static const char *wm8974_eq1[] = {"80Hz", "105Hz", "135Hz", "175Hz" };
  53. static const char *wm8974_eq2[] = {"230Hz", "300Hz", "385Hz", "500Hz" };
  54. static const char *wm8974_eq3[] = {"650Hz", "850Hz", "1.1kHz", "1.4kHz" };
  55. static const char *wm8974_eq4[] = {"1.8kHz", "2.4kHz", "3.2kHz", "4.1kHz" };
  56. static const char *wm8974_eq5[] = {"5.3kHz", "6.9kHz", "9kHz", "11.7kHz" };
  57. static const char *wm8974_alc[] = {"ALC", "Limiter" };
  58. static const struct soc_enum wm8974_enum[] = {
  59. SOC_ENUM_SINGLE(WM8974_COMP, 1, 4, wm8974_companding), /* adc */
  60. SOC_ENUM_SINGLE(WM8974_COMP, 3, 4, wm8974_companding), /* dac */
  61. SOC_ENUM_SINGLE(WM8974_DAC, 4, 4, wm8974_deemp),
  62. SOC_ENUM_SINGLE(WM8974_EQ1, 8, 2, wm8974_eqmode),
  63. SOC_ENUM_SINGLE(WM8974_EQ1, 5, 4, wm8974_eq1),
  64. SOC_ENUM_SINGLE(WM8974_EQ2, 8, 2, wm8974_bw),
  65. SOC_ENUM_SINGLE(WM8974_EQ2, 5, 4, wm8974_eq2),
  66. SOC_ENUM_SINGLE(WM8974_EQ3, 8, 2, wm8974_bw),
  67. SOC_ENUM_SINGLE(WM8974_EQ3, 5, 4, wm8974_eq3),
  68. SOC_ENUM_SINGLE(WM8974_EQ4, 8, 2, wm8974_bw),
  69. SOC_ENUM_SINGLE(WM8974_EQ4, 5, 4, wm8974_eq4),
  70. SOC_ENUM_SINGLE(WM8974_EQ5, 8, 2, wm8974_bw),
  71. SOC_ENUM_SINGLE(WM8974_EQ5, 5, 4, wm8974_eq5),
  72. SOC_ENUM_SINGLE(WM8974_ALC3, 8, 2, wm8974_alc),
  73. };
  74. static const char *wm8974_auxmode_text[] = { "Buffer", "Mixer" };
  75. static SOC_ENUM_SINGLE_DECL(wm8974_auxmode,
  76. WM8974_INPUT, 3, wm8974_auxmode_text);
  77. static const DECLARE_TLV_DB_SCALE(digital_tlv, -12750, 50, 1);
  78. static const DECLARE_TLV_DB_SCALE(eq_tlv, -1200, 100, 0);
  79. static const DECLARE_TLV_DB_SCALE(inpga_tlv, -1200, 75, 0);
  80. static const DECLARE_TLV_DB_SCALE(spk_tlv, -5700, 100, 0);
  81. static const struct snd_kcontrol_new wm8974_snd_controls[] = {
  82. SOC_SINGLE("Digital Loopback Switch", WM8974_COMP, 0, 1, 0),
  83. SOC_ENUM("DAC Companding", wm8974_enum[1]),
  84. SOC_ENUM("ADC Companding", wm8974_enum[0]),
  85. SOC_ENUM("Playback De-emphasis", wm8974_enum[2]),
  86. SOC_SINGLE("DAC Inversion Switch", WM8974_DAC, 0, 1, 0),
  87. SOC_SINGLE_TLV("PCM Volume", WM8974_DACVOL, 0, 255, 0, digital_tlv),
  88. SOC_SINGLE("High Pass Filter Switch", WM8974_ADC, 8, 1, 0),
  89. SOC_SINGLE("High Pass Cut Off", WM8974_ADC, 4, 7, 0),
  90. SOC_SINGLE("ADC Inversion Switch", WM8974_ADC, 0, 1, 0),
  91. SOC_SINGLE_TLV("Capture Volume", WM8974_ADCVOL, 0, 255, 0, digital_tlv),
  92. SOC_ENUM("Equaliser Function", wm8974_enum[3]),
  93. SOC_ENUM("EQ1 Cut Off", wm8974_enum[4]),
  94. SOC_SINGLE_TLV("EQ1 Volume", WM8974_EQ1, 0, 24, 1, eq_tlv),
  95. SOC_ENUM("Equaliser EQ2 Bandwidth", wm8974_enum[5]),
  96. SOC_ENUM("EQ2 Cut Off", wm8974_enum[6]),
  97. SOC_SINGLE_TLV("EQ2 Volume", WM8974_EQ2, 0, 24, 1, eq_tlv),
  98. SOC_ENUM("Equaliser EQ3 Bandwidth", wm8974_enum[7]),
  99. SOC_ENUM("EQ3 Cut Off", wm8974_enum[8]),
  100. SOC_SINGLE_TLV("EQ3 Volume", WM8974_EQ3, 0, 24, 1, eq_tlv),
  101. SOC_ENUM("Equaliser EQ4 Bandwidth", wm8974_enum[9]),
  102. SOC_ENUM("EQ4 Cut Off", wm8974_enum[10]),
  103. SOC_SINGLE_TLV("EQ4 Volume", WM8974_EQ4, 0, 24, 1, eq_tlv),
  104. SOC_ENUM("Equaliser EQ5 Bandwidth", wm8974_enum[11]),
  105. SOC_ENUM("EQ5 Cut Off", wm8974_enum[12]),
  106. SOC_SINGLE_TLV("EQ5 Volume", WM8974_EQ5, 0, 24, 1, eq_tlv),
  107. SOC_SINGLE("DAC Playback Limiter Switch", WM8974_DACLIM1, 8, 1, 0),
  108. SOC_SINGLE("DAC Playback Limiter Decay", WM8974_DACLIM1, 4, 15, 0),
  109. SOC_SINGLE("DAC Playback Limiter Attack", WM8974_DACLIM1, 0, 15, 0),
  110. SOC_SINGLE("DAC Playback Limiter Threshold", WM8974_DACLIM2, 4, 7, 0),
  111. SOC_SINGLE("DAC Playback Limiter Boost", WM8974_DACLIM2, 0, 15, 0),
  112. SOC_SINGLE("ALC Enable Switch", WM8974_ALC1, 8, 1, 0),
  113. SOC_SINGLE("ALC Capture Max Gain", WM8974_ALC1, 3, 7, 0),
  114. SOC_SINGLE("ALC Capture Min Gain", WM8974_ALC1, 0, 7, 0),
  115. SOC_SINGLE("ALC Capture ZC Switch", WM8974_ALC2, 8, 1, 0),
  116. SOC_SINGLE("ALC Capture Hold", WM8974_ALC2, 4, 7, 0),
  117. SOC_SINGLE("ALC Capture Target", WM8974_ALC2, 0, 15, 0),
  118. SOC_ENUM("ALC Capture Mode", wm8974_enum[13]),
  119. SOC_SINGLE("ALC Capture Decay", WM8974_ALC3, 4, 15, 0),
  120. SOC_SINGLE("ALC Capture Attack", WM8974_ALC3, 0, 15, 0),
  121. SOC_SINGLE("ALC Capture Noise Gate Switch", WM8974_NGATE, 3, 1, 0),
  122. SOC_SINGLE("ALC Capture Noise Gate Threshold", WM8974_NGATE, 0, 7, 0),
  123. SOC_SINGLE("Capture PGA ZC Switch", WM8974_INPPGA, 7, 1, 0),
  124. SOC_SINGLE_TLV("Capture PGA Volume", WM8974_INPPGA, 0, 63, 0, inpga_tlv),
  125. SOC_SINGLE("Speaker Playback ZC Switch", WM8974_SPKVOL, 7, 1, 0),
  126. SOC_SINGLE("Speaker Playback Switch", WM8974_SPKVOL, 6, 1, 1),
  127. SOC_SINGLE_TLV("Speaker Playback Volume", WM8974_SPKVOL, 0, 63, 0, spk_tlv),
  128. SOC_ENUM("Aux Mode", wm8974_auxmode),
  129. SOC_SINGLE("Capture Boost(+20dB)", WM8974_ADCBOOST, 8, 1, 0),
  130. SOC_SINGLE("Mono Playback Switch", WM8974_MONOMIX, 6, 1, 1),
  131. /* DAC / ADC oversampling */
  132. SOC_SINGLE("DAC 128x Oversampling Switch", WM8974_DAC, 8, 1, 0),
  133. SOC_SINGLE("ADC 128x Oversampling Switch", WM8974_ADC, 8, 1, 0),
  134. };
  135. /* Speaker Output Mixer */
  136. static const struct snd_kcontrol_new wm8974_speaker_mixer_controls[] = {
  137. SOC_DAPM_SINGLE("Line Bypass Switch", WM8974_SPKMIX, 1, 1, 0),
  138. SOC_DAPM_SINGLE("Aux Playback Switch", WM8974_SPKMIX, 5, 1, 0),
  139. SOC_DAPM_SINGLE("PCM Playback Switch", WM8974_SPKMIX, 0, 1, 0),
  140. };
  141. /* Mono Output Mixer */
  142. static const struct snd_kcontrol_new wm8974_mono_mixer_controls[] = {
  143. SOC_DAPM_SINGLE("Line Bypass Switch", WM8974_MONOMIX, 1, 1, 0),
  144. SOC_DAPM_SINGLE("Aux Playback Switch", WM8974_MONOMIX, 2, 1, 0),
  145. SOC_DAPM_SINGLE("PCM Playback Switch", WM8974_MONOMIX, 0, 1, 0),
  146. };
  147. /* Boost mixer */
  148. static const struct snd_kcontrol_new wm8974_boost_mixer[] = {
  149. SOC_DAPM_SINGLE("Aux Switch", WM8974_INPPGA, 6, 1, 1),
  150. };
  151. /* Input PGA */
  152. static const struct snd_kcontrol_new wm8974_inpga[] = {
  153. SOC_DAPM_SINGLE("Aux Switch", WM8974_INPUT, 2, 1, 0),
  154. SOC_DAPM_SINGLE("MicN Switch", WM8974_INPUT, 1, 1, 0),
  155. SOC_DAPM_SINGLE("MicP Switch", WM8974_INPUT, 0, 1, 0),
  156. };
  157. static const struct snd_soc_dapm_widget wm8974_dapm_widgets[] = {
  158. SND_SOC_DAPM_MIXER("Speaker Mixer", WM8974_POWER3, 2, 0,
  159. &wm8974_speaker_mixer_controls[0],
  160. ARRAY_SIZE(wm8974_speaker_mixer_controls)),
  161. SND_SOC_DAPM_MIXER("Mono Mixer", WM8974_POWER3, 3, 0,
  162. &wm8974_mono_mixer_controls[0],
  163. ARRAY_SIZE(wm8974_mono_mixer_controls)),
  164. SND_SOC_DAPM_DAC("DAC", "HiFi Playback", WM8974_POWER3, 0, 0),
  165. SND_SOC_DAPM_ADC("ADC", "HiFi Capture", WM8974_POWER2, 0, 0),
  166. SND_SOC_DAPM_PGA("Aux Input", WM8974_POWER1, 6, 0, NULL, 0),
  167. SND_SOC_DAPM_PGA("SpkN Out", WM8974_POWER3, 5, 0, NULL, 0),
  168. SND_SOC_DAPM_PGA("SpkP Out", WM8974_POWER3, 6, 0, NULL, 0),
  169. SND_SOC_DAPM_PGA("Mono Out", WM8974_POWER3, 7, 0, NULL, 0),
  170. SND_SOC_DAPM_MIXER("Input PGA", WM8974_POWER2, 2, 0, wm8974_inpga,
  171. ARRAY_SIZE(wm8974_inpga)),
  172. SND_SOC_DAPM_MIXER("Boost Mixer", WM8974_POWER2, 4, 0,
  173. wm8974_boost_mixer, ARRAY_SIZE(wm8974_boost_mixer)),
  174. SND_SOC_DAPM_SUPPLY("Mic Bias", WM8974_POWER1, 4, 0, NULL, 0),
  175. SND_SOC_DAPM_INPUT("MICN"),
  176. SND_SOC_DAPM_INPUT("MICP"),
  177. SND_SOC_DAPM_INPUT("AUX"),
  178. SND_SOC_DAPM_OUTPUT("MONOOUT"),
  179. SND_SOC_DAPM_OUTPUT("SPKOUTP"),
  180. SND_SOC_DAPM_OUTPUT("SPKOUTN"),
  181. };
  182. static const struct snd_soc_dapm_route wm8974_dapm_routes[] = {
  183. /* Mono output mixer */
  184. {"Mono Mixer", "PCM Playback Switch", "DAC"},
  185. {"Mono Mixer", "Aux Playback Switch", "Aux Input"},
  186. {"Mono Mixer", "Line Bypass Switch", "Boost Mixer"},
  187. /* Speaker output mixer */
  188. {"Speaker Mixer", "PCM Playback Switch", "DAC"},
  189. {"Speaker Mixer", "Aux Playback Switch", "Aux Input"},
  190. {"Speaker Mixer", "Line Bypass Switch", "Boost Mixer"},
  191. /* Outputs */
  192. {"Mono Out", NULL, "Mono Mixer"},
  193. {"MONOOUT", NULL, "Mono Out"},
  194. {"SpkN Out", NULL, "Speaker Mixer"},
  195. {"SpkP Out", NULL, "Speaker Mixer"},
  196. {"SPKOUTN", NULL, "SpkN Out"},
  197. {"SPKOUTP", NULL, "SpkP Out"},
  198. /* Boost Mixer */
  199. {"ADC", NULL, "Boost Mixer"},
  200. {"Boost Mixer", "Aux Switch", "Aux Input"},
  201. {"Boost Mixer", NULL, "Input PGA"},
  202. {"Boost Mixer", NULL, "MICP"},
  203. /* Input PGA */
  204. {"Input PGA", "Aux Switch", "Aux Input"},
  205. {"Input PGA", "MicN Switch", "MICN"},
  206. {"Input PGA", "MicP Switch", "MICP"},
  207. /* Inputs */
  208. {"Aux Input", NULL, "AUX"},
  209. };
  210. struct pll_ {
  211. unsigned int pre_div:1;
  212. unsigned int n:4;
  213. unsigned int k;
  214. };
  215. /* The size in bits of the pll divide multiplied by 10
  216. * to allow rounding later */
  217. #define FIXED_PLL_SIZE ((1 << 24) * 10)
  218. static void pll_factors(struct pll_ *pll_div,
  219. unsigned int target, unsigned int source)
  220. {
  221. unsigned long long Kpart;
  222. unsigned int K, Ndiv, Nmod;
  223. /* There is a fixed divide by 4 in the output path */
  224. target *= 4;
  225. Ndiv = target / source;
  226. if (Ndiv < 6) {
  227. source /= 2;
  228. pll_div->pre_div = 1;
  229. Ndiv = target / source;
  230. } else
  231. pll_div->pre_div = 0;
  232. if ((Ndiv < 6) || (Ndiv > 12))
  233. printk(KERN_WARNING
  234. "WM8974 N value %u outwith recommended range!\n",
  235. Ndiv);
  236. pll_div->n = Ndiv;
  237. Nmod = target % source;
  238. Kpart = FIXED_PLL_SIZE * (long long)Nmod;
  239. do_div(Kpart, source);
  240. K = Kpart & 0xFFFFFFFF;
  241. /* Check if we need to round */
  242. if ((K % 10) >= 5)
  243. K += 5;
  244. /* Move down to proper range now rounding is done */
  245. K /= 10;
  246. pll_div->k = K;
  247. }
  248. static int wm8974_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
  249. int source, unsigned int freq_in, unsigned int freq_out)
  250. {
  251. struct snd_soc_component *component = codec_dai->component;
  252. struct pll_ pll_div;
  253. u16 reg;
  254. if (freq_in == 0 || freq_out == 0) {
  255. /* Clock CODEC directly from MCLK */
  256. reg = snd_soc_component_read(component, WM8974_CLOCK);
  257. snd_soc_component_write(component, WM8974_CLOCK, reg & 0x0ff);
  258. /* Turn off PLL */
  259. reg = snd_soc_component_read(component, WM8974_POWER1);
  260. snd_soc_component_write(component, WM8974_POWER1, reg & 0x1df);
  261. return 0;
  262. }
  263. pll_factors(&pll_div, freq_out, freq_in);
  264. snd_soc_component_write(component, WM8974_PLLN, (pll_div.pre_div << 4) | pll_div.n);
  265. snd_soc_component_write(component, WM8974_PLLK1, pll_div.k >> 18);
  266. snd_soc_component_write(component, WM8974_PLLK2, (pll_div.k >> 9) & 0x1ff);
  267. snd_soc_component_write(component, WM8974_PLLK3, pll_div.k & 0x1ff);
  268. reg = snd_soc_component_read(component, WM8974_POWER1);
  269. snd_soc_component_write(component, WM8974_POWER1, reg | 0x020);
  270. /* Run CODEC from PLL instead of MCLK */
  271. reg = snd_soc_component_read(component, WM8974_CLOCK);
  272. snd_soc_component_write(component, WM8974_CLOCK, reg | 0x100);
  273. return 0;
  274. }
  275. /*
  276. * Configure WM8974 clock dividers.
  277. */
  278. static int wm8974_set_dai_clkdiv(struct snd_soc_dai *codec_dai,
  279. int div_id, int div)
  280. {
  281. struct snd_soc_component *component = codec_dai->component;
  282. u16 reg;
  283. switch (div_id) {
  284. case WM8974_OPCLKDIV:
  285. reg = snd_soc_component_read(component, WM8974_GPIO) & 0x1cf;
  286. snd_soc_component_write(component, WM8974_GPIO, reg | div);
  287. break;
  288. case WM8974_MCLKDIV:
  289. reg = snd_soc_component_read(component, WM8974_CLOCK) & 0x11f;
  290. snd_soc_component_write(component, WM8974_CLOCK, reg | div);
  291. break;
  292. case WM8974_BCLKDIV:
  293. reg = snd_soc_component_read(component, WM8974_CLOCK) & 0x1e3;
  294. snd_soc_component_write(component, WM8974_CLOCK, reg | div);
  295. break;
  296. default:
  297. return -EINVAL;
  298. }
  299. return 0;
  300. }
  301. static unsigned int wm8974_get_mclkdiv(unsigned int f_in, unsigned int f_out,
  302. int *mclkdiv)
  303. {
  304. unsigned int ratio = 2 * f_in / f_out;
  305. if (ratio <= 2) {
  306. *mclkdiv = WM8974_MCLKDIV_1;
  307. ratio = 2;
  308. } else if (ratio == 3) {
  309. *mclkdiv = WM8974_MCLKDIV_1_5;
  310. } else if (ratio == 4) {
  311. *mclkdiv = WM8974_MCLKDIV_2;
  312. } else if (ratio <= 6) {
  313. *mclkdiv = WM8974_MCLKDIV_3;
  314. ratio = 6;
  315. } else if (ratio <= 8) {
  316. *mclkdiv = WM8974_MCLKDIV_4;
  317. ratio = 8;
  318. } else if (ratio <= 12) {
  319. *mclkdiv = WM8974_MCLKDIV_6;
  320. ratio = 12;
  321. } else if (ratio <= 16) {
  322. *mclkdiv = WM8974_MCLKDIV_8;
  323. ratio = 16;
  324. } else {
  325. *mclkdiv = WM8974_MCLKDIV_12;
  326. ratio = 24;
  327. }
  328. return f_out * ratio / 2;
  329. }
  330. static int wm8974_update_clocks(struct snd_soc_dai *dai)
  331. {
  332. struct snd_soc_component *component = dai->component;
  333. struct wm8974_priv *priv = snd_soc_component_get_drvdata(component);
  334. unsigned int fs256;
  335. unsigned int fpll = 0;
  336. unsigned int f;
  337. int mclkdiv;
  338. if (!priv->mclk || !priv->fs)
  339. return 0;
  340. fs256 = 256 * priv->fs;
  341. f = wm8974_get_mclkdiv(priv->mclk, fs256, &mclkdiv);
  342. if (f != priv->mclk) {
  343. /* The PLL performs best around 90MHz */
  344. fpll = wm8974_get_mclkdiv(22500000, fs256, &mclkdiv);
  345. }
  346. wm8974_set_dai_pll(dai, 0, 0, priv->mclk, fpll);
  347. wm8974_set_dai_clkdiv(dai, WM8974_MCLKDIV, mclkdiv);
  348. return 0;
  349. }
  350. static int wm8974_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id,
  351. unsigned int freq, int dir)
  352. {
  353. struct snd_soc_component *component = dai->component;
  354. struct wm8974_priv *priv = snd_soc_component_get_drvdata(component);
  355. if (dir != SND_SOC_CLOCK_IN)
  356. return -EINVAL;
  357. priv->mclk = freq;
  358. return wm8974_update_clocks(dai);
  359. }
  360. static int wm8974_set_dai_fmt(struct snd_soc_dai *codec_dai,
  361. unsigned int fmt)
  362. {
  363. struct snd_soc_component *component = codec_dai->component;
  364. u16 iface = 0;
  365. u16 clk = snd_soc_component_read(component, WM8974_CLOCK) & 0x1fe;
  366. /* set master/slave audio interface */
  367. switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
  368. case SND_SOC_DAIFMT_CBM_CFM:
  369. clk |= 0x0001;
  370. break;
  371. case SND_SOC_DAIFMT_CBS_CFS:
  372. break;
  373. default:
  374. return -EINVAL;
  375. }
  376. /* interface format */
  377. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  378. case SND_SOC_DAIFMT_I2S:
  379. iface |= 0x0010;
  380. break;
  381. case SND_SOC_DAIFMT_RIGHT_J:
  382. break;
  383. case SND_SOC_DAIFMT_LEFT_J:
  384. iface |= 0x0008;
  385. break;
  386. case SND_SOC_DAIFMT_DSP_A:
  387. if ((fmt & SND_SOC_DAIFMT_INV_MASK) == SND_SOC_DAIFMT_IB_IF ||
  388. (fmt & SND_SOC_DAIFMT_INV_MASK) == SND_SOC_DAIFMT_NB_IF) {
  389. return -EINVAL;
  390. }
  391. iface |= 0x00018;
  392. break;
  393. default:
  394. return -EINVAL;
  395. }
  396. /* clock inversion */
  397. switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
  398. case SND_SOC_DAIFMT_NB_NF:
  399. break;
  400. case SND_SOC_DAIFMT_IB_IF:
  401. iface |= 0x0180;
  402. break;
  403. case SND_SOC_DAIFMT_IB_NF:
  404. iface |= 0x0100;
  405. break;
  406. case SND_SOC_DAIFMT_NB_IF:
  407. iface |= 0x0080;
  408. break;
  409. default:
  410. return -EINVAL;
  411. }
  412. snd_soc_component_write(component, WM8974_IFACE, iface);
  413. snd_soc_component_write(component, WM8974_CLOCK, clk);
  414. return 0;
  415. }
  416. static int wm8974_pcm_hw_params(struct snd_pcm_substream *substream,
  417. struct snd_pcm_hw_params *params,
  418. struct snd_soc_dai *dai)
  419. {
  420. struct snd_soc_component *component = dai->component;
  421. struct wm8974_priv *priv = snd_soc_component_get_drvdata(component);
  422. u16 iface = snd_soc_component_read(component, WM8974_IFACE) & 0x19f;
  423. u16 adn = snd_soc_component_read(component, WM8974_ADD) & 0x1f1;
  424. int err;
  425. priv->fs = params_rate(params);
  426. err = wm8974_update_clocks(dai);
  427. if (err)
  428. return err;
  429. /* bit size */
  430. switch (params_width(params)) {
  431. case 16:
  432. break;
  433. case 20:
  434. iface |= 0x0020;
  435. break;
  436. case 24:
  437. iface |= 0x0040;
  438. break;
  439. case 32:
  440. iface |= 0x0060;
  441. break;
  442. }
  443. /* filter coefficient */
  444. switch (params_rate(params)) {
  445. case 8000:
  446. adn |= 0x5 << 1;
  447. break;
  448. case 11025:
  449. adn |= 0x4 << 1;
  450. break;
  451. case 16000:
  452. adn |= 0x3 << 1;
  453. break;
  454. case 22050:
  455. adn |= 0x2 << 1;
  456. break;
  457. case 32000:
  458. adn |= 0x1 << 1;
  459. break;
  460. case 44100:
  461. case 48000:
  462. break;
  463. }
  464. snd_soc_component_write(component, WM8974_IFACE, iface);
  465. snd_soc_component_write(component, WM8974_ADD, adn);
  466. return 0;
  467. }
  468. static int wm8974_mute(struct snd_soc_dai *dai, int mute, int direction)
  469. {
  470. struct snd_soc_component *component = dai->component;
  471. u16 mute_reg = snd_soc_component_read(component, WM8974_DAC) & 0xffbf;
  472. if (mute)
  473. snd_soc_component_write(component, WM8974_DAC, mute_reg | 0x40);
  474. else
  475. snd_soc_component_write(component, WM8974_DAC, mute_reg);
  476. return 0;
  477. }
  478. /* liam need to make this lower power with dapm */
  479. static int wm8974_set_bias_level(struct snd_soc_component *component,
  480. enum snd_soc_bias_level level)
  481. {
  482. u16 power1 = snd_soc_component_read(component, WM8974_POWER1) & ~0x3;
  483. switch (level) {
  484. case SND_SOC_BIAS_ON:
  485. case SND_SOC_BIAS_PREPARE:
  486. power1 |= 0x1; /* VMID 50k */
  487. snd_soc_component_write(component, WM8974_POWER1, power1);
  488. break;
  489. case SND_SOC_BIAS_STANDBY:
  490. power1 |= WM8974_POWER1_BIASEN | WM8974_POWER1_BUFIOEN;
  491. if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
  492. regcache_sync(dev_get_regmap(component->dev, NULL));
  493. /* Initial cap charge at VMID 5k */
  494. snd_soc_component_write(component, WM8974_POWER1, power1 | 0x3);
  495. mdelay(100);
  496. }
  497. power1 |= 0x2; /* VMID 500k */
  498. snd_soc_component_write(component, WM8974_POWER1, power1);
  499. break;
  500. case SND_SOC_BIAS_OFF:
  501. snd_soc_component_write(component, WM8974_POWER1, 0);
  502. snd_soc_component_write(component, WM8974_POWER2, 0);
  503. snd_soc_component_write(component, WM8974_POWER3, 0);
  504. break;
  505. }
  506. return 0;
  507. }
  508. #define WM8974_RATES (SNDRV_PCM_RATE_8000_48000)
  509. #define WM8974_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
  510. SNDRV_PCM_FMTBIT_S24_LE)
  511. static const struct snd_soc_dai_ops wm8974_ops = {
  512. .hw_params = wm8974_pcm_hw_params,
  513. .mute_stream = wm8974_mute,
  514. .set_fmt = wm8974_set_dai_fmt,
  515. .set_clkdiv = wm8974_set_dai_clkdiv,
  516. .set_pll = wm8974_set_dai_pll,
  517. .set_sysclk = wm8974_set_dai_sysclk,
  518. .no_capture_mute = 1,
  519. };
  520. static struct snd_soc_dai_driver wm8974_dai = {
  521. .name = "wm8974-hifi",
  522. .playback = {
  523. .stream_name = "Playback",
  524. .channels_min = 1,
  525. .channels_max = 2, /* Only 1 channel of data */
  526. .rates = WM8974_RATES,
  527. .formats = WM8974_FORMATS,},
  528. .capture = {
  529. .stream_name = "Capture",
  530. .channels_min = 1,
  531. .channels_max = 2, /* Only 1 channel of data */
  532. .rates = WM8974_RATES,
  533. .formats = WM8974_FORMATS,},
  534. .ops = &wm8974_ops,
  535. .symmetric_rates = 1,
  536. };
  537. static const struct regmap_config wm8974_regmap = {
  538. .reg_bits = 7,
  539. .val_bits = 9,
  540. .max_register = WM8974_MONOMIX,
  541. .reg_defaults = wm8974_reg_defaults,
  542. .num_reg_defaults = ARRAY_SIZE(wm8974_reg_defaults),
  543. .cache_type = REGCACHE_FLAT,
  544. };
  545. static int wm8974_probe(struct snd_soc_component *component)
  546. {
  547. int ret = 0;
  548. ret = wm8974_reset(component);
  549. if (ret < 0) {
  550. dev_err(component->dev, "Failed to issue reset\n");
  551. return ret;
  552. }
  553. return 0;
  554. }
  555. static const struct snd_soc_component_driver soc_component_dev_wm8974 = {
  556. .probe = wm8974_probe,
  557. .set_bias_level = wm8974_set_bias_level,
  558. .controls = wm8974_snd_controls,
  559. .num_controls = ARRAY_SIZE(wm8974_snd_controls),
  560. .dapm_widgets = wm8974_dapm_widgets,
  561. .num_dapm_widgets = ARRAY_SIZE(wm8974_dapm_widgets),
  562. .dapm_routes = wm8974_dapm_routes,
  563. .num_dapm_routes = ARRAY_SIZE(wm8974_dapm_routes),
  564. .suspend_bias_off = 1,
  565. .idle_bias_on = 1,
  566. .use_pmdown_time = 1,
  567. .endianness = 1,
  568. .non_legacy_dai_naming = 1,
  569. };
  570. static int wm8974_i2c_probe(struct i2c_client *i2c,
  571. const struct i2c_device_id *id)
  572. {
  573. struct wm8974_priv *priv;
  574. struct regmap *regmap;
  575. int ret;
  576. priv = devm_kzalloc(&i2c->dev, sizeof(*priv), GFP_KERNEL);
  577. if (!priv)
  578. return -ENOMEM;
  579. i2c_set_clientdata(i2c, priv);
  580. regmap = devm_regmap_init_i2c(i2c, &wm8974_regmap);
  581. if (IS_ERR(regmap))
  582. return PTR_ERR(regmap);
  583. ret = devm_snd_soc_register_component(&i2c->dev,
  584. &soc_component_dev_wm8974, &wm8974_dai, 1);
  585. return ret;
  586. }
  587. static const struct i2c_device_id wm8974_i2c_id[] = {
  588. { "wm8974", 0 },
  589. { }
  590. };
  591. MODULE_DEVICE_TABLE(i2c, wm8974_i2c_id);
  592. static const struct of_device_id wm8974_of_match[] = {
  593. { .compatible = "wlf,wm8974", },
  594. { }
  595. };
  596. MODULE_DEVICE_TABLE(of, wm8974_of_match);
  597. static struct i2c_driver wm8974_i2c_driver = {
  598. .driver = {
  599. .name = "wm8974",
  600. .of_match_table = wm8974_of_match,
  601. },
  602. .probe = wm8974_i2c_probe,
  603. .id_table = wm8974_i2c_id,
  604. };
  605. module_i2c_driver(wm8974_i2c_driver);
  606. MODULE_DESCRIPTION("ASoC WM8974 driver");
  607. MODULE_AUTHOR("Liam Girdwood");
  608. MODULE_LICENSE("GPL");