unsigned short hardware,
                      unsigned short hwshare,
                      struct snd_wss **rchip);
-int snd_wss_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm);
-int snd_wss_timer(struct snd_wss *chip, int device, struct snd_timer **rtimer);
+int snd_wss_pcm(struct snd_wss *chip, int device);
+int snd_wss_timer(struct snd_wss *chip, int device);
 int snd_wss_mixer(struct snd_wss *chip);
 
 const struct snd_pcm_ops *snd_wss_get_pcm_ops(int direction);
                      unsigned short hardware,
                      unsigned short hwshare,
                      struct snd_wss **rchip);
-int snd_cs4236_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm);
+int snd_cs4236_pcm(struct snd_wss *chip, int device);
 int snd_cs4236_mixer(struct snd_wss *chip);
 
 /*
 
 {
        struct snd_card *card;
        struct snd_wss *chip;
-       struct snd_pcm *pcm;
        int error;
 
        error = snd_card_new(dev, index[n], id[n], THIS_MODULE, 0, &card);
 
        card->private_data = chip;
 
-       error = snd_wss_pcm(chip, 0, &pcm);
+       error = snd_wss_pcm(chip, 0);
        if (error < 0)
                goto out;
 
                goto out;
 
        strcpy(card->driver, "AD1848");
-       strcpy(card->shortname, pcm->name);
+       strcpy(card->shortname, chip->pcm->name);
 
        sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
-               pcm->name, chip->port, irq[n], dma1[n]);
+               chip->pcm->name, chip->port, irq[n], dma1[n]);
        if (thinkpad[n])
                strcat(card->longname, " [Thinkpad]");
 
 
        sprintf(card->longname, "%s, WSS at 0x%lx, irq %i, dma %i&%i",
                card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]);
 
-       error = snd_wss_pcm(chip, 0, NULL);
+       error = snd_wss_pcm(chip, 0);
        if (error < 0) {
                snd_card_free(card);
                return error;
                snd_card_free(card);
                return error;
        }
-       error = snd_wss_timer(chip, 0, NULL);
+       error = snd_wss_timer(chip, 0);
        if (error < 0) {
                snd_card_free(card);
                return error;
 
        if (err < 0)
                goto error;
 
-       err = snd_wss_pcm(cmi->wss, 0, NULL);
+       err = snd_wss_pcm(cmi->wss, 0);
        if (err < 0)
                goto error;
 
        if (err < 0)
                goto error;
 
-       if (snd_wss_timer(cmi->wss, 0, NULL) < 0)
+       if (snd_wss_timer(cmi->wss, 0) < 0)
                snd_printk(KERN_WARNING "error initializing WSS timer\n");
 
        if (mpuport[ndev] == SNDRV_AUTO_PORT) {
 
 {
        struct snd_card *card;
        struct snd_wss *chip;
-       struct snd_pcm *pcm;
        int error;
 
        error = snd_card_new(dev, index[n], id[n], THIS_MODULE, 0, &card);
 
        card->private_data = chip;
 
-       error = snd_wss_pcm(chip, 0, &pcm);
+       error = snd_wss_pcm(chip, 0);
        if (error < 0)
                goto out;
 
        strcpy(card->driver, "CS4231");
-       strcpy(card->shortname, pcm->name);
+       strcpy(card->shortname, chip->pcm->name);
 
        sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
-               pcm->name, chip->port, irq[n], dma1[n]);
+               chip->pcm->name, chip->port, irq[n], dma1[n]);
        if (dma2[n] >= 0)
                sprintf(card->longname + strlen(card->longname), "&%d", dma2[n]);
 
        if (error < 0)
                goto out;
 
-       error = snd_wss_timer(chip, 0, NULL);
+       error = snd_wss_timer(chip, 0);
        if (error < 0)
                goto out;
 
 
 static int snd_cs423x_probe(struct snd_card *card, int dev)
 {
        struct snd_card_cs4236 *acard;
-       struct snd_pcm *pcm;
        struct snd_wss *chip;
        struct snd_opl3 *opl3;
        int err;
        acard->chip = chip;
        if (chip->hardware & WSS_HW_CS4236B_MASK) {
 
-               err = snd_cs4236_pcm(chip, 0, &pcm);
+               err = snd_cs4236_pcm(chip, 0);
                if (err < 0)
                        return err;
 
                if (err < 0)
                        return err;
        } else {
-               err = snd_wss_pcm(chip, 0, &pcm);
+               err = snd_wss_pcm(chip, 0);
                if (err < 0)
                        return err;
 
                if (err < 0)
                        return err;
        }
-       strcpy(card->driver, pcm->name);
-       strcpy(card->shortname, pcm->name);
+       strcpy(card->driver, chip->pcm->name);
+       strcpy(card->shortname, chip->pcm->name);
        sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i",
-               pcm->name,
+               chip->pcm->name,
                chip->port,
                irq[dev],
                dma1[dev]);
        if (dma2[dev] >= 0)
                sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
 
-       err = snd_wss_timer(chip, 0, NULL);
+       err = snd_wss_timer(chip, 0);
        if (err < 0)
                return err;
 
 
        return 0;
 }
 
-int snd_cs4236_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
+int snd_cs4236_pcm(struct snd_wss *chip, int device)
 {
-       struct snd_pcm *pcm;
        int err;
        
-       err = snd_wss_pcm(chip, device, &pcm);
+       err = snd_wss_pcm(chip, device);
        if (err < 0)
                return err;
-       pcm->info_flags &= ~SNDRV_PCM_INFO_JOINT_DUPLEX;
-       if (rpcm)
-               *rpcm = pcm;
+       chip->pcm->info_flags &= ~SNDRV_PCM_INFO_JOINT_DUPLEX;
        return 0;
 }
 
 
        if (err < 0)
                goto error;
 
-       err = snd_wss_pcm(chip, 0, NULL);
+       err = snd_wss_pcm(chip, 0);
        if (err < 0)
                goto error;
 
        if (err < 0)
                goto error;
 
-       err = snd_wss_timer(chip, 0, NULL);
+       err = snd_wss_timer(chip, 0);
        if (err < 0)
                goto error;
 
 
        if (err < 0)
                goto _err;
 
-       err = snd_wss_pcm(wss, 0, NULL);
+       err = snd_wss_pcm(wss, 0);
        if (err < 0)
                goto _err;
 
        if (err < 0)
                goto _err;
 
-       err = snd_wss_timer(wss, 2, NULL);
+       err = snd_wss_timer(wss, 2);
        if (err < 0)
                goto _err;
 
 
 #ifdef SNDRV_STB
        struct snd_i2c_bus *i2c_bus;
 #endif
-       struct snd_pcm *pcm;
        char *str;
        int err;
 
        if (err < 0)
                return err;
 
-       err = snd_wss_pcm(wss, 0, &pcm);
+       err = snd_wss_pcm(wss, 0);
        if (err < 0)
                return err;
 
-       sprintf(pcm->name + strlen(pcm->name), " rev %c", gus->revision + 'A');
-       strcat(pcm->name, " (codec)");
+       sprintf(wss->pcm->name + strlen(wss->pcm->name), " rev %c",
+               gus->revision + 'A');
+       strcat(wss->pcm->name, " (codec)");
 
-       err = snd_wss_timer(wss, 2, NULL);
+       err = snd_wss_timer(wss, 2);
        if (err < 0)
                return err;
 
 
                return err;
        }
        chip->wss = wss;
-       err = snd_wss_pcm(wss, 0, NULL);
+       err = snd_wss_pcm(wss, 0);
        if (err < 0)
                return err;
        err = snd_wss_mixer(wss);
        err = snd_opl3sa2_mixer(card);
        if (err < 0)
                return err;
-       err = snd_wss_timer(wss, 0, NULL);
+       err = snd_wss_timer(wss, 0);
        if (err < 0)
                return err;
        if (fm_port[dev] >= 0x340 && fm_port[dev] < 0x400) {
 
        int error;
        struct snd_miro *miro = card->private_data;
        struct snd_wss *codec;
-       struct snd_timer *timer;
-       struct snd_pcm *pcm;
        struct snd_rawmidi *rmidi;
 
        if (!miro->res_mc_base) {
        if (error < 0)
                return error;
 
-       error = snd_wss_pcm(codec, 0, &pcm);
+       error = snd_wss_pcm(codec, 0);
        if (error < 0)
                return error;
 
        if (error < 0)
                return error;
 
-       error = snd_wss_timer(codec, 0, &timer);
+       error = snd_wss_timer(codec, 0);
        if (error < 0)
                return error;
 
-       miro->pcm = pcm;
+       miro->pcm = codec->pcm;
 
        error = snd_miro_mixer(card, miro);
        if (error < 0)
 
        strcpy(card->driver, "miro");
        sprintf(card->longname, "%s: OPTi%s, %s at 0x%lx, irq %d, dma %d&%d",
-               card->shortname, miro->name, pcm->name, miro->wss_base + 4,
-               miro->irq, miro->dma1, miro->dma2);
+               card->shortname, miro->name, codec->pcm->name,
+               miro->wss_base + 4, miro->irq, miro->dma1, miro->dma2);
 
        if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT)
                rmidi = NULL;
 
        int xdma2;
        struct snd_opti9xx *chip = card->private_data;
        struct snd_wss *codec;
-#ifdef CS4231
-       struct snd_timer *timer;
-#endif
-       struct snd_pcm *pcm;
        struct snd_rawmidi *rmidi;
        struct snd_hwdep *synth;
 
        if (error < 0)
                return error;
        chip->codec = codec;
-       error = snd_wss_pcm(codec, 0, &pcm);
+       error = snd_wss_pcm(codec, 0);
        if (error < 0)
                return error;
        error = snd_wss_mixer(codec);
                return error;
 #endif
 #ifdef CS4231
-       error = snd_wss_timer(codec, 0, &timer);
+       error = snd_wss_timer(codec, 0);
        if (error < 0)
                return error;
 #endif
        sprintf(card->shortname, "OPTi %s", card->driver);
 #if defined(CS4231) || defined(OPTi93X)
        sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d&%d",
-               card->shortname, pcm->name,
+               card->shortname, codec->pcm->name,
                chip->wss_base + 4, irq, dma1, xdma2);
 #else
        sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d",
-               card->shortname, pcm->name, chip->wss_base + 4, irq, dma1);
+               card->shortname, codec->pcm->name, chip->wss_base + 4, irq,
+               dma1);
 #endif /* CS4231 || OPTi93X */
 
        if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT)
 
        if (err < 0)
                goto err_unmap2;
 
