Lines Matching +full:mute +full:- +full:enable
1 // SPDX-License-Identifier: GPL-2.0-only
41 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
43 /* Enable this card */
44 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
50 module_param_array(enable, bool, NULL, 0444);
51 MODULE_PARM_DESC(enable, "Enable Sun CS4231 soundcard.");
68 void (*enable)(struct cs4231_dma_control *dma_cont, int on);
121 * now.... -DaveM
125 #include <sound/cs4231-regs.h>
128 #define CS4231U(chip, x) ((chip)->port + ((c_d_c_CS4231##x) << 2))
142 /* Defines for SBUS DMA-routines */
157 #define APC_XINT_ENA 0x80000 /* General ext int. enable */
164 #define APC_XINT_PENA 0x1000 /* play pipe empty Int enable */
168 #define APC_XINT_CENA 0x100 /* Cap. pipe empty int enable */
222 0x00, /* 00/00 - lic */
223 0x00, /* 01/01 - ric */
224 0x9f, /* 02/02 - la1ic */
225 0x9f, /* 03/03 - ra1ic */
226 0x9f, /* 04/04 - la2ic */
227 0x9f, /* 05/05 - ra2ic */
228 0xbf, /* 06/06 - loc */
229 0xbf, /* 07/07 - roc */
230 0x20, /* 08/08 - pdfr */
231 CS4231_AUTOCALIB, /* 09/09 - ic */
232 0x00, /* 0a/10 - pc */
233 0x00, /* 0b/11 - ti */
234 CS4231_MODE2, /* 0c/12 - mi */
235 0x00, /* 0d/13 - lbc */
236 0x00, /* 0e/14 - pbru */
237 0x00, /* 0f/15 - pbrl */
238 0x80, /* 10/16 - afei */
239 0x01, /* 11/17 - afeii */
240 0x9f, /* 12/18 - llic */
241 0x9f, /* 13/19 - rlic */
242 0x00, /* 14/20 - tlb */
243 0x00, /* 15/21 - thb */
244 0x00, /* 16/22 - la3mic/reserved */
245 0x00, /* 17/23 - ra3mic/reserved */
246 0x00, /* 18/24 - afs */
247 0x00, /* 19/25 - lamoc/version */
248 0x00, /* 1a/26 - mioc */
249 0x00, /* 1b/27 - ramoc/reserved */
250 0x20, /* 1c/28 - cdfr */
251 0x00, /* 1d/29 - res4 */
252 0x00, /* 1e/30 - cbru */
253 0x00, /* 1f/31 - cbrl */
258 if (cp->flags & CS4231_FLAG_EBUS)
267 if (cp->flags & CS4231_FLAG_EBUS)
281 for (timeout = 250; timeout > 0; timeout--) {
295 dev_dbg(chip->card->dev,
296 "out: auto calibration time out - reg = 0x%x, value = 0x%x\n",
299 __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL));
308 unsigned char tmp = (chip->image[reg] & mask) | value;
310 chip->image[reg] = tmp;
311 if (!chip->calibrate_mute)
319 chip->image[reg] = value;
328 dev_dbg(chip->card->dev,
329 "in: auto calibration time out - reg = 0x%x\n",
332 __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL));
346 for (timeout = 5; timeout > 0; timeout--)
350 for (timeout = 500; timeout > 0; timeout--) {
362 guard(spinlock_irqsave)(&chip->lock);
366 dev_dbg(chip->card->dev,
367 "mce_up - auto calibration time out (0)\n");
369 chip->mce_bit |= CS4231_MCE;
372 dev_dbg(chip->card->dev,
373 "mce_up [%p]: serious init problem - codec still busy\n",
374 chip->port);
376 __cs4231_writeb(chip, chip->mce_bit | (timeout & 0x1f),
386 spin_lock_irqsave(&chip->lock, flags);
389 dev_dbg(chip->card->dev,
390 "mce_down [%p] - auto calibration time out (0)\n",
393 chip->mce_bit &= ~CS4231_MCE;
395 __cs4231_writeb(chip, chip->mce_bit | (reg & 0x1f),
398 dev_dbg(chip->card->dev,
399 "mce_down [%p]: serious init problem - codec still busy\n",
400 chip->port);
402 spin_unlock_irqrestore(&chip->lock, flags);
407 * Wait for auto-calibration (AC) process to finish, i.e. ACI to go low.
411 spin_unlock_irqrestore(&chip->lock, flags);
413 spin_lock_irqsave(&chip->lock, flags);
417 spin_unlock_irqrestore(&chip->lock, flags);
420 dev_err(chip->card->dev,
421 "mce_down - auto calibration time out (2)\n");
428 struct snd_pcm_runtime *runtime = substream->runtime;
437 if (dma_cont->request(dma_cont,
438 runtime->dma_addr + offset, period_size))
440 (*periods_sent) = ((*periods_sent) + 1) % runtime->periods;
451 dma_cont = &chip->p_dma;
453 dma_cont->prepare(dma_cont, 0);
454 dma_cont->enable(dma_cont, 1);
456 chip->playback_substream,
457 &chip->p_periods_sent);
459 dma_cont->enable(dma_cont, 0);
463 dma_cont = &chip->c_dma;
465 dma_cont->prepare(dma_cont, 1);
466 dma_cont->enable(dma_cont, 1);
468 chip->capture_substream,
469 &chip->c_periods_sent);
471 dma_cont->enable(dma_cont, 0);
489 if (s == chip->playback_substream) {
492 } else if (s == chip->capture_substream) {
498 guard(spinlock_irqsave)(&chip->lock);
501 chip->image[CS4231_IFACE_CTRL] |= what;
504 chip->image[CS4231_IFACE_CTRL] &= ~what;
507 chip->image[CS4231_IFACE_CTRL]);
511 result = -EINVAL;
561 static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute)
563 mute = mute ? 1 : 0;
564 guard(spinlock_irqsave)(&chip->lock);
565 if (chip->calibrate_mute == mute)
568 if (!mute) {
570 chip->image[CS4231_LEFT_INPUT]);
572 chip->image[CS4231_RIGHT_INPUT]);
574 chip->image[CS4231_LOOPBACK]);
577 mute ? 0x80 : chip->image[CS4231_AUX1_LEFT_INPUT]);
579 mute ? 0x80 : chip->image[CS4231_AUX1_RIGHT_INPUT]);
581 mute ? 0x80 : chip->image[CS4231_AUX2_LEFT_INPUT]);
583 mute ? 0x80 : chip->image[CS4231_AUX2_RIGHT_INPUT]);
585 mute ? 0x80 : chip->image[CS4231_LEFT_OUTPUT]);
587 mute ? 0x80 : chip->image[CS4231_RIGHT_OUTPUT]);
589 mute ? 0x80 : chip->image[CS4231_LEFT_LINE_IN]);
591 mute ? 0x80 : chip->image[CS4231_RIGHT_LINE_IN]);
593 mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]);
594 chip->calibrate_mute = mute;
601 guard(mutex)(&chip->mce_mutex);
606 scoped_guard(spinlock_irqsave, &chip->lock) {
608 (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ?
609 (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) :
624 guard(mutex)(&chip->mce_mutex);
629 spin_lock_irqsave(&chip->lock, flags);
630 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
632 ((chip->image[CS4231_PLAYBK_FORMAT]) & 0xf0) |
634 spin_unlock_irqrestore(&chip->lock, flags);
637 spin_lock_irqsave(&chip->lock, flags);
640 spin_unlock_irqrestore(&chip->lock, flags);
655 return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920;
663 guard(spinlock_irqsave)(&chip->lock);
664 ticks = timer->sticks;
665 if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 ||
666 (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] ||
667 (unsigned char)ticks != chip->image[CS4231_TIMER_LOW]) {
669 chip->image[CS4231_TIMER_HIGH] =
672 chip->image[CS4231_TIMER_LOW] =
675 chip->image[CS4231_ALT_FEATURE_1] |
686 guard(spinlock_irqsave)(&chip->lock);
687 chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE;
689 chip->image[CS4231_ALT_FEATURE_1]);
702 scoped_guard(spinlock_irqsave, &chip->lock) {
703 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
708 chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB;
709 snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
718 scoped_guard(spinlock_irqsave, &chip->lock) {
720 chip->image[CS4231_ALT_FEATURE_1]);
725 pr_debug("init: (3) - afei = 0x%x\n",
726 chip->image[CS4231_ALT_FEATURE_1]);
729 scoped_guard(spinlock_irqsave, &chip->lock) {
731 chip->image[CS4231_ALT_FEATURE_2]);
735 scoped_guard(spinlock_irqsave, &chip->lock) {
737 chip->image[CS4231_PLAYBK_FORMAT]);
746 scoped_guard(spinlock_irqsave, &chip->lock) {
747 snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]);
758 guard(mutex)(&chip->open_mutex);
759 if ((chip->mode & mode))
760 return -EAGAIN;
761 if (chip->mode & CS4231_MODE_OPEN) {
762 chip->mode |= mode;
765 /* ok. now enable and ack CODEC IRQ */
766 guard(spinlock_irqsave)(&chip->lock);
779 chip->mode = mode;
787 guard(mutex)(&chip->open_mutex);
788 chip->mode &= ~mode;
789 if (chip->mode & CS4231_MODE_OPEN)
794 spin_lock_irqsave(&chip->lock, flags);
801 if (chip->image[CS4231_IFACE_CTRL] &
804 spin_unlock_irqrestore(&chip->lock, flags);
806 spin_lock_irqsave(&chip->lock, flags);
807 chip->image[CS4231_IFACE_CTRL] &=
811 chip->image[CS4231_IFACE_CTRL]);
812 spin_unlock_irqrestore(&chip->lock, flags);
814 spin_lock_irqsave(&chip->lock, flags);
821 spin_unlock_irqrestore(&chip->lock, flags);
825 chip->mode = 0;
878 struct snd_pcm_runtime *runtime = substream->runtime;
880 guard(spinlock_irqsave)(&chip->lock);
882 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
885 if (WARN_ON(runtime->period_size > 0xffff + 1))
886 return -EINVAL;
888 chip->p_periods_sent = 0;
911 guard(spinlock_irqsave)(&chip->lock);
912 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE |
916 chip->c_periods_sent = 0;
925 guard(spinlock_irqsave)(&chip->lock);
930 chip->capture_substream->runtime->overrange++;
935 if (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE) {
936 snd_pcm_period_elapsed(chip->playback_substream);
937 snd_cs4231_advance_dma(&chip->p_dma, chip->playback_substream,
938 &chip->p_periods_sent);
944 if (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) {
945 snd_pcm_period_elapsed(chip->capture_substream);
946 snd_cs4231_advance_dma(&chip->c_dma, chip->capture_substream,
947 &chip->c_periods_sent);
955 struct cs4231_dma_control *dma_cont = &chip->p_dma;
958 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE))
960 ptr = dma_cont->address(dma_cont);
962 ptr -= substream->runtime->dma_addr;
964 return bytes_to_frames(substream->runtime, ptr);
971 struct cs4231_dma_control *dma_cont = &chip->c_dma;
974 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE))
976 ptr = dma_cont->address(dma_cont);
978 ptr -= substream->runtime->dma_addr;
980 return bytes_to_frames(substream->runtime, ptr);
995 guard(spinlock_irqsave)(&chip->lock);
1003 dev_dbg(chip->card->dev,
1004 "cs4231: port = %p, id = 0x%x\n", chip->port, id);
1006 return -ENODEV; /* no valid device found */
1008 scoped_guard(spinlock_irqsave, &chip->lock) {
1015 chip->image[CS4231_MISC_INFO] = CS4231_MODE2;
1016 chip->image[CS4231_IFACE_CTRL] =
1017 chip->image[CS4231_IFACE_CTRL] & ~CS4231_SINGLE_DMA;
1018 chip->image[CS4231_ALT_FEATURE_1] = 0x80;
1019 chip->image[CS4231_ALT_FEATURE_2] = 0x01;
1021 chip->image[CS4231_ALT_FEATURE_2] |= 0x02;
1023 ptr = (unsigned char *) &chip->image;
1027 scoped_guard(spinlock_irqsave, &chip->lock) {
1092 struct snd_pcm_runtime *runtime = substream->runtime;
1095 runtime->hw = snd_cs4231_playback;
1100 chip->playback_substream = substream;
1101 chip->p_periods_sent = 0;
1111 struct snd_pcm_runtime *runtime = substream->runtime;
1114 runtime->hw = snd_cs4231_capture;
1119 chip->capture_substream = substream;
1120 chip->c_periods_sent = 0;
1132 chip->playback_substream = NULL;
1142 chip->capture_substream = NULL;
1147 /* XXX We can do some power-management, in particular on EBUS using
1171 struct snd_cs4231 *chip = card->private_data;
1185 pcm->private_data = chip;
1186 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
1187 strscpy(pcm->name, "CS4231");
1190 &chip->op->dev, 64 * 1024, 128 * 1024);
1192 chip->pcm = pcm;
1199 struct snd_cs4231 *chip = card->private_data;
1207 tid.card = card->number;
1213 strscpy(timer->name, "CS4231");
1214 timer->private_data = chip;
1215 timer->hw = snd_cs4231_timer_table;
1216 chip->timer = timer;
1240 guard(spinlock_irqsave)(&chip->lock);
1241 ucontrol->value.enumerated.item[0] =
1242 (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6;
1243 ucontrol->value.enumerated.item[1] =
1244 (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6;
1256 if (ucontrol->value.enumerated.item[0] > 3 ||
1257 ucontrol->value.enumerated.item[1] > 3)
1258 return -EINVAL;
1259 left = ucontrol->value.enumerated.item[0] << 6;
1260 right = ucontrol->value.enumerated.item[1] << 6;
1262 guard(spinlock_irqsave)(&chip->lock);
1264 left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left;
1265 right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right;
1266 change = left != chip->image[CS4231_LEFT_INPUT] ||
1267 right != chip->image[CS4231_RIGHT_INPUT];
1277 int mask = (kcontrol->private_value >> 16) & 0xff;
1279 uinfo->type = (mask == 1) ?
1281 uinfo->count = 1;
1282 uinfo->value.integer.min = 0;
1283 uinfo->value.integer.max = mask;
1292 int reg = kcontrol->private_value & 0xff;
1293 int shift = (kcontrol->private_value >> 8) & 0xff;
1294 int mask = (kcontrol->private_value >> 16) & 0xff;
1295 int invert = (kcontrol->private_value >> 24) & 0xff;
1297 guard(spinlock_irqsave)(&chip->lock);
1299 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
1302 ucontrol->value.integer.value[0] =
1303 (mask - ucontrol->value.integer.value[0]);
1312 int reg = kcontrol->private_value & 0xff;
1313 int shift = (kcontrol->private_value >> 8) & 0xff;
1314 int mask = (kcontrol->private_value >> 16) & 0xff;
1315 int invert = (kcontrol->private_value >> 24) & 0xff;
1319 val = (ucontrol->value.integer.value[0] & mask);
1321 val = mask - val;
1324 guard(spinlock_irqsave)(&chip->lock);
1326 val = (chip->image[reg] & ~(mask << shift)) | val;
1327 change = val != chip->image[reg];
1336 int mask = (kcontrol->private_value >> 24) & 0xff;
1338 uinfo->type = mask == 1 ?
1340 uinfo->count = 2;
1341 uinfo->value.integer.min = 0;
1342 uinfo->value.integer.max = mask;
1351 int left_reg = kcontrol->private_value & 0xff;
1352 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1353 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1354 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1355 int mask = (kcontrol->private_value >> 24) & 0xff;
1356 int invert = (kcontrol->private_value >> 22) & 1;
1358 guard(spinlock_irqsave)(&chip->lock);
1360 ucontrol->value.integer.value[0] =
1361 (chip->image[left_reg] >> shift_left) & mask;
1362 ucontrol->value.integer.value[1] =
1363 (chip->image[right_reg] >> shift_right) & mask;
1366 ucontrol->value.integer.value[0] =
1367 (mask - ucontrol->value.integer.value[0]);
1368 ucontrol->value.integer.value[1] =
1369 (mask - ucontrol->value.integer.value[1]);
1379 int left_reg = kcontrol->private_value & 0xff;
1380 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1381 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1382 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1383 int mask = (kcontrol->private_value >> 24) & 0xff;
1384 int invert = (kcontrol->private_value >> 22) & 1;
1388 val1 = ucontrol->value.integer.value[0] & mask;
1389 val2 = ucontrol->value.integer.value[1] & mask;
1391 val1 = mask - val1;
1392 val2 = mask - val2;
1397 guard(spinlock_irqsave)(&chip->lock);
1399 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
1400 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
1401 change = val1 != chip->image[left_reg];
1402 change |= val2 != chip->image[right_reg];
1464 struct snd_cs4231 *chip = card->private_data;
1467 if (snd_BUG_ON(!chip || !chip->pcm))
1468 return -EINVAL;
1470 strscpy(card->mixername, chip->pcm->name);
1493 return -ENODEV;
1495 if (!enable[dev]) {
1497 return -ENOENT;
1500 err = snd_card_new(&op->dev, index[dev], id[dev], THIS_MODULE,
1505 strscpy(card->driver, "CS4231");
1506 strscpy(card->shortname, "Sun CS4231");
1508 chip = card->private_data;
1509 chip->card = card;
1517 struct snd_cs4231 *chip = card->private_data;
1536 dev_set_drvdata(&chip->op->dev, chip);
1559 csr = sbus_readl(chip->port + APCCSR);
1561 sbus_writel(csr, chip->port + APCCSR);
1578 if (chip->timer)
1579 snd_timer_interrupt(chip->timer, chip->timer->sticks);
1586 guard(spinlock_irqsave)(&chip->lock);
1600 struct sbus_dma_info *base = &dma_cont->sbus_info;
1603 return -EINVAL;
1604 guard(spinlock_irqsave)(&base->lock);
1605 csr = sbus_readl(base->regs + APCCSR);
1607 if (base->dir == APC_PLAY)
1610 return -EINVAL;
1612 if (base->dir == APC_PLAY)
1615 return -EBUSY;
1616 sbus_writel(bus_addr, base->regs + base->dir + APCNVA);
1617 sbus_writel(len, base->regs + base->dir + APCNC);
1624 struct sbus_dma_info *base = &dma_cont->sbus_info;
1626 guard(spinlock_irqsave)(&base->lock);
1627 csr = sbus_readl(base->regs + APCCSR);
1631 if (base->dir == APC_RECORD)
1635 sbus_writel(csr, base->regs + APCCSR);
1641 struct sbus_dma_info *base = &dma_cont->sbus_info;
1643 guard(spinlock_irqsave)(&base->lock);
1645 sbus_writel(0, base->regs + base->dir + APCNC);
1646 sbus_writel(0, base->regs + base->dir + APCNVA);
1647 if (base->dir == APC_PLAY) {
1648 sbus_writel(0, base->regs + base->dir + APCC);
1649 sbus_writel(0, base->regs + base->dir + APCVA);
1654 csr = sbus_readl(base->regs + APCCSR);
1656 if (base->dir == APC_PLAY)
1662 sbus_writel(csr, base->regs + APCCSR);
1667 sbus_writel(csr, base->regs + APCCSR);
1672 struct sbus_dma_info *base = &dma_cont->sbus_info;
1674 return sbus_readl(base->regs + base->dir + APCVA);
1683 struct platform_device *op = chip->op;
1685 if (chip->irq[0])
1686 free_irq(chip->irq[0], chip);
1688 if (chip->port)
1689 of_iounmap(&op->resource[0], chip->port, chip->regs_size);
1696 struct snd_cs4231 *cp = device->device_data;
1709 struct snd_cs4231 *chip = card->private_data;
1712 spin_lock_init(&chip->lock);
1713 spin_lock_init(&chip->c_dma.sbus_info.lock);
1714 spin_lock_init(&chip->p_dma.sbus_info.lock);
1715 mutex_init(&chip->mce_mutex);
1716 mutex_init(&chip->open_mutex);
1717 chip->op = op;
1718 chip->regs_size = resource_size(&op->resource[0]);
1719 memcpy(&chip->image, &snd_cs4231_original_image,
1722 chip->port = of_ioremap(&op->resource[0], 0,
1723 chip->regs_size, "cs4231");
1724 if (!chip->port) {
1725 dev_dbg(chip->card->dev,
1726 "cs4231-%d: Unable to map chip registers.\n", dev);
1727 return -EIO;
1730 chip->c_dma.sbus_info.regs = chip->port;
1731 chip->p_dma.sbus_info.regs = chip->port;
1732 chip->c_dma.sbus_info.dir = APC_RECORD;
1733 chip->p_dma.sbus_info.dir = APC_PLAY;
1735 chip->p_dma.prepare = sbus_dma_prepare;
1736 chip->p_dma.enable = sbus_dma_enable;
1737 chip->p_dma.request = sbus_dma_request;
1738 chip->p_dma.address = sbus_dma_addr;
1740 chip->c_dma.prepare = sbus_dma_prepare;
1741 chip->c_dma.enable = sbus_dma_enable;
1742 chip->c_dma.request = sbus_dma_request;
1743 chip->c_dma.address = sbus_dma_addr;
1745 if (request_irq(op->archdata.irqs[0], snd_cs4231_sbus_interrupt,
1747 dev_dbg(chip->card->dev,
1748 "cs4231-%d: Unable to grab SBUS IRQ %d\n",
1749 dev, op->archdata.irqs[0]);
1751 return -EBUSY;
1753 chip->irq[0] = op->archdata.irqs[0];
1757 return -ENODEV;
1773 struct resource *rp = &op->resource[0];
1781 sprintf(card->longname, "%s at 0x%02lx:0x%016Lx, irq %d",
1782 card->shortname,
1783 rp->flags & 0xffL,
1784 (unsigned long long)rp->start,
1785 op->archdata.irqs[0]);
1822 return ebus_dma_request(&dma_cont->ebus_info, bus_addr, len);
1827 ebus_dma_enable(&dma_cont->ebus_info, on);
1832 ebus_dma_prepare(&dma_cont->ebus_info, dir);
1837 return ebus_dma_addr(&dma_cont->ebus_info);
1846 struct platform_device *op = chip->op;
1848 if (chip->c_dma.ebus_info.regs) {
1849 ebus_dma_unregister(&chip->c_dma.ebus_info);
1850 of_iounmap(&op->resource[2], chip->c_dma.ebus_info.regs, 0x10);
1852 if (chip->p_dma.ebus_info.regs) {
1853 ebus_dma_unregister(&chip->p_dma.ebus_info);
1854 of_iounmap(&op->resource[1], chip->p_dma.ebus_info.regs, 0x10);
1857 if (chip->port)
1858 of_iounmap(&op->resource[0], chip->port, 0x10);
1865 struct snd_cs4231 *cp = device->device_data;
1878 struct snd_cs4231 *chip = card->private_data;
1881 spin_lock_init(&chip->lock);
1882 spin_lock_init(&chip->c_dma.ebus_info.lock);
1883 spin_lock_init(&chip->p_dma.ebus_info.lock);
1884 mutex_init(&chip->mce_mutex);
1885 mutex_init(&chip->open_mutex);
1886 chip->flags |= CS4231_FLAG_EBUS;
1887 chip->op = op;
1888 memcpy(&chip->image, &snd_cs4231_original_image,
1890 strscpy(chip->c_dma.ebus_info.name, "cs4231(capture)");
1891 chip->c_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
1892 chip->c_dma.ebus_info.callback = snd_cs4231_ebus_capture_callback;
1893 chip->c_dma.ebus_info.client_cookie = chip;
1894 chip->c_dma.ebus_info.irq = op->archdata.irqs[0];
1895 strscpy(chip->p_dma.ebus_info.name, "cs4231(play)");
1896 chip->p_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
1897 chip->p_dma.ebus_info.callback = snd_cs4231_ebus_play_callback;
1898 chip->p_dma.ebus_info.client_cookie = chip;
1899 chip->p_dma.ebus_info.irq = op->archdata.irqs[1];
1901 chip->p_dma.prepare = _ebus_dma_prepare;
1902 chip->p_dma.enable = _ebus_dma_enable;
1903 chip->p_dma.request = _ebus_dma_request;
1904 chip->p_dma.address = _ebus_dma_addr;
1906 chip->c_dma.prepare = _ebus_dma_prepare;
1907 chip->c_dma.enable = _ebus_dma_enable;
1908 chip->c_dma.request = _ebus_dma_request;
1909 chip->c_dma.address = _ebus_dma_addr;
1911 chip->port = of_ioremap(&op->resource[0], 0, 0x10, "cs4231");
1912 chip->p_dma.ebus_info.regs =
1913 of_ioremap(&op->resource[1], 0, 0x10, "cs4231_pdma");
1914 chip->c_dma.ebus_info.regs =
1915 of_ioremap(&op->resource[2], 0, 0x10, "cs4231_cdma");
1916 if (!chip->port || !chip->p_dma.ebus_info.regs ||
1917 !chip->c_dma.ebus_info.regs) {
1919 dev_dbg(chip->card->dev,
1920 "cs4231-%d: Unable to map chip registers.\n", dev);
1921 return -EIO;
1924 if (ebus_dma_register(&chip->c_dma.ebus_info)) {
1926 dev_dbg(chip->card->dev,
1927 "cs4231-%d: Unable to register EBUS capture DMA\n",
1929 return -EBUSY;
1931 if (ebus_dma_irq_enable(&chip->c_dma.ebus_info, 1)) {
1933 dev_dbg(chip->card->dev,
1934 "cs4231-%d: Unable to enable EBUS capture IRQ\n",
1936 return -EBUSY;
1939 if (ebus_dma_register(&chip->p_dma.ebus_info)) {
1941 dev_dbg(chip->card->dev,
1942 "cs4231-%d: Unable to register EBUS play DMA\n",
1944 return -EBUSY;
1946 if (ebus_dma_irq_enable(&chip->p_dma.ebus_info, 1)) {
1948 dev_dbg(chip->card->dev,
1949 "cs4231-%d: Unable to enable EBUS play IRQ\n", dev);
1950 return -EBUSY;
1955 return -ENODEV;
1978 sprintf(card->longname, "%s at 0x%llx, irq %d",
1979 card->shortname,
1980 op->resource[0].start,
1981 op->archdata.irqs[0]);
1996 if (of_node_name_eq(op->dev.of_node->parent, "ebus"))
2000 if (of_node_name_eq(op->dev.of_node->parent, "sbus") ||
2001 of_node_name_eq(op->dev.of_node->parent, "sbi"))
2004 return -ENODEV;
2009 struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
2011 snd_card_free(chip->card);