Lines Matching refs:chip
18 * A working Maestro setup contains the Maestro chip wired to a
434 /* chip type */
572 static void __maestro_write(struct es1968 *chip, u16 reg, u16 data)
574 outw(reg, chip->io_port + ESM_INDEX);
575 outw(data, chip->io_port + ESM_DATA);
576 chip->maestro_map[reg] = data;
579 static inline void maestro_write(struct es1968 *chip, u16 reg, u16 data)
582 spin_lock_irqsave(&chip->reg_lock, flags);
583 __maestro_write(chip, reg, data);
584 spin_unlock_irqrestore(&chip->reg_lock, flags);
588 static u16 __maestro_read(struct es1968 *chip, u16 reg)
591 outw(reg, chip->io_port + ESM_INDEX);
592 chip->maestro_map[reg] = inw(chip->io_port + ESM_DATA);
594 return chip->maestro_map[reg];
597 static inline u16 maestro_read(struct es1968 *chip, u16 reg)
601 spin_lock_irqsave(&chip->reg_lock, flags);
602 result = __maestro_read(chip, reg);
603 spin_unlock_irqrestore(&chip->reg_lock, flags);
608 static int snd_es1968_ac97_wait(struct es1968 *chip)
613 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
617 dev_dbg(chip->card->dev, "ac97 timeout\n");
621 static int snd_es1968_ac97_wait_poll(struct es1968 *chip)
626 if (!(inb(chip->io_port + ESM_AC97_INDEX) & 1))
629 dev_dbg(chip->card->dev, "ac97 timeout\n");
635 struct es1968 *chip = ac97->private_data;
637 snd_es1968_ac97_wait(chip);
640 outw(val, chip->io_port + ESM_AC97_DATA);
642 outb(reg, chip->io_port + ESM_AC97_INDEX);
649 struct es1968 *chip = ac97->private_data;
651 snd_es1968_ac97_wait(chip);
653 outb(reg | 0x80, chip->io_port + ESM_AC97_INDEX);
656 if (!snd_es1968_ac97_wait_poll(chip)) {
657 data = inw(chip->io_port + ESM_AC97_DATA);
665 static void apu_index_set(struct es1968 *chip, u16 index)
668 __maestro_write(chip, IDR1_CRAM_POINTER, index);
670 if (__maestro_read(chip, IDR1_CRAM_POINTER) == index)
672 dev_dbg(chip->card->dev, "APU register select failed. (Timeout)\n");
676 static void apu_data_set(struct es1968 *chip, u16 data)
680 if (__maestro_read(chip, IDR0_DATA_PORT) == data)
682 __maestro_write(chip, IDR0_DATA_PORT, data);
684 dev_dbg(chip->card->dev, "APU register set probably failed (Timeout)!\n");
688 static void __apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
693 chip->apu_map[channel][reg] = data;
696 apu_index_set(chip, reg);
697 apu_data_set(chip, data);
700 static void apu_set_register(struct es1968 *chip, u16 channel, u8 reg, u16 data)
703 spin_lock_irqsave(&chip->reg_lock, flags);
704 __apu_set_register(chip, channel, reg, data);
705 spin_unlock_irqrestore(&chip->reg_lock, flags);
708 static u16 __apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
713 apu_index_set(chip, reg);
714 return __maestro_read(chip, IDR0_DATA_PORT);
717 static u16 apu_get_register(struct es1968 *chip, u16 channel, u8 reg)
721 spin_lock_irqsave(&chip->reg_lock, flags);
722 v = __apu_get_register(chip, channel, reg);
723 spin_unlock_irqrestore(&chip->reg_lock, flags);
729 static void assp_set_register(struct es1968 *chip, u32 reg, u32 value)
733 spin_lock_irqsave(&chip->reg_lock, flags);
734 outl(reg, chip->io_port + ASSP_INDEX);
735 outl(value, chip->io_port + ASSP_DATA);
736 spin_unlock_irqrestore(&chip->reg_lock, flags);
739 static u32 assp_get_register(struct es1968 *chip, u32 reg)
744 spin_lock_irqsave(&chip->reg_lock, flags);
745 outl(reg, chip->io_port + ASSP_INDEX);
746 value = inl(chip->io_port + ASSP_DATA);
747 spin_unlock_irqrestore(&chip->reg_lock, flags);
754 static void wave_set_register(struct es1968 *chip, u16 reg, u16 value)
758 spin_lock_irqsave(&chip->reg_lock, flags);
759 outw(reg, chip->io_port + WC_INDEX);
760 outw(value, chip->io_port + WC_DATA);
761 spin_unlock_irqrestore(&chip->reg_lock, flags);
764 static u16 wave_get_register(struct es1968 *chip, u16 reg)
769 spin_lock_irqsave(&chip->reg_lock, flags);
770 outw(reg, chip->io_port + WC_INDEX);
771 value = inw(chip->io_port + WC_DATA);
772 spin_unlock_irqrestore(&chip->reg_lock, flags);
781 static void snd_es1968_bob_stop(struct es1968 *chip)
785 reg = __maestro_read(chip, 0x11);
787 __maestro_write(chip, 0x11, reg);
788 reg = __maestro_read(chip, 0x17);
790 __maestro_write(chip, 0x17, reg);
793 static void snd_es1968_bob_start(struct es1968 *chip)
801 if (chip->bob_freq > (ESS_SYSCLK >> (prescale + 9)))
814 if (chip->bob_freq >
825 __maestro_write(chip, 6, 0x9000 | (prescale << 5) | divide); /* set reg */
828 __maestro_write(chip, 0x11, __maestro_read(chip, 0x11) | 1);
829 __maestro_write(chip, 0x17, __maestro_read(chip, 0x17) | 1);
833 static void snd_es1968_bob_inc(struct es1968 *chip, int freq)
835 chip->bobclient++;
836 if (chip->bobclient == 1) {
837 chip->bob_freq = freq;
838 snd_es1968_bob_start(chip);
839 } else if (chip->bob_freq < freq) {
840 snd_es1968_bob_stop(chip);
841 chip->bob_freq = freq;
842 snd_es1968_bob_start(chip);
847 static void snd_es1968_bob_dec(struct es1968 *chip)
849 chip->bobclient--;
850 if (chip->bobclient <= 0)
851 snd_es1968_bob_stop(chip);
852 else if (chip->bob_freq > ESM_BOB_FREQ) {
856 list_for_each_entry(es, &chip->substream_list, list) {
860 if (max_freq != chip->bob_freq) {
861 snd_es1968_bob_stop(chip);
862 chip->bob_freq = max_freq;
863 snd_es1968_bob_start(chip);
869 snd_es1968_calc_bob_rate(struct es1968 *chip, struct esschan *es,
891 static u32 snd_es1968_compute_rate(struct es1968 *chip, u32 freq)
893 u32 rate = (freq << 16) / chip->clock;
903 snd_es1968_get_dma_ptr(struct es1968 *chip, struct esschan *es)
907 offset = apu_get_register(chip, es->apu[0], 5);
914 static void snd_es1968_apu_set_freq(struct es1968 *chip, int apu, int freq)
916 apu_set_register(chip, apu, 2,
917 (apu_get_register(chip, apu, 2) & 0x00FF) |
919 apu_set_register(chip, apu, 3, freq >> 8);
931 static void snd_es1968_pcm_start(struct es1968 *chip, struct esschan *es)
933 spin_lock(&chip->reg_lock);
934 __apu_set_register(chip, es->apu[0], 5, es->base[0]);
935 snd_es1968_trigger_apu(chip, es->apu[0], es->apu_mode[0]);
937 __apu_set_register(chip, es->apu[2], 5, es->base[2]);
938 snd_es1968_trigger_apu(chip, es->apu[2], es->apu_mode[2]);
941 __apu_set_register(chip, es->apu[1], 5, es->base[1]);
942 snd_es1968_trigger_apu(chip, es->apu[1], es->apu_mode[1]);
944 __apu_set_register(chip, es->apu[3], 5, es->base[3]);
945 snd_es1968_trigger_apu(chip, es->apu[3], es->apu_mode[3]);
948 spin_unlock(&chip->reg_lock);
951 static void snd_es1968_pcm_stop(struct es1968 *chip, struct esschan *es)
953 spin_lock(&chip->reg_lock);
954 snd_es1968_trigger_apu(chip, es->apu[0], 0);
955 snd_es1968_trigger_apu(chip, es->apu[1], 0);
957 snd_es1968_trigger_apu(chip, es->apu[2], 0);
958 snd_es1968_trigger_apu(chip, es->apu[3], 0);
960 spin_unlock(&chip->reg_lock);
964 static void snd_es1968_program_wavecache(struct es1968 *chip, struct esschan *es,
977 wave_set_register(chip, es->apu[channel] << 3, tmpval);
985 static void snd_es1968_playback_setup(struct es1968 *chip, struct esschan *es,
1003 snd_es1968_program_wavecache(chip, es, channel, es->memory->buf.addr, 0);
1007 pa -= chip->dma.addr;
1025 apu_set_register(chip, apu, i, 0x0000);
1028 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1029 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1030 apu_set_register(chip, apu, 6, (pa + size) & 0xFFFF);
1032 apu_set_register(chip, apu, 7, size);
1035 apu_set_register(chip, apu, 8, 0x0000);
1037 apu_set_register(chip, apu, 9, 0xD000);
1040 apu_set_register(chip, apu, 11, 0x0000);
1042 apu_set_register(chip, apu, 0, 0x400F);
1055 apu_set_register(chip, apu, 10,
1059 apu_set_register(chip, apu, 10, 0x8F08);
1062 spin_lock_irqsave(&chip->reg_lock, flags);
1064 outw(1, chip->io_port + 0x04);
1066 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1067 spin_unlock_irqrestore(&chip->reg_lock, flags);
1080 freq = snd_es1968_compute_rate(chip, freq);
1083 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1084 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1088 static void init_capture_apu(struct es1968 *chip, struct esschan *es, int channel,
1097 snd_es1968_program_wavecache(chip, es, channel, pa, 1);
1100 pa -= chip->dma.addr;
1110 apu_set_register(chip, apu, i, 0x0000);
1114 apu_set_register(chip, apu, 2, 0x8);
1117 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xFF) << 8);
1118 apu_set_register(chip, apu, 5, pa & 0xFFFF);
1119 apu_set_register(chip, apu, 6, (pa + bsize) & 0xFFFF);
1120 apu_set_register(chip, apu, 7, bsize);
1122 apu_set_register(chip, apu, 8, 0x00F0);
1124 apu_set_register(chip, apu, 9, 0x0000);
1126 apu_set_register(chip, apu, 10, 0x8F08);
1128 apu_set_register(chip, apu, 11, route);
1130 apu_set_register(chip, apu, 0, 0x400F);
1133 static void snd_es1968_capture_setup(struct es1968 *chip, struct esschan *es,
1154 init_capture_apu(chip, es, 2,
1158 init_capture_apu(chip, es, 0, es->memory->buf.addr, size,
1162 init_capture_apu(chip, es, 3,
1167 init_capture_apu(chip, es, 1,
1179 freq = snd_es1968_compute_rate(chip, freq);
1182 snd_es1968_apu_set_freq(chip, es->apu[0], freq);
1183 snd_es1968_apu_set_freq(chip, es->apu[1], freq);
1187 snd_es1968_apu_set_freq(chip, es->apu[2], freq);
1188 snd_es1968_apu_set_freq(chip, es->apu[3], freq);
1190 spin_lock_irqsave(&chip->reg_lock, flags);
1192 outw(1, chip->io_port + 0x04);
1194 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ);
1195 spin_unlock_irqrestore(&chip->reg_lock, flags);
1204 struct es1968 *chip = snd_pcm_substream_chip(substream);
1220 es->bob_freq = snd_es1968_calc_bob_rate(chip, es, runtime);
1224 snd_es1968_playback_setup(chip, es, runtime);
1227 snd_es1968_capture_setup(chip, es, runtime);
1236 struct es1968 *chip = snd_pcm_substream_chip(substream);
1239 spin_lock(&chip->substream_lock);
1245 snd_es1968_bob_inc(chip, es->bob_freq);
1248 snd_es1968_pcm_start(chip, es);
1255 snd_es1968_pcm_stop(chip, es);
1257 snd_es1968_bob_dec(chip);
1260 spin_unlock(&chip->substream_lock);
1266 struct es1968 *chip = snd_pcm_substream_chip(substream);
1270 ptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1324 static int calc_available_memory_size(struct es1968 *chip)
1329 mutex_lock(&chip->memory_mutex);
1330 list_for_each_entry(buf, &chip->buf_list, list) {
1334 mutex_unlock(&chip->memory_mutex);
1341 static struct esm_memory *snd_es1968_new_memory(struct es1968 *chip, int size)
1346 mutex_lock(&chip->memory_mutex);
1347 list_for_each_entry(buf, &chip->buf_list, list) {
1351 mutex_unlock(&chip->memory_mutex);
1358 mutex_unlock(&chip->memory_mutex);
1370 mutex_unlock(&chip->memory_mutex);
1375 static void snd_es1968_free_memory(struct es1968 *chip, struct esm_memory *buf)
1379 mutex_lock(&chip->memory_mutex);
1381 if (buf->list.prev != &chip->buf_list) {
1390 if (buf->list.next != &chip->buf_list) {
1398 mutex_unlock(&chip->memory_mutex);
1401 static void snd_es1968_free_dmabuf(struct es1968 *chip)
1405 if (! chip->dma.area)
1407 snd_dma_free_pages(&chip->dma);
1408 while ((p = chip->buf_list.next) != &chip->buf_list) {
1416 snd_es1968_init_dmabuf(struct es1968 *chip)
1422 &chip->pci->dev,
1423 chip->total_bufsize, &chip->dma);
1424 if (err < 0 || ! chip->dma.area) {
1425 dev_err(chip->card->dev,
1427 chip->total_bufsize);
1430 if ((chip->dma.addr + chip->dma.bytes - 1) & ~((1 << 28) - 1)) {
1431 snd_dma_free_pages(&chip->dma);
1432 dev_err(chip->card->dev, "DMA buffer beyond 256MB.\n");
1436 INIT_LIST_HEAD(&chip->buf_list);
1440 snd_es1968_free_dmabuf(chip);
1443 memset(chip->dma.area, 0, ESM_MEM_ALIGN);
1444 chunk->buf = chip->dma;
1449 list_add(&chunk->list, &chip->buf_list);
1459 struct es1968 *chip = snd_pcm_substream_chip(substream);
1469 snd_es1968_free_memory(chip, chan->memory);
1471 chan->memory = snd_es1968_new_memory(chip, size);
1473 dev_dbg(chip->card->dev,
1484 struct es1968 *chip = snd_pcm_substream_chip(substream);
1492 snd_es1968_free_memory(chip, chan->memory);
1502 static int snd_es1968_alloc_apu_pair(struct es1968 *chip, int type)
1507 if (chip->apu[apu] == ESM_APU_FREE &&
1508 chip->apu[apu + 1] == ESM_APU_FREE) {
1509 chip->apu[apu] = chip->apu[apu + 1] = type;
1519 static void snd_es1968_free_apu_pair(struct es1968 *chip, int apu)
1521 chip->apu[apu] = chip->apu[apu + 1] = ESM_APU_FREE;
1531 struct es1968 *chip = snd_pcm_substream_chip(substream);
1537 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY);
1543 snd_es1968_free_apu_pair(chip, apu1);
1558 calc_available_memory_size(chip);
1560 spin_lock_irq(&chip->substream_lock);
1561 list_add(&es->list, &chip->substream_list);
1562 spin_unlock_irq(&chip->substream_lock);
1570 struct es1968 *chip = snd_pcm_substream_chip(substream);
1574 apu1 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_CAPTURE);
1577 apu2 = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_RATECONV);
1579 snd_es1968_free_apu_pair(chip, apu1);
1585 snd_es1968_free_apu_pair(chip, apu1);
1586 snd_es1968_free_apu_pair(chip, apu2);
1603 es->mixbuf = snd_es1968_new_memory(chip, ESM_MIXBUF_SIZE);
1605 snd_es1968_free_apu_pair(chip, apu1);
1606 snd_es1968_free_apu_pair(chip, apu2);
1615 calc_available_memory_size(chip) - 1024; /* keep MIXBUF size */
1618 spin_lock_irq(&chip->substream_lock);
1619 list_add(&es->list, &chip->substream_list);
1620 spin_unlock_irq(&chip->substream_lock);
1627 struct es1968 *chip = snd_pcm_substream_chip(substream);
1633 spin_lock_irq(&chip->substream_lock);
1635 spin_unlock_irq(&chip->substream_lock);
1636 snd_es1968_free_apu_pair(chip, es->apu[0]);
1644 struct es1968 *chip = snd_pcm_substream_chip(substream);
1650 spin_lock_irq(&chip->substream_lock);
1652 spin_unlock_irq(&chip->substream_lock);
1653 snd_es1968_free_memory(chip, es->mixbuf);
1654 snd_es1968_free_apu_pair(chip, es->apu[0]);
1655 snd_es1968_free_apu_pair(chip, es->apu[2]);
1687 static void es1968_measure_clock(struct es1968 *chip)
1695 if (chip->clock == 0)
1696 chip->clock = 48000; /* default clock value */
1699 apu = snd_es1968_alloc_apu_pair(chip, ESM_APU_PCM_PLAY);
1701 dev_err(chip->card->dev, "Hmm, cannot find empty APU pair!?\n");
1704 memory = snd_es1968_new_memory(chip, CLOCK_MEASURE_BUFSIZE);
1706 dev_warn(chip->card->dev,
1708 chip->clock);
1709 snd_es1968_free_apu_pair(chip, apu);
1715 wave_set_register(chip, apu << 3, (memory->buf.addr - 0x10) & 0xfff8);
1717 pa = (unsigned int)((memory->buf.addr - chip->dma.addr) >> 1);
1722 apu_set_register(chip, apu, i, 0x0000);
1724 apu_set_register(chip, apu, 0, 0x400f);
1725 apu_set_register(chip, apu, 4, ((pa >> 16) & 0xff) << 8);
1726 apu_set_register(chip, apu, 5, pa & 0xffff);
1727 apu_set_register(chip, apu, 6, (pa + CLOCK_MEASURE_BUFSIZE/2) & 0xffff);
1728 apu_set_register(chip, apu, 7, CLOCK_MEASURE_BUFSIZE/2);
1729 apu_set_register(chip, apu, 8, 0x0000);
1730 apu_set_register(chip, apu, 9, 0xD000);
1731 apu_set_register(chip, apu, 10, 0x8F08);
1732 apu_set_register(chip, apu, 11, 0x0000);
1733 spin_lock_irq(&chip->reg_lock);
1734 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
1735 outw(inw(chip->io_port + ESM_PORT_HOST_IRQ) | ESM_HIRQ_DSIE, chip->io_port + ESM_PORT_HOST_IRQ); /* enable WP ints */
1736 spin_unlock_irq(&chip->reg_lock);
1738 snd_es1968_apu_set_freq(chip, apu, ((unsigned int)48000 << 16) / chip->clock); /* 48000 Hz */
1740 chip->in_measurement = 1;
1741 chip->measure_apu = apu;
1742 spin_lock_irq(&chip->reg_lock);
1743 snd_es1968_bob_inc(chip, ESM_BOB_FREQ);
1744 __apu_set_register(chip, apu, 5, pa & 0xffff);
1745 snd_es1968_trigger_apu(chip, apu, ESM_APU_16BITLINEAR);
1747 spin_unlock_irq(&chip->reg_lock);
1749 spin_lock_irq(&chip->reg_lock);
1750 offset = __apu_get_register(chip, apu, 5);
1752 snd_es1968_trigger_apu(chip, apu, 0); /* stop */
1753 snd_es1968_bob_dec(chip);
1754 chip->in_measurement = 0;
1755 spin_unlock_irq(&chip->reg_lock);
1760 offset += chip->measure_count * (CLOCK_MEASURE_BUFSIZE/2);
1765 dev_err(chip->card->dev, "?? calculation error..\n");
1771 chip->clock = (chip->clock * offset) / 48000;
1773 dev_info(chip->card->dev, "clocking to %d\n", chip->clock);
1775 snd_es1968_free_memory(chip, memory);
1776 snd_es1968_free_apu_pair(chip, apu);
1791 snd_es1968_pcm(struct es1968 *chip, int device)
1797 err = snd_es1968_init_dmabuf(chip);
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 err = snd_pcm_new(chip->card, "ESS Maestro", device,
1808 chip->playback_streams,
1809 chip->capture_streams, &pcm);
1813 pcm->private_data = chip;
1823 chip->pcm = pcm;
1830 static void snd_es1968_suppress_jitter(struct es1968 *chip, struct esschan *es)
1836 cp1 = __apu_get_register(chip, 0, 5);
1837 cp2 = __apu_get_register(chip, 1, 5);
1841 __maestro_write(chip, IDR0_DATA_PORT, cp1);
1847 static void snd_es1968_update_pcm(struct es1968 *chip, struct esschan *es)
1856 hwptr = snd_es1968_get_dma_ptr(chip, es) << es->wav_shift;
1865 spin_unlock(&chip->substream_lock);
1867 spin_lock(&chip->substream_lock);
1878 struct es1968 *chip = container_of(work, struct es1968, hwvol_work);
1884 x = inb(chip->io_port + 0x1c) & 0xee;
1886 outb(0x88, chip->io_port + 0x1c);
1887 outb(0x88, chip->io_port + 0x1d);
1888 outb(0x88, chip->io_port + 0x1e);
1889 outb(0x88, chip->io_port + 0x1f);
1891 if (chip->in_suspend)
1895 if (! chip->master_switch || ! chip->master_volume)
1898 val = snd_ac97_read(chip->ac97, AC97_MASTER);
1919 if (snd_ac97_update(chip->ac97, AC97_MASTER, val))
1920 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1921 &chip->master_volume->id);
1923 if (!chip->input_dev)
1945 input_report_key(chip->input_dev, val, 1);
1946 input_sync(chip->input_dev);
1947 input_report_key(chip->input_dev, val, 0);
1948 input_sync(chip->input_dev);
1958 struct es1968 *chip = dev_id;
1961 event = inb(chip->io_port + 0x1A);
1965 outw(inw(chip->io_port + 4) & 1, chip->io_port + 4);
1968 schedule_work(&chip->hwvol_work);
1971 outb(0xFF, chip->io_port + 0x1A);
1973 if ((event & ESM_MPU401_IRQ) && chip->rmidi) {
1974 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1979 spin_lock(&chip->substream_lock);
1980 list_for_each_entry(es, &chip->substream_list, list) {
1982 snd_es1968_update_pcm(chip, es);
1984 snd_es1968_suppress_jitter(chip, es);
1987 spin_unlock(&chip->substream_lock);
1988 if (chip->in_measurement) {
1989 unsigned int curp = __apu_get_register(chip, chip->measure_apu, 5);
1990 if (curp < chip->measure_lastpos)
1991 chip->measure_count++;
1992 chip->measure_lastpos = curp;
2004 snd_es1968_mixer(struct es1968 *chip)
2014 err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus);
2020 ac97.private_data = chip;
2021 err = snd_ac97_mixer(pbus, &ac97, &chip->ac97);
2027 chip->master_switch = snd_ctl_find_id_mixer(chip->card,
2029 chip->master_volume = snd_ctl_find_id_mixer(chip->card,
2040 static void snd_es1968_ac97_reset(struct es1968 *chip)
2042 unsigned long ioaddr = chip->io_port;
2060 pci_read_config_word(chip->pci, 0x58, &w); /* something magical with gpio and bus arb. */
2061 pci_read_config_dword(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2091 dev_info(chip->card->dev, "trying software reset\n");
2133 /* Turn on the 978 docking chip.
2145 static void snd_es1968_reset(struct es1968 *chip)
2149 chip->io_port + ESM_PORT_HOST_IRQ);
2151 outw(0x0000, chip->io_port + ESM_PORT_HOST_IRQ);
2156 * initialize maestro chip
2158 static void snd_es1968_chip_init(struct es1968 *chip)
2160 struct pci_dev *pci = chip->pci;
2162 unsigned long iobase = chip->io_port;
2231 /* Set up 978 docking control chip. */
2240 snd_es1968_reset(chip);
2246 /* setup usual 0x34 stuff.. 0x36 may be chip specific */
2256 snd_es1968_ac97_reset(chip);
2292 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2293 (wave_get_register(chip, IDR7_WAVE_ROMRAM) & 0xFF00));
2294 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2295 wave_get_register(chip, IDR7_WAVE_ROMRAM) | 0x100);
2296 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2297 wave_get_register(chip, IDR7_WAVE_ROMRAM) & ~0x200);
2298 wave_set_register(chip, IDR7_WAVE_ROMRAM,
2299 wave_get_register(chip, IDR7_WAVE_ROMRAM) | ~0x400);
2302 maestro_write(chip, IDR2_CRAM_DATA, 0x0000);
2305 maestro_write(chip, 0x08, 0xB004);
2306 maestro_write(chip, 0x09, 0x001B);
2307 maestro_write(chip, 0x0A, 0x8000);
2308 maestro_write(chip, 0x0B, 0x3F37);
2309 maestro_write(chip, 0x0C, 0x0098);
2312 maestro_write(chip, 0x0C,
2313 (maestro_read(chip, 0x0C) & ~0xF000) | 0x8000);
2315 maestro_write(chip, 0x0C,
2316 (maestro_read(chip, 0x0C) & ~0x0F00) | 0x0500);
2318 maestro_write(chip, 0x0D, 0x7632);
2343 apu_set_register(chip, i, w, 0);
2349 static void snd_es1968_start_irq(struct es1968 *chip)
2353 if (chip->rmidi)
2355 outb(w, chip->io_port + 0x1A);
2356 outw(w, chip->io_port + ESM_PORT_HOST_IRQ);
2366 struct es1968 *chip = card->private_data;
2368 if (! chip->do_pm)
2371 chip->in_suspend = 1;
2372 cancel_work_sync(&chip->hwvol_work);
2374 snd_ac97_suspend(chip->ac97);
2375 snd_es1968_bob_stop(chip);
2382 struct es1968 *chip = card->private_data;
2385 if (! chip->do_pm)
2388 snd_es1968_chip_init(chip);
2391 if (chip->dma.addr) {
2393 wave_set_register(chip, 0x01FC, chip->dma.addr >> 12);
2396 snd_es1968_start_irq(chip);
2399 snd_ac97_resume(chip->ac97);
2401 list_for_each_entry(es, &chip->substream_list, list) {
2404 snd_es1968_playback_setup(chip, es, es->substream->runtime);
2407 snd_es1968_capture_setup(chip, es, es->substream->runtime);
2413 if (chip->bobclient)
2414 snd_es1968_bob_start(chip);
2417 chip->in_suspend = 0;
2429 static int snd_es1968_create_gameport(struct es1968 *chip, int dev)
2438 r = devm_request_region(&chip->pci->dev, JOYSTICK_ADDR, 8,
2443 chip->gameport = gp = gameport_allocate_port();
2445 dev_err(chip->card->dev,
2450 pci_read_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, &val);
2451 pci_write_config_word(chip->pci, ESM_LEGACY_AUDIO_CONTROL, val | 0x04);
2454 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
2455 gameport_set_dev_parent(gp, &chip->pci->dev);
2463 static void snd_es1968_free_gameport(struct es1968 *chip)
2465 if (chip->gameport) {
2466 gameport_unregister_port(chip->gameport);
2467 chip->gameport = NULL;
2471 static inline int snd_es1968_create_gameport(struct es1968 *chip, int dev) { return -ENOSYS; }
2472 static inline void snd_es1968_free_gameport(struct es1968 *chip) { }
2476 static int snd_es1968_input_register(struct es1968 *chip)
2481 input_dev = devm_input_allocate_device(&chip->pci->dev);
2485 snprintf(chip->phys, sizeof(chip->phys), "pci-%s/input0",
2486 pci_name(chip->pci));
2488 input_dev->name = chip->card->driver;
2489 input_dev->phys = chip->phys;
2491 input_dev->id.vendor = chip->pci->vendor;
2492 input_dev->id.product = chip->pci->device;
2493 input_dev->dev.parent = &chip->pci->dev;
2504 chip->input_dev = input_dev;
2527 #define get_tea575x_gpio(chip) \
2528 (&snd_es1968_tea575x_gpios[(chip)->tea575x_tuner])
2533 struct es1968 *chip = tea->private_data;
2534 struct snd_es1968_tea575x_gpio gpio = *get_tea575x_gpio(chip);
2541 outw(val, chip->io_port + GPIO_DATA);
2546 struct es1968 *chip = tea->private_data;
2547 struct snd_es1968_tea575x_gpio gpio = *get_tea575x_gpio(chip);
2548 u16 val = inw(chip->io_port + GPIO_DATA);
2561 struct es1968 *chip = tea->private_data;
2562 unsigned long io = chip->io_port + GPIO_DATA;
2564 struct snd_es1968_tea575x_gpio gpio = *get_tea575x_gpio(chip);
2588 struct es1968 *chip = card->private_data;
2590 cancel_work_sync(&chip->hwvol_work);
2592 if (chip->io_port) {
2593 outw(1, chip->io_port + 0x04); /* clear WP interrupts */
2594 outw(0, chip->io_port + ESM_PORT_HOST_IRQ); /* disable IRQ */
2598 snd_tea575x_exit(&chip->tea);
2599 v4l2_device_unregister(&chip->v4l2_dev);
2602 snd_es1968_free_gameport(chip);
2606 unsigned short type; /* chip type */
2634 struct es1968 *chip = card->private_data;
2649 chip->type = chip_type;
2650 spin_lock_init(&chip->reg_lock);
2651 spin_lock_init(&chip->substream_lock);
2652 INIT_LIST_HEAD(&chip->buf_list);
2653 INIT_LIST_HEAD(&chip->substream_list);
2654 mutex_init(&chip->memory_mutex);
2655 INIT_WORK(&chip->hwvol_work, es1968_update_hw_volume);
2656 chip->card = card;
2657 chip->pci = pci;
2658 chip->irq = -1;
2659 chip->total_bufsize = total_bufsize; /* in bytes */
2660 chip->playback_streams = play_streams;
2661 chip->capture_streams = capt_streams;
2666 chip->io_port = pci_resource_start(pci, 0);
2668 IRQF_SHARED, KBUILD_MODNAME, chip)) {
2672 chip->irq = pci->irq;
2673 card->sync_irq = chip->irq;
2678 chip->maestro_map[i] = 0;
2682 chip->apu[i] = ESM_APU_FREE;
2690 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2692 if (chip->type == pm_allowlist[i].type &&
2704 chip->do_pm = do_pm;
2706 snd_es1968_chip_init(chip);
2710 if (chip->pci->subsystem_vendor != 0x125d)
2712 err = v4l2_device_register(&pci->dev, &chip->v4l2_dev);
2715 chip->tea.v4l2_dev = &chip->v4l2_dev;
2716 chip->tea.private_data = chip;
2717 chip->tea.radio_nr = radio_nr;
2718 chip->tea.ops = &snd_es1968_tea_ops;
2719 sprintf(chip->tea.bus_info, "PCI:%s", pci_name(pci));
2721 chip->tea575x_tuner = i;
2722 if (!snd_tea575x_init(&chip->tea, THIS_MODULE)) {
2724 get_tea575x_gpio(chip)->name);
2725 strscpy(chip->tea.card, get_tea575x_gpio(chip)->name,
2726 sizeof(chip->tea.card));
2742 struct es1968 *chip;
2754 sizeof(*chip), &card);
2757 chip = card->private_data;
2773 switch (chip->type) {
2788 err = snd_es1968_pcm(chip, 0);
2792 err = snd_es1968_mixer(chip);
2799 pci_read_config_word(chip->pci, PCI_SUBSYSTEM_VENDOR_ID, &vend);
2801 if (chip->type == mpu_denylist[i].type &&
2810 chip->io_port + ESM_MPU401_PORT,
2813 -1, &chip->rmidi);
2818 snd_es1968_create_gameport(chip, dev);
2821 err = snd_es1968_input_register(chip);
2827 snd_es1968_start_irq(chip);
2829 chip->clock = clock[dev];
2830 if (! chip->clock)
2831 es1968_measure_clock(chip);
2834 card->shortname, chip->io_port, chip->irq);