[linux-2.6-block.git] / sound / pci / cs5535audio / cs5535audio.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Driver for audio on multifunction CS5535/6 companion device
 * Copyright (C) Jaya Kumar
 *
 * Based on Jaroslav Kysela and Takashi Iwai's examples.
 * This work was sponsored by CIS(M) Sdn Bhd.
 */

#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/io.h>
#include <sound/core.h>
#include <sound/control.h>
#include <sound/pcm.h>
#include <sound/rawmidi.h>
#include <sound/ac97_codec.h>
#include <sound/initval.h>
#include <sound/asoundef.h>
#include "cs5535audio.h"

#define DRIVER_NAME "cs5535audio"

static char *ac97_quirk;
module_param(ac97_quirk, charp, 0444);
MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds.");

static const struct ac97_quirk ac97_quirks[] = {
#if 0 /* Not yet confirmed if all 5536 boards are HP only */
	{
		.subvendor = PCI_VENDOR_ID_AMD, 
		.subdevice = PCI_DEVICE_ID_AMD_CS5536_AUDIO, 
		.name = "AMD RDK",     
		.type = AC97_TUNE_HP_ONLY
	},
#endif
	{}
};

static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;

module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "Index value for " DRIVER_NAME);
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string for " DRIVER_NAME);
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "Enable " DRIVER_NAME);

static const struct pci_device_id snd_cs5535audio_ids[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO) },
	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO) },
	{}
};

MODULE_DEVICE_TABLE(pci, snd_cs5535audio_ids);

static void wait_till_cmd_acked(struct cs5535audio *cs5535au, unsigned long timeout)
{
	unsigned int tmp;
	do {
		tmp = cs_readl(cs5535au, ACC_CODEC_CNTL);
		if (!(tmp & CMD_NEW))
			break;
		udelay(1);
	} while (--timeout);
	if (!timeout)
		dev_err(cs5535au->card->dev,
			"Failure writing to cs5535 codec\n");
}

static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
						 unsigned short reg)
{
	unsigned int regdata;
	unsigned int timeout;
	unsigned int val;

	regdata = ((unsigned int) reg) << 24;
	regdata |= ACC_CODEC_CNTL_RD_CMD;
	regdata |= CMD_NEW;

	cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
	wait_till_cmd_acked(cs5535au, 50);

	timeout = 50;
	do {
		val = cs_readl(cs5535au, ACC_CODEC_STATUS);
		if ((val & STS_NEW) && reg == (val >> 24))
			break;
		udelay(1);
	} while (--timeout);
	if (!timeout)
		dev_err(cs5535au->card->dev,
			"Failure reading codec reg 0x%x, Last value=0x%x\n",
			reg, val);

	return (unsigned short) val;
}

static void snd_cs5535audio_codec_write(struct cs5535audio *cs5535au,
					unsigned short reg, unsigned short val)
{
	unsigned int regdata;

	regdata = ((unsigned int) reg) << 24;
	regdata |= val;
	regdata &= CMD_MASK;
	regdata |= CMD_NEW;
	regdata &= ACC_CODEC_CNTL_WR_CMD;

	cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
	wait_till_cmd_acked(cs5535au, 50);
}

static void snd_cs5535audio_ac97_codec_write(struct snd_ac97 *ac97,
					     unsigned short reg, unsigned short val)
{
	struct cs5535audio *cs5535au = ac97->private_data;
	snd_cs5535audio_codec_write(cs5535au, reg, val);
}

static unsigned short snd_cs5535audio_ac97_codec_read(struct snd_ac97 *ac97,
						      unsigned short reg)
{
	struct cs5535audio *cs5535au = ac97->private_data;
	return snd_cs5535audio_codec_read(cs5535au, reg);
}

