drivers/staging/fbtft/flexfb.c

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