1 /* 2 * broadsheetfb.c -- FB driver for E-Ink Broadsheet 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 driver is written to be used with the Broadsheet display controller. 13 * 14 * It is intended to be architecture independent. A board specific driver 15 * must be used to perform all the physical IO interactions. 16 * 17 */ 18 19 #include <linux/module.h> 20 #include <linux/kernel.h> 21 #include <linux/errno.h> 22 #include <linux/string.h> 23 #include <linux/mm.h> 24 #include <linux/slab.h> 25 #include <linux/vmalloc.h> 26 #include <linux/delay.h> 27 #include <linux/interrupt.h> 28 #include <linux/fb.h> 29 #include <linux/init.h> 30 #include <linux/platform_device.h> 31 #include <linux/list.h> 32 #include <linux/firmware.h> 33 #include <linux/uaccess.h> 34 35 #include <video/broadsheetfb.h> 36 37 /* track panel specific parameters */ 38 struct panel_info { 39 int w; 40 int h; 41 u16 sdcfg; 42 u16 gdcfg; 43 u16 lutfmt; 44 u16 fsynclen; 45 u16 fendfbegin; 46 u16 lsynclen; 47 u16 lendlbegin; 48 u16 pixclk; 49 }; 50 51 /* table of panel specific parameters to be indexed into by the board drivers */ 52 static struct panel_info panel_table[] = { 53 { /* standard 6" on TFT backplane */ 54 .w = 800, 55 .h = 600, 56 .sdcfg = (100 | (1 << 8) | (1 << 9)), 57 .gdcfg = 2, 58 .lutfmt = (4 | (1 << 7)), 59 .fsynclen = 4, 60 .fendfbegin = (10 << 8) | 4, 61 .lsynclen = 10, 62 .lendlbegin = (100 << 8) | 4, 63 .pixclk = 6, 64 }, 65 { /* custom 3.7" flexible on PET or steel */ 66 .w = 320, 67 .h = 240, 68 .sdcfg = (67 | (0 << 8) | (0 << 9) | (0 << 10) | (0 << 12)), 69 .gdcfg = 3, 70 .lutfmt = (4 | (1 << 7)), 71 .fsynclen = 0, 72 .fendfbegin = (80 << 8) | 4, 73 .lsynclen = 10, 74 .lendlbegin = (80 << 8) | 20, 75 .pixclk = 14, 76 }, 77 { /* standard 9.7" on TFT backplane */ 78 .w = 1200, 79 .h = 825, 80 .sdcfg = (100 | (1 << 8) | (1 << 9) | (0 << 10) | (0 << 12)), 81 .gdcfg = 2, 82 .lutfmt = (4 | (1 << 7)), 83 .fsynclen = 0, 84 .fendfbegin = (4 << 8) | 4, 85 .lsynclen = 4, 86 .lendlbegin = (60 << 8) | 10, 87 .pixclk = 3, 88 }, 89 }; 90 91 #define DPY_W 800 92 #define DPY_H 600 93 94 static struct fb_fix_screeninfo broadsheetfb_fix = { 95 .id = "broadsheetfb", 96 .type = FB_TYPE_PACKED_PIXELS, 97 .visual = FB_VISUAL_STATIC_PSEUDOCOLOR, 98 .xpanstep = 0, 99 .ypanstep = 0, 100 .ywrapstep = 0, 101 .line_length = DPY_W, 102 .accel = FB_ACCEL_NONE, 103 }; 104 105 static struct fb_var_screeninfo broadsheetfb_var = { 106 .xres = DPY_W, 107 .yres = DPY_H, 108 .xres_virtual = DPY_W, 109 .yres_virtual = DPY_H, 110 .bits_per_pixel = 8, 111 .grayscale = 1, 112 .red = { 0, 4, 0 }, 113 .green = { 0, 4, 0 }, 114 .blue = { 0, 4, 0 }, 115 .transp = { 0, 0, 0 }, 116 }; 117 118 /* main broadsheetfb functions */ 119 static void broadsheet_gpio_issue_data(struct broadsheetfb_par *par, u16 data) 120 { 121 par->board->set_ctl(par, BS_WR, 0); 122 par->board->set_hdb(par, data); 123 par->board->set_ctl(par, BS_WR, 1); 124 } 125 126 static void broadsheet_gpio_issue_cmd(struct broadsheetfb_par *par, u16 data) 127 { 128 par->board->set_ctl(par, BS_DC, 0); 129 broadsheet_gpio_issue_data(par, data); 130 } 131 132 static void broadsheet_gpio_send_command(struct broadsheetfb_par *par, u16 data) 133 { 134 par->board->wait_for_rdy(par); 135 136 par->board->set_ctl(par, BS_CS, 0); 137 broadsheet_gpio_issue_cmd(par, data); 138 par->board->set_ctl(par, BS_DC, 1); 139 par->board->set_ctl(par, BS_CS, 1); 140 } 141 142 static void broadsheet_gpio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd, 143 int argc, u16 *argv) 144 { 145 int i; 146 147 par->board->wait_for_rdy(par); 148 149 par->board->set_ctl(par, BS_CS, 0); 150 broadsheet_gpio_issue_cmd(par, cmd); 151 par->board->set_ctl(par, BS_DC, 1); 152 153 for (i = 0; i < argc; i++) 154 broadsheet_gpio_issue_data(par, argv[i]); 155 par->board->set_ctl(par, BS_CS, 1); 156 } 157 158 static void broadsheet_mmio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd, 159 int argc, u16 *argv) 160 { 161 int i; 162 163 par->board->mmio_write(par, BS_MMIO_CMD, cmd); 164 165 for (i = 0; i < argc; i++) 166 par->board->mmio_write(par, BS_MMIO_DATA, argv[i]); 167 } 168 169 static void broadsheet_send_command(struct broadsheetfb_par *par, u16 data) 170 { 171 if (par->board->mmio_write) 172 par->board->mmio_write(par, BS_MMIO_CMD, data); 173 else 174 broadsheet_gpio_send_command(par, data); 175 } 176 177 static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd, 178 int argc, u16 *argv) 179 { 180 if (par->board->mmio_write) 181 broadsheet_mmio_send_cmdargs(par, cmd, argc, argv); 182 else 183 broadsheet_gpio_send_cmdargs(par, cmd, argc, argv); 184 } 185 186 static void broadsheet_gpio_burst_write(struct broadsheetfb_par *par, int size, 187 u16 *data) 188 { 189 int i; 190 u16 tmp; 191 192 par->board->set_ctl(par, BS_CS, 0); 193 par->board->set_ctl(par, BS_DC, 1); 194 195 for (i = 0; i < size; i++) { 196 par->board->set_ctl(par, BS_WR, 0); 197 tmp = (data[i] & 0x0F) << 4; 198 tmp |= (data[i] & 0x0F00) << 4; 199 par->board->set_hdb(par, tmp); 200 par->board->set_ctl(par, BS_WR, 1); 201 } 202 203 par->board->set_ctl(par, BS_CS, 1); 204 } 205 206 static void broadsheet_mmio_burst_write(struct broadsheetfb_par *par, int size, 207 u16 *data) 208 { 209 int i; 210 u16 tmp; 211 212 for (i = 0; i < size; i++) { 213 tmp = (data[i] & 0x0F) << 4; 214 tmp |= (data[i] & 0x0F00) << 4; 215 par->board->mmio_write(par, BS_MMIO_DATA, tmp); 216 } 217 218 } 219 220 static void broadsheet_burst_write(struct broadsheetfb_par *par, int size, 221 u16 *data) 222 { 223 if (par->board->mmio_write) 224 broadsheet_mmio_burst_write(par, size, data); 225 else 226 broadsheet_gpio_burst_write(par, size, data); 227 } 228 229 static u16 broadsheet_gpio_get_data(struct broadsheetfb_par *par) 230 { 231 u16 res; 232 /* wait for ready to go hi. (lo is busy) */ 233 par->board->wait_for_rdy(par); 234 235 /* cs lo, dc lo for cmd, we lo for each data, db as usual */ 236 par->board->set_ctl(par, BS_DC, 1); 237 par->board->set_ctl(par, BS_CS, 0); 238 par->board->set_ctl(par, BS_WR, 0); 239 240 res = par->board->get_hdb(par); 241 242 /* strobe wr */ 243 par->board->set_ctl(par, BS_WR, 1); 244 par->board->set_ctl(par, BS_CS, 1); 245 246 return res; 247 } 248 249 250 static u16 broadsheet_get_data(struct broadsheetfb_par *par) 251 { 252 if (par->board->mmio_read) 253 return par->board->mmio_read(par); 254 else 255 return broadsheet_gpio_get_data(par); 256 } 257 258 static void broadsheet_gpio_write_reg(struct broadsheetfb_par *par, u16 reg, 259 u16 data) 260 { 261 /* wait for ready to go hi. (lo is busy) */ 262 par->board->wait_for_rdy(par); 263 264 /* cs lo, dc lo for cmd, we lo for each data, db as usual */ 265 par->board->set_ctl(par, BS_CS, 0); 266 267 broadsheet_gpio_issue_cmd(par, BS_CMD_WR_REG); 268 269 par->board->set_ctl(par, BS_DC, 1); 270 271 broadsheet_gpio_issue_data(par, reg); 272 broadsheet_gpio_issue_data(par, data); 273 274 par->board->set_ctl(par, BS_CS, 1); 275 } 276 277 static void broadsheet_mmio_write_reg(struct broadsheetfb_par *par, u16 reg, 278 u16 data) 279 { 280 par->board->mmio_write(par, BS_MMIO_CMD, BS_CMD_WR_REG); 281 par->board->mmio_write(par, BS_MMIO_DATA, reg); 282 par->board->mmio_write(par, BS_MMIO_DATA, data); 283 284 } 285 286 static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg, 287 u16 data) 288 { 289 if (par->board->mmio_write) 290 broadsheet_mmio_write_reg(par, reg, data); 291 else 292 broadsheet_gpio_write_reg(par, reg, data); 293 } 294 295 static void broadsheet_write_reg32(struct broadsheetfb_par *par, u16 reg, 296 u32 data) 297 { 298 broadsheet_write_reg(par, reg, cpu_to_le32(data) & 0xFFFF); 299 broadsheet_write_reg(par, reg + 2, (cpu_to_le32(data) >> 16) & 0xFFFF); 300 } 301 302 303 static u16 broadsheet_read_reg(struct broadsheetfb_par *par, u16 reg) 304 { 305 broadsheet_send_cmdargs(par, BS_CMD_RD_REG, 1, ®); 306 par->board->wait_for_rdy(par); 307 return broadsheet_get_data(par); 308 } 309 310 /* functions for waveform manipulation */ 311 static int is_broadsheet_pll_locked(struct broadsheetfb_par *par) 312 { 313 return broadsheet_read_reg(par, 0x000A) & 0x0001; 314 } 315 316 static int broadsheet_setup_plls(struct broadsheetfb_par *par) 317 { 318 int retry_count = 0; 319 u16 tmp; 320 321 /* disable arral saemipu mode */ 322 broadsheet_write_reg(par, 0x0006, 0x0000); 323 324 broadsheet_write_reg(par, 0x0010, 0x0004); 325 broadsheet_write_reg(par, 0x0012, 0x5949); 326 broadsheet_write_reg(par, 0x0014, 0x0040); 327 broadsheet_write_reg(par, 0x0016, 0x0000); 328 329 do { 330 if (retry_count++ > 100) 331 return -ETIMEDOUT; 332 mdelay(1); 333 } while (!is_broadsheet_pll_locked(par)); 334 335 tmp = broadsheet_read_reg(par, 0x0006); 336 tmp &= ~0x1; 337 broadsheet_write_reg(par, 0x0006, tmp); 338 339 return 0; 340 } 341 342 static int broadsheet_setup_spi(struct broadsheetfb_par *par) 343 { 344 345 broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1)); 346 broadsheet_write_reg(par, 0x0208, 0x0001); 347 348 return 0; 349 } 350 351 static int broadsheet_setup_spiflash(struct broadsheetfb_par *par, 352 u16 *orig_sfmcd) 353 { 354 355 *orig_sfmcd = broadsheet_read_reg(par, 0x0204); 356 broadsheet_write_reg(par, 0x0208, 0); 357 broadsheet_write_reg(par, 0x0204, 0); 358 broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1)); 359 360 return 0; 361 } 362 363 static int broadsheet_spiflash_wait_for_bit(struct broadsheetfb_par *par, 364 u16 reg, int bitnum, int val, 365 int timeout) 366 { 367 u16 tmp; 368 369 do { 370 tmp = broadsheet_read_reg(par, reg); 371 if (((tmp >> bitnum) & 1) == val) 372 return 0; 373 mdelay(1); 374 } while (timeout--); 375 376 return -ETIMEDOUT; 377 } 378 379 static int broadsheet_spiflash_write_byte(struct broadsheetfb_par *par, u8 data) 380 { 381 broadsheet_write_reg(par, 0x0202, (data | 0x100)); 382 383 return broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100); 384 } 385 386 static int broadsheet_spiflash_read_byte(struct broadsheetfb_par *par, u8 *data) 387 { 388 int err; 389 u16 tmp; 390 391 broadsheet_write_reg(par, 0x0202, 0); 392 393 err = broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100); 394 if (err) 395 return err; 396 397 tmp = broadsheet_read_reg(par, 0x200); 398 399 *data = tmp & 0xFF; 400 401 return 0; 402 } 403 404 static int broadsheet_spiflash_wait_for_status(struct broadsheetfb_par *par, 405 int timeout) 406 { 407 u8 tmp; 408 int err; 409 410 do { 411 broadsheet_write_reg(par, 0x0208, 1); 412 413 err = broadsheet_spiflash_write_byte(par, 0x05); 414 if (err) 415 goto failout; 416 417 err = broadsheet_spiflash_read_byte(par, &tmp); 418 if (err) 419 goto failout; 420 421 broadsheet_write_reg(par, 0x0208, 0); 422 423 if (!(tmp & 0x1)) 424 return 0; 425 426 mdelay(5); 427 } while (timeout--); 428 429 dev_err(par->info->device, "Timed out waiting for spiflash status\n"); 430 return -ETIMEDOUT; 431 432 failout: 433 broadsheet_write_reg(par, 0x0208, 0); 434 return err; 435 } 436 437 static int broadsheet_spiflash_op_on_address(struct broadsheetfb_par *par, 438 u8 op, u32 addr) 439 { 440 int i; 441 u8 tmp; 442 int err; 443 444 broadsheet_write_reg(par, 0x0208, 1); 445 446 err = broadsheet_spiflash_write_byte(par, op); 447 if (err) 448 return err; 449 450 for (i = 2; i >= 0; i--) { 451 tmp = ((addr >> (i * 8)) & 0xFF); 452 err = broadsheet_spiflash_write_byte(par, tmp); 453 if (err) 454 return err; 455 } 456 457 return err; 458 } 459 460 static int broadsheet_verify_spiflash(struct broadsheetfb_par *par, 461 int *flash_type) 462 { 463 int err = 0; 464 u8 sig; 465 466 err = broadsheet_spiflash_op_on_address(par, 0xAB, 0x00000000); 467 if (err) 468 goto failout; 469 470 err = broadsheet_spiflash_read_byte(par, &sig); 471 if (err) 472 goto failout; 473 474 if ((sig != 0x10) && (sig != 0x11)) { 475 dev_err(par->info->device, "Unexpected flash type\n"); 476 err = -EINVAL; 477 goto failout; 478 } 479 480 *flash_type = sig; 481 482 failout: 483 broadsheet_write_reg(par, 0x0208, 0); 484 return err; 485 } 486 487 static int broadsheet_setup_for_wfm_write(struct broadsheetfb_par *par, 488 u16 *initial_sfmcd, int *flash_type) 489 490 { 491 int err; 492 493 err = broadsheet_setup_plls(par); 494 if (err) 495 return err; 496 497 broadsheet_write_reg(par, 0x0106, 0x0203); 498 499 err = broadsheet_setup_spi(par); 500 if (err) 501 return err; 502 503 err = broadsheet_setup_spiflash(par, initial_sfmcd); 504 if (err) 505 return err; 506 507 return broadsheet_verify_spiflash(par, flash_type); 508 } 509 510 static int broadsheet_spiflash_write_control(struct broadsheetfb_par *par, 511 int mode) 512 { 513 int err; 514 515 broadsheet_write_reg(par, 0x0208, 1); 516 if (mode) 517 err = broadsheet_spiflash_write_byte(par, 0x06); 518 else 519 err = broadsheet_spiflash_write_byte(par, 0x04); 520 521 broadsheet_write_reg(par, 0x0208, 0); 522 return err; 523 } 524 525 static int broadsheet_spiflash_erase_sector(struct broadsheetfb_par *par, 526 int addr) 527 { 528 int err; 529 530 broadsheet_spiflash_write_control(par, 1); 531 532 err = broadsheet_spiflash_op_on_address(par, 0xD8, addr); 533 534 broadsheet_write_reg(par, 0x0208, 0); 535 536 if (err) 537 return err; 538 539 err = broadsheet_spiflash_wait_for_status(par, 1000); 540 541 return err; 542 } 543 544 static int broadsheet_spiflash_read_range(struct broadsheetfb_par *par, 545 int addr, int size, char *data) 546 { 547 int err; 548 int i; 549 550 err = broadsheet_spiflash_op_on_address(par, 0x03, addr); 551 if (err) 552 goto failout; 553 554 for (i = 0; i < size; i++) { 555 err = broadsheet_spiflash_read_byte(par, &data[i]); 556 if (err) 557 goto failout; 558 } 559 560 failout: 561 broadsheet_write_reg(par, 0x0208, 0); 562 return err; 563 } 564 565 #define BS_SPIFLASH_PAGE_SIZE 256 566 static int broadsheet_spiflash_write_page(struct broadsheetfb_par *par, 567 int addr, const char *data) 568 { 569 int err; 570 int i; 571 572 broadsheet_spiflash_write_control(par, 1); 573 574 err = broadsheet_spiflash_op_on_address(par, 0x02, addr); 575 if (err) 576 goto failout; 577 578 for (i = 0; i < BS_SPIFLASH_PAGE_SIZE; i++) { 579 err = broadsheet_spiflash_write_byte(par, data[i]); 580 if (err) 581 goto failout; 582 } 583 584 broadsheet_write_reg(par, 0x0208, 0); 585 586 err = broadsheet_spiflash_wait_for_status(par, 100); 587 588 failout: 589 return err; 590 } 591 592 static int broadsheet_spiflash_write_sector(struct broadsheetfb_par *par, 593 int addr, const char *data, int sector_size) 594 { 595 int i; 596 int err; 597 598 for (i = 0; i < sector_size; i += BS_SPIFLASH_PAGE_SIZE) { 599 err = broadsheet_spiflash_write_page(par, addr + i, &data[i]); 600 if (err) 601 return err; 602 } 603 return 0; 604 } 605 606 /* 607 * The caller must guarantee that the data to be rewritten is entirely 608 * contained within this sector. That is, data_start_addr + data_len 609 * must be less than sector_start_addr + sector_size. 610 */ 611 static int broadsheet_spiflash_rewrite_sector(struct broadsheetfb_par *par, 612 int sector_size, int data_start_addr, 613 int data_len, const char *data) 614 { 615 int err; 616 char *sector_buffer; 617 int tail_start_addr; 618 int start_sector_addr; 619 620 sector_buffer = kzalloc(sector_size, GFP_KERNEL); 621 if (!sector_buffer) 622 return -ENOMEM; 623 624 /* the start address of the sector is the 0th byte of that sector */ 625 start_sector_addr = (data_start_addr / sector_size) * sector_size; 626 627 /* 628 * check if there is head data that we need to readback into our sector 629 * buffer first 630 */ 631 if (data_start_addr != start_sector_addr) { 632 /* 633 * we need to read every byte up till the start address of our 634 * data and we put it into our sector buffer. 635 */ 636 err = broadsheet_spiflash_read_range(par, start_sector_addr, 637 data_start_addr, sector_buffer); 638 if (err) 639 goto out; 640 } 641 642 /* now we copy our data into the right place in the sector buffer */ 643 memcpy(sector_buffer + data_start_addr, data, data_len); 644 645 /* 646 * now we check if there is a tail section of the sector that we need to 647 * readback. 648 */ 649 tail_start_addr = (data_start_addr + data_len) % sector_size; 650 651 if (tail_start_addr) { 652 int tail_len; 653 654 tail_len = sector_size - tail_start_addr; 655 656 /* now we read this tail into our sector buffer */ 657 err = broadsheet_spiflash_read_range(par, tail_start_addr, 658 tail_len, sector_buffer + tail_start_addr); 659 if (err) 660 goto out; 661 } 662 663 /* if we got here we have the full sector that we want to rewrite. */ 664 665 /* first erase the sector */ 666 err = broadsheet_spiflash_erase_sector(par, start_sector_addr); 667 if (err) 668 goto out; 669 670 /* now write it */ 671 err = broadsheet_spiflash_write_sector(par, start_sector_addr, 672 sector_buffer, sector_size); 673 out: 674 kfree(sector_buffer); 675 return err; 676 } 677 678 static int broadsheet_write_spiflash(struct broadsheetfb_par *par, u32 wfm_addr, 679 const u8 *wfm, int bytecount, int flash_type) 680 { 681 int sector_size; 682 int err; 683 int cur_addr; 684 int writecount; 685 int maxlen; 686 int offset = 0; 687 688 switch (flash_type) { 689 case 0x10: 690 sector_size = 32*1024; 691 break; 692 case 0x11: 693 default: 694 sector_size = 64*1024; 695 break; 696 } 697 698 while (bytecount) { 699 cur_addr = wfm_addr + offset; 700 maxlen = roundup(cur_addr, sector_size) - cur_addr; 701 writecount = min(bytecount, maxlen); 702 703 err = broadsheet_spiflash_rewrite_sector(par, sector_size, 704 cur_addr, writecount, wfm + offset); 705 if (err) 706 return err; 707 708 offset += writecount; 709 bytecount -= writecount; 710 } 711 712 return 0; 713 } 714 715 static int broadsheet_store_waveform_to_spiflash(struct broadsheetfb_par *par, 716 const u8 *wfm, size_t wfm_size) 717 { 718 int err = 0; 719 u16 initial_sfmcd = 0; 720 int flash_type = 0; 721 722 err = broadsheet_setup_for_wfm_write(par, &initial_sfmcd, &flash_type); 723 if (err) 724 goto failout; 725 726 err = broadsheet_write_spiflash(par, 0x886, wfm, wfm_size, flash_type); 727 728 failout: 729 broadsheet_write_reg(par, 0x0204, initial_sfmcd); 730 return err; 731 } 732 733 static ssize_t broadsheet_loadstore_waveform(struct device *dev, 734 struct device_attribute *attr, 735 const char *buf, size_t len) 736 { 737 int err; 738 struct fb_info *info = dev_get_drvdata(dev); 739 struct broadsheetfb_par *par = info->par; 740 const struct firmware *fw_entry; 741 742 if (len < 1) 743 return -EINVAL; 744 745 err = request_firmware(&fw_entry, "broadsheet.wbf", dev); 746 if (err < 0) { 747 dev_err(dev, "Failed to get broadsheet waveform\n"); 748 goto err_failed; 749 } 750 751 /* try to enforce reasonable min max on waveform */ 752 if ((fw_entry->size < 8*1024) || (fw_entry->size > 64*1024)) { 753 dev_err(dev, "Invalid waveform\n"); 754 err = -EINVAL; 755 goto err_fw; 756 } 757 758 mutex_lock(&(par->io_lock)); 759 err = broadsheet_store_waveform_to_spiflash(par, fw_entry->data, 760 fw_entry->size); 761 762 mutex_unlock(&(par->io_lock)); 763 if (err < 0) { 764 dev_err(dev, "Failed to store broadsheet waveform\n"); 765 goto err_fw; 766 } 767 768 dev_info(dev, "Stored broadsheet waveform, size %zd\n", fw_entry->size); 769 770 err = len; 771 772 err_fw: 773 release_firmware(fw_entry); 774 err_failed: 775 return err; 776 } 777 static DEVICE_ATTR(loadstore_waveform, S_IWUSR, NULL, 778 broadsheet_loadstore_waveform); 779 780 /* upper level functions that manipulate the display and other stuff */ 781 static void broadsheet_init_display(struct broadsheetfb_par *par) 782 { 783 u16 args[5]; 784 int xres = par->info->var.xres; 785 int yres = par->info->var.yres; 786 787 args[0] = panel_table[par->panel_index].w; 788 args[1] = panel_table[par->panel_index].h; 789 args[2] = panel_table[par->panel_index].sdcfg; 790 args[3] = panel_table[par->panel_index].gdcfg; 791 args[4] = panel_table[par->panel_index].lutfmt; 792 broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args); 793 794 /* did the controller really set it? */ 795 broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args); 796 797 args[0] = panel_table[par->panel_index].fsynclen; 798 args[1] = panel_table[par->panel_index].fendfbegin; 799 args[2] = panel_table[par->panel_index].lsynclen; 800 args[3] = panel_table[par->panel_index].lendlbegin; 801 args[4] = panel_table[par->panel_index].pixclk; 802 broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_TMG, 5, args); 803 804 broadsheet_write_reg32(par, 0x310, xres*yres*2); 805 806 /* setup waveform */ 807 args[0] = 0x886; 808 args[1] = 0; 809 broadsheet_send_cmdargs(par, BS_CMD_RD_WFM_INFO, 2, args); 810 811 broadsheet_send_command(par, BS_CMD_UPD_GDRV_CLR); 812 813 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG); 814 815 broadsheet_write_reg(par, 0x330, 0x84); 816 817 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG); 818 819 args[0] = (0x3 << 4); 820 broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args); 821 822 args[0] = 0x154; 823 broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args); 824 825 broadsheet_burst_write(par, (panel_table[par->panel_index].w * 826 panel_table[par->panel_index].h)/2, 827 (u16 *) par->info->screen_base); 828 829 broadsheet_send_command(par, BS_CMD_LD_IMG_END); 830 831 args[0] = 0x4300; 832 broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args); 833 834 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG); 835 836 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND); 837 838 par->board->wait_for_rdy(par); 839 } 840 841 static void broadsheet_identify(struct broadsheetfb_par *par) 842 { 843 u16 rev, prc; 844 struct device *dev = par->info->device; 845 846 rev = broadsheet_read_reg(par, BS_REG_REV); 847 prc = broadsheet_read_reg(par, BS_REG_PRC); 848 dev_info(dev, "Broadsheet Rev 0x%x, Product Code 0x%x\n", rev, prc); 849 850 if (prc != 0x0047) 851 dev_warn(dev, "Unrecognized Broadsheet Product Code\n"); 852 if (rev != 0x0100) 853 dev_warn(dev, "Unrecognized Broadsheet Revision\n"); 854 } 855 856 static void broadsheet_init(struct broadsheetfb_par *par) 857 { 858 broadsheet_send_command(par, BS_CMD_INIT_SYS_RUN); 859 /* the controller needs a second */ 860 msleep(1000); 861 broadsheet_init_display(par); 862 } 863 864 static void broadsheetfb_dpy_update_pages(struct broadsheetfb_par *par, 865 u16 y1, u16 y2) 866 { 867 u16 args[5]; 868 unsigned char *buf = (unsigned char *)par->info->screen_base; 869 870 mutex_lock(&(par->io_lock)); 871 /* y1 must be a multiple of 4 so drop the lower bits */ 872 y1 &= 0xFFFC; 873 /* y2 must be a multiple of 4 , but - 1 so up the lower bits */ 874 y2 |= 0x0003; 875 876 args[0] = 0x3 << 4; 877 args[1] = 0; 878 args[2] = y1; 879 args[3] = cpu_to_le16(par->info->var.xres); 880 args[4] = y2; 881 broadsheet_send_cmdargs(par, BS_CMD_LD_IMG_AREA, 5, args); 882 883 args[0] = 0x154; 884 broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args); 885 886 buf += y1 * par->info->var.xres; 887 broadsheet_burst_write(par, ((1 + y2 - y1) * par->info->var.xres)/2, 888 (u16 *) buf); 889 890 broadsheet_send_command(par, BS_CMD_LD_IMG_END); 891 892 args[0] = 0x4300; 893 broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args); 894 895 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG); 896 897 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND); 898 899 par->board->wait_for_rdy(par); 900 mutex_unlock(&(par->io_lock)); 901 902 } 903 904 static void broadsheetfb_dpy_update(struct broadsheetfb_par *par) 905 { 906 u16 args[5]; 907 908 mutex_lock(&(par->io_lock)); 909 args[0] = 0x3 << 4; 910 broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args); 911 912 args[0] = 0x154; 913 broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args); 914 broadsheet_burst_write(par, (panel_table[par->panel_index].w * 915 panel_table[par->panel_index].h)/2, 916 (u16 *) par->info->screen_base); 917 918 broadsheet_send_command(par, BS_CMD_LD_IMG_END); 919 920 args[0] = 0x4300; 921 broadsheet_send_cmdargs(par, BS_CMD_UPD_FULL, 1, args); 922 923 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_TRG); 924 925 broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND); 926 927 par->board->wait_for_rdy(par); 928 mutex_unlock(&(par->io_lock)); 929 } 930 931 /* this is called back from the deferred io workqueue */ 932 static void broadsheetfb_dpy_deferred_io(struct fb_info *info, 933 struct list_head *pagelist) 934 { 935 u16 y1 = 0, h = 0; 936 int prev_index = -1; 937 struct page *cur; 938 struct fb_deferred_io *fbdefio = info->fbdefio; 939 int h_inc; 940 u16 yres = info->var.yres; 941 u16 xres = info->var.xres; 942 943 /* height increment is fixed per page */ 944 h_inc = DIV_ROUND_UP(PAGE_SIZE , xres); 945 946 /* walk the written page list and swizzle the data */ 947 list_for_each_entry(cur, &fbdefio->pagelist, lru) { 948 if (prev_index < 0) { 949 /* just starting so assign first page */ 950 y1 = (cur->index << PAGE_SHIFT) / xres; 951 h = h_inc; 952 } else if ((prev_index + 1) == cur->index) { 953 /* this page is consecutive so increase our height */ 954 h += h_inc; 955 } else { 956 /* page not consecutive, issue previous update first */ 957 broadsheetfb_dpy_update_pages(info->par, y1, y1 + h); 958 /* start over with our non consecutive page */ 959 y1 = (cur->index << PAGE_SHIFT) / xres; 960 h = h_inc; 961 } 962 prev_index = cur->index; 963 } 964 965 /* if we still have any pages to update we do so now */ 966 if (h >= yres) { 967 /* its a full screen update, just do it */ 968 broadsheetfb_dpy_update(info->par); 969 } else { 970 broadsheetfb_dpy_update_pages(info->par, y1, 971 min((u16) (y1 + h), yres)); 972 } 973 } 974 975 static void broadsheetfb_fillrect(struct fb_info *info, 976 const struct fb_fillrect *rect) 977 { 978 struct broadsheetfb_par *par = info->par; 979 980 sys_fillrect(info, rect); 981 982 broadsheetfb_dpy_update(par); 983 } 984 985 static void broadsheetfb_copyarea(struct fb_info *info, 986 const struct fb_copyarea *area) 987 { 988 struct broadsheetfb_par *par = info->par; 989 990 sys_copyarea(info, area); 991 992 broadsheetfb_dpy_update(par); 993 } 994 995 static void broadsheetfb_imageblit(struct fb_info *info, 996 const struct fb_image *image) 997 { 998 struct broadsheetfb_par *par = info->par; 999 1000 sys_imageblit(info, image); 1001 1002 broadsheetfb_dpy_update(par); 1003 } 1004 1005 /* 1006 * this is the slow path from userspace. they can seek and write to 1007 * the fb. it's inefficient to do anything less than a full screen draw 1008 */ 1009 static ssize_t broadsheetfb_write(struct fb_info *info, const char __user *buf, 1010 size_t count, loff_t *ppos) 1011 { 1012 struct broadsheetfb_par *par = info->par; 1013 unsigned long p = *ppos; 1014 void *dst; 1015 int err = 0; 1016 unsigned long total_size; 1017 1018 if (info->state != FBINFO_STATE_RUNNING) 1019 return -EPERM; 1020 1021 total_size = info->fix.smem_len; 1022 1023 if (p > total_size) 1024 return -EFBIG; 1025 1026 if (count > total_size) { 1027 err = -EFBIG; 1028 count = total_size; 1029 } 1030 1031 if (count + p > total_size) { 1032 if (!err) 1033 err = -ENOSPC; 1034 1035 count = total_size - p; 1036 } 1037 1038 dst = (void *)(info->screen_base + p); 1039 1040 if (copy_from_user(dst, buf, count)) 1041 err = -EFAULT; 1042 1043 if (!err) 1044 *ppos += count; 1045 1046 broadsheetfb_dpy_update(par); 1047 1048 return (err) ? err : count; 1049 } 1050 1051 static struct fb_ops broadsheetfb_ops = { 1052 .owner = THIS_MODULE, 1053 .fb_read = fb_sys_read, 1054 .fb_write = broadsheetfb_write, 1055 .fb_fillrect = broadsheetfb_fillrect, 1056 .fb_copyarea = broadsheetfb_copyarea, 1057 .fb_imageblit = broadsheetfb_imageblit, 1058 }; 1059 1060 static struct fb_deferred_io broadsheetfb_defio = { 1061 .delay = HZ/4, 1062 .deferred_io = broadsheetfb_dpy_deferred_io, 1063 }; 1064 1065 static int broadsheetfb_probe(struct platform_device *dev) 1066 { 1067 struct fb_info *info; 1068 struct broadsheet_board *board; 1069 int retval = -ENOMEM; 1070 int videomemorysize; 1071 unsigned char *videomemory; 1072 struct broadsheetfb_par *par; 1073 int i; 1074 int dpyw, dpyh; 1075 int panel_index; 1076 1077 /* pick up board specific routines */ 1078 board = dev->dev.platform_data; 1079 if (!board) 1080 return -EINVAL; 1081 1082 /* try to count device specific driver, if can't, platform recalls */ 1083 if (!try_module_get(board->owner)) 1084 return -ENODEV; 1085 1086 info = framebuffer_alloc(sizeof(struct broadsheetfb_par), &dev->dev); 1087 if (!info) 1088 goto err; 1089 1090 switch (board->get_panel_type()) { 1091 case 37: 1092 panel_index = 1; 1093 break; 1094 case 97: 1095 panel_index = 2; 1096 break; 1097 case 6: 1098 default: 1099 panel_index = 0; 1100 break; 1101 } 1102 1103 dpyw = panel_table[panel_index].w; 1104 dpyh = panel_table[panel_index].h; 1105 1106 videomemorysize = roundup((dpyw*dpyh), PAGE_SIZE); 1107 1108 videomemory = vzalloc(videomemorysize); 1109 if (!videomemory) 1110 goto err_fb_rel; 1111 1112 info->screen_base = (char *)videomemory; 1113 info->fbops = &broadsheetfb_ops; 1114 1115 broadsheetfb_var.xres = dpyw; 1116 broadsheetfb_var.yres = dpyh; 1117 broadsheetfb_var.xres_virtual = dpyw; 1118 broadsheetfb_var.yres_virtual = dpyh; 1119 info->var = broadsheetfb_var; 1120 1121 broadsheetfb_fix.line_length = dpyw; 1122 info->fix = broadsheetfb_fix; 1123 info->fix.smem_len = videomemorysize; 1124 par = info->par; 1125 par->panel_index = panel_index; 1126 par->info = info; 1127 par->board = board; 1128 par->write_reg = broadsheet_write_reg; 1129 par->read_reg = broadsheet_read_reg; 1130 init_waitqueue_head(&par->waitq); 1131 1132 mutex_init(&par->io_lock); 1133 1134 info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB; 1135 1136 info->fbdefio = &broadsheetfb_defio; 1137 fb_deferred_io_init(info); 1138 1139 retval = fb_alloc_cmap(&info->cmap, 16, 0); 1140 if (retval < 0) { 1141 dev_err(&dev->dev, "Failed to allocate colormap\n"); 1142 goto err_vfree; 1143 } 1144 1145 /* set cmap */ 1146 for (i = 0; i < 16; i++) 1147 info->cmap.red[i] = (((2*i)+1)*(0xFFFF))/32; 1148 memcpy(info->cmap.green, info->cmap.red, sizeof(u16)*16); 1149 memcpy(info->cmap.blue, info->cmap.red, sizeof(u16)*16); 1150 1151 retval = par->board->setup_irq(info); 1152 if (retval < 0) 1153 goto err_cmap; 1154 1155 /* this inits the dpy */ 1156 retval = board->init(par); 1157 if (retval < 0) 1158 goto err_free_irq; 1159 1160 broadsheet_identify(par); 1161 1162 broadsheet_init(par); 1163 1164 retval = register_framebuffer(info); 1165 if (retval < 0) 1166 goto err_free_irq; 1167 1168 platform_set_drvdata(dev, info); 1169 1170 retval = device_create_file(&dev->dev, &dev_attr_loadstore_waveform); 1171 if (retval < 0) 1172 goto err_unreg_fb; 1173 1174 fb_info(info, "Broadsheet frame buffer, using %dK of video memory\n", 1175 videomemorysize >> 10); 1176 1177 1178 return 0; 1179 1180 err_unreg_fb: 1181 unregister_framebuffer(info); 1182 err_free_irq: 1183 board->cleanup(par); 1184 err_cmap: 1185 fb_dealloc_cmap(&info->cmap); 1186 err_vfree: 1187 vfree(videomemory); 1188 err_fb_rel: 1189 framebuffer_release(info); 1190 err: 1191 module_put(board->owner); 1192 return retval; 1193 1194 } 1195 1196 static int broadsheetfb_remove(struct platform_device *dev) 1197 { 1198 struct fb_info *info = platform_get_drvdata(dev); 1199 1200 if (info) { 1201 struct broadsheetfb_par *par = info->par; 1202 1203 device_remove_file(info->dev, &dev_attr_loadstore_waveform); 1204 unregister_framebuffer(info); 1205 fb_deferred_io_cleanup(info); 1206 par->board->cleanup(par); 1207 fb_dealloc_cmap(&info->cmap); 1208 vfree((void *)info->screen_base); 1209 module_put(par->board->owner); 1210 framebuffer_release(info); 1211 } 1212 return 0; 1213 } 1214 1215 static struct platform_driver broadsheetfb_driver = { 1216 .probe = broadsheetfb_probe, 1217 .remove = broadsheetfb_remove, 1218 .driver = { 1219 .name = "broadsheetfb", 1220 }, 1221 }; 1222 module_platform_driver(broadsheetfb_driver); 1223 1224 MODULE_DESCRIPTION("fbdev driver for Broadsheet controller"); 1225 MODULE_AUTHOR("Jaya Kumar"); 1226 MODULE_LICENSE("GPL"); 1227