static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
{
	struct snd_card *card = cs5535au->card;
	struct snd_ac97_bus *pbus;
	struct snd_ac97_template ac97;
	int err;
	static struct snd_ac97_bus_ops ops = {
		.write = snd_cs5535audio_ac97_codec_write,
		.read = snd_cs5535audio_ac97_codec_read,
	};

	if ((err = snd_ac97_bus(card, 0, &ops, NULL, &pbus)) < 0)
		return err;

	memset(&ac97, 0, sizeof(ac97));
	ac97.scaps = AC97_SCAP_AUDIO | AC97_SCAP_SKIP_MODEM
			| AC97_SCAP_POWER_SAVE;
	ac97.private_data = cs5535au;
	ac97.pci = cs5535au->pci;

	/* set any OLPC-specific scaps */
	olpc_prequirks(card, &ac97);

	if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
		dev_err(card->dev, "mixer failed\n");
		return err;
	}

	snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);

	err = olpc_quirks(card, cs5535au->ac97);
	if (err < 0) {
		dev_err(card->dev, "olpc quirks failed\n");
		return err;
	}

	return 0;
}

static void process_bm0_irq(struct cs5535audio *cs5535au)
{
	u8 bm_stat;
	spin_lock(&cs5535au->reg_lock);
	bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS);
	spin_unlock(&cs5535au->reg_lock);
	if (bm_stat & EOP) {
		snd_pcm_period_elapsed(cs5535au->playback_substream);
	} else {
		dev_err(cs5535au->card->dev,
			"unexpected bm0 irq src, bm_stat=%x\n",
			bm_stat);
	}
}

static void process_bm1_irq(struct cs5535audio *cs5535au)
{
	u8 bm_stat;
	spin_lock(&cs5535au->reg_lock);
	bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS);
	spin_unlock(&cs5535au->reg_lock);
	if (bm_stat & EOP)
		snd_pcm_period_elapsed(cs5535au->capture_substream);
}

static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id)
{
	u16 acc_irq_stat;
	unsigned char count;
	struct cs5535audio *cs5535au = dev_id;

	if (cs5535au == NULL)
		return IRQ_NONE;

	acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS);

	if (!acc_irq_stat)
		return IRQ_NONE;
	for (count = 0; count < 4; count++) {
		if (acc_irq_stat & (1 << count)) {
			switch (count) {
			case IRQ_STS:
				cs_readl(cs5535au, ACC_GPIO_STATUS);
				break;
			case WU_IRQ_STS:
				cs_readl(cs5535au, ACC_GPIO_STATUS);
				break;
			case BM0_IRQ_STS:
				process_bm0_irq(cs5535au);
				break;
			case BM1_IRQ_STS:
				process_bm1_irq(cs5535au);
				break;
			default:
				dev_err(cs5535au->card->dev,
					"Unexpected irq src: 0x%x\n",
					acc_irq_stat);
				break;
			}
		}
	}
	return IRQ_HANDLED;
}

static int snd_cs5535audio_free(struct cs5535audio *cs5535au)
{
	synchronize_irq(cs5535au->irq);
	pci_set_power_state(cs5535au->pci, PCI_D3hot);

	if (cs5535au->irq >= 0)
		free_irq(cs5535au->irq, cs5535au);

	pci_release_regions(cs5535au->pci);
	pci_disable_device(cs5535au->pci);
	kfree(cs5535au);
	return 0;
}

static int snd_cs5535audio_dev_free(struct snd_device *device)
{
	struct cs5535audio *cs5535au = device->device_data;
	return snd_cs5535audio_free(cs5535au);
}

static int snd_cs5535audio_create(struct snd_card *card,
				  struct pci_dev *pci,
				  struct cs5535audio **rcs5535au)
{
	struct cs5535audio *cs5535au;

	int err;
	static struct snd_device_ops ops = {
		.dev_free =	snd_cs5535audio_dev_free,
	};

	*rcs5535au = NULL;
	if ((err = pci_enable_device(pci)) < 0)
		return err;

