blob: 8d2499d1cafb30dff0ec2ccaed703696fc05f92f [file] [log] [blame]
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001/*
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>
Greg Kroah-Hartman16559ae2013-02-04 15:35:26 -080014#include <linux/platform_device.h>
Heiko Stübner2c8304d2012-04-28 12:20:00 +020015#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 },
Heiko Stübnerb61f2322013-03-22 15:17:32 +010043 [AUOK190X_RESOLUTION_600_800] = {
44 .w = 600,
45 .h = 800,
46 },
47 [AUOK190X_RESOLUTION_768_1024] = {
48 .w = 768,
49 .h = 1024,
50 },
Heiko Stübner2c8304d2012-04-28 12:20:00 +020051};
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
Heiko Stübner46574c72013-03-22 15:16:29 +010071/**
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
Heiko Stübner76de404b2013-03-22 15:15:55 +0100111static int auok190x_issue_pixels_gray8(struct auok190xfb_par *par, int size,
112 u16 *data)
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200113{
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
Heiko Stübner76de404b2013-03-22 15:15:55 +0100142static 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);
Heiko Stübner46574c72013-03-22 15:16:29 +0100150 else if (info->var.bits_per_pixel == 16)
151 auok190x_issue_pixels_rgb565(par, size, data);
Heiko Stübner76de404b2013-03-22 15:15:55 +0100152 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
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200159static 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;
Heiko Stübnera1655102013-03-22 15:13:02 +0100292 u16 line_length = info->fix.line_length;
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200293 u16 yres = info->var.yres;
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200294 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 */
Heiko Stübnera1655102013-03-22 15:13:02 +0100322 h_inc = DIV_ROUND_UP(PAGE_SIZE , line_length);
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200323
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 */
Heiko Stübnera1655102013-03-22 15:13:02 +0100333 y1 = (cur->index << PAGE_SHIFT) / line_length;
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200334 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 */
Heiko Stübnera1655102013-03-22 15:13:02 +0100343 y1 = (cur->index << PAGE_SHIFT) / line_length;
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200344 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{
Heiko Stübner03fc1492013-03-22 15:14:52 +0100444 struct device *dev = info->device;
Heiko Stübner4ea80d32013-03-22 15:15:27 +0100445 struct auok190xfb_par *par = info->par;
446 struct panel_info *panel = &panel_table[par->resolution];
Heiko Stübner03fc1492013-03-22 15:14:52 +0100447 int size;
448
Heiko Stübner4ea80d32013-03-22 15:15:27 +0100449 /*
Heiko Stübner76de404b2013-03-22 15:15:55 +0100450 * 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;
Heiko Stübner46574c72013-03-22 15:16:29 +0100472 } 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;
Heiko Stübner76de404b2013-03-22 15:15:55 +0100488 } 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 /*
Heiko Stübner4ea80d32013-03-22 15:15:27 +0100495 * Dimensions
496 */
497
Heiko Stübnerfd3871a2013-03-22 15:17:00 +0100498 switch (var->rotate) {
499 case FB_ROTATE_UR:
500 case FB_ROTATE_UD:
Heiko Stübner4ea80d32013-03-22 15:15:27 +0100501 var->xres = panel->w;
502 var->yres = panel->h;
Heiko Stübnerfd3871a2013-03-22 15:17:00 +0100503 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;
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200512 }
513
Heiko Stübner4ea80d32013-03-22 15:15:27 +0100514 var->xres_virtual = var->xres;
515 var->yres_virtual = var->yres;
516
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200517 /*
518 * Memory limit
519 */
520
Heiko Stübner03fc1492013-03-22 15:14:52 +0100521 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);
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200525 return -ENOMEM;
526 }
527
528 return 0;
529}
530
Heiko Stübner76de404b2013-03-22 15:15:55 +0100531static 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
Heiko Stübner46574c72013-03-22 15:16:29 +0100549static int auok190xfb_set_par(struct fb_info *info)
550{
551 struct auok190xfb_par *par = info->par;
552
Heiko Stübnerfd3871a2013-03-22 15:17:00 +0100553 par->rotation = info->var.rotate;
Heiko Stübner46574c72013-03-22 15:16:29 +0100554 auok190xfb_set_fix(info);
555
Heiko Stübnerfd3871a2013-03-22 15:17:00 +0100556 /* 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
Heiko Stübner46574c72013-03-22 15:16:29 +0100562 return 0;
563}
564
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200565static 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,
Heiko Stübner46574c72013-03-22 15:16:29 +0100573 .fb_set_par = auok190xfb_set_par,
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200574};
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{
Heiko Stübner4e0ab852013-03-22 15:14:22 +0100757 struct device *dev = par->info->device;
758
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200759 auok190x_power(par, 0);
760 msleep(100);
761 auok190x_power(par, 1);
762
Heiko Stübner4e0ab852013-03-22 15:14:22 +0100763 /* after powercycling the device, it's always active */
764 pm_runtime_set_active(dev);
765 par->standby = 0;
766
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200767 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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -0800949int auok190x_common_probe(struct platform_device *pdev,
950 struct auok190x_init_data *init)
Heiko Stübner2c8304d2012-04-28 12:20:00 +0200951{
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);
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001050 info->var.bits_per_pixel = 8;
1051 info->var.grayscale = 1;
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001052
1053 panel = &panel_table[board->resolution];
1054
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001055 par->resolution = board->resolution;
Heiko Stübnerfd3871a2013-03-22 15:17:00 +01001056 par->rotation = 0;
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001057
1058 /* videomemory handling */
1059
Heiko Stübner46574c72013-03-22 15:16:29 +01001060 videomemorysize = roundup((panel->w * panel->h) * 2, PAGE_SIZE);
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001061 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
Heiko Stübner4ea80d32013-03-22 15:15:27 +01001074 ret = auok190xfb_check_var(&info->var, info);
1075 if (ret)
1076 goto err_defio;
1077
Heiko Stübner76de404b2013-03-22 15:15:55 +01001078 auok190xfb_set_fix(info);
Heiko Stübner4ea80d32013-03-22 15:15:27 +01001079
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001080 /* 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
Masanari Iidaa895d572013-04-09 02:06:50 +09001091 dev_dbg(info->device, "targeting %d frames per second\n", board->fps);
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001092 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);
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001144err_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
Greg Kroah-Hartman48c68c42012-12-21 13:07:39 -08001163int auok190x_common_remove(struct platform_device *pdev)
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001164{
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);
Heiko Stübner2c8304d2012-04-28 12:20:00 +02001178
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");