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 < 0) 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 } 734