[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 const struct snd_ac97_bus_ops ops = {
		.write = snd_cs5535audio_ac97_codec_write,
		.read = snd_cs5535audio_ac97_codec_read,
	};

	err = snd_ac97_bus(card, 0, &ops, NULL, &pbus);
	if (err < 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);

	err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97);
	if (err < 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 void snd_cs5535audio_free(struct snd_card *card)
{
	olpc_quirks_cleanup();
}

static int snd_cs5535audio_create(struct snd_card *card,
				  struct pci_dev *pci)
{
	struct cs5535audio *cs5535au = card->private_data;
	int err;

	err = pcim_enable_device(pci);
	if (err < 0)
		return err;

	if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) {
		dev_warn(card->dev, "unable to get 32bit dma\n");
		return -ENXIO;
	}

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

	err = pci_request_regions(pci, "CS5535 Audio");
	if (err < 0)
		return err;

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

	if (devm_request_irq(&pci->dev, pci->irq, snd_cs5535audio_interrupt,
			     IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
		dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
		return -EBUSY;
	}

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

	return 0;
}

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_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
				sizeof(*cs5535au), &card);
	if (err < 0)
		return err;
	cs5535au = card->private_data;
	card->private_free = snd_cs5535audio_free;

	err = snd_cs5535audio_create(card, pci);
	if (err < 0)
		return err;

	err = snd_cs5535audio_mixer(cs5535au);
	if (err < 0)
		return err;

	err = snd_cs5535audio_pcm(cs5535au);
	if (err < 0)
		return err;

	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);

	err = snd_card_register(card);
	if (err < 0)
		return err;

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

static int snd_cs5535audio_probe(struct pci_dev *pci,
				 const struct pci_device_id *pci_id)
{
	return snd_card_free_on_error(&pci->dev, __snd_cs5535audio_probe(pci, pci_id));
}

static struct pci_driver cs5535audio_driver = {
	.name = KBUILD_MODNAME,
	.id_table = snd_cs5535audio_ids,
	.probe = snd_cs5535audio_probe,
#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");
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;
51055da5	141	static const struct snd_ac97_bus_ops ops = {
9b4ffa48 JK	142	.write = snd_cs5535audio_ac97_codec_write,
	143	.read = snd_cs5535audio_ac97_codec_read,
	144	};
	145
164b3dde TI	146	err = snd_ac97_bus(card, 0, &ops, NULL, &pbus);
164b3dde TI	147	if (err < 0)
9b4ffa48 JK	148	return err;
	149
	150	memset(&ac97, 0, sizeof(ac97));
b035ce0f JK	151	ac97.scaps = AC97_SCAP_AUDIO \| AC97_SCAP_SKIP_MODEM
b035ce0f JK	152	\| AC97_SCAP_POWER_SAVE;
9b4ffa48 JK	153	ac97.private_data = cs5535au;
9b4ffa48 JK	154	ac97.pci = cs5535au->pci;
9b4ffa48	155
3556d184 AS	156	/* set any OLPC-specific scaps */
	157	olpc_prequirks(card, &ac97);
	158
164b3dde TI	159	err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97);
164b3dde TI	160	if (err < 0) {
00980aa9	161	dev_err(card->dev, "mixer failed\n");
9b4ffa48 JK	162	return err;
	163	}
	164
9ac25594 JK	165	snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);
9ac25594 JK	166
57d4bf6d JK	167	err = olpc_quirks(card, cs5535au->ac97);
57d4bf6d JK	168	if (err < 0) {
00980aa9	169	dev_err(card->dev, "olpc quirks failed\n");
57d4bf6d JK	170	return err;
	171	}
	172
9b4ffa48 JK	173	return 0;
	174	}
	175
