chip->csubs = NULL;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                               snd_dma_pci_data(chip->pci),
-                                               BUFFER_BYTES_MAX / 2,
-                                               BUFFER_BYTES_MAX);
+                                             &chip->pci->dev,
+                                             BUFFER_BYTES_MAX / 2,
+                                             BUFFER_BYTES_MAX);
 
        return 0;
 }
 
                                desc->capture_ops);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(codec->pci),
+                                             &codec->pci->dev,
                                              64*1024, 128*1024);
 
        pcm->info_flags = 0;
 
 
        /* pre-allocation of buffers */
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-       snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 64*1024);
        return 0;
 }
 
 
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_als4000_playback_ops);
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_als4000_capture_ops);
 
-       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                             &chip->pci->dev,
                                              64*1024, 64*1024);
 
        chip->pcm = pcm;
 
        /*? do we want to emulate MMAP for non-BBM cards?
        Jack doesn't work with ALSAs MMAP emulation - WHY NOT? */
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                               snd_dma_pci_data(asihpi->pci),
-                                               64*1024, BUFFER_BYTES_MAX);
+                                             &asihpi->pci->dev,
+                                             64*1024, BUFFER_BYTES_MAX);
 
        return 0;
 }
 
 
        if (dma->desc_buf.area == NULL) {
                if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                       snd_dma_pci_data(chip->pci),
+                                       &chip->pci->dev,
                                        ATI_DESC_LIST_SIZE,
                                        &dma->desc_buf) < 0)
                        return -ENOMEM;
        chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, 128*1024);
 
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
        chip->pcmdevs[ATI_PCMDEV_DIGITAL] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, 128*1024);
 
        /* pre-select AC97 SPDIF slots 10/11 */
 
                return -ENOMEM;
 
        if (dma->desc_buf.area == NULL) {
-               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                        ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0)
                        return -ENOMEM;
                dma->period_bytes = dma->periods = 0; /* clear */
        chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, 128*1024);
 
        return 0;
 
        /* pre-allocation of Scatter-Gather buffers */
        
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci_dev),
+                                             &chip->pci_dev,
                                              0x10000, 0x10000);
 
        switch (VORTEX_PCM_TYPE(pcm)) {
 
        /* Preallocate continuous pages. */
        snd_pcm_lib_preallocate_pages_for_all(pcm_playback_ana,
                                              SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64 * 1024, 64 * 1024);
 
        err = snd_pcm_new(chip->card, "Audiowerk2 digital playback", 1, 1, 0,
        /* Preallocate continuous pages. */
        snd_pcm_lib_preallocate_pages_for_all(pcm_playback_num,
                                              SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64 * 1024, 64 * 1024);
 
        err = snd_pcm_new(chip->card, "Audiowerk2 capture", 2, 0, 1,
        /* Preallocate continuous pages. */
        snd_pcm_lib_preallocate_pages_for_all(pcm_capture,
                                              SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64 * 1024, 64 * 1024);
 
        /* Create control */
 
        chip->pcm[AZF_CODEC_CAPTURE] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                               snd_dma_pci_data(chip->pci),
-                                                       64*1024, 64*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 64*1024);
 
        err = snd_pcm_new(chip->card, "AZF3328 I2S OUT", AZF_PCMDEV_I2S_OUT,
                                                                1, 0, &pcm);
        chip->pcm[AZF_CODEC_I2S_OUT] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                               snd_dma_pci_data(chip->pci),
-                                                       64*1024, 64*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 64*1024);
 
        return 0;
 }
 
        __le32 *risc;
 
        if (chip->dma_risc.area == NULL) {
-               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                        PAGE_ALIGN(MAX_RISC_SIZE), &chip->dma_risc) < 0)
                        return -ENOMEM;
        }
        strcpy(pcm->name, name);
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_bt87x_pcm_ops);
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              128 * 1024,
                                              ALIGN(255 * 4092, 1024));
        return 0;
 
            substream; 
            substream = substream->next) {
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
        }
 
              substream; 
              substream = substream->next) {
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
        }
   
        chip->irq = pci->irq;
 
        /* This stores the periods table. */
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                1024, &chip->buffer) < 0) {
                snd_ca0106_free(chip);
                return -ENOMEM;
 
        cm->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(cm->pci), 64*1024, 128*1024);
