support for platform devices

Upcoming mobile Kepler GPUs (such as GK20A) use the platform bus instead of PCI to which Nouveau is tightly dependent. This patch allows Nouveau to handle platform devices by: - abstracting PCI-dependent functions that were typically used for resource querying and page mapping, - introducing a nv_device_is_pci() function that allows to make PCI-dependent code conditional, - providing a nouveau_drm_platform_probe() function that takes a GPU platform device to be probed. Core code as well as engine/subdev drivers are updated wherever possible to make use of these functions. Some older drivers are too dependent on PCI to be properly updated, but all newer code on which future chips may depend should at least be runnable with platform devices. Signed-off-by: Alexandre Courbot <acourbot@nvidia.com> Signed-off-by: Ben Skeggs <bskeggs@redhat.com>

support for platform devices
Upcoming mobile Kepler GPUs (such as GK20A) use the platform bus instead of PCI to which Nouveau is tightly dependent. This patch allows Nouveau to handle platform devices by: - abstracting PCI-dependent functions that were typically used for resource querying and page mapping, - introducing a nv_device_is_pci() function that allows to make PCI-dependent code conditional, - providing a nouveau_drm_platform_probe() function that takes a GPU platform device to be probed. Core code as well as engine/subdev drivers are updated wherever possible to make use of these functions. Some older drivers are too dependent on PCI to be properly updated, but all newer code on which future chips may depend should at least be runnable with platform devices. Signed-off-by: Alexandre Courbot <acourbot@nvidia.com> Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
Alexandre Courbot · Ben Skeggs
1 parent 0b681687fe
Showing 35 changed files with 305 additions and 127 deletions Side-by-side Diff
drivers/gpu/drm/nouveau/core/engine/device/base.c
drivers/gpu/drm/nouveau/core/engine/falcon.c
drivers/gpu/drm/nouveau/core/engine/fifo/base.c
drivers/gpu/drm/nouveau/core/engine/graph/nv20.c
drivers/gpu/drm/nouveau/core/engine/graph/nv40.c
drivers/gpu/drm/nouveau/core/engine/graph/nvc0.c
drivers/gpu/drm/nouveau/core/engine/xtensa.c
drivers/gpu/drm/nouveau/core/include/core/device.h
drivers/gpu/drm/nouveau/core/include/engine/device.h
drivers/gpu/drm/nouveau/core/include/subdev/mc.h
drivers/gpu/drm/nouveau/core/os.h
drivers/gpu/drm/nouveau/core/subdev/bar/base.c
drivers/gpu/drm/nouveau/core/subdev/bar/nv50.c
drivers/gpu/drm/nouveau/core/subdev/bar/nvc0.c
drivers/gpu/drm/nouveau/core/subdev/devinit/fbmem.h
drivers/gpu/drm/nouveau/core/subdev/devinit/nv04.c
drivers/gpu/drm/nouveau/core/subdev/devinit/nv05.c
drivers/gpu/drm/nouveau/core/subdev/devinit/nv10.c
drivers/gpu/drm/nouveau/core/subdev/devinit/nv20.c
drivers/gpu/drm/nouveau/core/subdev/fb/nv50.c
@@ -131,8 +131,8 @@
 	if (ret)
 		return ret;
  
-	mmio_base = pci_resource_start(device->pdev, 0);
-	mmio_size = pci_resource_len(device->pdev, 0);
+	mmio_base = nv_device_resource_start(device, 0);
+	mmio_size = nv_device_resource_len(device, 0);
  
 	/* translate api disable mask into internal mapping */
 	disable = args->debug0;
@@ -448,6 +448,72 @@
 	nouveau_engine_destroy(&device->base);
 }
  
+resource_size_t
+nv_device_resource_start(struct nouveau_device *device, unsigned int bar)
+{
+	if (nv_device_is_pci(device)) {
+		return pci_resource_start(device->pdev, bar);
+	} else {
+		struct resource *res;
+		res = platform_get_resource(device->platformdev,
+					    IORESOURCE_MEM, bar);
+		if (!res)
+			return 0;
+		return res->start;
+	}
+}
+
+resource_size_t
+nv_device_resource_len(struct nouveau_device *device, unsigned int bar)
+{
+	if (nv_device_is_pci(device)) {
+		return pci_resource_len(device->pdev, bar);
+	} else {
+		struct resource *res;
+		res = platform_get_resource(device->platformdev,
+					    IORESOURCE_MEM, bar);
+		if (!res)
+			return 0;
+		return resource_size(res);
+	}
+}
+
+dma_addr_t
+nv_device_map_page(struct nouveau_device *device, struct page *page)
+{
+	dma_addr_t ret;
+
+	if (nv_device_is_pci(device)) {
+		ret = pci_map_page(device->pdev, page, 0, PAGE_SIZE,
+				   PCI_DMA_BIDIRECTIONAL);
+		if (pci_dma_mapping_error(device->pdev, ret))
+			ret = 0;
+	} else {
+		ret = page_to_phys(page);
+	}
+
+	return ret;
+}
+
+void
+nv_device_unmap_page(struct nouveau_device *device, dma_addr_t addr)
+{
+	if (nv_device_is_pci(device))
+		pci_unmap_page(device->pdev, addr, PAGE_SIZE,
+			       PCI_DMA_BIDIRECTIONAL);
+}
+
+int
+nv_device_get_irq(struct nouveau_device *device, bool stall)
+{
+	if (nv_device_is_pci(device)) {
+		return device->pdev->irq;
+	} else {
+		return platform_get_irq_byname(device->platformdev,
+					       stall ? "stall" : "nonstall");
+	}
+}
+
 static struct nouveau_oclass
 nouveau_device_oclass = {
 	.handle = NV_ENGINE(DEVICE, 0x00),
@@ -459,8 +525,8 @@
 };
  
 int
