Lines Matching refs:chip
106 #define NM_ACK_INT(chip, X) snd_nm256_writew(chip, NM_INT_REG, (X) << 1)
123 #define NM2_ACK_INT(chip, X) snd_nm256_writel(chip, NM_INT_REG, (X))
175 struct nm256 *chip;
180 u32 buf; /* offset from chip->buffer */
266 snd_nm256_readb(struct nm256 *chip, int offset)
268 return readb(chip->cport + offset);
272 snd_nm256_readw(struct nm256 *chip, int offset)
274 return readw(chip->cport + offset);
278 snd_nm256_readl(struct nm256 *chip, int offset)
280 return readl(chip->cport + offset);
284 snd_nm256_writeb(struct nm256 *chip, int offset, u8 val)
286 writeb(val, chip->cport + offset);
290 snd_nm256_writew(struct nm256 *chip, int offset, u16 val)
292 writew(val, chip->cport + offset);
296 snd_nm256_writel(struct nm256 *chip, int offset, u32 val)
298 writel(val, chip->cport + offset);
302 snd_nm256_write_buffer(struct nm256 *chip, const void *src, int offset, int size)
304 offset -= chip->buffer_start;
306 if (offset < 0 || offset >= chip->buffer_size) {
307 dev_err(chip->card->dev,
313 memcpy_toio(chip->buffer + offset, src, size);
330 snd_nm256_load_one_coefficient(struct nm256 *chip, int stream, u32 port, int which)
332 u32 coeff_buf = chip->coeff_buf[stream];
336 snd_nm256_write_buffer(chip, coefficients + offset, coeff_buf, size);
337 snd_nm256_writel(chip, port, coeff_buf);
341 snd_nm256_writel(chip, port + 4, coeff_buf + size);
345 snd_nm256_load_coefficient(struct nm256 *chip, int stream, int number)
355 if (snd_nm256_readb(chip, poffset) & 1) {
356 dev_dbg(chip->card->dev,
366 if (! chip->use_cache) {
367 snd_nm256_load_one_coefficient(chip, stream, addr, number);
370 if (! chip->coeffs_current) {
371 snd_nm256_write_buffer(chip, coefficients, chip->all_coeff_buf,
373 chip->coeffs_current = 1;
375 u32 base = chip->all_coeff_buf;
378 snd_nm256_writel(chip, addr, base + offset);
381 snd_nm256_writel(chip, addr + 4, base + end_offset);
415 snd_nm256_set_format(struct nm256 *chip, struct nm256_stream *s,
436 snd_nm256_load_coefficient(chip, 0, rate_index); /* 0 = playback */
437 snd_nm256_writeb(chip,
442 snd_nm256_load_coefficient(chip, 1, rate_index); /* 1 = record */
443 snd_nm256_writeb(chip,
451 static int snd_nm256_acquire_irq(struct nm256 *chip)
453 mutex_lock(&chip->irq_mutex);
454 if (chip->irq < 0) {
455 if (request_irq(chip->pci->irq, chip->interrupt, IRQF_SHARED,
456 KBUILD_MODNAME, chip)) {
457 dev_err(chip->card->dev,
458 "unable to grab IRQ %d\n", chip->pci->irq);
459 mutex_unlock(&chip->irq_mutex);
462 chip->irq = chip->pci->irq;
463 chip->card->sync_irq = chip->irq;
465 chip->irq_acks++;
466 mutex_unlock(&chip->irq_mutex);
471 static void snd_nm256_release_irq(struct nm256 *chip)
473 mutex_lock(&chip->irq_mutex);
474 if (chip->irq_acks > 0)
475 chip->irq_acks--;
476 if (chip->irq_acks == 0 && chip->irq >= 0) {
477 free_irq(chip->irq, chip);
478 chip->irq = -1;
479 chip->card->sync_irq = -1;
481 mutex_unlock(&chip->irq_mutex);
489 static void snd_nm256_pcm_mark(struct nm256 *chip, struct nm256_stream *s, int reg)
493 snd_nm256_writel(chip, reg, s->buf + s->cur_period * s->period_size);
496 #define snd_nm256_playback_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_PBUFFER_WMARK)
497 #define snd_nm256_capture_mark(chip, s) snd_nm256_pcm_mark(chip, s, NM_RBUFFER_WMARK)
500 snd_nm256_playback_start(struct nm256 *chip, struct nm256_stream *s,
504 snd_nm256_writel(chip, NM_PBUFFER_START, s->buf);
505 snd_nm256_writel(chip, NM_PBUFFER_END, s->buf + s->dma_size - (1 << s->shift));
506 snd_nm256_writel(chip, NM_PBUFFER_CURRP, s->buf);
507 snd_nm256_playback_mark(chip, s);
510 snd_nm256_writeb(chip, NM_PLAYBACK_ENABLE_REG,
513 snd_nm256_writew(chip, NM_AUDIO_MUTE_REG, 0x0);
517 snd_nm256_capture_start(struct nm256 *chip, struct nm256_stream *s,
521 snd_nm256_writel(chip, NM_RBUFFER_START, s->buf);
522 snd_nm256_writel(chip, NM_RBUFFER_END, s->buf + s->dma_size);
523 snd_nm256_writel(chip, NM_RBUFFER_CURRP, s->buf);
524 snd_nm256_capture_mark(chip, s);
527 snd_nm256_writeb(chip, NM_RECORD_ENABLE_REG,
533 snd_nm256_playback_stop(struct nm256 *chip)
536 snd_nm256_writew(chip, NM_AUDIO_MUTE_REG,
539 snd_nm256_writeb(chip, NM_PLAYBACK_ENABLE_REG, 0);
543 snd_nm256_capture_stop(struct nm256 *chip)
546 snd_nm256_writeb(chip, NM_RECORD_ENABLE_REG, 0);
552 struct nm256 *chip = snd_pcm_substream_chip(substream);
559 spin_lock(&chip->reg_lock);
566 snd_nm256_playback_start(chip, s, substream);
575 snd_nm256_playback_stop(chip);
583 spin_unlock(&chip->reg_lock);
590 struct nm256 *chip = snd_pcm_substream_chip(substream);
597 spin_lock(&chip->reg_lock);
602 snd_nm256_capture_start(chip, s, substream);
609 snd_nm256_capture_stop(chip);
617 spin_unlock(&chip->reg_lock);
627 struct nm256 *chip = snd_pcm_substream_chip(substream);
638 spin_lock_irq(&chip->reg_lock);
640 snd_nm256_set_format(chip, s, substream);
641 spin_unlock_irq(&chip->reg_lock);
653 struct nm256 *chip = snd_pcm_substream_chip(substream);
659 curp = snd_nm256_readl(chip, NM_PBUFFER_CURRP) - (unsigned long)s->buf;
667 struct nm256 *chip = snd_pcm_substream_chip(substream);
673 curp = snd_nm256_readl(chip, NM_RBUFFER_CURRP) - (unsigned long)s->buf;
757 snd_nm256_playback_update(struct nm256 *chip)
761 s = &chip->streams[SNDRV_PCM_STREAM_PLAYBACK];
763 spin_unlock(&chip->reg_lock);
765 spin_lock(&chip->reg_lock);
766 snd_nm256_playback_mark(chip, s);
772 snd_nm256_capture_update(struct nm256 *chip)
776 s = &chip->streams[SNDRV_PCM_STREAM_CAPTURE];
778 spin_unlock(&chip->reg_lock);
780 spin_lock(&chip->reg_lock);
781 snd_nm256_capture_mark(chip, s);
839 static void snd_nm256_setup_stream(struct nm256 *chip, struct nm256_stream *s,
862 struct nm256 *chip = snd_pcm_substream_chip(substream);
864 if (snd_nm256_acquire_irq(chip) < 0)
866 snd_nm256_setup_stream(chip, &chip->streams[SNDRV_PCM_STREAM_PLAYBACK],
874 struct nm256 *chip = snd_pcm_substream_chip(substream);
876 if (snd_nm256_acquire_irq(chip) < 0)
878 snd_nm256_setup_stream(chip, &chip->streams[SNDRV_PCM_STREAM_CAPTURE],
889 struct nm256 *chip = snd_pcm_substream_chip(substream);
891 snd_nm256_release_irq(chip);
899 struct nm256 *chip = snd_pcm_substream_chip(substream);
901 snd_nm256_release_irq(chip);
938 snd_nm256_pcm(struct nm256 *chip, int device)
944 struct nm256_stream *s = &chip->streams[i];
945 s->bufptr = chip->buffer + (s->buf - chip->buffer_start);
946 s->bufptr_addr = chip->buffer_addr + (s->buf - chip->buffer_start);
949 err = snd_pcm_new(chip->card, chip->card->driver, device,
957 pcm->private_data = chip;
959 chip->pcm = pcm;
969 snd_nm256_init_chip(struct nm256 *chip)
972 snd_nm256_writeb(chip, 0x0, 0x11);
973 snd_nm256_writew(chip, 0x214, 0);
975 //snd_nm256_playback_stop(chip);
976 //snd_nm256_capture_stop(chip);
981 snd_nm256_intr_check(struct nm256 *chip)
983 if (chip->badintrcount++ > 1000) {
996 if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running)
997 snd_nm256_playback_stop(chip);
998 if (chip->streams[SNDRV_PCM_STREAM_CAPTURE].running)
999 snd_nm256_capture_stop(chip);
1000 chip->badintrcount = 0;
1018 struct nm256 *chip = dev_id;
1022 status = snd_nm256_readw(chip, NM_INT_REG);
1026 return snd_nm256_intr_check(chip);
1028 chip->badintrcount = 0;
1032 spin_lock(&chip->reg_lock);
1035 NM_ACK_INT(chip, NM_PLAYBACK_INT);
1036 snd_nm256_playback_update(chip);
1041 NM_ACK_INT(chip, NM_RECORD_INT);
1042 snd_nm256_capture_update(chip);
1047 NM_ACK_INT(chip, NM_MISC_INT_1);
1048 dev_dbg(chip->card->dev, "NM256: Got misc interrupt #1\n");
1049 snd_nm256_writew(chip, NM_INT_REG, 0x8000);
1050 cbyte = snd_nm256_readb(chip, 0x400);
1051 snd_nm256_writeb(chip, 0x400, cbyte | 2);
1056 NM_ACK_INT(chip, NM_MISC_INT_2);
1057 dev_dbg(chip->card->dev, "NM256: Got misc interrupt #2\n");
1058 cbyte = snd_nm256_readb(chip, 0x400);
1059 snd_nm256_writeb(chip, 0x400, cbyte & ~2);
1064 dev_dbg(chip->card->dev,
1068 NM_ACK_INT(chip, status);
1071 spin_unlock(&chip->reg_lock);
1084 struct nm256 *chip = dev_id;
1088 status = snd_nm256_readl(chip, NM_INT_REG);
1092 return snd_nm256_intr_check(chip);
1094 chip->badintrcount = 0;
1098 spin_lock(&chip->reg_lock);
1101 NM2_ACK_INT(chip, NM2_PLAYBACK_INT);
1102 snd_nm256_playback_update(chip);
1107 NM2_ACK_INT(chip, NM2_RECORD_INT);
1108 snd_nm256_capture_update(chip);
1113 NM2_ACK_INT(chip, NM2_MISC_INT_1);
1114 dev_dbg(chip->card->dev, "NM256: Got misc interrupt #1\n");
1115 cbyte = snd_nm256_readb(chip, 0x400);
1116 snd_nm256_writeb(chip, 0x400, cbyte | 2);
1121 NM2_ACK_INT(chip, NM2_MISC_INT_2);
1122 dev_dbg(chip->card->dev, "NM256: Got misc interrupt #2\n");
1123 cbyte = snd_nm256_readb(chip, 0x400);
1124 snd_nm256_writeb(chip, 0x400, cbyte & ~2);
1129 dev_dbg(chip->card->dev,
1133 NM2_ACK_INT(chip, status);
1136 spin_unlock(&chip->reg_lock);
1149 snd_nm256_ac97_ready(struct nm256 *chip)
1155 testaddr = chip->mixer_status_offset;
1156 testb = chip->mixer_status_mask;
1162 if ((snd_nm256_readw(chip, testaddr) & testb) == 0)
1220 struct nm256 *chip = ac97->private_data;
1225 return chip->ac97_regs[idx];
1234 struct nm256 *chip = ac97->private_data;
1242 base = chip->mixer_base;
1244 snd_nm256_ac97_ready(chip);
1248 snd_nm256_writew(chip, base + reg, val);
1250 if (snd_nm256_ac97_ready(chip)) {
1252 chip->ac97_regs[idx] = val;
1256 dev_dbg(chip->card->dev, "nm256: ac97 codec not ready..\n");
1280 struct nm256 *chip = ac97->private_data;
1283 snd_nm256_writeb(chip, 0x6c0, 1);
1284 if (! chip->reset_workaround) {
1286 snd_nm256_writeb(chip, 0x6cc, 0x87);
1288 if (! chip->reset_workaround_2) {
1290 snd_nm256_writeb(chip, 0x6cc, 0x80);
1291 snd_nm256_writeb(chip, 0x6cc, 0x0);
1293 if (! chip->in_resume) {
1307 snd_nm256_mixer(struct nm256 *chip)
1318 chip->ac97_regs = kcalloc(ARRAY_SIZE(nm256_ac97_init_val),
1320 if (! chip->ac97_regs)
1323 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1328 ac97.private_data = chip;
1331 err = snd_ac97_mixer(pbus, &ac97, &chip->ac97);
1334 if (! (chip->ac97->id & (0xf0000000))) {
1336 sprintf(chip->card->mixername, "%s AC97", chip->card->driver);
1348 snd_nm256_peek_for_sig(struct nm256 *chip)
1353 unsigned long pointer_found = chip->buffer_end - 0x1400;
1356 temp = ioremap(chip->buffer_addr + chip->buffer_end - 0x400, 16);
1358 dev_err(chip->card->dev,
1371 pointer < chip->buffer_size ||
1372 pointer > chip->buffer_end) {
1373 dev_err(chip->card->dev,
1379 dev_info(chip->card->dev,
1386 chip->buffer_end = pointer_found;
1399 struct nm256 *chip = card->private_data;
1402 snd_ac97_suspend(chip->ac97);
1403 chip->coeffs_current = 0;
1410 struct nm256 *chip = card->private_data;
1414 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;
1441 static int snd_nm256_free(struct nm256 *chip)
1443 if (chip->streams[SNDRV_PCM_STREAM_PLAYBACK].running)
1444 snd_nm256_playback_stop(chip);
1445 if (chip->streams[SNDRV_PCM_STREAM_CAPTURE].running)
1446 snd_nm256_capture_stop(chip);
1448 if (chip->irq >= 0)
1449 free_irq(chip->irq, chip);
1451 iounmap(chip->cport);
1452 iounmap(chip->buffer);
1453 release_and_free_resource(chip->res_cport);
1454 release_and_free_resource(chip->res_buffer);
1456 pci_disable_device(chip->pci);
1457 kfree(chip->ac97_regs);
1458 kfree(chip);
1464 struct nm256 *chip = device->device_data;
1465 return snd_nm256_free(chip);
1472 struct nm256 *chip;
1484 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1485 if (chip == NULL) {
1490 chip->card = card;
1491 chip->pci = pci;
1492 chip->use_cache = use_cache;
1493 spin_lock_init(&chip->reg_lock);
1494 chip->irq = -1;
1495 mutex_init(&chip->irq_mutex);
1498 chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize = playback_bufsize * 1024;
1499 chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize = capture_bufsize * 1024;
1508 chip->buffer_addr = pci_resource_start(pci, 0);
1509 chip->cport_addr = pci_resource_start(pci, 1);
1513 chip->res_cport = request_mem_region(chip->cport_addr, NM_PORT2_SIZE,
1515 if (chip->res_cport == NULL) {
1517 chip->cport_addr, NM_PORT2_SIZE);
1521 chip->cport = ioremap(chip->cport_addr, NM_PORT2_SIZE);
1522 if (chip->cport == NULL) {
1524 chip->cport_addr);
1531 pval = snd_nm256_readw(chip, NM_MIXER_PRESENCE);
1546 chip->buffer_end = 2560 * 1024;
1547 chip->interrupt = snd_nm256_interrupt;
1548 chip->mixer_status_offset = NM_MIXER_STATUS_OFFSET;
1549 chip->mixer_status_mask = NM_MIXER_READY_MASK;
1552 if (snd_nm256_readb(chip, 0xa0b) != 0)
1553 chip->buffer_end = 6144 * 1024;
1555 chip->buffer_end = 4096 * 1024;
1557 chip->interrupt = snd_nm256_interrupt_zx;
1558 chip->mixer_status_offset = NM2_MIXER_STATUS_OFFSET;
1559 chip->mixer_status_mask = NM2_MIXER_READY_MASK;
1562 chip->buffer_size = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize +
1563 chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize;
1564 if (chip->use_cache)
1565 chip->buffer_size += NM_TOTAL_COEFF_COUNT * 4;
1567 chip->buffer_size += NM_MAX_PLAYBACK_COEF_SIZE + NM_MAX_RECORD_COEF_SIZE;
1569 if (buffer_top >= chip->buffer_size && buffer_top < chip->buffer_end)
1570 chip->buffer_end = buffer_top;
1573 if ((err = snd_nm256_peek_for_sig(chip)) < 0)
1577 chip->buffer_start = chip->buffer_end - chip->buffer_size;
1578 chip->buffer_addr += chip->buffer_start;
1581 chip->buffer_start, chip->buffer_end);
1583 chip->res_buffer = request_mem_region(chip->buffer_addr,
1584 chip->buffer_size,
1586 if (chip->res_buffer == NULL) {
1588 chip->buffer_addr, chip->buffer_size);
1592 chip->buffer = ioremap(chip->buffer_addr, chip->buffer_size);
1593 if (chip->buffer == NULL) {
1596 chip->buffer_addr);
1601 addr = chip->buffer_start;
1602 chip->streams[SNDRV_PCM_STREAM_PLAYBACK].buf = addr;
1603 addr += chip->streams[SNDRV_PCM_STREAM_PLAYBACK].bufsize;
1604 chip->streams[SNDRV_PCM_STREAM_CAPTURE].buf = addr;
1605 addr += chip->streams[SNDRV_PCM_STREAM_CAPTURE].bufsize;
1606 if (chip->use_cache) {
1607 chip->all_coeff_buf = addr;
1609 chip->coeff_buf[SNDRV_PCM_STREAM_PLAYBACK] = addr;
1611 chip->coeff_buf[SNDRV_PCM_STREAM_CAPTURE] = addr;
1615 chip->mixer_base = NM_MIXER_OFFSET;
1617 chip->coeffs_current = 0;
1619 snd_nm256_init_chip(chip);
1623 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0)
1626 *chip_ret = chip;
1630 snd_nm256_free(chip);
1652 struct nm256 *chip;
1705 if ((err = snd_nm256_create(card, pci, &chip)) < 0) {
1709 card->private_data = chip;
1713 chip->reset_workaround = 1;
1718 chip->reset_workaround_2 = 1;
1721 if ((err = snd_nm256_pcm(chip, 0)) < 0 ||
1722 (err = snd_nm256_mixer(chip)) < 0) {
1730 chip->buffer_addr, chip->cport_addr, chip->irq);