[linux.git] / sound / ppc / burgundy.c

/*
 * PMac Burgundy lowlevel functions
 *
 * Copyright (c) by Takashi Iwai <[email protected]>
 * code based on dmasound.c.
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <asm/io.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <sound/core.h>
#include "pmac.h"
#include "burgundy.h"


/* Waits for busy flag to clear */
static inline void
snd_pmac_burgundy_busy_wait(struct snd_pmac *chip)
{
	int timeout = 50;
	while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--)
		udelay(1);
	if (! timeout)
		printk(KERN_DEBUG "burgundy_busy_wait: timeout\n");
}

static inline void
snd_pmac_burgundy_extend_wait(struct snd_pmac *chip)
{
	int timeout;
	timeout = 50;
	while (!(in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
		udelay(1);
	if (! timeout)
		printk(KERN_DEBUG "burgundy_extend_wait: timeout #1\n");
	timeout = 50;
	while ((in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
		udelay(1);
	if (! timeout)
		printk(KERN_DEBUG "burgundy_extend_wait: timeout #2\n");
}

static void
snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val)
{
	out_le32(&chip->awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff));
	snd_pmac_burgundy_busy_wait(chip);
	out_le32(&chip->awacs->codec_ctrl, addr + 0x200d00 +((val>>8) & 0xff));
	snd_pmac_burgundy_busy_wait(chip);
	out_le32(&chip->awacs->codec_ctrl, addr + 0x200e00 +((val>>16) & 0xff));
	snd_pmac_burgundy_busy_wait(chip);
	out_le32(&chip->awacs->codec_ctrl, addr + 0x200f00 +((val>>24) & 0xff));
	snd_pmac_burgundy_busy_wait(chip);
}

static unsigned
snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr)
{
	unsigned val = 0;
	unsigned long flags;

	spin_lock_irqsave(&chip->reg_lock, flags);

	out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
	snd_pmac_burgundy_busy_wait(chip);
	snd_pmac_burgundy_extend_wait(chip);
	val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;

	out_le32(&chip->awacs->codec_ctrl, addr + 0x100100);
	snd_pmac_burgundy_busy_wait(chip);
	snd_pmac_burgundy_extend_wait(chip);
	val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<8;

	out_le32(&chip->awacs->codec_ctrl, addr + 0x100200);
	snd_pmac_burgundy_busy_wait(chip);
	snd_pmac_burgundy_extend_wait(chip);
	val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<16;

	out_le32(&chip->awacs->codec_ctrl, addr + 0x100300);
	snd_pmac_burgundy_busy_wait(chip);
	snd_pmac_burgundy_extend_wait(chip);
	val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<24;

	spin_unlock_irqrestore(&chip->reg_lock, flags);

	return val;
}

static void
snd_pmac_burgundy_wcb(struct snd_pmac *chip, unsigned int addr, unsigned int val)
{
	out_le32(&chip->awacs->codec_ctrl, addr + 0x300000 + (val & 0xff));
	snd_pmac_burgundy_busy_wait(chip);
}

static unsigned
snd_pmac_burgundy_rcb(struct snd_pmac *chip, unsigned int addr)
{
	unsigned val = 0;
	unsigned long flags;

	spin_lock_irqsave(&chip->reg_lock, flags);

	out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
	snd_pmac_burgundy_busy_wait(chip);
	snd_pmac_burgundy_extend_wait(chip);
	val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;

	spin_unlock_irqrestore(&chip->reg_lock, flags);

	return val;
}

/*
 * Burgundy volume: 0 - 100, stereo
 */
static void
snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address,
			       long *volume, int shift)
{
	int hardvolume, lvolume, rvolume;

	if (volume[0] < 0 || volume[0] > 100 ||
	    volume[1] < 0 || volume[1] > 100)
		return; /* -EINVAL */
	lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;
	rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;

	hardvolume = lvolume + (rvolume << shift);
	if (shift == 8)
		hardvolume |= hardvolume << 16;

	snd_pmac_burgundy_wcw(chip, address, hardvolume);
}

static void
snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address,
			      long *volume, int shift)
{
	int wvolume;

	wvolume = snd_pmac_burgundy_rcw(chip, address);

	volume[0] = wvolume & 0xff;
	if (volume[0] >= BURGUNDY_VOLUME_OFFSET)
		volume[0] -= BURGUNDY_VOLUME_OFFSET;
	else
		volume[0] = 0;
	volume[1] = (wvolume >> shift) & 0xff;
	if (volume[1] >= BURGUNDY_VOLUME_OFFSET)
		volume[1] -= BURGUNDY_VOLUME_OFFSET;
	else
		volume[1] = 0;
}


