spin_lock_init(&chip->lock);    /* only now can we call ad1889_free */
 
        if (request_irq(pci->irq, snd_ad1889_interrupt,
-                       IRQF_SHARED, card->driver, chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                printk(KERN_ERR PFX "cannot obtain IRQ %d\n", pci->irq);
                snd_ad1889_free(chip);
                return -EBUSY;
 
        codec->port = pci_resource_start(codec->pci, 0);
 
        if (request_irq(codec->pci->irq, snd_ali_card_interrupt,
-                       IRQF_SHARED, "ALI 5451", codec)) {
+                       IRQF_SHARED, KBUILD_MODNAME, codec)) {
                snd_printk(KERN_ERR "Unable to request irq.\n");
                return -EBUSY;
        }
 
                irq_handler = snd_als300_interrupt;
 
        if (request_irq(pci->irq, irq_handler, IRQF_SHARED,
-                       card->shortname, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_als300_free(chip);
                return -EBUSY;
 
        }
 
        if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
-                       card->shortname, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_atiixp_free(chip);
                return -EBUSY;
 
        }
 
        if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
-                       card->shortname, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_atiixp_free(chip);
                return -EBUSY;
 
        }
 
        if ((err = request_irq(pci->irq, vortex_interrupt,
-                              IRQF_SHARED, CARD_NAME_SHORT,
+                              IRQF_SHARED, KBUILD_MODNAME,
                               chip)) != 0) {
                printk(KERN_ERR "cannot grab irq\n");
                goto irq_out;
 
        snd_aw2_saa7146_setup(&chip->saa7146, chip->iobase_virt);
 
        if (request_irq(pci->irq, snd_aw2_saa7146_interrupt,
-                       IRQF_SHARED, "Audiowerk2", chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                printk(KERN_ERR "aw2: Cannot grab irq %d\n", pci->irq);
 
                iounmap(chip->iobase_virt);
 
        codec_setup->name = "I2S_OUT";
 
        if (request_irq(pci->irq, snd_azf3328_interrupt,
-                       IRQF_SHARED, card->shortname, chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                err = -EBUSY;
                goto out_err;
 
        snd_bt87x_writel(chip, REG_INT_STAT, MY_INTERRUPTS);
 
        err = request_irq(pci->irq, snd_bt87x_interrupt, IRQF_SHARED,
-                         "Bt87x audio", chip);
+                         KBUILD_MODNAME, chip);
        if (err < 0) {
                snd_printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
                goto fail;
 
        }
 
        if (request_irq(pci->irq, snd_ca0106_interrupt,
-                       IRQF_SHARED, "snd_ca0106", chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                snd_ca0106_free(chip);
                printk(KERN_ERR "cannot grab irq\n");
                return -EBUSY;
 
        cm->iobase = pci_resource_start(pci, 0);
 
        if (request_irq(pci->irq, snd_cmipci_interrupt,
-                       IRQF_SHARED, card->driver, cm)) {
+                       IRQF_SHARED, KBUILD_MODNAME, cm)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_cmipci_free(cm);
                return -EBUSY;
 
        }
        
        if (request_irq(pci->irq, snd_cs4281_interrupt, IRQF_SHARED,
-                       "CS4281", chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_cs4281_free(chip);
                return -ENOMEM;
 
        }
 
        if (request_irq(pci->irq, snd_cs46xx_interrupt, IRQF_SHARED,
-                       "CS46XX", chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_cs46xx_free(chip);
                return -EBUSY;
 
        cs5535au->port = pci_resource_start(pci, 0);
 
        if (request_irq(pci->irq, snd_cs5535audio_interrupt,
-                       IRQF_SHARED, "CS5535 Audio", cs5535au)) {
+                       IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                err = -EBUSY;
                goto sndfail;
 
 
        if (hw->irq < 0) {
                err = request_irq(pci->irq, ct_20k1_interrupt, IRQF_SHARED,
-                                 "ctxfi", hw);
+                                 KBUILD_MODNAME, hw);
                if (err < 0) {
                        printk(KERN_ERR "XFi: Cannot get irq %d\n", pci->irq);
                        goto error2;
 
 
        if (hw->irq < 0) {
                err = request_irq(pci->irq, ct_20k2_interrupt, IRQF_SHARED,
-                                 "ctxfi", hw);
+                                 KBUILD_MODNAME, hw);
                if (err < 0) {
                        printk(KERN_ERR "XFi: Cannot get irq %d\n", pci->irq);
                        goto error2;
 
                ioremap_nocache(chip->dsp_registers_phys, sz);
 
        if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
-                       ECHOCARD_NAME, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_echo_free(chip);
                snd_printk(KERN_ERR "cannot grab irq\n");
                return -EBUSY;
        kfree(commpage_bak);
 
        if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
-                       ECHOCARD_NAME, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_echo_free(chip);
                snd_printk(KERN_ERR "cannot grab irq\n");
                return -EBUSY;
 
 
        /* irq handler must be registered after I/O ports are activated */
        if (request_irq(pci->irq, snd_emu10k1_interrupt, IRQF_SHARED,
-                       "EMU10K1", emu)) {
+                       KBUILD_MODNAME, emu)) {
                err = -EBUSY;
                goto error;
        }
 
        }
 
        if (request_irq(pci->irq, snd_emu10k1x_interrupt,
-                       IRQF_SHARED, "EMU10K1X", chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "emu10k1x: cannot grab irq %d\n", pci->irq);
                snd_emu10k1x_free(chip);
                return -EBUSY;
 
        }
        ensoniq->port = pci_resource_start(pci, 0);
        if (request_irq(pci->irq, snd_audiopci_interrupt, IRQF_SHARED,
-                       "Ensoniq AudioPCI", ensoniq)) {
+                       KBUILD_MODNAME, ensoniq)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_ensoniq_free(ensoniq);
                return -EBUSY;
 
        }
 
        if (request_irq(pci->irq, snd_es1938_interrupt,
-                       IRQF_SHARED, "ES1938", chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                printk(KERN_ERR "es1938: unable to grab IRQ %d, "
                       "disabling device\n", pci->irq);
                snd_card_disconnect(card);
        chip->mpu_port = pci_resource_start(pci, 3);
        chip->game_port = pci_resource_start(pci, 4);
        if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
-                       "ES1938", chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_es1938_free(chip);
                return -EBUSY;
 
        }
        chip->io_port = pci_resource_start(pci, 0);
        if (request_irq(pci->irq, snd_es1968_interrupt, IRQF_SHARED,
-                       "ESS Maestro", chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_es1968_free(chip);
                return -EBUSY;
 
        chip->port = pci_resource_start(pci, 0);
        if ((tea575x_tuner & TUNER_ONLY) == 0) {
                if (request_irq(pci->irq, snd_fm801_interrupt, IRQF_SHARED,
-                               "FM801", chip)) {
+                               KBUILD_MODNAME, chip)) {
                        snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->irq);
                        snd_fm801_free(chip);
                        return -EBUSY;
 
 {
        if (request_irq(chip->pci->irq, azx_interrupt,
                        chip->msi ? 0 : IRQF_SHARED,
-                       "hda_intel", chip)) {
+                       KBUILD_MODNAME, chip)) {
                printk(KERN_ERR "hda-intel: unable to grab IRQ %d, "
                       "disabling device\n", chip->pci->irq);
                if (do_disconnect)
 
        ice->profi_port = pci_resource_start(pci, 3);
 
        if (request_irq(pci->irq, snd_ice1712_interrupt, IRQF_SHARED,
-                       "ICE1712", ice)) {
+                       KBUILD_MODNAME, ice)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_ice1712_free(ice);
                return -EIO;
 
        ice->profi_port = pci_resource_start(pci, 1);
 
        if (request_irq(pci->irq, snd_vt1724_interrupt,
-                       IRQF_SHARED, "ICE1724", ice)) {
+                       IRQF_SHARED, KBUILD_MODNAME, ice)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_vt1724_free(ice);
                return -EIO;
 
        pci_set_master(pci);
        snd_intel8x0_chip_init(chip, 0);
        if (request_irq(pci->irq, snd_intel8x0_interrupt,
-                       IRQF_SHARED, card->shortname, chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                printk(KERN_ERR "intel8x0: unable to grab IRQ %d, "
                       "disabling device\n", pci->irq);
                snd_card_disconnect(card);
 
        /* request irq after initializaing int_sta_mask, etc */
        if (request_irq(pci->irq, snd_intel8x0_interrupt,
-                       IRQF_SHARED, card->shortname, chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_intel8x0_free(chip);
                return -EBUSY;
 
        }
        pci_set_master(pci);
        if (request_irq(pci->irq, snd_intel8x0m_interrupt,
-                       IRQF_SHARED, card->shortname, chip)) {
+                       IRQF_SHARED, KBUILD_MODNAME, chip)) {
                printk(KERN_ERR "intel8x0m: unable to grab IRQ %d, "
                       "disabling device\n", pci->irq);
                snd_card_disconnect(card);
 
  port_inited:
        if (request_irq(pci->irq, snd_intel8x0m_interrupt, IRQF_SHARED,
-                       card->shortname, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_intel8x0m_free(chip);
                return -EBUSY;
 
 
         err = request_irq(pci->irq, snd_korg1212_interrupt,
                           IRQF_SHARED,
-                          "korg1212", korg1212);
+                          KBUILD_MODNAME, korg1212);
 
         if (err) {
                snd_printk(KERN_ERR "korg1212: unable to grab IRQ %d\n", pci->irq);
 
                goto errout;
 
        if (request_irq(pci->irq, lola_interrupt, IRQF_SHARED,
-                       DRVNAME, chip)) {
+                       KBUILD_MODNAME, chip)) {
                printk(KERN_ERR SFX "unable to grab IRQ %d\n", pci->irq);
                err = -EBUSY;
                goto errout;
 
        chip->port_dsp_bar = pci_ioremap_bar(pci, 2);
 
        err = request_irq(pci->irq, lx_interrupt, IRQF_SHARED,
-                         card_name, chip);
+                         KBUILD_MODNAME, chip);
        if (err) {
                snd_printk(KERN_ERR LXP "unable to grab IRQ %d\n", pci->irq);
                goto request_irq_failed;
 
 #endif
 
        if (request_irq(pci->irq, snd_m3_interrupt, IRQF_SHARED,
-                       card->driver, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_m3_free(chip);
                return -ENOMEM;
 
        }
 
        if (request_irq(pci->irq, snd_mixart_interrupt, IRQF_SHARED,
-                       CARD_NAME, mgr)) {
+                       KBUILD_MODNAME, mgr)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_mixart_free(mgr);
                return -EBUSY;
 
        mutex_lock(&chip->irq_mutex);
        if (chip->irq < 0) {
                if (request_irq(chip->pci->irq, chip->interrupt, IRQF_SHARED,
-                               chip->card->driver, chip)) {
+                               KBUILD_MODNAME, chip)) {
                        snd_printk(KERN_ERR "unable to grab IRQ %d\n", chip->pci->irq);
                        mutex_unlock(&chip->irq_mutex);
                        return -EBUSY;
 
        chip->model.init(chip);
 
        err = request_irq(pci->irq, oxygen_interrupt, IRQF_SHARED,
-                         DRIVER, chip);
+                         KBUILD_MODNAME, chip);
        if (err < 0) {
                snd_printk(KERN_ERR "cannot grab interrupt %d\n", pci->irq);
                goto err_card;
 
        mgr->irq = -1;
 
        if (request_irq(pci->irq, pcxhr_interrupt, IRQF_SHARED,
-                       card_name, mgr)) {
+                       KBUILD_MODNAME, mgr)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                pcxhr_free(mgr);
                return -EBUSY;
 
        UNSET_AIE(hwport);
 
        if (request_irq(pci->irq, snd_riptide_interrupt, IRQF_SHARED,
-                       "RIPTIDE", chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "Riptide: unable to grab IRQ %d\n",
                           pci->irq);
                snd_riptide_free(chip);
 
        }
 
        if (request_irq(pci->irq, snd_rme32_interrupt, IRQF_SHARED,
-                       "RME32", rme32)) {
+                       KBUILD_MODNAME, rme32)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                return -EBUSY;
        }
 
        }
 
        if (request_irq(pci->irq, snd_rme96_interrupt, IRQF_SHARED,
-                       "RME96", rme96)) {
+                       KBUILD_MODNAME, rme96)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                return -EBUSY;
        }
 
        }
 
        if (request_irq(pci->irq, snd_hdsp_interrupt, IRQF_SHARED,
-                       "hdsp", hdsp)) {
+                       KBUILD_MODNAME, hdsp)) {
                snd_printk(KERN_ERR "Hammerfall-DSP: unable to use IRQ %d\n", pci->irq);
                return -EBUSY;
        }
 
                        hdspm->port + io_extent - 1);
 
        if (request_irq(pci->irq, snd_hdspm_interrupt,
-                               IRQF_SHARED, "hdspm", hdspm)) {
+                       IRQF_SHARED, KBUILD_MODNAME, hdspm)) {
                snd_printk(KERN_ERR "HDSPM: unable to use IRQ %d\n", pci->irq);
                return -EBUSY;
        }
 
        }
        
        if (request_irq(pci->irq, snd_rme9652_interrupt, IRQF_SHARED,
-                       "rme9652", rme9652)) {
+                       KBUILD_MODNAME, rme9652)) {
                snd_printk(KERN_ERR "unable to request IRQ %d\n", pci->irq);
                return -EBUSY;
        }
 
        }
 
        if (request_irq(pci->irq, sis_interrupt, IRQF_DISABLED|IRQF_SHARED,
-                               card->shortname, sis)) {
+                       KBUILD_MODNAME, sis)) {
                printk(KERN_ERR "sis7019: unable to regain IRQ %d\n", pci->irq);
                goto error;
        }
                goto error_out_cleanup;
 
        if (request_irq(pci->irq, sis_interrupt, IRQF_DISABLED|IRQF_SHARED,
-                               card->shortname, sis)) {
+                       KBUILD_MODNAME, sis)) {
                printk(KERN_ERR "unable to allocate irq %d\n", sis->irq);
                goto error_out_cleanup;
        }
 
        sonic->game_port = pci_resource_start(pci, 4);
 
        if (request_irq(pci->irq, snd_sonicvibes_interrupt, IRQF_SHARED,
-                       "S3 SonicVibes", sonic)) {
+                       KBUILD_MODNAME, sonic)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_sonicvibes_free(sonic);
                return -EBUSY;
 
        trident->port = pci_resource_start(pci, 0);
 
        if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
-                       "Trident Audio", trident)) {
+                       KBUILD_MODNAME, trident)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_trident_free(trident);
                return -EBUSY;
 
                        chip_type == TYPE_VIA8233 ?
                        snd_via8233_interrupt : snd_via686_interrupt,
                        IRQF_SHARED,
-                       card->driver, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_via82xx_free(chip);
                return -EBUSY;
 
        }
        chip->port = pci_resource_start(pci, 0);
        if (request_irq(pci->irq, snd_via82xx_interrupt, IRQF_SHARED,
-                       card->driver, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_via82xx_free(chip);
                return -EBUSY;
 
                vx->port[i] = pci_resource_start(pci, i + 1);
 
        if (request_irq(pci->irq, snd_vx_irq_handler, IRQF_SHARED,
-                       CARD_NAME, chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_vx222_free(chip);
                return -EBUSY;
 
                return -EBUSY;
        }
        if (request_irq(pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
-                       "YMFPCI", chip)) {
+                       KBUILD_MODNAME, chip)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_ymfpci_free(chip);
                return -EBUSY;