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:
5 edited

Legend:

Unmodified
Added
Removed

  • GPL/trunk

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

    r703 r717  
    114114        }
    115115
    116         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    117                            0, &card);
    118         if (err < 0)
    119                 return err;
     116        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     117                                sizeof(*emu), &card);
     118        if (err < 0)
     119                return err;
     120        emu = card->private_data;
     121
    120122        if (max_buffer_size[dev] < 32)
    121123                max_buffer_size[dev] = 32;
    … …  
    124126        err = snd_emu10k1_create(card, pci, extin[dev], extout[dev],
    125127                                 (long)max_buffer_size[dev] * 1024 * 1024,
    126                                  enable_ir[dev], subsystem[dev],
    127                                  &emu);
    128         if (err < 0)
    129                 goto error;
    130         card->private_data = emu;
     128                                 enable_ir[dev], subsystem[dev]);
     129        if (err < 0)
     130                return err;
    131131        emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f;
    132132        err = snd_emu10k1_pcm(emu, 0);
    133133        if (err < 0)
    134                 goto error;
     134                return err;
    135135        err = snd_emu10k1_pcm_mic(emu, 1);
    136136        if (err < 0)
    137                 goto error;
     137                return err;
    138138        err = snd_emu10k1_pcm_efx(emu, 2);
    139139        if (err < 0)
    140                 goto error;
     140                return err;
    141141        /* This stores the periods table. */
    142142        if (emu->card_capabilities->ca0151_chip) { /* P16V */   
    143                 err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
    144                                           1024, &emu->p16v_buffer);
    145                 if (err < 0)
    146                         goto error;
    147         }
    148 
     143                emu->p16v_buffer =
     144                        snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV, 1024);
     145                if (!emu->p16v_buffer)
     146                        return -ENOMEM;
     147        }
    149148        err = snd_emu10k1_mixer(emu, 0, 3);
    150149        if (err < 0)
    151                 goto error;
     150                return err;
    152151       
    153152        err = snd_emu10k1_timer(emu, 0);
    154153        if (err < 0)
    155                 goto error;
     154                return err;
    156155
    157156        err = snd_emu10k1_pcm_multi(emu, 3);
    158157        if (err < 0)
    159                 goto error;
     158                return err;
    160159        if (emu->card_capabilities->ca0151_chip) { /* P16V */
    161160                err = snd_p16v_pcm(emu, 4);
    162161                if (err < 0)
    163                         goto error;
     162                        return err;
    164163        }
    165164        if (emu->audigy) {
    166165                err = snd_emu10k1_audigy_midi(emu);
    167166                if (err < 0)
    168                         goto error;
     167                        return err;
    169168        } else {
    170169                err = snd_emu10k1_midi(emu);
    171170                if (err < 0)
    172                         goto error;
     171                        return err;
    173172        }
    174173        err = snd_emu10k1_fx8010_new(emu, 0);
    175174        if (err < 0)
    176                 goto error;
     175                return err;
    177176#ifdef ENABLE_SYNTH
    178177        if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
    … …  
    202201        err = snd_card_register(card);
    203202        if (err < 0)
    204                 goto error;
     203                return err;
    205204
    206205        if (emu->card_capabilities->emu_model)
    … …  
    210209        dev++;
    211210        return 0;
    212 
    213  error:
    214         snd_card_free(card);
    215         return err;
    216211}
    217 
    218 static void snd_card_emu10k1_remove(struct pci_dev *pci)
    219 {
    220         snd_card_free(pci_get_drvdata(pci));
    221 }
    222 
    223212
    224213#ifdef CONFIG_PM_SLEEP
    … …  
    278267        .id_table = snd_emu10k1_ids,
    279268        .probe = snd_card_emu10k1_probe,
    280         .remove = snd_card_emu10k1_remove,
    281269        .driver = {
    282270                .pm = SND_EMU10K1_PM_OPS,

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

    r695 r717  
    12521252#endif
    12531253
    1254 static int snd_emu10k1_free(struct snd_emu10k1 *emu)
     1254static void snd_emu10k1_free(struct snd_card *card)
    12551255{
     1256        struct snd_emu10k1 *emu = card->private_data;
     1257
    12561258        if (emu->port) {        /* avoid access to already used hardware */
    12571259                snd_emu10k1_fx8010_tram_setup(emu, 0);
    … …  
    12661268        release_firmware(emu->firmware);
    12671269        release_firmware(emu->dock_fw);
    1268         if (emu->irq >= 0)
    1269                 free_irq(emu->irq, emu);
    12701270        snd_util_memhdr_free(emu->memhdr);
    12711271        if (emu->silent_page.area)
    … …  
    12781278        free_pm_buffer(emu);
    12791279#endif
    1280         if (emu->port)
    1281                 pci_release_regions(emu->pci);
    1282         if (emu->card_capabilities->ca0151_chip) /* P16V */
    1283                 snd_p16v_free(emu);
    1284         pci_disable_device(emu->pci);
    1285         kfree(emu);
    1286         return 0;
    1287 }
    1288 
    1289 static int snd_emu10k1_dev_free(struct snd_device *device)
    1290 {
    1291         struct snd_emu10k1 *emu = device->device_data;
    1292         return snd_emu10k1_free(emu);
    12931280}
    12941281
    … …  
    17921779                       long max_cache_bytes,
    17931780                       int enable_ir,
    1794                        uint subsystem,
    1795                        struct snd_emu10k1 **remu)
     1781                       uint subsystem)
    17961782{
    1797         struct snd_emu10k1 *emu;
     1783        struct snd_emu10k1 *emu = card->private_data;
    17981784        int idx, err;
    17991785        int is_audigy;
    … …  
    18021788        unsigned int silent_page;
    18031789        const struct snd_emu_chip_details *c;
    1804         static const struct snd_device_ops ops = {
    1805                 .dev_free =     snd_emu10k1_dev_free,
    1806         };
    1807 
    1808         *remu = NULL;
    18091790
    18101791        /* enable PCI device */
    1811         err = pci_enable_device(pci);
     1792        err = pcim_enable_device(pci);
    18121793        if (err < 0)
    18131794                return err;
    18141795
    1815         emu = kzalloc(sizeof(*emu), GFP_KERNEL);
    1816         if (emu == NULL) {
    1817                 pci_disable_device(pci);
    1818                 return -ENOMEM;
    1819         }
     1796        card->private_free = snd_emu10k1_free;
    18201797        emu->card = card;
    18211798        spin_lock_init(&emu->reg_lock);
    … …  
    18641841        if (c->vendor == 0) {
    18651842                dev_err(card->dev, "emu10k1: Card not recognised\n");
    1866                 kfree(emu);
    1867                 pci_disable_device(pci);
    18681843                return -ENOENT;
    18691844        }
    … …  
    18971872                        "architecture does not support PCI busmaster DMA with mask 0x%lx\n",
    18981873                        emu->dma_mask);
    1899                 kfree(emu);
    1900                 pci_disable_device(pci);
    19011874                return -ENXIO;
    19021875        }
    … …  
    19071880
    19081881        err = pci_request_regions(pci, "EMU10K1");
    1909         if (err < 0) {
    1910                 kfree(emu);
    1911                 pci_disable_device(pci);
     1882        if (err < 0)
    19121883                return err;
    1913         }
    19141884        emu->port = pci_resource_start(pci, 0);
    19151885
    … …  
    19191889                                         MAXPAGES0);
    19201890        if (snd_emu10k1_alloc_pages_maybe_wider(emu, page_table_size,
    1921                                                 &emu->ptb_pages) < 0) {
    1922                 err = -ENOMEM;
    1923                 goto error;
    1924         }
     1891                                                &emu->ptb_pages) < 0)
     1892                return -ENOMEM;
    19251893        dev_dbg(card->dev, "page table address range is %.8lx:%.8lx\n",
    19261894                (unsigned long)emu->ptb_pages.addr,
    … …  
    19371905                                       sizeof(unsigned long));
    19381906#endif
    1939         if (emu->page_ptr_table == NULL || emu->page_addr_table == NULL) {
    1940                 err = -ENOMEM;
    1941                 goto error;
    1942         }
     1907
     1908        if (!emu->page_ptr_table || !emu->page_addr_table)
     1909                return -ENOMEM;
    19431910
    19441911        if (snd_emu10k1_alloc_pages_maybe_wider(emu, EMUPAGESIZE,
    1945                                                 &emu->silent_page) < 0) {
    1946                 err = -ENOMEM;
    1947                 goto error;
    1948         }
     1912                                                &emu->silent_page) < 0)
     1913                return -ENOMEM;
    19491914        dev_dbg(card->dev, "silent page range is %.8lx:%.8lx\n",
    19501915                (unsigned long)emu->silent_page.addr,
    … …  
    19531918
    19541919        emu->memhdr = snd_util_memhdr_new(emu->max_cache_pages * PAGE_SIZE);
    1955         if (emu->memhdr == NULL) {
    1956                 err = -ENOMEM;
    1957                 goto error;
    1958         }
     1920        if (!emu->memhdr)
     1921                return -ENOMEM;
    19591922        emu->memhdr->block_extra_size = sizeof(struct snd_emu10k1_memblk) -
    19601923                sizeof(struct snd_util_memblk);
    … …  
    19741937                err = snd_emu10k1_cardbus_init(emu);
    19751938                if (err < 0)
    1976                         goto error;
     1939                        return err;
    19771940        }
    19781941        if (emu->card_capabilities->ecard) {
    19791942                err = snd_emu10k1_ecard_init(emu);
    19801943                if (err < 0)
    1981                         goto error;
     1944                        return err;
    19821945        } else if (emu->card_capabilities->emu_model) {
    19831946                err = snd_emu10k1_emu1010_init(emu);
    1984                 if (err < 0) {
    1985                         snd_emu10k1_free(emu);
     1947                if (err < 0)
    19861948                        return err;
    1987                 }
    19881949        } else {
    19891950                /* 5.1: Enable the additional AC97 Slots. If the emu10k1 version
    … …  
    19991960
    20001961        /* irq handler must be registered after I/O ports are activated */
    2001         if (request_irq(pci->irq, snd_emu10k1_interrupt, IRQF_SHARED,
    2002                         KBUILD_MODNAME, emu)) {
    2003                 err = -EBUSY;
    2004                 goto error;
    2005         }
     1962        if (devm_request_irq(&pci->dev, pci->irq, snd_emu10k1_interrupt,
     1963                             IRQF_SHARED, KBUILD_MODNAME, emu))
     1964                return -EBUSY;
    20061965        emu->irq = pci->irq;
    20071966        card->sync_irq = emu->irq;
    … …  
    20422001        err = snd_emu10k1_init(emu, enable_ir, 0);
    20432002        if (err < 0)
    2044                 goto error;
     2003                return err;
    20452004#ifdef CONFIG_PM_SLEEP
    20462005        err = alloc_pm_buffer(emu);
    20472006        if (err < 0)
    2048                 goto error;
     2007                return err;
    20492008#endif
    20502009
    … …  
    20522011        err = snd_emu10k1_init_efx(emu);
    20532012        if (err < 0)
    2054                 goto error;
     2013                return err;
    20552014        snd_emu10k1_audio_enable(emu);
    2056 
    2057         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, emu, &ops);
    2058         if (err < 0)
    2059                 goto error;
    20602015
    20612016#ifdef CONFIG_SND_PROC_FS
    20622017        snd_emu10k1_proc_init(emu);
    20632018#endif
    2064 
    2065         *remu = emu;
    20662019        return 0;
    2067 
    2068  error:
    2069         snd_emu10k1_free(emu);
    2070         return err;
    20712020}
    20722021

  • 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

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

    r703 r717  
    291291        struct snd_pcm_runtime *runtime = substream->runtime;
    292292        int channel = substream->pcm->device - emu->p16v_device_offset;
    293         u32 *table_base = (u32 *)(emu->p16v_buffer.area+(8*16*channel));
     293        u32 *table_base = (u32 *)(emu->p16v_buffer->area+(8*16*channel));
    294294        u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
    295295        int i;
    … …  
    309309        dev_dbg(emu->card->dev,
    310310                "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
    311                    emu->p16v_buffer.addr, emu->p16v_buffer.area,
    312                    emu->p16v_buffer.bytes);
     311                   emu->p16v_buffer->addr, emu->p16v_buffer->area,
     312                   emu->p16v_buffer->bytes);
    313313#endif /* debug */
    314314        tmp = snd_emu10k1_ptr_read(emu, A_SPDIF_SAMPLERATE, channel);
    … …  
    334334        }
    335335 
    336         snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer.addr+(8*16*channel));
     336        snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_ADDR, channel, emu->p16v_buffer->addr+(8*16*channel));
    337337        snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
    338338        snd_emu10k1_ptr20_write(emu, PLAYBACK_LIST_PTR, channel, 0);
    … …  
    567567        .pointer =     snd_p16v_pcm_pointer_capture,
    568568};
    569 
    570 
    571 int snd_p16v_free(struct snd_emu10k1 *chip)
    572 {
    573         // release the data
    574         if (chip->p16v_buffer.area) {
    575                 snd_dma_free_pages(&chip->p16v_buffer);
    576                 /*
    577                 dev_dbg(chip->card->dev, "period lables free: %p\n",
    578                            &chip->p16v_buffer);
    579                 */
    580         }
    581         return 0;
    582 }
    583569
    584570int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)
Note: See TracChangeset for help on using the changeset viewer.