linux/sound/ppc/awacs.c
<<
>>
Prefs
   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
  37struct 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
  48static 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 */
  63static void
  64snd_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
  79static void
  80snd_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
  86static void
  87snd_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 */
  94static 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 */
 121static 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 */
 135static 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
 145static 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
 168static 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 */
 211static 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
 230static 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 */
 267static 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 */
 279static 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 */
 293static 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 */
 309static 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
 319static 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 */
 333static 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
 343static 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
 355static 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
 370static 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
 384static 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
 399static 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
 409static 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
 420static 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
 439static 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
 449static 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
 459static 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
 480static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = {
 481        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 482          .name = "PC 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
 517static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = {
 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
 526static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = {
 527        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 528        .name = "PC 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 */
 541static 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
 551static 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
 568static 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 */
 598static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = {
 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
 604static struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] __initdata = {
 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
 611static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __initdata = {
 612        AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
 613        AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
 614        AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
 615};
 616
 617static struct snd_kcontrol_new snd_pmac_screamer_mixers_g4agp[] __initdata = {
 618        AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
 619        AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
 620        AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
 621        AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
 622};
 623
 624static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] __initdata = {
 625        AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
 626        AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
 627        AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
 628};
 629
 630static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] __initdata = {
 631        AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
 632        AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
 633};
 634
 635/* FIXME: is this correct order?
 636 * screamer (powerbook G3 pismo) seems to have different bits...
 637 */
 638static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = {
 639        AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
 640        AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
 641};
 642
 643static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = {
 644        AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
 645        AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
 646};
 647
 648static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
 649AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
 650
 651static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __initdata =
 652AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
 653
 654static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
 655        AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
 656};
 657
 658static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = {
 659        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 660          .name = "Mic Boost Capture Volume",
 661          .info = snd_pmac_screamer_mic_boost_info,
 662          .get = snd_pmac_screamer_mic_boost_get,
 663          .put = snd_pmac_screamer_mic_boost_put,
 664        },
 665};
 666
 667static struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] __initdata =
 668{
 669        AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
 670};
 671
 672static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] __initdata =
 673{
 674        AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
 675        AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
 676};
 677
 678static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] __initdata =
 679{
 680        AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
 681        AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
 682};
 683
 684static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = {
 685        AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
 686};
 687
 688static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata =
 689AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
 690
 691static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 __initdata =
 692AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
 693
 694static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 __initdata =
 695AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
 696
 697
 698/*
 699 * add new mixer elements to the card
 700 */
 701static int build_mixers(struct snd_pmac *chip, int nums,
 702                        struct snd_kcontrol_new *mixers)
 703{
 704        int i, err;
 705
 706        for (i = 0; i < nums; i++) {
 707                err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip));
 708                if (err < 0)
 709                        return err;
 710        }
 711        return 0;
 712}
 713
 714
 715/*
 716 * restore all registers
 717 */
 718static void awacs_restore_all_regs(struct snd_pmac *chip)
 719{
 720        snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
 721        snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
 722        snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
 723        snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
 724        if (chip->model == PMAC_SCREAMER) {
 725                snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
 726                snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
 727                snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
 728        }
 729}
 730
 731#ifdef CONFIG_PM
 732static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
 733{
 734        snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
 735                                             | MASK_AMUTE | MASK_CMUTE));
 736}
 737
 738static void snd_pmac_awacs_resume(struct snd_pmac *chip)
 739{
 740        if (machine_is_compatible("PowerBook3,1")
 741            || machine_is_compatible("PowerBook3,2")) {
 742                msleep(100);
 743                snd_pmac_awacs_write_reg(chip, 1,
 744                        chip->awacs_reg[1] & ~MASK_PAROUT);
 745                msleep(300);
 746        }
 747
 748        awacs_restore_all_regs(chip);
 749        if (chip->model == PMAC_SCREAMER) {
 750                /* reset power bits in reg 6 */
 751                mdelay(5);
 752                snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
 753        }
 754        screamer_recalibrate(chip);
 755#ifdef PMAC_AMP_AVAIL
 756        if (chip->mixer_data) {
 757                struct awacs_amp *amp = chip->mixer_data;
 758                awacs_amp_set_vol(amp, 0,
 759                                  amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
 760                awacs_amp_set_vol(amp, 1,
 761                                  amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
 762                awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
 763                awacs_amp_set_master(amp, amp->amp_master);
 764        }
 765#endif
 766}
 767#endif /* CONFIG_PM */
 768
 769#define IS_PM7500 (machine_is_compatible("AAPL,7500"))
 770#define IS_BEIGE (machine_is_compatible("AAPL,Gossamer"))
 771#define IS_IMAC1 (machine_is_compatible("PowerMac2,1"))
 772#define IS_IMAC2 (machine_is_compatible("PowerMac2,2") \
 773                || machine_is_compatible("PowerMac4,1"))
 774#define IS_G4AGP (machine_is_compatible("PowerMac3,1"))
 775
 776static int imac1, imac2;
 777
 778#ifdef PMAC_SUPPORT_AUTOMUTE
 779/*
 780 * auto-mute stuffs
 781 */
 782static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
 783{
 784        return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
 785}
 786
 787#ifdef PMAC_AMP_AVAIL
 788static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
 789{
 790        int vol[2];
 791        vol[0] = amp->amp_vol[index][0] & 31;
 792        vol[1] = amp->amp_vol[index][1] & 31;
 793        if (mute) {
 794                vol[0] |= 32;
 795                vol[1] |= 32;
 796        }
 797        return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
 798}
 799#endif
 800
 801static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
 802{
 803        if (chip->auto_mute) {
 804#ifdef PMAC_AMP_AVAIL
 805                if (chip->mixer_data) {
 806                        struct awacs_amp *amp = chip->mixer_data;
 807                        int changed;
 808                        if (snd_pmac_awacs_detect_headphone(chip)) {
 809                                changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
 810                                changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
 811                        } else {
 812                                changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
 813                                changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
 814                        }
 815                        if (do_notify && ! changed)
 816                                return;
 817                } else
 818#endif
 819                {
 820                        int reg = chip->awacs_reg[1]
 821                                | (MASK_HDMUTE | MASK_SPKMUTE);
 822                        if (imac1) {
 823                                reg &= ~MASK_SPKMUTE;
 824                                reg |= MASK_PAROUT1;
 825                        } else if (imac2) {
 826                                reg &= ~MASK_SPKMUTE;
 827                                reg &= ~MASK_PAROUT1;
 828                        }
 829                        if (snd_pmac_awacs_detect_headphone(chip))
 830                                reg &= ~MASK_HDMUTE;
 831                        else if (imac1)
 832                                reg &= ~MASK_PAROUT1;
 833                        else if (imac2)
 834                                reg |= MASK_PAROUT1;
 835                        else
 836                                reg &= ~MASK_SPKMUTE;
 837                        if (do_notify && reg == chip->awacs_reg[1])
 838                                return;
 839                        snd_pmac_awacs_write_reg(chip, 1, reg);
 840                }
 841                if (do_notify) {
 842                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 843                                       &chip->master_sw_ctl->id);
 844                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 845                                       &chip->speaker_sw_ctl->id);
 846                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 847                                       &chip->hp_detect_ctl->id);
 848                }
 849        }
 850}
 851#endif /* PMAC_SUPPORT_AUTOMUTE */
 852
 853
 854/*
 855 * initialize chip
 856 */
 857int __init
 858snd_pmac_awacs_init(struct snd_pmac *chip)
 859{
 860        int pm7500 = IS_PM7500;
 861        int beige = IS_BEIGE;
 862        int g4agp = IS_G4AGP;
 863        int imac;
 864        int err, vol;
 865
 866        imac1 = IS_IMAC1;
 867        imac2 = IS_IMAC2;
 868        imac = imac1 || imac2;
 869        /* looks like MASK_GAINLINE triggers something, so we set here
 870         * as start-up
 871         */
 872        chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
 873        chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
 874        /* FIXME: Only machines with external SRS module need MASK_PAROUT */
 875        if (chip->has_iic || chip->device_id == 0x5 ||
 876            /* chip->_device_id == 0x8 || */
 877            chip->device_id == 0xb)
 878                chip->awacs_reg[1] |= MASK_PAROUT;
 879        /* get default volume from nvram */
 880        // vol = (~nvram_read_byte(0x1308) & 7) << 1;
 881        // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
 882        vol = 0x0f; /* no, on alsa, muted as default */
 883        vol = vol + (vol << 6);
 884        chip->awacs_reg[2] = vol;
 885        chip->awacs_reg[4] = vol;
 886        if (chip->model == PMAC_SCREAMER) {
 887                /* FIXME: screamer has loopthru vol control */
 888                chip->awacs_reg[5] = vol;
 889                /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
 890                chip->awacs_reg[6] = MASK_MIC_BOOST;
 891                chip->awacs_reg[7] = 0;
 892        }
 893
 894        awacs_restore_all_regs(chip);
 895        chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
 896        screamer_recalibrate(chip);
 897
 898        chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
 899#ifdef PMAC_AMP_AVAIL
 900        if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
 901                struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
 902                if (! amp)
 903                        return -ENOMEM;
 904                chip->mixer_data = amp;
 905                chip->mixer_free = awacs_amp_free;
 906                /* mute and zero vol */
 907                awacs_amp_set_vol(amp, 0, 63, 63, 0);
 908                awacs_amp_set_vol(amp, 1, 63, 63, 0);
 909                awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
 910                awacs_amp_set_master(amp, 79); /* 0 dB */
 911        }
 912#endif /* PMAC_AMP_AVAIL */
 913
 914        if (chip->hp_stat_mask == 0) {
 915                /* set headphone-jack detection bit */
 916                switch (chip->model) {
 917                case PMAC_AWACS:
 918                        chip->hp_stat_mask = pm7500 ? MASK_HDPCONN
 919                                : MASK_LOCONN;
 920                        break;
 921                case PMAC_SCREAMER:
 922                        switch (chip->device_id) {
 923                        case 0x08:
 924                        case 0x0B:
 925                                chip->hp_stat_mask = imac
 926                                        ? MASK_LOCONN_IMAC |
 927                                        MASK_HDPLCONN_IMAC |
 928                                        MASK_HDPRCONN_IMAC
 929                                        : MASK_HDPCONN;
 930                                break;
 931                        case 0x00:
 932                        case 0x05:
 933                                chip->hp_stat_mask = MASK_LOCONN;
 934                                break;
 935                        default:
 936                                chip->hp_stat_mask = MASK_HDPCONN;
 937                                break;
 938                        }
 939                        break;
 940                default:
 941                        snd_BUG();
 942                        break;
 943                }
 944        }
 945
 946        /*
 947         * build mixers
 948         */
 949        strcpy(chip->card->mixername, "PowerMac AWACS");
 950
 951        err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
 952                                snd_pmac_awacs_mixers);
 953        if (err < 0)
 954                return err;
 955        if (beige || g4agp)
 956                ;
 957        else if (chip->model == PMAC_SCREAMER)
 958                err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
 959                                   snd_pmac_screamer_mixers2);
 960        else if (!pm7500)
 961                err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
 962                                   snd_pmac_awacs_mixers2);
 963        if (err < 0)
 964                return err;
 965        if (pm7500)
 966                err = build_mixers(chip,
 967                                   ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
 968                                   snd_pmac_awacs_mixers_pmac7500);
 969        else if (beige)
 970                err = build_mixers(chip,
 971                                   ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
 972                                   snd_pmac_screamer_mixers_beige);
 973        else if (imac)
 974                err = build_mixers(chip,
 975                                   ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
 976                                   snd_pmac_screamer_mixers_imac);
 977        else if (g4agp)
 978                err = build_mixers(chip,
 979                                   ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
 980                                   snd_pmac_screamer_mixers_g4agp);
 981        else
 982                err = build_mixers(chip,
 983                                   ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
 984                                   snd_pmac_awacs_mixers_pmac);
 985        if (err < 0)
 986                return err;
 987        chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp)
 988                        ? &snd_pmac_awacs_master_sw_imac
 989                        : &snd_pmac_awacs_master_sw, chip);
 990        err = snd_ctl_add(chip->card, chip->master_sw_ctl);
 991        if (err < 0)
 992                return err;
 993#ifdef PMAC_AMP_AVAIL
 994        if (chip->mixer_data) {
 995                /* use amplifier.  the signal is connected from route A
 996                 * to the amp.  the amp has its headphone and speaker
 997                 * volumes and mute switches, so we use them instead of
 998                 * screamer registers.
 999                 * in this case, it seems the route C is not used.
1000                 */
1001                err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
1002                                        snd_pmac_awacs_amp_vol);
1003                if (err < 0)
1004                        return err;
1005                /* overwrite */
1006                chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw,
1007                                                        chip);
1008                err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1009                if (err < 0)
1010                        return err;
1011                chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw,
1012                                                        chip);
1013                err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1014                if (err < 0)
1015                        return err;
1016        } else
1017#endif /* PMAC_AMP_AVAIL */
1018        {
1019                /* route A = headphone, route C = speaker */
1020                err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
1021                                        snd_pmac_awacs_speaker_vol);
1022                if (err < 0)
1023                        return err;
1024                chip->speaker_sw_ctl = snd_ctl_new1(imac1
1025                                ? &snd_pmac_awacs_speaker_sw_imac1
1026                                : imac2
1027                                ? &snd_pmac_awacs_speaker_sw_imac2
1028                                : &snd_pmac_awacs_speaker_sw, chip);
1029                err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1030                if (err < 0)
1031                        return err;
1032        }
1033
1034        if (beige || g4agp)
1035                err = build_mixers(chip,
1036                                ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
1037                                snd_pmac_screamer_mic_boost_beige);
1038        else if (imac)
1039                err = build_mixers(chip,
1040                                ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
1041                                snd_pmac_screamer_mic_boost_imac);
1042        else if (chip->model == PMAC_SCREAMER)
1043                err = build_mixers(chip,
1044                                ARRAY_SIZE(snd_pmac_screamer_mic_boost),
1045                                snd_pmac_screamer_mic_boost);
1046        else if (pm7500)
1047                err = build_mixers(chip,
1048                                ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
1049                                snd_pmac_awacs_mic_boost_pmac7500);
1050        else
1051                err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
1052                                snd_pmac_awacs_mic_boost);
1053        if (err < 0)
1054                return err;
1055
1056        /*
1057         * set lowlevel callbacks
1058         */
1059        chip->set_format = snd_pmac_awacs_set_format;
1060#ifdef CONFIG_PM
1061        chip->suspend = snd_pmac_awacs_suspend;
1062        chip->resume = snd_pmac_awacs_resume;
1063#endif
1064#ifdef PMAC_SUPPORT_AUTOMUTE
1065        err = snd_pmac_add_automute(chip);
1066        if (err < 0)
1067                return err;
1068        chip->detect_headphone = snd_pmac_awacs_detect_headphone;
1069        chip->update_automute = snd_pmac_awacs_update_automute;
1070        snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
1071#endif
1072        if (chip->model == PMAC_SCREAMER) {
1073                snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
1074                snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
1075        }
1076
1077        return 0;
1078}
1079