recipes/linux/linux-openmoko-2.6.32/0010-Simplify-the-JBT6k74-driver.patch

   1 From cb84d543b9465a8ea48b504b1dfb745c6682a50e Mon Sep 17 00:00:00 2001
   2 From: Thomas White <taw@bitwiz.org.uk>
   3 Date: Sun, 28 Feb 2010 15:20:57 +0100
   4 Subject: [PATCH 1/2] Simplify the JBT6k74 driver
   5
   6 Simplify the JBT6k74 driver
   7
   8 We don't need all the native sleep states - they just complicate things.  Instead, just
   9 use the LDO "power switch" to send it firmly to sleep and wake it up in a virgin state
  10 each time.
  11
  12 Signed-off-by: Thomas White <taw@bitwiz.org.uk>
  13 ---
  14  drivers/mfd/glamo/glamo-display.c     |  116 ++++++++++++------------
  15  drivers/mfd/glamo/glamo-display.h     |    2 +
  16  drivers/mfd/glamo/glamo-drm-private.h |   10 ++
  17  drivers/mfd/glamo/glamo-kms-fb.c      |   54 ++----------
  18  drivers/video/backlight/jbt6k74.c     |  160 ++++++++-------------------------
  19  include/linux/jbt6k74.h               |    1 -
  20  6 files changed, 115 insertions(+), 228 deletions(-)
  21
  22 diff --git a/drivers/mfd/glamo/glamo-display.c b/drivers/mfd/glamo/glamo-display.c
  23 index 34a665a..a384c8b 100644
  24 --- a/drivers/mfd/glamo/glamo-display.c
  25 +++ b/drivers/mfd/glamo/glamo-display.c
  26 @@ -239,14 +239,6 @@ static int glamo_run_lcd_script(struct glamodrm_handle *gdrm,
  27  }
  28
  29
  30 -extern void jbt6k74_action(int val);
  31 -
  32 -/* Power on/off */
  33 -static void glamo_crtc_dpms(struct drm_crtc *crtc, int mode)
  34 -{
  35 -}
  36 -
  37 -
  38  static bool glamo_crtc_mode_fixup(struct drm_crtc *crtc,
  39                                    struct drm_display_mode *mode,
  40                                    struct drm_display_mode *adjusted_mode)
  41 @@ -275,6 +267,12 @@ static int glamo_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
  42         gcrtc = to_glamo_crtc(crtc);
  43         gdrm = gcrtc->gdrm;     /* Here it is! */
  44
  45 +       if ( !gcrtc->pixel_clock_on ) {
  46 +               printk(KERN_WARNING "[glamo-drm] Refusing to set base while "
  47 +                                   "pixel clock is off.\n");
  48 +               return -EBUSY;
  49 +       }
  50 +
  51         gfb = to_glamo_framebuffer(crtc->fb);
  52         obj = gfb->obj;
  53         gobj = obj->driver_private;
  54 @@ -306,6 +304,12 @@ static int glamo_crtc_mode_set(struct drm_crtc *crtc,
  55         gcrtc = to_glamo_crtc(crtc);
  56         gdrm = gcrtc->gdrm;     /* Here it is! */
  57
  58 +       if ( !gcrtc->pixel_clock_on ) {
  59 +               printk(KERN_WARNING "[glamo-drm] Refusing to set mode while "
  60 +                                   "pixel clock is off.\n");
  61 +               return -EBUSY;
  62 +       }
  63 +
  64         glamo_lcd_cmd_mode(gdrm, 1);
  65
  66         glamo_engine_reclock(gdrm->glamo_core, GLAMO_ENGINE_LCD, mode->clock);
  67 @@ -354,10 +358,47 @@ static int glamo_crtc_mode_set(struct drm_crtc *crtc,
  68
  69         glamo_crtc_mode_set_base(crtc, 0, 0, old_fb);
  70
  71 +       gcrtc->current_mode = *mode;
  72 +       gcrtc->current_mode_set = 1;
  73 +       gcrtc->current_fb = old_fb;
  74 +
  75         return 0;
  76  }
  77
  78
  79 +extern void jbt6k74_action(int val);
  80 +
  81 +/* This is not the right place to switch power on/off, because the helper
  82 + * stuff ends up calling this before/after setting the mode.  We can't
  83 + * set modes with the display off (although backlight off would be OK) */
  84 +static void glamo_crtc_dpms(struct drm_crtc *crtc, int mode)
  85 +{
  86 +       /* do nothing */
  87 +}
  88 +
  89 +
  90 +void glamo_lcd_power(struct glamodrm_handle *gdrm, int mode)
  91 +{
  92 +       struct drm_crtc *crtc = gdrm->crtc;
  93 +       struct glamo_crtc *gcrtc = to_glamo_crtc(crtc);
  94 +
  95 +       if ( mode ) {
  96 +               glamo_engine_enable(gdrm->glamo_core, GLAMO_ENGINE_LCD);
  97 +               gcrtc->pixel_clock_on = 1;
  98 +               jbt6k74_action(1);
  99 +               if ( gcrtc->current_mode_set ) {
 100 +                       glamo_crtc_mode_set(crtc, &gcrtc->current_mode,
 101 +                                           &gcrtc->current_mode, 0, 0,
 102 +                                           gcrtc->current_fb);
 103 +               }
 104 +       } else {
 105 +               jbt6k74_action(0);
 106 +               glamo_engine_suspend(gdrm->glamo_core, GLAMO_ENGINE_LCD);
 107 +               gcrtc->pixel_clock_on = 0;
 108 +       }
 109 +}
 110 +
 111 +
 112  static void glamo_crtc_prepare(struct drm_crtc *crtc)
 113  {
 114  }
 115 @@ -725,6 +766,8 @@ int glamo_display_init(struct drm_device *dev)
 116                            + sizeof(struct drm_connector *), GFP_KERNEL);
 117         if (glamo_crtc == NULL) return 1;
 118         glamo_crtc->gdrm = gdrm;
 119 +       gdrm->crtc = (struct drm_crtc *)glamo_crtc;
 120 +       glamo_crtc->pixel_clock_on = 1;
 121         glamo_crtc->blank_mode = DRM_MODE_DPMS_OFF;
 122         drm_crtc_init(dev, &glamo_crtc->base, &glamo_crtc_funcs);
 123         drm_crtc_helper_add(&glamo_crtc->base, &glamo_crtc_helper_funcs);
 124 @@ -808,62 +851,23 @@ int glamo_display_init(struct drm_device *dev)
 125
 126  void glamo_display_suspend(struct glamodrm_handle *gdrm)
 127  {
 128 -       gdrm->saved_width = reg_read_lcd(gdrm, GLAMO_REG_LCD_WIDTH);
 129 -       gdrm->saved_height = reg_read_lcd(gdrm, GLAMO_REG_LCD_HEIGHT);
 130 -       gdrm->saved_pitch = reg_read_lcd(gdrm, GLAMO_REG_LCD_PITCH);
 131 -       gdrm->saved_htotal = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_TOTAL);
 132 -       gdrm->saved_hrtrst = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_START);
 133 -       gdrm->saved_hrtren = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_END);
 134 -       gdrm->saved_hdspst = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_START);
 135 -       gdrm->saved_hdspen = reg_read_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_END);
 136 -       gdrm->saved_vtotal = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_TOTAL);
 137 -       gdrm->saved_vrtrst = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_START);
 138 -       gdrm->saved_vrtren = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_END);
 139 -       gdrm->saved_vdspst = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_START);
 140 -       gdrm->saved_vdspen = reg_read_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_END);
 141 +       /* do nothing */
 142  }
 143
 144
 145  void glamo_display_resume(struct glamodrm_handle *gdrm)
 146  {
 147 +       struct drm_crtc *crtc = gdrm->crtc;
 148 +       struct glamo_crtc *gcrtc = to_glamo_crtc(crtc);
 149 +
 150         glamo_engine_enable(gdrm->glamo_core, GLAMO_ENGINE_LCD);
 151         glamo_engine_reset(gdrm->glamo_core, GLAMO_ENGINE_LCD);
 152         glamo_run_lcd_script(gdrm, lcd_init_script,
 153                                    ARRAY_SIZE(lcd_init_script));
 154
 155 -       /* Restore timings */
 156 -       glamo_lcd_cmd_mode(gdrm, 1);
 157 -       glamo_engine_reclock(gdrm->glamo_core, GLAMO_ENGINE_LCD,
 158 -                            gdrm->saved_clock);
 159 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_WIDTH, GLAMO_LCD_WIDTH_MASK,
 160 -                            gdrm->saved_width);
 161 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HEIGHT, GLAMO_LCD_HEIGHT_MASK,
 162 -                            gdrm->saved_height);
 163 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_PITCH, GLAMO_LCD_PITCH_MASK,
 164 -                            gdrm->saved_pitch);
 165 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_TOTAL,
 166 -                            GLAMO_LCD_HV_TOTAL_MASK, gdrm->saved_htotal);
 167 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_START,
 168 -                            GLAMO_LCD_HV_RETR_START_MASK, gdrm->saved_hrtrst);
 169 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_RETR_END,
 170 -                            GLAMO_LCD_HV_RETR_END_MASK, gdrm->saved_hrtren);
 171 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_START,
 172 -                            GLAMO_LCD_HV_RETR_DISP_START_MASK,
 173 -                            gdrm->saved_hdspst);
 174 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_HORIZ_DISP_END,
 175 -                            GLAMO_LCD_HV_RETR_DISP_END_MASK,
 176 -                            gdrm->saved_hdspen);
 177 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_TOTAL,
 178 -                            GLAMO_LCD_HV_TOTAL_MASK, gdrm->saved_vtotal);
 179 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_START,
 180 -                            GLAMO_LCD_HV_RETR_START_MASK, gdrm->saved_vrtrst);
 181 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_RETR_END,
 182 -                            GLAMO_LCD_HV_RETR_END_MASK, gdrm->saved_vrtren);
 183 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_START,
 184 -                            GLAMO_LCD_HV_RETR_DISP_START_MASK,
 185 -                            gdrm->saved_vdspst);
 186 -       reg_set_bit_mask_lcd(gdrm, GLAMO_REG_LCD_VERT_DISP_END,
 187 -                            GLAMO_LCD_HV_RETR_DISP_END_MASK,
 188 -                            gdrm->saved_vdspen);
 189 -       glamo_lcd_cmd_mode(gdrm, 0);
 190 +       if ( gcrtc->current_mode_set ) {
 191 +               glamo_crtc_mode_set(crtc, &gcrtc->current_mode,
 192 +                                   &gcrtc->current_mode, 0, 0,
 193 +                                   gcrtc->current_fb);
 194 +       }
 195  }
 196 diff --git a/drivers/mfd/glamo/glamo-display.h b/drivers/mfd/glamo/glamo-display.h
 197 index d6f21bc..728bba5 100644
 198 --- a/drivers/mfd/glamo/glamo-display.h
 199 +++ b/drivers/mfd/glamo/glamo-display.h
 200 @@ -36,4 +36,6 @@ extern int glamo_framebuffer_create(struct drm_device *dev,
 201  extern void glamo_display_suspend(struct glamodrm_handle *gdrm);
 202  extern void glamo_display_resume(struct glamodrm_handle *gdrm);
 203
 204 +extern void glamo_lcd_power(struct glamodrm_handle *gdrm, int mode);
 205 +
 206  #endif /* __GLAMO_DISPLAY_H */
 207 diff --git a/drivers/mfd/glamo/glamo-drm-private.h b/drivers/mfd/glamo/glamo-drm-private.h
 208 index 7949a2e..4e24019 100644
 209 --- a/drivers/mfd/glamo/glamo-drm-private.h
 210 +++ b/drivers/mfd/glamo/glamo-drm-private.h
 211 @@ -106,6 +106,9 @@ struct glamodrm_handle {
 212
 213         /* A scratch block */
 214         struct drm_mm_node *scratch;
 215 +
 216 +       /* We only have one */
 217 +       struct drm_crtc *crtc;
 218  };
 219
 220
 221 @@ -118,11 +121,18 @@ struct drm_glamo_gem_object {
 222
 223
 224  struct glamo_crtc {
 225 +
 226         struct drm_crtc base;
 227         struct glamodrm_handle *gdrm;
 228         /* a mode_set for fbdev users on this crtc */
 229         struct drm_mode_set mode_set;
 230         int blank_mode;
 231 +
 232 +       int pixel_clock_on;
 233 +
 234 +       int current_mode_set;
 235 +       struct drm_display_mode current_mode;
 236 +       struct drm_framebuffer *current_fb;
 237  };
 238
 239
 240 diff --git a/drivers/mfd/glamo/glamo-kms-fb.c b/drivers/mfd/glamo/glamo-kms-fb.c
 241 index 61cd605..57680ed 100644
 242 --- a/drivers/mfd/glamo/glamo-kms-fb.c
 243 +++ b/drivers/mfd/glamo/glamo-kms-fb.c
 244 @@ -253,64 +253,24 @@ static void glamofb_on(struct fb_info *info)
 245  {
 246         struct glamofb_par *par = info->par;
 247         struct drm_device *dev = par->dev;
 248 -       struct drm_crtc *crtc;
 249 -       struct drm_encoder *encoder;
 250 -       int i;
 251 +       struct glamodrm_handle *gdrm = dev->dev_private;
 252
 253 -       /*
 254 -        * For each CRTC in this fb, find all associated encoders
 255 -        * and turn them off, then turn off the CRTC.
 256 -        */
 257 -       list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 258 -               struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 259 +       printk(KERN_CRIT "Turning on display...\n");
 260
 261 -               for (i = 0; i < par->crtc_count; i++)
 262 -                       if (crtc->base.id == par->crtc_ids[i])
 263 -                               break;
 264 -
 265 -               crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
 266 +       gdrm = dev->dev_private;
 267
 268 -               /* Found a CRTC on this fb, now find encoders */
 269 -               list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 270 -                       if (encoder->crtc == crtc) {
 271 -                               struct drm_encoder_helper_funcs *encoder_funcs;
 272 -                               encoder_funcs = encoder->helper_private;
 273 -                               encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
 274 -                       }
 275 -               }
 276 -       }
 277 +       glamo_lcd_power(gdrm, 1);
 278  }
 279
 280  static void glamofb_off(struct fb_info *info, int dpms_mode)
 281  {
 282         struct glamofb_par *par = info->par;
 283         struct drm_device *dev = par->dev;
 284 -       struct drm_crtc *crtc;
 285 -       struct drm_encoder *encoder;
 286 -       int i;
 287 +       struct glamodrm_handle *gdrm = dev->dev_private;
 288
 289 -       /*
 290 -        * For each CRTC in this fb, find all associated encoders
 291 -        * and turn them off, then turn off the CRTC.
 292 -        */
 293 -       list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 294 -               struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 295 -
 296 -               for (i = 0; i < par->crtc_count; i++)
 297 -                       if (crtc->base.id == par->crtc_ids[i])
 298 -                               break;
 299 +       printk(KERN_CRIT "Turning off display...\n");
 300
 301 -               /* Found a CRTC on this fb, now find encoders */
 302 -               list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
 303 -                       if (encoder->crtc == crtc) {
 304 -                               struct drm_encoder_helper_funcs *encoder_funcs;
 305 -                               encoder_funcs = encoder->helper_private;
 306 -                               encoder_funcs->dpms(encoder, dpms_mode);
 307 -                       }
 308 -               }
 309 -               if (dpms_mode == DRM_MODE_DPMS_OFF)
 310 -                       crtc_funcs->dpms(crtc, dpms_mode);
 311 -       }
 312 +       glamo_lcd_power(gdrm, 0);
 313  }
 314
 315  static int glamofb_blank(int blank, struct fb_info *info)
 316 diff --git a/drivers/video/backlight/jbt6k74.c b/drivers/video/backlight/jbt6k74.c
 317 index 95ca4cf..9554cb3 100644
 318 --- a/drivers/video/backlight/jbt6k74.c
 319 +++ b/drivers/video/backlight/jbt6k74.c
 320 @@ -107,14 +107,12 @@ enum jbt_resolution {
 321  };
 322
 323  enum jbt_power_mode {
 324 -       JBT_POWER_MODE_DEEP_STANDBY,
 325 -       JBT_POWER_MODE_SLEEP,
 326 +       JBT_POWER_MODE_OFF,
 327         JBT_POWER_MODE_NORMAL,
 328  };
 329
 330  static const char *jbt_power_mode_names[] = {
 331 -       [JBT_POWER_MODE_DEEP_STANDBY]   = "deep-standby",
 332 -       [JBT_POWER_MODE_SLEEP]          = "sleep",
 333 +       [JBT_POWER_MODE_OFF]            = "off",
 334         [JBT_POWER_MODE_NORMAL]         = "normal",
 335  };
 336
 337 @@ -260,14 +258,18 @@ static int jbt_init_regs(struct jbt_info *jbt)
 338         return ret ? -EIO : 0;
 339  }
 340
 341 -static int jbt_standby_to_sleep(struct jbt_info *jbt)
 342 +
 343 +static int jbt_off_to_normal(struct jbt_info *jbt)
 344  {
 345         int ret;
 346 +
 347         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
 348
 349         gpio_set_value_cansleep(pdata->gpio_reset, 1);
 350         ret = regulator_bulk_enable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
 351
 352 +       mdelay(30);
 353 +
 354         /* three times command zero */
 355         ret |= jbt_reg_write_nodata(jbt, 0x00);
 356         mdelay(1);
 357 @@ -279,18 +281,11 @@ static int jbt_standby_to_sleep(struct jbt_info *jbt)
 358         /* deep standby out */
 359         ret |= jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x11);
 360         mdelay(1);
 361 -       ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x28);
 362 +       ret |= jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x28);
 363
 364         /* (re)initialize register set */
 365         ret |= jbt_init_regs(jbt);
 366
 367 -       return ret ? -EIO : 0;
 368 -}
 369 -
 370 -static int jbt_sleep_to_normal(struct jbt_info *jbt)
 371 -{
 372 -       int ret;
 373 -
 374         /* Make sure we are 120 ms after SLEEP_OUT */
 375         if (time_before(jiffies, jbt->next_sleep))
 376                 mdelay(jiffies_to_msecs(jbt->next_sleep - jiffies));
 377 @@ -320,53 +315,34 @@ static int jbt_sleep_to_normal(struct jbt_info *jbt)
 378
 379         /* Sleep mode off */
 380         ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_OUT);
 381 -       jbt->next_sleep = jiffies + msecs_to_jiffies(120);
 382
 383 -       /* Allow the booster and display controller to restart stably */
 384 -       mdelay(5);
 385 -
 386 -       return ret ? -EIO : 0;
 387 -}
 388 -
 389 -static int jbt_normal_to_sleep(struct jbt_info *jbt)
 390 -{
 391 -       int ret;
 392 -
 393 -       /* Make sure we are 120 ms after SLEEP_OUT */
 394 -       while (time_before(jiffies, jbt->next_sleep))
 395 -               cpu_relax();
 396 -
 397 -       ret = jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_OFF);
 398 -       ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0x8000 | 1 << 3);
 399 -       ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_IN);
 400         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
 401
 402 -       /* Allow the internal circuits to stop automatically */
 403 +       /* Allow the booster and display controller to restart stably */
 404         mdelay(5);
 405
 406         return ret ? -EIO : 0;
 407  }
 408
 409 -static int jbt_sleep_to_standby(struct jbt_info *jbt)
 410 +static int jbt_normal_to_off(struct jbt_info *jbt)
 411  {
 412         int ret;
 413         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
 414
 415 -       ret = jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x00);
 416 -
 417 -       if (!ret)
 418 -               ret = regulator_bulk_disable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
 419 +       /* Pull the plug! */
 420 +       ret = regulator_bulk_disable(ARRAY_SIZE(jbt->supplies),
 421 +                                    jbt->supplies);
 422
 423         if (!ret)
 424                 gpio_set_value_cansleep(pdata->gpio_reset, 0);
 425
 426 -       return ret;
 427 +       return ret ? -EIO : 0;
 428  }
 429
 430 +
 431  static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
 432                                         enum jbt_power_mode new_mode)
 433  {
 434 -       struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
 435         int ret = -EINVAL;
 436
 437         dev_dbg(&jbt->spi->dev, "entering (old_state=%s, new_state=%s)\n",
 438 @@ -375,49 +351,14 @@ static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
 439
 440         mutex_lock(&jbt->lock);
 441
 442 -       if (jbt->suspended) {
 443 -               switch (new_mode) {
 444 -               case JBT_POWER_MODE_DEEP_STANDBY:
 445 -               case JBT_POWER_MODE_SLEEP:
 446 -               case JBT_POWER_MODE_NORMAL:
 447 -                       ret = 0;
 448 -                       jbt->suspend_mode = new_mode;
 449 -                       break;
 450 -               default:
 451 -                       break;
 452 -               }
 453 -       } else if (new_mode == JBT_POWER_MODE_NORMAL &&
 454 -                       pdata->enable_pixel_clock) {
 455 -               pdata->enable_pixel_clock(&jbt->spi->dev, 1);
 456 -       }
 457 -
 458         switch (jbt->power_mode) {
 459 -       case JBT_POWER_MODE_DEEP_STANDBY:
 460 -               switch (new_mode) {
 461 -               case JBT_POWER_MODE_DEEP_STANDBY:
 462 -                       ret = 0;
 463 -                       break;
 464 -               case JBT_POWER_MODE_SLEEP:
 465 -                       ret = jbt_standby_to_sleep(jbt);
 466 -                       break;
 467 -               case JBT_POWER_MODE_NORMAL:
 468 -                       /* first transition into sleep */
 469 -                       ret = jbt_standby_to_sleep(jbt);
 470 -                       /* then transition into normal */
 471 -                       ret |= jbt_sleep_to_normal(jbt);
 472 -                       break;
 473 -               }
 474 -               break;
 475 -       case JBT_POWER_MODE_SLEEP:
 476 +       case JBT_POWER_MODE_OFF:
 477                 switch (new_mode) {
 478 -               case JBT_POWER_MODE_SLEEP:
 479 +               case JBT_POWER_MODE_OFF:
 480                         ret = 0;
 481                         break;
 482 -               case JBT_POWER_MODE_DEEP_STANDBY:
 483 -                       ret = jbt_sleep_to_standby(jbt);
 484 -                       break;
 485                 case JBT_POWER_MODE_NORMAL:
 486 -                       ret = jbt_sleep_to_normal(jbt);
 487 +                       ret = jbt_off_to_normal(jbt);
 488                         break;
 489                 }
 490                 break;
 491 @@ -426,25 +367,16 @@ static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
 492                 case JBT_POWER_MODE_NORMAL:
 493                         ret = 0;
 494                         break;
 495 -               case JBT_POWER_MODE_DEEP_STANDBY:
 496 -                       /* first transition into sleep */
 497 -                       ret = jbt_normal_to_sleep(jbt);
 498 -                       /* then transition into deep standby */
 499 -                       ret |= jbt_sleep_to_standby(jbt);
 500 -                       break;
 501 -               case JBT_POWER_MODE_SLEEP:
 502 -                       ret = jbt_normal_to_sleep(jbt);
 503 +               case JBT_POWER_MODE_OFF:
 504 +                       ret = jbt_normal_to_off(jbt);
 505                         break;
 506                 }
 507         }
 508
 509         if (ret == 0) {
 510                 jbt->power_mode = new_mode;
 511 -               if (new_mode != JBT_POWER_MODE_NORMAL &&
 512 -                       pdata->enable_pixel_clock)
 513 -                       pdata->enable_pixel_clock(&jbt->spi->dev, 0);
 514         } else {
 515 -               dev_err(&jbt->spi->dev, "Failed enter state '%s': %d\n",
 516 +               dev_err(&jbt->spi->dev, "Failed to enter state '%s': %d\n",
 517                                 jbt_power_mode_names[new_mode], ret);
 518         }
 519
 520 @@ -470,8 +402,8 @@ static int jbt6k74_set_resolution(struct jbt_info *jbt,
 521         if (jbt->power_mode == JBT_POWER_MODE_NORMAL) {
 522
 523                 /* first transition into sleep */
 524 -               ret = jbt_normal_to_sleep(jbt);
 525 -               ret |= jbt_sleep_to_normal(jbt);
 526 +               ret = jbt_normal_to_off(jbt);
 527 +               ret |= jbt_off_to_normal(jbt);
 528
 529                 if (ret) {
 530                         jbt->resolution = old_resolution;
 531 @@ -589,7 +521,7 @@ static ssize_t reset_write(struct device *dev, struct device_attribute *attr,
 532
 533         mutex_unlock(&jbt->lock);
 534
 535 -       jbt->power_mode = JBT_POWER_MODE_DEEP_STANDBY;
 536 +       jbt->power_mode = JBT_POWER_MODE_OFF;
 537         jbt6k74_enter_power_mode(jbt, old_power_mode);
 538
 539         return count;
 540 @@ -616,27 +548,6 @@ static struct attribute_group jbt_attr_group = {
 541         .attrs  = jbt_sysfs_entries,
 542  };
 543
 544 -/* FIXME: This in an ugly hack to delay display blanking.
 545 -  When the jbt is in sleep mode it displays an all white screen and thus one
 546 -  will a see a short flash.
 547 -  By delaying the blanking we will give the backlight a chance to turn off and
 548 -  thus avoid getting the flash */
 549 -static void jbt_blank_worker(struct work_struct *work)
 550 -{
 551 -       struct jbt_info *jbt  = container_of(work, struct jbt_info,
 552 -                                               blank_work.work);
 553 -
 554 -       switch (jbt->blank_mode) {
 555 -       case FB_BLANK_NORMAL:
 556 -               jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_SLEEP);
 557 -               break;
 558 -       case FB_BLANK_POWERDOWN:
 559 -               jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_DEEP_STANDBY);
 560 -               break;
 561 -       default:
 562 -               break;
 563 -       }
 564 -}
 565
 566  static int jbt6k74_set_mode(struct lcd_device *ld, struct fb_videomode *m)
 567  {
 568 @@ -649,7 +560,7 @@ static int jbt6k74_set_mode(struct lcd_device *ld, struct fb_videomode *m)
 569                 ret = jbt6k74_set_resolution(jbt, JBT_RESOLUTION_VGA);
 570         } else {
 571                 dev_err(&jbt->spi->dev, "Unknown resolution.\n");
 572 -               jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_SLEEP);
 573 +               jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
 574         }
 575
 576         return ret;
 577 @@ -671,11 +582,11 @@ static int jbt6k74_set_power(struct lcd_device *ld, int power)
 578                 break;
 579         case FB_BLANK_NORMAL:
 580                 dev_dbg(&jbt->spi->dev, "blank\n");
 581 -               ret = schedule_delayed_work(&jbt->blank_work, HZ);
 582 +               ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
 583                 break;
 584         case FB_BLANK_POWERDOWN:
 585                 dev_dbg(&jbt->spi->dev, "powerdown\n");
 586 -               ret = schedule_delayed_work(&jbt->blank_work, HZ);
 587 +               ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
 588                 break;
 589         default:
 590                 break;
 591 @@ -691,10 +602,10 @@ static int jbt6k74_get_power(struct lcd_device *ld)
 592         switch (jbt->power_mode) {
 593         case JBT_POWER_MODE_NORMAL:
 594                 return FB_BLANK_UNBLANK;
 595 -       case JBT_POWER_MODE_SLEEP:
 596 +       case JBT_POWER_MODE_OFF:
 597                 return FB_BLANK_NORMAL;
 598         default:
 599 -               return JBT_POWER_MODE_DEEP_STANDBY;
 600 +               return JBT_POWER_MODE_OFF;
 601         }
 602  }
 603
 604 @@ -707,7 +618,7 @@ void jbt6k74_action(int val)
 605                 return;
 606         }
 607         if ( val == 0 ) {
 608 -               jbt6k74_enter_power_mode(jbt_global, JBT_POWER_MODE_SLEEP);
 609 +               jbt6k74_enter_power_mode(jbt_global, JBT_POWER_MODE_OFF);
 610         } else {
 611                 jbt6k74_enter_power_mode(jbt_global, JBT_POWER_MODE_NORMAL);
 612         }
 613 @@ -756,11 +667,9 @@ static int __devinit jbt_probe(struct spi_device *spi)
 614                 goto err_free_drvdata;
 615         }
 616
 617 -       INIT_DELAYED_WORK(&jbt->blank_work, jbt_blank_worker);
 618 -
 619         jbt->resolution = JBT_RESOLUTION_VGA;
 620 -       jbt->power_mode = JBT_POWER_MODE_DEEP_STANDBY;
 621         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
 622 +       jbt->power_mode = JBT_POWER_MODE_OFF;
 623         mutex_init(&jbt->lock);
 624
 625         dev_set_drvdata(&spi->dev, jbt);
 626 @@ -856,9 +765,10 @@ static int jbt_suspend(struct spi_device *spi, pm_message_t state)
 627
 628         jbt->suspend_mode = jbt->power_mode;
 629
 630 -       jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_DEEP_STANDBY);
 631 -       jbt->suspended = 1;
 632 +       printk(KERN_CRIT "[jbt] powering off for suspend\n");
 633 +       jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
 634
 635 +       printk(KERN_CRIT "[jbt] done\n");
 636         dev_info(&spi->dev, "suspended\n");
 637
 638         return 0;
 639 @@ -869,11 +779,13 @@ int jbt6k74_resume(struct spi_device *spi)
 640         struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
 641         dev_info(&spi->dev, "starting resume: %d\n", jbt->suspend_mode);
 642
 643 +       printk(KERN_CRIT "[jbt] powering on for resume\n");
 644         mdelay(20);
 645
 646         jbt->suspended = 0;
 647         jbt6k74_enter_power_mode(jbt, jbt->suspend_mode);
 648
 649 +       printk(KERN_CRIT "[jbt] done\n");
 650         dev_info(&spi->dev, "resumed: %d\n", jbt->suspend_mode);
 651
 652         return 0;
 653 diff --git a/include/linux/jbt6k74.h b/include/linux/jbt6k74.h
 654 index 75488c4..4cf760c 100644
 655 --- a/include/linux/jbt6k74.h
 656 +++ b/include/linux/jbt6k74.h
 657 @@ -13,7 +13,6 @@
 658   */
 659  struct jbt6k74_platform_data {
 660         void (*probe_completed)(struct device *dev);
 661 -       void (*enable_pixel_clock)(struct device *dev, int enable);
 662
 663         int gpio_reset;
 664  };
 665 --
 666 1.7.0
 667