/*
 */

#define BASE2ADDR(base)	((base) << 12)
#define ADDR2BASE(addr)	((addr) >> 12)

static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol,
					 struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = 2;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 100;
	return 0;
}

static int snd_pmac_burgundy_get_volume(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
	int shift = (kcontrol->private_value >> 8) & 0xff;
	snd_pmac_burgundy_read_volume(chip, addr, ucontrol->value.integer.value,
				      shift);
	return 0;
}

static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
	int shift = (kcontrol->private_value >> 8) & 0xff;
	long nvoices[2];

	snd_pmac_burgundy_write_volume(chip, addr, ucontrol->value.integer.value,
				       shift);
	snd_pmac_burgundy_read_volume(chip, addr, nvoices, shift);
	return (nvoices[0] != ucontrol->value.integer.value[0] ||
		nvoices[1] != ucontrol->value.integer.value[1]);
}

#define BURGUNDY_VOLUME(xname, xindex, addr, shift) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
  .info = snd_pmac_burgundy_info_volume,\
  .get = snd_pmac_burgundy_get_volume,\
  .put = snd_pmac_burgundy_put_volume,\
  .private_value = ((ADDR2BASE(addr) & 0xff) | ((shift) << 8)) }

/* lineout/speaker */

static int snd_pmac_burgundy_info_switch_out(struct snd_kcontrol *kcontrol,
					     struct snd_ctl_elem_info *uinfo)
{
	int stereo = (kcontrol->private_value >> 24) & 1;
	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
	uinfo->count = stereo + 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 1;
	return 0;
}

static int snd_pmac_burgundy_get_switch_out(struct snd_kcontrol *kcontrol,
					    struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
	int lmask = kcontrol->private_value & 0xff;
	int rmask = (kcontrol->private_value >> 8) & 0xff;
	int stereo = (kcontrol->private_value >> 24) & 1;
	int val = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
	ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0;
	if (stereo)
		ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0;
	return 0;
}

static int snd_pmac_burgundy_put_switch_out(struct snd_kcontrol *kcontrol,
					    struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
	int lmask = kcontrol->private_value & 0xff;
	int rmask = (kcontrol->private_value >> 8) & 0xff;
	int stereo = (kcontrol->private_value >> 24) & 1;
	int val, oval;
	oval = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
	val = oval & ~(lmask | rmask);
	if (ucontrol->value.integer.value[0])
		val |= lmask;
	if (stereo && ucontrol->value.integer.value[1])
		val |= rmask;
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, val);
	return val != oval;
}

#define BURGUNDY_OUTPUT_SWITCH(xname, xindex, lmask, rmask, stereo) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
  .info = snd_pmac_burgundy_info_switch_out,\
  .get = snd_pmac_burgundy_get_switch_out,\
  .put = snd_pmac_burgundy_put_switch_out,\
  .private_value = ((lmask) | ((rmask) << 8) | ((stereo) << 24)) }

/* line/speaker output volume */
static int snd_pmac_burgundy_info_volume_out(struct snd_kcontrol *kcontrol,
					     struct snd_ctl_elem_info *uinfo)
{
	int stereo = (kcontrol->private_value >> 24) & 1;
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = stereo + 1;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 15;
	return 0;
}

static int snd_pmac_burgundy_get_volume_out(struct snd_kcontrol *kcontrol,
					    struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
	int stereo = (kcontrol->private_value >> 24) & 1;
	int oval;

	oval = ~snd_pmac_burgundy_rcb(chip, addr) & 0xff;
	ucontrol->value.integer.value[0] = oval & 0xf;
	if (stereo)
		ucontrol->value.integer.value[1] = (oval >> 4) & 0xf;
	return 0;
}

static int snd_pmac_burgundy_put_volume_out(struct snd_kcontrol *kcontrol,
					    struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
	int stereo = (kcontrol->private_value >> 24) & 1;
	unsigned int oval, val;

	oval = ~snd_pmac_burgundy_rcb(chip, addr) & 0xff;
	val = ucontrol->value.integer.value[0] & 15;
	if (stereo)
		val |= (ucontrol->value.integer.value[1] & 15) << 4;
	else
		val |= val << 4;
	val = ~val & 0xff;
	snd_pmac_burgundy_wcb(chip, addr, val);
	return val != oval;
}

#define BURGUNDY_OUTPUT_VOLUME(xname, xindex, addr, stereo) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
  .info = snd_pmac_burgundy_info_volume_out,\
  .get = snd_pmac_burgundy_get_volume_out,\
  .put = snd_pmac_burgundy_put_volume_out,\
  .private_value = (ADDR2BASE(addr) | ((stereo) << 24)) }

