patch_analog.c 85 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709
  1. /*
  2. * HD audio interface patch for AD1981HD, AD1983, AD1986A, AD1988
  3. *
  4. * Copyright (c) 2005 Takashi Iwai <tiwai@suse.de>
  5. *
  6. * This driver is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This driver is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. */
  20. #include <sound/driver.h>
  21. #include <linux/init.h>
  22. #include <linux/delay.h>
  23. #include <linux/slab.h>
  24. #include <linux/pci.h>
  25. #include <linux/mutex.h>
  26. #include <sound/core.h>
  27. #include "hda_codec.h"
  28. #include "hda_local.h"
  29. struct ad198x_spec {
  30. struct snd_kcontrol_new *mixers[5];
  31. int num_mixers;
  32. const struct hda_verb *init_verbs[5]; /* initialization verbs
  33. * don't forget NULL termination!
  34. */
  35. unsigned int num_init_verbs;
  36. /* playback */
  37. struct hda_multi_out multiout; /* playback set-up
  38. * max_channels, dacs must be set
  39. * dig_out_nid and hp_nid are optional
  40. */
  41. unsigned int cur_eapd;
  42. unsigned int need_dac_fix;
  43. /* capture */
  44. unsigned int num_adc_nids;
  45. hda_nid_t *adc_nids;
  46. hda_nid_t dig_in_nid; /* digital-in NID; optional */
  47. /* capture source */
  48. const struct hda_input_mux *input_mux;
  49. hda_nid_t *capsrc_nids;
  50. unsigned int cur_mux[3];
  51. /* channel model */
  52. const struct hda_channel_mode *channel_mode;
  53. int num_channel_mode;
  54. /* PCM information */
  55. struct hda_pcm pcm_rec[2]; /* used in alc_build_pcms() */
  56. struct mutex amp_mutex; /* PCM volume/mute control mutex */
  57. unsigned int spdif_route;
  58. /* dynamic controls, init_verbs and input_mux */
  59. struct auto_pin_cfg autocfg;
  60. unsigned int num_kctl_alloc, num_kctl_used;
  61. struct snd_kcontrol_new *kctl_alloc;
  62. struct hda_input_mux private_imux;
  63. hda_nid_t private_dac_nids[4];
  64. };
  65. /*
  66. * input MUX handling (common part)
  67. */
  68. static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  69. {
  70. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  71. struct ad198x_spec *spec = codec->spec;
  72. return snd_hda_input_mux_info(spec->input_mux, uinfo);
  73. }
  74. static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  75. {
  76. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  77. struct ad198x_spec *spec = codec->spec;
  78. unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
  79. ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
  80. return 0;
  81. }
  82. static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  83. {
  84. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  85. struct ad198x_spec *spec = codec->spec;
  86. unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
  87. return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
  88. spec->capsrc_nids[adc_idx],
  89. &spec->cur_mux[adc_idx]);
  90. }
  91. /*
  92. * initialization (common callbacks)
  93. */
  94. static int ad198x_init(struct hda_codec *codec)
  95. {
  96. struct ad198x_spec *spec = codec->spec;
  97. int i;
  98. for (i = 0; i < spec->num_init_verbs; i++)
  99. snd_hda_sequence_write(codec, spec->init_verbs[i]);
  100. return 0;
  101. }
  102. static int ad198x_build_controls(struct hda_codec *codec)
  103. {
  104. struct ad198x_spec *spec = codec->spec;
  105. unsigned int i;
  106. int err;
  107. for (i = 0; i < spec->num_mixers; i++) {
  108. err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
  109. if (err < 0)
  110. return err;
  111. }
  112. if (spec->multiout.dig_out_nid) {
  113. err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
  114. if (err < 0)
  115. return err;
  116. }
  117. if (spec->dig_in_nid) {
  118. err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
  119. if (err < 0)
  120. return err;
  121. }
  122. return 0;
  123. }
  124. /*
  125. * Analog playback callbacks
  126. */
  127. static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
  128. struct hda_codec *codec,
  129. struct snd_pcm_substream *substream)
  130. {
  131. struct ad198x_spec *spec = codec->spec;
  132. return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
  133. }
  134. static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
  135. struct hda_codec *codec,
  136. unsigned int stream_tag,
  137. unsigned int format,
  138. struct snd_pcm_substream *substream)
  139. {
  140. struct ad198x_spec *spec = codec->spec;
  141. return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
  142. format, substream);
  143. }
  144. static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
  145. struct hda_codec *codec,
  146. struct snd_pcm_substream *substream)
  147. {
  148. struct ad198x_spec *spec = codec->spec;
  149. return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
  150. }
  151. /*
  152. * Digital out
  153. */
  154. static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
  155. struct hda_codec *codec,
  156. struct snd_pcm_substream *substream)
  157. {
  158. struct ad198x_spec *spec = codec->spec;
  159. return snd_hda_multi_out_dig_open(codec, &spec->multiout);
  160. }
  161. static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
  162. struct hda_codec *codec,
  163. struct snd_pcm_substream *substream)
  164. {
  165. struct ad198x_spec *spec = codec->spec;
  166. return snd_hda_multi_out_dig_close(codec, &spec->multiout);
  167. }
  168. /*
  169. * Analog capture
  170. */
  171. static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
  172. struct hda_codec *codec,
  173. unsigned int stream_tag,
  174. unsigned int format,
  175. struct snd_pcm_substream *substream)
  176. {
  177. struct ad198x_spec *spec = codec->spec;
  178. snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
  179. stream_tag, 0, format);
  180. return 0;
  181. }
  182. static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
  183. struct hda_codec *codec,
  184. struct snd_pcm_substream *substream)
  185. {
  186. struct ad198x_spec *spec = codec->spec;
  187. snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
  188. 0, 0, 0);
  189. return 0;
  190. }
  191. /*
  192. */
  193. static struct hda_pcm_stream ad198x_pcm_analog_playback = {
  194. .substreams = 1,
  195. .channels_min = 2,
  196. .channels_max = 6, /* changed later */
  197. .nid = 0, /* fill later */
  198. .ops = {
  199. .open = ad198x_playback_pcm_open,
  200. .prepare = ad198x_playback_pcm_prepare,
  201. .cleanup = ad198x_playback_pcm_cleanup
  202. },
  203. };
  204. static struct hda_pcm_stream ad198x_pcm_analog_capture = {
  205. .substreams = 1,
  206. .channels_min = 2,
  207. .channels_max = 2,
  208. .nid = 0, /* fill later */
  209. .ops = {
  210. .prepare = ad198x_capture_pcm_prepare,
  211. .cleanup = ad198x_capture_pcm_cleanup
  212. },
  213. };
  214. static struct hda_pcm_stream ad198x_pcm_digital_playback = {
  215. .substreams = 1,
  216. .channels_min = 2,
  217. .channels_max = 2,
  218. .nid = 0, /* fill later */
  219. .ops = {
  220. .open = ad198x_dig_playback_pcm_open,
  221. .close = ad198x_dig_playback_pcm_close
  222. },
  223. };
  224. static struct hda_pcm_stream ad198x_pcm_digital_capture = {
  225. .substreams = 1,
  226. .channels_min = 2,
  227. .channels_max = 2,
  228. /* NID is set in alc_build_pcms */
  229. };
  230. static int ad198x_build_pcms(struct hda_codec *codec)
  231. {
  232. struct ad198x_spec *spec = codec->spec;
  233. struct hda_pcm *info = spec->pcm_rec;
  234. codec->num_pcms = 1;
  235. codec->pcm_info = info;
  236. info->name = "AD198x Analog";
  237. info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
  238. info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
  239. info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
  240. info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
  241. info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
  242. info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
  243. if (spec->multiout.dig_out_nid) {
  244. info++;
  245. codec->num_pcms++;
  246. info->name = "AD198x Digital";
  247. info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
  248. info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
  249. if (spec->dig_in_nid) {
  250. info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
  251. info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
  252. }
  253. }
  254. return 0;
  255. }
  256. static void ad198x_free(struct hda_codec *codec)
  257. {
  258. struct ad198x_spec *spec = codec->spec;
  259. unsigned int i;
  260. if (spec->kctl_alloc) {
  261. for (i = 0; i < spec->num_kctl_used; i++)
  262. kfree(spec->kctl_alloc[i].name);
  263. kfree(spec->kctl_alloc);
  264. }
  265. kfree(codec->spec);
  266. }
  267. #ifdef CONFIG_PM
  268. static int ad198x_resume(struct hda_codec *codec)
  269. {
  270. struct ad198x_spec *spec = codec->spec;
  271. int i;
  272. codec->patch_ops.init(codec);
  273. for (i = 0; i < spec->num_mixers; i++)
  274. snd_hda_resume_ctls(codec, spec->mixers[i]);
  275. if (spec->multiout.dig_out_nid)
  276. snd_hda_resume_spdif_out(codec);
  277. if (spec->dig_in_nid)
  278. snd_hda_resume_spdif_in(codec);
  279. return 0;
  280. }
  281. #endif
  282. static struct hda_codec_ops ad198x_patch_ops = {
  283. .build_controls = ad198x_build_controls,
  284. .build_pcms = ad198x_build_pcms,
  285. .init = ad198x_init,
  286. .free = ad198x_free,
  287. #ifdef CONFIG_PM
  288. .resume = ad198x_resume,
  289. #endif
  290. };
  291. /*
  292. * EAPD control
  293. * the private value = nid | (invert << 8)
  294. */
  295. static int ad198x_eapd_info(struct snd_kcontrol *kcontrol,
  296. struct snd_ctl_elem_info *uinfo)
  297. {
  298. uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
  299. uinfo->count = 1;
  300. uinfo->value.integer.min = 0;
  301. uinfo->value.integer.max = 1;
  302. return 0;
  303. }
  304. static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
  305. struct snd_ctl_elem_value *ucontrol)
  306. {
  307. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  308. struct ad198x_spec *spec = codec->spec;
  309. int invert = (kcontrol->private_value >> 8) & 1;
  310. if (invert)
  311. ucontrol->value.integer.value[0] = ! spec->cur_eapd;
  312. else
  313. ucontrol->value.integer.value[0] = spec->cur_eapd;
  314. return 0;
  315. }
  316. static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
  317. struct snd_ctl_elem_value *ucontrol)
  318. {
  319. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  320. struct ad198x_spec *spec = codec->spec;
  321. int invert = (kcontrol->private_value >> 8) & 1;
  322. hda_nid_t nid = kcontrol->private_value & 0xff;
  323. unsigned int eapd;
  324. eapd = ucontrol->value.integer.value[0];
  325. if (invert)
  326. eapd = !eapd;
  327. if (eapd == spec->cur_eapd && ! codec->in_resume)
  328. return 0;
  329. spec->cur_eapd = eapd;
  330. snd_hda_codec_write(codec, nid,
  331. 0, AC_VERB_SET_EAPD_BTLENABLE,
  332. eapd ? 0x02 : 0x00);
  333. return 1;
  334. }
  335. static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
  336. struct snd_ctl_elem_info *uinfo);
  337. static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
  338. struct snd_ctl_elem_value *ucontrol);
  339. static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
  340. struct snd_ctl_elem_value *ucontrol);
  341. /*
  342. * AD1986A specific
  343. */
  344. #define AD1986A_SPDIF_OUT 0x02
  345. #define AD1986A_FRONT_DAC 0x03
  346. #define AD1986A_SURR_DAC 0x04
  347. #define AD1986A_CLFE_DAC 0x05
  348. #define AD1986A_ADC 0x06
  349. static hda_nid_t ad1986a_dac_nids[3] = {
  350. AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
  351. };
  352. static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
  353. static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
  354. static struct hda_input_mux ad1986a_capture_source = {
  355. .num_items = 7,
  356. .items = {
  357. { "Mic", 0x0 },
  358. { "CD", 0x1 },
  359. { "Aux", 0x3 },
  360. { "Line", 0x4 },
  361. { "Mix", 0x5 },
  362. { "Mono", 0x6 },
  363. { "Phone", 0x7 },
  364. },
  365. };
  366. /*
  367. * PCM control
  368. *
  369. * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
  370. */
  371. #define ad1986a_pcm_amp_vol_info snd_hda_mixer_amp_volume_info
  372. static int ad1986a_pcm_amp_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  373. {
  374. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  375. struct ad198x_spec *ad = codec->spec;
  376. mutex_lock(&ad->amp_mutex);
  377. snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
  378. mutex_unlock(&ad->amp_mutex);
  379. return 0;
  380. }
  381. static int ad1986a_pcm_amp_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  382. {
  383. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  384. struct ad198x_spec *ad = codec->spec;
  385. int i, change = 0;
  386. mutex_lock(&ad->amp_mutex);
  387. for (i = 0; i < ARRAY_SIZE(ad1986a_dac_nids); i++) {
  388. kcontrol->private_value = HDA_COMPOSE_AMP_VAL(ad1986a_dac_nids[i], 3, 0, HDA_OUTPUT);
  389. change |= snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
  390. }
  391. kcontrol->private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT);
  392. mutex_unlock(&ad->amp_mutex);
  393. return change;
  394. }
  395. #define ad1986a_pcm_amp_sw_info snd_hda_mixer_amp_switch_info
  396. static int ad1986a_pcm_amp_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  397. {
  398. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  399. struct ad198x_spec *ad = codec->spec;
  400. mutex_lock(&ad->amp_mutex);
  401. snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
  402. mutex_unlock(&ad->amp_mutex);
  403. return 0;
  404. }
  405. static int ad1986a_pcm_amp_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  406. {
  407. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  408. struct ad198x_spec *ad = codec->spec;
  409. int i, change = 0;
  410. mutex_lock(&ad->amp_mutex);
  411. for (i = 0; i < ARRAY_SIZE(ad1986a_dac_nids); i++) {
  412. kcontrol->private_value = HDA_COMPOSE_AMP_VAL(ad1986a_dac_nids[i], 3, 0, HDA_OUTPUT);
  413. change |= snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
  414. }
  415. kcontrol->private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT);
  416. mutex_unlock(&ad->amp_mutex);
  417. return change;
  418. }
  419. /*
  420. * mixers
  421. */
  422. static struct snd_kcontrol_new ad1986a_mixers[] = {
  423. {
  424. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  425. .name = "PCM Playback Volume",
  426. .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
  427. SNDRV_CTL_ELEM_ACCESS_TLV_READ |
  428. SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,
  429. .info = ad1986a_pcm_amp_vol_info,
  430. .get = ad1986a_pcm_amp_vol_get,
  431. .put = ad1986a_pcm_amp_vol_put,
  432. .tlv = { .c = snd_hda_mixer_amp_tlv },
  433. .private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT)
  434. },
  435. {
  436. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  437. .name = "PCM Playback Switch",
  438. .info = ad1986a_pcm_amp_sw_info,
  439. .get = ad1986a_pcm_amp_sw_get,
  440. .put = ad1986a_pcm_amp_sw_put,
  441. .private_value = HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT)
  442. },
  443. HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
  444. HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
  445. HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
  446. HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
  447. HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
  448. HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
  449. HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
  450. HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
  451. HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
  452. HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
  453. HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
  454. HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
  455. HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
  456. HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
  457. HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
  458. HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
  459. HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  460. HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  461. HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
  462. HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
  463. HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
  464. HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
  465. HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
  466. HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
  467. {
  468. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  469. .name = "Capture Source",
  470. .info = ad198x_mux_enum_info,
  471. .get = ad198x_mux_enum_get,
  472. .put = ad198x_mux_enum_put,
  473. },
  474. HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
  475. { } /* end */
  476. };
  477. /* additional mixers for 3stack mode */
  478. static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
  479. {
  480. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  481. .name = "Channel Mode",
  482. .info = ad198x_ch_mode_info,
  483. .get = ad198x_ch_mode_get,
  484. .put = ad198x_ch_mode_put,
  485. },
  486. { } /* end */
  487. };
  488. /* laptop model - 2ch only */
  489. static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
  490. static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
  491. HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
  492. HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
  493. HDA_CODEC_VOLUME("Master Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
  494. HDA_CODEC_MUTE("Master Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
  495. /* HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
  496. HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT), */
  497. HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
  498. HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
  499. HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
  500. HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
  501. HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
  502. HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
  503. HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  504. HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  505. /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
  506. HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
  507. HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
  508. HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
  509. HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
  510. HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
  511. {
  512. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  513. .name = "Capture Source",
  514. .info = ad198x_mux_enum_info,
  515. .get = ad198x_mux_enum_get,
  516. .put = ad198x_mux_enum_put,
  517. },
  518. { } /* end */
  519. };
  520. /* laptop-eapd model - 2ch only */
  521. /* master controls both pins 0x1a and 0x1b */
  522. static int ad1986a_laptop_master_vol_put(struct snd_kcontrol *kcontrol,
  523. struct snd_ctl_elem_value *ucontrol)
  524. {
  525. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  526. long *valp = ucontrol->value.integer.value;
  527. int change;
  528. change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
  529. 0x7f, valp[0] & 0x7f);
  530. change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
  531. 0x7f, valp[1] & 0x7f);
  532. snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
  533. 0x7f, valp[0] & 0x7f);
  534. snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
  535. 0x7f, valp[1] & 0x7f);
  536. return change;
  537. }
  538. static int ad1986a_laptop_master_sw_put(struct snd_kcontrol *kcontrol,
  539. struct snd_ctl_elem_value *ucontrol)
  540. {
  541. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  542. long *valp = ucontrol->value.integer.value;
  543. int change;
  544. change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
  545. 0x80, valp[0] ? 0 : 0x80);
  546. change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
  547. 0x80, valp[1] ? 0 : 0x80);
  548. snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
  549. 0x80, valp[0] ? 0 : 0x80);
  550. snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
  551. 0x80, valp[1] ? 0 : 0x80);
  552. return change;
  553. }
  554. static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
  555. .num_items = 3,
  556. .items = {
  557. { "Mic", 0x0 },
  558. { "Internal Mic", 0x4 },
  559. { "Mix", 0x5 },
  560. },
  561. };
  562. static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
  563. {
  564. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  565. .name = "Master Playback Volume",
  566. .info = snd_hda_mixer_amp_volume_info,
  567. .get = snd_hda_mixer_amp_volume_get,
  568. .put = ad1986a_laptop_master_vol_put,
  569. .tlv = { .c = snd_hda_mixer_amp_tlv },
  570. .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
  571. },
  572. {
  573. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  574. .name = "Master Playback Switch",
  575. .info = snd_hda_mixer_amp_switch_info,
  576. .get = snd_hda_mixer_amp_switch_get,
  577. .put = ad1986a_laptop_master_sw_put,
  578. .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
  579. },
  580. HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
  581. HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
  582. HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
  583. HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
  584. HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  585. HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  586. HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
  587. HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
  588. {
  589. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  590. .name = "Capture Source",
  591. .info = ad198x_mux_enum_info,
  592. .get = ad198x_mux_enum_get,
  593. .put = ad198x_mux_enum_put,
  594. },
  595. {
  596. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  597. .name = "External Amplifier",
  598. .info = ad198x_eapd_info,
  599. .get = ad198x_eapd_get,
  600. .put = ad198x_eapd_put,
  601. .private_value = 0x1b | (1 << 8), /* port-D, inversed */
  602. },
  603. { } /* end */
  604. };
  605. /*
  606. * initialization verbs
  607. */
  608. static struct hda_verb ad1986a_init_verbs[] = {
  609. /* Front, Surround, CLFE DAC; mute as default */
  610. {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  611. {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  612. {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  613. /* Downmix - off */
  614. {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  615. /* HP, Line-Out, Surround, CLFE selectors */
  616. {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
  617. {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
  618. {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
  619. {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
  620. /* Mono selector */
  621. {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
  622. /* Mic selector: Mic 1/2 pin */
  623. {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
  624. /* Line-in selector: Line-in */
  625. {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
  626. /* Mic 1/2 swap */
  627. {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
  628. /* Record selector: mic */
  629. {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
  630. /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
  631. {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  632. {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  633. {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  634. {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  635. {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  636. /* PC beep */
  637. {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
  638. /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
  639. {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  640. {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  641. {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  642. {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  643. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  644. /* HP Pin */
  645. {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
  646. /* Front, Surround, CLFE Pins */
  647. {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  648. {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  649. {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  650. /* Mono Pin */
  651. {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  652. /* Mic Pin */
  653. {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  654. /* Line, Aux, CD, Beep-In Pin */
  655. {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  656. {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  657. {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  658. {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  659. {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  660. { } /* end */
  661. };
  662. /* additional verbs for 3-stack model */
  663. static struct hda_verb ad1986a_3st_init_verbs[] = {
  664. /* Mic and line-in selectors */
  665. {0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
  666. {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
  667. { } /* end */
  668. };
  669. static struct hda_verb ad1986a_ch2_init[] = {
  670. /* Surround out -> Line In */
  671. { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  672. { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  673. /* CLFE -> Mic in */
  674. { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  675. { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  676. { } /* end */
  677. };
  678. static struct hda_verb ad1986a_ch4_init[] = {
  679. /* Surround out -> Surround */
  680. { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  681. { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  682. /* CLFE -> Mic in */
  683. { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  684. { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  685. { } /* end */
  686. };
  687. static struct hda_verb ad1986a_ch6_init[] = {
  688. /* Surround out -> Surround out */
  689. { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  690. { 0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  691. /* CLFE -> CLFE */
  692. { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  693. { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  694. { } /* end */
  695. };
  696. static struct hda_channel_mode ad1986a_modes[3] = {
  697. { 2, ad1986a_ch2_init },
  698. { 4, ad1986a_ch4_init },
  699. { 6, ad1986a_ch6_init },
  700. };
  701. /* eapd initialization */
  702. static struct hda_verb ad1986a_eapd_init_verbs[] = {
  703. {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00},
  704. {}
  705. };
  706. /* models */
  707. enum { AD1986A_6STACK, AD1986A_3STACK, AD1986A_LAPTOP, AD1986A_LAPTOP_EAPD };
  708. static struct hda_board_config ad1986a_cfg_tbl[] = {
  709. { .modelname = "6stack", .config = AD1986A_6STACK },
  710. { .modelname = "3stack", .config = AD1986A_3STACK },
  711. { .pci_subvendor = 0x10de, .pci_subdevice = 0xcb84,
  712. .config = AD1986A_3STACK }, /* ASUS A8N-VM CSM */
  713. { .pci_subvendor = 0x1043, .pci_subdevice = 0x817f,
  714. .config = AD1986A_3STACK }, /* ASUS P5P-L2 */
  715. { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b3,
  716. .config = AD1986A_3STACK }, /* ASUS P5RD2-VM / P5GPL-X SE */
  717. { .pci_subvendor = 0x1043, .pci_subdevice = 0x81cb,
  718. .config = AD1986A_3STACK }, /* ASUS M2NPV-VM */
  719. { .modelname = "laptop", .config = AD1986A_LAPTOP },
  720. { .pci_subvendor = 0x144d, .pci_subdevice = 0xc01e,
  721. .config = AD1986A_LAPTOP }, /* FSC V2060 */
  722. { .pci_subvendor = 0x17c0, .pci_subdevice = 0x2017,
  723. .config = AD1986A_LAPTOP }, /* Samsung M50 */
  724. { .pci_subvendor = 0x1043, .pci_subdevice = 0x818f,
  725. .config = AD1986A_LAPTOP }, /* ASUS P5GV-MX */
  726. { .modelname = "laptop-eapd", .config = AD1986A_LAPTOP_EAPD },
  727. { .pci_subvendor = 0x144d, .pci_subdevice = 0xc023,
  728. .config = AD1986A_LAPTOP_EAPD }, /* Samsung X60 Chane */
  729. { .pci_subvendor = 0x144d, .pci_subdevice = 0xc024,
  730. .config = AD1986A_LAPTOP_EAPD }, /* Samsung R65-T2300 Charis */
  731. { .pci_subvendor = 0x144d, .pci_subdevice = 0xc026,
  732. .config = AD1986A_LAPTOP_EAPD }, /* Samsung X11-T2300 Culesa */
  733. { .pci_subvendor = 0x1043, .pci_subdevice = 0x1153,
  734. .config = AD1986A_LAPTOP_EAPD }, /* ASUS M9 */
  735. { .pci_subvendor = 0x1043, .pci_subdevice = 0x1213,
  736. .config = AD1986A_LAPTOP_EAPD }, /* ASUS A6J */
  737. { .pci_subvendor = 0x1043, .pci_subdevice = 0x11f7,
  738. .config = AD1986A_LAPTOP_EAPD }, /* ASUS U5A */
  739. { .pci_subvendor = 0x1043, .pci_subdevice = 0x1263,
  740. .config = AD1986A_LAPTOP_EAPD }, /* ASUS U5F */
  741. { .pci_subvendor = 0x1043, .pci_subdevice = 0x1297,
  742. .config = AD1986A_LAPTOP_EAPD }, /* ASUS Z62F */
  743. { .pci_subvendor = 0x1043, .pci_subdevice = 0x12b3,
  744. .config = AD1986A_LAPTOP_EAPD }, /* ASUS V1j */
  745. { .pci_subvendor = 0x103c, .pci_subdevice = 0x30af,
  746. .config = AD1986A_LAPTOP_EAPD }, /* HP Compaq Presario B2800 */
  747. { .pci_subvendor = 0x17aa, .pci_subdevice = 0x2066,
  748. .config = AD1986A_LAPTOP_EAPD }, /* Lenovo 3000 N100-07684JU */
  749. {}
  750. };
  751. static int patch_ad1986a(struct hda_codec *codec)
  752. {
  753. struct ad198x_spec *spec;
  754. int board_config;
  755. spec = kzalloc(sizeof(*spec), GFP_KERNEL);
  756. if (spec == NULL)
  757. return -ENOMEM;
  758. mutex_init(&spec->amp_mutex);
  759. codec->spec = spec;
  760. spec->multiout.max_channels = 6;
  761. spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
  762. spec->multiout.dac_nids = ad1986a_dac_nids;
  763. spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
  764. spec->num_adc_nids = 1;
  765. spec->adc_nids = ad1986a_adc_nids;
  766. spec->capsrc_nids = ad1986a_capsrc_nids;
  767. spec->input_mux = &ad1986a_capture_source;
  768. spec->num_mixers = 1;
  769. spec->mixers[0] = ad1986a_mixers;
  770. spec->num_init_verbs = 1;
  771. spec->init_verbs[0] = ad1986a_init_verbs;
  772. codec->patch_ops = ad198x_patch_ops;
  773. /* override some parameters */
  774. board_config = snd_hda_check_board_config(codec, ad1986a_cfg_tbl);
  775. switch (board_config) {
  776. case AD1986A_3STACK:
  777. spec->num_mixers = 2;
  778. spec->mixers[1] = ad1986a_3st_mixers;
  779. spec->num_init_verbs = 3;
  780. spec->init_verbs[1] = ad1986a_3st_init_verbs;
  781. spec->init_verbs[2] = ad1986a_ch2_init;
  782. spec->channel_mode = ad1986a_modes;
  783. spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
  784. spec->need_dac_fix = 1;
  785. spec->multiout.max_channels = 2;
  786. spec->multiout.num_dacs = 1;
  787. break;
  788. case AD1986A_LAPTOP:
  789. spec->mixers[0] = ad1986a_laptop_mixers;
  790. spec->multiout.max_channels = 2;
  791. spec->multiout.num_dacs = 1;
  792. spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
  793. break;
  794. case AD1986A_LAPTOP_EAPD:
  795. spec->mixers[0] = ad1986a_laptop_eapd_mixers;
  796. spec->num_init_verbs = 2;
  797. spec->init_verbs[1] = ad1986a_eapd_init_verbs;
  798. spec->multiout.max_channels = 2;
  799. spec->multiout.num_dacs = 1;
  800. spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
  801. spec->multiout.dig_out_nid = 0;
  802. spec->input_mux = &ad1986a_laptop_eapd_capture_source;
  803. break;
  804. }
  805. return 0;
  806. }
  807. /*
  808. * AD1983 specific
  809. */
  810. #define AD1983_SPDIF_OUT 0x02
  811. #define AD1983_DAC 0x03
  812. #define AD1983_ADC 0x04
  813. static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
  814. static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
  815. static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
  816. static struct hda_input_mux ad1983_capture_source = {
  817. .num_items = 4,
  818. .items = {
  819. { "Mic", 0x0 },
  820. { "Line", 0x1 },
  821. { "Mix", 0x2 },
  822. { "Mix Mono", 0x3 },
  823. },
  824. };
  825. /*
  826. * SPDIF playback route
  827. */
  828. static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  829. {
  830. static char *texts[] = { "PCM", "ADC" };
  831. uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  832. uinfo->count = 1;
  833. uinfo->value.enumerated.items = 2;
  834. if (uinfo->value.enumerated.item > 1)
  835. uinfo->value.enumerated.item = 1;
  836. strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
  837. return 0;
  838. }
  839. static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  840. {
  841. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  842. struct ad198x_spec *spec = codec->spec;
  843. ucontrol->value.enumerated.item[0] = spec->spdif_route;
  844. return 0;
  845. }
  846. static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  847. {
  848. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  849. struct ad198x_spec *spec = codec->spec;
  850. if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
  851. spec->spdif_route = ucontrol->value.enumerated.item[0];
  852. snd_hda_codec_write(codec, spec->multiout.dig_out_nid, 0,
  853. AC_VERB_SET_CONNECT_SEL, spec->spdif_route);
  854. return 1;
  855. }
  856. return 0;
  857. }
  858. static struct snd_kcontrol_new ad1983_mixers[] = {
  859. HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  860. HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
  861. HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
  862. HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
  863. HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
  864. HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
  865. HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  866. HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  867. HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  868. HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  869. HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  870. HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  871. HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
  872. HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
  873. HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
  874. HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  875. HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  876. {
  877. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  878. .name = "Capture Source",
  879. .info = ad198x_mux_enum_info,
  880. .get = ad198x_mux_enum_get,
  881. .put = ad198x_mux_enum_put,
  882. },
  883. {
  884. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  885. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
  886. .info = ad1983_spdif_route_info,
  887. .get = ad1983_spdif_route_get,
  888. .put = ad1983_spdif_route_put,
  889. },
  890. { } /* end */
  891. };
  892. static struct hda_verb ad1983_init_verbs[] = {
  893. /* Front, HP, Mono; mute as default */
  894. {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  895. {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  896. {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  897. /* Beep, PCM, Mic, Line-In: mute */
  898. {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  899. {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  900. {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  901. {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  902. /* Front, HP selectors; from Mix */
  903. {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
  904. {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
  905. /* Mono selector; from Mix */
  906. {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
  907. /* Mic selector; Mic */
  908. {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
  909. /* Line-in selector: Line-in */
  910. {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
  911. /* Mic boost: 0dB */
  912. {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  913. /* Record selector: mic */
  914. {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
  915. {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  916. /* SPDIF route: PCM */
  917. {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
  918. /* Front Pin */
  919. {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  920. /* HP Pin */
  921. {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
  922. /* Mono Pin */
  923. {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  924. /* Mic Pin */
  925. {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  926. /* Line Pin */
  927. {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  928. { } /* end */
  929. };
  930. static int patch_ad1983(struct hda_codec *codec)
  931. {
  932. struct ad198x_spec *spec;
  933. spec = kzalloc(sizeof(*spec), GFP_KERNEL);
  934. if (spec == NULL)
  935. return -ENOMEM;
  936. mutex_init(&spec->amp_mutex);
  937. codec->spec = spec;
  938. spec->multiout.max_channels = 2;
  939. spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
  940. spec->multiout.dac_nids = ad1983_dac_nids;
  941. spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
  942. spec->num_adc_nids = 1;
  943. spec->adc_nids = ad1983_adc_nids;
  944. spec->capsrc_nids = ad1983_capsrc_nids;
  945. spec->input_mux = &ad1983_capture_source;
  946. spec->num_mixers = 1;
  947. spec->mixers[0] = ad1983_mixers;
  948. spec->num_init_verbs = 1;
  949. spec->init_verbs[0] = ad1983_init_verbs;
  950. spec->spdif_route = 0;
  951. codec->patch_ops = ad198x_patch_ops;
  952. return 0;
  953. }
  954. /*
  955. * AD1981 HD specific
  956. */
  957. #define AD1981_SPDIF_OUT 0x02
  958. #define AD1981_DAC 0x03
  959. #define AD1981_ADC 0x04
  960. static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
  961. static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
  962. static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
  963. /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
  964. static struct hda_input_mux ad1981_capture_source = {
  965. .num_items = 7,
  966. .items = {
  967. { "Front Mic", 0x0 },
  968. { "Line", 0x1 },
  969. { "Mix", 0x2 },
  970. { "Mix Mono", 0x3 },
  971. { "CD", 0x4 },
  972. { "Mic", 0x6 },
  973. { "Aux", 0x7 },
  974. },
  975. };
  976. static struct snd_kcontrol_new ad1981_mixers[] = {
  977. HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  978. HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
  979. HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
  980. HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
  981. HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
  982. HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
  983. HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  984. HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  985. HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  986. HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  987. HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  988. HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  989. HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
  990. HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
  991. HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
  992. HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
  993. HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
  994. HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
  995. HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
  996. HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
  997. HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
  998. HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
  999. HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  1000. HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  1001. {
  1002. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1003. .name = "Capture Source",
  1004. .info = ad198x_mux_enum_info,
  1005. .get = ad198x_mux_enum_get,
  1006. .put = ad198x_mux_enum_put,
  1007. },
  1008. /* identical with AD1983 */
  1009. {
  1010. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1011. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
  1012. .info = ad1983_spdif_route_info,
  1013. .get = ad1983_spdif_route_get,
  1014. .put = ad1983_spdif_route_put,
  1015. },
  1016. { } /* end */
  1017. };
  1018. static struct hda_verb ad1981_init_verbs[] = {
  1019. /* Front, HP, Mono; mute as default */
  1020. {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1021. {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1022. {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1023. /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
  1024. {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1025. {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1026. {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1027. {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1028. {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1029. {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1030. {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1031. /* Front, HP selectors; from Mix */
  1032. {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
  1033. {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
  1034. /* Mono selector; from Mix */
  1035. {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
  1036. /* Mic Mixer; select Front Mic */
  1037. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  1038. {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1039. /* Mic boost: 0dB */
  1040. {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  1041. {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  1042. /* Record selector: Front mic */
  1043. {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
  1044. {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1045. /* SPDIF route: PCM */
  1046. {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
  1047. /* Front Pin */
  1048. {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  1049. /* HP Pin */
  1050. {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
  1051. /* Mono Pin */
  1052. {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
  1053. /* Front & Rear Mic Pins */
  1054. {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  1055. {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
  1056. /* Line Pin */
  1057. {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
  1058. /* Digital Beep */
  1059. {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
  1060. /* Line-Out as Input: disabled */
  1061. {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1062. { } /* end */
  1063. };
  1064. /*
  1065. * Patch for HP nx6320
  1066. *
  1067. * nx6320 uses EAPD in the reserve way - EAPD-on means the internal
  1068. * speaker output enabled _and_ mute-LED off.
  1069. */
  1070. #define AD1981_HP_EVENT 0x37
  1071. #define AD1981_MIC_EVENT 0x38
  1072. static struct hda_verb ad1981_hp_init_verbs[] = {
  1073. {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
  1074. /* pin sensing on HP and Mic jacks */
  1075. {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
  1076. {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
  1077. {}
  1078. };
  1079. /* turn on/off EAPD (+ mute HP) as a master switch */
  1080. static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
  1081. struct snd_ctl_elem_value *ucontrol)
  1082. {
  1083. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1084. struct ad198x_spec *spec = codec->spec;
  1085. if (! ad198x_eapd_put(kcontrol, ucontrol))
  1086. return 0;
  1087. /* toggle HP mute appropriately */
  1088. snd_hda_codec_amp_update(codec, 0x06, 0, HDA_OUTPUT, 0,
  1089. 0x80, spec->cur_eapd ? 0 : 0x80);
  1090. snd_hda_codec_amp_update(codec, 0x06, 1, HDA_OUTPUT, 0,
  1091. 0x80, spec->cur_eapd ? 0 : 0x80);
  1092. return 1;
  1093. }
  1094. /* bind volumes of both NID 0x05 and 0x06 */
  1095. static int ad1981_hp_master_vol_put(struct snd_kcontrol *kcontrol,
  1096. struct snd_ctl_elem_value *ucontrol)
  1097. {
  1098. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1099. long *valp = ucontrol->value.integer.value;
  1100. int change;
  1101. change = snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
  1102. 0x7f, valp[0] & 0x7f);
  1103. change |= snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
  1104. 0x7f, valp[1] & 0x7f);
  1105. snd_hda_codec_amp_update(codec, 0x06, 0, HDA_OUTPUT, 0,
  1106. 0x7f, valp[0] & 0x7f);
  1107. snd_hda_codec_amp_update(codec, 0x06, 1, HDA_OUTPUT, 0,
  1108. 0x7f, valp[1] & 0x7f);
  1109. return change;
  1110. }
  1111. /* mute internal speaker if HP is plugged */
  1112. static void ad1981_hp_automute(struct hda_codec *codec)
  1113. {
  1114. unsigned int present;
  1115. present = snd_hda_codec_read(codec, 0x06, 0,
  1116. AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
  1117. snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
  1118. 0x80, present ? 0x80 : 0);
  1119. snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
  1120. 0x80, present ? 0x80 : 0);
  1121. }
  1122. /* toggle input of built-in and mic jack appropriately */
  1123. static void ad1981_hp_automic(struct hda_codec *codec)
  1124. {
  1125. static struct hda_verb mic_jack_on[] = {
  1126. {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1127. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  1128. {}
  1129. };
  1130. static struct hda_verb mic_jack_off[] = {
  1131. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
  1132. {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
  1133. {}
  1134. };
  1135. unsigned int present;
  1136. present = snd_hda_codec_read(codec, 0x08, 0,
  1137. AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
  1138. if (present)
  1139. snd_hda_sequence_write(codec, mic_jack_on);
  1140. else
  1141. snd_hda_sequence_write(codec, mic_jack_off);
  1142. }
  1143. /* unsolicited event for HP jack sensing */
  1144. static void ad1981_hp_unsol_event(struct hda_codec *codec,
  1145. unsigned int res)
  1146. {
  1147. res >>= 26;
  1148. switch (res) {
  1149. case AD1981_HP_EVENT:
  1150. ad1981_hp_automute(codec);
  1151. break;
  1152. case AD1981_MIC_EVENT:
  1153. ad1981_hp_automic(codec);
  1154. break;
  1155. }
  1156. }
  1157. static struct hda_input_mux ad1981_hp_capture_source = {
  1158. .num_items = 3,
  1159. .items = {
  1160. { "Mic", 0x0 },
  1161. { "Docking-Station", 0x1 },
  1162. { "Mix", 0x2 },
  1163. },
  1164. };
  1165. static struct snd_kcontrol_new ad1981_hp_mixers[] = {
  1166. {
  1167. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1168. .name = "Master Playback Volume",
  1169. .info = snd_hda_mixer_amp_volume_info,
  1170. .get = snd_hda_mixer_amp_volume_get,
  1171. .put = ad1981_hp_master_vol_put,
  1172. .private_value = HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
  1173. },
  1174. {
  1175. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1176. .name = "Master Playback Switch",
  1177. .info = ad198x_eapd_info,
  1178. .get = ad198x_eapd_get,
  1179. .put = ad1981_hp_master_sw_put,
  1180. .private_value = 0x05,
  1181. },
  1182. HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  1183. HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  1184. #if 0
  1185. /* FIXME: analog mic/line loopback doesn't work with my tests...
  1186. * (although recording is OK)
  1187. */
  1188. HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  1189. HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  1190. HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
  1191. HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
  1192. HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
  1193. HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
  1194. /* FIXME: does this laptop have analog CD connection? */
  1195. HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
  1196. HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
  1197. #endif
  1198. HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
  1199. HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
  1200. HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  1201. HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  1202. {
  1203. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1204. .name = "Capture Source",
  1205. .info = ad198x_mux_enum_info,
  1206. .get = ad198x_mux_enum_get,
  1207. .put = ad198x_mux_enum_put,
  1208. },
  1209. { } /* end */
  1210. };
  1211. /* initialize jack-sensing, too */
  1212. static int ad1981_hp_init(struct hda_codec *codec)
  1213. {
  1214. ad198x_init(codec);
  1215. ad1981_hp_automute(codec);
  1216. ad1981_hp_automic(codec);
  1217. return 0;
  1218. }
  1219. /* configuration for Lenovo Thinkpad T60 */
  1220. static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
  1221. HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  1222. HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
  1223. HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
  1224. HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
  1225. HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
  1226. HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
  1227. HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
  1228. HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
  1229. HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
  1230. HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
  1231. HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
  1232. {
  1233. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1234. .name = "Capture Source",
  1235. .info = ad198x_mux_enum_info,
  1236. .get = ad198x_mux_enum_get,
  1237. .put = ad198x_mux_enum_put,
  1238. },
  1239. /* identical with AD1983 */
  1240. {
  1241. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1242. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
  1243. .info = ad1983_spdif_route_info,
  1244. .get = ad1983_spdif_route_get,
  1245. .put = ad1983_spdif_route_put,
  1246. },
  1247. { } /* end */
  1248. };
  1249. static struct hda_input_mux ad1981_thinkpad_capture_source = {
  1250. .num_items = 3,
  1251. .items = {
  1252. { "Mic", 0x0 },
  1253. { "Mix", 0x2 },
  1254. { "CD", 0x4 },
  1255. },
  1256. };
  1257. /* models */
  1258. enum { AD1981_BASIC, AD1981_HP, AD1981_THINKPAD };
  1259. static struct hda_board_config ad1981_cfg_tbl[] = {
  1260. { .modelname = "hp", .config = AD1981_HP },
  1261. /* All HP models */
  1262. { .pci_subvendor = 0x103c, .config = AD1981_HP },
  1263. { .pci_subvendor = 0x30b0, .pci_subdevice = 0x103c,
  1264. .config = AD1981_HP }, /* HP nx6320 (reversed SSID, H/W bug) */
  1265. { .modelname = "thinkpad", .config = AD1981_THINKPAD },
  1266. /* Lenovo Thinkpad T60/X60/Z6xx */
  1267. { .pci_subvendor = 0x17aa, .config = AD1981_THINKPAD },
  1268. { .pci_subvendor = 0x1014, .pci_subdevice = 0x0597,
  1269. .config = AD1981_THINKPAD }, /* Z60m/t */
  1270. { .modelname = "basic", .config = AD1981_BASIC },
  1271. {}
  1272. };
  1273. static int patch_ad1981(struct hda_codec *codec)
  1274. {
  1275. struct ad198x_spec *spec;
  1276. int board_config;
  1277. spec = kzalloc(sizeof(*spec), GFP_KERNEL);
  1278. if (spec == NULL)
  1279. return -ENOMEM;
  1280. mutex_init(&spec->amp_mutex);
  1281. codec->spec = spec;
  1282. spec->multiout.max_channels = 2;
  1283. spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
  1284. spec->multiout.dac_nids = ad1981_dac_nids;
  1285. spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
  1286. spec->num_adc_nids = 1;
  1287. spec->adc_nids = ad1981_adc_nids;
  1288. spec->capsrc_nids = ad1981_capsrc_nids;
  1289. spec->input_mux = &ad1981_capture_source;
  1290. spec->num_mixers = 1;
  1291. spec->mixers[0] = ad1981_mixers;
  1292. spec->num_init_verbs = 1;
  1293. spec->init_verbs[0] = ad1981_init_verbs;
  1294. spec->spdif_route = 0;
  1295. codec->patch_ops = ad198x_patch_ops;
  1296. /* override some parameters */
  1297. board_config = snd_hda_check_board_config(codec, ad1981_cfg_tbl);
  1298. switch (board_config) {
  1299. case AD1981_HP:
  1300. spec->mixers[0] = ad1981_hp_mixers;
  1301. spec->num_init_verbs = 2;
  1302. spec->init_verbs[1] = ad1981_hp_init_verbs;
  1303. spec->multiout.dig_out_nid = 0;
  1304. spec->input_mux = &ad1981_hp_capture_source;
  1305. codec->patch_ops.init = ad1981_hp_init;
  1306. codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
  1307. break;
  1308. case AD1981_THINKPAD:
  1309. spec->mixers[0] = ad1981_thinkpad_mixers;
  1310. spec->input_mux = &ad1981_thinkpad_capture_source;
  1311. break;
  1312. }
  1313. return 0;
  1314. }
  1315. /*
  1316. * AD1988
  1317. *
  1318. * Output pins and routes
  1319. *
  1320. * Pin Mix Sel DAC (*)
  1321. * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
  1322. * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
  1323. * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
  1324. * port-D 0x12 (mute/hp) <- 0x29 <- 04
  1325. * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
  1326. * port-F 0x16 (mute) <- 0x2a <- 06
  1327. * port-G 0x24 (mute) <- 0x27 <- 05
  1328. * port-H 0x25 (mute) <- 0x28 <- 0a
  1329. * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
  1330. *
  1331. * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
  1332. * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
  1333. *
  1334. * Input pins and routes
  1335. *
  1336. * pin boost mix input # / adc input #
  1337. * port-A 0x11 -> 0x38 -> mix 2, ADC 0
  1338. * port-B 0x14 -> 0x39 -> mix 0, ADC 1
  1339. * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
  1340. * port-D 0x12 -> 0x3d -> mix 3, ADC 8
  1341. * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
  1342. * port-F 0x16 -> 0x3b -> mix 5, ADC 3
  1343. * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
  1344. * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
  1345. *
  1346. *
  1347. * DAC assignment
  1348. * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
  1349. * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
  1350. *
  1351. * Inputs of Analog Mix (0x20)
  1352. * 0:Port-B (front mic)
  1353. * 1:Port-C/G/H (line-in)
  1354. * 2:Port-A
  1355. * 3:Port-D (line-in/2)
  1356. * 4:Port-E/G/H (mic-in)
  1357. * 5:Port-F (mic2-in)
  1358. * 6:CD
  1359. * 7:Beep
  1360. *
  1361. * ADC selection
  1362. * 0:Port-A
  1363. * 1:Port-B (front mic-in)
  1364. * 2:Port-C (line-in)
  1365. * 3:Port-F (mic2-in)
  1366. * 4:Port-E (mic-in)
  1367. * 5:CD
  1368. * 6:Port-G
  1369. * 7:Port-H
  1370. * 8:Port-D (line-in/2)
  1371. * 9:Mix
  1372. *
  1373. * Proposed pin assignments by the datasheet
  1374. *
  1375. * 6-stack
  1376. * Port-A front headphone
  1377. * B front mic-in
  1378. * C rear line-in
  1379. * D rear front-out
  1380. * E rear mic-in
  1381. * F rear surround
  1382. * G rear CLFE
  1383. * H rear side
  1384. *
  1385. * 3-stack
  1386. * Port-A front headphone
  1387. * B front mic
  1388. * C rear line-in/surround
  1389. * D rear front-out
  1390. * E rear mic-in/CLFE
  1391. *
  1392. * laptop
  1393. * Port-A headphone
  1394. * B mic-in
  1395. * C docking station
  1396. * D internal speaker (with EAPD)
  1397. * E/F quad mic array
  1398. */
  1399. /* models */
  1400. enum {
  1401. AD1988_6STACK,
  1402. AD1988_6STACK_DIG,
  1403. AD1988_3STACK,
  1404. AD1988_3STACK_DIG,
  1405. AD1988_LAPTOP,
  1406. AD1988_LAPTOP_DIG,
  1407. AD1988_AUTO,
  1408. AD1988_MODEL_LAST,
  1409. };
  1410. /* reivision id to check workarounds */
  1411. #define AD1988A_REV2 0x100200
  1412. #define is_rev2(codec) \
  1413. ((codec)->vendor_id == 0x11d41988 && \
  1414. (codec)->revision_id == AD1988A_REV2)
  1415. /*
  1416. * mixers
  1417. */
  1418. static hda_nid_t ad1988_6stack_dac_nids[4] = {
  1419. 0x04, 0x06, 0x05, 0x0a
  1420. };
  1421. static hda_nid_t ad1988_3stack_dac_nids[3] = {
  1422. 0x04, 0x05, 0x0a
  1423. };
  1424. /* for AD1988A revision-2, DAC2-4 are swapped */
  1425. static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
  1426. 0x04, 0x05, 0x0a, 0x06
  1427. };
  1428. static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
  1429. 0x04, 0x0a, 0x06
  1430. };
  1431. static hda_nid_t ad1988_adc_nids[3] = {
  1432. 0x08, 0x09, 0x0f
  1433. };
  1434. static hda_nid_t ad1988_capsrc_nids[3] = {
  1435. 0x0c, 0x0d, 0x0e
  1436. };
  1437. #define AD1988_SPDIF_OUT 0x02
  1438. #define AD1988_SPDIF_IN 0x07
  1439. static struct hda_input_mux ad1988_6stack_capture_source = {
  1440. .num_items = 5,
  1441. .items = {
  1442. { "Front Mic", 0x0 },
  1443. { "Line", 0x1 },
  1444. { "Mic", 0x4 },
  1445. { "CD", 0x5 },
  1446. { "Mix", 0x9 },
  1447. },
  1448. };
  1449. static struct hda_input_mux ad1988_laptop_capture_source = {
  1450. .num_items = 3,
  1451. .items = {
  1452. { "Mic/Line", 0x0 },
  1453. { "CD", 0x5 },
  1454. { "Mix", 0x9 },
  1455. },
  1456. };
  1457. /*
  1458. */
  1459. static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
  1460. struct snd_ctl_elem_info *uinfo)
  1461. {
  1462. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1463. struct ad198x_spec *spec = codec->spec;
  1464. return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
  1465. spec->num_channel_mode);
  1466. }
  1467. static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
  1468. struct snd_ctl_elem_value *ucontrol)
  1469. {
  1470. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1471. struct ad198x_spec *spec = codec->spec;
  1472. return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
  1473. spec->num_channel_mode, spec->multiout.max_channels);
  1474. }
  1475. static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
  1476. struct snd_ctl_elem_value *ucontrol)
  1477. {
  1478. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1479. struct ad198x_spec *spec = codec->spec;
  1480. int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
  1481. spec->num_channel_mode,
  1482. &spec->multiout.max_channels);
  1483. if (err >= 0 && spec->need_dac_fix)
  1484. spec->multiout.num_dacs = spec->multiout.max_channels / 2;
  1485. return err;
  1486. }
  1487. /* 6-stack mode */
  1488. static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
  1489. HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
  1490. HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
  1491. HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
  1492. HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
  1493. HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
  1494. { } /* end */
  1495. };
  1496. static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
  1497. HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
  1498. HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
  1499. HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
  1500. HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
  1501. HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
  1502. { } /* end */
  1503. };
  1504. static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
  1505. HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
  1506. HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
  1507. HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
  1508. HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
  1509. HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
  1510. HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
  1511. HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
  1512. HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
  1513. HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
  1514. HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
  1515. HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
  1516. HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
  1517. HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
  1518. HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
  1519. HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
  1520. HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
  1521. HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
  1522. HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
  1523. HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
  1524. HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
  1525. HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
  1526. { } /* end */
  1527. };
  1528. /* 3-stack mode */
  1529. static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
  1530. HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
  1531. HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
  1532. HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
  1533. HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
  1534. { } /* end */
  1535. };
  1536. static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
  1537. HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
  1538. HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
  1539. HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
  1540. HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
  1541. { } /* end */
  1542. };
  1543. static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
  1544. HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
  1545. HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
  1546. HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
  1547. HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
  1548. HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
  1549. HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
  1550. HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
  1551. HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
  1552. HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
  1553. HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
  1554. HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
  1555. HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
  1556. HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
  1557. HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
  1558. HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
  1559. HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
  1560. HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
  1561. HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
  1562. HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
  1563. HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
  1564. {
  1565. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1566. .name = "Channel Mode",
  1567. .info = ad198x_ch_mode_info,
  1568. .get = ad198x_ch_mode_get,
  1569. .put = ad198x_ch_mode_put,
  1570. },
  1571. { } /* end */
  1572. };
  1573. /* laptop mode */
  1574. static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
  1575. HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
  1576. HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
  1577. HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
  1578. HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
  1579. HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
  1580. HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
  1581. HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
  1582. HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
  1583. HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
  1584. HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
  1585. HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
  1586. HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
  1587. HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
  1588. HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
  1589. {
  1590. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1591. .name = "External Amplifier",
  1592. .info = ad198x_eapd_info,
  1593. .get = ad198x_eapd_get,
  1594. .put = ad198x_eapd_put,
  1595. .private_value = 0x12 | (1 << 8), /* port-D, inversed */
  1596. },
  1597. { } /* end */
  1598. };
  1599. /* capture */
  1600. static struct snd_kcontrol_new ad1988_capture_mixers[] = {
  1601. HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
  1602. HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
  1603. HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
  1604. HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
  1605. HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
  1606. HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
  1607. {
  1608. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1609. /* The multiple "Capture Source" controls confuse alsamixer
  1610. * So call somewhat different..
  1611. * FIXME: the controls appear in the "playback" view!
  1612. */
  1613. /* .name = "Capture Source", */
  1614. .name = "Input Source",
  1615. .count = 3,
  1616. .info = ad198x_mux_enum_info,
  1617. .get = ad198x_mux_enum_get,
  1618. .put = ad198x_mux_enum_put,
  1619. },
  1620. { } /* end */
  1621. };
  1622. static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
  1623. struct snd_ctl_elem_info *uinfo)
  1624. {
  1625. static char *texts[] = {
  1626. "PCM", "ADC1", "ADC2", "ADC3"
  1627. };
  1628. uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  1629. uinfo->count = 1;
  1630. uinfo->value.enumerated.items = 4;
  1631. if (uinfo->value.enumerated.item >= 4)
  1632. uinfo->value.enumerated.item = 3;
  1633. strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
  1634. return 0;
  1635. }
  1636. static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
  1637. struct snd_ctl_elem_value *ucontrol)
  1638. {
  1639. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1640. unsigned int sel;
  1641. sel = snd_hda_codec_read(codec, 0x02, 0, AC_VERB_GET_CONNECT_SEL, 0);
  1642. if (sel > 0) {
  1643. sel = snd_hda_codec_read(codec, 0x0b, 0, AC_VERB_GET_CONNECT_SEL, 0);
  1644. if (sel <= 3)
  1645. sel++;
  1646. else
  1647. sel = 0;
  1648. }
  1649. ucontrol->value.enumerated.item[0] = sel;
  1650. return 0;
  1651. }
  1652. static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
  1653. struct snd_ctl_elem_value *ucontrol)
  1654. {
  1655. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1656. unsigned int sel;
  1657. int change;
  1658. sel = snd_hda_codec_read(codec, 0x02, 0, AC_VERB_GET_CONNECT_SEL, 0);
  1659. if (! ucontrol->value.enumerated.item[0]) {
  1660. change = sel != 0;
  1661. if (change)
  1662. snd_hda_codec_write(codec, 0x02, 0, AC_VERB_SET_CONNECT_SEL, 0);
  1663. } else {
  1664. change = sel == 0;
  1665. if (change)
  1666. snd_hda_codec_write(codec, 0x02, 0, AC_VERB_SET_CONNECT_SEL, 1);
  1667. sel = snd_hda_codec_read(codec, 0x0b, 0, AC_VERB_GET_CONNECT_SEL, 0) + 1;
  1668. change |= sel == ucontrol->value.enumerated.item[0];
  1669. if (change)
  1670. snd_hda_codec_write(codec, 0x02, 0, AC_VERB_SET_CONNECT_SEL,
  1671. ucontrol->value.enumerated.item[0] - 1);
  1672. }
  1673. return change;
  1674. }
  1675. static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
  1676. HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
  1677. {
  1678. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  1679. .name = "IEC958 Playback Source",
  1680. .info = ad1988_spdif_playback_source_info,
  1681. .get = ad1988_spdif_playback_source_get,
  1682. .put = ad1988_spdif_playback_source_put,
  1683. },
  1684. { } /* end */
  1685. };
  1686. static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
  1687. HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
  1688. { } /* end */
  1689. };
  1690. /*
  1691. * initialization verbs
  1692. */
  1693. /*
  1694. * for 6-stack (+dig)
  1695. */
  1696. static struct hda_verb ad1988_6stack_init_verbs[] = {
  1697. /* Front, Surround, CLFE, side DAC; unmute as default */
  1698. {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1699. {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1700. {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1701. {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1702. /* Port-A front headphon path */
  1703. {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
  1704. {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1705. {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1706. {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1707. {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
  1708. /* Port-D line-out path */
  1709. {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1710. {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1711. {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1712. {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1713. /* Port-F surround path */
  1714. {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1715. {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1716. {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1717. {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1718. /* Port-G CLFE path */
  1719. {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1720. {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1721. {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1722. {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1723. /* Port-H side path */
  1724. {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1725. {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1726. {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1727. {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1728. /* Mono out path */
  1729. {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
  1730. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1731. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1732. {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1733. {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
  1734. /* Port-B front mic-in path */
  1735. {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1736. {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
  1737. {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1738. /* Port-C line-in path */
  1739. {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1740. {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
  1741. {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1742. {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
  1743. /* Port-E mic-in path */
  1744. {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1745. {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
  1746. {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1747. {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
  1748. { }
  1749. };
  1750. static struct hda_verb ad1988_capture_init_verbs[] = {
  1751. /* mute analog mix */
  1752. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1753. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1754. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
  1755. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
  1756. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
  1757. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
  1758. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
  1759. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
  1760. /* select ADCs - front-mic */
  1761. {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
  1762. {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
  1763. {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
  1764. /* ADCs; muted */
  1765. {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1766. {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1767. {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1768. { }
  1769. };
  1770. static struct hda_verb ad1988_spdif_init_verbs[] = {
  1771. /* SPDIF out sel */
  1772. {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
  1773. {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
  1774. {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
  1775. {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
  1776. /* SPDIF out pin */
  1777. {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
  1778. {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x17}, /* 0dB */
  1779. { }
  1780. };
  1781. /*
  1782. * verbs for 3stack (+dig)
  1783. */
  1784. static struct hda_verb ad1988_3stack_ch2_init[] = {
  1785. /* set port-C to line-in */
  1786. { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
  1787. { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
  1788. /* set port-E to mic-in */
  1789. { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
  1790. { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
  1791. { } /* end */
  1792. };
  1793. static struct hda_verb ad1988_3stack_ch6_init[] = {
  1794. /* set port-C to surround out */
  1795. { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  1796. { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
  1797. /* set port-E to CLFE out */
  1798. { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  1799. { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
  1800. { } /* end */
  1801. };
  1802. static struct hda_channel_mode ad1988_3stack_modes[2] = {
  1803. { 2, ad1988_3stack_ch2_init },
  1804. { 6, ad1988_3stack_ch6_init },
  1805. };
  1806. static struct hda_verb ad1988_3stack_init_verbs[] = {
  1807. /* Front, Surround, CLFE, side DAC; unmute as default */
  1808. {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1809. {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1810. {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1811. {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1812. /* Port-A front headphon path */
  1813. {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
  1814. {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1815. {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1816. {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1817. {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
  1818. /* Port-D line-out path */
  1819. {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1820. {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1821. {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1822. {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1823. /* Mono out path */
  1824. {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
  1825. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1826. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1827. {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1828. {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
  1829. /* Port-B front mic-in path */
  1830. {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1831. {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
  1832. {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1833. /* Port-C line-in/surround path - 6ch mode as default */
  1834. {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1835. {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1836. {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1837. {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
  1838. {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
  1839. /* Port-E mic-in/CLFE path - 6ch mode as default */
  1840. {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1841. {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1842. {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1843. {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
  1844. {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
  1845. /* mute analog mix */
  1846. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1847. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1848. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
  1849. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
  1850. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
  1851. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
  1852. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
  1853. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
  1854. /* select ADCs - front-mic */
  1855. {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
  1856. {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
  1857. {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
  1858. /* ADCs; muted */
  1859. {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1860. {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1861. {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1862. { }
  1863. };
  1864. /*
  1865. * verbs for laptop mode (+dig)
  1866. */
  1867. static struct hda_verb ad1988_laptop_hp_on[] = {
  1868. /* unmute port-A and mute port-D */
  1869. { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
  1870. { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
  1871. { } /* end */
  1872. };
  1873. static struct hda_verb ad1988_laptop_hp_off[] = {
  1874. /* mute port-A and unmute port-D */
  1875. { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
  1876. { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
  1877. { } /* end */
  1878. };
  1879. #define AD1988_HP_EVENT 0x01
  1880. static struct hda_verb ad1988_laptop_init_verbs[] = {
  1881. /* Front, Surround, CLFE, side DAC; unmute as default */
  1882. {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1883. {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1884. {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1885. {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1886. /* Port-A front headphon path */
  1887. {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
  1888. {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1889. {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1890. {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1891. {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
  1892. /* unsolicited event for pin-sense */
  1893. {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
  1894. /* Port-D line-out path + EAPD */
  1895. {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1896. {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1897. {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1898. {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1899. {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
  1900. /* Mono out path */
  1901. {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
  1902. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1903. {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1904. {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1905. {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
  1906. /* Port-B mic-in path */
  1907. {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1908. {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
  1909. {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1910. /* Port-C docking station - try to output */
  1911. {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
  1912. {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
  1913. {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
  1914. {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
  1915. /* mute analog mix */
  1916. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
  1917. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  1918. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
  1919. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
  1920. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
  1921. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
  1922. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
  1923. {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
  1924. /* select ADCs - mic */
  1925. {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
  1926. {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
  1927. {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
  1928. /* ADCs; muted */
  1929. {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1930. {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1931. {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
  1932. { }
  1933. };
  1934. static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
  1935. {
  1936. if ((res >> 26) != AD1988_HP_EVENT)
  1937. return;
  1938. if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
  1939. snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
  1940. else
  1941. snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
  1942. }
  1943. /*
  1944. * Automatic parse of I/O pins from the BIOS configuration
  1945. */
  1946. #define NUM_CONTROL_ALLOC 32
  1947. #define NUM_VERB_ALLOC 32
  1948. enum {
  1949. AD_CTL_WIDGET_VOL,
  1950. AD_CTL_WIDGET_MUTE,
  1951. AD_CTL_BIND_MUTE,
  1952. };
  1953. static struct snd_kcontrol_new ad1988_control_templates[] = {
  1954. HDA_CODEC_VOLUME(NULL, 0, 0, 0),
  1955. HDA_CODEC_MUTE(NULL, 0, 0, 0),
  1956. HDA_BIND_MUTE(NULL, 0, 0, 0),
  1957. };
  1958. /* add dynamic controls */
  1959. static int add_control(struct ad198x_spec *spec, int type, const char *name,
  1960. unsigned long val)
  1961. {
  1962. struct snd_kcontrol_new *knew;
  1963. if (spec->num_kctl_used >= spec->num_kctl_alloc) {
  1964. int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
  1965. knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
  1966. if (! knew)
  1967. return -ENOMEM;
  1968. if (spec->kctl_alloc) {
  1969. memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
  1970. kfree(spec->kctl_alloc);
  1971. }
  1972. spec->kctl_alloc = knew;
  1973. spec->num_kctl_alloc = num;
  1974. }
  1975. knew = &spec->kctl_alloc[spec->num_kctl_used];
  1976. *knew = ad1988_control_templates[type];
  1977. knew->name = kstrdup(name, GFP_KERNEL);
  1978. if (! knew->name)
  1979. return -ENOMEM;
  1980. knew->private_value = val;
  1981. spec->num_kctl_used++;
  1982. return 0;
  1983. }
  1984. #define AD1988_PIN_CD_NID 0x18
  1985. #define AD1988_PIN_BEEP_NID 0x10
  1986. static hda_nid_t ad1988_mixer_nids[8] = {
  1987. /* A B C D E F G H */
  1988. 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
  1989. };
  1990. static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
  1991. {
  1992. static hda_nid_t idx_to_dac[8] = {
  1993. /* A B C D E F G H */
  1994. 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
  1995. };
  1996. static hda_nid_t idx_to_dac_rev2[8] = {
  1997. /* A B C D E F G H */
  1998. 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
  1999. };
  2000. if (is_rev2(codec))
  2001. return idx_to_dac_rev2[idx];
  2002. else
  2003. return idx_to_dac[idx];
  2004. }
  2005. static hda_nid_t ad1988_boost_nids[8] = {
  2006. 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
  2007. };
  2008. static int ad1988_pin_idx(hda_nid_t nid)
  2009. {
  2010. static hda_nid_t ad1988_io_pins[8] = {
  2011. 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
  2012. };
  2013. int i;
  2014. for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
  2015. if (ad1988_io_pins[i] == nid)
  2016. return i;
  2017. return 0; /* should be -1 */
  2018. }
  2019. static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
  2020. {
  2021. static int loopback_idx[8] = {
  2022. 2, 0, 1, 3, 4, 5, 1, 4
  2023. };
  2024. switch (nid) {
  2025. case AD1988_PIN_CD_NID:
  2026. return 6;
  2027. default:
  2028. return loopback_idx[ad1988_pin_idx(nid)];
  2029. }
  2030. }
  2031. static int ad1988_pin_to_adc_idx(hda_nid_t nid)
  2032. {
  2033. static int adc_idx[8] = {
  2034. 0, 1, 2, 8, 4, 3, 6, 7
  2035. };
  2036. switch (nid) {
  2037. case AD1988_PIN_CD_NID:
  2038. return 5;
  2039. default:
  2040. return adc_idx[ad1988_pin_idx(nid)];
  2041. }
  2042. }
  2043. /* fill in the dac_nids table from the parsed pin configuration */
  2044. static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
  2045. const struct auto_pin_cfg *cfg)
  2046. {
  2047. struct ad198x_spec *spec = codec->spec;
  2048. int i, idx;
  2049. spec->multiout.dac_nids = spec->private_dac_nids;
  2050. /* check the pins hardwired to audio widget */
  2051. for (i = 0; i < cfg->line_outs; i++) {
  2052. idx = ad1988_pin_idx(cfg->line_out_pins[i]);
  2053. spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
  2054. }
  2055. spec->multiout.num_dacs = cfg->line_outs;
  2056. return 0;
  2057. }
  2058. /* add playback controls from the parsed DAC table */
  2059. static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
  2060. const struct auto_pin_cfg *cfg)
  2061. {
  2062. char name[32];
  2063. static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
  2064. hda_nid_t nid;
  2065. int i, err;
  2066. for (i = 0; i < cfg->line_outs; i++) {
  2067. hda_nid_t dac = spec->multiout.dac_nids[i];
  2068. if (! dac)
  2069. continue;
  2070. nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
  2071. if (i == 2) {
  2072. /* Center/LFE */
  2073. err = add_control(spec, AD_CTL_WIDGET_VOL,
  2074. "Center Playback Volume",
  2075. HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
  2076. if (err < 0)
  2077. return err;
  2078. err = add_control(spec, AD_CTL_WIDGET_VOL,
  2079. "LFE Playback Volume",
  2080. HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
  2081. if (err < 0)
  2082. return err;
  2083. err = add_control(spec, AD_CTL_BIND_MUTE,
  2084. "Center Playback Switch",
  2085. HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
  2086. if (err < 0)
  2087. return err;
  2088. err = add_control(spec, AD_CTL_BIND_MUTE,
  2089. "LFE Playback Switch",
  2090. HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
  2091. if (err < 0)
  2092. return err;
  2093. } else {
  2094. sprintf(name, "%s Playback Volume", chname[i]);
  2095. err = add_control(spec, AD_CTL_WIDGET_VOL, name,
  2096. HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
  2097. if (err < 0)
  2098. return err;
  2099. sprintf(name, "%s Playback Switch", chname[i]);
  2100. err = add_control(spec, AD_CTL_BIND_MUTE, name,
  2101. HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
  2102. if (err < 0)
  2103. return err;
  2104. }
  2105. }
  2106. return 0;
  2107. }
  2108. /* add playback controls for speaker and HP outputs */
  2109. static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
  2110. const char *pfx)
  2111. {
  2112. struct ad198x_spec *spec = codec->spec;
  2113. hda_nid_t nid;
  2114. int idx, err;
  2115. char name[32];
  2116. if (! pin)
  2117. return 0;
  2118. idx = ad1988_pin_idx(pin);
  2119. nid = ad1988_idx_to_dac(codec, idx);
  2120. /* specify the DAC as the extra output */
  2121. if (! spec->multiout.hp_nid)
  2122. spec->multiout.hp_nid = nid;
  2123. else
  2124. spec->multiout.extra_out_nid[0] = nid;
  2125. /* control HP volume/switch on the output mixer amp */
  2126. sprintf(name, "%s Playback Volume", pfx);
  2127. if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
  2128. HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
  2129. return err;
  2130. nid = ad1988_mixer_nids[idx];
  2131. sprintf(name, "%s Playback Switch", pfx);
  2132. if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
  2133. HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
  2134. return err;
  2135. return 0;
  2136. }
  2137. /* create input playback/capture controls for the given pin */
  2138. static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
  2139. const char *ctlname, int boost)
  2140. {
  2141. char name[32];
  2142. int err, idx;
  2143. sprintf(name, "%s Playback Volume", ctlname);
  2144. idx = ad1988_pin_to_loopback_idx(pin);
  2145. if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
  2146. HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
  2147. return err;
  2148. sprintf(name, "%s Playback Switch", ctlname);
  2149. if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
  2150. HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
  2151. return err;
  2152. if (boost) {
  2153. hda_nid_t bnid;
  2154. idx = ad1988_pin_idx(pin);
  2155. bnid = ad1988_boost_nids[idx];
  2156. if (bnid) {
  2157. sprintf(name, "%s Boost", ctlname);
  2158. return add_control(spec, AD_CTL_WIDGET_VOL, name,
  2159. HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
  2160. }
  2161. }
  2162. return 0;
  2163. }
  2164. /* create playback/capture controls for input pins */
  2165. static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
  2166. const struct auto_pin_cfg *cfg)
  2167. {
  2168. struct hda_input_mux *imux = &spec->private_imux;
  2169. int i, err;
  2170. for (i = 0; i < AUTO_PIN_LAST; i++) {
  2171. err = new_analog_input(spec, cfg->input_pins[i],
  2172. auto_pin_cfg_labels[i],
  2173. i <= AUTO_PIN_FRONT_MIC);
  2174. if (err < 0)
  2175. return err;
  2176. imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
  2177. imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
  2178. imux->num_items++;
  2179. }
  2180. imux->items[imux->num_items].label = "Mix";
  2181. imux->items[imux->num_items].index = 9;
  2182. imux->num_items++;
  2183. if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
  2184. "Analog Mix Playback Volume",
  2185. HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
  2186. return err;
  2187. if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
  2188. "Analog Mix Playback Switch",
  2189. HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
  2190. return err;
  2191. return 0;
  2192. }
  2193. static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
  2194. hda_nid_t nid, int pin_type,
  2195. int dac_idx)
  2196. {
  2197. /* set as output */
  2198. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
  2199. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
  2200. switch (nid) {
  2201. case 0x11: /* port-A - DAC 04 */
  2202. snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
  2203. break;
  2204. case 0x14: /* port-B - DAC 06 */
  2205. snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
  2206. break;
  2207. case 0x15: /* port-C - DAC 05 */
  2208. snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
  2209. break;
  2210. case 0x17: /* port-E - DAC 0a */
  2211. snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
  2212. break;
  2213. case 0x13: /* mono - DAC 04 */
  2214. snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
  2215. break;
  2216. }
  2217. }
  2218. static void ad1988_auto_init_multi_out(struct hda_codec *codec)
  2219. {
  2220. struct ad198x_spec *spec = codec->spec;
  2221. int i;
  2222. for (i = 0; i < spec->autocfg.line_outs; i++) {
  2223. hda_nid_t nid = spec->autocfg.line_out_pins[i];
  2224. ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
  2225. }
  2226. }
  2227. static void ad1988_auto_init_extra_out(struct hda_codec *codec)
  2228. {
  2229. struct ad198x_spec *spec = codec->spec;
  2230. hda_nid_t pin;
  2231. pin = spec->autocfg.speaker_pins[0];
  2232. if (pin) /* connect to front */
  2233. ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
  2234. pin = spec->autocfg.hp_pins[0];
  2235. if (pin) /* connect to front */
  2236. ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
  2237. }
  2238. static void ad1988_auto_init_analog_input(struct hda_codec *codec)
  2239. {
  2240. struct ad198x_spec *spec = codec->spec;
  2241. int i, idx;
  2242. for (i = 0; i < AUTO_PIN_LAST; i++) {
  2243. hda_nid_t nid = spec->autocfg.input_pins[i];
  2244. if (! nid)
  2245. continue;
  2246. switch (nid) {
  2247. case 0x15: /* port-C */
  2248. snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
  2249. break;
  2250. case 0x17: /* port-E */
  2251. snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
  2252. break;
  2253. }
  2254. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
  2255. i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
  2256. if (nid != AD1988_PIN_CD_NID)
  2257. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
  2258. AMP_OUT_MUTE);
  2259. idx = ad1988_pin_idx(nid);
  2260. if (ad1988_boost_nids[idx])
  2261. snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
  2262. AC_VERB_SET_AMP_GAIN_MUTE,
  2263. AMP_OUT_ZERO);
  2264. }
  2265. }
  2266. /* parse the BIOS configuration and set up the alc_spec */
  2267. /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
  2268. static int ad1988_parse_auto_config(struct hda_codec *codec)
  2269. {
  2270. struct ad198x_spec *spec = codec->spec;
  2271. int err;
  2272. if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
  2273. return err;
  2274. if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
  2275. return err;
  2276. if (! spec->autocfg.line_outs)
  2277. return 0; /* can't find valid BIOS pin config */
  2278. if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
  2279. (err = ad1988_auto_create_extra_out(codec,
  2280. spec->autocfg.speaker_pins[0],
  2281. "Speaker")) < 0 ||
  2282. (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
  2283. "Headphone")) < 0 ||
  2284. (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
  2285. return err;
  2286. spec->multiout.max_channels = spec->multiout.num_dacs * 2;
  2287. if (spec->autocfg.dig_out_pin)
  2288. spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
  2289. if (spec->autocfg.dig_in_pin)
  2290. spec->dig_in_nid = AD1988_SPDIF_IN;
  2291. if (spec->kctl_alloc)
  2292. spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
  2293. spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
  2294. spec->input_mux = &spec->private_imux;
  2295. return 1;
  2296. }
  2297. /* init callback for auto-configuration model -- overriding the default init */
  2298. static int ad1988_auto_init(struct hda_codec *codec)
  2299. {
  2300. ad198x_init(codec);
  2301. ad1988_auto_init_multi_out(codec);
  2302. ad1988_auto_init_extra_out(codec);
  2303. ad1988_auto_init_analog_input(codec);
  2304. return 0;
  2305. }
  2306. /*
  2307. */
  2308. static struct hda_board_config ad1988_cfg_tbl[] = {
  2309. { .modelname = "6stack", .config = AD1988_6STACK },
  2310. { .modelname = "6stack-dig", .config = AD1988_6STACK_DIG },
  2311. { .modelname = "3stack", .config = AD1988_3STACK },
  2312. { .modelname = "3stack-dig", .config = AD1988_3STACK_DIG },
  2313. { .modelname = "laptop", .config = AD1988_LAPTOP },
  2314. { .modelname = "laptop-dig", .config = AD1988_LAPTOP_DIG },
  2315. { .modelname = "auto", .config = AD1988_AUTO },
  2316. {}
  2317. };
  2318. static int patch_ad1988(struct hda_codec *codec)
  2319. {
  2320. struct ad198x_spec *spec;
  2321. int board_config;
  2322. spec = kzalloc(sizeof(*spec), GFP_KERNEL);
  2323. if (spec == NULL)
  2324. return -ENOMEM;
  2325. mutex_init(&spec->amp_mutex);
  2326. codec->spec = spec;
  2327. if (is_rev2(codec))
  2328. snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
  2329. board_config = snd_hda_check_board_config(codec, ad1988_cfg_tbl);
  2330. if (board_config < 0 || board_config >= AD1988_MODEL_LAST) {
  2331. printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
  2332. board_config = AD1988_AUTO;
  2333. }
  2334. if (board_config == AD1988_AUTO) {
  2335. /* automatic parse from the BIOS config */
  2336. int err = ad1988_parse_auto_config(codec);
  2337. if (err < 0) {
  2338. ad198x_free(codec);
  2339. return err;
  2340. } else if (! err) {
  2341. printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
  2342. board_config = AD1988_6STACK;
  2343. }
  2344. }
  2345. switch (board_config) {
  2346. case AD1988_6STACK:
  2347. case AD1988_6STACK_DIG:
  2348. spec->multiout.max_channels = 8;
  2349. spec->multiout.num_dacs = 4;
  2350. if (is_rev2(codec))
  2351. spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
  2352. else
  2353. spec->multiout.dac_nids = ad1988_6stack_dac_nids;
  2354. spec->input_mux = &ad1988_6stack_capture_source;
  2355. spec->num_mixers = 2;
  2356. if (is_rev2(codec))
  2357. spec->mixers[0] = ad1988_6stack_mixers1_rev2;
  2358. else
  2359. spec->mixers[0] = ad1988_6stack_mixers1;
  2360. spec->mixers[1] = ad1988_6stack_mixers2;
  2361. spec->num_init_verbs = 1;
  2362. spec->init_verbs[0] = ad1988_6stack_init_verbs;
  2363. if (board_config == AD1988_6STACK_DIG) {
  2364. spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
  2365. spec->dig_in_nid = AD1988_SPDIF_IN;
  2366. }
  2367. break;
  2368. case AD1988_3STACK:
  2369. case AD1988_3STACK_DIG:
  2370. spec->multiout.max_channels = 6;
  2371. spec->multiout.num_dacs = 3;
  2372. if (is_rev2(codec))
  2373. spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
  2374. else
  2375. spec->multiout.dac_nids = ad1988_3stack_dac_nids;
  2376. spec->input_mux = &ad1988_6stack_capture_source;
  2377. spec->channel_mode = ad1988_3stack_modes;
  2378. spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
  2379. spec->num_mixers = 2;
  2380. if (is_rev2(codec))
  2381. spec->mixers[0] = ad1988_3stack_mixers1_rev2;
  2382. else
  2383. spec->mixers[0] = ad1988_3stack_mixers1;
  2384. spec->mixers[1] = ad1988_3stack_mixers2;
  2385. spec->num_init_verbs = 1;
  2386. spec->init_verbs[0] = ad1988_3stack_init_verbs;
  2387. if (board_config == AD1988_3STACK_DIG)
  2388. spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
  2389. break;
  2390. case AD1988_LAPTOP:
  2391. case AD1988_LAPTOP_DIG:
  2392. spec->multiout.max_channels = 2;
  2393. spec->multiout.num_dacs = 1;
  2394. spec->multiout.dac_nids = ad1988_3stack_dac_nids;
  2395. spec->input_mux = &ad1988_laptop_capture_source;
  2396. spec->num_mixers = 1;
  2397. spec->mixers[0] = ad1988_laptop_mixers;
  2398. spec->num_init_verbs = 1;
  2399. spec->init_verbs[0] = ad1988_laptop_init_verbs;
  2400. if (board_config == AD1988_LAPTOP_DIG)
  2401. spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
  2402. break;
  2403. }
  2404. spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
  2405. spec->adc_nids = ad1988_adc_nids;
  2406. spec->capsrc_nids = ad1988_capsrc_nids;
  2407. spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
  2408. spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
  2409. if (spec->multiout.dig_out_nid) {
  2410. spec->mixers[spec->num_mixers++] = ad1988_spdif_out_mixers;
  2411. spec->init_verbs[spec->num_init_verbs++] = ad1988_spdif_init_verbs;
  2412. }
  2413. if (spec->dig_in_nid)
  2414. spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
  2415. codec->patch_ops = ad198x_patch_ops;
  2416. switch (board_config) {
  2417. case AD1988_AUTO:
  2418. codec->patch_ops.init = ad1988_auto_init;
  2419. break;
  2420. case AD1988_LAPTOP:
  2421. case AD1988_LAPTOP_DIG:
  2422. codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
  2423. break;
  2424. }
  2425. return 0;
  2426. }
  2427. /*
  2428. * patch entries
  2429. */
  2430. struct hda_codec_preset snd_hda_preset_analog[] = {
  2431. { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
  2432. { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
  2433. { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
  2434. { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
  2435. { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
  2436. {} /* terminator */
  2437. };