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