tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ALSA: Convert to snd_card_create() in sound/isa/*

Convert from snd_card_new() to the new snd_card_create() function.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

authored by

Takashi Iwai and committed by
Takashi Iwai c95eadd2 53fb1e63

+122 -100
+4 -3
sound/isa/ad1816a/ad1816a.c
··· 157 157 struct snd_ad1816a *chip; 158 158 struct snd_opl3 *opl3; 159 159 160 - if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, 161 - sizeof(struct snd_card_ad1816a))) == NULL) 162 - return -ENOMEM; 160 + error = snd_card_create(index[dev], id[dev], THIS_MODULE, 161 + sizeof(struct snd_card_ad1816a), &card); 162 + if (error < 0) 163 + return error; 163 164 acard = (struct snd_card_ad1816a *)card->private_data; 164 165 165 166 if ((error = snd_card_ad1816a_pnp(dev, acard, pcard, pid))) {
+3 -3
sound/isa/ad1848/ad1848.c
··· 91 91 struct snd_pcm *pcm; 92 92 int error; 93 93 94 - card = snd_card_new(index[n], id[n], THIS_MODULE, 0); 95 - if (!card) 96 - return -EINVAL; 94 + error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card); 95 + if (error < 0) 96 + return error; 97 97 98 98 error = snd_wss_create(card, port[n], -1, irq[n], dma1[n], -1, 99 99 thinkpad[n] ? WSS_HW_THINKPAD : WSS_HW_DETECT,
+3 -3
sound/isa/adlib.c
··· 53 53 struct snd_opl3 *opl3; 54 54 int error; 55 55 56 - card = snd_card_new(index[n], id[n], THIS_MODULE, 0); 57 - if (!card) { 56 + error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card); 57 + if (error < 0) { 58 58 dev_err(dev, "could not create card\n"); 59 - return -EINVAL; 59 + return error; 60 60 } 61 61 62 62 card->private_data = request_region(port[n], 4, CRD_NAME);
+4 -3
sound/isa/als100.c
··· 163 163 struct snd_card_als100 *acard; 164 164 struct snd_opl3 *opl3; 165 165 166 - if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, 167 - sizeof(struct snd_card_als100))) == NULL) 168 - return -ENOMEM; 166 + error = snd_card_create(index[dev], id[dev], THIS_MODULE, 167 + sizeof(struct snd_card_als100), &card); 168 + if (error < 0) 169 + return error; 169 170 acard = card->private_data; 170 171 171 172 if ((error = snd_card_als100_pnp(dev, acard, pcard, pid))) {
+4 -3
sound/isa/azt2320.c
··· 184 184 struct snd_wss *chip; 185 185 struct snd_opl3 *opl3; 186 186 187 - if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, 188 - sizeof(struct snd_card_azt2320))) == NULL) 189 - return -ENOMEM; 187 + error = snd_card_create(index[dev], id[dev], THIS_MODULE, 188 + sizeof(struct snd_card_azt2320), &card); 189 + if (error < 0) 190 + return error; 190 191 acard = (struct snd_card_azt2320 *)card->private_data; 191 192 192 193 if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
+14 -12
sound/isa/cmi8330.c
··· 467 467 468 468 #define PFX "cmi8330: " 469 469 470 - static struct snd_card *snd_cmi8330_card_new(int dev) 470 + static int snd_cmi8330_card_new(int dev, struct snd_card **cardp) 471 471 { 472 472 struct snd_card *card; 473 473 struct snd_cmi8330 *acard; 474 + int err; 474 475 475 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 476 - sizeof(struct snd_cmi8330)); 477 - if (card == NULL) { 476 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 477 + sizeof(struct snd_cmi8330), &card); 478 + if (err < 0) { 478 479 snd_printk(KERN_ERR PFX "could not get a new card\n"); 479 - return NULL; 480 + return err; 480 481 } 481 482 acard = card->private_data; 482 483 acard->card = card; 483 - return card; 484 + *cardp = card; 485 + return 0; 484 486 } 485 487 486 488 static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) ··· 566 564 struct snd_card *card; 567 565 int err; 568 566 569 - card = snd_cmi8330_card_new(dev); 570 - if (! card) 571 - return -ENOMEM; 567 + err = snd_cmi8330_card_new(dev, &card); 568 + if (err < 0) 569 + return err; 572 570 snd_card_set_dev(card, pdev); 573 571 if ((err = snd_cmi8330_probe(card, dev)) < 0) { 574 572 snd_card_free(card); ··· 630 628 if (dev >= SNDRV_CARDS) 631 629 return -ENODEV; 632 630 633 - card = snd_cmi8330_card_new(dev); 634 - if (! card) 635 - return -ENOMEM; 631 + res = snd_cmi8330_card_new(dev, &card); 632 + if (res < 0) 633 + return res; 636 634 if ((res = snd_cmi8330_pnp(dev, card->private_data, pcard, pid)) < 0) { 637 635 snd_printk(KERN_ERR PFX "PnP detection failed\n"); 638 636 snd_card_free(card);
+3 -3
sound/isa/cs423x/cs4231.c
··· 95 95 struct snd_pcm *pcm; 96 96 int error; 97 97 98 - card = snd_card_new(index[n], id[n], THIS_MODULE, 0); 99 - if (!card) 100 - return -EINVAL; 98 + error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card); 99 + if (error < 0) 100 + return error; 101 101 102 102 error = snd_wss_create(card, port[n], -1, irq[n], dma1[n], dma2[n], 103 103 WSS_HW_DETECT, 0, &chip);
+4 -3
sound/isa/cs423x/cs4236.c
··· 385 385 static struct snd_card *snd_cs423x_card_new(int dev) 386 386 { 387 387 struct snd_card *card; 388 + int err; 388 389 389 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 390 - sizeof(struct snd_card_cs4236)); 391 - if (card == NULL) 390 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 391 + sizeof(struct snd_card_cs4236), &card); 392 + if (err < 0) 392 393 return NULL; 393 394 card->private_free = snd_card_cs4236_free; 394 395 return card;
+4 -3
sound/isa/dt019x.c
··· 150 150 struct snd_card_dt019x *acard; 151 151 struct snd_opl3 *opl3; 152 152 153 - if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, 154 - sizeof(struct snd_card_dt019x))) == NULL) 155 - return -ENOMEM; 153 + error = snd_card_create(index[dev], id[dev], THIS_MODULE, 154 + sizeof(struct snd_card_dt019x), &card); 155 + if (error < 0) 156 + return error; 156 157 acard = card->private_data; 157 158 158 159 snd_card_set_dev(card, &pcard->card->dev);
+3 -3
sound/isa/es1688/es1688.c
··· 122 122 struct snd_pcm *pcm; 123 123 int error; 124 124 125 - card = snd_card_new(index[n], id[n], THIS_MODULE, 0); 126 - if (!card) 127 - return -EINVAL; 125 + error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card); 126 + if (error < 0) 127 + return error; 128 128 129 129 error = snd_es1688_legacy_create(card, dev, n, &chip); 130 130 if (error < 0)
+5 -2
sound/isa/es18xx.c
··· 2127 2127 2128 2128 static struct snd_card *snd_es18xx_card_new(int dev) 2129 2129 { 2130 - return snd_card_new(index[dev], id[dev], THIS_MODULE, 2131 - sizeof(struct snd_audiodrive)); 2130 + struct snd_card *card; 2131 + if (snd_card_create(index[dev], id[dev], THIS_MODULE, 2132 + sizeof(struct snd_audiodrive), &card) < 0) 2133 + return NULL; 2134 + return card; 2132 2135 } 2133 2136 2134 2137 static int __devinit snd_audiodrive_probe(struct snd_card *card, int dev)
+3 -3
sound/isa/gus/gusclassic.c
··· 148 148 struct snd_gus_card *gus; 149 149 int error; 150 150 151 - card = snd_card_new(index[n], id[n], THIS_MODULE, 0); 152 - if (!card) 153 - return -EINVAL; 151 + error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card); 152 + if (error < 0) 153 + return error; 154 154 155 155 if (pcm_channels[n] < 2) 156 156 pcm_channels[n] = 2;
+3 -3
sound/isa/gus/gusextreme.c
··· 241 241 struct snd_opl3 *opl3; 242 242 int error; 243 243 244 - card = snd_card_new(index[n], id[n], THIS_MODULE, 0); 245 - if (!card) 246 - return -EINVAL; 244 + error = snd_card_create(index[n], id[n], THIS_MODULE, 0, &card); 245 + if (error < 0) 246 + return error; 247 247 248 248 if (mpu_port[n] == SNDRV_AUTO_PORT) 249 249 mpu_port[n] = 0;
+4 -4
sound/isa/gus/gusmax.c
··· 214 214 struct snd_wss *wss; 215 215 struct snd_gusmax *maxcard; 216 216 217 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 218 - sizeof(struct snd_gusmax)); 219 - if (card == NULL) 220 - return -ENOMEM; 217 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 218 + sizeof(struct snd_gusmax), &card); 219 + if (err < 0) 220 + return err; 221 221 card->private_free = snd_gusmax_free; 222 222 maxcard = (struct snd_gusmax *)card->private_data; 223 223 maxcard->card = card;
+4 -3
sound/isa/gus/interwave.c
··· 630 630 { 631 631 struct snd_card *card; 632 632 struct snd_interwave *iwcard; 633 + int err; 633 634 634 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 635 - sizeof(struct snd_interwave)); 636 - if (card == NULL) 635 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 636 + sizeof(struct snd_interwave), &card); 637 + if (err < 0) 637 638 return NULL; 638 639 iwcard = card->private_data; 639 640 iwcard->card = card;
+17 -14
sound/isa/opl3sa2.c
··· 617 617 release_and_free_resource(chip->res_port); 618 618 } 619 619 620 - static struct snd_card *snd_opl3sa2_card_new(int dev) 620 + static int snd_opl3sa2_card_new(int dev, struct snd_card **cardp) 621 621 { 622 622 struct snd_card *card; 623 623 struct snd_opl3sa2 *chip; 624 + int err; 624 625 625 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_opl3sa2)); 626 - if (card == NULL) 627 - return NULL; 626 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 627 + sizeof(struct snd_opl3sa2), &card); 628 + if (err < 0) 629 + return err; 628 630 strcpy(card->driver, "OPL3SA2"); 629 631 strcpy(card->shortname, "Yamaha OPL3-SA2"); 630 632 chip = card->private_data; 631 633 spin_lock_init(&chip->reg_lock); 632 634 chip->irq = -1; 633 635 card->private_free = snd_opl3sa2_free; 634 - return card; 636 + *cardp = card; 637 + return 0; 635 638 } 636 639 637 640 static int __devinit snd_opl3sa2_probe(struct snd_card *card, int dev) ··· 726 723 if (dev >= SNDRV_CARDS) 727 724 return -ENODEV; 728 725 729 - card = snd_opl3sa2_card_new(dev); 730 - if (! card) 731 - return -ENOMEM; 726 + err = snd_opl3sa2_card_new(dev, &card); 727 + if (err < 0) 728 + return err; 732 729 if ((err = snd_opl3sa2_pnp(dev, card->private_data, pdev)) < 0) { 733 730 snd_card_free(card); 734 731 return err; ··· 792 789 if (dev >= SNDRV_CARDS) 793 790 return -ENODEV; 794 791 795 - card = snd_opl3sa2_card_new(dev); 796 - if (! card) 797 - return -ENOMEM; 792 + err = snd_opl3sa2_card_new(dev, &card); 793 + if (err < 0) 794 + return err; 798 795 if ((err = snd_opl3sa2_pnp(dev, card->private_data, pdev)) < 0) { 799 796 snd_card_free(card); 800 797 return err; ··· 873 870 struct snd_card *card; 874 871 int err; 875 872 876 - card = snd_opl3sa2_card_new(dev); 877 - if (! card) 878 - return -ENOMEM; 873 + err = snd_opl3sa2_card_new(dev, &card); 874 + if (err < 0) 875 + return err; 879 876 snd_card_set_dev(card, pdev); 880 877 if ((err = snd_opl3sa2_probe(card, dev)) < 0) { 881 878 snd_card_free(card);
+4 -3
sound/isa/opti9xx/miro.c
··· 1228 1228 struct snd_pcm *pcm; 1229 1229 struct snd_rawmidi *rmidi; 1230 1230 1231 - if (!(card = snd_card_new(index, id, THIS_MODULE, 1232 - sizeof(struct snd_miro)))) 1233 - return -ENOMEM; 1231 + error = snd_card_create(index, id, THIS_MODULE, 1232 + sizeof(struct snd_miro), &card); 1233 + if (error < 0) 1234 + return error; 1234 1235 1235 1236 card->private_free = snd_card_miro_free; 1236 1237 miro = card->private_data;
+4 -2
sound/isa/opti9xx/opti92x-ad1848.c
··· 833 833 static struct snd_card *snd_opti9xx_card_new(void) 834 834 { 835 835 struct snd_card *card; 836 + int err; 836 837 837 - card = snd_card_new(index, id, THIS_MODULE, sizeof(struct snd_opti9xx)); 838 - if (! card) 838 + err = snd_card_create(index, id, THIS_MODULE, 839 + sizeof(struct snd_opti9xx), &card); 840 + if (err < 0) 839 841 return NULL; 840 842 card->private_free = snd_card_opti9xx_free; 841 843 return card;
+4 -3
sound/isa/sb/es968.c
··· 108 108 struct snd_card *card; 109 109 struct snd_card_es968 *acard; 110 110 111 - if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, 112 - sizeof(struct snd_card_es968))) == NULL) 113 - return -ENOMEM; 111 + error = snd_card_create(index[dev], id[dev], THIS_MODULE, 112 + sizeof(struct snd_card_es968), &card); 113 + if (error < 0) 114 + return error; 114 115 acard = card->private_data; 115 116 if ((error = snd_card_es968_pnp(dev, acard, pcard, pid))) { 116 117 snd_card_free(card);
+6 -3
sound/isa/sb/sb16.c
··· 326 326 327 327 static struct snd_card *snd_sb16_card_new(int dev) 328 328 { 329 - struct snd_card *card = snd_card_new(index[dev], id[dev], THIS_MODULE, 330 - sizeof(struct snd_card_sb16)); 331 - if (card == NULL) 329 + struct snd_card *card; 330 + int err; 331 + 332 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 333 + sizeof(struct snd_card_sb16), &card); 334 + if (err < 0) 332 335 return NULL; 333 336 card->private_free = snd_sb16_free; 334 337 return card;
+4 -4
sound/isa/sb/sb8.c
··· 103 103 struct snd_opl3 *opl3; 104 104 int err; 105 105 106 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 107 - sizeof(struct snd_sb8)); 108 - if (card == NULL) 109 - return -ENOMEM; 106 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 107 + sizeof(struct snd_sb8), &card); 108 + if (err < 0) 109 + return err; 110 110 acard = card->private_data; 111 111 card->private_free = snd_sb8_free; 112 112
+3 -3
sound/isa/sc6000.c
··· 489 489 char __iomem *vmss_port; 490 490 491 491 492 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 493 - if (!card) 494 - return -ENOMEM; 492 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card); 493 + if (err < 0) 494 + return err; 495 495 496 496 if (xirq == SNDRV_AUTO_IRQ) { 497 497 xirq = snd_legacy_find_free_irq(possible_irqs);
+3 -3
sound/isa/sgalaxy.c
··· 243 243 struct snd_card *card; 244 244 struct snd_wss *chip; 245 245 246 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 247 - if (card == NULL) 248 - return -ENOMEM; 246 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card); 247 + if (err < 0) 248 + return err; 249 249 250 250 xirq = irq[dev]; 251 251 if (xirq == SNDRV_AUTO_IRQ) {
+8 -8
sound/isa/sscape.c
··· 1357 1357 struct soundscape *sscape; 1358 1358 int ret; 1359 1359 1360 - card = snd_card_new(index[dev], id[dev], THIS_MODULE, 1361 - sizeof(struct soundscape)); 1362 - if (!card) 1363 - return -ENOMEM; 1360 + ret = snd_card_create(index[dev], id[dev], THIS_MODULE, 1361 + sizeof(struct soundscape), &card); 1362 + if (ret < 0) 1363 + return ret; 1364 1364 1365 1365 sscape = get_card_soundscape(card); 1366 1366 sscape->type = SSCAPE; ··· 1462 1462 * Create a new ALSA sound card entry, in anticipation 1463 1463 * of detecting our hardware ... 1464 1464 */ 1465 - card = snd_card_new(index[idx], id[idx], THIS_MODULE, 1466 - sizeof(struct soundscape)); 1467 - if (!card) 1468 - return -ENOMEM; 1465 + ret = snd_card_create(index[idx], id[idx], THIS_MODULE, 1466 + sizeof(struct soundscape), &card); 1467 + if (ret < 0) 1468 + return ret; 1469 1469 1470 1470 sscape = get_card_soundscape(card); 1471 1471
+4 -3
sound/isa/wavefront/wavefront.c
··· 342 342 { 343 343 struct snd_card *card; 344 344 snd_wavefront_card_t *acard; 345 + int err; 345 346 346 - card = snd_card_new (index[dev], id[dev], THIS_MODULE, 347 - sizeof(snd_wavefront_card_t)); 348 - if (card == NULL) 347 + err = snd_card_create(index[dev], id[dev], THIS_MODULE, 348 + sizeof(snd_wavefront_card_t), &card); 349 + if (err < 0) 349 350 return NULL; 350 351 351 352 acard = card->private_data;