Ignore:
Timestamp:
Aug 7, 2022, 6:11:12 PM (3 years ago)
Author:
David Azarewicz
Message:

Merge changes from next branch.

Location:
GPL/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • GPL/trunk

  • GPL/trunk/alsa-kernel/pci/emu10k1/emu10k1x.c

    r703 r717  
    220220
    221221        unsigned long port;
    222         struct resource *res_port;
    223222        int irq;
    224223
     
    237236        u32 spdif_bits[3]; // SPDIF out setup
    238237
    239         struct snd_dma_buffer dma_buffer;
     238        struct snd_dma_buffer *dma_buffer;
    240239
    241240        struct emu10k1x_midi midi;
     
    446445        struct emu10k1x_pcm *epcm = runtime->private_data;
    447446        int voice = epcm->voice->number;
    448         u32 *table_base = (u32 *)(emu->dma_buffer.area+1024*voice);
     447        u32 *table_base = (u32 *)(emu->dma_buffer->area+1024*voice);
    449448        u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
    450449        int i;
     
    455454        }
    456455
    457         snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_ADDR, voice, emu->dma_buffer.addr+1024*voice);
     456        snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_ADDR, voice, emu->dma_buffer->addr+1024*voice);
    458457        snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_SIZE, voice, (runtime->periods - 1) << 19);
    459458        snd_emu10k1x_ptr_write(emu, PLAYBACK_LIST_PTR, voice, 0);
     
    741740}
    742741
    743 static int snd_emu10k1x_free(struct emu10k1x *chip)
    744 {
     742static void snd_emu10k1x_free(struct snd_card *card)
     743{
     744        struct emu10k1x *chip = card->private_data;
     745
    745746        snd_emu10k1x_ptr_write(chip, TRIGGER_CHANNEL, 0, 0);
    746747        // disable interrupts
     
    748749        // disable audio
    749750        outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG);
    750 
    751         /* release the irq */
    752         if (chip->irq >= 0)
    753                 free_irq(chip->irq, chip);
    754 
    755         // release the i/o port
    756         release_and_free_resource(chip->res_port);
    757 
    758         // release the DMA
    759         if (chip->dma_buffer.area) {
    760                 snd_dma_free_pages(&chip->dma_buffer);
    761         }
    762 
    763         pci_disable_device(chip->pci);
    764 
    765         // release the data
    766         kfree(chip);
    767         return 0;
    768 }
    769 
    770 static int snd_emu10k1x_dev_free(struct snd_device *device)
    771 {
    772         struct emu10k1x *chip = device->device_data;
    773         return snd_emu10k1x_free(chip);
    774751}
    775752
     
    889866
    890867static int snd_emu10k1x_create(struct snd_card *card,
    891                                struct pci_dev *pci,
    892                                struct emu10k1x **rchip)
    893 {
    894         struct emu10k1x *chip;
     868                               struct pci_dev *pci)
     869{
     870        struct emu10k1x *chip = card->private_data;
    895871        int err;
    896872        int ch;
    897         static const struct snd_device_ops ops = {
    898                 .dev_free = snd_emu10k1x_dev_free,
    899         };
    900 
    901         *rchip = NULL;
    902 
    903         err = pci_enable_device(pci);
     873
     874        err = pcim_enable_device(pci);
    904875        if (err < 0)
    905876                return err;
     
    907878        if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(28)) < 0) {
    908879                dev_err(card->dev, "error to set 28bit mask DMA\n");
    909                 pci_disable_device(pci);
    910880                return -ENXIO;
    911         }
    912 
    913         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    914         if (chip == NULL) {
    915                 pci_disable_device(pci);
    916                 return -ENOMEM;
    917881        }
    918882
     
    924888        spin_lock_init(&chip->voice_lock);
    925889 
     890        err = pci_request_regions(pci, "EMU10K1X");
     891        if (err < 0)
     892                return err;
    926893        chip->port = pci_resource_start(pci, 0);
    927         chip->res_port = request_region(chip->port, 8, "EMU10K1X");
    928         if (!chip->res_port) {
    929                 dev_err(card->dev, "cannot allocate the port 0x%lx\n",
    930                         chip->port);
    931                 snd_emu10k1x_free(chip);
    932                 return -EBUSY;
    933         }
    934 
    935         if (request_irq(pci->irq, snd_emu10k1x_interrupt,
    936                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
     894
     895        if (devm_request_irq(&pci->dev, pci->irq, snd_emu10k1x_interrupt,
     896                             IRQF_SHARED, KBUILD_MODNAME, chip)) {
    937897                dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
    938                 snd_emu10k1x_free(chip);
    939898                return -EBUSY;
    940899        }
    941900        chip->irq = pci->irq;
    942901        card->sync_irq = chip->irq;
     902        card->private_free = snd_emu10k1x_free;
    943903 
    944         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    945                                 4 * 1024, &chip->dma_buffer) < 0) {
    946                 snd_emu10k1x_free(chip);
     904        chip->dma_buffer = snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
     905                                                4 * 1024);
     906        if (!chip->dma_buffer)
    947907                return -ENOMEM;
    948         }
    949908
    950909        pci_set_master(pci);
     
    1006965        outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG);
    1007966
    1008         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1009         if (err < 0) {
    1010                 snd_emu10k1x_free(chip);
    1011                 return err;
    1012         }
    1013         *rchip = chip;
    1014967        return 0;
    1015968}
     
    15461499}
    15471500
    1548 static int snd_emu10k1x_probe(struct pci_dev *pci,
    1549                               const struct pci_device_id *pci_id)
     1501static int __snd_emu10k1x_probe(struct pci_dev *pci,
     1502                                const struct pci_device_id *pci_id)
    15501503{
    15511504        static int dev;
     
    15611514        }
    15621515
    1563         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1564                            0, &card);
    1565         if (err < 0)
    1566                 return err;
    1567 
    1568         err = snd_emu10k1x_create(card, pci, &chip);
    1569         if (err < 0) {
    1570                 snd_card_free(card);
    1571                 return err;
    1572         }
     1516        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1517                                sizeof(*chip), &card);
     1518        if (err < 0)
     1519                return err;
     1520        chip = card->private_data;
     1521
     1522        err = snd_emu10k1x_create(card, pci);
     1523        if (err < 0)
     1524                return err;
    15731525
    15741526        err = snd_emu10k1x_pcm(chip, 0);
    1575         if (err < 0) {
    1576                 snd_card_free(card);
    1577                 return err;
    1578         }
     1527        if (err < 0)
     1528                return err;
    15791529        err = snd_emu10k1x_pcm(chip, 1);
    1580         if (err < 0) {
    1581                 snd_card_free(card);
    1582                 return err;
    1583         }
     1530        if (err < 0)
     1531                return err;
    15841532        err = snd_emu10k1x_pcm(chip, 2);
    1585         if (err < 0) {
    1586                 snd_card_free(card);
    1587                 return err;
    1588         }
     1533        if (err < 0)
     1534                return err;
    15891535
    15901536        err = snd_emu10k1x_ac97(chip);
    1591         if (err < 0) {
    1592                 snd_card_free(card);
    1593                 return err;
    1594         }
     1537        if (err < 0)
     1538                return err;
    15951539
    15961540        err = snd_emu10k1x_mixer(chip);
    1597         if (err < 0) {
    1598                 snd_card_free(card);
    1599                 return err;
    1600         }
     1541        if (err < 0)
     1542                return err;
    16011543       
    16021544        err = snd_emu10k1x_midi(chip);
    1603         if (err < 0) {
    1604                 snd_card_free(card);
    1605                 return err;
    1606         }
     1545        if (err < 0)
     1546                return err;
    16071547
    16081548        snd_emu10k1x_proc_init(chip);
     
    16141554
    16151555        err = snd_card_register(card);
    1616         if (err < 0) {
    1617                 snd_card_free(card);
    1618                 return err;
    1619         }
     1556        if (err < 0)
     1557                return err;
    16201558
    16211559        pci_set_drvdata(pci, card);
     
    16241562}
    16251563
    1626 static void snd_emu10k1x_remove(struct pci_dev *pci)
    1627 {
    1628         snd_card_free(pci_get_drvdata(pci));
     1564static int snd_emu10k1x_probe(struct pci_dev *pci,
     1565                              const struct pci_device_id *pci_id)
     1566{
     1567        return snd_card_free_on_error(&pci->dev, __snd_emu10k1x_probe(pci, pci_id));
    16291568}
    16301569
     
    16411580        .id_table = snd_emu10k1x_ids,
    16421581        .probe = snd_emu10k1x_probe,
    1643         .remove = snd_emu10k1x_remove,
    16441582};
    16451583
Note: See TracChangeset for help on using the changeset viewer.