+                                             &cm->pci->dev, 64*1024, 128*1024);
 
        return 0;
 }
        cm->pcm2 = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(cm->pci), 64*1024, 128*1024);
+                                             &cm->pci->dev, 64*1024, 128*1024);
 
        return 0;
 }
        cm->pcm_spdif = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(cm->pci), 64*1024, 128*1024);
+                                             &cm->pci->dev, 64*1024, 128*1024);
 
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                     snd_pcm_alt_chmaps, cm->max_channels, 0,
 
        chip->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 512*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 512*1024);
 
        return 0;
 }
 
        cpcm = kzalloc(sizeof(*cpcm), GFP_KERNEL);
        if (cpcm == NULL)
                return -ENOMEM;
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                PAGE_SIZE, &cpcm->hw_buf) < 0) {
                kfree(cpcm);
                return -ENOMEM;
 {
        struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
 
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                PAGE_SIZE, &chip->capt.hw_buf) < 0)
                return -ENOMEM;
        chip->capt.substream = substream;
        chip->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return 0;
 }
        chip->pcm_rear = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return 0;
 }
        chip->pcm_center_lfe = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return 0;
 }
        chip->pcm_iec958 = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return 0;
 }
 
 
        if (dma->desc_buf.area == NULL) {
                if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                       snd_dma_pci_data(cs5535au->pci),
+                                       &cs5535au->pci->dev,
                                        CS5535AUDIO_DESC_LIST_SIZE+1,
                                        &dma->desc_buf) < 0)
                        return -ENOMEM;
        strcpy(pcm->name, "CS5535 Audio");
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                       snd_dma_pci_data(cs5535au->pci),
-                                       64*1024, 128*1024);
+                                             &cs5535au->pci->dev,
+                                             64*1024, 128*1024);
        cs5535au->pcm = pcm;
 
        return 0;
 
                                SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                       snd_dma_pci_data(atc->pci), 128*1024, 128*1024);
+                                             &atc->pci->dev,
+                                             128*1024, 128*1024);
 
        chs = 2;
        switch (device) {
 
        /* Allocate page table pages */
        for (i = 0; i < CT_PTP_NUM; i++) {
                err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                         snd_dma_pci_data(pci),
+                                         &pci->dev,
                                          PAGE_SIZE, &vm->ptp[i]);
                if (err < 0)
                        break;
 
                goto error;
        /* This stores the periods table. */
        if (emu->card_capabilities->ca0151_chip) { /* P16V */   
-               if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
-                                              1024, &emu->p16v_buffer)) < 0)
+               err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
+                                         1024, &emu->p16v_buffer);
+               if (err < 0)
                        goto error;
        }
 
 
        emu->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci), 
+                                             &emu->pci->dev,
                                              32*1024, 32*1024);
   
        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
        }
        chip->irq = pci->irq;
   
-       if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
-                              4 * 1024, &chip->dma_buffer) < 0) {
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
+                               4 * 1024, &chip->dma_buffer) < 0) {
                snd_emu10k1x_free(chip);
                return -ENOMEM;
        }
 
        }
 
        if (size > 0) {
-               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci),
+               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &emu->pci->dev,
                                        size * 2, &emu->fx8010.etram_pages) < 0)
                        return -ENOMEM;
                memset(emu->fx8010.etram_pages.area, 0, size * 2);
 
 
        for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
 
        for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next)
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
 
        return 0;
 
        for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
 
        return 0;
        emu->pcm_mic = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
 
        return 0;
                return err;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              64*1024, 64*1024);
 
        return 0;
 
        }
 
        return snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                  snd_dma_pci_data(emu->pci), size, dmab);
