Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d43f3010 authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: Add the driver for Digigram Lola PCI-e boards 



Added a new driver for supporting Digigram Lola PCI-e boards.

Lola has a similar h/w design like HD-audio but with extended verbs.
Thus the driver is written similarly like HD-audio driver in the bus
part.  The codec part is rather written in a fixed way specific to the
Lola board because of the verb incompatibility.

The driver provides basic PCM, supporting multi-streams and mixing.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 521cb40b

Documentation/sound/alsa/ALSA-Configuration.txt

+7 −0
Original line number Diff line number Diff line
@@ -1230,6 +1230,13 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed. 
    This module supports multiple cards.

    The driver requires the firmware loader support on kernel.



  Module snd-lola

  ---------------



    Module for Digigram Lola PCI-e boards



    This module supports multiple cards.



  Module snd-lx6464es

  -------------------

sound/pci/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -652,6 +652,15 @@ config SND_KORG1212 
	  To compile this driver as a module, choose M here: the module

	  will be called snd-korg1212.



config SND_LOLA

	tristate "Digigram Lola"

	select SND_PCM

	help

	  Say Y to include support for Digigram Lola boards.



	  To compile this driver as a module, choose M here: the module

	  will be called snd-lola.



config SND_LX6464ES

	tristate "Digigram LX6464ES"

	select SND_PCM

sound/pci/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -64,6 +64,7 @@ obj-$(CONFIG_SND) += \ 
	ca0106/ \

	cs46xx/ \

	cs5535audio/ \

	lola/ \

	lx6464es/ \

	echoaudio/ \

	emu10k1/ \

sound/pci/lola/Makefile

0 → 100644
+3 −0
Original line number Diff line number Diff line 
snd-lola-y := lola.o lola_pcm.o lola_clock.o lola_mixer.o

snd-lola-$(CONFIG_SND_DEBUG) += lola_proc.o

obj-m = snd-lola.o

sound/pci/lola/lola.c

0 → 100644
+731 −0
Original line number Diff line number Diff line 
/*

 *  Support for Digigram Lola PCI-e boards

 *

 *  Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>

 *

 *  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 <linux/kernel.h>

#include <linux/init.h>

#include <linux/moduleparam.h>

#include <linux/dma-mapping.h>

#include <linux/delay.h>

#include <linux/interrupt.h>

#include <linux/slab.h>

#include <linux/pci.h>

#include <sound/core.h>

#include <sound/control.h>

#include <sound/pcm.h>

#include <sound/initval.h>

#include "lola.h"



static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;

static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;

static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;



module_param_array(index, int, NULL, 0444);

MODULE_PARM_DESC(index, "Index value for Digigram Lola driver.");

module_param_array(id, charp, NULL, 0444);

MODULE_PARM_DESC(id, "ID string for Digigram Lola driver.");

module_param_array(enable, bool, NULL, 0444);

MODULE_PARM_DESC(enable, "Enable Digigram Lola driver.");



MODULE_LICENSE("GPL");

MODULE_SUPPORTED_DEVICE("{{Digigram, Lola}}");

MODULE_DESCRIPTION("Digigram Lola driver");

MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");



#ifdef CONFIG_SND_DEBUG_VERBOSE

static int debug;

module_param(debug, int, 0644);

#define verbose_debug(fmt, args...)			\

	do { if (debug > 1) printk(KERN_DEBUG SFX fmt, ##args); } while (0)

#else

#define verbose_debug(fmt, args...)

#endif



/*

 * pseudo-codec read/write via CORB/RIRB

 */



static int corb_send_verb(struct lola *chip, unsigned int nid,

			  unsigned int verb, unsigned int data,

			  unsigned int extdata)

{

	unsigned long flags;

	int ret = -EIO;



	chip->last_cmd_nid = nid;

	chip->last_verb = verb;

	chip->last_data = data;

	chip->last_extdata = extdata;

	data |= (nid << 20) | (verb << 8);

	spin_lock_irqsave(&chip->reg_lock, flags);

	if (chip->rirb.cmds < LOLA_CORB_ENTRIES - 1) {

		unsigned int wp = chip->corb.wp + 1;

		wp %= LOLA_CORB_ENTRIES;

		chip->corb.wp = wp;

		chip->corb.buf[wp * 2] = cpu_to_le32(data);

		chip->corb.buf[wp * 2 + 1] = cpu_to_le32(extdata);

		lola_writew(chip, BAR0, CORBWP, wp);

		chip->rirb.cmds++;

		smp_wmb();

		ret = 0;

	}

	spin_unlock_irqrestore(&chip->reg_lock, flags);

	return ret;

}



