cs4231.c

内核linux2.4.20,可跟rtlinux3.2打补丁 组成实时linux系统,编译内核

#endif

static void cs4231_start_output(struct sparcaudio_driver *drv, __u8 * buffer,
                                unsigned long count)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        u32 csr;

        tprintk(("in 4231 start output\n"));
        cs4231_chip->output_ptr = buffer;
        cs4231_chip->output_size = count;

        if (cs4231_chip->perchip_info.play.active || 
            (cs4231_chip->perchip_info.play.pause))
                return;

        cs4231_ready(drv);

        cs4231_chip->perchip_info.play.active = 1;
        cs4231_chip->playing_count = 0;

        csr = sbus_readl(cs4231_chip->regs + APCCSR);
        if ((csr & APC_PPAUSE) || !(csr & APC_PDMA_READY)) {
                u32 pnva;

                csr &= ~APC_XINT_PLAY;
                sbus_writel(csr, cs4231_chip->regs + APCCSR);
                csr &= ~APC_PPAUSE;
                sbus_writel(csr, cs4231_chip->regs + APCCSR);
    
                pnva = sbus_readl(cs4231_chip->regs + APCPNVA);
                cs4231_playintr(drv, (pnva == 0) ? 1 : 0);

                csr |= APC_PLAY_SETUP;
                sbus_writel(csr, cs4231_chip->regs + APCCSR);
                cs4231_enable_play(drv);

                cs4231_ready(drv);
        }
}

#ifdef EB4231_SUPPORT
static void eb4231_stop_output(struct sparcaudio_driver *drv)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        u32 dcsr;

        dprintk(("eb4231_stop_output: dcsr 0x%x dacr 0x%x dbcr %d\n",
                 readl(cs4231_chip->eb2p + EBDMA_CSR),
                 readl(cs4231_chip->eb2p + EBDMA_ADDR),
                 readl(cs4231_chip->eb2p + EBDMA_COUNT)));

        cs4231_chip->output_ptr = NULL;
        cs4231_chip->output_size = 0;

        if (cs4231_chip->output_dma_handle) {
		pci_unmap_single((struct pci_dev *)drv->dev,
				 cs4231_chip->output_dma_handle,
				 cs4231_chip->output_dma_size,
                                 PCI_DMA_TODEVICE);
                cs4231_chip->output_dma_handle = 0;
                cs4231_chip->output_dma_size = 0;
        }

        if (cs4231_chip->output_next_dma_handle) {
		pci_unmap_single((struct pci_dev *)drv->dev,
				 cs4231_chip->output_next_dma_handle,
				 cs4231_chip->output_next_dma_size,
                                 PCI_DMA_TODEVICE);
                cs4231_chip->output_next_dma_handle = 0;
                cs4231_chip->output_next_dma_size = 0;
        }
        dcsr = readl(cs4231_chip->eb2p + EBDMA_CSR);
        if(dcsr & EBUS_DCSR_EN_DMA)
                writel(dcsr & ~EBUS_DCSR_EN_DMA,
                       cs4231_chip->eb2p + EBDMA_CSR);

        /* Else subsequent speed setting changes are ignored by the chip. */
        cs4231_disable_play(drv);
}
#endif

static void cs4231_stop_output(struct sparcaudio_driver *drv)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;

        tprintk(("in cs4231_stop_output\n"));
        cs4231_chip->output_ptr = NULL;
        cs4231_chip->output_size = 0;

        if (cs4231_chip->output_dma_handle) {
                sbus_unmap_single(drv->dev,
                                  cs4231_chip->output_dma_handle,
                                  cs4231_chip->output_dma_size,
                                  SBUS_DMA_TODEVICE);
                cs4231_chip->output_dma_handle = 0;
                cs4231_chip->output_dma_size = 0;
        }

        if (cs4231_chip->output_next_dma_handle) {
                sbus_unmap_single(drv->dev,
                                  cs4231_chip->output_next_dma_handle,
                                  cs4231_chip->output_next_dma_size,
                                  SBUS_DMA_TODEVICE);
                cs4231_chip->output_next_dma_handle = 0;
                cs4231_chip->output_next_dma_size = 0;
        }
#if 0 /* Not safe without shutting off the DMA controller as well. -DaveM */
        /* Else subsequent speed setting changes are ignored by the chip. */
        cs4231_disable_play(drv);