-       err = snd_wss_pcm(chip, 0, NULL);
+       err = snd_wss_pcm(chip, 0);
        if (err < 0) {
                snd_printk(KERN_ERR PFX
                           "error creating new WSS PCM device\n");
 
                             codec_type, WSS_HWSHARE_DMA1, &chip);
        if (!err) {
                unsigned long flags;
-               struct snd_pcm *pcm;
 
                if (sscape->type != SSCAPE_VIVO) {
                        /*
 
                }
 
-               err = snd_wss_pcm(chip, 0, &pcm);
+               err = snd_wss_pcm(chip, 0);
                if (err < 0) {
                        snd_printk(KERN_ERR "sscape: No PCM device "
                                            "for AD1845 chip\n");
                        goto _error;
                }
                if (chip->hardware != WSS_HW_AD1848) {
-                       err = snd_wss_timer(chip, 0, NULL);
+                       err = snd_wss_timer(chip, 0);
                        if (err < 0) {
                                snd_printk(KERN_ERR "sscape: No timer device "
                                                    "for AD1845 chip\n");
 
                return err;
        }
 
-       err = snd_wss_pcm(chip, 0, NULL);
+       err = snd_wss_pcm(chip, 0);
        if (err < 0)
                return err;
 
-       err = snd_wss_timer(chip, 0, NULL);
+       err = snd_wss_timer(chip, 0);
        if (err < 0)
                return err;
 
 
        .pointer =      snd_wss_capture_pointer,
 };
 
-int snd_wss_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
+int snd_wss_pcm(struct snd_wss *chip, int device)
 {
        struct snd_pcm *pcm;
        int err;
                                              64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 
        chip->pcm = pcm;
-       if (rpcm)
-               *rpcm = pcm;
        return 0;
 }
 EXPORT_SYMBOL(snd_wss_pcm);
        chip->timer = NULL;
 }
 
-int snd_wss_timer(struct snd_wss *chip, int device, struct snd_timer **rtimer)
+int snd_wss_timer(struct snd_wss *chip, int device)
 {
        struct snd_timer *timer;
        struct snd_timer_id tid;
        timer->private_free = snd_wss_timer_free;
        timer->hw = snd_wss_timer_table;
        chip->timer = timer;
-       if (rtimer)
-               *rtimer = timer;
        return 0;
 }
 EXPORT_SYMBOL(snd_wss_timer);