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 <sound/driver.h> 23#include <asm/io.h> 24#include <linux/init.h> 25#include <linux/slab.h> 26#include <linux/delay.h> 27#include <sound/core.h> 28#include "pmac.h" 29#include "burgundy.h" 30 31 32/* Waits for busy flag to clear */ 33static inline void 34snd_pmac_burgundy_busy_wait(struct snd_pmac *chip) 35{ 36 int timeout = 50; 37 while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--) 38 udelay(1); 39 if (! timeout) 40 printk(KERN_DEBUG "burgundy_busy_wait: timeout\n"); 41} 42 43static inline void 44snd_pmac_burgundy_extend_wait(struct snd_pmac *chip) 45{ 46 int timeout; 47 timeout = 50; 48 while (!(in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--) 49 udelay(1); 50 if (! timeout) 51 printk(KERN_DEBUG "burgundy_extend_wait: timeout #1\n"); 52 timeout = 50; 53 while ((in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--) 54 udelay(1); 55 if (! timeout) 56 printk(KERN_DEBUG "burgundy_extend_wait: timeout #2\n"); 57} 58 59static void 60snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val) 61{ 62 out_le32(&chip->awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff)); 63 snd_pmac_burgundy_busy_wait(chip); 64 out_le32(&chip->awacs->codec_ctrl, addr + 0x200d00 +((val>>8) & 0xff)); 65 snd_pmac_burgundy_busy_wait(chip); 66 out_le32(&chip->awacs->codec_ctrl, addr + 0x200e00 +((val>>16) & 0xff)); 67 snd_pmac_burgundy_busy_wait(chip); 68 out_le32(&chip->awacs->codec_ctrl, addr + 0x200f00 +((val>>24) & 0xff)); 69 snd_pmac_burgundy_busy_wait(chip); 70} 71 72static unsigned 73snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr) 74{ 75 unsigned val = 0; 76 unsigned long flags; 77 78 spin_lock_irqsave(&chip->reg_lock, flags); 79 80 out_le32(&chip->awacs->codec_ctrl, addr + 0x100000); 81 snd_pmac_burgundy_busy_wait(chip); 82 snd_pmac_burgundy_extend_wait(chip); 83 val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff; 84 85 out_le32(&chip->awacs->codec_ctrl, addr + 0x100100); 86 snd_pmac_burgundy_busy_wait(chip); 87 snd_pmac_burgundy_extend_wait(chip); 88 val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<8; 89 90 out_le32(&chip->awacs->codec_ctrl, addr + 0x100200); 91 snd_pmac_burgundy_busy_wait(chip); 92 snd_pmac_burgundy_extend_wait(chip); 93 val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<16; 94 95 out_le32(&chip->awacs->codec_ctrl, addr + 0x100300); 96 snd_pmac_burgundy_busy_wait(chip); 97 snd_pmac_burgundy_extend_wait(chip); 98 val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<24; 99 100 spin_unlock_irqrestore(&chip->reg_lock, flags); 101 102 return val; 103} 104 105static void 106snd_pmac_burgundy_wcb(struct snd_pmac *chip, unsigned int addr, unsigned int val) 107{ 108 out_le32(&chip->awacs->codec_ctrl, addr + 0x300000 + (val & 0xff)); 109 snd_pmac_burgundy_busy_wait(chip); 110} 111 112static unsigned 113snd_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/* 131 * Burgundy volume: 0 - 100, stereo 132 */ 133static void 134snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address, 135 long *volume, int shift) 136{ 137 int hardvolume, lvolume, rvolume; 138 139 lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0; 140 rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0; 141 142 hardvolume = lvolume + (rvolume << shift); 143 if (shift == 8) 144 hardvolume |= hardvolume << 16; 145 146 snd_pmac_burgundy_wcw(chip, address, hardvolume); 147} 148 149static void 150snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address, 151 long *volume, int shift) 152{ 153 int wvolume; 154 155 wvolume = snd_pmac_burgundy_rcw(chip, address); 156 157 volume[0] = wvolume & 0xff; 158 if (volume[0] >= BURGUNDY_VOLUME_OFFSET) 159 volume[0] -= BURGUNDY_VOLUME_OFFSET; 160 else 161 volume[0] = 0; 162 volume[1] = (wvolume >> shift) & 0xff; 163 if (volume[1] >= BURGUNDY_VOLUME_OFFSET) 164 volume[1] -= BURGUNDY_VOLUME_OFFSET; 165 else 166 volume[1] = 0; 167} 168 169 170/* 171 */ 172 173#define BASE2ADDR(base) ((base) << 12) 174#define ADDR2BASE(addr) ((addr) >> 12) 175 176static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol, 177 struct snd_ctl_elem_info *uinfo) 178{ 179 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 180 uinfo->count = 2; 181 uinfo->value.integer.min = 0; 182 uinfo->value.integer.max = 100; 183 return 0; 184} 185 186static int snd_pmac_burgundy_get_volume(struct snd_kcontrol *kcontrol, 187 struct snd_ctl_elem_value *ucontrol) 188{ 189 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 190 unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); 191 int shift = (kcontrol->private_value >> 8) & 0xff; 192 snd_pmac_burgundy_read_volume(chip, addr, ucontrol->value.integer.value, 193 shift); 194 return 0; 195} 196 197static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol, 198 struct snd_ctl_elem_value *ucontrol) 199{ 200 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 201 unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); 202 int shift = (kcontrol->private_value >> 8) & 0xff; 203 long nvoices[2]; 204 205 snd_pmac_burgundy_write_volume(chip, addr, ucontrol->value.integer.value, 206 shift); 207 snd_pmac_burgundy_read_volume(chip, addr, nvoices, shift); 208 return (nvoices[0] != ucontrol->value.integer.value[0] || 209 nvoices[1] != ucontrol->value.integer.value[1]); 210} 211 212#define BURGUNDY_VOLUME(xname, xindex, addr, shift) \ 213{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\ 214 .info = snd_pmac_burgundy_info_volume,\ 215 .get = snd_pmac_burgundy_get_volume,\ 216 .put = snd_pmac_burgundy_put_volume,\ 217 .private_value = ((ADDR2BASE(addr) & 0xff) | ((shift) << 8)) } 218 219/* lineout/speaker */ 220 221static int snd_pmac_burgundy_info_switch_out(struct snd_kcontrol *kcontrol, 222 struct snd_ctl_elem_info *uinfo) 223{ 224 int stereo = (kcontrol->private_value >> 24) & 1; 225 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 226 uinfo->count = stereo + 1; 227 uinfo->value.integer.min = 0; 228 uinfo->value.integer.max = 1; 229 return 0; 230} 231 232static int snd_pmac_burgundy_get_switch_out(struct snd_kcontrol *kcontrol, 233 struct snd_ctl_elem_value *ucontrol) 234{ 235 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 236 int lmask = kcontrol->private_value & 0xff; 237 int rmask = (kcontrol->private_value >> 8) & 0xff; 238 int stereo = (kcontrol->private_value >> 24) & 1; 239 int val = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES); 240 ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0; 241 if (stereo) 242 ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0; 243 return 0; 244} 245 246static int snd_pmac_burgundy_put_switch_out(struct snd_kcontrol *kcontrol, 247 struct snd_ctl_elem_value *ucontrol) 248{ 249 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 250 int lmask = kcontrol->private_value & 0xff; 251 int rmask = (kcontrol->private_value >> 8) & 0xff; 252 int stereo = (kcontrol->private_value >> 24) & 1; 253 int val, oval; 254 oval = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES); 255 val = oval & ~(lmask | rmask); 256 if (ucontrol->value.integer.value[0]) 257 val |= lmask; 258 if (stereo && ucontrol->value.integer.value[1]) 259 val |= rmask; 260 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, val); 261 return val != oval; 262} 263 264#define BURGUNDY_OUTPUT_SWITCH(xname, xindex, lmask, rmask, stereo) \ 265{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\ 266 .info = snd_pmac_burgundy_info_switch_out,\ 267 .get = snd_pmac_burgundy_get_switch_out,\ 268 .put = snd_pmac_burgundy_put_switch_out,\ 269 .private_value = ((lmask) | ((rmask) << 8) | ((stereo) << 24)) } 270 271/* line/speaker output volume */ 272static int snd_pmac_burgundy_info_volume_out(struct snd_kcontrol *kcontrol, 273 struct snd_ctl_elem_info *uinfo) 274{ 275 int stereo = (kcontrol->private_value >> 24) & 1; 276 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 277 uinfo->count = stereo + 1; 278 uinfo->value.integer.min = 0; 279 uinfo->value.integer.max = 15; 280 return 0; 281} 282 283static int snd_pmac_burgundy_get_volume_out(struct snd_kcontrol *kcontrol, 284 struct snd_ctl_elem_value *ucontrol) 285{ 286 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 287 unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); 288 int stereo = (kcontrol->private_value >> 24) & 1; 289 int oval; 290 291 oval = ~snd_pmac_burgundy_rcb(chip, addr) & 0xff; 292 ucontrol->value.integer.value[0] = oval & 0xf; 293 if (stereo) 294 ucontrol->value.integer.value[1] = (oval >> 4) & 0xf; 295 return 0; 296} 297 298static int snd_pmac_burgundy_put_volume_out(struct snd_kcontrol *kcontrol, 299 struct snd_ctl_elem_value *ucontrol) 300{ 301 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 302 unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff); 303 int stereo = (kcontrol->private_value >> 24) & 1; 304 int oval, val; 305 306 oval = ~snd_pmac_burgundy_rcb(chip, addr) & 0xff; 307 val = ucontrol->value.integer.value[0]; 308 if (stereo) 309 val |= ucontrol->value.integer.value[1] << 4; 310 else 311 val |= ucontrol->value.integer.value[0] << 4; 312 val = ~val & 0xff; 313 snd_pmac_burgundy_wcb(chip, addr, val); 314 return val != oval; 315} 316 317#define BURGUNDY_OUTPUT_VOLUME(xname, xindex, addr, stereo) \ 318{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\ 319 .info = snd_pmac_burgundy_info_volume_out,\ 320 .get = snd_pmac_burgundy_get_volume_out,\ 321 .put = snd_pmac_burgundy_put_volume_out,\ 322 .private_value = (ADDR2BASE(addr) | ((stereo) << 24)) } 323 324static struct snd_kcontrol_new snd_pmac_burgundy_mixers[] __initdata = { 325 BURGUNDY_VOLUME("Master Playback Volume", 0, MASK_ADDR_BURGUNDY_MASTER_VOLUME, 8), 326 BURGUNDY_VOLUME("Line Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLLINE, 16), 327 BURGUNDY_VOLUME("CD Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLCD, 16), 328 BURGUNDY_VOLUME("Mic Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLMIC, 16), 329 BURGUNDY_OUTPUT_VOLUME("PC Speaker Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENHP, 0), 330 /*BURGUNDY_OUTPUT_VOLUME("PCM Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1),*/ 331 BURGUNDY_OUTPUT_VOLUME("Headphone Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1), 332}; 333static struct snd_kcontrol_new snd_pmac_burgundy_master_sw __initdata = 334BURGUNDY_OUTPUT_SWITCH("Headphone Playback Switch", 0, BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1); 335static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw __initdata = 336BURGUNDY_OUTPUT_SWITCH("PC Speaker Playback Switch", 0, BURGUNDY_OUTPUT_INTERN, 0, 0); 337 338 339#ifdef PMAC_SUPPORT_AUTOMUTE 340/* 341 * auto-mute stuffs 342 */ 343static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip) 344{ 345 return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0; 346} 347 348static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify) 349{ 350 if (chip->auto_mute) { 351 int reg, oreg; 352 reg = oreg = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES); 353 reg &= ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT | BURGUNDY_OUTPUT_INTERN); 354 if (snd_pmac_burgundy_detect_headphone(chip)) 355 reg |= BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT; 356 else 357 reg |= BURGUNDY_OUTPUT_INTERN; 358 if (do_notify && reg == oreg) 359 return; 360 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, reg); 361 if (do_notify) { 362 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 363 &chip->master_sw_ctl->id); 364 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 365 &chip->speaker_sw_ctl->id); 366 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 367 &chip->hp_detect_ctl->id); 368 } 369 } 370} 371#endif /* PMAC_SUPPORT_AUTOMUTE */ 372 373 374/* 375 * initialize burgundy 376 */ 377int __init snd_pmac_burgundy_init(struct snd_pmac *chip) 378{ 379 int i, err; 380 381 /* Checks to see the chip is alive and kicking */ 382 if ((in_le32(&chip->awacs->codec_ctrl) & MASK_ERRCODE) == 0xf0000) { 383 printk(KERN_WARNING "pmac burgundy: disabled by MacOS :-(\n"); 384 return 1; 385 } 386 387 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_OUTPUTENABLES, 388 DEF_BURGUNDY_OUTPUTENABLES); 389 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, 390 DEF_BURGUNDY_MORE_OUTPUTENABLES); 391 snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 392 DEF_BURGUNDY_OUTPUTSELECTS); 393 394 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL21, 395 DEF_BURGUNDY_INPSEL21); 396 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL3, 397 DEF_BURGUNDY_INPSEL3); 398 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINCD, 399 DEF_BURGUNDY_GAINCD); 400 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINLINE, 401 DEF_BURGUNDY_GAINLINE); 402 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMIC, 403 DEF_BURGUNDY_GAINMIC); 404 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMODEM, 405 DEF_BURGUNDY_GAINMODEM); 406 407 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENSPEAKER, 408 DEF_BURGUNDY_ATTENSPEAKER); 409 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENLINEOUT, 410 DEF_BURGUNDY_ATTENLINEOUT); 411 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENHP, 412 DEF_BURGUNDY_ATTENHP); 413 414 snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_MASTER_VOLUME, 415 DEF_BURGUNDY_MASTER_VOLUME); 416 snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLCD, 417 DEF_BURGUNDY_VOLCD); 418 snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLLINE, 419 DEF_BURGUNDY_VOLLINE); 420 snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLMIC, 421 DEF_BURGUNDY_VOLMIC); 422 423 if (chip->hp_stat_mask == 0) 424 /* set headphone-jack detection bit */ 425 chip->hp_stat_mask = 0x04; 426 427 /* 428 * build burgundy mixers 429 */ 430 strcpy(chip->card->mixername, "PowerMac Burgundy"); 431 432 for (i = 0; i < ARRAY_SIZE(snd_pmac_burgundy_mixers); i++) { 433 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_pmac_burgundy_mixers[i], chip))) < 0) 434 return err; 435 } 436 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_burgundy_master_sw, chip); 437 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0) 438 return err; 439 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_burgundy_speaker_sw, chip); 440 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0) 441 return err; 442#ifdef PMAC_SUPPORT_AUTOMUTE 443 if ((err = snd_pmac_add_automute(chip)) < 0) 444 return err; 445 446 chip->detect_headphone = snd_pmac_burgundy_detect_headphone; 447 chip->update_automute = snd_pmac_burgundy_update_automute; 448 snd_pmac_burgundy_update_automute(chip, 0); /* update the status only */ 449#endif 450 451 return 0; 452} 453