static void lola_queue_unsol_event(struct lola *chip, unsigned int res,

				   unsigned int res_ex)

{

	lola_update_ext_clock_freq(chip, res);

}



/* retrieve RIRB entry - called from interrupt handler */

static void lola_update_rirb(struct lola *chip)

{

	unsigned int rp, wp;

	u32 res, res_ex;



	wp = lola_readw(chip, BAR0, RIRBWP);

	if (wp == chip->rirb.wp)

		return;

	chip->rirb.wp = wp;



	while (chip->rirb.rp != wp) {

		chip->rirb.rp++;

		chip->rirb.rp %= LOLA_CORB_ENTRIES;



		rp = chip->rirb.rp << 1; /* an RIRB entry is 8-bytes */

		res_ex = le32_to_cpu(chip->rirb.buf[rp + 1]);

		res = le32_to_cpu(chip->rirb.buf[rp]);

		if (res_ex & LOLA_RIRB_EX_UNSOL_EV)

			lola_queue_unsol_event(chip, res, res_ex);

		else if (chip->rirb.cmds) {

			chip->res = res;

			chip->res_ex = res_ex;

			smp_wmb();

			chip->rirb.cmds--;

		}

	}

}



static int rirb_get_response(struct lola *chip, unsigned int *val,

			     unsigned int *extval)

{

	unsigned long timeout;



	timeout = jiffies + msecs_to_jiffies(1000);

	for (;;) {

		if (!chip->rirb.cmds) {

			*val = chip->res;

			if (extval)

				*extval = chip->res_ex;

			verbose_debug("get_response: %x, %x\n",

				      chip->res, chip->res_ex);

			if (chip->res_ex & LOLA_RIRB_EX_ERROR) {

				printk(KERN_WARNING SFX "RIRB ERROR: "

				       "NID=%x, verb=%x, data=%x, ext=%x\n",

				       chip->last_cmd_nid,

				       chip->last_verb, chip->last_data,

				       chip->last_extdata);

				return -EIO;

			}

			return 0;

		}

		if (time_after(jiffies, timeout))

			break;

		udelay(20);

		cond_resched();

		lola_update_rirb(chip);

	}

	printk(KERN_WARNING SFX "RIRB response error\n");

	return -EIO;

}



/* aynchronous write of a codec verb with data */

int lola_codec_write(struct lola *chip, unsigned int nid, unsigned int verb,

		     unsigned int data, unsigned int extdata)

{

	verbose_debug("codec_write NID=%x, verb=%x, data=%x, ext=%x\n",

		      nid, verb, data, extdata);

	return corb_send_verb(chip, nid, verb, data, extdata);

}



/* write a codec verb with data and read the returned status */

int lola_codec_read(struct lola *chip, unsigned int nid, unsigned int verb,

		    unsigned int data, unsigned int extdata,

		    unsigned int *val, unsigned int *extval)

{

	int err;



	verbose_debug("codec_read NID=%x, verb=%x, data=%x, ext=%x\n",

		      nid, verb, data, extdata);

	err = corb_send_verb(chip, nid, verb, data, extdata);

	if (err < 0)

		return err;

	err = rirb_get_response(chip, val, extval);

	return err;

}



/* flush all pending codec writes */

int lola_codec_flush(struct lola *chip)

{

	unsigned int tmp;

	return rirb_get_response(chip, &tmp, NULL);

}



/*

 * interrupt handler

 */

static irqreturn_t lola_interrupt(int irq, void *dev_id)

