lola.c 18 KB

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