patch_realtek.c 110 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893
  1. /*
  2. * Universal Interface for Intel High Definition Audio Codec
  3. *
  4. * HD audio interface patch for Realtek ALC codecs
  5. *
  6. * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
  7. * PeiSen Hou <pshou@realtek.com.tw>
  8. * Takashi Iwai <tiwai@suse.de>
  9. * Jonathan Woithe <jwoithe@just42.net>
  10. *
  11. * This driver is free software; you can redistribute it and/or modify
  12. * it under the terms of the GNU General Public License as published by
  13. * the Free Software Foundation; either version 2 of the License, or
  14. * (at your option) any later version.
  15. *
  16. * This driver is distributed in the hope that it will be useful,
  17. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19. * GNU General Public License for more details.
  20. *
  21. * You should have received a copy of the GNU General Public License
  22. * along with this program; if not, write to the Free Software
  23. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24. */
  25. #include <linux/init.h>
  26. #include <linux/delay.h>
  27. #include <linux/slab.h>
  28. #include <linux/pci.h>
  29. #include <linux/dmi.h>
  30. #include <linux/module.h>
  31. #include <sound/core.h>
  32. #include <sound/jack.h>
  33. #include "hda_codec.h"
  34. #include "hda_local.h"
  35. #include "hda_auto_parser.h"
  36. #include "hda_beep.h"
  37. #include "hda_jack.h"
  38. #include "hda_generic.h"
  39. /* unsol event tags */
  40. #define ALC_DCVOL_EVENT 0x08
  41. /* for GPIO Poll */
  42. #define GPIO_MASK 0x03
  43. /* extra amp-initialization sequence types */
  44. enum {
  45. ALC_INIT_NONE,
  46. ALC_INIT_DEFAULT,
  47. ALC_INIT_GPIO1,
  48. ALC_INIT_GPIO2,
  49. ALC_INIT_GPIO3,
  50. };
  51. struct alc_customize_define {
  52. unsigned int sku_cfg;
  53. unsigned char port_connectivity;
  54. unsigned char check_sum;
  55. unsigned char customization;
  56. unsigned char external_amp;
  57. unsigned int enable_pcbeep:1;
  58. unsigned int platform_type:1;
  59. unsigned int swap:1;
  60. unsigned int override:1;
  61. unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
  62. };
  63. struct alc_spec {
  64. struct hda_gen_spec gen; /* must be at head */
  65. /* codec parameterization */
  66. const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
  67. unsigned int num_mixers;
  68. unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
  69. struct alc_customize_define cdefine;
  70. unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  71. /* inverted dmic fix */
  72. unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */
  73. unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */
  74. hda_nid_t inv_dmic_pin;
  75. /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
  76. int mute_led_polarity;
  77. hda_nid_t mute_led_nid;
  78. /* hooks */
  79. void (*init_hook)(struct hda_codec *codec);
  80. #ifdef CONFIG_PM
  81. void (*power_hook)(struct hda_codec *codec);
  82. #endif
  83. void (*shutup)(struct hda_codec *codec);
  84. int init_amp;
  85. int codec_variant; /* flag for other variants */
  86. /* for PLL fix */
  87. hda_nid_t pll_nid;
  88. unsigned int pll_coef_idx, pll_coef_bit;
  89. unsigned int coef0;
  90. };
  91. /*
  92. * Append the given mixer and verb elements for the later use
  93. * The mixer array is referred in build_controls(), and init_verbs are
  94. * called in init().
  95. */
  96. static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
  97. {
  98. if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
  99. return;
  100. spec->mixers[spec->num_mixers++] = mix;
  101. }
  102. /*
  103. * GPIO setup tables, used in initialization
  104. */
  105. /* Enable GPIO mask and set output */
  106. static const struct hda_verb alc_gpio1_init_verbs[] = {
  107. {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
  108. {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
  109. {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
  110. { }
  111. };
  112. static const struct hda_verb alc_gpio2_init_verbs[] = {
  113. {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
  114. {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
  115. {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
  116. { }
  117. };
  118. static const struct hda_verb alc_gpio3_init_verbs[] = {
  119. {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
  120. {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
  121. {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
  122. { }
  123. };
  124. /*
  125. * Fix hardware PLL issue
  126. * On some codecs, the analog PLL gating control must be off while
  127. * the default value is 1.
  128. */
  129. static void alc_fix_pll(struct hda_codec *codec)
  130. {
  131. struct alc_spec *spec = codec->spec;
  132. unsigned int val;
  133. if (!spec->pll_nid)
  134. return;
  135. snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
  136. spec->pll_coef_idx);
  137. val = snd_hda_codec_read(codec, spec->pll_nid, 0,
  138. AC_VERB_GET_PROC_COEF, 0);
  139. snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
  140. spec->pll_coef_idx);
  141. snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
  142. val & ~(1 << spec->pll_coef_bit));
  143. }
  144. static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
  145. unsigned int coef_idx, unsigned int coef_bit)
  146. {
  147. struct alc_spec *spec = codec->spec;
  148. spec->pll_nid = nid;
  149. spec->pll_coef_idx = coef_idx;
  150. spec->pll_coef_bit = coef_bit;
  151. alc_fix_pll(codec);
  152. }
  153. /* update the master volume per volume-knob's unsol event */
  154. static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)
  155. {
  156. unsigned int val;
  157. struct snd_kcontrol *kctl;
  158. struct snd_ctl_elem_value *uctl;
  159. kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
  160. if (!kctl)
  161. return;
  162. uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
  163. if (!uctl)
  164. return;
  165. val = snd_hda_codec_read(codec, jack->nid, 0,
  166. AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
  167. val &= HDA_AMP_VOLMASK;
  168. uctl->value.integer.value[0] = val;
  169. uctl->value.integer.value[1] = val;
  170. kctl->put(kctl, uctl);
  171. kfree(uctl);
  172. }
  173. static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
  174. {
  175. /* For some reason, the res given from ALC880 is broken.
  176. Here we adjust it properly. */
  177. snd_hda_jack_unsol_event(codec, res >> 2);
  178. }
  179. /* additional initialization for ALC888 variants */
  180. static void alc888_coef_init(struct hda_codec *codec)
  181. {
  182. unsigned int tmp;
  183. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
  184. tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
  185. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
  186. if ((tmp & 0xf0) == 0x20)
  187. /* alc888S-VC */
  188. snd_hda_codec_read(codec, 0x20, 0,
  189. AC_VERB_SET_PROC_COEF, 0x830);
  190. else
  191. /* alc888-VB */
  192. snd_hda_codec_read(codec, 0x20, 0,
  193. AC_VERB_SET_PROC_COEF, 0x3030);
  194. }
  195. /* additional initialization for ALC889 variants */
  196. static void alc889_coef_init(struct hda_codec *codec)
  197. {
  198. unsigned int tmp;
  199. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
  200. tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
  201. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
  202. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
  203. }
  204. /* turn on/off EAPD control (only if available) */
  205. static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
  206. {
  207. if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
  208. return;
  209. if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
  210. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
  211. on ? 2 : 0);
  212. }
  213. /* turn on/off EAPD controls of the codec */
  214. static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
  215. {
  216. /* We currently only handle front, HP */
  217. static hda_nid_t pins[] = {
  218. 0x0f, 0x10, 0x14, 0x15, 0
  219. };
  220. hda_nid_t *p;
  221. for (p = pins; *p; p++)
  222. set_eapd(codec, *p, on);
  223. }
  224. /* generic shutup callback;
  225. * just turning off EPAD and a little pause for avoiding pop-noise
  226. */
  227. static void alc_eapd_shutup(struct hda_codec *codec)
  228. {
  229. alc_auto_setup_eapd(codec, false);
  230. msleep(200);
  231. }
  232. /* generic EAPD initialization */
  233. static void alc_auto_init_amp(struct hda_codec *codec, int type)
  234. {
  235. unsigned int tmp;
  236. alc_auto_setup_eapd(codec, true);
  237. switch (type) {
  238. case ALC_INIT_GPIO1:
  239. snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
  240. break;
  241. case ALC_INIT_GPIO2:
  242. snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
  243. break;
  244. case ALC_INIT_GPIO3:
  245. snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
  246. break;
  247. case ALC_INIT_DEFAULT:
  248. switch (codec->vendor_id) {
  249. case 0x10ec0260:
  250. snd_hda_codec_write(codec, 0x1a, 0,
  251. AC_VERB_SET_COEF_INDEX, 7);
  252. tmp = snd_hda_codec_read(codec, 0x1a, 0,
  253. AC_VERB_GET_PROC_COEF, 0);
  254. snd_hda_codec_write(codec, 0x1a, 0,
  255. AC_VERB_SET_COEF_INDEX, 7);
  256. snd_hda_codec_write(codec, 0x1a, 0,
  257. AC_VERB_SET_PROC_COEF,
  258. tmp | 0x2010);
  259. break;
  260. case 0x10ec0262:
  261. case 0x10ec0880:
  262. case 0x10ec0882:
  263. case 0x10ec0883:
  264. case 0x10ec0885:
  265. case 0x10ec0887:
  266. /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
  267. alc889_coef_init(codec);
  268. break;
  269. case 0x10ec0888:
  270. alc888_coef_init(codec);
  271. break;
  272. #if 0 /* XXX: This may cause the silent output on speaker on some machines */
  273. case 0x10ec0267:
  274. case 0x10ec0268:
  275. snd_hda_codec_write(codec, 0x20, 0,
  276. AC_VERB_SET_COEF_INDEX, 7);
  277. tmp = snd_hda_codec_read(codec, 0x20, 0,
  278. AC_VERB_GET_PROC_COEF, 0);
  279. snd_hda_codec_write(codec, 0x20, 0,
  280. AC_VERB_SET_COEF_INDEX, 7);
  281. snd_hda_codec_write(codec, 0x20, 0,
  282. AC_VERB_SET_PROC_COEF,
  283. tmp | 0x3000);
  284. break;
  285. #endif /* XXX */
  286. }
  287. break;
  288. }
  289. }
  290. /*
  291. * Realtek SSID verification
  292. */
  293. /* Could be any non-zero and even value. When used as fixup, tells
  294. * the driver to ignore any present sku defines.
  295. */
  296. #define ALC_FIXUP_SKU_IGNORE (2)
  297. static void alc_fixup_sku_ignore(struct hda_codec *codec,
  298. const struct hda_fixup *fix, int action)
  299. {
  300. struct alc_spec *spec = codec->spec;
  301. if (action == HDA_FIXUP_ACT_PRE_PROBE) {
  302. spec->cdefine.fixup = 1;
  303. spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
  304. }
  305. }
  306. static int alc_auto_parse_customize_define(struct hda_codec *codec)
  307. {
  308. unsigned int ass, tmp, i;
  309. unsigned nid = 0;
  310. struct alc_spec *spec = codec->spec;
  311. spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
  312. if (spec->cdefine.fixup) {
  313. ass = spec->cdefine.sku_cfg;
  314. if (ass == ALC_FIXUP_SKU_IGNORE)
  315. return -1;
  316. goto do_sku;
  317. }
  318. ass = codec->subsystem_id & 0xffff;
  319. if (ass != codec->bus->pci->subsystem_device && (ass & 1))
  320. goto do_sku;
  321. nid = 0x1d;
  322. if (codec->vendor_id == 0x10ec0260)
  323. nid = 0x17;
  324. ass = snd_hda_codec_get_pincfg(codec, nid);
  325. if (!(ass & 1)) {
  326. printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
  327. codec->chip_name, ass);
  328. return -1;
  329. }
  330. /* check sum */
  331. tmp = 0;
  332. for (i = 1; i < 16; i++) {
  333. if ((ass >> i) & 1)
  334. tmp++;
  335. }
  336. if (((ass >> 16) & 0xf) != tmp)
  337. return -1;
  338. spec->cdefine.port_connectivity = ass >> 30;
  339. spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
  340. spec->cdefine.check_sum = (ass >> 16) & 0xf;
  341. spec->cdefine.customization = ass >> 8;
  342. do_sku:
  343. spec->cdefine.sku_cfg = ass;
  344. spec->cdefine.external_amp = (ass & 0x38) >> 3;
  345. spec->cdefine.platform_type = (ass & 0x4) >> 2;
  346. spec->cdefine.swap = (ass & 0x2) >> 1;
  347. spec->cdefine.override = ass & 0x1;
  348. snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
  349. nid, spec->cdefine.sku_cfg);
  350. snd_printd("SKU: port_connectivity=0x%x\n",
  351. spec->cdefine.port_connectivity);
  352. snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
  353. snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
  354. snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
  355. snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
  356. snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
  357. snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
  358. snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
  359. return 0;
  360. }
  361. /* return the position of NID in the list, or -1 if not found */
  362. static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
  363. {
  364. int i;
  365. for (i = 0; i < nums; i++)
  366. if (list[i] == nid)
  367. return i;
  368. return -1;
  369. }
  370. /* return true if the given NID is found in the list */
  371. static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
  372. {
  373. return find_idx_in_nid_list(nid, list, nums) >= 0;
  374. }
  375. /* check subsystem ID and set up device-specific initialization;
  376. * return 1 if initialized, 0 if invalid SSID
  377. */
  378. /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
  379. * 31 ~ 16 : Manufacture ID
  380. * 15 ~ 8 : SKU ID
  381. * 7 ~ 0 : Assembly ID
  382. * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
  383. */
  384. static int alc_subsystem_id(struct hda_codec *codec,
  385. hda_nid_t porta, hda_nid_t porte,
  386. hda_nid_t portd, hda_nid_t porti)
  387. {
  388. unsigned int ass, tmp, i;
  389. unsigned nid;
  390. struct alc_spec *spec = codec->spec;
  391. if (spec->cdefine.fixup) {
  392. ass = spec->cdefine.sku_cfg;
  393. if (ass == ALC_FIXUP_SKU_IGNORE)
  394. return 0;
  395. goto do_sku;
  396. }
  397. ass = codec->subsystem_id & 0xffff;
  398. if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
  399. goto do_sku;
  400. /* invalid SSID, check the special NID pin defcfg instead */
  401. /*
  402. * 31~30 : port connectivity
  403. * 29~21 : reserve
  404. * 20 : PCBEEP input
  405. * 19~16 : Check sum (15:1)
  406. * 15~1 : Custom
  407. * 0 : override
  408. */
  409. nid = 0x1d;
  410. if (codec->vendor_id == 0x10ec0260)
  411. nid = 0x17;
  412. ass = snd_hda_codec_get_pincfg(codec, nid);
  413. snd_printd("realtek: No valid SSID, "
  414. "checking pincfg 0x%08x for NID 0x%x\n",
  415. ass, nid);
  416. if (!(ass & 1))
  417. return 0;
  418. if ((ass >> 30) != 1) /* no physical connection */
  419. return 0;
  420. /* check sum */
  421. tmp = 0;
  422. for (i = 1; i < 16; i++) {
  423. if ((ass >> i) & 1)
  424. tmp++;
  425. }
  426. if (((ass >> 16) & 0xf) != tmp)
  427. return 0;
  428. do_sku:
  429. snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
  430. ass & 0xffff, codec->vendor_id);
  431. /*
  432. * 0 : override
  433. * 1 : Swap Jack
  434. * 2 : 0 --> Desktop, 1 --> Laptop
  435. * 3~5 : External Amplifier control
  436. * 7~6 : Reserved
  437. */
  438. tmp = (ass & 0x38) >> 3; /* external Amp control */
  439. switch (tmp) {
  440. case 1:
  441. spec->init_amp = ALC_INIT_GPIO1;
  442. break;
  443. case 3:
  444. spec->init_amp = ALC_INIT_GPIO2;
  445. break;
  446. case 7:
  447. spec->init_amp = ALC_INIT_GPIO3;
  448. break;
  449. case 5:
  450. default:
  451. spec->init_amp = ALC_INIT_DEFAULT;
  452. break;
  453. }
  454. /* is laptop or Desktop and enable the function "Mute internal speaker
  455. * when the external headphone out jack is plugged"
  456. */
  457. if (!(ass & 0x8000))
  458. return 1;
  459. /*
  460. * 10~8 : Jack location
  461. * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
  462. * 14~13: Resvered
  463. * 15 : 1 --> enable the function "Mute internal speaker
  464. * when the external headphone out jack is plugged"
  465. */
  466. if (!spec->gen.autocfg.hp_pins[0] &&
  467. !(spec->gen.autocfg.line_out_pins[0] &&
  468. spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
  469. hda_nid_t nid;
  470. tmp = (ass >> 11) & 0x3; /* HP to chassis */
  471. if (tmp == 0)
  472. nid = porta;
  473. else if (tmp == 1)
  474. nid = porte;
  475. else if (tmp == 2)
  476. nid = portd;
  477. else if (tmp == 3)
  478. nid = porti;
  479. else
  480. return 1;
  481. if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
  482. spec->gen.autocfg.line_outs))
  483. return 1;
  484. spec->gen.autocfg.hp_pins[0] = nid;
  485. }
  486. return 1;
  487. }
  488. /* Check the validity of ALC subsystem-id
  489. * ports contains an array of 4 pin NIDs for port-A, E, D and I */
  490. static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
  491. {
  492. if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
  493. struct alc_spec *spec = codec->spec;
  494. snd_printd("realtek: "
  495. "Enable default setup for auto mode as fallback\n");
  496. spec->init_amp = ALC_INIT_DEFAULT;
  497. }
  498. }
  499. /*
  500. * COEF access helper functions
  501. */
  502. static int alc_read_coef_idx(struct hda_codec *codec,
  503. unsigned int coef_idx)
  504. {
  505. unsigned int val;
  506. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
  507. coef_idx);
  508. val = snd_hda_codec_read(codec, 0x20, 0,
  509. AC_VERB_GET_PROC_COEF, 0);
  510. return val;
  511. }
  512. static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
  513. unsigned int coef_val)
  514. {
  515. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
  516. coef_idx);
  517. snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
  518. coef_val);
  519. }
  520. /* a special bypass for COEF 0; read the cached value at the second time */
  521. static unsigned int alc_get_coef0(struct hda_codec *codec)
  522. {
  523. struct alc_spec *spec = codec->spec;
  524. if (!spec->coef0)
  525. spec->coef0 = alc_read_coef_idx(codec, 0);
  526. return spec->coef0;
  527. }
  528. /*
  529. */
  530. static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)
  531. {
  532. struct hda_gen_spec *spec = codec->spec;
  533. if (spec->dyn_adc_switch)
  534. adc_idx = spec->dyn_adc_idx[imux_idx];
  535. return spec->adc_nids[adc_idx];
  536. }
  537. static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)
  538. {
  539. struct alc_spec *spec = codec->spec;
  540. struct hda_input_mux *imux = &spec->gen.input_mux;
  541. struct nid_path *path;
  542. hda_nid_t nid;
  543. int i, dir, parm;
  544. unsigned int val;
  545. for (i = 0; i < imux->num_items; i++) {
  546. if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)
  547. break;
  548. }
  549. if (i >= imux->num_items)
  550. return;
  551. path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,
  552. get_adc_nid(codec, adc_idx, i));
  553. val = path->ctls[NID_PATH_MUTE_CTL];
  554. if (!val)
  555. return;
  556. nid = get_amp_nid_(val);
  557. dir = get_amp_direction_(val);
  558. parm = AC_AMP_SET_RIGHT |
  559. (dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);
  560. /* flush all cached amps at first */
  561. snd_hda_codec_flush_amp_cache(codec);
  562. /* we care only right channel */
  563. val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);
  564. if (val & 0x80) /* if already muted, we don't need to touch */
  565. return;
  566. val |= 0x80;
  567. snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
  568. parm | val);
  569. }
  570. /*
  571. * Inverted digital-mic handling
  572. *
  573. * First off, it's a bit tricky. The "Inverted Internal Mic Capture Switch"
  574. * gives the additional mute only to the right channel of the digital mic
  575. * capture stream. This is a workaround for avoiding the almost silence
  576. * by summing the stereo stream from some (known to be ForteMedia)
  577. * digital mic unit.
  578. *
  579. * The logic is to call alc_inv_dmic_sync() after each action (possibly)
  580. * modifying ADC amp. When the mute flag is set, it mutes the R-channel
  581. * without caching so that the cache can still keep the original value.
  582. * The cached value is then restored when the flag is set off or any other
  583. * than d-mic is used as the current input source.
  584. */
  585. static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)
  586. {
  587. struct alc_spec *spec = codec->spec;
  588. int src, nums;
  589. if (!spec->inv_dmic_fixup)
  590. return;
  591. if (!spec->inv_dmic_muted && !force)
  592. return;
  593. nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;
  594. for (src = 0; src < nums; src++) {
  595. bool dmic_fixup = false;
  596. if (spec->inv_dmic_muted &&
  597. spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)
  598. dmic_fixup = true;
  599. if (!dmic_fixup && !force)
  600. continue;
  601. alc_inv_dmic_sync_adc(codec, src);
  602. }
  603. }
  604. static void alc_inv_dmic_hook(struct hda_codec *codec,
  605. struct snd_ctl_elem_value *ucontrol)
  606. {
  607. alc_inv_dmic_sync(codec, false);
  608. }
  609. static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,
  610. struct snd_ctl_elem_value *ucontrol)
  611. {
  612. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  613. struct alc_spec *spec = codec->spec;
  614. ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;
  615. return 0;
  616. }
  617. static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,
  618. struct snd_ctl_elem_value *ucontrol)
  619. {
  620. struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  621. struct alc_spec *spec = codec->spec;
  622. unsigned int val = !ucontrol->value.integer.value[0];
  623. if (val == spec->inv_dmic_muted)
  624. return 0;
  625. spec->inv_dmic_muted = val;
  626. alc_inv_dmic_sync(codec, true);
  627. return 0;
  628. }
  629. static const struct snd_kcontrol_new alc_inv_dmic_sw = {
  630. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  631. .name = "Inverted Internal Mic Capture Switch",
  632. .info = snd_ctl_boolean_mono_info,
  633. .get = alc_inv_dmic_sw_get,
  634. .put = alc_inv_dmic_sw_put,
  635. };
  636. static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)
  637. {
  638. struct alc_spec *spec = codec->spec;
  639. if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))
  640. return -ENOMEM;
  641. spec->inv_dmic_fixup = 1;
  642. spec->inv_dmic_muted = 0;
  643. spec->inv_dmic_pin = nid;
  644. spec->gen.cap_sync_hook = alc_inv_dmic_hook;
  645. return 0;
  646. }
  647. /* typically the digital mic is put at node 0x12 */
  648. static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,
  649. const struct hda_fixup *fix, int action)
  650. {
  651. if (action == HDA_FIXUP_ACT_PROBE)
  652. alc_add_inv_dmic_mixer(codec, 0x12);
  653. }
  654. #ifdef CONFIG_SND_HDA_INPUT_BEEP
  655. /* additional beep mixers; the actual parameters are overwritten at build */
  656. static const struct snd_kcontrol_new alc_beep_mixer[] = {
  657. HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
  658. HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
  659. { } /* end */
  660. };
  661. #endif
  662. static int alc_build_controls(struct hda_codec *codec)
  663. {
  664. struct alc_spec *spec = codec->spec;
  665. int i, err;
  666. err = snd_hda_gen_build_controls(codec);
  667. if (err < 0)
  668. return err;
  669. for (i = 0; i < spec->num_mixers; i++) {
  670. err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
  671. if (err < 0)
  672. return err;
  673. }
  674. #ifdef CONFIG_SND_HDA_INPUT_BEEP
  675. /* create beep controls if needed */
  676. if (spec->beep_amp) {
  677. const struct snd_kcontrol_new *knew;
  678. for (knew = alc_beep_mixer; knew->name; knew++) {
  679. struct snd_kcontrol *kctl;
  680. kctl = snd_ctl_new1(knew, codec);
  681. if (!kctl)
  682. return -ENOMEM;
  683. kctl->private_value = spec->beep_amp;
  684. err = snd_hda_ctl_add(codec, 0, kctl);
  685. if (err < 0)
  686. return err;
  687. }
  688. }
  689. #endif
  690. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
  691. return 0;
  692. }
  693. /*
  694. * Common callbacks
  695. */
  696. static int alc_init(struct hda_codec *codec)
  697. {
  698. struct alc_spec *spec = codec->spec;
  699. if (spec->init_hook)
  700. spec->init_hook(codec);
  701. alc_fix_pll(codec);
  702. alc_auto_init_amp(codec, spec->init_amp);
  703. snd_hda_gen_init(codec);
  704. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
  705. return 0;
  706. }
  707. static inline void alc_shutup(struct hda_codec *codec)
  708. {
  709. struct alc_spec *spec = codec->spec;
  710. if (spec && spec->shutup)
  711. spec->shutup(codec);
  712. snd_hda_shutup_pins(codec);
  713. }
  714. static void alc_free(struct hda_codec *codec)
  715. {
  716. struct alc_spec *spec = codec->spec;
  717. if (!spec)
  718. return;
  719. snd_hda_gen_spec_free(&spec->gen);
  720. snd_hda_detach_beep_device(codec);
  721. kfree(spec);
  722. }
  723. #ifdef CONFIG_PM
  724. static void alc_power_eapd(struct hda_codec *codec)
  725. {
  726. alc_auto_setup_eapd(codec, false);
  727. }
  728. static int alc_suspend(struct hda_codec *codec)
  729. {
  730. struct alc_spec *spec = codec->spec;
  731. alc_shutup(codec);
  732. if (spec && spec->power_hook)
  733. spec->power_hook(codec);
  734. return 0;
  735. }
  736. #endif
  737. #ifdef CONFIG_PM
  738. static int alc_resume(struct hda_codec *codec)
  739. {
  740. msleep(150); /* to avoid pop noise */
  741. codec->patch_ops.init(codec);
  742. snd_hda_codec_resume_amp(codec);
  743. snd_hda_codec_resume_cache(codec);
  744. alc_inv_dmic_sync(codec, true);
  745. hda_call_check_power_status(codec, 0x01);
  746. return 0;
  747. }
  748. #endif
  749. /*
  750. */
  751. static const struct hda_codec_ops alc_patch_ops = {
  752. .build_controls = alc_build_controls,
  753. .build_pcms = snd_hda_gen_build_pcms,
  754. .init = alc_init,
  755. .free = alc_free,
  756. .unsol_event = snd_hda_jack_unsol_event,
  757. #ifdef CONFIG_PM
  758. .resume = alc_resume,
  759. .suspend = alc_suspend,
  760. .check_power_status = snd_hda_gen_check_power_status,
  761. #endif
  762. .reboot_notify = alc_shutup,
  763. };
  764. /* replace the codec chip_name with the given string */
  765. static int alc_codec_rename(struct hda_codec *codec, const char *name)
  766. {
  767. kfree(codec->chip_name);
  768. codec->chip_name = kstrdup(name, GFP_KERNEL);
  769. if (!codec->chip_name) {
  770. alc_free(codec);
  771. return -ENOMEM;
  772. }
  773. return 0;
  774. }
  775. /*
  776. * Rename codecs appropriately from COEF value
  777. */
  778. struct alc_codec_rename_table {
  779. unsigned int vendor_id;
  780. unsigned short coef_mask;
  781. unsigned short coef_bits;
  782. const char *name;
  783. };
  784. static struct alc_codec_rename_table rename_tbl[] = {
  785. { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
  786. { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
  787. { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
  788. { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
  789. { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
  790. { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
  791. { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
  792. { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
  793. { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
  794. { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
  795. { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
  796. { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
  797. { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
  798. { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
  799. { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
  800. { } /* terminator */
  801. };
  802. static int alc_codec_rename_from_preset(struct hda_codec *codec)
  803. {
  804. const struct alc_codec_rename_table *p;
  805. for (p = rename_tbl; p->vendor_id; p++) {
  806. if (p->vendor_id != codec->vendor_id)
  807. continue;
  808. if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
  809. return alc_codec_rename(codec, p->name);
  810. }
  811. return 0;
  812. }
  813. /*
  814. * Digital-beep handlers
  815. */
  816. #ifdef CONFIG_SND_HDA_INPUT_BEEP
  817. #define set_beep_amp(spec, nid, idx, dir) \
  818. ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
  819. static const struct snd_pci_quirk beep_white_list[] = {
  820. SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
  821. SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
  822. SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
  823. SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
  824. SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
  825. SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
  826. SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
  827. {}
  828. };
  829. static inline int has_cdefine_beep(struct hda_codec *codec)
  830. {
  831. struct alc_spec *spec = codec->spec;
  832. const struct snd_pci_quirk *q;
  833. q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
  834. if (q)
  835. return q->value;
  836. return spec->cdefine.enable_pcbeep;
  837. }
  838. #else
  839. #define set_beep_amp(spec, nid, idx, dir) /* NOP */
  840. #define has_cdefine_beep(codec) 0
  841. #endif
  842. /* parse the BIOS configuration and set up the alc_spec */
  843. /* return 1 if successful, 0 if the proper config is not found,
  844. * or a negative error code
  845. */
  846. static int alc_parse_auto_config(struct hda_codec *codec,
  847. const hda_nid_t *ignore_nids,
  848. const hda_nid_t *ssid_nids)
  849. {
  850. struct alc_spec *spec = codec->spec;
  851. struct auto_pin_cfg *cfg = &spec->gen.autocfg;
  852. int err;
  853. err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
  854. spec->parse_flags);
  855. if (err < 0)
  856. return err;
  857. if (ssid_nids)
  858. alc_ssid_check(codec, ssid_nids);
  859. err = snd_hda_gen_parse_auto_config(codec, cfg);
  860. if (err < 0)
  861. return err;
  862. return 1;
  863. }
  864. /* common preparation job for alc_spec */
  865. static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
  866. {
  867. struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
  868. int err;
  869. if (!spec)
  870. return -ENOMEM;
  871. codec->spec = spec;
  872. snd_hda_gen_spec_init(&spec->gen);
  873. spec->gen.mixer_nid = mixer_nid;
  874. spec->gen.own_eapd_ctl = 1;
  875. codec->single_adc_amp = 1;
  876. /* FIXME: do we need this for all Realtek codec models? */
  877. codec->spdif_status_reset = 1;
  878. err = alc_codec_rename_from_preset(codec);
  879. if (err < 0) {
  880. kfree(spec);
  881. return err;
  882. }
  883. return 0;
  884. }
  885. static int alc880_parse_auto_config(struct hda_codec *codec)
  886. {
  887. static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
  888. static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  889. return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
  890. }
  891. /*
  892. * ALC880 fix-ups
  893. */
  894. enum {
  895. ALC880_FIXUP_GPIO1,
  896. ALC880_FIXUP_GPIO2,
  897. ALC880_FIXUP_MEDION_RIM,
  898. ALC880_FIXUP_LG,
  899. ALC880_FIXUP_W810,
  900. ALC880_FIXUP_EAPD_COEF,
  901. ALC880_FIXUP_TCL_S700,
  902. ALC880_FIXUP_VOL_KNOB,
  903. ALC880_FIXUP_FUJITSU,
  904. ALC880_FIXUP_F1734,
  905. ALC880_FIXUP_UNIWILL,
  906. ALC880_FIXUP_UNIWILL_DIG,
  907. ALC880_FIXUP_Z71V,
  908. ALC880_FIXUP_3ST_BASE,
  909. ALC880_FIXUP_3ST,
  910. ALC880_FIXUP_3ST_DIG,
  911. ALC880_FIXUP_5ST_BASE,
  912. ALC880_FIXUP_5ST,
  913. ALC880_FIXUP_5ST_DIG,
  914. ALC880_FIXUP_6ST_BASE,
  915. ALC880_FIXUP_6ST,
  916. ALC880_FIXUP_6ST_DIG,
  917. };
  918. /* enable the volume-knob widget support on NID 0x21 */
  919. static void alc880_fixup_vol_knob(struct hda_codec *codec,
  920. const struct hda_fixup *fix, int action)
  921. {
  922. if (action == HDA_FIXUP_ACT_PROBE)
  923. snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);
  924. }
  925. static const struct hda_fixup alc880_fixups[] = {
  926. [ALC880_FIXUP_GPIO1] = {
  927. .type = HDA_FIXUP_VERBS,
  928. .v.verbs = alc_gpio1_init_verbs,
  929. },
  930. [ALC880_FIXUP_GPIO2] = {
  931. .type = HDA_FIXUP_VERBS,
  932. .v.verbs = alc_gpio2_init_verbs,
  933. },
  934. [ALC880_FIXUP_MEDION_RIM] = {
  935. .type = HDA_FIXUP_VERBS,
  936. .v.verbs = (const struct hda_verb[]) {
  937. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  938. { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
  939. { }
  940. },
  941. .chained = true,
  942. .chain_id = ALC880_FIXUP_GPIO2,
  943. },
  944. [ALC880_FIXUP_LG] = {
  945. .type = HDA_FIXUP_PINS,
  946. .v.pins = (const struct hda_pintbl[]) {
  947. /* disable bogus unused pins */
  948. { 0x16, 0x411111f0 },
  949. { 0x18, 0x411111f0 },
  950. { 0x1a, 0x411111f0 },
  951. { }
  952. }
  953. },
  954. [ALC880_FIXUP_W810] = {
  955. .type = HDA_FIXUP_PINS,
  956. .v.pins = (const struct hda_pintbl[]) {
  957. /* disable bogus unused pins */
  958. { 0x17, 0x411111f0 },
  959. { }
  960. },
  961. .chained = true,
  962. .chain_id = ALC880_FIXUP_GPIO2,
  963. },
  964. [ALC880_FIXUP_EAPD_COEF] = {
  965. .type = HDA_FIXUP_VERBS,
  966. .v.verbs = (const struct hda_verb[]) {
  967. /* change to EAPD mode */
  968. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  969. { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
  970. {}
  971. },
  972. },
  973. [ALC880_FIXUP_TCL_S700] = {
  974. .type = HDA_FIXUP_VERBS,
  975. .v.verbs = (const struct hda_verb[]) {
  976. /* change to EAPD mode */
  977. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  978. { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
  979. {}
  980. },
  981. .chained = true,
  982. .chain_id = ALC880_FIXUP_GPIO2,
  983. },
  984. [ALC880_FIXUP_VOL_KNOB] = {
  985. .type = HDA_FIXUP_FUNC,
  986. .v.func = alc880_fixup_vol_knob,
  987. },
  988. [ALC880_FIXUP_FUJITSU] = {
  989. /* override all pins as BIOS on old Amilo is broken */
  990. .type = HDA_FIXUP_PINS,
  991. .v.pins = (const struct hda_pintbl[]) {
  992. { 0x14, 0x0121411f }, /* HP */
  993. { 0x15, 0x99030120 }, /* speaker */
  994. { 0x16, 0x99030130 }, /* bass speaker */
  995. { 0x17, 0x411111f0 }, /* N/A */
  996. { 0x18, 0x411111f0 }, /* N/A */
  997. { 0x19, 0x01a19950 }, /* mic-in */
  998. { 0x1a, 0x411111f0 }, /* N/A */
  999. { 0x1b, 0x411111f0 }, /* N/A */
  1000. { 0x1c, 0x411111f0 }, /* N/A */
  1001. { 0x1d, 0x411111f0 }, /* N/A */
  1002. { 0x1e, 0x01454140 }, /* SPDIF out */
  1003. { }
  1004. },
  1005. .chained = true,
  1006. .chain_id = ALC880_FIXUP_VOL_KNOB,
  1007. },
  1008. [ALC880_FIXUP_F1734] = {
  1009. /* almost compatible with FUJITSU, but no bass and SPDIF */
  1010. .type = HDA_FIXUP_PINS,
  1011. .v.pins = (const struct hda_pintbl[]) {
  1012. { 0x14, 0x0121411f }, /* HP */
  1013. { 0x15, 0x99030120 }, /* speaker */
  1014. { 0x16, 0x411111f0 }, /* N/A */
  1015. { 0x17, 0x411111f0 }, /* N/A */
  1016. { 0x18, 0x411111f0 }, /* N/A */
  1017. { 0x19, 0x01a19950 }, /* mic-in */
  1018. { 0x1a, 0x411111f0 }, /* N/A */
  1019. { 0x1b, 0x411111f0 }, /* N/A */
  1020. { 0x1c, 0x411111f0 }, /* N/A */
  1021. { 0x1d, 0x411111f0 }, /* N/A */
  1022. { 0x1e, 0x411111f0 }, /* N/A */
  1023. { }
  1024. },
  1025. .chained = true,
  1026. .chain_id = ALC880_FIXUP_VOL_KNOB,
  1027. },
  1028. [ALC880_FIXUP_UNIWILL] = {
  1029. /* need to fix HP and speaker pins to be parsed correctly */
  1030. .type = HDA_FIXUP_PINS,
  1031. .v.pins = (const struct hda_pintbl[]) {
  1032. { 0x14, 0x0121411f }, /* HP */
  1033. { 0x15, 0x99030120 }, /* speaker */
  1034. { 0x16, 0x99030130 }, /* bass speaker */
  1035. { }
  1036. },
  1037. },
  1038. [ALC880_FIXUP_UNIWILL_DIG] = {
  1039. .type = HDA_FIXUP_PINS,
  1040. .v.pins = (const struct hda_pintbl[]) {
  1041. /* disable bogus unused pins */
  1042. { 0x17, 0x411111f0 },
  1043. { 0x19, 0x411111f0 },
  1044. { 0x1b, 0x411111f0 },
  1045. { 0x1f, 0x411111f0 },
  1046. { }
  1047. }
  1048. },
  1049. [ALC880_FIXUP_Z71V] = {
  1050. .type = HDA_FIXUP_PINS,
  1051. .v.pins = (const struct hda_pintbl[]) {
  1052. /* set up the whole pins as BIOS is utterly broken */
  1053. { 0x14, 0x99030120 }, /* speaker */
  1054. { 0x15, 0x0121411f }, /* HP */
  1055. { 0x16, 0x411111f0 }, /* N/A */
  1056. { 0x17, 0x411111f0 }, /* N/A */
  1057. { 0x18, 0x01a19950 }, /* mic-in */
  1058. { 0x19, 0x411111f0 }, /* N/A */
  1059. { 0x1a, 0x01813031 }, /* line-in */
  1060. { 0x1b, 0x411111f0 }, /* N/A */
  1061. { 0x1c, 0x411111f0 }, /* N/A */
  1062. { 0x1d, 0x411111f0 }, /* N/A */
  1063. { 0x1e, 0x0144111e }, /* SPDIF */
  1064. { }
  1065. }
  1066. },
  1067. [ALC880_FIXUP_3ST_BASE] = {
  1068. .type = HDA_FIXUP_PINS,
  1069. .v.pins = (const struct hda_pintbl[]) {
  1070. { 0x14, 0x01014010 }, /* line-out */
  1071. { 0x15, 0x411111f0 }, /* N/A */
  1072. { 0x16, 0x411111f0 }, /* N/A */
  1073. { 0x17, 0x411111f0 }, /* N/A */
  1074. { 0x18, 0x01a19c30 }, /* mic-in */
  1075. { 0x19, 0x0121411f }, /* HP */
  1076. { 0x1a, 0x01813031 }, /* line-in */
  1077. { 0x1b, 0x02a19c40 }, /* front-mic */
  1078. { 0x1c, 0x411111f0 }, /* N/A */
  1079. { 0x1d, 0x411111f0 }, /* N/A */
  1080. /* 0x1e is filled in below */
  1081. { 0x1f, 0x411111f0 }, /* N/A */
  1082. { }
  1083. }
  1084. },
  1085. [ALC880_FIXUP_3ST] = {
  1086. .type = HDA_FIXUP_PINS,
  1087. .v.pins = (const struct hda_pintbl[]) {
  1088. { 0x1e, 0x411111f0 }, /* N/A */
  1089. { }
  1090. },
  1091. .chained = true,
  1092. .chain_id = ALC880_FIXUP_3ST_BASE,
  1093. },
  1094. [ALC880_FIXUP_3ST_DIG] = {
  1095. .type = HDA_FIXUP_PINS,
  1096. .v.pins = (const struct hda_pintbl[]) {
  1097. { 0x1e, 0x0144111e }, /* SPDIF */
  1098. { }
  1099. },
  1100. .chained = true,
  1101. .chain_id = ALC880_FIXUP_3ST_BASE,
  1102. },
  1103. [ALC880_FIXUP_5ST_BASE] = {
  1104. .type = HDA_FIXUP_PINS,
  1105. .v.pins = (const struct hda_pintbl[]) {
  1106. { 0x14, 0x01014010 }, /* front */
  1107. { 0x15, 0x411111f0 }, /* N/A */
  1108. { 0x16, 0x01011411 }, /* CLFE */
  1109. { 0x17, 0x01016412 }, /* surr */
  1110. { 0x18, 0x01a19c30 }, /* mic-in */
  1111. { 0x19, 0x0121411f }, /* HP */
  1112. { 0x1a, 0x01813031 }, /* line-in */
  1113. { 0x1b, 0x02a19c40 }, /* front-mic */
  1114. { 0x1c, 0x411111f0 }, /* N/A */
  1115. { 0x1d, 0x411111f0 }, /* N/A */
  1116. /* 0x1e is filled in below */
  1117. { 0x1f, 0x411111f0 }, /* N/A */
  1118. { }
  1119. }
  1120. },
  1121. [ALC880_FIXUP_5ST] = {
  1122. .type = HDA_FIXUP_PINS,
  1123. .v.pins = (const struct hda_pintbl[]) {
  1124. { 0x1e, 0x411111f0 }, /* N/A */
  1125. { }
  1126. },
  1127. .chained = true,
  1128. .chain_id = ALC880_FIXUP_5ST_BASE,
  1129. },
  1130. [ALC880_FIXUP_5ST_DIG] = {
  1131. .type = HDA_FIXUP_PINS,
  1132. .v.pins = (const struct hda_pintbl[]) {
  1133. { 0x1e, 0x0144111e }, /* SPDIF */
  1134. { }
  1135. },
  1136. .chained = true,
  1137. .chain_id = ALC880_FIXUP_5ST_BASE,
  1138. },
  1139. [ALC880_FIXUP_6ST_BASE] = {
  1140. .type = HDA_FIXUP_PINS,
  1141. .v.pins = (const struct hda_pintbl[]) {
  1142. { 0x14, 0x01014010 }, /* front */
  1143. { 0x15, 0x01016412 }, /* surr */
  1144. { 0x16, 0x01011411 }, /* CLFE */
  1145. { 0x17, 0x01012414 }, /* side */
  1146. { 0x18, 0x01a19c30 }, /* mic-in */
  1147. { 0x19, 0x02a19c40 }, /* front-mic */
  1148. { 0x1a, 0x01813031 }, /* line-in */
  1149. { 0x1b, 0x0121411f }, /* HP */
  1150. { 0x1c, 0x411111f0 }, /* N/A */
  1151. { 0x1d, 0x411111f0 }, /* N/A */
  1152. /* 0x1e is filled in below */
  1153. { 0x1f, 0x411111f0 }, /* N/A */
  1154. { }
  1155. }
  1156. },
  1157. [ALC880_FIXUP_6ST] = {
  1158. .type = HDA_FIXUP_PINS,
  1159. .v.pins = (const struct hda_pintbl[]) {
  1160. { 0x1e, 0x411111f0 }, /* N/A */
  1161. { }
  1162. },
  1163. .chained = true,
  1164. .chain_id = ALC880_FIXUP_6ST_BASE,
  1165. },
  1166. [ALC880_FIXUP_6ST_DIG] = {
  1167. .type = HDA_FIXUP_PINS,
  1168. .v.pins = (const struct hda_pintbl[]) {
  1169. { 0x1e, 0x0144111e }, /* SPDIF */
  1170. { }
  1171. },
  1172. .chained = true,
  1173. .chain_id = ALC880_FIXUP_6ST_BASE,
  1174. },
  1175. };
  1176. static const struct snd_pci_quirk alc880_fixup_tbl[] = {
  1177. SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
  1178. SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
  1179. SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
  1180. SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
  1181. SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
  1182. SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
  1183. SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
  1184. SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
  1185. SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
  1186. SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
  1187. SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
  1188. SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_FIXUP_F1734),
  1189. SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
  1190. SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
  1191. SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
  1192. SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
  1193. SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
  1194. SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
  1195. SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
  1196. /* Below is the copied entries from alc880_quirks.c.
  1197. * It's not quite sure whether BIOS sets the correct pin-config table
  1198. * on these machines, thus they are kept to be compatible with
  1199. * the old static quirks. Once when it's confirmed to work without
  1200. * these overrides, it'd be better to remove.
  1201. */
  1202. SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
  1203. SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
  1204. SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
  1205. SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
  1206. SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
  1207. SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
  1208. SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
  1209. SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
  1210. SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
  1211. SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
  1212. SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
  1213. SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
  1214. SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
  1215. SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
  1216. SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
  1217. SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
  1218. SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
  1219. SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
  1220. SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
  1221. SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
  1222. SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
  1223. SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
  1224. SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
  1225. SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1226. SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1227. SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1228. SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
  1229. SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1230. SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
  1231. SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
  1232. SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1233. SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1234. SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
  1235. /* default Intel */
  1236. SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
  1237. SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
  1238. SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
  1239. {}
  1240. };
  1241. static const struct hda_model_fixup alc880_fixup_models[] = {
  1242. {.id = ALC880_FIXUP_3ST, .name = "3stack"},
  1243. {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
  1244. {.id = ALC880_FIXUP_5ST, .name = "5stack"},
  1245. {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
  1246. {.id = ALC880_FIXUP_6ST, .name = "6stack"},
  1247. {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
  1248. {}
  1249. };
  1250. /*
  1251. * OK, here we have finally the patch for ALC880
  1252. */
  1253. static int patch_alc880(struct hda_codec *codec)
  1254. {
  1255. struct alc_spec *spec;
  1256. int err;
  1257. err = alc_alloc_spec(codec, 0x0b);
  1258. if (err < 0)
  1259. return err;
  1260. spec = codec->spec;
  1261. spec->gen.need_dac_fix = 1;
  1262. snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
  1263. alc880_fixups);
  1264. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  1265. /* automatic parse from the BIOS config */
  1266. err = alc880_parse_auto_config(codec);
  1267. if (err < 0)
  1268. goto error;
  1269. if (!spec->gen.no_analog) {
  1270. err = snd_hda_attach_beep_device(codec, 0x1);
  1271. if (err < 0)
  1272. goto error;
  1273. set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
  1274. }
  1275. codec->patch_ops = alc_patch_ops;
  1276. codec->patch_ops.unsol_event = alc880_unsol_event;
  1277. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  1278. return 0;
  1279. error:
  1280. alc_free(codec);
  1281. return err;
  1282. }
  1283. /*
  1284. * ALC260 support
  1285. */
  1286. static int alc260_parse_auto_config(struct hda_codec *codec)
  1287. {
  1288. static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
  1289. static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
  1290. return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
  1291. }
  1292. /*
  1293. * Pin config fixes
  1294. */
  1295. enum {
  1296. ALC260_FIXUP_HP_DC5750,
  1297. ALC260_FIXUP_HP_PIN_0F,
  1298. ALC260_FIXUP_COEF,
  1299. ALC260_FIXUP_GPIO1,
  1300. ALC260_FIXUP_GPIO1_TOGGLE,
  1301. ALC260_FIXUP_REPLACER,
  1302. ALC260_FIXUP_HP_B1900,
  1303. ALC260_FIXUP_KN1,
  1304. ALC260_FIXUP_FSC_S7020,
  1305. };
  1306. static void alc260_gpio1_automute(struct hda_codec *codec)
  1307. {
  1308. struct alc_spec *spec = codec->spec;
  1309. snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
  1310. spec->gen.hp_jack_present);
  1311. }
  1312. static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
  1313. const struct hda_fixup *fix, int action)
  1314. {
  1315. struct alc_spec *spec = codec->spec;
  1316. if (action == HDA_FIXUP_ACT_PROBE) {
  1317. /* although the machine has only one output pin, we need to
  1318. * toggle GPIO1 according to the jack state
  1319. */
  1320. spec->gen.automute_hook = alc260_gpio1_automute;
  1321. spec->gen.detect_hp = 1;
  1322. spec->gen.automute_speaker = 1;
  1323. spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
  1324. snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,
  1325. snd_hda_gen_hp_automute);
  1326. snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
  1327. }
  1328. }
  1329. static void alc260_fixup_kn1(struct hda_codec *codec,
  1330. const struct hda_fixup *fix, int action)
  1331. {
  1332. struct alc_spec *spec = codec->spec;
  1333. static const struct hda_pintbl pincfgs[] = {
  1334. { 0x0f, 0x02214000 }, /* HP/speaker */
  1335. { 0x12, 0x90a60160 }, /* int mic */
  1336. { 0x13, 0x02a19000 }, /* ext mic */
  1337. { 0x18, 0x01446000 }, /* SPDIF out */
  1338. /* disable bogus I/O pins */
  1339. { 0x10, 0x411111f0 },
  1340. { 0x11, 0x411111f0 },
  1341. { 0x14, 0x411111f0 },
  1342. { 0x15, 0x411111f0 },
  1343. { 0x16, 0x411111f0 },
  1344. { 0x17, 0x411111f0 },
  1345. { 0x19, 0x411111f0 },
  1346. { }
  1347. };
  1348. switch (action) {
  1349. case HDA_FIXUP_ACT_PRE_PROBE:
  1350. snd_hda_apply_pincfgs(codec, pincfgs);
  1351. break;
  1352. case HDA_FIXUP_ACT_PROBE:
  1353. spec->init_amp = ALC_INIT_NONE;
  1354. break;
  1355. }
  1356. }
  1357. static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
  1358. const struct hda_fixup *fix, int action)
  1359. {
  1360. struct alc_spec *spec = codec->spec;
  1361. if (action == HDA_FIXUP_ACT_PRE_PROBE)
  1362. spec->gen.add_out_jack_modes = 1;
  1363. }
  1364. static const struct hda_fixup alc260_fixups[] = {
  1365. [ALC260_FIXUP_HP_DC5750] = {
  1366. .type = HDA_FIXUP_PINS,
  1367. .v.pins = (const struct hda_pintbl[]) {
  1368. { 0x11, 0x90130110 }, /* speaker */
  1369. { }
  1370. }
  1371. },
  1372. [ALC260_FIXUP_HP_PIN_0F] = {
  1373. .type = HDA_FIXUP_PINS,
  1374. .v.pins = (const struct hda_pintbl[]) {
  1375. { 0x0f, 0x01214000 }, /* HP */
  1376. { }
  1377. }
  1378. },
  1379. [ALC260_FIXUP_COEF] = {
  1380. .type = HDA_FIXUP_VERBS,
  1381. .v.verbs = (const struct hda_verb[]) {
  1382. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  1383. { 0x20, AC_VERB_SET_PROC_COEF, 0x3040 },
  1384. { }
  1385. },
  1386. .chained = true,
  1387. .chain_id = ALC260_FIXUP_HP_PIN_0F,
  1388. },
  1389. [ALC260_FIXUP_GPIO1] = {
  1390. .type = HDA_FIXUP_VERBS,
  1391. .v.verbs = alc_gpio1_init_verbs,
  1392. },
  1393. [ALC260_FIXUP_GPIO1_TOGGLE] = {
  1394. .type = HDA_FIXUP_FUNC,
  1395. .v.func = alc260_fixup_gpio1_toggle,
  1396. .chained = true,
  1397. .chain_id = ALC260_FIXUP_HP_PIN_0F,
  1398. },
  1399. [ALC260_FIXUP_REPLACER] = {
  1400. .type = HDA_FIXUP_VERBS,
  1401. .v.verbs = (const struct hda_verb[]) {
  1402. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  1403. { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
  1404. { }
  1405. },
  1406. .chained = true,
  1407. .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
  1408. },
  1409. [ALC260_FIXUP_HP_B1900] = {
  1410. .type = HDA_FIXUP_FUNC,
  1411. .v.func = alc260_fixup_gpio1_toggle,
  1412. .chained = true,
  1413. .chain_id = ALC260_FIXUP_COEF,
  1414. },
  1415. [ALC260_FIXUP_KN1] = {
  1416. .type = HDA_FIXUP_FUNC,
  1417. .v.func = alc260_fixup_kn1,
  1418. },
  1419. [ALC260_FIXUP_FSC_S7020] = {
  1420. .type = HDA_FIXUP_FUNC,
  1421. .v.func = alc260_fixup_fsc_s7020,
  1422. },
  1423. };
  1424. static const struct snd_pci_quirk alc260_fixup_tbl[] = {
  1425. SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
  1426. SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
  1427. SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
  1428. SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
  1429. SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
  1430. SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
  1431. SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
  1432. SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
  1433. SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
  1434. SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
  1435. {}
  1436. };
  1437. /*
  1438. */
  1439. static int patch_alc260(struct hda_codec *codec)
  1440. {
  1441. struct alc_spec *spec;
  1442. int err;
  1443. err = alc_alloc_spec(codec, 0x07);
  1444. if (err < 0)
  1445. return err;
  1446. spec = codec->spec;
  1447. /* as quite a few machines require HP amp for speaker outputs,
  1448. * it's easier to enable it unconditionally; even if it's unneeded,
  1449. * it's almost harmless.
  1450. */
  1451. spec->gen.prefer_hp_amp = 1;
  1452. snd_hda_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
  1453. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  1454. /* automatic parse from the BIOS config */
  1455. err = alc260_parse_auto_config(codec);
  1456. if (err < 0)
  1457. goto error;
  1458. if (!spec->gen.no_analog) {
  1459. err = snd_hda_attach_beep_device(codec, 0x1);
  1460. if (err < 0)
  1461. goto error;
  1462. set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
  1463. }
  1464. codec->patch_ops = alc_patch_ops;
  1465. spec->shutup = alc_eapd_shutup;
  1466. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  1467. return 0;
  1468. error:
  1469. alc_free(codec);
  1470. return err;
  1471. }
  1472. /*
  1473. * ALC882/883/885/888/889 support
  1474. *
  1475. * ALC882 is almost identical with ALC880 but has cleaner and more flexible
  1476. * configuration. Each pin widget can choose any input DACs and a mixer.
  1477. * Each ADC is connected from a mixer of all inputs. This makes possible
  1478. * 6-channel independent captures.
  1479. *
  1480. * In addition, an independent DAC for the multi-playback (not used in this
  1481. * driver yet).
  1482. */
  1483. /*
  1484. * Pin config fixes
  1485. */
  1486. enum {
  1487. ALC882_FIXUP_ABIT_AW9D_MAX,
  1488. ALC882_FIXUP_LENOVO_Y530,
  1489. ALC882_FIXUP_PB_M5210,
  1490. ALC882_FIXUP_ACER_ASPIRE_7736,
  1491. ALC882_FIXUP_ASUS_W90V,
  1492. ALC889_FIXUP_CD,
  1493. ALC889_FIXUP_VAIO_TT,
  1494. ALC888_FIXUP_EEE1601,
  1495. ALC882_FIXUP_EAPD,
  1496. ALC883_FIXUP_EAPD,
  1497. ALC883_FIXUP_ACER_EAPD,
  1498. ALC882_FIXUP_GPIO1,
  1499. ALC882_FIXUP_GPIO2,
  1500. ALC882_FIXUP_GPIO3,
  1501. ALC889_FIXUP_COEF,
  1502. ALC882_FIXUP_ASUS_W2JC,
  1503. ALC882_FIXUP_ACER_ASPIRE_4930G,
  1504. ALC882_FIXUP_ACER_ASPIRE_8930G,
  1505. ALC882_FIXUP_ASPIRE_8930G_VERBS,
  1506. ALC885_FIXUP_MACPRO_GPIO,
  1507. ALC889_FIXUP_DAC_ROUTE,
  1508. ALC889_FIXUP_MBP_VREF,
  1509. ALC889_FIXUP_IMAC91_VREF,
  1510. ALC882_FIXUP_INV_DMIC,
  1511. ALC882_FIXUP_NO_PRIMARY_HP,
  1512. };
  1513. static void alc889_fixup_coef(struct hda_codec *codec,
  1514. const struct hda_fixup *fix, int action)
  1515. {
  1516. if (action != HDA_FIXUP_ACT_INIT)
  1517. return;
  1518. alc889_coef_init(codec);
  1519. }
  1520. /* toggle speaker-output according to the hp-jack state */
  1521. static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
  1522. {
  1523. unsigned int gpiostate, gpiomask, gpiodir;
  1524. gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
  1525. AC_VERB_GET_GPIO_DATA, 0);
  1526. if (!muted)
  1527. gpiostate |= (1 << pin);
  1528. else
  1529. gpiostate &= ~(1 << pin);
  1530. gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
  1531. AC_VERB_GET_GPIO_MASK, 0);
  1532. gpiomask |= (1 << pin);
  1533. gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
  1534. AC_VERB_GET_GPIO_DIRECTION, 0);
  1535. gpiodir |= (1 << pin);
  1536. snd_hda_codec_write(codec, codec->afg, 0,
  1537. AC_VERB_SET_GPIO_MASK, gpiomask);
  1538. snd_hda_codec_write(codec, codec->afg, 0,
  1539. AC_VERB_SET_GPIO_DIRECTION, gpiodir);
  1540. msleep(1);
  1541. snd_hda_codec_write(codec, codec->afg, 0,
  1542. AC_VERB_SET_GPIO_DATA, gpiostate);
  1543. }
  1544. /* set up GPIO at initialization */
  1545. static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
  1546. const struct hda_fixup *fix, int action)
  1547. {
  1548. if (action != HDA_FIXUP_ACT_INIT)
  1549. return;
  1550. alc882_gpio_mute(codec, 0, 0);
  1551. alc882_gpio_mute(codec, 1, 0);
  1552. }
  1553. /* Fix the connection of some pins for ALC889:
  1554. * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
  1555. * work correctly (bko#42740)
  1556. */
  1557. static void alc889_fixup_dac_route(struct hda_codec *codec,
  1558. const struct hda_fixup *fix, int action)
  1559. {
  1560. if (action == HDA_FIXUP_ACT_PRE_PROBE) {
  1561. /* fake the connections during parsing the tree */
  1562. hda_nid_t conn1[2] = { 0x0c, 0x0d };
  1563. hda_nid_t conn2[2] = { 0x0e, 0x0f };
  1564. snd_hda_override_conn_list(codec, 0x14, 2, conn1);
  1565. snd_hda_override_conn_list(codec, 0x15, 2, conn1);
  1566. snd_hda_override_conn_list(codec, 0x18, 2, conn2);
  1567. snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
  1568. } else if (action == HDA_FIXUP_ACT_PROBE) {
  1569. /* restore the connections */
  1570. hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
  1571. snd_hda_override_conn_list(codec, 0x14, 5, conn);
  1572. snd_hda_override_conn_list(codec, 0x15, 5, conn);
  1573. snd_hda_override_conn_list(codec, 0x18, 5, conn);
  1574. snd_hda_override_conn_list(codec, 0x1a, 5, conn);
  1575. }
  1576. }
  1577. /* Set VREF on HP pin */
  1578. static void alc889_fixup_mbp_vref(struct hda_codec *codec,
  1579. const struct hda_fixup *fix, int action)
  1580. {
  1581. struct alc_spec *spec = codec->spec;
  1582. static hda_nid_t nids[2] = { 0x14, 0x15 };
  1583. int i;
  1584. if (action != HDA_FIXUP_ACT_INIT)
  1585. return;
  1586. for (i = 0; i < ARRAY_SIZE(nids); i++) {
  1587. unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
  1588. if (get_defcfg_device(val) != AC_JACK_HP_OUT)
  1589. continue;
  1590. val = snd_hda_codec_get_pin_target(codec, nids[i]);
  1591. val |= AC_PINCTL_VREF_80;
  1592. snd_hda_set_pin_ctl(codec, nids[i], val);
  1593. spec->gen.keep_vref_in_automute = 1;
  1594. break;
  1595. }
  1596. }
  1597. /* Set VREF on speaker pins on imac91 */
  1598. static void alc889_fixup_imac91_vref(struct hda_codec *codec,
  1599. const struct hda_fixup *fix, int action)
  1600. {
  1601. struct alc_spec *spec = codec->spec;
  1602. static hda_nid_t nids[2] = { 0x18, 0x1a };
  1603. int i;
  1604. if (action != HDA_FIXUP_ACT_INIT)
  1605. return;
  1606. for (i = 0; i < ARRAY_SIZE(nids); i++) {
  1607. unsigned int val;
  1608. val = snd_hda_codec_get_pin_target(codec, nids[i]);
  1609. val |= AC_PINCTL_VREF_50;
  1610. snd_hda_set_pin_ctl(codec, nids[i], val);
  1611. }
  1612. spec->gen.keep_vref_in_automute = 1;
  1613. }
  1614. /* Don't take HP output as primary
  1615. * strangely, the speaker output doesn't work on VAIO Z through DAC 0x05
  1616. */
  1617. static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
  1618. const struct hda_fixup *fix, int action)
  1619. {
  1620. struct alc_spec *spec = codec->spec;
  1621. if (action == HDA_FIXUP_ACT_PRE_PROBE)
  1622. spec->gen.no_primary_hp = 1;
  1623. }
  1624. static const struct hda_fixup alc882_fixups[] = {
  1625. [ALC882_FIXUP_ABIT_AW9D_MAX] = {
  1626. .type = HDA_FIXUP_PINS,
  1627. .v.pins = (const struct hda_pintbl[]) {
  1628. { 0x15, 0x01080104 }, /* side */
  1629. { 0x16, 0x01011012 }, /* rear */
  1630. { 0x17, 0x01016011 }, /* clfe */
  1631. { }
  1632. }
  1633. },
  1634. [ALC882_FIXUP_LENOVO_Y530] = {
  1635. .type = HDA_FIXUP_PINS,
  1636. .v.pins = (const struct hda_pintbl[]) {
  1637. { 0x15, 0x99130112 }, /* rear int speakers */
  1638. { 0x16, 0x99130111 }, /* subwoofer */
  1639. { }
  1640. }
  1641. },
  1642. [ALC882_FIXUP_PB_M5210] = {
  1643. .type = HDA_FIXUP_PINCTLS,
  1644. .v.pins = (const struct hda_pintbl[]) {
  1645. { 0x19, PIN_VREF50 },
  1646. {}
  1647. }
  1648. },
  1649. [ALC882_FIXUP_ACER_ASPIRE_7736] = {
  1650. .type = HDA_FIXUP_FUNC,
  1651. .v.func = alc_fixup_sku_ignore,
  1652. },
  1653. [ALC882_FIXUP_ASUS_W90V] = {
  1654. .type = HDA_FIXUP_PINS,
  1655. .v.pins = (const struct hda_pintbl[]) {
  1656. { 0x16, 0x99130110 }, /* fix sequence for CLFE */
  1657. { }
  1658. }
  1659. },
  1660. [ALC889_FIXUP_CD] = {
  1661. .type = HDA_FIXUP_PINS,
  1662. .v.pins = (const struct hda_pintbl[]) {
  1663. { 0x1c, 0x993301f0 }, /* CD */
  1664. { }
  1665. }
  1666. },
  1667. [ALC889_FIXUP_VAIO_TT] = {
  1668. .type = HDA_FIXUP_PINS,
  1669. .v.pins = (const struct hda_pintbl[]) {
  1670. { 0x17, 0x90170111 }, /* hidden surround speaker */
  1671. { }
  1672. }
  1673. },
  1674. [ALC888_FIXUP_EEE1601] = {
  1675. .type = HDA_FIXUP_VERBS,
  1676. .v.verbs = (const struct hda_verb[]) {
  1677. { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
  1678. { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
  1679. { }
  1680. }
  1681. },
  1682. [ALC882_FIXUP_EAPD] = {
  1683. .type = HDA_FIXUP_VERBS,
  1684. .v.verbs = (const struct hda_verb[]) {
  1685. /* change to EAPD mode */
  1686. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  1687. { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
  1688. { }
  1689. }
  1690. },
  1691. [ALC883_FIXUP_EAPD] = {
  1692. .type = HDA_FIXUP_VERBS,
  1693. .v.verbs = (const struct hda_verb[]) {
  1694. /* change to EAPD mode */
  1695. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  1696. { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
  1697. { }
  1698. }
  1699. },
  1700. [ALC883_FIXUP_ACER_EAPD] = {
  1701. .type = HDA_FIXUP_VERBS,
  1702. .v.verbs = (const struct hda_verb[]) {
  1703. /* eanable EAPD on Acer laptops */
  1704. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  1705. { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
  1706. { }
  1707. }
  1708. },
  1709. [ALC882_FIXUP_GPIO1] = {
  1710. .type = HDA_FIXUP_VERBS,
  1711. .v.verbs = alc_gpio1_init_verbs,
  1712. },
  1713. [ALC882_FIXUP_GPIO2] = {
  1714. .type = HDA_FIXUP_VERBS,
  1715. .v.verbs = alc_gpio2_init_verbs,
  1716. },
  1717. [ALC882_FIXUP_GPIO3] = {
  1718. .type = HDA_FIXUP_VERBS,
  1719. .v.verbs = alc_gpio3_init_verbs,
  1720. },
  1721. [ALC882_FIXUP_ASUS_W2JC] = {
  1722. .type = HDA_FIXUP_VERBS,
  1723. .v.verbs = alc_gpio1_init_verbs,
  1724. .chained = true,
  1725. .chain_id = ALC882_FIXUP_EAPD,
  1726. },
  1727. [ALC889_FIXUP_COEF] = {
  1728. .type = HDA_FIXUP_FUNC,
  1729. .v.func = alc889_fixup_coef,
  1730. },
  1731. [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
  1732. .type = HDA_FIXUP_PINS,
  1733. .v.pins = (const struct hda_pintbl[]) {
  1734. { 0x16, 0x99130111 }, /* CLFE speaker */
  1735. { 0x17, 0x99130112 }, /* surround speaker */
  1736. { }
  1737. },
  1738. .chained = true,
  1739. .chain_id = ALC882_FIXUP_GPIO1,
  1740. },
  1741. [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
  1742. .type = HDA_FIXUP_PINS,
  1743. .v.pins = (const struct hda_pintbl[]) {
  1744. { 0x16, 0x99130111 }, /* CLFE speaker */
  1745. { 0x1b, 0x99130112 }, /* surround speaker */
  1746. { }
  1747. },
  1748. .chained = true,
  1749. .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
  1750. },
  1751. [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
  1752. /* additional init verbs for Acer Aspire 8930G */
  1753. .type = HDA_FIXUP_VERBS,
  1754. .v.verbs = (const struct hda_verb[]) {
  1755. /* Enable all DACs */
  1756. /* DAC DISABLE/MUTE 1? */
  1757. /* setting bits 1-5 disables DAC nids 0x02-0x06
  1758. * apparently. Init=0x38 */
  1759. { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
  1760. { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
  1761. /* DAC DISABLE/MUTE 2? */
  1762. /* some bit here disables the other DACs.
  1763. * Init=0x4900 */
  1764. { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
  1765. { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
  1766. /* DMIC fix
  1767. * This laptop has a stereo digital microphone.
  1768. * The mics are only 1cm apart which makes the stereo
  1769. * useless. However, either the mic or the ALC889
  1770. * makes the signal become a difference/sum signal
  1771. * instead of standard stereo, which is annoying.
  1772. * So instead we flip this bit which makes the
  1773. * codec replicate the sum signal to both channels,
  1774. * turning it into a normal mono mic.
  1775. */
  1776. /* DMIC_CONTROL? Init value = 0x0001 */
  1777. { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
  1778. { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
  1779. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  1780. { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
  1781. { }
  1782. },
  1783. .chained = true,
  1784. .chain_id = ALC882_FIXUP_GPIO1,
  1785. },
  1786. [ALC885_FIXUP_MACPRO_GPIO] = {
  1787. .type = HDA_FIXUP_FUNC,
  1788. .v.func = alc885_fixup_macpro_gpio,
  1789. },
  1790. [ALC889_FIXUP_DAC_ROUTE] = {
  1791. .type = HDA_FIXUP_FUNC,
  1792. .v.func = alc889_fixup_dac_route,
  1793. },
  1794. [ALC889_FIXUP_MBP_VREF] = {
  1795. .type = HDA_FIXUP_FUNC,
  1796. .v.func = alc889_fixup_mbp_vref,
  1797. .chained = true,
  1798. .chain_id = ALC882_FIXUP_GPIO1,
  1799. },
  1800. [ALC889_FIXUP_IMAC91_VREF] = {
  1801. .type = HDA_FIXUP_FUNC,
  1802. .v.func = alc889_fixup_imac91_vref,
  1803. .chained = true,
  1804. .chain_id = ALC882_FIXUP_GPIO1,
  1805. },
  1806. [ALC882_FIXUP_INV_DMIC] = {
  1807. .type = HDA_FIXUP_FUNC,
  1808. .v.func = alc_fixup_inv_dmic_0x12,
  1809. },
  1810. [ALC882_FIXUP_NO_PRIMARY_HP] = {
  1811. .type = HDA_FIXUP_FUNC,
  1812. .v.func = alc882_fixup_no_primary_hp,
  1813. },
  1814. };
  1815. static const struct snd_pci_quirk alc882_fixup_tbl[] = {
  1816. SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
  1817. SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
  1818. SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
  1819. SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
  1820. SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
  1821. SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
  1822. SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
  1823. ALC882_FIXUP_ACER_ASPIRE_4930G),
  1824. SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
  1825. ALC882_FIXUP_ACER_ASPIRE_4930G),
  1826. SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
  1827. ALC882_FIXUP_ACER_ASPIRE_8930G),
  1828. SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
  1829. ALC882_FIXUP_ACER_ASPIRE_8930G),
  1830. SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
  1831. ALC882_FIXUP_ACER_ASPIRE_4930G),
  1832. SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
  1833. ALC882_FIXUP_ACER_ASPIRE_4930G),
  1834. SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
  1835. ALC882_FIXUP_ACER_ASPIRE_4930G),
  1836. SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
  1837. SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
  1838. ALC882_FIXUP_ACER_ASPIRE_4930G),
  1839. SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
  1840. SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
  1841. SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
  1842. SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
  1843. SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
  1844. SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
  1845. SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
  1846. SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
  1847. SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
  1848. /* All Apple entries are in codec SSIDs */
  1849. SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
  1850. SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
  1851. SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
  1852. SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
  1853. SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
  1854. SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
  1855. SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
  1856. SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
  1857. SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
  1858. SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBP_VREF),
  1859. SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBP_VREF),
  1860. SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
  1861. SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
  1862. SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
  1863. SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
  1864. SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
  1865. SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
  1866. SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),
  1867. SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
  1868. SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
  1869. SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
  1870. SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_IMAC91_VREF),
  1871. SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
  1872. SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
  1873. SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
  1874. SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3", ALC889_FIXUP_CD),
  1875. SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
  1876. SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
  1877. SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
  1878. SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
  1879. SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
  1880. {}
  1881. };
  1882. static const struct hda_model_fixup alc882_fixup_models[] = {
  1883. {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
  1884. {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
  1885. {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
  1886. {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
  1887. {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
  1888. {}
  1889. };
  1890. /*
  1891. * BIOS auto configuration
  1892. */
  1893. /* almost identical with ALC880 parser... */
  1894. static int alc882_parse_auto_config(struct hda_codec *codec)
  1895. {
  1896. static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
  1897. static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  1898. return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
  1899. }
  1900. /*
  1901. */
  1902. static int patch_alc882(struct hda_codec *codec)
  1903. {
  1904. struct alc_spec *spec;
  1905. int err;
  1906. err = alc_alloc_spec(codec, 0x0b);
  1907. if (err < 0)
  1908. return err;
  1909. spec = codec->spec;
  1910. switch (codec->vendor_id) {
  1911. case 0x10ec0882:
  1912. case 0x10ec0885:
  1913. break;
  1914. default:
  1915. /* ALC883 and variants */
  1916. alc_fix_pll_init(codec, 0x20, 0x0a, 10);
  1917. break;
  1918. }
  1919. snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
  1920. alc882_fixups);
  1921. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  1922. alc_auto_parse_customize_define(codec);
  1923. /* automatic parse from the BIOS config */
  1924. err = alc882_parse_auto_config(codec);
  1925. if (err < 0)
  1926. goto error;
  1927. if (!spec->gen.no_analog && has_cdefine_beep(codec)) {
  1928. err = snd_hda_attach_beep_device(codec, 0x1);
  1929. if (err < 0)
  1930. goto error;
  1931. set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
  1932. }
  1933. codec->patch_ops = alc_patch_ops;
  1934. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  1935. return 0;
  1936. error:
  1937. alc_free(codec);
  1938. return err;
  1939. }
  1940. /*
  1941. * ALC262 support
  1942. */
  1943. static int alc262_parse_auto_config(struct hda_codec *codec)
  1944. {
  1945. static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
  1946. static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  1947. return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
  1948. }
  1949. /*
  1950. * Pin config fixes
  1951. */
  1952. enum {
  1953. ALC262_FIXUP_FSC_H270,
  1954. ALC262_FIXUP_FSC_S7110,
  1955. ALC262_FIXUP_HP_Z200,
  1956. ALC262_FIXUP_TYAN,
  1957. ALC262_FIXUP_LENOVO_3000,
  1958. ALC262_FIXUP_BENQ,
  1959. ALC262_FIXUP_BENQ_T31,
  1960. ALC262_FIXUP_INV_DMIC,
  1961. };
  1962. static const struct hda_fixup alc262_fixups[] = {
  1963. [ALC262_FIXUP_FSC_H270] = {
  1964. .type = HDA_FIXUP_PINS,
  1965. .v.pins = (const struct hda_pintbl[]) {
  1966. { 0x14, 0x99130110 }, /* speaker */
  1967. { 0x15, 0x0221142f }, /* front HP */
  1968. { 0x1b, 0x0121141f }, /* rear HP */
  1969. { }
  1970. }
  1971. },
  1972. [ALC262_FIXUP_FSC_S7110] = {
  1973. .type = HDA_FIXUP_PINS,
  1974. .v.pins = (const struct hda_pintbl[]) {
  1975. { 0x15, 0x90170110 }, /* speaker */
  1976. { }
  1977. },
  1978. .chained = true,
  1979. .chain_id = ALC262_FIXUP_BENQ,
  1980. },
  1981. [ALC262_FIXUP_HP_Z200] = {
  1982. .type = HDA_FIXUP_PINS,
  1983. .v.pins = (const struct hda_pintbl[]) {
  1984. { 0x16, 0x99130120 }, /* internal speaker */
  1985. { }
  1986. }
  1987. },
  1988. [ALC262_FIXUP_TYAN] = {
  1989. .type = HDA_FIXUP_PINS,
  1990. .v.pins = (const struct hda_pintbl[]) {
  1991. { 0x14, 0x1993e1f0 }, /* int AUX */
  1992. { }
  1993. }
  1994. },
  1995. [ALC262_FIXUP_LENOVO_3000] = {
  1996. .type = HDA_FIXUP_PINCTLS,
  1997. .v.pins = (const struct hda_pintbl[]) {
  1998. { 0x19, PIN_VREF50 },
  1999. {}
  2000. },
  2001. .chained = true,
  2002. .chain_id = ALC262_FIXUP_BENQ,
  2003. },
  2004. [ALC262_FIXUP_BENQ] = {
  2005. .type = HDA_FIXUP_VERBS,
  2006. .v.verbs = (const struct hda_verb[]) {
  2007. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  2008. { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
  2009. {}
  2010. }
  2011. },
  2012. [ALC262_FIXUP_BENQ_T31] = {
  2013. .type = HDA_FIXUP_VERBS,
  2014. .v.verbs = (const struct hda_verb[]) {
  2015. { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
  2016. { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
  2017. {}
  2018. }
  2019. },
  2020. [ALC262_FIXUP_INV_DMIC] = {
  2021. .type = HDA_FIXUP_FUNC,
  2022. .v.func = alc_fixup_inv_dmic_0x12,
  2023. },
  2024. };
  2025. static const struct snd_pci_quirk alc262_fixup_tbl[] = {
  2026. SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
  2027. SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
  2028. SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
  2029. SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
  2030. SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
  2031. SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
  2032. SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
  2033. SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
  2034. {}
  2035. };
  2036. static const struct hda_model_fixup alc262_fixup_models[] = {
  2037. {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
  2038. {}
  2039. };
  2040. /*
  2041. */
  2042. static int patch_alc262(struct hda_codec *codec)
  2043. {
  2044. struct alc_spec *spec;
  2045. int err;
  2046. err = alc_alloc_spec(codec, 0x0b);
  2047. if (err < 0)
  2048. return err;
  2049. spec = codec->spec;
  2050. spec->gen.shared_mic_vref_pin = 0x18;
  2051. #if 0
  2052. /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
  2053. * under-run
  2054. */
  2055. {
  2056. int tmp;
  2057. snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
  2058. tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
  2059. snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
  2060. snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
  2061. }
  2062. #endif
  2063. alc_fix_pll_init(codec, 0x20, 0x0a, 10);
  2064. snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
  2065. alc262_fixups);
  2066. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  2067. alc_auto_parse_customize_define(codec);
  2068. /* automatic parse from the BIOS config */
  2069. err = alc262_parse_auto_config(codec);
  2070. if (err < 0)
  2071. goto error;
  2072. if (!spec->gen.no_analog && has_cdefine_beep(codec)) {
  2073. err = snd_hda_attach_beep_device(codec, 0x1);
  2074. if (err < 0)
  2075. goto error;
  2076. set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
  2077. }
  2078. codec->patch_ops = alc_patch_ops;
  2079. spec->shutup = alc_eapd_shutup;
  2080. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  2081. return 0;
  2082. error:
  2083. alc_free(codec);
  2084. return err;
  2085. }
  2086. /*
  2087. * ALC268
  2088. */
  2089. /* bind Beep switches of both NID 0x0f and 0x10 */
  2090. static const struct hda_bind_ctls alc268_bind_beep_sw = {
  2091. .ops = &snd_hda_bind_sw,
  2092. .values = {
  2093. HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
  2094. HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
  2095. 0
  2096. },
  2097. };
  2098. static const struct snd_kcontrol_new alc268_beep_mixer[] = {
  2099. HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
  2100. HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
  2101. { }
  2102. };
  2103. /* set PCBEEP vol = 0, mute connections */
  2104. static const struct hda_verb alc268_beep_init_verbs[] = {
  2105. {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
  2106. {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  2107. {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
  2108. { }
  2109. };
  2110. enum {
  2111. ALC268_FIXUP_INV_DMIC,
  2112. ALC268_FIXUP_HP_EAPD,
  2113. };
  2114. static const struct hda_fixup alc268_fixups[] = {
  2115. [ALC268_FIXUP_INV_DMIC] = {
  2116. .type = HDA_FIXUP_FUNC,
  2117. .v.func = alc_fixup_inv_dmic_0x12,
  2118. },
  2119. [ALC268_FIXUP_HP_EAPD] = {
  2120. .type = HDA_FIXUP_VERBS,
  2121. .v.verbs = (const struct hda_verb[]) {
  2122. {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
  2123. {}
  2124. }
  2125. },
  2126. };
  2127. static const struct hda_model_fixup alc268_fixup_models[] = {
  2128. {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
  2129. {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
  2130. {}
  2131. };
  2132. static const struct snd_pci_quirk alc268_fixup_tbl[] = {
  2133. /* below is codec SSID since multiple Toshiba laptops have the
  2134. * same PCI SSID 1179:ff00
  2135. */
  2136. SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
  2137. {}
  2138. };
  2139. /*
  2140. * BIOS auto configuration
  2141. */
  2142. static int alc268_parse_auto_config(struct hda_codec *codec)
  2143. {
  2144. static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  2145. struct alc_spec *spec = codec->spec;
  2146. int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
  2147. if (err > 0) {
  2148. if (!spec->gen.no_analog &&
  2149. spec->gen.autocfg.speaker_pins[0] != 0x1d) {
  2150. add_mixer(spec, alc268_beep_mixer);
  2151. snd_hda_add_verbs(codec, alc268_beep_init_verbs);
  2152. }
  2153. }
  2154. return err;
  2155. }
  2156. /*
  2157. */
  2158. static int patch_alc268(struct hda_codec *codec)
  2159. {
  2160. struct alc_spec *spec;
  2161. int i, has_beep, err;
  2162. /* ALC268 has no aa-loopback mixer */
  2163. err = alc_alloc_spec(codec, 0);
  2164. if (err < 0)
  2165. return err;
  2166. spec = codec->spec;
  2167. snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
  2168. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  2169. /* automatic parse from the BIOS config */
  2170. err = alc268_parse_auto_config(codec);
  2171. if (err < 0)
  2172. goto error;
  2173. has_beep = 0;
  2174. for (i = 0; i < spec->num_mixers; i++) {
  2175. if (spec->mixers[i] == alc268_beep_mixer) {
  2176. has_beep = 1;
  2177. break;
  2178. }
  2179. }
  2180. if (has_beep) {
  2181. err = snd_hda_attach_beep_device(codec, 0x1);
  2182. if (err < 0)
  2183. goto error;
  2184. if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
  2185. /* override the amp caps for beep generator */
  2186. snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
  2187. (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
  2188. (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
  2189. (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
  2190. (0 << AC_AMPCAP_MUTE_SHIFT));
  2191. }
  2192. codec->patch_ops = alc_patch_ops;
  2193. spec->shutup = alc_eapd_shutup;
  2194. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  2195. return 0;
  2196. error:
  2197. alc_free(codec);
  2198. return err;
  2199. }
  2200. /*
  2201. * ALC269
  2202. */
  2203. static int playback_pcm_open(struct hda_pcm_stream *hinfo,
  2204. struct hda_codec *codec,
  2205. struct snd_pcm_substream *substream)
  2206. {
  2207. struct hda_gen_spec *spec = codec->spec;
  2208. return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
  2209. hinfo);
  2210. }
  2211. static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
  2212. struct hda_codec *codec,
  2213. unsigned int stream_tag,
  2214. unsigned int format,
  2215. struct snd_pcm_substream *substream)
  2216. {
  2217. struct hda_gen_spec *spec = codec->spec;
  2218. return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
  2219. stream_tag, format, substream);
  2220. }
  2221. static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
  2222. struct hda_codec *codec,
  2223. struct snd_pcm_substream *substream)
  2224. {
  2225. struct hda_gen_spec *spec = codec->spec;
  2226. return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
  2227. }
  2228. static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
  2229. .substreams = 1,
  2230. .channels_min = 2,
  2231. .channels_max = 8,
  2232. .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
  2233. /* NID is set in alc_build_pcms */
  2234. .ops = {
  2235. .open = playback_pcm_open,
  2236. .prepare = playback_pcm_prepare,
  2237. .cleanup = playback_pcm_cleanup
  2238. },
  2239. };
  2240. static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
  2241. .substreams = 1,
  2242. .channels_min = 2,
  2243. .channels_max = 2,
  2244. .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
  2245. /* NID is set in alc_build_pcms */
  2246. };
  2247. /* different alc269-variants */
  2248. enum {
  2249. ALC269_TYPE_ALC269VA,
  2250. ALC269_TYPE_ALC269VB,
  2251. ALC269_TYPE_ALC269VC,
  2252. ALC269_TYPE_ALC269VD,
  2253. ALC269_TYPE_ALC280,
  2254. ALC269_TYPE_ALC282,
  2255. ALC269_TYPE_ALC284,
  2256. };
  2257. /*
  2258. * BIOS auto configuration
  2259. */
  2260. static int alc269_parse_auto_config(struct hda_codec *codec)
  2261. {
  2262. static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
  2263. static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
  2264. static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  2265. struct alc_spec *spec = codec->spec;
  2266. const hda_nid_t *ssids;
  2267. switch (spec->codec_variant) {
  2268. case ALC269_TYPE_ALC269VA:
  2269. case ALC269_TYPE_ALC269VC:
  2270. case ALC269_TYPE_ALC280:
  2271. case ALC269_TYPE_ALC284:
  2272. ssids = alc269va_ssids;
  2273. break;
  2274. case ALC269_TYPE_ALC269VB:
  2275. case ALC269_TYPE_ALC269VD:
  2276. case ALC269_TYPE_ALC282:
  2277. ssids = alc269_ssids;
  2278. break;
  2279. default:
  2280. ssids = alc269_ssids;
  2281. break;
  2282. }
  2283. return alc_parse_auto_config(codec, alc269_ignore, ssids);
  2284. }
  2285. static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
  2286. {
  2287. int val = alc_read_coef_idx(codec, 0x04);
  2288. if (power_up)
  2289. val |= 1 << 11;
  2290. else
  2291. val &= ~(1 << 11);
  2292. alc_write_coef_idx(codec, 0x04, val);
  2293. }
  2294. static void alc269_shutup(struct hda_codec *codec)
  2295. {
  2296. struct alc_spec *spec = codec->spec;
  2297. if (spec->codec_variant != ALC269_TYPE_ALC269VB)
  2298. return;
  2299. if (spec->codec_variant == ALC269_TYPE_ALC269VB)
  2300. alc269vb_toggle_power_output(codec, 0);
  2301. if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
  2302. (alc_get_coef0(codec) & 0x00ff) == 0x018) {
  2303. msleep(150);
  2304. }
  2305. }
  2306. #ifdef CONFIG_PM
  2307. static int alc269_resume(struct hda_codec *codec)
  2308. {
  2309. struct alc_spec *spec = codec->spec;
  2310. if (spec->codec_variant == ALC269_TYPE_ALC269VB)
  2311. alc269vb_toggle_power_output(codec, 0);
  2312. if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
  2313. (alc_get_coef0(codec) & 0x00ff) == 0x018) {
  2314. msleep(150);
  2315. }
  2316. codec->patch_ops.init(codec);
  2317. if (spec->codec_variant == ALC269_TYPE_ALC269VB)
  2318. alc269vb_toggle_power_output(codec, 1);
  2319. if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
  2320. (alc_get_coef0(codec) & 0x00ff) == 0x017) {
  2321. msleep(200);
  2322. }
  2323. snd_hda_codec_resume_amp(codec);
  2324. snd_hda_codec_resume_cache(codec);
  2325. hda_call_check_power_status(codec, 0x01);
  2326. return 0;
  2327. }
  2328. #endif /* CONFIG_PM */
  2329. static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
  2330. const struct hda_fixup *fix, int action)
  2331. {
  2332. struct alc_spec *spec = codec->spec;
  2333. if (action == HDA_FIXUP_ACT_PRE_PROBE)
  2334. spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
  2335. }
  2336. static void alc269_fixup_hweq(struct hda_codec *codec,
  2337. const struct hda_fixup *fix, int action)
  2338. {
  2339. int coef;
  2340. if (action != HDA_FIXUP_ACT_INIT)
  2341. return;
  2342. coef = alc_read_coef_idx(codec, 0x1e);
  2343. alc_write_coef_idx(codec, 0x1e, coef | 0x80);
  2344. }
  2345. static void alc271_fixup_dmic(struct hda_codec *codec,
  2346. const struct hda_fixup *fix, int action)
  2347. {
  2348. static const struct hda_verb verbs[] = {
  2349. {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
  2350. {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
  2351. {}
  2352. };
  2353. unsigned int cfg;
  2354. if (strcmp(codec->chip_name, "ALC271X"))
  2355. return;
  2356. cfg = snd_hda_codec_get_pincfg(codec, 0x12);
  2357. if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
  2358. snd_hda_sequence_write(codec, verbs);
  2359. }
  2360. static void alc269_fixup_pcm_44k(struct hda_codec *codec,
  2361. const struct hda_fixup *fix, int action)
  2362. {
  2363. struct alc_spec *spec = codec->spec;
  2364. if (action != HDA_FIXUP_ACT_PROBE)
  2365. return;
  2366. /* Due to a hardware problem on Lenovo Ideadpad, we need to
  2367. * fix the sample rate of analog I/O to 44.1kHz
  2368. */
  2369. spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
  2370. spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
  2371. }
  2372. static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
  2373. const struct hda_fixup *fix, int action)
  2374. {
  2375. int coef;
  2376. if (action != HDA_FIXUP_ACT_INIT)
  2377. return;
  2378. /* The digital-mic unit sends PDM (differential signal) instead of
  2379. * the standard PCM, thus you can't record a valid mono stream as is.
  2380. * Below is a workaround specific to ALC269 to control the dmic
  2381. * signal source as mono.
  2382. */
  2383. coef = alc_read_coef_idx(codec, 0x07);
  2384. alc_write_coef_idx(codec, 0x07, coef | 0x80);
  2385. }
  2386. static void alc269_quanta_automute(struct hda_codec *codec)
  2387. {
  2388. snd_hda_gen_update_outputs(codec);
  2389. snd_hda_codec_write(codec, 0x20, 0,
  2390. AC_VERB_SET_COEF_INDEX, 0x0c);
  2391. snd_hda_codec_write(codec, 0x20, 0,
  2392. AC_VERB_SET_PROC_COEF, 0x680);
  2393. snd_hda_codec_write(codec, 0x20, 0,
  2394. AC_VERB_SET_COEF_INDEX, 0x0c);
  2395. snd_hda_codec_write(codec, 0x20, 0,
  2396. AC_VERB_SET_PROC_COEF, 0x480);
  2397. }
  2398. static void alc269_fixup_quanta_mute(struct hda_codec *codec,
  2399. const struct hda_fixup *fix, int action)
  2400. {
  2401. struct alc_spec *spec = codec->spec;
  2402. if (action != HDA_FIXUP_ACT_PROBE)
  2403. return;
  2404. spec->gen.automute_hook = alc269_quanta_automute;
  2405. }
  2406. /* update mute-LED according to the speaker mute state via mic VREF pin */
  2407. static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
  2408. {
  2409. struct hda_codec *codec = private_data;
  2410. struct alc_spec *spec = codec->spec;
  2411. unsigned int pinval;
  2412. if (spec->mute_led_polarity)
  2413. enabled = !enabled;
  2414. pinval = AC_PINCTL_IN_EN |
  2415. (enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80);
  2416. if (spec->mute_led_nid)
  2417. snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
  2418. }
  2419. static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
  2420. const struct hda_fixup *fix, int action)
  2421. {
  2422. struct alc_spec *spec = codec->spec;
  2423. const struct dmi_device *dev = NULL;
  2424. if (action != HDA_FIXUP_ACT_PRE_PROBE)
  2425. return;
  2426. while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
  2427. int pol, pin;
  2428. if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
  2429. continue;
  2430. if (pin < 0x0a || pin >= 0x10)
  2431. break;
  2432. spec->mute_led_polarity = pol;
  2433. spec->mute_led_nid = pin - 0x0a + 0x18;
  2434. spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
  2435. spec->gen.vmaster_mute_enum = 1;
  2436. snd_printd("Detected mute LED for %x:%d\n", spec->mute_led_nid,
  2437. spec->mute_led_polarity);
  2438. break;
  2439. }
  2440. }
  2441. static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
  2442. const struct hda_fixup *fix, int action)
  2443. {
  2444. struct alc_spec *spec = codec->spec;
  2445. if (action == HDA_FIXUP_ACT_PRE_PROBE) {
  2446. spec->mute_led_polarity = 0;
  2447. spec->mute_led_nid = 0x19;
  2448. spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
  2449. spec->gen.vmaster_mute_enum = 1;
  2450. }
  2451. }
  2452. static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
  2453. const struct hda_fixup *fix,
  2454. int action)
  2455. {
  2456. struct alc_spec *spec = codec->spec;
  2457. if (snd_BUG_ON(!spec->gen.am_entry[1].pin ||
  2458. !spec->gen.autocfg.hp_pins[0]))
  2459. return;
  2460. if (action == HDA_FIXUP_ACT_PROBE)
  2461. snd_hda_jack_set_gating_jack(codec, spec->gen.am_entry[1].pin,
  2462. spec->gen.autocfg.hp_pins[0]);
  2463. }
  2464. enum {
  2465. ALC269_FIXUP_SONY_VAIO,
  2466. ALC275_FIXUP_SONY_VAIO_GPIO2,
  2467. ALC269_FIXUP_DELL_M101Z,
  2468. ALC269_FIXUP_SKU_IGNORE,
  2469. ALC269_FIXUP_ASUS_G73JW,
  2470. ALC269_FIXUP_LENOVO_EAPD,
  2471. ALC275_FIXUP_SONY_HWEQ,
  2472. ALC271_FIXUP_DMIC,
  2473. ALC269_FIXUP_PCM_44K,
  2474. ALC269_FIXUP_STEREO_DMIC,
  2475. ALC269_FIXUP_QUANTA_MUTE,
  2476. ALC269_FIXUP_LIFEBOOK,
  2477. ALC269_FIXUP_AMIC,
  2478. ALC269_FIXUP_DMIC,
  2479. ALC269VB_FIXUP_AMIC,
  2480. ALC269VB_FIXUP_DMIC,
  2481. ALC269_FIXUP_HP_MUTE_LED,
  2482. ALC269_FIXUP_HP_MUTE_LED_MIC2,
  2483. ALC269_FIXUP_INV_DMIC,
  2484. ALC269_FIXUP_LENOVO_DOCK,
  2485. ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
  2486. ALC271_FIXUP_AMIC_MIC2,
  2487. ALC271_FIXUP_HP_GATE_MIC_JACK,
  2488. };
  2489. static const struct hda_fixup alc269_fixups[] = {
  2490. [ALC269_FIXUP_SONY_VAIO] = {
  2491. .type = HDA_FIXUP_PINCTLS,
  2492. .v.pins = (const struct hda_pintbl[]) {
  2493. {0x19, PIN_VREFGRD},
  2494. {}
  2495. }
  2496. },
  2497. [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
  2498. .type = HDA_FIXUP_VERBS,
  2499. .v.verbs = (const struct hda_verb[]) {
  2500. {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
  2501. {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
  2502. {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
  2503. { }
  2504. },
  2505. .chained = true,
  2506. .chain_id = ALC269_FIXUP_SONY_VAIO
  2507. },
  2508. [ALC269_FIXUP_DELL_M101Z] = {
  2509. .type = HDA_FIXUP_VERBS,
  2510. .v.verbs = (const struct hda_verb[]) {
  2511. /* Enables internal speaker */
  2512. {0x20, AC_VERB_SET_COEF_INDEX, 13},
  2513. {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
  2514. {}
  2515. }
  2516. },
  2517. [ALC269_FIXUP_SKU_IGNORE] = {
  2518. .type = HDA_FIXUP_FUNC,
  2519. .v.func = alc_fixup_sku_ignore,
  2520. },
  2521. [ALC269_FIXUP_ASUS_G73JW] = {
  2522. .type = HDA_FIXUP_PINS,
  2523. .v.pins = (const struct hda_pintbl[]) {
  2524. { 0x17, 0x99130111 }, /* subwoofer */
  2525. { }
  2526. }
  2527. },
  2528. [ALC269_FIXUP_LENOVO_EAPD] = {
  2529. .type = HDA_FIXUP_VERBS,
  2530. .v.verbs = (const struct hda_verb[]) {
  2531. {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
  2532. {}
  2533. }
  2534. },
  2535. [ALC275_FIXUP_SONY_HWEQ] = {
  2536. .type = HDA_FIXUP_FUNC,
  2537. .v.func = alc269_fixup_hweq,
  2538. .chained = true,
  2539. .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
  2540. },
  2541. [ALC271_FIXUP_DMIC] = {
  2542. .type = HDA_FIXUP_FUNC,
  2543. .v.func = alc271_fixup_dmic,
  2544. },
  2545. [ALC269_FIXUP_PCM_44K] = {
  2546. .type = HDA_FIXUP_FUNC,
  2547. .v.func = alc269_fixup_pcm_44k,
  2548. .chained = true,
  2549. .chain_id = ALC269_FIXUP_QUANTA_MUTE
  2550. },
  2551. [ALC269_FIXUP_STEREO_DMIC] = {
  2552. .type = HDA_FIXUP_FUNC,
  2553. .v.func = alc269_fixup_stereo_dmic,
  2554. },
  2555. [ALC269_FIXUP_QUANTA_MUTE] = {
  2556. .type = HDA_FIXUP_FUNC,
  2557. .v.func = alc269_fixup_quanta_mute,
  2558. },
  2559. [ALC269_FIXUP_LIFEBOOK] = {
  2560. .type = HDA_FIXUP_PINS,
  2561. .v.pins = (const struct hda_pintbl[]) {
  2562. { 0x1a, 0x2101103f }, /* dock line-out */
  2563. { 0x1b, 0x23a11040 }, /* dock mic-in */
  2564. { }
  2565. },
  2566. .chained = true,
  2567. .chain_id = ALC269_FIXUP_QUANTA_MUTE
  2568. },
  2569. [ALC269_FIXUP_AMIC] = {
  2570. .type = HDA_FIXUP_PINS,
  2571. .v.pins = (const struct hda_pintbl[]) {
  2572. { 0x14, 0x99130110 }, /* speaker */
  2573. { 0x15, 0x0121401f }, /* HP out */
  2574. { 0x18, 0x01a19c20 }, /* mic */
  2575. { 0x19, 0x99a3092f }, /* int-mic */
  2576. { }
  2577. },
  2578. },
  2579. [ALC269_FIXUP_DMIC] = {
  2580. .type = HDA_FIXUP_PINS,
  2581. .v.pins = (const struct hda_pintbl[]) {
  2582. { 0x12, 0x99a3092f }, /* int-mic */
  2583. { 0x14, 0x99130110 }, /* speaker */
  2584. { 0x15, 0x0121401f }, /* HP out */
  2585. { 0x18, 0x01a19c20 }, /* mic */
  2586. { }
  2587. },
  2588. },
  2589. [ALC269VB_FIXUP_AMIC] = {
  2590. .type = HDA_FIXUP_PINS,
  2591. .v.pins = (const struct hda_pintbl[]) {
  2592. { 0x14, 0x99130110 }, /* speaker */
  2593. { 0x18, 0x01a19c20 }, /* mic */
  2594. { 0x19, 0x99a3092f }, /* int-mic */
  2595. { 0x21, 0x0121401f }, /* HP out */
  2596. { }
  2597. },
  2598. },
  2599. [ALC269VB_FIXUP_DMIC] = {
  2600. .type = HDA_FIXUP_PINS,
  2601. .v.pins = (const struct hda_pintbl[]) {
  2602. { 0x12, 0x99a3092f }, /* int-mic */
  2603. { 0x14, 0x99130110 }, /* speaker */
  2604. { 0x18, 0x01a19c20 }, /* mic */
  2605. { 0x21, 0x0121401f }, /* HP out */
  2606. { }
  2607. },
  2608. },
  2609. [ALC269_FIXUP_HP_MUTE_LED] = {
  2610. .type = HDA_FIXUP_FUNC,
  2611. .v.func = alc269_fixup_hp_mute_led,
  2612. },
  2613. [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
  2614. .type = HDA_FIXUP_FUNC,
  2615. .v.func = alc269_fixup_hp_mute_led_mic2,
  2616. },
  2617. [ALC269_FIXUP_INV_DMIC] = {
  2618. .type = HDA_FIXUP_FUNC,
  2619. .v.func = alc_fixup_inv_dmic_0x12,
  2620. },
  2621. [ALC269_FIXUP_LENOVO_DOCK] = {
  2622. .type = HDA_FIXUP_PINS,
  2623. .v.pins = (const struct hda_pintbl[]) {
  2624. { 0x19, 0x23a11040 }, /* dock mic */
  2625. { 0x1b, 0x2121103f }, /* dock headphone */
  2626. { }
  2627. },
  2628. .chained = true,
  2629. .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
  2630. },
  2631. [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
  2632. .type = HDA_FIXUP_FUNC,
  2633. .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
  2634. },
  2635. [ALC271_FIXUP_AMIC_MIC2] = {
  2636. .type = HDA_FIXUP_PINS,
  2637. .v.pins = (const struct hda_pintbl[]) {
  2638. { 0x14, 0x99130110 }, /* speaker */
  2639. { 0x19, 0x01a19c20 }, /* mic */
  2640. { 0x1b, 0x99a7012f }, /* int-mic */
  2641. { 0x21, 0x0121401f }, /* HP out */
  2642. { }
  2643. },
  2644. },
  2645. [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
  2646. .type = HDA_FIXUP_FUNC,
  2647. .v.func = alc271_hp_gate_mic_jack,
  2648. .chained = true,
  2649. .chain_id = ALC271_FIXUP_AMIC_MIC2,
  2650. },
  2651. };
  2652. static const struct snd_pci_quirk alc269_fixup_tbl[] = {
  2653. SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
  2654. SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
  2655. SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
  2656. SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
  2657. SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_DMIC),
  2658. SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_DMIC),
  2659. SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
  2660. SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
  2661. SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
  2662. SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
  2663. SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
  2664. SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
  2665. SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
  2666. SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
  2667. SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
  2668. SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
  2669. SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
  2670. SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
  2671. SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
  2672. SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
  2673. SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
  2674. SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
  2675. SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
  2676. SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
  2677. SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
  2678. SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
  2679. SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
  2680. SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
  2681. SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
  2682. SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
  2683. SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
  2684. SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
  2685. SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
  2686. #if 0
  2687. /* Below is a quirk table taken from the old code.
  2688. * Basically the device should work as is without the fixup table.
  2689. * If BIOS doesn't give a proper info, enable the corresponding
  2690. * fixup entry.
  2691. */
  2692. SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
  2693. ALC269_FIXUP_AMIC),
  2694. SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
  2695. SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
  2696. SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
  2697. SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
  2698. SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
  2699. SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
  2700. SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
  2701. SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
  2702. SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
  2703. SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
  2704. SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
  2705. SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
  2706. SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
  2707. SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
  2708. SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
  2709. SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
  2710. SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
  2711. SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
  2712. SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
  2713. SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
  2714. SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
  2715. SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
  2716. SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
  2717. SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
  2718. SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
  2719. SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
  2720. SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
  2721. SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
  2722. SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
  2723. SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
  2724. SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
  2725. SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
  2726. SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
  2727. SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
  2728. SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
  2729. SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
  2730. SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
  2731. SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
  2732. SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
  2733. #endif
  2734. {}
  2735. };
  2736. static const struct hda_model_fixup alc269_fixup_models[] = {
  2737. {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
  2738. {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
  2739. {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
  2740. {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
  2741. {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
  2742. {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
  2743. {}
  2744. };
  2745. static void alc269_fill_coef(struct hda_codec *codec)
  2746. {
  2747. struct alc_spec *spec = codec->spec;
  2748. int val;
  2749. if (spec->codec_variant != ALC269_TYPE_ALC269VB)
  2750. return;
  2751. if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
  2752. alc_write_coef_idx(codec, 0xf, 0x960b);
  2753. alc_write_coef_idx(codec, 0xe, 0x8817);
  2754. }
  2755. if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
  2756. alc_write_coef_idx(codec, 0xf, 0x960b);
  2757. alc_write_coef_idx(codec, 0xe, 0x8814);
  2758. }
  2759. if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
  2760. val = alc_read_coef_idx(codec, 0x04);
  2761. /* Power up output pin */
  2762. alc_write_coef_idx(codec, 0x04, val | (1<<11));
  2763. }
  2764. if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
  2765. val = alc_read_coef_idx(codec, 0xd);
  2766. if ((val & 0x0c00) >> 10 != 0x1) {
  2767. /* Capless ramp up clock control */
  2768. alc_write_coef_idx(codec, 0xd, val | (1<<10));
  2769. }
  2770. val = alc_read_coef_idx(codec, 0x17);
  2771. if ((val & 0x01c0) >> 6 != 0x4) {
  2772. /* Class D power on reset */
  2773. alc_write_coef_idx(codec, 0x17, val | (1<<7));
  2774. }
  2775. }
  2776. val = alc_read_coef_idx(codec, 0xd); /* Class D */
  2777. alc_write_coef_idx(codec, 0xd, val | (1<<14));
  2778. val = alc_read_coef_idx(codec, 0x4); /* HP */
  2779. alc_write_coef_idx(codec, 0x4, val | (1<<11));
  2780. }
  2781. /*
  2782. */
  2783. static int patch_alc269(struct hda_codec *codec)
  2784. {
  2785. struct alc_spec *spec;
  2786. int err;
  2787. err = alc_alloc_spec(codec, 0x0b);
  2788. if (err < 0)
  2789. return err;
  2790. spec = codec->spec;
  2791. spec->gen.shared_mic_vref_pin = 0x18;
  2792. snd_hda_pick_fixup(codec, alc269_fixup_models,
  2793. alc269_fixup_tbl, alc269_fixups);
  2794. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  2795. alc_auto_parse_customize_define(codec);
  2796. switch (codec->vendor_id) {
  2797. case 0x10ec0269:
  2798. spec->codec_variant = ALC269_TYPE_ALC269VA;
  2799. switch (alc_get_coef0(codec) & 0x00f0) {
  2800. case 0x0010:
  2801. if (codec->bus->pci->subsystem_vendor == 0x1025 &&
  2802. spec->cdefine.platform_type == 1)
  2803. err = alc_codec_rename(codec, "ALC271X");
  2804. spec->codec_variant = ALC269_TYPE_ALC269VB;
  2805. break;
  2806. case 0x0020:
  2807. if (codec->bus->pci->subsystem_vendor == 0x17aa &&
  2808. codec->bus->pci->subsystem_device == 0x21f3)
  2809. err = alc_codec_rename(codec, "ALC3202");
  2810. spec->codec_variant = ALC269_TYPE_ALC269VC;
  2811. break;
  2812. case 0x0030:
  2813. spec->codec_variant = ALC269_TYPE_ALC269VD;
  2814. break;
  2815. default:
  2816. alc_fix_pll_init(codec, 0x20, 0x04, 15);
  2817. }
  2818. if (err < 0)
  2819. goto error;
  2820. spec->init_hook = alc269_fill_coef;
  2821. alc269_fill_coef(codec);
  2822. break;
  2823. case 0x10ec0280:
  2824. case 0x10ec0290:
  2825. spec->codec_variant = ALC269_TYPE_ALC280;
  2826. break;
  2827. case 0x10ec0282:
  2828. case 0x10ec0283:
  2829. spec->codec_variant = ALC269_TYPE_ALC282;
  2830. break;
  2831. case 0x10ec0284:
  2832. case 0x10ec0292:
  2833. spec->codec_variant = ALC269_TYPE_ALC284;
  2834. break;
  2835. }
  2836. /* automatic parse from the BIOS config */
  2837. err = alc269_parse_auto_config(codec);
  2838. if (err < 0)
  2839. goto error;
  2840. if (!spec->gen.no_analog && has_cdefine_beep(codec)) {
  2841. err = snd_hda_attach_beep_device(codec, 0x1);
  2842. if (err < 0)
  2843. goto error;
  2844. set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
  2845. }
  2846. codec->patch_ops = alc_patch_ops;
  2847. #ifdef CONFIG_PM
  2848. codec->patch_ops.resume = alc269_resume;
  2849. #endif
  2850. spec->shutup = alc269_shutup;
  2851. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  2852. return 0;
  2853. error:
  2854. alc_free(codec);
  2855. return err;
  2856. }
  2857. /*
  2858. * ALC861
  2859. */
  2860. static int alc861_parse_auto_config(struct hda_codec *codec)
  2861. {
  2862. static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
  2863. static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
  2864. return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
  2865. }
  2866. /* Pin config fixes */
  2867. enum {
  2868. ALC861_FIXUP_FSC_AMILO_PI1505,
  2869. ALC861_FIXUP_AMP_VREF_0F,
  2870. ALC861_FIXUP_NO_JACK_DETECT,
  2871. ALC861_FIXUP_ASUS_A6RP,
  2872. };
  2873. /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
  2874. static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
  2875. const struct hda_fixup *fix, int action)
  2876. {
  2877. struct alc_spec *spec = codec->spec;
  2878. unsigned int val;
  2879. if (action != HDA_FIXUP_ACT_INIT)
  2880. return;
  2881. val = snd_hda_codec_get_pin_target(codec, 0x0f);
  2882. if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
  2883. val |= AC_PINCTL_IN_EN;
  2884. val |= AC_PINCTL_VREF_50;
  2885. snd_hda_set_pin_ctl(codec, 0x0f, val);
  2886. spec->gen.keep_vref_in_automute = 1;
  2887. }
  2888. /* suppress the jack-detection */
  2889. static void alc_fixup_no_jack_detect(struct hda_codec *codec,
  2890. const struct hda_fixup *fix, int action)
  2891. {
  2892. if (action == HDA_FIXUP_ACT_PRE_PROBE)
  2893. codec->no_jack_detect = 1;
  2894. }
  2895. static const struct hda_fixup alc861_fixups[] = {
  2896. [ALC861_FIXUP_FSC_AMILO_PI1505] = {
  2897. .type = HDA_FIXUP_PINS,
  2898. .v.pins = (const struct hda_pintbl[]) {
  2899. { 0x0b, 0x0221101f }, /* HP */
  2900. { 0x0f, 0x90170310 }, /* speaker */
  2901. { }
  2902. }
  2903. },
  2904. [ALC861_FIXUP_AMP_VREF_0F] = {
  2905. .type = HDA_FIXUP_FUNC,
  2906. .v.func = alc861_fixup_asus_amp_vref_0f,
  2907. },
  2908. [ALC861_FIXUP_NO_JACK_DETECT] = {
  2909. .type = HDA_FIXUP_FUNC,
  2910. .v.func = alc_fixup_no_jack_detect,
  2911. },
  2912. [ALC861_FIXUP_ASUS_A6RP] = {
  2913. .type = HDA_FIXUP_FUNC,
  2914. .v.func = alc861_fixup_asus_amp_vref_0f,
  2915. .chained = true,
  2916. .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
  2917. }
  2918. };
  2919. static const struct snd_pci_quirk alc861_fixup_tbl[] = {
  2920. SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
  2921. SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
  2922. SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
  2923. SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
  2924. SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
  2925. SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
  2926. {}
  2927. };
  2928. /*
  2929. */
  2930. static int patch_alc861(struct hda_codec *codec)
  2931. {
  2932. struct alc_spec *spec;
  2933. int err;
  2934. err = alc_alloc_spec(codec, 0x15);
  2935. if (err < 0)
  2936. return err;
  2937. spec = codec->spec;
  2938. snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
  2939. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  2940. /* automatic parse from the BIOS config */
  2941. err = alc861_parse_auto_config(codec);
  2942. if (err < 0)
  2943. goto error;
  2944. if (!spec->gen.no_analog) {
  2945. err = snd_hda_attach_beep_device(codec, 0x23);
  2946. if (err < 0)
  2947. goto error;
  2948. set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
  2949. }
  2950. codec->patch_ops = alc_patch_ops;
  2951. #ifdef CONFIG_PM
  2952. spec->power_hook = alc_power_eapd;
  2953. #endif
  2954. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  2955. return 0;
  2956. error:
  2957. alc_free(codec);
  2958. return err;
  2959. }
  2960. /*
  2961. * ALC861-VD support
  2962. *
  2963. * Based on ALC882
  2964. *
  2965. * In addition, an independent DAC
  2966. */
  2967. static int alc861vd_parse_auto_config(struct hda_codec *codec)
  2968. {
  2969. static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
  2970. static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  2971. return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
  2972. }
  2973. enum {
  2974. ALC660VD_FIX_ASUS_GPIO1,
  2975. ALC861VD_FIX_DALLAS,
  2976. };
  2977. /* exclude VREF80 */
  2978. static void alc861vd_fixup_dallas(struct hda_codec *codec,
  2979. const struct hda_fixup *fix, int action)
  2980. {
  2981. if (action == HDA_FIXUP_ACT_PRE_PROBE) {
  2982. snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
  2983. snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
  2984. }
  2985. }
  2986. static const struct hda_fixup alc861vd_fixups[] = {
  2987. [ALC660VD_FIX_ASUS_GPIO1] = {
  2988. .type = HDA_FIXUP_VERBS,
  2989. .v.verbs = (const struct hda_verb[]) {
  2990. /* reset GPIO1 */
  2991. {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
  2992. {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
  2993. {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
  2994. { }
  2995. }
  2996. },
  2997. [ALC861VD_FIX_DALLAS] = {
  2998. .type = HDA_FIXUP_FUNC,
  2999. .v.func = alc861vd_fixup_dallas,
  3000. },
  3001. };
  3002. static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
  3003. SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
  3004. SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
  3005. SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
  3006. {}
  3007. };
  3008. /*
  3009. */
  3010. static int patch_alc861vd(struct hda_codec *codec)
  3011. {
  3012. struct alc_spec *spec;
  3013. int err;
  3014. err = alc_alloc_spec(codec, 0x0b);
  3015. if (err < 0)
  3016. return err;
  3017. spec = codec->spec;
  3018. snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
  3019. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  3020. /* automatic parse from the BIOS config */
  3021. err = alc861vd_parse_auto_config(codec);
  3022. if (err < 0)
  3023. goto error;
  3024. if (!spec->gen.no_analog) {
  3025. err = snd_hda_attach_beep_device(codec, 0x23);
  3026. if (err < 0)
  3027. goto error;
  3028. set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
  3029. }
  3030. codec->patch_ops = alc_patch_ops;
  3031. spec->shutup = alc_eapd_shutup;
  3032. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  3033. return 0;
  3034. error:
  3035. alc_free(codec);
  3036. return err;
  3037. }
  3038. /*
  3039. * ALC662 support
  3040. *
  3041. * ALC662 is almost identical with ALC880 but has cleaner and more flexible
  3042. * configuration. Each pin widget can choose any input DACs and a mixer.
  3043. * Each ADC is connected from a mixer of all inputs. This makes possible
  3044. * 6-channel independent captures.
  3045. *
  3046. * In addition, an independent DAC for the multi-playback (not used in this
  3047. * driver yet).
  3048. */
  3049. /*
  3050. * BIOS auto configuration
  3051. */
  3052. static int alc662_parse_auto_config(struct hda_codec *codec)
  3053. {
  3054. static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
  3055. static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
  3056. static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
  3057. const hda_nid_t *ssids;
  3058. if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
  3059. codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
  3060. ssids = alc663_ssids;
  3061. else
  3062. ssids = alc662_ssids;
  3063. return alc_parse_auto_config(codec, alc662_ignore, ssids);
  3064. }
  3065. static void alc272_fixup_mario(struct hda_codec *codec,
  3066. const struct hda_fixup *fix, int action)
  3067. {
  3068. if (action != HDA_FIXUP_ACT_PRE_PROBE)
  3069. return;
  3070. if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
  3071. (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
  3072. (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
  3073. (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
  3074. (0 << AC_AMPCAP_MUTE_SHIFT)))
  3075. printk(KERN_WARNING
  3076. "hda_codec: failed to override amp caps for NID 0x2\n");
  3077. }
  3078. enum {
  3079. ALC662_FIXUP_ASPIRE,
  3080. ALC662_FIXUP_IDEAPAD,
  3081. ALC272_FIXUP_MARIO,
  3082. ALC662_FIXUP_CZC_P10T,
  3083. ALC662_FIXUP_SKU_IGNORE,
  3084. ALC662_FIXUP_HP_RP5800,
  3085. ALC662_FIXUP_ASUS_MODE1,
  3086. ALC662_FIXUP_ASUS_MODE2,
  3087. ALC662_FIXUP_ASUS_MODE3,
  3088. ALC662_FIXUP_ASUS_MODE4,
  3089. ALC662_FIXUP_ASUS_MODE5,
  3090. ALC662_FIXUP_ASUS_MODE6,
  3091. ALC662_FIXUP_ASUS_MODE7,
  3092. ALC662_FIXUP_ASUS_MODE8,
  3093. ALC662_FIXUP_NO_JACK_DETECT,
  3094. ALC662_FIXUP_ZOTAC_Z68,
  3095. ALC662_FIXUP_INV_DMIC,
  3096. };
  3097. static const struct hda_fixup alc662_fixups[] = {
  3098. [ALC662_FIXUP_ASPIRE] = {
  3099. .type = HDA_FIXUP_PINS,
  3100. .v.pins = (const struct hda_pintbl[]) {
  3101. { 0x15, 0x99130112 }, /* subwoofer */
  3102. { }
  3103. }
  3104. },
  3105. [ALC662_FIXUP_IDEAPAD] = {
  3106. .type = HDA_FIXUP_PINS,
  3107. .v.pins = (const struct hda_pintbl[]) {
  3108. { 0x17, 0x99130112 }, /* subwoofer */
  3109. { }
  3110. }
  3111. },
  3112. [ALC272_FIXUP_MARIO] = {
  3113. .type = HDA_FIXUP_FUNC,
  3114. .v.func = alc272_fixup_mario,
  3115. },
  3116. [ALC662_FIXUP_CZC_P10T] = {
  3117. .type = HDA_FIXUP_VERBS,
  3118. .v.verbs = (const struct hda_verb[]) {
  3119. {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
  3120. {}
  3121. }
  3122. },
  3123. [ALC662_FIXUP_SKU_IGNORE] = {
  3124. .type = HDA_FIXUP_FUNC,
  3125. .v.func = alc_fixup_sku_ignore,
  3126. },
  3127. [ALC662_FIXUP_HP_RP5800] = {
  3128. .type = HDA_FIXUP_PINS,
  3129. .v.pins = (const struct hda_pintbl[]) {
  3130. { 0x14, 0x0221201f }, /* HP out */
  3131. { }
  3132. },
  3133. .chained = true,
  3134. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3135. },
  3136. [ALC662_FIXUP_ASUS_MODE1] = {
  3137. .type = HDA_FIXUP_PINS,
  3138. .v.pins = (const struct hda_pintbl[]) {
  3139. { 0x14, 0x99130110 }, /* speaker */
  3140. { 0x18, 0x01a19c20 }, /* mic */
  3141. { 0x19, 0x99a3092f }, /* int-mic */
  3142. { 0x21, 0x0121401f }, /* HP out */
  3143. { }
  3144. },
  3145. .chained = true,
  3146. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3147. },
  3148. [ALC662_FIXUP_ASUS_MODE2] = {
  3149. .type = HDA_FIXUP_PINS,
  3150. .v.pins = (const struct hda_pintbl[]) {
  3151. { 0x14, 0x99130110 }, /* speaker */
  3152. { 0x18, 0x01a19820 }, /* mic */
  3153. { 0x19, 0x99a3092f }, /* int-mic */
  3154. { 0x1b, 0x0121401f }, /* HP out */
  3155. { }
  3156. },
  3157. .chained = true,
  3158. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3159. },
  3160. [ALC662_FIXUP_ASUS_MODE3] = {
  3161. .type = HDA_FIXUP_PINS,
  3162. .v.pins = (const struct hda_pintbl[]) {
  3163. { 0x14, 0x99130110 }, /* speaker */
  3164. { 0x15, 0x0121441f }, /* HP */
  3165. { 0x18, 0x01a19840 }, /* mic */
  3166. { 0x19, 0x99a3094f }, /* int-mic */
  3167. { 0x21, 0x01211420 }, /* HP2 */
  3168. { }
  3169. },
  3170. .chained = true,
  3171. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3172. },
  3173. [ALC662_FIXUP_ASUS_MODE4] = {
  3174. .type = HDA_FIXUP_PINS,
  3175. .v.pins = (const struct hda_pintbl[]) {
  3176. { 0x14, 0x99130110 }, /* speaker */
  3177. { 0x16, 0x99130111 }, /* speaker */
  3178. { 0x18, 0x01a19840 }, /* mic */
  3179. { 0x19, 0x99a3094f }, /* int-mic */
  3180. { 0x21, 0x0121441f }, /* HP */
  3181. { }
  3182. },
  3183. .chained = true,
  3184. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3185. },
  3186. [ALC662_FIXUP_ASUS_MODE5] = {
  3187. .type = HDA_FIXUP_PINS,
  3188. .v.pins = (const struct hda_pintbl[]) {
  3189. { 0x14, 0x99130110 }, /* speaker */
  3190. { 0x15, 0x0121441f }, /* HP */
  3191. { 0x16, 0x99130111 }, /* speaker */
  3192. { 0x18, 0x01a19840 }, /* mic */
  3193. { 0x19, 0x99a3094f }, /* int-mic */
  3194. { }
  3195. },
  3196. .chained = true,
  3197. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3198. },
  3199. [ALC662_FIXUP_ASUS_MODE6] = {
  3200. .type = HDA_FIXUP_PINS,
  3201. .v.pins = (const struct hda_pintbl[]) {
  3202. { 0x14, 0x99130110 }, /* speaker */
  3203. { 0x15, 0x01211420 }, /* HP2 */
  3204. { 0x18, 0x01a19840 }, /* mic */
  3205. { 0x19, 0x99a3094f }, /* int-mic */
  3206. { 0x1b, 0x0121441f }, /* HP */
  3207. { }
  3208. },
  3209. .chained = true,
  3210. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3211. },
  3212. [ALC662_FIXUP_ASUS_MODE7] = {
  3213. .type = HDA_FIXUP_PINS,
  3214. .v.pins = (const struct hda_pintbl[]) {
  3215. { 0x14, 0x99130110 }, /* speaker */
  3216. { 0x17, 0x99130111 }, /* speaker */
  3217. { 0x18, 0x01a19840 }, /* mic */
  3218. { 0x19, 0x99a3094f }, /* int-mic */
  3219. { 0x1b, 0x01214020 }, /* HP */
  3220. { 0x21, 0x0121401f }, /* HP */
  3221. { }
  3222. },
  3223. .chained = true,
  3224. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3225. },
  3226. [ALC662_FIXUP_ASUS_MODE8] = {
  3227. .type = HDA_FIXUP_PINS,
  3228. .v.pins = (const struct hda_pintbl[]) {
  3229. { 0x14, 0x99130110 }, /* speaker */
  3230. { 0x12, 0x99a30970 }, /* int-mic */
  3231. { 0x15, 0x01214020 }, /* HP */
  3232. { 0x17, 0x99130111 }, /* speaker */
  3233. { 0x18, 0x01a19840 }, /* mic */
  3234. { 0x21, 0x0121401f }, /* HP */
  3235. { }
  3236. },
  3237. .chained = true,
  3238. .chain_id = ALC662_FIXUP_SKU_IGNORE
  3239. },
  3240. [ALC662_FIXUP_NO_JACK_DETECT] = {
  3241. .type = HDA_FIXUP_FUNC,
  3242. .v.func = alc_fixup_no_jack_detect,
  3243. },
  3244. [ALC662_FIXUP_ZOTAC_Z68] = {
  3245. .type = HDA_FIXUP_PINS,
  3246. .v.pins = (const struct hda_pintbl[]) {
  3247. { 0x1b, 0x02214020 }, /* Front HP */
  3248. { }
  3249. }
  3250. },
  3251. [ALC662_FIXUP_INV_DMIC] = {
  3252. .type = HDA_FIXUP_FUNC,
  3253. .v.func = alc_fixup_inv_dmic_0x12,
  3254. },
  3255. };
  3256. static const struct snd_pci_quirk alc662_fixup_tbl[] = {
  3257. SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
  3258. SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
  3259. SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
  3260. SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
  3261. SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
  3262. SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
  3263. SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
  3264. SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
  3265. SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
  3266. SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
  3267. SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
  3268. SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
  3269. SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
  3270. #if 0
  3271. /* Below is a quirk table taken from the old code.
  3272. * Basically the device should work as is without the fixup table.
  3273. * If BIOS doesn't give a proper info, enable the corresponding
  3274. * fixup entry.
  3275. */
  3276. SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
  3277. SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
  3278. SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
  3279. SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
  3280. SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
  3281. SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3282. SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
  3283. SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
  3284. SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
  3285. SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3286. SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
  3287. SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
  3288. SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
  3289. SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
  3290. SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
  3291. SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3292. SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
  3293. SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
  3294. SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3295. SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
  3296. SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
  3297. SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3298. SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
  3299. SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
  3300. SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
  3301. SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3302. SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
  3303. SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
  3304. SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3305. SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
  3306. SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3307. SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3308. SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
  3309. SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
  3310. SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
  3311. SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
  3312. SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
  3313. SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
  3314. SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
  3315. SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
  3316. SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
  3317. SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
  3318. SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
  3319. SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
  3320. SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
  3321. SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
  3322. SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
  3323. SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
  3324. SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
  3325. SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
  3326. #endif
  3327. {}
  3328. };
  3329. static const struct hda_model_fixup alc662_fixup_models[] = {
  3330. {.id = ALC272_FIXUP_MARIO, .name = "mario"},
  3331. {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
  3332. {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
  3333. {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
  3334. {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
  3335. {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
  3336. {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
  3337. {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
  3338. {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
  3339. {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
  3340. {}
  3341. };
  3342. static void alc662_fill_coef(struct hda_codec *codec)
  3343. {
  3344. int val, coef;
  3345. coef = alc_get_coef0(codec);
  3346. switch (codec->vendor_id) {
  3347. case 0x10ec0662:
  3348. if ((coef & 0x00f0) == 0x0030) {
  3349. val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */
  3350. alc_write_coef_idx(codec, 0x4, val & ~(1<<10));
  3351. }
  3352. break;
  3353. case 0x10ec0272:
  3354. case 0x10ec0273:
  3355. case 0x10ec0663:
  3356. case 0x10ec0665:
  3357. case 0x10ec0670:
  3358. case 0x10ec0671:
  3359. case 0x10ec0672:
  3360. val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */
  3361. alc_write_coef_idx(codec, 0xd, val | (1<<14));
  3362. break;
  3363. }
  3364. }
  3365. /*
  3366. */
  3367. static int patch_alc662(struct hda_codec *codec)
  3368. {
  3369. struct alc_spec *spec;
  3370. int err;
  3371. err = alc_alloc_spec(codec, 0x0b);
  3372. if (err < 0)
  3373. return err;
  3374. spec = codec->spec;
  3375. /* handle multiple HPs as is */
  3376. spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
  3377. alc_fix_pll_init(codec, 0x20, 0x04, 15);
  3378. spec->init_hook = alc662_fill_coef;
  3379. alc662_fill_coef(codec);
  3380. snd_hda_pick_fixup(codec, alc662_fixup_models,
  3381. alc662_fixup_tbl, alc662_fixups);
  3382. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
  3383. alc_auto_parse_customize_define(codec);
  3384. if ((alc_get_coef0(codec) & (1 << 14)) &&
  3385. codec->bus->pci->subsystem_vendor == 0x1025 &&
  3386. spec->cdefine.platform_type == 1) {
  3387. if (alc_codec_rename(codec, "ALC272X") < 0)
  3388. goto error;
  3389. }
  3390. /* automatic parse from the BIOS config */
  3391. err = alc662_parse_auto_config(codec);
  3392. if (err < 0)
  3393. goto error;
  3394. if (!spec->gen.no_analog && has_cdefine_beep(codec)) {
  3395. err = snd_hda_attach_beep_device(codec, 0x1);
  3396. if (err < 0)
  3397. goto error;
  3398. switch (codec->vendor_id) {
  3399. case 0x10ec0662:
  3400. set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
  3401. break;
  3402. case 0x10ec0272:
  3403. case 0x10ec0663:
  3404. case 0x10ec0665:
  3405. set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
  3406. break;
  3407. case 0x10ec0273:
  3408. set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
  3409. break;
  3410. }
  3411. }
  3412. codec->patch_ops = alc_patch_ops;
  3413. spec->shutup = alc_eapd_shutup;
  3414. snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
  3415. return 0;
  3416. error:
  3417. alc_free(codec);
  3418. return err;
  3419. }
  3420. /*
  3421. * ALC680 support
  3422. */
  3423. static int alc680_parse_auto_config(struct hda_codec *codec)
  3424. {
  3425. return alc_parse_auto_config(codec, NULL, NULL);
  3426. }
  3427. /*
  3428. */
  3429. static int patch_alc680(struct hda_codec *codec)
  3430. {
  3431. int err;
  3432. /* ALC680 has no aa-loopback mixer */
  3433. err = alc_alloc_spec(codec, 0);
  3434. if (err < 0)
  3435. return err;
  3436. /* automatic parse from the BIOS config */
  3437. err = alc680_parse_auto_config(codec);
  3438. if (err < 0) {
  3439. alc_free(codec);
  3440. return err;
  3441. }
  3442. codec->patch_ops = alc_patch_ops;
  3443. return 0;
  3444. }
  3445. /*
  3446. * patch entries
  3447. */
  3448. static const struct hda_codec_preset snd_hda_preset_realtek[] = {
  3449. { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
  3450. { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
  3451. { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
  3452. { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
  3453. { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
  3454. { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
  3455. { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
  3456. { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
  3457. { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
  3458. { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
  3459. { .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
  3460. { .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
  3461. { .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },
  3462. { .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },
  3463. { .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },
  3464. { .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },
  3465. { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
  3466. .patch = patch_alc861 },
  3467. { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
  3468. { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
  3469. { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
  3470. { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
  3471. .patch = patch_alc882 },
  3472. { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
  3473. .patch = patch_alc662 },
  3474. { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
  3475. .patch = patch_alc662 },
  3476. { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
  3477. { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
  3478. { .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
  3479. { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
  3480. { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
  3481. { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
  3482. { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
  3483. { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
  3484. { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
  3485. .patch = patch_alc882 },
  3486. { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
  3487. .patch = patch_alc882 },
  3488. { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
  3489. { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
  3490. { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
  3491. .patch = patch_alc882 },
  3492. { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
  3493. { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
  3494. { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
  3495. { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
  3496. { .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },
  3497. {} /* terminator */
  3498. };
  3499. MODULE_ALIAS("snd-hda-codec-id:10ec*");
  3500. MODULE_LICENSE("GPL");
  3501. MODULE_DESCRIPTION("Realtek HD-audio codec");
  3502. static struct hda_codec_preset_list realtek_list = {
  3503. .preset = snd_hda_preset_realtek,
  3504. .owner = THIS_MODULE,
  3505. };
  3506. static int __init patch_realtek_init(void)
  3507. {
  3508. return snd_hda_add_codec_preset(&realtek_list);
  3509. }
  3510. static void __exit patch_realtek_exit(void)
  3511. {
  3512. snd_hda_delete_codec_preset(&realtek_list);
  3513. }
  3514. module_init(patch_realtek_init)
  3515. module_exit(patch_realtek_exit)