tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Generic FB driver for TFT LCD displays
3 *
4 * Copyright (C) 2013 Noralf Tronnes
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 as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21#include <linux/module.h>
22#include <linux/kernel.h>
23#include <linux/init.h>
24#include <linux/vmalloc.h>
25#include <linux/gpio.h>
26#include <linux/spi/spi.h>
27#include <linux/delay.h>
28
29#include "fbtft.h"
30
31#define DRVNAME "flexfb"
32
33
34static char *chip;
35module_param(chip, charp, 0);
36MODULE_PARM_DESC(chip, "LCD controller");
37
38static unsigned int width;
39module_param(width, uint, 0);
40MODULE_PARM_DESC(width, "Display width");
41
42static unsigned int height;
43module_param(height, uint, 0);
44MODULE_PARM_DESC(height, "Display height");
45
46static int init[512];
47static int init_num;
48module_param_array(init, int, &init_num, 0);
49MODULE_PARM_DESC(init, "Init sequence");
50
51static unsigned int setaddrwin;
52module_param(setaddrwin, uint, 0);
53MODULE_PARM_DESC(setaddrwin, "Which set_addr_win() implementation to use");
54
55static unsigned int buswidth = 8;
56module_param(buswidth, uint, 0);
57MODULE_PARM_DESC(buswidth, "Width of databus (default: 8)");
58
59static unsigned int regwidth = 8;
60module_param(regwidth, uint, 0);
61MODULE_PARM_DESC(regwidth, "Width of controller register (default: 8)");
62
63static bool nobacklight;
64module_param(nobacklight, bool, 0);
65MODULE_PARM_DESC(nobacklight, "Turn off backlight functionality.");
66
67static bool latched;
68module_param(latched, bool, 0);
69MODULE_PARM_DESC(latched, "Use with latched 16-bit databus");
70
71
72static int *initp;
73static int initp_num;
74
75/* default init sequences */
76static int st7735r_init[] = {
77-1, 0x01, -2, 150, -1, 0x11, -2, 500, -1, 0xB1, 0x01, 0x2C, 0x2D, -1, 0xB2, 0x01, 0x2C, 0x2D, -1, 0xB3, 0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D,
78-1, 0xB4, 0x07, -1, 0xC0, 0xA2, 0x02, 0x84, -1, 0xC1, 0xC5, -1, 0xC2, 0x0A, 0x00, -1, 0xC3, 0x8A, 0x2A, -1, 0xC4, 0x8A, 0xEE, -1, 0xC5, 0x0E,
79-1, 0x20, -1, 0x36, 0xC0, -1, 0x3A, 0x05, -1, 0xE0, 0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22, 0x1f, 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10,
80-1, 0xE1, 0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e, 0x30, 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10, -1, 0x29, -2, 100, -1, 0x13, -2, 10, -3 };
81
82static int ssd1289_init[] = {
83-1, 0x00, 0x0001, -1, 0x03, 0xA8A4, -1, 0x0C, 0x0000, -1, 0x0D, 0x080C, -1, 0x0E, 0x2B00, -1, 0x1E, 0x00B7, -1, 0x01, 0x2B3F, -1, 0x02, 0x0600,
84-1, 0x10, 0x0000, -1, 0x11, 0x6070, -1, 0x05, 0x0000, -1, 0x06, 0x0000, -1, 0x16, 0xEF1C, -1, 0x17, 0x0003, -1, 0x07, 0x0233, -1, 0x0B, 0x0000,
85-1, 0x0F, 0x0000, -1, 0x41, 0x0000, -1, 0x42, 0x0000, -1, 0x48, 0x0000, -1, 0x49, 0x013F, -1, 0x4A, 0x0000, -1, 0x4B, 0x0000, -1, 0x44, 0xEF00,
86-1, 0x45, 0x0000, -1, 0x46, 0x013F, -1, 0x30, 0x0707, -1, 0x31, 0x0204, -1, 0x32, 0x0204, -1, 0x33, 0x0502, -1, 0x34, 0x0507, -1, 0x35, 0x0204,
87-1, 0x36, 0x0204, -1, 0x37, 0x0502, -1, 0x3A, 0x0302, -1, 0x3B, 0x0302, -1, 0x23, 0x0000, -1, 0x24, 0x0000, -1, 0x25, 0x8000, -1, 0x4f, 0x0000,
88-1, 0x4e, 0x0000, -1, 0x22, -3 };
89
90static int hx8340bn_init[] = {
91-1, 0xC1, 0xFF, 0x83, 0x40, -1, 0x11, -2, 150, -1, 0xCA, 0x70, 0x00, 0xD9, -1, 0xB0, 0x01, 0x11,
92-1, 0xC9, 0x90, 0x49, 0x10, 0x28, 0x28, 0x10, 0x00, 0x06, -2, 20, -1, 0xC2, 0x60, 0x71, 0x01, 0x0E, 0x05, 0x02, 0x09, 0x31, 0x0A,
93-1, 0xC3, 0x67, 0x30, 0x61, 0x17, 0x48, 0x07, 0x05, 0x33, -2, 10, -1, 0xB5, 0x35, 0x20, 0x45, -1, 0xB4, 0x33, 0x25, 0x4C, -2, 10,
94-1, 0x3A, 0x05, -1, 0x29, -2, 10, -3 };
95
96static int ili9225_init[] = {
97-1, 0x0001, 0x011C, -1, 0x0002, 0x0100, -1, 0x0003, 0x1030, -1, 0x0008, 0x0808, -1, 0x000C, 0x0000, -1, 0x000F, 0x0A01, -1, 0x0020, 0x0000,
98-1, 0x0021, 0x0000, -2, 50, -1, 0x0010, 0x0A00, -1, 0x0011, 0x1038, -2, 50, -1, 0x0012, 0x1121, -1, 0x0013, 0x004E, -1, 0x0014, 0x676F,
99-1, 0x0030, 0x0000, -1, 0x0031, 0x00DB, -1, 0x0032, 0x0000, -1, 0x0033, 0x0000, -1, 0x0034, 0x00DB, -1, 0x0035, 0x0000, -1, 0x0036, 0x00AF,
100-1, 0x0037, 0x0000, -1, 0x0038, 0x00DB, -1, 0x0039, 0x0000, -1, 0x0050, 0x0000, -1, 0x0051, 0x060A, -1, 0x0052, 0x0D0A, -1, 0x0053, 0x0303,
101-1, 0x0054, 0x0A0D, -1, 0x0055, 0x0A06, -1, 0x0056, 0x0000, -1, 0x0057, 0x0303, -1, 0x0058, 0x0000, -1, 0x0059, 0x0000, -2, 50,
102-1, 0x0007, 0x1017, -2, 50, -3 };
103
104static int ili9320_init[] = {
105-1, 0x00E5, 0x8000, -1, 0x0000, 0x0001, -1, 0x0001, 0x0100, -1, 0x0002, 0x0700, -1, 0x0003, 0x1030, -1, 0x0004, 0x0000, -1, 0x0008, 0x0202,
106-1, 0x0009, 0x0000, -1, 0x000A, 0x0000, -1, 0x000C, 0x0000, -1, 0x000D, 0x0000, -1, 0x000F, 0x0000, -1, 0x0010, 0x0000, -1, 0x0011, 0x0007,
107-1, 0x0012, 0x0000, -1, 0x0013, 0x0000, -2, 200, -1, 0x0010, 0x17B0, -1, 0x0011, 0x0031, -2, 50, -1, 0x0012, 0x0138, -2, 50, -1, 0x0013, 0x1800,
108-1, 0x0029, 0x0008, -2, 50, -1, 0x0020, 0x0000, -1, 0x0021, 0x0000, -1, 0x0030, 0x0000, -1, 0x0031, 0x0505, -1, 0x0032, 0x0004,
109-1, 0x0035, 0x0006, -1, 0x0036, 0x0707, -1, 0x0037, 0x0105, -1, 0x0038, 0x0002, -1, 0x0039, 0x0707, -1, 0x003C, 0x0704, -1, 0x003D, 0x0807,
110-1, 0x0050, 0x0000, -1, 0x0051, 0x00EF, -1, 0x0052, 0x0000, -1, 0x0053, 0x013F, -1, 0x0060, 0x2700, -1, 0x0061, 0x0001, -1, 0x006A, 0x0000,
111-1, 0x0080, 0x0000, -1, 0x0081, 0x0000, -1, 0x0082, 0x0000, -1, 0x0083, 0x0000, -1, 0x0084, 0x0000, -1, 0x0085, 0x0000, -1, 0x0090, 0x0010,
112-1, 0x0092, 0x0000, -1, 0x0093, 0x0003, -1, 0x0095, 0x0110, -1, 0x0097, 0x0000, -1, 0x0098, 0x0000, -1, 0x0007, 0x0173, -3 };
113
114static int ili9325_init[] = {
115-1, 0x00E3, 0x3008, -1, 0x00E7, 0x0012, -1, 0x00EF, 0x1231, -1, 0x0001, 0x0100, -1, 0x0002, 0x0700, -1, 0x0003, 0x1030, -1, 0x0004, 0x0000,
116-1, 0x0008, 0x0207, -1, 0x0009, 0x0000, -1, 0x000A, 0x0000, -1, 0x000C, 0x0000, -1, 0x000D, 0x0000, -1, 0x000F, 0x0000, -1, 0x0010, 0x0000,
117-1, 0x0011, 0x0007, -1, 0x0012, 0x0000, -1, 0x0013, 0x0000, -2, 200, -1, 0x0010, 0x1690, -1, 0x0011, 0x0223, -2, 50, -1, 0x0012, 0x000D, -2, 50,
118-1, 0x0013, 0x1200, -1, 0x0029, 0x000A, -1, 0x002B, 0x000C, -2, 50, -1, 0x0020, 0x0000, -1, 0x0021, 0x0000, -1, 0x0030, 0x0000,
119-1, 0x0031, 0x0506, -1, 0x0032, 0x0104, -1, 0x0035, 0x0207, -1, 0x0036, 0x000F, -1, 0x0037, 0x0306, -1, 0x0038, 0x0102, -1, 0x0039, 0x0707,
120-1, 0x003C, 0x0702, -1, 0x003D, 0x1604, -1, 0x0050, 0x0000, -1, 0x0051, 0x00EF, -1, 0x0052, 0x0000, -1, 0x0053, 0x013F, -1, 0x0060, 0xA700,
121-1, 0x0061, 0x0001, -1, 0x006A, 0x0000, -1, 0x0080, 0x0000, -1, 0x0081, 0x0000, -1, 0x0082, 0x0000, -1, 0x0083, 0x0000, -1, 0x0084, 0x0000,
122-1, 0x0085, 0x0000, -1, 0x0090, 0x0010, -1, 0x0092, 0x0600, -1, 0x0007, 0x0133, -3 };
123
124static int ili9341_init[] = {
125-1, 0x28, -2, 20, -1, 0xCF, 0x00, 0x83, 0x30, -1, 0xED, 0x64, 0x03, 0x12, 0x81, -1, 0xE8, 0x85, 0x01, 0x79,
126-1, 0xCB, 0x39, 0x2c, 0x00, 0x34, 0x02, -1, 0xF7, 0x20, -1, 0xEA, 0x00, 0x00, -1, 0xC0, 0x26, -1, 0xC1, 0x11,
127-1, 0xC5, 0x35, 0x3E, -1, 0xC7, 0xBE, -1, 0xB1, 0x00, 0x1B, -1, 0xB6, 0x0a, 0x82, 0x27, 0x00, -1, 0xB7, 0x07,
128-1, 0x3A, 0x55, -1, 0x36, 0x48, -1, 0x11, -2, 120, -1, 0x29, -2, 20, -3 };
129
130static int ssd1351_init[] = { -1, 0xfd, 0x12, -1, 0xfd, 0xb1, -1, 0xae, -1, 0xb3, 0xf1, -1, 0xca, 0x7f, -1, 0xa0, 0x74,
131 -1, 0x15, 0x00, 0x7f, -1, 0x75, 0x00, 0x7f, -1, 0xa1, 0x00, -1, 0xa2, 0x00, -1, 0xb5, 0x00,
132 -1, 0xab, 0x01, -1, 0xb1, 0x32, -1, 0xb4, 0xa0, 0xb5, 0x55, -1, 0xbb, 0x17, -1, 0xbe, 0x05,
133 -1, 0xc1, 0xc8, 0x80, 0xc8, -1, 0xc7, 0x0f, -1, 0xb6, 0x01, -1, 0xa6, -1, 0xaf, -3 };
134
135
136/* ili9320, ili9325 */
137static void flexfb_set_addr_win_1(struct fbtft_par *par,
138 int xs, int ys, int xe, int ye)
139{
140 fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
141 "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n",
142 __func__, xs, ys, xe, ye);
143 switch (par->info->var.rotate) {
144 /* R20h = Horizontal GRAM Start Address */
145 /* R21h = Vertical GRAM Start Address */
146 case 0:
147 write_reg(par, 0x0020, xs);
148 write_reg(par, 0x0021, ys);
149 break;
150 case 180:
151 write_reg(par, 0x0020, width - 1 - xs);
152 write_reg(par, 0x0021, height - 1 - ys);
153 break;
154 case 270:
155 write_reg(par, 0x0020, width - 1 - ys);
156 write_reg(par, 0x0021, xs);
157 break;
158 case 90:
159 write_reg(par, 0x0020, ys);
160 write_reg(par, 0x0021, height - 1 - xs);
161 break;
162 }
163 write_reg(par, 0x0022); /* Write Data to GRAM */
164}
165
166/* ssd1289 */
167static void flexfb_set_addr_win_2(struct fbtft_par *par,
168 int xs, int ys, int xe, int ye)
169{
170 fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
171 "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n",
172 __func__, xs, ys, xe, ye);
173
174 switch (par->info->var.rotate) {
175 /* R4Eh - Set GDDRAM X address counter */
176 /* R4Fh - Set GDDRAM Y address counter */
177 case 0:
178 write_reg(par, 0x4e, xs);
179 write_reg(par, 0x4f, ys);
180 break;
181 case 180:
182 write_reg(par, 0x4e, par->info->var.xres - 1 - xs);
183 write_reg(par, 0x4f, par->info->var.yres - 1 - ys);
184 break;
185 case 270:
186 write_reg(par, 0x4e, par->info->var.yres - 1 - ys);
187 write_reg(par, 0x4f, xs);
188 break;
189 case 90:
190 write_reg(par, 0x4e, ys);
191 write_reg(par, 0x4f, par->info->var.xres - 1 - xs);
192 break;
193 }
194
195 /* R22h - RAM data write */
196 write_reg(par, 0x22, 0);
197}
198
199/* ssd1351 */
200static void set_addr_win_3(struct fbtft_par *par,
201 int xs, int ys, int xe, int ye)
202{
203 fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
204 "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n", __func__,
205 xs, ys, xe, ye);
206
207 write_reg(par, 0x15, xs, xe);
208 write_reg(par, 0x75, ys, ye);
209 write_reg(par, 0x5C);
210}
211
212static int flexfb_verify_gpios_dc(struct fbtft_par *par)
213{
214 fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
215
216 if (par->gpio.dc < 0) {
217 dev_err(par->info->device,
218 "Missing info about 'dc' gpio. Aborting.\n");
219 return -EINVAL;
220 }
221
222 return 0;
223}
224
225static int flexfb_verify_gpios_db(struct fbtft_par *par)
226{
227 int i;
228 int num_db = buswidth;
229
230 fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
231
232 if (par->gpio.dc < 0) {
233 dev_err(par->info->device, "Missing info about 'dc' gpio. Aborting.\n");
234 return -EINVAL;
235 }
236 if (par->gpio.wr < 0) {
237 dev_err(par->info->device, "Missing info about 'wr' gpio. Aborting.\n");
238 return -EINVAL;
239 }
240 if (latched && (par->gpio.latch < 0)) {
241 dev_err(par->info->device, "Missing info about 'latch' gpio. Aborting.\n");
242 return -EINVAL;
243 }
244 if (latched)
245 num_db = buswidth/2;
246 for (i = 0; i < num_db; i++) {
247 if (par->gpio.db[i] < 0) {
248 dev_err(par->info->device,
249 "Missing info about 'db%02d' gpio. Aborting.\n",
250 i);
251 return -EINVAL;
252 }
253 }
254
255 return 0;
256}
257
258static struct fbtft_display flex_display = { };
259
260static int flexfb_probe_common(struct spi_device *sdev,
261 struct platform_device *pdev)
262{
263 struct device *dev;
264 struct fb_info *info;
265 struct fbtft_par *par;
266 int ret;
267
268 initp = init;
269 initp_num = init_num;
270
271 if (sdev)
272 dev = &sdev->dev;
273 else
274 dev = &pdev->dev;
275
276 fbtft_init_dbg(dev, "%s(%s)\n", __func__,
277 sdev ? "'SPI device'" : "'Platform device'");
278
279 if (chip) {
280
281 if (!strcmp(chip, "st7735r")) {
282 if (!width)
283 width = 128;
284 if (!height)
285 height = 160;
286 if (init_num == 0) {
287 initp = st7735r_init;
288 initp_num = ARRAY_SIZE(st7735r_init);
289 }
290
291
292 } else if (!strcmp(chip, "hx8340bn")) {
293 if (!width)
294 width = 176;
295 if (!height)
296 height = 220;
297 setaddrwin = 0;
298 if (init_num == 0) {
299 initp = hx8340bn_init;
300 initp_num = ARRAY_SIZE(hx8340bn_init);
301 }
302
303
304 } else if (!strcmp(chip, "ili9225")) {
305 if (!width)
306 width = 176;
307 if (!height)
308 height = 220;
309 setaddrwin = 0;
310 regwidth = 16;
311 if (init_num == 0) {
312 initp = ili9225_init;
313 initp_num = ARRAY_SIZE(ili9225_init);
314 }
315
316
317
318 } else if (!strcmp(chip, "ili9320")) {
319 if (!width)
320 width = 240;
321 if (!height)
322 height = 320;
323 setaddrwin = 1;
324 regwidth = 16;
325 if (init_num == 0) {
326 initp = ili9320_init;
327 initp_num = ARRAY_SIZE(ili9320_init);
328 }
329
330
331 } else if (!strcmp(chip, "ili9325")) {
332 if (!width)
333 width = 240;
334 if (!height)
335 height = 320;
336 setaddrwin = 1;
337 regwidth = 16;
338 if (init_num == 0) {
339 initp = ili9325_init;
340 initp_num = ARRAY_SIZE(ili9325_init);
341 }
342
343 } else if (!strcmp(chip, "ili9341")) {
344 if (!width)
345 width = 240;
346 if (!height)
347 height = 320;
348 setaddrwin = 0;
349 regwidth = 8;
350 if (init_num == 0) {
351 initp = ili9341_init;
352 initp_num = ARRAY_SIZE(ili9341_init);
353 }
354
355
356 } else if (!strcmp(chip, "ssd1289")) {
357 if (!width)
358 width = 240;
359 if (!height)
360 height = 320;
361 setaddrwin = 2;
362 regwidth = 16;
363 if (init_num == 0) {
364 initp = ssd1289_init;
365 initp_num = ARRAY_SIZE(ssd1289_init);
366 }
367
368
369
370 } else if (!strcmp(chip, "ssd1351")) {
371 if (!width)
372 width = 128;
373 if (!height)
374 height = 128;
375 setaddrwin = 3;
376 if (init_num == 0) {
377 initp = ssd1351_init;
378 initp_num = ARRAY_SIZE(ssd1351_init);
379 }
380 } else {
381 dev_err(dev, "chip=%s is not supported\n", chip);
382 return -EINVAL;
383 }
384 }
385
386 if (width == 0 || height == 0) {
387 dev_err(dev, "argument(s) missing: width and height has to be set.\n");
388 return -EINVAL;
389 }
390 flex_display.width = width;
391 flex_display.height = height;
392 fbtft_init_dbg(dev, "Display resolution: %dx%d\n", width, height);
393 fbtft_init_dbg(dev, "chip = %s\n", chip ? chip : "not set");
394 fbtft_init_dbg(dev, "setaddrwin = %d\n", setaddrwin);
395 fbtft_init_dbg(dev, "regwidth = %d\n", regwidth);
396 fbtft_init_dbg(dev, "buswidth = %d\n", buswidth);
397
398 info = fbtft_framebuffer_alloc(&flex_display, dev);
399 if (!info)
400 return -ENOMEM;
401
402 par = info->par;
403 if (sdev)
404 par->spi = sdev;
405 else
406 par->pdev = pdev;
407 if (!par->init_sequence)
408 par->init_sequence = initp;
409 par->fbtftops.init_display = fbtft_init_display;
410
411 /* registerwrite functions */
412 switch (regwidth) {
413 case 8:
414 par->fbtftops.write_register = fbtft_write_reg8_bus8;
415 break;
416 case 16:
417 par->fbtftops.write_register = fbtft_write_reg16_bus8;
418 break;
419 default:
420 dev_err(dev,
421 "argument 'regwidth': %d is not supported.\n",
422 regwidth);
423 return -EINVAL;
424 }
425
426 /* bus functions */
427 if (sdev) {
428 par->fbtftops.write = fbtft_write_spi;
429 switch (buswidth) {
430 case 8:
431 par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
432 if (!par->startbyte)
433 par->fbtftops.verify_gpios = flexfb_verify_gpios_dc;
434 break;
435 case 9:
436 if (regwidth == 16) {
437 dev_err(dev, "argument 'regwidth': %d is not supported with buswidth=%d and SPI.\n", regwidth, buswidth);
438 return -EINVAL;
439 }
440 par->fbtftops.write_register = fbtft_write_reg8_bus9;
441 par->fbtftops.write_vmem = fbtft_write_vmem16_bus9;
442 sdev->bits_per_word = 9;
443 ret = sdev->master->setup(sdev);
444 if (ret) {
445 dev_warn(dev,
446 "9-bit SPI not available, emulating using 8-bit.\n");
447 sdev->bits_per_word = 8;
448 ret = sdev->master->setup(sdev);
449 if (ret)
450 goto out_release;
451 /* allocate buffer with room for dc bits */
452 par->extra = devm_kzalloc(par->info->device,
453 par->txbuf.len + (par->txbuf.len / 8) + 8,
454 GFP_KERNEL);
455 if (!par->extra) {
456 ret = -ENOMEM;
457 goto out_release;
458 }
459 par->fbtftops.write = fbtft_write_spi_emulate_9;
460 }
461 break;
462 default:
463 dev_err(dev, "argument 'buswidth': %d is not supported with SPI.\n", buswidth);
464 return -EINVAL;
465 }
466 } else {
467 par->fbtftops.verify_gpios = flexfb_verify_gpios_db;
468 switch (buswidth) {
469 case 8:
470 par->fbtftops.write = fbtft_write_gpio8_wr;
471 par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
472 break;
473 case 16:
474 par->fbtftops.write_register = fbtft_write_reg16_bus16;
475 if (latched)
476 par->fbtftops.write = fbtft_write_gpio16_wr_latched;
477 else
478 par->fbtftops.write = fbtft_write_gpio16_wr;
479 par->fbtftops.write_vmem = fbtft_write_vmem16_bus16;
480 break;
481 default:
482 dev_err(dev, "argument 'buswidth': %d is not supported with parallel.\n", buswidth);
483 return -EINVAL;
484 }
485 }
486
487 /* set_addr_win function */
488 switch (setaddrwin) {
489 case 0:
490 /* use default */
491 break;
492 case 1:
493 par->fbtftops.set_addr_win = flexfb_set_addr_win_1;
494 break;
495 case 2:
496 par->fbtftops.set_addr_win = flexfb_set_addr_win_2;
497 break;
498 case 3:
499 par->fbtftops.set_addr_win = set_addr_win_3;
500 break;
501 default:
502 dev_err(dev, "argument 'setaddrwin': unknown value %d.\n",
503 setaddrwin);
504 return -EINVAL;
505 }
506
507 if (!nobacklight)
508 par->fbtftops.register_backlight = fbtft_register_backlight;
509
510 ret = fbtft_register_framebuffer(info);
511 if (ret < 0)
512 goto out_release;
513
514 return 0;
515
516out_release:
517 fbtft_framebuffer_release(info);
518
519 return ret;
520}
521
522static int flexfb_remove_common(struct device *dev, struct fb_info *info)
523{
524 struct fbtft_par *par;
525
526 if (!info)
527 return -EINVAL;
528 par = info->par;
529 if (par)
530 fbtft_par_dbg(DEBUG_DRIVER_INIT_FUNCTIONS, par,
531 "%s()\n", __func__);
532 fbtft_unregister_framebuffer(info);
533 fbtft_framebuffer_release(info);
534
535 return 0;
536}
537
538static int flexfb_probe_spi(struct spi_device *spi)
539{
540 return flexfb_probe_common(spi, NULL);
541}
542
543static int flexfb_remove_spi(struct spi_device *spi)
544{
545 struct fb_info *info = spi_get_drvdata(spi);
546
547 return flexfb_remove_common(&spi->dev, info);
548}
549
550static int flexfb_probe_pdev(struct platform_device *pdev)
551{
552 return flexfb_probe_common(NULL, pdev);
553}
554
555static int flexfb_remove_pdev(struct platform_device *pdev)
556{
557 struct fb_info *info = platform_get_drvdata(pdev);
558
559 return flexfb_remove_common(&pdev->dev, info);
560}
561
562static struct spi_driver flexfb_spi_driver = {
563 .driver = {
564 .name = DRVNAME,
565 .owner = THIS_MODULE,
566 },
567 .probe = flexfb_probe_spi,
568 .remove = flexfb_remove_spi,
569};
570
571static const struct platform_device_id flexfb_platform_ids[] = {
572 { "flexpfb", 0 },
573 { },
574};
575
576static struct platform_driver flexfb_platform_driver = {
577 .driver = {
578 .name = DRVNAME,
579 },
580 .id_table = flexfb_platform_ids,
581 .probe = flexfb_probe_pdev,
582 .remove = flexfb_remove_pdev,
583};
584
585static int __init flexfb_init(void)
586{
587 int ret, ret2;
588
589 ret = spi_register_driver(&flexfb_spi_driver);
590 ret2 = platform_driver_register(&flexfb_platform_driver);
591 if (ret < 0)
592 return ret;
593 return ret2;
594}
595
596static void __exit flexfb_exit(void)
597{
598 spi_unregister_driver(&flexfb_spi_driver);
599 platform_driver_unregister(&flexfb_platform_driver);
600}
601
602/* ------------------------------------------------------------------------- */
603
604module_init(flexfb_init);
605module_exit(flexfb_exit);
606
607MODULE_DESCRIPTION("Generic FB driver for TFT LCD displays");
608MODULE_AUTHOR("Noralf Tronnes");
609MODULE_LICENSE("GPL");