-nouveau_device_create_(struct pci_dev *pdev, u64 name, const char *sname,
-		       const char *cfg, const char *dbg,
+nouveau_device_create_(void *dev, enum nv_bus_type type, u64 name,
+		       const char *sname, const char *cfg, const char *dbg,
 		       int length, void **pobject)
 {
 	struct nouveau_device *device;
@@ -478,7 +544,14 @@
 	if (ret)
 		goto done;
  
-	device->pdev = pdev;
+	switch (type) {
+	case NOUVEAU_BUS_PCI:
+		device->pdev = dev;
+		break;
+	case NOUVEAU_BUS_PLATFORM:
+		device->platformdev = dev;
+		break;
+	}
 	device->handle = name;
 	device->cfgopt = cfg;
 	device->dbgopt = dbg;
@@ -119,7 +119,7 @@
 		snprintf(name, sizeof(name), "nouveau/nv%02x_fuc%03x",
 			 device->chipset, falcon->addr >> 12);
  
-		ret = request_firmware(&fw, name, &device->pdev->dev);
+		ret = request_firmware(&fw, name, nv_device_base(device));
 		if (ret == 0) {
 			falcon->code.data = vmemdup(fw->data, fw->size);
 			falcon->code.size = fw->size;
@@ -138,7 +138,7 @@
 		snprintf(name, sizeof(name), "nouveau/nv%02x_fuc%03xd",
 			 device->chipset, falcon->addr >> 12);
  
-		ret = request_firmware(&fw, name, &device->pdev->dev);
+		ret = request_firmware(&fw, name, nv_device_base(device));
 		if (ret) {
 			nv_error(falcon, "unable to load firmware data\n");
 			return ret;
@@ -153,7 +153,7 @@
 		snprintf(name, sizeof(name), "nouveau/nv%02x_fuc%03xc",
 			 device->chipset, falcon->addr >> 12);
  
-		ret = request_firmware(&fw, name, &device->pdev->dev);
+		ret = request_firmware(&fw, name, nv_device_base(device));
 		if (ret) {
 			nv_error(falcon, "unable to load firmware code\n");
 			return ret;
@@ -86,7 +86,7 @@
 	}
  
 	/* map fifo control registers */
-	chan->user = ioremap(pci_resource_start(device->pdev, bar) + addr +
+	chan->user = ioremap(nv_device_resource_start(device, bar) + addr +
 			     (chan->chid * size), size);
 	if (!chan->user)
 		return -EFAULT;
@@ -349,7 +349,7 @@
 	nv_wr32(priv, NV10_PGRAPH_SURFACE, tmp);
  
 	/* begin RAM config */
-	vramsz = pci_resource_len(nv_device(priv)->pdev, 0) - 1;
+	vramsz = nv_device_resource_len(nv_device(priv), 0) - 1;
 	nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
 	nv_wr32(priv, 0x4009A8, nv_rd32(priv, 0x100204));
 	nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
@@ -484,7 +484,7 @@
 		engine->tile_prog(engine, i);
  
 	/* begin RAM config */
-	vramsz = pci_resource_len(nv_device(priv)->pdev, 0) - 1;
+	vramsz = nv_device_resource_len(nv_device(priv), 0) - 1;
 	switch (nv_device(priv)->chipset) {
 	case 0x40:
 		nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
@@ -1091,10 +1091,10 @@
 	int ret;
  
 	snprintf(f, sizeof(f), "nouveau/nv%02x_%s", device->chipset, fwname);
-	ret = request_firmware(&fw, f, &device->pdev->dev);
+	ret = request_firmware(&fw, f, nv_device_base(device));
 	if (ret) {
 		snprintf(f, sizeof(f), "nouveau/%s", fwname);
-		ret = request_firmware(&fw, f, &device->pdev->dev);
+		ret = request_firmware(&fw, f, nv_device_base(device));
 		if (ret) {
 			nv_error(priv, "failed to load %s\n", fwname);
 			return ret;
@@ -112,7 +112,7 @@
 		snprintf(name, sizeof(name), "nouveau/nv84_xuc%03x",
 			 xtensa->addr >> 12);
  
-		ret = request_firmware(&fw, name, &device->pdev->dev);
+		ret = request_firmware(&fw, name, nv_device_base(device));
 		if (ret) {
 			nv_warn(xtensa, "unable to load firmware %s\n", name);
 			return ret;
@@ -66,6 +66,7 @@
 	struct list_head head;
  
 	struct pci_dev *pdev;
+	struct platform_device *platformdev;
 	u64 handle;
  
 	const char *cfgopt;
@@ -141,6 +142,34 @@
 	       device->pdev->subsystem_vendor == ven &&
 	       device->pdev->subsystem_device == sub;
 }
+
+static inline bool
+nv_device_is_pci(struct nouveau_device *device)
+{
+	return device->pdev != NULL;
+}
+
+static inline struct device *
+nv_device_base(struct nouveau_device *device)
+{
+	return nv_device_is_pci(device) ? &device->pdev->dev :
+					  &device->platformdev->dev;
+}
+
+resource_size_t
+nv_device_resource_start(struct nouveau_device *device, unsigned int bar);
+
+resource_size_t
+nv_device_resource_len(struct nouveau_device *device, unsigned int bar);
+
+dma_addr_t
+nv_device_map_page(struct nouveau_device *device, struct page *page);
+
+void
+nv_device_unmap_page(struct nouveau_device *device, dma_addr_t addr);
+
+int
+nv_device_get_irq(struct nouveau_device *device, bool stall);
  
 #endif
@@ -3,11 +3,20 @@
  
 #include <core/device.h>
  
-#define nouveau_device_create(p,n,s,c,d,u)                                     \
-	nouveau_device_create_((p), (n), (s), (c), (d), sizeof(**u), (void **)u)
+struct platform_device;
  
-int  nouveau_device_create_(struct pci_dev *, u64 name, const char *sname,
-			    const char *cfg, const char *dbg, int, void **);
+enum nv_bus_type {
+	NOUVEAU_BUS_PCI,
+	NOUVEAU_BUS_PLATFORM,
+};
+
+#define nouveau_device_create(p,t,n,s,c,d,u)                                   \
+	nouveau_device_create_((void *)(p), (t), (n), (s), (c), (d),           \
+			       sizeof(**u), (void **)u)
+
+int  nouveau_device_create_(void *, enum nv_bus_type type, u64 name,
+			    const char *sname, const char *cfg, const char *dbg,
+			    int, void **);
  
 int nv04_identify(struct nouveau_device *);
 int nv10_identify(struct nouveau_device *);
@@ -12,6 +12,7 @@
 struct nouveau_mc {
 	struct nouveau_subdev base;
 	bool use_msi;
+	unsigned int irq;
 };
  
 static inline struct nouveau_mc *
@@ -5,6 +5,7 @@
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
+#include <linux/platform_device.h>
 #include <linux/printk.h>
 #include <linux/bitops.h>
 #include <linux/firmware.h>
@@ -22,17 +23,6 @@
 #include <linux/pm_runtime.h>
  
 #include <asm/unaligned.h>
-
-static inline int
-ffsll(u64 mask)
-{
-	int i;
-	for (i = 0; i < 64; i++) {
-		if (mask & (1ULL << i))
-			return i + 1;
-	}
-	return 0;
-}
  
 #ifndef ioread32_native
 #ifdef __BIG_ENDIAN
@@ -118,8 +118,8 @@
 	if (ret)
 		return ret;
  
-	bar->iomem = ioremap(pci_resource_start(device->pdev, 3),
-			     pci_resource_len(device->pdev, 3));
+	bar->iomem = ioremap(nv_device_resource_start(device, 3),
+			     nv_device_resource_len(device, 3));
 	return 0;
 }
  
@@ -139,7 +139,7 @@
  
 	/* BAR3 */
 	start = 0x0100000000ULL;
-	limit = start + pci_resource_len(device->pdev, 3);
+	limit = start + nv_device_resource_len(device, 3);
  
 	ret = nouveau_vm_new(device, start, limit, start, &vm);
 	if (ret)
@@ -173,7 +173,7 @@
  
 	/* BAR1 */
 	start = 0x0000000000ULL;
-	limit = start + pci_resource_len(device->pdev, 1);
+	limit = start + nv_device_resource_len(device, 1);
  
 	ret = nouveau_vm_new(device, start, limit--, start, &vm);
 	if (ret)
@@ -84,7 +84,6 @@
 	      struct nouveau_object **pobject)
 {
 	struct nouveau_device *device = nv_device(parent);
-	struct pci_dev *pdev = device->pdev;
 	struct nvc0_bar_priv *priv;
 	struct nouveau_gpuobj *mem;
 	struct nouveau_vm *vm;
  
@@ -107,14 +106,14 @@
 	if (ret)
 		return ret;
  
-	ret = nouveau_vm_new(device, 0, pci_resource_len(pdev, 3), 0, &vm);
+	ret = nouveau_vm_new(device, 0, nv_device_resource_len(device, 3), 0, &vm);
 	if (ret)
 		return ret;
  
 	atomic_inc(&vm->engref[NVDEV_SUBDEV_BAR]);
  
 	ret = nouveau_gpuobj_new(nv_object(priv), NULL,
-				 (pci_resource_len(pdev, 3) >> 12) * 8,
+				 (nv_device_resource_len(device, 3) >> 12) * 8,
 				 0x1000, NVOBJ_FLAG_ZERO_ALLOC,
 				 &vm->pgt[0].obj[0]);
 	vm->pgt[0].refcount[0] = 1;
@@ -128,8 +127,8 @@
  
 	nv_wo32(mem, 0x0200, lower_32_bits(priv->bar[0].pgd->addr));
 	nv_wo32(mem, 0x0204, upper_32_bits(priv->bar[0].pgd->addr));
-	nv_wo32(mem, 0x0208, lower_32_bits(pci_resource_len(pdev, 3) - 1));
-	nv_wo32(mem, 0x020c, upper_32_bits(pci_resource_len(pdev, 3) - 1));
+	nv_wo32(mem, 0x0208, lower_32_bits(nv_device_resource_len(device, 3) - 1));
+	nv_wo32(mem, 0x020c, upper_32_bits(nv_device_resource_len(device, 3) - 1));
  
 	/* BAR1 */
 	ret = nouveau_gpuobj_new(nv_object(priv), NULL, 0x1000, 0, 0,
@@ -143,7 +142,7 @@
 	if (ret)
 		return ret;
  
-	ret = nouveau_vm_new(device, 0, pci_resource_len(pdev, 1), 0, &vm);
+	ret = nouveau_vm_new(device, 0, nv_device_resource_len(device, 1), 0, &vm);
 	if (ret)
 		return ret;
  
@@ -156,8 +155,8 @@
  
 	nv_wo32(mem, 0x0200, lower_32_bits(priv->bar[1].pgd->addr));
 	nv_wo32(mem, 0x0204, upper_32_bits(priv->bar[1].pgd->addr));
-	nv_wo32(mem, 0x0208, lower_32_bits(pci_resource_len(pdev, 1) - 1));
-	nv_wo32(mem, 0x020c, upper_32_bits(pci_resource_len(pdev, 1) - 1));
+	nv_wo32(mem, 0x0208, lower_32_bits(nv_device_resource_len(device, 1) - 1));
+	nv_wo32(mem, 0x020c, upper_32_bits(nv_device_resource_len(device, 1) - 1));
  
 	priv->base.alloc = nouveau_bar_alloc;
 	priv->base.kmap = nvc0_bar_kmap;
@@ -24,6 +24,8 @@
  *
  */
  
+#include <core/device.h>
+
 #define NV04_PFB_BOOT_0						0x00100000
 #	define NV04_PFB_BOOT_0_RAM_AMOUNT			0x00000003
 #	define NV04_PFB_BOOT_0_RAM_AMOUNT_32MB			0x00000000
  
@@ -60,10 +62,10 @@
 #	define NV10_PFB_REFCTRL_VALID_1				(1 << 31)
  
 static inline struct io_mapping *
-fbmem_init(struct pci_dev *pdev)
+fbmem_init(struct nouveau_device *dev)
 {
-	return io_mapping_create_wc(pci_resource_start(pdev, 1),
-				    pci_resource_len(pdev, 1));
+	return io_mapping_create_wc(nv_device_resource_start(dev, 1),
+				    nv_device_resource_len(dev, 1));
 }
  
 static inline void
@@ -38,7 +38,7 @@
 	int i;
  
 	/* Map the framebuffer aperture */
-	fb = fbmem_init(nv_device(priv)->pdev);
+	fb = fbmem_init(nv_device(priv));
 	if (!fb) {
 		nv_error(priv, "failed to map fb\n");
 		return;
@@ -53,7 +53,7 @@
 	int i, v;
  
 	/* Map the framebuffer aperture */
-	fb = fbmem_init(nv_device(priv)->pdev);
+	fb = fbmem_init(nv_device(priv));
 	if (!fb) {
 		nv_error(priv, "failed to map fb\n");
 		return;
@@ -46,7 +46,7 @@
 		mem_width_count = 2;
  
 	/* Map the framebuffer aperture */
-	fb = fbmem_init(nv_device(priv)->pdev);
+	fb = fbmem_init(nv_device(priv));
 	if (!fb) {
 		nv_error(priv, "failed to map fb\n");
 		return;
@@ -37,7 +37,7 @@
 	struct io_mapping *fb;
  
 	/* Map the framebuffer aperture */
-	fb = fbmem_init(nv_device(priv)->pdev);
+	fb = fbmem_init(nv_device(priv));
 	if (!fb) {
 		nv_error(priv, "failed to map fb\n");
 		return;
@@ -250,10 +250,8 @@
  
 	priv->r100c08_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
 	if (priv->r100c08_page) {
-		priv->r100c08 = pci_map_page(device->pdev, priv->r100c08_page,
-					     0, PAGE_SIZE,
-					     PCI_DMA_BIDIRECTIONAL);
-		if (pci_dma_mapping_error(device->pdev, priv->r100c08))
+		priv->r100c08 = nv_device_map_page(device, priv->r100c08_page);
+		if (!priv->r100c08)
 			nv_warn(priv, "failed 0x100c08 page map\n");
 	} else {
 		nv_warn(priv, "failed 0x100c08 page alloc\n");
@@ -270,8 +268,7 @@
 	struct nv50_fb_priv *priv = (void *)object;
  
 	if (priv->r100c08_page) {
-		pci_unmap_page(device->pdev, priv->r100c08, PAGE_SIZE,
-			       PCI_DMA_BIDIRECTIONAL);
+		nv_device_unmap_page(device, priv->r100c08);
 		__free_page(priv->r100c08_page);
 	}
  
@@ -70,8 +70,7 @@
 	struct nvc0_fb_priv *priv = (void *)object;
  
 	if (priv->r100c10_page) {
-		pci_unmap_page(device->pdev, priv->r100c10, PAGE_SIZE,
-			       PCI_DMA_BIDIRECTIONAL);
+		nv_device_unmap_page(device, priv->r100c10);
 		__free_page(priv->r100c10_page);
 	}
  
@@ -94,10 +93,8 @@
  
 	priv->r100c10_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
 	if (priv->r100c10_page) {
-		priv->r100c10 = pci_map_page(device->pdev, priv->r100c10_page,
-					     0, PAGE_SIZE,
-					     PCI_DMA_BIDIRECTIONAL);
-		if (pci_dma_mapping_error(device->pdev, priv->r100c10))
+		priv->r100c10 = nv_device_map_page(device, priv->r100c10_page);
+		if (!priv->r100c10)
 			return -EFAULT;
 	}
  
@@ -111,7 +111,7 @@
 	snprintf(port->adapter.name, sizeof(port->adapter.name),
 		 "nouveau-%s-%d", device->name, index);
 	port->adapter.owner = THIS_MODULE;
-	port->adapter.dev.parent = &device->pdev->dev;
+	port->adapter.dev.parent = nv_device_base(device);
 	port->index = index;
 	port->func = func;
 	i2c_set_adapdata(&port->adapter, i2c);
@@ -50,7 +50,6 @@
 		  struct nouveau_object **pobject)
 {
 	struct nouveau_device *device = nv_device(parent);
-	struct pci_dev *pdev = device->pdev;
 	struct nv04_instmem_priv *priv;
 	int ret, bar, vs;
  
  
@@ -60,13 +59,13 @@
 		return ret;
  
 	/* map bar */
-	if (pci_resource_len(pdev, 2))
+	if (nv_device_resource_len(device, 2))
 		bar = 2;
 	else
 		bar = 3;
  
-	priv->iomem = ioremap(pci_resource_start(pdev, bar),
-			      pci_resource_len(pdev, bar));
+	priv->iomem = ioremap(nv_device_resource_start(device, bar),
+			      nv_device_resource_len(device, bar));
 	if (!priv->iomem) {
 		nv_error(priv, "unable to map PRAMIN BAR\n");
 		return -EFAULT;
@@ -93,7 +93,7 @@
 {
 	struct nouveau_device *device = nv_device(object);
 	struct nouveau_mc *pmc = (void *)object;
-	free_irq(device->pdev->irq, pmc);
+	free_irq(pmc->irq, pmc);
 	if (pmc->use_msi)
 		pci_disable_msi(device->pdev);
 	nouveau_subdev_destroy(&pmc->base);
  
  
  
  
  
@@ -114,33 +114,44 @@
 	if (ret)
 		return ret;
  
-	switch (device->pdev->device & 0x0ff0) {
-	case 0x00f0:
-	case 0x02e0:
-		/* BR02? NFI how these would be handled yet exactly */
-		break;
-	default:
-		switch (device->chipset) {
-		case 0xaa: break; /* reported broken, nv also disable it */
-		default:
-			pmc->use_msi = true;
+	if (nv_device_is_pci(device))
+		switch (device->pdev->device & 0x0ff0) {
+		case 0x00f0:
+		case 0x02e0:
+			/* BR02? NFI how these would be handled yet exactly */
 			break;
+		default:
+			switch (device->chipset) {
+			case 0xaa:
+				/* reported broken, nv also disable it */
+				break;
+			default:
+				pmc->use_msi = true;
+				break;
 		}
-	}
  
-	pmc->use_msi = nouveau_boolopt(device->cfgopt, "NvMSI", pmc->use_msi);
-	if (pmc->use_msi && oclass->msi_rearm) {
-		pmc->use_msi = pci_enable_msi(device->pdev) == 0;
-		if (pmc->use_msi) {
-			nv_info(pmc, "MSI interrupts enabled\n");
-			oclass->msi_rearm(pmc);
+		pmc->use_msi = nouveau_boolopt(device->cfgopt, "NvMSI",
+					       pmc->use_msi);
+
+		if (pmc->use_msi && oclass->msi_rearm) {
+			pmc->use_msi = pci_enable_msi(device->pdev) == 0;
+			if (pmc->use_msi) {
+				nv_info(pmc, "MSI interrupts enabled\n");
+				oclass->msi_rearm(pmc);
+			}
+		} else {
+			pmc->use_msi = false;
 		}
-	} else {
-		pmc->use_msi = false;
 	}
  
-	ret = request_irq(device->pdev->irq, nouveau_mc_intr,
-			  IRQF_SHARED, "nouveau", pmc);
+	ret = nv_device_get_irq(device, true);
+	if (ret < 0)
+		return ret;
+	pmc->irq = ret;
+
+	ret = request_irq(pmc->irq, nouveau_mc_intr, IRQF_SHARED, "nouveau",
+			  pmc);
+
 	if (ret < 0)
 		return ret;
  
@@ -96,7 +96,7 @@
 	acpi_handle handle;
 	int rev;
  
-	handle = ACPI_HANDLE(&device->pdev->dev);
+	handle = ACPI_HANDLE(nv_device_base(device));
 	if (!handle)
 		return false;
  
@@ -180,12 +180,21 @@
 		getparam->value = device->chipset;
 		break;
 	case NOUVEAU_GETPARAM_PCI_VENDOR:
-		getparam->value = dev->pdev->vendor;
+		if (nv_device_is_pci(device))
+			getparam->value = dev->pdev->vendor;
+		else
+			getparam->value = 0;
 		break;
 	case NOUVEAU_GETPARAM_PCI_DEVICE:
-		getparam->value = dev->pdev->device;
+		if (nv_device_is_pci(device))
+			getparam->value = dev->pdev->device;
+		else
+			getparam->value = 0;
 		break;
 	case NOUVEAU_GETPARAM_BUS_TYPE:
+		if (!nv_device_is_pci(device))
+			getparam->value = 3;
+		else
 		if (drm_pci_device_is_agp(dev))
 			getparam->value = 0;
 		else
@@ -75,7 +75,7 @@
 {
 	struct drm_device *dev = drm->dev;
  
-	if (!drm_pci_device_is_agp(dev) || !dev->agp)
+	if (!dev->pdev || !drm_pci_device_is_agp(dev) || !dev->agp)
 		return false;
  
 	if (drm->agp.stat == UNKNOWN) {
@@ -2069,6 +2069,10 @@
 	struct nvbios *bios = &drm->vbios;
 	int ret;
  
+	/* only relevant for PCI devices */
+	if (!dev->pdev)
+		return 0;
+
 	if (!NVInitVBIOS(dev))
 		return -ENODEV;
  
@@ -1255,7 +1255,7 @@
 		/* fallthrough, tiled memory */
 	case TTM_PL_VRAM:
 		mem->bus.offset = mem->start << PAGE_SHIFT;
-		mem->bus.base = pci_resource_start(dev->pdev, 1);
+		mem->bus.base = nv_device_resource_start(nouveau_dev(dev), 1);
 		mem->bus.is_iomem = true;
 		if (nv_device(drm->device)->card_type >= NV_50) {
 			struct nouveau_bar *bar = nouveau_bar(drm->device);
@@ -1293,7 +1293,7 @@
 	struct nouveau_drm *drm = nouveau_bdev(bo->bdev);
 	struct nouveau_bo *nvbo = nouveau_bo(bo);
 	struct nouveau_device *device = nv_device(drm->device);
-	u32 mappable = pci_resource_len(device->pdev, 1) >> PAGE_SHIFT;
+	u32 mappable = nv_device_resource_len(device, 1) >> PAGE_SHIFT;
 	int ret;
  
 	/* as long as the bo isn't in vram, and isn't tiled, we've got
@@ -1331,6 +1331,7 @@
 {
 	struct ttm_dma_tt *ttm_dma = (void *)ttm;
 	struct nouveau_drm *drm;
+	struct nouveau_device *device;
 	struct drm_device *dev;
 	unsigned i;
 	int r;
@@ -1348,6 +1349,7 @@
 	}
  
 	drm = nouveau_bdev(ttm->bdev);
+	device = nv_device(drm->device);
 	dev = drm->dev;
  
 #if __OS_HAS_AGP
  
@@ -1368,13 +1370,12 @@
 	}
  
 	for (i = 0; i < ttm->num_pages; i++) {
-		ttm_dma->dma_address[i] = pci_map_page(dev->pdev, ttm->pages[i],
-						   0, PAGE_SIZE,
-						   PCI_DMA_BIDIRECTIONAL);
-		if (pci_dma_mapping_error(dev->pdev, ttm_dma->dma_address[i])) {
+		ttm_dma->dma_address[i] = nv_device_map_page(device,
+							     ttm->pages[i]);
+		if (!ttm_dma->dma_address[i]) {
 			while (--i) {
-				pci_unmap_page(dev->pdev, ttm_dma->dma_address[i],
-					       PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
+				nv_device_unmap_page(device,
+						     ttm_dma->dma_address[i]);
 				ttm_dma->dma_address[i] = 0;
 			}
 			ttm_pool_unpopulate(ttm);
@@ -1389,6 +1390,7 @@
 {
 	struct ttm_dma_tt *ttm_dma = (void *)ttm;
 	struct nouveau_drm *drm;
+	struct nouveau_device *device;
 	struct drm_device *dev;
 	unsigned i;
 	bool slave = !!(ttm->page_flags & TTM_PAGE_FLAG_SG);
@@ -1397,6 +1399,7 @@
 		return;
  
 	drm = nouveau_bdev(ttm->bdev);
+	device = nv_device(drm->device);
 	dev = drm->dev;
  
 #if __OS_HAS_AGP
@@ -1415,8 +1418,7 @@
  
 	for (i = 0; i < ttm->num_pages; i++) {
 		if (ttm_dma->dma_address[i]) {
-			pci_unmap_page(dev->pdev, ttm_dma->dma_address[i],
-				       PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
+			nv_device_unmap_page(device, ttm_dma->dma_address[i]);
 		}
 	}
  
@@ -154,7 +154,7 @@
 			 * nfi why this exists, it came from the -nv ddx.
 			 */
 			args.flags = NV_DMA_TARGET_PCI | NV_DMA_ACCESS_RDWR;
-			args.start = pci_resource_start(device->pdev, 1);
+			args.start = nv_device_resource_start(device, 1);
 			args.limit = args.start + limit;
 		} else {
 			args.flags = NV_DMA_TARGET_VRAM | NV_DMA_ACCESS_RDWR;
@@ -419,6 +419,7 @@
 nouveau_display_create(struct drm_device *dev)
 {
 	struct nouveau_drm *drm = nouveau_drm(dev);
+	struct nouveau_device *device = nouveau_dev(dev);
 	struct nouveau_display *disp;
 	int ret, gen;
  
@@ -459,7 +460,7 @@
 	}
  
 	dev->mode_config.funcs = &nouveau_mode_config_funcs;
-	dev->mode_config.fb_base = pci_resource_start(dev->pdev, 1);
+	dev->mode_config.fb_base = nv_device_resource_start(device, 1);
  
 	dev->mode_config.min_width = 0;
 	dev->mode_config.min_height = 0;
@@ -82,7 +82,7 @@
 static struct drm_driver driver;
  
 static u64
-nouveau_name(struct pci_dev *pdev)
+nouveau_pci_name(struct pci_dev *pdev)
 {
 	u64 name = (u64)pci_domain_nr(pdev->bus) << 32;
 	name |= pdev->bus->number << 16;
  
  
@@ -90,15 +90,30 @@
 	return name | PCI_FUNC(pdev->devfn);
 }
  
+static u64
+nouveau_platform_name(struct platform_device *platformdev)
+{
+	return platformdev->id;
+}
+
+static u64
+nouveau_name(struct drm_device *dev)
+{
+	if (dev->pdev)
+		return nouveau_pci_name(dev->pdev);
+	else
+		return nouveau_platform_name(dev->platformdev);
+}
+
 static int
-nouveau_cli_create(struct pci_dev *pdev, const char *name,
+nouveau_cli_create(u64 name, const char *sname,
 		   int size, void **pcli)
 {
 	struct nouveau_cli *cli;
 	int ret;
  
 	*pcli = NULL;
-	ret = nouveau_client_create_(name, nouveau_name(pdev), nouveau_config,
+	ret = nouveau_client_create_(sname, name, nouveau_config,
 				     nouveau_debug, size, pcli);
 	cli = *pcli;
 	if (ret) {
@@ -282,7 +297,8 @@
 	remove_conflicting_framebuffers(aper, "nouveaufb", boot);
 	kfree(aper);
  
-	ret = nouveau_device_create(pdev, nouveau_name(pdev), pci_name(pdev),
+	ret = nouveau_device_create(pdev, NOUVEAU_BUS_PCI,
+				    nouveau_pci_name(pdev), pci_name(pdev),
 				    nouveau_config, nouveau_debug, &device);
 	if (ret)
 		return ret;
@@ -305,6 +321,12 @@
 {
 	struct pci_dev *pdev = drm->dev->pdev;
  
+	if (!pdev) {
+		DRM_INFO("not a PCI device; no HDMI");
+		drm->hdmi_device = NULL;
+		return;
+	}
+
 	/* subfunction one is a hdmi audio device? */
 	drm->hdmi_device = pci_get_bus_and_slot((unsigned int)pdev->bus->number,
 						PCI_DEVFN(PCI_SLOT(pdev->devfn), 1));
@@ -330,7 +352,8 @@
 	struct nouveau_drm *drm;
 	int ret;
  
-	ret = nouveau_cli_create(pdev, "DRM", sizeof(*drm), (void**)&drm);
+	ret = nouveau_cli_create(nouveau_name(dev), "DRM", sizeof(*drm),
+				 (void **)&drm);
 	if (ret)
 		return ret;
  
@@ -346,7 +369,7 @@
 	/* make sure AGP controller is in a consistent state before we
 	 * (possibly) execute vbios init tables (see nouveau_agp.h)
 	 */
-	if (drm_pci_device_is_agp(dev) && dev->agp) {
+	if (pdev && drm_pci_device_is_agp(dev) && dev->agp) {
 		/* dummy device object, doesn't init anything, but allows
 		 * agp code access to registers
 		 */
@@ -672,7 +695,6 @@
 static int
 nouveau_drm_open(struct drm_device *dev, struct drm_file *fpriv)
 {
-	struct pci_dev *pdev = dev->pdev;
 	struct nouveau_drm *drm = nouveau_drm(dev);
 	struct nouveau_cli *cli;
 	char name[32], tmpname[TASK_COMM_LEN];
@@ -686,7 +708,9 @@
 	get_task_comm(tmpname, current);
 	snprintf(name, sizeof(name), "%s[%d]", tmpname, pid_nr(fpriv->pid));
  
-	ret = nouveau_cli_create(pdev, name, sizeof(*cli), (void **)&cli);
+	ret = nouveau_cli_create(nouveau_name(dev), name, sizeof(*cli),
+			(void **)&cli);
+
 	if (ret)
 		goto out_suspend;
  
@@ -974,6 +998,25 @@
 	.remove = nouveau_drm_remove,
 	.driver.pm = &nouveau_pm_ops,
 };
+
+int nouveau_drm_platform_probe(struct platform_device *pdev)
+{
+	struct nouveau_device *device;
+	int ret;
+
+	ret = nouveau_device_create(pdev, NOUVEAU_BUS_PLATFORM,
+				    nouveau_platform_name(pdev),
+				    dev_name(&pdev->dev), nouveau_config,
+				    nouveau_debug, &device);
+
+	ret = drm_platform_init(&driver, pdev);
+	if (ret) {
+		nouveau_object_ref(NULL, (struct nouveau_object **)&device);
+		return ret;
+	}
+
+	return ret;
+}
  
 static int __init
 nouveau_drm_init(void)
@@ -30,7 +30,7 @@
 static inline struct drm_device *
 drm_device(struct device *d)
 {
-	return pci_get_drvdata(to_pci_dev(d));
+	return dev_get_drvdata(d);
 }
  
 #define snappendf(p,r,f,a...) do {                                             \
  
@@ -132,9 +132,10 @@
 {
 	struct nouveau_sysfs *sysfs = nouveau_sysfs(dev);
 	struct nouveau_drm *drm = nouveau_drm(dev);
+	struct nouveau_device *device = nv_device(drm->device);
  
 	if (sysfs->ctrl) {
-		device_remove_file(&dev->pdev->dev, &dev_attr_pstate);
+		device_remove_file(nv_device_base(device), &dev_attr_pstate);
 		nouveau_object_del(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL);
 	}
  
@@ -146,6 +147,7 @@
 nouveau_sysfs_init(struct drm_device *dev)
 {
 	struct nouveau_drm *drm = nouveau_drm(dev);
+	struct nouveau_device *device = nv_device(drm->device);
 	struct nouveau_sysfs *sysfs;
 	int ret;
  
@@ -156,7 +158,7 @@
 	ret = nouveau_object_new(nv_object(drm), NVDRM_DEVICE, NVDRM_CONTROL,
 				 NV_CONTROL_CLASS, NULL, 0, &sysfs->ctrl);
 	if (ret == 0)
-		device_create_file(&dev->pdev->dev, &dev_attr_pstate);
+		device_create_file(nv_device_base(device), &dev_attr_pstate);
  
 	return 0;
 }
@@ -354,21 +354,26 @@
 nouveau_ttm_init(struct nouveau_drm *drm)
 {
 	struct drm_device *dev = drm->dev;
+	struct nouveau_device *device = nv_device(drm->device);
 	u32 bits;
 	int ret;
  
 	bits = nouveau_vmmgr(drm->device)->dma_bits;
-	if ( drm->agp.stat == ENABLED ||
-	    !pci_dma_supported(dev->pdev, DMA_BIT_MASK(bits)))
-		bits = 32;
+	if (nv_device_is_pci(device)) {
+		if (drm->agp.stat == ENABLED ||
+		     !pci_dma_supported(dev->pdev, DMA_BIT_MASK(bits)))
+			bits = 32;
  
-	ret = pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(bits));
-	if (ret)
-		return ret;
+		ret = pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(bits));
+		if (ret)
+			return ret;
  
-	ret = pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(bits));
-	if (ret)
-		pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32));
+		ret = pci_set_consistent_dma_mask(dev->pdev,
+						  DMA_BIT_MASK(bits));
+		if (ret)
+			pci_set_consistent_dma_mask(dev->pdev,
+						    DMA_BIT_MASK(32));
+	}
  
 	ret = nouveau_ttm_global_init(drm);
 	if (ret)
@@ -396,8 +401,8 @@
 		return ret;
 	}
  
-	drm->ttm.mtrr = arch_phys_wc_add(pci_resource_start(dev->pdev, 1),
-					 pci_resource_len(dev->pdev, 1));
+	drm->ttm.mtrr = arch_phys_wc_add(nv_device_resource_start(device, 1),
+					 nv_device_resource_len(device, 1));
  
 	/* GART init */
 	if (drm->agp.stat != ENABLED) {
@@ -84,6 +84,11 @@
 {
 	struct drm_device *dev = drm->dev;
 	bool runtime = false;
+
+	/* only relevant for PCI devices */
+	if (!dev->pdev)
+		return;
+
 	vga_client_register(dev->pdev, dev, NULL, nouveau_vga_set_decode);
  
 	if (nouveau_runtime_pm == 1)
...	...	@@ -131,8 +131,8 @@
131	131	if (ret)
132	132	return ret;
133	133
134		- mmio_base = pci_resource_start(device->pdev, 0);
135		- mmio_size = pci_resource_len(device->pdev, 0);
	134	+ mmio_base = nv_device_resource_start(device, 0);
	135	+ mmio_size = nv_device_resource_len(device, 0);
136	136
137	137	/* translate api disable mask into internal mapping */
138	138	disable = args->debug0;
...	...	@@ -448,6 +448,72 @@
448	448	nouveau_engine_destroy(&device->base);
449	449	}
450	450
	451	+resource_size_t
	452	+nv_device_resource_start(struct nouveau_device *device, unsigned int bar)
	453	+{
	454	+ if (nv_device_is_pci(device)) {
	455	+ return pci_resource_start(device->pdev, bar);
	456	+ } else {
	457	+ struct resource *res;
	458	+ res = platform_get_resource(device->platformdev,
	459	+ IORESOURCE_MEM, bar);
	460	+ if (!res)
	461	+ return 0;
	462	+ return res->start;
	463	+ }
	464	+}
	465	+
	466	+resource_size_t
	467	+nv_device_resource_len(struct nouveau_device *device, unsigned int bar)
	468	+{
	469	+ if (nv_device_is_pci(device)) {
	470	+ return pci_resource_len(device->pdev, bar);
	471	+ } else {
	472	+ struct resource *res;
	473	+ res = platform_get_resource(device->platformdev,
	474	+ IORESOURCE_MEM, bar);
	475	+ if (!res)
	476	+ return 0;
	477	+ return resource_size(res);
	478	+ }
	479	+}
	480	+
	481	+dma_addr_t
	482	+nv_device_map_page(struct nouveau_device device, struct page page)
	483	+{
	484	+ dma_addr_t ret;
	485	+
	486	+ if (nv_device_is_pci(device)) {
	487	+ ret = pci_map_page(device->pdev, page, 0, PAGE_SIZE,
	488	+ PCI_DMA_BIDIRECTIONAL);
	489	+ if (pci_dma_mapping_error(device->pdev, ret))
	490	+ ret = 0;
	491	+ } else {
	492	+ ret = page_to_phys(page);
	493	+ }
	494	+
	495	+ return ret;
	496	+}
	497	+
	498	+void
	499	+nv_device_unmap_page(struct nouveau_device *device, dma_addr_t addr)
	500	+{
	501	+ if (nv_device_is_pci(device))
	502	+ pci_unmap_page(device->pdev, addr, PAGE_SIZE,
	503	+ PCI_DMA_BIDIRECTIONAL);
	504	+}
	505	+
	506	+int
	507	+nv_device_get_irq(struct nouveau_device *device, bool stall)
	508	+{
	509	+ if (nv_device_is_pci(device)) {
	510	+ return device->pdev->irq;
	511	+ } else {
	512	+ return platform_get_irq_byname(device->platformdev,
	513	+ stall ? "stall" : "nonstall");
	514	+ }
	515	+}
	516	+
451	517	static struct nouveau_oclass
452	518	nouveau_device_oclass = {
453	519	.handle = NV_ENGINE(DEVICE, 0x00),
...	...	@@ -459,8 +525,8 @@
459	525	};
460	526
461	527	int
462		-nouveau_device_create_(struct pci_dev pdev, u64 name, const char sname,
463		- const char cfg, const char dbg,
	528	+nouveau_device_create_(void *dev, enum nv_bus_type type, u64 name,
	529	+ const char sname, const char cfg, const char *dbg,
464	530	int length, void **pobject)
465	531	{
466	532	struct nouveau_device *device;
...	...	@@ -478,7 +544,14 @@
478	544	if (ret)
479	545	goto done;
480	546
481		- device->pdev = pdev;
	547	+ switch (type) {
	548	+ case NOUVEAU_BUS_PCI:
	549	+ device->pdev = dev;
	550	+ break;
	551	+ case NOUVEAU_BUS_PLATFORM:
	552	+ device->platformdev = dev;
	553	+ break;
	554	+ }
482	555	device->handle = name;
483	556	device->cfgopt = cfg;
484	557	device->dbgopt = dbg;
...	...	@@ -119,7 +119,7 @@
119	119	snprintf(name, sizeof(name), "nouveau/nv%02x_fuc%03x",
120	120	device->chipset, falcon->addr >> 12);
121	121
122		- ret = request_firmware(&fw, name, &device->pdev->dev);
	122	+ ret = request_firmware(&fw, name, nv_device_base(device));
123	123	if (ret == 0) {
124	124	falcon->code.data = vmemdup(fw->data, fw->size);
125	125	falcon->code.size = fw->size;
...	...	@@ -138,7 +138,7 @@
138	138	snprintf(name, sizeof(name), "nouveau/nv%02x_fuc%03xd",
139	139	device->chipset, falcon->addr >> 12);
140	140
141		- ret = request_firmware(&fw, name, &device->pdev->dev);
	141	+ ret = request_firmware(&fw, name, nv_device_base(device));
142	142	if (ret) {
143	143	nv_error(falcon, "unable to load firmware data\n");
144	144	return ret;
...	...	@@ -153,7 +153,7 @@
153	153	snprintf(name, sizeof(name), "nouveau/nv%02x_fuc%03xc",
154	154	device->chipset, falcon->addr >> 12);
155	155
156		- ret = request_firmware(&fw, name, &device->pdev->dev);
	156	+ ret = request_firmware(&fw, name, nv_device_base(device));
157	157	if (ret) {
158	158	nv_error(falcon, "unable to load firmware code\n");
159	159	return ret;
...	...	@@ -86,7 +86,7 @@
86	86	}
87	87
88	88	/* map fifo control registers */
89		- chan->user = ioremap(pci_resource_start(device->pdev, bar) + addr +
	89	+ chan->user = ioremap(nv_device_resource_start(device, bar) + addr +
90	90	(chan->chid * size), size);
91	91	if (!chan->user)
92	92	return -EFAULT;
...	...	@@ -349,7 +349,7 @@
349	349	nv_wr32(priv, NV10_PGRAPH_SURFACE, tmp);
350	350
351	351	/* begin RAM config */
352		- vramsz = pci_resource_len(nv_device(priv)->pdev, 0) - 1;
	352	+ vramsz = nv_device_resource_len(nv_device(priv), 0) - 1;
353	353	nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
354	354	nv_wr32(priv, 0x4009A8, nv_rd32(priv, 0x100204));
355	355	nv_wr32(priv, NV10_PGRAPH_RDI_INDEX, 0x00EA0000);
...	...	@@ -484,7 +484,7 @@
484	484	engine->tile_prog(engine, i);
485	485
486	486	/* begin RAM config */
487		- vramsz = pci_resource_len(nv_device(priv)->pdev, 0) - 1;
	487	+ vramsz = nv_device_resource_len(nv_device(priv), 0) - 1;
488	488	switch (nv_device(priv)->chipset) {
489	489	case 0x40:
490	490	nv_wr32(priv, 0x4009A4, nv_rd32(priv, 0x100200));
...	...	@@ -1091,10 +1091,10 @@
1091	1091	int ret;
1092	1092
1093	1093	snprintf(f, sizeof(f), "nouveau/nv%02x_%s", device->chipset, fwname);
1094		- ret = request_firmware(&fw, f, &device->pdev->dev);
	1094	+ ret = request_firmware(&fw, f, nv_device_base(device));
1095	1095	if (ret) {
1096	1096	snprintf(f, sizeof(f), "nouveau/%s", fwname);
1097		- ret = request_firmware(&fw, f, &device->pdev->dev);
	1097	+ ret = request_firmware(&fw, f, nv_device_base(device));
1098	1098	if (ret) {
1099	1099	nv_error(priv, "failed to load %s\n", fwname);
1100	1100	return ret;
...	...	@@ -112,7 +112,7 @@
112	112	snprintf(name, sizeof(name), "nouveau/nv84_xuc%03x",
113	113	xtensa->addr >> 12);
114	114
115		- ret = request_firmware(&fw, name, &device->pdev->dev);
	115	+ ret = request_firmware(&fw, name, nv_device_base(device));
116	116	if (ret) {
117	117	nv_warn(xtensa, "unable to load firmware %s\n", name);
118	118	return ret;
...	...	@@ -66,6 +66,7 @@
66	66	struct list_head head;
67	67
68	68	struct pci_dev *pdev;
	69	+ struct platform_device *platformdev;
69	70	u64 handle;
70	71
71	72	const char *cfgopt;
...	...	@@ -141,6 +142,34 @@
141	142	device->pdev->subsystem_vendor == ven &&
142	143	device->pdev->subsystem_device == sub;
143	144	}
	145	+
	146	+static inline bool
	147	+nv_device_is_pci(struct nouveau_device *device)
	148	+{
	149	+ return device->pdev != NULL;
	150	+}
	151	+
	152	+static inline struct device *
	153	+nv_device_base(struct nouveau_device *device)
	154	+{
	155	+ return nv_device_is_pci(device) ? &device->pdev->dev :
	156	+ &device->platformdev->dev;
	157	+}
	158	+
	159	+resource_size_t
	160	+nv_device_resource_start(struct nouveau_device *device, unsigned int bar);
	161	+
	162	+resource_size_t
	163	+nv_device_resource_len(struct nouveau_device *device, unsigned int bar);
	164	+
	165	+dma_addr_t
	166	+nv_device_map_page(struct nouveau_device device, struct page page);
	167	+
	168	+void
	169	+nv_device_unmap_page(struct nouveau_device *device, dma_addr_t addr);
	170	+
	171	+int
	172	+nv_device_get_irq(struct nouveau_device *device, bool stall);
144	173
145	174	#endif
...	...	@@ -3,11 +3,20 @@
3	3
4	4	#include <core/device.h>
5	5
6		-#define nouveau_device_create(p,n,s,c,d,u) \
7		- nouveau_device_create_((p), (n), (s), (c), (d), sizeof(u), (void )u)
	6	+struct platform_device;
8	7
9		-int nouveau_device_create_(struct pci_dev , u64 name, const char sname,
10		- const char cfg, const char dbg, int, void **);
	8	+enum nv_bus_type {
	9	+ NOUVEAU_BUS_PCI,
	10	+ NOUVEAU_BUS_PLATFORM,
	11	+};
	12	+
	13	+#define nouveau_device_create(p,t,n,s,c,d,u) \
	14	+ nouveau_device_create_((void *)(p), (t), (n), (s), (c), (d), \
	15	+ sizeof(u), (void )u)
	16	+
	17	+int nouveau_device_create_(void *, enum nv_bus_type type, u64 name,
	18	+ const char sname, const char cfg, const char *dbg,
	19	+ int, void **);
11	20
12	21	int nv04_identify(struct nouveau_device *);
13	22	int nv10_identify(struct nouveau_device *);
...	...	@@ -12,6 +12,7 @@
12	12	struct nouveau_mc {
13	13	struct nouveau_subdev base;
14	14	bool use_msi;
	15	+ unsigned int irq;
15	16	};
16	17
17	18	static inline struct nouveau_mc *