Index: gbefb.c
===================================================================
RCS file: /home/cvs/linux/drivers/video/gbefb.c,v
retrieving revision 1.3
diff -u -r1.3 gbefb.c
--- gbefb.c	6 Jun 2004 02:12:49 -0000	1.3
+++ gbefb.c	18 Aug 2004 21:40:45 -0000
@@ -29,6 +29,7 @@
 #endif
 #include <asm/byteorder.h>
 #include <asm/io.h>
+#include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
 
 #include <video/gbe.h>
@@ -54,7 +55,7 @@
 #ifdef CONFIG_CPU_R10000
 #define pgprot_fb(_prot) (((_prot) & (~_CACHE_MASK)) | _CACHE_UNCACHED_ACCELERATED)
 #else
-#define pgprot_fb(_prot) (((_prot) & (~_CACHE_MASK)) | _CACHE_CACHABLE_NO_WA)
+#define pgprot_fb(_prot) (((_prot) & (~_CACHE_MASK)) | _CACHE_CACHABLE_NO_WA )
 #endif
 #endif
 #ifdef CONFIG_X86
@@ -85,7 +86,6 @@
 
 static int gbe_revision;
 
-static struct fb_info fb_info;
 static int ypan, ywrap;
 
 static uint32_t pseudo_palette[256];
@@ -389,6 +389,9 @@
 		break;
 
 	case 1:		/* blank */
+	case 2:
+	case 3:
+	case 4:
 		gbe_turn_off();
 		break;
 
@@ -659,12 +662,15 @@
 	switch (bytesPerPixel) {
 	case 1:
 		SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_I8);
+		info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
 		break;
 	case 2:
 		SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_ARGB5);
+		info->fix.visual = FB_VISUAL_TRUECOLOR;
 		break;
 	case 4:
 		SET_GBE_FIELD(WID, TYP, val, GBE_CMODE_RGB8);
+		info->fix.visual = FB_VISUAL_TRUECOLOR;
 		break;
 	}
 	SET_GBE_FIELD(WID, BUF, val, GBE_BMODE_BOTH);
@@ -793,8 +799,12 @@
 
 	/* Initialize the gamma map */
 	udelay(10);
-	for (i = 0; i < 256; i++)
+	for (i = 0; i < 256; i++) {
 		gbe->gmap[i] = (i << 24) | (i << 16) | (i << 8);
+		udelay(10);
+	}
+
+	udelay(10);
 
 	/* Initialize the color map */
 	for (i = 0; i < 256; i++) {
@@ -927,8 +937,8 @@
 		var->yoffset = info->var.yoffset;
 	}
 
-	/* No grayscale for now */
-	var->grayscale = 0;
+	var->xoffset = 0;
+	var->yoffset = 0;
 
 	/* Memory limit */
 	line_length = var->xres_virtual * var->bits_per_pixel / 8;
@@ -1002,7 +1012,7 @@
 	pgprot_val(vma->vm_page_prot) =
 		pgprot_fb(pgprot_val(vma->vm_page_prot));
 
-	vma->vm_flags |= VM_IO | VM_RESERVED;
+	vma->vm_flags |= ( VM_IO | VM_RESERVED ) ;
 	vma->vm_file = file;
 
 	/* look for the starting tile */
@@ -1031,6 +1041,7 @@
 	return 0;
 }
 
+
 static struct fb_ops gbefb_ops = {
 	.owner		= THIS_MODULE,
 	.fb_check_var	= gbefb_check_var,
@@ -1045,6 +1056,56 @@
 };
 
 /*
+ * sysfs
+ */
+
+static ssize_t gbefb_show_memsize(struct device *device, char *buf)
+{
+	struct platform_device *dev = to_platform_device(device);
+	struct fb_info          *info = dev_get_drvdata(&dev->dev);
+
+    if (dev == NULL)
+        return 0;
+
+    return snprintf(buf, PAGE_SIZE, "%d\n", 
+            gbe_mem_size);
+}
+
+static DEVICE_ATTR(size, S_IRUGO, gbefb_show_memsize, NULL);
+
+static ssize_t gbefb_show_rev(struct device *device, char *buf)
+{
+	struct platform_device *dev = to_platform_device(device);
+	struct fb_info          *info = dev_get_drvdata(&dev->dev);
+
+    if (dev == NULL)
+        return 0;
+
+    return snprintf(buf, PAGE_SIZE, "%d\n", 
+            gbe_revision);
+}
+
+static DEVICE_ATTR(revision, S_IRUGO, gbefb_show_rev, NULL);
+
+static void gbefb_remove_sysfs(struct device *dev)
+{
+	device_remove_file(dev, &dev_attr_size);
+	device_remove_file(dev, &dev_attr_revision);
+}
+
+static int gbefb_create_sysfs(struct device *dev) 
+{
+	int ret;
+
+	if ((ret = device_create_file(dev, &dev_attr_size)) ||
+    	(ret = device_create_file(dev, &dev_attr_revision))) {
+		printk(KERN_ERR "gbefb: unable to create sysfs files\n");
+		gbefb_remove_sysfs(dev);
+	}
+	return ret;
+}
+
+/*
  * Initialization
  */
 
