Lines Matching refs:chip
128 #define CS4231U(chip, x) ((chip)->port + ((c_d_c_CS4231##x) << 2))
174 #define APC_CHIP_RESET 0x01 /* Reset the chip */
277 static void snd_cs4231_ready(struct snd_cs4231 *chip)
282 int val = __cs4231_readb(chip, CS4231U(chip, REGSEL));
289 static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg,
292 snd_cs4231_ready(chip);
294 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
299 __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL));
301 __cs4231_writeb(chip, value, CS4231U(chip, REG));
305 static inline void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg,
308 unsigned char tmp = (chip->image[reg] & mask) | value;
310 chip->image[reg] = tmp;
311 if (!chip->calibrate_mute)
312 snd_cs4231_dout(chip, reg, tmp);
315 static void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg,
318 snd_cs4231_dout(chip, reg, value);
319 chip->image[reg] = value;
323 static unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg)
325 snd_cs4231_ready(chip);
327 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
331 __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL));
333 return __cs4231_readb(chip, CS4231U(chip, REG));
340 static void snd_cs4231_busy_wait(struct snd_cs4231 *chip)
344 /* looks like this sequence is proper for CS4231A chip (GUS MAX) */
346 __cs4231_readb(chip, CS4231U(chip, REGSEL));
350 int val = __cs4231_readb(chip, CS4231U(chip, REGSEL));
357 static void snd_cs4231_mce_up(struct snd_cs4231 *chip)
362 spin_lock_irqsave(&chip->lock, flags);
363 snd_cs4231_ready(chip);
365 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
368 chip->mce_bit |= CS4231_MCE;
369 timeout = __cs4231_readb(chip, CS4231U(chip, REGSEL));
373 chip->port);
375 __cs4231_writeb(chip, chip->mce_bit | (timeout & 0x1f),
376 CS4231U(chip, REGSEL));
377 spin_unlock_irqrestore(&chip->lock, flags);
380 static void snd_cs4231_mce_down(struct snd_cs4231 *chip)
385 snd_cs4231_busy_wait(chip);
386 spin_lock_irqsave(&chip->lock, flags);
388 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
390 CS4231U(chip, REGSEL));
392 chip->mce_bit &= ~CS4231_MCE;
393 reg = __cs4231_readb(chip, CS4231U(chip, REGSEL));
394 __cs4231_writeb(chip, chip->mce_bit | (reg & 0x1f),
395 CS4231U(chip, REGSEL));
398 "- codec still busy\n", chip->port);
400 spin_unlock_irqrestore(&chip->lock, flags);
409 spin_unlock_irqrestore(&chip->lock, flags);
411 spin_lock_irqsave(&chip->lock, flags);
412 reg = snd_cs4231_in(chip, CS4231_TEST_INIT);
415 spin_unlock_irqrestore(&chip->lock, flags);
445 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
449 dma_cont = &chip->p_dma;
454 chip->playback_substream,
455 &chip->p_periods_sent);
461 dma_cont = &chip->c_dma;
466 chip->capture_substream,
467 &chip->c_periods_sent);
476 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
488 if (s == chip->playback_substream) {
491 } else if (s == chip->capture_substream) {
497 spin_lock_irqsave(&chip->lock, flags);
500 chip->image[CS4231_IFACE_CTRL] |= what;
503 chip->image[CS4231_IFACE_CTRL] &= ~what;
505 snd_cs4231_out(chip, CS4231_IFACE_CTRL,
506 chip->image[CS4231_IFACE_CTRL]);
507 spin_unlock_irqrestore(&chip->lock, flags);
533 static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, int format,
561 static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute)
566 spin_lock_irqsave(&chip->lock, flags);
567 if (chip->calibrate_mute == mute) {
568 spin_unlock_irqrestore(&chip->lock, flags);
572 snd_cs4231_dout(chip, CS4231_LEFT_INPUT,
573 chip->image[CS4231_LEFT_INPUT]);
574 snd_cs4231_dout(chip, CS4231_RIGHT_INPUT,
575 chip->image[CS4231_RIGHT_INPUT]);
576 snd_cs4231_dout(chip, CS4231_LOOPBACK,
577 chip->image[CS4231_LOOPBACK]);
579 snd_cs4231_dout(chip, CS4231_AUX1_LEFT_INPUT,
580 mute ? 0x80 : chip->image[CS4231_AUX1_LEFT_INPUT]);
581 snd_cs4231_dout(chip, CS4231_AUX1_RIGHT_INPUT,
582 mute ? 0x80 : chip->image[CS4231_AUX1_RIGHT_INPUT]);
583 snd_cs4231_dout(chip, CS4231_AUX2_LEFT_INPUT,
584 mute ? 0x80 : chip->image[CS4231_AUX2_LEFT_INPUT]);
585 snd_cs4231_dout(chip, CS4231_AUX2_RIGHT_INPUT,
586 mute ? 0x80 : chip->image[CS4231_AUX2_RIGHT_INPUT]);
587 snd_cs4231_dout(chip, CS4231_LEFT_OUTPUT,
588 mute ? 0x80 : chip->image[CS4231_LEFT_OUTPUT]);
589 snd_cs4231_dout(chip, CS4231_RIGHT_OUTPUT,
590 mute ? 0x80 : chip->image[CS4231_RIGHT_OUTPUT]);
591 snd_cs4231_dout(chip, CS4231_LEFT_LINE_IN,
592 mute ? 0x80 : chip->image[CS4231_LEFT_LINE_IN]);
593 snd_cs4231_dout(chip, CS4231_RIGHT_LINE_IN,
594 mute ? 0x80 : chip->image[CS4231_RIGHT_LINE_IN]);
595 snd_cs4231_dout(chip, CS4231_MONO_CTRL,
596 mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]);
597 chip->calibrate_mute = mute;
598 spin_unlock_irqrestore(&chip->lock, flags);
601 static void snd_cs4231_playback_format(struct snd_cs4231 *chip,
607 mutex_lock(&chip->mce_mutex);
608 snd_cs4231_calibrate_mute(chip, 1);
610 snd_cs4231_mce_up(chip);
612 spin_lock_irqsave(&chip->lock, flags);
613 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
614 (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ?
615 (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) :
617 spin_unlock_irqrestore(&chip->lock, flags);
619 snd_cs4231_mce_down(chip);
621 snd_cs4231_calibrate_mute(chip, 0);
622 mutex_unlock(&chip->mce_mutex);
625 static void snd_cs4231_capture_format(struct snd_cs4231 *chip,
631 mutex_lock(&chip->mce_mutex);
632 snd_cs4231_calibrate_mute(chip, 1);
634 snd_cs4231_mce_up(chip);
636 spin_lock_irqsave(&chip->lock, flags);
637 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
638 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
639 ((chip->image[CS4231_PLAYBK_FORMAT]) & 0xf0) |
641 spin_unlock_irqrestore(&chip->lock, flags);
642 snd_cs4231_mce_down(chip);
643 snd_cs4231_mce_up(chip);
644 spin_lock_irqsave(&chip->lock, flags);
646 snd_cs4231_out(chip, CS4231_REC_FORMAT, cdfr);
647 spin_unlock_irqrestore(&chip->lock, flags);
649 snd_cs4231_mce_down(chip);
651 snd_cs4231_calibrate_mute(chip, 0);
652 mutex_unlock(&chip->mce_mutex);
661 struct snd_cs4231 *chip = snd_timer_chip(timer);
663 return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920;
670 struct snd_cs4231 *chip = snd_timer_chip(timer);
672 spin_lock_irqsave(&chip->lock, flags);
674 if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 ||
675 (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] ||
676 (unsigned char)ticks != chip->image[CS4231_TIMER_LOW]) {
677 snd_cs4231_out(chip, CS4231_TIMER_HIGH,
678 chip->image[CS4231_TIMER_HIGH] =
680 snd_cs4231_out(chip, CS4231_TIMER_LOW,
681 chip->image[CS4231_TIMER_LOW] =
683 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1,
684 chip->image[CS4231_ALT_FEATURE_1] |
687 spin_unlock_irqrestore(&chip->lock, flags);
695 struct snd_cs4231 *chip = snd_timer_chip(timer);
697 spin_lock_irqsave(&chip->lock, flags);
698 chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE;
699 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1,
700 chip->image[CS4231_ALT_FEATURE_1]);
701 spin_unlock_irqrestore(&chip->lock, flags);
706 static void snd_cs4231_init(struct snd_cs4231 *chip)
710 snd_cs4231_mce_down(chip);
715 snd_cs4231_mce_up(chip);
716 spin_lock_irqsave(&chip->lock, flags);
717 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
722 chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB;
723 snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
724 spin_unlock_irqrestore(&chip->lock, flags);
725 snd_cs4231_mce_down(chip);
731 snd_cs4231_mce_up(chip);
732 spin_lock_irqsave(&chip->lock, flags);
733 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1,
734 chip->image[CS4231_ALT_FEATURE_1]);
735 spin_unlock_irqrestore(&chip->lock, flags);
736 snd_cs4231_mce_down(chip);
740 chip->image[CS4231_ALT_FEATURE_1]);
743 spin_lock_irqsave(&chip->lock, flags);
744 snd_cs4231_out(chip, CS4231_ALT_FEATURE_2,
745 chip->image[CS4231_ALT_FEATURE_2]);
746 spin_unlock_irqrestore(&chip->lock, flags);
748 snd_cs4231_mce_up(chip);
749 spin_lock_irqsave(&chip->lock, flags);
750 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
751 chip->image[CS4231_PLAYBK_FORMAT]);
752 spin_unlock_irqrestore(&chip->lock, flags);
753 snd_cs4231_mce_down(chip);
759 snd_cs4231_mce_up(chip);
760 spin_lock_irqsave(&chip->lock, flags);
761 snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]);
762 spin_unlock_irqrestore(&chip->lock, flags);
763 snd_cs4231_mce_down(chip);
770 static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode)
774 mutex_lock(&chip->open_mutex);
775 if ((chip->mode & mode)) {
776 mutex_unlock(&chip->open_mutex);
779 if (chip->mode & CS4231_MODE_OPEN) {
780 chip->mode |= mode;
781 mutex_unlock(&chip->open_mutex);
785 spin_lock_irqsave(&chip->lock, flags);
786 snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ |
789 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
790 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
791 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
793 snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ |
796 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
798 spin_unlock_irqrestore(&chip->lock, flags);
800 chip->mode = mode;
801 mutex_unlock(&chip->open_mutex);
805 static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode)
809 mutex_lock(&chip->open_mutex);
810 chip->mode &= ~mode;
811 if (chip->mode & CS4231_MODE_OPEN) {
812 mutex_unlock(&chip->open_mutex);
815 snd_cs4231_calibrate_mute(chip, 1);
818 spin_lock_irqsave(&chip->lock, flags);
819 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
820 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
821 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
825 if (chip->image[CS4231_IFACE_CTRL] &
828 spin_unlock_irqrestore(&chip->lock, flags);
829 snd_cs4231_mce_up(chip);
830 spin_lock_irqsave(&chip->lock, flags);
831 chip->image[CS4231_IFACE_CTRL] &=
834 snd_cs4231_out(chip, CS4231_IFACE_CTRL,
835 chip->image[CS4231_IFACE_CTRL]);
836 spin_unlock_irqrestore(&chip->lock, flags);
837 snd_cs4231_mce_down(chip);
838 spin_lock_irqsave(&chip->lock, flags);
842 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
843 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
844 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
845 spin_unlock_irqrestore(&chip->lock, flags);
847 snd_cs4231_calibrate_mute(chip, 0);
849 chip->mode = 0;
850 mutex_unlock(&chip->open_mutex);
859 struct snd_cs4231 *chip = snd_timer_chip(timer);
860 snd_cs4231_open(chip, CS4231_MODE_TIMER);
866 struct snd_cs4231 *chip = snd_timer_chip(timer);
867 snd_cs4231_close(chip, CS4231_MODE_TIMER);
889 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
892 new_pdfr = snd_cs4231_get_format(chip, params_format(hw_params),
895 snd_cs4231_playback_format(chip, hw_params, new_pdfr);
902 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
907 spin_lock_irqsave(&chip->lock, flags);
909 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
917 chip->p_periods_sent = 0;
920 spin_unlock_irqrestore(&chip->lock, flags);
928 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
931 new_cdfr = snd_cs4231_get_format(chip, params_format(hw_params),
934 snd_cs4231_capture_format(chip, hw_params, new_cdfr);
941 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
944 spin_lock_irqsave(&chip->lock, flags);
945 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE |
949 chip->c_periods_sent = 0;
950 spin_unlock_irqrestore(&chip->lock, flags);
955 static void snd_cs4231_overrange(struct snd_cs4231 *chip)
960 spin_lock_irqsave(&chip->lock, flags);
961 res = snd_cs4231_in(chip, CS4231_TEST_INIT);
962 spin_unlock_irqrestore(&chip->lock, flags);
966 chip->capture_substream->runtime->overrange++;
969 static void snd_cs4231_play_callback(struct snd_cs4231 *chip)
971 if (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE) {
972 snd_pcm_period_elapsed(chip->playback_substream);
973 snd_cs4231_advance_dma(&chip->p_dma, chip->playback_substream,
974 &chip->p_periods_sent);
978 static void snd_cs4231_capture_callback(struct snd_cs4231 *chip)
980 if (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) {
981 snd_pcm_period_elapsed(chip->capture_substream);
982 snd_cs4231_advance_dma(&chip->c_dma, chip->capture_substream,
983 &chip->c_periods_sent);
990 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
991 struct cs4231_dma_control *dma_cont = &chip->p_dma;
994 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE))
1006 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1007 struct cs4231_dma_control *dma_cont = &chip->c_dma;
1010 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE))
1019 static int snd_cs4231_probe(struct snd_cs4231 *chip)
1029 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
1032 spin_lock_irqsave(&chip->lock, flags);
1033 snd_cs4231_out(chip, CS4231_MISC_INFO, CS4231_MODE2);
1034 id = snd_cs4231_in(chip, CS4231_MISC_INFO) & 0x0f;
1035 vers = snd_cs4231_in(chip, CS4231_VERSION);
1036 spin_unlock_irqrestore(&chip->lock, flags);
1041 snd_printdd("cs4231: port = %p, id = 0x%x\n", chip->port, id);
1045 spin_lock_irqsave(&chip->lock, flags);
1048 __cs4231_readb(chip, CS4231U(chip, STATUS));
1049 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS));
1052 spin_unlock_irqrestore(&chip->lock, flags);
1054 chip->image[CS4231_MISC_INFO] = CS4231_MODE2;
1055 chip->image[CS4231_IFACE_CTRL] =
1056 chip->image[CS4231_IFACE_CTRL] & ~CS4231_SINGLE_DMA;
1057 chip->image[CS4231_ALT_FEATURE_1] = 0x80;
1058 chip->image[CS4231_ALT_FEATURE_2] = 0x01;
1060 chip->image[CS4231_ALT_FEATURE_2] |= 0x02;
1062 ptr = (unsigned char *) &chip->image;
1064 snd_cs4231_mce_down(chip);
1066 spin_lock_irqsave(&chip->lock, flags);
1069 snd_cs4231_out(chip, i, *ptr++);
1071 spin_unlock_irqrestore(&chip->lock, flags);
1073 snd_cs4231_mce_up(chip);
1075 snd_cs4231_mce_down(chip);
1132 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1138 err = snd_cs4231_open(chip, CS4231_MODE_PLAY);
1141 chip->playback_substream = substream;
1142 chip->p_periods_sent = 0;
1151 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1157 err = snd_cs4231_open(chip, CS4231_MODE_RECORD);
1160 chip->capture_substream = substream;
1161 chip->c_periods_sent = 0;
1170 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1172 snd_cs4231_close(chip, CS4231_MODE_PLAY);
1173 chip->playback_substream = NULL;
1180 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1182 snd_cs4231_close(chip, CS4231_MODE_RECORD);
1183 chip->capture_substream = NULL;
1212 struct snd_cs4231 *chip = card->private_data;
1226 pcm->private_data = chip;
1231 &chip->op->dev, 64 * 1024, 128 * 1024);
1233 chip->pcm = pcm;
1240 struct snd_cs4231 *chip = card->private_data;
1255 timer->private_data = chip;
1257 chip->timer = timer;
1279 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1282 spin_lock_irqsave(&chip->lock, flags);
1284 (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6;
1286 (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6;
1287 spin_unlock_irqrestore(&chip->lock, flags);
1295 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1306 spin_lock_irqsave(&chip->lock, flags);
1308 left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left;
1309 right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right;
1310 change = left != chip->image[CS4231_LEFT_INPUT] ||
1311 right != chip->image[CS4231_RIGHT_INPUT];
1312 snd_cs4231_out(chip, CS4231_LEFT_INPUT, left);
1313 snd_cs4231_out(chip, CS4231_RIGHT_INPUT, right);
1315 spin_unlock_irqrestore(&chip->lock, flags);
1337 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1344 spin_lock_irqsave(&chip->lock, flags);
1346 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
1348 spin_unlock_irqrestore(&chip->lock, flags);
1360 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1374 spin_lock_irqsave(&chip->lock, flags);
1376 val = (chip->image[reg] & ~(mask << shift)) | val;
1377 change = val != chip->image[reg];
1378 snd_cs4231_out(chip, reg, val);
1380 spin_unlock_irqrestore(&chip->lock, flags);
1402 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1411 spin_lock_irqsave(&chip->lock, flags);
1414 (chip->image[left_reg] >> shift_left) & mask;
1416 (chip->image[right_reg] >> shift_right) & mask;
1418 spin_unlock_irqrestore(&chip->lock, flags);
1433 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1453 spin_lock_irqsave(&chip->lock, flags);
1455 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
1456 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
1457 change = val1 != chip->image[left_reg];
1458 change |= val2 != chip->image[right_reg];
1459 snd_cs4231_out(chip, left_reg, val1);
1460 snd_cs4231_out(chip, right_reg, val2);
1462 spin_unlock_irqrestore(&chip->lock, flags);
1522 struct snd_cs4231 *chip = card->private_data;
1525 if (snd_BUG_ON(!chip || !chip->pcm))
1528 strcpy(card->mixername, chip->pcm->name);
1532 snd_ctl_new1(&snd_cs4231_controls[idx], chip));
1545 struct snd_cs4231 *chip;
1566 chip = card->private_data;
1567 chip->card = card;
1575 struct snd_cs4231 *chip = card->private_data;
1594 dev_set_drvdata(&chip->op->dev, chip);
1611 struct snd_cs4231 *chip = dev_id;
1614 if (!(__cs4231_readb(chip, CS4231U(chip, STATUS)) & CS4231_GLOBALIRQ))
1618 csr = sbus_readl(chip->port + APCCSR);
1620 sbus_writel(csr, chip->port + APCCSR);
1626 snd_cs4231_play_callback(chip);
1632 snd_cs4231_capture_callback(chip);
1634 status = snd_cs4231_in(chip, CS4231_IRQ_STATUS);
1637 if (chip->timer)
1638 snd_timer_interrupt(chip->timer, chip->timer->sticks);
1642 snd_cs4231_overrange(chip);
1645 spin_lock_irqsave(&chip->lock, flags);
1646 snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0);
1647 spin_unlock_irqrestore(&chip->lock, flags);
1753 static int snd_cs4231_sbus_free(struct snd_cs4231 *chip)
1755 struct platform_device *op = chip->op;
1757 if (chip->irq[0])
1758 free_irq(chip->irq[0], chip);
1760 if (chip->port)
1761 of_iounmap(&op->resource[0], chip->port, chip->regs_size);
1781 struct snd_cs4231 *chip = card->private_data;
1784 spin_lock_init(&chip->lock);
1785 spin_lock_init(&chip->c_dma.sbus_info.lock);
1786 spin_lock_init(&chip->p_dma.sbus_info.lock);
1787 mutex_init(&chip->mce_mutex);
1788 mutex_init(&chip->open_mutex);
1789 chip->op = op;
1790 chip->regs_size = resource_size(&op->resource[0]);
1791 memcpy(&chip->image, &snd_cs4231_original_image,
1794 chip->port = of_ioremap(&op->resource[0], 0,
1795 chip->regs_size, "cs4231");
1796 if (!chip->port) {
1797 snd_printdd("cs4231-%d: Unable to map chip registers.\n", dev);
1801 chip->c_dma.sbus_info.regs = chip->port;
1802 chip->p_dma.sbus_info.regs = chip->port;
1803 chip->c_dma.sbus_info.dir = APC_RECORD;
1804 chip->p_dma.sbus_info.dir = APC_PLAY;
1806 chip->p_dma.prepare = sbus_dma_prepare;
1807 chip->p_dma.enable = sbus_dma_enable;
1808 chip->p_dma.request = sbus_dma_request;
1809 chip->p_dma.address = sbus_dma_addr;
1811 chip->c_dma.prepare = sbus_dma_prepare;
1812 chip->c_dma.enable = sbus_dma_enable;
1813 chip->c_dma.request = sbus_dma_request;
1814 chip->c_dma.address = sbus_dma_addr;
1817 IRQF_SHARED, "cs4231", chip)) {
1820 snd_cs4231_sbus_free(chip);
1823 chip->irq[0] = op->archdata.irqs[0];
1825 if (snd_cs4231_probe(chip) < 0) {
1826 snd_cs4231_sbus_free(chip);
1829 snd_cs4231_init(chip);
1832 chip, &snd_cs4231_sbus_dev_ops);
1834 snd_cs4231_sbus_free(chip);
1872 struct snd_cs4231 *chip = cookie;
1874 snd_cs4231_play_callback(chip);
1880 struct snd_cs4231 *chip = cookie;
1882 snd_cs4231_capture_callback(chip);
1914 static int snd_cs4231_ebus_free(struct snd_cs4231 *chip)
1916 struct platform_device *op = chip->op;
1918 if (chip->c_dma.ebus_info.regs) {
1919 ebus_dma_unregister(&chip->c_dma.ebus_info);
1920 of_iounmap(&op->resource[2], chip->c_dma.ebus_info.regs, 0x10);
1922 if (chip->p_dma.ebus_info.regs) {
1923 ebus_dma_unregister(&chip->p_dma.ebus_info);
1924 of_iounmap(&op->resource[1], chip->p_dma.ebus_info.regs, 0x10);
1927 if (chip->port)
1928 of_iounmap(&op->resource[0], chip->port, 0x10);
1948 struct snd_cs4231 *chip = card->private_data;
1951 spin_lock_init(&chip->lock);
1952 spin_lock_init(&chip->c_dma.ebus_info.lock);
1953 spin_lock_init(&chip->p_dma.ebus_info.lock);
1954 mutex_init(&chip->mce_mutex);
1955 mutex_init(&chip->open_mutex);
1956 chip->flags |= CS4231_FLAG_EBUS;
1957 chip->op = op;
1958 memcpy(&chip->image, &snd_cs4231_original_image,
1960 strcpy(chip->c_dma.ebus_info.name, "cs4231(capture)");
1961 chip->c_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
1962 chip->c_dma.ebus_info.callback = snd_cs4231_ebus_capture_callback;
1963 chip->c_dma.ebus_info.client_cookie = chip;
1964 chip->c_dma.ebus_info.irq = op->archdata.irqs[0];
1965 strcpy(chip->p_dma.ebus_info.name, "cs4231(play)");
1966 chip->p_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
1967 chip->p_dma.ebus_info.callback = snd_cs4231_ebus_play_callback;
1968 chip->p_dma.ebus_info.client_cookie = chip;
1969 chip->p_dma.ebus_info.irq = op->archdata.irqs[1];
1971 chip->p_dma.prepare = _ebus_dma_prepare;
1972 chip->p_dma.enable = _ebus_dma_enable;
1973 chip->p_dma.request = _ebus_dma_request;
1974 chip->p_dma.address = _ebus_dma_addr;
1976 chip->c_dma.prepare = _ebus_dma_prepare;
1977 chip->c_dma.enable = _ebus_dma_enable;
1978 chip->c_dma.request = _ebus_dma_request;
1979 chip->c_dma.address = _ebus_dma_addr;
1981 chip->port = of_ioremap(&op->resource[0], 0, 0x10, "cs4231");
1982 chip->p_dma.ebus_info.regs =
1984 chip->c_dma.ebus_info.regs =
1986 if (!chip->port || !chip->p_dma.ebus_info.regs ||
1987 !chip->c_dma.ebus_info.regs) {
1988 snd_cs4231_ebus_free(chip);
1989 snd_printdd("cs4231-%d: Unable to map chip registers.\n", dev);
1993 if (ebus_dma_register(&chip->c_dma.ebus_info)) {
1994 snd_cs4231_ebus_free(chip);
1999 if (ebus_dma_irq_enable(&chip->c_dma.ebus_info, 1)) {
2000 snd_cs4231_ebus_free(chip);
2006 if (ebus_dma_register(&chip->p_dma.ebus_info)) {
2007 snd_cs4231_ebus_free(chip);
2012 if (ebus_dma_irq_enable(&chip->p_dma.ebus_info, 1)) {
2013 snd_cs4231_ebus_free(chip);
2018 if (snd_cs4231_probe(chip) < 0) {
2019 snd_cs4231_ebus_free(chip);
2022 snd_cs4231_init(chip);
2025 chip, &snd_cs4231_ebus_dev_ops);
2027 snd_cs4231_ebus_free(chip);
2074 struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
2076 snd_card_free(chip->card);