#endif
}

#ifdef EB4231_SUPPORT
static void eb4231_pollinput(struct sparcaudio_driver *drv)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        int x;
        u32 dcsr;

        x = 0;
        do {
                dcsr = readl(cs4231_chip->eb2c + EBDMA_CSR);
                if (dcsr & EBUS_DCSR_TC)
                        break;
                x++;
        } while (x <= CS_TIMEOUT);

        writel(dcsr | EBUS_DCSR_TC,
               cs4231_chip->eb2c + EBDMA_CSR);
}
#endif

static void cs4231_pollinput(struct sparcaudio_driver *drv)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        int x;
        u32 csr;

        x = 0;
        do {
                csr = sbus_readl(cs4231_chip->regs + APCCSR);
                if (csr & APC_XINT_COVF)
                        break;
                x++;
        } while (x <= CS_TIMEOUT);

        sbus_writel(csr | APC_XINT_CEMP,
                    cs4231_chip->regs + APCCSR);
}

static void cs4231_start_input(struct sparcaudio_driver *drv, __u8 * buffer, 
                               unsigned long count)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        u32 csr;

        cs4231_chip->input_ptr = buffer;
        cs4231_chip->input_size = count;

        if (cs4231_chip->perchip_info.record.active || 
            (cs4231_chip->perchip_info.record.pause))
                return;

        cs4231_ready(drv);

        cs4231_chip->perchip_info.record.active = 1;
        cs4231_chip->recording_count = 0;

        csr = sbus_readl(cs4231_chip->regs + APCCSR);
        if ((csr & APC_CPAUSE) || !(csr & APC_CDMA_READY)) {
                csr &= ~APC_XINT_CAPT;
                sbus_writel(csr, cs4231_chip->regs + APCCSR);
                csr &= ~APC_CPAUSE;
                sbus_writel(csr, cs4231_chip->regs + APCCSR);

                cs4231_recintr(drv);

                csr |= APC_CAPT_SETUP;
                sbus_writel(csr, cs4231_chip->regs + APCCSR);

                cs4231_enable_rec(drv);
                cs4231_ready(drv);
        } else {
                cs4231_recintr(drv);
        }
}

static void cs4231_stop_input(struct sparcaudio_driver *drv)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        u32 csr;

        cs4231_chip->perchip_info.record.active = 0;

        csr = sbus_readl(cs4231_chip->regs + APCCSR);
        csr |= APC_CPAUSE;
        sbus_writel(csr, cs4231_chip->regs + APCCSR);

        cs4231_chip->input_ptr = NULL;
        cs4231_chip->input_size = 0;

        if (cs4231_chip->input_dma_handle) {
                sbus_unmap_single(drv->dev,
                                  cs4231_chip->input_dma_handle,
                                  cs4231_chip->input_dma_size,
                                  SBUS_DMA_FROMDEVICE);
                cs4231_chip->input_dma_handle = 0;
                cs4231_chip->input_dma_size = 0;
        }

        if (cs4231_chip->input_next_dma_handle) {
                sbus_unmap_single(drv->dev,
                                  cs4231_chip->input_next_dma_handle,
                                  cs4231_chip->input_next_dma_size,
                                  SBUS_DMA_FROMDEVICE);
                cs4231_chip->input_next_dma_handle = 0;
                cs4231_chip->input_next_dma_size = 0;
        }

        cs4231_pollinput(drv);
}

#ifdef EB4231_SUPPORT
static void eb4231_start_input(struct sparcaudio_driver *drv, __u8 * buffer, 
                               unsigned long count)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        u32 dcsr;

        cs4231_chip->input_ptr = buffer;
        cs4231_chip->input_size = count;

        if (cs4231_chip->perchip_info.record.active || 
            (cs4231_chip->perchip_info.record.pause))
                return;

        cs4231_ready(drv);
        cs4231_chip->perchip_info.record.active = 1;
        cs4231_chip->recording_count = 0;

        dcsr = readl(cs4231_chip->eb2c + EBDMA_CSR);
        if (!(dcsr & EBUS_DCSR_EN_DMA)) {
                writel(EBUS_DCSR_RESET, cs4231_chip->eb2c + EBDMA_CSR);
                writel(EBUS_DCSR_BURST_SZ_16, cs4231_chip->eb2c + EBDMA_CSR);

                eb4231_recintr(drv);

                writel(EBUS_DCSR_BURST_SZ_16 |
                       (EBUS_DCSR_EN_DMA | EBUS_DCSR_INT_EN |
                        EBUS_DCSR_EN_CNT | EBUS_DCSR_EN_NEXT),
                       cs4231_chip->eb2c + EBDMA_CSR);

                cs4231_enable_rec(drv);
                cs4231_ready(drv);
        } else {
                eb4231_recintr(drv);
        }
}

