2 * auok190xfb.c -- FB driver for AUO-K1901 controllers
4 * Copyright (C) 2011, 2012 Heiko Stuebner <heiko@sntech.de>
6 * based on broadsheetfb.c
8 * Copyright (C) 2008, Jaya Kumar
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
14 * Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven.
16 * This driver is written to be used with the AUO-K1901 display controller.
18 * It is intended to be architecture independent. A board specific driver
19 * must be used to perform all the physical IO interactions.
21 * The controller supports different update modes:
22 * mode0+1 16 step gray (4bit)
23 * mode2+3 4 step gray (2bit)
24 * mode4+5 2 step gray (1bit)
25 * - mode4 is described as "without LUT"
26 * mode7 automatic selection of update mode
28 * The most interesting difference to the K1900 is the ability to do screen
29 * updates in an asynchronous fashion. Where the K1900 needs to wait for the
30 * current update to complete, the K1901 can process later updates already.
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/errno.h>
36 #include <linux/string.h>
38 #include <linux/slab.h>
39 #include <linux/delay.h>
40 #include <linux/interrupt.h>
42 #include <linux/init.h>
43 #include <linux/platform_device.h>
44 #include <linux/list.h>
45 #include <linux/firmware.h>
46 #include <linux/gpio.h>
47 #include <linux/pm_runtime.h>
49 #include <video/auo_k190xfb.h>
51 #include "auo_k190x.h"
54 * AUO-K1901 specific commands
57 #define AUOK1901_CMD_LUT_INTERFACE 0x0005
58 #define AUOK1901_CMD_DMA_START 0x1001
59 #define AUOK1901_CMD_CURSOR_START 0x1007
60 #define AUOK1901_CMD_CURSOR_STOP AUOK190X_CMD_DATA_STOP
61 #define AUOK1901_CMD_DDMA_START 0x1009
63 #define AUOK1901_INIT_GATE_PULSE_LOW (0 << 14)
64 #define AUOK1901_INIT_GATE_PULSE_HIGH (1 << 14)
65 #define AUOK1901_INIT_SINGLE_GATE (0 << 13)
66 #define AUOK1901_INIT_DOUBLE_GATE (1 << 13)
69 * Mode 15-12 11-8 7-4 3-0
79 #define AUOK1901_INIT_FORMAT2 (1 << 7)
80 #define AUOK1901_INIT_FORMAT3 ((1 << 7) | (1 << 6))
81 #define AUOK1901_INIT_FORMAT4 (1 << 8)
82 #define AUOK1901_INIT_FORMAT5 ((1 << 8) | (1 << 6))
83 #define AUOK1901_INIT_FORMAT6 ((1 << 8) | (1 << 7))
84 #define AUOK1901_INIT_FORMAT7 ((1 << 8) | (1 << 7) | (1 << 6))
87 * res[3-0] to bits 5-2
89 #define AUOK1901_INIT_RESOLUTION(_res) (((_res & (1 << 4)) << 6) \
90 | ((_res & 0xf) << 2))
93 * portrait / landscape orientation in AUOK1901_CMD_DMA_START
95 #define AUOK1901_DMA_ROTATE90(_rot) ((_rot & 1) << 13)
98 * equivalent to 1 << 11, needs the ~ to have same rotation like K1900
100 #define AUOK1901_DDMA_ROTATE180(_rot) ((~_rot & 2) << 10)
102 static void auok1901_init(struct auok190xfb_par
*par
)
104 struct auok190x_board
*board
= par
->board
;
107 init_param
|= AUOK190X_INIT_INVERSE_WHITE
;
108 init_param
|= AUOK190X_INIT_FORMAT0
;
109 init_param
|= AUOK1901_INIT_RESOLUTION(par
->resolution
);
110 init_param
|= AUOK190X_INIT_SHIFT_LEFT
;
112 auok190x_send_cmdargs(par
, AUOK190X_CMD_INIT
, 1, &init_param
);
114 /* let the controller finish */
115 board
->wait_for_rdy(par
);
118 static void auok1901_update_region(struct auok190xfb_par
*par
, int mode
,
121 struct device
*dev
= par
->info
->device
;
122 unsigned char *buf
= (unsigned char *)par
->info
->screen_base
;
123 int xres
= par
->info
->var
.xres
;
126 pm_runtime_get_sync(dev
);
128 mutex_lock(&(par
->io_lock
));
130 /* y1 and y2 must be a multiple of 2 so drop the lowest bit */
134 dev_dbg(dev
, "update (x,y,w,h,mode)=(%d,%d,%d,%d,%d)\n",
135 1, y1
+1, xres
, y2
-y1
, mode
);
137 /* K1901: first transfer the region data */
138 args
[0] = AUOK1901_DMA_ROTATE90(par
->rotation
) | 1;
143 auok190x_send_cmdargs_pixels_nowait(par
, AUOK1901_CMD_DMA_START
, 4,
144 args
, ((y2
- y1
) * xres
)/2,
146 auok190x_send_command_nowait(par
, AUOK190X_CMD_DATA_STOP
);
148 /* K1901: second tell the controller to update the region with mode */
149 args
[0] = mode
| AUOK1901_DDMA_ROTATE180(par
->rotation
);
154 auok190x_send_cmdargs_nowait(par
, AUOK1901_CMD_DDMA_START
, 5, args
);
158 mutex_unlock(&(par
->io_lock
));
160 pm_runtime_mark_last_busy(dev
);
161 pm_runtime_put_autosuspend(dev
);
164 static void auok1901fb_dpy_update_pages(struct auok190xfb_par
*par
,
169 if (par
->update_mode
< 0) {
170 mode
= AUOK190X_UPDATE_MODE(1);
173 mode
= AUOK190X_UPDATE_MODE(par
->update_mode
);
174 par
->last_mode
= par
->update_mode
;
178 mode
|= AUOK190X_UPDATE_NONFLASH
;
180 auok1901_update_region(par
, mode
, y1
, y2
);
183 static void auok1901fb_dpy_update(struct auok190xfb_par
*par
)
187 /* When doing full updates, wait for the controller to be ready
188 * This will hopefully catch some hangs of the K1901
190 par
->board
->wait_for_rdy(par
);
192 if (par
->update_mode
< 0) {
193 mode
= AUOK190X_UPDATE_MODE(0);
196 mode
= AUOK190X_UPDATE_MODE(par
->update_mode
);
197 par
->last_mode
= par
->update_mode
;
201 mode
|= AUOK190X_UPDATE_NONFLASH
;
203 auok1901_update_region(par
, mode
, 0, par
->info
->var
.yres
);
207 static bool auok1901fb_need_refresh(struct auok190xfb_par
*par
)
209 return (par
->update_cnt
> 10);
212 static int __devinit
auok1901fb_probe(struct platform_device
*pdev
)
214 struct auok190x_init_data init
;
215 struct auok190x_board
*board
;
217 /* pick up board specific routines */
218 board
= pdev
->dev
.platform_data
;
222 /* fill temporary init struct for common init */
223 init
.id
= "auo_k1901fb";
225 init
.update_partial
= auok1901fb_dpy_update_pages
;
226 init
.update_all
= auok1901fb_dpy_update
;
227 init
.need_refresh
= auok1901fb_need_refresh
;
228 init
.init
= auok1901_init
;
230 return auok190x_common_probe(pdev
, &init
);
233 static int __devexit
auok1901fb_remove(struct platform_device
*pdev
)
235 return auok190x_common_remove(pdev
);
238 static struct platform_driver auok1901fb_driver
= {
239 .probe
= auok1901fb_probe
,
240 .remove
= __devexit_p(auok1901fb_remove
),
242 .owner
= THIS_MODULE
,
243 .name
= "auo_k1901fb",
247 module_platform_driver(auok1901fb_driver
);
249 MODULE_DESCRIPTION("framebuffer driver for the AUO-K1901 EPD controller");
250 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
251 MODULE_LICENSE("GPL");