sound/ppc/burgundy.c

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