Ignore:
Timestamp:
Mar 24, 2008, 2:43:42 AM (17 years ago)
Author:
Paul Smedley
Message:

Update source to ALSA 1.0.16 level

File:
1 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/uniaud-2.0/alsa-kernel/pci/atiixp.c

    r79 r305  
    2020 */
    2121
    22 #include <sound/driver.h>
    2322#include <asm/io.h>
    2423#include <linux/delay.h>
    … …  
    2827#include <linux/slab.h>
    2928#include <linux/moduleparam.h>
     29#include <linux/mutex.h>
    3030#include <sound/core.h>
    3131#include <sound/pcm.h>
    … …  
    4545static char *ac97_quirk;
    4646static int spdif_aclink = 1;
    47 
    48 //module_param(index, int, 0444);
     47static int ac97_codec = -1;
     48
     49module_param(index, int, 0444);
    4950MODULE_PARM_DESC(index, "Index value for ATI IXP controller.");
    50 //module_param(id, charp, 0444);
     51module_param(id, charp, 0444);
    5152MODULE_PARM_DESC(id, "ID string for ATI IXP controller.");
    52 //module_param(ac97_clock, int, 0444);
     53module_param(ac97_clock, int, 0444);
    5354MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
    54 //module_param(ac97_quirk, charp, 0444);
     55module_param(ac97_quirk, charp, 0444);
    5556MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware.");
    56 //module_param(spdif_aclink, bool, 0444);
     57module_param(ac97_codec, int, 0444);
     58MODULE_PARM_DESC(ac97_codec, "Specify codec instead of probing.");
     59module_param(spdif_aclink, bool, 0444);
    5760MODULE_PARM_DESC(spdif_aclink, "S/PDIF over AC-link.");
    5861
    5962/* just for backward compatibility */
    6063static int enable;
    61 //module_param(enable, bool, 0444);
     64module_param(enable, bool, 0444);
    6265
    6366
    … …  
    278281
    279282        int spdif_over_aclink;          /* passed from the module option */
    280         struct semaphore open_mutex;    /* playback open mutex */
     283        struct mutex open_mutex;        /* playback open mutex */
    281284};
    282285
    … …  
    293296MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
    294297
     298static struct snd_pci_quirk atiixp_quirks[] __devinitdata = {
     299        SND_PCI_QUIRK(0x15bd, 0x3100, "DFI RS482", 0),
     300        {0} /* terminator */
     301};
    295302
    296303/*
    … …  
    305312                                 unsigned int mask, unsigned int value)
    306313{
    307         void __iomem *addr = (char*)chip->remap_addr + reg;
     314        void __iomem *addr = chip->remap_addr + reg;
    308315        unsigned int data, old_data;
    309316        old_data = data = readl(addr);
    … …  
    320327 */
    321328#define atiixp_write(chip,reg,value) \
    322         writel(value, (char*)chip->remap_addr + ATI_REG_##reg)
     329        writel(value, chip->remap_addr + ATI_REG_##reg)
    323330#define atiixp_read(chip,reg) \
    324         readl((char*)chip->remap_addr + ATI_REG_##reg)
     331        readl(chip->remap_addr + ATI_REG_##reg)
    325332#define atiixp_update(chip,reg,mask,val) \
    326333        snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val)
    … …  
    366373        }
    367374
     375        if (dma->periods == periods && dma->period_bytes == period_bytes)
     376                return 0;
     377
    368378        /* reset DMA before changing the descriptor table */
    369379        spin_lock_irqsave(&chip->reg_lock, flags);
    370         writel(0, (char*)chip->remap_addr + dma->ops->llp_offset);
     380        writel(0, chip->remap_addr + dma->ops->llp_offset);
    371381        dma->ops->enable_dma(chip, 0);
    372382        dma->ops->enable_dma(chip, 1);
    373383        spin_unlock_irqrestore(&chip->reg_lock, flags);
    374 
    375         if (dma->periods == periods && dma->period_bytes == period_bytes)
    376         {
    377             writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
    378                    (char*)chip->remap_addr + dma->ops->llp_offset);
    379             return 0;
    380         }
    381384
    382385        /* fill the entries */
    … …  
    398401
    399402        writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
    400                (char*)chip->remap_addr + dma->ops->llp_offset);
     403               chip->remap_addr + dma->ops->llp_offset);
    401404
    402405        dma->period_bytes = period_bytes;
    … …  
    413416{
    414417        if (dma->desc_buf.area) {
    415                 writel(0, (char*)chip->remap_addr + dma->ops->llp_offset);
     418                writel(0, chip->remap_addr + dma->ops->llp_offset);
    416419                snd_dma_free_pages(&dma->desc_buf);
    417420                dma->desc_buf.area = NULL;
    … …  
    557560#define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME)
    558561
    559 static int snd_atiixp_codec_detect(struct atiixp *chip)
     562static int __devinit ac97_probing_bugs(struct pci_dev *pci)
     563{
     564        const struct snd_pci_quirk *q;
     565
     566        q = snd_pci_quirk_lookup(pci, atiixp_quirks);
     567        if (q) {
     568#ifndef TARGET_OS2
     569                snd_printdd(KERN_INFO "Atiixp quirk for %s.  "
     570                            "Forcing codec %d\n", q->name, q->value);
     571#endif
     572                return q->value;
     573        }
     574        /* this hardware doesn't need workarounds.  Probe for codec */
     575        return -1;
     576}
     577
     578static int __devinit snd_atiixp_codec_detect(struct atiixp *chip)
    560579{
    561580        int timeout;
    562581
    563582        chip->codec_not_ready_bits = 0;
     583        if (ac97_codec == -1)
     584                ac97_codec = ac97_probing_bugs(chip->pci);
     585        if (ac97_codec >= 0) {
     586                chip->codec_not_ready_bits |=
     587                        CODEC_CHECK_BITS ^ (1 << (ac97_codec + 10));
     588                return 0;
     589        }
     590
    564591        atiixp_write(chip, IER, CODEC_CHECK_BITS);
    565592        /* wait for the interrupts */
    … …  
    641668
    642669        while (timeout--) {
    643                 curptr = readl((char*)chip->remap_addr + dma->ops->dt_cur);
     670                curptr = readl(chip->remap_addr + dma->ops->dt_cur);
    644671                if (curptr < dma->buf_addr)
    645672                        continue;
    … …  
    650677        }
    651678        snd_printd("atiixp: invalid DMA pointer read 0x%x (buf=%x)\n",
    652                    readl((char*)chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
     679                   readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
    653680        return 0;
    654681}
    … …  
    10561083        int err;
    10571084
    1058         down(&chip->open_mutex);
     1085        mutex_lock(&chip->open_mutex);
    10591086        err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0);
    1060         up(&chip->open_mutex);
     1087        mutex_unlock(&chip->open_mutex);
    10611088        if (err < 0)
    10621089                return err;
    … …  
    10731100        struct atiixp *chip = snd_pcm_substream_chip(substream);
    10741101        int err;
    1075         down(&chip->open_mutex);
     1102        mutex_lock(&chip->open_mutex);
    10761103        err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
    1077         up(&chip->open_mutex);
     1104        mutex_unlock(&chip->open_mutex);
    10781105        return err;
    10791106}
    … …  
    10951122        struct atiixp *chip = snd_pcm_substream_chip(substream);
    10961123        int err;
    1097         down(&chip->open_mutex);
     1124        mutex_lock(&chip->open_mutex);
    10981125        if (chip->spdif_over_aclink) /* share DMA_PLAYBACK */
    10991126                err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 2);
    11001127        else
    11011128                err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_SPDIF], -1);
    1102         up(&chip->open_mutex);
     1129        mutex_unlock(&chip->open_mutex);
    11031130        return err;
    11041131}
    … …  
    11081135        struct atiixp *chip = snd_pcm_substream_chip(substream);
    11091136        int err;
    1110         down(&chip->open_mutex);
     1137        mutex_lock(&chip->open_mutex);
    11111138        if (chip->spdif_over_aclink)
    11121139                err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
    11131140        else
    11141141                err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_SPDIF]);
    1115         up(&chip->open_mutex);
     1142        mutex_unlock(&chip->open_mutex);
    11161143        return err;
    11171144}
    … …  
    13041331 * interrupt handler
    13051332 */
    1306 static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     1333static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id)
    13071334{
    13081335        struct atiixp *chip = dev_id;
    … …  
    14001427                ac97.pci = chip->pci;
    14011428                ac97.num = i;
    1402                 ac97.scaps = AC97_SCAP_SKIP_MODEM;
     1429                ac97.scaps = AC97_SCAP_SKIP_MODEM | AC97_SCAP_POWER_SAVE;
    14031430                if (! chip->spdif_over_aclink)
    14041431                        ac97.scaps |= AC97_SCAP_NO_SPDIF;
    … …  
    14371464                        struct atiixp_dma *dma = &chip->dmas[i];
    14381465                        if (dma->substream && dma->running)
    1439                                 dma->saved_curptr = readl((char*)chip->remap_addr +
     1466                                dma->saved_curptr = readl(chip->remap_addr +
    14401467                                                          dma->ops->dt_cur);
    14411468                        snd_pcm_suspend_all(chip->pcmdevs[i]);
    … …  
    14461473        snd_atiixp_chip_stop(chip);
    14471474
    1448         pci_set_power_state(pci, PCI_D3hot);
    14491475        pci_disable_device(pci);
    14501476        pci_save_state(pci);
     1477        pci_set_power_state(pci, pci_choose_state(pci, state));
    14511478        return 0;
    14521479}
    … …  
    14581485        int i;
    14591486
     1487        pci_set_power_state(pci, PCI_D0);
    14601488        pci_restore_state(pci);
    1461         pci_enable_device(pci);
    1462         pci_set_power_state(pci, PCI_D0);
     1489        if (pci_enable_device(pci) < 0) {
     1490                printk(KERN_ERR "atiixp: pci_enable_device failed, "
     1491                       "disabling device\n");
     1492                snd_card_disconnect(card);
     1493                return -EIO;
     1494        }
    14631495        pci_set_master(pci);
    14641496
    … …  
    14761508                                dma->substream->ops->prepare(dma->substream);
    14771509                                writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
    1478                                        (char*)chip->remap_addr + dma->ops->llp_offset);
    1479                                 writel(dma->saved_curptr, (char*)chip->remap_addr +
     1510                                       chip->remap_addr + dma->ops->llp_offset);
     1511                                writel(dma->saved_curptr, chip->remap_addr +
    14801512                                       dma->ops->dt_cur);
    14811513                        }
    … …  
    15001532
    15011533        for (i = 0; i < 256; i += 4)
    1502                 snd_iprintf(buffer, "%02x: %08x\n", i, readl((char*)chip->remap_addr + i));
     1534                snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i));
    15031535}
    15041536
    … …  
    15081540
    15091541        if (! snd_card_proc_new(chip->card, "atiixp", &entry))
    1510                 snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read);
     1542                snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
    15111543}
    15121544#else /* !CONFIG_PROC_FS */
    … …  
    15651597
    15661598        spin_lock_init(&chip->reg_lock);
    1567         init_MUTEX(&chip->open_mutex);
     1599        mutex_init(&chip->open_mutex);
    15681600        chip->card = card;
    15691601        chip->pci = pci;
    … …  
    15821614        }
    15831615
    1584         if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ,
     1616        if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
    15851617                        card->shortname, chip)) {
    15861618                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
    … …  
    16091641        struct snd_card *card;
    16101642        struct atiixp *chip;
    1611         unsigned char revision;
    16121643        int err;
    16131644
    … …  
    16151646        if (card == NULL)
    16161647                return -ENOMEM;
    1617 
    1618         pci_read_config_byte(pci, PCI_REVISION_ID, &revision);
    16191648
    16201649        strcpy(card->driver, spdif_aclink ? "ATIIXP" : "ATIIXP-SPDMA");
    … …  
    16391668        snd_atiixp_chip_start(chip);
    16401669
    1641         sprintf(card->longname,
    1642                  "%s rev %x with %s at %#lx, irq %i", card->shortname, revision,
     1670        snprintf(card->longname, sizeof(card->longname),
     1671                 "%s rev %x with %s at %#lx, irq %i", card->shortname,
     1672#ifndef TARGET_OS2
     1673                 pci->revision,
     1674#else
     1675                 snd_pci_revision(pci),
     1676#endif
    16431677                 chip->ac97[0] ? snd_ac97_get_short_name(chip->ac97[0]) : "?",
    16441678                 chip->addr, chip->irq);
Note: See TracChangeset for help on using the changeset viewer.