target/linux/xburst/patches-2.6.34/440-metronome.patch

   1 From c62dfb5d44444dd3add45e10c8950140dcb9f421 Mon Sep 17 00:00:00 2001
   2 From: Lars-Peter Clausen <lars@metafoo.de>
   3 Date: Wed, 12 May 2010 14:24:46 +0200
   4 Subject: [PATCH] metronome patches
   5
   6 ---
   7  drivers/video/metronomefb.c |  788 +++++++++++++++++++++++++++++++++++++------
   8  include/video/metronomefb.h |   33 ++-
   9  2 files changed, 710 insertions(+), 111 deletions(-)
  10
  11 diff --git a/drivers/video/metronomefb.c b/drivers/video/metronomefb.c
  12 index 9b3d6e4..719149e 100644
  13 --- a/drivers/video/metronomefb.c
  14 +++ b/drivers/video/metronomefb.c
  15 @@ -18,11 +18,13 @@
  16   * is provided as am200epd.c
  17   *
  18   */
  19 +
  20  #include <linux/module.h>
  21  #include <linux/kernel.h>
  22  #include <linux/errno.h>
  23  #include <linux/string.h>
  24  #include <linux/mm.h>
  25 +#include <linux/slab.h>
  26  #include <linux/vmalloc.h>
  27  #include <linux/delay.h>
  28  #include <linux/interrupt.h>
  29 @@ -34,16 +36,25 @@
  30  #include <linux/dma-mapping.h>
  31  #include <linux/uaccess.h>
  32  #include <linux/irq.h>
  33 +#include <linux/ctype.h>
  34
  35  #include <video/metronomefb.h>
  36
  37  #include <asm/unaligned.h>
  38
  39 -/* Display specific information */
  40 -#define DPY_W 832
  41 -#define DPY_H 622
  42 +/*
  43 + * 12 is ok to avoid refreshing whole screen while small elements are changed,
  44 + * while forcing full refresh if largish dialog boxes or menus are
  45 + * shown/dismissed.
  46 + */
  47 +#define DEFAULT_MANUAL_REFRESH_THRESHOLD 12
  48 +
  49 +#define WF_MODE_INIT   0 /* Initialization */
  50 +#define WF_MODE_MU     1 /* Monochrome update */
  51 +#define WF_MODE_GU     2 /* Grayscale update */
  52 +#define WF_MODE_GC     3 /* Grayscale clearing */
  53
  54 -static int user_wfm_size;
  55 +static int temp = 25;
  56
  57  /* frame differs from image. frame includes non-visible pixels */
  58  struct epd_frame {
  59 @@ -53,7 +64,7 @@ struct epd_frame {
  60         int wfm_size;
  61  };
  62
  63 -static struct epd_frame epd_frame_table[] = {
  64 +static const struct epd_frame epd_frame_table[] = {
  65         {
  66                 .fw = 832,
  67                 .fh = 622,
  68 @@ -97,24 +108,40 @@ static struct epd_frame epd_frame_table[] = {
  69                 },
  70                 .wfm_size = 46770,
  71         },
  72 +       {
  73 +               .fw = 800,
  74 +               .fh = 600,
  75 +               .config = {
  76 +                       15 /* sdlew */
  77 +                       | 2 << 8 /* sdosz */
  78 +                       | 0 << 11 /* sdor */
  79 +                       | 0 << 12 /* sdces */
  80 +                       | 0 << 15, /* sdcer */
  81 +                       42 /* gdspl */
  82 +                       | 1 << 8 /* gdr1 */
  83 +                       | 1 << 9 /* sdshr */
  84 +                       | 0 << 15, /* gdspp */
  85 +                       18 /* gdspw */
  86 +                       | 0 << 15, /* dispc */
  87 +                       599 /* vdlc */
  88 +                       | 0 << 11 /* dsi */
  89 +                       | 0 << 12, /* dsic */
  90 +               },
  91 +               .wfm_size = 46901,
  92 +       },
  93  };
  94
  95 -static struct fb_fix_screeninfo metronomefb_fix __devinitdata = {
  96 +static const struct fb_fix_screeninfo metronomefb_fix __devinitconst = {
  97         .id =           "metronomefb",
  98         .type =         FB_TYPE_PACKED_PIXELS,
  99         .visual =       FB_VISUAL_STATIC_PSEUDOCOLOR,
 100         .xpanstep =     0,
 101         .ypanstep =     0,
 102         .ywrapstep =    0,
 103 -       .line_length =  DPY_W,
 104         .accel =        FB_ACCEL_NONE,
 105  };
 106
 107 -static struct fb_var_screeninfo metronomefb_var __devinitdata = {
 108 -       .xres           = DPY_W,
 109 -       .yres           = DPY_H,
 110 -       .xres_virtual   = DPY_W,
 111 -       .yres_virtual   = DPY_H,
 112 +static const struct fb_var_screeninfo metronomefb_var __devinitconst = {
 113         .bits_per_pixel = 8,
 114         .grayscale      = 1,
 115         .nonstd         = 1,
 116 @@ -167,7 +194,7 @@ static u16 calc_img_cksum(u16 *start, int length)
 117  }
 118
 119  /* here we decode the incoming waveform file and populate metromem */
 120 -static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 121 +static int load_waveform(u8 *mem, size_t size, int m, int t,
 122                                 struct metronomefb_par *par)
 123  {
 124         int tta;
 125 @@ -181,16 +208,12 @@ static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 126         int mem_idx = 0;
 127         struct waveform_hdr *wfm_hdr;
 128         u8 *metromem = par->metromem_wfm;
 129 -       struct device *dev = par->info->dev;
 130 +       struct device *dev = &par->pdev->dev;
 131 +       u8 mc, trc;
 132 +       u16 *p;
 133 +       u16 img_cksum;
 134
 135 -       if (user_wfm_size)
 136 -               epd_frame_table[par->dt].wfm_size = user_wfm_size;
 137 -
 138 -       if (size != epd_frame_table[par->dt].wfm_size) {
 139 -               dev_err(dev, "Error: unexpected size %Zd != %d\n", size,
 140 -                                       epd_frame_table[par->dt].wfm_size);
 141 -               return -EINVAL;
 142 -       }
 143 +       dev_dbg(dev, "Loading waveforms, mode %d, temperature %d\n", m, t);
 144
 145         wfm_hdr = (struct waveform_hdr *) mem;
 146
 147 @@ -208,8 +231,9 @@ static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 148                                         wfm_hdr->wfm_cs);
 149                 return -EINVAL;
 150         }
 151 -       wfm_hdr->mc += 1;
 152 -       wfm_hdr->trc += 1;
 153 +       mc = wfm_hdr->mc + 1;
 154 +       trc = wfm_hdr->trc + 1;
 155 +
 156         for (i = 0; i < 5; i++) {
 157                 if (*(wfm_hdr->stuff2a + i) != 0) {
 158                         dev_err(dev, "Error: unexpected value in padding\n");
 159 @@ -221,10 +245,10 @@ static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 160         the waveform. presumably selecting the right one for the
 161         desired temperature. it works out the offset of the first
 162         v that exceeds the specified temperature */
 163 -       if ((sizeof(*wfm_hdr) + wfm_hdr->trc) > size)
 164 +       if ((sizeof(*wfm_hdr) + trc) > size)
 165                 return -EINVAL;
 166
 167 -       for (i = sizeof(*wfm_hdr); i <= sizeof(*wfm_hdr) + wfm_hdr->trc; i++) {
 168 +       for (i = sizeof(*wfm_hdr); i <= sizeof(*wfm_hdr) + trc; i++) {
 169                 if (mem[i] > t) {
 170                         trn = i - sizeof(*wfm_hdr) - 1;
 171                         break;
 172 @@ -232,7 +256,7 @@ static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 173         }
 174
 175         /* check temperature range table checksum */
 176 -       cksum_idx = sizeof(*wfm_hdr) + wfm_hdr->trc + 1;
 177 +       cksum_idx = sizeof(*wfm_hdr) + trc + 1;
 178         if (cksum_idx > size)
 179                 return -EINVAL;
 180         cksum = calc_cksum(sizeof(*wfm_hdr), cksum_idx, mem);
 181 @@ -294,6 +318,7 @@ static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 182         cksum_idx = wfm_idx;
 183         if (cksum_idx > size)
 184                 return -EINVAL;
 185 +       dev_dbg(dev, "mem_idx = %u\n", mem_idx);
 186         cksum = calc_cksum(owfm_idx, cksum_idx, mem);
 187         if (cksum != mem[cksum_idx]) {
 188                 dev_err(dev, "Error: bad waveform data cksum"
 189 @@ -302,16 +327,47 @@ static int __devinit load_waveform(u8 *mem, size_t size, int m, int t,
 190         }
 191         par->frame_count = (mem_idx/64);
 192
 193 +       p = (u16 *)par->metromem_wfm;
 194 +       img_cksum = calc_img_cksum(p, 16384 / 2);
 195 +       p[16384 / 2] = __cpu_to_le16(img_cksum);
 196 +
 197 +       par->current_wf_mode = m;
 198 +       par->current_wf_temp = t;
 199 +
 200         return 0;
 201  }
 202
 203 +static int check_err(struct metronomefb_par *par)
 204 +{
 205 +       int res;
 206 +
 207 +       res = par->board->get_err(par);
 208 +       dev_dbg(&par->pdev->dev, "ERR = %d\n", res);
 209 +       return res;
 210 +}
 211 +
 212 +static inline int wait_for_rdy(struct metronomefb_par *par)
 213 +{
 214 +       int res = 0;
 215 +
 216 +       if (!par->board->get_rdy(par))
 217 +               res = par->board->met_wait_event_intr(par);
 218 +
 219 +       return res;
 220 +}
 221 +
 222  static int metronome_display_cmd(struct metronomefb_par *par)
 223  {
 224         int i;
 225         u16 cs;
 226         u16 opcode;
 227 -       static u8 borderval;
 228 +       int res;
 229 +
 230 +       res = wait_for_rdy(par);
 231 +       if (res)
 232 +               return res;
 233
 234 +       dev_dbg(&par->pdev->dev, "%s: ENTER\n", __func__);
 235         /* setup display command
 236         we can't immediately set the opcode since the controller
 237         will try parse the command before we've set it all up
 238 @@ -324,8 +380,9 @@ static int metronome_display_cmd(struct metronomefb_par *par)
 239
 240         /* set the args ( 2 bytes ) for display */
 241         i = 0;
 242 -       par->metromem_cmd->args[i] =    1 << 3 /* border update */
 243 -                                       | ((borderval++ % 4) & 0x0F) << 4
 244 +       par->metromem_cmd->args[i] =    0 << 3 /* border update */
 245 +                                       | (3 << 4)
 246 +//                                     | ((borderval++ % 4) & 0x0F) << 4
 247                                         | (par->frame_count - 1) << 8;
 248         cs += par->metromem_cmd->args[i++];
 249
 250 @@ -335,21 +392,25 @@ static int metronome_display_cmd(struct metronomefb_par *par)
 251         par->metromem_cmd->csum = cs;
 252         par->metromem_cmd->opcode = opcode; /* display cmd */
 253
 254 -       return par->board->met_wait_event_intr(par);
 255 +       return 0;
 256 +
 257  }
 258
 259  static int __devinit metronome_powerup_cmd(struct metronomefb_par *par)
 260  {
 261         int i;
 262         u16 cs;
 263 +       int res;
 264
 265 +       dev_dbg(&par->pdev->dev, "%s: ENTER\n", __func__);
 266         /* setup power up command */
 267         par->metromem_cmd->opcode = 0x1234; /* pwr up pseudo cmd */
 268         cs = par->metromem_cmd->opcode;
 269
 270         /* set pwr1,2,3 to 1024 */
 271         for (i = 0; i < 3; i++) {
 272 -               par->metromem_cmd->args[i] = 1024;
 273 +//             par->metromem_cmd->args[i] = 1024;
 274 +               par->metromem_cmd->args[i] = 100;
 275                 cs += par->metromem_cmd->args[i];
 276         }
 277
 278 @@ -364,7 +425,9 @@ static int __devinit metronome_powerup_cmd(struct metronomefb_par *par)
 279         msleep(1);
 280         par->board->set_stdby(par, 1);
 281
 282 -       return par->board->met_wait_event(par);
 283 +       res = par->board->met_wait_event(par);
 284 +       dev_dbg(&par->pdev->dev, "%s: EXIT: %d\n", __func__, res);
 285 +       return res;
 286  }
 287
 288  static int __devinit metronome_config_cmd(struct metronomefb_par *par)
 289 @@ -373,8 +436,9 @@ static int __devinit metronome_config_cmd(struct metronomefb_par *par)
 290         we can't immediately set the opcode since the controller
 291         will try parse the command before we've set it all up */
 292
 293 -       memcpy(par->metromem_cmd->args, epd_frame_table[par->dt].config,
 294 -               sizeof(epd_frame_table[par->dt].config));
 295 +       dev_dbg(&par->pdev->dev, "%s: ENTER\n", __func__);
 296 +       memcpy(par->metromem_cmd->args, par->epd_frame->config,
 297 +               sizeof(par->epd_frame->config));
 298         /* the rest are 0 */
 299         memset((u8 *) (par->metromem_cmd->args + 4), 0, (32-4)*2);
 300
 301 @@ -395,11 +459,12 @@ static int __devinit metronome_init_cmd(struct metronomefb_par *par)
 302         will try parse the command before we've set it all up
 303         so we just set cs here and set the opcode at the end */
 304
 305 +       dev_dbg(&par->pdev->dev, "%s: ENTER\n", __func__);
 306         cs = 0xCC20;
 307
 308         /* set the args ( 2 bytes ) for init */
 309         i = 0;
 310 -       par->metromem_cmd->args[i] = 0;
 311 +       par->metromem_cmd->args[i] = 0x0007;
 312         cs += par->metromem_cmd->args[i++];
 313
 314         /* the rest are 0 */
 315 @@ -411,76 +476,268 @@ static int __devinit metronome_init_cmd(struct metronomefb_par *par)
 316         return par->board->met_wait_event(par);
 317  }
 318
 319 -static int __devinit metronome_init_regs(struct metronomefb_par *par)
 320 +static int metronome_bootup(struct metronomefb_par *par)
 321  {
 322         int res;
 323
 324 -       res = par->board->setup_io(par);
 325 -       if (res)
 326 -               return res;
 327 -
 328         res = metronome_powerup_cmd(par);
 329 -       if (res)
 330 -               return res;
 331 +       if (res) {
 332 +               dev_err(&par->pdev->dev, "metronomefb: POWERUP cmd failed\n");
 333 +               goto finish;
 334 +       }
 335
 336 +       check_err(par);
 337         res = metronome_config_cmd(par);
 338 -       if (res)
 339 -               return res;
 340 +       if (res) {
 341 +               dev_err(&par->pdev->dev, "metronomefb: CONFIG cmd failed\n");
 342 +               goto finish;
 343 +       }
 344 +       check_err(par);
 345
 346         res = metronome_init_cmd(par);
 347 +       if (res)
 348 +               dev_err(&par->pdev->dev, "metronomefb: INIT cmd failed\n");
 349 +       check_err(par);
 350 +
 351 +finish:
 352 +       return res;
 353 +}
 354 +
 355 +static int __devinit metronome_init_regs(struct metronomefb_par *par)
 356 +{
 357 +       int res;
 358 +
 359 +       if (par->board->power_ctl)
 360 +               par->board->power_ctl(par, METRONOME_POWER_ON);
 361 +
 362 +       res =  metronome_bootup(par);
 363
 364         return res;
 365  }
 366
 367 -static void metronomefb_dpy_update(struct metronomefb_par *par)
 368 +static uint16_t metronomefb_update_img_buffer_rotated(struct metronomefb_par *par)
 369  {
 370 -       int fbsize;
 371 -       u16 cksum;
 372 -       unsigned char *buf = (unsigned char __force *)par->info->screen_base;
 373 +       int x, y;
 374 +       int xstep, ystep;
 375 +       int i, j;
 376 +       uint16_t cksum = 0;
 377 +       uint8_t *buf = par->info->screen_base;
 378 +       uint32_t *img = (uint32_t *)(par->metromem_img);
 379 +       int fw = par->epd_frame->fw;
 380 +       int fh = par->epd_frame->fh;
 381 +       int fw_buf = fw / 4;
 382 +       uint32_t *fxbuckets = par->fxbuckets;
 383 +       uint32_t *fybuckets = par->fybuckets;
 384 +       uint32_t diff;
 385 +       uint32_t tmp;
 386 +
 387 +       switch (par->rotation) {
 388 +       case FB_ROTATE_CW:
 389 +               xstep = -fh;
 390 +               ystep = fw * fh + 1;
 391 +               j = (fw - 1) * fh;
 392 +               break;
 393 +       case FB_ROTATE_UD:
 394 +               xstep = -1;
 395 +               ystep = 0;
 396 +               j = fw * fh - 1;
 397 +               break;
 398 +       case FB_ROTATE_CCW:
 399 +               xstep = fh;
 400 +               ystep = -fw * fh - 1;
 401 +               j = fh - 1;
 402 +               break;
 403 +       default:
 404 +               BUG();
 405 +               break;
 406 +       }
 407 +
 408 +       memset(fxbuckets, 0, fw_buf * sizeof(*fxbuckets));
 409 +       memset(fybuckets, 0, fh * sizeof(*fybuckets));
 410
 411 -       fbsize = par->info->fix.smem_len;
 412 -       /* copy from vm to metromem */
 413 -       memcpy(par->metromem_img, buf, fbsize);
 414 +       i = 0;
 415 +       for (y = 0; y < fh; y++) {
 416 +               for(x = 0; x < fw_buf; x++, i++) {
 417 +                       tmp = (buf[j] << 5);
 418 +                       j += xstep;
 419 +                       tmp |= (buf[j] << 13);
 420 +                       j += xstep;
 421 +                       tmp |= (buf[j] << 21);
 422 +                       j += xstep;
 423 +                       tmp |= (buf[j] << 29);
 424 +                       j += xstep;
 425 +                       tmp &= 0xe0e0e0e0;
 426 +
 427 +                       img[i] &= 0xf0f0f0f0;
 428 +                       diff = img[i] ^ tmp;
 429 +
 430 +                       fxbuckets[x] |= diff;
 431 +                       fybuckets[y] |= diff;
 432 +
 433 +                       img[i] = (img[i] >> 4) | tmp;
 434 +                       cksum += img[i] & 0x0000ffff;
 435 +                       cksum += (img[i] >> 16);
 436
 437 -       cksum = calc_img_cksum((u16 *) par->metromem_img, fbsize/2);
 438 -       *((u16 *)(par->metromem_img) + fbsize/2) = cksum;
 439 -       metronome_display_cmd(par);
 440 +               }
 441 +               j += ystep;
 442 +       }
 443 +
 444 +       return cksum;
 445  }
 446
 447 -static u16 metronomefb_dpy_update_page(struct metronomefb_par *par, int index)
 448 +static uint16_t metronomefb_update_img_buffer_normal(struct metronomefb_par *par)
 449  {
 450 -       int i;
 451 -       u16 csum = 0;
 452 -       u16 *buf = (u16 __force *)(par->info->screen_base + index);
 453 -       u16 *img = (u16 *)(par->metromem_img + index);
 454 +       int x, y, i;
 455 +       uint16_t cksum = 0;
 456 +       uint32_t *buf = (uint32_t __force *)par->info->screen_base;
 457 +       uint32_t *img = (uint32_t *)(par->metromem_img);
 458 +       uint32_t diff;
 459 +       uint32_t tmp;
 460 +       int fw = par->epd_frame->fw;
 461 +       int fh = par->epd_frame->fh;
 462 +       int fw_buf = fw / sizeof(*buf);
 463 +       uint32_t *fxbuckets = par->fxbuckets;
 464 +       uint32_t *fybuckets = par->fybuckets;
 465 +
 466 +       memset(fxbuckets, 0, fw_buf * sizeof(*fxbuckets));
 467 +       memset(fybuckets, 0, fh * sizeof(*fybuckets));
 468 +
 469 +       i = 0;
 470 +       for (y = 0; y < fh; y++) {
 471 +               for(x = 0; x < fw_buf; x++, i++) {
 472 +                       tmp = (buf[i] << 5) & 0xe0e0e0e0;
 473 +                       img[i] &= 0xf0f0f0f0;
 474 +                       diff = img[i] ^ tmp;
 475 +
 476 +                       fxbuckets[x] |= diff;
 477 +                       fybuckets[y] |= diff;
 478 +
 479 +                       img[i] = (img[i] >> 4) | tmp;
 480 +                       cksum += img[i] & 0x0000ffff;
 481 +                       cksum += (img[i] >> 16);
 482 +               }
 483 +       }
 484 +
 485 +       return cksum;
 486 +}
 487 +
 488 +static unsigned int metronomefb_get_change_count(struct metronomefb_par *par)
 489 +{
 490 +       int min_x;
 491 +       int max_x;
 492 +       int min_y;
 493 +       int max_y;
 494 +       int fw = par->epd_frame->fw / 4;
 495 +       int fh = par->epd_frame->fh;
 496 +       unsigned int change_count;
 497 +       uint32_t *fxbuckets = par->fxbuckets;
 498 +       uint32_t *fybuckets = par->fybuckets;
 499 +
 500 +       for (min_x = 0; min_x < fw; ++min_x) {
 501 +               if(fxbuckets[min_x])
 502 +                       break;
 503 +       }
 504 +
 505 +       for (max_x = fw - 1; max_x >= 0; --max_x) {
 506 +               if(fxbuckets[max_x])
 507 +                       break;
 508 +       }
 509 +
 510 +       for (min_y = 0; min_y < fh; min_y++) {
 511 +               if(fybuckets[min_y])
 512 +                       break;
 513 +       }
 514
 515 -       /* swizzle from vm to metromem and recalc cksum at the same time*/
 516 -       for (i = 0; i < PAGE_SIZE/2; i++) {
 517 -               *(img + i) = (buf[i] << 5) & 0xE0E0;
 518 -               csum += *(img + i);
 519 +       for (max_y = fh - 1; max_y >= 0; --max_y) {
 520 +               if(fybuckets[max_y])
 521 +                       break;
 522         }
 523 -       return csum;
 524 +
 525 +       if ((min_x > max_x) || (min_y > max_y))
 526 +               change_count = 0;
 527 +       else
 528 +               change_count = (max_x - min_x + 1) * (max_y - min_y + 1) * 4;
 529 +
 530 +       dev_dbg(&par->pdev->dev, "min_x = %d, max_x = %d, min_y = %d, max_y = %d\n",
 531 +                       min_x, max_x, min_y, max_y);
 532 +
 533 +       return change_count;
 534 +}
 535 +
 536 +static void metronomefb_dpy_update(struct metronomefb_par *par, int clear_all)
 537 +{
 538 +       unsigned int fbsize = par->info->fix.smem_len;
 539 +       uint16_t cksum;
 540 +       int m;
 541 +
 542 +       wait_for_rdy(par);
 543 +
 544 +       if (par->rotation == 0)
 545 +               cksum = metronomefb_update_img_buffer_normal(par);
 546 +       else
 547 +               cksum = metronomefb_update_img_buffer_rotated(par);
 548 +
 549 +       *par->metromem_img_csum = __cpu_to_le16(cksum);
 550 +
 551 +       if (clear_all || par->is_first_update ||
 552 +               (par->partial_updates_count == par->partial_autorefresh_interval)) {
 553 +               m = WF_MODE_GC;
 554 +               par->partial_updates_count = 0;
 555 +       } else {
 556 +               int change_count = metronomefb_get_change_count(par);
 557 +               if (change_count < fbsize / 100 * par->manual_refresh_threshold)
 558 +                       m = WF_MODE_GU;
 559 +               else
 560 +                       m = WF_MODE_GC;
 561 +
 562 +               dev_dbg(&par->pdev->dev, "change_count = %u, treshold = %u%% (%u pixels)\n",
 563 +                               change_count, par->manual_refresh_threshold,
 564 +                               fbsize / 100 * par->manual_refresh_threshold);
 565 +               ++par->partial_updates_count;
 566 +       }
 567 +
 568 +       if (m != par->current_wf_mode)
 569 +               load_waveform((u8 *) par->firmware->data, par->firmware->size,
 570 +                               m, par->current_wf_temp, par);
 571 +
 572 +       for (;;) {
 573 +               if (likely(!check_err(par))) {
 574 +                       metronome_display_cmd(par);
 575 +                       break;
 576 +               }
 577 +
 578 +               par->board->set_stdby(par, 0);
 579 +               dev_warn(&par->pdev->dev, "Resetting Metronome\n");
 580 +               par->board->set_rst(par, 0);
 581 +               mdelay(1);
 582 +               if (par->board->power_ctl)
 583 +                       par->board->power_ctl(par, METRONOME_POWER_OFF);
 584 +
 585 +               mdelay(1);
 586 +               load_waveform((u8 *) par->firmware->data, par->firmware->size,
 587 +                               WF_MODE_GC, par->current_wf_temp, par);
 588 +
 589 +               if (par->board->power_ctl)
 590 +                       par->board->power_ctl(par, METRONOME_POWER_ON);
 591 +               metronome_bootup(par);
 592 +       }
 593 +
 594 +       par->is_first_update = 0;
 595  }
 596
 597  /* this is called back from the deferred io workqueue */
 598  static void metronomefb_dpy_deferred_io(struct fb_info *info,
 599                                 struct list_head *pagelist)
 600  {
 601 -       u16 cksum;
 602 -       struct page *cur;
 603 -       struct fb_deferred_io *fbdefio = info->fbdefio;
 604         struct metronomefb_par *par = info->par;
 605
 606 -       /* walk the written page list and swizzle the data */
 607 -       list_for_each_entry(cur, &fbdefio->pagelist, lru) {
 608 -               cksum = metronomefb_dpy_update_page(par,
 609 -                                       (cur->index << PAGE_SHIFT));
 610 -               par->metromem_img_csum -= par->csum_table[cur->index];
 611 -               par->csum_table[cur->index] = cksum;
 612 -               par->metromem_img_csum += cksum;
 613 -       }
 614 -
 615 -       metronome_display_cmd(par);
 616 +       /* We will update entire display because we need to change
 617 +        * 'previous image' field in pixels which was changed at
 618 +        * previous refresh
 619 +        */
 620 +       mutex_lock(&par->lock);
 621 +       metronomefb_dpy_update(par, 0);
 622 +       mutex_unlock(&par->lock);
 623  }
 624
 625  static void metronomefb_fillrect(struct fb_info *info,
 626 @@ -488,8 +745,10 @@ static void metronomefb_fillrect(struct fb_info *info,
 627  {
 628         struct metronomefb_par *par = info->par;
 629
 630 +       mutex_lock(&par->lock);
 631         sys_fillrect(info, rect);
 632 -       metronomefb_dpy_update(par);
 633 +       metronomefb_dpy_update(par, 0);
 634 +       mutex_unlock(&par->lock);
 635  }
 636
 637  static void metronomefb_copyarea(struct fb_info *info,
 638 @@ -497,8 +756,10 @@ static void metronomefb_copyarea(struct fb_info *info,
 639  {
 640         struct metronomefb_par *par = info->par;
 641
 642 +       mutex_lock(&par->lock);
 643         sys_copyarea(info, area);
 644 -       metronomefb_dpy_update(par);
 645 +       metronomefb_dpy_update(par, 0);
 646 +       mutex_unlock(&par->lock);
 647  }
 648
 649  static void metronomefb_imageblit(struct fb_info *info,
 650 @@ -506,8 +767,10 @@ static void metronomefb_imageblit(struct fb_info *info,
 651  {
 652         struct metronomefb_par *par = info->par;
 653
 654 +       mutex_lock(&par->lock);
 655         sys_imageblit(info, image);
 656 -       metronomefb_dpy_update(par);
 657 +       metronomefb_dpy_update(par, 0);
 658 +       mutex_unlock(&par->lock);
 659  }
 660
 661  /*
 662 @@ -545,30 +808,229 @@ static ssize_t metronomefb_write(struct fb_info *info, const char __user *buf,
 663
 664         dst = (void __force *)(info->screen_base + p);
 665
 666 +       mutex_lock(&par->lock);
 667 +
 668         if (copy_from_user(dst, buf, count))
 669                 err = -EFAULT;
 670
 671         if  (!err)
 672                 *ppos += count;
 673
 674 -       metronomefb_dpy_update(par);
 675 +       metronomefb_dpy_update(par, 0);
 676 +       mutex_unlock(&par->lock);
 677
 678         return (err) ? err : count;
 679  }
 680
 681 +static int metronome_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 682 +{
 683 +       struct metronomefb_par *par = info->par;
 684 +
 685 +       var->grayscale = 1;
 686 +
 687 +       switch (par->rotation) {
 688 +       case FB_ROTATE_CW:
 689 +       case FB_ROTATE_CCW:
 690 +               if (par->epd_frame->fw == var->yres && par->epd_frame->fh == var->xres)
 691 +                       return 0;
 692 +               break;
 693 +       case FB_ROTATE_UD:
 694 +       default:
 695 +               if (par->epd_frame->fw == var->xres && par->epd_frame->fh == var->yres)
 696 +                       return 0;
 697 +               break;
 698 +       }
 699 +
 700 +       return -EINVAL;
 701 +}
 702 +
 703 +static int metronomefb_set_par(struct fb_info *info)
 704 +{
 705 +       struct metronomefb_par *par = info->par;
 706 +
 707 +       par->rotation = (par->board->panel_rotation + info->var.rotate) % 4;
 708 +
 709 +       switch (par->rotation) {
 710 +       case FB_ROTATE_CW:
 711 +       case FB_ROTATE_CCW:
 712 +               info->fix.line_length = par->epd_frame->fh;
 713 +               break;
 714 +       case FB_ROTATE_UD:
 715 +       default:
 716 +               info->fix.line_length = par->epd_frame->fw;
 717 +               break;
 718 +       }
 719 +
 720 +       mutex_lock(&par->lock);
 721 +       metronomefb_dpy_update(info->par, 1);
 722 +       mutex_unlock(&par->lock);
 723 +
 724 +       return 0;
 725 +}
 726 +
 727  static struct fb_ops metronomefb_ops = {
 728         .owner          = THIS_MODULE,
 729         .fb_write       = metronomefb_write,
 730         .fb_fillrect    = metronomefb_fillrect,
 731         .fb_copyarea    = metronomefb_copyarea,
 732         .fb_imageblit   = metronomefb_imageblit,
 733 +       .fb_check_var   = metronome_check_var,
 734 +       .fb_set_par     = metronomefb_set_par,
 735  };
 736
 737  static struct fb_deferred_io metronomefb_defio = {
 738 -       .delay          = HZ,
 739 +       .delay          = HZ / 4,
 740         .deferred_io    = metronomefb_dpy_deferred_io,
 741  };
 742
 743 +static ssize_t metronomefb_defio_delay_show(struct device *dev,
 744 +               struct device_attribute *attr, char *buf)
 745 +{
 746 +       struct fb_info *info = dev_get_drvdata(dev);
 747 +
 748 +       sprintf(buf, "%lu\n", info->fbdefio->delay * 1000 / HZ);
 749 +       return strlen(buf) + 1;
 750 +}
 751 +
 752 +static ssize_t metronomefb_defio_delay_store(struct device *dev,
 753 +               struct device_attribute *attr, const char *buf, size_t size)
 754 +{
 755 +       struct fb_info *info = dev_get_drvdata(dev);
 756 +       char *after;
 757 +       unsigned long state = simple_strtoul(buf, &after, 10);
 758 +       size_t count = after - buf;
 759 +       ssize_t ret = -EINVAL;
 760 +
 761 +       if (*after && isspace(*after))
 762 +               count++;
 763 +
 764 +       state = state * HZ / 1000;
 765 +
 766 +       if (!state)
 767 +               state = 1;
 768 +
 769 +       if (count == size) {
 770 +               ret = count;
 771 +               info->fbdefio->delay = state;
 772 +       }
 773 +
 774 +       return ret;
 775 +}
 776 +
 777 +static ssize_t metronomefb_manual_refresh_thr_show(struct device *dev,
 778 +               struct device_attribute *attr, char *buf)
 779 +{
 780 +       struct fb_info *info = dev_get_drvdata(dev);
 781 +       struct metronomefb_par *par = info->par;
 782 +
 783 +       return sprintf(buf, "%u\n", par->manual_refresh_threshold);
 784 +}
 785 +
 786 +static ssize_t metronomefb_manual_refresh_thr_store(struct device *dev,
 787 +               struct device_attribute *attr, const char *buf, size_t size)
 788 +{
 789 +       struct fb_info *info = dev_get_drvdata(dev);
 790 +       struct metronomefb_par *par = info->par;
 791 +       char *after;
 792 +       unsigned long val = simple_strtoul(buf, &after, 10);
 793 +       size_t count = after - buf;
 794 +       ssize_t ret = -EINVAL;
 795 +
 796 +       if (*after && isspace(*after))
 797 +               count++;
 798 +
 799 +       if (val > 100)
 800 +               return -EINVAL;
 801 +
 802 +
 803 +       if (count == size) {
 804 +               ret = count;
 805 +               par->manual_refresh_threshold = val;
 806 +       }
 807 +
 808 +       return ret;
 809 +}
 810 +
 811 +static ssize_t metronomefb_autorefresh_interval_show(struct device *dev,
 812 +               struct device_attribute *attr, char *buf)
 813 +{
 814 +       struct fb_info *info = dev_get_drvdata(dev);
 815 +       struct metronomefb_par *par = info->par;
 816 +
 817 +       return sprintf(buf, "%u\n", par->partial_autorefresh_interval);
 818 +}
 819 +
 820 +static ssize_t metronomefb_autorefresh_interval_store(struct device *dev,
 821 +               struct device_attribute *attr, const char *buf, size_t size)
 822 +{
 823 +       struct fb_info *info = dev_get_drvdata(dev);
 824 +       struct metronomefb_par *par = info->par;
 825 +       char *after;
 826 +       unsigned long val = simple_strtoul(buf, &after, 10);
 827 +       size_t count = after - buf;
 828 +       ssize_t ret = -EINVAL;
 829 +
 830 +       if (*after && isspace(*after))
 831 +               count++;
 832 +
 833 +       if (val > 100)
 834 +               return -EINVAL;
 835 +
 836 +
 837 +       if (count == size) {
 838 +               ret = count;
 839 +               par->partial_autorefresh_interval = val;
 840 +       }
 841 +
 842 +       return ret;
 843 +}
 844 +
 845 +static ssize_t metronomefb_temp_show(struct device *dev,
 846 +               struct device_attribute *attr, char *buf)
 847 +{
 848 +       struct fb_info *info = dev_get_drvdata(dev);
 849 +       struct metronomefb_par *par = info->par;
 850 +
 851 +       return sprintf(buf, "%u\n", par->current_wf_temp);
 852 +}
 853 +
 854 +static ssize_t metronomefb_temp_store(struct device *dev,
 855 +               struct device_attribute *attr, const char *buf, size_t size)
 856 +{
 857 +       struct fb_info *info = dev_get_drvdata(dev);
 858 +       struct metronomefb_par *par = info->par;
 859 +       char *after;
 860 +       unsigned long val = simple_strtoul(buf, &after, 10);
 861 +       size_t count = after - buf;
 862 +       ssize_t ret = -EINVAL;
 863 +
 864 +       if (*after && isspace(*after))
 865 +               count++;
 866 +
 867 +       if (val > 100)
 868 +               return -EINVAL;
 869 +
 870 +
 871 +       if (count == size) {
 872 +               ret = count;
 873 +               if (val != par->current_wf_temp)
 874 +                       load_waveform((u8 *) par->firmware->data, par->firmware->size,
 875 +                                       par->current_wf_mode, val, par);
 876 +       }
 877 +
 878 +       return ret;
 879 +}
 880 +
 881 +DEVICE_ATTR(defio_delay, 0644,
 882 +               metronomefb_defio_delay_show, metronomefb_defio_delay_store);
 883 +DEVICE_ATTR(manual_refresh_threshold, 0644,
 884 +               metronomefb_manual_refresh_thr_show, metronomefb_manual_refresh_thr_store);
 885 +DEVICE_ATTR(temp, 0644,
 886 +               metronomefb_temp_show, metronomefb_temp_store);
 887 +DEVICE_ATTR(autorefresh_interval, 0644,
 888 +               metronomefb_autorefresh_interval_show, metronomefb_autorefresh_interval_store);
 889 +
 890 +
 891  static int __devinit metronomefb_probe(struct platform_device *dev)
 892  {
 893         struct fb_info *info;
 894 @@ -607,6 +1069,9 @@ static int __devinit metronomefb_probe(struct platform_device *dev)
 895
 896         panel_type = board->get_panel_type();
 897         switch (panel_type) {
 898 +       case 5:
 899 +               epd_dt_index = 3;
 900 +               break;
 901         case 6:
 902                 epd_dt_index = 0;
 903                 break;
 904 @@ -632,29 +1097,59 @@ static int __devinit metronomefb_probe(struct platform_device *dev)
 905         if (!videomemory)
 906                 goto err_fb_rel;
 907
 908 -       memset(videomemory, 0, videomemorysize);
 909 +       memset(videomemory, 0xff, videomemorysize);
 910
 911         info->screen_base = (char __force __iomem *)videomemory;
 912         info->fbops = &metronomefb_ops;
 913
 914 -       metronomefb_fix.line_length = fw;
 915 -       metronomefb_var.xres = fw;
 916 -       metronomefb_var.yres = fh;
 917 -       metronomefb_var.xres_virtual = fw;
 918 -       metronomefb_var.yres_virtual = fh;
 919         info->var = metronomefb_var;
 920         info->fix = metronomefb_fix;
 921 -       info->fix.smem_len = videomemorysize;
 922 +       switch (board->panel_rotation) {
 923 +       case FB_ROTATE_CW:
 924 +       case FB_ROTATE_CCW:
 925 +               info->var.xres = fh;
 926 +               info->var.yres = fw;
 927 +               info->var.xres_virtual = fh;
 928 +               info->var.yres_virtual = fw;
 929 +               info->fix.line_length = fh;
 930 +               break;
 931 +       case FB_ROTATE_UD:
 932 +       default:
 933 +               info->var.xres = fw;
 934 +               info->var.yres = fh;
 935 +               info->var.xres_virtual = fw;
 936 +               info->var.yres_virtual = fh;
 937 +               info->fix.line_length = fw;
 938 +               break;
 939 +       }
 940 +       info->fix.smem_len = fw * fh; /* Real size of image area */
 941         par = info->par;
 942         par->info = info;
 943         par->board = board;
 944 -       par->dt = epd_dt_index;
 945 +       par->epd_frame = &epd_frame_table[epd_dt_index];
 946 +       par->pdev = dev;
 947 +
 948 +       par->rotation = board->panel_rotation;
 949 +
 950 +       par->fxbuckets = kmalloc((fw / 4 + 1) * sizeof(*par->fxbuckets), GFP_KERNEL);
 951 +       if (!par->fxbuckets)
 952 +               goto err_vfree;
 953 +
 954 +       par->fybuckets = kmalloc(fh * sizeof(*par->fybuckets), GFP_KERNEL);
 955 +       if (!par->fybuckets)
 956 +               goto err_fxbuckets;
 957 +
 958         init_waitqueue_head(&par->waitq);
 959 +       par->manual_refresh_threshold = DEFAULT_MANUAL_REFRESH_THRESHOLD;
 960 +       par->partial_autorefresh_interval = 256;
 961 +       par->partial_updates_count = 0;
 962 +       par->is_first_update = 1;
 963 +       mutex_init(&par->lock);
 964
 965         /* this table caches per page csum values. */
 966         par->csum_table = vmalloc(videomemorysize/PAGE_SIZE);
 967         if (!par->csum_table)
 968 -               goto err_vfree;
 969 +               goto err_fybuckets;
 970
 971         /* the physical framebuffer that we use is setup by
 972          * the platform device driver. It will provide us
 973 @@ -684,13 +1179,19 @@ static int __devinit metronomefb_probe(struct platform_device *dev)
 974                 goto err_csum_table;
 975         }
 976
 977 -       retval = load_waveform((u8 *) fw_entry->data, fw_entry->size, 3, 31,
 978 +       retval = load_waveform((u8 *) fw_entry->data, fw_entry->size, WF_MODE_GC, temp,
 979                                 par);
 980 -       release_firmware(fw_entry);
 981         if (retval < 0) {
 982                 dev_err(&dev->dev, "Failed processing waveform\n");
 983                 goto err_csum_table;
 984         }
 985 +       par->firmware = fw_entry;
 986 +
 987 +       retval = board->setup_io(par);
 988 +       if (retval) {
 989 +               dev_err(&dev->dev, "metronomefb: setup_io() failed\n");
 990 +               goto err_csum_table;
 991 +       }
 992
 993         if (board->setup_irq(info))
 994                 goto err_csum_table;
 995 @@ -712,7 +1213,7 @@ static int __devinit metronomefb_probe(struct platform_device *dev)
 996
 997         /* set cmap */
 998         for (i = 0; i < 8; i++)
 999 -               info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/16;
1000 +               info->cmap.red[i] = ((2 * i + 1)*(0xFFFF))/16;
1001         memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*8);
1002         memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*8);
1003
1004 @@ -722,18 +1223,47 @@ static int __devinit metronomefb_probe(struct platform_device *dev)
1005
1006         platform_set_drvdata(dev, info);
1007
1008 -       dev_dbg(&dev->dev,
1009 +       retval = device_create_file(info->dev, &dev_attr_defio_delay);
1010 +       if (retval)
1011 +               goto err_devattr_defio_delay;
1012 +
1013 +       retval = device_create_file(info->dev, &dev_attr_manual_refresh_threshold);
1014 +       if (retval)
1015 +               goto err_devattr_manual_refresh_thr;
1016 +
1017 +       retval = device_create_file(info->dev, &dev_attr_temp);
1018 +       if (retval)
1019 +               goto err_devattr_temp;
1020 +
1021 +       retval = device_create_file(info->dev, &dev_attr_autorefresh_interval);
1022 +       if (retval)
1023 +               goto err_devattr_autorefresh;
1024 +
1025 +       dev_info(&dev->dev,
1026                 "fb%d: Metronome frame buffer device, using %dK of video"
1027                 " memory\n", info->node, videomemorysize >> 10);
1028
1029         return 0;
1030
1031 +       device_remove_file(info->dev, &dev_attr_autorefresh_interval);
1032 +err_devattr_autorefresh:
1033 +       device_remove_file(info->dev, &dev_attr_temp);
1034 +err_devattr_temp:
1035 +       device_remove_file(info->dev, &dev_attr_manual_refresh_threshold);
1036 +err_devattr_manual_refresh_thr:
1037 +       device_remove_file(info->dev, &dev_attr_defio_delay);
1038 +err_devattr_defio_delay:
1039 +       unregister_framebuffer(info);
1040  err_cmap:
1041         fb_dealloc_cmap(&info->cmap);
1042  err_free_irq:
1043         board->cleanup(par);
1044  err_csum_table:
1045         vfree(par->csum_table);
1046 +err_fybuckets:
1047 +       kfree(par->fybuckets);
1048 +err_fxbuckets:
1049 +       kfree(par->fxbuckets);
1050  err_vfree:
1051         vfree(videomemory);
1052  err_fb_rel:
1053 @@ -750,26 +1280,76 @@ static int __devexit metronomefb_remove(struct platform_device *dev)
1054         if (info) {
1055                 struct metronomefb_par *par = info->par;
1056
1057 +               par->board->set_stdby(par, 0);
1058 +               mdelay(1);
1059 +               if (par->board->power_ctl)
1060 +                       par->board->power_ctl(par, METRONOME_POWER_OFF);
1061 +
1062 +               device_remove_file(info->dev, &dev_attr_autorefresh_interval);
1063 +               device_remove_file(info->dev, &dev_attr_temp);
1064 +               device_remove_file(info->dev, &dev_attr_manual_refresh_threshold);
1065 +               device_remove_file(info->dev, &dev_attr_defio_delay);
1066                 unregister_framebuffer(info);
1067                 fb_deferred_io_cleanup(info);
1068                 fb_dealloc_cmap(&info->cmap);
1069                 par->board->cleanup(par);
1070                 vfree(par->csum_table);
1071 +               kfree(par->fybuckets);
1072 +               kfree(par->fxbuckets);
1073                 vfree((void __force *)info->screen_base);
1074                 module_put(par->board->owner);
1075 +               release_firmware(par->firmware);
1076                 dev_dbg(&dev->dev, "calling release\n");
1077                 framebuffer_release(info);
1078         }
1079         return 0;
1080  }
1081
1082 +#ifdef CONFIG_PM
1083 +static int metronomefb_suspend(struct platform_device *pdev, pm_message_t message)
1084 +{
1085 +       struct fb_info *info = platform_get_drvdata(pdev);
1086 +       struct metronomefb_par *par = info->par;
1087 +
1088 +       par->board->set_stdby(par, 0);
1089 +       par->board->set_rst(par, 0);
1090 +       if (par->board->power_ctl)
1091 +               par->board->power_ctl(par, METRONOME_POWER_OFF);
1092 +
1093 +
1094 +       return 0;
1095 +}
1096 +
1097 +static int metronomefb_resume(struct platform_device *pdev)
1098 +{
1099 +       struct fb_info *info = platform_get_drvdata(pdev);
1100 +       struct metronomefb_par *par = info->par;
1101 +
1102 +       if (par->board->power_ctl)
1103 +               par->board->power_ctl(par, METRONOME_POWER_ON);
1104 +
1105 +       mutex_lock(&par->lock);
1106 +       metronome_bootup(par);
1107 +       mutex_unlock(&par->lock);
1108 +
1109 +       return 0;
1110 +}
1111 +
1112 +#else
1113 +#define metronomefb_suspend NULL
1114 +#define metronomefb_resume NULL
1115 +#endif
1116 +
1117 +
1118  static struct platform_driver metronomefb_driver = {
1119 -       .probe  = metronomefb_probe,
1120 -       .remove = metronomefb_remove,
1121 -       .driver = {
1122 -               .owner  = THIS_MODULE,
1123 -               .name   = "metronomefb",
1124 -       },
1125 +       .driver         = {
1126 +                       .owner  = THIS_MODULE,
1127 +                       .name   = "metronomefb",
1128 +                       },
1129 +       .probe          = metronomefb_probe,
1130 +       .remove         = __devexit_p(metronomefb_remove),
1131 +       .suspend        = metronomefb_suspend,
1132 +       .resume         = metronomefb_resume,
1133  };
1134
1135  static int __init metronomefb_init(void)
1136 @@ -782,8 +1362,8 @@ static void __exit metronomefb_exit(void)
1137         platform_driver_unregister(&metronomefb_driver);
1138  }
1139
1140 -module_param(user_wfm_size, uint, 0);
1141 -MODULE_PARM_DESC(user_wfm_size, "Set custom waveform size");
1142 +module_param(temp, int, 0);
1143 +MODULE_PARM_DESC(temp, "Set current temperature");
1144
1145  module_init(metronomefb_init);
1146  module_exit(metronomefb_exit);
1147 diff --git a/include/video/metronomefb.h b/include/video/metronomefb.h
1148 index 9863f4b..f505348 100644
1149 --- a/include/video/metronomefb.h
1150 +++ b/include/video/metronomefb.h
1151 @@ -17,7 +17,9 @@ struct metromem_cmd {
1152         u16 opcode;
1153         u16 args[((64-2)/2)];
1154         u16 csum;
1155 -};
1156 +} __attribute__((packed));
1157 +
1158 +struct epd_frame;
1159
1160  /* struct used by metronome. board specific stuff comes from *board */
1161  struct metronomefb_par {
1162 @@ -27,19 +29,40 @@ struct metronomefb_par {
1163         u16 *metromem_img_csum;
1164         u16 *csum_table;
1165         dma_addr_t metromem_dma;
1166 +       const struct firmware *firmware;
1167         struct fb_info *info;
1168         struct metronome_board *board;
1169 +       struct platform_device *pdev;
1170         wait_queue_head_t waitq;
1171         u8 frame_count;
1172         int extra_size;
1173 -       int dt;
1174 +       int current_wf_mode;
1175 +       int current_wf_temp;
1176 +       unsigned int manual_refresh_threshold;
1177 +       unsigned int partial_autorefresh_interval;
1178 +       const struct epd_frame *epd_frame;
1179 +       u32 *fxbuckets;
1180 +       u32 *fybuckets;
1181 +
1182 +       int rotation;
1183 +
1184 +       unsigned int partial_updates_count;
1185 +       unsigned is_first_update:1;
1186 +
1187 +       struct mutex lock;
1188  };
1189
1190 +#define METRONOME_POWER_OFF    0
1191 +#define METRONOME_POWER_ON     1
1192 +
1193  /* board specific routines and data */
1194  struct metronome_board {
1195         struct module *owner; /* the platform device */
1196 +       void (*power_ctl)(struct metronomefb_par *, int);
1197         void (*set_rst)(struct metronomefb_par *, int);
1198         void (*set_stdby)(struct metronomefb_par *, int);
1199 +       int (*get_err)(struct metronomefb_par *);
1200 +       int (*get_rdy)(struct metronomefb_par *);
1201         void (*cleanup)(struct metronomefb_par *);
1202         int (*met_wait_event)(struct metronomefb_par *);
1203         int (*met_wait_event_intr)(struct metronomefb_par *);
1204 @@ -47,11 +70,7 @@ struct metronome_board {
1205         int (*setup_fb)(struct metronomefb_par *);
1206         int (*setup_io)(struct metronomefb_par *);
1207         int (*get_panel_type)(void);
1208 -       unsigned char *metromem;
1209 -       int fw;
1210 -       int fh;
1211 -       int wfm_size;
1212 -       struct fb_info *host_fbinfo; /* the host LCD controller's fbi */
1213 +       int panel_rotation;
1214  };
1215
1216  #endif
1217 --
1218 1.5.6.5
1219