drivers/staging/fbtft/flexfb.c

   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
  29 static char *chip;
  30 module_param(chip, charp, 0);
  31 MODULE_PARM_DESC(chip, "LCD controller");
  32
  33 static unsigned int width;
  34 module_param(width, uint, 0);
  35 MODULE_PARM_DESC(width, "Display width");
  36
  37 static unsigned int height;
  38 module_param(height, uint, 0);
  39 MODULE_PARM_DESC(height, "Display height");
  40
  41 static int init[512];
  42 static int init_num;
  43 module_param_array(init, int, &init_num, 0);
  44 MODULE_PARM_DESC(init, "Init sequence");
  45
  46 static unsigned int setaddrwin;
  47 module_param(setaddrwin, uint, 0);
  48 MODULE_PARM_DESC(setaddrwin, "Which set_addr_win() implementation to use");
  49
  50 static unsigned int buswidth = 8;
  51 module_param(buswidth, uint, 0);
  52 MODULE_PARM_DESC(buswidth, "Width of databus (default: 8)");
  53
  54 static unsigned int regwidth = 8;
  55 module_param(regwidth, uint, 0);
  56 MODULE_PARM_DESC(regwidth, "Width of controller register (default: 8)");
  57
  58 static bool nobacklight;
  59 module_param(nobacklight, bool, 0);
  60 MODULE_PARM_DESC(nobacklight, "Turn off backlight functionality.");
  61
  62 static bool latched;
  63 module_param(latched, bool, 0);
  64 MODULE_PARM_DESC(latched, "Use with latched 16-bit databus");
  65
  66 static int *initp;
  67 static int initp_num;
  68
  69 /* default init sequences */
  70 static 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
  76 static 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
  84 static 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
  90 static 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
  98 static 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
 108 static 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
 118 static 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
 124 static 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  */
 139 struct 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
 149 static 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 */
 233 static 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 */
 260 static 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 */
 289 static 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
 297 static 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
 310 static 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
 343 static 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
 358 static struct fbtft_display flex_display = { };
 359
 360 static 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
 375 static 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
 527 out_release:
 528         fbtft_framebuffer_release(info);
 529
 530         return ret;
 531 }
 532
 533 static 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
 549 static int flexfb_probe_spi(struct spi_device *spi)
 550 {
 551         return flexfb_probe_common(spi, NULL);
 552 }
 553
 554 static 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
 561 static int flexfb_probe_pdev(struct platform_device *pdev)
 562 {
 563         return flexfb_probe_common(NULL, pdev);
 564 }
 565
 566 static 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
 573 static struct spi_driver flexfb_spi_driver = {
 574         .driver = {
 575                 .name   = DRVNAME,
 576         },
 577         .probe  = flexfb_probe_spi,
 578         .remove = flexfb_remove_spi,
 579 };
 580
 581 static const struct platform_device_id flexfb_platform_ids[] = {
 582         { "flexpfb", 0 },
 583         { },
 584 };
 585
 586 static 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
 595 static 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
 606 static void __exit flexfb_exit(void)
 607 {
 608         spi_unregister_driver(&flexfb_spi_driver);
 609         platform_driver_unregister(&flexfb_platform_driver);
 610 }
 611
 612 /* ------------------------------------------------------------------------- */
 613
 614 module_init(flexfb_init);
 615 module_exit(flexfb_exit);
 616
 617 MODULE_DESCRIPTION("Generic FB driver for TFT LCD displays");
 618 MODULE_AUTHOR("Noralf Tronnes");
 619 MODULE_LICENSE("GPL");