2 * Support for Digigram Lola PCI-e boards
4 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc., 59
18 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/moduleparam.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/delay.h>
26 #include <linux/interrupt.h>
27 #include <linux/slab.h>
28 #include <linux/pci.h>
29 #include <sound/core.h>
30 #include <sound/control.h>
31 #include <sound/pcm.h>
32 #include <sound/initval.h>
35 /* Standard options */
36 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
37 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
38 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
40 module_param_array(index, int, NULL, 0444);
41 MODULE_PARM_DESC(index, "Index value for Digigram Lola driver.");
42 module_param_array(id, charp, NULL, 0444);
43 MODULE_PARM_DESC(id, "ID string for Digigram Lola driver.");
44 module_param_array(enable, bool, NULL, 0444);
45 MODULE_PARM_DESC(enable, "Enable Digigram Lola driver.");
47 /* Lola-specific options */
49 /* for instance use always max granularity which is compatible
50 * with all sample rates
52 static int granularity[SNDRV_CARDS] = {
53 [0 ... (SNDRV_CARDS - 1)] = LOLA_GRANULARITY_MAX
56 /* below a sample_rate of 16kHz the analogue audio quality is NOT excellent */
57 static int sample_rate_min[SNDRV_CARDS] = {
58 [0 ... (SNDRV_CARDS - 1) ] = 16000
61 module_param_array(granularity, int, NULL, 0444);
62 MODULE_PARM_DESC(granularity, "Granularity value");
63 module_param_array(sample_rate_min, int, NULL, 0444);
64 MODULE_PARM_DESC(sample_rate_min, "Minimal sample rate");
69 MODULE_LICENSE("GPL");
70 MODULE_SUPPORTED_DEVICE("{{Digigram, Lola}}");
71 MODULE_DESCRIPTION("Digigram Lola driver");
72 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
74 #ifdef CONFIG_SND_DEBUG_VERBOSE
76 module_param(debug, int, 0644);
77 #define verbose_debug(fmt, args...) \
78 do { if (debug > 1) printk(KERN_DEBUG SFX fmt, ##args); } while (0)
80 #define verbose_debug(fmt, args...)
84 * pseudo-codec read/write via CORB/RIRB
87 static int corb_send_verb(struct lola *chip, unsigned int nid,
88 unsigned int verb, unsigned int data,
94 chip->last_cmd_nid = nid;
95 chip->last_verb = verb;
96 chip->last_data = data;
97 chip->last_extdata = extdata;
98 data |= (nid << 20) | (verb << 8);
100 spin_lock_irqsave(&chip->reg_lock, flags);
101 if (chip->rirb.cmds < LOLA_CORB_ENTRIES - 1) {
102 unsigned int wp = chip->corb.wp + 1;
103 wp %= LOLA_CORB_ENTRIES;
105 chip->corb.buf[wp * 2] = cpu_to_le32(data);
106 chip->corb.buf[wp * 2 + 1] = cpu_to_le32(extdata);
107 lola_writew(chip, BAR0, CORBWP, wp);
112 spin_unlock_irqrestore(&chip->reg_lock, flags);
116 static void lola_queue_unsol_event(struct lola *chip, unsigned int res,
119 lola_update_ext_clock_freq(chip, res);
122 /* retrieve RIRB entry - called from interrupt handler */
123 static void lola_update_rirb(struct lola *chip)
128 wp = lola_readw(chip, BAR0, RIRBWP);
129 if (wp == chip->rirb.wp)
133 while (chip->rirb.rp != wp) {
135 chip->rirb.rp %= LOLA_CORB_ENTRIES;
137 rp = chip->rirb.rp << 1; /* an RIRB entry is 8-bytes */
138 res_ex = le32_to_cpu(chip->rirb.buf[rp + 1]);
139 res = le32_to_cpu(chip->rirb.buf[rp]);
140 if (res_ex & LOLA_RIRB_EX_UNSOL_EV)
141 lola_queue_unsol_event(chip, res, res_ex);
142 else if (chip->rirb.cmds) {
144 chip->res_ex = res_ex;
151 static int rirb_get_response(struct lola *chip, unsigned int *val,
152 unsigned int *extval)
154 unsigned long timeout;
156 timeout = jiffies + msecs_to_jiffies(1000);
158 if (!chip->rirb.cmds) {
161 *extval = chip->res_ex;
162 verbose_debug("get_response: %x, %x\n",
163 chip->res, chip->res_ex);
164 if (chip->res_ex & LOLA_RIRB_EX_ERROR) {
165 printk(KERN_WARNING SFX "RIRB ERROR: "
166 "NID=%x, verb=%x, data=%x, ext=%x\n",
168 chip->last_verb, chip->last_data,
174 if (time_after(jiffies, timeout))
178 lola_update_rirb(chip);
180 printk(KERN_WARNING SFX "RIRB response error\n");
184 /* aynchronous write of a codec verb with data */
185 int lola_codec_write(struct lola *chip, unsigned int nid, unsigned int verb,
186 unsigned int data, unsigned int extdata)
188 verbose_debug("codec_write NID=%x, verb=%x, data=%x, ext=%x\n",
189 nid, verb, data, extdata);
190 return corb_send_verb(chip, nid, verb, data, extdata);
193 /* write a codec verb with data and read the returned status */
194 int lola_codec_read(struct lola *chip, unsigned int nid, unsigned int verb,
195 unsigned int data, unsigned int extdata,
196 unsigned int *val, unsigned int *extval)
200 verbose_debug("codec_read NID=%x, verb=%x, data=%x, ext=%x\n",
201 nid, verb, data, extdata);
202 err = corb_send_verb(chip, nid, verb, data, extdata);
205 err = rirb_get_response(chip, val, extval);
209 /* flush all pending codec writes */
210 int lola_codec_flush(struct lola *chip)
213 return rirb_get_response(chip, &tmp, NULL);
219 static irqreturn_t lola_interrupt(int irq, void *dev_id)
221 struct lola *chip = dev_id;
222 unsigned int notify_ins, notify_outs, error_ins, error_outs;
226 notify_ins = notify_outs = error_ins = error_outs = 0;
227 spin_lock(&chip->reg_lock);
229 unsigned int status, in_sts, out_sts;
232 status = lola_readl(chip, BAR1, DINTSTS);
233 if (!status || status == -1)
236 in_sts = lola_readl(chip, BAR1, DIINTSTS);
237 out_sts = lola_readl(chip, BAR1, DOINTSTS);
239 /* clear Input Interrupts */
240 for (i = 0; in_sts && i < chip->pcm[CAPT].num_streams; i++) {
241 if (!(in_sts & (1 << i)))
244 reg = lola_dsd_read(chip, i, STS);
245 if (reg & LOLA_DSD_STS_DESE) /* error */
246 error_ins |= (1 << i);
247 if (reg & LOLA_DSD_STS_BCIS) /* notify */
248 notify_ins |= (1 << i);
250 lola_dsd_write(chip, i, STS, reg);
253 /* clear Output Interrupts */
254 for (i = 0; out_sts && i < chip->pcm[PLAY].num_streams; i++) {
255 if (!(out_sts & (1 << i)))
257 out_sts &= ~(1 << i);
258 reg = lola_dsd_read(chip, i + MAX_STREAM_IN_COUNT, STS);
259 if (reg & LOLA_DSD_STS_DESE) /* error */
260 error_outs |= (1 << i);
261 if (reg & LOLA_DSD_STS_BCIS) /* notify */
262 notify_outs |= (1 << i);
263 lola_dsd_write(chip, i + MAX_STREAM_IN_COUNT, STS, reg);
266 if (status & LOLA_DINT_CTRL) {
267 unsigned char rbsts; /* ring status is byte access */
268 rbsts = lola_readb(chip, BAR0, RIRBSTS);
269 rbsts &= LOLA_RIRB_INT_MASK;
271 lola_writeb(chip, BAR0, RIRBSTS, rbsts);
272 rbsts = lola_readb(chip, BAR0, CORBSTS);
273 rbsts &= LOLA_CORB_INT_MASK;
275 lola_writeb(chip, BAR0, CORBSTS, rbsts);
277 lola_update_rirb(chip);
280 if (status & (LOLA_DINT_FIFOERR | LOLA_DINT_MUERR)) {
281 /* clear global fifo error interrupt */
282 lola_writel(chip, BAR1, DINTSTS,
283 (status & (LOLA_DINT_FIFOERR | LOLA_DINT_MUERR)));
287 spin_unlock(&chip->reg_lock);
289 lola_pcm_update(chip, &chip->pcm[CAPT], notify_ins);
290 lola_pcm_update(chip, &chip->pcm[PLAY], notify_outs);
292 return IRQ_RETVAL(handled);
299 static int reset_controller(struct lola *chip)
301 unsigned int gctl = lola_readl(chip, BAR0, GCTL);
302 unsigned long end_time;
306 lola_writel(chip, BAR1, BOARD_MODE, 0);
310 chip->cold_reset = 1;
311 lola_writel(chip, BAR0, GCTL, LOLA_GCTL_RESET);
312 end_time = jiffies + msecs_to_jiffies(200);
315 gctl = lola_readl(chip, BAR0, GCTL);
318 } while (time_before(jiffies, end_time));
320 printk(KERN_ERR SFX "cannot reset controller\n");
326 static void lola_irq_enable(struct lola *chip)
330 /* enalbe all I/O streams */
331 val = (1 << chip->pcm[PLAY].num_streams) - 1;
332 lola_writel(chip, BAR1, DOINTCTL, val);
333 val = (1 << chip->pcm[CAPT].num_streams) - 1;
334 lola_writel(chip, BAR1, DIINTCTL, val);
336 /* enable global irqs */
337 val = LOLA_DINT_GLOBAL | LOLA_DINT_CTRL | LOLA_DINT_FIFOERR |
339 lola_writel(chip, BAR1, DINTCTL, val);
342 static void lola_irq_disable(struct lola *chip)
344 lola_writel(chip, BAR1, DINTCTL, 0);
345 lola_writel(chip, BAR1, DIINTCTL, 0);
346 lola_writel(chip, BAR1, DOINTCTL, 0);
349 static int setup_corb_rirb(struct lola *chip)
353 unsigned long end_time;
355 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
356 snd_dma_pci_data(chip->pci),
357 PAGE_SIZE, &chip->rb);
361 chip->corb.addr = chip->rb.addr;
362 chip->corb.buf = (u32 *)chip->rb.area;
363 chip->rirb.addr = chip->rb.addr + 2048;
364 chip->rirb.buf = (u32 *)(chip->rb.area + 2048);
366 /* disable ringbuffer DMAs */
367 lola_writeb(chip, BAR0, RIRBCTL, 0);
368 lola_writeb(chip, BAR0, CORBCTL, 0);
370 end_time = jiffies + msecs_to_jiffies(200);
372 if (!lola_readb(chip, BAR0, RIRBCTL) &&
373 !lola_readb(chip, BAR0, CORBCTL))
376 } while (time_before(jiffies, end_time));
379 lola_writel(chip, BAR0, CORBLBASE, (u32)chip->corb.addr);
380 lola_writel(chip, BAR0, CORBUBASE, upper_32_bits(chip->corb.addr));
381 /* set the corb size to 256 entries */
382 lola_writeb(chip, BAR0, CORBSIZE, 0x02);
383 /* set the corb write pointer to 0 */
384 lola_writew(chip, BAR0, CORBWP, 0);
385 /* reset the corb hw read pointer */
386 lola_writew(chip, BAR0, CORBRP, LOLA_RBRWP_CLR);
387 /* enable corb dma */
388 lola_writeb(chip, BAR0, CORBCTL, LOLA_RBCTL_DMA_EN);
389 /* clear flags if set */
390 tmp = lola_readb(chip, BAR0, CORBSTS) & LOLA_CORB_INT_MASK;
392 lola_writeb(chip, BAR0, CORBSTS, tmp);
396 lola_writel(chip, BAR0, RIRBLBASE, (u32)chip->rirb.addr);
397 lola_writel(chip, BAR0, RIRBUBASE, upper_32_bits(chip->rirb.addr));
398 /* set the rirb size to 256 entries */
399 lola_writeb(chip, BAR0, RIRBSIZE, 0x02);
400 /* reset the rirb hw write pointer */
401 lola_writew(chip, BAR0, RIRBWP, LOLA_RBRWP_CLR);
402 /* set N=1, get RIRB response interrupt for new entry */
403 lola_writew(chip, BAR0, RINTCNT, 1);
404 /* enable rirb dma and response irq */
405 lola_writeb(chip, BAR0, RIRBCTL, LOLA_RBCTL_DMA_EN | LOLA_RBCTL_IRQ_EN);
406 /* clear flags if set */
407 tmp = lola_readb(chip, BAR0, RIRBSTS) & LOLA_RIRB_INT_MASK;
409 lola_writeb(chip, BAR0, RIRBSTS, tmp);
410 chip->rirb.rp = chip->rirb.cmds = 0;
415 static void stop_corb_rirb(struct lola *chip)
417 /* disable ringbuffer DMAs */
418 lola_writeb(chip, BAR0, RIRBCTL, 0);
419 lola_writeb(chip, BAR0, CORBCTL, 0);
422 static void lola_reset_setups(struct lola *chip)
424 /* update the granularity */
425 lola_set_granularity(chip, chip->granularity, true);
426 /* update the sample clock */
427 lola_set_clock_index(chip, chip->clock.cur_index);
428 /* enable unsolicited events of the clock widget */
429 lola_enable_clock_events(chip);
430 /* update the analog gains */
431 lola_setup_all_analog_gains(chip, CAPT, false); /* input, update */
432 /* update SRC configuration if applicable */
433 lola_set_src_config(chip, chip->input_src_mask, false);
434 /* update the analog outputs */
435 lola_setup_all_analog_gains(chip, PLAY, false); /* output, update */
438 static int lola_parse_tree(struct lola *chip)
443 err = lola_read_param(chip, 0, LOLA_PAR_VENDOR_ID, &val);
445 printk(KERN_ERR SFX "Can't read VENDOR_ID\n");
450 printk(KERN_ERR SFX "Unknown codec vendor 0x%x\n", val);
454 err = lola_read_param(chip, 1, LOLA_PAR_FUNCTION_TYPE, &val);
456 printk(KERN_ERR SFX "Can't read FUNCTION_TYPE for 0x%x\n", nid);
460 printk(KERN_ERR SFX "Unknown function type %d\n", val);
464 err = lola_read_param(chip, 1, LOLA_PAR_SPECIFIC_CAPS, &val);
466 printk(KERN_ERR SFX "Can't read SPECCAPS\n");
469 chip->lola_caps = val;
470 chip->pin[CAPT].num_pins = LOLA_AFG_INPUT_PIN_COUNT(chip->lola_caps);
471 chip->pin[PLAY].num_pins = LOLA_AFG_OUTPUT_PIN_COUNT(chip->lola_caps);
472 snd_printdd(SFX "speccaps=0x%x, pins in=%d, out=%d\n",
474 chip->pin[CAPT].num_pins, chip->pin[PLAY].num_pins);
476 if (chip->pin[CAPT].num_pins > MAX_AUDIO_INOUT_COUNT ||
477 chip->pin[PLAY].num_pins > MAX_AUDIO_INOUT_COUNT) {
478 printk(KERN_ERR SFX "Invalid Lola-spec caps 0x%x\n", val);
483 err = lola_init_pcm(chip, CAPT, &nid);
486 err = lola_init_pcm(chip, PLAY, &nid);
490 err = lola_init_pins(chip, CAPT, &nid);
493 err = lola_init_pins(chip, PLAY, &nid);
497 if (LOLA_AFG_CLOCK_WIDGET_PRESENT(chip->lola_caps)) {
498 err = lola_init_clock_widget(chip, nid);
503 if (LOLA_AFG_MIXER_WIDGET_PRESENT(chip->lola_caps)) {
504 err = lola_init_mixer_widget(chip, nid);
510 /* enable unsolicited events of the clock widget */
511 err = lola_enable_clock_events(chip);
515 /* if last ResetController was not a ColdReset, we don't know
516 * the state of the card; initialize here again
518 if (!chip->cold_reset) {
519 lola_reset_setups(chip);
520 chip->cold_reset = 1;
522 /* set the granularity if it is not the default */
523 if (chip->granularity != LOLA_GRANULARITY_MIN)
524 lola_set_granularity(chip, chip->granularity, true);
530 static void lola_stop_hw(struct lola *chip)
532 stop_corb_rirb(chip);
533 lola_irq_disable(chip);
536 static void lola_free(struct lola *chip)
538 if (chip->initialized)
541 lola_free_mixer(chip);
543 free_irq(chip->irq, (void *)chip);
544 if (chip->bar[0].remap_addr)
545 iounmap(chip->bar[0].remap_addr);
546 if (chip->bar[1].remap_addr)
547 iounmap(chip->bar[1].remap_addr);
549 snd_dma_free_pages(&chip->rb);
550 pci_release_regions(chip->pci);
551 pci_disable_device(chip->pci);
555 static int lola_dev_free(struct snd_device *device)
557 lola_free(device->device_data);
561 static int __devinit lola_create(struct snd_card *card, struct pci_dev *pci,
562 int dev, struct lola **rchip)
567 static struct snd_device_ops ops = {
568 .dev_free = lola_dev_free,
573 err = pci_enable_device(pci);
577 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
579 snd_printk(KERN_ERR SFX "cannot allocate chip\n");
580 pci_disable_device(pci);
584 spin_lock_init(&chip->reg_lock);
585 mutex_init(&chip->open_mutex);
590 chip->granularity = granularity[dev];
591 switch (chip->granularity) {
593 chip->sample_rate_max = 48000;
596 chip->sample_rate_max = 96000;
599 chip->sample_rate_max = 192000;
602 snd_printk(KERN_WARNING SFX
603 "Invalid granularity %d, reset to %d\n",
604 chip->granularity, LOLA_GRANULARITY_MAX);
605 chip->granularity = LOLA_GRANULARITY_MAX;
606 chip->sample_rate_max = 192000;
609 chip->sample_rate_min = sample_rate_min[dev];
610 if (chip->sample_rate_min > chip->sample_rate_max) {
611 snd_printk(KERN_WARNING SFX
612 "Invalid sample_rate_min %d, reset to 16000\n",
613 chip->sample_rate_min);
614 chip->sample_rate_min = 16000;
617 err = pci_request_regions(pci, DRVNAME);
620 pci_disable_device(pci);
624 chip->bar[0].addr = pci_resource_start(pci, 0);
625 chip->bar[0].remap_addr = pci_ioremap_bar(pci, 0);
626 chip->bar[1].addr = pci_resource_start(pci, 2);
627 chip->bar[1].remap_addr = pci_ioremap_bar(pci, 2);
628 if (!chip->bar[0].remap_addr || !chip->bar[1].remap_addr) {
629 snd_printk(KERN_ERR SFX "ioremap error\n");
636 err = reset_controller(chip);
640 if (request_irq(pci->irq, lola_interrupt, IRQF_SHARED,
642 printk(KERN_ERR SFX "unable to grab IRQ %d\n", pci->irq);
646 chip->irq = pci->irq;
647 synchronize_irq(chip->irq);
649 dever = lola_readl(chip, BAR1, DEVER);
650 chip->pcm[CAPT].num_streams = (dever >> 0) & 0x3ff;
651 chip->pcm[PLAY].num_streams = (dever >> 10) & 0x3ff;
652 chip->version = (dever >> 24) & 0xff;
653 snd_printdd(SFX "streams in=%d, out=%d, version=0x%x\n",
654 chip->pcm[CAPT].num_streams, chip->pcm[PLAY].num_streams,
657 /* Test LOLA_BAR1_DEVER */
658 if (chip->pcm[CAPT].num_streams > MAX_STREAM_IN_COUNT ||
659 chip->pcm[PLAY].num_streams > MAX_STREAM_OUT_COUNT ||
660 (!chip->pcm[CAPT].num_streams &&
661 !chip->pcm[PLAY].num_streams)) {
662 printk(KERN_ERR SFX "invalid DEVER = %x\n", dever);
667 err = setup_corb_rirb(chip);
671 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
673 snd_printk(KERN_ERR SFX "Error creating device [card]!\n");
677 strcpy(card->driver, "Lola");
678 strlcpy(card->shortname, "Digigram Lola", sizeof(card->shortname));
679 snprintf(card->longname, sizeof(card->longname),
680 "%s at 0x%lx irq %i",
681 card->shortname, chip->bar[0].addr, chip->irq);
682 strcpy(card->mixername, card->shortname);
684 lola_irq_enable(chip);
686 chip->initialized = 1;
695 static int __devinit lola_probe(struct pci_dev *pci,
696 const struct pci_device_id *pci_id)
699 struct snd_card *card;
703 if (dev >= SNDRV_CARDS)
710 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
712 snd_printk(KERN_ERR SFX "Error creating card!\n");
716 snd_card_set_dev(card, &pci->dev);
718 err = lola_create(card, pci, dev, &chip);
721 card->private_data = chip;
723 err = lola_parse_tree(chip);
727 err = lola_create_pcm(chip);
731 err = lola_create_mixer(chip);
735 lola_proc_debug_new(chip);
737 err = snd_card_register(card);
741 pci_set_drvdata(pci, card);
749 static void __devexit lola_remove(struct pci_dev *pci)
751 snd_card_free(pci_get_drvdata(pci));
752 pci_set_drvdata(pci, NULL);
756 static DEFINE_PCI_DEVICE_TABLE(lola_ids) = {
757 { PCI_VDEVICE(DIGIGRAM, 0x0001) },
760 MODULE_DEVICE_TABLE(pci, lola_ids);
762 /* pci_driver definition */
763 static struct pci_driver driver = {
765 .id_table = lola_ids,
767 .remove = __devexit_p(lola_remove),
770 static int __init alsa_card_lola_init(void)
772 return pci_register_driver(&driver);
775 static void __exit alsa_card_lola_exit(void)
777 pci_unregister_driver(&driver);
780 module_init(alsa_card_lola_init)
781 module_exit(alsa_card_lola_exit)