66f8df6b	176	static void process_bm0_irq(struct cs5535audio *cs5535au)
9b4ffa48 JK	177	{
	178	u8 bm_stat;
	179	spin_lock(&cs5535au->reg_lock);
	180	bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS);
	181	spin_unlock(&cs5535au->reg_lock);
	182	if (bm_stat & EOP) {
9b4ffa48 JK	183	snd_pcm_period_elapsed(cs5535au->playback_substream);
9b4ffa48 JK	184	} else {
00980aa9 TI	185	dev_err(cs5535au->card->dev,
	186	"unexpected bm0 irq src, bm_stat=%x\n",
	187	bm_stat);
9b4ffa48 JK	188	}
	189	}
	190
66f8df6b	191	static void process_bm1_irq(struct cs5535audio *cs5535au)
9b4ffa48 JK	192	{
	193	u8 bm_stat;
	194	spin_lock(&cs5535au->reg_lock);
	195	bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS);
	196	spin_unlock(&cs5535au->reg_lock);
45bf4100	197	if (bm_stat & EOP)
9b4ffa48	198	snd_pcm_period_elapsed(cs5535au->capture_substream);
9b4ffa48 JK	199	}
9b4ffa48 JK	200
7d12e780	201	static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id)
9b4ffa48 JK	202	{
9b4ffa48 JK	203	u16 acc_irq_stat;
9b4ffa48	204	unsigned char count;
66f8df6b	205	struct cs5535audio *cs5535au = dev_id;
9b4ffa48 JK	206
	207	if (cs5535au == NULL)
	208	return IRQ_NONE;
	209
	210	acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS);
	211
	212	if (!acc_irq_stat)
	213	return IRQ_NONE;
4ea24163	214	for (count = 0; count < 4; count++) {
3e873174	215	if (acc_irq_stat & (1 << count)) {
9b4ffa48 JK	216	switch (count) {
	217	case IRQ_STS:
	218	cs_readl(cs5535au, ACC_GPIO_STATUS);
	219	break;
	220	case WU_IRQ_STS:
	221	cs_readl(cs5535au, ACC_GPIO_STATUS);
	222	break;
	223	case BM0_IRQ_STS:
	224	process_bm0_irq(cs5535au);
	225	break;
	226	case BM1_IRQ_STS:
	227	process_bm1_irq(cs5535au);
	228	break;
9b4ffa48	229	default:
00980aa9 TI	230	dev_err(cs5535au->card->dev,
	231	"Unexpected irq src: 0x%x\n",
	232	acc_irq_stat);
9b4ffa48 JK	233	break;
	234	}
	235	}
	236	}
	237	return IRQ_HANDLED;
	238	}
	239
5eba4c64	240	static void snd_cs5535audio_free(struct snd_card *card)
9b4ffa48	241	{
5eba4c64	242	olpc_quirks_cleanup();
9b4ffa48 JK	243	}
9b4ffa48 JK	244
e23e7a14	245	static int snd_cs5535audio_create(struct snd_card *card,
5eba4c64	246	struct pci_dev *pci)
9b4ffa48	247	{
5eba4c64	248	struct cs5535audio *cs5535au = card->private_data;
9b4ffa48	249	int err;
9b4ffa48	250
5eba4c64	251	err = pcim_enable_device(pci);
164b3dde	252	if (err < 0)
9b4ffa48 JK	253	return err;
9b4ffa48 JK	254
669f65ea	255	if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) {
00980aa9	256	dev_warn(card->dev, "unable to get 32bit dma\n");
5eba4c64	257	return -ENXIO;
9b4ffa48 JK	258	}
	259
	260	spin_lock_init(&cs5535au->reg_lock);
	261	cs5535au->card = card;
	262	cs5535au->pci = pci;
	263	cs5535au->irq = -1;
	264
164b3dde	265	err = pci_request_regions(pci, "CS5535 Audio");
5eba4c64 TI	266	if (err < 0)
5eba4c64 TI	267	return err;
9b4ffa48 JK	268
	269	cs5535au->port = pci_resource_start(pci, 0);
	270
