Lines Matching refs:chip
121 #define NM_ACK_INT(chip, X) snd_nm256_writew(chip, NM_INT_REG, (X) << 1)
138 #define NM2_ACK_INT(chip, X) snd_nm256_writel(chip, NM_INT_REG, (X))
190 struct nm256 *chip;
195 u32 buf; /* offset from chip->buffer */
281 snd_nm256_readb(struct nm256 *chip, int offset)
283 return readb(chip->cport + offset);
287 snd_nm256_readw(struct nm256 *chip, int offset)
289 return readw(chip->cport + offset);
293 snd_nm256_readl(struct nm256 *chip, int offset)
295 return readl(chip->cport + offset);
299 snd_nm256_writeb(struct nm256 *chip, int offset, u8 val)
301 writeb(val, chip->cport + offset);
305 snd_nm256_writew(struct nm256 *chip, int offset, u16 val)
307 writew(val, chip->cport + offset);
311 snd_nm256_writel(struct nm256 *chip, int offset, u32 val)
313 writel(val, chip->cport + offset);
317 snd_nm256_write_buffer(struct nm256 *chip, void *src, int offset, int size)
319 offset -= chip->buffer_start;
321 if (offset < 0 || offset >= chip->buffer_size) {
327 memcpy_toio(chip->buffer + offset, src, size);
344 snd_nm256_load_one_coefficient(struct nm256 *chip, int stream, u32 port, int which)
346 u32 coeff_buf = chip->coeff_buf[stream];
350 snd_nm256_write_buffer(chip, coefficients + offset, coeff_buf, size);
351 snd_nm256_writel(chip, port, coeff_buf);
355 snd_nm256_writel(chip, port + 4, coeff_buf + size);
359 snd_nm256_load_coefficient(struct nm256 *chip, int stream, int number)
369 if (snd_nm256_readb(chip, poffset) & 1) {
379 if (! chip->use_cache) {
380 snd_nm256_load_one_coefficient(chip, stream, addr, number);
383 if (! chip->coeffs_current) {
384 snd_nm256_write_buffer(chip, coefficients, chip->all_coeff_buf,
386 chip->coeffs_current = 1;
388 u32 base = chip->all_coeff_buf;
391 snd_nm256_writel(chip, addr, base + offset);
394 snd_nm256_writel(chip, addr + 4, base + end_offset);
428 snd_nm256_set_format(struct nm256 *chip, struct nm256_stream *s,
449 snd_nm256_load_coefficient(chip, 0, rate_index); /* 0 = playback */
450 snd_nm256_writeb(chip,
455 snd_nm256_load_coefficient(chip, 1, rate_index); /* 1 = record */
456 snd_nm256_writeb(chip,
464 static int snd_nm256_acquire_irq(struct nm256 *chip)
466 mutex_lock(&chip->irq_mutex);
467 if (chip->irq < 0) {
468 if (request_irq(chip->pci->irq, chip->interrupt, IRQF_SHARED,
469 chip->card->driver, chip)) {
470 snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->pci->irq);
471 mutex_unlock(&chip->irq_mutex);
474 chip->irq = chip->pci->irq;
476 chip->irq_acks++;
477 mutex_unlock(&chip->irq_mutex);
482 static void snd_nm256_release_irq(struct nm256 *chip)
484 mutex_lock(&chip->irq_mutex);
485 if (chip->irq_acks > 0)
486 chip->irq_acks--;
487 if (chip->irq_acks == 0 && chip->irq >= 0) {
488 free_irq(chip->irq, chip);
489 chip->irq = -1;
491 mutex_unlock(&chip->irq_mutex);
499 static void snd_nm256_pcm_mark(struct nm256 *chip, struct nm256_stream *s, int reg)
503 snd_nm256_writel(chip, reg, s->buf + s->cur_period * s->period_size);
506 #define snd_nm256_playback_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_PBUFFER_WMARK)
507 #define snd_nm256_capture_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_RBUFFER_WMARK)
510 snd_nm256_playback_start(struct nm256 *chip, struct nm256_stream *s,
514 snd_nm256_writel(chip, NM_PBUFFER_START, s->buf);
515 snd_nm256_writel(chip, NM_PBUFFER_END, s->buf + s->dma_size - (1 << s->shift));
516 snd_nm256_writel(chip, NM_PBUFFER_CURRP, s->buf);
517 snd_nm256_playback_mark(chip, s);
520 snd_nm256_writeb(chip, NM_PLAYBACK_ENABLE_REG,
523 snd_nm256_writew(chip, NM_AUDIO_MUTE_REG, 0x0);
527 snd_nm256_capture_start(struct nm256 *chip, struct nm256_stream *s,
531 snd_nm256_writel(chip, NM_RBUFFER_START, s->buf);
532 snd_nm256_writel(chip, NM_RBUFFER_END, s->buf + s->dma_size);
533 snd_nm256_writel(chip, NM_RBUFFER_CURRP, s->buf);
534 snd_nm256_capture_mark(chip, s);
537 snd_nm256_writeb(chip, NM_RECORD_ENABLE_REG,
543 snd_nm256_playback_stop(struct nm256 *chip)
546 snd_nm256_writew(chip, NM_AUDIO_MUTE_REG,
549 snd_nm256_writeb(chip, NM_PLAYBACK_ENABLE_REG, 0);
553 snd_nm256_capture_stop(struct nm256 *chip)
556 snd_nm256_writeb(chip, NM_RECORD_ENABLE_REG, 0);
562 struct nm256 *chip = snd_pcm_substream_chip(substream);
568 spin_lock(&chip->reg_lock);
575 snd_nm256_playback_start(chip, s, substream);
584 snd_nm256_playback_stop(chip);
592 spin_unlock(&chip->reg_lock);
599 struct nm256 *chip = snd_pcm_substream_chip(substream);
605 spin_lock(&chip->reg_lock);
610 snd_nm256_capture_start(chip, s, substream);
617 snd_nm256_capture_stop(chip);
625 spin_unlock(&chip->reg_lock);
635 struct nm256 *chip = snd_pcm_substream_chip(substream);
645 spin_lock_irq(&chip->reg_lock);
647 snd_nm256_set_format(chip, s, substream);
648 spin_unlock_irq(&chip->reg_lock);
660 struct nm256 *chip = snd_pcm_substream_chip(substream);
665 curp = snd_nm256_readl(chip, NM_PBUFFER_CURRP) - (unsigned long)s->buf;
673 struct nm256 *chip = snd_pcm_substream_chip(substream);
678 curp = snd_nm256_readl(chip, NM_RBUFFER_CURRP) - (unsigned long)s->buf;
747 snd_nm256_playback_update(struct nm256 *chip)
751 s = &chip->streams[SNDRV_PCM_STREAM_PLAYBACK];
753 spin_unlock(&chip->reg_lock);
755 spin_lock(&chip->reg_lock);
756 snd_nm256_playback_mark(chip, s);
762 snd_nm256_capture_update(struct nm256 *chip)
766 s = &chip->streams[SNDRV_PCM_STREAM_CAPTURE];
768 spin_unlock(&chip->reg_lock);
770 spin_lock(&chip->reg_lock);
771 snd_nm256_capture_mark(chip, s);
829 static void snd_nm256_setup_stream(struct nm256 *chip, struct nm256_stream *s,
853 struct nm256 *chip = snd_pcm_substream_chip(substream);
855 if (snd_nm256_acquire_irq(chip) < 0)
857 snd_nm256_setup_stream(chip, &chip->streams[SNDRV_PCM_STREAM_PLAYBACK],
865 struct nm256 *chip = snd_pcm_substream_chip(substream);
867 if (snd_nm256_acquire_irq(chip) < 0)
869 snd_nm256_setup_stream(chip, &chip->streams[SNDRV_PCM_STREAM_CAPTURE],
880 struct nm256 *chip = snd_pcm_substream_chip(substream);
882 snd_nm256_release_irq(chip);
890 struct nm256 *chip = snd_pcm_substream_chip(substream);
892 snd_nm256_release_irq(chip);
929 snd_nm256_pcm(struct nm256 *chip, int device)
935 struct nm256_stream *s = &chip->streams[i];
936 s->bufptr = chip->buffer + (s->buf - chip->buffer_start);
937 s->bufptr_addr = chip->buffer_addr + (s->buf - chip->buffer_start);
940 err = snd_pcm_new(chip->card, chip->card->driver, device,
948 pcm->private_data = chip;
950 chip->pcm = pcm;
960 snd_nm256_init_chip(struct nm256 *chip)
963 snd_nm256_writeb(chip, 0x0, 0x11);
964 snd_nm256_writew(chip, 0x214, 0);
966 //snd_nm256_playback_stop(chip);
967 //snd_nm256_capture_stop(chip);
972 snd_nm256_intr_check(struct nm256 *chip)
974 if (chip->badintrcount++ > 1000) {
987 if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running)
988 snd_nm256_playback_stop(chip);
989 if (chip->streams[SNDRV_PCM_STREAM_CAPTURE].running)
990 snd_nm256_capture_stop(chip);
991 chip->badintrcount = 0;
1009 struct nm256 *chip = dev_id;
1013 status = snd_nm256_readw(chip, NM_INT_REG);
1017 return snd_nm256_intr_check(chip);
1019 chip->badintrcount = 0;
1023 spin_lock(&chip->reg_lock);
1026 NM_ACK_INT(chip, NM_PLAYBACK_INT);
1027 snd_nm256_playback_update(chip);
1032 NM_ACK_INT(chip, NM_RECORD_INT);
1033 snd_nm256_capture_update(chip);
1038 NM_ACK_INT(chip, NM_MISC_INT_1);
1040 snd_nm256_writew(chip, NM_INT_REG, 0x8000);
1041 cbyte = snd_nm256_readb(chip, 0x400);
1042 snd_nm256_writeb(chip, 0x400, cbyte | 2);
1047 NM_ACK_INT(chip, NM_MISC_INT_2);
1049 cbyte = snd_nm256_readb(chip, 0x400);
1050 snd_nm256_writeb(chip, 0x400, cbyte & ~2);
1058 NM_ACK_INT(chip, status);
1061 spin_unlock(&chip->reg_lock);
1074 struct nm256 *chip = dev_id;
1078 status = snd_nm256_readl(chip, NM_INT_REG);
1082 return snd_nm256_intr_check(chip);
1084 chip->badintrcount = 0;
1088 spin_lock(&chip->reg_lock);
1091 NM2_ACK_INT(chip, NM2_PLAYBACK_INT);
1092 snd_nm256_playback_update(chip);
1097 NM2_ACK_INT(chip, NM2_RECORD_INT);
1098 snd_nm256_capture_update(chip);
1103 NM2_ACK_INT(chip, NM2_MISC_INT_1);
1105 cbyte = snd_nm256_readb(chip, 0x400);
1106 snd_nm256_writeb(chip, 0x400, cbyte | 2);
1111 NM2_ACK_INT(chip, NM2_MISC_INT_2);
1113 cbyte = snd_nm256_readb(chip, 0x400);
1114 snd_nm256_writeb(chip, 0x400, cbyte & ~2);
1122 NM2_ACK_INT(chip, status);
1125 spin_unlock(&chip->reg_lock);
1138 snd_nm256_ac97_ready(struct nm256 *chip)
1144 testaddr = chip->mixer_status_offset;
1145 testb = chip->mixer_status_mask;
1151 if ((snd_nm256_readw(chip, testaddr) & testb) == 0)
1209 struct nm256 *chip = ac97->private_data;
1214 return chip->ac97_regs[idx];
1223 struct nm256 *chip = ac97->private_data;
1231 base = chip->mixer_base;
1233 snd_nm256_ac97_ready(chip);
1237 snd_nm256_writew(chip, base + reg, val);
1239 if (snd_nm256_ac97_ready(chip)) {
1241 chip->ac97_regs[idx] = val;
1269 struct nm256 *chip = ac97->private_data;
1272 snd_nm256_writeb(chip, 0x6c0, 1);
1273 if (! chip->reset_workaround) {
1275 snd_nm256_writeb(chip, 0x6cc, 0x87);
1277 if (! chip->reset_workaround_2) {
1279 snd_nm256_writeb(chip, 0x6cc, 0x80);
1280 snd_nm256_writeb(chip, 0x6cc, 0x0);
1282 if (! chip->in_resume) {
1296 snd_nm256_mixer(struct nm256 *chip)
1307 chip->ac97_regs = kcalloc(sizeof(short),
1309 if (! chip->ac97_regs)
1312 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1317 ac97.private_data = chip;
1320 err = snd_ac97_mixer(pbus, &ac97, &chip->ac97);
1323 if (! (chip->ac97->id & (0xf0000000))) {
1325 sprintf(chip->card->mixername, "%s AC97", chip->card->driver);
1337 snd_nm256_peek_for_sig(struct nm256 *chip)
1342 unsigned long pointer_found = chip->buffer_end - 0x1400;
1345 temp = ioremap_nocache(chip->buffer_addr + chip->buffer_end - 0x400, 16);
1359 pointer < chip->buffer_size ||
1360 pointer > chip->buffer_end) {
1372 chip->buffer_end = pointer_found;
1385 struct nm256 *chip = card->private_data;
1388 snd_pcm_suspend_all(chip->pcm);
1389 snd_ac97_suspend(chip->ac97);
1390 chip->coeffs_current = 0;
1400 struct nm256 *chip = card->private_data;
1404 chip->in_resume = 1;
1416 snd_nm256_init_chip(chip);
1419 snd_ac97_resume(chip->ac97);
1422 struct nm256_stream *s = &chip->streams[i];
1424 spin_lock_irq(&chip->reg_lock);
1425 snd_nm256_set_format(chip, s, s->substream);
1426 spin_unlock_irq(&chip->reg_lock);
1431 chip->in_resume = 0;
1436 static int snd_nm256_free(struct nm256 *chip)
1438 if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running)
1439 snd_nm256_playback_stop(chip);
1440 if (chip->streams[SNDRV_PCM_STREAM_CAPTURE].running)
1441 snd_nm256_capture_stop(chip);
1443 if (chip->irq >= 0)
1444 synchronize_irq(chip->irq);
1446 if (chip->cport)
1447 iounmap(chip->cport);
1448 if (chip->buffer)
1449 iounmap(chip->buffer);
1450 release_and_free_resource(chip->res_cport);
1451 release_and_free_resource(chip->res_buffer);
1452 if (chip->irq >= 0)
1453 free_irq(chip->irq, chip);
1455 pci_disable_device(chip->pci);
1456 kfree(chip->ac97_regs);
1457 kfree(chip);
1463 struct nm256 *chip = device->device_data;
1464 return snd_nm256_free(chip);
1471 struct nm256 *chip;
1483 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1484 if (chip == NULL) {
1489 chip->card = card;
1490 chip->pci = pci;
1491 chip->use_cache = use_cache;
1492 spin_lock_init(&chip->reg_lock);
1493 chip->irq = -1;
1494 mutex_init(&chip->irq_mutex);
1497 chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize = playback_bufsize * 1024;
1498 chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize = capture_bufsize * 1024;
1507 chip->buffer_addr = pci_resource_start(pci, 0);
1508 chip->cport_addr = pci_resource_start(pci, 1);
1512 chip->res_cport = request_mem_region(chip->cport_addr, NM_PORT2_SIZE,
1514 if (chip->res_cport == NULL) {
1516 chip->cport_addr, NM_PORT2_SIZE);
1520 chip->cport = ioremap_nocache(chip->cport_addr, NM_PORT2_SIZE);
1521 if (chip->cport == NULL) {
1522 snd_printk(KERN_ERR "unable to map control port %lx\n", chip->cport_addr);
1529 pval = snd_nm256_readw(chip, NM_MIXER_PRESENCE);
1541 chip->buffer_end = 2560 * 1024;
1542 chip->interrupt = snd_nm256_interrupt;
1543 chip->mixer_status_offset = NM_MIXER_STATUS_OFFSET;
1544 chip->mixer_status_mask = NM_MIXER_READY_MASK;
1547 if (snd_nm256_readb(chip, 0xa0b) != 0)
1548 chip->buffer_end = 6144 * 1024;
1550 chip->buffer_end = 4096 * 1024;
1552 chip->interrupt = snd_nm256_interrupt_zx;
1553 chip->mixer_status_offset = NM2_MIXER_STATUS_OFFSET;
1554 chip->mixer_status_mask = NM2_MIXER_READY_MASK;
1557 chip->buffer_size = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize +
1558 chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize;
1559 if (chip->use_cache)
1560 chip->buffer_size += NM_TOTAL_COEFF_COUNT * 4;
1562 chip->buffer_size += NM_MAX_PLAYBACK_COEF_SIZE + NM_MAX_RECORD_COEF_SIZE;
1564 if (buffer_top >= chip->buffer_size && buffer_top < chip->buffer_end)
1565 chip->buffer_end = buffer_top;
1568 if ((err = snd_nm256_peek_for_sig(chip)) < 0)
1572 chip->buffer_start = chip->buffer_end - chip->buffer_size;
1573 chip->buffer_addr += chip->buffer_start;
1576 chip->buffer_start, chip->buffer_end);
1578 chip->res_buffer = request_mem_region(chip->buffer_addr,
1579 chip->buffer_size,
1581 if (chip->res_buffer == NULL) {
1583 chip->buffer_addr, chip->buffer_size);
1587 chip->buffer = ioremap_nocache(chip->buffer_addr, chip->buffer_size);
1588 if (chip->buffer == NULL) {
1590 snd_printk(KERN_ERR "unable to map ring buffer at %lx\n", chip->buffer_addr);
1595 addr = chip->buffer_start;
1596 chip->streams[SNDRV_PCM_STREAM_PLAYBACK].buf = addr;
1597 addr += chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize;
1598 chip->streams[SNDRV_PCM_STREAM_CAPTURE].buf = addr;
1599 addr += chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize;
1600 if (chip->use_cache) {
1601 chip->all_coeff_buf = addr;
1603 chip->coeff_buf[SNDRV_PCM_STREAM_PLAYBACK] = addr;
1605 chip->coeff_buf[SNDRV_PCM_STREAM_CAPTURE] = addr;
1609 chip->mixer_base = NM_MIXER_OFFSET;
1611 chip->coeffs_current = 0;
1613 snd_nm256_init_chip(chip);
1617 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0)
1622 *chip_ret = chip;
1626 snd_nm256_free(chip);
1648 struct nm256 *chip;
1700 if ((err = snd_nm256_create(card, pci, &chip)) < 0) {
1704 card->private_data = chip;
1708 chip->reset_workaround = 1;
1713 chip->reset_workaround_2 = 1;
1716 if ((err = snd_nm256_pcm(chip, 0)) < 0 ||
1717 (err = snd_nm256_mixer(chip)) < 0) {
1725 chip->buffer_addr, chip->cport_addr, chip->irq);