Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *   ALSA driver for ATI IXP 150/200/250 AC97 modem controllers
0004  *
0005  *  Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
0006  */
0007 
0008 #include <linux/io.h>
0009 #include <linux/delay.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/init.h>
0012 #include <linux/pci.h>
0013 #include <linux/slab.h>
0014 #include <linux/module.h>
0015 #include <linux/mutex.h>
0016 #include <sound/core.h>
0017 #include <sound/pcm.h>
0018 #include <sound/pcm_params.h>
0019 #include <sound/info.h>
0020 #include <sound/ac97_codec.h>
0021 #include <sound/initval.h>
0022 
0023 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
0024 MODULE_DESCRIPTION("ATI IXP MC97 controller");
0025 MODULE_LICENSE("GPL");
0026 
0027 static int index = -2; /* Exclude the first card */
0028 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
0029 static int ac97_clock = 48000;
0030 
0031 module_param(index, int, 0444);
0032 MODULE_PARM_DESC(index, "Index value for ATI IXP controller.");
0033 module_param(id, charp, 0444);
0034 MODULE_PARM_DESC(id, "ID string for ATI IXP controller.");
0035 module_param(ac97_clock, int, 0444);
0036 MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
0037 
0038 /* just for backward compatibility */
0039 static bool enable;
0040 module_param(enable, bool, 0444);
0041 
0042 
0043 /*
0044  */
0045 
0046 #define ATI_REG_ISR         0x00    /* interrupt source */
0047 #define  ATI_REG_ISR_MODEM_IN_XRUN  (1U<<0)
0048 #define  ATI_REG_ISR_MODEM_IN_STATUS    (1U<<1)
0049 #define  ATI_REG_ISR_MODEM_OUT1_XRUN    (1U<<2)
0050 #define  ATI_REG_ISR_MODEM_OUT1_STATUS  (1U<<3)
0051 #define  ATI_REG_ISR_MODEM_OUT2_XRUN    (1U<<4)
0052 #define  ATI_REG_ISR_MODEM_OUT2_STATUS  (1U<<5)
0053 #define  ATI_REG_ISR_MODEM_OUT3_XRUN    (1U<<6)
0054 #define  ATI_REG_ISR_MODEM_OUT3_STATUS  (1U<<7)
0055 #define  ATI_REG_ISR_PHYS_INTR      (1U<<8)
0056 #define  ATI_REG_ISR_PHYS_MISMATCH  (1U<<9)
0057 #define  ATI_REG_ISR_CODEC0_NOT_READY   (1U<<10)
0058 #define  ATI_REG_ISR_CODEC1_NOT_READY   (1U<<11)
0059 #define  ATI_REG_ISR_CODEC2_NOT_READY   (1U<<12)
0060 #define  ATI_REG_ISR_NEW_FRAME      (1U<<13)
0061 #define  ATI_REG_ISR_MODEM_GPIO_DATA    (1U<<14)
0062 
0063 #define ATI_REG_IER         0x04    /* interrupt enable */
0064 #define  ATI_REG_IER_MODEM_IN_XRUN_EN   (1U<<0)
0065 #define  ATI_REG_IER_MODEM_STATUS_EN    (1U<<1)
0066 #define  ATI_REG_IER_MODEM_OUT1_XRUN_EN (1U<<2)
0067 #define  ATI_REG_IER_MODEM_OUT2_XRUN_EN (1U<<4)
0068 #define  ATI_REG_IER_MODEM_OUT3_XRUN_EN (1U<<6)
0069 #define  ATI_REG_IER_PHYS_INTR_EN   (1U<<8)
0070 #define  ATI_REG_IER_PHYS_MISMATCH_EN   (1U<<9)
0071 #define  ATI_REG_IER_CODEC0_INTR_EN (1U<<10)
0072 #define  ATI_REG_IER_CODEC1_INTR_EN (1U<<11)
0073 #define  ATI_REG_IER_CODEC2_INTR_EN (1U<<12)
0074 #define  ATI_REG_IER_NEW_FRAME_EN   (1U<<13)    /* (RO */
0075 #define  ATI_REG_IER_MODEM_GPIO_DATA_EN (1U<<14)    /* (WO) modem is running */
0076 #define  ATI_REG_IER_MODEM_SET_BUS_BUSY (1U<<15)
0077 
0078 #define ATI_REG_CMD         0x08    /* command */
0079 #define  ATI_REG_CMD_POWERDOWN  (1U<<0)
0080 #define  ATI_REG_CMD_MODEM_RECEIVE_EN   (1U<<1) /* modem only */
0081 #define  ATI_REG_CMD_MODEM_SEND1_EN (1U<<2) /* modem only */
0082 #define  ATI_REG_CMD_MODEM_SEND2_EN (1U<<3) /* modem only */
0083 #define  ATI_REG_CMD_MODEM_SEND3_EN (1U<<4) /* modem only */
0084 #define  ATI_REG_CMD_MODEM_STATUS_MEM   (1U<<5) /* modem only */
0085 #define  ATI_REG_CMD_MODEM_IN_DMA_EN    (1U<<8) /* modem only */
0086 #define  ATI_REG_CMD_MODEM_OUT_DMA1_EN  (1U<<9) /* modem only */
0087 #define  ATI_REG_CMD_MODEM_OUT_DMA2_EN  (1U<<10)    /* modem only */
0088 #define  ATI_REG_CMD_MODEM_OUT_DMA3_EN  (1U<<11)    /* modem only */
0089 #define  ATI_REG_CMD_AUDIO_PRESENT  (1U<<20)
0090 #define  ATI_REG_CMD_MODEM_GPIO_THRU_DMA    (1U<<22)    /* modem only */
0091 #define  ATI_REG_CMD_LOOPBACK_EN    (1U<<23)
0092 #define  ATI_REG_CMD_PACKED_DIS     (1U<<24)
0093 #define  ATI_REG_CMD_BURST_EN       (1U<<25)
0094 #define  ATI_REG_CMD_PANIC_EN       (1U<<26)
0095 #define  ATI_REG_CMD_MODEM_PRESENT  (1U<<27)
0096 #define  ATI_REG_CMD_ACLINK_ACTIVE  (1U<<28)
0097 #define  ATI_REG_CMD_AC_SOFT_RESET  (1U<<29)
0098 #define  ATI_REG_CMD_AC_SYNC        (1U<<30)
0099 #define  ATI_REG_CMD_AC_RESET       (1U<<31)
0100 
0101 #define ATI_REG_PHYS_OUT_ADDR       0x0c
0102 #define  ATI_REG_PHYS_OUT_CODEC_MASK    (3U<<0)
0103 #define  ATI_REG_PHYS_OUT_RW        (1U<<2)
0104 #define  ATI_REG_PHYS_OUT_ADDR_EN   (1U<<8)
0105 #define  ATI_REG_PHYS_OUT_ADDR_SHIFT    9
0106 #define  ATI_REG_PHYS_OUT_DATA_SHIFT    16
0107 
0108 #define ATI_REG_PHYS_IN_ADDR        0x10
0109 #define  ATI_REG_PHYS_IN_READ_FLAG  (1U<<8)
0110 #define  ATI_REG_PHYS_IN_ADDR_SHIFT 9
0111 #define  ATI_REG_PHYS_IN_DATA_SHIFT 16
0112 
0113 #define ATI_REG_SLOTREQ         0x14
0114 
0115 #define ATI_REG_COUNTER         0x18
0116 #define  ATI_REG_COUNTER_SLOT       (3U<<0) /* slot # */
0117 #define  ATI_REG_COUNTER_BITCLOCK   (31U<<8)
0118 
0119 #define ATI_REG_IN_FIFO_THRESHOLD   0x1c
0120 
0121 #define ATI_REG_MODEM_IN_DMA_LINKPTR    0x20
0122 #define ATI_REG_MODEM_IN_DMA_DT_START   0x24    /* RO */
0123 #define ATI_REG_MODEM_IN_DMA_DT_NEXT    0x28    /* RO */
0124 #define ATI_REG_MODEM_IN_DMA_DT_CUR 0x2c    /* RO */
0125 #define ATI_REG_MODEM_IN_DMA_DT_SIZE    0x30
0126 #define ATI_REG_MODEM_OUT_FIFO      0x34    /* output threshold */
0127 #define  ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK  (0xf<<16)
0128 #define  ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT 16
0129 #define ATI_REG_MODEM_OUT_DMA1_LINKPTR  0x38
0130 #define ATI_REG_MODEM_OUT_DMA2_LINKPTR  0x3c
0131 #define ATI_REG_MODEM_OUT_DMA3_LINKPTR  0x40
0132 #define ATI_REG_MODEM_OUT_DMA1_DT_START 0x44
0133 #define ATI_REG_MODEM_OUT_DMA1_DT_NEXT  0x48
0134 #define ATI_REG_MODEM_OUT_DMA1_DT_CUR   0x4c
0135 #define ATI_REG_MODEM_OUT_DMA2_DT_START 0x50
0136 #define ATI_REG_MODEM_OUT_DMA2_DT_NEXT  0x54
0137 #define ATI_REG_MODEM_OUT_DMA2_DT_CUR   0x58
0138 #define ATI_REG_MODEM_OUT_DMA3_DT_START 0x5c
0139 #define ATI_REG_MODEM_OUT_DMA3_DT_NEXT  0x60
0140 #define ATI_REG_MODEM_OUT_DMA3_DT_CUR   0x64
0141 #define ATI_REG_MODEM_OUT_DMA12_DT_SIZE 0x68
0142 #define ATI_REG_MODEM_OUT_DMA3_DT_SIZE  0x6c
0143 #define ATI_REG_MODEM_OUT_FIFO_USED     0x70
0144 #define ATI_REG_MODEM_OUT_GPIO      0x74
0145 #define  ATI_REG_MODEM_OUT_GPIO_EN     1
0146 #define  ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT 5
0147 #define ATI_REG_MODEM_IN_GPIO       0x78
0148 
0149 #define ATI_REG_MODEM_MIRROR        0x7c
0150 #define ATI_REG_AUDIO_MIRROR        0x80
0151 
0152 #define ATI_REG_MODEM_FIFO_FLUSH    0x88
0153 #define  ATI_REG_MODEM_FIFO_OUT1_FLUSH  (1U<<0)
0154 #define  ATI_REG_MODEM_FIFO_OUT2_FLUSH  (1U<<1)
0155 #define  ATI_REG_MODEM_FIFO_OUT3_FLUSH  (1U<<2)
0156 #define  ATI_REG_MODEM_FIFO_IN_FLUSH    (1U<<3)
0157 
0158 /* LINKPTR */
0159 #define  ATI_REG_LINKPTR_EN     (1U<<0)
0160 
0161 #define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */
0162 
0163 
0164 struct atiixp_modem;
0165 
0166 /*
0167  * DMA packate descriptor
0168  */
0169 
0170 struct atiixp_dma_desc {
0171     __le32 addr;    /* DMA buffer address */
0172     u16 status; /* status bits */
0173     u16 size;   /* size of the packet in dwords */
0174     __le32 next;    /* address of the next packet descriptor */
0175 };
0176 
0177 /*
0178  * stream enum
0179  */
0180 enum { ATI_DMA_PLAYBACK, ATI_DMA_CAPTURE, NUM_ATI_DMAS }; /* DMAs */
0181 enum { ATI_PCM_OUT, ATI_PCM_IN, NUM_ATI_PCMS }; /* AC97 pcm slots */
0182 enum { ATI_PCMDEV_ANALOG, NUM_ATI_PCMDEVS }; /* pcm devices */
0183 
0184 #define NUM_ATI_CODECS  3
0185 
0186 
0187 /*
0188  * constants and callbacks for each DMA type
0189  */
0190 struct atiixp_dma_ops {
0191     int type;           /* ATI_DMA_XXX */
0192     unsigned int llp_offset;    /* LINKPTR offset */
0193     unsigned int dt_cur;        /* DT_CUR offset */
0194     /* called from open callback */
0195     void (*enable_dma)(struct atiixp_modem *chip, int on);
0196     /* called from trigger (START/STOP) */
0197     void (*enable_transfer)(struct atiixp_modem *chip, int on);
0198     /* called from trigger (STOP only) */
0199     void (*flush_dma)(struct atiixp_modem *chip);
0200 };
0201 
0202 /*
0203  * DMA stream
0204  */
0205 struct atiixp_dma {
0206     const struct atiixp_dma_ops *ops;
0207     struct snd_dma_buffer desc_buf;
0208     struct snd_pcm_substream *substream;    /* assigned PCM substream */
0209     unsigned int buf_addr, buf_bytes;   /* DMA buffer address, bytes */
0210     unsigned int period_bytes, periods;
0211     int opened;
0212     int running;
0213     int pcm_open_flag;
0214     int ac97_pcm_type;  /* index # of ac97_pcm to access, -1 = not used */
0215 };
0216 
0217 /*
0218  * ATI IXP chip
0219  */
0220 struct atiixp_modem {
0221     struct snd_card *card;
0222     struct pci_dev *pci;
0223 
0224     struct resource *res;       /* memory i/o */
0225     unsigned long addr;
0226     void __iomem *remap_addr;
0227     int irq;
0228     
0229     struct snd_ac97_bus *ac97_bus;
0230     struct snd_ac97 *ac97[NUM_ATI_CODECS];
0231 
0232     spinlock_t reg_lock;
0233 
0234     struct atiixp_dma dmas[NUM_ATI_DMAS];
0235     struct ac97_pcm *pcms[NUM_ATI_PCMS];
0236     struct snd_pcm *pcmdevs[NUM_ATI_PCMDEVS];
0237 
0238     int max_channels;       /* max. channels for PCM out */
0239 
0240     unsigned int codec_not_ready_bits;  /* for codec detection */
0241 
0242     int spdif_over_aclink;      /* passed from the module option */
0243     struct mutex open_mutex;    /* playback open mutex */
0244 };
0245 
0246 
0247 /*
0248  */
0249 static const struct pci_device_id snd_atiixp_ids[] = {
0250     { PCI_VDEVICE(ATI, 0x434d), 0 }, /* SB200 */
0251     { PCI_VDEVICE(ATI, 0x4378), 0 }, /* SB400 */
0252     { 0, }
0253 };
0254 
0255 MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
0256 
0257 
0258 /*
0259  * lowlevel functions
0260  */
0261 
0262 /*
0263  * update the bits of the given register.
0264  * return 1 if the bits changed.
0265  */
0266 static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg,
0267                   unsigned int mask, unsigned int value)
0268 {
0269     void __iomem *addr = chip->remap_addr + reg;
0270     unsigned int data, old_data;
0271     old_data = data = readl(addr);
0272     data &= ~mask;
0273     data |= value;
0274     if (old_data == data)
0275         return 0;
0276     writel(data, addr);
0277     return 1;
0278 }
0279 
0280 /*
0281  * macros for easy use
0282  */
0283 #define atiixp_write(chip,reg,value) \
0284     writel(value, chip->remap_addr + ATI_REG_##reg)
0285 #define atiixp_read(chip,reg) \
0286     readl(chip->remap_addr + ATI_REG_##reg)
0287 #define atiixp_update(chip,reg,mask,val) \
0288     snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val)
0289 
0290 /*
0291  * handling DMA packets
0292  *
0293  * we allocate a linear buffer for the DMA, and split it to  each packet.
0294  * in a future version, a scatter-gather buffer should be implemented.
0295  */
0296 
0297 #define ATI_DESC_LIST_SIZE \
0298     PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc))
0299 
0300 /*
0301  * build packets ring for the given buffer size.
0302  *
0303  * IXP handles the buffer descriptors, which are connected as a linked
0304  * list.  although we can change the list dynamically, in this version,
0305  * a static RING of buffer descriptors is used.
0306  *
0307  * the ring is built in this function, and is set up to the hardware. 
0308  */
0309 static int atiixp_build_dma_packets(struct atiixp_modem *chip,
0310                     struct atiixp_dma *dma,
0311                     struct snd_pcm_substream *substream,
0312                     unsigned int periods,
0313                     unsigned int period_bytes)
0314 {
0315     unsigned int i;
0316     u32 addr, desc_addr;
0317     unsigned long flags;
0318 
0319     if (periods > ATI_MAX_DESCRIPTORS)
0320         return -ENOMEM;
0321 
0322     if (dma->desc_buf.area == NULL) {
0323         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
0324                     ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0)
0325             return -ENOMEM;
0326         dma->period_bytes = dma->periods = 0; /* clear */
0327     }
0328 
0329     if (dma->periods == periods && dma->period_bytes == period_bytes)
0330         return 0;
0331 
0332     /* reset DMA before changing the descriptor table */
0333     spin_lock_irqsave(&chip->reg_lock, flags);
0334     writel(0, chip->remap_addr + dma->ops->llp_offset);
0335     dma->ops->enable_dma(chip, 0);
0336     dma->ops->enable_dma(chip, 1);
0337     spin_unlock_irqrestore(&chip->reg_lock, flags);
0338 
0339     /* fill the entries */
0340     addr = (u32)substream->runtime->dma_addr;
0341     desc_addr = (u32)dma->desc_buf.addr;
0342     for (i = 0; i < periods; i++) {
0343         struct atiixp_dma_desc *desc;
0344         desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i];
0345         desc->addr = cpu_to_le32(addr);
0346         desc->status = 0;
0347         desc->size = period_bytes >> 2; /* in dwords */
0348         desc_addr += sizeof(struct atiixp_dma_desc);
0349         if (i == periods - 1)
0350             desc->next = cpu_to_le32((u32)dma->desc_buf.addr);
0351         else
0352             desc->next = cpu_to_le32(desc_addr);
0353         addr += period_bytes;
0354     }
0355 
0356     writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
0357            chip->remap_addr + dma->ops->llp_offset);
0358 
0359     dma->period_bytes = period_bytes;
0360     dma->periods = periods;
0361 
0362     return 0;
0363 }
0364 
0365 /*
0366  * remove the ring buffer and release it if assigned
0367  */
0368 static void atiixp_clear_dma_packets(struct atiixp_modem *chip,
0369                      struct atiixp_dma *dma,
0370                      struct snd_pcm_substream *substream)
0371 {
0372     if (dma->desc_buf.area) {
0373         writel(0, chip->remap_addr + dma->ops->llp_offset);
0374         snd_dma_free_pages(&dma->desc_buf);
0375         dma->desc_buf.area = NULL;
0376     }
0377 }
0378 
0379 /*
0380  * AC97 interface
0381  */
0382 static int snd_atiixp_acquire_codec(struct atiixp_modem *chip)
0383 {
0384     int timeout = 1000;
0385 
0386     while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
0387         if (! timeout--) {
0388             dev_warn(chip->card->dev, "codec acquire timeout\n");
0389             return -EBUSY;
0390         }
0391         udelay(1);
0392     }
0393     return 0;
0394 }
0395 
0396 static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip,
0397                         unsigned short codec,
0398                         unsigned short reg)
0399 {
0400     unsigned int data;
0401     int timeout;
0402 
0403     if (snd_atiixp_acquire_codec(chip) < 0)
0404         return 0xffff;
0405     data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
0406         ATI_REG_PHYS_OUT_ADDR_EN |
0407         ATI_REG_PHYS_OUT_RW |
0408         codec;
0409     atiixp_write(chip, PHYS_OUT_ADDR, data);
0410     if (snd_atiixp_acquire_codec(chip) < 0)
0411         return 0xffff;
0412     timeout = 1000;
0413     do {
0414         data = atiixp_read(chip, PHYS_IN_ADDR);
0415         if (data & ATI_REG_PHYS_IN_READ_FLAG)
0416             return data >> ATI_REG_PHYS_IN_DATA_SHIFT;
0417         udelay(1);
0418     } while (--timeout);
0419     /* time out may happen during reset */
0420     if (reg < 0x7c)
0421         dev_warn(chip->card->dev, "codec read timeout (reg %x)\n", reg);
0422     return 0xffff;
0423 }
0424 
0425 
0426 static void snd_atiixp_codec_write(struct atiixp_modem *chip,
0427                    unsigned short codec,
0428                    unsigned short reg, unsigned short val)
0429 {
0430     unsigned int data;
0431     
0432     if (snd_atiixp_acquire_codec(chip) < 0)
0433         return;
0434     data = ((unsigned int)val << ATI_REG_PHYS_OUT_DATA_SHIFT) |
0435         ((unsigned int)reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
0436         ATI_REG_PHYS_OUT_ADDR_EN | codec;
0437     atiixp_write(chip, PHYS_OUT_ADDR, data);
0438 }
0439 
0440 
0441 static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97,
0442                        unsigned short reg)
0443 {
0444     struct atiixp_modem *chip = ac97->private_data;
0445     return snd_atiixp_codec_read(chip, ac97->num, reg);
0446     
0447 }
0448 
0449 static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
0450                   unsigned short val)
0451 {
0452     struct atiixp_modem *chip = ac97->private_data;
0453     if (reg == AC97_GPIO_STATUS) {
0454         atiixp_write(chip, MODEM_OUT_GPIO,
0455             (val << ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT) | ATI_REG_MODEM_OUT_GPIO_EN);
0456         return;
0457     }
0458     snd_atiixp_codec_write(chip, ac97->num, reg, val);
0459 }
0460 
0461 /*
0462  * reset AC link
0463  */
0464 static int snd_atiixp_aclink_reset(struct atiixp_modem *chip)
0465 {
0466     int timeout;
0467 
0468     /* reset powerdoewn */
0469     if (atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN, 0))
0470         udelay(10);
0471 
0472     /* perform a software reset */
0473     atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, ATI_REG_CMD_AC_SOFT_RESET);
0474     atiixp_read(chip, CMD);
0475     udelay(10);
0476     atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, 0);
0477     
0478     timeout = 10;
0479     while (! (atiixp_read(chip, CMD) & ATI_REG_CMD_ACLINK_ACTIVE)) {
0480         /* do a hard reset */
0481         atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET,
0482                   ATI_REG_CMD_AC_SYNC);
0483         atiixp_read(chip, CMD);
0484         msleep(1);
0485         atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
0486         if (!--timeout) {
0487             dev_err(chip->card->dev, "codec reset timeout\n");
0488             break;
0489         }
0490     }
0491 
0492     /* deassert RESET and assert SYNC to make sure */
0493     atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET,
0494               ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET);
0495 
0496     return 0;
0497 }
0498 
0499 #ifdef CONFIG_PM_SLEEP
0500 static int snd_atiixp_aclink_down(struct atiixp_modem *chip)
0501 {
0502     // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */
0503     //  return -EBUSY;
0504     atiixp_update(chip, CMD,
0505              ATI_REG_CMD_POWERDOWN | ATI_REG_CMD_AC_RESET,
0506              ATI_REG_CMD_POWERDOWN);
0507     return 0;
0508 }
0509 #endif
0510 
0511 /*
0512  * auto-detection of codecs
0513  *
0514  * the IXP chip can generate interrupts for the non-existing codecs.
0515  * NEW_FRAME interrupt is used to make sure that the interrupt is generated
0516  * even if all three codecs are connected.
0517  */
0518 
0519 #define ALL_CODEC_NOT_READY \
0520         (ATI_REG_ISR_CODEC0_NOT_READY |\
0521          ATI_REG_ISR_CODEC1_NOT_READY |\
0522          ATI_REG_ISR_CODEC2_NOT_READY)
0523 #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME)
0524 
0525 static int snd_atiixp_codec_detect(struct atiixp_modem *chip)
0526 {
0527     int timeout;
0528 
0529     chip->codec_not_ready_bits = 0;
0530     atiixp_write(chip, IER, CODEC_CHECK_BITS);
0531     /* wait for the interrupts */
0532     timeout = 50;
0533     while (timeout-- > 0) {
0534         msleep(1);
0535         if (chip->codec_not_ready_bits)
0536             break;
0537     }
0538     atiixp_write(chip, IER, 0); /* disable irqs */
0539 
0540     if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) {
0541         dev_err(chip->card->dev, "no codec detected!\n");
0542         return -ENXIO;
0543     }
0544     return 0;
0545 }
0546 
0547 
0548 /*
0549  * enable DMA and irqs
0550  */
0551 static int snd_atiixp_chip_start(struct atiixp_modem *chip)
0552 {
0553     unsigned int reg;
0554 
0555     /* set up spdif, enable burst mode */
0556     reg = atiixp_read(chip, CMD);
0557     reg |= ATI_REG_CMD_BURST_EN;
0558     if(!(reg & ATI_REG_CMD_MODEM_PRESENT))
0559         reg |= ATI_REG_CMD_MODEM_PRESENT;
0560     atiixp_write(chip, CMD, reg);
0561 
0562     /* clear all interrupt source */
0563     atiixp_write(chip, ISR, 0xffffffff);
0564     /* enable irqs */
0565     atiixp_write(chip, IER,
0566              ATI_REG_IER_MODEM_STATUS_EN |
0567              ATI_REG_IER_MODEM_IN_XRUN_EN |
0568              ATI_REG_IER_MODEM_OUT1_XRUN_EN);
0569     return 0;
0570 }
0571 
0572 
0573 /*
0574  * disable DMA and IRQs
0575  */
0576 static int snd_atiixp_chip_stop(struct atiixp_modem *chip)
0577 {
0578     /* clear interrupt source */
0579     atiixp_write(chip, ISR, atiixp_read(chip, ISR));
0580     /* disable irqs */
0581     atiixp_write(chip, IER, 0);
0582     return 0;
0583 }
0584 
0585 
0586 /*
0587  * PCM section
0588  */
0589 
0590 /*
0591  * pointer callback simplly reads XXX_DMA_DT_CUR register as the current
0592  * position.  when SG-buffer is implemented, the offset must be calculated
0593  * correctly...
0594  */
0595 static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream)
0596 {
0597     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0598     struct snd_pcm_runtime *runtime = substream->runtime;
0599     struct atiixp_dma *dma = runtime->private_data;
0600     unsigned int curptr;
0601     int timeout = 1000;
0602 
0603     while (timeout--) {
0604         curptr = readl(chip->remap_addr + dma->ops->dt_cur);
0605         if (curptr < dma->buf_addr)
0606             continue;
0607         curptr -= dma->buf_addr;
0608         if (curptr >= dma->buf_bytes)
0609             continue;
0610         return bytes_to_frames(runtime, curptr);
0611     }
0612     dev_dbg(chip->card->dev, "invalid DMA pointer read 0x%x (buf=%x)\n",
0613            readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
0614     return 0;
0615 }
0616 
0617 /*
0618  * XRUN detected, and stop the PCM substream
0619  */
0620 static void snd_atiixp_xrun_dma(struct atiixp_modem *chip,
0621                 struct atiixp_dma *dma)
0622 {
0623     if (! dma->substream || ! dma->running)
0624         return;
0625     dev_dbg(chip->card->dev, "XRUN detected (DMA %d)\n", dma->ops->type);
0626     snd_pcm_stop_xrun(dma->substream);
0627 }
0628 
0629 /*
0630  * the period ack.  update the substream.
0631  */
0632 static void snd_atiixp_update_dma(struct atiixp_modem *chip,
0633                   struct atiixp_dma *dma)
0634 {
0635     if (! dma->substream || ! dma->running)
0636         return;
0637     snd_pcm_period_elapsed(dma->substream);
0638 }
0639 
0640 /* set BUS_BUSY interrupt bit if any DMA is running */
0641 /* call with spinlock held */
0642 static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip)
0643 {
0644     unsigned int bus_busy;
0645     if (atiixp_read(chip, CMD) & (ATI_REG_CMD_MODEM_SEND1_EN |
0646                       ATI_REG_CMD_MODEM_RECEIVE_EN))
0647         bus_busy = ATI_REG_IER_MODEM_SET_BUS_BUSY;
0648     else
0649         bus_busy = 0;
0650     atiixp_update(chip, IER, ATI_REG_IER_MODEM_SET_BUS_BUSY, bus_busy);
0651 }
0652 
0653 /* common trigger callback
0654  * calling the lowlevel callbacks in it
0655  */
0656 static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
0657 {
0658     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0659     struct atiixp_dma *dma = substream->runtime->private_data;
0660     int err = 0;
0661 
0662     if (snd_BUG_ON(!dma->ops->enable_transfer ||
0663                !dma->ops->flush_dma))
0664         return -EINVAL;
0665 
0666     spin_lock(&chip->reg_lock);
0667     switch(cmd) {
0668     case SNDRV_PCM_TRIGGER_START:
0669         dma->ops->enable_transfer(chip, 1);
0670         dma->running = 1;
0671         break;
0672     case SNDRV_PCM_TRIGGER_STOP:
0673         dma->ops->enable_transfer(chip, 0);
0674         dma->running = 0;
0675         break;
0676     default:
0677         err = -EINVAL;
0678         break;
0679     }
0680     if (! err) {
0681     snd_atiixp_check_bus_busy(chip);
0682     if (cmd == SNDRV_PCM_TRIGGER_STOP) {
0683         dma->ops->flush_dma(chip);
0684         snd_atiixp_check_bus_busy(chip);
0685     }
0686     }
0687     spin_unlock(&chip->reg_lock);
0688     return err;
0689 }
0690 
0691 
0692 /*
0693  * lowlevel callbacks for each DMA type
0694  *
0695  * every callback is supposed to be called in chip->reg_lock spinlock
0696  */
0697 
0698 /* flush FIFO of analog OUT DMA */
0699 static void atiixp_out_flush_dma(struct atiixp_modem *chip)
0700 {
0701     atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH);
0702 }
0703 
0704 /* enable/disable analog OUT DMA */
0705 static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on)
0706 {
0707     unsigned int data;
0708     data = atiixp_read(chip, CMD);
0709     if (on) {
0710         if (data & ATI_REG_CMD_MODEM_OUT_DMA1_EN)
0711             return;
0712         atiixp_out_flush_dma(chip);
0713         data |= ATI_REG_CMD_MODEM_OUT_DMA1_EN;
0714     } else
0715         data &= ~ATI_REG_CMD_MODEM_OUT_DMA1_EN;
0716     atiixp_write(chip, CMD, data);
0717 }
0718 
0719 /* start/stop transfer over OUT DMA */
0720 static void atiixp_out_enable_transfer(struct atiixp_modem *chip, int on)
0721 {
0722     atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_SEND1_EN,
0723               on ? ATI_REG_CMD_MODEM_SEND1_EN : 0);
0724 }
0725 
0726 /* enable/disable analog IN DMA */
0727 static void atiixp_in_enable_dma(struct atiixp_modem *chip, int on)
0728 {
0729     atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_IN_DMA_EN,
0730               on ? ATI_REG_CMD_MODEM_IN_DMA_EN : 0);
0731 }
0732 
0733 /* start/stop analog IN DMA */
0734 static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on)
0735 {
0736     if (on) {
0737         unsigned int data = atiixp_read(chip, CMD);
0738         if (! (data & ATI_REG_CMD_MODEM_RECEIVE_EN)) {
0739             data |= ATI_REG_CMD_MODEM_RECEIVE_EN;
0740             atiixp_write(chip, CMD, data);
0741         }
0742     } else
0743         atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_RECEIVE_EN, 0);
0744 }
0745 
0746 /* flush FIFO of analog IN DMA */
0747 static void atiixp_in_flush_dma(struct atiixp_modem *chip)
0748 {
0749     atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH);
0750 }
0751 
0752 /* set up slots and formats for analog OUT */
0753 static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream)
0754 {
0755     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0756     unsigned int data;
0757 
0758     spin_lock_irq(&chip->reg_lock);
0759     /* set output threshold */
0760     data = atiixp_read(chip, MODEM_OUT_FIFO);
0761     data &= ~ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK;
0762     data |= 0x04 << ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT;
0763     atiixp_write(chip, MODEM_OUT_FIFO, data);
0764     spin_unlock_irq(&chip->reg_lock);
0765     return 0;
0766 }
0767 
0768 /* set up slots and formats for analog IN */
0769 static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream)
0770 {
0771     return 0;
0772 }
0773 
0774 /*
0775  * hw_params - allocate the buffer and set up buffer descriptors
0776  */
0777 static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream,
0778                    struct snd_pcm_hw_params *hw_params)
0779 {
0780     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0781     struct atiixp_dma *dma = substream->runtime->private_data;
0782     int err;
0783     int i;
0784 
0785     dma->buf_addr = substream->runtime->dma_addr;
0786     dma->buf_bytes = params_buffer_bytes(hw_params);
0787 
0788     err = atiixp_build_dma_packets(chip, dma, substream,
0789                        params_periods(hw_params),
0790                        params_period_bytes(hw_params));
0791     if (err < 0)
0792         return err;
0793 
0794     /* set up modem rate */
0795     for (i = 0; i < NUM_ATI_CODECS; i++) {
0796         if (! chip->ac97[i])
0797             continue;
0798         snd_ac97_write(chip->ac97[i], AC97_LINE1_RATE, params_rate(hw_params));
0799         snd_ac97_write(chip->ac97[i], AC97_LINE1_LEVEL, 0);
0800     }
0801 
0802     return err;
0803 }
0804 
0805 static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream)
0806 {
0807     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0808     struct atiixp_dma *dma = substream->runtime->private_data;
0809 
0810     atiixp_clear_dma_packets(chip, dma, substream);
0811     return 0;
0812 }
0813 
0814 
0815 /*
0816  * pcm hardware definition, identical for all DMA types
0817  */
0818 static const struct snd_pcm_hardware snd_atiixp_pcm_hw =
0819 {
0820     .info =         (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
0821                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
0822                  SNDRV_PCM_INFO_MMAP_VALID),
0823     .formats =      SNDRV_PCM_FMTBIT_S16_LE,
0824     .rates =        (SNDRV_PCM_RATE_8000 |
0825                  SNDRV_PCM_RATE_16000 |
0826                  SNDRV_PCM_RATE_KNOT),
0827     .rate_min =     8000,
0828     .rate_max =     16000,
0829     .channels_min =     2,
0830     .channels_max =     2,
0831     .buffer_bytes_max = 256 * 1024,
0832     .period_bytes_min = 32,
0833     .period_bytes_max = 128 * 1024,
0834     .periods_min =      2,
0835     .periods_max =      ATI_MAX_DESCRIPTORS,
0836 };
0837 
0838 static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream,
0839                    struct atiixp_dma *dma, int pcm_type)
0840 {
0841     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0842     struct snd_pcm_runtime *runtime = substream->runtime;
0843     int err;
0844     static const unsigned int rates[] = { 8000,  9600, 12000, 16000 };
0845     static const struct snd_pcm_hw_constraint_list hw_constraints_rates = {
0846         .count = ARRAY_SIZE(rates),
0847         .list = rates,
0848         .mask = 0,
0849     };
0850 
0851     if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma))
0852         return -EINVAL;
0853 
0854     if (dma->opened)
0855         return -EBUSY;
0856     dma->substream = substream;
0857     runtime->hw = snd_atiixp_pcm_hw;
0858     dma->ac97_pcm_type = pcm_type;
0859     err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
0860                      &hw_constraints_rates);
0861     if (err < 0)
0862         return err;
0863     err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
0864     if (err < 0)
0865         return err;
0866     runtime->private_data = dma;
0867 
0868     /* enable DMA bits */
0869     spin_lock_irq(&chip->reg_lock);
0870     dma->ops->enable_dma(chip, 1);
0871     spin_unlock_irq(&chip->reg_lock);
0872     dma->opened = 1;
0873 
0874     return 0;
0875 }
0876 
0877 static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream,
0878                 struct atiixp_dma *dma)
0879 {
0880     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0881     /* disable DMA bits */
0882     if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma))
0883         return -EINVAL;
0884     spin_lock_irq(&chip->reg_lock);
0885     dma->ops->enable_dma(chip, 0);
0886     spin_unlock_irq(&chip->reg_lock);
0887     dma->substream = NULL;
0888     dma->opened = 0;
0889     return 0;
0890 }
0891 
0892 /*
0893  */
0894 static int snd_atiixp_playback_open(struct snd_pcm_substream *substream)
0895 {
0896     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0897     int err;
0898 
0899     mutex_lock(&chip->open_mutex);
0900     err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0);
0901     mutex_unlock(&chip->open_mutex);
0902     if (err < 0)
0903         return err;
0904     return 0;
0905 }
0906 
0907 static int snd_atiixp_playback_close(struct snd_pcm_substream *substream)
0908 {
0909     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0910     int err;
0911     mutex_lock(&chip->open_mutex);
0912     err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
0913     mutex_unlock(&chip->open_mutex);
0914     return err;
0915 }
0916 
0917 static int snd_atiixp_capture_open(struct snd_pcm_substream *substream)
0918 {
0919     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0920     return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1);
0921 }
0922 
0923 static int snd_atiixp_capture_close(struct snd_pcm_substream *substream)
0924 {
0925     struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
0926     return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]);
0927 }
0928 
0929 
0930 /* AC97 playback */
0931 static const struct snd_pcm_ops snd_atiixp_playback_ops = {
0932     .open =     snd_atiixp_playback_open,
0933     .close =    snd_atiixp_playback_close,
0934     .hw_params =    snd_atiixp_pcm_hw_params,
0935     .hw_free =  snd_atiixp_pcm_hw_free,
0936     .prepare =  snd_atiixp_playback_prepare,
0937     .trigger =  snd_atiixp_pcm_trigger,
0938     .pointer =  snd_atiixp_pcm_pointer,
0939 };
0940 
0941 /* AC97 capture */
0942 static const struct snd_pcm_ops snd_atiixp_capture_ops = {
0943     .open =     snd_atiixp_capture_open,
0944     .close =    snd_atiixp_capture_close,
0945     .hw_params =    snd_atiixp_pcm_hw_params,
0946     .hw_free =  snd_atiixp_pcm_hw_free,
0947     .prepare =  snd_atiixp_capture_prepare,
0948     .trigger =  snd_atiixp_pcm_trigger,
0949     .pointer =  snd_atiixp_pcm_pointer,
0950 };
0951 
0952 static const struct atiixp_dma_ops snd_atiixp_playback_dma_ops = {
0953     .type = ATI_DMA_PLAYBACK,
0954     .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR,
0955     .dt_cur = ATI_REG_MODEM_OUT_DMA1_DT_CUR,
0956     .enable_dma = atiixp_out_enable_dma,
0957     .enable_transfer = atiixp_out_enable_transfer,
0958     .flush_dma = atiixp_out_flush_dma,
0959 };
0960     
0961 static const struct atiixp_dma_ops snd_atiixp_capture_dma_ops = {
0962     .type = ATI_DMA_CAPTURE,
0963     .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR,
0964     .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR,
0965     .enable_dma = atiixp_in_enable_dma,
0966     .enable_transfer = atiixp_in_enable_transfer,
0967     .flush_dma = atiixp_in_flush_dma,
0968 };
0969 
0970 static int snd_atiixp_pcm_new(struct atiixp_modem *chip)
0971 {
0972     struct snd_pcm *pcm;
0973     int err;
0974 
0975     /* initialize constants */
0976     chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops;
0977     chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops;
0978 
0979     /* PCM #0: analog I/O */
0980     err = snd_pcm_new(chip->card, "ATI IXP MC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm);
0981     if (err < 0)
0982         return err;
0983     snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops);
0984     snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops);
0985     pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
0986     pcm->private_data = chip;
0987     strcpy(pcm->name, "ATI IXP MC97");
0988     chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm;
0989 
0990     snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
0991                        &chip->pci->dev, 64*1024, 128*1024);
0992 
0993     return 0;
0994 }
0995 
0996 
0997 
0998 /*
0999  * interrupt handler
1000  */
1001 static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id)
1002 {
1003     struct atiixp_modem *chip = dev_id;
1004     unsigned int status;
1005 
1006     status = atiixp_read(chip, ISR);
1007 
1008     if (! status)
1009         return IRQ_NONE;
1010 
1011     /* process audio DMA */
1012     if (status & ATI_REG_ISR_MODEM_OUT1_XRUN)
1013         snd_atiixp_xrun_dma(chip,  &chip->dmas[ATI_DMA_PLAYBACK]);
1014     else if (status & ATI_REG_ISR_MODEM_OUT1_STATUS)
1015         snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]);
1016     if (status & ATI_REG_ISR_MODEM_IN_XRUN)
1017         snd_atiixp_xrun_dma(chip,  &chip->dmas[ATI_DMA_CAPTURE]);
1018     else if (status & ATI_REG_ISR_MODEM_IN_STATUS)
1019         snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]);
1020 
1021     /* for codec detection */
1022     if (status & CODEC_CHECK_BITS) {
1023         unsigned int detected;
1024         detected = status & CODEC_CHECK_BITS;
1025         spin_lock(&chip->reg_lock);
1026         chip->codec_not_ready_bits |= detected;
1027         atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */
1028         spin_unlock(&chip->reg_lock);
1029     }
1030 
1031     /* ack */
1032     atiixp_write(chip, ISR, status);
1033 
1034     return IRQ_HANDLED;
1035 }
1036 
1037 
1038 /*
1039  * ac97 mixer section
1040  */
1041 
1042 static int snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
1043 {
1044     struct snd_ac97_bus *pbus;
1045     struct snd_ac97_template ac97;
1046     int i, err;
1047     int codec_count;
1048     static const struct snd_ac97_bus_ops ops = {
1049         .write = snd_atiixp_ac97_write,
1050         .read = snd_atiixp_ac97_read,
1051     };
1052     static const unsigned int codec_skip[NUM_ATI_CODECS] = {
1053         ATI_REG_ISR_CODEC0_NOT_READY,
1054         ATI_REG_ISR_CODEC1_NOT_READY,
1055         ATI_REG_ISR_CODEC2_NOT_READY,
1056     };
1057 
1058     if (snd_atiixp_codec_detect(chip) < 0)
1059         return -ENXIO;
1060 
1061     err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus);
1062     if (err < 0)
1063         return err;
1064     pbus->clock = clock;
1065     chip->ac97_bus = pbus;
1066 
1067     codec_count = 0;
1068     for (i = 0; i < NUM_ATI_CODECS; i++) {
1069         if (chip->codec_not_ready_bits & codec_skip[i])
1070             continue;
1071         memset(&ac97, 0, sizeof(ac97));
1072         ac97.private_data = chip;
1073         ac97.pci = chip->pci;
1074         ac97.num = i;
1075         ac97.scaps = AC97_SCAP_SKIP_AUDIO | AC97_SCAP_POWER_SAVE;
1076         err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i]);
1077         if (err < 0) {
1078             chip->ac97[i] = NULL; /* to be sure */
1079             dev_dbg(chip->card->dev,
1080                 "codec %d not available for modem\n", i);
1081             continue;
1082         }
1083         codec_count++;
1084     }
1085 
1086     if (! codec_count) {
1087         dev_err(chip->card->dev, "no codec available\n");
1088         return -ENODEV;
1089     }
1090 
1091     /* snd_ac97_tune_hardware(chip->ac97, ac97_quirks); */
1092 
1093     return 0;
1094 }
1095 
1096 
1097 #ifdef CONFIG_PM_SLEEP
1098 /*
1099  * power management
1100  */
1101 static int snd_atiixp_suspend(struct device *dev)
1102 {
1103     struct snd_card *card = dev_get_drvdata(dev);
1104     struct atiixp_modem *chip = card->private_data;
1105     int i;
1106 
1107     snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1108     for (i = 0; i < NUM_ATI_CODECS; i++)
1109         snd_ac97_suspend(chip->ac97[i]);
1110     snd_atiixp_aclink_down(chip);
1111     snd_atiixp_chip_stop(chip);
1112     return 0;
1113 }
1114 
1115 static int snd_atiixp_resume(struct device *dev)
1116 {
1117     struct snd_card *card = dev_get_drvdata(dev);
1118     struct atiixp_modem *chip = card->private_data;
1119     int i;
1120 
1121     snd_atiixp_aclink_reset(chip);
1122     snd_atiixp_chip_start(chip);
1123 
1124     for (i = 0; i < NUM_ATI_CODECS; i++)
1125         snd_ac97_resume(chip->ac97[i]);
1126 
1127     snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1128     return 0;
1129 }
1130 
1131 static SIMPLE_DEV_PM_OPS(snd_atiixp_pm, snd_atiixp_suspend, snd_atiixp_resume);
1132 #define SND_ATIIXP_PM_OPS   &snd_atiixp_pm
1133 #else
1134 #define SND_ATIIXP_PM_OPS   NULL
1135 #endif /* CONFIG_PM_SLEEP */
1136 
1137 /*
1138  * proc interface for register dump
1139  */
1140 
1141 static void snd_atiixp_proc_read(struct snd_info_entry *entry,
1142                  struct snd_info_buffer *buffer)
1143 {
1144     struct atiixp_modem *chip = entry->private_data;
1145     int i;
1146 
1147     for (i = 0; i < 256; i += 4)
1148         snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i));
1149 }
1150 
1151 static void snd_atiixp_proc_init(struct atiixp_modem *chip)
1152 {
1153     snd_card_ro_proc_new(chip->card, "atiixp-modem", chip,
1154                  snd_atiixp_proc_read);
1155 }
1156 
1157 
1158 /*
1159  * destructor
1160  */
1161 
1162 static void snd_atiixp_free(struct snd_card *card)
1163 {
1164     snd_atiixp_chip_stop(card->private_data);
1165 }
1166 
1167 /*
1168  * constructor for chip instance
1169  */
1170 static int snd_atiixp_init(struct snd_card *card, struct pci_dev *pci)
1171 {
1172     struct atiixp_modem *chip = card->private_data;
1173     int err;
1174 
1175     err = pcim_enable_device(pci);
1176     if (err < 0)
1177         return err;
1178 
1179     spin_lock_init(&chip->reg_lock);
1180     mutex_init(&chip->open_mutex);
1181     chip->card = card;
1182     chip->pci = pci;
1183     chip->irq = -1;
1184     err = pcim_iomap_regions(pci, 1 << 0, "ATI IXP MC97");
1185     if (err < 0)
1186         return err;
1187     chip->addr = pci_resource_start(pci, 0);
1188     chip->remap_addr = pcim_iomap_table(pci)[0];
1189 
1190     if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt,
1191                  IRQF_SHARED, KBUILD_MODNAME, chip)) {
1192         dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
1193         return -EBUSY;
1194     }
1195     chip->irq = pci->irq;
1196     card->sync_irq = chip->irq;
1197     card->private_free = snd_atiixp_free;
1198     pci_set_master(pci);
1199 
1200     return 0;
1201 }
1202 
1203 
1204 static int __snd_atiixp_probe(struct pci_dev *pci,
1205                   const struct pci_device_id *pci_id)
1206 {
1207     struct snd_card *card;
1208     struct atiixp_modem *chip;
1209     int err;
1210 
1211     err = snd_devm_card_new(&pci->dev, index, id, THIS_MODULE,
1212                 sizeof(*chip), &card);
1213     if (err < 0)
1214         return err;
1215     chip = card->private_data;
1216 
1217     strcpy(card->driver, "ATIIXP-MODEM");
1218     strcpy(card->shortname, "ATI IXP Modem");
1219     err = snd_atiixp_init(card, pci);
1220     if (err < 0)
1221         return err;
1222 
1223     err = snd_atiixp_aclink_reset(chip);
1224     if (err < 0)
1225         return err;
1226 
1227     err = snd_atiixp_mixer_new(chip, ac97_clock);
1228     if (err < 0)
1229         return err;
1230 
1231     err = snd_atiixp_pcm_new(chip);
1232     if (err < 0)
1233         return err;
1234     
1235     snd_atiixp_proc_init(chip);
1236 
1237     snd_atiixp_chip_start(chip);
1238 
1239     sprintf(card->longname, "%s rev %x at 0x%lx, irq %i",
1240         card->shortname, pci->revision, chip->addr, chip->irq);
1241 
1242     err = snd_card_register(card);
1243     if (err < 0)
1244         return err;
1245 
1246     pci_set_drvdata(pci, card);
1247     return 0;
1248 }
1249 
1250 static int snd_atiixp_probe(struct pci_dev *pci,
1251                 const struct pci_device_id *pci_id)
1252 {
1253     return snd_card_free_on_error(&pci->dev, __snd_atiixp_probe(pci, pci_id));
1254 }
1255 
1256 static struct pci_driver atiixp_modem_driver = {
1257     .name = KBUILD_MODNAME,
1258     .id_table = snd_atiixp_ids,
1259     .probe = snd_atiixp_probe,
1260     .driver = {
1261         .pm = SND_ATIIXP_PM_OPS,
1262     },
1263 };
1264 
1265 module_pci_driver(atiixp_modem_driver);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!