[PATCH] DCON: Add the DCON platform device

Jordan Crouse jordan.crouse at amd.com
Tue Nov 7 22:37:12 EST 2006


Commit:     aca4163a73dc442bfe24ab1e1462513504c162df
Parent:     89ca0c5a674fcf78fd87bb541e75ae3139422ecb
commit aca4163a73dc442bfe24ab1e1462513504c162df
Author:     Jordan Crouse <jordan.crouse at amd.com>
AuthorDate: Thu Oct 5 16:51:32 2006 -0600
Commit:     Jordan Crouse <jordan.crouse at amd.com>
CommitDate: Fri Oct 6 09:26:07 2006 -0600

    [PATCH] DCON:  Add the DCON platform device
---
 arch/i386/kernel/olpc.c           |    4 
 drivers/video/backlight/dcon_bl.c |    6 -
 drivers/video/geode/gxfb_core.c   |   17 +
 drivers/video/geode/gxfb_dcon.c   |  444 +++++++++++++++++++++++--------------
 drivers/video/geode/gxfb_dcon.h   |   12 +
 5 files changed, 297 insertions(+), 186 deletions(-)

diff --git a/arch/i386/kernel/olpc.c b/arch/i386/kernel/olpc.c
index ffa4823..33ac22d 100644
--- a/arch/i386/kernel/olpc.c
+++ b/arch/i386/kernel/olpc.c
@@ -1,4 +1,4 @@
-/* Support for the OLPC Childrens Machine
+/* Support for the OLPC DCON
  * Copyright (C) 2006, Advanced Micro Devices, Inc.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -25,7 +25,7 @@ static int __init olpc_init(void) {
 
   unsigned char val;
 
-  /* Read the DCON present bit and set the flag accordingly */
+  /* Read the DCON present bit in the CMOS and set the flag accordingly */
 
   val = CMOS_READ(OLPC_CMOS_DCON_OFFSET);
   olpc_dcon_present = (val & OLPC_CMOS_DCON_MASK);
