linux-openmoko-2.6.32: simplified JBT6k74 driver as WSOD fix

Signed-off-by: Martin Jansa <Martin.Jansa@gmail.com>

2 files changed, 746 insertions, 0 deletions

diff --git a/recipes/linux/linux-openmoko-2.6.32/0010-Simplify-the-JBT6k74-driver.patch b/recipes/linux/linux-openmoko-2.6.32/0010-Simplify-the-JBT6k74-driver.patch
new file mode 100644
index 0000000000..ca0c2af15b
--- /dev/null
+++ b/recipes/linux/linux-openmoko-2.6.32/0010-Simplify-the-JBT6k74-driver.patch
@@ -0,0 +1,667 @@
+From cb84d543b9465a8ea48b504b1dfb745c6682a50e Mon Sep 17 00:00:00 2001
+From: Thomas White <taw@bitwiz.org.uk>
+Date: Sun, 28 Feb 2010 15:20:57 +0100
+Subject: [PATCH 1/2] Simplify the JBT6k74 driver
+
+Simplify the JBT6k74 driver
+
+We don't need all the native sleep states - they just complicate things.  Instead, just
+use the LDO "power switch" to send it firmly to sleep and wake it up in a virgin state
+each time.
+
+Signed-off-by: Thomas White <taw@bitwiz.org.uk>
+---
+ drivers/mfd/glamo/glamo-display.c     |  116 ++++++++++++------------
+ drivers/mfd/glamo/glamo-display.h     |    2 +
+ drivers/mfd/glamo/glamo-drm-private.h |   10 ++
+ drivers/mfd/glamo/glamo-kms-fb.c      |   54 ++----------
+ drivers/video/backlight/jbt6k74.c     |  160 ++++++++-------------------------
+ include/linux/jbt6k74.h               |    1 -
+ 6 files changed, 115 insertions(+), 228 deletions(-)
+
+diff --git a/drivers/mfd/glamo/glamo-display.c b/drivers/mfd/glamo/glamo-display.c
+index 34a665a..a384c8b 100644
+--- a/drivers/mfd/glamo/glamo-display.c
++++ b/drivers/mfd/glamo/glamo-display.c
+@@ -239,14 +239,6 @@ static int glamo_run_lcd_script(struct glamodrm_handle *gdrm,
+ }
+ 
+ 
+-extern void jbt6k74_action(int val);
+-
+-/* Power on/off */
+-static void glamo_crtc_dpms(struct drm_crtc *crtc, int mode)
+-{
+-}
+-
+-
+ static bool glamo_crtc_mode_fixup(struct drm_crtc *crtc,
+                                   struct drm_display_mode *mode,
+                                   struct drm_display_mode *adjusted_mode)
+@@ -275,6 +267,12 @@ static int glamo_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
+ 	gcrtc = to_glamo_crtc(crtc);
+ 	gdrm = gcrtc->gdrm;	/* Here it is! */
+ 
++	if ( !gcrtc->pixel_clock_on ) {
++		printk(KERN_WARNING "[glamo-drm] Refusing to set base while "
++		                    "pixel clock is off.\n");
++		return -EBUSY;
++	}
++
+ 	gfb = to_glamo_framebuffer(crtc->fb);
+ 	obj = gfb->obj;
+ 	gobj = obj->driver_private;
+@@ -306,6 +304,12 @@ static int glamo_crtc_mode_set(struct drm_crtc *crtc,
+ 	gcrtc = to_glamo_crtc(crtc);
+ 	gdrm = gcrtc->gdrm;	/* Here it is! */
+ 
++	if ( !gcrtc->pixel_clock_on ) {
++		printk(KERN_WARNING "[glamo-drm] Refusing to set mode while "
++		                    "pixel clock is off.\n");
++		return -EBUSY;
++	}
++
+ 	glamo_lcd_cmd_mode(gdrm, 1);
+ 
+ 	glamo_engine_reclock(gdrm->glamo_core, GLAMO_ENGINE_LCD, mode->clock);
+@@ -354,10 +358,47 @@ static int glamo_crtc_mode_set(struct drm_crtc *crtc,
+ 
+ 	glamo_crtc_mode_set_base(crtc, 0, 0, old_fb);
+ 
++	gcrtc->current_mode = *mode;
++	gcrtc->current_mode_set = 1;
++	gcrtc->current_fb = old_fb;
++
+ 	return 0;
+ }
+ 
+ 
++extern void jbt6k74_action(int val);
++
++/* This is not the right place to switch power on/off, because the helper
++ * stuff ends up calling this before/after setting the mode.  We can't
++ * set modes with the display off (although backlight off would be OK) */
++static void glamo_crtc_dpms(struct drm_crtc *crtc, int mode)
++{
++	/* do nothing */
++}
++
++
++void glamo_lcd_power(struct glamodrm_handle *gdrm, int mode)
++{
++	struct drm_crtc *crtc = gdrm->crtc;
++	struct glamo_crtc *gcrtc = to_glamo_crtc(crtc);
++
++	if ( mode ) {
++		glamo_engine_enable(gdrm->glamo_core, GLAMO_ENGINE_LCD);
++		gcrtc->pixel_clock_on = 1;
++		jbt6k74_action(1);
++		if ( gcrtc->current_mode_set ) {
++			glamo_crtc_mode_set(crtc, &gcrtc->current_mode,
++			                    &gcrtc->current_mode, 0, 0,
++			                    gcrtc->current_fb);
++		}
++	} else {
++		jbt6k74_action(0);
++		glamo_engine_suspend(gdrm->glamo_core, GLAMO_ENGINE_LCD);
++		gcrtc->pixel_clock_on = 0;
++	}
++}
++
++
+ static void glamo_crtc_prepare(struct drm_crtc *crtc)
+ {
+ }
+@@ -725,6 +766,8 @@ int glamo_display_init(struct drm_device *dev)
+ 	                   + sizeof(struct drm_connector *), GFP_KERNEL);
+ 	if (glamo_crtc == NULL) return 1;
+ 	glamo_crtc->gdrm = gdrm;
++	gdrm->crtc = (struct drm_crtc *)glamo_crtc;
++	glamo_crtc->pixel_clock_on = 1;
+ 	glamo_crtc->blank_mode = DRM_MODE_DPMS_OFF;
+ 	drm_crtc_init(dev, &glamo_crtc->base, &glamo_crtc_funcs);
+ 	drm_crtc_helper_add(&glamo_crtc->base, &glamo_crtc_helper_funcs);
+@@ -808,62 +851,23 @@ int glamo_display_init(struct drm_device *dev)
+ 
+ void glamo_display_suspend(struct glamodrm_handle *gdrm)
+ {
+-	gdrm->saved_width = reg_read_lcd(gdrm, GLAMO_REG_LCD_WIDTH);
+-	gdrm->saved_height = reg_read_lcd(gdrm, GLAMO_REG_LCD_HEIGHT);
+-	gdrm->saved_pitch = reg_read_lcd(gdrm, GLAMO_REG_LCD_PITCH);
+-	gdrm->saved_htotal = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_TOTAL);
+-	gdrm->saved_hrtrst = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_START);
+-	gdrm->saved_hrtren = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_END);
+-	gdrm->saved_hdspst = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_START);
+-	gdrm->saved_hdspen = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_END);
+-	gdrm->saved_vtotal = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_TOTAL);
+-	gdrm->saved_vrtrst = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_START);
+-	gdrm->saved_vrtren = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_END);
+-	gdrm->saved_vdspst = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_START);
+-	gdrm->saved_vdspen = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_END);
++	/* do nothing */
+ }
+ 
+ 
+ void glamo_display_resume(struct glamodrm_handle *gdrm)
+ {
++	struct drm_crtc *crtc = gdrm->crtc;
++	struct glamo_crtc *gcrtc = to_glamo_crtc(crtc);
++
+ 	glamo_engine_enable(gdrm->glamo_core, GLAMO_ENGINE_LCD);
+ 	glamo_engine_reset(gdrm->glamo_core, GLAMO_ENGINE_LCD);
+ 	glamo_run_lcd_script(gdrm, lcd_init_script,
+ 	                           ARRAY_SIZE(lcd_init_script));
+ 
+-	/* Restore timings */
+-	glamo_lcd_cmd_mode(gdrm, 1);
+-	glamo_engine_reclock(gdrm->glamo_core, GLAMO_ENGINE_LCD,
+-	                     gdrm->saved_clock);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_WIDTH, GLAMO_LCD_WIDTH_MASK,
+-	                     gdrm->saved_width);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HEIGHT, GLAMO_LCD_HEIGHT_MASK,
+-	                     gdrm->saved_height);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_PITCH, GLAMO_LCD_PITCH_MASK,
+-	                     gdrm->saved_pitch);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_TOTAL,
+-	                     GLAMO_LCD_HV_TOTAL_MASK, gdrm->saved_htotal);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_START,
+-	                     GLAMO_LCD_HV_RETR_START_MASK, gdrm->saved_hrtrst);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_END,
+-	                     GLAMO_LCD_HV_RETR_END_MASK, gdrm->saved_hrtren);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_START,
+-	                     GLAMO_LCD_HV_RETR_DISP_START_MASK,
+-	                     gdrm->saved_hdspst);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_END,
+-	                     GLAMO_LCD_HV_RETR_DISP_END_MASK,
+-	                     gdrm->saved_hdspen);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_TOTAL,
+-	                     GLAMO_LCD_HV_TOTAL_MASK, gdrm->saved_vtotal);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_START,
+-	                     GLAMO_LCD_HV_RETR_START_MASK, gdrm->saved_vrtrst);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_END,
+-	                     GLAMO_LCD_HV_RETR_END_MASK, gdrm->saved_vrtren);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_START,
+-	                     GLAMO_LCD_HV_RETR_DISP_START_MASK,
+-	                     gdrm->saved_vdspst);
+-	reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_END,
+-	                     GLAMO_LCD_HV_RETR_DISP_END_MASK,
+-	                     gdrm->saved_vdspen);
+-	glamo_lcd_cmd_mode(gdrm, 0);
++	if ( gcrtc->current_mode_set ) {
++		glamo_crtc_mode_set(crtc, &gcrtc->current_mode,
++		                    &gcrtc->current_mode, 0, 0,
++		                    gcrtc->current_fb);
++	}
+ }
+diff --git a/drivers/mfd/glamo/glamo-display.h b/drivers/mfd/glamo/glamo-display.h
+index d6f21bc..728bba5 100644
+--- a/drivers/mfd/glamo/glamo-display.h
++++ b/drivers/mfd/glamo/glamo-display.h
+@@ -36,4 +36,6 @@ extern int glamo_framebuffer_create(struct drm_device *dev,
+ extern void glamo_display_suspend(struct glamodrm_handle *gdrm);
+ extern void glamo_display_resume(struct glamodrm_handle *gdrm);
+ 
++extern void glamo_lcd_power(struct glamodrm_handle *gdrm, int mode);
++
+ #endif /* __GLAMO_DISPLAY_H */
+diff --git a/drivers/mfd/glamo/glamo-drm-private.h b/drivers/mfd/glamo/glamo-drm-private.h
+index 7949a2e..4e24019 100644
+--- a/drivers/mfd/glamo/glamo-drm-private.h
++++ b/drivers/mfd/glamo/glamo-drm-private.h
+@@ -106,6 +106,9 @@ struct glamodrm_handle {
+ 
+ 	/* A scratch block */
+ 	struct drm_mm_node *scratch;
++
++	/* We only have one */
++	struct drm_crtc *crtc;
+ };
+ 
+ 
+@@ -118,11 +121,18 @@ struct drm_glamo_gem_object {
+ 
+ 
+ struct glamo_crtc {
++
+ 	struct drm_crtc base;
+ 	struct glamodrm_handle *gdrm;
+ 	/* a mode_set for fbdev users on this crtc */
+ 	struct drm_mode_set mode_set;
+ 	int blank_mode;
++
++	int pixel_clock_on;
++
++	int current_mode_set;
++	struct drm_display_mode current_mode;
++	struct drm_framebuffer *current_fb;
+ };
+ 
+ 
+diff --git a/drivers/mfd/glamo/glamo-kms-fb.c b/drivers/mfd/glamo/glamo-kms-fb.c
+index 61cd605..57680ed 100644
+--- a/drivers/mfd/glamo/glamo-kms-fb.c
++++ b/drivers/mfd/glamo/glamo-kms-fb.c
+@@ -253,64 +253,24 @@ static void glamofb_on(struct fb_info *info)
+ {
+ 	struct glamofb_par *par = info->par;
+ 	struct drm_device *dev = par->dev;
+-	struct drm_crtc *crtc;
+-	struct drm_encoder *encoder;
+-	int i;
++	struct glamodrm_handle *gdrm = dev->dev_private;
+ 
+-	/*
+-	 * For each CRTC in this fb, find all associated encoders
+-	 * and turn them off, then turn off the CRTC.
+-	 */
+-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+-		struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
++	printk(KERN_CRIT "Turning on display...\n");
+ 
+-		for (i = 0; i < par->crtc_count; i++)
+-			if (crtc->base.id == par->crtc_ids[i])
+-				break;
+-
+-		crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
++	gdrm = dev->dev_private;
+ 
+-		/* Found a CRTC on this fb, now find encoders */
+-		list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+-			if (encoder->crtc == crtc) {
+-				struct drm_encoder_helper_funcs *encoder_funcs;
+-				encoder_funcs = encoder->helper_private;
+-				encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
+-			}
+-		}
+-	}
++	glamo_lcd_power(gdrm, 1);
+ }
+ 
+ static void glamofb_off(struct fb_info *info, int dpms_mode)
+ {
+ 	struct glamofb_par *par = info->par;
+ 	struct drm_device *dev = par->dev;
+-	struct drm_crtc *crtc;
+-	struct drm_encoder *encoder;
+-	int i;
++	struct glamodrm_handle *gdrm = dev->dev_private;
+ 
+-	/*
+-	 * For each CRTC in this fb, find all associated encoders
+-	 * and turn them off, then turn off the CRTC.
+-	 */
+-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+-		struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
+-
+-		for (i = 0; i < par->crtc_count; i++)
+-			if (crtc->base.id == par->crtc_ids[i])
+-				break;
++	printk(KERN_CRIT "Turning off display...\n");
+ 
+-		/* Found a CRTC on this fb, now find encoders */
+-		list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+-			if (encoder->crtc == crtc) {
+-				struct drm_encoder_helper_funcs *encoder_funcs;
+-				encoder_funcs = encoder->helper_private;
+-				encoder_funcs->dpms(encoder, dpms_mode);
+-			}
+-		}
+-		if (dpms_mode == DRM_MODE_DPMS_OFF)
+-			crtc_funcs->dpms(crtc, dpms_mode);
+-	}
++	glamo_lcd_power(gdrm, 0);
+ }
+ 
+ static int glamofb_blank(int blank, struct fb_info *info)
+diff --git a/drivers/video/backlight/jbt6k74.c b/drivers/video/backlight/jbt6k74.c
+index 95ca4cf..9554cb3 100644
+--- a/drivers/video/backlight/jbt6k74.c
++++ b/drivers/video/backlight/jbt6k74.c
+@@ -107,14 +107,12 @@ enum jbt_resolution {
+ };
+ 
+ enum jbt_power_mode {
+-	JBT_POWER_MODE_DEEP_STANDBY,
+-	JBT_POWER_MODE_SLEEP,
++	JBT_POWER_MODE_OFF,
+ 	JBT_POWER_MODE_NORMAL,
+ };
+ 
+ static const char *jbt_power_mode_names[] = {
+-	[JBT_POWER_MODE_DEEP_STANDBY]	= "deep-standby",
+-	[JBT_POWER_MODE_SLEEP]		= "sleep",
++	[JBT_POWER_MODE_OFF]		= "off",
+ 	[JBT_POWER_MODE_NORMAL]		= "normal",
+ };
+ 
+@@ -260,14 +258,18 @@ static int jbt_init_regs(struct jbt_info *jbt)
+ 	return ret ? -EIO : 0;
+ }
+ 
+-static int jbt_standby_to_sleep(struct jbt_info *jbt)
++
++static int jbt_off_to_normal(struct jbt_info *jbt)
+ {
+ 	int ret;
++
+ 	struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
+ 
+ 	gpio_set_value_cansleep(pdata->gpio_reset, 1);
+ 	ret = regulator_bulk_enable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
+ 
++	mdelay(30);
++
+ 	/* three times command zero */
+ 	ret |= jbt_reg_write_nodata(jbt, 0x00);
+ 	mdelay(1);
+@@ -279,18 +281,11 @@ static int jbt_standby_to_sleep(struct jbt_info *jbt)
+ 	/* deep standby out */
+ 	ret |= jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x11);
+ 	mdelay(1);
+-	ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x28);
++	ret |= jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x28);
+ 
+ 	/* (re)initialize register set */
+ 	ret |= jbt_init_regs(jbt);
+ 
+-	return ret ? -EIO : 0;
+-}
+-
+-static int jbt_sleep_to_normal(struct jbt_info *jbt)
+-{
+-	int ret;
+-
+ 	/* Make sure we are 120 ms after SLEEP_OUT */
+ 	if (time_before(jiffies, jbt->next_sleep))
+ 		mdelay(jiffies_to_msecs(jbt->next_sleep - jiffies));
+@@ -320,53 +315,34 @@ static int jbt_sleep_to_normal(struct jbt_info *jbt)
+ 
+ 	/* Sleep mode off */
+ 	ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_OUT);
+-	jbt->next_sleep = jiffies + msecs_to_jiffies(120);
+ 
+-	/* Allow the booster and display controller to restart stably */
+-	mdelay(5);
+-
+-	return ret ? -EIO : 0;
+-}
+-
+-static int jbt_normal_to_sleep(struct jbt_info *jbt)
+-{
+-	int ret;
+-
+-	/* Make sure we are 120 ms after SLEEP_OUT */
+-	while (time_before(jiffies, jbt->next_sleep))
+-		cpu_relax();
+-
+-	ret = jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_OFF);
+-	ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0x8000 | 1 << 3);
+-	ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_IN);
+ 	jbt->next_sleep = jiffies + msecs_to_jiffies(120);
+ 
+-	/* Allow the internal circuits to stop automatically */
++	/* Allow the booster and display controller to restart stably */
+ 	mdelay(5);
+ 
+ 	return ret ? -EIO : 0;
+ }
+ 
+-static int jbt_sleep_to_standby(struct jbt_info *jbt)
++static int jbt_normal_to_off(struct jbt_info *jbt)
+ {
+ 	int ret;
+ 	struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
+ 
+-	ret = jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x00);
+-
+-	if (!ret)
+-		ret = regulator_bulk_disable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
++	/* Pull the plug! */
++	ret = regulator_bulk_disable(ARRAY_SIZE(jbt->supplies),
++	                             jbt->supplies);
+ 
+ 	if (!ret)
+ 		gpio_set_value_cansleep(pdata->gpio_reset, 0);
+ 
+-	return ret;
++	return ret ? -EIO : 0;
+ }
+ 
++
+ static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
+ 					enum jbt_power_mode new_mode)
+ {
+-	struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
+ 	int ret = -EINVAL;
+ 
+ 	dev_dbg(&jbt->spi->dev, "entering (old_state=%s, new_state=%s)\n",
+@@ -375,49 +351,14 @@ static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
+ 
+ 	mutex_lock(&jbt->lock);
+ 
+-	if (jbt->suspended) {
+-		switch (new_mode) {
+-		case JBT_POWER_MODE_DEEP_STANDBY:
+-		case JBT_POWER_MODE_SLEEP:
+-		case JBT_POWER_MODE_NORMAL:
+-			ret = 0;
+-			jbt->suspend_mode = new_mode;
+-			break;
+-		default:
+-			break;
+-		}
+-	} else if (new_mode == JBT_POWER_MODE_NORMAL &&
+-			pdata->enable_pixel_clock) {
+-		pdata->enable_pixel_clock(&jbt->spi->dev, 1);
+-	}
+-
+ 	switch (jbt->power_mode) {
+-	case JBT_POWER_MODE_DEEP_STANDBY:
+-		switch (new_mode) {
+-		case JBT_POWER_MODE_DEEP_STANDBY:
+-			ret = 0;
+-			break;
+-		case JBT_POWER_MODE_SLEEP:
+-			ret = jbt_standby_to_sleep(jbt);
+-			break;
+-		case JBT_POWER_MODE_NORMAL:
+-			/* first transition into sleep */
+-			ret = jbt_standby_to_sleep(jbt);
+-			/* then transition into normal */
+-			ret |= jbt_sleep_to_normal(jbt);
+-			break;
+-		}
+-		break;
+-	case JBT_POWER_MODE_SLEEP:
++	case JBT_POWER_MODE_OFF:
+ 		switch (new_mode) {
+-		case JBT_POWER_MODE_SLEEP:
++		case JBT_POWER_MODE_OFF:
+ 			ret = 0;
+ 			break;
+-		case JBT_POWER_MODE_DEEP_STANDBY:
+-			ret = jbt_sleep_to_standby(jbt);
+-			break;
+ 		case JBT_POWER_MODE_NORMAL:
+-			ret = jbt_sleep_to_normal(jbt);
++			ret = jbt_off_to_normal(jbt);
+ 			break;
+ 		}
+ 		break;
+@@ -426,25 +367,16 @@ static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
+ 		case JBT_POWER_MODE_NORMAL:
+ 			ret = 0;
+ 			break;
+-		case JBT_POWER_MODE_DEEP_STANDBY:
+-			/* first transition into sleep */
+-			ret = jbt_normal_to_sleep(jbt);
+-			/* then transition into deep standby */
+-			ret |= jbt_sleep_to_standby(jbt);
+-			break;
+-		case JBT_POWER_MODE_SLEEP:
+-			ret = jbt_normal_to_sleep(jbt);
++		case JBT_POWER_MODE_OFF:
++			ret = jbt_normal_to_off(jbt);
+ 			break;
+ 		}
+ 	}
+ 
+ 	if (ret == 0) {
+ 		jbt->power_mode = new_mode;
+-		if (new_mode != JBT_POWER_MODE_NORMAL &&
+-			pdata->enable_pixel_clock)
+-			pdata->enable_pixel_clock(&jbt->spi->dev, 0);
+ 	} else {
+-		dev_err(&jbt->spi->dev, "Failed enter state '%s': %d\n",
++		dev_err(&jbt->spi->dev, "Failed to enter state '%s': %d\n",
+ 				jbt_power_mode_names[new_mode], ret);
+ 	}
+ 
+@@ -470,8 +402,8 @@ static int jbt6k74_set_resolution(struct jbt_info *jbt,
+ 	if (jbt->power_mode == JBT_POWER_MODE_NORMAL) {
+ 
+ 		/* first transition into sleep */
+-		ret = jbt_normal_to_sleep(jbt);
+-		ret |= jbt_sleep_to_normal(jbt);
++		ret = jbt_normal_to_off(jbt);
++		ret |= jbt_off_to_normal(jbt);
+ 
+ 		if (ret) {
+ 			jbt->resolution = old_resolution;
+@@ -589,7 +521,7 @@ static ssize_t reset_write(struct device *dev, struct device_attribute *attr,
+ 
+ 	mutex_unlock(&jbt->lock);
+ 
+-	jbt->power_mode = JBT_POWER_MODE_DEEP_STANDBY;
++	jbt->power_mode = JBT_POWER_MODE_OFF;
+ 	jbt6k74_enter_power_mode(jbt, old_power_mode);
+ 
+ 	return count;
+@@ -616,27 +548,6 @@ static struct attribute_group jbt_attr_group = {
+ 	.attrs	= jbt_sysfs_entries,
+ };
+ 
+-/* FIXME: This in an ugly hack to delay display blanking.
+-  When the jbt is in sleep mode it displays an all white screen and thus one
+-  will a see a short flash.
+-  By delaying the blanking we will give the backlight a chance to turn off and
+-  thus avoid getting the flash */
+-static void jbt_blank_worker(struct work_struct *work)
+-{
+-	struct jbt_info *jbt  = container_of(work, struct jbt_info,
+-						blank_work.work);
+-
+-	switch (jbt->blank_mode) {
+-	case FB_BLANK_NORMAL:
+-		jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_SLEEP);
+-		break;
+-	case FB_BLANK_POWERDOWN:
+-		jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_DEEP_STANDBY);
+-		break;
+-	default:
+-		break;
+-	}
+-}
+ 
+ static int jbt6k74_set_mode(struct lcd_device *ld, struct fb_videomode *m)
+ {
+@@ -649,7 +560,7 @@ static int jbt6k74_set_mode(struct lcd_device *ld, struct fb_videomode *m)
+ 		ret = jbt6k74_set_resolution(jbt, JBT_RESOLUTION_VGA);
+ 	} else {
+ 		dev_err(&jbt->spi->dev, "Unknown resolution.\n");
+-		jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_SLEEP);
++		jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
+ 	}
+ 
+ 	return ret;
+@@ -671,11 +582,11 @@ static int jbt6k74_set_power(struct lcd_device *ld, int power)
+ 		break;
+ 	case FB_BLANK_NORMAL:
+ 		dev_dbg(&jbt->spi->dev, "blank\n");
+-		ret = schedule_delayed_work(&jbt->blank_work, HZ);
++		ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
+ 		break;
+ 	case FB_BLANK_POWERDOWN:
+ 		dev_dbg(&jbt->spi->dev, "powerdown\n");
+-		ret = schedule_delayed_work(&jbt->blank_work, HZ);
++		ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
+ 		break;
+ 	default:
+ 		break;
+@@ -691,10 +602,10 @@ static int jbt6k74_get_power(struct lcd_device *ld)
+ 	switch (jbt->power_mode) {
+ 	case JBT_POWER_MODE_NORMAL:
+ 		return FB_BLANK_UNBLANK;
+-	case JBT_POWER_MODE_SLEEP:
++	case JBT_POWER_MODE_OFF:
+ 		return FB_BLANK_NORMAL;
+ 	default:
+-		return JBT_POWER_MODE_DEEP_STANDBY;
++		return JBT_POWER_MODE_OFF;
+ 	}
+ }
+ 
+@@ -707,7 +618,7 @@ void jbt6k74_action(int val)
+ 		return;
+ 	}
+ 	if ( val == 0 ) {
+-		jbt6k74_enter_power_mode(jbt_global, JBT_POWER_MODE_SLEEP);
++		jbt6k74_enter_power_mode(jbt_global, JBT_POWER_MODE_OFF);
+ 	} else {
+ 		jbt6k74_enter_power_mode(jbt_global, JBT_POWER_MODE_NORMAL);
+ 	}
+@@ -756,11 +667,9 @@ static int __devinit jbt_probe(struct spi_device *spi)
+ 		goto err_free_drvdata;
+ 	}
+ 
+-	INIT_DELAYED_WORK(&jbt->blank_work, jbt_blank_worker);
+-
+ 	jbt->resolution = JBT_RESOLUTION_VGA;
+-	jbt->power_mode = JBT_POWER_MODE_DEEP_STANDBY;
+ 	jbt->next_sleep = jiffies + msecs_to_jiffies(120);
++	jbt->power_mode = JBT_POWER_MODE_OFF;
+ 	mutex_init(&jbt->lock);
+ 
+ 	dev_set_drvdata(&spi->dev, jbt);
+@@ -856,9 +765,10 @@ static int jbt_suspend(struct spi_device *spi, pm_message_t state)
+ 
+ 	jbt->suspend_mode = jbt->power_mode;
+ 
+-	jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_DEEP_STANDBY);
+-	jbt->suspended = 1;
++	printk(KERN_CRIT "[jbt] powering off for suspend\n");
++	jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
+ 
++	printk(KERN_CRIT "[jbt] done\n");
+ 	dev_info(&spi->dev, "suspended\n");
+ 
+ 	return 0;
+@@ -869,11 +779,13 @@ int jbt6k74_resume(struct spi_device *spi)
+ 	struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
+ 	dev_info(&spi->dev, "starting resume: %d\n", jbt->suspend_mode);
+ 
++	printk(KERN_CRIT "[jbt] powering on for resume\n");
+ 	mdelay(20);
+ 
+ 	jbt->suspended = 0;
+ 	jbt6k74_enter_power_mode(jbt, jbt->suspend_mode);
+ 
++	printk(KERN_CRIT "[jbt] done\n");
+ 	dev_info(&spi->dev, "resumed: %d\n", jbt->suspend_mode);
+ 
+ 	return 0;
+diff --git a/include/linux/jbt6k74.h b/include/linux/jbt6k74.h
+index 75488c4..4cf760c 100644
+--- a/include/linux/jbt6k74.h
++++ b/include/linux/jbt6k74.h
+@@ -13,7 +13,6 @@
+  */
+ struct jbt6k74_platform_data {
+ 	void (*probe_completed)(struct device *dev);
+-	void (*enable_pixel_clock)(struct device *dev, int enable);
+ 
+ 	int gpio_reset;
+ };
+-- 
+1.7.0
+
diff --git a/recipes/linux/linux-openmoko-2.6.32/0011-Don-t-choke-if-userspace-provides-a-pixel-clock-valu.patch b/recipes/linux/linux-openmoko-2.6.32/0011-Don-t-choke-if-userspace-provides-a-pixel-clock-valu.patch
new file mode 100644
index 0000000000..0d47c1263f
--- /dev/null
+++ b/recipes/linux/linux-openmoko-2.6.32/0011-Don-t-choke-if-userspace-provides-a-pixel-clock-valu.patch
@@ -0,0 +1,79 @@
+From 73abadc5bbbc94f4ca67effc5f5c3174c2a3ac48 Mon Sep 17 00:00:00 2001
+From: Thomas White <taw@bitwiz.org.uk>
+Date: Sun, 28 Feb 2010 15:40:13 +0100
+Subject: [PATCH 2/2] Don't choke if userspace provides a pixel clock value
+
+Don't choke if userspace provides a pixel clock value
+
+Signed-off-by: Thomas White <taw@bitwiz.org.uk>
+---
+ drivers/mfd/glamo/glamo-kms-fb.c |   46 ++++++++++++++++++-------------------
+ 1 files changed, 22 insertions(+), 24 deletions(-)
+
+diff --git a/drivers/mfd/glamo/glamo-kms-fb.c b/drivers/mfd/glamo/glamo-kms-fb.c
+index 57680ed..6d4b9ea 100644
+--- a/drivers/mfd/glamo/glamo-kms-fb.c
++++ b/drivers/mfd/glamo/glamo-kms-fb.c
+@@ -177,37 +177,35 @@ static int glamofb_set_par(struct fb_info *info)
+ 	struct drm_device *dev = par->dev;
+ 	struct fb_var_screeninfo *var = &info->var;
+ 	int i;
++	struct drm_crtc *crtc;
++	int ret;
+ 
+ 	DRM_DEBUG("%d %d\n", var->xres, var->pixclock);
+ 
+ 	if (var->pixclock != -1) {
++		DRM_ERROR("Warning: userspace gave me a pixel clock value (%i)"
++		          "- I'm ignoring it.\n", var->pixclock);
++	}
+ 
+-		DRM_ERROR("PIXEL CLOCK SET\n");
+-		return -EINVAL;
+-	} else {
+-		struct drm_crtc *crtc;
+-		int ret;
+-
+-		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+-			struct glamo_crtc *glamo_crtc = to_glamo_crtc(crtc);
+-
+-			for (i = 0; i < par->crtc_count; i++)
+-				if (crtc->base.id == par->crtc_ids[i])
+-					break;
+-
+-			if (i == par->crtc_count)
+-				continue;
+-
+-			if (crtc->fb == glamo_crtc->mode_set.fb) {
+-				mutex_lock(&dev->mode_config.mutex);
+-				ret = crtc->funcs->set_config(&glamo_crtc->mode_set);
+-				mutex_unlock(&dev->mode_config.mutex);
+-				if (ret)
+-					return ret;
+-			}
++	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
++		struct glamo_crtc *glamo_crtc = to_glamo_crtc(crtc);
++
++		for (i = 0; i < par->crtc_count; i++)
++			if (crtc->base.id == par->crtc_ids[i])
++				break;
++
++		if (i == par->crtc_count)
++			continue;
++
++		if (crtc->fb == glamo_crtc->mode_set.fb) {
++			mutex_lock(&dev->mode_config.mutex);
++			ret = crtc->funcs->set_config(&glamo_crtc->mode_set);
++			mutex_unlock(&dev->mode_config.mutex);
++			if (ret)
++				return ret;
+ 		}
+-		return 0;
+ 	}
++	return 0;
+ }
+ 
+ static int glamofb_pan_display(struct fb_var_screeninfo *var,
+-- 
+1.7.0
+