alc5623.c 34 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * alc5623.c -- alc562[123] ALSA Soc Audio driver
  4. *
  5. * Copyright 2008 Realtek Microelectronics
  6. * Author: flove <flove@realtek.com> Ethan <eku@marvell.com>
  7. *
  8. * Copyright 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
  9. *
  10. * Based on WM8753.c
  11. */
  12. #include <linux/module.h>
  13. #include <linux/kernel.h>
  14. #include <linux/init.h>
  15. #include <linux/delay.h>
  16. #include <linux/pm.h>
  17. #include <linux/i2c.h>
  18. #include <linux/regmap.h>
  19. #include <linux/slab.h>
  20. #include <linux/of.h>
  21. #include <sound/core.h>
  22. #include <sound/pcm.h>
  23. #include <sound/pcm_params.h>
  24. #include <sound/tlv.h>
  25. #include <sound/soc.h>
  26. #include <sound/initval.h>
  27. #include <sound/alc5623.h>
  28. #include "alc5623.h"
  29. static int caps_charge = 2000;
  30. module_param(caps_charge, int, 0);
  31. MODULE_PARM_DESC(caps_charge, "ALC5623 cap charge time (msecs)");
  32. /* codec private data */
  33. struct alc5623_priv {
  34. struct regmap *regmap;
  35. u8 id;
  36. unsigned int sysclk;
  37. unsigned int add_ctrl;
  38. unsigned int jack_det_ctrl;
  39. };
  40. static inline int alc5623_reset(struct snd_soc_component *component)
  41. {
  42. return snd_soc_component_write(component, ALC5623_RESET, 0);
  43. }
  44. static int amp_mixer_event(struct snd_soc_dapm_widget *w,
  45. struct snd_kcontrol *kcontrol, int event)
  46. {
  47. struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
  48. /* to power-on/off class-d amp generators/speaker */
  49. /* need to write to 'index-46h' register : */
  50. /* so write index num (here 0x46) to reg 0x6a */
  51. /* and then 0xffff/0 to reg 0x6c */
  52. snd_soc_component_write(component, ALC5623_HID_CTRL_INDEX, 0x46);
  53. switch (event) {
  54. case SND_SOC_DAPM_PRE_PMU:
  55. snd_soc_component_write(component, ALC5623_HID_CTRL_DATA, 0xFFFF);
  56. break;
  57. case SND_SOC_DAPM_POST_PMD:
  58. snd_soc_component_write(component, ALC5623_HID_CTRL_DATA, 0);
  59. break;
  60. }
  61. return 0;
  62. }
  63. /*
  64. * ALC5623 Controls
  65. */
  66. static const DECLARE_TLV_DB_SCALE(vol_tlv, -3450, 150, 0);
  67. static const DECLARE_TLV_DB_SCALE(hp_tlv, -4650, 150, 0);
  68. static const DECLARE_TLV_DB_SCALE(adc_rec_tlv, -1650, 150, 0);
  69. static const DECLARE_TLV_DB_RANGE(boost_tlv,
  70. 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
  71. 1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
  72. 2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0)
  73. );
  74. static const DECLARE_TLV_DB_SCALE(dig_tlv, 0, 600, 0);
  75. static const struct snd_kcontrol_new alc5621_vol_snd_controls[] = {
  76. SOC_DOUBLE_TLV("Speaker Playback Volume",
  77. ALC5623_SPK_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  78. SOC_DOUBLE("Speaker Playback Switch",
  79. ALC5623_SPK_OUT_VOL, 15, 7, 1, 1),
  80. SOC_DOUBLE_TLV("Headphone Playback Volume",
  81. ALC5623_HP_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  82. SOC_DOUBLE("Headphone Playback Switch",
  83. ALC5623_HP_OUT_VOL, 15, 7, 1, 1),
  84. };
  85. static const struct snd_kcontrol_new alc5622_vol_snd_controls[] = {
  86. SOC_DOUBLE_TLV("Speaker Playback Volume",
  87. ALC5623_SPK_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  88. SOC_DOUBLE("Speaker Playback Switch",
  89. ALC5623_SPK_OUT_VOL, 15, 7, 1, 1),
  90. SOC_DOUBLE_TLV("Line Playback Volume",
  91. ALC5623_HP_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  92. SOC_DOUBLE("Line Playback Switch",
  93. ALC5623_HP_OUT_VOL, 15, 7, 1, 1),
  94. };
  95. static const struct snd_kcontrol_new alc5623_vol_snd_controls[] = {
  96. SOC_DOUBLE_TLV("Line Playback Volume",
  97. ALC5623_SPK_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  98. SOC_DOUBLE("Line Playback Switch",
  99. ALC5623_SPK_OUT_VOL, 15, 7, 1, 1),
  100. SOC_DOUBLE_TLV("Headphone Playback Volume",
  101. ALC5623_HP_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  102. SOC_DOUBLE("Headphone Playback Switch",
  103. ALC5623_HP_OUT_VOL, 15, 7, 1, 1),
  104. };
  105. static const struct snd_kcontrol_new alc5623_snd_controls[] = {
  106. SOC_DOUBLE_TLV("Auxout Playback Volume",
  107. ALC5623_MONO_AUX_OUT_VOL, 8, 0, 31, 1, hp_tlv),
  108. SOC_DOUBLE("Auxout Playback Switch",
  109. ALC5623_MONO_AUX_OUT_VOL, 15, 7, 1, 1),
  110. SOC_DOUBLE_TLV("PCM Playback Volume",
  111. ALC5623_STEREO_DAC_VOL, 8, 0, 31, 1, vol_tlv),
  112. SOC_DOUBLE_TLV("AuxI Capture Volume",
  113. ALC5623_AUXIN_VOL, 8, 0, 31, 1, vol_tlv),
  114. SOC_DOUBLE_TLV("LineIn Capture Volume",
  115. ALC5623_LINE_IN_VOL, 8, 0, 31, 1, vol_tlv),
  116. SOC_SINGLE_TLV("Mic1 Capture Volume",
  117. ALC5623_MIC_VOL, 8, 31, 1, vol_tlv),
  118. SOC_SINGLE_TLV("Mic2 Capture Volume",
  119. ALC5623_MIC_VOL, 0, 31, 1, vol_tlv),
  120. SOC_DOUBLE_TLV("Rec Capture Volume",
  121. ALC5623_ADC_REC_GAIN, 7, 0, 31, 0, adc_rec_tlv),
  122. SOC_SINGLE_TLV("Mic 1 Boost Volume",
  123. ALC5623_MIC_CTRL, 10, 2, 0, boost_tlv),
  124. SOC_SINGLE_TLV("Mic 2 Boost Volume",
  125. ALC5623_MIC_CTRL, 8, 2, 0, boost_tlv),
  126. SOC_SINGLE_TLV("Digital Boost Volume",
  127. ALC5623_ADD_CTRL_REG, 4, 3, 0, dig_tlv),
  128. };
  129. /*
  130. * DAPM Controls
  131. */
  132. static const struct snd_kcontrol_new alc5623_hp_mixer_controls[] = {
  133. SOC_DAPM_SINGLE("LI2HP Playback Switch", ALC5623_LINE_IN_VOL, 15, 1, 1),
  134. SOC_DAPM_SINGLE("AUXI2HP Playback Switch", ALC5623_AUXIN_VOL, 15, 1, 1),
  135. SOC_DAPM_SINGLE("MIC12HP Playback Switch", ALC5623_MIC_ROUTING_CTRL, 15, 1, 1),
  136. SOC_DAPM_SINGLE("MIC22HP Playback Switch", ALC5623_MIC_ROUTING_CTRL, 7, 1, 1),
  137. SOC_DAPM_SINGLE("DAC2HP Playback Switch", ALC5623_STEREO_DAC_VOL, 15, 1, 1),
  138. };
  139. static const struct snd_kcontrol_new alc5623_hpl_mixer_controls[] = {
  140. SOC_DAPM_SINGLE("ADC2HP_L Playback Switch", ALC5623_ADC_REC_GAIN, 15, 1, 1),
  141. };
  142. static const struct snd_kcontrol_new alc5623_hpr_mixer_controls[] = {
  143. SOC_DAPM_SINGLE("ADC2HP_R Playback Switch", ALC5623_ADC_REC_GAIN, 14, 1, 1),
  144. };
  145. static const struct snd_kcontrol_new alc5623_mono_mixer_controls[] = {
  146. SOC_DAPM_SINGLE("ADC2MONO_L Playback Switch", ALC5623_ADC_REC_GAIN, 13, 1, 1),
  147. SOC_DAPM_SINGLE("ADC2MONO_R Playback Switch", ALC5623_ADC_REC_GAIN, 12, 1, 1),
  148. SOC_DAPM_SINGLE("LI2MONO Playback Switch", ALC5623_LINE_IN_VOL, 13, 1, 1),
  149. SOC_DAPM_SINGLE("AUXI2MONO Playback Switch", ALC5623_AUXIN_VOL, 13, 1, 1),
  150. SOC_DAPM_SINGLE("MIC12MONO Playback Switch", ALC5623_MIC_ROUTING_CTRL, 13, 1, 1),
  151. SOC_DAPM_SINGLE("MIC22MONO Playback Switch", ALC5623_MIC_ROUTING_CTRL, 5, 1, 1),
  152. SOC_DAPM_SINGLE("DAC2MONO Playback Switch", ALC5623_STEREO_DAC_VOL, 13, 1, 1),
  153. };
  154. static const struct snd_kcontrol_new alc5623_speaker_mixer_controls[] = {
  155. SOC_DAPM_SINGLE("LI2SPK Playback Switch", ALC5623_LINE_IN_VOL, 14, 1, 1),
  156. SOC_DAPM_SINGLE("AUXI2SPK Playback Switch", ALC5623_AUXIN_VOL, 14, 1, 1),
  157. SOC_DAPM_SINGLE("MIC12SPK Playback Switch", ALC5623_MIC_ROUTING_CTRL, 14, 1, 1),
  158. SOC_DAPM_SINGLE("MIC22SPK Playback Switch", ALC5623_MIC_ROUTING_CTRL, 6, 1, 1),
  159. SOC_DAPM_SINGLE("DAC2SPK Playback Switch", ALC5623_STEREO_DAC_VOL, 14, 1, 1),
  160. };
  161. /* Left Record Mixer */
  162. static const struct snd_kcontrol_new alc5623_captureL_mixer_controls[] = {
  163. SOC_DAPM_SINGLE("Mic1 Capture Switch", ALC5623_ADC_REC_MIXER, 14, 1, 1),
  164. SOC_DAPM_SINGLE("Mic2 Capture Switch", ALC5623_ADC_REC_MIXER, 13, 1, 1),
  165. SOC_DAPM_SINGLE("LineInL Capture Switch", ALC5623_ADC_REC_MIXER, 12, 1, 1),
  166. SOC_DAPM_SINGLE("Left AuxI Capture Switch", ALC5623_ADC_REC_MIXER, 11, 1, 1),
  167. SOC_DAPM_SINGLE("HPMixerL Capture Switch", ALC5623_ADC_REC_MIXER, 10, 1, 1),
  168. SOC_DAPM_SINGLE("SPKMixer Capture Switch", ALC5623_ADC_REC_MIXER, 9, 1, 1),
  169. SOC_DAPM_SINGLE("MonoMixer Capture Switch", ALC5623_ADC_REC_MIXER, 8, 1, 1),
  170. };
  171. /* Right Record Mixer */
  172. static const struct snd_kcontrol_new alc5623_captureR_mixer_controls[] = {
  173. SOC_DAPM_SINGLE("Mic1 Capture Switch", ALC5623_ADC_REC_MIXER, 6, 1, 1),
  174. SOC_DAPM_SINGLE("Mic2 Capture Switch", ALC5623_ADC_REC_MIXER, 5, 1, 1),
  175. SOC_DAPM_SINGLE("LineInR Capture Switch", ALC5623_ADC_REC_MIXER, 4, 1, 1),
  176. SOC_DAPM_SINGLE("Right AuxI Capture Switch", ALC5623_ADC_REC_MIXER, 3, 1, 1),
  177. SOC_DAPM_SINGLE("HPMixerR Capture Switch", ALC5623_ADC_REC_MIXER, 2, 1, 1),
  178. SOC_DAPM_SINGLE("SPKMixer Capture Switch", ALC5623_ADC_REC_MIXER, 1, 1, 1),
  179. SOC_DAPM_SINGLE("MonoMixer Capture Switch", ALC5623_ADC_REC_MIXER, 0, 1, 1),
  180. };
  181. static const char *alc5623_spk_n_sour_sel[] = {
  182. "RN/-R", "RP/+R", "LN/-R", "Vmid" };
  183. static const char *alc5623_hpl_out_input_sel[] = {
  184. "Vmid", "HP Left Mix"};
  185. static const char *alc5623_hpr_out_input_sel[] = {
  186. "Vmid", "HP Right Mix"};
  187. static const char *alc5623_spkout_input_sel[] = {
  188. "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"};
  189. static const char *alc5623_aux_out_input_sel[] = {
  190. "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"};
  191. /* auxout output mux */
  192. static SOC_ENUM_SINGLE_DECL(alc5623_aux_out_input_enum,
  193. ALC5623_OUTPUT_MIXER_CTRL, 6,
  194. alc5623_aux_out_input_sel);
  195. static const struct snd_kcontrol_new alc5623_auxout_mux_controls =
  196. SOC_DAPM_ENUM("Route", alc5623_aux_out_input_enum);
  197. /* speaker output mux */
  198. static SOC_ENUM_SINGLE_DECL(alc5623_spkout_input_enum,
  199. ALC5623_OUTPUT_MIXER_CTRL, 10,
  200. alc5623_spkout_input_sel);
  201. static const struct snd_kcontrol_new alc5623_spkout_mux_controls =
  202. SOC_DAPM_ENUM("Route", alc5623_spkout_input_enum);
  203. /* headphone left output mux */
  204. static SOC_ENUM_SINGLE_DECL(alc5623_hpl_out_input_enum,
  205. ALC5623_OUTPUT_MIXER_CTRL, 9,
  206. alc5623_hpl_out_input_sel);
  207. static const struct snd_kcontrol_new alc5623_hpl_out_mux_controls =
  208. SOC_DAPM_ENUM("Route", alc5623_hpl_out_input_enum);
  209. /* headphone right output mux */
  210. static SOC_ENUM_SINGLE_DECL(alc5623_hpr_out_input_enum,
  211. ALC5623_OUTPUT_MIXER_CTRL, 8,
  212. alc5623_hpr_out_input_sel);
  213. static const struct snd_kcontrol_new alc5623_hpr_out_mux_controls =
  214. SOC_DAPM_ENUM("Route", alc5623_hpr_out_input_enum);
  215. /* speaker output N select */
  216. static SOC_ENUM_SINGLE_DECL(alc5623_spk_n_sour_enum,
  217. ALC5623_OUTPUT_MIXER_CTRL, 14,
  218. alc5623_spk_n_sour_sel);
  219. static const struct snd_kcontrol_new alc5623_spkoutn_mux_controls =
  220. SOC_DAPM_ENUM("Route", alc5623_spk_n_sour_enum);
  221. static const struct snd_soc_dapm_widget alc5623_dapm_widgets[] = {
  222. /* Muxes */
  223. SND_SOC_DAPM_MUX("AuxOut Mux", SND_SOC_NOPM, 0, 0,
  224. &alc5623_auxout_mux_controls),
  225. SND_SOC_DAPM_MUX("SpeakerOut Mux", SND_SOC_NOPM, 0, 0,
  226. &alc5623_spkout_mux_controls),
  227. SND_SOC_DAPM_MUX("Left Headphone Mux", SND_SOC_NOPM, 0, 0,
  228. &alc5623_hpl_out_mux_controls),
  229. SND_SOC_DAPM_MUX("Right Headphone Mux", SND_SOC_NOPM, 0, 0,
  230. &alc5623_hpr_out_mux_controls),
  231. SND_SOC_DAPM_MUX("SpeakerOut N Mux", SND_SOC_NOPM, 0, 0,
  232. &alc5623_spkoutn_mux_controls),
  233. /* output mixers */
  234. SND_SOC_DAPM_MIXER("HP Mix", SND_SOC_NOPM, 0, 0,
  235. &alc5623_hp_mixer_controls[0],
  236. ARRAY_SIZE(alc5623_hp_mixer_controls)),
  237. SND_SOC_DAPM_MIXER("HPR Mix", ALC5623_PWR_MANAG_ADD2, 4, 0,
  238. &alc5623_hpr_mixer_controls[0],
  239. ARRAY_SIZE(alc5623_hpr_mixer_controls)),
  240. SND_SOC_DAPM_MIXER("HPL Mix", ALC5623_PWR_MANAG_ADD2, 5, 0,
  241. &alc5623_hpl_mixer_controls[0],
  242. ARRAY_SIZE(alc5623_hpl_mixer_controls)),
  243. SND_SOC_DAPM_MIXER("HPOut Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
  244. SND_SOC_DAPM_MIXER("Mono Mix", ALC5623_PWR_MANAG_ADD2, 2, 0,
  245. &alc5623_mono_mixer_controls[0],
  246. ARRAY_SIZE(alc5623_mono_mixer_controls)),
  247. SND_SOC_DAPM_MIXER("Speaker Mix", ALC5623_PWR_MANAG_ADD2, 3, 0,
  248. &alc5623_speaker_mixer_controls[0],
  249. ARRAY_SIZE(alc5623_speaker_mixer_controls)),
  250. /* input mixers */
  251. SND_SOC_DAPM_MIXER("Left Capture Mix", ALC5623_PWR_MANAG_ADD2, 1, 0,
  252. &alc5623_captureL_mixer_controls[0],
  253. ARRAY_SIZE(alc5623_captureL_mixer_controls)),
  254. SND_SOC_DAPM_MIXER("Right Capture Mix", ALC5623_PWR_MANAG_ADD2, 0, 0,
  255. &alc5623_captureR_mixer_controls[0],
  256. ARRAY_SIZE(alc5623_captureR_mixer_controls)),
  257. SND_SOC_DAPM_DAC("Left DAC", "Left HiFi Playback",
  258. ALC5623_PWR_MANAG_ADD2, 9, 0),
  259. SND_SOC_DAPM_DAC("Right DAC", "Right HiFi Playback",
  260. ALC5623_PWR_MANAG_ADD2, 8, 0),
  261. SND_SOC_DAPM_MIXER("I2S Mix", ALC5623_PWR_MANAG_ADD1, 15, 0, NULL, 0),
  262. SND_SOC_DAPM_MIXER("AuxI Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
  263. SND_SOC_DAPM_MIXER("Line Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
  264. SND_SOC_DAPM_ADC("Left ADC", "Left HiFi Capture",
  265. ALC5623_PWR_MANAG_ADD2, 7, 0),
  266. SND_SOC_DAPM_ADC("Right ADC", "Right HiFi Capture",
  267. ALC5623_PWR_MANAG_ADD2, 6, 0),
  268. SND_SOC_DAPM_PGA("Left Headphone", ALC5623_PWR_MANAG_ADD3, 10, 0, NULL, 0),
  269. SND_SOC_DAPM_PGA("Right Headphone", ALC5623_PWR_MANAG_ADD3, 9, 0, NULL, 0),
  270. SND_SOC_DAPM_PGA("SpeakerOut", ALC5623_PWR_MANAG_ADD3, 12, 0, NULL, 0),
  271. SND_SOC_DAPM_PGA("Left AuxOut", ALC5623_PWR_MANAG_ADD3, 14, 0, NULL, 0),
  272. SND_SOC_DAPM_PGA("Right AuxOut", ALC5623_PWR_MANAG_ADD3, 13, 0, NULL, 0),
  273. SND_SOC_DAPM_PGA("Left LineIn", ALC5623_PWR_MANAG_ADD3, 7, 0, NULL, 0),
  274. SND_SOC_DAPM_PGA("Right LineIn", ALC5623_PWR_MANAG_ADD3, 6, 0, NULL, 0),
  275. SND_SOC_DAPM_PGA("Left AuxI", ALC5623_PWR_MANAG_ADD3, 5, 0, NULL, 0),
  276. SND_SOC_DAPM_PGA("Right AuxI", ALC5623_PWR_MANAG_ADD3, 4, 0, NULL, 0),
  277. SND_SOC_DAPM_PGA("MIC1 PGA", ALC5623_PWR_MANAG_ADD3, 3, 0, NULL, 0),
  278. SND_SOC_DAPM_PGA("MIC2 PGA", ALC5623_PWR_MANAG_ADD3, 2, 0, NULL, 0),
  279. SND_SOC_DAPM_PGA("MIC1 Pre Amp", ALC5623_PWR_MANAG_ADD3, 1, 0, NULL, 0),
  280. SND_SOC_DAPM_PGA("MIC2 Pre Amp", ALC5623_PWR_MANAG_ADD3, 0, 0, NULL, 0),
  281. SND_SOC_DAPM_MICBIAS("Mic Bias1", ALC5623_PWR_MANAG_ADD1, 11, 0),
  282. SND_SOC_DAPM_OUTPUT("AUXOUTL"),
  283. SND_SOC_DAPM_OUTPUT("AUXOUTR"),
  284. SND_SOC_DAPM_OUTPUT("HPL"),
  285. SND_SOC_DAPM_OUTPUT("HPR"),
  286. SND_SOC_DAPM_OUTPUT("SPKOUT"),
  287. SND_SOC_DAPM_OUTPUT("SPKOUTN"),
  288. SND_SOC_DAPM_INPUT("LINEINL"),
  289. SND_SOC_DAPM_INPUT("LINEINR"),
  290. SND_SOC_DAPM_INPUT("AUXINL"),
  291. SND_SOC_DAPM_INPUT("AUXINR"),
  292. SND_SOC_DAPM_INPUT("MIC1"),
  293. SND_SOC_DAPM_INPUT("MIC2"),
  294. SND_SOC_DAPM_VMID("Vmid"),
  295. };
  296. static const char *alc5623_amp_names[] = {"AB Amp", "D Amp"};
  297. static SOC_ENUM_SINGLE_DECL(alc5623_amp_enum,
  298. ALC5623_OUTPUT_MIXER_CTRL, 13,
  299. alc5623_amp_names);
  300. static const struct snd_kcontrol_new alc5623_amp_mux_controls =
  301. SOC_DAPM_ENUM("Route", alc5623_amp_enum);
  302. static const struct snd_soc_dapm_widget alc5623_dapm_amp_widgets[] = {
  303. SND_SOC_DAPM_PGA_E("D Amp", ALC5623_PWR_MANAG_ADD2, 14, 0, NULL, 0,
  304. amp_mixer_event, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
  305. SND_SOC_DAPM_PGA("AB Amp", ALC5623_PWR_MANAG_ADD2, 15, 0, NULL, 0),
  306. SND_SOC_DAPM_MUX("AB-D Amp Mux", SND_SOC_NOPM, 0, 0,
  307. &alc5623_amp_mux_controls),
  308. };
  309. static const struct snd_soc_dapm_route intercon[] = {
  310. /* virtual mixer - mixes left & right channels */
  311. {"I2S Mix", NULL, "Left DAC"},
  312. {"I2S Mix", NULL, "Right DAC"},
  313. {"Line Mix", NULL, "Right LineIn"},
  314. {"Line Mix", NULL, "Left LineIn"},
  315. {"AuxI Mix", NULL, "Left AuxI"},
  316. {"AuxI Mix", NULL, "Right AuxI"},
  317. {"AUXOUTL", NULL, "Left AuxOut"},
  318. {"AUXOUTR", NULL, "Right AuxOut"},
  319. /* HP mixer */
  320. {"HPL Mix", "ADC2HP_L Playback Switch", "Left Capture Mix"},
  321. {"HPL Mix", NULL, "HP Mix"},
  322. {"HPR Mix", "ADC2HP_R Playback Switch", "Right Capture Mix"},
  323. {"HPR Mix", NULL, "HP Mix"},
  324. {"HP Mix", "LI2HP Playback Switch", "Line Mix"},
  325. {"HP Mix", "AUXI2HP Playback Switch", "AuxI Mix"},
  326. {"HP Mix", "MIC12HP Playback Switch", "MIC1 PGA"},
  327. {"HP Mix", "MIC22HP Playback Switch", "MIC2 PGA"},
  328. {"HP Mix", "DAC2HP Playback Switch", "I2S Mix"},
  329. /* speaker mixer */
  330. {"Speaker Mix", "LI2SPK Playback Switch", "Line Mix"},
  331. {"Speaker Mix", "AUXI2SPK Playback Switch", "AuxI Mix"},
  332. {"Speaker Mix", "MIC12SPK Playback Switch", "MIC1 PGA"},
  333. {"Speaker Mix", "MIC22SPK Playback Switch", "MIC2 PGA"},
  334. {"Speaker Mix", "DAC2SPK Playback Switch", "I2S Mix"},
  335. /* mono mixer */
  336. {"Mono Mix", "ADC2MONO_L Playback Switch", "Left Capture Mix"},
  337. {"Mono Mix", "ADC2MONO_R Playback Switch", "Right Capture Mix"},
  338. {"Mono Mix", "LI2MONO Playback Switch", "Line Mix"},
  339. {"Mono Mix", "AUXI2MONO Playback Switch", "AuxI Mix"},
  340. {"Mono Mix", "MIC12MONO Playback Switch", "MIC1 PGA"},
  341. {"Mono Mix", "MIC22MONO Playback Switch", "MIC2 PGA"},
  342. {"Mono Mix", "DAC2MONO Playback Switch", "I2S Mix"},
  343. /* Left record mixer */
  344. {"Left Capture Mix", "LineInL Capture Switch", "LINEINL"},
  345. {"Left Capture Mix", "Left AuxI Capture Switch", "AUXINL"},
  346. {"Left Capture Mix", "Mic1 Capture Switch", "MIC1 Pre Amp"},
  347. {"Left Capture Mix", "Mic2 Capture Switch", "MIC2 Pre Amp"},
  348. {"Left Capture Mix", "HPMixerL Capture Switch", "HPL Mix"},
  349. {"Left Capture Mix", "SPKMixer Capture Switch", "Speaker Mix"},
  350. {"Left Capture Mix", "MonoMixer Capture Switch", "Mono Mix"},
  351. /*Right record mixer */
  352. {"Right Capture Mix", "LineInR Capture Switch", "LINEINR"},
  353. {"Right Capture Mix", "Right AuxI Capture Switch", "AUXINR"},
  354. {"Right Capture Mix", "Mic1 Capture Switch", "MIC1 Pre Amp"},
  355. {"Right Capture Mix", "Mic2 Capture Switch", "MIC2 Pre Amp"},
  356. {"Right Capture Mix", "HPMixerR Capture Switch", "HPR Mix"},
  357. {"Right Capture Mix", "SPKMixer Capture Switch", "Speaker Mix"},
  358. {"Right Capture Mix", "MonoMixer Capture Switch", "Mono Mix"},
  359. /* headphone left mux */
  360. {"Left Headphone Mux", "HP Left Mix", "HPL Mix"},
  361. {"Left Headphone Mux", "Vmid", "Vmid"},
  362. /* headphone right mux */
  363. {"Right Headphone Mux", "HP Right Mix", "HPR Mix"},
  364. {"Right Headphone Mux", "Vmid", "Vmid"},
  365. /* speaker out mux */
  366. {"SpeakerOut Mux", "Vmid", "Vmid"},
  367. {"SpeakerOut Mux", "HPOut Mix", "HPOut Mix"},
  368. {"SpeakerOut Mux", "Speaker Mix", "Speaker Mix"},
  369. {"SpeakerOut Mux", "Mono Mix", "Mono Mix"},
  370. /* Mono/Aux Out mux */
  371. {"AuxOut Mux", "Vmid", "Vmid"},
  372. {"AuxOut Mux", "HPOut Mix", "HPOut Mix"},
  373. {"AuxOut Mux", "Speaker Mix", "Speaker Mix"},
  374. {"AuxOut Mux", "Mono Mix", "Mono Mix"},
  375. /* output pga */
  376. {"HPL", NULL, "Left Headphone"},
  377. {"Left Headphone", NULL, "Left Headphone Mux"},
  378. {"HPR", NULL, "Right Headphone"},
  379. {"Right Headphone", NULL, "Right Headphone Mux"},
  380. {"Left AuxOut", NULL, "AuxOut Mux"},
  381. {"Right AuxOut", NULL, "AuxOut Mux"},
  382. /* input pga */
  383. {"Left LineIn", NULL, "LINEINL"},
  384. {"Right LineIn", NULL, "LINEINR"},
  385. {"Left AuxI", NULL, "AUXINL"},
  386. {"Right AuxI", NULL, "AUXINR"},
  387. {"MIC1 Pre Amp", NULL, "MIC1"},
  388. {"MIC2 Pre Amp", NULL, "MIC2"},
  389. {"MIC1 PGA", NULL, "MIC1 Pre Amp"},
  390. {"MIC2 PGA", NULL, "MIC2 Pre Amp"},
  391. /* left ADC */
  392. {"Left ADC", NULL, "Left Capture Mix"},
  393. /* right ADC */
  394. {"Right ADC", NULL, "Right Capture Mix"},
  395. {"SpeakerOut N Mux", "RN/-R", "SpeakerOut"},
  396. {"SpeakerOut N Mux", "RP/+R", "SpeakerOut"},
  397. {"SpeakerOut N Mux", "LN/-R", "SpeakerOut"},
  398. {"SpeakerOut N Mux", "Vmid", "Vmid"},
  399. {"SPKOUT", NULL, "SpeakerOut"},
  400. {"SPKOUTN", NULL, "SpeakerOut N Mux"},
  401. };
  402. static const struct snd_soc_dapm_route intercon_spk[] = {
  403. {"SpeakerOut", NULL, "SpeakerOut Mux"},
  404. };
  405. static const struct snd_soc_dapm_route intercon_amp_spk[] = {
  406. {"AB Amp", NULL, "SpeakerOut Mux"},
  407. {"D Amp", NULL, "SpeakerOut Mux"},
  408. {"AB-D Amp Mux", "AB Amp", "AB Amp"},
  409. {"AB-D Amp Mux", "D Amp", "D Amp"},
  410. {"SpeakerOut", NULL, "AB-D Amp Mux"},
  411. };
  412. /* PLL divisors */
  413. struct _pll_div {
  414. u32 pll_in;
  415. u32 pll_out;
  416. u16 regvalue;
  417. };
  418. /* Note : pll code from original alc5623 driver. Not sure of how good it is */
  419. /* useful only for master mode */
  420. static const struct _pll_div codec_master_pll_div[] = {
  421. { 2048000, 8192000, 0x0ea0},
  422. { 3686400, 8192000, 0x4e27},
  423. { 12000000, 8192000, 0x456b},
  424. { 13000000, 8192000, 0x495f},
  425. { 13100000, 8192000, 0x0320},
  426. { 2048000, 11289600, 0xf637},
  427. { 3686400, 11289600, 0x2f22},
  428. { 12000000, 11289600, 0x3e2f},
  429. { 13000000, 11289600, 0x4d5b},
  430. { 13100000, 11289600, 0x363b},
  431. { 2048000, 16384000, 0x1ea0},
  432. { 3686400, 16384000, 0x9e27},
  433. { 12000000, 16384000, 0x452b},
  434. { 13000000, 16384000, 0x542f},
  435. { 13100000, 16384000, 0x03a0},
  436. { 2048000, 16934400, 0xe625},
  437. { 3686400, 16934400, 0x9126},
  438. { 12000000, 16934400, 0x4d2c},
  439. { 13000000, 16934400, 0x742f},
  440. { 13100000, 16934400, 0x3c27},
  441. { 2048000, 22579200, 0x2aa0},
  442. { 3686400, 22579200, 0x2f20},
  443. { 12000000, 22579200, 0x7e2f},
  444. { 13000000, 22579200, 0x742f},
  445. { 13100000, 22579200, 0x3c27},
  446. { 2048000, 24576000, 0x2ea0},
  447. { 3686400, 24576000, 0xee27},
  448. { 12000000, 24576000, 0x2915},
  449. { 13000000, 24576000, 0x772e},
  450. { 13100000, 24576000, 0x0d20},
  451. };
  452. static const struct _pll_div codec_slave_pll_div[] = {
  453. { 1024000, 16384000, 0x3ea0},
  454. { 1411200, 22579200, 0x3ea0},
  455. { 1536000, 24576000, 0x3ea0},
  456. { 2048000, 16384000, 0x1ea0},
  457. { 2822400, 22579200, 0x1ea0},
  458. { 3072000, 24576000, 0x1ea0},
  459. };
  460. static int alc5623_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
  461. int source, unsigned int freq_in, unsigned int freq_out)
  462. {
  463. int i;
  464. struct snd_soc_component *component = codec_dai->component;
  465. int gbl_clk = 0, pll_div = 0;
  466. u16 reg;
  467. if (pll_id < ALC5623_PLL_FR_MCLK || pll_id > ALC5623_PLL_FR_BCK)
  468. return -ENODEV;
  469. /* Disable PLL power */
  470. snd_soc_component_update_bits(component, ALC5623_PWR_MANAG_ADD2,
  471. ALC5623_PWR_ADD2_PLL,
  472. 0);
  473. /* pll is not used in slave mode */
  474. reg = snd_soc_component_read(component, ALC5623_DAI_CONTROL);
  475. if (reg & ALC5623_DAI_SDP_SLAVE_MODE)
  476. return 0;
  477. if (!freq_in || !freq_out)
  478. return 0;
  479. switch (pll_id) {
  480. case ALC5623_PLL_FR_MCLK:
  481. for (i = 0; i < ARRAY_SIZE(codec_master_pll_div); i++) {
  482. if (codec_master_pll_div[i].pll_in == freq_in
  483. && codec_master_pll_div[i].pll_out == freq_out) {
  484. /* PLL source from MCLK */
  485. pll_div = codec_master_pll_div[i].regvalue;
  486. break;
  487. }
  488. }
  489. break;
  490. case ALC5623_PLL_FR_BCK:
  491. for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) {
  492. if (codec_slave_pll_div[i].pll_in == freq_in
  493. && codec_slave_pll_div[i].pll_out == freq_out) {
  494. /* PLL source from Bitclk */
  495. gbl_clk = ALC5623_GBL_CLK_PLL_SOUR_SEL_BITCLK;
  496. pll_div = codec_slave_pll_div[i].regvalue;
  497. break;
  498. }
  499. }
  500. break;
  501. default:
  502. return -EINVAL;
  503. }
  504. if (!pll_div)
  505. return -EINVAL;
  506. snd_soc_component_write(component, ALC5623_GLOBAL_CLK_CTRL_REG, gbl_clk);
  507. snd_soc_component_write(component, ALC5623_PLL_CTRL, pll_div);
  508. snd_soc_component_update_bits(component, ALC5623_PWR_MANAG_ADD2,
  509. ALC5623_PWR_ADD2_PLL,
  510. ALC5623_PWR_ADD2_PLL);
  511. gbl_clk |= ALC5623_GBL_CLK_SYS_SOUR_SEL_PLL;
  512. snd_soc_component_write(component, ALC5623_GLOBAL_CLK_CTRL_REG, gbl_clk);
  513. return 0;
  514. }
  515. struct _coeff_div {
  516. u16 fs;
  517. u16 regvalue;
  518. };
  519. /* codec hifi mclk (after PLL) clock divider coefficients */
  520. /* values inspired from column BCLK=32Fs of Appendix A table */
  521. static const struct _coeff_div coeff_div[] = {
  522. {256*8, 0x3a69},
  523. {384*8, 0x3c6b},
  524. {256*4, 0x2a69},
  525. {384*4, 0x2c6b},
  526. {256*2, 0x1a69},
  527. {384*2, 0x1c6b},
  528. {256*1, 0x0a69},
  529. {384*1, 0x0c6b},
  530. };
  531. static int get_coeff(struct snd_soc_component *component, int rate)
  532. {
  533. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  534. int i;
  535. for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
  536. if (coeff_div[i].fs * rate == alc5623->sysclk)
  537. return i;
  538. }
  539. return -EINVAL;
  540. }
  541. /*
  542. * Clock after PLL and dividers
  543. */
  544. static int alc5623_set_dai_sysclk(struct snd_soc_dai *codec_dai,
  545. int clk_id, unsigned int freq, int dir)
  546. {
  547. struct snd_soc_component *component = codec_dai->component;
  548. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  549. switch (freq) {
  550. case 8192000:
  551. case 11289600:
  552. case 12288000:
  553. case 16384000:
  554. case 16934400:
  555. case 18432000:
  556. case 22579200:
  557. case 24576000:
  558. alc5623->sysclk = freq;
  559. return 0;
  560. }
  561. return -EINVAL;
  562. }
  563. static int alc5623_set_dai_fmt(struct snd_soc_dai *codec_dai,
  564. unsigned int fmt)
  565. {
  566. struct snd_soc_component *component = codec_dai->component;
  567. u16 iface = 0;
  568. /* set master/slave audio interface */
  569. switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
  570. case SND_SOC_DAIFMT_CBM_CFM:
  571. iface = ALC5623_DAI_SDP_MASTER_MODE;
  572. break;
  573. case SND_SOC_DAIFMT_CBS_CFS:
  574. iface = ALC5623_DAI_SDP_SLAVE_MODE;
  575. break;
  576. default:
  577. return -EINVAL;
  578. }
  579. /* interface format */
  580. switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  581. case SND_SOC_DAIFMT_I2S:
  582. iface |= ALC5623_DAI_I2S_DF_I2S;
  583. break;
  584. case SND_SOC_DAIFMT_RIGHT_J:
  585. iface |= ALC5623_DAI_I2S_DF_RIGHT;
  586. break;
  587. case SND_SOC_DAIFMT_LEFT_J:
  588. iface |= ALC5623_DAI_I2S_DF_LEFT;
  589. break;
  590. case SND_SOC_DAIFMT_DSP_A:
  591. iface |= ALC5623_DAI_I2S_DF_PCM;
  592. break;
  593. case SND_SOC_DAIFMT_DSP_B:
  594. iface |= ALC5623_DAI_I2S_DF_PCM | ALC5623_DAI_I2S_PCM_MODE;
  595. break;
  596. default:
  597. return -EINVAL;
  598. }
  599. /* clock inversion */
  600. switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
  601. case SND_SOC_DAIFMT_NB_NF:
  602. break;
  603. case SND_SOC_DAIFMT_IB_IF:
  604. iface |= ALC5623_DAI_MAIN_I2S_BCLK_POL_CTRL;
  605. break;
  606. case SND_SOC_DAIFMT_IB_NF:
  607. iface |= ALC5623_DAI_MAIN_I2S_BCLK_POL_CTRL;
  608. break;
  609. case SND_SOC_DAIFMT_NB_IF:
  610. break;
  611. default:
  612. return -EINVAL;
  613. }
  614. return snd_soc_component_write(component, ALC5623_DAI_CONTROL, iface);
  615. }
  616. static int alc5623_pcm_hw_params(struct snd_pcm_substream *substream,
  617. struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
  618. {
  619. struct snd_soc_component *component = dai->component;
  620. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  621. int coeff, rate;
  622. u16 iface;
  623. iface = snd_soc_component_read(component, ALC5623_DAI_CONTROL);
  624. iface &= ~ALC5623_DAI_I2S_DL_MASK;
  625. /* bit size */
  626. switch (params_width(params)) {
  627. case 16:
  628. iface |= ALC5623_DAI_I2S_DL_16;
  629. break;
  630. case 20:
  631. iface |= ALC5623_DAI_I2S_DL_20;
  632. break;
  633. case 24:
  634. iface |= ALC5623_DAI_I2S_DL_24;
  635. break;
  636. case 32:
  637. iface |= ALC5623_DAI_I2S_DL_32;
  638. break;
  639. default:
  640. return -EINVAL;
  641. }
  642. /* set iface & srate */
  643. snd_soc_component_write(component, ALC5623_DAI_CONTROL, iface);
  644. rate = params_rate(params);
  645. coeff = get_coeff(component, rate);
  646. if (coeff < 0)
  647. return -EINVAL;
  648. coeff = coeff_div[coeff].regvalue;
  649. dev_dbg(component->dev, "%s: sysclk=%d,rate=%d,coeff=0x%04x\n",
  650. __func__, alc5623->sysclk, rate, coeff);
  651. snd_soc_component_write(component, ALC5623_STEREO_AD_DA_CLK_CTRL, coeff);
  652. return 0;
  653. }
  654. static int alc5623_mute(struct snd_soc_dai *dai, int mute, int direction)
  655. {
  656. struct snd_soc_component *component = dai->component;
  657. u16 hp_mute = ALC5623_MISC_M_DAC_L_INPUT | ALC5623_MISC_M_DAC_R_INPUT;
  658. u16 mute_reg = snd_soc_component_read(component, ALC5623_MISC_CTRL) & ~hp_mute;
  659. if (mute)
  660. mute_reg |= hp_mute;
  661. return snd_soc_component_write(component, ALC5623_MISC_CTRL, mute_reg);
  662. }
  663. #define ALC5623_ADD2_POWER_EN (ALC5623_PWR_ADD2_VREF \
  664. | ALC5623_PWR_ADD2_DAC_REF_CIR)
  665. #define ALC5623_ADD3_POWER_EN (ALC5623_PWR_ADD3_MAIN_BIAS \
  666. | ALC5623_PWR_ADD3_MIC1_BOOST_AD)
  667. #define ALC5623_ADD1_POWER_EN \
  668. (ALC5623_PWR_ADD1_SHORT_CURR_DET_EN | ALC5623_PWR_ADD1_SOFTGEN_EN \
  669. | ALC5623_PWR_ADD1_DEPOP_BUF_HP | ALC5623_PWR_ADD1_HP_OUT_AMP \
  670. | ALC5623_PWR_ADD1_HP_OUT_ENH_AMP)
  671. #define ALC5623_ADD1_POWER_EN_5622 \
  672. (ALC5623_PWR_ADD1_SHORT_CURR_DET_EN \
  673. | ALC5623_PWR_ADD1_HP_OUT_AMP)
  674. static void enable_power_depop(struct snd_soc_component *component)
  675. {
  676. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  677. snd_soc_component_update_bits(component, ALC5623_PWR_MANAG_ADD1,
  678. ALC5623_PWR_ADD1_SOFTGEN_EN,
  679. ALC5623_PWR_ADD1_SOFTGEN_EN);
  680. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD3, ALC5623_ADD3_POWER_EN);
  681. snd_soc_component_update_bits(component, ALC5623_MISC_CTRL,
  682. ALC5623_MISC_HP_DEPOP_MODE2_EN,
  683. ALC5623_MISC_HP_DEPOP_MODE2_EN);
  684. msleep(500);
  685. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD2, ALC5623_ADD2_POWER_EN);
  686. /* avoid writing '1' into 5622 reserved bits */
  687. if (alc5623->id == 0x22)
  688. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD1,
  689. ALC5623_ADD1_POWER_EN_5622);
  690. else
  691. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD1,
  692. ALC5623_ADD1_POWER_EN);
  693. /* disable HP Depop2 */
  694. snd_soc_component_update_bits(component, ALC5623_MISC_CTRL,
  695. ALC5623_MISC_HP_DEPOP_MODE2_EN,
  696. 0);
  697. }
  698. static int alc5623_set_bias_level(struct snd_soc_component *component,
  699. enum snd_soc_bias_level level)
  700. {
  701. switch (level) {
  702. case SND_SOC_BIAS_ON:
  703. enable_power_depop(component);
  704. break;
  705. case SND_SOC_BIAS_PREPARE:
  706. break;
  707. case SND_SOC_BIAS_STANDBY:
  708. /* everything off except vref/vmid, */
  709. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD2,
  710. ALC5623_PWR_ADD2_VREF);
  711. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD3,
  712. ALC5623_PWR_ADD3_MAIN_BIAS);
  713. break;
  714. case SND_SOC_BIAS_OFF:
  715. /* everything off, dac mute, inactive */
  716. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD2, 0);
  717. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD3, 0);
  718. snd_soc_component_write(component, ALC5623_PWR_MANAG_ADD1, 0);
  719. break;
  720. }
  721. return 0;
  722. }
  723. #define ALC5623_FORMATS (SNDRV_PCM_FMTBIT_S16_LE \
  724. | SNDRV_PCM_FMTBIT_S24_LE \
  725. | SNDRV_PCM_FMTBIT_S32_LE)
  726. static const struct snd_soc_dai_ops alc5623_dai_ops = {
  727. .hw_params = alc5623_pcm_hw_params,
  728. .mute_stream = alc5623_mute,
  729. .set_fmt = alc5623_set_dai_fmt,
  730. .set_sysclk = alc5623_set_dai_sysclk,
  731. .set_pll = alc5623_set_dai_pll,
  732. .no_capture_mute = 1,
  733. };
  734. static struct snd_soc_dai_driver alc5623_dai = {
  735. .name = "alc5623-hifi",
  736. .playback = {
  737. .stream_name = "Playback",
  738. .channels_min = 1,
  739. .channels_max = 2,
  740. .rate_min = 8000,
  741. .rate_max = 48000,
  742. .rates = SNDRV_PCM_RATE_8000_48000,
  743. .formats = ALC5623_FORMATS,},
  744. .capture = {
  745. .stream_name = "Capture",
  746. .channels_min = 1,
  747. .channels_max = 2,
  748. .rate_min = 8000,
  749. .rate_max = 48000,
  750. .rates = SNDRV_PCM_RATE_8000_48000,
  751. .formats = ALC5623_FORMATS,},
  752. .ops = &alc5623_dai_ops,
  753. };
  754. static int alc5623_suspend(struct snd_soc_component *component)
  755. {
  756. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  757. regcache_cache_only(alc5623->regmap, true);
  758. return 0;
  759. }
  760. static int alc5623_resume(struct snd_soc_component *component)
  761. {
  762. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  763. int ret;
  764. /* Sync reg_cache with the hardware */
  765. regcache_cache_only(alc5623->regmap, false);
  766. ret = regcache_sync(alc5623->regmap);
  767. if (ret != 0) {
  768. dev_err(component->dev, "Failed to sync register cache: %d\n",
  769. ret);
  770. regcache_cache_only(alc5623->regmap, true);
  771. return ret;
  772. }
  773. return 0;
  774. }
  775. static int alc5623_probe(struct snd_soc_component *component)
  776. {
  777. struct alc5623_priv *alc5623 = snd_soc_component_get_drvdata(component);
  778. struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
  779. alc5623_reset(component);
  780. if (alc5623->add_ctrl) {
  781. snd_soc_component_write(component, ALC5623_ADD_CTRL_REG,
  782. alc5623->add_ctrl);
  783. }
  784. if (alc5623->jack_det_ctrl) {
  785. snd_soc_component_write(component, ALC5623_JACK_DET_CTRL,
  786. alc5623->jack_det_ctrl);
  787. }
  788. switch (alc5623->id) {
  789. case 0x21:
  790. snd_soc_add_component_controls(component, alc5621_vol_snd_controls,
  791. ARRAY_SIZE(alc5621_vol_snd_controls));
  792. break;
  793. case 0x22:
  794. snd_soc_add_component_controls(component, alc5622_vol_snd_controls,
  795. ARRAY_SIZE(alc5622_vol_snd_controls));
  796. break;
  797. case 0x23:
  798. snd_soc_add_component_controls(component, alc5623_vol_snd_controls,
  799. ARRAY_SIZE(alc5623_vol_snd_controls));
  800. break;
  801. default:
  802. return -EINVAL;
  803. }
  804. snd_soc_add_component_controls(component, alc5623_snd_controls,
  805. ARRAY_SIZE(alc5623_snd_controls));
  806. snd_soc_dapm_new_controls(dapm, alc5623_dapm_widgets,
  807. ARRAY_SIZE(alc5623_dapm_widgets));
  808. /* set up audio path interconnects */
  809. snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon));
  810. switch (alc5623->id) {
  811. case 0x21:
  812. case 0x22:
  813. snd_soc_dapm_new_controls(dapm, alc5623_dapm_amp_widgets,
  814. ARRAY_SIZE(alc5623_dapm_amp_widgets));
  815. snd_soc_dapm_add_routes(dapm, intercon_amp_spk,
  816. ARRAY_SIZE(intercon_amp_spk));
  817. break;
  818. case 0x23:
  819. snd_soc_dapm_add_routes(dapm, intercon_spk,
  820. ARRAY_SIZE(intercon_spk));
  821. break;
  822. default:
  823. return -EINVAL;
  824. }
  825. return 0;
  826. }
  827. static const struct snd_soc_component_driver soc_component_device_alc5623 = {
  828. .probe = alc5623_probe,
  829. .suspend = alc5623_suspend,
  830. .resume = alc5623_resume,
  831. .set_bias_level = alc5623_set_bias_level,
  832. .suspend_bias_off = 1,
  833. .idle_bias_on = 1,
  834. .use_pmdown_time = 1,
  835. .endianness = 1,
  836. .non_legacy_dai_naming = 1,
  837. };
  838. static const struct regmap_config alc5623_regmap = {
  839. .reg_bits = 8,
  840. .val_bits = 16,
  841. .reg_stride = 2,
  842. .max_register = ALC5623_VENDOR_ID2,
  843. .cache_type = REGCACHE_RBTREE,
  844. };
  845. /*
  846. * ALC5623 2 wire address is determined by A1 pin
  847. * state during powerup.
  848. * low = 0x1a
  849. * high = 0x1b
  850. */
  851. static int alc5623_i2c_probe(struct i2c_client *client,
  852. const struct i2c_device_id *id)
  853. {
  854. struct alc5623_platform_data *pdata;
  855. struct alc5623_priv *alc5623;
  856. struct device_node *np;
  857. unsigned int vid1, vid2;
  858. int ret;
  859. u32 val32;
  860. alc5623 = devm_kzalloc(&client->dev, sizeof(struct alc5623_priv),
  861. GFP_KERNEL);
  862. if (alc5623 == NULL)
  863. return -ENOMEM;
  864. alc5623->regmap = devm_regmap_init_i2c(client, &alc5623_regmap);
  865. if (IS_ERR(alc5623->regmap)) {
  866. ret = PTR_ERR(alc5623->regmap);
  867. dev_err(&client->dev, "Failed to initialise I/O: %d\n", ret);
  868. return ret;
  869. }
  870. ret = regmap_read(alc5623->regmap, ALC5623_VENDOR_ID1, &vid1);
  871. if (ret < 0) {
  872. dev_err(&client->dev, "failed to read vendor ID1: %d\n", ret);
  873. return ret;
  874. }
  875. ret = regmap_read(alc5623->regmap, ALC5623_VENDOR_ID2, &vid2);
  876. if (ret < 0) {
  877. dev_err(&client->dev, "failed to read vendor ID2: %d\n", ret);
  878. return ret;
  879. }
  880. vid2 >>= 8;
  881. if ((vid1 != 0x10ec) || (vid2 != id->driver_data)) {
  882. dev_err(&client->dev, "unknown or wrong codec\n");
  883. dev_err(&client->dev, "Expected %x:%lx, got %x:%x\n",
  884. 0x10ec, id->driver_data,
  885. vid1, vid2);
  886. return -ENODEV;
  887. }
  888. dev_dbg(&client->dev, "Found codec id : alc56%02x\n", vid2);
  889. pdata = client->dev.platform_data;
  890. if (pdata) {
  891. alc5623->add_ctrl = pdata->add_ctrl;
  892. alc5623->jack_det_ctrl = pdata->jack_det_ctrl;
  893. } else {
  894. if (client->dev.of_node) {
  895. np = client->dev.of_node;
  896. ret = of_property_read_u32(np, "add-ctrl", &val32);
  897. if (!ret)
  898. alc5623->add_ctrl = val32;
  899. ret = of_property_read_u32(np, "jack-det-ctrl", &val32);
  900. if (!ret)
  901. alc5623->jack_det_ctrl = val32;
  902. }
  903. }
  904. alc5623->id = vid2;
  905. switch (alc5623->id) {
  906. case 0x21:
  907. alc5623_dai.name = "alc5621-hifi";
  908. break;
  909. case 0x22:
  910. alc5623_dai.name = "alc5622-hifi";
  911. break;
  912. case 0x23:
  913. alc5623_dai.name = "alc5623-hifi";
  914. break;
  915. default:
  916. return -EINVAL;
  917. }
  918. i2c_set_clientdata(client, alc5623);
  919. ret = devm_snd_soc_register_component(&client->dev,
  920. &soc_component_device_alc5623, &alc5623_dai, 1);
  921. if (ret != 0)
  922. dev_err(&client->dev, "Failed to register codec: %d\n", ret);
  923. return ret;
  924. }
  925. static const struct i2c_device_id alc5623_i2c_table[] = {
  926. {"alc5621", 0x21},
  927. {"alc5622", 0x22},
  928. {"alc5623", 0x23},
  929. {}
  930. };
  931. MODULE_DEVICE_TABLE(i2c, alc5623_i2c_table);
  932. static const struct of_device_id alc5623_of_match[] = {
  933. { .compatible = "realtek,alc5623", },
  934. { }
  935. };
  936. MODULE_DEVICE_TABLE(of, alc5623_of_match);
  937. /* i2c codec control layer */
  938. static struct i2c_driver alc5623_i2c_driver = {
  939. .driver = {
  940. .name = "alc562x-codec",
  941. .of_match_table = of_match_ptr(alc5623_of_match),
  942. },
  943. .probe = alc5623_i2c_probe,
  944. .id_table = alc5623_i2c_table,
  945. };
  946. module_i2c_driver(alc5623_i2c_driver);
  947. MODULE_DESCRIPTION("ASoC alc5621/2/3 driver");
  948. MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
  949. MODULE_LICENSE("GPL");