{

	struct lola *chip = dev_id;

	unsigned int notify_ins, notify_outs, error_ins, error_outs;

	int handled = 0;

	int i;



	notify_ins = notify_outs = error_ins = error_outs = 0;

	spin_lock(&chip->reg_lock);

	for (;;) {

		unsigned int status, in_sts, out_sts;

		unsigned int reg;



		status = lola_readl(chip, BAR1, DINTSTS);

		if (!status || status == -1)

			break;



		in_sts = lola_readl(chip, BAR1, DIINTSTS);

		out_sts = lola_readl(chip, BAR1, DOINTSTS);



		/* clear Input Interrupts */

		for (i = 0; in_sts && i < chip->pcm[CAPT].num_streams; i++) {

			if (!(in_sts & (1 << i)))

				continue;

			in_sts &= ~(1 << i);

			reg = lola_dsd_read(chip, i, STS);

			if (reg & LOLA_DSD_STS_DESE) /* error */

				error_ins |= (1 << i);

			if (reg & LOLA_DSD_STS_BCIS) /* notify */

				notify_ins |= (1 << i);

			/* clear */

			lola_dsd_write(chip, i, STS, reg);

		}



		/* clear Output Interrupts */

		for (i = 0; out_sts && i < chip->pcm[PLAY].num_streams; i++) {

			if (!(out_sts & (1 << i)))

				continue;

			out_sts &= ~(1 << i);

			reg = lola_dsd_read(chip, i + MAX_STREAM_IN_COUNT, STS);

			if (reg & LOLA_DSD_STS_DESE) /* error */

				error_outs |= (1 << i);

			if (reg & LOLA_DSD_STS_BCIS) /* notify */

				notify_outs |= (1 << i);

			lola_dsd_write(chip, i + MAX_STREAM_IN_COUNT, STS, reg);

		}



		if (status & LOLA_DINT_CTRL) {

			unsigned char rbsts; /* ring status is byte access */

			rbsts = lola_readb(chip, BAR0, RIRBSTS);

			rbsts &= LOLA_RIRB_INT_MASK;

			if (rbsts)

				lola_writeb(chip, BAR0, RIRBSTS, rbsts);

			rbsts = lola_readb(chip, BAR0, CORBSTS);

			rbsts &= LOLA_CORB_INT_MASK;

			if (rbsts)

				lola_writeb(chip, BAR0, CORBSTS, rbsts);



			lola_update_rirb(chip);

		}



		if (status & (LOLA_DINT_FIFOERR | LOLA_DINT_MUERR)) {

			/* clear global fifo error interrupt */

			lola_writel(chip, BAR1, DINTSTS,

				    (status & (LOLA_DINT_FIFOERR | LOLA_DINT_MUERR)));

		}

		handled = 1;

	}

	spin_unlock(&chip->reg_lock);



	lola_pcm_update(chip, &chip->pcm[CAPT], notify_ins);

	lola_pcm_update(chip, &chip->pcm[PLAY], notify_outs);



	return IRQ_RETVAL(handled);

}





/*

 * controller

 */

static int reset_controller(struct lola *chip)

{

	unsigned int gctl = lola_readl(chip, BAR0, GCTL);

	unsigned long end_time;



	if (gctl) {

		/* to be sure */

		lola_writel(chip, BAR1, BOARD_MODE, 0);

		return 0;

	}



	chip->cold_reset = 1;

	lola_writel(chip, BAR0, GCTL, LOLA_GCTL_RESET);

	end_time = jiffies + msecs_to_jiffies(200);

	do {

		msleep(1);

		gctl = lola_readl(chip, BAR0, GCTL);

		if (gctl)

			break;

	} while (time_before(jiffies, end_time));

	if (!gctl) {

		printk(KERN_ERR SFX "cannot reset controller\n");

		return -EIO;

	}

	return 0;

}



static void lola_irq_enable(struct lola *chip)

{

	unsigned int val;



	/* enalbe all I/O streams */

	val = (1 << chip->pcm[PLAY].num_streams) - 1;

	lola_writel(chip, BAR1, DOINTCTL, val);

	val = (1 << chip->pcm[CAPT].num_streams) - 1;

	lola_writel(chip, BAR1, DIINTCTL, val);



	/* enable global irqs */

	val = LOLA_DINT_GLOBAL | LOLA_DINT_CTRL | LOLA_DINT_FIFOERR |

		LOLA_DINT_MUERR;

	lola_writel(chip, BAR1, DINTCTL, val);

}



static void lola_irq_disable(struct lola *chip)

{

	lola_writel(chip, BAR1, DINTCTL, 0);

	lola_writel(chip, BAR1, DIINTCTL, 0);

	lola_writel(chip, BAR1, DOINTCTL, 0);

}



static int setup_corb_rirb(struct lola *chip)

