ac97_codec.c 92 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888
  1. /*
  2. * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
  3. * Universal interface for Audio Codec '97
  4. *
  5. * For more details look to AC '97 component specification revision 2.2
  6. * by Intel Corporation (http://developer.intel.com).
  7. *
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22. *
  23. */
  24. #include <sound/driver.h>
  25. #include <linux/delay.h>
  26. #include <linux/init.h>
  27. #include <linux/slab.h>
  28. #include <linux/pci.h>
  29. #include <linux/moduleparam.h>
  30. #include <linux/mutex.h>
  31. #include <sound/core.h>
  32. #include <sound/pcm.h>
  33. #include <sound/tlv.h>
  34. #include <sound/ac97_codec.h>
  35. #include <sound/asoundef.h>
  36. #include <sound/initval.h>
  37. #include "ac97_id.h"
  38. #include "ac97_patch.c"
  39. MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
  40. MODULE_DESCRIPTION("Universal interface for Audio Codec '97");
  41. MODULE_LICENSE("GPL");
  42. static int enable_loopback;
  43. module_param(enable_loopback, bool, 0444);
  44. MODULE_PARM_DESC(enable_loopback, "Enable AC97 ADC/DAC Loopback Control");
  45. #ifdef CONFIG_SND_AC97_POWER_SAVE
  46. static int power_save;
  47. module_param(power_save, bool, 0644);
  48. MODULE_PARM_DESC(power_save, "Enable AC97 power-saving control");
  49. #endif
  50. /*
  51. */
  52. struct ac97_codec_id {
  53. unsigned int id;
  54. unsigned int mask;
  55. const char *name;
  56. int (*patch)(struct snd_ac97 *ac97);
  57. int (*mpatch)(struct snd_ac97 *ac97);
  58. unsigned int flags;
  59. };
  60. static const struct ac97_codec_id snd_ac97_codec_id_vendors[] = {
  61. { 0x414b4d00, 0xffffff00, "Asahi Kasei", NULL, NULL },
  62. { 0x41445300, 0xffffff00, "Analog Devices", NULL, NULL },
  63. { 0x414c4300, 0xffffff00, "Realtek", NULL, NULL },
  64. { 0x414c4700, 0xffffff00, "Realtek", NULL, NULL },
  65. { 0x434d4900, 0xffffff00, "C-Media Electronics", NULL, NULL },
  66. { 0x43525900, 0xffffff00, "Cirrus Logic", NULL, NULL },
  67. { 0x43585400, 0xffffff00, "Conexant", NULL, NULL },
  68. { 0x44543000, 0xffffff00, "Diamond Technology", NULL, NULL },
  69. { 0x454d4300, 0xffffff00, "eMicro", NULL, NULL },
  70. { 0x45838300, 0xffffff00, "ESS Technology", NULL, NULL },
  71. { 0x48525300, 0xffffff00, "Intersil", NULL, NULL },
  72. { 0x49434500, 0xffffff00, "ICEnsemble", NULL, NULL },
  73. { 0x49544500, 0xffffff00, "ITE Tech.Inc", NULL, NULL },
  74. { 0x4e534300, 0xffffff00, "National Semiconductor", NULL, NULL },
  75. { 0x50534300, 0xffffff00, "Philips", NULL, NULL },
  76. { 0x53494c00, 0xffffff00, "Silicon Laboratory", NULL, NULL },
  77. { 0x54524100, 0xffffff00, "TriTech", NULL, NULL },
  78. { 0x54584e00, 0xffffff00, "Texas Instruments", NULL, NULL },
  79. { 0x56494100, 0xffffff00, "VIA Technologies", NULL, NULL },
  80. { 0x57454300, 0xffffff00, "Winbond", NULL, NULL },
  81. { 0x574d4c00, 0xffffff00, "Wolfson", NULL, NULL },
  82. { 0x594d4800, 0xffffff00, "Yamaha", NULL, NULL },
  83. { 0x83847600, 0xffffff00, "SigmaTel", NULL, NULL },
  84. { 0, 0, NULL, NULL, NULL }
  85. };
  86. static const struct ac97_codec_id snd_ac97_codec_ids[] = {
  87. { 0x414b4d00, 0xffffffff, "AK4540", NULL, NULL },
  88. { 0x414b4d01, 0xffffffff, "AK4542", NULL, NULL },
  89. { 0x414b4d02, 0xffffffff, "AK4543", NULL, NULL },
  90. { 0x414b4d06, 0xffffffff, "AK4544A", NULL, NULL },
  91. { 0x414b4d07, 0xffffffff, "AK4545", NULL, NULL },
  92. { 0x41445303, 0xffffffff, "AD1819", patch_ad1819, NULL },
  93. { 0x41445340, 0xffffffff, "AD1881", patch_ad1881, NULL },
  94. { 0x41445348, 0xffffffff, "AD1881A", patch_ad1881, NULL },
  95. { 0x41445360, 0xffffffff, "AD1885", patch_ad1885, NULL },
  96. { 0x41445361, 0xffffffff, "AD1886", patch_ad1886, NULL },
  97. { 0x41445362, 0xffffffff, "AD1887", patch_ad1881, NULL },
  98. { 0x41445363, 0xffffffff, "AD1886A", patch_ad1881, NULL },
  99. { 0x41445368, 0xffffffff, "AD1888", patch_ad1888, NULL },
  100. { 0x41445370, 0xffffffff, "AD1980", patch_ad1980, NULL },
  101. { 0x41445372, 0xffffffff, "AD1981A", patch_ad1981a, NULL },
  102. { 0x41445374, 0xffffffff, "AD1981B", patch_ad1981b, NULL },
  103. { 0x41445375, 0xffffffff, "AD1985", patch_ad1985, NULL },
  104. { 0x41445378, 0xffffffff, "AD1986", patch_ad1986, NULL },
  105. { 0x414c4300, 0xffffff00, "ALC100,100P", NULL, NULL },
  106. { 0x414c4710, 0xfffffff0, "ALC200,200P", NULL, NULL },
  107. { 0x414c4721, 0xffffffff, "ALC650D", NULL, NULL }, /* already patched */
  108. { 0x414c4722, 0xffffffff, "ALC650E", NULL, NULL }, /* already patched */
  109. { 0x414c4723, 0xffffffff, "ALC650F", NULL, NULL }, /* already patched */
  110. { 0x414c4720, 0xfffffff0, "ALC650", patch_alc650, NULL },
  111. { 0x414c4760, 0xfffffff0, "ALC655", patch_alc655, NULL },
  112. { 0x414c4781, 0xffffffff, "ALC658D", NULL, NULL }, /* already patched */
  113. { 0x414c4780, 0xfffffff0, "ALC658", patch_alc655, NULL },
  114. { 0x414c4790, 0xfffffff0, "ALC850", patch_alc850, NULL },
  115. { 0x414c4730, 0xffffffff, "ALC101", NULL, NULL },
  116. { 0x414c4740, 0xfffffff0, "ALC202", NULL, NULL },
  117. { 0x414c4750, 0xfffffff0, "ALC250", NULL, NULL },
  118. { 0x414c4770, 0xfffffff0, "ALC203", NULL, NULL },
  119. { 0x434d4941, 0xffffffff, "CMI9738", patch_cm9738, NULL },
  120. { 0x434d4961, 0xffffffff, "CMI9739", patch_cm9739, NULL },
  121. { 0x434d4969, 0xffffffff, "CMI9780", patch_cm9780, NULL },
  122. { 0x434d4978, 0xffffffff, "CMI9761A", patch_cm9761, NULL },
  123. { 0x434d4982, 0xffffffff, "CMI9761B", patch_cm9761, NULL },
  124. { 0x434d4983, 0xffffffff, "CMI9761A+", patch_cm9761, NULL },
  125. { 0x43525900, 0xfffffff8, "CS4297", NULL, NULL },
  126. { 0x43525910, 0xfffffff8, "CS4297A", patch_cirrus_spdif, NULL },
  127. { 0x43525920, 0xfffffff8, "CS4298", patch_cirrus_spdif, NULL },
  128. { 0x43525928, 0xfffffff8, "CS4294", NULL, NULL },
  129. { 0x43525930, 0xfffffff8, "CS4299", patch_cirrus_cs4299, NULL },
  130. { 0x43525948, 0xfffffff8, "CS4201", NULL, NULL },
  131. { 0x43525958, 0xfffffff8, "CS4205", patch_cirrus_spdif, NULL },
  132. { 0x43525960, 0xfffffff8, "CS4291", NULL, NULL },
  133. { 0x43525970, 0xfffffff8, "CS4202", NULL, NULL },
  134. { 0x43585421, 0xffffffff, "HSD11246", NULL, NULL }, // SmartMC II
  135. { 0x43585428, 0xfffffff8, "Cx20468", patch_conexant, NULL }, // SmartAMC fixme: the mask might be different
  136. { 0x43585431, 0xffffffff, "Cx20551", patch_cx20551, NULL },
  137. { 0x44543031, 0xfffffff0, "DT0398", NULL, NULL },
  138. { 0x454d4328, 0xffffffff, "EM28028", NULL, NULL }, // same as TR28028?
  139. { 0x45838308, 0xffffffff, "ESS1988", NULL, NULL },
  140. { 0x48525300, 0xffffff00, "HMP9701", NULL, NULL },
  141. { 0x49434501, 0xffffffff, "ICE1230", NULL, NULL },
  142. { 0x49434511, 0xffffffff, "ICE1232", NULL, NULL }, // alias VIA VT1611A?
  143. { 0x49434514, 0xffffffff, "ICE1232A", NULL, NULL },
  144. { 0x49434551, 0xffffffff, "VT1616", patch_vt1616, NULL },
  145. { 0x49434552, 0xffffffff, "VT1616i", patch_vt1616, NULL }, // VT1616 compatible (chipset integrated)
  146. { 0x49544520, 0xffffffff, "IT2226E", NULL, NULL },
  147. { 0x49544561, 0xffffffff, "IT2646E", patch_it2646, NULL },
  148. { 0x4e534300, 0xffffffff, "LM4540,43,45,46,48", NULL, NULL }, // only guess --jk
  149. { 0x4e534331, 0xffffffff, "LM4549", NULL, NULL },
  150. { 0x4e534350, 0xffffffff, "LM4550", patch_lm4550, NULL }, // volume wrap fix
  151. { 0x50534304, 0xffffffff, "UCB1400", patch_ucb1400, NULL },
  152. { 0x53494c20, 0xffffffe0, "Si3036,8", mpatch_si3036, mpatch_si3036, AC97_MODEM_PATCH },
  153. { 0x54524102, 0xffffffff, "TR28022", NULL, NULL },
  154. { 0x54524106, 0xffffffff, "TR28026", NULL, NULL },
  155. { 0x54524108, 0xffffffff, "TR28028", patch_tritech_tr28028, NULL }, // added by xin jin [07/09/99]
  156. { 0x54524123, 0xffffffff, "TR28602", NULL, NULL }, // only guess --jk [TR28023 = eMicro EM28023 (new CT1297)]
  157. { 0x54584e20, 0xffffffff, "TLC320AD9xC", NULL, NULL },
  158. { 0x56494161, 0xffffffff, "VIA1612A", NULL, NULL }, // modified ICE1232 with S/PDIF
  159. { 0x56494170, 0xffffffff, "VIA1617A", patch_vt1617a, NULL }, // modified VT1616 with S/PDIF
  160. { 0x56494182, 0xffffffff, "VIA1618", NULL, NULL },
  161. { 0x57454301, 0xffffffff, "W83971D", NULL, NULL },
  162. { 0x574d4c00, 0xffffffff, "WM9701A", NULL, NULL },
  163. { 0x574d4C03, 0xffffffff, "WM9703,WM9707,WM9708,WM9717", patch_wolfson03, NULL},
  164. { 0x574d4C04, 0xffffffff, "WM9704M,WM9704Q", patch_wolfson04, NULL},
  165. { 0x574d4C05, 0xffffffff, "WM9705,WM9710", patch_wolfson05, NULL},
  166. { 0x574d4C09, 0xffffffff, "WM9709", NULL, NULL},
  167. { 0x574d4C12, 0xffffffff, "WM9711,WM9712", patch_wolfson11, NULL},
  168. { 0x574d4c13, 0xffffffff, "WM9713,WM9714", patch_wolfson13, NULL, AC97_DEFAULT_POWER_OFF},
  169. { 0x594d4800, 0xffffffff, "YMF743", NULL, NULL },
  170. { 0x594d4802, 0xffffffff, "YMF752", NULL, NULL },
  171. { 0x594d4803, 0xffffffff, "YMF753", patch_yamaha_ymf753, NULL },
  172. { 0x83847600, 0xffffffff, "STAC9700,83,84", patch_sigmatel_stac9700, NULL },
  173. { 0x83847604, 0xffffffff, "STAC9701,3,4,5", NULL, NULL },
  174. { 0x83847605, 0xffffffff, "STAC9704", NULL, NULL },
  175. { 0x83847608, 0xffffffff, "STAC9708,11", patch_sigmatel_stac9708, NULL },
  176. { 0x83847609, 0xffffffff, "STAC9721,23", patch_sigmatel_stac9721, NULL },
  177. { 0x83847644, 0xffffffff, "STAC9744", patch_sigmatel_stac9744, NULL },
  178. { 0x83847650, 0xffffffff, "STAC9750,51", NULL, NULL }, // patch?
  179. { 0x83847652, 0xffffffff, "STAC9752,53", NULL, NULL }, // patch?
  180. { 0x83847656, 0xffffffff, "STAC9756,57", patch_sigmatel_stac9756, NULL },
  181. { 0x83847658, 0xffffffff, "STAC9758,59", patch_sigmatel_stac9758, NULL },
  182. { 0x83847666, 0xffffffff, "STAC9766,67", NULL, NULL }, // patch?
  183. { 0, 0, NULL, NULL, NULL }
  184. };
  185. static void update_power_regs(struct snd_ac97 *ac97);
  186. #ifdef CONFIG_SND_AC97_POWER_SAVE
  187. #define ac97_is_power_save_mode(ac97) \
  188. ((ac97->scaps & AC97_SCAP_POWER_SAVE) && power_save)
  189. #else
  190. #define ac97_is_power_save_mode(ac97) 0
  191. #endif
  192. /*
  193. * I/O routines
  194. */
  195. static int snd_ac97_valid_reg(struct snd_ac97 *ac97, unsigned short reg)
  196. {
  197. /* filter some registers for buggy codecs */
  198. switch (ac97->id) {
  199. case AC97_ID_AK4540:
  200. case AC97_ID_AK4542:
  201. if (reg <= 0x1c || reg == 0x20 || reg == 0x26 || reg >= 0x7c)
  202. return 1;
  203. return 0;
  204. case AC97_ID_AD1819: /* AD1819 */
  205. case AC97_ID_AD1881: /* AD1881 */
  206. case AC97_ID_AD1881A: /* AD1881A */
  207. if (reg >= 0x3a && reg <= 0x6e) /* 0x59 */
  208. return 0;
  209. return 1;
  210. case AC97_ID_AD1885: /* AD1885 */
  211. case AC97_ID_AD1886: /* AD1886 */
  212. case AC97_ID_AD1886A: /* AD1886A - !!verify!! --jk */
  213. case AC97_ID_AD1887: /* AD1887 - !!verify!! --jk */
  214. if (reg == 0x5a)
  215. return 1;
  216. if (reg >= 0x3c && reg <= 0x6e) /* 0x59 */
  217. return 0;
  218. return 1;
  219. case AC97_ID_STAC9700:
  220. case AC97_ID_STAC9704:
  221. case AC97_ID_STAC9705:
  222. case AC97_ID_STAC9708:
  223. case AC97_ID_STAC9721:
  224. case AC97_ID_STAC9744:
  225. case AC97_ID_STAC9756:
  226. if (reg <= 0x3a || reg >= 0x5a)
  227. return 1;
  228. return 0;
  229. }
  230. return 1;
  231. }
  232. /**
  233. * snd_ac97_write - write a value on the given register
  234. * @ac97: the ac97 instance
  235. * @reg: the register to change
  236. * @value: the value to set
  237. *
  238. * Writes a value on the given register. This will invoke the write
  239. * callback directly after the register check.
  240. * This function doesn't change the register cache unlike
  241. * #snd_ca97_write_cache(), so use this only when you don't want to
  242. * reflect the change to the suspend/resume state.
  243. */
  244. void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)
  245. {
  246. if (!snd_ac97_valid_reg(ac97, reg))
  247. return;
  248. if ((ac97->id & 0xffffff00) == AC97_ID_ALC100) {
  249. /* Fix H/W bug of ALC100/100P */
  250. if (reg == AC97_MASTER || reg == AC97_HEADPHONE)
  251. ac97->bus->ops->write(ac97, AC97_RESET, 0); /* reset audio codec */
  252. }
  253. ac97->bus->ops->write(ac97, reg, value);
  254. }
  255. EXPORT_SYMBOL(snd_ac97_write);
  256. /**
  257. * snd_ac97_read - read a value from the given register
  258. *
  259. * @ac97: the ac97 instance
  260. * @reg: the register to read
  261. *
  262. * Reads a value from the given register. This will invoke the read
  263. * callback directly after the register check.
  264. *
  265. * Returns the read value.
  266. */
  267. unsigned short snd_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
  268. {
  269. if (!snd_ac97_valid_reg(ac97, reg))
  270. return 0;
  271. return ac97->bus->ops->read(ac97, reg);
  272. }
  273. /* read a register - return the cached value if already read */
  274. static inline unsigned short snd_ac97_read_cache(struct snd_ac97 *ac97, unsigned short reg)
  275. {
  276. if (! test_bit(reg, ac97->reg_accessed)) {
  277. ac97->regs[reg] = ac97->bus->ops->read(ac97, reg);
  278. // set_bit(reg, ac97->reg_accessed);
  279. }
  280. return ac97->regs[reg];
  281. }
  282. EXPORT_SYMBOL(snd_ac97_read);
  283. /**
  284. * snd_ac97_write_cache - write a value on the given register and update the cache
  285. * @ac97: the ac97 instance
  286. * @reg: the register to change
  287. * @value: the value to set
  288. *
  289. * Writes a value on the given register and updates the register
  290. * cache. The cached values are used for the cached-read and the
  291. * suspend/resume.
  292. */
  293. void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)
  294. {
  295. if (!snd_ac97_valid_reg(ac97, reg))
  296. return;
  297. mutex_lock(&ac97->reg_mutex);
  298. ac97->regs[reg] = value;
  299. ac97->bus->ops->write(ac97, reg, value);
  300. set_bit(reg, ac97->reg_accessed);
  301. mutex_unlock(&ac97->reg_mutex);
  302. }
  303. EXPORT_SYMBOL(snd_ac97_write_cache);
  304. /**
  305. * snd_ac97_update - update the value on the given register
  306. * @ac97: the ac97 instance
  307. * @reg: the register to change
  308. * @value: the value to set
  309. *
  310. * Compares the value with the register cache and updates the value
  311. * only when the value is changed.
  312. *
  313. * Returns 1 if the value is changed, 0 if no change, or a negative
  314. * code on failure.
  315. */
  316. int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short value)
  317. {
  318. int change;
  319. if (!snd_ac97_valid_reg(ac97, reg))
  320. return -EINVAL;
  321. mutex_lock(&ac97->reg_mutex);
  322. change = ac97->regs[reg] != value;
  323. if (change) {
  324. ac97->regs[reg] = value;
  325. ac97->bus->ops->write(ac97, reg, value);
  326. }
  327. set_bit(reg, ac97->reg_accessed);
  328. mutex_unlock(&ac97->reg_mutex);
  329. return change;
  330. }
  331. EXPORT_SYMBOL(snd_ac97_update);
  332. /**
  333. * snd_ac97_update_bits - update the bits on the given register
  334. * @ac97: the ac97 instance
  335. * @reg: the register to change
  336. * @mask: the bit-mask to change
  337. * @value: the value to set
  338. *
  339. * Updates the masked-bits on the given register only when the value
  340. * is changed.
  341. *
  342. * Returns 1 if the bits are changed, 0 if no change, or a negative
  343. * code on failure.
  344. */
  345. int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value)
  346. {
  347. int change;
  348. if (!snd_ac97_valid_reg(ac97, reg))
  349. return -EINVAL;
  350. mutex_lock(&ac97->reg_mutex);
  351. change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
  352. mutex_unlock(&ac97->reg_mutex);
  353. return change;
  354. }
  355. EXPORT_SYMBOL(snd_ac97_update_bits);
  356. /* no lock version - see snd_ac97_updat_bits() */
  357. int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg,
  358. unsigned short mask, unsigned short value)
  359. {
  360. int change;
  361. unsigned short old, new;
  362. old = snd_ac97_read_cache(ac97, reg);
  363. new = (old & ~mask) | (value & mask);
  364. change = old != new;
  365. if (change) {
  366. ac97->regs[reg] = new;
  367. ac97->bus->ops->write(ac97, reg, new);
  368. }
  369. set_bit(reg, ac97->reg_accessed);
  370. return change;
  371. }
  372. static int snd_ac97_ad18xx_update_pcm_bits(struct snd_ac97 *ac97, int codec, unsigned short mask, unsigned short value)
  373. {
  374. int change;
  375. unsigned short old, new, cfg;
  376. mutex_lock(&ac97->page_mutex);
  377. old = ac97->spec.ad18xx.pcmreg[codec];
  378. new = (old & ~mask) | (value & mask);
  379. change = old != new;
  380. if (change) {
  381. mutex_lock(&ac97->reg_mutex);
  382. cfg = snd_ac97_read_cache(ac97, AC97_AD_SERIAL_CFG);
  383. ac97->spec.ad18xx.pcmreg[codec] = new;
  384. /* select single codec */
  385. ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
  386. (cfg & ~0x7000) |
  387. ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
  388. /* update PCM bits */
  389. ac97->bus->ops->write(ac97, AC97_PCM, new);
  390. /* select all codecs */
  391. ac97->bus->ops->write(ac97, AC97_AD_SERIAL_CFG,
  392. cfg | 0x7000);
  393. mutex_unlock(&ac97->reg_mutex);
  394. }
  395. mutex_unlock(&ac97->page_mutex);
  396. return change;
  397. }
  398. /*
  399. * Controls
  400. */
  401. static int snd_ac97_info_enum_double(struct snd_kcontrol *kcontrol,
  402. struct snd_ctl_elem_info *uinfo)
  403. {
  404. struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
  405. uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  406. uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
  407. uinfo->value.enumerated.items = e->mask;
  408. if (uinfo->value.enumerated.item > e->mask - 1)
  409. uinfo->value.enumerated.item = e->mask - 1;
  410. strcpy(uinfo->value.enumerated.name, e->texts[uinfo->value.enumerated.item]);
  411. return 0;
  412. }
  413. static int snd_ac97_get_enum_double(struct snd_kcontrol *kcontrol,
  414. struct snd_ctl_elem_value *ucontrol)
  415. {
  416. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  417. struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
  418. unsigned short val, bitmask;
  419. for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
  420. ;
  421. val = snd_ac97_read_cache(ac97, e->reg);
  422. ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
  423. if (e->shift_l != e->shift_r)
  424. ucontrol->value.enumerated.item[1] = (val >> e->shift_r) & (bitmask - 1);
  425. return 0;
  426. }
  427. static int snd_ac97_put_enum_double(struct snd_kcontrol *kcontrol,
  428. struct snd_ctl_elem_value *ucontrol)
  429. {
  430. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  431. struct ac97_enum *e = (struct ac97_enum *)kcontrol->private_value;
  432. unsigned short val;
  433. unsigned short mask, bitmask;
  434. for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
  435. ;
  436. if (ucontrol->value.enumerated.item[0] > e->mask - 1)
  437. return -EINVAL;
  438. val = ucontrol->value.enumerated.item[0] << e->shift_l;
  439. mask = (bitmask - 1) << e->shift_l;
  440. if (e->shift_l != e->shift_r) {
  441. if (ucontrol->value.enumerated.item[1] > e->mask - 1)
  442. return -EINVAL;
  443. val |= ucontrol->value.enumerated.item[1] << e->shift_r;
  444. mask |= (bitmask - 1) << e->shift_r;
  445. }
  446. return snd_ac97_update_bits(ac97, e->reg, mask, val);
  447. }
  448. /* save/restore ac97 v2.3 paging */
  449. static int snd_ac97_page_save(struct snd_ac97 *ac97, int reg, struct snd_kcontrol *kcontrol)
  450. {
  451. int page_save = -1;
  452. if ((kcontrol->private_value & (1<<25)) &&
  453. (ac97->ext_id & AC97_EI_REV_MASK) >= AC97_EI_REV_23 &&
  454. (reg >= 0x60 && reg < 0x70)) {
  455. unsigned short page = (kcontrol->private_value >> 26) & 0x0f;
  456. mutex_lock(&ac97->page_mutex); /* lock paging */
  457. page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
  458. snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
  459. }
  460. return page_save;
  461. }
  462. static void snd_ac97_page_restore(struct snd_ac97 *ac97, int page_save)
  463. {
  464. if (page_save >= 0) {
  465. snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
  466. mutex_unlock(&ac97->page_mutex); /* unlock paging */
  467. }
  468. }
  469. /* volume and switch controls */
  470. static int snd_ac97_info_volsw(struct snd_kcontrol *kcontrol,
  471. struct snd_ctl_elem_info *uinfo)
  472. {
  473. int mask = (kcontrol->private_value >> 16) & 0xff;
  474. int shift = (kcontrol->private_value >> 8) & 0x0f;
  475. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  476. uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
  477. uinfo->count = shift == rshift ? 1 : 2;
  478. uinfo->value.integer.min = 0;
  479. uinfo->value.integer.max = mask;
  480. return 0;
  481. }
  482. static int snd_ac97_get_volsw(struct snd_kcontrol *kcontrol,
  483. struct snd_ctl_elem_value *ucontrol)
  484. {
  485. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  486. int reg = kcontrol->private_value & 0xff;
  487. int shift = (kcontrol->private_value >> 8) & 0x0f;
  488. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  489. int mask = (kcontrol->private_value >> 16) & 0xff;
  490. int invert = (kcontrol->private_value >> 24) & 0x01;
  491. int page_save;
  492. page_save = snd_ac97_page_save(ac97, reg, kcontrol);
  493. ucontrol->value.integer.value[0] = (snd_ac97_read_cache(ac97, reg) >> shift) & mask;
  494. if (shift != rshift)
  495. ucontrol->value.integer.value[1] = (snd_ac97_read_cache(ac97, reg) >> rshift) & mask;
  496. if (invert) {
  497. ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
  498. if (shift != rshift)
  499. ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
  500. }
  501. snd_ac97_page_restore(ac97, page_save);
  502. return 0;
  503. }
  504. static int snd_ac97_put_volsw(struct snd_kcontrol *kcontrol,
  505. struct snd_ctl_elem_value *ucontrol)
  506. {
  507. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  508. int reg = kcontrol->private_value & 0xff;
  509. int shift = (kcontrol->private_value >> 8) & 0x0f;
  510. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  511. int mask = (kcontrol->private_value >> 16) & 0xff;
  512. int invert = (kcontrol->private_value >> 24) & 0x01;
  513. int err, page_save;
  514. unsigned short val, val2, val_mask;
  515. page_save = snd_ac97_page_save(ac97, reg, kcontrol);
  516. val = (ucontrol->value.integer.value[0] & mask);
  517. if (invert)
  518. val = mask - val;
  519. val_mask = mask << shift;
  520. val = val << shift;
  521. if (shift != rshift) {
  522. val2 = (ucontrol->value.integer.value[1] & mask);
  523. if (invert)
  524. val2 = mask - val2;
  525. val_mask |= mask << rshift;
  526. val |= val2 << rshift;
  527. }
  528. err = snd_ac97_update_bits(ac97, reg, val_mask, val);
  529. snd_ac97_page_restore(ac97, page_save);
  530. #ifdef CONFIG_SND_AC97_POWER_SAVE
  531. /* check analog mixer power-down */
  532. if ((val_mask & 0x8000) &&
  533. (kcontrol->private_value & (1<<30))) {
  534. if (val & 0x8000)
  535. ac97->power_up &= ~(1 << (reg>>1));
  536. else
  537. ac97->power_up |= 1 << (reg>>1);
  538. update_power_regs(ac97);
  539. }
  540. #endif
  541. return err;
  542. }
  543. static const struct snd_kcontrol_new snd_ac97_controls_master_mono[2] = {
  544. AC97_SINGLE("Master Mono Playback Switch", AC97_MASTER_MONO, 15, 1, 1),
  545. AC97_SINGLE("Master Mono Playback Volume", AC97_MASTER_MONO, 0, 31, 1)
  546. };
  547. static const struct snd_kcontrol_new snd_ac97_controls_tone[2] = {
  548. AC97_SINGLE("Tone Control - Bass", AC97_MASTER_TONE, 8, 15, 1),
  549. AC97_SINGLE("Tone Control - Treble", AC97_MASTER_TONE, 0, 15, 1)
  550. };
  551. static const struct snd_kcontrol_new snd_ac97_controls_pc_beep[2] = {
  552. AC97_SINGLE("PC Speaker Playback Switch", AC97_PC_BEEP, 15, 1, 1),
  553. AC97_SINGLE("PC Speaker Playback Volume", AC97_PC_BEEP, 1, 15, 1)
  554. };
  555. static const struct snd_kcontrol_new snd_ac97_controls_mic_boost =
  556. AC97_SINGLE("Mic Boost (+20dB)", AC97_MIC, 6, 1, 0);
  557. static const char* std_rec_sel[] = {"Mic", "CD", "Video", "Aux", "Line", "Mix", "Mix Mono", "Phone"};
  558. static const char* std_3d_path[] = {"pre 3D", "post 3D"};
  559. static const char* std_mix[] = {"Mix", "Mic"};
  560. static const char* std_mic[] = {"Mic1", "Mic2"};
  561. static const struct ac97_enum std_enum[] = {
  562. AC97_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, std_rec_sel),
  563. AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, std_3d_path),
  564. AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 9, 2, std_mix),
  565. AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 8, 2, std_mic),
  566. };
  567. static const struct snd_kcontrol_new snd_ac97_control_capture_src =
  568. AC97_ENUM("Capture Source", std_enum[0]);
  569. static const struct snd_kcontrol_new snd_ac97_control_capture_vol =
  570. AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 15, 0);
  571. static const struct snd_kcontrol_new snd_ac97_controls_mic_capture[2] = {
  572. AC97_SINGLE("Mic Capture Switch", AC97_REC_GAIN_MIC, 15, 1, 1),
  573. AC97_SINGLE("Mic Capture Volume", AC97_REC_GAIN_MIC, 0, 15, 0)
  574. };
  575. enum {
  576. AC97_GENERAL_PCM_OUT = 0,
  577. AC97_GENERAL_STEREO_ENHANCEMENT,
  578. AC97_GENERAL_3D,
  579. AC97_GENERAL_LOUDNESS,
  580. AC97_GENERAL_MONO,
  581. AC97_GENERAL_MIC,
  582. AC97_GENERAL_LOOPBACK
  583. };
  584. static const struct snd_kcontrol_new snd_ac97_controls_general[7] = {
  585. AC97_ENUM("PCM Out Path & Mute", std_enum[1]),
  586. AC97_SINGLE("Simulated Stereo Enhancement", AC97_GENERAL_PURPOSE, 14, 1, 0),
  587. AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
  588. AC97_SINGLE("Loudness (bass boost)", AC97_GENERAL_PURPOSE, 12, 1, 0),
  589. AC97_ENUM("Mono Output Select", std_enum[2]),
  590. AC97_ENUM("Mic Select", std_enum[3]),
  591. AC97_SINGLE("ADC/DAC Loopback", AC97_GENERAL_PURPOSE, 7, 1, 0)
  592. };
  593. static const struct snd_kcontrol_new snd_ac97_controls_3d[2] = {
  594. AC97_SINGLE("3D Control - Center", AC97_3D_CONTROL, 8, 15, 0),
  595. AC97_SINGLE("3D Control - Depth", AC97_3D_CONTROL, 0, 15, 0)
  596. };
  597. static const struct snd_kcontrol_new snd_ac97_controls_center[2] = {
  598. AC97_SINGLE("Center Playback Switch", AC97_CENTER_LFE_MASTER, 7, 1, 1),
  599. AC97_SINGLE("Center Playback Volume", AC97_CENTER_LFE_MASTER, 0, 31, 1)
  600. };
  601. static const struct snd_kcontrol_new snd_ac97_controls_lfe[2] = {
  602. AC97_SINGLE("LFE Playback Switch", AC97_CENTER_LFE_MASTER, 15, 1, 1),
  603. AC97_SINGLE("LFE Playback Volume", AC97_CENTER_LFE_MASTER, 8, 31, 1)
  604. };
  605. static const struct snd_kcontrol_new snd_ac97_control_eapd =
  606. AC97_SINGLE("External Amplifier", AC97_POWERDOWN, 15, 1, 1);
  607. static const struct snd_kcontrol_new snd_ac97_controls_modem_switches[2] = {
  608. AC97_SINGLE("Off-hook Switch", AC97_GPIO_STATUS, 0, 1, 0),
  609. AC97_SINGLE("Caller ID Switch", AC97_GPIO_STATUS, 2, 1, 0)
  610. };
  611. /* change the existing EAPD control as inverted */
  612. static void set_inv_eapd(struct snd_ac97 *ac97, struct snd_kcontrol *kctl)
  613. {
  614. kctl->private_value = AC97_SINGLE_VALUE(AC97_POWERDOWN, 15, 1, 0);
  615. snd_ac97_update_bits(ac97, AC97_POWERDOWN, (1<<15), (1<<15)); /* EAPD up */
  616. ac97->scaps |= AC97_SCAP_INV_EAPD;
  617. }
  618. static int snd_ac97_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  619. {
  620. uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
  621. uinfo->count = 1;
  622. return 0;
  623. }
  624. static int snd_ac97_spdif_cmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  625. {
  626. ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
  627. IEC958_AES0_NONAUDIO |
  628. IEC958_AES0_CON_EMPHASIS_5015 |
  629. IEC958_AES0_CON_NOT_COPYRIGHT;
  630. ucontrol->value.iec958.status[1] = IEC958_AES1_CON_CATEGORY |
  631. IEC958_AES1_CON_ORIGINAL;
  632. ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
  633. return 0;
  634. }
  635. static int snd_ac97_spdif_pmask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  636. {
  637. /* FIXME: AC'97 spec doesn't say which bits are used for what */
  638. ucontrol->value.iec958.status[0] = IEC958_AES0_PROFESSIONAL |
  639. IEC958_AES0_NONAUDIO |
  640. IEC958_AES0_PRO_FS |
  641. IEC958_AES0_PRO_EMPHASIS_5015;
  642. return 0;
  643. }
  644. static int snd_ac97_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  645. {
  646. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  647. mutex_lock(&ac97->reg_mutex);
  648. ucontrol->value.iec958.status[0] = ac97->spdif_status & 0xff;
  649. ucontrol->value.iec958.status[1] = (ac97->spdif_status >> 8) & 0xff;
  650. ucontrol->value.iec958.status[2] = (ac97->spdif_status >> 16) & 0xff;
  651. ucontrol->value.iec958.status[3] = (ac97->spdif_status >> 24) & 0xff;
  652. mutex_unlock(&ac97->reg_mutex);
  653. return 0;
  654. }
  655. static int snd_ac97_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  656. {
  657. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  658. unsigned int new = 0;
  659. unsigned short val = 0;
  660. int change;
  661. new = val = ucontrol->value.iec958.status[0] & (IEC958_AES0_PROFESSIONAL|IEC958_AES0_NONAUDIO);
  662. if (ucontrol->value.iec958.status[0] & IEC958_AES0_PROFESSIONAL) {
  663. new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_PRO_FS|IEC958_AES0_PRO_EMPHASIS_5015);
  664. switch (new & IEC958_AES0_PRO_FS) {
  665. case IEC958_AES0_PRO_FS_44100: val |= 0<<12; break;
  666. case IEC958_AES0_PRO_FS_48000: val |= 2<<12; break;
  667. case IEC958_AES0_PRO_FS_32000: val |= 3<<12; break;
  668. default: val |= 1<<12; break;
  669. }
  670. if ((new & IEC958_AES0_PRO_EMPHASIS) == IEC958_AES0_PRO_EMPHASIS_5015)
  671. val |= 1<<3;
  672. } else {
  673. new |= ucontrol->value.iec958.status[0] & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT);
  674. new |= ((ucontrol->value.iec958.status[1] & (IEC958_AES1_CON_CATEGORY|IEC958_AES1_CON_ORIGINAL)) << 8);
  675. new |= ((ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) << 24);
  676. if ((new & IEC958_AES0_CON_EMPHASIS) == IEC958_AES0_CON_EMPHASIS_5015)
  677. val |= 1<<3;
  678. if (!(new & IEC958_AES0_CON_NOT_COPYRIGHT))
  679. val |= 1<<2;
  680. val |= ((new >> 8) & 0xff) << 4; // category + original
  681. switch ((new >> 24) & 0xff) {
  682. case IEC958_AES3_CON_FS_44100: val |= 0<<12; break;
  683. case IEC958_AES3_CON_FS_48000: val |= 2<<12; break;
  684. case IEC958_AES3_CON_FS_32000: val |= 3<<12; break;
  685. default: val |= 1<<12; break;
  686. }
  687. }
  688. mutex_lock(&ac97->reg_mutex);
  689. change = ac97->spdif_status != new;
  690. ac97->spdif_status = new;
  691. if (ac97->flags & AC97_CS_SPDIF) {
  692. int x = (val >> 12) & 0x03;
  693. switch (x) {
  694. case 0: x = 1; break; // 44.1
  695. case 2: x = 0; break; // 48.0
  696. default: x = 0; break; // illegal.
  697. }
  698. change |= snd_ac97_update_bits_nolock(ac97, AC97_CSR_SPDIF, 0x3fff, ((val & 0xcfff) | (x << 12)));
  699. } else if (ac97->flags & AC97_CX_SPDIF) {
  700. int v;
  701. v = new & (IEC958_AES0_CON_EMPHASIS_5015|IEC958_AES0_CON_NOT_COPYRIGHT) ? 0 : AC97_CXR_COPYRGT;
  702. v |= new & IEC958_AES0_NONAUDIO ? AC97_CXR_SPDIF_AC3 : AC97_CXR_SPDIF_PCM;
  703. change |= snd_ac97_update_bits_nolock(ac97, AC97_CXR_AUDIO_MISC,
  704. AC97_CXR_SPDIF_MASK | AC97_CXR_COPYRGT,
  705. v);
  706. } else {
  707. unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
  708. snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
  709. change |= snd_ac97_update_bits_nolock(ac97, AC97_SPDIF, 0x3fff, val);
  710. if (extst & AC97_EA_SPDIF) {
  711. snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
  712. }
  713. }
  714. mutex_unlock(&ac97->reg_mutex);
  715. return change;
  716. }
  717. static int snd_ac97_put_spsa(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  718. {
  719. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  720. int reg = kcontrol->private_value & 0xff;
  721. int shift = (kcontrol->private_value >> 8) & 0xff;
  722. int mask = (kcontrol->private_value >> 16) & 0xff;
  723. // int invert = (kcontrol->private_value >> 24) & 0xff;
  724. unsigned short value, old, new;
  725. int change;
  726. value = (ucontrol->value.integer.value[0] & mask);
  727. mutex_lock(&ac97->reg_mutex);
  728. mask <<= shift;
  729. value <<= shift;
  730. old = snd_ac97_read_cache(ac97, reg);
  731. new = (old & ~mask) | value;
  732. change = old != new;
  733. if (change) {
  734. unsigned short extst = snd_ac97_read_cache(ac97, AC97_EXTENDED_STATUS);
  735. snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0); /* turn off */
  736. change = snd_ac97_update_bits_nolock(ac97, reg, mask, value);
  737. if (extst & AC97_EA_SPDIF)
  738. snd_ac97_update_bits_nolock(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
  739. }
  740. mutex_unlock(&ac97->reg_mutex);
  741. return change;
  742. }
  743. static const struct snd_kcontrol_new snd_ac97_controls_spdif[5] = {
  744. {
  745. .access = SNDRV_CTL_ELEM_ACCESS_READ,
  746. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  747. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
  748. .info = snd_ac97_spdif_mask_info,
  749. .get = snd_ac97_spdif_cmask_get,
  750. },
  751. {
  752. .access = SNDRV_CTL_ELEM_ACCESS_READ,
  753. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  754. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
  755. .info = snd_ac97_spdif_mask_info,
  756. .get = snd_ac97_spdif_pmask_get,
  757. },
  758. {
  759. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  760. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
  761. .info = snd_ac97_spdif_mask_info,
  762. .get = snd_ac97_spdif_default_get,
  763. .put = snd_ac97_spdif_default_put,
  764. },
  765. AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),AC97_EXTENDED_STATUS, 2, 1, 0),
  766. {
  767. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  768. .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA",
  769. .info = snd_ac97_info_volsw,
  770. .get = snd_ac97_get_volsw,
  771. .put = snd_ac97_put_spsa,
  772. .private_value = AC97_SINGLE_VALUE(AC97_EXTENDED_STATUS, 4, 3, 0)
  773. },
  774. };
  775. #define AD18XX_PCM_BITS(xname, codec, lshift, rshift, mask) \
  776. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_bits, \
  777. .get = snd_ac97_ad18xx_pcm_get_bits, .put = snd_ac97_ad18xx_pcm_put_bits, \
  778. .private_value = (codec) | ((lshift) << 8) | ((rshift) << 12) | ((mask) << 16) }
  779. static int snd_ac97_ad18xx_pcm_info_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  780. {
  781. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  782. int mask = (kcontrol->private_value >> 16) & 0x0f;
  783. int lshift = (kcontrol->private_value >> 8) & 0x0f;
  784. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  785. uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
  786. if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
  787. uinfo->count = 2;
  788. else
  789. uinfo->count = 1;
  790. uinfo->value.integer.min = 0;
  791. uinfo->value.integer.max = mask;
  792. return 0;
  793. }
  794. static int snd_ac97_ad18xx_pcm_get_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  795. {
  796. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  797. int codec = kcontrol->private_value & 3;
  798. int lshift = (kcontrol->private_value >> 8) & 0x0f;
  799. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  800. int mask = (kcontrol->private_value >> 16) & 0xff;
  801. ucontrol->value.integer.value[0] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> lshift) & mask);
  802. if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES))
  803. ucontrol->value.integer.value[1] = mask - ((ac97->spec.ad18xx.pcmreg[codec] >> rshift) & mask);
  804. return 0;
  805. }
  806. static int snd_ac97_ad18xx_pcm_put_bits(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  807. {
  808. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  809. int codec = kcontrol->private_value & 3;
  810. int lshift = (kcontrol->private_value >> 8) & 0x0f;
  811. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  812. int mask = (kcontrol->private_value >> 16) & 0xff;
  813. unsigned short val, valmask;
  814. val = (mask - (ucontrol->value.integer.value[0] & mask)) << lshift;
  815. valmask = mask << lshift;
  816. if (lshift != rshift && (ac97->flags & AC97_STEREO_MUTES)) {
  817. val |= (mask - (ucontrol->value.integer.value[1] & mask)) << rshift;
  818. valmask |= mask << rshift;
  819. }
  820. return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, valmask, val);
  821. }
  822. #define AD18XX_PCM_VOLUME(xname, codec) \
  823. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ac97_ad18xx_pcm_info_volume, \
  824. .get = snd_ac97_ad18xx_pcm_get_volume, .put = snd_ac97_ad18xx_pcm_put_volume, \
  825. .private_value = codec }
  826. static int snd_ac97_ad18xx_pcm_info_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
  827. {
  828. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  829. uinfo->count = 2;
  830. uinfo->value.integer.min = 0;
  831. uinfo->value.integer.max = 31;
  832. return 0;
  833. }
  834. static int snd_ac97_ad18xx_pcm_get_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  835. {
  836. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  837. int codec = kcontrol->private_value & 3;
  838. mutex_lock(&ac97->page_mutex);
  839. ucontrol->value.integer.value[0] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 0) & 31);
  840. ucontrol->value.integer.value[1] = 31 - ((ac97->spec.ad18xx.pcmreg[codec] >> 8) & 31);
  841. mutex_unlock(&ac97->page_mutex);
  842. return 0;
  843. }
  844. static int snd_ac97_ad18xx_pcm_put_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  845. {
  846. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  847. int codec = kcontrol->private_value & 3;
  848. unsigned short val1, val2;
  849. val1 = 31 - (ucontrol->value.integer.value[0] & 31);
  850. val2 = 31 - (ucontrol->value.integer.value[1] & 31);
  851. return snd_ac97_ad18xx_update_pcm_bits(ac97, codec, 0x1f1f, (val1 << 8) | val2);
  852. }
  853. static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_pcm[2] = {
  854. AD18XX_PCM_BITS("PCM Playback Switch", 0, 15, 7, 1),
  855. AD18XX_PCM_VOLUME("PCM Playback Volume", 0)
  856. };
  857. static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_surround[2] = {
  858. AD18XX_PCM_BITS("Surround Playback Switch", 1, 15, 7, 1),
  859. AD18XX_PCM_VOLUME("Surround Playback Volume", 1)
  860. };
  861. static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_center[2] = {
  862. AD18XX_PCM_BITS("Center Playback Switch", 2, 15, 15, 1),
  863. AD18XX_PCM_BITS("Center Playback Volume", 2, 8, 8, 31)
  864. };
  865. static const struct snd_kcontrol_new snd_ac97_controls_ad18xx_lfe[2] = {
  866. AD18XX_PCM_BITS("LFE Playback Switch", 2, 7, 7, 1),
  867. AD18XX_PCM_BITS("LFE Playback Volume", 2, 0, 0, 31)
  868. };
  869. /*
  870. *
  871. */
  872. static void snd_ac97_powerdown(struct snd_ac97 *ac97);
  873. static int snd_ac97_bus_free(struct snd_ac97_bus *bus)
  874. {
  875. if (bus) {
  876. snd_ac97_bus_proc_done(bus);
  877. kfree(bus->pcms);
  878. if (bus->private_free)
  879. bus->private_free(bus);
  880. kfree(bus);
  881. }
  882. return 0;
  883. }
  884. static int snd_ac97_bus_dev_free(struct snd_device *device)
  885. {
  886. struct snd_ac97_bus *bus = device->device_data;
  887. return snd_ac97_bus_free(bus);
  888. }
  889. static int snd_ac97_free(struct snd_ac97 *ac97)
  890. {
  891. if (ac97) {
  892. #ifdef CONFIG_SND_AC97_POWER_SAVE
  893. cancel_delayed_work(&ac97->power_work);
  894. flush_scheduled_work();
  895. #endif
  896. snd_ac97_proc_done(ac97);
  897. if (ac97->bus)
  898. ac97->bus->codec[ac97->num] = NULL;
  899. if (ac97->private_free)
  900. ac97->private_free(ac97);
  901. kfree(ac97);
  902. }
  903. return 0;
  904. }
  905. static int snd_ac97_dev_free(struct snd_device *device)
  906. {
  907. struct snd_ac97 *ac97 = device->device_data;
  908. snd_ac97_powerdown(ac97); /* for avoiding click noises during shut down */
  909. return snd_ac97_free(ac97);
  910. }
  911. static int snd_ac97_try_volume_mix(struct snd_ac97 * ac97, int reg)
  912. {
  913. unsigned short val, mask = 0x8000;
  914. if (! snd_ac97_valid_reg(ac97, reg))
  915. return 0;
  916. switch (reg) {
  917. case AC97_MASTER_TONE:
  918. return ac97->caps & 0x04 ? 1 : 0;
  919. case AC97_HEADPHONE:
  920. return ac97->caps & 0x10 ? 1 : 0;
  921. case AC97_REC_GAIN_MIC:
  922. return ac97->caps & 0x01 ? 1 : 0;
  923. case AC97_3D_CONTROL:
  924. if (ac97->caps & 0x7c00) {
  925. val = snd_ac97_read(ac97, reg);
  926. /* if nonzero - fixed and we can't set it */
  927. return val == 0;
  928. }
  929. return 0;
  930. case AC97_CENTER_LFE_MASTER: /* center */
  931. if ((ac97->ext_id & AC97_EI_CDAC) == 0)
  932. return 0;
  933. break;
  934. case AC97_CENTER_LFE_MASTER+1: /* lfe */
  935. if ((ac97->ext_id & AC97_EI_LDAC) == 0)
  936. return 0;
  937. reg = AC97_CENTER_LFE_MASTER;
  938. mask = 0x0080;
  939. break;
  940. case AC97_SURROUND_MASTER:
  941. if ((ac97->ext_id & AC97_EI_SDAC) == 0)
  942. return 0;
  943. break;
  944. }
  945. val = snd_ac97_read(ac97, reg);
  946. if (!(val & mask)) {
  947. /* nothing seems to be here - mute flag is not set */
  948. /* try another test */
  949. snd_ac97_write_cache(ac97, reg, val | mask);
  950. val = snd_ac97_read(ac97, reg);
  951. val = snd_ac97_read(ac97, reg);
  952. if (!(val & mask))
  953. return 0; /* nothing here */
  954. }
  955. return 1; /* success, useable */
  956. }
  957. static void check_volume_resolution(struct snd_ac97 *ac97, int reg, unsigned char *lo_max, unsigned char *hi_max)
  958. {
  959. unsigned short cbit[3] = { 0x20, 0x10, 0x01 };
  960. unsigned char max[3] = { 63, 31, 15 };
  961. int i;
  962. /* first look up the static resolution table */
  963. if (ac97->res_table) {
  964. const struct snd_ac97_res_table *tbl;
  965. for (tbl = ac97->res_table; tbl->reg; tbl++) {
  966. if (tbl->reg == reg) {
  967. *lo_max = tbl->bits & 0xff;
  968. *hi_max = (tbl->bits >> 8) & 0xff;
  969. return;
  970. }
  971. }
  972. }
  973. *lo_max = *hi_max = 0;
  974. for (i = 0 ; i < ARRAY_SIZE(cbit); i++) {
  975. unsigned short val;
  976. snd_ac97_write(ac97, reg, 0x8080 | cbit[i] | (cbit[i] << 8));
  977. /* Do the read twice due to buffers on some ac97 codecs.
  978. * e.g. The STAC9704 returns exactly what you wrote to the register
  979. * if you read it immediately. This causes the detect routine to fail.
  980. */
  981. val = snd_ac97_read(ac97, reg);
  982. val = snd_ac97_read(ac97, reg);
  983. if (! *lo_max && (val & 0x7f) == cbit[i])
  984. *lo_max = max[i];
  985. if (! *hi_max && ((val >> 8) & 0x7f) == cbit[i])
  986. *hi_max = max[i];
  987. if (*lo_max && *hi_max)
  988. break;
  989. }
  990. }
  991. static int snd_ac97_try_bit(struct snd_ac97 * ac97, int reg, int bit)
  992. {
  993. unsigned short mask, val, orig, res;
  994. mask = 1 << bit;
  995. orig = snd_ac97_read(ac97, reg);
  996. val = orig ^ mask;
  997. snd_ac97_write(ac97, reg, val);
  998. res = snd_ac97_read(ac97, reg);
  999. snd_ac97_write_cache(ac97, reg, orig);
  1000. return res == val;
  1001. }
  1002. /* check the volume resolution of center/lfe */
  1003. static void snd_ac97_change_volume_params2(struct snd_ac97 * ac97, int reg, int shift, unsigned char *max)
  1004. {
  1005. unsigned short val, val1;
  1006. *max = 63;
  1007. val = 0x8080 | (0x20 << shift);
  1008. snd_ac97_write(ac97, reg, val);
  1009. val1 = snd_ac97_read(ac97, reg);
  1010. if (val != val1) {
  1011. *max = 31;
  1012. }
  1013. /* reset volume to zero */
  1014. snd_ac97_write_cache(ac97, reg, 0x8080);
  1015. }
  1016. static inline int printable(unsigned int x)
  1017. {
  1018. x &= 0xff;
  1019. if (x < ' ' || x >= 0x71) {
  1020. if (x <= 0x89)
  1021. return x - 0x71 + 'A';
  1022. return '?';
  1023. }
  1024. return x;
  1025. }
  1026. static struct snd_kcontrol *snd_ac97_cnew(const struct snd_kcontrol_new *_template,
  1027. struct snd_ac97 * ac97)
  1028. {
  1029. struct snd_kcontrol_new template;
  1030. memcpy(&template, _template, sizeof(template));
  1031. template.index = ac97->num;
  1032. return snd_ctl_new1(&template, ac97);
  1033. }
  1034. /*
  1035. * create mute switch(es) for normal stereo controls
  1036. */
  1037. static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg,
  1038. int check_stereo, int check_amix,
  1039. struct snd_ac97 *ac97)
  1040. {
  1041. struct snd_kcontrol *kctl;
  1042. int err;
  1043. unsigned short val, val1, mute_mask;
  1044. if (! snd_ac97_valid_reg(ac97, reg))
  1045. return 0;
  1046. mute_mask = 0x8000;
  1047. val = snd_ac97_read(ac97, reg);
  1048. if (check_stereo || (ac97->flags & AC97_STEREO_MUTES)) {
  1049. /* check whether both mute bits work */
  1050. val1 = val | 0x8080;
  1051. snd_ac97_write(ac97, reg, val1);
  1052. if (val1 == snd_ac97_read(ac97, reg))
  1053. mute_mask = 0x8080;
  1054. }
  1055. if (mute_mask == 0x8080) {
  1056. struct snd_kcontrol_new tmp = AC97_DOUBLE(name, reg, 15, 7, 1, 1);
  1057. if (check_amix)
  1058. tmp.private_value |= (1 << 30);
  1059. tmp.index = ac97->num;
  1060. kctl = snd_ctl_new1(&tmp, ac97);
  1061. } else {
  1062. struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 15, 1, 1);
  1063. if (check_amix)
  1064. tmp.private_value |= (1 << 30);
  1065. tmp.index = ac97->num;
  1066. kctl = snd_ctl_new1(&tmp, ac97);
  1067. }
  1068. err = snd_ctl_add(card, kctl);
  1069. if (err < 0)
  1070. return err;
  1071. /* mute as default */
  1072. snd_ac97_write_cache(ac97, reg, val | mute_mask);
  1073. return 0;
  1074. }
  1075. /*
  1076. * set dB information
  1077. */
  1078. static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
  1079. static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
  1080. static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
  1081. static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
  1082. static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
  1083. static const unsigned int *find_db_scale(unsigned int maxval)
  1084. {
  1085. switch (maxval) {
  1086. case 0x0f: return db_scale_4bit;
  1087. case 0x1f: return db_scale_5bit;
  1088. case 0x3f: return db_scale_6bit;
  1089. }
  1090. return NULL;
  1091. }
  1092. static void set_tlv_db_scale(struct snd_kcontrol *kctl, const unsigned int *tlv)
  1093. {
  1094. kctl->tlv.p = tlv;
  1095. if (tlv)
  1096. kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
  1097. }
  1098. /*
  1099. * create a volume for normal stereo/mono controls
  1100. */
  1101. static int snd_ac97_cvol_new(struct snd_card *card, char *name, int reg, unsigned int lo_max,
  1102. unsigned int hi_max, struct snd_ac97 *ac97)
  1103. {
  1104. int err;
  1105. struct snd_kcontrol *kctl;
  1106. if (! snd_ac97_valid_reg(ac97, reg))
  1107. return 0;
  1108. if (hi_max) {
  1109. /* invert */
  1110. struct snd_kcontrol_new tmp = AC97_DOUBLE(name, reg, 8, 0, lo_max, 1);
  1111. tmp.index = ac97->num;
  1112. kctl = snd_ctl_new1(&tmp, ac97);
  1113. } else {
  1114. /* invert */
  1115. struct snd_kcontrol_new tmp = AC97_SINGLE(name, reg, 0, lo_max, 1);
  1116. tmp.index = ac97->num;
  1117. kctl = snd_ctl_new1(&tmp, ac97);
  1118. }
  1119. if (reg >= AC97_PHONE && reg <= AC97_PCM)
  1120. set_tlv_db_scale(kctl, db_scale_5bit_12db_max);
  1121. else
  1122. set_tlv_db_scale(kctl, find_db_scale(lo_max));
  1123. err = snd_ctl_add(card, kctl);
  1124. if (err < 0)
  1125. return err;
  1126. snd_ac97_write_cache(ac97, reg,
  1127. (snd_ac97_read(ac97, reg) & 0x8080) |
  1128. lo_max | (hi_max << 8));
  1129. return 0;
  1130. }
  1131. /*
  1132. * create a mute-switch and a volume for normal stereo/mono controls
  1133. */
  1134. static int snd_ac97_cmix_new_stereo(struct snd_card *card, const char *pfx,
  1135. int reg, int check_stereo, int check_amix,
  1136. struct snd_ac97 *ac97)
  1137. {
  1138. int err;
  1139. char name[44];
  1140. unsigned char lo_max, hi_max;
  1141. if (! snd_ac97_valid_reg(ac97, reg))
  1142. return 0;
  1143. if (snd_ac97_try_bit(ac97, reg, 15)) {
  1144. sprintf(name, "%s Switch", pfx);
  1145. if ((err = snd_ac97_cmute_new_stereo(card, name, reg,
  1146. check_stereo, check_amix,
  1147. ac97)) < 0)
  1148. return err;
  1149. }
  1150. check_volume_resolution(ac97, reg, &lo_max, &hi_max);
  1151. if (lo_max) {
  1152. sprintf(name, "%s Volume", pfx);
  1153. if ((err = snd_ac97_cvol_new(card, name, reg, lo_max, hi_max, ac97)) < 0)
  1154. return err;
  1155. }
  1156. return 0;
  1157. }
  1158. #define snd_ac97_cmix_new(card, pfx, reg, acheck, ac97) \
  1159. snd_ac97_cmix_new_stereo(card, pfx, reg, 0, acheck, ac97)
  1160. #define snd_ac97_cmute_new(card, name, reg, acheck, ac97) \
  1161. snd_ac97_cmute_new_stereo(card, name, reg, 0, acheck, ac97)
  1162. static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97);
  1163. static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
  1164. {
  1165. struct snd_card *card = ac97->bus->card;
  1166. struct snd_kcontrol *kctl;
  1167. int err;
  1168. unsigned int idx;
  1169. unsigned char max;
  1170. /* build master controls */
  1171. /* AD claims to remove this control from AD1887, although spec v2.2 does not allow this */
  1172. if (snd_ac97_try_volume_mix(ac97, AC97_MASTER)) {
  1173. if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
  1174. err = snd_ac97_cmute_new(card, "Master Playback Switch",
  1175. AC97_MASTER, 0, ac97);
  1176. else
  1177. err = snd_ac97_cmix_new(card, "Master Playback",
  1178. AC97_MASTER, 0, ac97);
  1179. if (err < 0)
  1180. return err;
  1181. }
  1182. ac97->regs[AC97_CENTER_LFE_MASTER] = 0x8080;
  1183. /* build center controls */
  1184. if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER))
  1185. && !(ac97->flags & AC97_AD_MULTI)) {
  1186. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97))) < 0)
  1187. return err;
  1188. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_center[1], ac97))) < 0)
  1189. return err;
  1190. snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 0, &max);
  1191. kctl->private_value &= ~(0xff << 16);
  1192. kctl->private_value |= (int)max << 16;
  1193. set_tlv_db_scale(kctl, find_db_scale(max));
  1194. snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max);
  1195. }
  1196. /* build LFE controls */
  1197. if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1))
  1198. && !(ac97->flags & AC97_AD_MULTI)) {
  1199. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97))) < 0)
  1200. return err;
  1201. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_lfe[1], ac97))) < 0)
  1202. return err;
  1203. snd_ac97_change_volume_params2(ac97, AC97_CENTER_LFE_MASTER, 8, &max);
  1204. kctl->private_value &= ~(0xff << 16);
  1205. kctl->private_value |= (int)max << 16;
  1206. set_tlv_db_scale(kctl, find_db_scale(max));
  1207. snd_ac97_write_cache(ac97, AC97_CENTER_LFE_MASTER, ac97->regs[AC97_CENTER_LFE_MASTER] | max << 8);
  1208. }
  1209. /* build surround controls */
  1210. if ((snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER))
  1211. && !(ac97->flags & AC97_AD_MULTI)) {
  1212. /* Surround Master (0x38) is with stereo mutes */
  1213. if ((err = snd_ac97_cmix_new_stereo(card, "Surround Playback",
  1214. AC97_SURROUND_MASTER, 1, 0,
  1215. ac97)) < 0)
  1216. return err;
  1217. }
  1218. /* build headphone controls */
  1219. if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE)) {
  1220. if ((err = snd_ac97_cmix_new(card, "Headphone Playback",
  1221. AC97_HEADPHONE, 0, ac97)) < 0)
  1222. return err;
  1223. }
  1224. /* build master mono controls */
  1225. if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
  1226. if ((err = snd_ac97_cmix_new(card, "Master Mono Playback",
  1227. AC97_MASTER_MONO, 0, ac97)) < 0)
  1228. return err;
  1229. }
  1230. /* build master tone controls */
  1231. if (!(ac97->flags & AC97_HAS_NO_TONE)) {
  1232. if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_TONE)) {
  1233. for (idx = 0; idx < 2; idx++) {
  1234. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_tone[idx], ac97))) < 0)
  1235. return err;
  1236. if (ac97->id == AC97_ID_YMF753) {
  1237. kctl->private_value &= ~(0xff << 16);
  1238. kctl->private_value |= 7 << 16;
  1239. }
  1240. }
  1241. snd_ac97_write_cache(ac97, AC97_MASTER_TONE, 0x0f0f);
  1242. }
  1243. }
  1244. /* build PC Speaker controls */
  1245. if (!(ac97->flags & AC97_HAS_NO_PC_BEEP) &&
  1246. ((ac97->flags & AC97_HAS_PC_BEEP) ||
  1247. snd_ac97_try_volume_mix(ac97, AC97_PC_BEEP))) {
  1248. for (idx = 0; idx < 2; idx++)
  1249. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_pc_beep[idx], ac97))) < 0)
  1250. return err;
  1251. set_tlv_db_scale(kctl, db_scale_4bit);
  1252. snd_ac97_write_cache(ac97, AC97_PC_BEEP,
  1253. snd_ac97_read(ac97, AC97_PC_BEEP) | 0x801e);
  1254. }
  1255. /* build Phone controls */
  1256. if (!(ac97->flags & AC97_HAS_NO_PHONE)) {
  1257. if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
  1258. if ((err = snd_ac97_cmix_new(card, "Phone Playback",
  1259. AC97_PHONE, 1, ac97)) < 0)
  1260. return err;
  1261. }
  1262. }
  1263. /* build MIC controls */
  1264. if (!(ac97->flags & AC97_HAS_NO_MIC)) {
  1265. if (snd_ac97_try_volume_mix(ac97, AC97_MIC)) {
  1266. if ((err = snd_ac97_cmix_new(card, "Mic Playback",
  1267. AC97_MIC, 1, ac97)) < 0)
  1268. return err;
  1269. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_boost, ac97))) < 0)
  1270. return err;
  1271. }
  1272. }
  1273. /* build Line controls */
  1274. if (snd_ac97_try_volume_mix(ac97, AC97_LINE)) {
  1275. if ((err = snd_ac97_cmix_new(card, "Line Playback",
  1276. AC97_LINE, 1, ac97)) < 0)
  1277. return err;
  1278. }
  1279. /* build CD controls */
  1280. if (!(ac97->flags & AC97_HAS_NO_CD)) {
  1281. if (snd_ac97_try_volume_mix(ac97, AC97_CD)) {
  1282. if ((err = snd_ac97_cmix_new(card, "CD Playback",
  1283. AC97_CD, 1, ac97)) < 0)
  1284. return err;
  1285. }
  1286. }
  1287. /* build Video controls */
  1288. if (!(ac97->flags & AC97_HAS_NO_VIDEO)) {
  1289. if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
  1290. if ((err = snd_ac97_cmix_new(card, "Video Playback",
  1291. AC97_VIDEO, 1, ac97)) < 0)
  1292. return err;
  1293. }
  1294. }
  1295. /* build Aux controls */
  1296. if (!(ac97->flags & AC97_HAS_NO_AUX)) {
  1297. if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
  1298. if ((err = snd_ac97_cmix_new(card, "Aux Playback",
  1299. AC97_AUX, 1, ac97)) < 0)
  1300. return err;
  1301. }
  1302. }
  1303. /* build PCM controls */
  1304. if (ac97->flags & AC97_AD_MULTI) {
  1305. unsigned short init_val;
  1306. if (ac97->flags & AC97_STEREO_MUTES)
  1307. init_val = 0x9f9f;
  1308. else
  1309. init_val = 0x9f1f;
  1310. for (idx = 0; idx < 2; idx++)
  1311. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_pcm[idx], ac97))) < 0)
  1312. return err;
  1313. set_tlv_db_scale(kctl, db_scale_5bit);
  1314. ac97->spec.ad18xx.pcmreg[0] = init_val;
  1315. if (ac97->scaps & AC97_SCAP_SURROUND_DAC) {
  1316. for (idx = 0; idx < 2; idx++)
  1317. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_surround[idx], ac97))) < 0)
  1318. return err;
  1319. set_tlv_db_scale(kctl, db_scale_5bit);
  1320. ac97->spec.ad18xx.pcmreg[1] = init_val;
  1321. }
  1322. if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC) {
  1323. for (idx = 0; idx < 2; idx++)
  1324. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_center[idx], ac97))) < 0)
  1325. return err;
  1326. set_tlv_db_scale(kctl, db_scale_5bit);
  1327. for (idx = 0; idx < 2; idx++)
  1328. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_ad18xx_lfe[idx], ac97))) < 0)
  1329. return err;
  1330. set_tlv_db_scale(kctl, db_scale_5bit);
  1331. ac97->spec.ad18xx.pcmreg[2] = init_val;
  1332. }
  1333. snd_ac97_write_cache(ac97, AC97_PCM, init_val);
  1334. } else {
  1335. if (!(ac97->flags & AC97_HAS_NO_STD_PCM)) {
  1336. if (ac97->flags & AC97_HAS_NO_PCM_VOL)
  1337. err = snd_ac97_cmute_new(card,
  1338. "PCM Playback Switch",
  1339. AC97_PCM, 0, ac97);
  1340. else
  1341. err = snd_ac97_cmix_new(card, "PCM Playback",
  1342. AC97_PCM, 0, ac97);
  1343. if (err < 0)
  1344. return err;
  1345. }
  1346. }
  1347. /* build Capture controls */
  1348. if (!(ac97->flags & AC97_HAS_NO_REC_GAIN)) {
  1349. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_src, ac97))) < 0)
  1350. return err;
  1351. if (snd_ac97_try_bit(ac97, AC97_REC_GAIN, 15)) {
  1352. err = snd_ac97_cmute_new(card, "Capture Switch",
  1353. AC97_REC_GAIN, 0, ac97);
  1354. if (err < 0)
  1355. return err;
  1356. }
  1357. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
  1358. return err;
  1359. set_tlv_db_scale(kctl, db_scale_rec_gain);
  1360. snd_ac97_write_cache(ac97, AC97_REC_SEL, 0x0000);
  1361. snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x0000);
  1362. }
  1363. /* build MIC Capture controls */
  1364. if (snd_ac97_try_volume_mix(ac97, AC97_REC_GAIN_MIC)) {
  1365. for (idx = 0; idx < 2; idx++)
  1366. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_mic_capture[idx], ac97))) < 0)
  1367. return err;
  1368. set_tlv_db_scale(kctl, db_scale_rec_gain);
  1369. snd_ac97_write_cache(ac97, AC97_REC_GAIN_MIC, 0x0000);
  1370. }
  1371. /* build PCM out path & mute control */
  1372. if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 15)) {
  1373. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_PCM_OUT], ac97))) < 0)
  1374. return err;
  1375. }
  1376. /* build Simulated Stereo Enhancement control */
  1377. if (ac97->caps & 0x0008) {
  1378. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_STEREO_ENHANCEMENT], ac97))) < 0)
  1379. return err;
  1380. }
  1381. /* build 3D Stereo Enhancement control */
  1382. if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 13)) {
  1383. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_3D], ac97))) < 0)
  1384. return err;
  1385. }
  1386. /* build Loudness control */
  1387. if (ac97->caps & 0x0020) {
  1388. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOUDNESS], ac97))) < 0)
  1389. return err;
  1390. }
  1391. /* build Mono output select control */
  1392. if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 9)) {
  1393. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MONO], ac97))) < 0)
  1394. return err;
  1395. }
  1396. /* build Mic select control */
  1397. if (snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 8)) {
  1398. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_MIC], ac97))) < 0)
  1399. return err;
  1400. }
  1401. /* build ADC/DAC loopback control */
  1402. if (enable_loopback && snd_ac97_try_bit(ac97, AC97_GENERAL_PURPOSE, 7)) {
  1403. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_general[AC97_GENERAL_LOOPBACK], ac97))) < 0)
  1404. return err;
  1405. }
  1406. snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, ~AC97_GP_DRSS_MASK, 0x0000);
  1407. /* build 3D controls */
  1408. if (ac97->build_ops->build_3d) {
  1409. ac97->build_ops->build_3d(ac97);
  1410. } else {
  1411. if (snd_ac97_try_volume_mix(ac97, AC97_3D_CONTROL)) {
  1412. unsigned short val;
  1413. val = 0x0707;
  1414. snd_ac97_write(ac97, AC97_3D_CONTROL, val);
  1415. val = snd_ac97_read(ac97, AC97_3D_CONTROL);
  1416. val = val == 0x0606;
  1417. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
  1418. return err;
  1419. if (val)
  1420. kctl->private_value = AC97_3D_CONTROL | (9 << 8) | (7 << 16);
  1421. if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[1], ac97))) < 0)
  1422. return err;
  1423. if (val)
  1424. kctl->private_value = AC97_3D_CONTROL | (1 << 8) | (7 << 16);
  1425. snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
  1426. }
  1427. }
  1428. /* build S/PDIF controls */
  1429. /* Hack for ASUS P5P800-VM, which does not indicate S/PDIF capability */
  1430. if (ac97->subsystem_vendor == 0x1043 &&
  1431. ac97->subsystem_device == 0x810f)
  1432. ac97->ext_id |= AC97_EI_SPDIF;
  1433. if ((ac97->ext_id & AC97_EI_SPDIF) && !(ac97->scaps & AC97_SCAP_NO_SPDIF)) {
  1434. if (ac97->build_ops->build_spdif) {
  1435. if ((err = ac97->build_ops->build_spdif(ac97)) < 0)
  1436. return err;
  1437. } else {
  1438. for (idx = 0; idx < 5; idx++)
  1439. if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_spdif[idx], ac97))) < 0)
  1440. return err;
  1441. if (ac97->build_ops->build_post_spdif) {
  1442. if ((err = ac97->build_ops->build_post_spdif(ac97)) < 0)
  1443. return err;
  1444. }
  1445. /* set default PCM S/PDIF params */
  1446. /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
  1447. snd_ac97_write_cache(ac97, AC97_SPDIF, 0x2a20);
  1448. ac97->rates[AC97_RATES_SPDIF] = snd_ac97_determine_spdif_rates(ac97);
  1449. }
  1450. ac97->spdif_status = SNDRV_PCM_DEFAULT_CON_SPDIF;
  1451. }
  1452. /* build chip specific controls */
  1453. if (ac97->build_ops->build_specific)
  1454. if ((err = ac97->build_ops->build_specific(ac97)) < 0)
  1455. return err;
  1456. if (snd_ac97_try_bit(ac97, AC97_POWERDOWN, 15)) {
  1457. kctl = snd_ac97_cnew(&snd_ac97_control_eapd, ac97);
  1458. if (! kctl)
  1459. return -ENOMEM;
  1460. if (ac97->scaps & AC97_SCAP_INV_EAPD)
  1461. set_inv_eapd(ac97, kctl);
  1462. if ((err = snd_ctl_add(card, kctl)) < 0)
  1463. return err;
  1464. }
  1465. return 0;
  1466. }
  1467. static int snd_ac97_modem_build(struct snd_card *card, struct snd_ac97 * ac97)
  1468. {
  1469. int err, idx;
  1470. //printk("AC97_GPIO_CFG = %x\n",snd_ac97_read(ac97,AC97_GPIO_CFG));
  1471. snd_ac97_write(ac97, AC97_GPIO_CFG, 0xffff & ~(AC97_GPIO_LINE1_OH));
  1472. snd_ac97_write(ac97, AC97_GPIO_POLARITY, 0xffff & ~(AC97_GPIO_LINE1_OH));
  1473. snd_ac97_write(ac97, AC97_GPIO_STICKY, 0xffff);
  1474. snd_ac97_write(ac97, AC97_GPIO_WAKEUP, 0x0);
  1475. snd_ac97_write(ac97, AC97_MISC_AFE, 0x0);
  1476. /* build modem switches */
  1477. for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_modem_switches); idx++)
  1478. if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ac97_controls_modem_switches[idx], ac97))) < 0)
  1479. return err;
  1480. /* build chip specific controls */
  1481. if (ac97->build_ops->build_specific)
  1482. if ((err = ac97->build_ops->build_specific(ac97)) < 0)
  1483. return err;
  1484. return 0;
  1485. }
  1486. static int snd_ac97_test_rate(struct snd_ac97 *ac97, int reg, int shadow_reg, int rate)
  1487. {
  1488. unsigned short val;
  1489. unsigned int tmp;
  1490. tmp = ((unsigned int)rate * ac97->bus->clock) / 48000;
  1491. snd_ac97_write_cache(ac97, reg, tmp & 0xffff);
  1492. if (shadow_reg)
  1493. snd_ac97_write_cache(ac97, shadow_reg, tmp & 0xffff);
  1494. val = snd_ac97_read(ac97, reg);
  1495. return val == (tmp & 0xffff);
  1496. }
  1497. static void snd_ac97_determine_rates(struct snd_ac97 *ac97, int reg, int shadow_reg, unsigned int *r_result)
  1498. {
  1499. unsigned int result = 0;
  1500. unsigned short saved;
  1501. if (ac97->bus->no_vra) {
  1502. *r_result = SNDRV_PCM_RATE_48000;
  1503. if ((ac97->flags & AC97_DOUBLE_RATE) &&
  1504. reg == AC97_PCM_FRONT_DAC_RATE)
  1505. *r_result |= SNDRV_PCM_RATE_96000;
  1506. return;
  1507. }
  1508. saved = snd_ac97_read(ac97, reg);
  1509. if ((ac97->ext_id & AC97_EI_DRA) && reg == AC97_PCM_FRONT_DAC_RATE)
  1510. snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
  1511. AC97_EA_DRA, 0);
  1512. /* test a non-standard rate */
  1513. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11000))
  1514. result |= SNDRV_PCM_RATE_CONTINUOUS;
  1515. /* let's try to obtain standard rates */
  1516. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 8000))
  1517. result |= SNDRV_PCM_RATE_8000;
  1518. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 11025))
  1519. result |= SNDRV_PCM_RATE_11025;
  1520. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 16000))
  1521. result |= SNDRV_PCM_RATE_16000;
  1522. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 22050))
  1523. result |= SNDRV_PCM_RATE_22050;
  1524. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 32000))
  1525. result |= SNDRV_PCM_RATE_32000;
  1526. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 44100))
  1527. result |= SNDRV_PCM_RATE_44100;
  1528. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 48000))
  1529. result |= SNDRV_PCM_RATE_48000;
  1530. if ((ac97->flags & AC97_DOUBLE_RATE) &&
  1531. reg == AC97_PCM_FRONT_DAC_RATE) {
  1532. /* test standard double rates */
  1533. snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
  1534. AC97_EA_DRA, AC97_EA_DRA);
  1535. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 64000 / 2))
  1536. result |= SNDRV_PCM_RATE_64000;
  1537. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 88200 / 2))
  1538. result |= SNDRV_PCM_RATE_88200;
  1539. if (snd_ac97_test_rate(ac97, reg, shadow_reg, 96000 / 2))
  1540. result |= SNDRV_PCM_RATE_96000;
  1541. /* some codecs don't support variable double rates */
  1542. if (!snd_ac97_test_rate(ac97, reg, shadow_reg, 76100 / 2))
  1543. result &= ~SNDRV_PCM_RATE_CONTINUOUS;
  1544. snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS,
  1545. AC97_EA_DRA, 0);
  1546. }
  1547. /* restore the default value */
  1548. snd_ac97_write_cache(ac97, reg, saved);
  1549. if (shadow_reg)
  1550. snd_ac97_write_cache(ac97, shadow_reg, saved);
  1551. *r_result = result;
  1552. }
  1553. /* check AC97_SPDIF register to accept which sample rates */
  1554. static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97)
  1555. {
  1556. unsigned int result = 0;
  1557. int i;
  1558. static unsigned short ctl_bits[] = {
  1559. AC97_SC_SPSR_44K, AC97_SC_SPSR_32K, AC97_SC_SPSR_48K
  1560. };
  1561. static unsigned int rate_bits[] = {
  1562. SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_32000, SNDRV_PCM_RATE_48000
  1563. };
  1564. for (i = 0; i < (int)ARRAY_SIZE(ctl_bits); i++) {
  1565. snd_ac97_update_bits(ac97, AC97_SPDIF, AC97_SC_SPSR_MASK, ctl_bits[i]);
  1566. if ((snd_ac97_read(ac97, AC97_SPDIF) & AC97_SC_SPSR_MASK) == ctl_bits[i])
  1567. result |= rate_bits[i];
  1568. }
  1569. return result;
  1570. }
  1571. /* look for the codec id table matching with the given id */
  1572. static const struct ac97_codec_id *look_for_codec_id(const struct ac97_codec_id *table,
  1573. unsigned int id)
  1574. {
  1575. const struct ac97_codec_id *pid;
  1576. for (pid = table; pid->id; pid++)
  1577. if (pid->id == (id & pid->mask))
  1578. return pid;
  1579. return NULL;
  1580. }
  1581. void snd_ac97_get_name(struct snd_ac97 *ac97, unsigned int id, char *name, int modem)
  1582. {
  1583. const struct ac97_codec_id *pid;
  1584. sprintf(name, "0x%x %c%c%c", id,
  1585. printable(id >> 24),
  1586. printable(id >> 16),
  1587. printable(id >> 8));
  1588. pid = look_for_codec_id(snd_ac97_codec_id_vendors, id);
  1589. if (! pid)
  1590. return;
  1591. strcpy(name, pid->name);
  1592. if (ac97 && pid->patch) {
  1593. if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
  1594. (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
  1595. pid->patch(ac97);
  1596. }
  1597. pid = look_for_codec_id(snd_ac97_codec_ids, id);
  1598. if (pid) {
  1599. strcat(name, " ");
  1600. strcat(name, pid->name);
  1601. if (pid->mask != 0xffffffff)
  1602. sprintf(name + strlen(name), " rev %d", id & ~pid->mask);
  1603. if (ac97 && pid->patch) {
  1604. if ((modem && (pid->flags & AC97_MODEM_PATCH)) ||
  1605. (! modem && ! (pid->flags & AC97_MODEM_PATCH)))
  1606. pid->patch(ac97);
  1607. }
  1608. } else
  1609. sprintf(name + strlen(name), " id %x", id & 0xff);
  1610. }
  1611. /**
  1612. * snd_ac97_get_short_name - retrieve codec name
  1613. * @ac97: the codec instance
  1614. *
  1615. * Returns the short identifying name of the codec.
  1616. */
  1617. const char *snd_ac97_get_short_name(struct snd_ac97 *ac97)
  1618. {
  1619. const struct ac97_codec_id *pid;
  1620. for (pid = snd_ac97_codec_ids; pid->id; pid++)
  1621. if (pid->id == (ac97->id & pid->mask))
  1622. return pid->name;
  1623. return "unknown codec";
  1624. }
  1625. EXPORT_SYMBOL(snd_ac97_get_short_name);
  1626. /* wait for a while until registers are accessible after RESET
  1627. * return 0 if ok, negative not ready
  1628. */
  1629. static int ac97_reset_wait(struct snd_ac97 *ac97, int timeout, int with_modem)
  1630. {
  1631. unsigned long end_time;
  1632. unsigned short val;
  1633. end_time = jiffies + timeout;
  1634. do {
  1635. /* use preliminary reads to settle the communication */
  1636. snd_ac97_read(ac97, AC97_RESET);
  1637. snd_ac97_read(ac97, AC97_VENDOR_ID1);
  1638. snd_ac97_read(ac97, AC97_VENDOR_ID2);
  1639. /* modem? */
  1640. if (with_modem) {
  1641. val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
  1642. if (val != 0xffff && (val & 1) != 0)
  1643. return 0;
  1644. }
  1645. if (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) {
  1646. /* probably only Xbox issue - all registers are read as zero */
  1647. val = snd_ac97_read(ac97, AC97_VENDOR_ID1);
  1648. if (val != 0 && val != 0xffff)
  1649. return 0;
  1650. } else {
  1651. /* because the PCM or MASTER volume registers can be modified,
  1652. * the REC_GAIN register is used for tests
  1653. */
  1654. /* test if we can write to the record gain volume register */
  1655. snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a05);
  1656. if ((snd_ac97_read(ac97, AC97_REC_GAIN) & 0x7fff) == 0x0a05)
  1657. return 0;
  1658. }
  1659. schedule_timeout_uninterruptible(1);
  1660. } while (time_after_eq(end_time, jiffies));
  1661. return -ENODEV;
  1662. }
  1663. /**
  1664. * snd_ac97_bus - create an AC97 bus component
  1665. * @card: the card instance
  1666. * @num: the bus number
  1667. * @ops: the bus callbacks table
  1668. * @private_data: private data pointer for the new instance
  1669. * @rbus: the pointer to store the new AC97 bus instance.
  1670. *
  1671. * Creates an AC97 bus component. An struct snd_ac97_bus instance is newly
  1672. * allocated and initialized.
  1673. *
  1674. * The ops table must include valid callbacks (at least read and
  1675. * write). The other callbacks, wait and reset, are not mandatory.
  1676. *
  1677. * The clock is set to 48000. If another clock is needed, set
  1678. * (*rbus)->clock manually.
  1679. *
  1680. * The AC97 bus instance is registered as a low-level device, so you don't
  1681. * have to release it manually.
  1682. *
  1683. * Returns zero if successful, or a negative error code on failure.
  1684. */
  1685. int snd_ac97_bus(struct snd_card *card, int num, struct snd_ac97_bus_ops *ops,
  1686. void *private_data, struct snd_ac97_bus **rbus)
  1687. {
  1688. int err;
  1689. struct snd_ac97_bus *bus;
  1690. static struct snd_device_ops dev_ops = {
  1691. .dev_free = snd_ac97_bus_dev_free,
  1692. };
  1693. snd_assert(card != NULL, return -EINVAL);
  1694. snd_assert(rbus != NULL, return -EINVAL);
  1695. bus = kzalloc(sizeof(*bus), GFP_KERNEL);
  1696. if (bus == NULL)
  1697. return -ENOMEM;
  1698. bus->card = card;
  1699. bus->num = num;
  1700. bus->ops = ops;
  1701. bus->private_data = private_data;
  1702. bus->clock = 48000;
  1703. spin_lock_init(&bus->bus_lock);
  1704. snd_ac97_bus_proc_init(bus);
  1705. if ((err = snd_device_new(card, SNDRV_DEV_BUS, bus, &dev_ops)) < 0) {
  1706. snd_ac97_bus_free(bus);
  1707. return err;
  1708. }
  1709. *rbus = bus;
  1710. return 0;
  1711. }
  1712. EXPORT_SYMBOL(snd_ac97_bus);
  1713. /* stop no dev release warning */
  1714. static void ac97_device_release(struct device * dev)
  1715. {
  1716. }
  1717. /* register ac97 codec to bus */
  1718. static int snd_ac97_dev_register(struct snd_device *device)
  1719. {
  1720. struct snd_ac97 *ac97 = device->device_data;
  1721. int err;
  1722. ac97->dev.bus = &ac97_bus_type;
  1723. ac97->dev.parent = ac97->bus->card->dev;
  1724. ac97->dev.release = ac97_device_release;
  1725. snprintf(ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s",
  1726. ac97->bus->card->number, ac97->num,
  1727. snd_ac97_get_short_name(ac97));
  1728. if ((err = device_register(&ac97->dev)) < 0) {
  1729. snd_printk(KERN_ERR "Can't register ac97 bus\n");
  1730. ac97->dev.bus = NULL;
  1731. return err;
  1732. }
  1733. return 0;
  1734. }
  1735. /* disconnect ac97 codec */
  1736. static int snd_ac97_dev_disconnect(struct snd_device *device)
  1737. {
  1738. struct snd_ac97 *ac97 = device->device_data;
  1739. if (ac97->dev.bus)
  1740. device_unregister(&ac97->dev);
  1741. return 0;
  1742. }
  1743. /* build_ops to do nothing */
  1744. static struct snd_ac97_build_ops null_build_ops;
  1745. #ifdef CONFIG_SND_AC97_POWER_SAVE
  1746. static void do_update_power(struct work_struct *work)
  1747. {
  1748. update_power_regs(
  1749. container_of(work, struct snd_ac97, power_work.work));
  1750. }
  1751. #endif
  1752. /**
  1753. * snd_ac97_mixer - create an Codec97 component
  1754. * @bus: the AC97 bus which codec is attached to
  1755. * @template: the template of ac97, including index, callbacks and
  1756. * the private data.
  1757. * @rac97: the pointer to store the new ac97 instance.
  1758. *
  1759. * Creates an Codec97 component. An struct snd_ac97 instance is newly
  1760. * allocated and initialized from the template. The codec
  1761. * is then initialized by the standard procedure.
  1762. *
  1763. * The template must include the codec number (num) and address (addr),
  1764. * and the private data (private_data).
  1765. *
  1766. * The ac97 instance is registered as a low-level device, so you don't
  1767. * have to release it manually.
  1768. *
  1769. * Returns zero if successful, or a negative error code on failure.
  1770. */
  1771. int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template, struct snd_ac97 **rac97)
  1772. {
  1773. int err;
  1774. struct snd_ac97 *ac97;
  1775. struct snd_card *card;
  1776. char name[64];
  1777. unsigned long end_time;
  1778. unsigned int reg;
  1779. const struct ac97_codec_id *pid;
  1780. static struct snd_device_ops ops = {
  1781. .dev_free = snd_ac97_dev_free,
  1782. .dev_register = snd_ac97_dev_register,
  1783. .dev_disconnect = snd_ac97_dev_disconnect,
  1784. };
  1785. snd_assert(rac97 != NULL, return -EINVAL);
  1786. *rac97 = NULL;
  1787. snd_assert(bus != NULL && template != NULL, return -EINVAL);
  1788. snd_assert(template->num < 4 && bus->codec[template->num] == NULL, return -EINVAL);
  1789. card = bus->card;
  1790. ac97 = kzalloc(sizeof(*ac97), GFP_KERNEL);
  1791. if (ac97 == NULL)
  1792. return -ENOMEM;
  1793. ac97->private_data = template->private_data;
  1794. ac97->private_free = template->private_free;
  1795. ac97->bus = bus;
  1796. ac97->pci = template->pci;
  1797. ac97->num = template->num;
  1798. ac97->addr = template->addr;
  1799. ac97->scaps = template->scaps;
  1800. ac97->res_table = template->res_table;
  1801. bus->codec[ac97->num] = ac97;
  1802. mutex_init(&ac97->reg_mutex);
  1803. mutex_init(&ac97->page_mutex);
  1804. #ifdef CONFIG_SND_AC97_POWER_SAVE
  1805. INIT_DELAYED_WORK(&ac97->power_work, do_update_power);
  1806. #endif
  1807. #ifdef CONFIG_PCI
  1808. if (ac97->pci) {
  1809. pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_VENDOR_ID, &ac97->subsystem_vendor);
  1810. pci_read_config_word(ac97->pci, PCI_SUBSYSTEM_ID, &ac97->subsystem_device);
  1811. }
  1812. #endif
  1813. if (bus->ops->reset) {
  1814. bus->ops->reset(ac97);
  1815. goto __access_ok;
  1816. }
  1817. ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
  1818. ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
  1819. if (ac97->id && ac97->id != (unsigned int)-1) {
  1820. pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
  1821. if (pid && (pid->flags & AC97_DEFAULT_POWER_OFF))
  1822. goto __access_ok;
  1823. }
  1824. /* reset to defaults */
  1825. if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
  1826. snd_ac97_write(ac97, AC97_RESET, 0);
  1827. if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
  1828. snd_ac97_write(ac97, AC97_EXTENDED_MID, 0);
  1829. if (bus->ops->wait)
  1830. bus->ops->wait(ac97);
  1831. else {
  1832. udelay(50);
  1833. if (ac97->scaps & AC97_SCAP_SKIP_AUDIO)
  1834. err = ac97_reset_wait(ac97, msecs_to_jiffies(500), 1);
  1835. else {
  1836. err = ac97_reset_wait(ac97, msecs_to_jiffies(500), 0);
  1837. if (err < 0)
  1838. err = ac97_reset_wait(ac97,
  1839. msecs_to_jiffies(500), 1);
  1840. }
  1841. if (err < 0) {
  1842. snd_printk(KERN_WARNING "AC'97 %d does not respond - RESET\n", ac97->num);
  1843. /* proceed anyway - it's often non-critical */
  1844. }
  1845. }
  1846. __access_ok:
  1847. ac97->id = snd_ac97_read(ac97, AC97_VENDOR_ID1) << 16;
  1848. ac97->id |= snd_ac97_read(ac97, AC97_VENDOR_ID2);
  1849. if (! (ac97->scaps & AC97_SCAP_DETECT_BY_VENDOR) &&
  1850. (ac97->id == 0x00000000 || ac97->id == 0xffffffff)) {
  1851. snd_printk(KERN_ERR "AC'97 %d access is not valid [0x%x], removing mixer.\n", ac97->num, ac97->id);
  1852. snd_ac97_free(ac97);
  1853. return -EIO;
  1854. }
  1855. pid = look_for_codec_id(snd_ac97_codec_ids, ac97->id);
  1856. if (pid)
  1857. ac97->flags |= pid->flags;
  1858. /* test for AC'97 */
  1859. if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO) && !(ac97->scaps & AC97_SCAP_AUDIO)) {
  1860. /* test if we can write to the record gain volume register */
  1861. snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x8a06);
  1862. if (((err = snd_ac97_read(ac97, AC97_REC_GAIN)) & 0x7fff) == 0x0a06)
  1863. ac97->scaps |= AC97_SCAP_AUDIO;
  1864. }
  1865. if (ac97->scaps & AC97_SCAP_AUDIO) {
  1866. ac97->caps = snd_ac97_read(ac97, AC97_RESET);
  1867. ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
  1868. if (ac97->ext_id == 0xffff) /* invalid combination */
  1869. ac97->ext_id = 0;
  1870. }
  1871. /* test for MC'97 */
  1872. if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM) && !(ac97->scaps & AC97_SCAP_MODEM)) {
  1873. ac97->ext_mid = snd_ac97_read(ac97, AC97_EXTENDED_MID);
  1874. if (ac97->ext_mid == 0xffff) /* invalid combination */
  1875. ac97->ext_mid = 0;
  1876. if (ac97->ext_mid & 1)
  1877. ac97->scaps |= AC97_SCAP_MODEM;
  1878. }
  1879. if (!ac97_is_audio(ac97) && !ac97_is_modem(ac97)) {
  1880. if (!(ac97->scaps & (AC97_SCAP_SKIP_AUDIO|AC97_SCAP_SKIP_MODEM)))
  1881. snd_printk(KERN_ERR "AC'97 %d access error (not audio or modem codec)\n", ac97->num);
  1882. snd_ac97_free(ac97);
  1883. return -EACCES;
  1884. }
  1885. if (bus->ops->reset) // FIXME: always skipping?
  1886. goto __ready_ok;
  1887. /* FIXME: add powerdown control */
  1888. if (ac97_is_audio(ac97)) {
  1889. /* nothing should be in powerdown mode */
  1890. snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
  1891. if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
  1892. snd_ac97_write_cache(ac97, AC97_RESET, 0); /* reset to defaults */
  1893. udelay(100);
  1894. snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0);
  1895. }
  1896. /* nothing should be in powerdown mode */
  1897. snd_ac97_write_cache(ac97, AC97_GENERAL_PURPOSE, 0);
  1898. end_time = jiffies + msecs_to_jiffies(100);
  1899. do {
  1900. if ((snd_ac97_read(ac97, AC97_POWERDOWN) & 0x0f) == 0x0f)
  1901. goto __ready_ok;
  1902. schedule_timeout_uninterruptible(1);
  1903. } while (time_after_eq(end_time, jiffies));
  1904. snd_printk(KERN_WARNING "AC'97 %d analog subsections not ready\n", ac97->num);
  1905. }
  1906. /* FIXME: add powerdown control */
  1907. if (ac97_is_modem(ac97)) {
  1908. unsigned char tmp;
  1909. /* nothing should be in powerdown mode */
  1910. /* note: it's important to set the rate at first */
  1911. tmp = AC97_MEA_GPIO;
  1912. if (ac97->ext_mid & AC97_MEI_LINE1) {
  1913. snd_ac97_write_cache(ac97, AC97_LINE1_RATE, 8000);
  1914. tmp |= AC97_MEA_ADC1 | AC97_MEA_DAC1;
  1915. }
  1916. if (ac97->ext_mid & AC97_MEI_LINE2) {
  1917. snd_ac97_write_cache(ac97, AC97_LINE2_RATE, 8000);
  1918. tmp |= AC97_MEA_ADC2 | AC97_MEA_DAC2;
  1919. }
  1920. if (ac97->ext_mid & AC97_MEI_HANDSET) {
  1921. snd_ac97_write_cache(ac97, AC97_HANDSET_RATE, 8000);
  1922. tmp |= AC97_MEA_HADC | AC97_MEA_HDAC;
  1923. }
  1924. snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0);
  1925. udelay(100);
  1926. /* nothing should be in powerdown mode */
  1927. snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0);
  1928. end_time = jiffies + msecs_to_jiffies(100);
  1929. do {
  1930. if ((snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS) & tmp) == tmp)
  1931. goto __ready_ok;
  1932. schedule_timeout_uninterruptible(1);
  1933. } while (time_after_eq(end_time, jiffies));
  1934. snd_printk(KERN_WARNING "MC'97 %d converters and GPIO not ready (0x%x)\n", ac97->num, snd_ac97_read(ac97, AC97_EXTENDED_MSTATUS));
  1935. }
  1936. __ready_ok:
  1937. if (ac97_is_audio(ac97))
  1938. ac97->addr = (ac97->ext_id & AC97_EI_ADDR_MASK) >> AC97_EI_ADDR_SHIFT;
  1939. else
  1940. ac97->addr = (ac97->ext_mid & AC97_MEI_ADDR_MASK) >> AC97_MEI_ADDR_SHIFT;
  1941. if (ac97->ext_id & 0x01c9) { /* L/R, MIC, SDAC, LDAC VRA support */
  1942. reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
  1943. reg |= ac97->ext_id & 0x01c0; /* LDAC/SDAC/CDAC */
  1944. if (! bus->no_vra)
  1945. reg |= ac97->ext_id & 0x0009; /* VRA/VRM */
  1946. snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
  1947. }
  1948. if ((ac97->ext_id & AC97_EI_DRA) && bus->dra) {
  1949. /* Intel controllers require double rate data to be put in
  1950. * slots 7+8, so let's hope the codec supports it. */
  1951. snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, AC97_GP_DRSS_78);
  1952. if ((snd_ac97_read(ac97, AC97_GENERAL_PURPOSE) & AC97_GP_DRSS_MASK) == AC97_GP_DRSS_78)
  1953. ac97->flags |= AC97_DOUBLE_RATE;
  1954. /* restore to slots 10/11 to avoid the confliction with surrounds */
  1955. snd_ac97_update_bits(ac97, AC97_GENERAL_PURPOSE, AC97_GP_DRSS_MASK, 0);
  1956. }
  1957. if (ac97->ext_id & AC97_EI_VRA) { /* VRA support */
  1958. snd_ac97_determine_rates(ac97, AC97_PCM_FRONT_DAC_RATE, 0, &ac97->rates[AC97_RATES_FRONT_DAC]);
  1959. snd_ac97_determine_rates(ac97, AC97_PCM_LR_ADC_RATE, 0, &ac97->rates[AC97_RATES_ADC]);
  1960. } else {
  1961. ac97->rates[AC97_RATES_FRONT_DAC] = SNDRV_PCM_RATE_48000;
  1962. if (ac97->flags & AC97_DOUBLE_RATE)
  1963. ac97->rates[AC97_RATES_FRONT_DAC] |= SNDRV_PCM_RATE_96000;
  1964. ac97->rates[AC97_RATES_ADC] = SNDRV_PCM_RATE_48000;
  1965. }
  1966. if (ac97->ext_id & AC97_EI_SPDIF) {
  1967. /* codec specific code (patch) should override these values */
  1968. ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_32000;
  1969. }
  1970. if (ac97->ext_id & AC97_EI_VRM) { /* MIC VRA support */
  1971. snd_ac97_determine_rates(ac97, AC97_PCM_MIC_ADC_RATE, 0, &ac97->rates[AC97_RATES_MIC_ADC]);
  1972. } else {
  1973. ac97->rates[AC97_RATES_MIC_ADC] = SNDRV_PCM_RATE_48000;
  1974. }
  1975. if (ac97->ext_id & AC97_EI_SDAC) { /* SDAC support */
  1976. snd_ac97_determine_rates(ac97, AC97_PCM_SURR_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_SURR_DAC]);
  1977. ac97->scaps |= AC97_SCAP_SURROUND_DAC;
  1978. }
  1979. if (ac97->ext_id & AC97_EI_LDAC) { /* LDAC support */
  1980. snd_ac97_determine_rates(ac97, AC97_PCM_LFE_DAC_RATE, AC97_PCM_FRONT_DAC_RATE, &ac97->rates[AC97_RATES_LFE_DAC]);
  1981. ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
  1982. }
  1983. /* additional initializations */
  1984. if (bus->ops->init)
  1985. bus->ops->init(ac97);
  1986. snd_ac97_get_name(ac97, ac97->id, name, !ac97_is_audio(ac97));
  1987. snd_ac97_get_name(NULL, ac97->id, name, !ac97_is_audio(ac97)); // ac97->id might be changed in the special setup code
  1988. if (! ac97->build_ops)
  1989. ac97->build_ops = &null_build_ops;
  1990. if (ac97_is_audio(ac97)) {
  1991. char comp[16];
  1992. if (card->mixername[0] == '\0') {
  1993. strcpy(card->mixername, name);
  1994. } else {
  1995. if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
  1996. strcat(card->mixername, ",");
  1997. strcat(card->mixername, name);
  1998. }
  1999. }
  2000. sprintf(comp, "AC97a:%08x", ac97->id);
  2001. if ((err = snd_component_add(card, comp)) < 0) {
  2002. snd_ac97_free(ac97);
  2003. return err;
  2004. }
  2005. if (snd_ac97_mixer_build(ac97) < 0) {
  2006. snd_ac97_free(ac97);
  2007. return -ENOMEM;
  2008. }
  2009. }
  2010. if (ac97_is_modem(ac97)) {
  2011. char comp[16];
  2012. if (card->mixername[0] == '\0') {
  2013. strcpy(card->mixername, name);
  2014. } else {
  2015. if (strlen(card->mixername) + 1 + strlen(name) + 1 <= sizeof(card->mixername)) {
  2016. strcat(card->mixername, ",");
  2017. strcat(card->mixername, name);
  2018. }
  2019. }
  2020. sprintf(comp, "AC97m:%08x", ac97->id);
  2021. if ((err = snd_component_add(card, comp)) < 0) {
  2022. snd_ac97_free(ac97);
  2023. return err;
  2024. }
  2025. if (snd_ac97_modem_build(card, ac97) < 0) {
  2026. snd_ac97_free(ac97);
  2027. return -ENOMEM;
  2028. }
  2029. }
  2030. if (ac97_is_audio(ac97))
  2031. update_power_regs(ac97);
  2032. snd_ac97_proc_init(ac97);
  2033. if ((err = snd_device_new(card, SNDRV_DEV_CODEC, ac97, &ops)) < 0) {
  2034. snd_ac97_free(ac97);
  2035. return err;
  2036. }
  2037. *rac97 = ac97;
  2038. return 0;
  2039. }
  2040. EXPORT_SYMBOL(snd_ac97_mixer);
  2041. /*
  2042. * Power down the chip.
  2043. *
  2044. * MASTER and HEADPHONE registers are muted but the register cache values
  2045. * are not changed, so that the values can be restored in snd_ac97_resume().
  2046. */
  2047. static void snd_ac97_powerdown(struct snd_ac97 *ac97)
  2048. {
  2049. unsigned short power;
  2050. if (ac97_is_audio(ac97)) {
  2051. /* some codecs have stereo mute bits */
  2052. snd_ac97_write(ac97, AC97_MASTER, 0x9f9f);
  2053. snd_ac97_write(ac97, AC97_HEADPHONE, 0x9f9f);
  2054. }
  2055. /* surround, CLFE, mic powerdown */
  2056. power = ac97->regs[AC97_EXTENDED_STATUS];
  2057. if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
  2058. power |= AC97_EA_PRJ;
  2059. if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
  2060. power |= AC97_EA_PRI | AC97_EA_PRK;
  2061. power |= AC97_EA_PRL;
  2062. snd_ac97_write(ac97, AC97_EXTENDED_STATUS, power);
  2063. /* powerdown external amplifier */
  2064. if (ac97->scaps & AC97_SCAP_INV_EAPD)
  2065. power = ac97->regs[AC97_POWERDOWN] & ~AC97_PD_EAPD;
  2066. else if (! (ac97->scaps & AC97_SCAP_EAPD_LED))
  2067. power = ac97->regs[AC97_POWERDOWN] | AC97_PD_EAPD;
  2068. power |= AC97_PD_PR6; /* Headphone amplifier powerdown */
  2069. power |= AC97_PD_PR0 | AC97_PD_PR1; /* ADC & DAC powerdown */
  2070. snd_ac97_write(ac97, AC97_POWERDOWN, power);
  2071. udelay(100);
  2072. power |= AC97_PD_PR2 | AC97_PD_PR3; /* Analog Mixer powerdown */
  2073. snd_ac97_write(ac97, AC97_POWERDOWN, power);
  2074. if (ac97_is_power_save_mode(ac97)) {
  2075. udelay(100);
  2076. /* AC-link powerdown, internal Clk disable */
  2077. /* FIXME: this may cause click noises on some boards */
  2078. power |= AC97_PD_PR4 | AC97_PD_PR5;
  2079. snd_ac97_write(ac97, AC97_POWERDOWN, power);
  2080. }
  2081. }
  2082. struct ac97_power_reg {
  2083. unsigned short reg;
  2084. unsigned short power_reg;
  2085. unsigned short mask;
  2086. };
  2087. enum { PWIDX_ADC, PWIDX_FRONT, PWIDX_CLFE, PWIDX_SURR, PWIDX_MIC, PWIDX_SIZE };
  2088. static struct ac97_power_reg power_regs[PWIDX_SIZE] = {
  2089. [PWIDX_ADC] = { AC97_PCM_LR_ADC_RATE, AC97_POWERDOWN, AC97_PD_PR0},
  2090. [PWIDX_FRONT] = { AC97_PCM_FRONT_DAC_RATE, AC97_POWERDOWN, AC97_PD_PR1},
  2091. [PWIDX_CLFE] = { AC97_PCM_LFE_DAC_RATE, AC97_EXTENDED_STATUS,
  2092. AC97_EA_PRI | AC97_EA_PRK},
  2093. [PWIDX_SURR] = { AC97_PCM_SURR_DAC_RATE, AC97_EXTENDED_STATUS,
  2094. AC97_EA_PRJ},
  2095. [PWIDX_MIC] = { AC97_PCM_MIC_ADC_RATE, AC97_EXTENDED_STATUS,
  2096. AC97_EA_PRL},
  2097. };
  2098. #ifdef CONFIG_SND_AC97_POWER_SAVE
  2099. /**
  2100. * snd_ac97_update_power - update the powerdown register
  2101. * @ac97: the codec instance
  2102. * @reg: the rate register, e.g. AC97_PCM_FRONT_DAC_RATE
  2103. * @powerup: non-zero when power up the part
  2104. *
  2105. * Update the AC97 powerdown register bits of the given part.
  2106. */
  2107. int snd_ac97_update_power(struct snd_ac97 *ac97, int reg, int powerup)
  2108. {
  2109. int i;
  2110. if (! ac97)
  2111. return 0;
  2112. if (reg) {
  2113. /* SPDIF requires DAC power, too */
  2114. if (reg == AC97_SPDIF)
  2115. reg = AC97_PCM_FRONT_DAC_RATE;
  2116. for (i = 0; i < PWIDX_SIZE; i++) {
  2117. if (power_regs[i].reg == reg) {
  2118. if (powerup)
  2119. ac97->power_up |= (1 << i);
  2120. else
  2121. ac97->power_up &= ~(1 << i);
  2122. break;
  2123. }
  2124. }
  2125. }
  2126. if (ac97_is_power_save_mode(ac97) && !powerup)
  2127. /* adjust power-down bits after two seconds delay
  2128. * (for avoiding loud click noises for many (OSS) apps
  2129. * that open/close frequently)
  2130. */
  2131. schedule_delayed_work(&ac97->power_work,
  2132. msecs_to_jiffies(2000));
  2133. else {
  2134. cancel_delayed_work(&ac97->power_work);
  2135. update_power_regs(ac97);
  2136. }
  2137. return 0;
  2138. }
  2139. EXPORT_SYMBOL(snd_ac97_update_power);
  2140. #endif /* CONFIG_SND_AC97_POWER_SAVE */
  2141. static void update_power_regs(struct snd_ac97 *ac97)
  2142. {
  2143. unsigned int power_up, bits;
  2144. int i;
  2145. power_up = (1 << PWIDX_FRONT) | (1 << PWIDX_ADC);
  2146. power_up |= (1 << PWIDX_MIC);
  2147. if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
  2148. power_up |= (1 << PWIDX_SURR);
  2149. if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
  2150. power_up |= (1 << PWIDX_CLFE);
  2151. #ifdef CONFIG_SND_AC97_POWER_SAVE
  2152. if (ac97_is_power_save_mode(ac97))
  2153. power_up = ac97->power_up;
  2154. #endif
  2155. if (power_up) {
  2156. if (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2) {
  2157. /* needs power-up analog mix and vref */
  2158. snd_ac97_update_bits(ac97, AC97_POWERDOWN,
  2159. AC97_PD_PR3, 0);
  2160. msleep(1);
  2161. snd_ac97_update_bits(ac97, AC97_POWERDOWN,
  2162. AC97_PD_PR2, 0);
  2163. }
  2164. }
  2165. for (i = 0; i < PWIDX_SIZE; i++) {
  2166. if (power_up & (1 << i))
  2167. bits = 0;
  2168. else
  2169. bits = power_regs[i].mask;
  2170. snd_ac97_update_bits(ac97, power_regs[i].power_reg,
  2171. power_regs[i].mask, bits);
  2172. }
  2173. if (! power_up) {
  2174. if (! (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2)) {
  2175. /* power down analog mix and vref */
  2176. snd_ac97_update_bits(ac97, AC97_POWERDOWN,
  2177. AC97_PD_PR2, AC97_PD_PR2);
  2178. snd_ac97_update_bits(ac97, AC97_POWERDOWN,
  2179. AC97_PD_PR3, AC97_PD_PR3);
  2180. }
  2181. }
  2182. }
  2183. #ifdef CONFIG_PM
  2184. /**
  2185. * snd_ac97_suspend - General suspend function for AC97 codec
  2186. * @ac97: the ac97 instance
  2187. *
  2188. * Suspends the codec, power down the chip.
  2189. */
  2190. void snd_ac97_suspend(struct snd_ac97 *ac97)
  2191. {
  2192. if (! ac97)
  2193. return;
  2194. if (ac97->build_ops->suspend)
  2195. ac97->build_ops->suspend(ac97);
  2196. #ifdef CONFIG_SND_AC97_POWER_SAVE
  2197. cancel_delayed_work(&ac97->power_work);
  2198. flush_scheduled_work();
  2199. #endif
  2200. snd_ac97_powerdown(ac97);
  2201. }
  2202. EXPORT_SYMBOL(snd_ac97_suspend);
  2203. /*
  2204. * restore ac97 status
  2205. */
  2206. static void snd_ac97_restore_status(struct snd_ac97 *ac97)
  2207. {
  2208. int i;
  2209. for (i = 2; i < 0x7c ; i += 2) {
  2210. if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
  2211. continue;
  2212. /* restore only accessible registers
  2213. * some chip (e.g. nm256) may hang up when unsupported registers
  2214. * are accessed..!
  2215. */
  2216. if (test_bit(i, ac97->reg_accessed)) {
  2217. snd_ac97_write(ac97, i, ac97->regs[i]);
  2218. snd_ac97_read(ac97, i);
  2219. }
  2220. }
  2221. }
  2222. /*
  2223. * restore IEC958 status
  2224. */
  2225. static void snd_ac97_restore_iec958(struct snd_ac97 *ac97)
  2226. {
  2227. if (ac97->ext_id & AC97_EI_SPDIF) {
  2228. if (ac97->regs[AC97_EXTENDED_STATUS] & AC97_EA_SPDIF) {
  2229. /* reset spdif status */
  2230. snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, 0);
  2231. snd_ac97_write(ac97, AC97_EXTENDED_STATUS, ac97->regs[AC97_EXTENDED_STATUS]);
  2232. if (ac97->flags & AC97_CS_SPDIF)
  2233. snd_ac97_write(ac97, AC97_CSR_SPDIF, ac97->regs[AC97_CSR_SPDIF]);
  2234. else
  2235. snd_ac97_write(ac97, AC97_SPDIF, ac97->regs[AC97_SPDIF]);
  2236. snd_ac97_update_bits(ac97, AC97_EXTENDED_STATUS, AC97_EA_SPDIF, AC97_EA_SPDIF); /* turn on again */
  2237. }
  2238. }
  2239. }
  2240. /**
  2241. * snd_ac97_resume - General resume function for AC97 codec
  2242. * @ac97: the ac97 instance
  2243. *
  2244. * Do the standard resume procedure, power up and restoring the
  2245. * old register values.
  2246. */
  2247. void snd_ac97_resume(struct snd_ac97 *ac97)
  2248. {
  2249. unsigned long end_time;
  2250. if (! ac97)
  2251. return;
  2252. if (ac97->bus->ops->reset) {
  2253. ac97->bus->ops->reset(ac97);
  2254. goto __reset_ready;
  2255. }
  2256. snd_ac97_write(ac97, AC97_POWERDOWN, 0);
  2257. if (! (ac97->flags & AC97_DEFAULT_POWER_OFF)) {
  2258. if (!(ac97->scaps & AC97_SCAP_SKIP_AUDIO))
  2259. snd_ac97_write(ac97, AC97_RESET, 0);
  2260. else if (!(ac97->scaps & AC97_SCAP_SKIP_MODEM))
  2261. snd_ac97_write(ac97, AC97_EXTENDED_MID, 0);
  2262. udelay(100);
  2263. snd_ac97_write(ac97, AC97_POWERDOWN, 0);
  2264. }
  2265. snd_ac97_write(ac97, AC97_GENERAL_PURPOSE, 0);
  2266. snd_ac97_write(ac97, AC97_POWERDOWN, ac97->regs[AC97_POWERDOWN]);
  2267. if (ac97_is_audio(ac97)) {
  2268. ac97->bus->ops->write(ac97, AC97_MASTER, 0x8101);
  2269. end_time = jiffies + msecs_to_jiffies(100);
  2270. do {
  2271. if (snd_ac97_read(ac97, AC97_MASTER) == 0x8101)
  2272. break;
  2273. schedule_timeout_uninterruptible(1);
  2274. } while (time_after_eq(end_time, jiffies));
  2275. /* FIXME: extra delay */
  2276. ac97->bus->ops->write(ac97, AC97_MASTER, 0x8000);
  2277. if (snd_ac97_read(ac97, AC97_MASTER) != 0x8000)
  2278. msleep(250);
  2279. } else {
  2280. end_time = jiffies + msecs_to_jiffies(100);
  2281. do {
  2282. unsigned short val = snd_ac97_read(ac97, AC97_EXTENDED_MID);
  2283. if (val != 0xffff && (val & 1) != 0)
  2284. break;
  2285. schedule_timeout_uninterruptible(1);
  2286. } while (time_after_eq(end_time, jiffies));
  2287. }
  2288. __reset_ready:
  2289. if (ac97->bus->ops->init)
  2290. ac97->bus->ops->init(ac97);
  2291. if (ac97->build_ops->resume)
  2292. ac97->build_ops->resume(ac97);
  2293. else {
  2294. snd_ac97_restore_status(ac97);
  2295. snd_ac97_restore_iec958(ac97);
  2296. }
  2297. }
  2298. EXPORT_SYMBOL(snd_ac97_resume);
  2299. #endif
  2300. /*
  2301. * Hardware tuning
  2302. */
  2303. static void set_ctl_name(char *dst, const char *src, const char *suffix)
  2304. {
  2305. if (suffix)
  2306. sprintf(dst, "%s %s", src, suffix);
  2307. else
  2308. strcpy(dst, src);
  2309. }
  2310. /* remove the control with the given name and optional suffix */
  2311. static int snd_ac97_remove_ctl(struct snd_ac97 *ac97, const char *name,
  2312. const char *suffix)
  2313. {
  2314. struct snd_ctl_elem_id id;
  2315. memset(&id, 0, sizeof(id));
  2316. set_ctl_name(id.name, name, suffix);
  2317. id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
  2318. return snd_ctl_remove_id(ac97->bus->card, &id);
  2319. }
  2320. static struct snd_kcontrol *ctl_find(struct snd_ac97 *ac97, const char *name, const char *suffix)
  2321. {
  2322. struct snd_ctl_elem_id sid;
  2323. memset(&sid, 0, sizeof(sid));
  2324. set_ctl_name(sid.name, name, suffix);
  2325. sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
  2326. return snd_ctl_find_id(ac97->bus->card, &sid);
  2327. }
  2328. /* rename the control with the given name and optional suffix */
  2329. static int snd_ac97_rename_ctl(struct snd_ac97 *ac97, const char *src,
  2330. const char *dst, const char *suffix)
  2331. {
  2332. struct snd_kcontrol *kctl = ctl_find(ac97, src, suffix);
  2333. if (kctl) {
  2334. set_ctl_name(kctl->id.name, dst, suffix);
  2335. return 0;
  2336. }
  2337. return -ENOENT;
  2338. }
  2339. /* rename both Volume and Switch controls - don't check the return value */
  2340. static void snd_ac97_rename_vol_ctl(struct snd_ac97 *ac97, const char *src,
  2341. const char *dst)
  2342. {
  2343. snd_ac97_rename_ctl(ac97, src, dst, "Switch");
  2344. snd_ac97_rename_ctl(ac97, src, dst, "Volume");
  2345. }
  2346. /* swap controls */
  2347. static int snd_ac97_swap_ctl(struct snd_ac97 *ac97, const char *s1,
  2348. const char *s2, const char *suffix)
  2349. {
  2350. struct snd_kcontrol *kctl1, *kctl2;
  2351. kctl1 = ctl_find(ac97, s1, suffix);
  2352. kctl2 = ctl_find(ac97, s2, suffix);
  2353. if (kctl1 && kctl2) {
  2354. set_ctl_name(kctl1->id.name, s2, suffix);
  2355. set_ctl_name(kctl2->id.name, s1, suffix);
  2356. return 0;
  2357. }
  2358. return -ENOENT;
  2359. }
  2360. #if 1
  2361. /* bind hp and master controls instead of using only hp control */
  2362. static int bind_hp_volsw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  2363. {
  2364. int err = snd_ac97_put_volsw(kcontrol, ucontrol);
  2365. if (err > 0) {
  2366. unsigned long priv_saved = kcontrol->private_value;
  2367. kcontrol->private_value = (kcontrol->private_value & ~0xff) | AC97_HEADPHONE;
  2368. snd_ac97_put_volsw(kcontrol, ucontrol);
  2369. kcontrol->private_value = priv_saved;
  2370. }
  2371. return err;
  2372. }
  2373. /* ac97 tune: bind Master and Headphone controls */
  2374. static int tune_hp_only(struct snd_ac97 *ac97)
  2375. {
  2376. struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
  2377. struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
  2378. if (! msw || ! mvol)
  2379. return -ENOENT;
  2380. msw->put = bind_hp_volsw_put;
  2381. mvol->put = bind_hp_volsw_put;
  2382. snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
  2383. snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
  2384. return 0;
  2385. }
  2386. #else
  2387. /* ac97 tune: use Headphone control as master */
  2388. static int tune_hp_only(struct snd_ac97 *ac97)
  2389. {
  2390. if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
  2391. return -ENOENT;
  2392. snd_ac97_remove_ctl(ac97, "Master Playback", "Switch");
  2393. snd_ac97_remove_ctl(ac97, "Master Playback", "Volume");
  2394. snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
  2395. return 0;
  2396. }
  2397. #endif
  2398. /* ac97 tune: swap Headphone and Master controls */
  2399. static int tune_swap_hp(struct snd_ac97 *ac97)
  2400. {
  2401. if (ctl_find(ac97, "Headphone Playback Switch", NULL) == NULL)
  2402. return -ENOENT;
  2403. snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Line-Out Playback");
  2404. snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
  2405. return 0;
  2406. }
  2407. /* ac97 tune: swap Surround and Master controls */
  2408. static int tune_swap_surround(struct snd_ac97 *ac97)
  2409. {
  2410. if (snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Switch") ||
  2411. snd_ac97_swap_ctl(ac97, "Master Playback", "Surround Playback", "Volume"))
  2412. return -ENOENT;
  2413. return 0;
  2414. }
  2415. /* ac97 tune: set up mic sharing for AD codecs */
  2416. static int tune_ad_sharing(struct snd_ac97 *ac97)
  2417. {
  2418. unsigned short scfg;
  2419. if ((ac97->id & 0xffffff00) != 0x41445300) {
  2420. snd_printk(KERN_ERR "ac97_quirk AD_SHARING is only for AD codecs\n");
  2421. return -EINVAL;
  2422. }
  2423. /* Turn on OMS bit to route microphone to back panel */
  2424. scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
  2425. snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x0200);
  2426. return 0;
  2427. }
  2428. static const struct snd_kcontrol_new snd_ac97_alc_jack_detect =
  2429. AC97_SINGLE("Jack Detect", AC97_ALC650_CLOCK, 5, 1, 0);
  2430. /* ac97 tune: set up ALC jack-select */
  2431. static int tune_alc_jack(struct snd_ac97 *ac97)
  2432. {
  2433. if ((ac97->id & 0xffffff00) != 0x414c4700) {
  2434. snd_printk(KERN_ERR "ac97_quirk ALC_JACK is only for Realtek codecs\n");
  2435. return -EINVAL;
  2436. }
  2437. snd_ac97_update_bits(ac97, 0x7a, 0x20, 0x20); /* select jack detect function */
  2438. snd_ac97_update_bits(ac97, 0x7a, 0x01, 0x01); /* Line-out auto mute */
  2439. if (ac97->id == AC97_ID_ALC658D)
  2440. snd_ac97_update_bits(ac97, 0x74, 0x0800, 0x0800);
  2441. return snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&snd_ac97_alc_jack_detect, ac97));
  2442. }
  2443. /* ac97 tune: inversed EAPD bit */
  2444. static int tune_inv_eapd(struct snd_ac97 *ac97)
  2445. {
  2446. struct snd_kcontrol *kctl = ctl_find(ac97, "External Amplifier", NULL);
  2447. if (! kctl)
  2448. return -ENOENT;
  2449. set_inv_eapd(ac97, kctl);
  2450. return 0;
  2451. }
  2452. static int master_mute_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
  2453. {
  2454. int err = snd_ac97_put_volsw(kcontrol, ucontrol);
  2455. if (err > 0) {
  2456. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  2457. int shift = (kcontrol->private_value >> 8) & 0x0f;
  2458. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  2459. unsigned short mask;
  2460. if (shift != rshift)
  2461. mask = 0x8080;
  2462. else
  2463. mask = 0x8000;
  2464. snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000,
  2465. (ac97->regs[AC97_MASTER] & mask) == mask ?
  2466. 0x8000 : 0);
  2467. }
  2468. return err;
  2469. }
  2470. /* ac97 tune: EAPD controls mute LED bound with the master mute */
  2471. static int tune_mute_led(struct snd_ac97 *ac97)
  2472. {
  2473. struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
  2474. if (! msw)
  2475. return -ENOENT;
  2476. msw->put = master_mute_sw_put;
  2477. snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
  2478. snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, 0x8000); /* mute LED on */
  2479. ac97->scaps |= AC97_SCAP_EAPD_LED;
  2480. return 0;
  2481. }
  2482. static int hp_master_mute_sw_put(struct snd_kcontrol *kcontrol,
  2483. struct snd_ctl_elem_value *ucontrol)
  2484. {
  2485. int err = bind_hp_volsw_put(kcontrol, ucontrol);
  2486. if (err > 0) {
  2487. struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
  2488. int shift = (kcontrol->private_value >> 8) & 0x0f;
  2489. int rshift = (kcontrol->private_value >> 12) & 0x0f;
  2490. unsigned short mask;
  2491. if (shift != rshift)
  2492. mask = 0x8080;
  2493. else
  2494. mask = 0x8000;
  2495. snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000,
  2496. (ac97->regs[AC97_MASTER] & mask) == mask ?
  2497. 0x8000 : 0);
  2498. }
  2499. return err;
  2500. }
  2501. static int tune_hp_mute_led(struct snd_ac97 *ac97)
  2502. {
  2503. struct snd_kcontrol *msw = ctl_find(ac97, "Master Playback Switch", NULL);
  2504. struct snd_kcontrol *mvol = ctl_find(ac97, "Master Playback Volume", NULL);
  2505. if (! msw || ! mvol)
  2506. return -ENOENT;
  2507. msw->put = hp_master_mute_sw_put;
  2508. mvol->put = bind_hp_volsw_put;
  2509. snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
  2510. snd_ac97_remove_ctl(ac97, "Headphone Playback", "Switch");
  2511. snd_ac97_remove_ctl(ac97, "Headphone Playback", "Volume");
  2512. snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, 0x8000); /* mute LED on */
  2513. return 0;
  2514. }
  2515. struct quirk_table {
  2516. const char *name;
  2517. int (*func)(struct snd_ac97 *);
  2518. };
  2519. static struct quirk_table applicable_quirks[] = {
  2520. { "none", NULL },
  2521. { "hp_only", tune_hp_only },
  2522. { "swap_hp", tune_swap_hp },
  2523. { "swap_surround", tune_swap_surround },
  2524. { "ad_sharing", tune_ad_sharing },
  2525. { "alc_jack", tune_alc_jack },
  2526. { "inv_eapd", tune_inv_eapd },
  2527. { "mute_led", tune_mute_led },
  2528. { "hp_mute_led", tune_hp_mute_led },
  2529. };
  2530. /* apply the quirk with the given type */
  2531. static int apply_quirk(struct snd_ac97 *ac97, int type)
  2532. {
  2533. if (type <= 0)
  2534. return 0;
  2535. else if (type >= ARRAY_SIZE(applicable_quirks))
  2536. return -EINVAL;
  2537. if (applicable_quirks[type].func)
  2538. return applicable_quirks[type].func(ac97);
  2539. return 0;
  2540. }
  2541. /* apply the quirk with the given name */
  2542. static int apply_quirk_str(struct snd_ac97 *ac97, const char *typestr)
  2543. {
  2544. int i;
  2545. struct quirk_table *q;
  2546. for (i = 0; i < ARRAY_SIZE(applicable_quirks); i++) {
  2547. q = &applicable_quirks[i];
  2548. if (q->name && ! strcmp(typestr, q->name))
  2549. return apply_quirk(ac97, i);
  2550. }
  2551. /* for compatibility, accept the numbers, too */
  2552. if (*typestr >= '0' && *typestr <= '9')
  2553. return apply_quirk(ac97, (int)simple_strtoul(typestr, NULL, 10));
  2554. return -EINVAL;
  2555. }
  2556. /**
  2557. * snd_ac97_tune_hardware - tune up the hardware
  2558. * @ac97: the ac97 instance
  2559. * @quirk: quirk list
  2560. * @override: explicit quirk value (overrides the list if non-NULL)
  2561. *
  2562. * Do some workaround for each pci device, such as renaming of the
  2563. * headphone (true line-out) control as "Master".
  2564. * The quirk-list must be terminated with a zero-filled entry.
  2565. *
  2566. * Returns zero if successful, or a negative error code on failure.
  2567. */
  2568. int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, const char *override)
  2569. {
  2570. int result;
  2571. /* quirk overriden? */
  2572. if (override && strcmp(override, "-1") && strcmp(override, "default")) {
  2573. result = apply_quirk_str(ac97, override);
  2574. if (result < 0)
  2575. snd_printk(KERN_ERR "applying quirk type %s failed (%d)\n", override, result);
  2576. return result;
  2577. }
  2578. if (! quirk)
  2579. return -EINVAL;
  2580. for (; quirk->subvendor; quirk++) {
  2581. if (quirk->subvendor != ac97->subsystem_vendor)
  2582. continue;
  2583. if ((! quirk->mask && quirk->subdevice == ac97->subsystem_device) ||
  2584. quirk->subdevice == (quirk->mask & ac97->subsystem_device)) {
  2585. if (quirk->codec_id && quirk->codec_id != ac97->id)
  2586. continue;
  2587. snd_printdd("ac97 quirk for %s (%04x:%04x)\n", quirk->name, ac97->subsystem_vendor, ac97->subsystem_device);
  2588. result = apply_quirk(ac97, quirk->type);
  2589. if (result < 0)
  2590. snd_printk(KERN_ERR "applying quirk type %d for %s failed (%d)\n", quirk->type, quirk->name, result);
  2591. return result;
  2592. }
  2593. }
  2594. return 0;
  2595. }
  2596. EXPORT_SYMBOL(snd_ac97_tune_hardware);
  2597. /*
  2598. * INIT part
  2599. */
  2600. static int __init alsa_ac97_init(void)
  2601. {
  2602. return 0;
  2603. }
  2604. static void __exit alsa_ac97_exit(void)
  2605. {
  2606. }
  2607. module_init(alsa_ac97_init)
  2608. module_exit(alsa_ac97_exit)