static void eb4231_stop_input(struct sparcaudio_driver *drv)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        u32 dcsr;

        cs4231_chip->perchip_info.record.active = 0;

        cs4231_chip->input_ptr = NULL;
        cs4231_chip->input_size = 0;

        if (cs4231_chip->input_dma_handle) {
		pci_unmap_single((struct pci_dev *)drv->dev,
				 cs4231_chip->input_dma_handle,
				 cs4231_chip->input_dma_size,
                                 PCI_DMA_FROMDEVICE);
                cs4231_chip->input_dma_handle = 0;
                cs4231_chip->input_dma_size = 0;
        }

        if (cs4231_chip->input_next_dma_handle) {
		pci_unmap_single((struct pci_dev *)drv->dev,
				 cs4231_chip->input_next_dma_handle,
				 cs4231_chip->input_next_dma_size,
                                 PCI_DMA_FROMDEVICE);
                cs4231_chip->input_next_dma_handle = 0;
                cs4231_chip->input_next_dma_size = 0;
        }

        dcsr = readl(cs4231_chip->eb2c + EBDMA_CSR);
        if (dcsr & EBUS_DCSR_EN_DMA)
                writel(dcsr & ~EBUS_DCSR_EN_DMA, cs4231_chip->eb2c + EBDMA_CSR);

        cs4231_disable_rec(drv);
}
#endif

static int cs4231_set_output_pause(struct sparcaudio_driver *drv, int value)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;

        cs4231_chip->perchip_info.play.pause = value;

        if (!value)
                sparcaudio_output_done(drv, 0);

        return value;
}

static int cs4231_set_output_error(struct sparcaudio_driver *drv, int value)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        int i;
  
        i = cs4231_chip->perchip_info.play.error;
        cs4231_chip->perchip_info.play.error = value;
  
        return i;
}

static int cs4231_set_input_error(struct sparcaudio_driver *drv, int value)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        int i;
  
        i = cs4231_chip->perchip_info.record.error;
        cs4231_chip->perchip_info.record.error = value;
  
        return i;
}

static int cs4231_set_output_samples(struct sparcaudio_driver *drv, int value)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *)drv->private;
        int i;
  
        i = cs4231_chip->perchip_info.play.samples;
        cs4231_chip->perchip_info.play.samples = value;
  
        return i;
}

static int cs4231_set_input_samples(struct sparcaudio_driver *drv, int value)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;
        int i;
  
        i = cs4231_chip->perchip_info.record.samples;
        cs4231_chip->perchip_info.record.samples = value;

        return i;
}

static int cs4231_set_input_pause(struct sparcaudio_driver *drv, int value)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;

        cs4231_chip->perchip_info.record.pause = value;
	
        if (value)
                cs4231_stop_input(drv);
	
        return value;
}

static void cs4231_audio_getdev(struct sparcaudio_driver *drv,
                                 audio_device_t * audinfo)
{
        struct cs4231_chip *cs4231_chip = (struct cs4231_chip *) drv->private;

        strncpy(audinfo->name, "SUNW,CS4231", sizeof(audinfo->name) - 1);
        /* versions */
        /* a: SPARCstation 4/5          b: Ultra 1/2 (electron)       */
        /* c: Ultra 1/2 PCI? (positron) d: ppc                        */
        /* e: x86                       f: Ultra Enterprise? (tazmo)  */
        /* g: Ultra 30? (quark)         h: Ultra 5/10? (darwin)       */
        /* apparently Ultra 1, Ultra 2 don't have internal CD input */
        if (cs4231_chip->status & CS_STATUS_IS_ULTRA)
                strncpy(audinfo->ver