{

	int err;

	unsigned char tmp;

	unsigned long end_time;



	err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,

				  snd_dma_pci_data(chip->pci),

				  PAGE_SIZE, &chip->rb);

	if (err < 0)

		return err;



	chip->corb.addr = chip->rb.addr;

	chip->corb.buf = (u32 *)chip->rb.area;

	chip->rirb.addr = chip->rb.addr + 2048;

	chip->rirb.buf = (u32 *)(chip->rb.area + 2048);

	lola_writel(chip, BAR0, CORBLBASE, (u32)chip->corb.addr);

	lola_writel(chip, BAR0, CORBUBASE, upper_32_bits(chip->corb.addr));



	/* disable ringbuffer DMAs */

	lola_writeb(chip, BAR0, RIRBCTL, 0);

	lola_writeb(chip, BAR0, CORBCTL, 0);



	end_time = jiffies + msecs_to_jiffies(200);

	do {

		if (!lola_readb(chip, BAR0, RIRBCTL) &&

		    !lola_readb(chip, BAR0, CORBCTL))

			break;

		msleep(1);

	} while (time_before(jiffies, end_time));



	/* CORB set up */

	lola_writel(chip, BAR0, CORBLBASE, (u32)chip->corb.addr);

	lola_writel(chip, BAR0, CORBUBASE, upper_32_bits(chip->corb.addr));

	/* set the corb size to 256 entries */

	lola_writeb(chip, BAR0, CORBSIZE, 0x02);

	/* set the corb write pointer to 0 */

	lola_writew(chip, BAR0, CORBWP, 0);

	/* reset the corb hw read pointer */

	lola_writew(chip, BAR0, CORBRP, LOLA_RBRWP_CLR);

	/* enable corb dma */

	lola_writeb(chip, BAR0, CORBCTL, LOLA_RBCTL_DMA_EN);

	/* clear flags if set */

	tmp = lola_readb(chip, BAR0, CORBSTS) & LOLA_CORB_INT_MASK;

	if (tmp)

		lola_writeb(chip, BAR0, CORBSTS, tmp);

	chip->corb.wp = 0;



	/* RIRB set up */

	lola_writel(chip, BAR0, RIRBLBASE, (u32)chip->rirb.addr);

	lola_writel(chip, BAR0, RIRBUBASE, upper_32_bits(chip->rirb.addr));

	/* set the rirb size to 256 entries */

	lola_writeb(chip, BAR0, RIRBSIZE, 0x02);

	/* reset the rirb hw write pointer */

	lola_writew(chip, BAR0, RIRBWP, LOLA_RBRWP_CLR);

	/* set N=1, get RIRB response interrupt for new entry */

	lola_writew(chip, BAR0, RINTCNT, 1);

	/* enable rirb dma and response irq */

	lola_writeb(chip, BAR0, RIRBCTL, LOLA_RBCTL_DMA_EN | LOLA_RBCTL_IRQ_EN);

	/* clear flags if set */

	tmp =  lola_readb(chip, BAR0, RIRBSTS) & LOLA_RIRB_INT_MASK;

	if (tmp)

		lola_writeb(chip, BAR0, RIRBSTS, tmp);

	chip->rirb.rp = chip->rirb.cmds = 0;



	return 0;

}



static void stop_corb_rirb(struct lola *chip)

{

	/* disable ringbuffer DMAs */

	lola_writeb(chip, BAR0, RIRBCTL, 0);

	lola_writeb(chip, BAR0, CORBCTL, 0);

}



static void lola_reset_setups(struct lola *chip)

{

	/* update the granularity */

	lola_set_granularity(chip, chip->granularity, true);

	/* update the sample clock */

	lola_set_clock_index(chip, chip->clock.cur_index);

	/* enable unsolicited events of the clock widget */

	lola_enable_clock_events(chip);

	/* update the analog gains */

	lola_setup_all_analog_gains(chip, CAPT, false); /* input, update */

	/* update SRC configuration if applicable */

	lola_set_src_config(chip, chip->input_src_mask, false);

	/* update the analog outputs */

	lola_setup_all_analog_gains(chip, PLAY, false); /* output, update */

}



static int lola_parse_tree(struct lola *chip)

