721 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * PMac Burgundy lowlevel functions4 *5 * Copyright (c) by Takashi Iwai <tiwai@suse.de>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 */19static inline void20snd_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 29static inline void30snd_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 45static void46snd_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 58static unsigned59snd_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 91static void92snd_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 99static unsigned100snd_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 reg122 */123static void124snd_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 142static void143snd_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 else154 volume[0] = 0;155 volume[1] = (wvolume >> shift) & 0xff;156 if (volume[1] >= BURGUNDY_VOLUME_OFFSET)157 volume[1] -= BURGUNDY_VOLUME_OFFSET;158 else159 volume[1] = 0;160}161 162static 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 172static 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 183static 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 reg207 */208static void209snd_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 222static void223snd_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 else230 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 else235 volume[1] = 0;236}237 238static 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 248static 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 259static 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 reg283 */284static 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 295static 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 313static 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 else329 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 reg345 */346static 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 357static 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 372static 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 mask401 */402static 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 413static 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 428static 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 mixers457 */458static 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};486static 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};512static 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};528static const struct snd_kcontrol_new snd_pmac_burgundy_master_sw_imac =529BURGUNDY_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);533static const struct snd_kcontrol_new snd_pmac_burgundy_master_sw_pmac =534BURGUNDY_SWITCH_B("Master Playback Switch", 0,535 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,536 BURGUNDY_OUTPUT_INTERN537 | BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);538static const struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_imac =539BURGUNDY_SWITCH_B("Speaker Playback Switch", 0,540 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,541 BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);542static const struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_pmac =543BURGUNDY_SWITCH_B("Speaker Playback Switch", 0,544 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,545 BURGUNDY_OUTPUT_INTERN, 0, 0);546static const struct snd_kcontrol_new snd_pmac_burgundy_line_sw_imac =547BURGUNDY_SWITCH_B("Line out Playback Switch", 0,548 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,549 BURGUNDY_LINEOUT_LEFT, BURGUNDY_LINEOUT_RIGHT, 1);550static const struct snd_kcontrol_new snd_pmac_burgundy_line_sw_pmac =551BURGUNDY_SWITCH_B("Line out Playback Switch", 0,552 MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,553 BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);554static const struct snd_kcontrol_new snd_pmac_burgundy_hp_sw_imac =555BURGUNDY_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_AUTOMUTE561/*562 * auto-mute stuffs563 */564static 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 569static 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_RIGHT577 | BURGUNDY_HP_LEFT | BURGUNDY_HP_RIGHT)578 : ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT579 | BURGUNDY_OUTPUT_INTERN);580 if (snd_pmac_burgundy_detect_headphone(chip))581 reg |= imac ? (BURGUNDY_HP_LEFT | BURGUNDY_HP_RIGHT)582 : (BURGUNDY_OUTPUT_LEFT583 | BURGUNDY_OUTPUT_RIGHT);584 else585 reg |= imac ? (BURGUNDY_OUTPUT_LEFT586 | 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 burgundy607 */608int 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_IMAC630 : 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_UPPER660 | BURGUNDY_HPDETECT_IMAC_LOWER661 | BURGUNDY_HPDETECT_IMAC_SIDE;662 else663 chip->hp_stat_mask = BURGUNDY_HPDETECT_PMAC_BACK;664 }665 /*666 * build burgundy mixers667 */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(imac685 ? &snd_pmac_burgundy_master_sw_imac686 : &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(imac691 ? &snd_pmac_burgundy_line_sw_imac692 : &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(imac704 ? &snd_pmac_burgundy_speaker_sw_imac705 : &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_AUTOMUTE710 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#endif718 719 return 0;720}721