5eba4c64 TI	271	if (devm_request_irq(&pci->dev, pci->irq, snd_cs5535audio_interrupt,
5eba4c64 TI	272	IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
00980aa9	273	dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
5eba4c64	274	return -EBUSY;
9b4ffa48 JK	275	}
	276
	277	cs5535au->irq = pci->irq;
25ec679b	278	card->sync_irq = cs5535au->irq;
9b4ffa48 JK	279	pci_set_master(pci);
9b4ffa48 JK	280
9b4ffa48	281	return 0;
9b4ffa48 JK	282	}
9b4ffa48 JK	283
2a563147 TI	284	static int __snd_cs5535audio_probe(struct pci_dev *pci,
2a563147 TI	285	const struct pci_device_id *pci_id)
9b4ffa48 JK	286	{
9b4ffa48 JK	287	static int dev;
66f8df6b TI	288	struct snd_card *card;
66f8df6b TI	289	struct cs5535audio *cs5535au;
9b4ffa48 JK	290	int err;
	291
	292	if (dev >= SNDRV_CARDS)
	293	return -ENODEV;
302e4c2f TI	294	if (!enable[dev]) {
	295	dev++;
	296	return -ENOENT;
	297	}
9b4ffa48	298
5eba4c64 TI	299	err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
5eba4c64 TI	300	sizeof(*cs5535au), &card);
e58de7ba TI	301	if (err < 0)
e58de7ba TI	302	return err;
5eba4c64 TI	303	cs5535au = card->private_data;
5eba4c64 TI	304	card->private_free = snd_cs5535audio_free;
9b4ffa48	305
5eba4c64	306	err = snd_cs5535audio_create(card, pci);
164b3dde	307	if (err < 0)
5eba4c64	308	return err;
9ac25594	309
164b3dde TI	310	err = snd_cs5535audio_mixer(cs5535au);
164b3dde TI	311	if (err < 0)
5eba4c64	312	return err;
9b4ffa48	313
164b3dde TI	314	err = snd_cs5535audio_pcm(cs5535au);
164b3dde TI	315	if (err < 0)
5eba4c64	316	return err;
9b4ffa48 JK	317
	318	strcpy(card->driver, DRIVER_NAME);
	319
	320	strcpy(card->shortname, "CS5535 Audio");
	321	sprintf(card->longname, "%s %s at 0x%lx, irq %i",
	322	card->shortname, card->driver,
	323	cs5535au->port, cs5535au->irq);
	324
164b3dde TI	325	err = snd_card_register(card);
164b3dde TI	326	if (err < 0)
5eba4c64	327	return err;
9b4ffa48 JK	328
	329	pci_set_drvdata(pci, card);
	330	dev++;
	331	return 0;
9b4ffa48 JK	332	}
9b4ffa48 JK	333
2a563147 TI	334	static int snd_cs5535audio_probe(struct pci_dev *pci,
	335	const struct pci_device_id *pci_id)
	336	{
	337	return snd_card_free_on_error(&pci->dev, __snd_cs5535audio_probe(pci, pci_id));
	338	}
	339
e9f66d9b	340	static struct pci_driver cs5535audio_driver = {
3733e424	341	.name = KBUILD_MODNAME,
9b4ffa48 JK	342	.id_table = snd_cs5535audio_ids,
9b4ffa48 JK	343	.probe = snd_cs5535audio_probe,
c7561cd8	344	#ifdef CONFIG_PM_SLEEP
68cb2b55 TI	345	.driver = {
	346	.pm = &snd_cs5535audio_pm,
	347	},
9ac25594	348	#endif
9b4ffa48 JK	349	};
9b4ffa48 JK	350
e9f66d9b	351	module_pci_driver(cs5535audio_driver);
9b4ffa48 JK	352
	353	MODULE_AUTHOR("Jaya Kumar");
	354	MODULE_LICENSE("GPL");
	355	MODULE_DESCRIPTION("CS5535 Audio");