{

	unsigned int val;

	int nid, err;



	err = lola_read_param(chip, 0, LOLA_PAR_VENDOR_ID, &val);

	if (err < 0) {

		printk(KERN_ERR SFX "Can't read VENDOR_ID\n");

		return err;

	}

	val >>= 16;

	if (val != 0x1369) {

		printk(KERN_ERR SFX "Unknown codec vendor 0x%x\n", val);

		return -EINVAL;

	}



	err = lola_read_param(chip, 1, LOLA_PAR_FUNCTION_TYPE, &val);

	if (err < 0) {

		printk(KERN_ERR SFX "Can't read FUNCTION_TYPE for 0x%x\n", nid);

		return err;

	}

	if (val != 1) {

		printk(KERN_ERR SFX "Unknown function type %d\n", val);

		return -EINVAL;

	}



	err = lola_read_param(chip, 1, LOLA_PAR_SPECIFIC_CAPS, &val);

	if (err < 0) {

		printk(KERN_ERR SFX "Can't read SPECCAPS\n");

		return err;

	}

	chip->lola_caps = val;

	chip->pin[CAPT].num_pins = LOLA_AFG_INPUT_PIN_COUNT(chip->lola_caps);

	chip->pin[PLAY].num_pins = LOLA_AFG_OUTPUT_PIN_COUNT(chip->lola_caps);

	snd_printd(SFX "speccaps=0x%x, pins in=%d, out=%d\n",

		   chip->lola_caps,

		   chip->pin[CAPT].num_pins, chip->pin[PLAY].num_pins);



	if (chip->pin[CAPT].num_pins > MAX_AUDIO_INOUT_COUNT ||

	    chip->pin[PLAY].num_pins > MAX_AUDIO_INOUT_COUNT) {

		printk(KERN_ERR SFX "Invalid Lola-spec caps 0x%x\n", val);

		return -EINVAL;

	}



	nid = 0x02;

	err = lola_init_pcm(chip, CAPT, &nid);

	if (err < 0)

		return err;

	err = lola_init_pcm(chip, PLAY, &nid);

	if (err < 0)

		return err;



	err = lola_init_pins(chip, CAPT, &nid);

	if (err < 0)

		return err;

	err = lola_init_pins(chip, PLAY, &nid);

	if (err < 0)

		return err;



	if (LOLA_AFG_CLOCK_WIDGET_PRESENT(chip->lola_caps)) {

		err = lola_init_clock_widget(chip, nid);

		if (err < 0)

			return err;

		nid++;

	}

	if (LOLA_AFG_MIXER_WIDGET_PRESENT(chip->lola_caps)) {

		err = lola_init_mixer_widget(chip, nid);

		if (err < 0)

			return err;

		nid++;

	}



	/* enable unsolicited events of the clock widget */

	err = lola_enable_clock_events(chip);

	if (err < 0)

		return err;



	/* if last ResetController was not a ColdReset, we don't know

	 * the state of the card; initialize here again

	 */

	if (!chip->cold_reset) {

		lola_reset_setups(chip);

		chip->cold_reset = 1;

	}



	return 0;

}



static void lola_stop_hw(struct lola *chip)

{

	stop_corb_rirb(chip);

	lola_irq_disable(chip);

}



static void lola_free(struct lola *chip)

{

	if (chip->initialized)

		lola_stop_hw(chip);

	lola_free_pcm(chip);

	lola_free_mixer(chip);

	if (chip->irq >= 0)

		free_irq(chip->irq, (void *)chip);

	if (chip->bar[0].remap_addr)

		iounmap(chip->bar[0].remap_addr);

	if (chip->bar[1].remap_addr)

		iounmap(chip->bar[1].remap_addr);

	if (chip->rb.area)

		snd_dma_free_pages(&chip->rb);

	pci_release_regions(chip->pci);

	pci_disable_device(chip->pci);

	kfree(chip);

}



static int lola_dev_free(struct snd_device *device)

{

	lola_free(device->device_data);

	return 0;

}



static int __devinit lola_create(struct snd_card *card, struct pci_dev *pci,

				 struct lola **rchip)

{

	struct lola *chip;

	int err;

	unsigned int dever;

	static struct snd_device_ops ops = {

		.dev_free = lola_dev_free,

	};



	*rchip = NULL;



	err = pci_enable_device(pci);

	if (err < 0)

		return err;



	chip = kzalloc(sizeof(*chip), GFP_KERNEL);

	if (!chip) {

		snd_printk(KERN_ERR SFX "cannot allocate chip\n");

		pci_disable_device(pci);

		return -ENOMEM;

	}



	spin_lock_init(&chip->reg_lock);

	mutex_init(&chip->open_mutex);

	chip->card = card;

	chip->pci = pci;

	chip->irq = -1;



	chip->sample_rate_min = 48000;

	chip->granularity = LOLA_GRANULARITY_MIN;



	err = pci_request_regions(pci, DRVNAME);

	if (err < 0) {

		kfree(chip);

		pci_disable_device(pci);

		return err;

	}



	chip->bar[0].addr = pci_resource_start(pci, 0);

	chip->bar[0].remap_addr = pci_ioremap_bar(pci, 0);

	chip->bar[1].addr = pci_resource_start(pci, 2);

