1 /* 2 * PMac AWACS 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 23 #include <asm/io.h> 24 #include <asm/nvram.h> 25 #include <linux/init.h> 26 #include <linux/delay.h> 27 #include <linux/slab.h> 28 #include <sound/core.h> 29 #include "pmac.h" 30 31 32 #ifdef CONFIG_ADB_CUDA 33 #define PMAC_AMP_AVAIL 34 #endif 35 36 #ifdef PMAC_AMP_AVAIL 37 struct awacs_amp { 38 unsigned char amp_master; 39 unsigned char amp_vol[2][2]; 40 unsigned char amp_tone[2]; 41 }; 42 43 #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA) 44 45 #endif /* PMAC_AMP_AVAIL */ 46 47 48 static void snd_pmac_screamer_wait(struct snd_pmac *chip) 49 { 50 long timeout = 2000; 51 while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) { 52 mdelay(1); 53 if (! --timeout) { 54 snd_printd("snd_pmac_screamer_wait timeout\n"); 55 break; 56 } 57 } 58 } 59 60 /* 61 * write AWACS register 62 */ 63 static void 64 snd_pmac_awacs_write(struct snd_pmac *chip, int val) 65 { 66 long timeout = 5000000; 67 68 if (chip->model == PMAC_SCREAMER) 69 snd_pmac_screamer_wait(chip); 70 out_le32(&chip->awacs->codec_ctrl, val | (chip->subframe << 22)); 71 while (in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) { 72 if (! --timeout) { 73 snd_printd("snd_pmac_awacs_write timeout\n"); 74 break; 75 } 76 } 77 } 78 79 static void 80 snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val) 81 { 82 snd_pmac_awacs_write(chip, val | (reg << 12)); 83 chip->awacs_reg[reg] = val; 84 } 85 86 static void 87 snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val) 88 { 89 snd_pmac_awacs_write(chip, val | (reg << 12)); 90 } 91 92 #ifdef CONFIG_PM 93 /* Recalibrate chip */ 94 static void screamer_recalibrate(struct snd_pmac *chip) 95 { 96 if (chip->model != PMAC_SCREAMER) 97 return; 98 99 /* Sorry for the horrible delays... I hope to get that improved 100 * by making the whole PM process asynchronous in a future version 101 */ 102 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]); 103 if (chip->manufacturer == 0x1) 104 /* delay for broken crystal part */ 105 msleep(750); 106 snd_pmac_awacs_write_noreg(chip, 1, 107 chip->awacs_reg[1] | MASK_RECALIBRATE | 108 MASK_CMUTE | MASK_AMUTE); 109 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]); 110 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]); 111 } 112 113 #else 114 #define screamer_recalibrate(chip) /* NOP */ 115 #endif 116 117 118 /* 119 * additional callback to set the pcm format 120 */ 121 static void snd_pmac_awacs_set_format(struct snd_pmac *chip) 122 { 123 chip->awacs_reg[1] &= ~MASK_SAMPLERATE; 124 chip->awacs_reg[1] |= chip->rate_index << 3; 125 snd_pmac_awacs_write_reg(chip, 1, chip->awacs_reg[1]); 126 } 127 128 129 /* 130 * AWACS volume callbacks 131 */ 132 /* 133 * volumes: 0-15 stereo 134 */ 135 static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol, 136 struct snd_ctl_elem_info *uinfo) 137 { 138 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 139 uinfo->count = 2; 140 uinfo->value.integer.min = 0; 141 uinfo->value.integer.max = 15; 142 return 0; 143 } 144 145 static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol, 146 struct snd_ctl_elem_value *ucontrol) 147 { 148 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 149 int reg = kcontrol->private_value & 0xff; 150 int lshift = (kcontrol->private_value >> 8) & 0xff; 151 int inverted = (kcontrol->private_value >> 16) & 1; 152 unsigned long flags; 153 int vol[2]; 154 155 spin_lock_irqsave(&chip->reg_lock, flags); 156 vol[0] = (chip->awacs_reg[reg] >> lshift) & 0xf; 157 vol[1] = chip->awacs_reg[reg] & 0xf; 158 spin_unlock_irqrestore(&chip->reg_lock, flags); 159 if (inverted) { 160 vol[0] = 0x0f - vol[0]; 161 vol[1] = 0x0f - vol[1]; 162 } 163 ucontrol->value.integer.value[0] = vol[0]; 164 ucontrol->value.integer.value[1] = vol[1]; 165 return 0; 166 } 167 168 static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol, 169 struct snd_ctl_elem_value *ucontrol) 170 { 171 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 172 int reg = kcontrol->private_value & 0xff; 173 int lshift = (kcontrol->private_value >> 8) & 0xff; 174 int inverted = (kcontrol->private_value >> 16) & 1; 175 int val, oldval; 176 unsigned long flags; 177 unsigned int vol[2]; 178 179 vol[0] = ucontrol->value.integer.value[0]; 180 vol[1] = ucontrol->value.integer.value[1]; 181 if (vol[0] > 0x0f || vol[1] > 0x0f) 182 return -EINVAL; 183 if (inverted) { 184 vol[0] = 0x0f - vol[0]; 185 vol[1] = 0x0f - vol[1]; 186 } 187 vol[0] &= 0x0f; 188 vol[1] &= 0x0f; 189 spin_lock_irqsave(&chip->reg_lock, flags); 190 oldval = chip->awacs_reg[reg]; 191 val = oldval & ~(0xf | (0xf << lshift)); 192 val |= vol[0] << lshift; 193 val |= vol[1]; 194 if (oldval != val) 195 snd_pmac_awacs_write_reg(chip, reg, val); 196 spin_unlock_irqrestore(&chip->reg_lock, flags); 197 return oldval != reg; 198 } 199 200 201 #define AWACS_VOLUME(xname, xreg, xshift, xinverted) \ 202 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 203 .info = snd_pmac_awacs_info_volume, \ 204 .get = snd_pmac_awacs_get_volume, \ 205 .put = snd_pmac_awacs_put_volume, \ 206 .private_value = (xreg) | ((xshift) << 8) | ((xinverted) << 16) } 207 208 /* 209 * mute master/ogain for AWACS: mono 210 */ 211 static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol, 212 struct snd_ctl_elem_value *ucontrol) 213 { 214 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 215 int reg = kcontrol->private_value & 0xff; 216 int shift = (kcontrol->private_value >> 8) & 0xff; 217 int invert = (kcontrol->private_value >> 16) & 1; 218 int val; 219 unsigned long flags; 220 221 spin_lock_irqsave(&chip->reg_lock, flags); 222 val = (chip->awacs_reg[reg] >> shift) & 1; 223 spin_unlock_irqrestore(&chip->reg_lock, flags); 224 if (invert) 225 val = 1 - val; 226 ucontrol->value.integer.value[0] = val; 227 return 0; 228 } 229 230 static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol, 231 struct snd_ctl_elem_value *ucontrol) 232 { 233 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 234 int reg = kcontrol->private_value & 0xff; 235 int shift = (kcontrol->private_value >> 8) & 0xff; 236 int invert = (kcontrol->private_value >> 16) & 1; 237 int mask = 1 << shift; 238 int val, changed; 239 unsigned long flags; 240 241 spin_lock_irqsave(&chip->reg_lock, flags); 242 val = chip->awacs_reg[reg] & ~mask; 243 if (ucontrol->value.integer.value[0] != invert) 244 val |= mask; 245 changed = chip->awacs_reg[reg] != val; 246 if (changed) 247 snd_pmac_awacs_write_reg(chip, reg, val); 248 spin_unlock_irqrestore(&chip->reg_lock, flags); 249 return changed; 250 } 251 252 #define AWACS_SWITCH(xname, xreg, xshift, xinvert) \ 253 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 254 .info = snd_pmac_boolean_mono_info, \ 255 .get = snd_pmac_awacs_get_switch, \ 256 .put = snd_pmac_awacs_put_switch, \ 257 .private_value = (xreg) | ((xshift) << 8) | ((xinvert) << 16) } 258 259 260 #ifdef PMAC_AMP_AVAIL 261 /* 262 * controls for perch/whisper extension cards, e.g. G3 desktop 263 * 264 * TDA7433 connected via i2c address 0x45 (= 0x8a), 265 * accessed through cuda 266 */ 267 static void awacs_set_cuda(int reg, int val) 268 { 269 struct adb_request req; 270 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a, reg, val); 271 while (! req.complete) 272 cuda_poll(); 273 } 274 275 /* 276 * level = 0 - 14, 7 = 0 dB 277 */ 278 static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble) 279 { 280 amp->amp_tone[0] = bass; 281 amp->amp_tone[1] = treble; 282 if (bass > 7) 283 bass = (14 - bass) + 8; 284 if (treble > 7) 285 treble = (14 - treble) + 8; 286 awacs_set_cuda(2, (bass << 4) | treble); 287 } 288 289 /* 290 * vol = 0 - 31 (attenuation), 32 = mute bit, stereo 291 */ 292 static int awacs_amp_set_vol(struct awacs_amp *amp, int index, int lvol, int rvol, 293 int do_check) 294 { 295 if (do_check && amp->amp_vol[index][0] == lvol && 296 amp->amp_vol[index][1] == rvol) 297 return 0; 298 awacs_set_cuda(3 + index, lvol); 299 awacs_set_cuda(5 + index, rvol); 300 amp->amp_vol[index][0] = lvol; 301 amp->amp_vol[index][1] = rvol; 302 return 1; 303 } 304 305 /* 306 * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB 307 */ 308 static void awacs_amp_set_master(struct awacs_amp *amp, int vol) 309 { 310 amp->amp_master = vol; 311 if (vol <= 79) 312 vol = 32 + (79 - vol); 313 else 314 vol = 32 - (vol - 79); 315 awacs_set_cuda(1, vol); 316 } 317 318 static void awacs_amp_free(struct snd_pmac *chip) 319 { 320 struct awacs_amp *amp = chip->mixer_data; 321 snd_assert(amp, return); 322 kfree(amp); 323 chip->mixer_data = NULL; 324 chip->mixer_free = NULL; 325 } 326 327 328 /* 329 * mixer controls 330 */ 331 static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol, 332 struct snd_ctl_elem_info *uinfo) 333 { 334 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 335 uinfo->count = 2; 336 uinfo->value.integer.min = 0; 337 uinfo->value.integer.max = 31; 338 return 0; 339 } 340 341 static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol, 342 struct snd_ctl_elem_value *ucontrol) 343 { 344 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 345 int index = kcontrol->private_value; 346 struct awacs_amp *amp = chip->mixer_data; 347 snd_assert(amp, return -EINVAL); 348 snd_assert(index >= 0 && index <= 1, return -EINVAL); 349 ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31); 350 ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31); 351 return 0; 352 } 353 354 static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol, 355 struct snd_ctl_elem_value *ucontrol) 356 { 357 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 358 int index = kcontrol->private_value; 359 int vol[2]; 360 struct awacs_amp *amp = chip->mixer_data; 361 snd_assert(amp, return -EINVAL); 362 snd_assert(index >= 0 && index <= 1, return -EINVAL); 363 364 vol[0] = (31 - (ucontrol->value.integer.value[0] & 31)) | (amp->amp_vol[index][0] & 32); 365 vol[1] = (31 - (ucontrol->value.integer.value[1] & 31)) | (amp->amp_vol[index][1] & 32); 366 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1); 367 } 368 369 static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol, 370 struct snd_ctl_elem_value *ucontrol) 371 { 372 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 373 int index = kcontrol->private_value; 374 struct awacs_amp *amp = chip->mixer_data; 375 snd_assert(amp, return -EINVAL); 376 snd_assert(index >= 0 && index <= 1, return -EINVAL); 377 ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32) ? 0 : 1; 378 ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32) ? 0 : 1; 379 return 0; 380 } 381 382 static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol, 383 struct snd_ctl_elem_value *ucontrol) 384 { 385 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 386 int index = kcontrol->private_value; 387 int vol[2]; 388 struct awacs_amp *amp = chip->mixer_data; 389 snd_assert(amp, return -EINVAL); 390 snd_assert(index >= 0 && index <= 1, return -EINVAL); 391 392 vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32) | (amp->amp_vol[index][0] & 31); 393 vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32) | (amp->amp_vol[index][1] & 31); 394 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1); 395 } 396 397 static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol, 398 struct snd_ctl_elem_info *uinfo) 399 { 400 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 401 uinfo->count = 1; 402 uinfo->value.integer.min = 0; 403 uinfo->value.integer.max = 14; 404 return 0; 405 } 406 407 static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol, 408 struct snd_ctl_elem_value *ucontrol) 409 { 410 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 411 int index = kcontrol->private_value; 412 struct awacs_amp *amp = chip->mixer_data; 413 snd_assert(amp, return -EINVAL); 414 snd_assert(index >= 0 && index <= 1, return -EINVAL); 415 ucontrol->value.integer.value[0] = amp->amp_tone[index]; 416 return 0; 417 } 418 419 static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol, 420 struct snd_ctl_elem_value *ucontrol) 421 { 422 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 423 int index = kcontrol->private_value; 424 struct awacs_amp *amp = chip->mixer_data; 425 unsigned int val; 426 snd_assert(amp, return -EINVAL); 427 snd_assert(index >= 0 && index <= 1, return -EINVAL); 428 val = ucontrol->value.integer.value[0]; 429 if (val > 14) 430 return -EINVAL; 431 if (val != amp->amp_tone[index]) { 432 amp->amp_tone[index] = val; 433 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]); 434 return 1; 435 } 436 return 0; 437 } 438 439 static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol, 440 struct snd_ctl_elem_info *uinfo) 441 { 442 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 443 uinfo->count = 1; 444 uinfo->value.integer.min = 0; 445 uinfo->value.integer.max = 99; 446 return 0; 447 } 448 449 static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol, 450 struct snd_ctl_elem_value *ucontrol) 451 { 452 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 453 struct awacs_amp *amp = chip->mixer_data; 454 snd_assert(amp, return -EINVAL); 455 ucontrol->value.integer.value[0] = amp->amp_master; 456 return 0; 457 } 458 459 static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol, 460 struct snd_ctl_elem_value *ucontrol) 461 { 462 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 463 struct awacs_amp *amp = chip->mixer_data; 464 unsigned int val; 465 snd_assert(amp, return -EINVAL); 466 val = ucontrol->value.integer.value[0]; 467 if (val > 99) 468 return -EINVAL; 469 if (val != amp->amp_master) { 470 amp->amp_master = val; 471 awacs_amp_set_master(amp, amp->amp_master); 472 return 1; 473 } 474 return 0; 475 } 476 477 #define AMP_CH_SPK 0 478 #define AMP_CH_HD 1 479 480 static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = { 481 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 482 .name = "PC Speaker Playback Volume", 483 .info = snd_pmac_awacs_info_volume_amp, 484 .get = snd_pmac_awacs_get_volume_amp, 485 .put = snd_pmac_awacs_put_volume_amp, 486 .private_value = AMP_CH_SPK, 487 }, 488 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 489 .name = "Headphone Playback Volume", 490 .info = snd_pmac_awacs_info_volume_amp, 491 .get = snd_pmac_awacs_get_volume_amp, 492 .put = snd_pmac_awacs_put_volume_amp, 493 .private_value = AMP_CH_HD, 494 }, 495 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 496 .name = "Tone Control - Bass", 497 .info = snd_pmac_awacs_info_tone_amp, 498 .get = snd_pmac_awacs_get_tone_amp, 499 .put = snd_pmac_awacs_put_tone_amp, 500 .private_value = 0, 501 }, 502 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 503 .name = "Tone Control - Treble", 504 .info = snd_pmac_awacs_info_tone_amp, 505 .get = snd_pmac_awacs_get_tone_amp, 506 .put = snd_pmac_awacs_put_tone_amp, 507 .private_value = 1, 508 }, 509 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 510 .name = "Amp Master Playback Volume", 511 .info = snd_pmac_awacs_info_master_amp, 512 .get = snd_pmac_awacs_get_master_amp, 513 .put = snd_pmac_awacs_put_master_amp, 514 }, 515 }; 516 517 static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = { 518 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 519 .name = "Headphone Playback Switch", 520 .info = snd_pmac_boolean_stereo_info, 521 .get = snd_pmac_awacs_get_switch_amp, 522 .put = snd_pmac_awacs_put_switch_amp, 523 .private_value = AMP_CH_HD, 524 }; 525 526 static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = { 527 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 528 .name = "PC Speaker Playback Switch", 529 .info = snd_pmac_boolean_stereo_info, 530 .get = snd_pmac_awacs_get_switch_amp, 531 .put = snd_pmac_awacs_put_switch_amp, 532 .private_value = AMP_CH_SPK, 533 }; 534 535 #endif /* PMAC_AMP_AVAIL */ 536 537 538 /* 539 * mic boost for screamer 540 */ 541 static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol, 542 struct snd_ctl_elem_info *uinfo) 543 { 544 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 545 uinfo->count = 1; 546 uinfo->value.integer.min = 0; 547 uinfo->value.integer.max = 2; 548 return 0; 549 } 550 551 static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol, 552 struct snd_ctl_elem_value *ucontrol) 553 { 554 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 555 int val; 556 unsigned long flags; 557 558 spin_lock_irqsave(&chip->reg_lock, flags); 559 if (chip->awacs_reg[6] & MASK_MIC_BOOST) 560 val = 2; 561 else if (chip->awacs_reg[0] & MASK_GAINLINE) 562 val = 1; 563 else 564 val = 0; 565 spin_unlock_irqrestore(&chip->reg_lock, flags); 566 ucontrol->value.integer.value[0] = val; 567 return 0; 568 } 569 570 static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol, 571 struct snd_ctl_elem_value *ucontrol) 572 { 573 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol); 574 int changed = 0; 575 int val0, val6; 576 unsigned long flags; 577 578 spin_lock_irqsave(&chip->reg_lock, flags); 579 val0 = chip->awacs_reg[0] & ~MASK_GAINLINE; 580 val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST; 581 if (ucontrol->value.integer.value[0] > 0) { 582 val0 |= MASK_GAINLINE; 583 if (ucontrol->value.integer.value[0] > 1) 584 val6 |= MASK_MIC_BOOST; 585 } 586 if (val0 != chip->awacs_reg[0]) { 587 snd_pmac_awacs_write_reg(chip, 0, val0); 588 changed = 1; 589 } 590 if (val6 != chip->awacs_reg[6]) { 591 snd_pmac_awacs_write_reg(chip, 6, val6); 592 changed = 1; 593 } 594 spin_unlock_irqrestore(&chip->reg_lock, flags); 595 return changed; 596 } 597 598 /* 599 * lists of mixer elements 600 */ 601 static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = { 602 AWACS_VOLUME("Master Playback Volume", 2, 6, 1), 603 AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0), 604 AWACS_VOLUME("Capture Volume", 0, 4, 0), 605 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0), 606 }; 607 608 /* FIXME: is this correct order? 609 * screamer (powerbook G3 pismo) seems to have different bits... 610 */ 611 static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = { 612 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0), 613 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0), 614 }; 615 616 static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = { 617 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0), 618 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0), 619 }; 620 621 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata = 622 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1); 623 624 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = { 625 AWACS_SWITCH("Mic Boost", 0, SHIFT_GAINLINE, 0), 626 }; 627 628 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = { 629 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 630 .name = "Mic Boost", 631 .info = snd_pmac_screamer_mic_boost_info, 632 .get = snd_pmac_screamer_mic_boost_get, 633 .put = snd_pmac_screamer_mic_boost_put, 634 }, 635 }; 636 637 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = { 638 AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1), 639 }; 640 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata = 641 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1); 642 643 644 /* 645 * add new mixer elements to the card 646 */ 647 static int build_mixers(struct snd_pmac *chip, int nums, struct snd_kcontrol_new *mixers) 648 { 649 int i, err; 650 651 for (i = 0; i < nums; i++) { 652 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip))) < 0) 653 return err; 654 } 655 return 0; 656 } 657 658 659 /* 660 * restore all registers 661 */ 662 static void awacs_restore_all_regs(struct snd_pmac *chip) 663 { 664 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]); 665 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]); 666 snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]); 667 snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]); 668 if (chip->model == PMAC_SCREAMER) { 669 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]); 670 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]); 671 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]); 672 } 673 } 674 675 #ifdef CONFIG_PM 676 static void snd_pmac_awacs_suspend(struct snd_pmac *chip) 677 { 678 snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1] 679 | MASK_AMUTE | MASK_CMUTE)); 680 } 681 682 static void snd_pmac_awacs_resume(struct snd_pmac *chip) 683 { 684 if (machine_is_compatible("PowerBook3,1") 685 || machine_is_compatible("PowerBook3,2")) { 686 msleep(100); 687 snd_pmac_awacs_write_reg(chip, 1, 688 chip->awacs_reg[1] & ~MASK_PAROUT); 689 msleep(300); 690 } 691 692 awacs_restore_all_regs(chip); 693 if (chip->model == PMAC_SCREAMER) { 694 /* reset power bits in reg 6 */ 695 mdelay(5); 696 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]); 697 } 698 screamer_recalibrate(chip); 699 #ifdef PMAC_AMP_AVAIL 700 if (chip->mixer_data) { 701 struct awacs_amp *amp = chip->mixer_data; 702 awacs_amp_set_vol(amp, 0, amp->amp_vol[0][0], amp->amp_vol[0][1], 0); 703 awacs_amp_set_vol(amp, 1, amp->amp_vol[1][0], amp->amp_vol[1][1], 0); 704 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]); 705 awacs_amp_set_master(amp, amp->amp_master); 706 } 707 #endif 708 } 709 #endif /* CONFIG_PM */ 710 711 #ifdef PMAC_SUPPORT_AUTOMUTE 712 /* 713 * auto-mute stuffs 714 */ 715 static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip) 716 { 717 return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0; 718 } 719 720 #ifdef PMAC_AMP_AVAIL 721 static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute) 722 { 723 int vol[2]; 724 vol[0] = amp->amp_vol[index][0] & 31; 725 vol[1] = amp->amp_vol[index][1] & 31; 726 if (mute) { 727 vol[0] |= 32; 728 vol[1] |= 32; 729 } 730 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1); 731 } 732 #endif 733 734 static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify) 735 { 736 if (chip->auto_mute) { 737 #ifdef PMAC_AMP_AVAIL 738 if (chip->mixer_data) { 739 struct awacs_amp *amp = chip->mixer_data; 740 int changed; 741 if (snd_pmac_awacs_detect_headphone(chip)) { 742 changed = toggle_amp_mute(amp, AMP_CH_HD, 0); 743 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1); 744 } else { 745 changed = toggle_amp_mute(amp, AMP_CH_HD, 1); 746 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0); 747 } 748 if (do_notify && ! changed) 749 return; 750 } else 751 #endif 752 { 753 int reg = chip->awacs_reg[1] | (MASK_HDMUTE|MASK_SPKMUTE); 754 if (snd_pmac_awacs_detect_headphone(chip)) 755 reg &= ~MASK_HDMUTE; 756 else 757 reg &= ~MASK_SPKMUTE; 758 if (do_notify && reg == chip->awacs_reg[1]) 759 return; 760 snd_pmac_awacs_write_reg(chip, 1, reg); 761 } 762 if (do_notify) { 763 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 764 &chip->master_sw_ctl->id); 765 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 766 &chip->speaker_sw_ctl->id); 767 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 768 &chip->hp_detect_ctl->id); 769 } 770 } 771 } 772 #endif /* PMAC_SUPPORT_AUTOMUTE */ 773 774 775 /* 776 * initialize chip 777 */ 778 int __init 779 snd_pmac_awacs_init(struct snd_pmac *chip) 780 { 781 int err, vol; 782 783 /* looks like MASK_GAINLINE triggers something, so we set here 784 * as start-up 785 */ 786 chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE; 787 chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE; 788 /* FIXME: Only machines with external SRS module need MASK_PAROUT */ 789 if (chip->has_iic || chip->device_id == 0x5 || 790 /*chip->_device_id == 0x8 || */ 791 chip->device_id == 0xb) 792 chip->awacs_reg[1] |= MASK_PAROUT; 793 /* get default volume from nvram */ 794 // vol = (~nvram_read_byte(0x1308) & 7) << 1; 795 // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 ); 796 vol = 0x0f; /* no, on alsa, muted as default */ 797 vol = vol + (vol << 6); 798 chip->awacs_reg[2] = vol; 799 chip->awacs_reg[4] = vol; 800 if (chip->model == PMAC_SCREAMER) { 801 chip->awacs_reg[5] = vol; /* FIXME: screamer has loopthru vol control */ 802 chip->awacs_reg[6] = MASK_MIC_BOOST; /* FIXME: maybe should be vol << 3 for PCMCIA speaker */ 803 chip->awacs_reg[7] = 0; 804 } 805 806 awacs_restore_all_regs(chip); 807 chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf; 808 screamer_recalibrate(chip); 809 810 chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf; 811 #ifdef PMAC_AMP_AVAIL 812 if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) { 813 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL); 814 if (! amp) 815 return -ENOMEM; 816 chip->mixer_data = amp; 817 chip->mixer_free = awacs_amp_free; 818 awacs_amp_set_vol(amp, 0, 63, 63, 0); /* mute and zero vol */ 819 awacs_amp_set_vol(amp, 1, 63, 63, 0); 820 awacs_amp_set_tone(amp, 7, 7); /* 0 dB */ 821 awacs_amp_set_master(amp, 79); /* 0 dB */ 822 } 823 #endif /* PMAC_AMP_AVAIL */ 824 825 if (chip->hp_stat_mask == 0) { 826 /* set headphone-jack detection bit */ 827 switch (chip->model) { 828 case PMAC_AWACS: 829 chip->hp_stat_mask = 0x04; 830 break; 831 case PMAC_SCREAMER: 832 switch (chip->device_id) { 833 case 0x08: 834 /* 1 = side jack, 2 = front jack */ 835 chip->hp_stat_mask = 0x03; 836 break; 837 case 0x00: 838 case 0x05: 839 chip->hp_stat_mask = 0x04; 840 break; 841 default: 842 chip->hp_stat_mask = 0x08; 843 break; 844 } 845 break; 846 default: 847 snd_BUG(); 848 break; 849 } 850 } 851 852 /* 853 * build mixers 854 */ 855 strcpy(chip->card->mixername, "PowerMac AWACS"); 856 857 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers), 858 snd_pmac_awacs_mixers)) < 0) 859 return err; 860 if (chip->model == PMAC_SCREAMER) 861 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2), 862 snd_pmac_screamer_mixers2); 863 else 864 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2), 865 snd_pmac_awacs_mixers2); 866 if (err < 0) 867 return err; 868 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_master_sw, chip); 869 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0) 870 return err; 871 #ifdef PMAC_AMP_AVAIL 872 if (chip->mixer_data) { 873 /* use amplifier. the signal is connected from route A 874 * to the amp. the amp has its headphone and speaker 875 * volumes and mute switches, so we use them instead of 876 * screamer registers. 877 * in this case, it seems the route C is not used. 878 */ 879 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol), 880 snd_pmac_awacs_amp_vol)) < 0) 881 return err; 882 /* overwrite */ 883 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw, chip); 884 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0) 885 return err; 886 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw, chip); 887 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0) 888 return err; 889 } else 890 #endif /* PMAC_AMP_AVAIL */ 891 { 892 /* route A = headphone, route C = speaker */ 893 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol), 894 snd_pmac_awacs_speaker_vol)) < 0) 895 return err; 896 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_speaker_sw, chip); 897 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0) 898 return err; 899 } 900 901 if (chip->model == PMAC_SCREAMER) { 902 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mic_boost), 903 snd_pmac_screamer_mic_boost)) < 0) 904 return err; 905 } else { 906 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost), 907 snd_pmac_awacs_mic_boost)) < 0) 908 return err; 909 } 910 911 /* 912 * set lowlevel callbacks 913 */ 914 chip->set_format = snd_pmac_awacs_set_format; 915 #ifdef CONFIG_PM 916 chip->suspend = snd_pmac_awacs_suspend; 917 chip->resume = snd_pmac_awacs_resume; 918 #endif 919 #ifdef PMAC_SUPPORT_AUTOMUTE 920 if ((err = snd_pmac_add_automute(chip)) < 0) 921 return err; 922 chip->detect_headphone = snd_pmac_awacs_detect_headphone; 923 chip->update_automute = snd_pmac_awacs_update_automute; 924 snd_pmac_awacs_update_automute(chip, 0); /* update the status only */ 925 #endif 926 if (chip->model == PMAC_SCREAMER) { 927 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]); 928 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]); 929 } 930 931 return 0; 932 } 933