ac97_codec.c 93 KB

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