	chip->bar[1].remap_addr = pci_ioremap_bar(pci, 2);

	if (!chip->bar[0].remap_addr || !chip->bar[1].remap_addr) {

		snd_printk(KERN_ERR SFX "ioremap error\n");

		err = -ENXIO;

		goto errout;

	}



	pci_set_master(pci);



	err = reset_controller(chip);

	if (err < 0)

		goto errout;



	if (request_irq(pci->irq, lola_interrupt, IRQF_SHARED,

			DRVNAME, chip)) {

		printk(KERN_ERR SFX "unable to grab IRQ %d\n", pci->irq);

		err = -EBUSY;

		goto errout;

	}

	chip->irq = pci->irq;

	synchronize_irq(chip->irq);



	dever = lola_readl(chip, BAR1, DEVER);

	chip->pcm[CAPT].num_streams = (dever >> 0) & 0x3ff;

	chip->pcm[PLAY].num_streams = (dever >> 10) & 0x3ff;

	chip->version = (dever >> 24) & 0xff;

	snd_printd(SFX "streams in=%d, out=%d, version=0x%x\n",

		    chip->pcm[CAPT].num_streams, chip->pcm[PLAY].num_streams,

		    chip->version);



	/* Test LOLA_BAR1_DEVER */

	if (chip->pcm[CAPT].num_streams > MAX_STREAM_IN_COUNT ||

	    chip->pcm[PLAY].num_streams > MAX_STREAM_OUT_COUNT ||

	    (!chip->pcm[CAPT].num_streams &&

	     !chip->pcm[PLAY].num_streams)) {

		printk(KERN_ERR SFX "invalid DEVER = %x\n", dever);

		err = -EINVAL;

		goto errout;

	}



	err = setup_corb_rirb(chip);

	if (err < 0)

		goto errout;



	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);

	if (err < 0) {

		snd_printk(KERN_ERR SFX "Error creating device [card]!\n");

		goto errout;

	}



	strcpy(card->driver, "Lola");

	strlcpy(card->shortname, "Digigram Lola", sizeof(card->shortname));

	snprintf(card->longname, sizeof(card->longname),

		 "%s at 0x%lx irq %i",

		 card->shortname, chip->bar[0].addr, chip->irq);

	strcpy(card->mixername, card->shortname);



	lola_irq_enable(chip);



	chip->initialized = 1;

	*rchip = chip;

	return 0;



 errout:

	lola_free(chip);

	return err;

}



static int __devinit lola_probe(struct pci_dev *pci,

				const struct pci_device_id *pci_id)

{

	static int dev;

	struct snd_card *card;

	struct lola *chip;

	int err;



	if (dev >= SNDRV_CARDS)

		return -ENODEV;

	if (!enable[dev]) {

		dev++;

		return -ENOENT;

	}



	err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);

	if (err < 0) {

		snd_printk(KERN_ERR SFX "Error creating card!\n");

		return err;

	}



	snd_card_set_dev(card, &pci->dev);



	err = lola_create(card, pci, &chip);

	if (err < 0)

		goto out_free;

	card->private_data = chip;



	err = lola_parse_tree(chip);

	if (err < 0)

		goto out_free;



	err = lola_create_pcm(chip);

	if (err < 0)

		goto out_free;



	err = lola_create_mixer(chip);

	if (err < 0)

		goto out_free;



	lola_proc_debug_new(chip);



	err = snd_card_register(card);

	if (err < 0)

		goto out_free;



	pci_set_drvdata(pci, card);

	dev++;

	return err;

out_free:

	snd_card_free(card);

	return err;

}



static void __devexit lola_remove(struct pci_dev *pci)

{

	snd_card_free(pci_get_drvdata(pci));

	pci_set_drvdata(pci, NULL);

}



/* PCI IDs */

static DEFINE_PCI_DEVICE_TABLE(lola_ids) = {

	{ PCI_VDEVICE(DIGIGRAM, 0x0001) },

	{ 0, }

};

MODULE_DEVICE_TABLE(pci, lola_ids);



/* pci_driver definition */

static struct pci_driver driver = {

	.name = DRVNAME,

	.id_table = lola_ids,

	.probe = lola_probe,

	.remove = __devexit_p(lola_remove),

};



static int __init alsa_card_lola_init(void)

{

	return pci_register_driver(&driver);

}



static void __exit alsa_card_lola_exit(void)

{

	pci_unregister_driver(&driver);

}



module_init(alsa_card_lola_init)

module_exit(alsa_card_lola_exit)