+                                  &emu->pci->dev, size, dmab);
 }
 
 /*
        int page;
 
        dmab.dev.type = SNDRV_DMA_TYPE_DEV;
-       dmab.dev.dev = snd_dma_pci_data(emu->pci);
+       dmab.dev.dev = &emu->pci->dev;
 
        for (page = first_page; page <= last_page; page++) {
                if (emu->page_ptr_table[page] == NULL)
 
            substream; 
            substream = substream->next) {
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              (65536 - 64) * 8,
                                              (65536 - 64) * 8);
                /*
              substream; 
              substream = substream->next) {
                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(emu->pci),
+                                             &emu->pci->dev,
                                              65536 - 64, 65536 - 64);
                /*
                dev_dbg(emu->card->dev,
 
        ensoniq->pcm1 = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ensoniq->pci), 64*1024, 128*1024);
+                                             &ensoniq->pci->dev,
+                                             64*1024, 128*1024);
 
 #ifdef CHIP1370
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
        ensoniq->pcm2 = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ensoniq->pci), 64*1024, 128*1024);
+                                             &ensoniq->pci->dev,
+                                             64*1024, 128*1024);
 
 #ifdef CHIP1370
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
        }
        ensoniq->irq = pci->irq;
 #ifdef CHIP1370
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                16, &ensoniq->dma_bug) < 0) {
                dev_err(card->dev, "unable to allocate space for phantom area - dma_bug\n");
                snd_ensoniq_free(ensoniq);
 
        strcpy(pcm->name, "ESS Solo-1");
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 64*1024);
 
        chip->pcm = pcm;
        return 0;
 
        chip->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(pdev),
+                                             &pdev->dev,
                                              chip->multichannel ? 128*1024 : 64*1024, 128*1024);
 
        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 
        ice->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ice->pci), 64*1024, 64*1024);
+                                             &ice->pci->dev,
+                                             64*1024, 64*1024);
 
        dev_warn(ice->card->dev,
                 "Consumer PCM code does not work well at the moment --jk\n");
        ice->pcm_ds = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ice->pci), 64*1024, 128*1024);
+                                             &ice->pci->dev,
+                                             64*1024, 128*1024);
 
        return 0;
 }
        strcpy(pcm->name, "ICE1712 multi");
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ice->pci), 256*1024, 256*1024);
+                                             &ice->pci->dev,
+                                             256*1024, 256*1024);
 
        ice->pcm_pro = pcm;
 
 
        strcpy(pcm->name, "ICE1724");
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ice->pci),
+                                             &ice->pci->dev,
                                              256*1024, 256*1024);
 
        ice->pcm_pro = pcm;
        strcpy(pcm->name, name);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ice->pci),
+                                             &ice->pci->dev,
                                              256*1024, 256*1024);
 
        ice->pcm = pcm;
        strcpy(pcm->name, "ICE1724 Surround PCM");
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(ice->pci),
+                                             &ice->pci->dev,
                                              256*1024, 256*1024);
 
        ice->pcm_ds = pcm;
 
        chip->pcm[device] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, intel8x0_dma_type(chip),
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              rec->prealloc_size, rec->prealloc_max_size);
 
        if (rec->playback_ops &&
 
        /* allocate buffer descriptor lists */
        /* the start of each lists must be aligned to 8 bytes */
