patch_via.c 52 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932
  1. /*
  2. * Universal Interface for Intel High Definition Audio Codec
  3. *
  4. * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
  5. *
  6. * (C) 2006-2009 VIA Technology, Inc.
  7. * (C) 2006-2008 Takashi Iwai <tiwai@suse.de>
  8. *
  9. * This driver is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This driver is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22. */
  23. /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
  24. /* */
  25. /* 2006-03-03 Lydia Wang Create the basic patch to support VT1708 codec */
  26. /* 2006-03-14 Lydia Wang Modify hard code for some pin widget nid */
  27. /* 2006-08-02 Lydia Wang Add support to VT1709 codec */
  28. /* 2006-09-08 Lydia Wang Fix internal loopback recording source select bug */
  29. /* 2007-09-12 Lydia Wang Add EAPD enable during driver initialization */
  30. /* 2007-09-17 Lydia Wang Add VT1708B codec support */
  31. /* 2007-11-14 Lydia Wang Add VT1708A codec HP and CD pin connect config */
  32. /* 2008-02-03 Lydia Wang Fix Rear channels and Back channels inverse issue */
  33. /* 2008-03-06 Lydia Wang Add VT1702 codec and VT1708S codec support */
  34. /* 2008-04-09 Lydia Wang Add mute front speaker when HP plugin */
  35. /* 2008-04-09 Lydia Wang Add Independent HP feature */
  36. /* 2008-05-28 Lydia Wang Add second S/PDIF Out support for VT1702 */
  37. /* 2008-09-15 Logan Li Add VT1708S Mic Boost workaround/backdoor */
  38. /* 2009-02-16 Logan Li Add support for VT1718S */
  39. /* 2009-03-13 Logan Li Add support for VT1716S */
  40. /* 2009-04-14 Lydai Wang Add support for VT1828S and VT2020 */
  41. /* 2009-07-08 Lydia Wang Add support for VT2002P */
  42. /* 2009-07-21 Lydia Wang Add support for VT1812 */
  43. /* 2009-09-19 Lydia Wang Add support for VT1818S */
  44. /* */
  45. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  46. #include <linux/init.h>
  47. #include <linux/delay.h>
  48. #include <linux/slab.h>
  49. #include <linux/module.h>
  50. #include <sound/core.h>
  51. #include <sound/asoundef.h>
  52. #include "hda_codec.h"
  53. #include "hda_local.h"
  54. #include "hda_auto_parser.h"
  55. #include "hda_jack.h"
  56. #include "hda_generic.h"
  57. /* Pin Widget NID */
  58. #define VT1708_HP_PIN_NID 0x20
  59. #define VT1708_CD_PIN_NID 0x24
  60. enum VIA_HDA_CODEC {
  61. UNKNOWN = -1,
  62. VT1708,
  63. VT1709_10CH,
  64. VT1709_6CH,
  65. VT1708B_8CH,
  66. VT1708B_4CH,
  67. VT1708S,
  68. VT1708BCE,
  69. VT1702,
  70. VT1718S,
  71. VT1716S,
  72. VT2002P,
  73. VT1812,
  74. VT1802,
  75. VT1705CF,
  76. VT1808,
  77. CODEC_TYPES,
  78. };
  79. #define VT2002P_COMPATIBLE(spec) \
  80. ((spec)->codec_type == VT2002P ||\
  81. (spec)->codec_type == VT1812 ||\
  82. (spec)->codec_type == VT1802)
  83. struct via_spec {
  84. struct hda_gen_spec gen;
  85. /* codec parameterization */
  86. const struct snd_kcontrol_new *mixers[6];
  87. unsigned int num_mixers;
  88. const struct hda_verb *init_verbs[5];
  89. unsigned int num_iverbs;
  90. /* HP mode source */
  91. unsigned int dmic_enabled;
  92. unsigned int no_pin_power_ctl;
  93. enum VIA_HDA_CODEC codec_type;
  94. /* analog low-power control */
  95. bool alc_mode;
  96. /* work to check hp jack state */
  97. int hp_work_active;
  98. int vt1708_jack_detect;
  99. void (*set_widgets_power_state)(struct hda_codec *codec);
  100. unsigned int dac_stream_tag[4];
  101. };
  102. static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
  103. static void via_playback_pcm_hook(struct hda_pcm_stream *hinfo,
  104. struct hda_codec *codec,
  105. struct snd_pcm_substream *substream,
  106. int action);
  107. static void via_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *tbl);
  108. static struct via_spec *via_new_spec(struct hda_codec *codec)
  109. {
  110. struct via_spec *spec;
  111. spec = kzalloc(sizeof(*spec), GFP_KERNEL);
  112. if (spec == NULL)
  113. return NULL;
  114. codec->spec = spec;
  115. snd_hda_gen_spec_init(&spec->gen);
  116. spec->codec_type = get_codec_type(codec);
  117. /* VT1708BCE & VT1708S are almost same */
  118. if (spec->codec_type == VT1708BCE)
  119. spec->codec_type = VT1708S;
  120. spec->no_pin_power_ctl = 1;
  121. spec->gen.indep_hp = 1;
  122. spec->gen.keep_eapd_on = 1;
  123. spec->gen.pcm_playback_hook = via_playback_pcm_hook;
  124. return spec;
  125. }
  126. static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
  127. {
  128. u32 vendor_id = codec->vendor_id;
  129. u16 ven_id = vendor_id >> 16;
  130. u16 dev_id = vendor_id & 0xffff;
  131. enum VIA_HDA_CODEC codec_type;
  132. /* get codec type */
  133. if (ven_id != 0x1106)
  134. codec_type = UNKNOWN;
  135. else if (dev_id >= 0x1708 && dev_id <= 0x170b)
  136. codec_type = VT1708;
  137. else if (dev_id >= 0xe710 && dev_id <= 0xe713)
  138. codec_type = VT1709_10CH;
  139. else if (dev_id >= 0xe714 && dev_id <= 0xe717)
  140. codec_type = VT1709_6CH;
  141. else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
  142. codec_type = VT1708B_8CH;
  143. if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
  144. codec_type = VT1708BCE;
  145. } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
  146. codec_type = VT1708B_4CH;
  147. else if ((dev_id & 0xfff) == 0x397
  148. && (dev_id >> 12) < 8)
  149. codec_type = VT1708S;
  150. else if ((dev_id & 0xfff) == 0x398
  151. && (dev_id >> 12) < 8)
  152. codec_type = VT1702;
  153. else if ((dev_id & 0xfff) == 0x428
  154. && (dev_id >> 12) < 8)
  155. codec_type = VT1718S;
  156. else if (dev_id == 0x0433 || dev_id == 0xa721)
  157. codec_type = VT1716S;
  158. else if (dev_id == 0x0441 || dev_id == 0x4441)
  159. codec_type = VT1718S;
  160. else if (dev_id == 0x0438 || dev_id == 0x4438)
  161. codec_type = VT2002P;
  162. else if (dev_id == 0x0448)
  163. codec_type = VT1812;
  164. else if (dev_id == 0x0440)
  165. codec_type = VT1708S;
  166. else if ((dev_id & 0xfff) == 0x446)
  167. codec_type = VT1802;
  168. else if (dev_id == 0x4760)
  169. codec_type = VT1705CF;
  170. else if (dev_id == 0x4761 || dev_id == 0x4762)
  171. codec_type = VT1808;
  172. else
  173. codec_type = UNKNOWN;
  174. return codec_type;
  175. };
  176. static void analog_low_current_mode(struct hda_codec *codec);
  177. static bool is_aa_path_mute(struct hda_codec *codec);
  178. #define hp_detect_with_aa(codec) \
  179. (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1 && \
  180. !is_aa_path_mute(codec))
  181. static void vt1708_stop_hp_work(struct hda_codec *codec)
  182. {
  183. struct via_spec *spec = codec->spec;
  184. if (spec->codec_type != VT1708 || !spec->gen.autocfg.hp_outs)
  185. return;
  186. if (spec->hp_work_active) {
  187. snd_hda_codec_write(codec, 0x1, 0, 0xf81, 1);
  188. cancel_delayed_work_sync(&codec->jackpoll_work);
  189. spec->hp_work_active = false;
  190. codec->jackpoll_interval = 0;
  191. }
  192. }
  193. static void vt1708_update_hp_work(struct hda_codec *codec)
  194. {
  195. struct via_spec *spec = codec->spec;
  196. if (spec->codec_type != VT1708 || !spec->gen.autocfg.hp_outs)
  197. return;
  198. if (spec->vt1708_jack_detect) {
  199. if (!spec->hp_work_active) {
  200. codec->jackpoll_interval = msecs_to_jiffies(100);
  201. snd_hda_codec_write(codec, 0x1, 0, 0xf81, 0);
  202. queue_delayed_work(codec->bus->workq,
  203. &codec->jackpoll_work, 0);
  204. spec->hp_work_active = true;
  205. }
  206. } else if (!hp_detect_with_aa(codec))
  207. vt1708_stop_hp_work(codec);
  208. }
  209. static void set_widgets_power_state(struct hda_codec *codec)
  210. {
  211. #if 0 /* FIXME: the assumed connections don't match always with the
  212. * actual routes by the generic parser, so better to disable
  213. * the control for safety.
  214. */
  215. struct via_spec *spec = codec->spec;
  216. if (spec->set_widgets_power_state)
  217. spec->set_widgets_power_state(codec);
  218. #endif
  219. }
  220. static void update_power_state(struct hda_codec *codec, hda_nid_t nid,
  221. unsigned int parm)
  222. {
  223. if (snd_hda_check_power_state(codec, nid, parm))
  224. return;
  225. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
  226. }
  227. static void update_conv_power_state(struct hda_codec *codec, hda_nid_t nid,
  228. unsigned int parm, unsigned int index)
  229. {
  230. struct via_spec *spec = codec->spec;
  231. unsigned int format;
  232. if (snd_hda_check_power_state(codec, nid, parm))
  233. return;
  234. format = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
  235. if (format && (spec->dac_stream_tag[index] != format))
  236. spec->dac_stream_tag[index] = format;
  237. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
  238. if (parm == AC_PWRST_D0) {
  239. format = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
  240. if (!format && (spec->dac_stream_tag[index] != format))
  241. snd_hda_codec_write(codec, nid, 0,
  242. AC_VERB_SET_CHANNEL_STREAMID,
  243. spec->dac_stream_tag[index]);
  244. }
  245. }
  246. static bool smart51_enabled(struct hda_codec *codec)
  247. {
  248. struct via_spec *spec = codec->spec;
  249. return spec->gen.ext_channel_count > 2;
  250. }
  251. static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
  252. {
  253. struct via_spec *spec = codec->spec;
  254. int i;
  255. for (i = 0; i < spec->gen.multi_ios; i++)
  256. if (spec->gen.multi_io[i].pin == pin)
  257. return true;
  258. return false;
  259. }
  260. static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
  261. unsigned int *affected_parm)
  262. {
  263. unsigned parm;
  264. unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
  265. unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
  266. >> AC_DEFCFG_MISC_SHIFT
  267. & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
  268. struct via_spec *spec = codec->spec;
  269. unsigned present = 0;
  270. no_presence |= spec->no_pin_power_ctl;
  271. if (!no_presence)
  272. present = snd_hda_jack_detect(codec, nid);
  273. if ((smart51_enabled(codec) && is_smart51_pins(codec, nid))
  274. || ((no_presence || present)
  275. && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
  276. *affected_parm = AC_PWRST_D0; /* if it's connected */
  277. parm = AC_PWRST_D0;
  278. } else
  279. parm = AC_PWRST_D3;
  280. update_power_state(codec, nid, parm);
  281. }
  282. static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
  283. struct snd_ctl_elem_info *uinfo)
  284. {
  285. return snd_hda_enum_bool_helper_info(kcontrol, uinfo);
  286. }
  287. static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
  288. struct snd_ctl_elem_value *ucontrol)
  289. {
  290. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  291. struct via_spec *spec = codec->spec;
  292. ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
  293. return 0;
  294. }
  295. static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
  296. struct snd_ctl_elem_value *ucontrol)
  297. {
  298. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  299. struct via_spec *spec = codec->spec;
  300. unsigned int val = !ucontrol->value.enumerated.item[0];
  301. if (val == spec->no_pin_power_ctl)
  302. return 0;
  303. spec->no_pin_power_ctl = val;
  304. set_widgets_power_state(codec);
  305. analog_low_current_mode(codec);
  306. return 1;
  307. }
  308. static const struct snd_kcontrol_new via_pin_power_ctl_enum[] = {
  309. {
  310. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  311. .name = "Dynamic Power-Control",
  312. .info = via_pin_power_ctl_info,
  313. .get = via_pin_power_ctl_get,
  314. .put = via_pin_power_ctl_put,
  315. },
  316. {} /* terminator */
  317. };
  318. /* check AA path's mute status */
  319. static bool is_aa_path_mute(struct hda_codec *codec)
  320. {
  321. struct via_spec *spec = codec->spec;
  322. const struct hda_amp_list *p;
  323. int ch, v;
  324. p = spec->gen.loopback.amplist;
  325. if (!p)
  326. return true;
  327. for (; p->nid; p++) {
  328. for (ch = 0; ch < 2; ch++) {
  329. v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
  330. p->idx);
  331. if (!(v & HDA_AMP_MUTE) && v > 0)
  332. return false;
  333. }
  334. }
  335. return true;
  336. }
  337. /* enter/exit analog low-current mode */
  338. static void __analog_low_current_mode(struct hda_codec *codec, bool force)
  339. {
  340. struct via_spec *spec = codec->spec;
  341. bool enable;
  342. unsigned int verb, parm;
  343. if (spec->no_pin_power_ctl)
  344. enable = false;
  345. else
  346. enable = is_aa_path_mute(codec) && !spec->gen.active_streams;
  347. if (enable == spec->alc_mode && !force)
  348. return;
  349. spec->alc_mode = enable;
  350. /* decide low current mode's verb & parameter */
  351. switch (spec->codec_type) {
  352. case VT1708B_8CH:
  353. case VT1708B_4CH:
  354. verb = 0xf70;
  355. parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
  356. break;
  357. case VT1708S:
  358. case VT1718S:
  359. case VT1716S:
  360. verb = 0xf73;
  361. parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
  362. break;
  363. case VT1702:
  364. verb = 0xf73;
  365. parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
  366. break;
  367. case VT2002P:
  368. case VT1812:
  369. case VT1802:
  370. verb = 0xf93;
  371. parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
  372. break;
  373. case VT1705CF:
  374. case VT1808:
  375. verb = 0xf82;
  376. parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
  377. break;
  378. default:
  379. return; /* other codecs are not supported */
  380. }
  381. /* send verb */
  382. snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
  383. }
  384. static void analog_low_current_mode(struct hda_codec *codec)
  385. {
  386. return __analog_low_current_mode(codec, false);
  387. }
  388. static int via_build_controls(struct hda_codec *codec)
  389. {
  390. struct via_spec *spec = codec->spec;
  391. int err, i;
  392. err = snd_hda_gen_build_controls(codec);
  393. if (err < 0)
  394. return err;
  395. if (spec->set_widgets_power_state)
  396. spec->mixers[spec->num_mixers++] = via_pin_power_ctl_enum;
  397. for (i = 0; i < spec->num_mixers; i++) {
  398. err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
  399. if (err < 0)
  400. return err;
  401. }
  402. return 0;
  403. }
  404. static void via_playback_pcm_hook(struct hda_pcm_stream *hinfo,
  405. struct hda_codec *codec,
  406. struct snd_pcm_substream *substream,
  407. int action)
  408. {
  409. analog_low_current_mode(codec);
  410. vt1708_update_hp_work(codec);
  411. }
  412. static void via_free(struct hda_codec *codec)
  413. {
  414. struct via_spec *spec = codec->spec;
  415. if (!spec)
  416. return;
  417. vt1708_stop_hp_work(codec);
  418. snd_hda_gen_spec_free(&spec->gen);
  419. kfree(spec);
  420. }
  421. #ifdef CONFIG_PM
  422. static int via_suspend(struct hda_codec *codec)
  423. {
  424. struct via_spec *spec = codec->spec;
  425. vt1708_stop_hp_work(codec);
  426. if (spec->codec_type == VT1802) {
  427. /* Fix pop noise on headphones */
  428. int i;
  429. for (i = 0; i < spec->gen.autocfg.hp_outs; i++)
  430. snd_hda_set_pin_ctl(codec, spec->gen.autocfg.hp_pins[i], 0);
  431. }
  432. return 0;
  433. }
  434. #endif
  435. #ifdef CONFIG_PM
  436. static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
  437. {
  438. struct via_spec *spec = codec->spec;
  439. set_widgets_power_state(codec);
  440. analog_low_current_mode(codec);
  441. vt1708_update_hp_work(codec);
  442. return snd_hda_check_amp_list_power(codec, &spec->gen.loopback, nid);
  443. }
  444. #endif
  445. /*
  446. */
  447. static int via_init(struct hda_codec *codec);
  448. static const struct hda_codec_ops via_patch_ops = {
  449. .build_controls = via_build_controls,
  450. .build_pcms = snd_hda_gen_build_pcms,
  451. .init = via_init,
  452. .free = via_free,
  453. .unsol_event = snd_hda_jack_unsol_event,
  454. #ifdef CONFIG_PM
  455. .suspend = via_suspend,
  456. .check_power_status = via_check_power_status,
  457. #endif
  458. };
  459. static const struct hda_verb vt1708_init_verbs[] = {
  460. /* power down jack detect function */
  461. {0x1, 0xf81, 0x1},
  462. { }
  463. };
  464. static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
  465. {
  466. unsigned int def_conf;
  467. unsigned char seqassoc;
  468. def_conf = snd_hda_codec_get_pincfg(codec, nid);
  469. seqassoc = (unsigned char) get_defcfg_association(def_conf);
  470. seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
  471. if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
  472. && (seqassoc == 0xf0 || seqassoc == 0xff)) {
  473. def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
  474. snd_hda_codec_set_pincfg(codec, nid, def_conf);
  475. }
  476. return;
  477. }
  478. static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
  479. struct snd_ctl_elem_value *ucontrol)
  480. {
  481. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  482. struct via_spec *spec = codec->spec;
  483. if (spec->codec_type != VT1708)
  484. return 0;
  485. ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
  486. return 0;
  487. }
  488. static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
  489. struct snd_ctl_elem_value *ucontrol)
  490. {
  491. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  492. struct via_spec *spec = codec->spec;
  493. int val;
  494. if (spec->codec_type != VT1708)
  495. return 0;
  496. val = !!ucontrol->value.integer.value[0];
  497. if (spec->vt1708_jack_detect == val)
  498. return 0;
  499. spec->vt1708_jack_detect = val;
  500. vt1708_update_hp_work(codec);
  501. return 1;
  502. }
  503. static const struct snd_kcontrol_new vt1708_jack_detect_ctl[] = {
  504. {
  505. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  506. .name = "Jack Detect",
  507. .count = 1,
  508. .info = snd_ctl_boolean_mono_info,
  509. .get = vt1708_jack_detect_get,
  510. .put = vt1708_jack_detect_put,
  511. },
  512. {} /* terminator */
  513. };
  514. static void via_hp_automute(struct hda_codec *codec, struct hda_jack_tbl *tbl)
  515. {
  516. set_widgets_power_state(codec);
  517. snd_hda_gen_hp_automute(codec, tbl);
  518. }
  519. static void via_line_automute(struct hda_codec *codec, struct hda_jack_tbl *tbl)
  520. {
  521. set_widgets_power_state(codec);
  522. snd_hda_gen_line_automute(codec, tbl);
  523. }
  524. static void via_jack_powerstate_event(struct hda_codec *codec, struct hda_jack_tbl *tbl)
  525. {
  526. set_widgets_power_state(codec);
  527. }
  528. #define VIA_JACK_EVENT (HDA_GEN_LAST_EVENT + 1)
  529. static void via_set_jack_unsol_events(struct hda_codec *codec)
  530. {
  531. struct via_spec *spec = codec->spec;
  532. struct auto_pin_cfg *cfg = &spec->gen.autocfg;
  533. hda_nid_t pin;
  534. int i;
  535. spec->gen.hp_automute_hook = via_hp_automute;
  536. if (cfg->speaker_pins[0])
  537. spec->gen.line_automute_hook = via_line_automute;
  538. for (i = 0; i < cfg->line_outs; i++) {
  539. pin = cfg->line_out_pins[i];
  540. if (pin && !snd_hda_jack_tbl_get(codec, pin) &&
  541. is_jack_detectable(codec, pin))
  542. snd_hda_jack_detect_enable_callback(codec, pin,
  543. VIA_JACK_EVENT,
  544. via_jack_powerstate_event);
  545. }
  546. for (i = 0; i < cfg->num_inputs; i++) {
  547. pin = cfg->line_out_pins[i];
  548. if (pin && !snd_hda_jack_tbl_get(codec, pin) &&
  549. is_jack_detectable(codec, pin))
  550. snd_hda_jack_detect_enable_callback(codec, pin,
  551. VIA_JACK_EVENT,
  552. via_jack_powerstate_event);
  553. }
  554. }
  555. static const struct badness_table via_main_out_badness = {
  556. .no_primary_dac = 0x10000,
  557. .no_dac = 0x4000,
  558. .shared_primary = 0x10000,
  559. .shared_surr = 0x20,
  560. .shared_clfe = 0x20,
  561. .shared_surr_main = 0x20,
  562. };
  563. static const struct badness_table via_extra_out_badness = {
  564. .no_primary_dac = 0x4000,
  565. .no_dac = 0x4000,
  566. .shared_primary = 0x12,
  567. .shared_surr = 0x20,
  568. .shared_clfe = 0x20,
  569. .shared_surr_main = 0x10,
  570. };
  571. static int via_parse_auto_config(struct hda_codec *codec)
  572. {
  573. struct via_spec *spec = codec->spec;
  574. int err;
  575. spec->gen.main_out_badness = &via_main_out_badness;
  576. spec->gen.extra_out_badness = &via_extra_out_badness;
  577. err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL, 0);
  578. if (err < 0)
  579. return err;
  580. err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
  581. if (err < 0)
  582. return err;
  583. via_set_jack_unsol_events(codec);
  584. return 0;
  585. }
  586. static int via_init(struct hda_codec *codec)
  587. {
  588. struct via_spec *spec = codec->spec;
  589. int i;
  590. for (i = 0; i < spec->num_iverbs; i++)
  591. snd_hda_sequence_write(codec, spec->init_verbs[i]);
  592. /* init power states */
  593. set_widgets_power_state(codec);
  594. __analog_low_current_mode(codec, true);
  595. snd_hda_gen_init(codec);
  596. vt1708_update_hp_work(codec);
  597. return 0;
  598. }
  599. static int vt1708_build_controls(struct hda_codec *codec)
  600. {
  601. /* In order not to create "Phantom Jack" controls,
  602. temporary enable jackpoll */
  603. int err;
  604. int old_interval = codec->jackpoll_interval;
  605. codec->jackpoll_interval = msecs_to_jiffies(100);
  606. err = via_build_controls(codec);
  607. codec->jackpoll_interval = old_interval;
  608. return err;
  609. }
  610. static int vt1708_build_pcms(struct hda_codec *codec)
  611. {
  612. struct via_spec *spec = codec->spec;
  613. int i, err;
  614. err = snd_hda_gen_build_pcms(codec);
  615. if (err < 0 || codec->vendor_id != 0x11061708)
  616. return err;
  617. /* We got noisy outputs on the right channel on VT1708 when
  618. * 24bit samples are used. Until any workaround is found,
  619. * disable the 24bit format, so far.
  620. */
  621. for (i = 0; i < codec->num_pcms; i++) {
  622. struct hda_pcm *info = &spec->gen.pcm_rec[i];
  623. if (!info->stream[SNDRV_PCM_STREAM_PLAYBACK].substreams ||
  624. info->pcm_type != HDA_PCM_TYPE_AUDIO)
  625. continue;
  626. info->stream[SNDRV_PCM_STREAM_PLAYBACK].formats =
  627. SNDRV_PCM_FMTBIT_S16_LE;
  628. }
  629. return 0;
  630. }
  631. static int patch_vt1708(struct hda_codec *codec)
  632. {
  633. struct via_spec *spec;
  634. int err;
  635. /* create a codec specific record */
  636. spec = via_new_spec(codec);
  637. if (spec == NULL)
  638. return -ENOMEM;
  639. spec->gen.mixer_nid = 0x17;
  640. /* set jackpoll_interval while parsing the codec */
  641. codec->jackpoll_interval = msecs_to_jiffies(100);
  642. spec->vt1708_jack_detect = 1;
  643. /* don't support the input jack switching due to lack of unsol event */
  644. /* (it may work with polling, though, but it needs testing) */
  645. spec->gen.suppress_auto_mic = 1;
  646. /* Add HP and CD pin config connect bit re-config action */
  647. vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
  648. vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
  649. /* automatic parse from the BIOS config */
  650. err = via_parse_auto_config(codec);
  651. if (err < 0) {
  652. via_free(codec);
  653. return err;
  654. }
  655. /* add jack detect on/off control */
  656. spec->mixers[spec->num_mixers++] = vt1708_jack_detect_ctl;
  657. spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
  658. codec->patch_ops = via_patch_ops;
  659. codec->patch_ops.build_controls = vt1708_build_controls;
  660. codec->patch_ops.build_pcms = vt1708_build_pcms;
  661. /* clear jackpoll_interval again; it's set dynamically */
  662. codec->jackpoll_interval = 0;
  663. return 0;
  664. }
  665. static int patch_vt1709(struct hda_codec *codec)
  666. {
  667. struct via_spec *spec;
  668. int err;
  669. /* create a codec specific record */
  670. spec = via_new_spec(codec);
  671. if (spec == NULL)
  672. return -ENOMEM;
  673. spec->gen.mixer_nid = 0x18;
  674. err = via_parse_auto_config(codec);
  675. if (err < 0) {
  676. via_free(codec);
  677. return err;
  678. }
  679. codec->patch_ops = via_patch_ops;
  680. return 0;
  681. }
  682. static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
  683. {
  684. struct via_spec *spec = codec->spec;
  685. int imux_is_smixer;
  686. unsigned int parm;
  687. int is_8ch = 0;
  688. if ((spec->codec_type != VT1708B_4CH) &&
  689. (codec->vendor_id != 0x11064397))
  690. is_8ch = 1;
  691. /* SW0 (17h) = stereo mixer */
  692. imux_is_smixer =
  693. (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
  694. == ((spec->codec_type == VT1708S) ? 5 : 0));
  695. /* inputs */
  696. /* PW 1/2/5 (1ah/1bh/1eh) */
  697. parm = AC_PWRST_D3;
  698. set_pin_power_state(codec, 0x1a, &parm);
  699. set_pin_power_state(codec, 0x1b, &parm);
  700. set_pin_power_state(codec, 0x1e, &parm);
  701. if (imux_is_smixer)
  702. parm = AC_PWRST_D0;
  703. /* SW0 (17h), AIW 0/1 (13h/14h) */
  704. update_power_state(codec, 0x17, parm);
  705. update_power_state(codec, 0x13, parm);
  706. update_power_state(codec, 0x14, parm);
  707. /* outputs */
  708. /* PW0 (19h), SW1 (18h), AOW1 (11h) */
  709. parm = AC_PWRST_D3;
  710. set_pin_power_state(codec, 0x19, &parm);
  711. if (smart51_enabled(codec))
  712. set_pin_power_state(codec, 0x1b, &parm);
  713. update_power_state(codec, 0x18, parm);
  714. update_power_state(codec, 0x11, parm);
  715. /* PW6 (22h), SW2 (26h), AOW2 (24h) */
  716. if (is_8ch) {
  717. parm = AC_PWRST_D3;
  718. set_pin_power_state(codec, 0x22, &parm);
  719. if (smart51_enabled(codec))
  720. set_pin_power_state(codec, 0x1a, &parm);
  721. update_power_state(codec, 0x26, parm);
  722. update_power_state(codec, 0x24, parm);
  723. } else if (codec->vendor_id == 0x11064397) {
  724. /* PW7(23h), SW2(27h), AOW2(25h) */
  725. parm = AC_PWRST_D3;
  726. set_pin_power_state(codec, 0x23, &parm);
  727. if (smart51_enabled(codec))
  728. set_pin_power_state(codec, 0x1a, &parm);
  729. update_power_state(codec, 0x27, parm);
  730. update_power_state(codec, 0x25, parm);
  731. }
  732. /* PW 3/4/7 (1ch/1dh/23h) */
  733. parm = AC_PWRST_D3;
  734. /* force to D0 for internal Speaker */
  735. set_pin_power_state(codec, 0x1c, &parm);
  736. set_pin_power_state(codec, 0x1d, &parm);
  737. if (is_8ch)
  738. set_pin_power_state(codec, 0x23, &parm);
  739. /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
  740. update_power_state(codec, 0x16, imux_is_smixer ? AC_PWRST_D0 : parm);
  741. update_power_state(codec, 0x10, parm);
  742. if (is_8ch) {
  743. update_power_state(codec, 0x25, parm);
  744. update_power_state(codec, 0x27, parm);
  745. } else if (codec->vendor_id == 0x11064397 && spec->gen.indep_hp_enabled)
  746. update_power_state(codec, 0x25, parm);
  747. }
  748. static int patch_vt1708S(struct hda_codec *codec);
  749. static int patch_vt1708B(struct hda_codec *codec)
  750. {
  751. struct via_spec *spec;
  752. int err;
  753. if (get_codec_type(codec) == VT1708BCE)
  754. return patch_vt1708S(codec);
  755. /* create a codec specific record */
  756. spec = via_new_spec(codec);
  757. if (spec == NULL)
  758. return -ENOMEM;
  759. spec->gen.mixer_nid = 0x16;
  760. /* automatic parse from the BIOS config */
  761. err = via_parse_auto_config(codec);
  762. if (err < 0) {
  763. via_free(codec);
  764. return err;
  765. }
  766. codec->patch_ops = via_patch_ops;
  767. spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
  768. return 0;
  769. }
  770. /* Patch for VT1708S */
  771. static const struct hda_verb vt1708S_init_verbs[] = {
  772. /* Enable Mic Boost Volume backdoor */
  773. {0x1, 0xf98, 0x1},
  774. /* don't bybass mixer */
  775. {0x1, 0xf88, 0xc0},
  776. { }
  777. };
  778. static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
  779. int offset, int num_steps, int step_size)
  780. {
  781. snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
  782. (offset << AC_AMPCAP_OFFSET_SHIFT) |
  783. (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
  784. (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
  785. (0 << AC_AMPCAP_MUTE_SHIFT));
  786. }
  787. static int patch_vt1708S(struct hda_codec *codec)
  788. {
  789. struct via_spec *spec;
  790. int err;
  791. /* create a codec specific record */
  792. spec = via_new_spec(codec);
  793. if (spec == NULL)
  794. return -ENOMEM;
  795. spec->gen.mixer_nid = 0x16;
  796. override_mic_boost(codec, 0x1a, 0, 3, 40);
  797. override_mic_boost(codec, 0x1e, 0, 3, 40);
  798. /* correct names for VT1708BCE */
  799. if (get_codec_type(codec) == VT1708BCE) {
  800. kfree(codec->chip_name);
  801. codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
  802. snprintf(codec->bus->card->mixername,
  803. sizeof(codec->bus->card->mixername),
  804. "%s %s", codec->vendor_name, codec->chip_name);
  805. }
  806. /* correct names for VT1705 */
  807. if (codec->vendor_id == 0x11064397) {
  808. kfree(codec->chip_name);
  809. codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
  810. snprintf(codec->bus->card->mixername,
  811. sizeof(codec->bus->card->mixername),
  812. "%s %s", codec->vendor_name, codec->chip_name);
  813. }
  814. /* automatic parse from the BIOS config */
  815. err = via_parse_auto_config(codec);
  816. if (err < 0) {
  817. via_free(codec);
  818. return err;
  819. }
  820. spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
  821. codec->patch_ops = via_patch_ops;
  822. spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
  823. return 0;
  824. }
  825. /* Patch for VT1702 */
  826. static const struct hda_verb vt1702_init_verbs[] = {
  827. /* mixer enable */
  828. {0x1, 0xF88, 0x3},
  829. /* GPIO 0~2 */
  830. {0x1, 0xF82, 0x3F},
  831. { }
  832. };
  833. static void set_widgets_power_state_vt1702(struct hda_codec *codec)
  834. {
  835. int imux_is_smixer =
  836. snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
  837. unsigned int parm;
  838. /* inputs */
  839. /* PW 1/2/5 (14h/15h/18h) */
  840. parm = AC_PWRST_D3;
  841. set_pin_power_state(codec, 0x14, &parm);
  842. set_pin_power_state(codec, 0x15, &parm);
  843. set_pin_power_state(codec, 0x18, &parm);
  844. if (imux_is_smixer)
  845. parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
  846. /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
  847. update_power_state(codec, 0x13, parm);
  848. update_power_state(codec, 0x12, parm);
  849. update_power_state(codec, 0x1f, parm);
  850. update_power_state(codec, 0x20, parm);
  851. /* outputs */
  852. /* PW 3/4 (16h/17h) */
  853. parm = AC_PWRST_D3;
  854. set_pin_power_state(codec, 0x17, &parm);
  855. set_pin_power_state(codec, 0x16, &parm);
  856. /* MW0 (1ah), AOW 0/1 (10h/1dh) */
  857. update_power_state(codec, 0x1a, imux_is_smixer ? AC_PWRST_D0 : parm);
  858. update_power_state(codec, 0x10, parm);
  859. update_power_state(codec, 0x1d, parm);
  860. }
  861. static int patch_vt1702(struct hda_codec *codec)
  862. {
  863. struct via_spec *spec;
  864. int err;
  865. /* create a codec specific record */
  866. spec = via_new_spec(codec);
  867. if (spec == NULL)
  868. return -ENOMEM;
  869. spec->gen.mixer_nid = 0x1a;
  870. /* limit AA path volume to 0 dB */
  871. snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
  872. (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
  873. (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
  874. (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
  875. (1 << AC_AMPCAP_MUTE_SHIFT));
  876. /* automatic parse from the BIOS config */
  877. err = via_parse_auto_config(codec);
  878. if (err < 0) {
  879. via_free(codec);
  880. return err;
  881. }
  882. spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
  883. codec->patch_ops = via_patch_ops;
  884. spec->set_widgets_power_state = set_widgets_power_state_vt1702;
  885. return 0;
  886. }
  887. /* Patch for VT1718S */
  888. static const struct hda_verb vt1718S_init_verbs[] = {
  889. /* Enable MW0 adjust Gain 5 */
  890. {0x1, 0xfb2, 0x10},
  891. /* Enable Boost Volume backdoor */
  892. {0x1, 0xf88, 0x8},
  893. { }
  894. };
  895. static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
  896. {
  897. struct via_spec *spec = codec->spec;
  898. int imux_is_smixer;
  899. unsigned int parm, parm2;
  900. /* MUX6 (1eh) = stereo mixer */
  901. imux_is_smixer =
  902. snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
  903. /* inputs */
  904. /* PW 5/6/7 (29h/2ah/2bh) */
  905. parm = AC_PWRST_D3;
  906. set_pin_power_state(codec, 0x29, &parm);
  907. set_pin_power_state(codec, 0x2a, &parm);
  908. set_pin_power_state(codec, 0x2b, &parm);
  909. if (imux_is_smixer)
  910. parm = AC_PWRST_D0;
  911. /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
  912. update_power_state(codec, 0x1e, parm);
  913. update_power_state(codec, 0x1f, parm);
  914. update_power_state(codec, 0x10, parm);
  915. update_power_state(codec, 0x11, parm);
  916. /* outputs */
  917. /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
  918. parm = AC_PWRST_D3;
  919. set_pin_power_state(codec, 0x27, &parm);
  920. update_power_state(codec, 0x1a, parm);
  921. parm2 = parm; /* for pin 0x0b */
  922. /* PW2 (26h), AOW2 (ah) */
  923. parm = AC_PWRST_D3;
  924. set_pin_power_state(codec, 0x26, &parm);
  925. if (smart51_enabled(codec))
  926. set_pin_power_state(codec, 0x2b, &parm);
  927. update_power_state(codec, 0xa, parm);
  928. /* PW0 (24h), AOW0 (8h) */
  929. parm = AC_PWRST_D3;
  930. set_pin_power_state(codec, 0x24, &parm);
  931. if (!spec->gen.indep_hp_enabled) /* check for redirected HP */
  932. set_pin_power_state(codec, 0x28, &parm);
  933. update_power_state(codec, 0x8, parm);
  934. if (!spec->gen.indep_hp_enabled && parm2 != AC_PWRST_D3)
  935. parm = parm2;
  936. update_power_state(codec, 0xb, parm);
  937. /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
  938. update_power_state(codec, 0x21, imux_is_smixer ? AC_PWRST_D0 : parm);
  939. /* PW1 (25h), AOW1 (9h) */
  940. parm = AC_PWRST_D3;
  941. set_pin_power_state(codec, 0x25, &parm);
  942. if (smart51_enabled(codec))
  943. set_pin_power_state(codec, 0x2a, &parm);
  944. update_power_state(codec, 0x9, parm);
  945. if (spec->gen.indep_hp_enabled) {
  946. /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
  947. parm = AC_PWRST_D3;
  948. set_pin_power_state(codec, 0x28, &parm);
  949. update_power_state(codec, 0x1b, parm);
  950. update_power_state(codec, 0x34, parm);
  951. update_power_state(codec, 0xc, parm);
  952. }
  953. }
  954. /* Add a connection to the primary DAC from AA-mixer for some codecs
  955. * This isn't listed from the raw info, but the chip has a secret connection.
  956. */
  957. static int add_secret_dac_path(struct hda_codec *codec)
  958. {
  959. struct via_spec *spec = codec->spec;
  960. int i, nums;
  961. hda_nid_t conn[8];
  962. hda_nid_t nid;
  963. if (!spec->gen.mixer_nid)
  964. return 0;
  965. nums = snd_hda_get_connections(codec, spec->gen.mixer_nid, conn,
  966. ARRAY_SIZE(conn) - 1);
  967. for (i = 0; i < nums; i++) {
  968. if (get_wcaps_type(get_wcaps(codec, conn[i])) == AC_WID_AUD_OUT)
  969. return 0;
  970. }
  971. /* find the primary DAC and add to the connection list */
  972. nid = codec->start_nid;
  973. for (i = 0; i < codec->num_nodes; i++, nid++) {
  974. unsigned int caps = get_wcaps(codec, nid);
  975. if (get_wcaps_type(caps) == AC_WID_AUD_OUT &&
  976. !(caps & AC_WCAP_DIGITAL)) {
  977. conn[nums++] = nid;
  978. return snd_hda_override_conn_list(codec,
  979. spec->gen.mixer_nid,
  980. nums, conn);
  981. }
  982. }
  983. return 0;
  984. }
  985. static int patch_vt1718S(struct hda_codec *codec)
  986. {
  987. struct via_spec *spec;
  988. int err;
  989. /* create a codec specific record */
  990. spec = via_new_spec(codec);
  991. if (spec == NULL)
  992. return -ENOMEM;
  993. spec->gen.mixer_nid = 0x21;
  994. override_mic_boost(codec, 0x2b, 0, 3, 40);
  995. override_mic_boost(codec, 0x29, 0, 3, 40);
  996. add_secret_dac_path(codec);
  997. /* automatic parse from the BIOS config */
  998. err = via_parse_auto_config(codec);
  999. if (err < 0) {
  1000. via_free(codec);
  1001. return err;
  1002. }
  1003. spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
  1004. codec->patch_ops = via_patch_ops;
  1005. spec->set_widgets_power_state = set_widgets_power_state_vt1718S;
  1006. return 0;
  1007. }
  1008. /* Patch for VT1716S */
  1009. static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
  1010. struct snd_ctl_elem_info *uinfo)
  1011. {
  1012. uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
  1013. uinfo->count = 1;
  1014. uinfo->value.integer.min = 0;
  1015. uinfo->value.integer.max = 1;
  1016. return 0;
  1017. }
  1018. static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
  1019. struct snd_ctl_elem_value *ucontrol)
  1020. {
  1021. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1022. int index = 0;
  1023. index = snd_hda_codec_read(codec, 0x26, 0,
  1024. AC_VERB_GET_CONNECT_SEL, 0);
  1025. if (index != -1)
  1026. *ucontrol->value.integer.value = index;
  1027. return 0;
  1028. }
  1029. static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
  1030. struct snd_ctl_elem_value *ucontrol)
  1031. {
  1032. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1033. struct via_spec *spec = codec->spec;
  1034. int index = *ucontrol->value.integer.value;
  1035. snd_hda_codec_write(codec, 0x26, 0,
  1036. AC_VERB_SET_CONNECT_SEL, index);
  1037. spec->dmic_enabled = index;
  1038. set_widgets_power_state(codec);
  1039. return 1;
  1040. }
  1041. static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
  1042. HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
  1043. {
  1044. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1045. .name = "Digital Mic Capture Switch",
  1046. .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
  1047. .count = 1,
  1048. .info = vt1716s_dmic_info,
  1049. .get = vt1716s_dmic_get,
  1050. .put = vt1716s_dmic_put,
  1051. },
  1052. {} /* end */
  1053. };
  1054. /* mono-out mixer elements */
  1055. static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
  1056. HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
  1057. { } /* end */
  1058. };
  1059. static const struct hda_verb vt1716S_init_verbs[] = {
  1060. /* Enable Boost Volume backdoor */
  1061. {0x1, 0xf8a, 0x80},
  1062. /* don't bybass mixer */
  1063. {0x1, 0xf88, 0xc0},
  1064. /* Enable mono output */
  1065. {0x1, 0xf90, 0x08},
  1066. { }
  1067. };
  1068. static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
  1069. {
  1070. struct via_spec *spec = codec->spec;
  1071. int imux_is_smixer;
  1072. unsigned int parm;
  1073. unsigned int mono_out, present;
  1074. /* SW0 (17h) = stereo mixer */
  1075. imux_is_smixer =
  1076. (snd_hda_codec_read(codec, 0x17, 0,
  1077. AC_VERB_GET_CONNECT_SEL, 0x00) == 5);
  1078. /* inputs */
  1079. /* PW 1/2/5 (1ah/1bh/1eh) */
  1080. parm = AC_PWRST_D3;
  1081. set_pin_power_state(codec, 0x1a, &parm);
  1082. set_pin_power_state(codec, 0x1b, &parm);
  1083. set_pin_power_state(codec, 0x1e, &parm);
  1084. if (imux_is_smixer)
  1085. parm = AC_PWRST_D0;
  1086. /* SW0 (17h), AIW0(13h) */
  1087. update_power_state(codec, 0x17, parm);
  1088. update_power_state(codec, 0x13, parm);
  1089. parm = AC_PWRST_D3;
  1090. set_pin_power_state(codec, 0x1e, &parm);
  1091. /* PW11 (22h) */
  1092. if (spec->dmic_enabled)
  1093. set_pin_power_state(codec, 0x22, &parm);
  1094. else
  1095. update_power_state(codec, 0x22, AC_PWRST_D3);
  1096. /* SW2(26h), AIW1(14h) */
  1097. update_power_state(codec, 0x26, parm);
  1098. update_power_state(codec, 0x14, parm);
  1099. /* outputs */
  1100. /* PW0 (19h), SW1 (18h), AOW1 (11h) */
  1101. parm = AC_PWRST_D3;
  1102. set_pin_power_state(codec, 0x19, &parm);
  1103. /* Smart 5.1 PW2(1bh) */
  1104. if (smart51_enabled(codec))
  1105. set_pin_power_state(codec, 0x1b, &parm);
  1106. update_power_state(codec, 0x18, parm);
  1107. update_power_state(codec, 0x11, parm);
  1108. /* PW7 (23h), SW3 (27h), AOW3 (25h) */
  1109. parm = AC_PWRST_D3;
  1110. set_pin_power_state(codec, 0x23, &parm);
  1111. /* Smart 5.1 PW1(1ah) */
  1112. if (smart51_enabled(codec))
  1113. set_pin_power_state(codec, 0x1a, &parm);
  1114. update_power_state(codec, 0x27, parm);
  1115. /* Smart 5.1 PW5(1eh) */
  1116. if (smart51_enabled(codec))
  1117. set_pin_power_state(codec, 0x1e, &parm);
  1118. update_power_state(codec, 0x25, parm);
  1119. /* Mono out */
  1120. /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
  1121. present = snd_hda_jack_detect(codec, 0x1c);
  1122. if (present)
  1123. mono_out = 0;
  1124. else {
  1125. present = snd_hda_jack_detect(codec, 0x1d);
  1126. if (!spec->gen.indep_hp_enabled && present)
  1127. mono_out = 0;
  1128. else
  1129. mono_out = 1;
  1130. }
  1131. parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
  1132. update_power_state(codec, 0x28, parm);
  1133. update_power_state(codec, 0x29, parm);
  1134. update_power_state(codec, 0x2a, parm);
  1135. /* PW 3/4 (1ch/1dh) */
  1136. parm = AC_PWRST_D3;
  1137. set_pin_power_state(codec, 0x1c, &parm);
  1138. set_pin_power_state(codec, 0x1d, &parm);
  1139. /* HP Independent Mode, power on AOW3 */
  1140. if (spec->gen.indep_hp_enabled)
  1141. update_power_state(codec, 0x25, parm);
  1142. /* force to D0 for internal Speaker */
  1143. /* MW0 (16h), AOW0 (10h) */
  1144. update_power_state(codec, 0x16, imux_is_smixer ? AC_PWRST_D0 : parm);
  1145. update_power_state(codec, 0x10, mono_out ? AC_PWRST_D0 : parm);
  1146. }
  1147. static int patch_vt1716S(struct hda_codec *codec)
  1148. {
  1149. struct via_spec *spec;
  1150. int err;
  1151. /* create a codec specific record */
  1152. spec = via_new_spec(codec);
  1153. if (spec == NULL)
  1154. return -ENOMEM;
  1155. spec->gen.mixer_nid = 0x16;
  1156. override_mic_boost(codec, 0x1a, 0, 3, 40);
  1157. override_mic_boost(codec, 0x1e, 0, 3, 40);
  1158. /* automatic parse from the BIOS config */
  1159. err = via_parse_auto_config(codec);
  1160. if (err < 0) {
  1161. via_free(codec);
  1162. return err;
  1163. }
  1164. spec->init_verbs[spec->num_iverbs++] = vt1716S_init_verbs;
  1165. spec->mixers[spec->num_mixers++] = vt1716s_dmic_mixer;
  1166. spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
  1167. codec->patch_ops = via_patch_ops;
  1168. spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
  1169. return 0;
  1170. }
  1171. /* for vt2002P */
  1172. static const struct hda_verb vt2002P_init_verbs[] = {
  1173. /* Class-D speaker related verbs */
  1174. {0x1, 0xfe0, 0x4},
  1175. {0x1, 0xfe9, 0x80},
  1176. {0x1, 0xfe2, 0x22},
  1177. /* Enable Boost Volume backdoor */
  1178. {0x1, 0xfb9, 0x24},
  1179. /* Enable AOW0 to MW9 */
  1180. {0x1, 0xfb8, 0x88},
  1181. { }
  1182. };
  1183. static const struct hda_verb vt1802_init_verbs[] = {
  1184. /* Enable Boost Volume backdoor */
  1185. {0x1, 0xfb9, 0x24},
  1186. /* Enable AOW0 to MW9 */
  1187. {0x1, 0xfb8, 0x88},
  1188. { }
  1189. };
  1190. static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
  1191. {
  1192. struct via_spec *spec = codec->spec;
  1193. int imux_is_smixer;
  1194. unsigned int parm;
  1195. unsigned int present;
  1196. /* MUX9 (1eh) = stereo mixer */
  1197. imux_is_smixer =
  1198. snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
  1199. /* inputs */
  1200. /* PW 5/6/7 (29h/2ah/2bh) */
  1201. parm = AC_PWRST_D3;
  1202. set_pin_power_state(codec, 0x29, &parm);
  1203. set_pin_power_state(codec, 0x2a, &parm);
  1204. set_pin_power_state(codec, 0x2b, &parm);
  1205. parm = AC_PWRST_D0;
  1206. /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
  1207. update_power_state(codec, 0x1e, parm);
  1208. update_power_state(codec, 0x1f, parm);
  1209. update_power_state(codec, 0x10, parm);
  1210. update_power_state(codec, 0x11, parm);
  1211. /* outputs */
  1212. /* AOW0 (8h)*/
  1213. update_power_state(codec, 0x8, parm);
  1214. if (spec->codec_type == VT1802) {
  1215. /* PW4 (28h), MW4 (18h), MUX4(38h) */
  1216. parm = AC_PWRST_D3;
  1217. set_pin_power_state(codec, 0x28, &parm);
  1218. update_power_state(codec, 0x18, parm);
  1219. update_power_state(codec, 0x38, parm);
  1220. } else {
  1221. /* PW4 (26h), MW4 (1ch), MUX4(37h) */
  1222. parm = AC_PWRST_D3;
  1223. set_pin_power_state(codec, 0x26, &parm);
  1224. update_power_state(codec, 0x1c, parm);
  1225. update_power_state(codec, 0x37, parm);
  1226. }
  1227. if (spec->codec_type == VT1802) {
  1228. /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
  1229. parm = AC_PWRST_D3;
  1230. set_pin_power_state(codec, 0x25, &parm);
  1231. update_power_state(codec, 0x15, parm);
  1232. update_power_state(codec, 0x35, parm);
  1233. } else {
  1234. /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
  1235. parm = AC_PWRST_D3;
  1236. set_pin_power_state(codec, 0x25, &parm);
  1237. update_power_state(codec, 0x19, parm);
  1238. update_power_state(codec, 0x35, parm);
  1239. }
  1240. if (spec->gen.indep_hp_enabled)
  1241. update_power_state(codec, 0x9, AC_PWRST_D0);
  1242. /* Class-D */
  1243. /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
  1244. present = snd_hda_jack_detect(codec, 0x25);
  1245. parm = AC_PWRST_D3;
  1246. set_pin_power_state(codec, 0x24, &parm);
  1247. parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
  1248. if (spec->codec_type == VT1802)
  1249. update_power_state(codec, 0x14, parm);
  1250. else
  1251. update_power_state(codec, 0x18, parm);
  1252. update_power_state(codec, 0x34, parm);
  1253. /* Mono Out */
  1254. present = snd_hda_jack_detect(codec, 0x26);
  1255. parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
  1256. if (spec->codec_type == VT1802) {
  1257. /* PW15 (33h), MW8(1ch), MUX8(3ch) */
  1258. update_power_state(codec, 0x33, parm);
  1259. update_power_state(codec, 0x1c, parm);
  1260. update_power_state(codec, 0x3c, parm);
  1261. } else {
  1262. /* PW15 (31h), MW8(17h), MUX8(3bh) */
  1263. update_power_state(codec, 0x31, parm);
  1264. update_power_state(codec, 0x17, parm);
  1265. update_power_state(codec, 0x3b, parm);
  1266. }
  1267. /* MW9 (21h) */
  1268. if (imux_is_smixer || !is_aa_path_mute(codec))
  1269. update_power_state(codec, 0x21, AC_PWRST_D0);
  1270. else
  1271. update_power_state(codec, 0x21, AC_PWRST_D3);
  1272. }
  1273. /*
  1274. * pin fix-up
  1275. */
  1276. enum {
  1277. VIA_FIXUP_INTMIC_BOOST,
  1278. VIA_FIXUP_ASUS_G75,
  1279. };
  1280. static void via_fixup_intmic_boost(struct hda_codec *codec,
  1281. const struct hda_fixup *fix, int action)
  1282. {
  1283. if (action == HDA_FIXUP_ACT_PRE_PROBE)
  1284. override_mic_boost(codec, 0x30, 0, 2, 40);
  1285. }
  1286. static const struct hda_fixup via_fixups[] = {
  1287. [VIA_FIXUP_INTMIC_BOOST] = {
  1288. .type = HDA_FIXUP_FUNC,
  1289. .v.func = via_fixup_intmic_boost,
  1290. },
  1291. [VIA_FIXUP_ASUS_G75] = {
  1292. .type = HDA_FIXUP_PINS,
  1293. .v.pins = (const struct hda_pintbl[]) {
  1294. /* set 0x24 and 0x33 as speakers */
  1295. { 0x24, 0x991301f0 },
  1296. { 0x33, 0x991301f1 }, /* subwoofer */
  1297. { }
  1298. }
  1299. },
  1300. };
  1301. static const struct snd_pci_quirk vt2002p_fixups[] = {
  1302. SND_PCI_QUIRK(0x1043, 0x1487, "Asus G75", VIA_FIXUP_ASUS_G75),
  1303. SND_PCI_QUIRK(0x1043, 0x8532, "Asus X202E", VIA_FIXUP_INTMIC_BOOST),
  1304. {}
  1305. };
  1306. /* NIDs 0x24 and 0x33 on VT1802 have connections to non-existing NID 0x3e
  1307. * Replace this with mixer NID 0x1c
  1308. */
  1309. static void fix_vt1802_connections(struct hda_codec *codec)
  1310. {
  1311. static hda_nid_t conn_24[] = { 0x14, 0x1c };
  1312. static hda_nid_t conn_33[] = { 0x1c };
  1313. snd_hda_override_conn_list(codec, 0x24, ARRAY_SIZE(conn_24), conn_24);
  1314. snd_hda_override_conn_list(codec, 0x33, ARRAY_SIZE(conn_33), conn_33);
  1315. }
  1316. /* patch for vt2002P */
  1317. static int patch_vt2002P(struct hda_codec *codec)
  1318. {
  1319. struct via_spec *spec;
  1320. int err;
  1321. /* create a codec specific record */
  1322. spec = via_new_spec(codec);
  1323. if (spec == NULL)
  1324. return -ENOMEM;
  1325. spec->gen.mixer_nid = 0x21;
  1326. override_mic_boost(codec, 0x2b, 0, 3, 40);
  1327. override_mic_boost(codec, 0x29, 0, 3, 40);
  1328. if (spec->codec_type == VT1802)
  1329. fix_vt1802_connections(codec);
  1330. add_secret_dac_path(codec);
  1331. snd_hda_pick_fixup(codec, NULL, vt2002p_fixups, via_fixups);
  1332. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  1333. /* automatic parse from the BIOS config */
  1334. err = via_parse_auto_config(codec);
  1335. if (err < 0) {
  1336. via_free(codec);
  1337. return err;
  1338. }
  1339. if (spec->codec_type == VT1802)
  1340. spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
  1341. else
  1342. spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
  1343. codec->patch_ops = via_patch_ops;
  1344. spec->set_widgets_power_state = set_widgets_power_state_vt2002P;
  1345. return 0;
  1346. }
  1347. /* for vt1812 */
  1348. static const struct hda_verb vt1812_init_verbs[] = {
  1349. /* Enable Boost Volume backdoor */
  1350. {0x1, 0xfb9, 0x24},
  1351. /* Enable AOW0 to MW9 */
  1352. {0x1, 0xfb8, 0xa8},
  1353. { }
  1354. };
  1355. static void set_widgets_power_state_vt1812(struct hda_codec *codec)
  1356. {
  1357. struct via_spec *spec = codec->spec;
  1358. unsigned int parm;
  1359. unsigned int present;
  1360. /* inputs */
  1361. /* PW 5/6/7 (29h/2ah/2bh) */
  1362. parm = AC_PWRST_D3;
  1363. set_pin_power_state(codec, 0x29, &parm);
  1364. set_pin_power_state(codec, 0x2a, &parm);
  1365. set_pin_power_state(codec, 0x2b, &parm);
  1366. parm = AC_PWRST_D0;
  1367. /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
  1368. update_power_state(codec, 0x1e, parm);
  1369. update_power_state(codec, 0x1f, parm);
  1370. update_power_state(codec, 0x10, parm);
  1371. update_power_state(codec, 0x11, parm);
  1372. /* outputs */
  1373. /* AOW0 (8h)*/
  1374. update_power_state(codec, 0x8, AC_PWRST_D0);
  1375. /* PW4 (28h), MW4 (18h), MUX4(38h) */
  1376. parm = AC_PWRST_D3;
  1377. set_pin_power_state(codec, 0x28, &parm);
  1378. update_power_state(codec, 0x18, parm);
  1379. update_power_state(codec, 0x38, parm);
  1380. /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
  1381. parm = AC_PWRST_D3;
  1382. set_pin_power_state(codec, 0x25, &parm);
  1383. update_power_state(codec, 0x15, parm);
  1384. update_power_state(codec, 0x35, parm);
  1385. if (spec->gen.indep_hp_enabled)
  1386. update_power_state(codec, 0x9, AC_PWRST_D0);
  1387. /* Internal Speaker */
  1388. /* PW0 (24h), MW0(14h), MUX0(34h) */
  1389. present = snd_hda_jack_detect(codec, 0x25);
  1390. parm = AC_PWRST_D3;
  1391. set_pin_power_state(codec, 0x24, &parm);
  1392. if (present) {
  1393. update_power_state(codec, 0x14, AC_PWRST_D3);
  1394. update_power_state(codec, 0x34, AC_PWRST_D3);
  1395. } else {
  1396. update_power_state(codec, 0x14, AC_PWRST_D0);
  1397. update_power_state(codec, 0x34, AC_PWRST_D0);
  1398. }
  1399. /* Mono Out */
  1400. /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
  1401. present = snd_hda_jack_detect(codec, 0x28);
  1402. parm = AC_PWRST_D3;
  1403. set_pin_power_state(codec, 0x31, &parm);
  1404. if (present) {
  1405. update_power_state(codec, 0x1c, AC_PWRST_D3);
  1406. update_power_state(codec, 0x3c, AC_PWRST_D3);
  1407. update_power_state(codec, 0x3e, AC_PWRST_D3);
  1408. } else {
  1409. update_power_state(codec, 0x1c, AC_PWRST_D0);
  1410. update_power_state(codec, 0x3c, AC_PWRST_D0);
  1411. update_power_state(codec, 0x3e, AC_PWRST_D0);
  1412. }
  1413. /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
  1414. parm = AC_PWRST_D3;
  1415. set_pin_power_state(codec, 0x33, &parm);
  1416. update_power_state(codec, 0x1d, parm);
  1417. update_power_state(codec, 0x3d, parm);
  1418. }
  1419. /* patch for vt1812 */
  1420. static int patch_vt1812(struct hda_codec *codec)
  1421. {
  1422. struct via_spec *spec;
  1423. int err;
  1424. /* create a codec specific record */
  1425. spec = via_new_spec(codec);
  1426. if (spec == NULL)
  1427. return -ENOMEM;
  1428. spec->gen.mixer_nid = 0x21;
  1429. override_mic_boost(codec, 0x2b, 0, 3, 40);
  1430. override_mic_boost(codec, 0x29, 0, 3, 40);
  1431. add_secret_dac_path(codec);
  1432. /* automatic parse from the BIOS config */
  1433. err = via_parse_auto_config(codec);
  1434. if (err < 0) {
  1435. via_free(codec);
  1436. return err;
  1437. }
  1438. spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs;
  1439. codec->patch_ops = via_patch_ops;
  1440. spec->set_widgets_power_state = set_widgets_power_state_vt1812;
  1441. return 0;
  1442. }
  1443. /* patch for vt3476 */
  1444. static const struct hda_verb vt3476_init_verbs[] = {
  1445. /* Enable DMic 8/16/32K */
  1446. {0x1, 0xF7B, 0x30},
  1447. /* Enable Boost Volume backdoor */
  1448. {0x1, 0xFB9, 0x20},
  1449. /* Enable AOW-MW9 path */
  1450. {0x1, 0xFB8, 0x10},
  1451. { }
  1452. };
  1453. static void set_widgets_power_state_vt3476(struct hda_codec *codec)
  1454. {
  1455. struct via_spec *spec = codec->spec;
  1456. int imux_is_smixer;
  1457. unsigned int parm, parm2;
  1458. /* MUX10 (1eh) = stereo mixer */
  1459. imux_is_smixer =
  1460. snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 4;
  1461. /* inputs */
  1462. /* PW 5/6/7 (29h/2ah/2bh) */
  1463. parm = AC_PWRST_D3;
  1464. set_pin_power_state(codec, 0x29, &parm);
  1465. set_pin_power_state(codec, 0x2a, &parm);
  1466. set_pin_power_state(codec, 0x2b, &parm);
  1467. if (imux_is_smixer)
  1468. parm = AC_PWRST_D0;
  1469. /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
  1470. update_power_state(codec, 0x1e, parm);
  1471. update_power_state(codec, 0x1f, parm);
  1472. update_power_state(codec, 0x10, parm);
  1473. update_power_state(codec, 0x11, parm);
  1474. /* outputs */
  1475. /* PW3 (27h), MW3(37h), AOW3 (bh) */
  1476. if (spec->codec_type == VT1705CF) {
  1477. parm = AC_PWRST_D3;
  1478. update_power_state(codec, 0x27, parm);
  1479. update_power_state(codec, 0x37, parm);
  1480. } else {
  1481. parm = AC_PWRST_D3;
  1482. set_pin_power_state(codec, 0x27, &parm);
  1483. update_power_state(codec, 0x37, parm);
  1484. }
  1485. /* PW2 (26h), MW2(36h), AOW2 (ah) */
  1486. parm = AC_PWRST_D3;
  1487. set_pin_power_state(codec, 0x26, &parm);
  1488. update_power_state(codec, 0x36, parm);
  1489. if (smart51_enabled(codec)) {
  1490. /* PW7(2bh), MW7(3bh), MUX7(1Bh) */
  1491. set_pin_power_state(codec, 0x2b, &parm);
  1492. update_power_state(codec, 0x3b, parm);
  1493. update_power_state(codec, 0x1b, parm);
  1494. }
  1495. update_conv_power_state(codec, 0xa, parm, 2);
  1496. /* PW1 (25h), MW1(35h), AOW1 (9h) */
  1497. parm = AC_PWRST_D3;
  1498. set_pin_power_state(codec, 0x25, &parm);
  1499. update_power_state(codec, 0x35, parm);
  1500. if (smart51_enabled(codec)) {
  1501. /* PW6(2ah), MW6(3ah), MUX6(1ah) */
  1502. set_pin_power_state(codec, 0x2a, &parm);
  1503. update_power_state(codec, 0x3a, parm);
  1504. update_power_state(codec, 0x1a, parm);
  1505. }
  1506. update_conv_power_state(codec, 0x9, parm, 1);
  1507. /* PW4 (28h), MW4 (38h), MUX4(18h), AOW3(bh)/AOW0(8h) */
  1508. parm = AC_PWRST_D3;
  1509. set_pin_power_state(codec, 0x28, &parm);
  1510. update_power_state(codec, 0x38, parm);
  1511. update_power_state(codec, 0x18, parm);
  1512. if (spec->gen.indep_hp_enabled)
  1513. update_conv_power_state(codec, 0xb, parm, 3);
  1514. parm2 = parm; /* for pin 0x0b */
  1515. /* PW0 (24h), MW0(34h), MW9(3fh), AOW0 (8h) */
  1516. parm = AC_PWRST_D3;
  1517. set_pin_power_state(codec, 0x24, &parm);
  1518. update_power_state(codec, 0x34, parm);
  1519. if (!spec->gen.indep_hp_enabled && parm2 != AC_PWRST_D3)
  1520. parm = parm2;
  1521. update_conv_power_state(codec, 0x8, parm, 0);
  1522. /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
  1523. update_power_state(codec, 0x3f, imux_is_smixer ? AC_PWRST_D0 : parm);
  1524. }
  1525. static int patch_vt3476(struct hda_codec *codec)
  1526. {
  1527. struct via_spec *spec;
  1528. int err;
  1529. /* create a codec specific record */
  1530. spec = via_new_spec(codec);
  1531. if (spec == NULL)
  1532. return -ENOMEM;
  1533. spec->gen.mixer_nid = 0x3f;
  1534. add_secret_dac_path(codec);
  1535. /* automatic parse from the BIOS config */
  1536. err = via_parse_auto_config(codec);
  1537. if (err < 0) {
  1538. via_free(codec);
  1539. return err;
  1540. }
  1541. spec->init_verbs[spec->num_iverbs++] = vt3476_init_verbs;
  1542. codec->patch_ops = via_patch_ops;
  1543. spec->set_widgets_power_state = set_widgets_power_state_vt3476;
  1544. return 0;
  1545. }
  1546. /*
  1547. * patch entries
  1548. */
  1549. static const struct hda_codec_preset snd_hda_preset_via[] = {
  1550. { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
  1551. { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
  1552. { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
  1553. { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
  1554. { .id = 0x1106e710, .name = "VT1709 10-Ch",
  1555. .patch = patch_vt1709},
  1556. { .id = 0x1106e711, .name = "VT1709 10-Ch",
  1557. .patch = patch_vt1709},
  1558. { .id = 0x1106e712, .name = "VT1709 10-Ch",
  1559. .patch = patch_vt1709},
  1560. { .id = 0x1106e713, .name = "VT1709 10-Ch",
  1561. .patch = patch_vt1709},
  1562. { .id = 0x1106e714, .name = "VT1709 6-Ch",
  1563. .patch = patch_vt1709},
  1564. { .id = 0x1106e715, .name = "VT1709 6-Ch",
  1565. .patch = patch_vt1709},
  1566. { .id = 0x1106e716, .name = "VT1709 6-Ch",
  1567. .patch = patch_vt1709},
  1568. { .id = 0x1106e717, .name = "VT1709 6-Ch",
  1569. .patch = patch_vt1709},
  1570. { .id = 0x1106e720, .name = "VT1708B 8-Ch",
  1571. .patch = patch_vt1708B},
  1572. { .id = 0x1106e721, .name = "VT1708B 8-Ch",
  1573. .patch = patch_vt1708B},
  1574. { .id = 0x1106e722, .name = "VT1708B 8-Ch",
  1575. .patch = patch_vt1708B},
  1576. { .id = 0x1106e723, .name = "VT1708B 8-Ch",
  1577. .patch = patch_vt1708B},
  1578. { .id = 0x1106e724, .name = "VT1708B 4-Ch",
  1579. .patch = patch_vt1708B},
  1580. { .id = 0x1106e725, .name = "VT1708B 4-Ch",
  1581. .patch = patch_vt1708B},
  1582. { .id = 0x1106e726, .name = "VT1708B 4-Ch",
  1583. .patch = patch_vt1708B},
  1584. { .id = 0x1106e727, .name = "VT1708B 4-Ch",
  1585. .patch = patch_vt1708B},
  1586. { .id = 0x11060397, .name = "VT1708S",
  1587. .patch = patch_vt1708S},
  1588. { .id = 0x11061397, .name = "VT1708S",
  1589. .patch = patch_vt1708S},
  1590. { .id = 0x11062397, .name = "VT1708S",
  1591. .patch = patch_vt1708S},
  1592. { .id = 0x11063397, .name = "VT1708S",
  1593. .patch = patch_vt1708S},
  1594. { .id = 0x11064397, .name = "VT1705",
  1595. .patch = patch_vt1708S},
  1596. { .id = 0x11065397, .name = "VT1708S",
  1597. .patch = patch_vt1708S},
  1598. { .id = 0x11066397, .name = "VT1708S",
  1599. .patch = patch_vt1708S},
  1600. { .id = 0x11067397, .name = "VT1708S",
  1601. .patch = patch_vt1708S},
  1602. { .id = 0x11060398, .name = "VT1702",
  1603. .patch = patch_vt1702},
  1604. { .id = 0x11061398, .name = "VT1702",
  1605. .patch = patch_vt1702},
  1606. { .id = 0x11062398, .name = "VT1702",
  1607. .patch = patch_vt1702},
  1608. { .id = 0x11063398, .name = "VT1702",
  1609. .patch = patch_vt1702},
  1610. { .id = 0x11064398, .name = "VT1702",
  1611. .patch = patch_vt1702},
  1612. { .id = 0x11065398, .name = "VT1702",
  1613. .patch = patch_vt1702},
  1614. { .id = 0x11066398, .name = "VT1702",
  1615. .patch = patch_vt1702},
  1616. { .id = 0x11067398, .name = "VT1702",
  1617. .patch = patch_vt1702},
  1618. { .id = 0x11060428, .name = "VT1718S",
  1619. .patch = patch_vt1718S},
  1620. { .id = 0x11064428, .name = "VT1718S",
  1621. .patch = patch_vt1718S},
  1622. { .id = 0x11060441, .name = "VT2020",
  1623. .patch = patch_vt1718S},
  1624. { .id = 0x11064441, .name = "VT1828S",
  1625. .patch = patch_vt1718S},
  1626. { .id = 0x11060433, .name = "VT1716S",
  1627. .patch = patch_vt1716S},
  1628. { .id = 0x1106a721, .name = "VT1716S",
  1629. .patch = patch_vt1716S},
  1630. { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
  1631. { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
  1632. { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
  1633. { .id = 0x11060440, .name = "VT1818S",
  1634. .patch = patch_vt1708S},
  1635. { .id = 0x11060446, .name = "VT1802",
  1636. .patch = patch_vt2002P},
  1637. { .id = 0x11068446, .name = "VT1802",
  1638. .patch = patch_vt2002P},
  1639. { .id = 0x11064760, .name = "VT1705CF",
  1640. .patch = patch_vt3476},
  1641. { .id = 0x11064761, .name = "VT1708SCE",
  1642. .patch = patch_vt3476},
  1643. { .id = 0x11064762, .name = "VT1808",
  1644. .patch = patch_vt3476},
  1645. {} /* terminator */
  1646. };
  1647. MODULE_ALIAS("snd-hda-codec-id:1106*");
  1648. static struct hda_codec_preset_list via_list = {
  1649. .preset = snd_hda_preset_via,
  1650. .owner = THIS_MODULE,
  1651. };
  1652. MODULE_LICENSE("GPL");
  1653. MODULE_DESCRIPTION("VIA HD-audio codec");
  1654. static int __init patch_via_init(void)
  1655. {
  1656. return snd_hda_add_codec_preset(&via_list);
  1657. }
  1658. static void __exit patch_via_exit(void)
  1659. {
  1660. snd_hda_delete_codec_preset(&via_list);
  1661. }
  1662. module_init(patch_via_init)
  1663. module_exit(patch_via_exit)