diff --git a/drivers/video/backlight/dcon_bl.c b/drivers/video/backlight/dcon_bl.c
index d356c36..78403da 100644
--- a/drivers/video/backlight/dcon_bl.c
+++ b/drivers/video/backlight/dcon_bl.c
@@ -27,12 +27,12 @@ static int dconbl_set(struct backlight_d
 	if (power != FB_BLANK_UNBLANK)
 	  level = 0;
 
-	gxfb_dcon_setbl(level);
+	dcon_set_backlight(level);
 	return 0;
 }
 
 static int dconbl_get(struct backlight_device *dev) {
-	return gxfb_dcon_getbl();
+	return dcon_get_backlight();
 }
 
 static struct backlight_properties dcon_data = {
@@ -49,7 +49,7 @@ static int dconbl_probe(struct platform_
 	if (IS_ERR(dconbl_dev))
 		return PTR_ERR(dconbl_dev);
 	
-	dcon_data.brightness = gxfb_dcon_getbl();
+	dcon_data.brightness = dcon_get_backlight();
 	return 0;
 }
 
diff --git a/drivers/video/geode/gxfb_core.c b/drivers/video/geode/gxfb_core.c
index ab14dda..7617e3d 100644
--- a/drivers/video/geode/gxfb_core.c
+++ b/drivers/video/geode/gxfb_core.c
@@ -121,8 +121,6 @@ static const struct fb_videomode gx_dcon
 extern int olpc_dcon_present;
 #endif
 
-unsigned long gxfb_dc_regs;
-EXPORT_SYMBOL(gxfb_dc_regs);
 
 static int gxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 {
@@ -249,8 +247,6 @@ static int __init gxfb_map_video_memory(
 	if (!par->dc_regs)
 		return -ENOMEM;
 
-	gxfb_dc_regs = par->dc_regs;
-
 	ret = pci_request_region(dev, 0, "gxfb (framebuffer)");
 	if (ret < 0)
 		return ret;
@@ -281,13 +277,14 @@ static int __init gxfb_map_video_memory(
 	return 0;
 }
 
-int (*gxfb_ioctl_func)(struct fb_info *info, unsigned int cmd, unsigned long arg);
+int (*gxfb_ioctl_func)(struct fb_info *, unsigned int, unsigned long);
 EXPORT_SYMBOL(gxfb_ioctl_func);
 
-gxfb_ioctl( struct fb_info *info, unsigned int cmd, unsigned long arg) {
-  
+static int gxfb_ioctl( struct fb_info *info, unsigned int cmd,
+		       unsigned long arg)
+{
 	int ret = -ENOTTY;
-  
+
 	if (gxfb_ioctl_func != NULL)
 		ret = gxfb_ioctl_func(info, cmd, arg);
 
@@ -346,7 +343,8 @@ static struct fb_info * __init gxfb_init
 	return info;
 }
 
-static int __init gxfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+static int __init gxfb_probe(struct pci_dev *pdev,
+			     const struct pci_device_id *id)
 {
 	struct geodefb_par *par;
 	struct fb_info *info;
@@ -359,6 +357,7 @@ static int __init gxfb_probe(struct pci_
 	info = gxfb_init_fbinfo(&pdev->dev);
 	if (!info)
 		return -ENOMEM;
+
 	par = info->par;
 
 	/* GX display controller and GX video device. */
diff --git a/drivers/video/geode/gxfb_dcon.c b/drivers/video/geode/gxfb_dcon.c
index ec1489a..e745e89 100644
--- a/drivers/video/geode/gxfb_dcon.c
+++ b/drivers/video/geode/gxfb_dcon.c
@@ -1,6 +1,6 @@
 /*
  *  Mainly by David Woodhouse, somewhat modified by Jordan Crouse
- *  
+ *
  * Jordan's work is copyright (C) 2006 Advanced Micro Devices, Inc.
  *
  * This program is free software.  You can redistribute it and/or
@@ -16,9 +16,13 @@ #include "geodefb.h"
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/i2c-id.h>
+#include <linux/pci.h>
+#include <linux/pci_ids.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
+#include <linux/device.h>
 #include <asm/uaccess.h>
+#include <linux/ctype.h>
 #include <asm/tsc.h>
 
 #include "gxfb_dcon.h"
@@ -47,176 +51,167 @@ static struct i2c_driver dcon_driver;
 static struct i2c_client *dcon_client;
 
 /* Platform devices */
-static struct platform_device *dcon_bl_dev;
+static struct platform_device *dcon_device;
+static struct platform_device *dconbl_device;
 
 /* Base address of the GPIO registers */
 static unsigned long gpio_base;
 
+/* fbinfo from the GX framebuffer driver */
+static struct fb_info *fbinfo;
+
 /* Current source */
 static int dcon_source = DCON_SOURCE_CPU;
 
 /* Current output type */
 static int dcon_output = DCON_OUTPUT_COLOR;
 
+/* Current sleep status (not yet implemented) */
+static int dcon_sleep = DCON_ACTIVE;
+
 /* Shadow register for the DCON_REG_MODE register */
 static unsigned short dcon_disp_mode;
 
 /* Variables used during switches */
-int dcon_waiting;
+static int dcon_switched;
 
-static DECLARE_WAIT_QUEUE_HEAD(dcon_mode_wq);
-extern unsigned long gxfb_dc_regs;
+static DECLARE_WAIT_QUEUE_HEAD(dcon_wait_queue);
 
 extern int gxfb_powerdown(struct fb_info *info);
 extern int gxfb_powerup(struct fb_info *info);
 
+extern int (*gxfb_ioctl_func)(struct fb_info *, unsigned int, unsigned long);
+
+static unsigned short normal_i2c[] = { 0x0D, I2C_CLIENT_END };
+I2C_CLIENT_INSMOD;
 
 #define dcon_write(reg,val) i2c_smbus_write_word_data(dcon_client,reg,val)
 #define dcon_read(reg) i2c_smbus_read_word_data(dcon_client,reg)
 
 /* ===== API functions - these are called by a variety of users ==== */
 
+/* The current backlight value - this saves us some smbus traffic */
 static int gxfb_bl_val = -1;
 
-/* To cut down on SMBUS, we assume that getbl and setbl are the only entities that change the BL,
-   so we shadow the variable
-*/
-
-int gxfb_dcon_getbl(void) {
+/* Backlight notes - turning off the backlight enable bit in the DCON
+ * doesn't save us any power over just pushing the BL to zero, so we
+ * don't use that bit in this code.
+ */
 
-  if (dcon_client == NULL)
-    return 0;
+int dcon_get_backlight(void)
+{
+	if (dcon_client == NULL)
+		return 0;
 
-  if (gxfb_bl_val == -1)
-	  gxfb_bl_val = dcon_read(DCON_REG_BRIGHT) & 0x0F;
+	if (gxfb_bl_val == -1)
+		gxfb_bl_val = dcon_read(DCON_REG_BRIGHT) & 0x0F;
 
-  return (dcon_disp_mode & MODE_BL_ENABLE) ? gxfb_bl_val : 0;
+	return gxfb_bl_val;
 }
 
-void gxfb_dcon_setbl(int level) {
+void dcon_set_backlight(int level)
+{
+	if (dcon_client == NULL)
+		return;
 
-  if (dcon_client == NULL)
-    return;
+	if (gxfb_bl_val == (level & 0x0F))
+		return;
 
-  if (level == 0) {
-	  if ((dcon_disp_mode & MODE_BL_ENABLE)) {
-		  dcon_disp_mode &= ~MODE_BL_ENABLE;
-		  dcon_write(DCON_REG_MODE, dcon_disp_mode);
-	  }
+	gxfb_bl_val = level & 0x0F;
+	dcon_write(DCON_REG_BRIGHT, gxfb_bl_val);
+}
+
+/* Set the output type to either color or mono */
+
+static int dcon_set_output(int arg)
+{
+	if (dcon_output == arg)
+		return 0;
 
-	  return;
-  }
+	dcon_output = arg;
 
-  if (!(dcon_disp_mode & MODE_BL_ENABLE)) {
-	  dcon_disp_mode |= MODE_BL_ENABLE;
-	  dcon_write(DCON_REG_MODE, dcon_disp_mode);
-  }
+	if (arg == DCON_OUTPUT_MONO) {
+		dcon_disp_mode &= ~(MODE_CSWIZZLE | MODE_COL_AA);
+		dcon_disp_mode |= MODE_MONO_LUMA;
+	}
+	else {
+		dcon_disp_mode &= ~(MODE_MONO_LUMA);
+		dcon_disp_mode |= (MODE_CSWIZZLE | MODE_COL_AA);
+	}
 
-  gxfb_bl_val = level & 0x0F;
-  dcon_write(DCON_REG_BRIGHT, gxfb_bl_val);
+	dcon_write(DCON_REG_MODE, dcon_disp_mode);
+	return 0;
 }
 
-EXPORT_SYMBOL(gxfb_dcon_getbl);
-EXPORT_SYMBOL(gxfb_dcon_setbl);
+EXPORT_SYMBOL(dcon_get_backlight);
+EXPORT_SYMBOL(dcon_set_backlight);
 
-static int dcon_set_source(struct fb_info *info, int arg)
-{
-	struct geodefb_par *par = info->par;
+/* Set the source of the display (CPU or DCON) */
 
+static int dcon_set_source(int arg)
+{
 	if (dcon_source == arg)
 		return 0;
 
 	dcon_source = arg;
 
+	DECLARE_WAITQUEUE(wait, current);
+
+	dcon_switched = 0;
+
 	if (arg == DCON_SOURCE_CPU) {
-		unsigned long timeo = jiffies + (10 * HZ);
-		unsigned long scanline1, scanline2;
 
-		/* Power up the graphics engine */
-		gxfb_powerup(info);
+		/* FIXME:  Set the task uninterruptable for this bit? */
 
-		/* Wait for up to a second for our output to coincide with
-		   DCON's */
+		/* Enable the scanline interrupt bit */
+		dcon_write(DCON_REG_MODE, dcon_disp_mode | MODE_SCAN_INT);
 
-		while (time_before(jiffies, timeo)) {
-			unsigned long dconblnk =
-				(inl(gpio_base + GPIOx_READ_BACK) >> 12) & 1;
-			scanline1 =
-				readl((void __iomem *)(gxfb_dc_regs + 0x6c));
-			scanline1 >>= 16;
-			scanline1 &= 0x7ff;
+		/* Wait up to one second for the mode to change */
+		wait_event_timeout(dcon_wait_queue, dcon_switched == 1, HZ);
 
-			if (!dconblnk && scanline1 >= resumeline &&
-			    scanline1 <= (resumeline+2))
-				goto ready;
+		/* Turn off the scanline interrupt */
+		dcon_write(DCON_REG_MODE, dcon_disp_mode);
 
-#if 0
-			if (!dconblnk)
-				printk("Not ready. blnk %ld, line %ld\n",
-				       dconblnk, scanline1);
-#endif
+		if (!dcon_switched) {
+			printk(KERN_ERR "dcon:  Timeout entering CPU mode\n");
+			return -1;
 		}
 
-		printk("Wait for VGA ready timed out\n");
-ready:
+		/* Turn on the graphics engine */
+		gxfb_powerup(fbinfo);
 		outl(1<<11, gpio_base + GPIOx_OUT_VAL);
-		scanline2 = readl((void __iomem *)(gxfb_dc_regs + 0x6c));
-		scanline2 >>= 16;
-		scanline2 &= 0x7ff;
-		printk("Re-enabled between %ld and %ld\n",
-				scanline1, scanline2);
 
-	} else {
+		printk(KERN_INFO "dcon: The CPU has control\n");
+	}
+	else {
 		int t;
-		DECLARE_WAITQUEUE(wait, current);
 
-		add_wait_queue(&dcon_mode_wq, &wait);
+		add_wait_queue(&dcon_wait_queue, &wait);
 		set_current_state(TASK_UNINTERRUPTIBLE);
-		dcon_waiting = 1;
 
-		/* Clear GPIO11 (DCONLOAD) - this implies that the DCON is in 
+		/* Clear GPIO11 (DCONLOAD) - this implies that the DCON is in
 		   control */
 
 		outl(1 << (11 + 16), gpio_base + GPIOx_OUT_VAL);
-		
+
 		t = schedule_timeout(HZ/2);
-		remove_wait_queue(&dcon_mode_wq, &wait);
+		remove_wait_queue(&dcon_wait_queue, &wait);
 		set_current_state(TASK_RUNNING);
 
-		if (dcon_waiting) {
-			printk("Timeout entering DCON mode\n");
+		if (!dcon_switched) {
+			printk(KERN_ERR "dcon: Timeout entering DCON mode\n");
 
-			/* Re-enable GPIO11 - we never gave up control */
+			/* Set DCONLOAD back to CPU control */
 			outl(1 << 11, gpio_base + GPIOx_OUT_VAL);
-
 			return -1;
 		}
 
 		/* Turn off the graphics engine completely */
-		gxfb_powerdown(info);
-	}
-
-	return 0;
-}
-
-static int dcon_set_output(struct fb_info *info, int arg)
-{
-	if (dcon_output == arg)
-		return 0;
-
-	dcon_output = arg;
-
-	if (arg == DCON_OUTPUT_MONO) {
-		dcon_disp_mode &= ~(MODE_CSWIZZLE | MODE_COL_AA);
-		dcon_disp_mode |= MODE_MONO_LUMA;
-	}
-	else {
-		dcon_disp_mode &= ~(MODE_MONO_LUMA);
-		dcon_disp_mode |= (MODE_CSWIZZLE | MODE_COL_AA);
+		gxfb_powerdown(fbinfo);
+		printk(KERN_INFO "dcon: The DCON has control\n");
 	}
 
-	i2c_smbus_write_word_data(dcon_client, DCON_REG_MODE, dcon_disp_mode);
-
+	dcon_source = arg;
 	return 0;
 }
 
@@ -236,9 +231,9 @@ static int gxfb_dcon_ioctl(struct fb_inf
 			return -EINVAL;
 
 		if (karg > -1)
-			ret = dcon_set_source(info, karg);
+			ret = dcon_set_source(karg);
 
-		if (ret) 
+		if (ret)
 			karg = -1;
 		else
 			karg = dcon_source;
@@ -254,9 +249,9 @@ static int gxfb_dcon_ioctl(struct fb_inf
 			return -EINVAL;
 
 		if (karg > -1)
-			ret = dcon_set_output(info, karg);
+			ret = dcon_set_output(karg);
 
-		if (ret) 
+		if (ret)
 			return ret;
 
 		karg = dcon_output;
@@ -293,11 +288,11 @@ static int gxfb_dcon_ioctl(struct fb_inf
 		karg = 0;
 		break;
 
-	case DCONIOC_SETBL:	  
+	case DCONIOC_SETBL:
 		if (get_user(karg, (int __user *)arg))
 			return -EFAULT;
 
-		gxfb_dcon_setbl(karg);
+		dcon_set_backlight(karg);
 		karg = 0;
 		break;
 
@@ -305,7 +300,7 @@ static int gxfb_dcon_ioctl(struct fb_inf
 		if (get_user(karg, (int __user *)arg))
 			return -EFAULT;
 
-		karg = gxfb_dcon_getbl();
+		karg = dcon_get_backlight();
 		break;
 
 	default:
@@ -316,22 +311,123 @@ static int gxfb_dcon_ioctl(struct fb_inf
 	return ret;
 }
 
-static unsigned short normal_i2c[] = { 0x0D, I2C_CLIENT_END };
-I2C_CLIENT_INSMOD;
+static ssize_t dcon_mode_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%4.4X\n", dcon_disp_mode);
+}
+
+static ssize_t dcon_sleep_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%d\n", dcon_sleep);
+}
+
+static ssize_t dcon_source_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%d\n", dcon_source);
+}
+
+static ssize_t dcon_output_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%d\n", dcon_output);
+}
+
+static int _strtoul(const char *buf, int len, unsigned int *val)
+{
+
+	char *endp;
+	unsigned int output = simple_strtoul(buf, &endp, 0);
+	int size = endp - buf;
+
+	if (*endp && isspace(*endp))
+		size++;
+
+	if (size != len)
+		return -EINVAL;
+
+	*val = output;
+	return 0;
+}
+
+static ssize_t dcon_output_store(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int output;
+	int rc = -EINVAL;
+
+	if (_strtoul(buf, count, &output))
+		return -EINVAL;
+
+	if (output == DCON_OUTPUT_COLOR || output == DCON_OUTPUT_MONO) {
+		dcon_set_output(output);
+		rc = count;
+	}
+
+	return rc;
+}
 
-extern int (*gxfb_ioctl_func)(struct fb_info *info, unsigned int cmd,
-		       unsigned long arg);
+static ssize_t dcon_source_store(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int output;
+	int rc = -EINVAL;
+
+	if (_strtoul(buf, count, &output))
+		return -EINVAL;
+
+	if (output == DCON_SOURCE_CPU || output == DCON_SOURCE_DCON) {
+		dcon_set_source(output);
+		rc = count;
+	}
+
+	return rc;
+}
+
+#if 0
+/* FIXME:  I haven't yet implemented sleep support */
 
+static ssize_t dcon_sleep_store(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t count)
+{
+	int output;
+	int rc = -EINVAL;
+
+	if (_strtoul(buf, count, &output))
+		return -EINVAL;
+
+	dcon_sleep(output ? DCON_SLEEP : DCON_ACTIVE);
+	return count;
+}
+#endif
+
+static struct device_attribute dcon_device_files[] = {
+	__ATTR(mode, 0444, dcon_mode_show, NULL),
+	__ATTR(sleep, 0644, dcon_sleep_show, NULL),
+	__ATTR(source, 0644, dcon_source_show, dcon_source_store),
+	__ATTR(output, 0644, dcon_output_show, dcon_output_store),
+};
 
 static int dcon_probe(struct i2c_adapter *adap, int addr, int kind)
 {
 	struct i2c_client *client;
+	struct pci_dev *dev;
 	uint16_t ver;
-	int rc;
+	int rc, i;
+
+	dev = pci_find_device(PCI_VENDOR_ID_NS,PCI_DEVICE_ID_NS_GX_VIDEO,
+			      NULL);
+
+	if (dev == NULL || (fbinfo = pci_get_drvdata(dev)) == NULL) {
+		printk(KERN_ERR "dcon:  Couldn't find the GX GPU device\n");
+		return -ENXIO;
+	}
 
 	if (adap->id != I2C_HW_SMBUS_SCX200) {
 		printk(KERN_ERR "gxfb-dcon: Invalid I2C bus (%d not %d)\n",
-				adap->id, I2C_HW_SMBUS_SCX200);
+		       adap->id, I2C_HW_SMBUS_SCX200);
 		return -ENXIO;
 	}
 
@@ -346,25 +442,17 @@ static int dcon_probe(struct i2c_adapter
 
 	if ((rc = i2c_attach_client(client)) != 0) {
 		printk(KERN_ERR "gxfb-dcon: Unable to attach the I2C client.\n");
-		kfree(client);
-		return rc;
+		goto eclient;
 	}
 
 	ver = i2c_smbus_read_word_data(client, DCON_REG_ID);
 
 	if ((ver >> 8) != 0xDC) {
-		/* Not a DCON chip? */
 		printk(KERN_ERR "gxfb-dcon: DCON ID not 0xDCxx: 0x%04x instead.\n", ver);
-		i2c_detach_client(client);
-		kfree(client);
-		return -ENXIO;
+		rc = -ENXIO;
+		goto ei2c;
 	}
 
-	printk(KERN_INFO "gxfb-dcon: Discovered DCON version %x\n", ver & 0xFF);
-
-	dcon_client = client;
-	gxfb_ioctl_func = gxfb_dcon_ioctl;
-
 	if (!noinit) {
 		/* Initialize the DCON registers */
 
@@ -377,7 +465,7 @@ static int dcon_probe(struct i2c_adapter
 			MODE_CSWIZZLE | MODE_COL_AA;
 
 		i2c_smbus_write_word_data(client, DCON_REG_MODE,
-				dcon_disp_mode);
+					  dcon_disp_mode);
 
 		/* Initialise SDRAM */
 
@@ -393,22 +481,62 @@ static int dcon_probe(struct i2c_adapter
 		i2c_smbus_write_word_data(client, 0x43, 0x0101);
 	}
 
-	/* Now create a backlight device on the platform bus - note that failures here are non fatal */
+	/* Set the scanline to interrupt on during resume */
 
-	dcon_bl_dev = platform_device_alloc("dcon-bl", -1);
+	i2c_smbus_write_word_data(client, DCON_REG_SCAN_INT, resumeline);
 
-	if (dcon_bl_dev == NULL) {
-		printk(KERN_INFO "gxfb-dcon: Couldn't allocate the BL device.\n");
-		return 0;
+	/* Add the DCON device */
+
+	dcon_device = platform_device_alloc("dcon", -1);
+
+	if (dcon_device == NULL) {
+		printk(KERN_ERR "dcon:  Unable to create the DCON device\n");
+		rc = -ENOMEM;
+		goto ei2c;
+	}
+
+	if ((rc = platform_device_add(dcon_device))) {
+		printk(KERN_ERR "dcon:  Unable to add the DCON device\n");
+		goto edev;
+	}
+
+	for(i = 0; i < ARRAY_SIZE(dcon_device_files); i++)
+		device_create_file(&dcon_device->dev, &dcon_device_files[i]);
+
+	/* Add the DCON backlight device (for use by the backlight engine) */
+
+	dconbl_device = platform_device_alloc("dcon-bl", -1);
+
+	if (dconbl_device == NULL) {
+		printk(KERN_ERR "dcon:  Unable to create the DCON backlight device\n");
+		rc = -ENOMEM;
+		goto edev;
 	}
 
-	if (platform_device_add(dcon_bl_dev)) {
-		printk(KERN_INFO "gxfb-dcon: Couldn't attach the BL device.\n");
-		platform_device_put(dcon_bl_dev);
-		dcon_bl_dev = NULL;
+	if ((rc = platform_device_add(dconbl_device))) {
+		printk(KERN_ERR "dcon:  Unable to add the DCON backlight device\n");
+		goto ebldev;
 	}
 
+	dcon_client = client;
+	gxfb_ioctl_func = gxfb_dcon_ioctl;
+
+	printk(KERN_INFO "gxfb-dcon: Discovered DCON version %x\n", ver & 0xFF);
+
 	return 0;
+
+ ebldev:
+	platform_device_unregister(dconbl_device);
+	dconbl_device = NULL;
+ edev:
+	platform_device_unregister(dcon_device);
+	dcon_device = NULL;
+ ei2c:
+	i2c_detach_client(client);
+ eclient:
+	kfree(client);
+
+	return rc;
 }
 
 static int dcon_attach(struct i2c_adapter *adap)
@@ -432,8 +560,11 @@ static int dcon_detach(struct i2c_client
 	if ((rc = i2c_detach_client(client)) == 0)
 		kfree(i2c_get_clientdata(client));
 
-	if (dcon_bl_dev != NULL)
-		platform_device_unregister(dcon_bl_dev);
+	if (dconbl_device != NULL)
+		platform_device_unregister(dconbl_device);
+
+	if (dcon_device != NULL)
+		platform_device_unregister(dcon_device);
 
 	return rc;
 }
@@ -448,45 +579,27 @@ static struct i2c_driver dcon_driver = {
 };
 
 
-
-int dcon_interrupt(int irq, void *id, struct pt_regs *regs)
+static int dcon_interrupt(int irq, void *id, struct pt_regs *regs)
 {
-	unsigned long gpios = inl(gpio_base + GPIOx_READ_BACK);
-	int dconstat = (gpios >> 5) & 3;
-	int dconblnk = (gpios >> 12) & 1;
-	cycles_t foo = get_cycles();
-	static cycles_t foo1;
-	static int lastec7;
-
-	unsigned long scanline = readl((void __iomem *)(gxfb_dc_regs + 0x6c));
-	int ec7 = inl(gpio_base + 0xDC);
-	int dconirq = (gpios >> 7) & 1;
-
-	scanline >>= 16;
-	scanline &= 0x7ff;
-	printk("IRQ! TSC %08lx (+%ld), line %ld, STAT %d BLNK %d IRQ %d EC7 %d:+%d\n",
-	       (long)foo, (long)(foo-foo1), scanline, dconstat, dconblnk, dconirq, ec7, ec7-lastec7);
-	foo1 = foo;
-	lastec7 = ec7;
+	unsigned long gin = inl(gpio_base + GPIOx_READ_BACK);
+	int dconstat = (gin >> 5) & 3;
 
 	/* Clear the negative edge status for GPIO7 */
 	outl(1 << 7, gpio_base + GPIOx_NEGEDGE_STS);
 
-#if 0
-	printk("GPIOL_NEGEDGE_STS[7] is %d\n", (inl(gpio_base+0x4c)>>7) & 1);
+	if (dconstat == 2 || dconstat == 1) {
+		if (dconstat == 2)
+			printk("IRQ - switch to DCON mode\n");
+		else
+			printk("IRQ - switch to CPU mode\n");
 
-	outl(1<<7, gpio_base+0x4c);
-	outl(1<<(16+7), gpio_base + GPIOx_EVNTCNT_EN);
-	outl(1<<(7), gpio_base + GPIOx_EVNTCNT_EN);
-#endif
-	if (dconstat == 2) {
-		dcon_waiting = 0;
-		wake_up(&dcon_mode_wq);
+		dcon_switched = 1;
+		wake_up(&dcon_wait_queue);
 	}
+
 	return IRQ_HANDLED;
 }
 
-
 /* List of GPIOs that we care about:
    (in)  GPIO12   -- DCONBLNK
    (in)  GPIO[56] -- DCONSTAT[01]
@@ -505,7 +618,7 @@ int __init gxfb_dcon_init(void)
 
 	/* Check the mask and whether GPIO is enabled (sanity check) */
 	if (hi != 0x0000f001) {
-		printk(KERN_WARNING "GPIO not enabled -- cannot use DCON\n");
+		printk(KERN_ERR "GPIO not enabled -- cannot use DCON\n");
 		return -ENODEV;
 	}
 
@@ -521,7 +634,7 @@ int __init gxfb_dcon_init(void)
 	outl(1 << (16 + 7), gpio_base + GPIOx_EVNT_EN);
 
 	/* Set up the interrupt mappings first, so we can collect the
-	 * first interrupt when it happens 
+	 * first interrupt when it happens
 	 */
 
 	hi = inl(gpio_base + GPIO_MAP_X);
@@ -533,7 +646,7 @@ int __init gxfb_dcon_init(void)
 
 	hi = inl(gpio_base + GPIO_MAP_Y);
 	hi &= 0xfff0ffff;
-	hi |= 0x00000000;	
+	hi |= 0x00000000;
 	outl(hi, gpio_base + GPIO_MAP_Y);
 
 	/* Enable GPIO IRQ 7 to trigger the PIC interrupt in the Z sources */
@@ -606,4 +719,3 @@ module_init(gxfb_dcon_init);
 module_exit(gxfb_dcon_exit);
 
 MODULE_LICENSE("GPL");
-
diff --git a/drivers/video/geode/gxfb_dcon.h b/drivers/video/geode/gxfb_dcon.h
index 140f2f0..522bd7a 100644
--- a/drivers/video/geode/gxfb_dcon.h
+++ b/drivers/video/geode/gxfb_dcon.h
@@ -65,15 +65,15 @@ #define DCON_SOURCE_CPU         1
 #define DCON_OUTPUT_COLOR       0
 #define DCON_OUTPUT_MONO        1
 
+/* Sleep values */
+#define DCON_ACTIVE             0
+#define DCON_SLEEPING           1
+
 /* Interrupt */
 #define DCON_IRQ                6
 
-/* Functions available to the world */
-
-/* Set the backlight */
-void gxfb_dcon_setbl(int);
 
-/* Get the backlight value */
-int gxfb_dcon_getbl(void);
+void dcon_set_backlight(int);
+int dcon_get_backlight(void);
 
 #endif


More information about the Commits-kernel mailing list