sound/ppc/awacs.c

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