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