Lines Matching refs:chip
18 * A working Maestro setup contains the Maestro chip wired to a
438 /* chip type */
576 static void __maestro_write(struct es1968 *chip, u16 reg, u16 data)
578 outw(reg, chip->io_port + ESM_INDEX);
579 outw(data, chip->io_port + ESM_DATA);
580 chip->maestro_map[reg] = data;
583 static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data)
586 spin_lock_irqsave(&chip->reg_lock, flags);
587 __maestro_write(chip, reg, data);
588 spin_unlock_irqrestore(&chip->reg_lock, flags);
592 static u16 __maestro_read(struct es1968 *chip, u16 reg)
595 outw(reg, chip->io_port + ESM_INDEX);
596 chip->maestro_map[reg] = inw(chip->io_port + ESM_DATA);
598 return chip->maestro_map[reg];
601 static inline u16 maestro_read(struct es1968 *chip, u16 reg)
605 spin_lock_irqsave(&chip->reg_lock, flags);
606 result = __maestro_read(chip, reg);
607 spin_unlock_irqrestore(&chip->reg_lock, flags);
612 static int snd_es1968_ac97_wait(struct es1968 *chip)
617 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
621 dev_dbg(chip->card->dev, "ac97 timeout\n");
625 static int snd_es1968_ac97_wait_poll(struct es1968 *chip)
630 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
633 dev_dbg(chip->card->dev, "ac97 timeout\n");
639 struct es1968 *chip = ac97->private_data;
641 snd_es1968_ac97_wait(chip);
644 outw(val, chip->io_port + ESM_AC97_DATA);
646 outb(reg, chip->io_port + ESM_AC97_INDEX);
653 struct es1968 *chip = ac97->private_data;
655 snd_es1968_ac97_wait(chip);
657 outb(reg | 0x80, chip->io_port + ESM_AC97_INDEX);
660 if (!snd_es1968_ac97_wait_poll(chip)) {
661 data = inw(chip->io_port + ESM_AC97_DATA);
669 static void apu_index_set(struct es1968 *chip, u16 index)
672 __maestro_write(chip, IDR1_CRAM_POINTER, index);
674 if (__maestro_read(chip, IDR1_CRAM_POINTER) == index)
676 dev_dbg(chip->card->dev, "APU register select failed. (Timeout)\n");
680 static void apu_data_set(struct es1968 *chip, u16 data)
684 if (__maestro_read(chip, IDR0_DATA_PORT) == data)
686 __maestro_write(chip, IDR0_DATA_PORT, data);
688 dev_dbg(chip->card->dev, "APU register set probably failed (Timeout)!\n");
692 static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
697 chip->apu_map[channel][reg] = data;
700 apu_index_set(chip, reg);
701 apu_data_set(chip, data);
704 static void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
707 spin_lock_irqsave(&chip->reg_lock, flags);
708 __apu_set_register(chip, channel, reg, data);
709 spin_unlock_irqrestore(&chip->reg_lock, flags);
712 static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
717 apu_index_set(chip, reg);
718 return __maestro_read(chip, IDR0_DATA_PORT);
721 static u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
725 spin_lock_irqsave(&chip->reg_lock, flags);
726 v = __apu_get_register(chip, channel, reg);
727 spin_unlock_irqrestore(&chip->reg_lock, flags);
733 static void assp_set_register(struct es1968 *chip, u32 reg, u32 value)
737 spin_lock_irqsave(&chip->reg_lock, flags);
738 outl(reg, chip->io_port + ASSP_INDEX);
739 outl(value, chip->io_port + ASSP_DATA);
740 spin_unlock_irqrestore(&chip->reg_lock, flags);
743 static u32 assp_get_register(struct es1968 *chip, u32 reg)
748 spin_lock_irqsave(&chip->reg_lock, flags);
749 outl(reg, chip->io_port + ASSP_INDEX);
750 value = inl(chip->io_port + ASSP_DATA);
751 spin_unlock_irqrestore(&chip->reg_lock, flags);
758 static void wave_set_register(struct es1968 *chip, u16 reg, u16 value)
762 spin_lock_irqsave(&chip->reg_lock, flags);
763 outw(reg, chip->io_port + WC_INDEX);
764 outw(value, chip->io_port + WC_DATA);
765 spin_unlock_irqrestore(&chip->reg_lock, flags);
768 static u16 wave_get_register(struct es1968 *chip, u16 reg)
773 spin_lock_irqsave(&chip->reg_lock, flags);
774 outw(reg, chip->io_port + WC_INDEX);
775 value = inw(chip->io_port + WC_DATA);
776 spin_unlock_irqrestore(&chip->reg_lock, flags);
785 static void snd_es1968_bob_stop(struct es1968 *chip)
789 reg = __maestro_read(chip, 0x11);
791 __maestro_write(chip, 0x11, reg);
792 reg = __maestro_read(chip, 0x17);
794 __maestro_write(chip, 0x17, reg);
797 static void snd_es1968_bob_start(struct es1968 *chip)
805 if (chip->bob_freq > (ESS_SYSCLK >> (prescale + 9)))
818 if (chip->bob_freq >
829 __maestro_write(chip, 6, 0x9000 | (prescale << 5) | divide); /* set reg */
832 __maestro_write(chip, 0x11, __maestro_read(chip, 0x11) | 1);
833 __maestro_write(chip, 0x17, __maestro_read(chip, 0x17) | 1);
837 static void snd_es1968_bob_inc(struct es1968 *chip, int freq)
839 chip->bobclient++;
840 if (chip->bobclient == 1) {
841 chip->bob_freq = freq;
842 snd_es1968_bob_start(chip);
843 } else if (chip->bob_freq < freq) {
844 snd_es1968_bob_stop(chip);
845 chip->bob_freq = freq;
846 snd_es1968_bob_start(chip);
851 static void snd_es1968_bob_dec(struct es1968 *chip)
853 chip->bobclient--;
854 if (chip->bobclient <= 0)
855 snd_es1968_bob_stop(chip);
856 else if (chip->bob_freq > ESM_BOB_FREQ) {
860 list_for_each_entry(es, &chip->substream_list, list) {
864 if (max_freq != chip->bob_freq) {
865 snd_es1968_bob_stop(chip);
866 chip->bob_freq = max_freq;
867 snd_es1968_bob_start(chip);
873 snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,
895 static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq)
897 u32 rate = (freq << 16) / chip->clock;
907 snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)
911 offset = apu_get_register(chip, es->apu[0], 5);
918 static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq)
920 apu_set_register(chip, apu, 2,
921 (apu_get_register(chip, apu, 2) & 0x00FF) |
923 apu_set_register(chip, apu, 3, freq >> 8);
935 static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)
937 spin_lock(&chip->reg_lock);
938 __apu_set_register(chip, es->apu[0], 5, es->base[0]);
939 snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]);
941 __apu_set_register(chip, es->apu[2], 5, es->base[2]);
942 snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]);
945 __apu_set_register(chip, es->apu[1], 5, es->base[1]);
946 snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]);
948 __apu_set_register(chip, es->apu[3], 5, es->base[3]);
949 snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]);
952 spin_unlock(&chip->reg_lock);
955 static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)
957 spin_lock(&chip->reg_lock);
958 snd_es1968_trigger_apu(chip, es->apu[0], 0);
959 snd_es1968_trigger_apu(chip, es->apu[1], 0);
961 snd_es1968_trigger_apu(chip, es->apu[2], 0);
962 snd_es1968_trigger_apu(chip, es->apu[3], 0);
964 spin_unlock(&chip->reg_lock);
968 static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,
981 wave_set_register(chip, es->apu[channel] << 3, tmpval);
989 static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,
1007 snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0);
1011 pa -= chip->dma.addr;
1029 apu_set_register(chip, apu, i, 0x0000);
1032 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1033 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1034 apu_set_register(chip, apu, 6, (pa + size) & 0xFFFF);
1036 apu_set_register(chip, apu, 7, size);
1039 apu_set_register(chip, apu, 8, 0x0000);
1041 apu_set_register(chip, apu, 9, 0xD000);
1044 apu_set_register(chip, apu, 11, 0x0000);
1046 apu_set_register(chip, apu, 0, 0x400F);
1059 apu_set_register(chip, apu, 10,
1063 apu_set_register(chip, apu, 10, 0x8F08);
1066 spin_lock_irqsave(&chip->reg_lock, flags);
1068 outw(1, chip->io_port + 0x04);
1070 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1071 spin_unlock_irqrestore(&chip->reg_lock, flags);
1084 freq = snd_es1968_compute_rate(chip, freq);
1087 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1088 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1092 static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,
1101 snd_es1968_program_wavecache(chip, es, channel, pa, 1);
1104 pa -= chip->dma.addr;
1114 apu_set_register(chip, apu, i, 0x0000);
1118 apu_set_register(chip, apu, 2, 0x8);
1121 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1122 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1123 apu_set_register(chip, apu, 6, (pa + bsize) & 0xFFFF);
1124 apu_set_register(chip, apu, 7, bsize);
1126 apu_set_register(chip, apu, 8, 0x00F0);
1128 apu_set_register(chip, apu, 9, 0x0000);
1130 apu_set_register(chip, apu, 10, 0x8F08);
1132 apu_set_register(chip, apu, 11, route);
1134 apu_set_register(chip, apu, 0, 0x400F);
1137 static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,
1158 init_capture_apu(chip, es, 2,
1162 init_capture_apu(chip, es, 0, es->memory->buf.addr, size,
1166 init_capture_apu(chip, es, 3,
1171 init_capture_apu(chip, es, 1,
1183 freq = snd_es1968_compute_rate(chip, freq);
1186 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1187 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1191 snd_es1968_apu_set_freq(chip, es->apu[2], freq);
1192 snd_es1968_apu_set_freq(chip, es->apu[3], freq);
1194 spin_lock_irqsave(&chip->reg_lock, flags);
1196 outw(1, chip->io_port + 0x04);
1198 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1199 spin_unlock_irqrestore(&chip->reg_lock, flags);
1208 struct es1968 *chip = snd_pcm_substream_chip(substream);
1224 es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime);
1228 snd_es1968_playback_setup(chip, es, runtime);
1231 snd_es1968_capture_setup(chip, es, runtime);
1240 struct es1968 *chip = snd_pcm_substream_chip(substream);
1243 spin_lock(&chip->substream_lock);
1249 snd_es1968_bob_inc(chip, es->bob_freq);
1252 snd_es1968_pcm_start(chip, es);
1259 snd_es1968_pcm_stop(chip, es);
1261 snd_es1968_bob_dec(chip);
1264 spin_unlock(&chip->substream_lock);
1270 struct es1968 *chip = snd_pcm_substream_chip(substream);
1274 ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1328 static int calc_available_memory_size(struct es1968 *chip)
1333 mutex_lock(&chip->memory_mutex);
1334 list_for_each_entry(buf, &chip->buf_list, list) {
1338 mutex_unlock(&chip->memory_mutex);
1345 static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size)
1350 mutex_lock(&chip->memory_mutex);
1351 list_for_each_entry(buf, &chip->buf_list, list) {
1355 mutex_unlock(&chip->memory_mutex);
1362 mutex_unlock(&chip->memory_mutex);
1374 mutex_unlock(&chip->memory_mutex);
1379 static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf)
1383 mutex_lock(&chip->memory_mutex);
1385 if (buf->list.prev != &chip->buf_list) {
1394 if (buf->list.next != &chip->buf_list) {
1402 mutex_unlock(&chip->memory_mutex);
1405 static void snd_es1968_free_dmabuf(struct es1968 *chip)
1409 if (! chip->dma.area)
1411 snd_dma_free_pages(&chip->dma);
1412 while ((p = chip->buf_list.next) != &chip->buf_list) {
1420 snd_es1968_init_dmabuf(struct es1968 *chip)
1426 &chip->pci->dev,
1427 chip->total_bufsize, &chip->dma);
1428 if (err < 0 || ! chip->dma.area) {
1429 dev_err(chip->card->dev,
1431 chip->total_bufsize);
1434 if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) {
1435 snd_dma_free_pages(&chip->dma);
1436 dev_err(chip->card->dev, "DMA buffer beyond 256MB.\n");
1440 INIT_LIST_HEAD(&chip->buf_list);
1444 snd_es1968_free_dmabuf(chip);
1447 memset(chip->dma.area, 0, ESM_MEM_ALIGN);
1448 chunk->buf = chip->dma;
1453 list_add(&chunk->list, &chip->buf_list);
1463 struct es1968 *chip = snd_pcm_substream_chip(substream);
1473 snd_es1968_free_memory(chip, chan->memory);
1475 chan->memory = snd_es1968_new_memory(chip, size);
1477 dev_dbg(chip->card->dev,
1488 struct es1968 *chip = snd_pcm_substream_chip(substream);
1496 snd_es1968_free_memory(chip, chan->memory);
1506 static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type)
1511 if (chip->apu[apu] == ESM_APU_FREE &&
1512 chip->apu[apu + 1] == ESM_APU_FREE) {
1513 chip->apu[apu] = chip->apu[apu + 1] = type;
1523 static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu)
1525 chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE;
1535 struct es1968 *chip = snd_pcm_substream_chip(substream);
1541 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY);
1547 snd_es1968_free_apu_pair(chip, apu1);
1562 calc_available_memory_size(chip);
1564 spin_lock_irq(&chip->substream_lock);
1565 list_add(&es->list, &chip->substream_list);
1566 spin_unlock_irq(&chip->substream_lock);
1574 struct es1968 *chip = snd_pcm_substream_chip(substream);
1578 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
1581 apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV);
1583 snd_es1968_free_apu_pair(chip, apu1);
1589 snd_es1968_free_apu_pair(chip, apu1);
1590 snd_es1968_free_apu_pair(chip, apu2);
1607 if ((es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE)) == NULL) {
1608 snd_es1968_free_apu_pair(chip, apu1);
1609 snd_es1968_free_apu_pair(chip, apu2);
1618 calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */
1621 spin_lock_irq(&chip->substream_lock);
1622 list_add(&es->list, &chip->substream_list);
1623 spin_unlock_irq(&chip->substream_lock);
1630 struct es1968 *chip = snd_pcm_substream_chip(substream);
1636 spin_lock_irq(&chip->substream_lock);
1638 spin_unlock_irq(&chip->substream_lock);
1639 snd_es1968_free_apu_pair(chip, es->apu[0]);
1647 struct es1968 *chip = snd_pcm_substream_chip(substream);
1653 spin_lock_irq(&chip->substream_lock);
1655 spin_unlock_irq(&chip->substream_lock);
1656 snd_es1968_free_memory(chip, es->mixbuf);
1657 snd_es1968_free_apu_pair(chip, es->apu[0]);
1658 snd_es1968_free_apu_pair(chip, es->apu[2]);
1690 static void es1968_measure_clock(struct es1968 *chip)
1698 if (chip->clock == 0)
1699 chip->clock = 48000; /* default clock value */
1702 if ((apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY)) < 0) {
1703 dev_err(chip->card->dev, "Hmm, cannot find empty APU pair!?\n");
1706 if ((memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE)) == NULL) {
1707 dev_warn(chip->card->dev,
1709 chip->clock);
1710 snd_es1968_free_apu_pair(chip, apu);
1716 wave_set_register(chip, apu << 3, (memory->buf.addr - 0x10) & 0xfff8);
1718 pa = (unsigned int)((memory->buf.addr - chip->dma.addr) >> 1);
1723 apu_set_register(chip, apu, i, 0x0000);
1725 apu_set_register(chip, apu, 0, 0x400f);
1726 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xff) << 8);
1727 apu_set_register(chip, apu, 5, pa & 0xffff);
1728 apu_set_register(chip, apu, 6, (pa + CLOCK_MEASURE_BUFSIZE/2) & 0xffff);
1729 apu_set_register(chip, apu, 7, CLOCK_MEASURE_BUFSIZE/2);
1730 apu_set_register(chip, apu, 8, 0x0000);
1731 apu_set_register(chip, apu, 9, 0xD000);
1732 apu_set_register(chip, apu, 10, 0x8F08);
1733 apu_set_register(chip, apu, 11, 0x0000);
1734 spin_lock_irq(&chip->reg_lock);
1735 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
1736 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); /* enable WP ints */
1737 spin_unlock_irq(&chip->reg_lock);
1739 snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock); /* 48000 Hz */
1741 chip->in_measurement = 1;
1742 chip->measure_apu = apu;
1743 spin_lock_irq(&chip->reg_lock);
1744 snd_es1968_bob_inc(chip, ESM_BOB_FREQ);
1745 __apu_set_register(chip, apu, 5, pa & 0xffff);
1746 snd_es1968_trigger_apu(chip, apu, ESM_APU_16BITLINEAR);
1748 spin_unlock_irq(&chip->reg_lock);
1750 spin_lock_irq(&chip->reg_lock);
1751 offset = __apu_get_register(chip, apu, 5);
1753 snd_es1968_trigger_apu(chip, apu, 0); /* stop */
1754 snd_es1968_bob_dec(chip);
1755 chip->in_measurement = 0;
1756 spin_unlock_irq(&chip->reg_lock);
1761 offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2);
1766 dev_err(chip->card->dev, "?? calculation error..\n");
1772 chip->clock = (chip->clock * offset) / 48000;
1774 dev_info(chip->card->dev, "clocking to %d\n", chip->clock);
1776 snd_es1968_free_memory(chip, memory);
1777 snd_es1968_free_apu_pair(chip, apu);
1792 snd_es1968_pcm(struct es1968 *chip, int device)
1798 if ((err = snd_es1968_init_dmabuf(chip)) < 0)
1802 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
1803 wave_set_register(chip, 0x01FD, chip->dma.addr >> 12);
1804 wave_set_register(chip, 0x01FE, chip->dma.addr >> 12);
1805 wave_set_register(chip, 0x01FF, chip->dma.addr >> 12);
1807 if ((err = snd_pcm_new(chip->card, "ESS Maestro", device,
1808 chip->playback_streams,
1809 chip->capture_streams, &pcm)) < 0)
1812 pcm->private_data = chip;
1822 chip->pcm = pcm;
1829 static void snd_es1968_suppress_jitter(struct es1968 *chip, struct esschan *es)
1835 cp1 = __apu_get_register(chip, 0, 5);
1836 cp2 = __apu_get_register(chip, 1, 5);
1840 __maestro_write(chip, IDR0_DATA_PORT, cp1);
1846 static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
1855 hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1864 spin_unlock(&chip->substream_lock);
1866 spin_lock(&chip->substream_lock);
1877 struct es1968 *chip = container_of(work, struct es1968, hwvol_work);
1883 x = inb(chip->io_port + 0x1c) & 0xee;
1885 outb(0x88, chip->io_port + 0x1c);
1886 outb(0x88, chip->io_port + 0x1d);
1887 outb(0x88, chip->io_port + 0x1e);
1888 outb(0x88, chip->io_port + 0x1f);
1890 if (chip->in_suspend)
1894 if (! chip->master_switch || ! chip->master_volume)
1897 val = snd_ac97_read(chip->ac97, AC97_MASTER);
1918 if (snd_ac97_update(chip->ac97, AC97_MASTER, val))
1919 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1920 &chip->master_volume->id);
1922 if (!chip->input_dev)
1944 input_report_key(chip->input_dev, val, 1);
1945 input_sync(chip->input_dev);
1946 input_report_key(chip->input_dev, val, 0);
1947 input_sync(chip->input_dev);
1957 struct es1968 *chip = dev_id;
1960 if (!(event = inb(chip->io_port + 0x1A)))
1963 outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
1966 schedule_work(&chip->hwvol_work);
1969 outb(0xFF, chip->io_port + 0x1A);
1971 if ((event & ESM_MPU401_IRQ) && chip->rmidi) {
1972 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1977 spin_lock(&chip->substream_lock);
1978 list_for_each_entry(es, &chip->substream_list, list) {
1980 snd_es1968_update_pcm(chip, es);
1982 snd_es1968_suppress_jitter(chip, es);
1985 spin_unlock(&chip->substream_lock);
1986 if (chip->in_measurement) {
1987 unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5);
1988 if (curp < chip->measure_lastpos)
1989 chip->measure_count++;
1990 chip->measure_lastpos = curp;
2002 snd_es1968_mixer(struct es1968 *chip)
2015 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
2020 ac97.private_data = chip;
2021 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0)
2029 chip->master_switch = snd_ctl_find_id(chip->card, &elem_id);
2033 chip->master_volume = snd_ctl_find_id(chip->card, &elem_id);
2043 static void snd_es1968_ac97_reset(struct es1968 *chip)
2045 unsigned long ioaddr = chip->io_port;
2063 pci_read_config_word(chip->pci, 0x58, &w); /* something magical with gpio and bus arb. */
2064 pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2094 dev_info(chip->card->dev, "trying software reset\n");
2136 /* Turn on the 978 docking chip.
2148 static void snd_es1968_reset(struct es1968 *chip)
2152 chip->io_port + ESM_PORT_HOST_IRQ);
2154 outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ);
2159 * initialize maestro chip
2161 static void snd_es1968_chip_init(struct es1968 *chip)
2163 struct pci_dev *pci = chip->pci;
2165 unsigned long iobase = chip->io_port;
2234 /* Set up 978 docking control chip. */
2243 snd_es1968_reset(chip);
2249 /* setup usual 0x34 stuff.. 0x36 may be chip specific */
2259 snd_es1968_ac97_reset(chip);
2295 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2296 (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00));
2297 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2298 wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100);
2299 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2300 wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200);
2301 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2302 wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400);
2305 maestro_write(chip, IDR2_CRAM_DATA, 0x0000);
2308 maestro_write(chip, 0x08, 0xB004);
2309 maestro_write(chip, 0x09, 0x001B);
2310 maestro_write(chip, 0x0A, 0x8000);
2311 maestro_write(chip, 0x0B, 0x3F37);
2312 maestro_write(chip, 0x0C, 0x0098);
2315 maestro_write(chip, 0x0C,
2316 (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000);
2318 maestro_write(chip, 0x0C,
2319 (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500);
2321 maestro_write(chip, 0x0D, 0x7632);
2346 apu_set_register(chip, i, w, 0);
2352 static void snd_es1968_start_irq(struct es1968 *chip)
2356 if (chip->rmidi)
2358 outb(w, chip->io_port + 0x1A);
2359 outw(w, chip->io_port + ESM_PORT_HOST_IRQ);
2369 struct es1968 *chip = card->private_data;
2371 if (! chip->do_pm)
2374 chip->in_suspend = 1;
2375 cancel_work_sync(&chip->hwvol_work);
2377 snd_ac97_suspend(chip->ac97);
2378 snd_es1968_bob_stop(chip);
2385 struct es1968 *chip = card->private_data;
2388 if (! chip->do_pm)
2391 snd_es1968_chip_init(chip);
2394 if (chip->dma.addr) {
2396 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
2399 snd_es1968_start_irq(chip);
2402 snd_ac97_resume(chip->ac97);
2404 list_for_each_entry(es, &chip->substream_list, list) {
2407 snd_es1968_playback_setup(chip, es, es->substream->runtime);
2410 snd_es1968_capture_setup(chip, es, es->substream->runtime);
2416 if (chip->bobclient)
2417 snd_es1968_bob_start(chip);
2420 chip->in_suspend = 0;
2432 static int snd_es1968_create_gameport(struct es1968 *chip, int dev)
2445 chip->gameport = gp = gameport_allocate_port();
2447 dev_err(chip->card->dev,
2453 pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val);
2454 pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04);
2457 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
2458 gameport_set_dev_parent(gp, &chip->pci->dev);
2467 static void snd_es1968_free_gameport(struct es1968 *chip)
2469 if (chip->gameport) {
2470 struct resource *r = gameport_get_port_data(chip->gameport);
2472 gameport_unregister_port(chip->gameport);
2473 chip->gameport = NULL;
2479 static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }
2480 static inline void snd_es1968_free_gameport(struct es1968 *chip) { }
2484 static int snd_es1968_input_register(struct es1968 *chip)
2493 snprintf(chip->phys, sizeof(chip->phys), "pci-%s/input0",
2494 pci_name(chip->pci));
2496 input_dev->name = chip->card->driver;
2497 input_dev->phys = chip->phys;
2499 input_dev->id.vendor = chip->pci->vendor;
2500 input_dev->id.product = chip->pci->device;
2501 input_dev->dev.parent = &chip->pci->dev;
2514 chip->input_dev = input_dev;
2537 #define get_tea575x_gpio(chip) \
2538 (&snd_es1968_tea575x_gpios[(chip)->tea575x_tuner])
2543 struct es1968 *chip = tea->private_data;
2544 struct snd_es1968_tea575x_gpio gpio = *get_tea575x_gpio(chip);
2551 outw(val, chip->io_port + GPIO_DATA);
2556 struct es1968 *chip = tea->private_data;
2557 struct snd_es1968_tea575x_gpio gpio = *get_tea575x_gpio(chip);
2558 u16 val = inw(chip->io_port + GPIO_DATA);
2571 struct es1968 *chip = tea->private_data;
2572 unsigned long io = chip->io_port + GPIO_DATA;
2574 struct snd_es1968_tea575x_gpio gpio = *get_tea575x_gpio(chip);
2596 static int snd_es1968_free(struct es1968 *chip)
2598 cancel_work_sync(&chip->hwvol_work);
2600 if (chip->input_dev)
2601 input_unregister_device(chip->input_dev);
2604 if (chip->io_port) {
2605 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
2606 outw(0, chip->io_port + ESM_PORT_HOST_IRQ); /* disable IRQ */
2610 snd_tea575x_exit(&chip->tea);
2611 v4l2_device_unregister(&chip->v4l2_dev);
2614 if (chip->irq >= 0)
2615 free_irq(chip->irq, chip);
2616 snd_es1968_free_gameport(chip);
2617 pci_release_regions(chip->pci);
2618 pci_disable_device(chip->pci);
2619 kfree(chip);
2625 struct es1968 *chip = device->device_data;
2626 return snd_es1968_free(chip);
2630 unsigned short type; /* chip type */
2662 struct es1968 *chip;
2679 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
2680 if (! chip) {
2686 chip->type = chip_type;
2687 spin_lock_init(&chip->reg_lock);
2688 spin_lock_init(&chip->substream_lock);
2689 INIT_LIST_HEAD(&chip->buf_list);
2690 INIT_LIST_HEAD(&chip->substream_list);
2691 mutex_init(&chip->memory_mutex);
2692 INIT_WORK(&chip->hwvol_work, es1968_update_hw_volume);
2693 chip->card = card;
2694 chip->pci = pci;
2695 chip->irq = -1;
2696 chip->total_bufsize = total_bufsize; /* in bytes */
2697 chip->playback_streams = play_streams;
2698 chip->capture_streams = capt_streams;
2701 kfree(chip);
2705 chip->io_port = pci_resource_start(pci, 0);
2707 KBUILD_MODNAME, chip)) {
2709 snd_es1968_free(chip);
2712 chip->irq = pci->irq;
2713 card->sync_irq = chip->irq;
2717 chip->maestro_map[i] = 0;
2721 chip->apu[i] = ESM_APU_FREE;
2729 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2731 if (chip->type == pm_allowlist[i].type &&
2743 chip->do_pm = do_pm;
2745 snd_es1968_chip_init(chip);
2747 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2748 snd_es1968_free(chip);
2754 if (chip->pci->subsystem_vendor != 0x125d)
2756 err = v4l2_device_register(&pci->dev, &chip->v4l2_dev);
2758 snd_es1968_free(chip);
2761 chip->tea.v4l2_dev = &chip->v4l2_dev;
2762 chip->tea.private_data = chip;
2763 chip->tea.radio_nr = radio_nr;
2764 chip->tea.ops = &snd_es1968_tea_ops;
2765 sprintf(chip->tea.bus_info, "PCI:%s", pci_name(pci));
2767 chip->tea575x_tuner = i;
2768 if (!snd_tea575x_init(&chip->tea, THIS_MODULE)) {
2770 get_tea575x_gpio(chip)->name);
2771 strlcpy(chip->tea.card, get_tea575x_gpio(chip)->name,
2772 sizeof(chip->tea.card));
2779 *chip_ret = chip;
2792 struct es1968 *chip;
2819 &chip)) < 0) {
2823 card->private_data = chip;
2825 switch (chip->type) {
2840 if ((err = snd_es1968_pcm(chip, 0)) < 0) {
2845 if ((err = snd_es1968_mixer(chip)) < 0) {
2853 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2855 if (chip->type == mpu_denylist[i].type &&
2864 chip->io_port + ESM_MPU401_PORT,
2867 -1, &chip->rmidi)) < 0) {
2872 snd_es1968_create_gameport(chip, dev);
2875 err = snd_es1968_input_register(chip);
2881 snd_es1968_start_irq(chip);
2883 chip->clock = clock[dev];
2884 if (! chip->clock)
2885 es1968_measure_clock(chip);
2888 card->shortname, chip->io_port, chip->irq);