-       if (snd_dma_alloc_pages(intel8x0_dma_type(chip), snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(intel8x0_dma_type(chip), &pci->dev,
                                chip->bdbars_count * sizeof(u32) * ICH_MAX_FRAGS * 2,
                                &chip->bdbars) < 0) {
                snd_intel8x0_free(chip);
 
        chip->pcm[device] = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              rec->prealloc_size,
                                              rec->prealloc_max_size);
 
 
        /* allocate buffer descriptor lists */
        /* the start of each lists must be aligned to 8 bytes */
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                chip->bdbars_count * sizeof(u32) * ICH_MAX_FRAGS * 2,
                                &chip->bdbars) < 0) {
                snd_intel8x0m_free(chip);
 
                    korg1212->idRegPtr,
                   stateName[korg1212->cardState]);
 
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                sizeof(struct KorgSharedBuffer), &korg1212->dma_shared) < 0) {
                snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%zd bytes)\n", sizeof(struct KorgSharedBuffer));
                 snd_korg1212_free(korg1212);
 
         korg1212->DataBufsSize = sizeof(struct KorgAudioBuffer) * kNumBuffers;
 
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                korg1212->DataBufsSize, &korg1212->dma_play) < 0) {
                snd_printk(KERN_ERR "korg1212: can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
                 snd_korg1212_free(korg1212);
         K1212_DEBUG_PRINTK("K1212_DEBUG: Play Data Area = 0x%p (0x%08x), %d bytes\n",
                korg1212->playDataBufsPtr, korg1212->PlayDataPhy, korg1212->DataBufsSize);
 
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                korg1212->DataBufsSize, &korg1212->dma_rec) < 0) {
                snd_printk(KERN_ERR "korg1212: can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
                 snd_korg1212_free(korg1212);
                return err;
        }
 
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                dsp_code->size, &korg1212->dma_dsp) < 0) {
                snd_printk(KERN_ERR "korg1212: cannot allocate dsp code memory (%zd bytes)\n", dsp_code->size);
                 snd_korg1212_free(korg1212);
 
        unsigned long end_time;
 
        err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                 snd_dma_pci_data(chip->pci),
+                                 &chip->pci->dev,
                                  PAGE_SIZE, &chip->rb);
        if (err < 0)
                return err;
 
 
        for (i = 0; i < 2; i++) {
                err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                         snd_dma_pci_data(chip->pci),
+                                         &chip->pci->dev,
                                          PAGE_SIZE, &chip->pcm[i].bdl);
                if (err < 0)
                        return err;
        }
        /* buffer pre-allocation */
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              1024 * 64, 32 * 1024 * 1024);
        return 0;
 }
 
        strcpy(pcm->name, card_name);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              size, size);
 
        chip->pcm = pcm;
 
        chip->pcm = pcm;
        
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 64*1024);
 
        return 0;
 }
 
        }
 #endif
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->mgr->pci), 32*1024, 32*1024);
+                                             &chip->mgr->pci->dev,
+                                             32*1024, 32*1024);
 }
 
 /*
        /* create array of streaminfo */
        size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS *
                            sizeof(struct mixart_flowinfo)) );
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                size, &mgr->flowinfo) < 0) {
                snd_mixart_free(mgr);
                return -ENOMEM;
        /* create array of bufferinfo */
        size = PAGE_ALIGN( (MIXART_MAX_STREAM_PER_CARD * MIXART_MAX_CARDS *
                            sizeof(struct mixart_bufferinfo)) );
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                size, &mgr->bufferinfo) < 0) {
                snd_mixart_free(mgr);
                return -ENOMEM;
 
                if (outs)
                        snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
                                                      SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(chip->pci),
+                                                     &chip->pci->dev,
                                                      DEFAULT_BUFFER_BYTES_MULTICH,
                                                      BUFFER_BYTES_MAX_MULTICH);
                if (ins)
                        snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
                                                      SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(chip->pci),
+                                                     &chip->pci->dev,
                                                      DEFAULT_BUFFER_BYTES,
                                                      BUFFER_BYTES_MAX);
        }
                pcm->private_data = chip;
                strcpy(pcm->name, "Digital");
                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(chip->pci),
+                                                     &chip->pci->dev,
                                                      DEFAULT_BUFFER_BYTES,
                                                      BUFFER_BYTES_MAX);
        }
                pcm->private_data = chip;
                strcpy(pcm->name, outs ? "Front Panel" : "Analog 2");
                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(chip->pci),
+                                                     &chip->pci->dev,
                                                      DEFAULT_BUFFER_BYTES,
                                                      BUFFER_BYTES_MAX);
        }
                pcm->private_data = chip;
                strcpy(pcm->name, "Analog 3");
                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(chip->pci),
+                                                     &chip->pci->dev,
                                                      DEFAULT_BUFFER_BYTES,
                                                      BUFFER_BYTES_MAX);
        }
 
        strcpy(pcm->name, name);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->mgr->pci),
+                                             &chip->mgr->pci->dev,
                                              32*1024, 32*1024);
        chip->pcm = pcm;
        return 0;
 
        /* create hostport purgebuffer */
        size = PAGE_ALIGN(sizeof(struct pcxhr_hostport));
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                size, &mgr->hostport) < 0) {
                pcxhr_free(mgr);
                return -ENOMEM;
 
        if (sgdlist->area)
                snd_dma_free_pages(sgdlist);
        if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
-                                      snd_dma_pci_data(chip->pci),
+                                      &chip->pci->dev,
                                       sizeof(struct sgd) * (DESC_MAX_MASK + 1),
                                       sgdlist)) < 0) {
                snd_printk(KERN_ERR "Riptide: failed to alloc %d dma bytes\n",
        strcpy(pcm->name, "RIPTIDE");
        chip->pcm = pcm;
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64 * 1024, 128 * 1024);
        return 0;
 }
 
         * world if this fails.
         */
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                               snd_dma_pci_data(sis->pci), 64*1024, 128*1024);
+                                             &sis->pci->dev,
+                                             64*1024, 128*1024);
 
        return 0;
 }
 
        sonic->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(sonic->pci), 64*1024, 128*1024);
