sound/pci/lola/lola.c

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

DEFINITIONS
