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