getparam->value = device->info.chipset;
                break;
        case NOUVEAU_GETPARAM_PCI_VENDOR:
-               if (nvxx_device(device)->func->pci)
+               if (device->info.platform != NV_DEVICE_INFO_V0_SOC)
                        getparam->value = dev->pdev->vendor;
                else
                        getparam->value = 0;
                break;
        case NOUVEAU_GETPARAM_PCI_DEVICE:
-               if (nvxx_device(device)->func->pci)
+               if (device->info.platform != NV_DEVICE_INFO_V0_SOC)
                        getparam->value = dev->pdev->device;
                else
                        getparam->value = 0;
                break;
        case NOUVEAU_GETPARAM_BUS_TYPE:
-               if (!nvxx_device(device)->func->pci)
-                       getparam->value = 3;
-               else
-               if (pci_find_capability(dev->pdev, PCI_CAP_ID_AGP))
-                       getparam->value = 0;
-               else
-               if (!pci_is_pcie(dev->pdev))
-                       getparam->value = 1;
-               else
-                       getparam->value = 2;
-               break;
+               switch (device->info.platform) {
+               case NV_DEVICE_INFO_V0_AGP : getparam->value = 0; break;
+               case NV_DEVICE_INFO_V0_PCI : getparam->value = 1; break;
+               case NV_DEVICE_INFO_V0_PCIE: getparam->value = 2; break;
+               case NV_DEVICE_INFO_V0_SOC : getparam->value = 3; break;
+               case NV_DEVICE_INFO_V0_IGP :
+                       if (!pci_is_pcie(dev->pdev))
+                               getparam->value = 1;
+                       else
+                               getparam->value = 2;
+                       break;
+               default:
+                       WARN_ON(1);
+                       break;
+               }
        case NOUVEAU_GETPARAM_FB_SIZE:
                getparam->value = drm->gem.vram_available;
                break;
 
 {
        struct nouveau_drm *drm = nouveau_drm(dev);
        int i = reg - drm->tile.reg;
-       struct nvkm_device *device = nvxx_device(&drm->client.device);
-       struct nvkm_fb *fb = device->fb;
+       struct nvkm_fb *fb = nvxx_fb(&drm->client.device);
        struct nvkm_fb_tile *tile = &fb->tile.region[i];
 
        nouveau_fence_unref(®->fence);
 nouveau_bo_sync_for_device(struct nouveau_bo *nvbo)
 {
        struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
-       struct nvkm_device *device = nvxx_device(&drm->client.device);
        struct ttm_dma_tt *ttm_dma = (struct ttm_dma_tt *)nvbo->bo.ttm;
        int i;
 
                return;
 
        for (i = 0; i < ttm_dma->ttm.num_pages; i++)
-               dma_sync_single_for_device(device->dev, ttm_dma->dma_address[i],
+               dma_sync_single_for_device(drm->dev->dev,
+                                          ttm_dma->dma_address[i],
                                           PAGE_SIZE, DMA_TO_DEVICE);
 }
 
 nouveau_bo_sync_for_cpu(struct nouveau_bo *nvbo)
 {
        struct nouveau_drm *drm = nouveau_bdev(nvbo->bo.bdev);
-       struct nvkm_device *device = nvxx_device(&drm->client.device);
        struct ttm_dma_tt *ttm_dma = (struct ttm_dma_tt *)nvbo->bo.ttm;
        int i;
 
                return;
 
        for (i = 0; i < ttm_dma->ttm.num_pages; i++)
-               dma_sync_single_for_cpu(device->dev, ttm_dma->dma_address[i],
+               dma_sync_single_for_cpu(drm->dev->dev, ttm_dma->dma_address[i],
                                        PAGE_SIZE, DMA_FROM_DEVICE);
 }
 
 {
        struct ttm_dma_tt *ttm_dma = (void *)ttm;
        struct nouveau_drm *drm;
-       struct nvkm_device *device;
-       struct drm_device *dev;
-       struct device *pdev;
+       struct device *dev;
        unsigned i;
        int r;
        bool slave = !!(ttm->page_flags & TTM_PAGE_FLAG_SG);
        }
 
        drm = nouveau_bdev(ttm->bdev);
-       device = nvxx_device(&drm->client.device);
-       dev = drm->dev;
-       pdev = device->dev;
+       dev = drm->dev->dev;
 
 #if IS_ENABLED(CONFIG_AGP)
        if (drm->agp.bridge) {
 
 #if IS_ENABLED(CONFIG_SWIOTLB) && IS_ENABLED(CONFIG_X86)
        if (swiotlb_nr_tbl()) {
-               return ttm_dma_populate((void *)ttm, dev->dev);
+               return ttm_dma_populate((void *)ttm, dev);
        }
 #endif
 
        for (i = 0; i < ttm->num_pages; i++) {
                dma_addr_t addr;
 
-               addr = dma_map_page(pdev, ttm->pages[i], 0, PAGE_SIZE,
+               addr = dma_map_page(dev, ttm->pages[i], 0, PAGE_SIZE,
                                    DMA_BIDIRECTIONAL);
 
-               if (dma_mapping_error(pdev, addr)) {
+               if (dma_mapping_error(dev, addr)) {
                        while (i--) {
-                               dma_unmap_page(pdev, ttm_dma->dma_address[i],
+                               dma_unmap_page(dev, ttm_dma->dma_address[i],
                                               PAGE_SIZE, DMA_BIDIRECTIONAL);
                                ttm_dma->dma_address[i] = 0;
                        }
 {
        struct ttm_dma_tt *ttm_dma = (void *)ttm;
        struct nouveau_drm *drm;
-       struct nvkm_device *device;
-       struct drm_device *dev;
-       struct device *pdev;
+       struct device *dev;
        unsigned i;
        bool slave = !!(ttm->page_flags & TTM_PAGE_FLAG_SG);
 
                return;
 
        drm = nouveau_bdev(ttm->bdev);
-       device = nvxx_device(&drm->client.device);
-       dev = drm->dev;
-       pdev = device->dev;
+       dev = drm->dev->dev;
 
 #if IS_ENABLED(CONFIG_AGP)
        if (drm->agp.bridge) {
 
 #if IS_ENABLED(CONFIG_SWIOTLB) && IS_ENABLED(CONFIG_X86)
        if (swiotlb_nr_tbl()) {
-               ttm_dma_unpopulate((void *)ttm, dev->dev);
+               ttm_dma_unpopulate((void *)ttm, dev);
                return;
        }
 #endif
 
        for (i = 0; i < ttm->num_pages; i++) {
                if (ttm_dma->dma_address[i]) {
-                       dma_unmap_page(pdev, ttm_dma->dma_address[i], PAGE_SIZE,
+                       dma_unmap_page(dev, ttm_dma->dma_address[i], PAGE_SIZE,
                                       DMA_BIDIRECTIONAL);
                }
        }