	if (dma_set_mask(&pci->dev, DMA_BIT_MASK(32)) < 0 ||
	    dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(32)) < 0) {
		dev_warn(card->dev, "unable to get 32bit dma\n");
		err = -ENXIO;
		goto pcifail;
	}

	cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
	if (cs5535au == NULL) {
		err = -ENOMEM;
		goto pcifail;
	}

	spin_lock_init(&cs5535au->reg_lock);
	cs5535au->card = card;
	cs5535au->pci = pci;
	cs5535au->irq = -1;

	if ((err = pci_request_regions(pci, "CS5535 Audio")) < 0) {
		kfree(cs5535au);
		goto pcifail;
	}

	cs5535au->port = pci_resource_start(pci, 0);

	if (request_irq(pci->irq, snd_cs5535audio_interrupt,
			IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
		dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
		err = -EBUSY;
		goto sndfail;
	}

	cs5535au->irq = pci->irq;
	pci_set_master(pci);

	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
				  cs5535au, &ops)) < 0)
		goto sndfail;

	*rcs5535au = cs5535au;
	return 0;

sndfail: /* leave the device alive, just kill the snd */
	snd_cs5535audio_free(cs5535au);
	return err;

pcifail:
	pci_disable_device(pci);
	return err;
}

static int snd_cs5535audio_probe(struct pci_dev *pci,
				 const struct pci_device_id *pci_id)
{
	static int dev;
	struct snd_card *card;
	struct cs5535audio *cs5535au;
	int err;

	if (dev >= SNDRV_CARDS)
		return -ENODEV;
	if (!enable[dev]) {
		dev++;
		return -ENOENT;
	}

	err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
			   0, &card);
	if (err < 0)
		return err;

	if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0)
		goto probefail_out;

	card->private_data = cs5535au;

	if ((err = snd_cs5535audio_mixer(cs5535au)) < 0)
		goto probefail_out;

	if ((err = snd_cs5535audio_pcm(cs5535au)) < 0)
		goto probefail_out;

	strcpy(card->driver, DRIVER_NAME);

	strcpy(card->shortname, "CS5535 Audio");
	sprintf(card->longname, "%s %s at 0x%lx, irq %i",
		card->shortname, card->driver,
		cs5535au->port, cs5535au->irq);

	if ((err = snd_card_register(card)) < 0)
		goto probefail_out;

	pci_set_drvdata(pci, card);
	dev++;
	return 0;

probefail_out:
	snd_card_free(card);
	return err;
}

static void snd_cs5535audio_remove(struct pci_dev *pci)
{
	olpc_quirks_cleanup();
	snd_card_free(pci_get_drvdata(pci));
}

static struct pci_driver cs5535audio_driver = {
	.name = KBUILD_MODNAME,
	.id_table = snd_cs5535audio_ids,
	.probe = snd_cs5535audio_probe,
	.remove = snd_cs5535audio_remove,
#ifdef CONFIG_PM_SLEEP
	.driver = {
		.pm = &snd_cs5535audio_pm,
	},
#endif
};

module_pci_driver(cs5535audio_driver);

MODULE_AUTHOR("Jaya Kumar");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("CS5535 Audio");
MODULE_SUPPORTED_DEVICE("CS5535 Audio");
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
9b4ffa48	2	/*
9ac25594	3	* Driver for audio on multifunction CS5535/6 companion device
9b4ffa48 JK	4	* Copyright (C) Jaya Kumar
	5	*
	6	* Based on Jaroslav Kysela and Takashi Iwai's examples.
	7	* This work was sponsored by CIS(M) Sdn Bhd.
9b4ffa48 JK	8	*/
	9
	10	#include <linux/delay.h>
	11	#include <linux/interrupt.h>
	12	#include <linux/init.h>
	13	#include <linux/pci.h>
	14	#include <linux/slab.h>
65a77217	15	#include <linux/module.h>
6cbbfe1c	16	#include <linux/io.h>
9b4ffa48 JK	17	#include <sound/core.h>
	18	#include <sound/control.h>
	19	#include <sound/pcm.h>
	20	#include <sound/rawmidi.h>
	21	#include <sound/ac97_codec.h>
	22	#include <sound/initval.h>
	23	#include <sound/asoundef.h>
	24	#include "cs5535audio.h"
	25
	26	#define DRIVER_NAME "cs5535audio"
	27
9ac25594 JK	28	static char *ac97_quirk;
	29	module_param(ac97_quirk, charp, 0444);
	30	MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds.");
	31
