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