target/linux/xburst/files-2.6.32/drivers/video/metronomefb.c

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