drivers/video/auo_k190x.c

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