cs42l56.c 40 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * cs42l56.c -- CS42L56 ALSA SoC audio driver
  4. *
  5. * Copyright 2014 CirrusLogic, Inc.
  6. *
  7. * Author: Brian Austin <brian.austin@cirrus.com>
  8. */
  9. #include <linux/module.h>
  10. #include <linux/moduleparam.h>
  11. #include <linux/kernel.h>
  12. #include <linux/init.h>
  13. #include <linux/delay.h>
  14. #include <linux/pm.h>
  15. #include <linux/i2c.h>
  16. #include <linux/input.h>
  17. #include <linux/regmap.h>
  18. #include <linux/slab.h>
  19. #include <linux/workqueue.h>
  20. #include <linux/platform_device.h>
  21. #include <linux/regulator/consumer.h>
  22. #include <linux/of_device.h>
  23. #include <linux/of_gpio.h>
  24. #include <sound/core.h>
  25. #include <sound/pcm.h>
  26. #include <sound/pcm_params.h>
  27. #include <sound/soc.h>
  28. #include <sound/soc-dapm.h>
  29. #include <sound/initval.h>
  30. #include <sound/tlv.h>
  31. #include <sound/cs42l56.h>
  32. #include "cs42l56.h"
  33. #define CS42L56_NUM_SUPPLIES 3
  34. static const char *const cs42l56_supply_names[CS42L56_NUM_SUPPLIES] = {
  35. "VA",
  36. "VCP",
  37. "VLDO",
  38. };
  39. struct cs42l56_private {
  40. struct regmap *regmap;
  41. struct snd_soc_component *component;
  42. struct device *dev;
  43. struct cs42l56_platform_data pdata;
  44. struct regulator_bulk_data supplies[CS42L56_NUM_SUPPLIES];
  45. u32 mclk;
  46. u8 mclk_prediv;
  47. u8 mclk_div2;
  48. u8 mclk_ratio;
  49. u8 iface;
  50. u8 iface_fmt;
  51. u8 iface_inv;
  52. #if IS_ENABLED(CONFIG_INPUT)
  53. struct input_dev *beep;
  54. struct work_struct beep_work;
  55. int beep_rate;
  56. #endif
  57. };
  58. static const struct reg_default cs42l56_reg_defaults[] = {
  59. { 3, 0x7f }, /* r03 - Power Ctl 1 */
  60. { 4, 0xff }, /* r04 - Power Ctl 2 */
  61. { 5, 0x00 }, /* ro5 - Clocking Ctl 1 */
  62. { 6, 0x0b }, /* r06 - Clocking Ctl 2 */
  63. { 7, 0x00 }, /* r07 - Serial Format */
  64. { 8, 0x05 }, /* r08 - Class H Ctl */
  65. { 9, 0x0c }, /* r09 - Misc Ctl */
  66. { 10, 0x80 }, /* r0a - INT Status */
  67. { 11, 0x00 }, /* r0b - Playback Ctl */
  68. { 12, 0x0c }, /* r0c - DSP Mute Ctl */
  69. { 13, 0x00 }, /* r0d - ADCA Mixer Volume */
  70. { 14, 0x00 }, /* r0e - ADCB Mixer Volume */
  71. { 15, 0x00 }, /* r0f - PCMA Mixer Volume */
  72. { 16, 0x00 }, /* r10 - PCMB Mixer Volume */
  73. { 17, 0x00 }, /* r11 - Analog Input Advisory Volume */
  74. { 18, 0x00 }, /* r12 - Digital Input Advisory Volume */
  75. { 19, 0x00 }, /* r13 - Master A Volume */
  76. { 20, 0x00 }, /* r14 - Master B Volume */
  77. { 21, 0x00 }, /* r15 - Beep Freq / On Time */
  78. { 22, 0x00 }, /* r16 - Beep Volume / Off Time */
  79. { 23, 0x00 }, /* r17 - Beep Tone Ctl */
  80. { 24, 0x88 }, /* r18 - Tone Ctl */
  81. { 25, 0x00 }, /* r19 - Channel Mixer & Swap */
  82. { 26, 0x00 }, /* r1a - AIN Ref Config / ADC Mux */
  83. { 27, 0xa0 }, /* r1b - High-Pass Filter Ctl */
  84. { 28, 0x00 }, /* r1c - Misc ADC Ctl */
  85. { 29, 0x00 }, /* r1d - Gain & Bias Ctl */
  86. { 30, 0x00 }, /* r1e - PGAA Mux & Volume */
  87. { 31, 0x00 }, /* r1f - PGAB Mux & Volume */
  88. { 32, 0x00 }, /* r20 - ADCA Attenuator */
  89. { 33, 0x00 }, /* r21 - ADCB Attenuator */
  90. { 34, 0x00 }, /* r22 - ALC Enable & Attack Rate */
  91. { 35, 0xbf }, /* r23 - ALC Release Rate */
  92. { 36, 0x00 }, /* r24 - ALC Threshold */
  93. { 37, 0x00 }, /* r25 - Noise Gate Ctl */
  94. { 38, 0x00 }, /* r26 - ALC, Limiter, SFT, ZeroCross */
  95. { 39, 0x00 }, /* r27 - Analog Mute, LO & HP Mux */
  96. { 40, 0x00 }, /* r28 - HP A Volume */
  97. { 41, 0x00 }, /* r29 - HP B Volume */
  98. { 42, 0x00 }, /* r2a - LINEOUT A Volume */
  99. { 43, 0x00 }, /* r2b - LINEOUT B Volume */
  100. { 44, 0x00 }, /* r2c - Limit Threshold Ctl */
  101. { 45, 0x7f }, /* r2d - Limiter Ctl & Release Rate */
  102. { 46, 0x00 }, /* r2e - Limiter Attack Rate */
  103. };
  104. static bool cs42l56_readable_register(struct device *dev, unsigned int reg)
  105. {
  106. switch (reg) {
  107. case CS42L56_CHIP_ID_1 ... CS42L56_LIM_ATTACK_RATE:
  108. return true;
  109. default:
  110. return false;
  111. }
  112. }
  113. static bool cs42l56_volatile_register(struct device *dev, unsigned int reg)
  114. {
  115. switch (reg) {
  116. case CS42L56_INT_STATUS:
  117. return true;
  118. default:
  119. return false;
  120. }
  121. }
  122. static DECLARE_TLV_DB_SCALE(beep_tlv, -5000, 200, 0);
  123. static DECLARE_TLV_DB_SCALE(hl_tlv, -6000, 50, 0);
  124. static DECLARE_TLV_DB_SCALE(adv_tlv, -10200, 50, 0);
  125. static DECLARE_TLV_DB_SCALE(adc_tlv, -9600, 100, 0);
  126. static DECLARE_TLV_DB_SCALE(tone_tlv, -1050, 150, 0);
  127. static DECLARE_TLV_DB_SCALE(preamp_tlv, 0, 1000, 0);
  128. static DECLARE_TLV_DB_SCALE(pga_tlv, -600, 50, 0);
  129. static const DECLARE_TLV_DB_RANGE(ngnb_tlv,
  130. 0, 1, TLV_DB_SCALE_ITEM(-8200, 600, 0),
  131. 2, 5, TLV_DB_SCALE_ITEM(-7600, 300, 0)
  132. );
  133. static const DECLARE_TLV_DB_RANGE(ngb_tlv,
  134. 0, 2, TLV_DB_SCALE_ITEM(-6400, 600, 0),
  135. 3, 7, TLV_DB_SCALE_ITEM(-4600, 300, 0)
  136. );
  137. static const DECLARE_TLV_DB_RANGE(alc_tlv,
  138. 0, 2, TLV_DB_SCALE_ITEM(-3000, 600, 0),
  139. 3, 7, TLV_DB_SCALE_ITEM(-1200, 300, 0)
  140. );
  141. static const char * const beep_config_text[] = {
  142. "Off", "Single", "Multiple", "Continuous"
  143. };
  144. static const struct soc_enum beep_config_enum =
  145. SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 6,
  146. ARRAY_SIZE(beep_config_text), beep_config_text);
  147. static const char * const beep_pitch_text[] = {
  148. "C4", "C5", "D5", "E5", "F5", "G5", "A5", "B5",
  149. "C6", "D6", "E6", "F6", "G6", "A6", "B6", "C7"
  150. };
  151. static const struct soc_enum beep_pitch_enum =
  152. SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_ONTIME, 4,
  153. ARRAY_SIZE(beep_pitch_text), beep_pitch_text);
  154. static const char * const beep_ontime_text[] = {
  155. "86 ms", "430 ms", "780 ms", "1.20 s", "1.50 s",
  156. "1.80 s", "2.20 s", "2.50 s", "2.80 s", "3.20 s",
  157. "3.50 s", "3.80 s", "4.20 s", "4.50 s", "4.80 s", "5.20 s"
  158. };
  159. static const struct soc_enum beep_ontime_enum =
  160. SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_ONTIME, 0,
  161. ARRAY_SIZE(beep_ontime_text), beep_ontime_text);
  162. static const char * const beep_offtime_text[] = {
  163. "1.23 s", "2.58 s", "3.90 s", "5.20 s",
  164. "6.60 s", "8.05 s", "9.35 s", "10.80 s"
  165. };
  166. static const struct soc_enum beep_offtime_enum =
  167. SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_OFFTIME, 5,
  168. ARRAY_SIZE(beep_offtime_text), beep_offtime_text);
  169. static const char * const beep_treble_text[] = {
  170. "5kHz", "7kHz", "10kHz", "15kHz"
  171. };
  172. static const struct soc_enum beep_treble_enum =
  173. SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 3,
  174. ARRAY_SIZE(beep_treble_text), beep_treble_text);
  175. static const char * const beep_bass_text[] = {
  176. "50Hz", "100Hz", "200Hz", "250Hz"
  177. };
  178. static const struct soc_enum beep_bass_enum =
  179. SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 1,
  180. ARRAY_SIZE(beep_bass_text), beep_bass_text);
  181. static const char * const pgaa_mux_text[] = {
  182. "AIN1A", "AIN2A", "AIN3A"};
  183. static const struct soc_enum pgaa_mux_enum =
  184. SOC_ENUM_SINGLE(CS42L56_PGAA_MUX_VOLUME, 0,
  185. ARRAY_SIZE(pgaa_mux_text),
  186. pgaa_mux_text);
  187. static const struct snd_kcontrol_new pgaa_mux =
  188. SOC_DAPM_ENUM("Route", pgaa_mux_enum);
  189. static const char * const pgab_mux_text[] = {
  190. "AIN1B", "AIN2B", "AIN3B"};
  191. static const struct soc_enum pgab_mux_enum =
  192. SOC_ENUM_SINGLE(CS42L56_PGAB_MUX_VOLUME, 0,
  193. ARRAY_SIZE(pgab_mux_text),
  194. pgab_mux_text);
  195. static const struct snd_kcontrol_new pgab_mux =
  196. SOC_DAPM_ENUM("Route", pgab_mux_enum);
  197. static const char * const adca_mux_text[] = {
  198. "PGAA", "AIN1A", "AIN2A", "AIN3A"};
  199. static const struct soc_enum adca_mux_enum =
  200. SOC_ENUM_SINGLE(CS42L56_AIN_REFCFG_ADC_MUX, 0,
  201. ARRAY_SIZE(adca_mux_text),
  202. adca_mux_text);
  203. static const struct snd_kcontrol_new adca_mux =
  204. SOC_DAPM_ENUM("Route", adca_mux_enum);
  205. static const char * const adcb_mux_text[] = {
  206. "PGAB", "AIN1B", "AIN2B", "AIN3B"};
  207. static const struct soc_enum adcb_mux_enum =
  208. SOC_ENUM_SINGLE(CS42L56_AIN_REFCFG_ADC_MUX, 2,
  209. ARRAY_SIZE(adcb_mux_text),
  210. adcb_mux_text);
  211. static const struct snd_kcontrol_new adcb_mux =
  212. SOC_DAPM_ENUM("Route", adcb_mux_enum);
  213. static const char * const left_swap_text[] = {
  214. "Left", "LR 2", "Right"};
  215. static const char * const right_swap_text[] = {
  216. "Right", "LR 2", "Left"};
  217. static const unsigned int swap_values[] = { 0, 1, 3 };
  218. static const struct soc_enum adca_swap_enum =
  219. SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 0, 3,
  220. ARRAY_SIZE(left_swap_text),
  221. left_swap_text,
  222. swap_values);
  223. static const struct snd_kcontrol_new adca_swap_mux =
  224. SOC_DAPM_ENUM("Route", adca_swap_enum);
  225. static const struct soc_enum pcma_swap_enum =
  226. SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 4, 3,
  227. ARRAY_SIZE(left_swap_text),
  228. left_swap_text,
  229. swap_values);
  230. static const struct snd_kcontrol_new pcma_swap_mux =
  231. SOC_DAPM_ENUM("Route", pcma_swap_enum);
  232. static const struct soc_enum adcb_swap_enum =
  233. SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 2, 3,
  234. ARRAY_SIZE(right_swap_text),
  235. right_swap_text,
  236. swap_values);
  237. static const struct snd_kcontrol_new adcb_swap_mux =
  238. SOC_DAPM_ENUM("Route", adcb_swap_enum);
  239. static const struct soc_enum pcmb_swap_enum =
  240. SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 6, 3,
  241. ARRAY_SIZE(right_swap_text),
  242. right_swap_text,
  243. swap_values);
  244. static const struct snd_kcontrol_new pcmb_swap_mux =
  245. SOC_DAPM_ENUM("Route", pcmb_swap_enum);
  246. static const struct snd_kcontrol_new hpa_switch =
  247. SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 6, 1, 1);
  248. static const struct snd_kcontrol_new hpb_switch =
  249. SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 4, 1, 1);
  250. static const struct snd_kcontrol_new loa_switch =
  251. SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 2, 1, 1);
  252. static const struct snd_kcontrol_new lob_switch =
  253. SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 0, 1, 1);
  254. static const char * const hploa_input_text[] = {
  255. "DACA", "PGAA"};
  256. static const struct soc_enum lineouta_input_enum =
  257. SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 2,
  258. ARRAY_SIZE(hploa_input_text),
  259. hploa_input_text);
  260. static const struct snd_kcontrol_new lineouta_input =
  261. SOC_DAPM_ENUM("Route", lineouta_input_enum);
  262. static const struct soc_enum hpa_input_enum =
  263. SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 0,
  264. ARRAY_SIZE(hploa_input_text),
  265. hploa_input_text);
  266. static const struct snd_kcontrol_new hpa_input =
  267. SOC_DAPM_ENUM("Route", hpa_input_enum);
  268. static const char * const hplob_input_text[] = {
  269. "DACB", "PGAB"};
  270. static const struct soc_enum lineoutb_input_enum =
  271. SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 3,
  272. ARRAY_SIZE(hplob_input_text),
  273. hplob_input_text);
  274. static const struct snd_kcontrol_new lineoutb_input =
  275. SOC_DAPM_ENUM("Route", lineoutb_input_enum);
  276. static const struct soc_enum hpb_input_enum =
  277. SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 1,
  278. ARRAY_SIZE(hplob_input_text),
  279. hplob_input_text);
  280. static const struct snd_kcontrol_new hpb_input =
  281. SOC_DAPM_ENUM("Route", hpb_input_enum);
  282. static const char * const dig_mux_text[] = {
  283. "ADC", "DSP"};
  284. static const struct soc_enum dig_mux_enum =
  285. SOC_ENUM_SINGLE(CS42L56_MISC_CTL, 7,
  286. ARRAY_SIZE(dig_mux_text),
  287. dig_mux_text);
  288. static const struct snd_kcontrol_new dig_mux =
  289. SOC_DAPM_ENUM("Route", dig_mux_enum);
  290. static const char * const hpf_freq_text[] = {
  291. "1.8Hz", "119Hz", "236Hz", "464Hz"
  292. };
  293. static const struct soc_enum hpfa_freq_enum =
  294. SOC_ENUM_SINGLE(CS42L56_HPF_CTL, 0,
  295. ARRAY_SIZE(hpf_freq_text), hpf_freq_text);
  296. static const struct soc_enum hpfb_freq_enum =
  297. SOC_ENUM_SINGLE(CS42L56_HPF_CTL, 2,
  298. ARRAY_SIZE(hpf_freq_text), hpf_freq_text);
  299. static const char * const ng_delay_text[] = {
  300. "50ms", "100ms", "150ms", "200ms"
  301. };
  302. static const struct soc_enum ng_delay_enum =
  303. SOC_ENUM_SINGLE(CS42L56_NOISE_GATE_CTL, 0,
  304. ARRAY_SIZE(ng_delay_text), ng_delay_text);
  305. static const struct snd_kcontrol_new cs42l56_snd_controls[] = {
  306. SOC_DOUBLE_R_SX_TLV("Master Volume", CS42L56_MASTER_A_VOLUME,
  307. CS42L56_MASTER_B_VOLUME, 0, 0x34, 0xE4, adv_tlv),
  308. SOC_DOUBLE("Master Mute Switch", CS42L56_DSP_MUTE_CTL, 0, 1, 1, 1),
  309. SOC_DOUBLE_R_SX_TLV("ADC Mixer Volume", CS42L56_ADCA_MIX_VOLUME,
  310. CS42L56_ADCB_MIX_VOLUME, 0, 0x88, 0x90, hl_tlv),
  311. SOC_DOUBLE("ADC Mixer Mute Switch", CS42L56_DSP_MUTE_CTL, 6, 7, 1, 1),
  312. SOC_DOUBLE_R_SX_TLV("PCM Mixer Volume", CS42L56_PCMA_MIX_VOLUME,
  313. CS42L56_PCMB_MIX_VOLUME, 0, 0x88, 0x90, hl_tlv),
  314. SOC_DOUBLE("PCM Mixer Mute Switch", CS42L56_DSP_MUTE_CTL, 4, 5, 1, 1),
  315. SOC_SINGLE_TLV("Analog Advisory Volume",
  316. CS42L56_ANAINPUT_ADV_VOLUME, 0, 0x00, 1, adv_tlv),
  317. SOC_SINGLE_TLV("Digital Advisory Volume",
  318. CS42L56_DIGINPUT_ADV_VOLUME, 0, 0x00, 1, adv_tlv),
  319. SOC_DOUBLE_R_SX_TLV("PGA Volume", CS42L56_PGAA_MUX_VOLUME,
  320. CS42L56_PGAB_MUX_VOLUME, 0, 0x34, 0x24, pga_tlv),
  321. SOC_DOUBLE_R_TLV("ADC Volume", CS42L56_ADCA_ATTENUATOR,
  322. CS42L56_ADCB_ATTENUATOR, 0, 0x00, 1, adc_tlv),
  323. SOC_DOUBLE("ADC Mute Switch", CS42L56_MISC_ADC_CTL, 2, 3, 1, 1),
  324. SOC_DOUBLE("ADC Boost Switch", CS42L56_GAIN_BIAS_CTL, 3, 2, 1, 1),
  325. SOC_DOUBLE_R_SX_TLV("Headphone Volume", CS42L56_HPA_VOLUME,
  326. CS42L56_HPB_VOLUME, 0, 0x84, 0x48, hl_tlv),
  327. SOC_DOUBLE_R_SX_TLV("LineOut Volume", CS42L56_LOA_VOLUME,
  328. CS42L56_LOB_VOLUME, 0, 0x84, 0x48, hl_tlv),
  329. SOC_SINGLE_TLV("Bass Shelving Volume", CS42L56_TONE_CTL,
  330. 0, 0x00, 1, tone_tlv),
  331. SOC_SINGLE_TLV("Treble Shelving Volume", CS42L56_TONE_CTL,
  332. 4, 0x00, 1, tone_tlv),
  333. SOC_DOUBLE_TLV("PGA Preamp Volume", CS42L56_GAIN_BIAS_CTL,
  334. 4, 6, 0x02, 1, preamp_tlv),
  335. SOC_SINGLE("DSP Switch", CS42L56_PLAYBACK_CTL, 7, 1, 1),
  336. SOC_SINGLE("Gang Playback Switch", CS42L56_PLAYBACK_CTL, 4, 1, 1),
  337. SOC_SINGLE("Gang ADC Switch", CS42L56_MISC_ADC_CTL, 7, 1, 1),
  338. SOC_SINGLE("Gang PGA Switch", CS42L56_MISC_ADC_CTL, 6, 1, 1),
  339. SOC_SINGLE("PCMA Invert", CS42L56_PLAYBACK_CTL, 2, 1, 1),
  340. SOC_SINGLE("PCMB Invert", CS42L56_PLAYBACK_CTL, 3, 1, 1),
  341. SOC_SINGLE("ADCA Invert", CS42L56_MISC_ADC_CTL, 2, 1, 1),
  342. SOC_SINGLE("ADCB Invert", CS42L56_MISC_ADC_CTL, 3, 1, 1),
  343. SOC_DOUBLE("HPF Switch", CS42L56_HPF_CTL, 5, 7, 1, 1),
  344. SOC_DOUBLE("HPF Freeze Switch", CS42L56_HPF_CTL, 4, 6, 1, 1),
  345. SOC_ENUM("HPFA Corner Freq", hpfa_freq_enum),
  346. SOC_ENUM("HPFB Corner Freq", hpfb_freq_enum),
  347. SOC_SINGLE("Analog Soft Ramp", CS42L56_MISC_CTL, 4, 1, 1),
  348. SOC_DOUBLE("Analog Soft Ramp Disable", CS42L56_ALC_LIM_SFT_ZC,
  349. 7, 5, 1, 1),
  350. SOC_SINGLE("Analog Zero Cross", CS42L56_MISC_CTL, 3, 1, 1),
  351. SOC_DOUBLE("Analog Zero Cross Disable", CS42L56_ALC_LIM_SFT_ZC,
  352. 6, 4, 1, 1),
  353. SOC_SINGLE("Digital Soft Ramp", CS42L56_MISC_CTL, 2, 1, 1),
  354. SOC_SINGLE("Digital Soft Ramp Disable", CS42L56_ALC_LIM_SFT_ZC,
  355. 3, 1, 1),
  356. SOC_SINGLE("HL Deemphasis", CS42L56_PLAYBACK_CTL, 6, 1, 1),
  357. SOC_SINGLE("ALC Switch", CS42L56_ALC_EN_ATTACK_RATE, 6, 1, 1),
  358. SOC_SINGLE("ALC Limit All Switch", CS42L56_ALC_RELEASE_RATE, 7, 1, 1),
  359. SOC_SINGLE_RANGE("ALC Attack", CS42L56_ALC_EN_ATTACK_RATE,
  360. 0, 0, 0x3f, 0),
  361. SOC_SINGLE_RANGE("ALC Release", CS42L56_ALC_RELEASE_RATE,
  362. 0, 0x3f, 0, 0),
  363. SOC_SINGLE_TLV("ALC MAX", CS42L56_ALC_THRESHOLD,
  364. 5, 0x07, 1, alc_tlv),
  365. SOC_SINGLE_TLV("ALC MIN", CS42L56_ALC_THRESHOLD,
  366. 2, 0x07, 1, alc_tlv),
  367. SOC_SINGLE("Limiter Switch", CS42L56_LIM_CTL_RELEASE_RATE, 7, 1, 1),
  368. SOC_SINGLE("Limit All Switch", CS42L56_LIM_CTL_RELEASE_RATE, 6, 1, 1),
  369. SOC_SINGLE_RANGE("Limiter Attack", CS42L56_LIM_ATTACK_RATE,
  370. 0, 0, 0x3f, 0),
  371. SOC_SINGLE_RANGE("Limiter Release", CS42L56_LIM_CTL_RELEASE_RATE,
  372. 0, 0x3f, 0, 0),
  373. SOC_SINGLE_TLV("Limiter MAX", CS42L56_LIM_THRESHOLD_CTL,
  374. 5, 0x07, 1, alc_tlv),
  375. SOC_SINGLE_TLV("Limiter Cushion", CS42L56_ALC_THRESHOLD,
  376. 2, 0x07, 1, alc_tlv),
  377. SOC_SINGLE("NG Switch", CS42L56_NOISE_GATE_CTL, 6, 1, 1),
  378. SOC_SINGLE("NG All Switch", CS42L56_NOISE_GATE_CTL, 7, 1, 1),
  379. SOC_SINGLE("NG Boost Switch", CS42L56_NOISE_GATE_CTL, 5, 1, 1),
  380. SOC_SINGLE_TLV("NG Unboost Threshold", CS42L56_NOISE_GATE_CTL,
  381. 2, 0x07, 1, ngnb_tlv),
  382. SOC_SINGLE_TLV("NG Boost Threshold", CS42L56_NOISE_GATE_CTL,
  383. 2, 0x07, 1, ngb_tlv),
  384. SOC_ENUM("NG Delay", ng_delay_enum),
  385. SOC_ENUM("Beep Config", beep_config_enum),
  386. SOC_ENUM("Beep Pitch", beep_pitch_enum),
  387. SOC_ENUM("Beep on Time", beep_ontime_enum),
  388. SOC_ENUM("Beep off Time", beep_offtime_enum),
  389. SOC_SINGLE_SX_TLV("Beep Volume", CS42L56_BEEP_FREQ_OFFTIME,
  390. 0, 0x07, 0x23, beep_tlv),
  391. SOC_SINGLE("Beep Tone Ctl Switch", CS42L56_BEEP_TONE_CFG, 0, 1, 1),
  392. SOC_ENUM("Beep Treble Corner Freq", beep_treble_enum),
  393. SOC_ENUM("Beep Bass Corner Freq", beep_bass_enum),
  394. };
  395. static const struct snd_soc_dapm_widget cs42l56_dapm_widgets[] = {
  396. SND_SOC_DAPM_SIGGEN("Beep"),
  397. SND_SOC_DAPM_SUPPLY("VBUF", CS42L56_PWRCTL_1, 5, 1, NULL, 0),
  398. SND_SOC_DAPM_MICBIAS("MIC1 Bias", CS42L56_PWRCTL_1, 4, 1),
  399. SND_SOC_DAPM_SUPPLY("Charge Pump", CS42L56_PWRCTL_1, 3, 1, NULL, 0),
  400. SND_SOC_DAPM_INPUT("AIN1A"),
  401. SND_SOC_DAPM_INPUT("AIN2A"),
  402. SND_SOC_DAPM_INPUT("AIN1B"),
  403. SND_SOC_DAPM_INPUT("AIN2B"),
  404. SND_SOC_DAPM_INPUT("AIN3A"),
  405. SND_SOC_DAPM_INPUT("AIN3B"),
  406. SND_SOC_DAPM_AIF_OUT("SDOUT", NULL, 0,
  407. SND_SOC_NOPM, 0, 0),
  408. SND_SOC_DAPM_AIF_IN("SDIN", NULL, 0,
  409. SND_SOC_NOPM, 0, 0),
  410. SND_SOC_DAPM_MUX("Digital Output Mux", SND_SOC_NOPM,
  411. 0, 0, &dig_mux),
  412. SND_SOC_DAPM_PGA("PGAA", SND_SOC_NOPM, 0, 0, NULL, 0),
  413. SND_SOC_DAPM_PGA("PGAB", SND_SOC_NOPM, 0, 0, NULL, 0),
  414. SND_SOC_DAPM_MUX("PGAA Input Mux",
  415. SND_SOC_NOPM, 0, 0, &pgaa_mux),
  416. SND_SOC_DAPM_MUX("PGAB Input Mux",
  417. SND_SOC_NOPM, 0, 0, &pgab_mux),
  418. SND_SOC_DAPM_MUX("ADCA Mux", SND_SOC_NOPM,
  419. 0, 0, &adca_mux),
  420. SND_SOC_DAPM_MUX("ADCB Mux", SND_SOC_NOPM,
  421. 0, 0, &adcb_mux),
  422. SND_SOC_DAPM_ADC("ADCA", NULL, CS42L56_PWRCTL_1, 1, 1),
  423. SND_SOC_DAPM_ADC("ADCB", NULL, CS42L56_PWRCTL_1, 2, 1),
  424. SND_SOC_DAPM_MUX("ADCA Swap Mux", SND_SOC_NOPM, 0, 0,
  425. &adca_swap_mux),
  426. SND_SOC_DAPM_MUX("ADCB Swap Mux", SND_SOC_NOPM, 0, 0,
  427. &adcb_swap_mux),
  428. SND_SOC_DAPM_MUX("PCMA Swap Mux", SND_SOC_NOPM, 0, 0,
  429. &pcma_swap_mux),
  430. SND_SOC_DAPM_MUX("PCMB Swap Mux", SND_SOC_NOPM, 0, 0,
  431. &pcmb_swap_mux),
  432. SND_SOC_DAPM_DAC("DACA", NULL, SND_SOC_NOPM, 0, 0),
  433. SND_SOC_DAPM_DAC("DACB", NULL, SND_SOC_NOPM, 0, 0),
  434. SND_SOC_DAPM_OUTPUT("HPA"),
  435. SND_SOC_DAPM_OUTPUT("LOA"),
  436. SND_SOC_DAPM_OUTPUT("HPB"),
  437. SND_SOC_DAPM_OUTPUT("LOB"),
  438. SND_SOC_DAPM_SWITCH("Headphone Right",
  439. CS42L56_PWRCTL_2, 4, 1, &hpb_switch),
  440. SND_SOC_DAPM_SWITCH("Headphone Left",
  441. CS42L56_PWRCTL_2, 6, 1, &hpa_switch),
  442. SND_SOC_DAPM_SWITCH("Lineout Right",
  443. CS42L56_PWRCTL_2, 0, 1, &lob_switch),
  444. SND_SOC_DAPM_SWITCH("Lineout Left",
  445. CS42L56_PWRCTL_2, 2, 1, &loa_switch),
  446. SND_SOC_DAPM_MUX("LINEOUTA Input Mux", SND_SOC_NOPM,
  447. 0, 0, &lineouta_input),
  448. SND_SOC_DAPM_MUX("LINEOUTB Input Mux", SND_SOC_NOPM,
  449. 0, 0, &lineoutb_input),
  450. SND_SOC_DAPM_MUX("HPA Input Mux", SND_SOC_NOPM,
  451. 0, 0, &hpa_input),
  452. SND_SOC_DAPM_MUX("HPB Input Mux", SND_SOC_NOPM,
  453. 0, 0, &hpb_input),
  454. };
  455. static const struct snd_soc_dapm_route cs42l56_audio_map[] = {
  456. {"HiFi Capture", "DSP", "Digital Output Mux"},
  457. {"HiFi Capture", "ADC", "Digital Output Mux"},
  458. {"Digital Output Mux", NULL, "ADCA"},
  459. {"Digital Output Mux", NULL, "ADCB"},
  460. {"ADCB", NULL, "ADCB Swap Mux"},
  461. {"ADCA", NULL, "ADCA Swap Mux"},
  462. {"ADCA Swap Mux", NULL, "ADCA"},
  463. {"ADCB Swap Mux", NULL, "ADCB"},
  464. {"DACA", "Left", "ADCA Swap Mux"},
  465. {"DACA", "LR 2", "ADCA Swap Mux"},
  466. {"DACA", "Right", "ADCA Swap Mux"},
  467. {"DACB", "Left", "ADCB Swap Mux"},
  468. {"DACB", "LR 2", "ADCB Swap Mux"},
  469. {"DACB", "Right", "ADCB Swap Mux"},
  470. {"ADCA Mux", NULL, "AIN3A"},
  471. {"ADCA Mux", NULL, "AIN2A"},
  472. {"ADCA Mux", NULL, "AIN1A"},
  473. {"ADCA Mux", NULL, "PGAA"},
  474. {"ADCB Mux", NULL, "AIN3B"},
  475. {"ADCB Mux", NULL, "AIN2B"},
  476. {"ADCB Mux", NULL, "AIN1B"},
  477. {"ADCB Mux", NULL, "PGAB"},
  478. {"PGAA", "AIN1A", "PGAA Input Mux"},
  479. {"PGAA", "AIN2A", "PGAA Input Mux"},
  480. {"PGAA", "AIN3A", "PGAA Input Mux"},
  481. {"PGAB", "AIN1B", "PGAB Input Mux"},
  482. {"PGAB", "AIN2B", "PGAB Input Mux"},
  483. {"PGAB", "AIN3B", "PGAB Input Mux"},
  484. {"PGAA Input Mux", NULL, "AIN1A"},
  485. {"PGAA Input Mux", NULL, "AIN2A"},
  486. {"PGAA Input Mux", NULL, "AIN3A"},
  487. {"PGAB Input Mux", NULL, "AIN1B"},
  488. {"PGAB Input Mux", NULL, "AIN2B"},
  489. {"PGAB Input Mux", NULL, "AIN3B"},
  490. {"LOB", "Switch", "LINEOUTB Input Mux"},
  491. {"LOA", "Switch", "LINEOUTA Input Mux"},
  492. {"LINEOUTA Input Mux", "PGAA", "PGAA"},
  493. {"LINEOUTB Input Mux", "PGAB", "PGAB"},
  494. {"LINEOUTA Input Mux", "DACA", "DACA"},
  495. {"LINEOUTB Input Mux", "DACB", "DACB"},
  496. {"HPA", "Switch", "HPB Input Mux"},
  497. {"HPB", "Switch", "HPA Input Mux"},
  498. {"HPA Input Mux", "PGAA", "PGAA"},
  499. {"HPB Input Mux", "PGAB", "PGAB"},
  500. {"HPA Input Mux", "DACA", "DACA"},
  501. {"HPB Input Mux", "DACB", "DACB"},
  502. {"DACA", NULL, "PCMA Swap Mux"},
  503. {"DACB", NULL, "PCMB Swap Mux"},
  504. {"PCMB Swap Mux", "Left", "HiFi Playback"},
  505. {"PCMB Swap Mux", "LR 2", "HiFi Playback"},
  506. {"PCMB Swap Mux", "Right", "HiFi Playback"},
  507. {"PCMA Swap Mux", "Left", "HiFi Playback"},
  508. {"PCMA Swap Mux", "LR 2", "HiFi Playback"},
  509. {"PCMA Swap Mux", "Right", "HiFi Playback"},
  510. };
  511. struct cs42l56_clk_para {
  512. u32 mclk;
  513. u32 srate;
  514. u8 ratio;
  515. };
  516. static const struct cs42l56_clk_para clk_ratio_table[] = {
  517. /* 8k */
  518. { 6000000, 8000, CS42L56_MCLK_LRCLK_768 },
  519. { 6144000, 8000, CS42L56_MCLK_LRCLK_750 },
  520. { 12000000, 8000, CS42L56_MCLK_LRCLK_768 },
  521. { 12288000, 8000, CS42L56_MCLK_LRCLK_750 },
  522. { 24000000, 8000, CS42L56_MCLK_LRCLK_768 },
  523. { 24576000, 8000, CS42L56_MCLK_LRCLK_750 },
  524. /* 11.025k */
  525. { 5644800, 11025, CS42L56_MCLK_LRCLK_512},
  526. { 11289600, 11025, CS42L56_MCLK_LRCLK_512},
  527. { 22579200, 11025, CS42L56_MCLK_LRCLK_512 },
  528. /* 11.0294k */
  529. { 6000000, 110294, CS42L56_MCLK_LRCLK_544 },
  530. { 12000000, 110294, CS42L56_MCLK_LRCLK_544 },
  531. { 24000000, 110294, CS42L56_MCLK_LRCLK_544 },
  532. /* 12k */
  533. { 6000000, 12000, CS42L56_MCLK_LRCLK_500 },
  534. { 6144000, 12000, CS42L56_MCLK_LRCLK_512 },
  535. { 12000000, 12000, CS42L56_MCLK_LRCLK_500 },
  536. { 12288000, 12000, CS42L56_MCLK_LRCLK_512 },
  537. { 24000000, 12000, CS42L56_MCLK_LRCLK_500 },
  538. { 24576000, 12000, CS42L56_MCLK_LRCLK_512 },
  539. /* 16k */
  540. { 6000000, 16000, CS42L56_MCLK_LRCLK_375 },
  541. { 6144000, 16000, CS42L56_MCLK_LRCLK_384 },
  542. { 12000000, 16000, CS42L56_MCLK_LRCLK_375 },
  543. { 12288000, 16000, CS42L56_MCLK_LRCLK_384 },
  544. { 24000000, 16000, CS42L56_MCLK_LRCLK_375 },
  545. { 24576000, 16000, CS42L56_MCLK_LRCLK_384 },
  546. /* 22.050k */
  547. { 5644800, 22050, CS42L56_MCLK_LRCLK_256 },
  548. { 11289600, 22050, CS42L56_MCLK_LRCLK_256 },
  549. { 22579200, 22050, CS42L56_MCLK_LRCLK_256 },
  550. /* 22.0588k */
  551. { 6000000, 220588, CS42L56_MCLK_LRCLK_272 },
  552. { 12000000, 220588, CS42L56_MCLK_LRCLK_272 },
  553. { 24000000, 220588, CS42L56_MCLK_LRCLK_272 },
  554. /* 24k */
  555. { 6000000, 24000, CS42L56_MCLK_LRCLK_250 },
  556. { 6144000, 24000, CS42L56_MCLK_LRCLK_256 },
  557. { 12000000, 24000, CS42L56_MCLK_LRCLK_250 },
  558. { 12288000, 24000, CS42L56_MCLK_LRCLK_256 },
  559. { 24000000, 24000, CS42L56_MCLK_LRCLK_250 },
  560. { 24576000, 24000, CS42L56_MCLK_LRCLK_256 },
  561. /* 32k */
  562. { 6000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
  563. { 6144000, 32000, CS42L56_MCLK_LRCLK_192 },
  564. { 12000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
  565. { 12288000, 32000, CS42L56_MCLK_LRCLK_192 },
  566. { 24000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
  567. { 24576000, 32000, CS42L56_MCLK_LRCLK_192 },
  568. /* 44.118k */
  569. { 6000000, 44118, CS42L56_MCLK_LRCLK_136 },
  570. { 12000000, 44118, CS42L56_MCLK_LRCLK_136 },
  571. { 24000000, 44118, CS42L56_MCLK_LRCLK_136 },
  572. /* 44.1k */
  573. { 5644800, 44100, CS42L56_MCLK_LRCLK_128 },
  574. { 11289600, 44100, CS42L56_MCLK_LRCLK_128 },
  575. { 22579200, 44100, CS42L56_MCLK_LRCLK_128 },
  576. /* 48k */
  577. { 6000000, 48000, CS42L56_MCLK_LRCLK_125 },
  578. { 6144000, 48000, CS42L56_MCLK_LRCLK_128 },
  579. { 12000000, 48000, CS42L56_MCLK_LRCLK_125 },
  580. { 12288000, 48000, CS42L56_MCLK_LRCLK_128 },
  581. { 24000000, 48000, CS42L56_MCLK_LRCLK_125 },
  582. { 24576000, 48000, CS42L56_MCLK_LRCLK_128 },
  583. };
  584. static int cs42l56_get_mclk_ratio(int mclk, int rate)
  585. {
  586. int i;
  587. for (i = 0; i < ARRAY_SIZE(clk_ratio_table); i++) {
  588. if (clk_ratio_table[i].mclk == mclk &&
  589. clk_ratio_table[i].srate == rate)
  590. return clk_ratio_table[i].ratio;
  591. }
  592. return -EINVAL;
  593. }
  594. static int cs42l56_set_sysclk(struct snd_soc_dai *codec_dai,
  595. int clk_id, unsigned int freq, int dir)
  596. {
  597. struct snd_soc_component *component = codec_dai->component;
  598. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  599. switch (freq) {
  600. case CS42L56_MCLK_5P6448MHZ:
  601. case CS42L56_MCLK_6MHZ:
  602. case CS42L56_MCLK_6P144MHZ:
  603. cs42l56->mclk_div2 = 0;
  604. cs42l56->mclk_prediv = 0;
  605. break;
  606. case CS42L56_MCLK_11P2896MHZ:
  607. case CS42L56_MCLK_12MHZ:
  608. case CS42L56_MCLK_12P288MHZ:
  609. cs42l56->mclk_div2 = CS42L56_MCLK_DIV2;
  610. cs42l56->mclk_prediv = 0;
  611. break;
  612. case CS42L56_MCLK_22P5792MHZ:
  613. case CS42L56_MCLK_24MHZ:
  614. case CS42L56_MCLK_24P576MHZ:
  615. cs42l56->mclk_div2 = CS42L56_MCLK_DIV2;
  616. cs42l56->mclk_prediv = CS42L56_MCLK_PREDIV;
  617. break;
  618. default:
  619. return -EINVAL;
  620. }
  621. cs42l56->mclk = freq;
  622. snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
  623. CS42L56_MCLK_PREDIV_MASK,
  624. cs42l56->mclk_prediv);
  625. snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
  626. CS42L56_MCLK_DIV2_MASK,
  627. cs42l56->mclk_div2);
  628. return 0;
  629. }
  630. static int cs42l56_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
  631. {
  632. struct snd_soc_component *component = codec_dai->component;
  633. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  634. switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
  635. case SND_SOC_DAIFMT_CBM_CFM:
  636. cs42l56->iface = CS42L56_MASTER_MODE;
  637. break;
  638. case SND_SOC_DAIFMT_CBS_CFS:
  639. cs42l56->iface = CS42L56_SLAVE_MODE;
  640. break;
  641. default:
  642. return -EINVAL;
  643. }
  644. /* interface format */
  645. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  646. case SND_SOC_DAIFMT_I2S:
  647. cs42l56->iface_fmt = CS42L56_DIG_FMT_I2S;
  648. break;
  649. case SND_SOC_DAIFMT_LEFT_J:
  650. cs42l56->iface_fmt = CS42L56_DIG_FMT_LEFT_J;
  651. break;
  652. default:
  653. return -EINVAL;
  654. }
  655. /* sclk inversion */
  656. switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
  657. case SND_SOC_DAIFMT_NB_NF:
  658. cs42l56->iface_inv = 0;
  659. break;
  660. case SND_SOC_DAIFMT_IB_NF:
  661. cs42l56->iface_inv = CS42L56_SCLK_INV;
  662. break;
  663. default:
  664. return -EINVAL;
  665. }
  666. snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
  667. CS42L56_MS_MODE_MASK, cs42l56->iface);
  668. snd_soc_component_update_bits(component, CS42L56_SERIAL_FMT,
  669. CS42L56_DIG_FMT_MASK, cs42l56->iface_fmt);
  670. snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
  671. CS42L56_SCLK_INV_MASK, cs42l56->iface_inv);
  672. return 0;
  673. }
  674. static int cs42l56_mute(struct snd_soc_dai *dai, int mute, int direction)
  675. {
  676. struct snd_soc_component *component = dai->component;
  677. if (mute) {
  678. /* Hit the DSP Mixer first */
  679. snd_soc_component_update_bits(component, CS42L56_DSP_MUTE_CTL,
  680. CS42L56_ADCAMIX_MUTE_MASK |
  681. CS42L56_ADCBMIX_MUTE_MASK |
  682. CS42L56_PCMAMIX_MUTE_MASK |
  683. CS42L56_PCMBMIX_MUTE_MASK |
  684. CS42L56_MSTB_MUTE_MASK |
  685. CS42L56_MSTA_MUTE_MASK,
  686. CS42L56_MUTE_ALL);
  687. /* Mute ADC's */
  688. snd_soc_component_update_bits(component, CS42L56_MISC_ADC_CTL,
  689. CS42L56_ADCA_MUTE_MASK |
  690. CS42L56_ADCB_MUTE_MASK,
  691. CS42L56_MUTE_ALL);
  692. /* HP And LO */
  693. snd_soc_component_update_bits(component, CS42L56_HPA_VOLUME,
  694. CS42L56_HP_MUTE_MASK, CS42L56_MUTE_ALL);
  695. snd_soc_component_update_bits(component, CS42L56_HPB_VOLUME,
  696. CS42L56_HP_MUTE_MASK, CS42L56_MUTE_ALL);
  697. snd_soc_component_update_bits(component, CS42L56_LOA_VOLUME,
  698. CS42L56_LO_MUTE_MASK, CS42L56_MUTE_ALL);
  699. snd_soc_component_update_bits(component, CS42L56_LOB_VOLUME,
  700. CS42L56_LO_MUTE_MASK, CS42L56_MUTE_ALL);
  701. } else {
  702. snd_soc_component_update_bits(component, CS42L56_DSP_MUTE_CTL,
  703. CS42L56_ADCAMIX_MUTE_MASK |
  704. CS42L56_ADCBMIX_MUTE_MASK |
  705. CS42L56_PCMAMIX_MUTE_MASK |
  706. CS42L56_PCMBMIX_MUTE_MASK |
  707. CS42L56_MSTB_MUTE_MASK |
  708. CS42L56_MSTA_MUTE_MASK,
  709. CS42L56_UNMUTE);
  710. snd_soc_component_update_bits(component, CS42L56_MISC_ADC_CTL,
  711. CS42L56_ADCA_MUTE_MASK |
  712. CS42L56_ADCB_MUTE_MASK,
  713. CS42L56_UNMUTE);
  714. snd_soc_component_update_bits(component, CS42L56_HPA_VOLUME,
  715. CS42L56_HP_MUTE_MASK, CS42L56_UNMUTE);
  716. snd_soc_component_update_bits(component, CS42L56_HPB_VOLUME,
  717. CS42L56_HP_MUTE_MASK, CS42L56_UNMUTE);
  718. snd_soc_component_update_bits(component, CS42L56_LOA_VOLUME,
  719. CS42L56_LO_MUTE_MASK, CS42L56_UNMUTE);
  720. snd_soc_component_update_bits(component, CS42L56_LOB_VOLUME,
  721. CS42L56_LO_MUTE_MASK, CS42L56_UNMUTE);
  722. }
  723. return 0;
  724. }
  725. static int cs42l56_pcm_hw_params(struct snd_pcm_substream *substream,
  726. struct snd_pcm_hw_params *params,
  727. struct snd_soc_dai *dai)
  728. {
  729. struct snd_soc_component *component = dai->component;
  730. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  731. int ratio;
  732. ratio = cs42l56_get_mclk_ratio(cs42l56->mclk, params_rate(params));
  733. if (ratio >= 0) {
  734. snd_soc_component_update_bits(component, CS42L56_CLKCTL_2,
  735. CS42L56_CLK_RATIO_MASK, ratio);
  736. } else {
  737. dev_err(component->dev, "unsupported mclk/sclk/lrclk ratio\n");
  738. return -EINVAL;
  739. }
  740. return 0;
  741. }
  742. static int cs42l56_set_bias_level(struct snd_soc_component *component,
  743. enum snd_soc_bias_level level)
  744. {
  745. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  746. int ret;
  747. switch (level) {
  748. case SND_SOC_BIAS_ON:
  749. break;
  750. case SND_SOC_BIAS_PREPARE:
  751. snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
  752. CS42L56_MCLK_DIS_MASK, 0);
  753. snd_soc_component_update_bits(component, CS42L56_PWRCTL_1,
  754. CS42L56_PDN_ALL_MASK, 0);
  755. break;
  756. case SND_SOC_BIAS_STANDBY:
  757. if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
  758. regcache_cache_only(cs42l56->regmap, false);
  759. regcache_sync(cs42l56->regmap);
  760. ret = regulator_bulk_enable(ARRAY_SIZE(cs42l56->supplies),
  761. cs42l56->supplies);
  762. if (ret != 0) {
  763. dev_err(cs42l56->dev,
  764. "Failed to enable regulators: %d\n",
  765. ret);
  766. return ret;
  767. }
  768. }
  769. snd_soc_component_update_bits(component, CS42L56_PWRCTL_1,
  770. CS42L56_PDN_ALL_MASK, 1);
  771. break;
  772. case SND_SOC_BIAS_OFF:
  773. snd_soc_component_update_bits(component, CS42L56_PWRCTL_1,
  774. CS42L56_PDN_ALL_MASK, 1);
  775. snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
  776. CS42L56_MCLK_DIS_MASK, 1);
  777. regcache_cache_only(cs42l56->regmap, true);
  778. regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
  779. cs42l56->supplies);
  780. break;
  781. }
  782. return 0;
  783. }
  784. #define CS42L56_RATES (SNDRV_PCM_RATE_8000_48000)
  785. #define CS42L56_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S18_3LE | \
  786. SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE | \
  787. SNDRV_PCM_FMTBIT_S32_LE)
  788. static const struct snd_soc_dai_ops cs42l56_ops = {
  789. .hw_params = cs42l56_pcm_hw_params,
  790. .mute_stream = cs42l56_mute,
  791. .set_fmt = cs42l56_set_dai_fmt,
  792. .set_sysclk = cs42l56_set_sysclk,
  793. .no_capture_mute = 1,
  794. };
  795. static struct snd_soc_dai_driver cs42l56_dai = {
  796. .name = "cs42l56",
  797. .playback = {
  798. .stream_name = "HiFi Playback",
  799. .channels_min = 1,
  800. .channels_max = 2,
  801. .rates = CS42L56_RATES,
  802. .formats = CS42L56_FORMATS,
  803. },
  804. .capture = {
  805. .stream_name = "HiFi Capture",
  806. .channels_min = 1,
  807. .channels_max = 2,
  808. .rates = CS42L56_RATES,
  809. .formats = CS42L56_FORMATS,
  810. },
  811. .ops = &cs42l56_ops,
  812. };
  813. static int beep_freq[] = {
  814. 261, 522, 585, 667, 706, 774, 889, 1000,
  815. 1043, 1200, 1333, 1412, 1600, 1714, 2000, 2182
  816. };
  817. static void cs42l56_beep_work(struct work_struct *work)
  818. {
  819. struct cs42l56_private *cs42l56 =
  820. container_of(work, struct cs42l56_private, beep_work);
  821. struct snd_soc_component *component = cs42l56->component;
  822. struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
  823. int i;
  824. int val = 0;
  825. int best = 0;
  826. if (cs42l56->beep_rate) {
  827. for (i = 0; i < ARRAY_SIZE(beep_freq); i++) {
  828. if (abs(cs42l56->beep_rate - beep_freq[i]) <
  829. abs(cs42l56->beep_rate - beep_freq[best]))
  830. best = i;
  831. }
  832. dev_dbg(component->dev, "Set beep rate %dHz for requested %dHz\n",
  833. beep_freq[best], cs42l56->beep_rate);
  834. val = (best << CS42L56_BEEP_RATE_SHIFT);
  835. snd_soc_dapm_enable_pin(dapm, "Beep");
  836. } else {
  837. dev_dbg(component->dev, "Disabling beep\n");
  838. snd_soc_dapm_disable_pin(dapm, "Beep");
  839. }
  840. snd_soc_component_update_bits(component, CS42L56_BEEP_FREQ_ONTIME,
  841. CS42L56_BEEP_FREQ_MASK, val);
  842. snd_soc_dapm_sync(dapm);
  843. }
  844. /* For usability define a way of injecting beep events for the device -
  845. * many systems will not have a keyboard.
  846. */
  847. static int cs42l56_beep_event(struct input_dev *dev, unsigned int type,
  848. unsigned int code, int hz)
  849. {
  850. struct snd_soc_component *component = input_get_drvdata(dev);
  851. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  852. dev_dbg(component->dev, "Beep event %x %x\n", code, hz);
  853. switch (code) {
  854. case SND_BELL:
  855. if (hz)
  856. hz = 261;
  857. case SND_TONE:
  858. break;
  859. default:
  860. return -1;
  861. }
  862. /* Kick the beep from a workqueue */
  863. cs42l56->beep_rate = hz;
  864. schedule_work(&cs42l56->beep_work);
  865. return 0;
  866. }
  867. static ssize_t cs42l56_beep_set(struct device *dev,
  868. struct device_attribute *attr,
  869. const char *buf, size_t count)
  870. {
  871. struct cs42l56_private *cs42l56 = dev_get_drvdata(dev);
  872. long int time;
  873. int ret;
  874. ret = kstrtol(buf, 10, &time);
  875. if (ret != 0)
  876. return ret;
  877. input_event(cs42l56->beep, EV_SND, SND_TONE, time);
  878. return count;
  879. }
  880. static DEVICE_ATTR(beep, 0200, NULL, cs42l56_beep_set);
  881. static void cs42l56_init_beep(struct snd_soc_component *component)
  882. {
  883. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  884. int ret;
  885. cs42l56->beep = devm_input_allocate_device(component->dev);
  886. if (!cs42l56->beep) {
  887. dev_err(component->dev, "Failed to allocate beep device\n");
  888. return;
  889. }
  890. INIT_WORK(&cs42l56->beep_work, cs42l56_beep_work);
  891. cs42l56->beep_rate = 0;
  892. cs42l56->beep->name = "CS42L56 Beep Generator";
  893. cs42l56->beep->phys = dev_name(component->dev);
  894. cs42l56->beep->id.bustype = BUS_I2C;
  895. cs42l56->beep->evbit[0] = BIT_MASK(EV_SND);
  896. cs42l56->beep->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
  897. cs42l56->beep->event = cs42l56_beep_event;
  898. cs42l56->beep->dev.parent = component->dev;
  899. input_set_drvdata(cs42l56->beep, component);
  900. ret = input_register_device(cs42l56->beep);
  901. if (ret != 0) {
  902. cs42l56->beep = NULL;
  903. dev_err(component->dev, "Failed to register beep device\n");
  904. }
  905. ret = device_create_file(component->dev, &dev_attr_beep);
  906. if (ret != 0) {
  907. dev_err(component->dev, "Failed to create keyclick file: %d\n",
  908. ret);
  909. }
  910. }
  911. static void cs42l56_free_beep(struct snd_soc_component *component)
  912. {
  913. struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
  914. device_remove_file(component->dev, &dev_attr_beep);
  915. cancel_work_sync(&cs42l56->beep_work);
  916. cs42l56->beep = NULL;
  917. snd_soc_component_update_bits(component, CS42L56_BEEP_TONE_CFG,
  918. CS42L56_BEEP_EN_MASK, 0);
  919. }
  920. static int cs42l56_probe(struct snd_soc_component *component)
  921. {
  922. cs42l56_init_beep(component);
  923. return 0;
  924. }
  925. static void cs42l56_remove(struct snd_soc_component *component)
  926. {
  927. cs42l56_free_beep(component);
  928. }
  929. static const struct snd_soc_component_driver soc_component_dev_cs42l56 = {
  930. .probe = cs42l56_probe,
  931. .remove = cs42l56_remove,
  932. .set_bias_level = cs42l56_set_bias_level,
  933. .controls = cs42l56_snd_controls,
  934. .num_controls = ARRAY_SIZE(cs42l56_snd_controls),
  935. .dapm_widgets = cs42l56_dapm_widgets,
  936. .num_dapm_widgets = ARRAY_SIZE(cs42l56_dapm_widgets),
  937. .dapm_routes = cs42l56_audio_map,
  938. .num_dapm_routes = ARRAY_SIZE(cs42l56_audio_map),
  939. .suspend_bias_off = 1,
  940. .idle_bias_on = 1,
  941. .use_pmdown_time = 1,
  942. .endianness = 1,
  943. .non_legacy_dai_naming = 1,
  944. };
  945. static const struct regmap_config cs42l56_regmap = {
  946. .reg_bits = 8,
  947. .val_bits = 8,
  948. .max_register = CS42L56_MAX_REGISTER,
  949. .reg_defaults = cs42l56_reg_defaults,
  950. .num_reg_defaults = ARRAY_SIZE(cs42l56_reg_defaults),
  951. .readable_reg = cs42l56_readable_register,
  952. .volatile_reg = cs42l56_volatile_register,
  953. .cache_type = REGCACHE_RBTREE,
  954. };
  955. static int cs42l56_handle_of_data(struct i2c_client *i2c_client,
  956. struct cs42l56_platform_data *pdata)
  957. {
  958. struct device_node *np = i2c_client->dev.of_node;
  959. u32 val32;
  960. if (of_property_read_bool(np, "cirrus,ain1a-reference-cfg"))
  961. pdata->ain1a_ref_cfg = true;
  962. if (of_property_read_bool(np, "cirrus,ain2a-reference-cfg"))
  963. pdata->ain2a_ref_cfg = true;
  964. if (of_property_read_bool(np, "cirrus,ain1b-reference-cfg"))
  965. pdata->ain1b_ref_cfg = true;
  966. if (of_property_read_bool(np, "cirrus,ain2b-reference-cfg"))
  967. pdata->ain2b_ref_cfg = true;
  968. if (of_property_read_u32(np, "cirrus,micbias-lvl", &val32) >= 0)
  969. pdata->micbias_lvl = val32;
  970. if (of_property_read_u32(np, "cirrus,chgfreq-divisor", &val32) >= 0)
  971. pdata->chgfreq = val32;
  972. if (of_property_read_u32(np, "cirrus,adaptive-pwr-cfg", &val32) >= 0)
  973. pdata->adaptive_pwr = val32;
  974. if (of_property_read_u32(np, "cirrus,hpf-left-freq", &val32) >= 0)
  975. pdata->hpfa_freq = val32;
  976. if (of_property_read_u32(np, "cirrus,hpf-left-freq", &val32) >= 0)
  977. pdata->hpfb_freq = val32;
  978. pdata->gpio_nreset = of_get_named_gpio(np, "cirrus,gpio-nreset", 0);
  979. return 0;
  980. }
  981. static int cs42l56_i2c_probe(struct i2c_client *i2c_client,
  982. const struct i2c_device_id *id)
  983. {
  984. struct cs42l56_private *cs42l56;
  985. struct cs42l56_platform_data *pdata =
  986. dev_get_platdata(&i2c_client->dev);
  987. int ret, i;
  988. unsigned int devid = 0;
  989. unsigned int alpha_rev, metal_rev;
  990. unsigned int reg;
  991. cs42l56 = devm_kzalloc(&i2c_client->dev, sizeof(*cs42l56), GFP_KERNEL);
  992. if (cs42l56 == NULL)
  993. return -ENOMEM;
  994. cs42l56->dev = &i2c_client->dev;
  995. cs42l56->regmap = devm_regmap_init_i2c(i2c_client, &cs42l56_regmap);
  996. if (IS_ERR(cs42l56->regmap)) {
  997. ret = PTR_ERR(cs42l56->regmap);
  998. dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret);
  999. return ret;
  1000. }
  1001. if (pdata) {
  1002. cs42l56->pdata = *pdata;
  1003. } else {
  1004. pdata = devm_kzalloc(&i2c_client->dev, sizeof(*pdata),
  1005. GFP_KERNEL);
  1006. if (!pdata)
  1007. return -ENOMEM;
  1008. if (i2c_client->dev.of_node) {
  1009. ret = cs42l56_handle_of_data(i2c_client,
  1010. &cs42l56->pdata);
  1011. if (ret != 0)
  1012. return ret;
  1013. }
  1014. cs42l56->pdata = *pdata;
  1015. }
  1016. if (cs42l56->pdata.gpio_nreset) {
  1017. ret = gpio_request_one(cs42l56->pdata.gpio_nreset,
  1018. GPIOF_OUT_INIT_HIGH, "CS42L56 /RST");
  1019. if (ret < 0) {
  1020. dev_err(&i2c_client->dev,
  1021. "Failed to request /RST %d: %d\n",
  1022. cs42l56->pdata.gpio_nreset, ret);
  1023. return ret;
  1024. }
  1025. gpio_set_value_cansleep(cs42l56->pdata.gpio_nreset, 0);
  1026. gpio_set_value_cansleep(cs42l56->pdata.gpio_nreset, 1);
  1027. }
  1028. i2c_set_clientdata(i2c_client, cs42l56);
  1029. for (i = 0; i < ARRAY_SIZE(cs42l56->supplies); i++)
  1030. cs42l56->supplies[i].supply = cs42l56_supply_names[i];
  1031. ret = devm_regulator_bulk_get(&i2c_client->dev,
  1032. ARRAY_SIZE(cs42l56->supplies),
  1033. cs42l56->supplies);
  1034. if (ret != 0) {
  1035. dev_err(&i2c_client->dev,
  1036. "Failed to request supplies: %d\n", ret);
  1037. return ret;
  1038. }
  1039. ret = regulator_bulk_enable(ARRAY_SIZE(cs42l56->supplies),
  1040. cs42l56->supplies);
  1041. if (ret != 0) {
  1042. dev_err(&i2c_client->dev,
  1043. "Failed to enable supplies: %d\n", ret);
  1044. return ret;
  1045. }
  1046. ret = regmap_read(cs42l56->regmap, CS42L56_CHIP_ID_1, &reg);
  1047. devid = reg & CS42L56_CHIP_ID_MASK;
  1048. if (devid != CS42L56_DEVID) {
  1049. dev_err(&i2c_client->dev,
  1050. "CS42L56 Device ID (%X). Expected %X\n",
  1051. devid, CS42L56_DEVID);
  1052. ret = -EINVAL;
  1053. goto err_enable;
  1054. }
  1055. alpha_rev = reg & CS42L56_AREV_MASK;
  1056. metal_rev = reg & CS42L56_MTLREV_MASK;
  1057. dev_info(&i2c_client->dev, "Cirrus Logic CS42L56 ");
  1058. dev_info(&i2c_client->dev, "Alpha Rev %X Metal Rev %X\n",
  1059. alpha_rev, metal_rev);
  1060. if (cs42l56->pdata.ain1a_ref_cfg)
  1061. regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
  1062. CS42L56_AIN1A_REF_MASK,
  1063. CS42L56_AIN1A_REF_MASK);
  1064. if (cs42l56->pdata.ain1b_ref_cfg)
  1065. regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
  1066. CS42L56_AIN1B_REF_MASK,
  1067. CS42L56_AIN1B_REF_MASK);
  1068. if (cs42l56->pdata.ain2a_ref_cfg)
  1069. regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
  1070. CS42L56_AIN2A_REF_MASK,
  1071. CS42L56_AIN2A_REF_MASK);
  1072. if (cs42l56->pdata.ain2b_ref_cfg)
  1073. regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
  1074. CS42L56_AIN2B_REF_MASK,
  1075. CS42L56_AIN2B_REF_MASK);
  1076. if (cs42l56->pdata.micbias_lvl)
  1077. regmap_update_bits(cs42l56->regmap, CS42L56_GAIN_BIAS_CTL,
  1078. CS42L56_MIC_BIAS_MASK,
  1079. cs42l56->pdata.micbias_lvl);
  1080. if (cs42l56->pdata.chgfreq)
  1081. regmap_update_bits(cs42l56->regmap, CS42L56_CLASSH_CTL,
  1082. CS42L56_CHRG_FREQ_MASK,
  1083. cs42l56->pdata.chgfreq);
  1084. if (cs42l56->pdata.hpfb_freq)
  1085. regmap_update_bits(cs42l56->regmap, CS42L56_HPF_CTL,
  1086. CS42L56_HPFB_FREQ_MASK,
  1087. cs42l56->pdata.hpfb_freq);
  1088. if (cs42l56->pdata.hpfa_freq)
  1089. regmap_update_bits(cs42l56->regmap, CS42L56_HPF_CTL,
  1090. CS42L56_HPFA_FREQ_MASK,
  1091. cs42l56->pdata.hpfa_freq);
  1092. if (cs42l56->pdata.adaptive_pwr)
  1093. regmap_update_bits(cs42l56->regmap, CS42L56_CLASSH_CTL,
  1094. CS42L56_ADAPT_PWR_MASK,
  1095. cs42l56->pdata.adaptive_pwr);
  1096. ret = devm_snd_soc_register_component(&i2c_client->dev,
  1097. &soc_component_dev_cs42l56, &cs42l56_dai, 1);
  1098. if (ret < 0)
  1099. goto err_enable;
  1100. return 0;
  1101. err_enable:
  1102. regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
  1103. cs42l56->supplies);
  1104. return ret;
  1105. }
  1106. static int cs42l56_i2c_remove(struct i2c_client *client)
  1107. {
  1108. struct cs42l56_private *cs42l56 = i2c_get_clientdata(client);
  1109. regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
  1110. cs42l56->supplies);
  1111. return 0;
  1112. }
  1113. static const struct of_device_id cs42l56_of_match[] = {
  1114. { .compatible = "cirrus,cs42l56", },
  1115. { }
  1116. };
  1117. MODULE_DEVICE_TABLE(of, cs42l56_of_match);
  1118. static const struct i2c_device_id cs42l56_id[] = {
  1119. { "cs42l56", 0 },
  1120. { }
  1121. };
  1122. MODULE_DEVICE_TABLE(i2c, cs42l56_id);
  1123. static struct i2c_driver cs42l56_i2c_driver = {
  1124. .driver = {
  1125. .name = "cs42l56",
  1126. .of_match_table = cs42l56_of_match,
  1127. },
  1128. .id_table = cs42l56_id,
  1129. .probe = cs42l56_i2c_probe,
  1130. .remove = cs42l56_i2c_remove,
  1131. };
  1132. module_i2c_driver(cs42l56_i2c_driver);
  1133. MODULE_DESCRIPTION("ASoC CS42L56 driver");
  1134. MODULE_AUTHOR("Brian Austin, Cirrus Logic Inc, <brian.austin@cirrus.com>");
  1135. MODULE_LICENSE("GPL");