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

Legend:

Unmodified
Added
Removed

  • GPL/trunk

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

    r703 r717  
    110110
    111111        if (!r) {
    112                 r = request_region(io_port, 1, "YMFPCI gameport");
     112                r = devm_request_region(&chip->pci->dev, io_port, 1,
     113                                        "YMFPCI gameport");
    113114                if (!r) {
    114115                        dev_err(chip->card->dev,
    … …  
    122123                dev_err(chip->card->dev,
    123124                        "cannot allocate memory for gameport\n");
    124                 release_and_free_resource(r);
    125125                return -ENOMEM;
    126126        }
    … …  
    131131        gameport_set_dev_parent(gp, &chip->pci->dev);
    132132        gp->io = io_port;
    133         gameport_set_port_data(gp, r);
    134133
    135134        if (chip->pci->device >= 0x0010) /* YMF 744/754 */
    … …  
    147146{
    148147        if (chip->gameport) {
    149                 struct resource *r = gameport_get_port_data(chip->gameport);
    150 
    151148                gameport_unregister_port(chip->gameport);
    152149                chip->gameport = NULL;
    153 
    154                 release_and_free_resource(r);
    155150        }
    156151}
    … …  
    181176
    182177        err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    183                            0, &card);
    184         if (err < 0)
    185                 return err;
     178                           sizeof(*chip), &card);
     179        if (err < 0)
     180                return err;
     181        chip = card->private_data;
    186182
    187183        switch (pci_id->device) {
    … …  
    204200                }
    205201                if (fm_port[dev] > 0)
    206                         fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3");
     202                        fm_res = devm_request_region(&pci->dev, fm_port[dev],
     203                                                     4, "YMFPCI OPL3");
    207204                if (fm_res) {
    208205                        legacy_ctrl |= YMFPCI_LEGACY_FMEN;
    … …  
    214211                }
    215212                if (mpu_port[dev] > 0)
    216                         mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401");
     213                        mpu_res = devm_request_region(&pci->dev, mpu_port[dev],
     214                                                      2, "YMFPCI MPU401");
    217215                if (mpu_res) {
    218216                        legacy_ctrl |= YMFPCI_LEGACY_MEN;
    … …  
    228226                }
    229227                if (fm_port[dev] > 0)
    230                         fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3");
     228                        fm_res = devm_request_region(&pci->dev, fm_port[dev],
     229                                                     4, "YMFPCI OPL3");
    231230                if (fm_res) {
    232231                        legacy_ctrl |= YMFPCI_LEGACY_FMEN;
    … …  
    243242                }
    244243                if (mpu_port[dev] > 0)
    245                         mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401");
     244                        mpu_res = devm_request_region(&pci->dev, mpu_port[dev],
     245                                                      2, "YMFPCI MPU401");
    246246                if (mpu_res) {
    247247                        legacy_ctrl |= YMFPCI_LEGACY_MEN;
    … …  
    258258        pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl);
    259259        pci_write_config_word(pci, PCIR_DSXG_ELEGACY, legacy_ctrl2);
    260         err = snd_ymfpci_create(card, pci, old_legacy_ctrl, &chip);
    261         if (err  < 0) {
    262                 release_and_free_resource(mpu_res);
    263                 release_and_free_resource(fm_res);
    264                 goto free_card;
    265         }
    266         chip->fm_res = fm_res;
    267         chip->mpu_res = mpu_res;
    268         card->private_data = chip;
     260        err = snd_ymfpci_create(card, pci, old_legacy_ctrl);
     261        if (err  < 0)
     262                return err;
    269263
    270264        strcpy(card->driver, str);
    … …  
    276270        err = snd_ymfpci_pcm(chip, 0);
    277271        if (err < 0)
    278                 goto free_card;
     272                return err;
    279273
    280274        err = snd_ymfpci_pcm_spdif(chip, 1);
    281275        if (err < 0)
    282                 goto free_card;
     276                return err;
    283277
    284278        err = snd_ymfpci_mixer(chip, rear_switch[dev]);
    285279        if (err < 0)
    286                 goto free_card;
     280                return err;
    287281
    288282        if (chip->ac97->ext_id & AC97_EI_SDAC) {
    289283                err = snd_ymfpci_pcm_4ch(chip, 2);
    290284                if (err < 0)
    291                         goto free_card;
     285                        return err;
    292286
    293287                err = snd_ymfpci_pcm2(chip, 3);
    294288                if (err < 0)
    295                         goto free_card;
     289                        return err;
    296290        }
    297291        err = snd_ymfpci_timer(chip, 0);
    298292        if (err < 0)
    299                 goto free_card;
    300 
    301         if (chip->mpu_res) {
     293                return err;
     294
     295        if (mpu_res) {
    302296                err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI,
    303297                                          mpu_port[dev],
    … …  
    313307                }
    314308        }
    315         if (chip->fm_res) {
     309        if (fm_res) {
    316310                err = snd_opl3_create(card,
    317311                                      fm_port[dev],
    … …  
    328322                        if (err < 0) {
    329323                                dev_err(card->dev, "cannot create opl3 hwdep\n");
    330                                 goto free_card;
     324                                return err;
    331325                        }
    332326                }
    … …  
    337331        err = snd_card_register(card);
    338332        if (err < 0)
    339                 goto free_card;
     333                return err;
    340334
    341335        pci_set_drvdata(pci, card);
    342336        dev++;
    343337        return 0;
    344 
    345 free_card:
    346         snd_card_free(card);
    347         return err;
    348 }
    349 
    350 static void snd_card_ymfpci_remove(struct pci_dev *pci)
    351 {
    352         snd_card_free(pci_get_drvdata(pci));
    353338}
    354339
    … …  
    357342        .id_table = snd_ymfpci_ids,
    358343        .probe = snd_card_ymfpci_probe,
    359         .remove = snd_card_ymfpci_remove,
    360344#ifdef CONFIG_PM_SLEEP
    361345        .driver = {

  • GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci.h

    r679 r717  
    276276        unsigned long reg_area_phys;
    277277        void __iomem *reg_area_virt;
    278         struct resource *res_reg_area;
    279         struct resource *fm_res;
    280         struct resource *mpu_res;
    281278
    282279        unsigned short old_legacy_ctrl;
    … …  
    285282#endif
    286283
    287         struct snd_dma_buffer work_ptr;
     284        struct snd_dma_buffer *work_ptr;
    288285
    289286        unsigned int bank_size_playback;
    … …  
    359356int snd_ymfpci_create(struct snd_card *card,
    360357                      struct pci_dev *pci,
    361                       unsigned short old_legacy_ctrl,
    362                       struct snd_ymfpci ** rcodec);
     358                      unsigned short old_legacy_ctrl);
    363359void snd_ymfpci_free_gameport(struct snd_ymfpci *chip);
    364360

  • GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci_main.c

    r703 r717  
    21212121        /* work_ptr must be aligned to 256 bytes, but it's already
    21222122           covered with the kernel page allocation mechanism */
    2123         if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
    2124                                 size, &chip->work_ptr) < 0)
     2123        chip->work_ptr = snd_devm_alloc_pages(&chip->pci->dev,
     2124                                              SNDRV_DMA_TYPE_DEV, size);
     2125        if (!chip->work_ptr)
    21252126                return -ENOMEM;
    2126         ptr = chip->work_ptr.area;
    2127         ptr_addr = chip->work_ptr.addr;
     2127        ptr = chip->work_ptr->area;
     2128        ptr_addr = chip->work_ptr->addr;
    21282129        memset(ptr, 0, size);   /* for sure */
    21292130
    … …  
    21702171       
    21712172        snd_BUG_ON(ptr + chip->work_size !=
    2172                    chip->work_ptr.area + chip->work_ptr.bytes);
     2173                   chip->work_ptr->area + chip->work_ptr->bytes);
    21732174
    21742175        snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, chip->bank_base_playback_addr);
    … …  
    22012202}
    22022203
    2203 static int snd_ymfpci_free(struct snd_ymfpci *chip)
    2204 {
     2204static void snd_ymfpci_free(struct snd_card *card)
     2205{
     2206        struct snd_ymfpci *chip = card->private_data;
    22052207        u16 ctrl;
    22062208
    2207         if (snd_BUG_ON(!chip))
    2208                 return -EINVAL;
    2209 
    2210         if (chip->res_reg_area) {       /* don't touch busy hardware */
    2211                 snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
    2212                 snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
    2213                 snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0);
    2214                 snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0);
    2215                 snd_ymfpci_disable_dsp(chip);
    2216                 snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0);
    2217                 snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0);
    2218                 snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0);
    2219                 snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0);
    2220                 snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0);
    2221                 ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
    2222                 snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
    2223         }
     2209        snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
     2210        snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
     2211        snd_ymfpci_writel(chip, YDSXGR_LEGACYOUTVOL, 0);
     2212        snd_ymfpci_writel(chip, YDSXGR_STATUS, ~0);
     2213        snd_ymfpci_disable_dsp(chip);
     2214        snd_ymfpci_writel(chip, YDSXGR_PLAYCTRLBASE, 0);
     2215        snd_ymfpci_writel(chip, YDSXGR_RECCTRLBASE, 0);
     2216        snd_ymfpci_writel(chip, YDSXGR_EFFCTRLBASE, 0);
     2217        snd_ymfpci_writel(chip, YDSXGR_WORKBASE, 0);
     2218        snd_ymfpci_writel(chip, YDSXGR_WORKSIZE, 0);
     2219        ctrl = snd_ymfpci_readw(chip, YDSXGR_GLOBALCTRL);
     2220        snd_ymfpci_writew(chip, YDSXGR_GLOBALCTRL, ctrl & ~0x0007);
    22242221
    22252222        snd_ymfpci_ac3_done(chip);
    22262223
    2227         /* Set PCI device to D3 state */
    2228 #if 0
    2229         /* FIXME: temporarily disabled, otherwise we cannot fire up
    2230          * the chip again unless reboot.  ACPI bug?
    2231          */
    2232         pci_set_power_state(chip->pci, PCI_D3hot);
    2233 #endif
    2234 
    2235 #ifdef CONFIG_PM_SLEEP
    2236         kfree(chip->saved_regs);
    2237 #endif
    2238         if (chip->irq >= 0)
    2239                 free_irq(chip->irq, chip);
    2240         release_and_free_resource(chip->mpu_res);
    2241         release_and_free_resource(chip->fm_res);
    22422224        snd_ymfpci_free_gameport(chip);
    2243         iounmap(chip->reg_area_virt);
    2244         if (chip->work_ptr.area)
    2245                 snd_dma_free_pages(&chip->work_ptr);
    2246        
    2247         release_and_free_resource(chip->res_reg_area);
    2248 
     2225       
    22492226        pci_write_config_word(chip->pci, 0x40, chip->old_legacy_ctrl);
    22502227       
    2251         pci_disable_device(chip->pci);
    22522228        release_firmware(chip->dsp_microcode);
    22532229        release_firmware(chip->controller_microcode);
    2254         kfree(chip);
    2255         return 0;
    2256 }
    2257 
    2258 static int snd_ymfpci_dev_free(struct snd_device *device)
    2259 {
    2260         struct snd_ymfpci *chip = device->device_data;
    2261         return snd_ymfpci_free(chip);
    22622230}
    22632231
    … …  
    23512319int snd_ymfpci_create(struct snd_card *card,
    23522320                      struct pci_dev *pci,
    2353                       unsigned short old_legacy_ctrl,
    2354                       struct snd_ymfpci **rchip)
    2355 {
    2356         struct snd_ymfpci *chip;
     2321                      unsigned short old_legacy_ctrl)
     2322{
     2323        struct snd_ymfpci *chip = card->private_data;
    23572324        int err;
    2358         static const struct snd_device_ops ops = {
    2359                 .dev_free =     snd_ymfpci_dev_free,
    2360         };
    2361        
    2362         *rchip = NULL;
    2363 
     2325       
    23642326        /* enable PCI device */
    2365         err = pci_enable_device(pci);
     2327        err = pcim_enable_device(pci);
    23662328        if (err < 0)
    23672329                return err;
    23682330
    2369         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    2370         if (chip == NULL) {
    2371                 pci_disable_device(pci);
    2372                 return -ENOMEM;
    2373         }
    23742331        chip->old_legacy_ctrl = old_legacy_ctrl;
    23752332        spin_lock_init(&chip->reg_lock);
    … …  
    23822339        chip->device_id = pci->device;
    23832340        chip->rev = pci->revision;
     2341
     2342        err = pci_request_regions(pci, "YMFPCI");
     2343        if (err < 0)
     2344                return err;
     2345
    23842346        chip->reg_area_phys = pci_resource_start(pci, 0);
    2385         chip->reg_area_virt = ioremap(chip->reg_area_phys, 0x8000);
    2386         pci_set_master(pci);
    2387         chip->src441_used = -1;
    2388 
    2389         chip->res_reg_area = request_mem_region(chip->reg_area_phys, 0x8000, "YMFPCI");
    2390         if (!chip->res_reg_area) {
     2347        chip->reg_area_virt = devm_ioremap(&pci->dev, chip->reg_area_phys, 0x8000);
     2348        if (!chip->reg_area_virt) {
    23912349                dev_err(chip->card->dev,
    23922350                        "unable to grab memory region 0x%lx-0x%lx\n",
    23932351                        chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1);
    2394                 err = -EBUSY;
    2395                 goto free_chip;
    2396         }
    2397         if (request_irq(pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
     2352                return -EBUSY;
     2353        }
     2354        pci_set_master(pci);
     2355        chip->src441_used = -1;
     2356
     2357        if (devm_request_irq(&pci->dev, pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
    23982358                        KBUILD_MODNAME, chip)) {
    23992359                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
    2400                 err = -EBUSY;
    2401                 goto free_chip;
     2360                return -EBUSY;
    24022361        }
    24032362        chip->irq = pci->irq;
    24042363        card->sync_irq = chip->irq;
     2364        card->private_free = snd_ymfpci_free;
    24052365
    24062366        snd_ymfpci_aclink_reset(pci);
    2407         if (snd_ymfpci_codec_ready(chip, 0) < 0) {
    2408                 err = -EIO;
    2409                 goto free_chip;
    2410         }
     2367        if (snd_ymfpci_codec_ready(chip, 0) < 0)
     2368                return -EIO;
    24112369
    24122370        err = snd_ymfpci_request_firmware(chip);
    24132371        if (err < 0) {
    24142372                dev_err(chip->card->dev, "firmware request failed: %d\n", err);
    2415                 goto free_chip;
     2373                return err;
    24162374        }
    24172375        snd_ymfpci_download_image(chip);
    … …  
    24192377        udelay(100); /* seems we need a delay after downloading image.. */
    24202378
    2421         if (snd_ymfpci_memalloc(chip) < 0) {
    2422                 err = -EIO;
    2423                 goto free_chip;
    2424         }
     2379        if (snd_ymfpci_memalloc(chip) < 0)
     2380                return -EIO;
    24252381
    24262382        err = snd_ymfpci_ac3_init(chip);
    24272383        if (err < 0)
    2428                 goto free_chip;
     2384                return err;
    24292385
    24302386#ifdef CONFIG_PM_SLEEP
    2431         chip->saved_regs = kmalloc_array(YDSXGR_NUM_SAVED_REGS, sizeof(u32),
    2432                                          GFP_KERNEL);
    2433         if (chip->saved_regs == NULL) {
    2434                 err = -ENOMEM;
    2435                 goto free_chip;
    2436         }
     2387        chip->saved_regs = devm_kmalloc_array(&pci->dev, YDSXGR_NUM_SAVED_REGS,
     2388                                              sizeof(u32), GFP_KERNEL);
     2389        if (!chip->saved_regs)
     2390                return -ENOMEM;
    24372391#endif
    24382392
    2439         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    2440         if (err < 0)
    2441                 goto free_chip;
    2442 
    24432393        snd_ymfpci_proc_init(card, chip);
    24442394
    2445         *rchip = chip;
    2446         return 0;
    2447 
    2448 free_chip:
    2449         snd_ymfpci_free(chip);
    2450         return err;
    2451 }
     2395        return 0;
     2396}
Note: See TracChangeset for help on using the changeset viewer.