/* * ALSA driver for ATI IXP 150/200/250 AC97 modem controllers * * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #include <sound/driver.h> #include <asm/io.h> #include <linux/delay.h> #include <linux/interrupt.h> #include <linux/init.h> #include <linux/pci.h> #include <linux/slab.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include <sound/info.h> #include <sound/ac97_codec.h> #include <sound/initval.h> MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); MODULE_DESCRIPTION("ATI IXP MC97 controller"); MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("{{ATI,IXP150/200/250}}"); static int index[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -2}; /* Exclude the first card */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ static int ac97_clock[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 48000}; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for ATI IXP controller."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for ATI IXP controller."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable audio part of ATI IXP controller."); module_param_array(ac97_clock, int, NULL, 0444); MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz)."); /* */ #define ATI_REG_ISR 0x00 /* interrupt source */ #define ATI_REG_ISR_MODEM_IN_XRUN (1U<<0) #define ATI_REG_ISR_MODEM_IN_STATUS (1U<<1) #define ATI_REG_ISR_MODEM_OUT1_XRUN (1U<<2) #define ATI_REG_ISR_MODEM_OUT1_STATUS (1U<<3) #define ATI_REG_ISR_MODEM_OUT2_XRUN (1U<<4) #define ATI_REG_ISR_MODEM_OUT2_STATUS (1U<<5) #define ATI_REG_ISR_MODEM_OUT3_XRUN (1U<<6) #define ATI_REG_ISR_MODEM_OUT3_STATUS (1U<<7) #define ATI_REG_ISR_PHYS_INTR (1U<<8) #define ATI_REG_ISR_PHYS_MISMATCH (1U<<9) #define ATI_REG_ISR_CODEC0_NOT_READY (1U<<10) #define ATI_REG_ISR_CODEC1_NOT_READY (1U<<11) #define ATI_REG_ISR_CODEC2_NOT_READY (1U<<12) #define ATI_REG_ISR_NEW_FRAME (1U<<13) #define ATI_REG_ISR_MODEM_GPIO_DATA (1U<<14) #define ATI_REG_IER 0x04 /* interrupt enable */ #define ATI_REG_IER_MODEM_IN_XRUN_EN (1U<<0) #define ATI_REG_IER_MODEM_STATUS_EN (1U<<1) #define ATI_REG_IER_MODEM_OUT1_XRUN_EN (1U<<2) #define ATI_REG_IER_MODEM_OUT2_XRUN_EN (1U<<4) #define ATI_REG_IER_MODEM_OUT3_XRUN_EN (1U<<6) #define ATI_REG_IER_PHYS_INTR_EN (1U<<8) #define ATI_REG_IER_PHYS_MISMATCH_EN (1U<<9) #define ATI_REG_IER_CODEC0_INTR_EN (1U<<10) #define ATI_REG_IER_CODEC1_INTR_EN (1U<<11) #define ATI_REG_IER_CODEC2_INTR_EN (1U<<12) #define ATI_REG_IER_NEW_FRAME_EN (1U<<13) /* (RO */ #define ATI_REG_IER_MODEM_GPIO_DATA_EN (1U<<14) /* (WO) modem is running */ #define ATI_REG_IER_MODEM_SET_BUS_BUSY (1U<<15) #define ATI_REG_CMD 0x08 /* command */ #define ATI_REG_CMD_POWERDOWN (1U<<0) #define ATI_REG_CMD_MODEM_RECEIVE_EN (1U<<1) /* modem only */ #define ATI_REG_CMD_MODEM_SEND1_EN (1U<<2) /* modem only */ #define ATI_REG_CMD_MODEM_SEND2_EN (1U<<3) /* modem only */ #define ATI_REG_CMD_MODEM_SEND3_EN (1U<<4) /* modem only */ #define ATI_REG_CMD_MODEM_STATUS_MEM (1U<<5) /* modem only */ #define ATI_REG_CMD_MODEM_IN_DMA_EN (1U<<8) /* modem only */ #define ATI_REG_CMD_MODEM_OUT_DMA1_EN (1U<<9) /* modem only */ #define ATI_REG_CMD_MODEM_OUT_DMA2_EN (1U<<10) /* modem only */ #define ATI_REG_CMD_MODEM_OUT_DMA3_EN (1U<<11) /* modem only */ #define ATI_REG_CMD_AUDIO_PRESENT (1U<<20) #define ATI_REG_CMD_MODEM_GPIO_THRU_DMA (1U<<22) /* modem only */ #define ATI_REG_CMD_LOOPBACK_EN (1U<<23) #define ATI_REG_CMD_PACKED_DIS (1U<<24) #define ATI_REG_CMD_BURST_EN (1U<<25) #define ATI_REG_CMD_PANIC_EN (1U<<26) #define ATI_REG_CMD_MODEM_PRESENT (1U<<27) #define ATI_REG_CMD_ACLINK_ACTIVE (1U<<28) #define ATI_REG_CMD_AC_SOFT_RESET (1U<<29) #define ATI_REG_CMD_AC_SYNC (1U<<30) #define ATI_REG_CMD_AC_RESET (1U<<31) #define ATI_REG_PHYS_OUT_ADDR 0x0c #define ATI_REG_PHYS_OUT_CODEC_MASK (3U<<0) #define ATI_REG_PHYS_OUT_RW (1U<<2) #define ATI_REG_PHYS_OUT_ADDR_EN (1U<<8) #define ATI_REG_PHYS_OUT_ADDR_SHIFT 9 #define ATI_REG_PHYS_OUT_DATA_SHIFT 16 #define ATI_REG_PHYS_IN_ADDR 0x10 #define ATI_REG_PHYS_IN_READ_FLAG (1U<<8) #define ATI_REG_PHYS_IN_ADDR_SHIFT 9 #define ATI_REG_PHYS_IN_DATA_SHIFT 16 #define ATI_REG_SLOTREQ 0x14 #define ATI_REG_COUNTER 0x18 #define ATI_REG_COUNTER_SLOT (3U<<0) /* slot # */ #define ATI_REG_COUNTER_BITCLOCK (31U<<8) #define ATI_REG_IN_FIFO_THRESHOLD 0x1c #define ATI_REG_MODEM_IN_DMA_LINKPTR 0x20 #define ATI_REG_MODEM_IN_DMA_DT_START 0x24 /* RO */ #define ATI_REG_MODEM_IN_DMA_DT_NEXT 0x28 /* RO */ #define ATI_REG_MODEM_IN_DMA_DT_CUR 0x2c /* RO */ #define ATI_REG_MODEM_IN_DMA_DT_SIZE 0x30 #define ATI_REG_MODEM_OUT_FIFO 0x34 /* output threshold */ #define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK (0xf<<16) #define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT 16 #define ATI_REG_MODEM_OUT_DMA1_LINKPTR 0x38 #define ATI_REG_MODEM_OUT_DMA2_LINKPTR 0x3c #define ATI_REG_MODEM_OUT_DMA3_LINKPTR 0x40 #define ATI_REG_MODEM_OUT_DMA1_DT_START 0x44 #define ATI_REG_MODEM_OUT_DMA1_DT_NEXT 0x48 #define ATI_REG_MODEM_OUT_DMA1_DT_CUR 0x4c #define ATI_REG_MODEM_OUT_DMA2_DT_START 0x50 #define ATI_REG_MODEM_OUT_DMA2_DT_NEXT 0x54 #define ATI_REG_MODEM_OUT_DMA2_DT_CUR 0x58 #define ATI_REG_MODEM_OUT_DMA3_DT_START 0x5c #define ATI_REG_MODEM_OUT_DMA3_DT_NEXT 0x60 #define ATI_REG_MODEM_OUT_DMA3_DT_CUR 0x64 #define ATI_REG_MODEM_OUT_DMA12_DT_SIZE 0x68 #define ATI_REG_MODEM_OUT_DMA3_DT_SIZE 0x6c #define ATI_REG_MODEM_OUT_FIFO_USED 0x70 #define ATI_REG_MODEM_OUT_GPIO 0x74 #define ATI_REG_MODEM_OUT_GPIO_EN 1 #define ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT 5 #define ATI_REG_MODEM_IN_GPIO 0x78 #define ATI_REG_MODEM_MIRROR 0x7c #define ATI_REG_AUDIO_MIRROR 0x80 #define ATI_REG_MODEM_FIFO_FLUSH 0x88 #define ATI_REG_MODEM_FIFO_OUT1_FLUSH (1U<<0) #define ATI_REG_MODEM_FIFO_OUT2_FLUSH (1U<<1) #define ATI_REG_MODEM_FIFO_OUT3_FLUSH (1U<<2) #define ATI_REG_MODEM_FIFO_IN_FLUSH (1U<<3) /* LINKPTR */ #define ATI_REG_LINKPTR_EN (1U<<0) #define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */ /* */ typedef struct snd_atiixp atiixp_t; typedef struct snd_atiixp_dma atiixp_dma_t; typedef struct snd_atiixp_dma_ops atiixp_dma_ops_t; /* * DMA packate descriptor */ typedef struct atiixp_dma_desc { u32 addr; /* DMA buffer address */ u16 status; /* status bits */ u16 size; /* size of the packet in dwords */ u32 next; /* address of the next packet descriptor */ } atiixp_dma_desc_t; /* * stream enum */ enum { ATI_DMA_PLAYBACK, ATI_DMA_CAPTURE, NUM_ATI_DMAS }; /* DMAs */ enum { ATI_PCM_OUT, ATI_PCM_IN, NUM_ATI_PCMS }; /* AC97 pcm slots */ enum { ATI_PCMDEV_ANALOG, NUM_ATI_PCMDEVS }; /* pcm devices */ #define NUM_ATI_CODECS 3 /* * constants and callbacks for each DMA type */ struct snd_atiixp_dma_ops { int type; /* ATI_DMA_XXX */ unsigned int llp_offset; /* LINKPTR offset */ unsigned int dt_cur; /* DT_CUR offset */ void (*enable_dma)(atiixp_t *chip, int on); /* called from open callback */ void (*enable_transfer)(atiixp_t *chip, int on); /* called from trigger (START/STOP) */ void (*flush_dma)(atiixp_t *chip); /* called from trigger (STOP only) */ }; /* * DMA stream */ struct snd_atiixp_dma { const atiixp_dma_ops_t *ops; struct snd_dma_buffer desc_buf; snd_pcm_substream_t *substream; /* assigned PCM substream */ unsigned int buf_addr, buf_bytes; /* DMA buffer address, bytes */ unsigned int period_bytes, periods; int opened; int running; int pcm_open_flag; int ac97_pcm_type; /* index # of ac97_pcm to access, -1 = not used */ }; /* * ATI IXP chip */ struct snd_atiixp { snd_card_t *card; struct pci_dev *pci; struct resource *res; /* memory i/o */ unsigned long addr; void __iomem *remap_addr; int irq; ac97_bus_t *ac97_bus; ac97_t *ac97[NUM_ATI_CODECS]; spinlock_t reg_lock; atiixp_dma_t dmas[NUM_ATI_DMAS]; struct ac97_pcm *pcms[NUM_ATI_PCMS]; snd_pcm_t *pcmdevs[NUM_ATI_PCMDEVS]; int max_channels; /* max. channels for PCM out */ unsigned int codec_not_ready_bits; /* for codec detection */ int spdif_over_aclink; /* passed from the module option */ struct semaphore open_mutex; /* playback open mutex */ }; /* */ static struct pci_device_id snd_atiixp_ids[] = { { 0x1002, 0x434d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB200 */ { 0x1002, 0x4378, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB400 */ { 0, } }; MODULE_DEVICE_TABLE(pci, snd_atiixp_ids); /* * lowlevel functions */ /* * update the bits of the given register. * return 1 if the bits changed. */ static int snd_atiixp_update_bits(atiixp_t *chip, unsigned int reg, unsigned int mask, unsigned int value) { void __iomem *addr = chip->remap_addr + reg; unsigned int data, old_data; old_data = data = readl(addr); data &= ~mask; data |= value; if (old_data == data) return 0; writel(data, addr); return 1; } /* * macros for easy use */ #define atiixp_write(chip,reg,value) \ writel(value, chip->remap_addr + ATI_REG_##reg) #define atiixp_read(chip,reg) \ readl(chip->remap_addr + ATI_REG_##reg) #define atiixp_update(chip,reg,mask,val) \ snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val) /* delay for one tick */ #define do_delay() do { \ set_current_state(TASK_UNINTERRUPTIBLE); \ schedule_timeout(1); \ } while (0) /* * handling DMA packets * * we allocate a linear buffer for the DMA, and split it to each packet. * in a future version, a scatter-gather buffer should be implemented. */ #define ATI_DESC_LIST_SIZE \ PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(atiixp_dma_desc_t)) /* * build packets ring for the given buffer size. * * IXP handles the buffer descriptors, which are connected as a linked * list. although we can change the list dynamically, in this version, * a static RING of buffer descriptors is used. * * the ring is built in this function, and is set up to the hardware. */ static int atiixp_build_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, snd_pcm_substream_t *substream, unsigned int periods, unsigned int period_bytes) { unsigned int i; u32 addr, desc_addr; unsigned long flags; if (periods > ATI_MAX_DESCRIPTORS) return -ENOMEM; if (dma->desc_buf.area == NULL) { if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0) return -ENOMEM; dma->period_bytes = dma->periods = 0; /* clear */ } if (dma->periods == periods && dma->period_bytes == period_bytes) return 0; /* reset DMA before changing the descriptor table */ spin_lock_irqsave(&chip->reg_lock, flags); writel(0, chip->remap_addr + dma->ops->llp_offset); dma->ops->enable_dma(chip, 0); dma->ops->enable_dma(chip, 1); spin_unlock_irqrestore(&chip->reg_lock, flags); /* fill the entries */ addr = (u32)substream->runtime->dma_addr; desc_addr = (u32)dma->desc_buf.addr; for (i = 0; i < periods; i++) { atiixp_dma_desc_t *desc = &((atiixp_dma_desc_t *)dma->desc_buf.area)[i]; desc->addr = cpu_to_le32(addr); desc->status = 0; desc->size = period_bytes >> 2; /* in dwords */ desc_addr += sizeof(atiixp_dma_desc_t); if (i == periods - 1) desc->next = cpu_to_le32((u32)dma->desc_buf.addr); else desc->next = cpu_to_le32(desc_addr); addr += period_bytes; } writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN, chip->remap_addr + dma->ops->llp_offset); dma->period_bytes = period_bytes; dma->periods = periods; return 0; } /* * remove the ring buffer and release it if assigned */ static void atiixp_clear_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, snd_pcm_substream_t *substream) { if (dma->desc_buf.area) { writel(0, chip->remap_addr + dma->ops->llp_offset); snd_dma_free_pages(&dma->desc_buf); dma->desc_buf.area = NULL; } } /* * AC97 interface */ static int snd_atiixp_acquire_codec(atiixp_t *chip) { int timeout = 1000; while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) { if (! timeout--) { snd_printk(KERN_WARNING "atiixp: codec acquire timeout\n"); return -EBUSY; } udelay(1); } return 0; } static unsigned short snd_atiixp_codec_read(atiixp_t *chip, unsigned short codec, unsigned short reg) { unsigned int data; int timeout; if (snd_atiixp_acquire_codec(chip) < 0) return 0xffff; data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) | ATI_REG_PHYS_OUT_ADDR_EN | ATI_REG_PHYS_OUT_RW | codec; atiixp_write(chip, PHYS_OUT_ADDR, data); if (snd_atiixp_acquire_codec(chip) < 0) return 0xffff; timeout = 1000; do { data = atiixp_read(chip, PHYS_IN_ADDR); if (data & ATI_REG_PHYS_IN_READ_FLAG) return data >> ATI_REG_PHYS_IN_DATA_SHIFT; udelay(1); } while (--timeout); /* time out may happen during reset */ if (reg < 0x7c) snd_printk(KERN_WARNING "atiixp: codec read timeout (reg %x)\n", reg); return 0xffff; } static void snd_atiixp_codec_write(atiixp_t *chip, unsigned short codec, unsigned short reg, unsigned short val) { unsigned int data; if (snd_atiixp_acquire_codec(chip) < 0) return; data = ((unsigned int)val << ATI_REG_PHYS_OUT_DATA_SHIFT) | ((unsigned int)reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) | ATI_REG_PHYS_OUT_ADDR_EN | codec; atiixp_write(chip, PHYS_OUT_ADDR, data); } static unsigned short snd_atiixp_ac97_read(ac97_t *ac97, unsigned short reg) { atiixp_t *chip = ac97->private_data; return snd_atiixp_codec_read(chip, ac97->num, reg); } static void snd_atiixp_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val) { atiixp_t *chip = ac97->private_data; if (reg == AC97_GPIO_STATUS) { atiixp_write(chip, MODEM_OUT_GPIO, (val << ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT) | ATI_REG_MODEM_OUT_GPIO_EN); return; } snd_atiixp_codec_write(chip, ac97->num, reg, val); } /* * reset AC link */ static int snd_atiixp_aclink_reset(atiixp_t *chip) { int timeout; /* reset powerdoewn */ if (atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN, 0)) udelay(10); /* perform a software reset */ atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, ATI_REG_CMD_AC_SOFT_RESET); atiixp_read(chip, CMD); udelay(10); atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, 0); timeout = 10; while (! (atiixp_read(chip, CMD) & ATI_REG_CMD_ACLINK_ACTIVE)) { /* do a hard reset */ atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_SYNC); atiixp_read(chip, CMD); do_delay(); atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET); if (--timeout) { snd_printk(KERN_ERR "atiixp: codec reset timeout\n"); break; } } /* deassert RESET and assert SYNC to make sure */ atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET); return 0; } #ifdef CONFIG_PM static int snd_atiixp_aclink_down(atiixp_t *chip) { // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */ // return -EBUSY; atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN | ATI_REG_CMD_AC_RESET, ATI_REG_CMD_POWERDOWN); return 0; } #endif /* * auto-detection of codecs * * the IXP chip can generate interrupts for the non-existing codecs. * NEW_FRAME interrupt is used to make sure that the interrupt is generated * even if all three codecs are connected. */ #define ALL_CODEC_NOT_READY \ (ATI_REG_ISR_CODEC0_NOT_READY |\ ATI_REG_ISR_CODEC1_NOT_READY |\ ATI_REG_ISR_CODEC2_NOT_READY) #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME) static int snd_atiixp_codec_detect(atiixp_t *chip) { int timeout; chip->codec_not_ready_bits = 0; atiixp_write(chip, IER, CODEC_CHECK_BITS); /* wait for the interrupts */ timeout = HZ / 10; while (timeout-- > 0) { do_delay(); if (chip->codec_not_ready_bits) break; } atiixp_write(chip, IER, 0); /* disable irqs */ if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) { snd_printk(KERN_ERR "atiixp: no codec detected!\n"); return -ENXIO; } return 0; } /* * enable DMA and irqs */ static int snd_atiixp_chip_start(atiixp_t *chip) { unsigned int reg; /* set up spdif, enable burst mode */ reg = atiixp_read(chip, CMD); reg |= ATI_REG_CMD_BURST_EN; if(!(reg & ATI_REG_CMD_MODEM_PRESENT)) reg |= ATI_REG_CMD_MODEM_PRESENT; atiixp_write(chip, CMD, reg); /* clear all interrupt source */ atiixp_write(chip, ISR, 0xffffffff); /* enable irqs */ atiixp_write(chip, IER, ATI_REG_IER_MODEM_STATUS_EN | ATI_REG_IER_MODEM_IN_XRUN_EN | ATI_REG_IER_MODEM_OUT1_XRUN_EN); return 0; } /* * disable DMA and IRQs */ static int snd_atiixp_chip_stop(atiixp_t *chip) { /* clear interrupt source */ atiixp_write(chip, ISR, atiixp_read(chip, ISR)); /* disable irqs */ atiixp_write(chip, IER, 0); return 0; } /* * PCM section */ /* * pointer callback simplly reads XXX_DMA_DT_CUR register as the current * position. when SG-buffer is implemented, the offset must be calculated * correctly... */ static snd_pcm_uframes_t snd_atiixp_pcm_pointer(snd_pcm_substream_t *substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); snd_pcm_runtime_t *runtime = substream->runtime; atiixp_dma_t *dma = (atiixp_dma_t *)runtime->private_data; unsigned int curptr; int timeout = 1000; while (timeout--) { curptr = readl(chip->remap_addr + dma->ops->dt_cur); if (curptr < dma->buf_addr) continue; curptr -= dma->buf_addr; if (curptr >= dma->buf_bytes) continue; return bytes_to_frames(runtime, curptr); } snd_printd("atiixp-modem: invalid DMA pointer read 0x%x (buf=%x)\n", readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr); return 0; } /* * XRUN detected, and stop the PCM substream */ static void snd_atiixp_xrun_dma(atiixp_t *chip, atiixp_dma_t *dma) { if (! dma->substream || ! dma->running) return; snd_printdd("atiixp: XRUN detected (DMA %d)\n", dma->ops->type); snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN); } /* * the period ack. update the substream. */ static void snd_atiixp_update_dma(atiixp_t *chip, atiixp_dma_t *dma) { if (! dma->substream || ! dma->running) return; snd_pcm_period_elapsed(dma->substream); } /* set BUS_BUSY interrupt bit if any DMA is running */ /* call with spinlock held */ static void snd_atiixp_check_bus_busy(atiixp_t *chip) { unsigned int bus_busy; if (atiixp_read(chip, CMD) & (ATI_REG_CMD_MODEM_SEND1_EN | ATI_REG_CMD_MODEM_RECEIVE_EN)) bus_busy = ATI_REG_IER_MODEM_SET_BUS_BUSY; else bus_busy = 0; atiixp_update(chip, IER, ATI_REG_IER_MODEM_SET_BUS_BUSY, bus_busy); } /* common trigger callback * calling the lowlevel callbacks in it */ static int snd_atiixp_pcm_trigger(snd_pcm_substream_t *substream, int cmd) { atiixp_t *chip = snd_pcm_substream_chip(substream); atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; int err = 0; snd_assert(dma->ops->enable_transfer && dma->ops->flush_dma, return -EINVAL); spin_lock(&chip->reg_lock); switch(cmd) { case SNDRV_PCM_TRIGGER_START: dma->ops->enable_transfer(chip, 1); dma->running = 1; break; case SNDRV_PCM_TRIGGER_STOP: dma->ops->enable_transfer(chip, 0); dma->running = 0; break; default: err = -EINVAL; break; } if (! err) { snd_atiixp_check_bus_busy(chip); if (cmd == SNDRV_PCM_TRIGGER_STOP) { dma->ops->flush_dma(chip); snd_atiixp_check_bus_busy(chip); } } spin_unlock(&chip->reg_lock); return err; } /* * lowlevel callbacks for each DMA type * * every callback is supposed to be called in chip->reg_lock spinlock */ /* flush FIFO of analog OUT DMA */ static void atiixp_out_flush_dma(atiixp_t *chip) { atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH); } /* enable/disable analog OUT DMA */ static void atiixp_out_enable_dma(atiixp_t *chip, int on) { unsigned int data; data = atiixp_read(chip, CMD); if (on) { if (data & ATI_REG_CMD_MODEM_OUT_DMA1_EN) return; atiixp_out_flush_dma(chip); data |= ATI_REG_CMD_MODEM_OUT_DMA1_EN; } else data &= ~ATI_REG_CMD_MODEM_OUT_DMA1_EN; atiixp_write(chip, CMD, data); } /* start/stop transfer over OUT DMA */ static void atiixp_out_enable_transfer(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_SEND1_EN, on ? ATI_REG_CMD_MODEM_SEND1_EN : 0); } /* enable/disable analog IN DMA */ static void atiixp_in_enable_dma(atiixp_t *chip, int on) { atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_IN_DMA_EN, on ? ATI_REG_CMD_MODEM_IN_DMA_EN : 0); } /* start/stop analog IN DMA */ static void atiixp_in_enable_transfer(atiixp_t *chip, int on) { if (on) { unsigned int data = atiixp_read(chip, CMD); if (! (data & ATI_REG_CMD_MODEM_RECEIVE_EN)) { data |= ATI_REG_CMD_MODEM_RECEIVE_EN; atiixp_write(chip, CMD, data); } } else atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_RECEIVE_EN, 0); } /* flush FIFO of analog IN DMA */ static void atiixp_in_flush_dma(atiixp_t *chip) { atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH); } /* set up slots and formats for analog OUT */ static int snd_atiixp_playback_prepare(snd_pcm_substream_t *substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); unsigned int data; spin_lock_irq(&chip->reg_lock); /* set output threshold */ data = atiixp_read(chip, MODEM_OUT_FIFO); data &= ~ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK; data |= 0x04 << ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT; atiixp_write(chip, MODEM_OUT_FIFO, data); spin_unlock_irq(&chip->reg_lock); return 0; } /* set up slots and formats for analog IN */ static int snd_atiixp_capture_prepare(snd_pcm_substream_t *substream) { return 0; } /* * hw_params - allocate the buffer and set up buffer descriptors */ static int snd_atiixp_pcm_hw_params(snd_pcm_substream_t *substream, snd_pcm_hw_params_t *hw_params) { atiixp_t *chip = snd_pcm_substream_chip(substream); atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; int err; int i; err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); if (err < 0) return err; dma->buf_addr = substream->runtime->dma_addr; dma->buf_bytes = params_buffer_bytes(hw_params); err = atiixp_build_dma_packets(chip, dma, substream, params_periods(hw_params), params_period_bytes(hw_params)); if (err < 0) return err; /* set up modem rate */ for (i = 0; i < NUM_ATI_CODECS; i++) { if (! chip->ac97[i]) continue; snd_ac97_write(chip->ac97[i], AC97_LINE1_RATE, params_rate(hw_params)); snd_ac97_write(chip->ac97[i], AC97_LINE1_LEVEL, 0); } return err; } static int snd_atiixp_pcm_hw_free(snd_pcm_substream_t * substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data; atiixp_clear_dma_packets(chip, dma, substream); snd_pcm_lib_free_pages(substream); return 0; } /* * pcm hardware definition, identical for all DMA types */ static snd_pcm_hardware_t snd_atiixp_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_KNOT, .rate_min = 8000, .rate_max = 16000, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 256 * 1024, .period_bytes_min = 32, .period_bytes_max = 128 * 1024, .periods_min = 2, .periods_max = ATI_MAX_DESCRIPTORS, }; static int snd_atiixp_pcm_open(snd_pcm_substream_t *substream, atiixp_dma_t *dma, int pcm_type) { atiixp_t *chip = snd_pcm_substream_chip(substream); snd_pcm_runtime_t *runtime = substream->runtime; int err; static unsigned int rates[] = { 8000, 9600, 12000, 16000 }; static snd_pcm_hw_constraint_list_t hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, }; snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL); if (dma->opened) return -EBUSY; dma->substream = substream; runtime->hw = snd_atiixp_pcm_hw; dma->ac97_pcm_type = pcm_type; if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates)) < 0) return err; if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) return err; runtime->private_data = dma; /* enable DMA bits */ spin_lock_irq(&chip->reg_lock); dma->ops->enable_dma(chip, 1); spin_unlock_irq(&chip->reg_lock); dma->opened = 1; return 0; } static int snd_atiixp_pcm_close(snd_pcm_substream_t *substream, atiixp_dma_t *dma) { atiixp_t *chip = snd_pcm_substream_chip(substream); /* disable DMA bits */ snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL); spin_lock_irq(&chip->reg_lock); dma->ops->enable_dma(chip, 0); spin_unlock_irq(&chip->reg_lock); dma->substream = NULL; dma->opened = 0; return 0; } /* */ static int snd_atiixp_playback_open(snd_pcm_substream_t *substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0); up(&chip->open_mutex); if (err < 0) return err; return 0; } static int snd_atiixp_playback_close(snd_pcm_substream_t *substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); int err; down(&chip->open_mutex); err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]); up(&chip->open_mutex); return err; } static int snd_atiixp_capture_open(snd_pcm_substream_t *substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1); } static int snd_atiixp_capture_close(snd_pcm_substream_t *substream) { atiixp_t *chip = snd_pcm_substream_chip(substream); return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]); } /* AC97 playback */ static snd_pcm_ops_t snd_atiixp_playback_ops = { .open = snd_atiixp_playback_open, .close = snd_atiixp_playback_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = snd_atiixp_pcm_hw_params, .hw_free = snd_atiixp_pcm_hw_free, .prepare = snd_atiixp_playback_prepare, .trigger = snd_atiixp_pcm_trigger, .pointer = snd_atiixp_pcm_pointer, }; /* AC97 capture */ static snd_pcm_ops_t snd_atiixp_capture_ops = { .open = snd_atiixp_capture_open, .close = snd_atiixp_capture_close, .ioctl = snd_pcm_lib_ioctl, .hw_params = snd_atiixp_pcm_hw_params, .hw_free = snd_atiixp_pcm_hw_free, .prepare = snd_atiixp_capture_prepare, .trigger = snd_atiixp_pcm_trigger, .pointer = snd_atiixp_pcm_pointer, }; static atiixp_dma_ops_t snd_atiixp_playback_dma_ops = { .type = ATI_DMA_PLAYBACK, .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR, .dt_cur = ATI_REG_MODEM_OUT_DMA1_DT_CUR, .enable_dma = atiixp_out_enable_dma, .enable_transfer = atiixp_out_enable_transfer, .flush_dma = atiixp_out_flush_dma, }; static atiixp_dma_ops_t snd_atiixp_capture_dma_ops = { .type = ATI_DMA_CAPTURE, .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR, .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR, .enable_dma = atiixp_in_enable_dma, .enable_transfer = atiixp_in_enable_transfer, .flush_dma = atiixp_in_flush_dma, }; static int __devinit snd_atiixp_pcm_new(atiixp_t *chip) { snd_pcm_t *pcm; int err; /* initialize constants */ chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops; chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops; /* PCM #0: analog I/O */ err = snd_pcm_new(chip->card, "ATI IXP MC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops); pcm->private_data = chip; strcpy(pcm->name, "ATI IXP MC97"); chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm; snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci), 64*1024, 128*1024); return 0; } /* * interrupt handler */ static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id, struct pt_regs *regs) { atiixp_t *chip = dev_id; unsigned int status; status = atiixp_read(chip, ISR); if (! status) return IRQ_NONE; /* process audio DMA */ if (status & ATI_REG_ISR_MODEM_OUT1_XRUN) snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]); else if (status & ATI_REG_ISR_MODEM_OUT1_STATUS) snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]); if (status & ATI_REG_ISR_MODEM_IN_XRUN) snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]); else if (status & ATI_REG_ISR_MODEM_IN_STATUS) snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]); /* for codec detection */ if (status & CODEC_CHECK_BITS) { unsigned int detected; detected = status & CODEC_CHECK_BITS; spin_lock(&chip->reg_lock); chip->codec_not_ready_bits |= detected; atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */ spin_unlock(&chip->reg_lock); } /* ack */ atiixp_write(chip, ISR, status); return IRQ_HANDLED; } /* * ac97 mixer section */ static int __devinit snd_atiixp_mixer_new(atiixp_t *chip, int clock) { ac97_bus_t *pbus; ac97_template_t ac97; int i, err; int codec_count; static ac97_bus_ops_t ops = { .write = snd_atiixp_ac97_write, .read = snd_atiixp_ac97_read, }; static unsigned int codec_skip[NUM_ATI_CODECS] = { ATI_REG_ISR_CODEC0_NOT_READY, ATI_REG_ISR_CODEC1_NOT_READY, ATI_REG_ISR_CODEC2_NOT_READY, }; if (snd_atiixp_codec_detect(chip) < 0) return -ENXIO; if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus)) < 0) return err; pbus->clock = clock; pbus->shared_type = AC97_SHARED_TYPE_ATIIXP; /* shared with audio driver */ chip->ac97_bus = pbus; codec_count = 0; for (i = 0; i < NUM_ATI_CODECS; i++) { if (chip->codec_not_ready_bits & codec_skip[i]) continue; memset(&ac97, 0, sizeof(ac97)); ac97.private_data = chip; ac97.pci = chip->pci; ac97.num = i; ac97.scaps = AC97_SCAP_SKIP_AUDIO; if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) { chip->ac97[i] = NULL; /* to be sure */ snd_printdd("atiixp: codec %d not available for modem\n", i); continue; } codec_count++; } if (! codec_count) { snd_printk(KERN_ERR "atiixp: no codec available\n"); return -ENODEV; } /* snd_ac97_tune_hardware(chip->ac97, ac97_quirks); */ return 0; } #ifdef CONFIG_PM /* * power management */ static int snd_atiixp_suspend(snd_card_t *card, pm_message_t state) { atiixp_t *chip = card->pm_private_data; int i; for (i = 0; i < NUM_ATI_PCMDEVS; i++) if (chip->pcmdevs[i]) snd_pcm_suspend_all(chip->pcmdevs[i]); for (i = 0; i < NUM_ATI_CODECS; i++) if (chip->ac97[i]) snd_ac97_suspend(chip->ac97[i]); snd_atiixp_aclink_down(chip); snd_atiixp_chip_stop(chip); pci_set_power_state(chip->pci, PCI_D3hot); pci_disable_device(chip->pci); return 0; } static int snd_atiixp_resume(snd_card_t *card) { atiixp_t *chip = card->pm_private_data; int i; pci_enable_device(chip->pci); pci_set_power_state(chip->pci, PCI_D0); pci_set_master(chip->pci); snd_atiixp_aclink_reset(chip); snd_atiixp_chip_start(chip); for (i = 0; i < NUM_ATI_CODECS; i++) if (chip->ac97[i]) snd_ac97_resume(chip->ac97[i]); return 0; } #endif /* CONFIG_PM */ /* * proc interface for register dump */ static void snd_atiixp_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer) { atiixp_t *chip = entry->private_data; int i; for (i = 0; i < 256; i += 4) snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i)); } static void __devinit snd_atiixp_proc_init(atiixp_t *chip) { snd_info_entry_t *entry; if (! snd_card_proc_new(chip->card, "atiixp", &entry)) snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read); } /* * destructor */ static int snd_atiixp_free(atiixp_t *chip) { if (chip->irq < 0) goto __hw_end; snd_atiixp_chip_stop(chip); synchronize_irq(chip->irq); __hw_end: if (chip->irq >= 0) free_irq(chip->irq, (void *)chip); if (chip->remap_addr) iounmap(chip->remap_addr); pci_release_regions(chip->pci); pci_disable_device(chip->pci); kfree(chip); return 0; } static int snd_atiixp_dev_free(snd_device_t *device) { atiixp_t *chip = device->device_data; return snd_atiixp_free(chip); } /* * constructor for chip instance */ static int __devinit snd_atiixp_create(snd_card_t *card, struct pci_dev *pci, atiixp_t **r_chip) { static snd_device_ops_t ops = { .dev_free = snd_atiixp_dev_free, }; atiixp_t *chip; int err; if ((err = pci_enable_device(pci)) < 0) return err; chip = kcalloc(1, sizeof(*chip), GFP_KERNEL); if (chip == NULL) { pci_disable_device(pci); return -ENOMEM; } spin_lock_init(&chip->reg_lock); init_MUTEX(&chip->open_mutex); chip->card = card; chip->pci = pci; chip->irq = -1; if ((err = pci_request_regions(pci, "ATI IXP MC97")) < 0) { kfree(chip); pci_disable_device(pci); return err; } chip->addr = pci_resource_start(pci, 0); chip->remap_addr = ioremap_nocache(chip->addr, pci_resource_len(pci, 0)); if (chip->remap_addr == NULL) { snd_printk(KERN_ERR "AC'97 space ioremap problem\n"); snd_atiixp_free(chip); return -EIO; } if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip)) { snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); snd_atiixp_free(chip); return -EBUSY; } chip->irq = pci->irq; pci_set_master(pci); synchronize_irq(chip->irq); if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { snd_atiixp_free(chip); return err; } snd_card_set_dev(card, &pci->dev); *r_chip = chip; return 0; } static int __devinit snd_atiixp_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) { static int dev; snd_card_t *card; atiixp_t *chip; unsigned char revision; int err; if (dev >= SNDRV_CARDS) return -ENODEV; if (!enable[dev]) { dev++; return -ENOENT; } card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); if (card == NULL) return -ENOMEM; pci_read_config_byte(pci, PCI_REVISION_ID, &revision); strcpy(card->driver, "ATIIXP-MODEM"); strcpy(card->shortname, "ATI IXP Modem"); if ((err = snd_atiixp_create(card, pci, &chip)) < 0) goto __error; if ((err = snd_atiixp_aclink_reset(chip)) < 0) goto __error; if ((err = snd_atiixp_mixer_new(chip, ac97_clock[dev])) < 0) goto __error; if ((err = snd_atiixp_pcm_new(chip)) < 0) goto __error; snd_atiixp_proc_init(chip); snd_atiixp_chip_start(chip); sprintf(card->longname, "%s rev %x at 0x%lx, irq %i", card->shortname, revision, chip->addr, chip->irq); snd_card_set_pm_callback(card, snd_atiixp_suspend, snd_atiixp_resume, chip); if ((err = snd_card_register(card)) < 0) goto __error; pci_set_drvdata(pci, card); dev++; return 0; __error: snd_card_free(card); return err; } static void __devexit snd_atiixp_remove(struct pci_dev *pci) { snd_card_free(pci_get_drvdata(pci)); pci_set_drvdata(pci, NULL); } static struct pci_driver driver = { .name = "ATI IXP MC97 controller", .id_table = snd_atiixp_ids, .probe = snd_atiixp_probe, .remove = __devexit_p(snd_atiixp_remove), SND_PCI_PM_CALLBACKS }; static int __init alsa_card_atiixp_init(void) { return pci_register_driver(&driver); } static void __exit alsa_card_atiixp_exit(void) { pci_unregister_driver(&driver); } module_init(alsa_card_atiixp_init) module_exit(alsa_card_atiixp_exit)