git.oblomov.eu Git - linux-2.6/blob - sound/ppc/burgundy.c

   1 /*
   2  * PMac Burgundy 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 #include <asm/io.h>
  23 #include <linux/init.h>
  24 #include <linux/slab.h>
  25 #include <linux/delay.h>
  26 #include <sound/core.h>
  27 #include "pmac.h"
  28 #include "burgundy.h"
  29
  30
  31 /* Waits for busy flag to clear */
  32 static inline void
  33 snd_pmac_burgundy_busy_wait(struct snd_pmac *chip)
  34 {
  35         int timeout = 50;
  36         while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--)
  37                 udelay(1);
  38         if (! timeout)
  39                 printk(KERN_DEBUG "burgundy_busy_wait: timeout\n");
  40 }
  41
  42 static inline void
  43 snd_pmac_burgundy_extend_wait(struct snd_pmac *chip)
  44 {
  45         int timeout;
  46         timeout = 50;
  47         while (!(in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
  48                 udelay(1);
  49         if (! timeout)
  50                 printk(KERN_DEBUG "burgundy_extend_wait: timeout #1\n");
  51         timeout = 50;
  52         while ((in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
  53                 udelay(1);
  54         if (! timeout)
  55                 printk(KERN_DEBUG "burgundy_extend_wait: timeout #2\n");
  56 }
  57
  58 static void
  59 snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val)
  60 {
  61         out_le32(&chip->awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff));
  62         snd_pmac_burgundy_busy_wait(chip);
  63         out_le32(&chip->awacs->codec_ctrl, addr + 0x200d00 +((val>>8) & 0xff));
  64         snd_pmac_burgundy_busy_wait(chip);
  65         out_le32(&chip->awacs->codec_ctrl, addr + 0x200e00 +((val>>16) & 0xff));
  66         snd_pmac_burgundy_busy_wait(chip);
  67         out_le32(&chip->awacs->codec_ctrl, addr + 0x200f00 +((val>>24) & 0xff));
  68         snd_pmac_burgundy_busy_wait(chip);
  69 }
  70
  71 static unsigned
  72 snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr)
  73 {
  74         unsigned val = 0;
  75         unsigned long flags;
  76
  77         spin_lock_irqsave(&chip->reg_lock, flags);
  78
  79         out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
  80         snd_pmac_burgundy_busy_wait(chip);
  81         snd_pmac_burgundy_extend_wait(chip);
  82         val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;
  83
  84         out_le32(&chip->awacs->codec_ctrl, addr + 0x100100);
  85         snd_pmac_burgundy_busy_wait(chip);
  86         snd_pmac_burgundy_extend_wait(chip);
  87         val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<8;
  88
  89         out_le32(&chip->awacs->codec_ctrl, addr + 0x100200);
  90         snd_pmac_burgundy_busy_wait(chip);
  91         snd_pmac_burgundy_extend_wait(chip);
  92         val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<16;
  93
  94         out_le32(&chip->awacs->codec_ctrl, addr + 0x100300);
  95         snd_pmac_burgundy_busy_wait(chip);
  96         snd_pmac_burgundy_extend_wait(chip);
  97         val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<24;
  98
  99         spin_unlock_irqrestore(&chip->reg_lock, flags);
 100
 101         return val;
 102 }
 103
 104 static void
 105 snd_pmac_burgundy_wcb(struct snd_pmac *chip, unsigned int addr,
 106                       unsigned int val)
 107 {
 108         out_le32(&chip->awacs->codec_ctrl, addr + 0x300000 + (val & 0xff));
 109         snd_pmac_burgundy_busy_wait(chip);
 110 }
 111
 112 static unsigned
 113 snd_pmac_burgundy_rcb(struct snd_pmac *chip, unsigned int addr)
 114 {
 115         unsigned val = 0;
 116         unsigned long flags;
 117
 118         spin_lock_irqsave(&chip->reg_lock, flags);
 119
 120         out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
 121         snd_pmac_burgundy_busy_wait(chip);
 122         snd_pmac_burgundy_extend_wait(chip);
 123         val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;
 124
 125         spin_unlock_irqrestore(&chip->reg_lock, flags);
 126
 127         return val;
 128 }
 129
 130 #define BASE2ADDR(base) ((base) << 12)
 131 #define ADDR2BASE(addr) ((addr) >> 12)
 132
 133 /*
 134  * Burgundy volume: 0 - 100, stereo, word reg
 135  */
 136 static void
 137 snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address,
 138                                long *volume, int shift)
 139 {
 140         int hardvolume, lvolume, rvolume;
 141
 142         if (volume[0] < 0 || volume[0] > 100 ||
 143             volume[1] < 0 || volume[1] > 100)
 144                 return; /* -EINVAL */
 145         lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;
 146         rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;
 147
 148         hardvolume = lvolume + (rvolume << shift);
 149         if (shift == 8)
 150                 hardvolume |= hardvolume << 16;
 151
 152         snd_pmac_burgundy_wcw(chip, address, hardvolume);
 153 }
 154
 155 static void
 156 snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address,
 157                               long *volume, int shift)
 158 {
 159         int wvolume;
 160
 161         wvolume = snd_pmac_burgundy_rcw(chip, address);
 162
 163         volume[0] = wvolume & 0xff;
 164         if (volume[0] >= BURGUNDY_VOLUME_OFFSET)
 165                 volume[0] -= BURGUNDY_VOLUME_OFFSET;
 166         else
 167                 volume[0] = 0;
 168         volume[1] = (wvolume >> shift) & 0xff;
 169         if (volume[1] >= BURGUNDY_VOLUME_OFFSET)
 170                 volume[1] -= BURGUNDY_VOLUME_OFFSET;
 171         else
 172                 volume[1] = 0;
 173 }
 174
 175 static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol,
 176                                          struct snd_ctl_elem_info *uinfo)
 177 {
 178         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 179         uinfo->count = 2;
 180         uinfo->value.integer.min = 0;
 181         uinfo->value.integer.max = 100;
 182         return 0;
 183 }
 184
 185 static int snd_pmac_burgundy_get_volume(struct snd_kcontrol *kcontrol,
 186                                         struct snd_ctl_elem_value *ucontrol)
 187 {
 188         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 189         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
 190         int shift = (kcontrol->private_value >> 8) & 0xff;
 191         snd_pmac_burgundy_read_volume(chip, addr,
 192                                       ucontrol->value.integer.value, shift);
 193         return 0;
 194 }
 195
 196 static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol,
 197                                         struct snd_ctl_elem_value *ucontrol)
 198 {
 199         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 200         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
 201         int shift = (kcontrol->private_value >> 8) & 0xff;
 202         long nvoices[2];
 203
 204         snd_pmac_burgundy_write_volume(chip, addr,
 205                                        ucontrol->value.integer.value, shift);
 206         snd_pmac_burgundy_read_volume(chip, addr, nvoices, shift);
 207         return (nvoices[0] != ucontrol->value.integer.value[0] ||
 208                 nvoices[1] != ucontrol->value.integer.value[1]);
 209 }
 210
 211 #define BURGUNDY_VOLUME_W(xname, xindex, addr, shift) \
 212 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
 213   .info = snd_pmac_burgundy_info_volume,\
 214   .get = snd_pmac_burgundy_get_volume,\
 215   .put = snd_pmac_burgundy_put_volume,\
 216   .private_value = ((ADDR2BASE(addr) & 0xff) | ((shift) << 8)) }
 217
 218 /*
 219  * Burgundy volume: 0 - 100, stereo, 2-byte reg
 220  */
 221 static void
 222 snd_pmac_burgundy_write_volume_2b(struct snd_pmac *chip, unsigned int address,
 223                                   long *volume, int off)
 224 {
 225         int lvolume, rvolume;
 226
 227         off |= off << 2;
 228         lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;
 229         rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;
 230
 231         snd_pmac_burgundy_wcb(chip, address + off, lvolume);
 232         snd_pmac_burgundy_wcb(chip, address + off + 0x500, rvolume);
 233 }
 234
 235 static void
 236 snd_pmac_burgundy_read_volume_2b(struct snd_pmac *chip, unsigned int address,
 237                                  long *volume, int off)
 238 {
 239         volume[0] = snd_pmac_burgundy_rcb(chip, address + off);
 240         if (volume[0] >= BURGUNDY_VOLUME_OFFSET)
 241                 volume[0] -= BURGUNDY_VOLUME_OFFSET;
 242         else
 243                 volume[0] = 0;
 244         volume[1] = snd_pmac_burgundy_rcb(chip, address + off + 0x100);
 245         if (volume[1] >= BURGUNDY_VOLUME_OFFSET)
 246                 volume[1] -= BURGUNDY_VOLUME_OFFSET;
 247         else
 248                 volume[1] = 0;
 249 }
 250
 251 static int snd_pmac_burgundy_info_volume_2b(struct snd_kcontrol *kcontrol,
 252                                             struct snd_ctl_elem_info *uinfo)
 253 {
 254         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 255         uinfo->count = 2;
 256         uinfo->value.integer.min = 0;
 257         uinfo->value.integer.max = 100;
 258         return 0;
 259 }
 260
 261 static int snd_pmac_burgundy_get_volume_2b(struct snd_kcontrol *kcontrol,
 262                                            struct snd_ctl_elem_value *ucontrol)
 263 {
 264         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 265         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
 266         int off = kcontrol->private_value & 0x300;
 267         snd_pmac_burgundy_read_volume_2b(chip, addr,
 268                         ucontrol->value.integer.value, off);
 269         return 0;
 270 }
 271
 272 static int snd_pmac_burgundy_put_volume_2b(struct snd_kcontrol *kcontrol,
 273                                            struct snd_ctl_elem_value *ucontrol)
 274 {
 275         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 276         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
 277         int off = kcontrol->private_value & 0x300;
 278         long nvoices[2];
 279
 280         snd_pmac_burgundy_write_volume_2b(chip, addr,
 281                         ucontrol->value.integer.value, off);
 282         snd_pmac_burgundy_read_volume_2b(chip, addr, nvoices, off);
 283         return (nvoices[0] != ucontrol->value.integer.value[0] ||
 284                 nvoices[1] != ucontrol->value.integer.value[1]);
 285 }
 286
 287 #define BURGUNDY_VOLUME_2B(xname, xindex, addr, off) \
 288 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
 289   .info = snd_pmac_burgundy_info_volume_2b,\
 290   .get = snd_pmac_burgundy_get_volume_2b,\
 291   .put = snd_pmac_burgundy_put_volume_2b,\
 292   .private_value = ((ADDR2BASE(addr) & 0xff) | ((off) << 8)) }
 293
 294 /*
 295  * Burgundy gain/attenuation: 0 - 15, mono/stereo, byte reg
 296  */
 297 static int snd_pmac_burgundy_info_gain(struct snd_kcontrol *kcontrol,
 298                                        struct snd_ctl_elem_info *uinfo)
 299 {
 300         int stereo = (kcontrol->private_value >> 24) & 1;
 301         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 302         uinfo->count = stereo + 1;
 303         uinfo->value.integer.min = 0;
 304         uinfo->value.integer.max = 15;
 305         return 0;
 306 }
 307
 308 static int snd_pmac_burgundy_get_gain(struct snd_kcontrol *kcontrol,
 309                                       struct snd_ctl_elem_value *ucontrol)
 310 {
 311         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 312         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
 313         int stereo = (kcontrol->private_value >> 24) & 1;
 314         int atten = (kcontrol->private_value >> 25) & 1;
 315         int oval;
 316
 317         oval = snd_pmac_burgundy_rcb(chip, addr);
 318         if (atten)
 319                 oval = ~oval & 0xff;
 320         ucontrol->value.integer.value[0] = oval & 0xf;
 321         if (stereo)
 322                 ucontrol->value.integer.value[1] = (oval >> 4) & 0xf;
 323         return 0;
 324 }
 325
 326 static int snd_pmac_burgundy_put_gain(struct snd_kcontrol *kcontrol,
 327                                       struct snd_ctl_elem_value *ucontrol)
 328 {
 329         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 330         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
 331         int stereo = (kcontrol->private_value >> 24) & 1;
 332         int atten = (kcontrol->private_value >> 25) & 1;
 333         int oval, val;
 334
 335         oval = snd_pmac_burgundy_rcb(chip, addr);
 336         if (atten)
 337                 oval = ~oval & 0xff;
 338         val = ucontrol->value.integer.value[0];
 339         if (stereo)
 340                 val |= ucontrol->value.integer.value[1] << 4;
 341         else
 342                 val |= ucontrol->value.integer.value[0] << 4;
 343         if (atten)
 344                 val = ~val & 0xff;
 345         snd_pmac_burgundy_wcb(chip, addr, val);
 346         return val != oval;
 347 }
 348
 349 #define BURGUNDY_VOLUME_B(xname, xindex, addr, stereo, atten) \
 350 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
 351   .info = snd_pmac_burgundy_info_gain,\
 352   .get = snd_pmac_burgundy_get_gain,\
 353   .put = snd_pmac_burgundy_put_gain,\
 354   .private_value = (ADDR2BASE(addr) | ((stereo) << 24) | ((atten) << 25)) }
 355
 356 /*
 357  * Burgundy switch: 0/1, mono/stereo, word reg
 358  */
 359 static int snd_pmac_burgundy_info_switch_w(struct snd_kcontrol *kcontrol,
 360                                            struct snd_ctl_elem_info *uinfo)
 361 {
 362         int stereo = (kcontrol->private_value >> 24) & 1;
 363         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 364         uinfo->count = stereo + 1;
 365         uinfo->value.integer.min = 0;
 366         uinfo->value.integer.max = 1;
 367         return 0;
 368 }
 369
 370 static int snd_pmac_burgundy_get_switch_w(struct snd_kcontrol *kcontrol,
 371                                           struct snd_ctl_elem_value *ucontrol)
 372 {
 373         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 374         unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
 375         int lmask = 1 << (kcontrol->private_value & 0xff);
 376         int rmask = 1 << ((kcontrol->private_value >> 8) & 0xff);
 377         int stereo = (kcontrol->private_value >> 24) & 1;
 378         int val = snd_pmac_burgundy_rcw(chip, addr);
 379         ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0;
 380         if (stereo)
 381                 ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0;
 382         return 0;
 383 }
 384
 385 static int snd_pmac_burgundy_put_switch_w(struct snd_kcontrol *kcontrol,
 386                                           struct snd_ctl_elem_value *ucontrol)
 387 {
 388         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 389         unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
 390         int lmask = 1 << (kcontrol->private_value & 0xff);
 391         int rmask = 1 << ((kcontrol->private_value >> 8) & 0xff);
 392         int stereo = (kcontrol->private_value >> 24) & 1;
 393         int val, oval;
 394         oval = snd_pmac_burgundy_rcw(chip, addr);
 395         val = oval & ~(lmask | (stereo ? rmask : 0));
 396         if (ucontrol->value.integer.value[0])
 397                 val |= lmask;
 398         if (stereo && ucontrol->value.integer.value[1])
 399                 val |= rmask;
 400         snd_pmac_burgundy_wcw(chip, addr, val);
 401         return val != oval;
 402 }
 403
 404 #define BURGUNDY_SWITCH_W(xname, xindex, addr, lbit, rbit, stereo) \
 405 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
 406   .info = snd_pmac_burgundy_info_switch_w,\
 407   .get = snd_pmac_burgundy_get_switch_w,\
 408   .put = snd_pmac_burgundy_put_switch_w,\
 409   .private_value = ((lbit) | ((rbit) << 8)\
 410                 | (ADDR2BASE(addr) << 16) | ((stereo) << 24)) }
 411
 412 /*
 413  * Burgundy switch: 0/1, mono/stereo, byte reg, bit mask
 414  */
 415 static int snd_pmac_burgundy_info_switch_b(struct snd_kcontrol *kcontrol,
 416                                            struct snd_ctl_elem_info *uinfo)
 417 {
 418         int stereo = (kcontrol->private_value >> 24) & 1;
 419         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 420         uinfo->count = stereo + 1;
 421         uinfo->value.integer.min = 0;
 422         uinfo->value.integer.max = 1;
 423         return 0;
 424 }
 425
 426 static int snd_pmac_burgundy_get_switch_b(struct snd_kcontrol *kcontrol,
 427                                           struct snd_ctl_elem_value *ucontrol)
 428 {
 429         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 430         unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
 431         int lmask = kcontrol->private_value & 0xff;
 432         int rmask = (kcontrol->private_value >> 8) & 0xff;
 433         int stereo = (kcontrol->private_value >> 24) & 1;
 434         int val = snd_pmac_burgundy_rcb(chip, addr);
 435         ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0;
 436         if (stereo)
 437                 ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0;
 438         return 0;
 439 }
 440
 441 static int snd_pmac_burgundy_put_switch_b(struct snd_kcontrol *kcontrol,
 442                                           struct snd_ctl_elem_value *ucontrol)
 443 {
 444         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 445         unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
 446         int lmask = kcontrol->private_value & 0xff;
 447         int rmask = (kcontrol->private_value >> 8) & 0xff;
 448         int stereo = (kcontrol->private_value >> 24) & 1;
 449         int val, oval;
 450         oval = snd_pmac_burgundy_rcb(chip, addr);
 451         val = oval & ~(lmask | rmask);
 452         if (ucontrol->value.integer.value[0])
 453                 val |= lmask;
 454         if (stereo && ucontrol->value.integer.value[1])
 455                 val |= rmask;
 456         snd_pmac_burgundy_wcb(chip, addr, val);
 457         return val != oval;
 458 }
 459
 460 #define BURGUNDY_SWITCH_B(xname, xindex, addr, lmask, rmask, stereo) \
 461 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
 462   .info = snd_pmac_burgundy_info_switch_b,\
 463   .get = snd_pmac_burgundy_get_switch_b,\
 464   .put = snd_pmac_burgundy_put_switch_b,\
 465   .private_value = ((lmask) | ((rmask) << 8)\
 466                 | (ADDR2BASE(addr) << 16) | ((stereo) << 24)) }
 467
 468 /*
 469  * Burgundy mixers
 470  */
 471 static struct snd_kcontrol_new snd_pmac_burgundy_mixers[] __initdata = {
 472         BURGUNDY_VOLUME_W("Master Playback Volume", 0,
 473                         MASK_ADDR_BURGUNDY_MASTER_VOLUME, 8),
 474         BURGUNDY_VOLUME_W("CD Capture Volume", 0,
 475                         MASK_ADDR_BURGUNDY_VOLCD, 16),
 476         BURGUNDY_VOLUME_2B("Input Capture Volume", 0,
 477                         MASK_ADDR_BURGUNDY_VOLMIX01, 2),
 478         BURGUNDY_VOLUME_2B("Mixer Playback Volume", 0,
 479                         MASK_ADDR_BURGUNDY_VOLMIX23, 0),
 480         BURGUNDY_VOLUME_B("CD Gain Capture Volume", 0,
 481                         MASK_ADDR_BURGUNDY_GAINCD, 1, 0),
 482         BURGUNDY_SWITCH_W("Master Capture Switch", 0,
 483                         MASK_ADDR_BURGUNDY_OUTPUTENABLES, 24, 0, 0),
 484         BURGUNDY_SWITCH_W("CD Capture Switch", 0,
 485                         MASK_ADDR_BURGUNDY_CAPTURESELECTS, 0, 16, 1),
 486         BURGUNDY_SWITCH_W("CD Playback Switch", 0,
 487                         MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 0, 16, 1),
 488 /*      BURGUNDY_SWITCH_W("Loop Capture Switch", 0,
 489  *              MASK_ADDR_BURGUNDY_CAPTURESELECTS, 8, 24, 1),
 490  *      BURGUNDY_SWITCH_B("Mixer out Capture Switch", 0,
 491  *              MASK_ADDR_BURGUNDY_HOSTIFAD, 0x02, 0, 0),
 492  *      BURGUNDY_SWITCH_B("Mixer Capture Switch", 0,
 493  *              MASK_ADDR_BURGUNDY_HOSTIFAD, 0x01, 0, 0),
 494  *      BURGUNDY_SWITCH_B("PCM out Capture Switch", 0,
 495  *              MASK_ADDR_BURGUNDY_HOSTIFEH, 0x02, 0, 0),
 496  */     BURGUNDY_SWITCH_B("PCM Capture Switch", 0,
 497                         MASK_ADDR_BURGUNDY_HOSTIFEH, 0x01, 0, 0)
 498 };
 499 static struct snd_kcontrol_new snd_pmac_burgundy_mixers_imac[] __initdata = {
 500         BURGUNDY_VOLUME_W("Line in Capture Volume", 0,
 501                         MASK_ADDR_BURGUNDY_VOLLINE, 16),
 502         BURGUNDY_VOLUME_W("Mic Capture Volume", 0,
 503                         MASK_ADDR_BURGUNDY_VOLMIC, 16),
 504         BURGUNDY_VOLUME_B("Line in Gain Capture Volume", 0,
 505                         MASK_ADDR_BURGUNDY_GAINLINE, 1, 0),
 506         BURGUNDY_VOLUME_B("Mic Gain Capture Volume", 0,
 507                         MASK_ADDR_BURGUNDY_GAINMIC, 1, 0),
 508         BURGUNDY_VOLUME_B("PC Speaker Playback Volume", 0,
 509                         MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1, 1),
 510         BURGUNDY_VOLUME_B("Line out Playback Volume", 0,
 511                         MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1, 1),
 512         BURGUNDY_VOLUME_B("Headphone Playback Volume", 0,
 513                         MASK_ADDR_BURGUNDY_ATTENHP, 1, 1),
 514         BURGUNDY_SWITCH_W("Line in Capture Switch", 0,
 515                         MASK_ADDR_BURGUNDY_CAPTURESELECTS, 1, 17, 1),
 516         BURGUNDY_SWITCH_W("Mic Capture Switch", 0,
 517                         MASK_ADDR_BURGUNDY_CAPTURESELECTS, 2, 18, 1),
 518         BURGUNDY_SWITCH_W("Line in Playback Switch", 0,
 519                         MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 1, 17, 1),
 520         BURGUNDY_SWITCH_W("Mic Playback Switch", 0,
 521                         MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 2, 18, 1),
 522         BURGUNDY_SWITCH_B("Mic Boost Capture Switch", 0,
 523                         MASK_ADDR_BURGUNDY_INPBOOST, 0x40, 0x80, 1)
 524 };
 525 static struct snd_kcontrol_new snd_pmac_burgundy_mixers_pmac[] __initdata = {
 526         BURGUNDY_VOLUME_W("Line in Capture Volume", 0,
 527                         MASK_ADDR_BURGUNDY_VOLMIC, 16),
 528         BURGUNDY_VOLUME_B("Line in Gain Capture Volume", 0,
 529                         MASK_ADDR_BURGUNDY_GAINMIC, 1, 0),
 530         BURGUNDY_VOLUME_B("PC Speaker Playback Volume", 0,
 531                         MASK_ADDR_BURGUNDY_ATTENMONO, 0, 1),
 532         BURGUNDY_VOLUME_B("Line out Playback Volume", 0,
 533                         MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1, 1),
 534         BURGUNDY_SWITCH_W("Line in Capture Switch", 0,
 535                         MASK_ADDR_BURGUNDY_CAPTURESELECTS, 2, 18, 1),
 536         BURGUNDY_SWITCH_W("Line in Playback Switch", 0,
 537                         MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 2, 18, 1),
 538 /*      BURGUNDY_SWITCH_B("Line in Boost Capture Switch", 0,
 539  *              MASK_ADDR_BURGUNDY_INPBOOST, 0x40, 0x80, 1) */
 540 };
 541 static struct snd_kcontrol_new snd_pmac_burgundy_master_sw_imac __initdata =
 542 BURGUNDY_SWITCH_B("Master Playback Switch", 0,
 543         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 544         BURGUNDY_OUTPUT_LEFT | BURGUNDY_LINEOUT_LEFT | BURGUNDY_HP_LEFT,
 545         BURGUNDY_OUTPUT_RIGHT | BURGUNDY_LINEOUT_RIGHT | BURGUNDY_HP_RIGHT, 1);
 546 static struct snd_kcontrol_new snd_pmac_burgundy_master_sw_pmac __initdata =
 547 BURGUNDY_SWITCH_B("Master Playback Switch", 0,
 548         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 549         BURGUNDY_OUTPUT_INTERN
 550         | BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
 551 static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_imac __initdata =
 552 BURGUNDY_SWITCH_B("PC Speaker Playback Switch", 0,
 553         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 554         BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
 555 static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_pmac __initdata =
 556 BURGUNDY_SWITCH_B("PC Speaker Playback Switch", 0,
 557         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 558         BURGUNDY_OUTPUT_INTERN, 0, 0);
 559 static struct snd_kcontrol_new snd_pmac_burgundy_line_sw_imac __initdata =
 560 BURGUNDY_SWITCH_B("Line out Playback Switch", 0,
 561         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 562         BURGUNDY_LINEOUT_LEFT, BURGUNDY_LINEOUT_RIGHT, 1);
 563 static struct snd_kcontrol_new snd_pmac_burgundy_line_sw_pmac __initdata =
 564 BURGUNDY_SWITCH_B("Line out Playback Switch", 0,
 565         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 566         BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
 567 static struct snd_kcontrol_new snd_pmac_burgundy_hp_sw_imac __initdata =
 568 BURGUNDY_SWITCH_B("Headphone Playback Switch", 0,
 569         MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 570         BURGUNDY_HP_LEFT, BURGUNDY_HP_RIGHT, 1);
 571
 572
 573 #ifdef PMAC_SUPPORT_AUTOMUTE
 574 /*
 575  * auto-mute stuffs
 576  */
 577 static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip)
 578 {
 579         return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
 580 }
 581
 582 static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify)
 583 {
 584         if (chip->auto_mute) {
 585                 int imac = machine_is_compatible("iMac");
 586                 int reg, oreg;
 587                 reg = oreg = snd_pmac_burgundy_rcb(chip,
 588                                 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
 589                 reg &= imac ? ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT
 590                                 | BURGUNDY_HP_LEFT | BURGUNDY_HP_RIGHT)
 591                         : ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT
 592                                 | BURGUNDY_OUTPUT_INTERN);
 593                 if (snd_pmac_burgundy_detect_headphone(chip))
 594                         reg |= imac ? (BURGUNDY_HP_LEFT | BURGUNDY_HP_RIGHT)
 595                                 : (BURGUNDY_OUTPUT_LEFT
 596                                         | BURGUNDY_OUTPUT_RIGHT);
 597                 else
 598                         reg |= imac ? (BURGUNDY_OUTPUT_LEFT
 599                                         | BURGUNDY_OUTPUT_RIGHT)
 600                                 : (BURGUNDY_OUTPUT_INTERN);
 601                 if (do_notify && reg == oreg)
 602                         return;
 603                 snd_pmac_burgundy_wcb(chip,
 604                                 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, reg);
 605                 if (do_notify) {
 606                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 607                                        &chip->master_sw_ctl->id);
 608                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 609                                        &chip->speaker_sw_ctl->id);
 610                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 611                                        &chip->hp_detect_ctl->id);
 612                 }
 613         }
 614 }
 615 #endif /* PMAC_SUPPORT_AUTOMUTE */
 616
 617
 618 /*
 619  * initialize burgundy
 620  */
 621 int __init snd_pmac_burgundy_init(struct snd_pmac *chip)
 622 {
 623         int imac = machine_is_compatible("iMac");
 624         int i, err;
 625
 626         /* Checks to see the chip is alive and kicking */
 627         if ((in_le32(&chip->awacs->codec_ctrl) & MASK_ERRCODE) == 0xf0000) {
 628                 printk(KERN_WARNING "pmac burgundy: disabled by MacOS :-(\n");
 629                 return 1;
 630         }
 631
 632         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTENABLES,
 633                            DEF_BURGUNDY_OUTPUTENABLES);
 634         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
 635                            DEF_BURGUNDY_MORE_OUTPUTENABLES);
 636         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTSELECTS,
 637                            DEF_BURGUNDY_OUTPUTSELECTS);
 638
 639         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL21,
 640                            DEF_BURGUNDY_INPSEL21);
 641         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL3,
 642                            imac ? DEF_BURGUNDY_INPSEL3_IMAC
 643                            : DEF_BURGUNDY_INPSEL3_PMAC);
 644         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINCD,
 645                            DEF_BURGUNDY_GAINCD);
 646         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINLINE,
 647                            DEF_BURGUNDY_GAINLINE);
 648         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMIC,
 649                            DEF_BURGUNDY_GAINMIC);
 650         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMODEM,
 651                            DEF_BURGUNDY_GAINMODEM);
 652
 653         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENSPEAKER,
 654                            DEF_BURGUNDY_ATTENSPEAKER);
 655         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENLINEOUT,
 656                            DEF_BURGUNDY_ATTENLINEOUT);
 657         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENHP,
 658                            DEF_BURGUNDY_ATTENHP);
 659
 660         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_MASTER_VOLUME,
 661                            DEF_BURGUNDY_MASTER_VOLUME);
 662         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLCD,
 663                            DEF_BURGUNDY_VOLCD);
 664         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLLINE,
 665                            DEF_BURGUNDY_VOLLINE);
 666         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLMIC,
 667                            DEF_BURGUNDY_VOLMIC);
 668
 669         if (chip->hp_stat_mask == 0) {
 670                 /* set headphone-jack detection bit */
 671                 if (imac)
 672                         chip->hp_stat_mask = BURGUNDY_HPDETECT_IMAC_UPPER
 673                                 | BURGUNDY_HPDETECT_IMAC_LOWER
 674                                 | BURGUNDY_HPDETECT_IMAC_SIDE;
 675                 else
 676                         chip->hp_stat_mask = BURGUNDY_HPDETECT_PMAC_BACK;
 677         }
 678         /*
 679          * build burgundy mixers
 680          */
 681         strcpy(chip->card->mixername, "PowerMac Burgundy");
 682
 683         for (i = 0; i < ARRAY_SIZE(snd_pmac_burgundy_mixers); i++) {
 684                 err = snd_ctl_add(chip->card,
 685                     snd_ctl_new1(&snd_pmac_burgundy_mixers[i], chip));
 686                 if (err < 0)
 687                         return err;
 688         }
 689         for (i = 0; i < (imac ? ARRAY_SIZE(snd_pmac_burgundy_mixers_imac)
 690                         : ARRAY_SIZE(snd_pmac_burgundy_mixers_pmac)); i++) {
 691                 err = snd_ctl_add(chip->card,
 692                     snd_ctl_new1(imac ? &snd_pmac_burgundy_mixers_imac[i]
 693                     : &snd_pmac_burgundy_mixers_pmac[i], chip));
 694                 if (err < 0)
 695                         return err;
 696         }
 697         chip->master_sw_ctl = snd_ctl_new1(imac
 698                         ? &snd_pmac_burgundy_master_sw_imac
 699                         : &snd_pmac_burgundy_master_sw_pmac, chip);
 700         err = snd_ctl_add(chip->card, chip->master_sw_ctl);
 701         if (err < 0)
 702                 return err;
 703         chip->master_sw_ctl = snd_ctl_new1(imac
 704                         ? &snd_pmac_burgundy_line_sw_imac
 705                         : &snd_pmac_burgundy_line_sw_pmac, chip);
 706         err = snd_ctl_add(chip->card, chip->master_sw_ctl);
 707         if (err < 0)
 708                 return err;
 709         if (imac) {
 710                 chip->master_sw_ctl = snd_ctl_new1(
 711                                 &snd_pmac_burgundy_hp_sw_imac, chip);
 712                 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
 713                 if (err < 0)
 714                         return err;
 715         }
 716         chip->speaker_sw_ctl = snd_ctl_new1(imac
 717                         ? &snd_pmac_burgundy_speaker_sw_imac
 718                         : &snd_pmac_burgundy_speaker_sw_pmac, chip);
 719         err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
 720         if (err < 0)
 721                 return err;
 722 #ifdef PMAC_SUPPORT_AUTOMUTE
 723         err = snd_pmac_add_automute(chip);
 724         if (err < 0)
 725                 return err;
 726
 727         chip->detect_headphone = snd_pmac_burgundy_detect_headphone;
 728         chip->update_automute = snd_pmac_burgundy_update_automute;
 729         snd_pmac_burgundy_update_automute(chip, 0); /* update the status only */
 730 #endif
 731
 732         return 0;
 733 }