awacs.c 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * PMac AWACS lowlevel functions
  4. *
  5. * Copyright (c) by Takashi Iwai <tiwai@suse.de>
  6. * code based on dmasound.c.
  7. */
  8. #include <linux/io.h>
  9. #include <asm/nvram.h>
  10. #include <linux/init.h>
  11. #include <linux/delay.h>
  12. #include <linux/slab.h>
  13. #include <sound/core.h>
  14. #include "pmac.h"
  15. #ifdef CONFIG_ADB_CUDA
  16. #define PMAC_AMP_AVAIL
  17. #endif
  18. #ifdef PMAC_AMP_AVAIL
  19. struct awacs_amp {
  20. unsigned char amp_master;
  21. unsigned char amp_vol[2][2];
  22. unsigned char amp_tone[2];
  23. };
  24. #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA)
  25. #endif /* PMAC_AMP_AVAIL */
  26. static void snd_pmac_screamer_wait(struct snd_pmac *chip)
  27. {
  28. long timeout = 2000;
  29. while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) {
  30. mdelay(1);
  31. if (! --timeout) {
  32. snd_printd("snd_pmac_screamer_wait timeout\n");
  33. break;
  34. }
  35. }
  36. }
  37. /*
  38. * write AWACS register
  39. */
  40. static void
  41. snd_pmac_awacs_write(struct snd_pmac *chip, int val)
  42. {
  43. long timeout = 5000000;
  44. if (chip->model == PMAC_SCREAMER)
  45. snd_pmac_screamer_wait(chip);
  46. out_le32(&chip->awacs->codec_ctrl, val | (chip->subframe << 22));
  47. while (in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) {
  48. if (! --timeout) {
  49. snd_printd("snd_pmac_awacs_write timeout\n");
  50. break;
  51. }
  52. }
  53. }
  54. static void
  55. snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val)
  56. {
  57. snd_pmac_awacs_write(chip, val | (reg << 12));
  58. chip->awacs_reg[reg] = val;
  59. }
  60. static void
  61. snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val)
  62. {
  63. snd_pmac_awacs_write(chip, val | (reg << 12));
  64. }
  65. #ifdef CONFIG_PM
  66. /* Recalibrate chip */
  67. static void screamer_recalibrate(struct snd_pmac *chip)
  68. {
  69. if (chip->model != PMAC_SCREAMER)
  70. return;
  71. /* Sorry for the horrible delays... I hope to get that improved
  72. * by making the whole PM process asynchronous in a future version
  73. */
  74. snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
  75. if (chip->manufacturer == 0x1)
  76. /* delay for broken crystal part */
  77. msleep(750);
  78. snd_pmac_awacs_write_noreg(chip, 1,
  79. chip->awacs_reg[1] | MASK_RECALIBRATE |
  80. MASK_CMUTE | MASK_AMUTE);
  81. snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
  82. snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
  83. }
  84. #else
  85. #define screamer_recalibrate(chip) /* NOP */
  86. #endif
  87. /*
  88. * additional callback to set the pcm format
  89. */
  90. static void snd_pmac_awacs_set_format(struct snd_pmac *chip)
  91. {
  92. chip->awacs_reg[1] &= ~MASK_SAMPLERATE;
  93. chip->awacs_reg[1] |= chip->rate_index << 3;
  94. snd_pmac_awacs_write_reg(chip, 1, chip->awacs_reg[1]);
  95. }
  96. /*
  97. * AWACS volume callbacks
  98. */
  99. /*
  100. * volumes: 0-15 stereo
  101. */
  102. static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol,
  103. struct snd_ctl_elem_info *uinfo)
  104. {
  105. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  106. uinfo->count = 2;
  107. uinfo->value.integer.min = 0;
  108. uinfo->value.integer.max = 15;
  109. return 0;
  110. }
  111. static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol,
  112. struct snd_ctl_elem_value *ucontrol)
  113. {
  114. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  115. int reg = kcontrol->private_value & 0xff;
  116. int lshift = (kcontrol->private_value >> 8) & 0xff;
  117. int inverted = (kcontrol->private_value >> 16) & 1;
  118. unsigned long flags;
  119. int vol[2];
  120. spin_lock_irqsave(&chip->reg_lock, flags);
  121. vol[0] = (chip->awacs_reg[reg] >> lshift) & 0xf;
  122. vol[1] = chip->awacs_reg[reg] & 0xf;
  123. spin_unlock_irqrestore(&chip->reg_lock, flags);
  124. if (inverted) {
  125. vol[0] = 0x0f - vol[0];
  126. vol[1] = 0x0f - vol[1];
  127. }
  128. ucontrol->value.integer.value[0] = vol[0];
  129. ucontrol->value.integer.value[1] = vol[1];
  130. return 0;
  131. }
  132. static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol,
  133. struct snd_ctl_elem_value *ucontrol)
  134. {
  135. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  136. int reg = kcontrol->private_value & 0xff;
  137. int lshift = (kcontrol->private_value >> 8) & 0xff;
  138. int inverted = (kcontrol->private_value >> 16) & 1;
  139. int val, oldval;
  140. unsigned long flags;
  141. unsigned int vol[2];
  142. vol[0] = ucontrol->value.integer.value[0];
  143. vol[1] = ucontrol->value.integer.value[1];
  144. if (vol[0] > 0x0f || vol[1] > 0x0f)
  145. return -EINVAL;
  146. if (inverted) {
  147. vol[0] = 0x0f - vol[0];
  148. vol[1] = 0x0f - vol[1];
  149. }
  150. vol[0] &= 0x0f;
  151. vol[1] &= 0x0f;
  152. spin_lock_irqsave(&chip->reg_lock, flags);
  153. oldval = chip->awacs_reg[reg];
  154. val = oldval & ~(0xf | (0xf << lshift));
  155. val |= vol[0] << lshift;
  156. val |= vol[1];
  157. if (oldval != val)
  158. snd_pmac_awacs_write_reg(chip, reg, val);
  159. spin_unlock_irqrestore(&chip->reg_lock, flags);
  160. return oldval != reg;
  161. }
  162. #define AWACS_VOLUME(xname, xreg, xshift, xinverted) \
  163. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
  164. .info = snd_pmac_awacs_info_volume, \
  165. .get = snd_pmac_awacs_get_volume, \
  166. .put = snd_pmac_awacs_put_volume, \
  167. .private_value = (xreg) | ((xshift) << 8) | ((xinverted) << 16) }
  168. /*
  169. * mute master/ogain for AWACS: mono
  170. */
  171. static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol,
  172. struct snd_ctl_elem_value *ucontrol)
  173. {
  174. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  175. int reg = kcontrol->private_value & 0xff;
  176. int shift = (kcontrol->private_value >> 8) & 0xff;
  177. int invert = (kcontrol->private_value >> 16) & 1;
  178. int val;
  179. unsigned long flags;
  180. spin_lock_irqsave(&chip->reg_lock, flags);
  181. val = (chip->awacs_reg[reg] >> shift) & 1;
  182. spin_unlock_irqrestore(&chip->reg_lock, flags);
  183. if (invert)
  184. val = 1 - val;
  185. ucontrol->value.integer.value[0] = val;
  186. return 0;
  187. }
  188. static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol,
  189. struct snd_ctl_elem_value *ucontrol)
  190. {
  191. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  192. int reg = kcontrol->private_value & 0xff;
  193. int shift = (kcontrol->private_value >> 8) & 0xff;
  194. int invert = (kcontrol->private_value >> 16) & 1;
  195. int mask = 1 << shift;
  196. int val, changed;
  197. unsigned long flags;
  198. spin_lock_irqsave(&chip->reg_lock, flags);
  199. val = chip->awacs_reg[reg] & ~mask;
  200. if (ucontrol->value.integer.value[0] != invert)
  201. val |= mask;
  202. changed = chip->awacs_reg[reg] != val;
  203. if (changed)
  204. snd_pmac_awacs_write_reg(chip, reg, val);
  205. spin_unlock_irqrestore(&chip->reg_lock, flags);
  206. return changed;
  207. }
  208. #define AWACS_SWITCH(xname, xreg, xshift, xinvert) \
  209. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
  210. .info = snd_pmac_boolean_mono_info, \
  211. .get = snd_pmac_awacs_get_switch, \
  212. .put = snd_pmac_awacs_put_switch, \
  213. .private_value = (xreg) | ((xshift) << 8) | ((xinvert) << 16) }
  214. #ifdef PMAC_AMP_AVAIL
  215. /*
  216. * controls for perch/whisper extension cards, e.g. G3 desktop
  217. *
  218. * TDA7433 connected via i2c address 0x45 (= 0x8a),
  219. * accessed through cuda
  220. */
  221. static void awacs_set_cuda(int reg, int val)
  222. {
  223. struct adb_request req;
  224. cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a,
  225. reg, val);
  226. while (! req.complete)
  227. cuda_poll();
  228. }
  229. /*
  230. * level = 0 - 14, 7 = 0 dB
  231. */
  232. static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble)
  233. {
  234. amp->amp_tone[0] = bass;
  235. amp->amp_tone[1] = treble;
  236. if (bass > 7)
  237. bass = (14 - bass) + 8;
  238. if (treble > 7)
  239. treble = (14 - treble) + 8;
  240. awacs_set_cuda(2, (bass << 4) | treble);
  241. }
  242. /*
  243. * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
  244. */
  245. static int awacs_amp_set_vol(struct awacs_amp *amp, int index,
  246. int lvol, int rvol, int do_check)
  247. {
  248. if (do_check && amp->amp_vol[index][0] == lvol &&
  249. amp->amp_vol[index][1] == rvol)
  250. return 0;
  251. awacs_set_cuda(3 + index, lvol);
  252. awacs_set_cuda(5 + index, rvol);
  253. amp->amp_vol[index][0] = lvol;
  254. amp->amp_vol[index][1] = rvol;
  255. return 1;
  256. }
  257. /*
  258. * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
  259. */
  260. static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
  261. {
  262. amp->amp_master = vol;
  263. if (vol <= 79)
  264. vol = 32 + (79 - vol);
  265. else
  266. vol = 32 - (vol - 79);
  267. awacs_set_cuda(1, vol);
  268. }
  269. static void awacs_amp_free(struct snd_pmac *chip)
  270. {
  271. struct awacs_amp *amp = chip->mixer_data;
  272. if (!amp)
  273. return;
  274. kfree(amp);
  275. chip->mixer_data = NULL;
  276. chip->mixer_free = NULL;
  277. }
  278. /*
  279. * mixer controls
  280. */
  281. static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
  282. struct snd_ctl_elem_info *uinfo)
  283. {
  284. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  285. uinfo->count = 2;
  286. uinfo->value.integer.min = 0;
  287. uinfo->value.integer.max = 31;
  288. return 0;
  289. }
  290. static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
  291. struct snd_ctl_elem_value *ucontrol)
  292. {
  293. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  294. int index = kcontrol->private_value;
  295. struct awacs_amp *amp = chip->mixer_data;
  296. ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
  297. ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
  298. return 0;
  299. }
  300. static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
  301. struct snd_ctl_elem_value *ucontrol)
  302. {
  303. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  304. int index = kcontrol->private_value;
  305. int vol[2];
  306. struct awacs_amp *amp = chip->mixer_data;
  307. vol[0] = (31 - (ucontrol->value.integer.value[0] & 31))
  308. | (amp->amp_vol[index][0] & 32);
  309. vol[1] = (31 - (ucontrol->value.integer.value[1] & 31))
  310. | (amp->amp_vol[index][1] & 32);
  311. return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
  312. }
  313. static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
  314. struct snd_ctl_elem_value *ucontrol)
  315. {
  316. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  317. int index = kcontrol->private_value;
  318. struct awacs_amp *amp = chip->mixer_data;
  319. ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32)
  320. ? 0 : 1;
  321. ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32)
  322. ? 0 : 1;
  323. return 0;
  324. }
  325. static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
  326. struct snd_ctl_elem_value *ucontrol)
  327. {
  328. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  329. int index = kcontrol->private_value;
  330. int vol[2];
  331. struct awacs_amp *amp = chip->mixer_data;
  332. vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32)
  333. | (amp->amp_vol[index][0] & 31);
  334. vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32)
  335. | (amp->amp_vol[index][1] & 31);
  336. return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
  337. }
  338. static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
  339. struct snd_ctl_elem_info *uinfo)
  340. {
  341. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  342. uinfo->count = 1;
  343. uinfo->value.integer.min = 0;
  344. uinfo->value.integer.max = 14;
  345. return 0;
  346. }
  347. static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
  348. struct snd_ctl_elem_value *ucontrol)
  349. {
  350. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  351. int index = kcontrol->private_value;
  352. struct awacs_amp *amp = chip->mixer_data;
  353. ucontrol->value.integer.value[0] = amp->amp_tone[index];
  354. return 0;
  355. }
  356. static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
  357. struct snd_ctl_elem_value *ucontrol)
  358. {
  359. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  360. int index = kcontrol->private_value;
  361. struct awacs_amp *amp = chip->mixer_data;
  362. unsigned int val;
  363. val = ucontrol->value.integer.value[0];
  364. if (val > 14)
  365. return -EINVAL;
  366. if (val != amp->amp_tone[index]) {
  367. amp->amp_tone[index] = val;
  368. awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
  369. return 1;
  370. }
  371. return 0;
  372. }
  373. static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol,
  374. struct snd_ctl_elem_info *uinfo)
  375. {
  376. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  377. uinfo->count = 1;
  378. uinfo->value.integer.min = 0;
  379. uinfo->value.integer.max = 99;
  380. return 0;
  381. }
  382. static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
  383. struct snd_ctl_elem_value *ucontrol)
  384. {
  385. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  386. struct awacs_amp *amp = chip->mixer_data;
  387. ucontrol->value.integer.value[0] = amp->amp_master;
  388. return 0;
  389. }
  390. static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
  391. struct snd_ctl_elem_value *ucontrol)
  392. {
  393. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  394. struct awacs_amp *amp = chip->mixer_data;
  395. unsigned int val;
  396. val = ucontrol->value.integer.value[0];
  397. if (val > 99)
  398. return -EINVAL;
  399. if (val != amp->amp_master) {
  400. amp->amp_master = val;
  401. awacs_amp_set_master(amp, amp->amp_master);
  402. return 1;
  403. }
  404. return 0;
  405. }
  406. #define AMP_CH_SPK 0
  407. #define AMP_CH_HD 1
  408. static const struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] = {
  409. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  410. .name = "Speaker Playback Volume",
  411. .info = snd_pmac_awacs_info_volume_amp,
  412. .get = snd_pmac_awacs_get_volume_amp,
  413. .put = snd_pmac_awacs_put_volume_amp,
  414. .private_value = AMP_CH_SPK,
  415. },
  416. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  417. .name = "Headphone Playback Volume",
  418. .info = snd_pmac_awacs_info_volume_amp,
  419. .get = snd_pmac_awacs_get_volume_amp,
  420. .put = snd_pmac_awacs_put_volume_amp,
  421. .private_value = AMP_CH_HD,
  422. },
  423. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  424. .name = "Tone Control - Bass",
  425. .info = snd_pmac_awacs_info_tone_amp,
  426. .get = snd_pmac_awacs_get_tone_amp,
  427. .put = snd_pmac_awacs_put_tone_amp,
  428. .private_value = 0,
  429. },
  430. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  431. .name = "Tone Control - Treble",
  432. .info = snd_pmac_awacs_info_tone_amp,
  433. .get = snd_pmac_awacs_get_tone_amp,
  434. .put = snd_pmac_awacs_put_tone_amp,
  435. .private_value = 1,
  436. },
  437. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  438. .name = "Amp Master Playback Volume",
  439. .info = snd_pmac_awacs_info_master_amp,
  440. .get = snd_pmac_awacs_get_master_amp,
  441. .put = snd_pmac_awacs_put_master_amp,
  442. },
  443. };
  444. static const struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw = {
  445. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  446. .name = "Headphone Playback Switch",
  447. .info = snd_pmac_boolean_stereo_info,
  448. .get = snd_pmac_awacs_get_switch_amp,
  449. .put = snd_pmac_awacs_put_switch_amp,
  450. .private_value = AMP_CH_HD,
  451. };
  452. static const struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw = {
  453. .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  454. .name = "Speaker Playback Switch",
  455. .info = snd_pmac_boolean_stereo_info,
  456. .get = snd_pmac_awacs_get_switch_amp,
  457. .put = snd_pmac_awacs_put_switch_amp,
  458. .private_value = AMP_CH_SPK,
  459. };
  460. #endif /* PMAC_AMP_AVAIL */
  461. /*
  462. * mic boost for screamer
  463. */
  464. static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol,
  465. struct snd_ctl_elem_info *uinfo)
  466. {
  467. uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  468. uinfo->count = 1;
  469. uinfo->value.integer.min = 0;
  470. uinfo->value.integer.max = 3;
  471. return 0;
  472. }
  473. static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol,
  474. struct snd_ctl_elem_value *ucontrol)
  475. {
  476. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  477. int val = 0;
  478. unsigned long flags;
  479. spin_lock_irqsave(&chip->reg_lock, flags);
  480. if (chip->awacs_reg[6] & MASK_MIC_BOOST)
  481. val |= 2;
  482. if (chip->awacs_reg[0] & MASK_GAINLINE)
  483. val |= 1;
  484. spin_unlock_irqrestore(&chip->reg_lock, flags);
  485. ucontrol->value.integer.value[0] = val;
  486. return 0;
  487. }
  488. static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
  489. struct snd_ctl_elem_value *ucontrol)
  490. {
  491. struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
  492. int changed = 0;
  493. int val0, val6;
  494. unsigned long flags;
  495. spin_lock_irqsave(&chip->reg_lock, flags);
  496. val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
  497. val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
  498. if (ucontrol->value.integer.value[0] & 1)
  499. val0 |= MASK_GAINLINE;
  500. if (ucontrol->value.integer.value[0] & 2)
  501. val6 |= MASK_MIC_BOOST;
  502. if (val0 != chip->awacs_reg[0]) {
  503. snd_pmac_awacs_write_reg(chip, 0, val0);
  504. changed = 1;
  505. }
  506. if (val6 != chip->awacs_reg[6]) {
  507. snd_pmac_awacs_write_reg(chip, 6, val6);
  508. changed = 1;
  509. }
  510. spin_unlock_irqrestore(&chip->reg_lock, flags);
  511. return changed;
  512. }
  513. /*
  514. * lists of mixer elements
  515. */
  516. static const struct snd_kcontrol_new snd_pmac_awacs_mixers[] = {
  517. AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
  518. AWACS_VOLUME("Master Capture Volume", 0, 4, 0),
  519. /* AWACS_SWITCH("Unknown Playback Switch", 6, SHIFT_PAROUT0, 0), */
  520. };
  521. static const struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] = {
  522. AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
  523. AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
  524. AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
  525. AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_LINE, 0),
  526. };
  527. static const struct snd_kcontrol_new snd_pmac_screamer_mixers_lo[] = {
  528. AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
  529. };
  530. static const struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] = {
  531. AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
  532. AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
  533. };
  534. static const struct snd_kcontrol_new snd_pmac_screamer_mixers_g4agp[] = {
  535. AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
  536. AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
  537. AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
  538. AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
  539. };
  540. static const struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] = {
  541. AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
  542. AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
  543. AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
  544. };
  545. static const struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac5500[] = {
  546. AWACS_VOLUME("Headphone Playback Volume", 2, 6, 1),
  547. };
  548. static const struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] = {
  549. AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
  550. AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
  551. };
  552. /* FIXME: is this correct order?
  553. * screamer (powerbook G3 pismo) seems to have different bits...
  554. */
  555. static const struct snd_kcontrol_new snd_pmac_awacs_mixers2[] = {
  556. AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
  557. AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
  558. };
  559. static const struct snd_kcontrol_new snd_pmac_screamer_mixers2[] = {
  560. AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
  561. AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
  562. };
  563. static const struct snd_kcontrol_new snd_pmac_awacs_mixers2_pmac5500[] = {
  564. AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
  565. };
  566. static const struct snd_kcontrol_new snd_pmac_awacs_master_sw =
  567. AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
  568. static const struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac =
  569. AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
  570. static const struct snd_kcontrol_new snd_pmac_awacs_master_sw_pmac5500 =
  571. AWACS_SWITCH("Headphone Playback Switch", 1, SHIFT_HDMUTE, 1);
  572. static const struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] = {
  573. AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
  574. };
  575. static const struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] = {
  576. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
  577. .name = "Mic Boost Capture Volume",
  578. .info = snd_pmac_screamer_mic_boost_info,
  579. .get = snd_pmac_screamer_mic_boost_get,
  580. .put = snd_pmac_screamer_mic_boost_put,
  581. },
  582. };
  583. static const struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] =
  584. {
  585. AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
  586. };
  587. static const struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] =
  588. {
  589. AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
  590. AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
  591. };
  592. static const struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] =
  593. {
  594. AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
  595. AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
  596. };
  597. static const struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] = {
  598. AWACS_VOLUME("Speaker Playback Volume", 4, 6, 1),
  599. };
  600. static const struct snd_kcontrol_new snd_pmac_awacs_speaker_sw =
  601. AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
  602. static const struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 =
  603. AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
  604. static const struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 =
  605. AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
  606. /*
  607. * add new mixer elements to the card
  608. */
  609. static int build_mixers(struct snd_pmac *chip, int nums,
  610. const struct snd_kcontrol_new *mixers)
  611. {
  612. int i, err;
  613. for (i = 0; i < nums; i++) {
  614. err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip));
  615. if (err < 0)
  616. return err;
  617. }
  618. return 0;
  619. }
  620. /*
  621. * restore all registers
  622. */
  623. static void awacs_restore_all_regs(struct snd_pmac *chip)
  624. {
  625. snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
  626. snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
  627. snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
  628. snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
  629. if (chip->model == PMAC_SCREAMER) {
  630. snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
  631. snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
  632. snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
  633. }
  634. }
  635. #ifdef CONFIG_PM
  636. static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
  637. {
  638. snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
  639. | MASK_AMUTE | MASK_CMUTE));
  640. }
  641. static void snd_pmac_awacs_resume(struct snd_pmac *chip)
  642. {
  643. if (of_machine_is_compatible("PowerBook3,1")
  644. || of_machine_is_compatible("PowerBook3,2")) {
  645. msleep(100);
  646. snd_pmac_awacs_write_reg(chip, 1,
  647. chip->awacs_reg[1] & ~MASK_PAROUT);
  648. msleep(300);
  649. }
  650. awacs_restore_all_regs(chip);
  651. if (chip->model == PMAC_SCREAMER) {
  652. /* reset power bits in reg 6 */
  653. mdelay(5);
  654. snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
  655. }
  656. screamer_recalibrate(chip);
  657. #ifdef PMAC_AMP_AVAIL
  658. if (chip->mixer_data) {
  659. struct awacs_amp *amp = chip->mixer_data;
  660. awacs_amp_set_vol(amp, 0,
  661. amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
  662. awacs_amp_set_vol(amp, 1,
  663. amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
  664. awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
  665. awacs_amp_set_master(amp, amp->amp_master);
  666. }
  667. #endif
  668. }
  669. #endif /* CONFIG_PM */
  670. #define IS_PM7500 (of_machine_is_compatible("AAPL,7500") \
  671. || of_machine_is_compatible("AAPL,8500") \
  672. || of_machine_is_compatible("AAPL,9500"))
  673. #define IS_PM5500 (of_machine_is_compatible("AAPL,e411"))
  674. #define IS_BEIGE (of_machine_is_compatible("AAPL,Gossamer"))
  675. #define IS_IMAC1 (of_machine_is_compatible("PowerMac2,1"))
  676. #define IS_IMAC2 (of_machine_is_compatible("PowerMac2,2") \
  677. || of_machine_is_compatible("PowerMac4,1"))
  678. #define IS_G4AGP (of_machine_is_compatible("PowerMac3,1"))
  679. #define IS_LOMBARD (of_machine_is_compatible("PowerBook1,1"))
  680. static int imac1, imac2;
  681. #ifdef PMAC_SUPPORT_AUTOMUTE
  682. /*
  683. * auto-mute stuffs
  684. */
  685. static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
  686. {
  687. return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
  688. }
  689. #ifdef PMAC_AMP_AVAIL
  690. static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
  691. {
  692. int vol[2];
  693. vol[0] = amp->amp_vol[index][0] & 31;
  694. vol[1] = amp->amp_vol[index][1] & 31;
  695. if (mute) {
  696. vol[0] |= 32;
  697. vol[1] |= 32;
  698. }
  699. return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
  700. }
  701. #endif
  702. static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
  703. {
  704. if (chip->auto_mute) {
  705. #ifdef PMAC_AMP_AVAIL
  706. if (chip->mixer_data) {
  707. struct awacs_amp *amp = chip->mixer_data;
  708. int changed;
  709. if (snd_pmac_awacs_detect_headphone(chip)) {
  710. changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
  711. changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
  712. } else {
  713. changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
  714. changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
  715. }
  716. if (do_notify && ! changed)
  717. return;
  718. } else
  719. #endif
  720. {
  721. int reg = chip->awacs_reg[1]
  722. | (MASK_HDMUTE | MASK_SPKMUTE);
  723. if (imac1) {
  724. reg &= ~MASK_SPKMUTE;
  725. reg |= MASK_PAROUT1;
  726. } else if (imac2) {
  727. reg &= ~MASK_SPKMUTE;
  728. reg &= ~MASK_PAROUT1;
  729. }
  730. if (snd_pmac_awacs_detect_headphone(chip))
  731. reg &= ~MASK_HDMUTE;
  732. else if (imac1)
  733. reg &= ~MASK_PAROUT1;
  734. else if (imac2)
  735. reg |= MASK_PAROUT1;
  736. else
  737. reg &= ~MASK_SPKMUTE;
  738. if (do_notify && reg == chip->awacs_reg[1])
  739. return;
  740. snd_pmac_awacs_write_reg(chip, 1, reg);
  741. }
  742. if (do_notify) {
  743. snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
  744. &chip->master_sw_ctl->id);
  745. snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
  746. &chip->speaker_sw_ctl->id);
  747. snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
  748. &chip->hp_detect_ctl->id);
  749. }
  750. }
  751. }
  752. #endif /* PMAC_SUPPORT_AUTOMUTE */
  753. /*
  754. * initialize chip
  755. */
  756. int
  757. snd_pmac_awacs_init(struct snd_pmac *chip)
  758. {
  759. int pm7500 = IS_PM7500;
  760. int pm5500 = IS_PM5500;
  761. int beige = IS_BEIGE;
  762. int g4agp = IS_G4AGP;
  763. int lombard = IS_LOMBARD;
  764. int imac;
  765. int err, vol;
  766. struct snd_kcontrol *vmaster_sw, *vmaster_vol;
  767. struct snd_kcontrol *master_vol, *speaker_vol;
  768. imac1 = IS_IMAC1;
  769. imac2 = IS_IMAC2;
  770. imac = imac1 || imac2;
  771. /* looks like MASK_GAINLINE triggers something, so we set here
  772. * as start-up
  773. */
  774. chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
  775. chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
  776. /* FIXME: Only machines with external SRS module need MASK_PAROUT */
  777. if (chip->has_iic || chip->device_id == 0x5 ||
  778. /* chip->_device_id == 0x8 || */
  779. chip->device_id == 0xb)
  780. chip->awacs_reg[1] |= MASK_PAROUT;
  781. /* get default volume from nvram */
  782. // vol = (~nvram_read_byte(0x1308) & 7) << 1;
  783. // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
  784. vol = 0x0f; /* no, on alsa, muted as default */
  785. vol = vol + (vol << 6);
  786. chip->awacs_reg[2] = vol;
  787. chip->awacs_reg[4] = vol;
  788. if (chip->model == PMAC_SCREAMER) {
  789. /* FIXME: screamer has loopthru vol control */
  790. chip->awacs_reg[5] = vol;
  791. /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
  792. chip->awacs_reg[6] = MASK_MIC_BOOST;
  793. chip->awacs_reg[7] = 0;
  794. }
  795. awacs_restore_all_regs(chip);
  796. chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
  797. screamer_recalibrate(chip);
  798. chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
  799. #ifdef PMAC_AMP_AVAIL
  800. if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
  801. struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
  802. if (! amp)
  803. return -ENOMEM;
  804. chip->mixer_data = amp;
  805. chip->mixer_free = awacs_amp_free;
  806. /* mute and zero vol */
  807. awacs_amp_set_vol(amp, 0, 63, 63, 0);
  808. awacs_amp_set_vol(amp, 1, 63, 63, 0);
  809. awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
  810. awacs_amp_set_master(amp, 79); /* 0 dB */
  811. }
  812. #endif /* PMAC_AMP_AVAIL */
  813. if (chip->hp_stat_mask == 0) {
  814. /* set headphone-jack detection bit */
  815. switch (chip->model) {
  816. case PMAC_AWACS:
  817. chip->hp_stat_mask = pm7500 || pm5500 ? MASK_HDPCONN
  818. : MASK_LOCONN;
  819. break;
  820. case PMAC_SCREAMER:
  821. switch (chip->device_id) {
  822. case 0x08:
  823. case 0x0B:
  824. chip->hp_stat_mask = imac
  825. ? MASK_LOCONN_IMAC |
  826. MASK_HDPLCONN_IMAC |
  827. MASK_HDPRCONN_IMAC
  828. : MASK_HDPCONN;
  829. break;
  830. case 0x00:
  831. case 0x05:
  832. chip->hp_stat_mask = MASK_LOCONN;
  833. break;
  834. default:
  835. chip->hp_stat_mask = MASK_HDPCONN;
  836. break;
  837. }
  838. break;
  839. default:
  840. snd_BUG();
  841. break;
  842. }
  843. }
  844. /*
  845. * build mixers
  846. */
  847. strcpy(chip->card->mixername, "PowerMac AWACS");
  848. err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
  849. snd_pmac_awacs_mixers);
  850. if (err < 0)
  851. return err;
  852. if (beige || g4agp)
  853. ;
  854. else if (chip->model == PMAC_SCREAMER || pm5500)
  855. err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
  856. snd_pmac_screamer_mixers2);
  857. else if (!pm7500)
  858. err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
  859. snd_pmac_awacs_mixers2);
  860. if (err < 0)
  861. return err;
  862. if (pm5500) {
  863. err = build_mixers(chip,
  864. ARRAY_SIZE(snd_pmac_awacs_mixers2_pmac5500),
  865. snd_pmac_awacs_mixers2_pmac5500);
  866. if (err < 0)
  867. return err;
  868. }
  869. master_vol = NULL;
  870. if (pm7500)
  871. err = build_mixers(chip,
  872. ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
  873. snd_pmac_awacs_mixers_pmac7500);
  874. else if (pm5500)
  875. err = snd_ctl_add(chip->card,
  876. (master_vol = snd_ctl_new1(snd_pmac_awacs_mixers_pmac5500,
  877. chip)));
  878. else if (beige)
  879. err = build_mixers(chip,
  880. ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
  881. snd_pmac_screamer_mixers_beige);
  882. else if (imac || lombard) {
  883. err = snd_ctl_add(chip->card,
  884. (master_vol = snd_ctl_new1(snd_pmac_screamer_mixers_lo,
  885. chip)));
  886. if (err < 0)
  887. return err;
  888. err = build_mixers(chip,
  889. ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
  890. snd_pmac_screamer_mixers_imac);
  891. } else if (g4agp)
  892. err = build_mixers(chip,
  893. ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
  894. snd_pmac_screamer_mixers_g4agp);
  895. else
  896. err = build_mixers(chip,
  897. ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
  898. snd_pmac_awacs_mixers_pmac);
  899. if (err < 0)
  900. return err;
  901. chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp || lombard)
  902. ? &snd_pmac_awacs_master_sw_imac
  903. : pm5500
  904. ? &snd_pmac_awacs_master_sw_pmac5500
  905. : &snd_pmac_awacs_master_sw, chip);
  906. err = snd_ctl_add(chip->card, chip->master_sw_ctl);
  907. if (err < 0)
  908. return err;
  909. #ifdef PMAC_AMP_AVAIL
  910. if (chip->mixer_data) {
  911. /* use amplifier. the signal is connected from route A
  912. * to the amp. the amp has its headphone and speaker
  913. * volumes and mute switches, so we use them instead of
  914. * screamer registers.
  915. * in this case, it seems the route C is not used.
  916. */
  917. err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
  918. snd_pmac_awacs_amp_vol);
  919. if (err < 0)
  920. return err;
  921. /* overwrite */
  922. chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw,
  923. chip);
  924. err = snd_ctl_add(chip->card, chip->master_sw_ctl);
  925. if (err < 0)
  926. return err;
  927. chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw,
  928. chip);
  929. err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
  930. if (err < 0)
  931. return err;
  932. } else
  933. #endif /* PMAC_AMP_AVAIL */
  934. {
  935. /* route A = headphone, route C = speaker */
  936. err = snd_ctl_add(chip->card,
  937. (speaker_vol = snd_ctl_new1(snd_pmac_awacs_speaker_vol,
  938. chip)));
  939. if (err < 0)
  940. return err;
  941. chip->speaker_sw_ctl = snd_ctl_new1(imac1
  942. ? &snd_pmac_awacs_speaker_sw_imac1
  943. : imac2
  944. ? &snd_pmac_awacs_speaker_sw_imac2
  945. : &snd_pmac_awacs_speaker_sw, chip);
  946. err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
  947. if (err < 0)
  948. return err;
  949. }
  950. if (pm5500 || imac || lombard) {
  951. vmaster_sw = snd_ctl_make_virtual_master(
  952. "Master Playback Switch", (unsigned int *) NULL);
  953. err = snd_ctl_add_follower_uncached(vmaster_sw,
  954. chip->master_sw_ctl);
  955. if (err < 0)
  956. return err;
  957. err = snd_ctl_add_follower_uncached(vmaster_sw,
  958. chip->speaker_sw_ctl);
  959. if (err < 0)
  960. return err;
  961. err = snd_ctl_add(chip->card, vmaster_sw);
  962. if (err < 0)
  963. return err;
  964. vmaster_vol = snd_ctl_make_virtual_master(
  965. "Master Playback Volume", (unsigned int *) NULL);
  966. err = snd_ctl_add_follower(vmaster_vol, master_vol);
  967. if (err < 0)
  968. return err;
  969. err = snd_ctl_add_follower(vmaster_vol, speaker_vol);
  970. if (err < 0)
  971. return err;
  972. err = snd_ctl_add(chip->card, vmaster_vol);
  973. if (err < 0)
  974. return err;
  975. }
  976. if (beige || g4agp)
  977. err = build_mixers(chip,
  978. ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
  979. snd_pmac_screamer_mic_boost_beige);
  980. else if (imac)
  981. err = build_mixers(chip,
  982. ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
  983. snd_pmac_screamer_mic_boost_imac);
  984. else if (chip->model == PMAC_SCREAMER)
  985. err = build_mixers(chip,
  986. ARRAY_SIZE(snd_pmac_screamer_mic_boost),
  987. snd_pmac_screamer_mic_boost);
  988. else if (pm7500)
  989. err = build_mixers(chip,
  990. ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
  991. snd_pmac_awacs_mic_boost_pmac7500);
  992. else
  993. err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
  994. snd_pmac_awacs_mic_boost);
  995. if (err < 0)
  996. return err;
  997. /*
  998. * set lowlevel callbacks
  999. */
  1000. chip->set_format = snd_pmac_awacs_set_format;
  1001. #ifdef CONFIG_PM
  1002. chip->suspend = snd_pmac_awacs_suspend;
  1003. chip->resume = snd_pmac_awacs_resume;
  1004. #endif
  1005. #ifdef PMAC_SUPPORT_AUTOMUTE
  1006. err = snd_pmac_add_automute(chip);
  1007. if (err < 0)
  1008. return err;
  1009. chip->detect_headphone = snd_pmac_awacs_detect_headphone;
  1010. chip->update_automute = snd_pmac_awacs_update_automute;
  1011. snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
  1012. #endif
  1013. if (chip->model == PMAC_SCREAMER) {
  1014. snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
  1015. snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
  1016. }
  1017. return 0;
  1018. }