sound/pci/lola/lola.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Support for Digigram Lola PCI-e boards
   4  *
   5  *  Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/dma-mapping.h>
  12 #include <linux/delay.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/slab.h>
  15 #include <linux/pci.h>
  16 #include <sound/core.h>
  17 #include <sound/control.h>
  18 #include <sound/pcm.h>
  19 #include <sound/initval.h>
  20 #include "lola.h"
  21
  22 /* Standard options */
  23 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  24 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
  25 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  26
  27 module_param_array(index, int, NULL, 0444);
  28 MODULE_PARM_DESC(index, "Index value for Digigram Lola driver.");
  29 module_param_array(id, charp, NULL, 0444);
  30 MODULE_PARM_DESC(id, "ID string for Digigram Lola driver.");
  31 module_param_array(enable, bool, NULL, 0444);
  32 MODULE_PARM_DESC(enable, "Enable Digigram Lola driver.");
  33
  34 /* Lola-specific options */
  35
  36 /* for instance use always max granularity which is compatible
  37  * with all sample rates
  38  */
  39 static int granularity[SNDRV_CARDS] = {
  40         [0 ... (SNDRV_CARDS - 1)] = LOLA_GRANULARITY_MAX
  41 };
  42
  43 /* below a sample_rate of 16kHz the analogue audio quality is NOT excellent */
  44 static int sample_rate_min[SNDRV_CARDS] = {
  45         [0 ... (SNDRV_CARDS - 1) ] = 16000
  46 };
  47
  48 module_param_array(granularity, int, NULL, 0444);
  49 MODULE_PARM_DESC(granularity, "Granularity value");
  50 module_param_array(sample_rate_min, int, NULL, 0444);
  51 MODULE_PARM_DESC(sample_rate_min, "Minimal sample rate");
  52
  53 /*
  54  */
  55
  56 MODULE_LICENSE("GPL");
  57 MODULE_DESCRIPTION("Digigram Lola driver");
  58 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
  59
  60 #ifdef CONFIG_SND_DEBUG_VERBOSE
  61 static int debug;
  62 module_param(debug, int, 0644);
  63 #define verbose_debug(fmt, args...)                     \
  64         do { if (debug > 1) pr_debug(SFX fmt, ##args); } while (0)
  65 #else
  66 #define verbose_debug(fmt, args...)
  67 #endif
  68
  69 /*
  70  * pseudo-codec read/write via CORB/RIRB
  71  */
  72
  73 static int corb_send_verb(struct lola *chip, unsigned int nid,
  74                           unsigned int verb, unsigned int data,
  75                           unsigned int extdata)
  76 {
  77         unsigned long flags;
  78         int ret = -EIO;
  79
  80         chip->last_cmd_nid = nid;
  81         chip->last_verb = verb;
  82         chip->last_data = data;
  83         chip->last_extdata = extdata;
  84         data |= (nid << 20) | (verb << 8);
  85
  86         spin_lock_irqsave(&chip->reg_lock, flags);
  87         if (chip->rirb.cmds < LOLA_CORB_ENTRIES - 1) {
  88                 unsigned int wp = chip->corb.wp + 1;
  89                 wp %= LOLA_CORB_ENTRIES;
  90                 chip->corb.wp = wp;
  91                 chip->corb.buf[wp * 2] = cpu_to_le32(data);
  92                 chip->corb.buf[wp * 2 + 1] = cpu_to_le32(extdata);
  93                 lola_writew(chip, BAR0, CORBWP, wp);
  94                 chip->rirb.cmds++;
  95                 smp_wmb();
  96                 ret = 0;
  97         }
  98         spin_unlock_irqrestore(&chip->reg_lock, flags);
  99         return ret;
 100 }
 101
 102 static void lola_queue_unsol_event(struct lola *chip, unsigned int res,
 103                                    unsigned int res_ex)
 104 {
 105         lola_update_ext_clock_freq(chip, res);
 106 }
 107
 108 /* retrieve RIRB entry - called from interrupt handler */
 109 static void lola_update_rirb(struct lola *chip)
 110 {
 111         unsigned int rp, wp;
 112         u32 res, res_ex;
 113
 114         wp = lola_readw(chip, BAR0, RIRBWP);
 115         if (wp == chip->rirb.wp)
 116                 return;
 117         chip->rirb.wp = wp;
 118
 119         while (chip->rirb.rp != wp) {
 120                 chip->rirb.rp++;
 121                 chip->rirb.rp %= LOLA_CORB_ENTRIES;
 122
 123                 rp = chip->rirb.rp << 1; /* an RIRB entry is 8-bytes */
 124                 res_ex = le32_to_cpu(chip->rirb.buf[rp + 1]);
 125                 res = le32_to_cpu(chip->rirb.buf[rp]);
 126                 if (res_ex & LOLA_RIRB_EX_UNSOL_EV)
 127                         lola_queue_unsol_event(chip, res, res_ex);
 128                 else if (chip->rirb.cmds) {
 129                         chip->res = res;
 130                         chip->res_ex = res_ex;
 131                         smp_wmb();
 132                         chip->rirb.cmds--;
 133                 }
 134         }
 135 }
 136
 137 static int rirb_get_response(struct lola *chip, unsigned int *val,
 138                              unsigned int *extval)
 139 {
 140         unsigned long timeout;
 141
 142  again:
 143         timeout = jiffies + msecs_to_jiffies(1000);
 144         for (;;) {
 145                 if (chip->polling_mode) {
 146                         spin_lock_irq(&chip->reg_lock);
 147                         lola_update_rirb(chip);
 148                         spin_unlock_irq(&chip->reg_lock);
 149                 }
 150                 if (!chip->rirb.cmds) {
 151                         *val = chip->res;
 152                         if (extval)
 153                                 *extval = chip->res_ex;
 154                         verbose_debug("get_response: %x, %x\n",
 155                                       chip->res, chip->res_ex);
 156                         if (chip->res_ex & LOLA_RIRB_EX_ERROR) {
 157                                 dev_warn(chip->card->dev, "RIRB ERROR: "
 158                                        "NID=%x, verb=%x, data=%x, ext=%x\n",
 159                                        chip->last_cmd_nid,
 160                                        chip->last_verb, chip->last_data,
 161                                        chip->last_extdata);
 162                                 return -EIO;
 163                         }
 164                         return 0;
 165                 }
 166                 if (time_after(jiffies, timeout))
 167                         break;
 168                 udelay(20);
 169                 cond_resched();
 170         }
 171         dev_warn(chip->card->dev, "RIRB response error\n");
 172         if (!chip->polling_mode) {
 173                 dev_warn(chip->card->dev, "switching to polling mode\n");
 174                 chip->polling_mode = 1;
 175                 goto again;
 176         }
 177         return -EIO;
 178 }
 179
 180 /* aynchronous write of a codec verb with data */
 181 int lola_codec_write(struct lola *chip, unsigned int nid, unsigned int verb,
 182                      unsigned int data, unsigned int extdata)
 183 {
 184         verbose_debug("codec_write NID=%x, verb=%x, data=%x, ext=%x\n",
 185                       nid, verb, data, extdata);
 186         return corb_send_verb(chip, nid, verb, data, extdata);
 187 }
 188
 189 /* write a codec verb with data and read the returned status */
 190 int lola_codec_read(struct lola *chip, unsigned int nid, unsigned int verb,
 191                     unsigned int data, unsigned int extdata,
 192                     unsigned int *val, unsigned int *extval)
 193 {
 194         int err;
 195
 196         verbose_debug("codec_read NID=%x, verb=%x, data=%x, ext=%x\n",
 197                       nid, verb, data, extdata);
 198         err = corb_send_verb(chip, nid, verb, data, extdata);
 199         if (err < 0)
 200                 return err;
 201         err = rirb_get_response(chip, val, extval);
 202         return err;
 203 }
 204
 205 /* flush all pending codec writes */
 206 int lola_codec_flush(struct lola *chip)
 207 {
 208         unsigned int tmp;
 209         return rirb_get_response(chip, &tmp, NULL);
 210 }
 211
 212 /*
 213  * interrupt handler
 214  */
 215 static irqreturn_t lola_interrupt(int irq, void *dev_id)
 216 {
 217         struct lola *chip = dev_id;
 218         unsigned int notify_ins, notify_outs, error_ins, error_outs;
 219         int handled = 0;
 220         int i;
 221
 222         notify_ins = notify_outs = error_ins = error_outs = 0;
 223         spin_lock(&chip->reg_lock);
 224         for (;;) {
 225                 unsigned int status, in_sts, out_sts;
 226                 unsigned int reg;
 227
 228                 status = lola_readl(chip, BAR1, DINTSTS);
 229                 if (!status || status == -1)
 230                         break;
 231
 232                 in_sts = lola_readl(chip, BAR1, DIINTSTS);
 233                 out_sts = lola_readl(chip, BAR1, DOINTSTS);
 234
 235                 /* clear Input Interrupts */
 236                 for (i = 0; in_sts && i < chip->pcm[CAPT].num_streams; i++) {
 237                         if (!(in_sts & (1 << i)))
 238                                 continue;
 239                         in_sts &= ~(1 << i);
 240                         reg = lola_dsd_read(chip, i, STS);
 241                         if (reg & LOLA_DSD_STS_DESE) /* error */
 242                                 error_ins |= (1 << i);
 243                         if (reg & LOLA_DSD_STS_BCIS) /* notify */
 244                                 notify_ins |= (1 << i);
 245                         /* clear */
 246                         lola_dsd_write(chip, i, STS, reg);
 247                 }
 248
 249                 /* clear Output Interrupts */
 250                 for (i = 0; out_sts && i < chip->pcm[PLAY].num_streams; i++) {
 251                         if (!(out_sts & (1 << i)))
 252                                 continue;
 253                         out_sts &= ~(1 << i);
 254                         reg = lola_dsd_read(chip, i + MAX_STREAM_IN_COUNT, STS);
 255                         if (reg & LOLA_DSD_STS_DESE) /* error */
 256                                 error_outs |= (1 << i);
 257                         if (reg & LOLA_DSD_STS_BCIS) /* notify */
 258                                 notify_outs |= (1 << i);
 259                         lola_dsd_write(chip, i + MAX_STREAM_IN_COUNT, STS, reg);
 260                 }
 261
 262                 if (status & LOLA_DINT_CTRL) {
 263                         unsigned char rbsts; /* ring status is byte access */
 264                         rbsts = lola_readb(chip, BAR0, RIRBSTS);
 265                         rbsts &= LOLA_RIRB_INT_MASK;
 266                         if (rbsts)
 267                                 lola_writeb(chip, BAR0, RIRBSTS, rbsts);
 268                         rbsts = lola_readb(chip, BAR0, CORBSTS);
 269                         rbsts &= LOLA_CORB_INT_MASK;
 270                         if (rbsts)
 271                                 lola_writeb(chip, BAR0, CORBSTS, rbsts);
 272
 273                         lola_update_rirb(chip);
 274                 }
 275
 276                 if (status & (LOLA_DINT_FIFOERR | LOLA_DINT_MUERR)) {
 277                         /* clear global fifo error interrupt */
 278                         lola_writel(chip, BAR1, DINTSTS,
 279                                     (status & (LOLA_DINT_FIFOERR | LOLA_DINT_MUERR)));
 280                 }
 281                 handled = 1;
 282         }
 283         spin_unlock(&chip->reg_lock);
 284
 285         lola_pcm_update(chip, &chip->pcm[CAPT], notify_ins);
 286         lola_pcm_update(chip, &chip->pcm[PLAY], notify_outs);
 287
 288         return IRQ_RETVAL(handled);
 289 }
 290
 291
 292 /*
 293  * controller
 294  */
 295 static int reset_controller(struct lola *chip)
 296 {
 297         unsigned int gctl = lola_readl(chip, BAR0, GCTL);
 298         unsigned long end_time;
 299
 300         if (gctl) {
 301                 /* to be sure */
 302                 lola_writel(chip, BAR1, BOARD_MODE, 0);
 303                 return 0;
 304         }
 305
 306         chip->cold_reset = 1;
 307         lola_writel(chip, BAR0, GCTL, LOLA_GCTL_RESET);
 308         end_time = jiffies + msecs_to_jiffies(200);
 309         do {
 310                 msleep(1);
 311                 gctl = lola_readl(chip, BAR0, GCTL);
 312                 if (gctl)
 313                         break;
 314         } while (time_before(jiffies, end_time));
 315         if (!gctl) {
 316                 dev_err(chip->card->dev, "cannot reset controller\n");
 317                 return -EIO;
 318         }
 319         return 0;
 320 }
 321
 322 static void lola_irq_enable(struct lola *chip)
 323 {
 324         unsigned int val;
 325
 326         /* enalbe all I/O streams */
 327         val = (1 << chip->pcm[PLAY].num_streams) - 1;
 328         lola_writel(chip, BAR1, DOINTCTL, val);
 329         val = (1 << chip->pcm[CAPT].num_streams) - 1;
 330         lola_writel(chip, BAR1, DIINTCTL, val);
 331
 332         /* enable global irqs */
 333         val = LOLA_DINT_GLOBAL | LOLA_DINT_CTRL | LOLA_DINT_FIFOERR |
 334                 LOLA_DINT_MUERR;
 335         lola_writel(chip, BAR1, DINTCTL, val);
 336 }
 337
 338 static void lola_irq_disable(struct lola *chip)
 339 {
 340         lola_writel(chip, BAR1, DINTCTL, 0);
 341         lola_writel(chip, BAR1, DIINTCTL, 0);
 342         lola_writel(chip, BAR1, DOINTCTL, 0);
 343 }
 344
 345 static int setup_corb_rirb(struct lola *chip)
 346 {
 347         int err;
 348         unsigned char tmp;
 349         unsigned long end_time;
 350
 351         err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
 352                                   &chip->pci->dev,
 353                                   PAGE_SIZE, &chip->rb);
 354         if (err < 0)
 355                 return err;
 356
 357         chip->corb.addr = chip->rb.addr;
 358         chip->corb.buf = (__le32 *)chip->rb.area;
 359         chip->rirb.addr = chip->rb.addr + 2048;
 360         chip->rirb.buf = (__le32 *)(chip->rb.area + 2048);
 361
 362         /* disable ringbuffer DMAs */
 363         lola_writeb(chip, BAR0, RIRBCTL, 0);
 364         lola_writeb(chip, BAR0, CORBCTL, 0);
 365
 366         end_time = jiffies + msecs_to_jiffies(200);
 367         do {
 368                 if (!lola_readb(chip, BAR0, RIRBCTL) &&
 369                     !lola_readb(chip, BAR0, CORBCTL))
 370                         break;
 371                 msleep(1);
 372         } while (time_before(jiffies, end_time));
 373
 374         /* CORB set up */
 375         lola_writel(chip, BAR0, CORBLBASE, (u32)chip->corb.addr);
 376         lola_writel(chip, BAR0, CORBUBASE, upper_32_bits(chip->corb.addr));
 377         /* set the corb size to 256 entries */
 378         lola_writeb(chip, BAR0, CORBSIZE, 0x02);
 379         /* set the corb write pointer to 0 */
 380         lola_writew(chip, BAR0, CORBWP, 0);
 381         /* reset the corb hw read pointer */
 382         lola_writew(chip, BAR0, CORBRP, LOLA_RBRWP_CLR);
 383         /* enable corb dma */
 384         lola_writeb(chip, BAR0, CORBCTL, LOLA_RBCTL_DMA_EN);
 385         /* clear flags if set */
 386         tmp = lola_readb(chip, BAR0, CORBSTS) & LOLA_CORB_INT_MASK;
 387         if (tmp)
 388                 lola_writeb(chip, BAR0, CORBSTS, tmp);
 389         chip->corb.wp = 0;
 390
 391         /* RIRB set up */
 392         lola_writel(chip, BAR0, RIRBLBASE, (u32)chip->rirb.addr);
 393         lola_writel(chip, BAR0, RIRBUBASE, upper_32_bits(chip->rirb.addr));
 394         /* set the rirb size to 256 entries */
 395         lola_writeb(chip, BAR0, RIRBSIZE, 0x02);
 396         /* reset the rirb hw write pointer */
 397         lola_writew(chip, BAR0, RIRBWP, LOLA_RBRWP_CLR);
 398         /* set N=1, get RIRB response interrupt for new entry */
 399         lola_writew(chip, BAR0, RINTCNT, 1);
 400         /* enable rirb dma and response irq */
 401         lola_writeb(chip, BAR0, RIRBCTL, LOLA_RBCTL_DMA_EN | LOLA_RBCTL_IRQ_EN);
 402         /* clear flags if set */
 403         tmp =  lola_readb(chip, BAR0, RIRBSTS) & LOLA_RIRB_INT_MASK;
 404         if (tmp)
 405                 lola_writeb(chip, BAR0, RIRBSTS, tmp);
 406         chip->rirb.rp = chip->rirb.cmds = 0;
 407
 408         return 0;
 409 }
 410
 411 static void stop_corb_rirb(struct lola *chip)
 412 {
 413         /* disable ringbuffer DMAs */
 414         lola_writeb(chip, BAR0, RIRBCTL, 0);
 415         lola_writeb(chip, BAR0, CORBCTL, 0);
 416 }
 417
 418 static void lola_reset_setups(struct lola *chip)
 419 {
 420         /* update the granularity */
 421         lola_set_granularity(chip, chip->granularity, true);
 422         /* update the sample clock */
 423         lola_set_clock_index(chip, chip->clock.cur_index);
 424         /* enable unsolicited events of the clock widget */
 425         lola_enable_clock_events(chip);
 426         /* update the analog gains */
 427         lola_setup_all_analog_gains(chip, CAPT, false); /* input, update */
 428         /* update SRC configuration if applicable */
 429         lola_set_src_config(chip, chip->input_src_mask, false);
 430         /* update the analog outputs */
 431         lola_setup_all_analog_gains(chip, PLAY, false); /* output, update */
 432 }
 433
 434 static int lola_parse_tree(struct lola *chip)
 435 {
 436         unsigned int val;
 437         int nid, err;
 438
 439         err = lola_read_param(chip, 0, LOLA_PAR_VENDOR_ID, &val);
 440         if (err < 0) {
 441                 dev_err(chip->card->dev, "Can't read VENDOR_ID\n");
 442                 return err;
 443         }
 444         val >>= 16;
 445         if (val != 0x1369) {
 446                 dev_err(chip->card->dev, "Unknown codec vendor 0x%x\n", val);
 447                 return -EINVAL;
 448         }
 449
 450         err = lola_read_param(chip, 1, LOLA_PAR_FUNCTION_TYPE, &val);
 451         if (err < 0) {
 452                 dev_err(chip->card->dev, "Can't read FUNCTION_TYPE\n");
 453                 return err;
 454         }
 455         if (val != 1) {
 456                 dev_err(chip->card->dev, "Unknown function type %d\n", val);
 457                 return -EINVAL;
 458         }
 459
 460         err = lola_read_param(chip, 1, LOLA_PAR_SPECIFIC_CAPS, &val);
 461         if (err < 0) {
 462                 dev_err(chip->card->dev, "Can't read SPECCAPS\n");
 463                 return err;
 464         }
 465         chip->lola_caps = val;
 466         chip->pin[CAPT].num_pins = LOLA_AFG_INPUT_PIN_COUNT(chip->lola_caps);
 467         chip->pin[PLAY].num_pins = LOLA_AFG_OUTPUT_PIN_COUNT(chip->lola_caps);
 468         dev_dbg(chip->card->dev, "speccaps=0x%x, pins in=%d, out=%d\n",
 469                     chip->lola_caps,
 470                     chip->pin[CAPT].num_pins, chip->pin[PLAY].num_pins);
 471
 472         if (chip->pin[CAPT].num_pins > MAX_AUDIO_INOUT_COUNT ||
 473             chip->pin[PLAY].num_pins > MAX_AUDIO_INOUT_COUNT) {
 474                 dev_err(chip->card->dev, "Invalid Lola-spec caps 0x%x\n", val);
 475                 return -EINVAL;
 476         }
 477
 478         nid = 0x02;
 479         err = lola_init_pcm(chip, CAPT, &nid);
 480         if (err < 0)
 481                 return err;
 482         err = lola_init_pcm(chip, PLAY, &nid);
 483         if (err < 0)
 484                 return err;
 485
 486         err = lola_init_pins(chip, CAPT, &nid);
 487         if (err < 0)
 488                 return err;
 489         err = lola_init_pins(chip, PLAY, &nid);
 490         if (err < 0)
 491                 return err;
 492
 493         if (LOLA_AFG_CLOCK_WIDGET_PRESENT(chip->lola_caps)) {
 494                 err = lola_init_clock_widget(chip, nid);
 495                 if (err < 0)
 496                         return err;
 497                 nid++;
 498         }
 499         if (LOLA_AFG_MIXER_WIDGET_PRESENT(chip->lola_caps)) {
 500                 err = lola_init_mixer_widget(chip, nid);
 501                 if (err < 0)
 502                         return err;
 503                 nid++;
 504         }
 505
 506         /* enable unsolicited events of the clock widget */
 507         err = lola_enable_clock_events(chip);
 508         if (err < 0)
 509                 return err;
 510
 511         /* if last ResetController was not a ColdReset, we don't know
 512          * the state of the card; initialize here again
 513          */
 514         if (!chip->cold_reset) {
 515                 lola_reset_setups(chip);
 516                 chip->cold_reset = 1;
 517         } else {
 518                 /* set the granularity if it is not the default */
 519                 if (chip->granularity != LOLA_GRANULARITY_MIN)
 520                         lola_set_granularity(chip, chip->granularity, true);
 521         }
 522
 523         return 0;
 524 }
 525
 526 static void lola_stop_hw(struct lola *chip)
 527 {
 528         stop_corb_rirb(chip);
 529         lola_irq_disable(chip);
 530 }
 531
 532 static void lola_free(struct lola *chip)
 533 {
 534         if (chip->initialized)
 535                 lola_stop_hw(chip);
 536         lola_free_pcm(chip);
 537         lola_free_mixer(chip);
 538         if (chip->irq >= 0)
 539                 free_irq(chip->irq, (void *)chip);
 540         iounmap(chip->bar[0].remap_addr);
 541         iounmap(chip->bar[1].remap_addr);
 542         if (chip->rb.area)
 543                 snd_dma_free_pages(&chip->rb);
 544         pci_release_regions(chip->pci);
 545         pci_disable_device(chip->pci);
 546         kfree(chip);
 547 }
 548
 549 static int lola_dev_free(struct snd_device *device)
 550 {
 551         lola_free(device->device_data);
 552         return 0;
 553 }
 554
 555 static int lola_create(struct snd_card *card, struct pci_dev *pci,
 556                        int dev, struct lola **rchip)
 557 {
 558         struct lola *chip;
 559         int err;
 560         unsigned int dever;
 561         static const struct snd_device_ops ops = {
 562                 .dev_free = lola_dev_free,
 563         };
 564
 565         *rchip = NULL;
 566
 567         err = pci_enable_device(pci);
 568         if (err < 0)
 569                 return err;
 570
 571         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 572         if (!chip) {
 573                 pci_disable_device(pci);
 574                 return -ENOMEM;
 575         }
 576
 577         spin_lock_init(&chip->reg_lock);
 578         mutex_init(&chip->open_mutex);
 579         chip->card = card;
 580         chip->pci = pci;
 581         chip->irq = -1;
 582
 583         chip->granularity = granularity[dev];
 584         switch (chip->granularity) {
 585         case 8:
 586                 chip->sample_rate_max = 48000;
 587                 break;
 588         case 16:
 589                 chip->sample_rate_max = 96000;
 590                 break;
 591         case 32:
 592                 chip->sample_rate_max = 192000;
 593                 break;
 594         default:
 595                 dev_warn(chip->card->dev,
 596                            "Invalid granularity %d, reset to %d\n",
 597                            chip->granularity, LOLA_GRANULARITY_MAX);
 598                 chip->granularity = LOLA_GRANULARITY_MAX;
 599                 chip->sample_rate_max = 192000;
 600                 break;
 601         }
 602         chip->sample_rate_min = sample_rate_min[dev];
 603         if (chip->sample_rate_min > chip->sample_rate_max) {
 604                 dev_warn(chip->card->dev,
 605                            "Invalid sample_rate_min %d, reset to 16000\n",
 606                            chip->sample_rate_min);
 607                 chip->sample_rate_min = 16000;
 608         }
 609
 610         err = pci_request_regions(pci, DRVNAME);
 611         if (err < 0) {
 612                 kfree(chip);
 613                 pci_disable_device(pci);
 614                 return err;
 615         }
 616
 617         chip->bar[0].addr = pci_resource_start(pci, 0);
 618         chip->bar[0].remap_addr = pci_ioremap_bar(pci, 0);
 619         chip->bar[1].addr = pci_resource_start(pci, 2);
 620         chip->bar[1].remap_addr = pci_ioremap_bar(pci, 2);
 621         if (!chip->bar[0].remap_addr || !chip->bar[1].remap_addr) {
 622                 dev_err(chip->card->dev, "ioremap error\n");
 623                 err = -ENXIO;
 624                 goto errout;
 625         }
 626
 627         pci_set_master(pci);
 628
 629         err = reset_controller(chip);
 630         if (err < 0)
 631                 goto errout;
 632
 633         if (request_irq(pci->irq, lola_interrupt, IRQF_SHARED,
 634                         KBUILD_MODNAME, chip)) {
 635                 dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
 636                 err = -EBUSY;
 637                 goto errout;
 638         }
 639         chip->irq = pci->irq;
 640         card->sync_irq = chip->irq;
 641
 642         dever = lola_readl(chip, BAR1, DEVER);
 643         chip->pcm[CAPT].num_streams = (dever >> 0) & 0x3ff;
 644         chip->pcm[PLAY].num_streams = (dever >> 10) & 0x3ff;
 645         chip->version = (dever >> 24) & 0xff;
 646         dev_dbg(chip->card->dev, "streams in=%d, out=%d, version=0x%x\n",
 647                     chip->pcm[CAPT].num_streams, chip->pcm[PLAY].num_streams,
 648                     chip->version);
 649
 650         /* Test LOLA_BAR1_DEVER */
 651         if (chip->pcm[CAPT].num_streams > MAX_STREAM_IN_COUNT ||
 652             chip->pcm[PLAY].num_streams > MAX_STREAM_OUT_COUNT ||
 653             (!chip->pcm[CAPT].num_streams &&
 654              !chip->pcm[PLAY].num_streams)) {
 655                 dev_err(chip->card->dev, "invalid DEVER = %x\n", dever);
 656                 err = -EINVAL;
 657                 goto errout;
 658         }
 659
 660         err = setup_corb_rirb(chip);
 661         if (err < 0)
 662                 goto errout;
 663
 664         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
 665         if (err < 0) {
 666                 dev_err(chip->card->dev, "Error creating device [card]!\n");
 667                 goto errout;
 668         }
 669
 670         strcpy(card->driver, "Lola");
 671         strscpy(card->shortname, "Digigram Lola", sizeof(card->shortname));
 672         snprintf(card->longname, sizeof(card->longname),
 673                  "%s at 0x%lx irq %i",
 674                  card->shortname, chip->bar[0].addr, chip->irq);
 675         strcpy(card->mixername, card->shortname);
 676
 677         lola_irq_enable(chip);
 678
 679         chip->initialized = 1;
 680         *rchip = chip;
 681         return 0;
 682
 683  errout:
 684         lola_free(chip);
 685         return err;
 686 }
 687
 688 static int lola_probe(struct pci_dev *pci,
 689                       const struct pci_device_id *pci_id)
 690 {
 691         static int dev;
 692         struct snd_card *card;
 693         struct lola *chip;
 694         int err;
 695
 696         if (dev >= SNDRV_CARDS)
 697                 return -ENODEV;
 698         if (!enable[dev]) {
 699                 dev++;
 700                 return -ENOENT;
 701         }
 702
 703         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
 704                            0, &card);
 705         if (err < 0) {
 706                 dev_err(&pci->dev, "Error creating card!\n");
 707                 return err;
 708         }
 709
 710         err = lola_create(card, pci, dev, &chip);
 711         if (err < 0)
 712                 goto out_free;
 713         card->private_data = chip;
 714
 715         err = lola_parse_tree(chip);
 716         if (err < 0)
 717                 goto out_free;
 718
 719         err = lola_create_pcm(chip);
 720         if (err < 0)
 721                 goto out_free;
 722
 723         err = lola_create_mixer(chip);
 724         if (err < 0)
 725                 goto out_free;
 726
 727         lola_proc_debug_new(chip);
 728
 729         err = snd_card_register(card);
 730         if (err < 0)
 731                 goto out_free;
 732
 733         pci_set_drvdata(pci, card);
 734         dev++;
 735         return err;
 736 out_free:
 737         snd_card_free(card);
 738         return err;
 739 }
 740
 741 static void lola_remove(struct pci_dev *pci)
 742 {
 743         snd_card_free(pci_get_drvdata(pci));
 744 }
 745
 746 /* PCI IDs */
 747 static const struct pci_device_id lola_ids[] = {
 748         { PCI_VDEVICE(DIGIGRAM, 0x0001) },
 749         { 0, }
 750 };
 751 MODULE_DEVICE_TABLE(pci, lola_ids);
 752
 753 /* pci_driver definition */
 754 static struct pci_driver lola_driver = {
 755         .name = KBUILD_MODNAME,
 756         .id_table = lola_ids,
 757         .probe = lola_probe,
 758         .remove = lola_remove,
 759 };
 760
 761 module_pci_driver(lola_driver);