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/fm801.c

    r703 r717  
    10371037};
    10381038
    1039 static void snd_fm801_mixer_free_ac97_bus(struct snd_ac97_bus *bus)
    1040 {
    1041         struct fm801 *chip = bus->private_data;
    1042         chip->ac97_bus = NULL;
    1043 }
    1044 
    1045 static void snd_fm801_mixer_free_ac97(struct snd_ac97 *ac97)
    1046 {
    1047         struct fm801 *chip = ac97->private_data;
    1048         if (ac97->num == 0) {
    1049                 chip->ac97 = NULL;
    1050         } else {
    1051                 chip->ac97_sec = NULL;
    1052         }
    1053 }
    1054 
    10551039static int snd_fm801_mixer(struct fm801 *chip)
    10561040{
     
    10661050        if (err < 0)
    10671051                return err;
    1068         chip->ac97_bus->private_free = snd_fm801_mixer_free_ac97_bus;
    10691052
    10701053        memset(&ac97, 0, sizeof(ac97));
    10711054        ac97.private_data = chip;
    1072         ac97.private_free = snd_fm801_mixer_free_ac97;
    10731055        err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97);
    10741056        if (err < 0)
     
    11861168}
    11871169
    1188 static int snd_fm801_free(struct fm801 *chip)
    1189 {
     1170static void snd_fm801_free(struct snd_card *card)
     1171{
     1172        struct fm801 *chip = card->private_data;
    11901173        unsigned short cmdw;
    1191 
    1192         if (chip->irq < 0)
    1193                 goto __end_hw;
    11941174
    11951175        /* interrupt setup - mask everything */
     
    11981178        fm801_writew(chip, IRQ_MASK, cmdw);
    11991179
    1200         devm_free_irq(chip->dev, chip->irq, chip);
    1201 
    1202       __end_hw:
    12031180#ifdef CONFIG_SND_FM801_TEA575X_BOOL
    12041181        if (!(chip->tea575x_tuner & TUNER_DISABLED)) {
     
    12071184        }
    12081185#endif
    1209         return 0;
    1210 }
    1211 
    1212 static int snd_fm801_dev_free(struct snd_device *device)
    1213 {
    1214         struct fm801 *chip = device->device_data;
    1215         return snd_fm801_free(chip);
    1216 }
     1186}
     1187
    12171188
    12181189static int snd_fm801_create(struct snd_card *card,
    12191190                            struct pci_dev *pci,
    12201191                            int tea575x_tuner,
    1221                             int radio_nr,
    1222                             struct fm801 **rchip)
    1223 {
    1224         struct fm801 *chip;
     1192                            int radio_nr)
     1193{
     1194        struct fm801 *chip = card->private_data;
    12251195        int err;
    1226         static const struct snd_device_ops ops = {
    1227                 .dev_free =     snd_fm801_dev_free,
    1228         };
    1229 
    1230         *rchip = NULL;
     1196
    12311197#ifndef TARGET_OS2
    12321198        err = pcim_enable_device(pci);
    12331199        if (err < 0)
    12341200                return err;
    1235         chip = devm_kzalloc(&pci->dev, sizeof(*chip), GFP_KERNEL);
    12361201#else
    12371202        if ((err = pci_enable_device(pci)) < 0)
    12381203                return err;
    1239         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
    12401204#endif
    1241         if (chip == NULL)
    1242                 return -ENOMEM;
    12431205        spin_lock_init(&chip->reg_lock);
    12441206        chip->card = card;
     
    12771239#endif
    12781240                        dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
    1279                         snd_fm801_free(chip);
    12801241                        return -EBUSY;
    12811242                }
     
    12851246        }
    12861247
     1248        card->private_free = snd_fm801_free;
    12871249        snd_fm801_chip_init(chip);
    1288 
    1289         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
    1290         if (err < 0) {
    1291                 snd_fm801_free(chip);
    1292                 return err;
    1293         }
    12941250
    12951251#ifdef CONFIG_SND_FM801_TEA575X_BOOL
    12961252        err = v4l2_device_register(&pci->dev, &chip->v4l2_dev);
    1297         if (err < 0) {
    1298                 snd_fm801_free(chip);
    1299                 return err;
    1300         }
     1253        if (err < 0)
     1254                return err;
    13011255        chip->tea.v4l2_dev = &chip->v4l2_dev;
    13021256        chip->tea.radio_nr = radio_nr;
     
    13081262                if (snd_tea575x_init(&chip->tea, THIS_MODULE)) {
    13091263                        dev_err(card->dev, "TEA575x radio not found\n");
    1310                         snd_fm801_free(chip);
    13111264                        return -ENODEV;
    13121265                }
     
    13361289        }
    13371290#endif
    1338 
    1339         *rchip = chip;
    1340         return 0;
    1341 }
    1342 
    1343 static int snd_card_fm801_probe(struct pci_dev *pci,
    1344                                 const struct pci_device_id *pci_id)
     1291        return 0;
     1292}
     1293
     1294static int __snd_card_fm801_probe(struct pci_dev *pci,
     1295                                  const struct pci_device_id *pci_id)
    13451296{
    13461297        static int dev;
     
    13571308        }
    13581309
    1359         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
    1360                            0, &card);
    1361         if (err < 0)
    1362                 return err;
    1363         err = snd_fm801_create(card, pci, tea575x_tuner[dev], radio_nr[dev], &chip);
    1364         if (err < 0) {
    1365                 snd_card_free(card);
    1366                 return err;
    1367         }
    1368         card->private_data = chip;
     1310        err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
     1311                                sizeof(*chip), &card);
     1312        if (err < 0)
     1313                return err;
     1314        chip = card->private_data;
     1315        err = snd_fm801_create(card, pci, tea575x_tuner[dev], radio_nr[dev]);
     1316        if (err < 0)
     1317                return err;
    13691318
    13701319        strcpy(card->driver, "FM801");
     
    13781327
    13791328        err = snd_fm801_pcm(chip, 0);
    1380         if (err < 0) {
    1381                 snd_card_free(card);
    1382                 return err;
    1383         }
     1329        if (err < 0)
     1330                return err;
    13841331        err = snd_fm801_mixer(chip);
    1385         if (err < 0) {
    1386                 snd_card_free(card);
    1387                 return err;
    1388         }
     1332        if (err < 0)
     1333                return err;
    13891334        err = snd_mpu401_uart_new(card, 0, MPU401_HW_FM801,
    13901335                                  chip->port + FM801_MPU401_DATA,
     
    13921337                                  MPU401_INFO_IRQ_HOOK,
    13931338                                  -1, &chip->rmidi);
    1394         if (err < 0) {
    1395                 snd_card_free(card);
    1396                 return err;
    1397         }
     1339        if (err < 0)
     1340                return err;
    13981341        err = snd_opl3_create(card, chip->port + FM801_OPL3_BANK0,
    13991342                              chip->port + FM801_OPL3_BANK1,
    14001343                              OPL3_HW_OPL3_FM801, 1, &opl3);
    1401         if (err < 0) {
    1402                 snd_card_free(card);
    1403                 return err;
    1404         }
     1344        if (err < 0)
     1345                return err;
    14051346        err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
    1406         if (err < 0) {
    1407                 snd_card_free(card);
    1408                 return err;
    1409         }
     1347        if (err < 0)
     1348                return err;
    14101349
    14111350      __fm801_tuner_only:
    14121351        err = snd_card_register(card);
    1413         if (err < 0) {
    1414                 snd_card_free(card);
    1415                 return err;
    1416         }
     1352        if (err < 0)
     1353                return err;
    14171354        pci_set_drvdata(pci, card);
    14181355        dev++;
     
    14201357}
    14211358
    1422 static void snd_card_fm801_remove(struct pci_dev *pci)
    1423 {
    1424         snd_card_free(pci_get_drvdata(pci));
     1359static int snd_card_fm801_probe(struct pci_dev *pci,
     1360                                const struct pci_device_id *pci_id)
     1361{
     1362        return snd_card_free_on_error(&pci->dev, __snd_card_fm801_probe(pci, pci_id));
    14251363}
    14261364
     
    14921430        .id_table = snd_fm801_ids,
    14931431        .probe = snd_card_fm801_probe,
    1494         .remove = snd_card_fm801_remove,
    14951432        .driver = {
    14961433                .pm = SND_FM801_PM_OPS,
Note: See TracChangeset for help on using the changeset viewer.