1/* 2 * Common code for AUO-K190X framebuffer drivers 3 * 4 * Copyright (C) 2012 Heiko Stuebner <heiko@sntech.de> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11#include <linux/module.h> 12#include <linux/kernel.h> 13#include <linux/gpio.h> 14#include <linux/platform_device.h> 15#include <linux/pm_runtime.h> 16#include <linux/fb.h> 17#include <linux/delay.h> 18#include <linux/uaccess.h> 19#include <linux/vmalloc.h> 20#include <linux/regulator/consumer.h> 21 22#include <video/auo_k190xfb.h> 23 24#include "auo_k190x.h" 25 26struct panel_info { 27 int w; 28 int h; 29}; 30 31/* table of panel specific parameters to be indexed into by the board drivers */ 32static struct panel_info panel_table[] = { 33 /* standard 6" */ 34 [AUOK190X_RESOLUTION_800_600] = { 35 .w = 800, 36 .h = 600, 37 }, 38 /* standard 9" */ 39 [AUOK190X_RESOLUTION_1024_768] = { 40 .w = 1024, 41 .h = 768, 42 }, 43 [AUOK190X_RESOLUTION_600_800] = { 44 .w = 600, 45 .h = 800, 46 }, 47 [AUOK190X_RESOLUTION_768_1024] = { 48 .w = 768, 49 .h = 1024, 50 }, 51}; 52 53/* 54 * private I80 interface to the board driver 55 */ 56 57static void auok190x_issue_data(struct auok190xfb_par *par, u16 data) 58{ 59 par->board->set_ctl(par, AUOK190X_I80_WR, 0); 60 par->board->set_hdb(par, data); 61 par->board->set_ctl(par, AUOK190X_I80_WR, 1); 62} 63 64static void auok190x_issue_cmd(struct auok190xfb_par *par, u16 data) 65{ 66 par->board->set_ctl(par, AUOK190X_I80_DC, 0); 67 auok190x_issue_data(par, data); 68 par->board->set_ctl(par, AUOK190X_I80_DC, 1); 69} 70 71/** 72 * Conversion of 16bit color to 4bit grayscale 73 * does roughly (0.3 * R + 0.6 G + 0.1 B) / 2 74 */ 75static inline int rgb565_to_gray4(u16 data, struct fb_var_screeninfo *var) 76{ 77 return ((((data & 0xF800) >> var->red.offset) * 77 + 78 ((data & 0x07E0) >> (var->green.offset + 1)) * 151 + 79 ((data & 0x1F) >> var->blue.offset) * 28) >> 8 >> 1); 80} 81 82static int auok190x_issue_pixels_rgb565(struct auok190xfb_par *par, int size, 83 u16 *data) 84{ 85 struct fb_var_screeninfo *var = &par->info->var; 86 struct device *dev = par->info->device; 87 int i; 88 u16 tmp; 89 90 if (size & 7) { 91 dev_err(dev, "issue_pixels: size %d must be a multiple of 8\n", 92 size); 93 return -EINVAL; 94 } 95 96 for (i = 0; i < (size >> 2); i++) { 97 par->board->set_ctl(par, AUOK190X_I80_WR, 0); 98 99 tmp = (rgb565_to_gray4(data[4*i], var) & 0x000F); 100 tmp |= (rgb565_to_gray4(data[4*i+1], var) << 4) & 0x00F0; 101 tmp |= (rgb565_to_gray4(data[4*i+2], var) << 8) & 0x0F00; 102 tmp |= (rgb565_to_gray4(data[4*i+3], var) << 12) & 0xF000; 103 104 par->board->set_hdb(par, tmp); 105 par->board->set_ctl(par, AUOK190X_I80_WR, 1); 106 } 107 108 return 0; 109} 110 111static int auok190x_issue_pixels_gray8(struct auok190xfb_par *par, int size, 112 u16 *data) 113{ 114 struct device *dev = par->info->device; 115 int i; 116 u16 tmp; 117 118 if (size & 3) { 119 dev_err(dev, "issue_pixels: size %d must be a multiple of 4\n", 120 size); 121 return -EINVAL; 122 } 123 124 for (i = 0; i < (size >> 1); i++) { 125 par->board->set_ctl(par, AUOK190X_I80_WR, 0); 126 127 /* simple reduction of 8bit staticgray to 4bit gray 128 * combines 4 * 4bit pixel values into a 16bit value 129 */ 130 tmp = (data[2*i] & 0xF0) >> 4; 131 tmp |= (data[2*i] & 0xF000) >> 8; 132 tmp |= (data[2*i+1] & 0xF0) << 4; 133 tmp |= (data[2*i+1] & 0xF000); 134 135 par->board->set_hdb(par, tmp); 136 par->board->set_ctl(par, AUOK190X_I80_WR, 1); 137 } 138 139 return 0; 140} 141 142static int auok190x_issue_pixels(struct auok190xfb_par *par, int size, 143 u16 *data) 144{ 145 struct fb_info *info = par->info; 146 struct device *dev = par->info->device; 147 148 if (info->var.bits_per_pixel == 8 && info->var.grayscale) 149 auok190x_issue_pixels_gray8(par, size, data); 150 else if (info->var.bits_per_pixel == 16) 151 auok190x_issue_pixels_rgb565(par, size, data); 152 else 153 dev_err(dev, "unsupported color mode (bits: %d, gray: %d)\n", 154 info->var.bits_per_pixel, info->var.grayscale); 155 156 return 0; 157} 158 159static u16 auok190x_read_data(struct auok190xfb_par *par) 160{ 161 u16 data; 162 163 par->board->set_ctl(par, AUOK190X_I80_OE, 0); 164 data = par->board->get_hdb(par); 165 par->board->set_ctl(par, AUOK190X_I80_OE, 1); 166 167 return data; 168} 169 170/* 171 * Command interface for the controller drivers 172 */ 173 174void auok190x_send_command_nowait(struct auok190xfb_par *par, u16 data) 175{ 176 par->board->set_ctl(par, AUOK190X_I80_CS, 0); 177 auok190x_issue_cmd(par, data); 178 par->board->set_ctl(par, AUOK190X_I80_CS, 1); 179} 180EXPORT_SYMBOL_GPL(auok190x_send_command_nowait); 181 182void auok190x_send_cmdargs_nowait(struct auok190xfb_par *par, u16 cmd, 183 int argc, u16 *argv) 184{ 185 int i; 186 187 par->board->set_ctl(par, AUOK190X_I80_CS, 0); 188 auok190x_issue_cmd(par, cmd); 189 190 for (i = 0; i < argc; i++) 191 auok190x_issue_data(par, argv[i]); 192 par->board->set_ctl(par, AUOK190X_I80_CS, 1); 193} 194EXPORT_SYMBOL_GPL(auok190x_send_cmdargs_nowait); 195 196int auok190x_send_command(struct auok190xfb_par *par, u16 data) 197{ 198 int ret; 199 200 ret = par->board->wait_for_rdy(par); 201 if (ret) 202 return ret; 203 204 auok190x_send_command_nowait(par, data); 205 return 0; 206} 207EXPORT_SYMBOL_GPL(auok190x_send_command); 208 209int auok190x_send_cmdargs(struct auok190xfb_par *par, u16 cmd, 210 int argc, u16 *argv) 211{ 212 int ret; 213 214 ret = par->board->wait_for_rdy(par); 215 if (ret) 216 return ret; 217 218 auok190x_send_cmdargs_nowait(par, cmd, argc, argv); 219 return 0; 220} 221EXPORT_SYMBOL_GPL(auok190x_send_cmdargs); 222 223int auok190x_read_cmdargs(struct auok190xfb_par *par, u16 cmd, 224 int argc, u16 *argv) 225{ 226 int i, ret; 227 228 ret = par->board->wait_for_rdy(par); 229 if (ret) 230 return ret; 231 232 par->board->set_ctl(par, AUOK190X_I80_CS, 0); 233 auok190x_issue_cmd(par, cmd); 234 235 for (i = 0; i < argc; i++) 236 argv[i] = auok190x_read_data(par); 237 par->board->set_ctl(par, AUOK190X_I80_CS, 1); 238 239 return 0; 240} 241EXPORT_SYMBOL_GPL(auok190x_read_cmdargs); 242 243void auok190x_send_cmdargs_pixels_nowait(struct auok190xfb_par *par, u16 cmd, 244 int argc, u16 *argv, int size, u16 *data) 245{ 246 int i; 247 248 par->board->set_ctl(par, AUOK190X_I80_CS, 0); 249 250 auok190x_issue_cmd(par, cmd); 251 252 for (i = 0; i < argc; i++) 253 auok190x_issue_data(par, argv[i]); 254 255 auok190x_issue_pixels(par, size, data); 256 257 par->board->set_ctl(par, AUOK190X_I80_CS, 1); 258} 259EXPORT_SYMBOL_GPL(auok190x_send_cmdargs_pixels_nowait); 260 261int auok190x_send_cmdargs_pixels(struct auok190xfb_par *par, u16 cmd, 262 int argc, u16 *argv, int size, u16 *data) 263{ 264 int ret; 265 266 ret = par->board->wait_for_rdy(par); 267 if (ret) 268 return ret; 269 270 auok190x_send_cmdargs_pixels_nowait(par, cmd, argc, argv, size, data); 271 272 return 0; 273} 274EXPORT_SYMBOL_GPL(auok190x_send_cmdargs_pixels); 275 276/* 277 * fbdefio callbacks - common on both controllers. 278 */ 279 280static void auok190xfb_dpy_first_io(struct fb_info *info) 281{ 282 /* tell runtime-pm that we wish to use the device in a short time */ 283 pm_runtime_get(info->device); 284} 285 286/* this is called back from the deferred io workqueue */ 287static void auok190xfb_dpy_deferred_io(struct fb_info *info, 288 struct list_head *pagelist) 289{ 290 struct fb_deferred_io *fbdefio = info->fbdefio; 291 struct auok190xfb_par *par = info->par; 292 u16 line_length = info->fix.line_length; 293 u16 yres = info->var.yres; 294 u16 y1 = 0, h = 0; 295 int prev_index = -1; 296 struct page *cur; 297 int h_inc; 298 int threshold; 299 300 if (!list_empty(pagelist)) 301 /* the device resume should've been requested through first_io, 302 * if the resume did not finish until now, wait for it. 303 */ 304 pm_runtime_barrier(info->device); 305 else 306 /* We reached this via the fsync or some other way. 307 * In either case the first_io function did not run, 308 * so we runtime_resume the device here synchronously. 309 */ 310 pm_runtime_get_sync(info->device); 311 312 /* Do a full screen update every n updates to prevent 313 * excessive darkening of the Sipix display. 314 * If we do this, there is no need to walk the pages. 315 */ 316 if (par->need_refresh(par)) { 317 par->update_all(par); 318 goto out; 319 } 320 321 /* height increment is fixed per page */ 322 h_inc = DIV_ROUND_UP(PAGE_SIZE , line_length); 323 324 /* calculate number of pages from pixel height */ 325 threshold = par->consecutive_threshold / h_inc; 326 if (threshold < 1) 327 threshold = 1; 328 329 /* walk the written page list and swizzle the data */ 330 list_for_each_entry(cur, &fbdefio->pagelist, lru) { 331 if (prev_index < 0) { 332 /* just starting so assign first page */ 333 y1 = (cur->index << PAGE_SHIFT) / line_length; 334 h = h_inc; 335 } else if ((cur->index - prev_index) <= threshold) { 336 /* page is within our threshold for single updates */ 337 h += h_inc * (cur->index - prev_index); 338 } else { 339 /* page not consecutive, issue previous update first */ 340 par->update_partial(par, y1, y1 + h); 341 342 /* start over with our non consecutive page */ 343 y1 = (cur->index << PAGE_SHIFT) / line_length; 344 h = h_inc; 345 } 346 prev_index = cur->index; 347 } 348 349 /* if we still have any pages to update we do so now */ 350 if (h >= yres) 351 /* its a full screen update, just do it */ 352 par->update_all(par); 353 else 354 par->update_partial(par, y1, min((u16) (y1 + h), yres)); 355 356out: 357 pm_runtime_mark_last_busy(info->device); 358 pm_runtime_put_autosuspend(info->device); 359} 360 361/* 362 * framebuffer operations 363 */ 364 365/* 366 * this is the slow path from userspace. they can seek and write to 367 * the fb. it's inefficient to do anything less than a full screen draw 368 */ 369static ssize_t auok190xfb_write(struct fb_info *info, const char __user *buf, 370 size_t count, loff_t *ppos) 371{ 372 struct auok190xfb_par *par = info->par; 373 unsigned long p = *ppos; 374 void *dst; 375 int err = 0; 376 unsigned long total_size; 377 378 if (info->state != FBINFO_STATE_RUNNING) 379 return -EPERM; 380 381 total_size = info->fix.smem_len; 382 383 if (p > total_size) 384 return -EFBIG; 385 386 if (count > total_size) { 387 err = -EFBIG; 388 count = total_size; 389 } 390 391 if (count + p > total_size) { 392 if (!err) 393 err = -ENOSPC; 394 395 count = total_size - p; 396 } 397 398 dst = (void *)(info->screen_base + p); 399 400 if (copy_from_user(dst, buf, count)) 401 err = -EFAULT; 402 403 if (!err) 404 *ppos += count; 405 406 par->update_all(par); 407 408 return (err) ? err : count; 409} 410 411static void auok190xfb_fillrect(struct fb_info *info, 412 const struct fb_fillrect *rect) 413{ 414 struct auok190xfb_par *par = info->par; 415 416 sys_fillrect(info, rect); 417 418 par->update_all(par); 419} 420 421static void auok190xfb_copyarea(struct fb_info *info, 422 const struct fb_copyarea *area) 423{ 424 struct auok190xfb_par *par = info->par; 425 426 sys_copyarea(info, area); 427 428 par->update_all(par); 429} 430 431static void auok190xfb_imageblit(struct fb_info *info, 432 const struct fb_image *image) 433{ 434 struct auok190xfb_par *par = info->par; 435 436 sys_imageblit(info, image); 437 438 par->update_all(par); 439} 440 441static int auok190xfb_check_var(struct fb_var_screeninfo *var, 442 struct fb_info *info) 443{ 444 struct device *dev = info->device; 445 struct auok190xfb_par *par = info->par; 446 struct panel_info *panel = &panel_table[par->resolution]; 447 int size; 448 449 /* 450 * Color depth 451 */ 452 453 if (var->bits_per_pixel == 8 && var->grayscale == 1) { 454 /* 455 * For 8-bit grayscale, R, G, and B offset are equal. 456 */ 457 var->red.length = 8; 458 var->red.offset = 0; 459 var->red.msb_right = 0; 460 461 var->green.length = 8; 462 var->green.offset = 0; 463 var->green.msb_right = 0; 464 465 var->blue.length = 8; 466 var->blue.offset = 0; 467 var->blue.msb_right = 0; 468 469 var->transp.length = 0; 470 var->transp.offset = 0; 471 var->transp.msb_right = 0; 472 } else if (var->bits_per_pixel == 16) { 473 var->red.length = 5; 474 var->red.offset = 11; 475 var->red.msb_right = 0; 476 477 var->green.length = 6; 478 var->green.offset = 5; 479 var->green.msb_right = 0; 480 481 var->blue.length = 5; 482 var->blue.offset = 0; 483 var->blue.msb_right = 0; 484 485 var->transp.length = 0; 486 var->transp.offset = 0; 487 var->transp.msb_right = 0; 488 } else { 489 dev_warn(dev, "unsupported color mode (bits: %d, grayscale: %d)\n", 490 info->var.bits_per_pixel, info->var.grayscale); 491 return -EINVAL; 492 } 493 494 /* 495 * Dimensions 496 */ 497 498 switch (var->rotate) { 499 case FB_ROTATE_UR: 500 case FB_ROTATE_UD: 501 var->xres = panel->w; 502 var->yres = panel->h; 503 break; 504 case FB_ROTATE_CW: 505 case FB_ROTATE_CCW: 506 var->xres = panel->h; 507 var->yres = panel->w; 508 break; 509 default: 510 dev_dbg(dev, "Invalid rotation request\n"); 511 return -EINVAL; 512 } 513 514 var->xres_virtual = var->xres; 515 var->yres_virtual = var->yres; 516 517 /* 518 * Memory limit 519 */ 520 521 size = var->xres_virtual * var->yres_virtual * var->bits_per_pixel / 8; 522 if (size > info->fix.smem_len) { 523 dev_err(dev, "Memory limit exceeded, requested %dK\n", 524 size >> 10); 525 return -ENOMEM; 526 } 527 528 return 0; 529} 530 531static int auok190xfb_set_fix(struct fb_info *info) 532{ 533 struct fb_fix_screeninfo *fix = &info->fix; 534 struct fb_var_screeninfo *var = &info->var; 535 536 fix->line_length = var->xres_virtual * var->bits_per_pixel / 8; 537 538 fix->type = FB_TYPE_PACKED_PIXELS; 539 fix->accel = FB_ACCEL_NONE; 540 fix->visual = (var->grayscale) ? FB_VISUAL_STATIC_PSEUDOCOLOR 541 : FB_VISUAL_TRUECOLOR; 542 fix->xpanstep = 0; 543 fix->ypanstep = 0; 544 fix->ywrapstep = 0; 545 546 return 0; 547} 548 549static int auok190xfb_set_par(struct fb_info *info) 550{ 551 struct auok190xfb_par *par = info->par; 552 553 par->rotation = info->var.rotate; 554 auok190xfb_set_fix(info); 555 556 /* reinit the controller to honor the rotation */ 557 par->init(par); 558 559 /* wait for init to complete */ 560 par->board->wait_for_rdy(par); 561 562 return 0; 563} 564 565static struct fb_ops auok190xfb_ops = { 566 .owner = THIS_MODULE, 567 .fb_read = fb_sys_read, 568 .fb_write = auok190xfb_write, 569 .fb_fillrect = auok190xfb_fillrect, 570 .fb_copyarea = auok190xfb_copyarea, 571 .fb_imageblit = auok190xfb_imageblit, 572 .fb_check_var = auok190xfb_check_var, 573 .fb_set_par = auok190xfb_set_par, 574}; 575 576/* 577 * Controller-functions common to both K1900 and K1901 578 */ 579 580static int auok190x_read_temperature(struct auok190xfb_par *par) 581{ 582 struct device *dev = par->info->device; 583 u16 data[4]; 584 int temp; 585 586 pm_runtime_get_sync(dev); 587 588 mutex_lock(&(par->io_lock)); 589 590 auok190x_read_cmdargs(par, AUOK190X_CMD_READ_VERSION, 4, data); 591 592 mutex_unlock(&(par->io_lock)); 593 594 pm_runtime_mark_last_busy(dev); 595 pm_runtime_put_autosuspend(dev); 596 597 /* sanitize and split of half-degrees for now */ 598 temp = ((data[0] & AUOK190X_VERSION_TEMP_MASK) >> 1); 599 600 /* handle positive and negative temperatures */ 601 if (temp >= 201) 602 return (255 - temp + 1) * (-1); 603 else 604 return temp; 605} 606 607static void auok190x_identify(struct auok190xfb_par *par) 608{ 609 struct device *dev = par->info->device; 610 u16 data[4]; 611 612 pm_runtime_get_sync(dev); 613 614 mutex_lock(&(par->io_lock)); 615 616 auok190x_read_cmdargs(par, AUOK190X_CMD_READ_VERSION, 4, data); 617 618 mutex_unlock(&(par->io_lock)); 619 620 par->epd_type = data[1] & AUOK190X_VERSION_TEMP_MASK; 621 622 par->panel_size_int = AUOK190X_VERSION_SIZE_INT(data[2]); 623 par->panel_size_float = AUOK190X_VERSION_SIZE_FLOAT(data[2]); 624 par->panel_model = AUOK190X_VERSION_MODEL(data[2]); 625 626 par->tcon_version = AUOK190X_VERSION_TCON(data[3]); 627 par->lut_version = AUOK190X_VERSION_LUT(data[3]); 628 629 dev_dbg(dev, "panel %d.%din, model 0x%x, EPD 0x%x TCON-rev 0x%x, LUT-rev 0x%x", 630 par->panel_size_int, par->panel_size_float, par->panel_model, 631 par->epd_type, par->tcon_version, par->lut_version); 632 633 pm_runtime_mark_last_busy(dev); 634 pm_runtime_put_autosuspend(dev); 635} 636 637/* 638 * Sysfs functions 639 */ 640 641static ssize_t update_mode_show(struct device *dev, 642 struct device_attribute *attr, char *buf) 643{ 644 struct fb_info *info = dev_get_drvdata(dev); 645 struct auok190xfb_par *par = info->par; 646 647 return sprintf(buf, "%d\n", par->update_mode); 648} 649 650static ssize_t update_mode_store(struct device *dev, 651 struct device_attribute *attr, 652 const char *buf, size_t count) 653{ 654 struct fb_info *info = dev_get_drvdata(dev); 655 struct auok190xfb_par *par = info->par; 656 int mode, ret; 657 658 ret = kstrtoint(buf, 10, &mode); 659 if (ret) 660 return ret; 661 662 par->update_mode = mode; 663 664 /* if we enter a better mode, do a full update */ 665 if (par->last_mode > 1 && mode < par->last_mode) 666 par->update_all(par); 667 668 return count; 669} 670 671static ssize_t flash_show(struct device *dev, struct device_attribute *attr, 672 char *buf) 673{ 674 struct fb_info *info = dev_get_drvdata(dev); 675 struct auok190xfb_par *par = info->par; 676 677 return sprintf(buf, "%d\n", par->flash); 678} 679 680static ssize_t flash_store(struct device *dev, struct device_attribute *attr, 681 const char *buf, size_t count) 682{ 683 struct fb_info *info = dev_get_drvdata(dev); 684 struct auok190xfb_par *par = info->par; 685 int flash, ret; 686 687 ret = kstrtoint(buf, 10, &flash); 688 if (ret) 689 return ret; 690 691 if (flash > 0) 692 par->flash = 1; 693 else 694 par->flash = 0; 695 696 return count; 697} 698 699static ssize_t temp_show(struct device *dev, struct device_attribute *attr, 700 char *buf) 701{ 702 struct fb_info *info = dev_get_drvdata(dev); 703 struct auok190xfb_par *par = info->par; 704 int temp; 705 706 temp = auok190x_read_temperature(par); 707 return sprintf(buf, "%d\n", temp); 708} 709 710static DEVICE_ATTR(update_mode, 0644, update_mode_show, update_mode_store); 711static DEVICE_ATTR(flash, 0644, flash_show, flash_store); 712static DEVICE_ATTR(temp, 0644, temp_show, NULL); 713 714static struct attribute *auok190x_attributes[] = { 715 &dev_attr_update_mode.attr, 716 &dev_attr_flash.attr, 717 &dev_attr_temp.attr, 718 NULL 719}; 720 721static const struct attribute_group auok190x_attr_group = { 722 .attrs = auok190x_attributes, 723}; 724 725static int auok190x_power(struct auok190xfb_par *par, bool on) 726{ 727 struct auok190x_board *board = par->board; 728 int ret; 729 730 if (on) { 731 /* We should maintain POWER up for at least 80ms before set 732 * RST_N and SLP_N to high (TCON spec 20100803_v35 p59) 733 */ 734 ret = regulator_enable(par->regulator); 735 if (ret) 736 return ret; 737 738 msleep(200); 739 gpio_set_value(board->gpio_nrst, 1); 740 gpio_set_value(board->gpio_nsleep, 1); 741 msleep(200); 742 } else { 743 regulator_disable(par->regulator); 744 gpio_set_value(board->gpio_nrst, 0); 745 gpio_set_value(board->gpio_nsleep, 0); 746 } 747 748 return 0; 749} 750 751/* 752 * Recovery - powercycle the controller 753 */ 754 755static void auok190x_recover(struct auok190xfb_par *par) 756{ 757 struct device *dev = par->info->device; 758 759 auok190x_power(par, 0); 760 msleep(100); 761 auok190x_power(par, 1); 762 763 /* after powercycling the device, it's always active */ 764 pm_runtime_set_active(dev); 765 par->standby = 0; 766 767 par->init(par); 768 769 /* wait for init to complete */ 770 par->board->wait_for_rdy(par); 771} 772 773/* 774 * Power-management 775 */ 776 777#ifdef CONFIG_PM 778static int auok190x_runtime_suspend(struct device *dev) 779{ 780 struct platform_device *pdev = to_platform_device(dev); 781 struct fb_info *info = platform_get_drvdata(pdev); 782 struct auok190xfb_par *par = info->par; 783 struct auok190x_board *board = par->board; 784 u16 standby_param; 785 786 /* take and keep the lock until we are resumed, as the controller 787 * will never reach the non-busy state when in standby mode 788 */ 789 mutex_lock(&(par->io_lock)); 790 791 if (par->standby) { 792 dev_warn(dev, "already in standby, runtime-pm pairing mismatch\n"); 793 mutex_unlock(&(par->io_lock)); 794 return 0; 795 } 796 797 /* according to runtime_pm.txt runtime_suspend only means, that the 798 * device will not process data and will not communicate with the CPU 799 * As we hold the lock, this stays true even without standby 800 */ 801 if (board->quirks & AUOK190X_QUIRK_STANDBYBROKEN) { 802 dev_dbg(dev, "runtime suspend without standby\n"); 803 goto finish; 804 } else if (board->quirks & AUOK190X_QUIRK_STANDBYPARAM) { 805 /* for some TCON versions STANDBY expects a parameter (0) but 806 * it seems the real tcon version has to be determined yet. 807 */ 808 dev_dbg(dev, "runtime suspend with additional empty param\n"); 809 standby_param = 0; 810 auok190x_send_cmdargs(par, AUOK190X_CMD_STANDBY, 1, 811 &standby_param); 812 } else { 813 dev_dbg(dev, "runtime suspend without param\n"); 814 auok190x_send_command(par, AUOK190X_CMD_STANDBY); 815 } 816 817 msleep(64); 818 819finish: 820 par->standby = 1; 821 822 return 0; 823} 824 825static int auok190x_runtime_resume(struct device *dev) 826{ 827 struct platform_device *pdev = to_platform_device(dev); 828 struct fb_info *info = platform_get_drvdata(pdev); 829 struct auok190xfb_par *par = info->par; 830 struct auok190x_board *board = par->board; 831 832 if (!par->standby) { 833 dev_warn(dev, "not in standby, runtime-pm pairing mismatch\n"); 834 return 0; 835 } 836 837 if (board->quirks & AUOK190X_QUIRK_STANDBYBROKEN) { 838 dev_dbg(dev, "runtime resume without standby\n"); 839 } else { 840 /* when in standby, controller is always busy 841 * and only accepts the wakeup command 842 */ 843 dev_dbg(dev, "runtime resume from standby\n"); 844 auok190x_send_command_nowait(par, AUOK190X_CMD_WAKEUP); 845 846 msleep(160); 847 848 /* wait for the controller to be ready and release the lock */ 849 board->wait_for_rdy(par); 850 } 851 852 par->standby = 0; 853 854 mutex_unlock(&(par->io_lock)); 855 856 return 0; 857} 858 859static int auok190x_suspend(struct device *dev) 860{ 861 struct platform_device *pdev = to_platform_device(dev); 862 struct fb_info *info = platform_get_drvdata(pdev); 863 struct auok190xfb_par *par = info->par; 864 struct auok190x_board *board = par->board; 865 int ret; 866 867 dev_dbg(dev, "suspend\n"); 868 if (board->quirks & AUOK190X_QUIRK_STANDBYBROKEN) { 869 /* suspend via powering off the ic */ 870 dev_dbg(dev, "suspend with broken standby\n"); 871 872 auok190x_power(par, 0); 873 } else { 874 dev_dbg(dev, "suspend using sleep\n"); 875 876 /* the sleep state can only be entered from the standby state. 877 * pm_runtime_get_noresume gets called before the suspend call. 878 * So the devices usage count is >0 but it is not necessarily 879 * active. 880 */ 881 if (!pm_runtime_status_suspended(dev)) { 882 ret = auok190x_runtime_suspend(dev); 883 if (ret < 0) { 884 dev_err(dev, "auok190x_runtime_suspend failed with %d\n", 885 ret); 886 return ret; 887 } 888 par->manual_standby = 1; 889 } 890 891 gpio_direction_output(board->gpio_nsleep, 0); 892 } 893 894 msleep(100); 895 896 return 0; 897} 898 899static int auok190x_resume(struct device *dev) 900{ 901 struct platform_device *pdev = to_platform_device(dev); 902 struct fb_info *info = platform_get_drvdata(pdev); 903 struct auok190xfb_par *par = info->par; 904 struct auok190x_board *board = par->board; 905 906 dev_dbg(dev, "resume\n"); 907 if (board->quirks & AUOK190X_QUIRK_STANDBYBROKEN) { 908 dev_dbg(dev, "resume with broken standby\n"); 909 910 auok190x_power(par, 1); 911 912 par->init(par); 913 } else { 914 dev_dbg(dev, "resume from sleep\n"); 915 916 /* device should be in runtime suspend when we were suspended 917 * and pm_runtime_put_sync gets called after this function. 918 * So there is no need to touch the standby mode here at all. 919 */ 920 gpio_direction_output(board->gpio_nsleep, 1); 921 msleep(100); 922 923 /* an additional init call seems to be necessary after sleep */ 924 auok190x_runtime_resume(dev); 925 par->init(par); 926 927 /* if we were runtime-suspended before, suspend again*/ 928 if (!par->manual_standby) 929 auok190x_runtime_suspend(dev); 930 else 931 par->manual_standby = 0; 932 } 933 934 return 0; 935} 936#endif 937 938const struct dev_pm_ops auok190x_pm = { 939 SET_RUNTIME_PM_OPS(auok190x_runtime_suspend, auok190x_runtime_resume, 940 NULL) 941 SET_SYSTEM_SLEEP_PM_OPS(auok190x_suspend, auok190x_resume) 942}; 943EXPORT_SYMBOL_GPL(auok190x_pm); 944 945/* 946 * Common probe and remove code 947 */ 948 949int auok190x_common_probe(struct platform_device *pdev, 950 struct auok190x_init_data *init) 951{ 952 struct auok190x_board *board = init->board; 953 struct auok190xfb_par *par; 954 struct fb_info *info; 955 struct panel_info *panel; 956 int videomemorysize, ret; 957 unsigned char *videomemory; 958 959 /* check board contents */ 960 if (!board->init || !board->cleanup || !board->wait_for_rdy 961 || !board->set_ctl || !board->set_hdb || !board->get_hdb 962 || !board->setup_irq) 963 return -EINVAL; 964 965 info = framebuffer_alloc(sizeof(struct auok190xfb_par), &pdev->dev); 966 if (!info) 967 return -ENOMEM; 968 969 par = info->par; 970 par->info = info; 971 par->board = board; 972 par->recover = auok190x_recover; 973 par->update_partial = init->update_partial; 974 par->update_all = init->update_all; 975 par->need_refresh = init->need_refresh; 976 par->init = init->init; 977 978 /* init update modes */ 979 par->update_cnt = 0; 980 par->update_mode = -1; 981 par->last_mode = -1; 982 par->flash = 0; 983 984 par->regulator = regulator_get(info->device, "vdd"); 985 if (IS_ERR(par->regulator)) { 986 ret = PTR_ERR(par->regulator); 987 dev_err(info->device, "Failed to get regulator: %d\n", ret); 988 goto err_reg; 989 } 990 991 ret = board->init(par); 992 if (ret) { 993 dev_err(info->device, "board init failed, %d\n", ret); 994 goto err_board; 995 } 996 997 ret = gpio_request(board->gpio_nsleep, "AUOK190x sleep"); 998 if (ret) { 999 dev_err(info->device, "could not request sleep gpio, %d\n", 1000 ret); 1001 goto err_gpio1; 1002 } 1003 1004 ret = gpio_direction_output(board->gpio_nsleep, 0); 1005 if (ret) { 1006 dev_err(info->device, "could not set sleep gpio, %d\n", ret); 1007 goto err_gpio2; 1008 } 1009 1010 ret = gpio_request(board->gpio_nrst, "AUOK190x reset"); 1011 if (ret) { 1012 dev_err(info->device, "could not request reset gpio, %d\n", 1013 ret); 1014 goto err_gpio2; 1015 } 1016 1017 ret = gpio_direction_output(board->gpio_nrst, 0); 1018 if (ret) { 1019 dev_err(info->device, "could not set reset gpio, %d\n", ret); 1020 goto err_gpio3; 1021 } 1022 1023 ret = auok190x_power(par, 1); 1024 if (ret) { 1025 dev_err(info->device, "could not power on the device, %d\n", 1026 ret); 1027 goto err_gpio3; 1028 } 1029 1030 mutex_init(&par->io_lock); 1031 1032 init_waitqueue_head(&par->waitq); 1033 1034 ret = par->board->setup_irq(par->info); 1035 if (ret) { 1036 dev_err(info->device, "could not setup ready-irq, %d\n", ret); 1037 goto err_irq; 1038 } 1039 1040 /* wait for init to complete */ 1041 par->board->wait_for_rdy(par); 1042 1043 /* 1044 * From here on the controller can talk to us 1045 */ 1046 1047 /* initialise fix, var, resolution and rotation */ 1048 1049 strlcpy(info->fix.id, init->id, 16); 1050 info->var.bits_per_pixel = 8; 1051 info->var.grayscale = 1; 1052 1053 panel = &panel_table[board->resolution]; 1054 1055 par->resolution = board->resolution; 1056 par->rotation = 0; 1057 1058 /* videomemory handling */ 1059 1060 videomemorysize = roundup((panel->w * panel->h) * 2, PAGE_SIZE); 1061 videomemory = vmalloc(videomemorysize); 1062 if (!videomemory) { 1063 ret = -ENOMEM; 1064 goto err_irq; 1065 } 1066 1067 memset(videomemory, 0, videomemorysize); 1068 info->screen_base = (char *)videomemory; 1069 info->fix.smem_len = videomemorysize; 1070 1071 info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB; 1072 info->fbops = &auok190xfb_ops; 1073 1074 ret = auok190xfb_check_var(&info->var, info); 1075 if (ret) 1076 goto err_defio; 1077 1078 auok190xfb_set_fix(info); 1079 1080 /* deferred io init */ 1081 1082 info->fbdefio = devm_kzalloc(info->device, 1083 sizeof(struct fb_deferred_io), 1084 GFP_KERNEL); 1085 if (!info->fbdefio) { 1086 dev_err(info->device, "Failed to allocate memory\n"); 1087 ret = -ENOMEM; 1088 goto err_defio; 1089 } 1090 1091 dev_dbg(info->device, "targeting %d frames per second\n", board->fps); 1092 info->fbdefio->delay = HZ / board->fps; 1093 info->fbdefio->first_io = auok190xfb_dpy_first_io, 1094 info->fbdefio->deferred_io = auok190xfb_dpy_deferred_io, 1095 fb_deferred_io_init(info); 1096 1097 /* color map */ 1098 1099 ret = fb_alloc_cmap(&info->cmap, 256, 0); 1100 if (ret < 0) { 1101 dev_err(info->device, "Failed to allocate colormap\n"); 1102 goto err_cmap; 1103 } 1104 1105 /* controller init */ 1106 1107 par->consecutive_threshold = 100; 1108 par->init(par); 1109 auok190x_identify(par); 1110 1111 platform_set_drvdata(pdev, info); 1112 1113 ret = register_framebuffer(info); 1114 if (ret < 0) 1115 goto err_regfb; 1116 1117 ret = sysfs_create_group(&info->device->kobj, &auok190x_attr_group); 1118 if (ret) 1119 goto err_sysfs; 1120 1121 dev_info(info->device, "fb%d: %dx%d using %dK of video memory\n", 1122 info->node, info->var.xres, info->var.yres, 1123 videomemorysize >> 10); 1124 1125 /* increase autosuspend_delay when we use alternative methods 1126 * for runtime_pm 1127 */ 1128 par->autosuspend_delay = (board->quirks & AUOK190X_QUIRK_STANDBYBROKEN) 1129 ? 1000 : 200; 1130 1131 pm_runtime_set_active(info->device); 1132 pm_runtime_enable(info->device); 1133 pm_runtime_set_autosuspend_delay(info->device, par->autosuspend_delay); 1134 pm_runtime_use_autosuspend(info->device); 1135 1136 return 0; 1137 1138err_sysfs: 1139 unregister_framebuffer(info); 1140err_regfb: 1141 fb_dealloc_cmap(&info->cmap); 1142err_cmap: 1143 fb_deferred_io_cleanup(info); 1144err_defio: 1145 vfree((void *)info->screen_base); 1146err_irq: 1147 auok190x_power(par, 0); 1148err_gpio3: 1149 gpio_free(board->gpio_nrst); 1150err_gpio2: 1151 gpio_free(board->gpio_nsleep); 1152err_gpio1: 1153 board->cleanup(par); 1154err_board: 1155 regulator_put(par->regulator); 1156err_reg: 1157 framebuffer_release(info); 1158 1159 return ret; 1160} 1161EXPORT_SYMBOL_GPL(auok190x_common_probe); 1162 1163int auok190x_common_remove(struct platform_device *pdev) 1164{ 1165 struct fb_info *info = platform_get_drvdata(pdev); 1166 struct auok190xfb_par *par = info->par; 1167 struct auok190x_board *board = par->board; 1168 1169 pm_runtime_disable(info->device); 1170 1171 sysfs_remove_group(&info->device->kobj, &auok190x_attr_group); 1172 1173 unregister_framebuffer(info); 1174 1175 fb_dealloc_cmap(&info->cmap); 1176 1177 fb_deferred_io_cleanup(info); 1178 1179 vfree((void *)info->screen_base); 1180 1181 auok190x_power(par, 0); 1182 1183 gpio_free(board->gpio_nrst); 1184 gpio_free(board->gpio_nsleep); 1185 1186 board->cleanup(par); 1187 1188 regulator_put(par->regulator); 1189 1190 framebuffer_release(info); 1191 1192 return 0; 1193} 1194EXPORT_SYMBOL_GPL(auok190x_common_remove); 1195 1196MODULE_DESCRIPTION("Common code for AUO-K190X controllers"); 1197MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); 1198MODULE_LICENSE("GPL"); 1199