+                                             &sonic->pci->dev,
+                                             64*1024, 128*1024);
 
        return 0;
 }
 
                struct snd_pcm_substream *substream;
                for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
                        snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
-                                                     snd_dma_pci_data(trident->pci),
+                                                     &trident->pci->dev,
                                                      64*1024, 128*1024);
                snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
-                                             SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+                                             SNDRV_DMA_TYPE_DEV,
+                                             &trident->pci->dev,
                                              64*1024, 128*1024);
        } else {
                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
+                                                     &trident->pci->dev,
+                                                     64*1024, 128*1024);
        }
 
        return 0;
 
        if (trident->tlb.entries)
                snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
-                                                     snd_dma_pci_data(trident->pci), 0, 128*1024);
+                                                     &trident->pci->dev,
+                                                     0, 128*1024);
        else
                snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
-                                                     snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
+                                                     &trident->pci->dev,
+                                                     64*1024, 128*1024);
 
        return 0;
 }
        strcpy(spdif->name, "Trident 4DWave IEC958");
        trident->spdif = spdif;
 
-       snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
+       snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV,
+                                             &trident->pci->dev,
+                                             64*1024, 128*1024);
 
        return 0;
 }
        /* TLB array must be aligned to 16kB !!! so we allocate
           32kB region and correct offset when necessary */
 
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
                                2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
                dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
                return -ENOMEM;
                return -ENOMEM;
 
        /* allocate and setup silent page and initialise TLB entries */
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
                                SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
                dev_err(trident->card->dev, "unable to allocate silent page\n");
                return -ENOMEM;
 
                /* the start of each lists must be aligned to 8 bytes,
                 * but the kernel pages are much bigger, so we don't care
                 */
-               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                        PAGE_ALIGN(VIA_TABLE_SIZE * 2 * 8),
                                        &dev->table) < 0)
                        return -ENOMEM;
        init_viadev(chip, chip->capture_devno, VIA_REG_CAPTURE_8233_STATUS, 6, 1);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, VIA_MAX_BUFSIZE);
 
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
        init_viadev(chip, chip->capture_devno + 1, VIA_REG_CAPTURE_8233_STATUS + 0x10, 7, 1);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, VIA_MAX_BUFSIZE);
 
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
        init_viadev(chip, chip->capture_devno, VIA_REG_CAPTURE_8233_STATUS, 6, 1);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, VIA_MAX_BUFSIZE);
 
        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
        init_viadev(chip, chip->playback_devno, 0x30, 3, 0);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, VIA_MAX_BUFSIZE);
        return 0;
 }
        init_viadev(chip, 1, VIA_REG_CAPTURE_STATUS, 0, 1);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, VIA_MAX_BUFSIZE);
        return 0;
 }
 
                /* the start of each lists must be aligned to 8 bytes,
                 * but the kernel pages are much bigger, so we don't care
                 */
-               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+               if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                        PAGE_ALIGN(VIA_TABLE_SIZE * 2 * 8),
                                        &dev->table) < 0)
                        return -ENOMEM;
        init_viadev(chip, 1, VIA_REG_MI_STATUS, 1);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                             snd_dma_pci_data(chip->pci),
+                                             &chip->pci->dev,
                                              64*1024, 128*1024);
        return 0;
 }
 
 
 static int snd_ymfpci_ac3_init(struct snd_ymfpci *chip)
 {
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                4096, &chip->ac3_tmp_base) < 0)
                return -ENOMEM;
 
        chip->pcm = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                     snd_pcm_std_chmaps, 2, 0, NULL);
        chip->pcm2 = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return 0;
 }
        chip->pcm_spdif = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return 0;
 }
        chip->pcm_4ch = pcm;
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                             snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
+                                             &chip->pci->dev,
+                                             64*1024, 256*1024);
 
        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                     surround_map, 2, 0, NULL);
               chip->work_size;
        /* work_ptr must be aligned to 256 bytes, but it's already
           covered with the kernel page allocation mechanism */
-       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+       if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                size, &chip->work_ptr) < 0) 
                return -ENOMEM;
        ptr = chip->work_ptr.area;