eab0fbfa	32	static const struct ac97_quirk ac97_quirks[] = {
9ac25594 JK	33	#if 0 /* Not yet confirmed if all 5536 boards are HP only */
	34	{
	35	.subvendor = PCI_VENDOR_ID_AMD,
	36	.subdevice = PCI_DEVICE_ID_AMD_CS5536_AUDIO,
	37	.name = "AMD RDK",
	38	.type = AC97_TUNE_HP_ONLY
	39	},
	40	#endif
	41	{}
	42	};
9b4ffa48	43
302e4c2f TI	44	static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
302e4c2f TI	45	static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
a67ff6a5	46	static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
9b4ffa48	47
302e4c2f	48	module_param_array(index, int, NULL, 0444);
1dbfd8c5	49	MODULE_PARM_DESC(index, "Index value for " DRIVER_NAME);
302e4c2f	50	module_param_array(id, charp, NULL, 0444);
1dbfd8c5	51	MODULE_PARM_DESC(id, "ID string for " DRIVER_NAME);
302e4c2f TI	52	module_param_array(enable, bool, NULL, 0444);
302e4c2f TI	53	MODULE_PARM_DESC(enable, "Enable " DRIVER_NAME);
1dbfd8c5	54
9baa3c34	55	static const struct pci_device_id snd_cs5535audio_ids[] = {
9ac25594 JK	56	{ PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO) },
9ac25594 JK	57	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO) },
9b4ffa48 JK	58	{}
	59	};
	60
	61	MODULE_DEVICE_TABLE(pci, snd_cs5535audio_ids);
	62
66f8df6b	63	static void wait_till_cmd_acked(struct cs5535audio *cs5535au, unsigned long timeout)
9b4ffa48	64	{
3e873174	65	unsigned int tmp;
9b4ffa48 JK	66	do {
	67	tmp = cs_readl(cs5535au, ACC_CODEC_CNTL);
	68	if (!(tmp & CMD_NEW))
	69	break;
1037593c	70	udelay(1);
9b4ffa48 JK	71	} while (--timeout);
9b4ffa48 JK	72	if (!timeout)
00980aa9 TI	73	dev_err(cs5535au->card->dev,
00980aa9 TI	74	"Failure writing to cs5535 codec\n");
9b4ffa48 JK	75	}
9b4ffa48 JK	76
66f8df6b TI	77	static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
66f8df6b TI	78	unsigned short reg)
9b4ffa48	79	{
3e873174	80	unsigned int regdata;
66f8df6b	81	unsigned int timeout;
3e873174	82	unsigned int val;
9b4ffa48	83
3e873174	84	regdata = ((unsigned int) reg) << 24;
9b4ffa48 JK	85	regdata \|= ACC_CODEC_CNTL_RD_CMD;
	86	regdata \|= CMD_NEW;
	87
	88	cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
1037593c	89	wait_till_cmd_acked(cs5535au, 50);
9b4ffa48 JK	90
	91	timeout = 50;
	92	do {
	93	val = cs_readl(cs5535au, ACC_CODEC_STATUS);
3e873174	94	if ((val & STS_NEW) && reg == (val >> 24))
9b4ffa48	95	break;
1037593c	96	udelay(1);
9b4ffa48 JK	97	} while (--timeout);
9b4ffa48 JK	98	if (!timeout)
00980aa9 TI	99	dev_err(cs5535au->card->dev,
	100	"Failure reading codec reg 0x%x, Last value=0x%x\n",
	101	reg, val);
9b4ffa48	102
3e873174	103	return (unsigned short) val;
9b4ffa48 JK	104	}
9b4ffa48 JK	105
66f8df6b TI	106	static void snd_cs5535audio_codec_write(struct cs5535audio *cs5535au,
66f8df6b TI	107	unsigned short reg, unsigned short val)
9b4ffa48	108	{
3e873174	109	unsigned int regdata;
9b4ffa48	110
3e873174 TI	111	regdata = ((unsigned int) reg) << 24;
3e873174 TI	112	regdata \|= val;
9b4ffa48 JK	113	regdata &= CMD_MASK;
	114	regdata \|= CMD_NEW;
	115	regdata &= ACC_CODEC_CNTL_WR_CMD;
	116
	117	cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
	118	wait_till_cmd_acked(cs5535au, 50);
	119	}
	120