static struct snd_kcontrol_new snd_pmac_burgundy_mixers[] __initdata = {
	BURGUNDY_VOLUME("Master Playback Volume", 0, MASK_ADDR_BURGUNDY_MASTER_VOLUME, 8),
	BURGUNDY_VOLUME("Line Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLLINE, 16),
	BURGUNDY_VOLUME("CD Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLCD, 16),
	BURGUNDY_VOLUME("Mic Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLMIC, 16),
	BURGUNDY_OUTPUT_VOLUME("PC Speaker Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENHP, 0),
	/*BURGUNDY_OUTPUT_VOLUME("PCM Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1),*/
	BURGUNDY_OUTPUT_VOLUME("Headphone Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1),
};	
static struct snd_kcontrol_new snd_pmac_burgundy_master_sw __initdata = 
BURGUNDY_OUTPUT_SWITCH("Headphone Playback Switch", 0, BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw __initdata = 
BURGUNDY_OUTPUT_SWITCH("PC Speaker Playback Switch", 0, BURGUNDY_OUTPUT_INTERN, 0, 0);


#ifdef PMAC_SUPPORT_AUTOMUTE
/*
 * auto-mute stuffs
 */
static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip)
{
	return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
}

static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify)
{
	if (chip->auto_mute) {
		int reg, oreg;
		reg = oreg = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
		reg &= ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT | BURGUNDY_OUTPUT_INTERN);
		if (snd_pmac_burgundy_detect_headphone(chip))
			reg |= BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT;
		else
			reg |= BURGUNDY_OUTPUT_INTERN;
		if (do_notify && reg == oreg)
			return;
		snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, reg);
		if (do_notify) {
			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
				       &chip->master_sw_ctl->id);
			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
				       &chip->speaker_sw_ctl->id);
			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
				       &chip->hp_detect_ctl->id);
		}
	}
}
#endif /* PMAC_SUPPORT_AUTOMUTE */


/*
 * initialize burgundy
 */
int __init snd_pmac_burgundy_init(struct snd_pmac *chip)
{
	int i, err;

	/* Checks to see the chip is alive and kicking */
	if ((in_le32(&chip->awacs->codec_ctrl) & MASK_ERRCODE) == 0xf0000) {
		printk(KERN_WARNING "pmac burgundy: disabled by MacOS :-(\n");
		return 1;
	}

	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_OUTPUTENABLES,
			   DEF_BURGUNDY_OUTPUTENABLES);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
			   DEF_BURGUNDY_MORE_OUTPUTENABLES);
	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTSELECTS,
			   DEF_BURGUNDY_OUTPUTSELECTS);

	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL21,
			   DEF_BURGUNDY_INPSEL21);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL3,
			   DEF_BURGUNDY_INPSEL3);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINCD,
			   DEF_BURGUNDY_GAINCD);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINLINE,
			   DEF_BURGUNDY_GAINLINE);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMIC,
			   DEF_BURGUNDY_GAINMIC);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMODEM,
			   DEF_BURGUNDY_GAINMODEM);

	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENSPEAKER,
			   DEF_BURGUNDY_ATTENSPEAKER);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENLINEOUT,
			   DEF_BURGUNDY_ATTENLINEOUT);
	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENHP,
			   DEF_BURGUNDY_ATTENHP);

	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_MASTER_VOLUME,
			   DEF_BURGUNDY_MASTER_VOLUME);
	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLCD,
			   DEF_BURGUNDY_VOLCD);
	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLLINE,
			   DEF_BURGUNDY_VOLLINE);
	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLMIC,
			   DEF_BURGUNDY_VOLMIC);

	if (chip->hp_stat_mask == 0)
		/* set headphone-jack detection bit */
		chip->hp_stat_mask = 0x04;

	/*
	 * build burgundy mixers
	 */
	strcpy(chip->card->mixername, "PowerMac Burgundy");

	for (i = 0; i < ARRAY_SIZE(snd_pmac_burgundy_mixers); i++) {
		if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_pmac_burgundy_mixers[i], chip))) < 0)
			return err;
	}
	chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_burgundy_master_sw, chip);
	if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
		return err;
	chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_burgundy_speaker_sw, chip);
	if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
		return err;
#ifdef PMAC_SUPPORT_AUTOMUTE
	if ((err = snd_pmac_add_automute(chip)) < 0)
		return err;

	chip->detect_headphone = snd_pmac_burgundy_detect_headphone;
	chip->update_automute = snd_pmac_burgundy_update_automute;
	snd_pmac_burgundy_update_automute(chip, 0); /* update the status only */
#endif

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