@@ -1079,15 +1140,25 @@
 	return 0;
 }
 
-int __init gbefb_init(void)
+int __init gbefb_probe(struct device *device)
 {
 	int i, ret = 0;
+	struct platform_device *dev = to_platform_device(device);
+	struct fb_info *info;
+	unsigned long page, gbe_mem_cac;
+
+	info = framebuffer_alloc(sizeof(struct fb_info), &dev->dev);
+	if (!info)
+		return -ENOMEM;
 
 	if (!request_mem_region(GBE_BASE, sizeof(struct sgi_gbe), "GBE")) {
 		printk(KERN_ERR "gbefb: couldn't reserve mmio region\n");
+		framebuffer_release(info);
 		return -EBUSY;
 	}
 
+	device->coherent_dma_mask = 0xffffffff;
+
 	gbe = (struct sgi_gbe *) ioremap(GBE_BASE, sizeof(struct sgi_gbe));
 	if (!gbe) {
 		printk(KERN_ERR "gbefb: couldn't map mmio region\n");
@@ -1097,7 +1168,7 @@
 	gbe_revision = gbe->ctrlstat & 15;
 
 	gbe_tiles.cpu =
-		dma_alloc_coherent(NULL, GBE_TLB_SIZE * sizeof(uint16_t),
+		dma_alloc_coherent(device, GBE_TLB_SIZE * sizeof(uint16_t),
 				   &gbe_tiles.dma, GFP_KERNEL);
 	if (!gbe_tiles.cpu) {
 		printk(KERN_ERR "gbefb: couldn't allocate tiles table\n");
@@ -1105,19 +1176,35 @@
 		goto out_unmap;
 	}
 
-
 	if (gbe_mem_phys) {
+		printk(KERN_ERR "gbefb: memory already allocated\n");
 		/* memory was allocated at boot time */
 		gbe_mem = ioremap_nocache(gbe_mem_phys, gbe_mem_size);
 		gbe_dma_addr = 0;
 	} else {
+		printk(KERN_ERR "gbefb: allocating memory\n");
 		/* try to allocate memory with the classical allocator
 		 * this has high chance to fail on low memory machines */
-		gbe_mem = dma_alloc_coherent(NULL, gbe_mem_size, &gbe_dma_addr,
+		gbe_mem = dma_alloc_coherent(device, gbe_mem_size, &gbe_dma_addr,
 					     GFP_KERNEL);
 		gbe_mem_phys = (unsigned long) gbe_dma_addr;
+
 	}
 
+	/* dma_alloc_coherent gives us a "wrong" (UNCAC_ADDR) address, so doing 
+	 * SetPageReserved there has no effect. Use the CAC_ADDR address to do
+	 * SetPageReserved in the correct place. This fixed mmap access...
+	 * XXX: is the above correct ? 
+	 */
+	gbe_mem_cac= (unsigned long)CAC_ADDR(gbe_mem);
+
+	for (page = (unsigned long)gbe_mem_cac; 
+		page < PAGE_ALIGN( ((unsigned long)(gbe_mem_cac + gbe_mem_size)));
+		page += PAGE_SIZE)
+			SetPageReserved(virt_to_page(page));
+
+	flush_cache_all();
+
 #ifdef CONFIG_X86
 	mtrr_add(gbe_mem_phys, gbe_mem_size, MTRR_TYPE_WRCOMB, 1);
 #endif
@@ -1132,33 +1219,36 @@
 	for (i = 0; i < (gbe_mem_size >> TILE_SHIFT); i++)
 		gbe_tiles.cpu[i] = (gbe_mem_phys >> TILE_SHIFT) + i;
 
-	fb_info.currcon = -1;
-	fb_info.fbops = &gbefb_ops;
-	fb_info.pseudo_palette = pseudo_palette;
-	fb_info.flags = FBINFO_FLAG_DEFAULT;
-	fb_info.screen_base = gbe_mem;
-	fb_alloc_cmap(&fb_info.cmap, 256, 0);
+	info->currcon = -1;
+	info->fbops = &gbefb_ops;
+	info->pseudo_palette = pseudo_palette;
+	info->flags = FBINFO_FLAG_DEFAULT;
+	info->screen_base = gbe_mem;
+	fb_alloc_cmap(&info->cmap, 256, 0);
 
 	/* reset GBE */
 	gbe_reset();
 
 	/* turn on default video mode */
-	if (fb_find_mode(&par_current.var, &fb_info, mode_option, NULL, 0,
+	if (fb_find_mode(&par_current.var, info, mode_option, NULL, 0,
 			 default_mode, 8) == 0)
 		par_current.var = *default_var;
-	fb_info.var = par_current.var;
-	gbefb_check_var(&par_current.var, &fb_info);
-	gbefb_encode_fix(&fb_info.fix, &fb_info.var);
-	fb_info.par = &par_current;
+	info->var = par_current.var;
+	gbefb_check_var(&par_current.var, info);
+	gbefb_encode_fix(&info->fix, &info->var);
+	info->par = &par_current;
 
-	if (register_framebuffer(&fb_info) < 0) {
+	if (register_framebuffer(info) < 0) {
 		ret = -ENXIO;
 		printk(KERN_ERR "gbefb: couldn't register framebuffer\n");
 		goto out_gbe_unmap;
 	}
 
+	dev_set_drvdata(&dev->dev, info);
+	gbefb_create_sysfs(device);
+
 	printk(KERN_INFO "fb%d: %s rev %d @ 0x%08x using %dkB memory\n",
-	       fb_info.node, fb_info.fix.id, gbe_revision, (unsigned) GBE_BASE,
+	       info->node, info->fix.id, gbe_revision, (unsigned) GBE_BASE,
 	       gbe_mem_size >> 10);
 
 	return 0;
@@ -1175,12 +1265,30 @@
 	iounmap(gbe);
 out_release_mem_region:
 	release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
+	framebuffer_release(info);
 	return ret;
 }
 
-void __exit gbefb_exit(void)
+static int __devexit gbefb_remove(struct device* device);
+
+static struct device_driver gbefb_driver = {
+	.name = "gbefb",
+	.bus = &platform_bus_type,
+	.probe = gbefb_probe,
+	.remove = gbefb_remove,
+};
+
+static struct platform_device gbefb_device = {
+	.name = "gbefb",
+	.id = 0,
+};
+
+static int __devexit gbefb_remove(struct device* device)
 {
-	unregister_framebuffer(&fb_info);
+	struct platform_device *dev = to_platform_device(device);
+	struct fb_info          *info = dev_get_drvdata(&dev->dev);
+
+	unregister_framebuffer(info);
 	gbe_turn_off();
 	if (gbe_dma_addr)
 		dma_free_coherent(NULL, gbe_mem_size, gbe_mem, gbe_mem_phys);
@@ -1190,6 +1298,29 @@
 			  (void *)gbe_tiles.cpu, gbe_tiles.dma);
 	release_mem_region(GBE_BASE, sizeof(struct sgi_gbe));
 	iounmap(gbe);
+	
+	framebuffer_release(info);
+	
+	return 0;	
+}
+
+void __devexit gbefb_exit(void)
+{
+	 driver_unregister(&gbefb_driver);
+}
+
+int __init gbefb_init(void)
+{
+	int ret;
+
+	ret = driver_register(&gbefb_driver);
+
+	if (!ret) {
+		ret = platform_device_register(&gbefb_device);
+		 if (ret)
+			 driver_unregister(&gbefb_driver);
+	}
+	return ret;
 }
 
 #ifdef MODULE