66f8df6b TI	121	static void snd_cs5535audio_ac97_codec_write(struct snd_ac97 *ac97,
66f8df6b TI	122	unsigned short reg, unsigned short val)
9b4ffa48	123	{
66f8df6b	124	struct cs5535audio *cs5535au = ac97->private_data;
9b4ffa48 JK	125	snd_cs5535audio_codec_write(cs5535au, reg, val);
	126	}
	127
66f8df6b TI	128	static unsigned short snd_cs5535audio_ac97_codec_read(struct snd_ac97 *ac97,
66f8df6b TI	129	unsigned short reg)
9b4ffa48	130	{
66f8df6b	131	struct cs5535audio *cs5535au = ac97->private_data;
9b4ffa48 JK	132	return snd_cs5535audio_codec_read(cs5535au, reg);
	133	}
	134
e23e7a14	135	static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
9b4ffa48	136	{
66f8df6b TI	137	struct snd_card *card = cs5535au->card;
	138	struct snd_ac97_bus *pbus;
	139	struct snd_ac97_template ac97;
9b4ffa48	140	int err;
66f8df6b	141	static struct snd_ac97_bus_ops ops = {
9b4ffa48 JK	142	.write = snd_cs5535audio_ac97_codec_write,
	143	.read = snd_cs5535audio_ac97_codec_read,
	144	};
	145
	146	if ((err = snd_ac97_bus(card, 0, &ops, NULL, &pbus)) < 0)
	147	return err;
	148
	149	memset(&ac97, 0, sizeof(ac97));
b035ce0f JK	150	ac97.scaps = AC97_SCAP_AUDIO \| AC97_SCAP_SKIP_MODEM
b035ce0f JK	151	\| AC97_SCAP_POWER_SAVE;
9b4ffa48 JK	152	ac97.private_data = cs5535au;
9b4ffa48 JK	153	ac97.pci = cs5535au->pci;
9b4ffa48	154
3556d184 AS	155	/* set any OLPC-specific scaps */
	156	olpc_prequirks(card, &ac97);
	157
9b4ffa48	158	if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
00980aa9	159	dev_err(card->dev, "mixer failed\n");
9b4ffa48 JK	160	return err;
	161	}
	162
9ac25594 JK	163	snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);
9ac25594 JK	164
57d4bf6d JK	165	err = olpc_quirks(card, cs5535au->ac97);
57d4bf6d JK	166	if (err < 0) {
00980aa9	167	dev_err(card->dev, "olpc quirks failed\n");
57d4bf6d JK	168	return err;
	169	}
	170
9b4ffa48 JK	171	return 0;
	172	}
	173
66f8df6b	174	static void process_bm0_irq(struct cs5535audio *cs5535au)
9b4ffa48 JK	175	{
	176	u8 bm_stat;
	177	spin_lock(&cs5535au->reg_lock);
	178	bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS);
	179	spin_unlock(&cs5535au->reg_lock);
	180	if (bm_stat & EOP) {
9b4ffa48 JK	181	snd_pcm_period_elapsed(cs5535au->playback_substream);
9b4ffa48 JK	182	} else {
00980aa9 TI	183	dev_err(cs5535au->card->dev,
	184	"unexpected bm0 irq src, bm_stat=%x\n",
	185	bm_stat);
9b4ffa48 JK	186	}
	187	}
	188
66f8df6b	189	static void process_bm1_irq(struct cs5535audio *cs5535au)
9b4ffa48 JK	190	{
	191	u8 bm_stat;
	192	spin_lock(&cs5535au->reg_lock);
	193	bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS);
	194	spin_unlock(&cs5535au->reg_lock);
