Lines Matching refs:chip
129 #define CS4231U(chip, x) ((chip)->port + ((c_d_c_CS4231##x) << 2))
175 #define APC_CHIP_RESET 0x01 /* Reset the chip */
278 static void snd_cs4231_ready(struct snd_cs4231 *chip)
283 int val = __cs4231_readb(chip, CS4231U(chip, REGSEL));
290 static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg,
293 snd_cs4231_ready(chip);
295 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
300 __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL));
302 __cs4231_writeb(chip, value, CS4231U(chip, REG));
306 static inline void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg,
309 unsigned char tmp = (chip->image[reg] & mask) | value;
311 chip->image[reg] = tmp;
312 if (!chip->calibrate_mute)
313 snd_cs4231_dout(chip, reg, tmp);
316 static void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg,
319 snd_cs4231_dout(chip, reg, value);
320 chip->image[reg] = value;
324 static unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg)
326 snd_cs4231_ready(chip);
328 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
332 __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL));
334 return __cs4231_readb(chip, CS4231U(chip, REG));
341 static void snd_cs4231_busy_wait(struct snd_cs4231 *chip)
345 /* looks like this sequence is proper for CS4231A chip (GUS MAX) */
347 __cs4231_readb(chip, CS4231U(chip, REGSEL));
351 int val = __cs4231_readb(chip, CS4231U(chip, REGSEL));
358 static void snd_cs4231_mce_up(struct snd_cs4231 *chip)
363 spin_lock_irqsave(&chip->lock, flags);
364 snd_cs4231_ready(chip);
366 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
369 chip->mce_bit |= CS4231_MCE;
370 timeout = __cs4231_readb(chip, CS4231U(chip, REGSEL));
374 chip->port);
376 __cs4231_writeb(chip, chip->mce_bit | (timeout & 0x1f),
377 CS4231U(chip, REGSEL));
378 spin_unlock_irqrestore(&chip->lock, flags);
381 static void snd_cs4231_mce_down(struct snd_cs4231 *chip)
386 snd_cs4231_busy_wait(chip);
387 spin_lock_irqsave(&chip->lock, flags);
389 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
391 CS4231U(chip, REGSEL));
393 chip->mce_bit &= ~CS4231_MCE;
394 reg = __cs4231_readb(chip, CS4231U(chip, REGSEL));
395 __cs4231_writeb(chip, chip->mce_bit | (reg & 0x1f),
396 CS4231U(chip, REGSEL));
399 "- codec still busy\n", chip->port);
401 spin_unlock_irqrestore(&chip->lock, flags);
410 spin_unlock_irqrestore(&chip->lock, flags);
412 spin_lock_irqsave(&chip->lock, flags);
413 reg = snd_cs4231_in(chip, CS4231_TEST_INIT);
416 spin_unlock_irqrestore(&chip->lock, flags);
446 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
450 dma_cont = &chip->p_dma;
455 chip->playback_substream,
456 &chip->p_periods_sent);
462 dma_cont = &chip->c_dma;
467 chip->capture_substream,
468 &chip->c_periods_sent);
477 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
489 if (s == chip->playback_substream) {
492 } else if (s == chip->capture_substream) {
498 spin_lock_irqsave(&chip->lock, flags);
501 chip->image[CS4231_IFACE_CTRL] |= what;
504 chip->image[CS4231_IFACE_CTRL] &= ~what;
506 snd_cs4231_out(chip, CS4231_IFACE_CTRL,
507 chip->image[CS4231_IFACE_CTRL]);
508 spin_unlock_irqrestore(&chip->lock, flags);
534 static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, int format,
562 static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute)
567 spin_lock_irqsave(&chip->lock, flags);
568 if (chip->calibrate_mute == mute) {
569 spin_unlock_irqrestore(&chip->lock, flags);
573 snd_cs4231_dout(chip, CS4231_LEFT_INPUT,
574 chip->image[CS4231_LEFT_INPUT]);
575 snd_cs4231_dout(chip, CS4231_RIGHT_INPUT,
576 chip->image[CS4231_RIGHT_INPUT]);
577 snd_cs4231_dout(chip, CS4231_LOOPBACK,
578 chip->image[CS4231_LOOPBACK]);
580 snd_cs4231_dout(chip, CS4231_AUX1_LEFT_INPUT,
581 mute ? 0x80 : chip->image[CS4231_AUX1_LEFT_INPUT]);
582 snd_cs4231_dout(chip, CS4231_AUX1_RIGHT_INPUT,
583 mute ? 0x80 : chip->image[CS4231_AUX1_RIGHT_INPUT]);
584 snd_cs4231_dout(chip, CS4231_AUX2_LEFT_INPUT,
585 mute ? 0x80 : chip->image[CS4231_AUX2_LEFT_INPUT]);
586 snd_cs4231_dout(chip, CS4231_AUX2_RIGHT_INPUT,
587 mute ? 0x80 : chip->image[CS4231_AUX2_RIGHT_INPUT]);
588 snd_cs4231_dout(chip, CS4231_LEFT_OUTPUT,
589 mute ? 0x80 : chip->image[CS4231_LEFT_OUTPUT]);
590 snd_cs4231_dout(chip, CS4231_RIGHT_OUTPUT,
591 mute ? 0x80 : chip->image[CS4231_RIGHT_OUTPUT]);
592 snd_cs4231_dout(chip, CS4231_LEFT_LINE_IN,
593 mute ? 0x80 : chip->image[CS4231_LEFT_LINE_IN]);
594 snd_cs4231_dout(chip, CS4231_RIGHT_LINE_IN,
595 mute ? 0x80 : chip->image[CS4231_RIGHT_LINE_IN]);
596 snd_cs4231_dout(chip, CS4231_MONO_CTRL,
597 mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]);
598 chip->calibrate_mute = mute;
599 spin_unlock_irqrestore(&chip->lock, flags);
602 static void snd_cs4231_playback_format(struct snd_cs4231 *chip,
608 mutex_lock(&chip->mce_mutex);
609 snd_cs4231_calibrate_mute(chip, 1);
611 snd_cs4231_mce_up(chip);
613 spin_lock_irqsave(&chip->lock, flags);
614 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
615 (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ?
616 (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) :
618 spin_unlock_irqrestore(&chip->lock, flags);
620 snd_cs4231_mce_down(chip);
622 snd_cs4231_calibrate_mute(chip, 0);
623 mutex_unlock(&chip->mce_mutex);
626 static void snd_cs4231_capture_format(struct snd_cs4231 *chip,
632 mutex_lock(&chip->mce_mutex);
633 snd_cs4231_calibrate_mute(chip, 1);
635 snd_cs4231_mce_up(chip);
637 spin_lock_irqsave(&chip->lock, flags);
638 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
639 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
640 ((chip->image[CS4231_PLAYBK_FORMAT]) & 0xf0) |
642 spin_unlock_irqrestore(&chip->lock, flags);
643 snd_cs4231_mce_down(chip);
644 snd_cs4231_mce_up(chip);
645 spin_lock_irqsave(&chip->lock, flags);
647 snd_cs4231_out(chip, CS4231_REC_FORMAT, cdfr);
648 spin_unlock_irqrestore(&chip->lock, flags);
650 snd_cs4231_mce_down(chip);
652 snd_cs4231_calibrate_mute(chip, 0);
653 mutex_unlock(&chip->mce_mutex);
662 struct snd_cs4231 *chip = snd_timer_chip(timer);
664 return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920;
671 struct snd_cs4231 *chip = snd_timer_chip(timer);
673 spin_lock_irqsave(&chip->lock, flags);
675 if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 ||
676 (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] ||
677 (unsigned char)ticks != chip->image[CS4231_TIMER_LOW]) {
678 snd_cs4231_out(chip, CS4231_TIMER_HIGH,
679 chip->image[CS4231_TIMER_HIGH] =
681 snd_cs4231_out(chip, CS4231_TIMER_LOW,
682 chip->image[CS4231_TIMER_LOW] =
684 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1,
685 chip->image[CS4231_ALT_FEATURE_1] |
688 spin_unlock_irqrestore(&chip->lock, flags);
696 struct snd_cs4231 *chip = snd_timer_chip(timer);
698 spin_lock_irqsave(&chip->lock, flags);
699 chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE;
700 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1,
701 chip->image[CS4231_ALT_FEATURE_1]);
702 spin_unlock_irqrestore(&chip->lock, flags);
707 static void snd_cs4231_init(struct snd_cs4231 *chip)
711 snd_cs4231_mce_down(chip);
716 snd_cs4231_mce_up(chip);
717 spin_lock_irqsave(&chip->lock, flags);
718 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
723 chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB;
724 snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
725 spin_unlock_irqrestore(&chip->lock, flags);
726 snd_cs4231_mce_down(chip);
732 snd_cs4231_mce_up(chip);
733 spin_lock_irqsave(&chip->lock, flags);
734 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1,
735 chip->image[CS4231_ALT_FEATURE_1]);
736 spin_unlock_irqrestore(&chip->lock, flags);
737 snd_cs4231_mce_down(chip);
741 chip->image[CS4231_ALT_FEATURE_1]);
744 spin_lock_irqsave(&chip->lock, flags);
745 snd_cs4231_out(chip, CS4231_ALT_FEATURE_2,
746 chip->image[CS4231_ALT_FEATURE_2]);
747 spin_unlock_irqrestore(&chip->lock, flags);
749 snd_cs4231_mce_up(chip);
750 spin_lock_irqsave(&chip->lock, flags);
751 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
752 chip->image[CS4231_PLAYBK_FORMAT]);
753 spin_unlock_irqrestore(&chip->lock, flags);
754 snd_cs4231_mce_down(chip);
760 snd_cs4231_mce_up(chip);
761 spin_lock_irqsave(&chip->lock, flags);
762 snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]);
763 spin_unlock_irqrestore(&chip->lock, flags);
764 snd_cs4231_mce_down(chip);
771 static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode)
775 mutex_lock(&chip->open_mutex);
776 if ((chip->mode & mode)) {
777 mutex_unlock(&chip->open_mutex);
780 if (chip->mode & CS4231_MODE_OPEN) {
781 chip->mode |= mode;
782 mutex_unlock(&chip->open_mutex);
786 spin_lock_irqsave(&chip->lock, flags);
787 snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ |
790 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
791 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
792 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
794 snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ |
797 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
799 spin_unlock_irqrestore(&chip->lock, flags);
801 chip->mode = mode;
802 mutex_unlock(&chip->open_mutex);
806 static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode)
810 mutex_lock(&chip->open_mutex);
811 chip->mode &= ~mode;
812 if (chip->mode & CS4231_MODE_OPEN) {
813 mutex_unlock(&chip->open_mutex);
816 snd_cs4231_calibrate_mute(chip, 1);
819 spin_lock_irqsave(&chip->lock, flags);
820 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
821 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
822 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
826 if (chip->image[CS4231_IFACE_CTRL] &
829 spin_unlock_irqrestore(&chip->lock, flags);
830 snd_cs4231_mce_up(chip);
831 spin_lock_irqsave(&chip->lock, flags);
832 chip->image[CS4231_IFACE_CTRL] &=
835 snd_cs4231_out(chip, CS4231_IFACE_CTRL,
836 chip->image[CS4231_IFACE_CTRL]);
837 spin_unlock_irqrestore(&chip->lock, flags);
838 snd_cs4231_mce_down(chip);
839 spin_lock_irqsave(&chip->lock, flags);
843 snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
844 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
845 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */
846 spin_unlock_irqrestore(&chip->lock, flags);
848 snd_cs4231_calibrate_mute(chip, 0);
850 chip->mode = 0;
851 mutex_unlock(&chip->open_mutex);
860 struct snd_cs4231 *chip = snd_timer_chip(timer);
861 snd_cs4231_open(chip, CS4231_MODE_TIMER);
867 struct snd_cs4231 *chip = snd_timer_chip(timer);
868 snd_cs4231_close(chip, CS4231_MODE_TIMER);
890 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
893 new_pdfr = snd_cs4231_get_format(chip, params_format(hw_params),
896 snd_cs4231_playback_format(chip, hw_params, new_pdfr);
903 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
908 spin_lock_irqsave(&chip->lock, flags);
910 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
918 chip->p_periods_sent = 0;
921 spin_unlock_irqrestore(&chip->lock, flags);
929 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
932 new_cdfr = snd_cs4231_get_format(chip, params_format(hw_params),
935 snd_cs4231_capture_format(chip, hw_params, new_cdfr);
942 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
945 spin_lock_irqsave(&chip->lock, flags);
946 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE |
950 chip->c_periods_sent = 0;
951 spin_unlock_irqrestore(&chip->lock, flags);
956 static void snd_cs4231_overrange(struct snd_cs4231 *chip)
961 spin_lock_irqsave(&chip->lock, flags);
962 res = snd_cs4231_in(chip, CS4231_TEST_INIT);
963 spin_unlock_irqrestore(&chip->lock, flags);
967 chip->capture_substream->runtime->overrange++;
970 static void snd_cs4231_play_callback(struct snd_cs4231 *chip)
972 if (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE) {
973 snd_pcm_period_elapsed(chip->playback_substream);
974 snd_cs4231_advance_dma(&chip->p_dma, chip->playback_substream,
975 &chip->p_periods_sent);
979 static void snd_cs4231_capture_callback(struct snd_cs4231 *chip)
981 if (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) {
982 snd_pcm_period_elapsed(chip->capture_substream);
983 snd_cs4231_advance_dma(&chip->c_dma, chip->capture_substream,
984 &chip->c_periods_sent);
991 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
992 struct cs4231_dma_control *dma_cont = &chip->p_dma;
995 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE))
1007 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1008 struct cs4231_dma_control *dma_cont = &chip->c_dma;
1011 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE))
1020 static int snd_cs4231_probe(struct snd_cs4231 *chip)
1030 if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT)
1033 spin_lock_irqsave(&chip->lock, flags);
1034 snd_cs4231_out(chip, CS4231_MISC_INFO, CS4231_MODE2);
1035 id = snd_cs4231_in(chip, CS4231_MISC_INFO) & 0x0f;
1036 vers = snd_cs4231_in(chip, CS4231_VERSION);
1037 spin_unlock_irqrestore(&chip->lock, flags);
1042 snd_printdd("cs4231: port = %p, id = 0x%x\n", chip->port, id);
1046 spin_lock_irqsave(&chip->lock, flags);
1049 __cs4231_readb(chip, CS4231U(chip, STATUS));
1050 __cs4231_writeb(chip, 0, CS4231U(chip, STATUS));
1053 spin_unlock_irqrestore(&chip->lock, flags);
1055 chip->image[CS4231_MISC_INFO] = CS4231_MODE2;
1056 chip->image[CS4231_IFACE_CTRL] =
1057 chip->image[CS4231_IFACE_CTRL] & ~CS4231_SINGLE_DMA;
1058 chip->image[CS4231_ALT_FEATURE_1] = 0x80;
1059 chip->image[CS4231_ALT_FEATURE_2] = 0x01;
1061 chip->image[CS4231_ALT_FEATURE_2] |= 0x02;
1063 ptr = (unsigned char *) &chip->image;
1065 snd_cs4231_mce_down(chip);
1067 spin_lock_irqsave(&chip->lock, flags);
1070 snd_cs4231_out(chip, i, *ptr++);
1072 spin_unlock_irqrestore(&chip->lock, flags);
1074 snd_cs4231_mce_up(chip);
1076 snd_cs4231_mce_down(chip);
1133 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1139 err = snd_cs4231_open(chip, CS4231_MODE_PLAY);
1142 chip->playback_substream = substream;
1143 chip->p_periods_sent = 0;
1152 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1158 err = snd_cs4231_open(chip, CS4231_MODE_RECORD);
1161 chip->capture_substream = substream;
1162 chip->c_periods_sent = 0;
1171 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1173 snd_cs4231_close(chip, CS4231_MODE_PLAY);
1174 chip->playback_substream = NULL;
1181 struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1183 snd_cs4231_close(chip, CS4231_MODE_RECORD);
1184 chip->capture_substream = NULL;
1213 struct snd_cs4231 *chip = card->private_data;
1227 pcm->private_data = chip;
1232 &chip->op->dev, 64 * 1024, 128 * 1024);
1234 chip->pcm = pcm;
1241 struct snd_cs4231 *chip = card->private_data;
1256 timer->private_data = chip;
1258 chip->timer = timer;
1280 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1283 spin_lock_irqsave(&chip->lock, flags);
1285 (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6;
1287 (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6;
1288 spin_unlock_irqrestore(&chip->lock, flags);
1296 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1307 spin_lock_irqsave(&chip->lock, flags);
1309 left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left;
1310 right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right;
1311 change = left != chip->image[CS4231_LEFT_INPUT] ||
1312 right != chip->image[CS4231_RIGHT_INPUT];
1313 snd_cs4231_out(chip, CS4231_LEFT_INPUT, left);
1314 snd_cs4231_out(chip, CS4231_RIGHT_INPUT, right);
1316 spin_unlock_irqrestore(&chip->lock, flags);
1338 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1345 spin_lock_irqsave(&chip->lock, flags);
1347 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
1349 spin_unlock_irqrestore(&chip->lock, flags);
1361 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1375 spin_lock_irqsave(&chip->lock, flags);
1377 val = (chip->image[reg] & ~(mask << shift)) | val;
1378 change = val != chip->image[reg];
1379 snd_cs4231_out(chip, reg, val);
1381 spin_unlock_irqrestore(&chip->lock, flags);
1403 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1412 spin_lock_irqsave(&chip->lock, flags);
1415 (chip->image[left_reg] >> shift_left) & mask;
1417 (chip->image[right_reg] >> shift_right) & mask;
1419 spin_unlock_irqrestore(&chip->lock, flags);
1434 struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1454 spin_lock_irqsave(&chip->lock, flags);
1456 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
1457 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
1458 change = val1 != chip->image[left_reg];
1459 change |= val2 != chip->image[right_reg];
1460 snd_cs4231_out(chip, left_reg, val1);
1461 snd_cs4231_out(chip, right_reg, val2);
1463 spin_unlock_irqrestore(&chip->lock, flags);
1523 struct snd_cs4231 *chip = card->private_data;
1526 if (snd_BUG_ON(!chip || !chip->pcm))
1529 strcpy(card->mixername, chip->pcm->name);
1533 snd_ctl_new1(&snd_cs4231_controls[idx], chip));
1546 struct snd_cs4231 *chip;
1567 chip = card->private_data;
1568 chip->card = card;
1576 struct snd_cs4231 *chip = card->private_data;
1595 dev_set_drvdata(&chip->op->dev, chip);
1612 struct snd_cs4231 *chip = dev_id;
1615 if (!(__cs4231_readb(chip, CS4231U(chip, STATUS)) & CS4231_GLOBALIRQ))
1619 csr = sbus_readl(chip->port + APCCSR);
1621 sbus_writel(csr, chip->port + APCCSR);
1627 snd_cs4231_play_callback(chip);
1633 snd_cs4231_capture_callback(chip);
1635 status = snd_cs4231_in(chip, CS4231_IRQ_STATUS);
1638 if (chip->timer)
1639 snd_timer_interrupt(chip->timer, chip->timer->sticks);
1643 snd_cs4231_overrange(chip);
1646 spin_lock_irqsave(&chip->lock, flags);
1647 snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0);
1648 spin_unlock_irqrestore(&chip->lock, flags);
1754 static int snd_cs4231_sbus_free(struct snd_cs4231 *chip)
1756 struct platform_device *op = chip->op;
1758 if (chip->irq[0])
1759 free_irq(chip->irq[0], chip);
1761 if (chip->port)
1762 of_iounmap(&op->resource[0], chip->port, chip->regs_size);
1782 struct snd_cs4231 *chip = card->private_data;
1785 spin_lock_init(&chip->lock);
1786 spin_lock_init(&chip->c_dma.sbus_info.lock);
1787 spin_lock_init(&chip->p_dma.sbus_info.lock);
1788 mutex_init(&chip->mce_mutex);
1789 mutex_init(&chip->open_mutex);
1790 chip->op = op;
1791 chip->regs_size = resource_size(&op->resource[0]);
1792 memcpy(&chip->image, &snd_cs4231_original_image,
1795 chip->port = of_ioremap(&op->resource[0], 0,
1796 chip->regs_size, "cs4231");
1797 if (!chip->port) {
1798 snd_printdd("cs4231-%d: Unable to map chip registers.\n", dev);
1802 chip->c_dma.sbus_info.regs = chip->port;
1803 chip->p_dma.sbus_info.regs = chip->port;
1804 chip->c_dma.sbus_info.dir = APC_RECORD;
1805 chip->p_dma.sbus_info.dir = APC_PLAY;
1807 chip->p_dma.prepare = sbus_dma_prepare;
1808 chip->p_dma.enable = sbus_dma_enable;
1809 chip->p_dma.request = sbus_dma_request;
1810 chip->p_dma.address = sbus_dma_addr;
1812 chip->c_dma.prepare = sbus_dma_prepare;
1813 chip->c_dma.enable = sbus_dma_enable;
1814 chip->c_dma.request = sbus_dma_request;
1815 chip->c_dma.address = sbus_dma_addr;
1818 IRQF_SHARED, "cs4231", chip)) {
1821 snd_cs4231_sbus_free(chip);
1824 chip->irq[0] = op->archdata.irqs[0];
1826 if (snd_cs4231_probe(chip) < 0) {
1827 snd_cs4231_sbus_free(chip);
1830 snd_cs4231_init(chip);
1833 chip, &snd_cs4231_sbus_dev_ops)) < 0) {
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)) < 0) {
2026 snd_cs4231_ebus_free(chip);
2073 struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
2075 snd_card_free(chip->card);