45bf4100	195	if (bm_stat & EOP)
9b4ffa48	196	snd_pcm_period_elapsed(cs5535au->capture_substream);
9b4ffa48 JK	197	}
9b4ffa48 JK	198
7d12e780	199	static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id)
9b4ffa48 JK	200	{
9b4ffa48 JK	201	u16 acc_irq_stat;
9b4ffa48	202	unsigned char count;
66f8df6b	203	struct cs5535audio *cs5535au = dev_id;
9b4ffa48 JK	204
	205	if (cs5535au == NULL)
	206	return IRQ_NONE;
	207
	208	acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS);
	209
	210	if (!acc_irq_stat)
	211	return IRQ_NONE;
4ea24163	212	for (count = 0; count < 4; count++) {
3e873174	213	if (acc_irq_stat & (1 << count)) {
9b4ffa48 JK	214	switch (count) {
	215	case IRQ_STS:
	216	cs_readl(cs5535au, ACC_GPIO_STATUS);
	217	break;
	218	case WU_IRQ_STS:
	219	cs_readl(cs5535au, ACC_GPIO_STATUS);
	220	break;
	221	case BM0_IRQ_STS:
	222	process_bm0_irq(cs5535au);
	223	break;
	224	case BM1_IRQ_STS:
	225	process_bm1_irq(cs5535au);
	226	break;
9b4ffa48	227	default:
00980aa9 TI	228	dev_err(cs5535au->card->dev,
	229	"Unexpected irq src: 0x%x\n",
	230	acc_irq_stat);
9b4ffa48 JK	231	break;
	232	}
	233	}
	234	}
	235	return IRQ_HANDLED;
	236	}
	237
66f8df6b	238	static int snd_cs5535audio_free(struct cs5535audio *cs5535au)
9b4ffa48 JK	239	{
9b4ffa48 JK	240	synchronize_irq(cs5535au->irq);
ec06b2be	241	pci_set_power_state(cs5535au->pci, PCI_D3hot);
9b4ffa48 JK	242
	243	if (cs5535au->irq >= 0)
	244	free_irq(cs5535au->irq, cs5535au);
	245
	246	pci_release_regions(cs5535au->pci);
	247	pci_disable_device(cs5535au->pci);
	248	kfree(cs5535au);
	249	return 0;
	250	}
	251
66f8df6b	252	static int snd_cs5535audio_dev_free(struct snd_device *device)
9b4ffa48	253	{
66f8df6b	254	struct cs5535audio *cs5535au = device->device_data;
9b4ffa48 JK	255	return snd_cs5535audio_free(cs5535au);
	256	}
	257
e23e7a14 BP	258	static int snd_cs5535audio_create(struct snd_card *card,
	259	struct pci_dev *pci,
	260	struct cs5535audio **rcs5535au)
9b4ffa48	261	{
66f8df6b	262	struct cs5535audio *cs5535au;
9b4ffa48 JK	263
9b4ffa48 JK	264	int err;
66f8df6b	265	static struct snd_device_ops ops = {
9b4ffa48 JK	266	.dev_free = snd_cs5535audio_dev_free,
	267	};
	268
	269	*rcs5535au = NULL;
	270	if ((err = pci_enable_device(pci)) < 0)
	271	return err;
	272
412b979c QL	273	if (dma_set_mask(&pci->dev, DMA_BIT_MASK(32)) < 0 \|\|
412b979c QL	274	dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(32)) < 0) {
00980aa9	275	dev_warn(card->dev, "unable to get 32bit dma\n");
9b4ffa48 JK	276	err = -ENXIO;
	277	goto pcifail;
	278	}
	279
	280	cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
	281	if (cs5535au == NULL) {
	282	err = -ENOMEM;
	283	goto pcifail;
	284	}
	285
	286	spin_lock_init(&cs5535au->reg_lock);
	287	cs5535au->card = card;
	288	cs5535au->pci = pci;
	289	cs5535au->irq = -1;
	290
	291	if ((err = pci_request_regions(pci, "CS5535 Audio")) < 0) {
	292	kfree(cs5535au);
	293	goto pcifail;
	294	}
	295
	296	cs5535au->port = pci_resource_start(pci, 0);
	297
	298	if (request_irq(pci->irq, snd_cs5535audio_interrupt,
934c2b6d	299	IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
00980aa9	300	dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
9b4ffa48 JK	301	err = -EBUSY;
	302	goto sndfail;
	303	}
	304
	305	cs5535au->irq = pci->irq;
	306	pci_set_master(pci);
	307
	308	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
66f8df6b	309	cs5535au, &ops)) < 0)
9b4ffa48 JK	310	goto sndfail;
9b4ffa48 JK	311
9b4ffa48 JK	312	*rcs5535au = cs5535au;
	313	return 0;
	314
	315	sndfail: /* leave the device alive, just kill the snd */
	316	snd_cs5535audio_free(cs5535au);
	317	return err;
	318
	319	pcifail:
	320	pci_disable_device(pci);
	321	return err;
	322	}
	323
e23e7a14 BP	324	static int snd_cs5535audio_probe(struct pci_dev *pci,
e23e7a14 BP	325	const struct pci_device_id *pci_id)
9b4ffa48 JK	326	{
9b4ffa48 JK	327	static int dev;
66f8df6b TI	328	struct snd_card *card;
66f8df6b TI	329	struct cs5535audio *cs5535au;
9b4ffa48 JK	330	int err;
	331
	332	if (dev >= SNDRV_CARDS)
	333	return -ENODEV;
302e4c2f TI	334	if (!enable[dev]) {
	335	dev++;
	336	return -ENOENT;
	337	}
9b4ffa48	338
60c5772b TI	339	err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
60c5772b TI	340	0, &card);
e58de7ba TI	341	if (err < 0)
e58de7ba TI	342	return err;
9b4ffa48 JK	343
	344	if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0)
	345	goto probefail_out;
	346
9ac25594 JK	347	card->private_data = cs5535au;
9ac25594 JK	348
9b4ffa48 JK	349	if ((err = snd_cs5535audio_mixer(cs5535au)) < 0)
	350	goto probefail_out;
	351
	352	if ((err = snd_cs5535audio_pcm(cs5535au)) < 0)
	353	goto probefail_out;
	354
	355	strcpy(card->driver, DRIVER_NAME);
	356
	357	strcpy(card->shortname, "CS5535 Audio");
	358	sprintf(card->longname, "%s %s at 0x%lx, irq %i",
	359	card->shortname, card->driver,
	360	cs5535au->port, cs5535au->irq);
	361
	362	if ((err = snd_card_register(card)) < 0)
	363	goto probefail_out;
	364
	365	pci_set_drvdata(pci, card);
	366	dev++;
	367	return 0;
	368
	369	probefail_out:
	370	snd_card_free(card);
	371	return err;
	372	}
	373
e23e7a14	374	static void snd_cs5535audio_remove(struct pci_dev *pci)
9b4ffa48	375	{
3c554946	376	olpc_quirks_cleanup();
9b4ffa48	377	snd_card_free(pci_get_drvdata(pci));
9b4ffa48 JK	378	}
9b4ffa48 JK	379
e9f66d9b	380	static struct pci_driver cs5535audio_driver = {
3733e424	381	.name = KBUILD_MODNAME,
9b4ffa48 JK	382	.id_table = snd_cs5535audio_ids,
9b4ffa48 JK	383	.probe = snd_cs5535audio_probe,
e23e7a14	384	.remove = snd_cs5535audio_remove,
c7561cd8	385	#ifdef CONFIG_PM_SLEEP
68cb2b55 TI	386	.driver = {
	387	.pm = &snd_cs5535audio_pm,
	388	},
9ac25594	389	#endif
9b4ffa48 JK	390	};
9b4ffa48 JK	391
e9f66d9b	392	module_pci_driver(cs5535audio_driver);
9b4ffa48 JK	393
	394	MODULE_AUTHOR("Jaya Kumar");
	395	MODULE_LICENSE("GPL");
	396	MODULE_DESCRIPTION("CS5535 Audio");
	397	MODULE_SUPPORTED_DEVICE("CS5535 Audio");