drivers/staging/fbtft/fbtft_device.c

   1 /*
   2  *
   3  * Copyright (C) 2013, Noralf Tronnes
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #define pr_fmt(fmt) "fbtft_device: " fmt
  17 #include <linux/module.h>
  18 #include <linux/kernel.h>
  19 #include <linux/init.h>
  20 #include <linux/gpio.h>
  21 #include <linux/spi/spi.h>
  22 #include <video/mipi_display.h>
  23
  24 #include "fbtft.h"
  25
  26 #define MAX_GPIOS 32
  27
  28 static struct spi_device *spi_device;
  29 static struct platform_device *p_device;
  30
  31 static char *name;
  32 module_param(name, charp, 0);
  33 MODULE_PARM_DESC(name, "Devicename (required). name=list => list all supported devices.");
  34
  35 static unsigned rotate;
  36 module_param(rotate, uint, 0);
  37 MODULE_PARM_DESC(rotate,
  38 "Angle to rotate display counter clockwise: 0, 90, 180, 270");
  39
  40 static unsigned busnum;
  41 module_param(busnum, uint, 0);
  42 MODULE_PARM_DESC(busnum, "SPI bus number (default=0)");
  43
  44 static unsigned cs;
  45 module_param(cs, uint, 0);
  46 MODULE_PARM_DESC(cs, "SPI chip select (default=0)");
  47
  48 static unsigned speed;
  49 module_param(speed, uint, 0);
  50 MODULE_PARM_DESC(speed, "SPI speed (override device default)");
  51
  52 static int mode = -1;
  53 module_param(mode, int, 0);
  54 MODULE_PARM_DESC(mode, "SPI mode (override device default)");
  55
  56 static char *gpios;
  57 module_param(gpios, charp, 0);
  58 MODULE_PARM_DESC(gpios,
  59 "List of gpios. Comma separated with the form: reset:23,dc:24 (when overriding the default, all gpios must be specified)");
  60
  61 static unsigned fps;
  62 module_param(fps, uint, 0);
  63 MODULE_PARM_DESC(fps, "Frames per second (override driver default)");
  64
  65 static char *gamma;
  66 module_param(gamma, charp, 0);
  67 MODULE_PARM_DESC(gamma,
  68 "String representation of Gamma Curve(s). Driver specific.");
  69
  70 static int txbuflen;
  71 module_param(txbuflen, int, 0);
  72 MODULE_PARM_DESC(txbuflen, "txbuflen (override driver default)");
  73
  74 static int bgr = -1;
  75 module_param(bgr, int, 0);
  76 MODULE_PARM_DESC(bgr,
  77 "BGR bit (supported by some drivers).");
  78
  79 static unsigned startbyte;
  80 module_param(startbyte, uint, 0);
  81 MODULE_PARM_DESC(startbyte, "Sets the Start byte used by some SPI displays.");
  82
  83 static bool custom;
  84 module_param(custom, bool, 0);
  85 MODULE_PARM_DESC(custom, "Add a custom display device. Use speed= argument to make it a SPI device, else platform_device");
  86
  87 static unsigned width;
  88 module_param(width, uint, 0);
  89 MODULE_PARM_DESC(width, "Display width, used with the custom argument");
  90
  91 static unsigned height;
  92 module_param(height, uint, 0);
  93 MODULE_PARM_DESC(height, "Display height, used with the custom argument");
  94
  95 static unsigned buswidth = 8;
  96 module_param(buswidth, uint, 0);
  97 MODULE_PARM_DESC(buswidth, "Display bus width, used with the custom argument");
  98
  99 static int init[FBTFT_MAX_INIT_SEQUENCE];
 100 static int init_num;
 101 module_param_array(init, int, &init_num, 0);
 102 MODULE_PARM_DESC(init, "Init sequence, used with the custom argument");
 103
 104 static unsigned long debug;
 105 module_param(debug, ulong, 0);
 106 MODULE_PARM_DESC(debug,
 107 "level: 0-7 (the remaining 29 bits is for advanced usage)");
 108
 109 static unsigned verbose = 3;
 110 module_param(verbose, uint, 0);
 111 MODULE_PARM_DESC(verbose,
 112 "0 silent, >0 show gpios, >1 show devices, >2 show devices before (default=3)");
 113
 114 struct fbtft_device_display {
 115         char *name;
 116         struct spi_board_info *spi;
 117         struct platform_device *pdev;
 118 };
 119
 120 static void fbtft_device_pdev_release(struct device *dev);
 121
 122 static int write_gpio16_wr_slow(struct fbtft_par *par, void *buf, size_t len);
 123 static void adafruit18_green_tab_set_addr_win(struct fbtft_par *par,
 124         int xs, int ys, int xe, int ye);
 125
 126 #define ADAFRUIT18_GAMMA \
 127                 "02 1c 07 12 37 32 29 2d 29 25 2B 39 00 01 03 10\n" \
 128                 "03 1d 07 06 2E 2C 29 2D 2E 2E 37 3F 00 00 02 10"
 129
 130 #define CBERRY28_GAMMA \
 131                 "D0 00 14 15 13 2C 42 43 4E 09 16 14 18 21\n" \
 132                 "D0 00 14 15 13 0B 43 55 53 0C 17 14 23 20"
 133
 134 static int cberry28_init_sequence[] = {
 135         /* turn off sleep mode */
 136         -1, MIPI_DCS_EXIT_SLEEP_MODE,
 137         -2, 120,
 138
 139         /* set pixel format to RGB-565 */
 140         -1, MIPI_DCS_SET_PIXEL_FORMAT, MIPI_DCS_PIXEL_FMT_16BIT,
 141
 142         -1, 0xB2, 0x0C, 0x0C, 0x00, 0x33, 0x33,
 143
 144         /*
 145          * VGH = 13.26V
 146          * VGL = -10.43V
 147          */
 148         -1, 0xB7, 0x35,
 149
 150         /*
 151          * VDV and VRH register values come from command write
 152          * (instead of NVM)
 153          */
 154         -1, 0xC2, 0x01, 0xFF,
 155
 156         /*
 157          * VAP =  4.7V + (VCOM + VCOM offset + 0.5 * VDV)
 158          * VAN = -4.7V + (VCOM + VCOM offset + 0.5 * VDV)
 159          */
 160         -1, 0xC3, 0x17,
 161
 162         /* VDV = 0V */
 163         -1, 0xC4, 0x20,
 164
 165         /* VCOM = 0.675V */
 166         -1, 0xBB, 0x17,
 167
 168         /* VCOM offset = 0V */
 169         -1, 0xC5, 0x20,
 170
 171         /*
 172          * AVDD = 6.8V
 173          * AVCL = -4.8V
 174          * VDS = 2.3V
 175          */
 176         -1, 0xD0, 0xA4, 0xA1,
 177
 178         -1, MIPI_DCS_SET_DISPLAY_ON,
 179
 180         -3,
 181 };
 182
 183 static int hy28b_init_sequence[] = {
 184         -1, 0x00e7, 0x0010, -1, 0x0000, 0x0001,
 185         -1, 0x0001, 0x0100, -1, 0x0002, 0x0700,
 186         -1, 0x0003, 0x1030, -1, 0x0004, 0x0000,
 187         -1, 0x0008, 0x0207, -1, 0x0009, 0x0000,
 188         -1, 0x000a, 0x0000, -1, 0x000c, 0x0001,
 189         -1, 0x000d, 0x0000, -1, 0x000f, 0x0000,
 190         -1, 0x0010, 0x0000, -1, 0x0011, 0x0007,
 191         -1, 0x0012, 0x0000, -1, 0x0013, 0x0000,
 192         -2, 50, -1, 0x0010, 0x1590, -1, 0x0011,
 193         0x0227, -2, 50, -1, 0x0012, 0x009c, -2, 50,
 194         -1, 0x0013, 0x1900, -1, 0x0029, 0x0023,
 195         -1, 0x002b, 0x000e, -2, 50,
 196         -1, 0x0020, 0x0000, -1, 0x0021, 0x0000,
 197         -2, 50, -1, 0x0050, 0x0000,
 198         -1, 0x0051, 0x00ef, -1, 0x0052, 0x0000,
 199         -1, 0x0053, 0x013f, -1, 0x0060, 0xa700,
 200         -1, 0x0061, 0x0001, -1, 0x006a, 0x0000,
 201         -1, 0x0080, 0x0000, -1, 0x0081, 0x0000,
 202         -1, 0x0082, 0x0000, -1, 0x0083, 0x0000,
 203         -1, 0x0084, 0x0000, -1, 0x0085, 0x0000,
 204         -1, 0x0090, 0x0010, -1, 0x0092, 0x0000,
 205         -1, 0x0093, 0x0003, -1, 0x0095, 0x0110,
 206         -1, 0x0097, 0x0000, -1, 0x0098, 0x0000,
 207         -1, 0x0007, 0x0133, -1, 0x0020, 0x0000,
 208         -1, 0x0021, 0x0000, -2, 100, -3 };
 209
 210 #define HY28B_GAMMA \
 211         "04 1F 4 7 7 0 7 7 6 0\n" \
 212         "0F 00 1 7 4 0 0 0 6 7"
 213
 214 static int pitft_init_sequence[] = {
 215         -1, MIPI_DCS_SOFT_RESET,
 216         -2, 5,
 217         -1, MIPI_DCS_SET_DISPLAY_OFF,
 218         -1, 0xEF, 0x03, 0x80, 0x02,
 219         -1, 0xCF, 0x00, 0xC1, 0x30,
 220         -1, 0xED, 0x64, 0x03, 0x12, 0x81,
 221         -1, 0xE8, 0x85, 0x00, 0x78,
 222         -1, 0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02,
 223         -1, 0xF7, 0x20,
 224         -1, 0xEA, 0x00, 0x00,
 225         -1, 0xC0, 0x23,
 226         -1, 0xC1, 0x10,
 227         -1, 0xC5, 0x3E, 0x28,
 228         -1, 0xC7, 0x86,
 229         -1, MIPI_DCS_SET_PIXEL_FORMAT, 0x55,
 230         -1, 0xB1, 0x00, 0x18,
 231         -1, 0xB6, 0x08, 0x82, 0x27,
 232         -1, 0xF2, 0x00,
 233         -1, MIPI_DCS_SET_GAMMA_CURVE, 0x01,
 234         -1, 0xE0, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E,
 235                 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
 236         -1, 0xE1, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31,
 237                 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
 238         -1, MIPI_DCS_EXIT_SLEEP_MODE,
 239         -2, 100,
 240         -1, MIPI_DCS_SET_DISPLAY_ON,
 241         -2, 20,
 242         -3
 243 };
 244
 245 static int waveshare32b_init_sequence[] = {
 246         -1, 0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02,
 247         -1, 0xCF, 0x00, 0xC1, 0x30,
 248         -1, 0xE8, 0x85, 0x00, 0x78,
 249         -1, 0xEA, 0x00, 0x00,
 250         -1, 0xED, 0x64, 0x03, 0x12, 0x81,
 251         -1, 0xF7, 0x20,
 252         -1, 0xC0, 0x23,
 253         -1, 0xC1, 0x10,
 254         -1, 0xC5, 0x3E, 0x28,
 255         -1, 0xC7, 0x86,
 256         -1, MIPI_DCS_SET_ADDRESS_MODE, 0x28,
 257         -1, MIPI_DCS_SET_PIXEL_FORMAT, 0x55,
 258         -1, 0xB1, 0x00, 0x18,
 259         -1, 0xB6, 0x08, 0x82, 0x27,
 260         -1, 0xF2, 0x00,
 261         -1, MIPI_DCS_SET_GAMMA_CURVE, 0x01,
 262         -1, 0xE0, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E,
 263                 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00,
 264         -1, 0xE1, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31,
 265                 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F,
 266         -1, MIPI_DCS_EXIT_SLEEP_MODE,
 267         -2, 120,
 268         -1, MIPI_DCS_SET_DISPLAY_ON,
 269         -1, MIPI_DCS_WRITE_MEMORY_START,
 270         -3
 271 };
 272
 273 /* Supported displays in alphabetical order */
 274 static struct fbtft_device_display displays[] = {
 275         {
 276                 .name = "adafruit18",
 277                 .spi = &(struct spi_board_info) {
 278                         .modalias = "fb_st7735r",
 279                         .max_speed_hz = 32000000,
 280                         .mode = SPI_MODE_0,
 281                         .platform_data = &(struct fbtft_platform_data) {
 282                                 .display = {
 283                                         .buswidth = 8,
 284                                         .backlight = 1,
 285                                 },
 286                                 .gpios = (const struct fbtft_gpio []) {
 287                                         { "reset", 25 },
 288                                         { "dc", 24 },
 289                                         { "led", 18 },
 290                                         {},
 291                                 },
 292                                 .gamma = ADAFRUIT18_GAMMA,
 293                         }
 294                 }
 295         }, {
 296                 .name = "adafruit18_green",
 297                 .spi = &(struct spi_board_info) {
 298                         .modalias = "fb_st7735r",
 299                         .max_speed_hz = 4000000,
 300                         .mode = SPI_MODE_0,
 301                         .platform_data = &(struct fbtft_platform_data) {
 302                                 .display = {
 303                                         .buswidth = 8,
 304                                         .backlight = 1,
 305                                         .fbtftops.set_addr_win =
 306                                             adafruit18_green_tab_set_addr_win,
 307                                 },
 308                                 .bgr = true,
 309                                 .gpios = (const struct fbtft_gpio []) {
 310                                         { "reset", 25 },
 311                                         { "dc", 24 },
 312                                         { "led", 18 },
 313                                         {},
 314                                 },
 315                                 .gamma = ADAFRUIT18_GAMMA,
 316                         }
 317                 }
 318         }, {
 319                 .name = "adafruit22",
 320                 .spi = &(struct spi_board_info) {
 321                         .modalias = "fb_hx8340bn",
 322                         .max_speed_hz = 32000000,
 323                         .mode = SPI_MODE_0,
 324                         .platform_data = &(struct fbtft_platform_data) {
 325                                 .display = {
 326                                         .buswidth = 9,
 327                                         .backlight = 1,
 328                                 },
 329                                 .bgr = true,
 330                                 .gpios = (const struct fbtft_gpio []) {
 331                                         { "reset", 25 },
 332                                         { "led", 23 },
 333                                         {},
 334                                 },
 335                         }
 336                 }
 337         }, {
 338                 .name = "adafruit22a",
 339                 .spi = &(struct spi_board_info) {
 340                         .modalias = "fb_ili9340",
 341                         .max_speed_hz = 32000000,
 342                         .mode = SPI_MODE_0,
 343                         .platform_data = &(struct fbtft_platform_data) {
 344                                 .display = {
 345                                         .buswidth = 8,
 346                                         .backlight = 1,
 347                                 },
 348                                 .bgr = true,
 349                                 .gpios = (const struct fbtft_gpio []) {
 350                                         { "reset", 25 },
 351                                         { "dc", 24 },
 352                                         { "led", 18 },
 353                                         {},
 354                                 },
 355                         }
 356                 }
 357         }, {
 358                 .name = "adafruit28",
 359                 .spi = &(struct spi_board_info) {
 360                         .modalias = "fb_ili9341",
 361                         .max_speed_hz = 32000000,
 362                         .mode = SPI_MODE_0,
 363                         .platform_data = &(struct fbtft_platform_data) {
 364                                 .display = {
 365                                         .buswidth = 8,
 366                                         .backlight = 1,
 367                                 },
 368                                 .bgr = true,
 369                                 .gpios = (const struct fbtft_gpio []) {
 370                                         { "reset", 25 },
 371                                         { "dc", 24 },
 372                                         { "led", 18 },
 373                                         {},
 374                                 },
 375                         }
 376                 }
 377         }, {
 378                 .name = "adafruit13m",
 379                 .spi = &(struct spi_board_info) {
 380                         .modalias = "fb_ssd1306",
 381                         .max_speed_hz = 16000000,
 382                         .mode = SPI_MODE_0,
 383                         .platform_data = &(struct fbtft_platform_data) {
 384                                 .display = {
 385                                         .buswidth = 8,
 386                                 },
 387                                 .gpios = (const struct fbtft_gpio []) {
 388                                         { "reset", 25 },
 389                                         { "dc", 24 },
 390                                         {},
 391                                 },
 392                         }
 393                 }
 394         }, {
 395                 .name = "admatec_c-berry28",
 396                 .spi = &(struct spi_board_info) {
 397                         .modalias = "fb_st7789v",
 398                         .max_speed_hz = 48000000,
 399                         .mode = SPI_MODE_0,
 400                         .platform_data = &(struct fbtft_platform_data) {
 401                                 .display = {
 402                                         .buswidth = 8,
 403                                         .backlight = 1,
 404                                         .init_sequence = cberry28_init_sequence,
 405                                 },
 406                                 .gpios = (const struct fbtft_gpio []) {
 407                                         { "reset", 25 },
 408                                         { "dc", 22 },
 409                                         { "led", 18 },
 410                                         {},
 411                                 },
 412                                 .gamma = CBERRY28_GAMMA,
 413                         }
 414                 }
 415         }, {
 416                 .name = "agm1264k-fl",
 417                 .pdev = &(struct platform_device) {
 418                         .name = "fb_agm1264k-fl",
 419                         .id = 0,
 420                         .dev = {
 421                         .release = fbtft_device_pdev_release,
 422                         .platform_data = &(struct fbtft_platform_data) {
 423                                 .display = {
 424                                         .buswidth = 8,
 425                                         .backlight = FBTFT_ONBOARD_BACKLIGHT,
 426                                 },
 427                                 .gpios = (const struct fbtft_gpio []) {
 428                                         {},
 429                                 },
 430                         },
 431                         }
 432                 }
 433         }, {
 434                 .name = "dogs102",
 435                 .spi = &(struct spi_board_info) {
 436                         .modalias = "fb_uc1701",
 437                         .max_speed_hz = 8000000,
 438                         .mode = SPI_MODE_0,
 439                         .platform_data = &(struct fbtft_platform_data) {
 440                                 .display = {
 441                                         .buswidth = 8,
 442                                 },
 443                                 .bgr = true,
 444                                 .gpios = (const struct fbtft_gpio []) {
 445                                         { "reset", 13 },
 446                                         { "dc", 6 },
 447                                         {},
 448                                 },
 449                         }
 450                 }
 451         }, {
 452                 .name = "er_tftm050_2",
 453                 .spi = &(struct spi_board_info) {
 454                         .modalias = "fb_ra8875",
 455                         .max_speed_hz = 5000000,
 456                         .mode = SPI_MODE_3,
 457                         .platform_data = &(struct fbtft_platform_data) {
 458                                 .display = {
 459                                         .buswidth = 8,
 460                                         .backlight = 1,
 461                                         .width = 480,
 462                                         .height = 272,
 463                                 },
 464                                 .bgr = true,
 465                                 .gpios = (const struct fbtft_gpio []) {
 466                                         { "reset", 25 },
 467                                         { "dc", 24 },
 468                                         {},
 469                                 },
 470                         }
 471                 }
 472         }, {
 473                 .name = "er_tftm070_5",
 474                 .spi = &(struct spi_board_info) {
 475                         .modalias = "fb_ra8875",
 476                         .max_speed_hz = 5000000,
 477                         .mode = SPI_MODE_3,
 478                         .platform_data = &(struct fbtft_platform_data) {
 479                                 .display = {
 480                                         .buswidth = 8,
 481                                         .backlight = 1,
 482                                         .width = 800,
 483                                         .height = 480,
 484                                 },
 485                                 .bgr = true,
 486                                 .gpios = (const struct fbtft_gpio []) {
 487                                         { "reset", 25 },
 488                                         { "dc", 24 },
 489                                         {},
 490                                 },
 491                         }
 492                 }
 493         }, {
 494                 .name = "ew24ha0",
 495                 .spi = &(struct spi_board_info) {
 496                         .modalias = "fb_uc1611",
 497                         .max_speed_hz = 32000000,
 498                         .mode = SPI_MODE_3,
 499                         .platform_data = &(struct fbtft_platform_data) {
 500                                 .display = {
 501                                         .buswidth = 8,
 502                                 },
 503                                 .gpios = (const struct fbtft_gpio []) {
 504                                         { "dc", 24 },
 505                                         {},
 506                                 },
 507                         }
 508                 }
 509         }, {
 510                 .name = "ew24ha0_9bit",
 511                 .spi = &(struct spi_board_info) {
 512                         .modalias = "fb_uc1611",
 513                         .max_speed_hz = 32000000,
 514                         .mode = SPI_MODE_3,
 515                         .platform_data = &(struct fbtft_platform_data) {
 516                                 .display = {
 517                                         .buswidth = 9,
 518                                 },
 519                                 .gpios = (const struct fbtft_gpio []) {
 520                                         {},
 521                                 },
 522                         }
 523                 }
 524         }, {
 525                 .name = "flexfb",
 526                 .spi = &(struct spi_board_info) {
 527                         .modalias = "flexfb",
 528                         .max_speed_hz = 32000000,
 529                         .mode = SPI_MODE_0,
 530                         .platform_data = &(struct fbtft_platform_data) {
 531                                 .gpios = (const struct fbtft_gpio []) {
 532                                         { "reset", 25 },
 533                                         { "dc", 24 },
 534                                         {},
 535                                 },
 536                         }
 537                 }
 538         }, {
 539                 .name = "flexpfb",
 540                 .pdev = &(struct platform_device) {
 541                         .name = "flexpfb",
 542                         .id = 0,
 543                         .dev = {
 544                         .release = fbtft_device_pdev_release,
 545                         .platform_data = &(struct fbtft_platform_data) {
 546                                 .gpios = (const struct fbtft_gpio []) {
 547                                         { "reset", 17 },
 548                                         { "dc", 1 },
 549                                         { "wr", 0 },
 550                                         { "cs", 21 },
 551                                         { "db00", 9 },
 552                                         { "db01", 11 },
 553                                         { "db02", 18 },
 554                                         { "db03", 23 },
 555                                         { "db04", 24 },
 556                                         { "db05", 25 },
 557                                         { "db06", 8 },
 558                                         { "db07", 7 },
 559                                         { "led", 4 },
 560                                         {},
 561                                 },
 562                         },
 563                         }
 564                 }
 565         }, {
 566                 .name = "freetronicsoled128",
 567                 .spi = &(struct spi_board_info) {
 568                         .modalias = "fb_ssd1351",
 569                         .max_speed_hz = 20000000,
 570                         .mode = SPI_MODE_0,
 571                         .platform_data = &(struct fbtft_platform_data) {
 572                                 .display = {
 573                                         .buswidth = 8,
 574                                         .backlight = FBTFT_ONBOARD_BACKLIGHT,
 575                                 },
 576                                 .bgr = true,
 577                                 .gpios = (const struct fbtft_gpio []) {
 578                                         { "reset", 24 },
 579                                         { "dc", 25 },
 580                                         {},
 581                                 },
 582                         }
 583                 }
 584         }, {
 585                 .name = "hx8353d",
 586                 .spi = &(struct spi_board_info) {
 587                         .modalias = "fb_hx8353d",
 588                         .max_speed_hz = 16000000,
 589                         .mode = SPI_MODE_0,
 590                         .platform_data = &(struct fbtft_platform_data) {
 591                                 .display = {
 592                                         .buswidth = 8,
 593                                         .backlight = 1,
 594                                 },
 595                                 .gpios = (const struct fbtft_gpio []) {
 596                                         { "reset", 25 },
 597                                         { "dc", 24 },
 598                                         { "led", 23 },
 599                                         {},
 600                                 },
 601                         }
 602                 }
 603         }, {
 604                 .name = "hy28a",
 605                 .spi = &(struct spi_board_info) {
 606                         .modalias = "fb_ili9320",
 607                         .max_speed_hz = 32000000,
 608                         .mode = SPI_MODE_3,
 609                         .platform_data = &(struct fbtft_platform_data) {
 610                                 .display = {
 611                                         .buswidth = 8,
 612                                         .backlight = 1,
 613                                 },
 614                                 .startbyte = 0x70,
 615                                 .bgr = true,
 616                                 .gpios = (const struct fbtft_gpio []) {
 617                                         { "reset", 25 },
 618                                         { "led", 18 },
 619                                         {},
 620                                 },
 621                         }
 622                 }
 623         }, {
 624                 .name = "hy28b",
 625                 .spi = &(struct spi_board_info) {
 626                         .modalias = "fb_ili9325",
 627                         .max_speed_hz = 48000000,
 628                         .mode = SPI_MODE_3,
 629                         .platform_data = &(struct fbtft_platform_data) {
 630                                 .display = {
 631                                         .buswidth = 8,
 632                                         .backlight = 1,
 633                                         .init_sequence = hy28b_init_sequence,
 634                                 },
 635                                 .startbyte = 0x70,
 636                                 .bgr = true,
 637                                 .fps = 50,
 638                                 .gpios = (const struct fbtft_gpio []) {
 639                                         { "reset", 25 },
 640                                         { "led", 18 },
 641                                         {},
 642                                 },
 643                                 .gamma = HY28B_GAMMA,
 644                         }
 645                 }
 646         }, {
 647                 .name = "ili9481",
 648                 .spi = &(struct spi_board_info) {
 649                         .modalias = "fb_ili9481",
 650                         .max_speed_hz = 32000000,
 651                         .mode = SPI_MODE_0,
 652                         .platform_data = &(struct fbtft_platform_data) {
 653                                 .display = {
 654                                         .regwidth = 16,
 655                                         .buswidth = 8,
 656                                         .backlight = 1,
 657                                 },
 658                                 .bgr = true,
 659                                 .gpios = (const struct fbtft_gpio []) {
 660                                         { "reset", 25 },
 661                                         { "dc", 24 },
 662                                         { "led", 22 },
 663                                         {},
 664                                 },
 665                         }
 666                 }
 667         }, {
 668                 .name = "itdb24",
 669                 .pdev = &(struct platform_device) {
 670                         .name = "fb_s6d1121",
 671                         .id = 0,
 672                         .dev = {
 673                         .release = fbtft_device_pdev_release,
 674                         .platform_data = &(struct fbtft_platform_data) {
 675                                 .display = {
 676                                         .buswidth = 8,
 677                                         .backlight = 1,
 678                                 },
 679                                 .bgr = false,
 680                                 .gpios = (const struct fbtft_gpio []) {
 681                                         /* Wiring for LCD adapter kit */
 682                                         { "reset", 7 },
 683                                         { "dc", 0 },    /* rev 2: 2 */
 684                                         { "wr", 1 },    /* rev 2: 3 */
 685                                         { "cs", 8 },
 686                                         { "db00", 17 },
 687                                         { "db01", 18 },
 688                                         { "db02", 21 }, /* rev 2: 27 */
 689                                         { "db03", 22 },
 690                                         { "db04", 23 },
 691                                         { "db05", 24 },
 692                                         { "db06", 25 },
 693                                         { "db07", 4 },
 694                                         {}
 695                                 },
 696                         },
 697                         }
 698                 }
 699         }, {
 700                 .name = "itdb28",
 701                 .pdev = &(struct platform_device) {
 702                         .name = "fb_ili9325",
 703                         .id = 0,
 704                         .dev = {
 705                         .release = fbtft_device_pdev_release,
 706                         .platform_data = &(struct fbtft_platform_data) {
 707                                 .display = {
 708                                         .buswidth = 8,
 709                                         .backlight = 1,
 710                                 },
 711                                 .bgr = true,
 712                                 .gpios = (const struct fbtft_gpio []) {
 713                                         {},
 714                                 },
 715                         },
 716                         }
 717                 }
 718         }, {
 719                 .name = "itdb28_spi",
 720                 .spi = &(struct spi_board_info) {
 721                         .modalias = "fb_ili9325",
 722                         .max_speed_hz = 32000000,
 723                         .mode = SPI_MODE_0,
 724                         .platform_data = &(struct fbtft_platform_data) {
 725                                 .display = {
 726                                         .buswidth = 8,
 727                                         .backlight = 1,
 728                                 },
 729                                 .bgr = true,
 730                                 .gpios = (const struct fbtft_gpio []) {
 731                                         { "reset", 25 },
 732                                         { "dc", 24 },
 733                                         {},
 734                                 },
 735                         }
 736                 }
 737         }, {
 738                 .name = "mi0283qt-2",
 739                 .spi = &(struct spi_board_info) {
 740                         .modalias = "fb_hx8347d",
 741                         .max_speed_hz = 32000000,
 742                         .mode = SPI_MODE_0,
 743                         .platform_data = &(struct fbtft_platform_data) {
 744                                 .display = {
 745                                         .buswidth = 8,
 746                                         .backlight = 1,
 747                                 },
 748                                 .startbyte = 0x70,
 749                                 .bgr = true,
 750                                 .gpios = (const struct fbtft_gpio []) {
 751                                         { "reset", 25 },
 752                                         { "dc", 24 },
 753                                         { "led", 18 },
 754                                         {},
 755                                 },
 756                         }
 757                 }
 758         }, {
 759                 .name = "mi0283qt-9a",
 760                 .spi = &(struct spi_board_info) {
 761                         .modalias = "fb_ili9341",
 762                         .max_speed_hz = 32000000,
 763                         .mode = SPI_MODE_0,
 764                         .platform_data = &(struct fbtft_platform_data) {
 765                                 .display = {
 766                                         .buswidth = 9,
 767                                         .backlight = 1,
 768                                 },
 769                                 .bgr = true,
 770                                 .gpios = (const struct fbtft_gpio []) {
 771                                         { "reset", 25 },
 772                                         { "led", 18 },
 773                                         {},
 774                                 },
 775                         }
 776                 }
 777         }, {
 778                 .name = "mi0283qt-v2",
 779                 .spi = &(struct spi_board_info) {
 780                         .modalias = "fb_watterott",
 781                         .max_speed_hz = 4000000,
 782                         .mode = SPI_MODE_3,
 783                         .platform_data = &(struct fbtft_platform_data) {
 784                                 .gpios = (const struct fbtft_gpio []) {
 785                                         { "reset", 25 },
 786                                         {},
 787                                 },
 788                         }
 789                 }
 790         }, {
 791                 .name = "nokia3310",
 792                 .spi = &(struct spi_board_info) {
 793                         .modalias = "fb_pcd8544",
 794                         .max_speed_hz = 400000,
 795                         .mode = SPI_MODE_0,
 796                         .platform_data = &(struct fbtft_platform_data) {
 797                                 .display = {
 798                                         .buswidth = 8,
 799                                 },
 800                                 .gpios = (const struct fbtft_gpio []) {
 801                                         { "reset", 25 },
 802                                         { "dc", 24 },
 803                                         { "led", 23 },
 804                                         {},
 805                                 },
 806                         }
 807                 }
 808         }, {
 809                 .name = "nokia3310a",
 810                 .spi = &(struct spi_board_info) {
 811                         .modalias = "fb_tls8204",
 812                         .max_speed_hz = 1000000,
 813                         .mode = SPI_MODE_0,
 814                         .platform_data = &(struct fbtft_platform_data) {
 815                                 .display = {
 816                                         .buswidth = 8,
 817                                 },
 818                                 .gpios = (const struct fbtft_gpio []) {
 819                                         { "reset", 25 },
 820                                         { "dc", 24 },
 821                                         { "led", 23 },
 822                                         {},
 823                                 },
 824                         }
 825                 }
 826         }, {
 827                 .name = "nokia5110",
 828                 .spi = &(struct spi_board_info) {
 829                         .modalias = "fb_ili9163",
 830                         .max_speed_hz = 12000000,
 831                         .mode = SPI_MODE_0,
 832                         .platform_data = &(struct fbtft_platform_data) {
 833                                 .display = {
 834                                         .buswidth = 8,
 835                                         .backlight = 1,
 836                                 },
 837                                 .bgr = true,
 838                                 .gpios = (const struct fbtft_gpio []) {
 839                                         {},
 840                                 },
 841                         }
 842                 }
 843         }, {
 844
 845                 .name = "piscreen",
 846                 .spi = &(struct spi_board_info) {
 847                         .modalias = "fb_ili9486",
 848                         .max_speed_hz = 32000000,
 849                         .mode = SPI_MODE_0,
 850                         .platform_data = &(struct fbtft_platform_data) {
 851                                 .display = {
 852                                         .regwidth = 16,
 853                                         .buswidth = 8,
 854                                         .backlight = 1,
 855                                 },
 856                                 .bgr = true,
 857                                 .gpios = (const struct fbtft_gpio []) {
 858                                         { "reset", 25 },
 859                                         { "dc", 24 },
 860                                         { "led", 22 },
 861                                         {},
 862                                 },
 863                         }
 864                 }
 865         }, {
 866                 .name = "pitft",
 867                 .spi = &(struct spi_board_info) {
 868                         .modalias = "fb_ili9340",
 869                         .max_speed_hz = 32000000,
 870                         .mode = SPI_MODE_0,
 871                         .chip_select = 0,
 872                         .platform_data = &(struct fbtft_platform_data) {
 873                                 .display = {
 874                                         .buswidth = 8,
 875                                         .backlight = 1,
 876                                         .init_sequence = pitft_init_sequence,
 877                                 },
 878                                 .bgr = true,
 879                                 .gpios = (const struct fbtft_gpio []) {
 880                                         { "dc", 25 },
 881                                         {},
 882                                 },
 883                         }
 884                 }
 885         }, {
 886                 .name = "pioled",
 887                 .spi = &(struct spi_board_info) {
 888                         .modalias = "fb_ssd1351",
 889                         .max_speed_hz = 20000000,
 890                         .mode = SPI_MODE_0,
 891                         .platform_data = &(struct fbtft_platform_data) {
 892                                 .display = {
 893                                         .buswidth = 8,
 894                                 },
 895                                 .bgr = true,
 896                                 .gpios = (const struct fbtft_gpio []) {
 897                                         { "reset", 24 },
 898                                         { "dc", 25 },
 899                                         {},
 900                                 },
 901                                 .gamma =        "0 2 2 2 2 2 2 2 "
 902                                                 "2 2 2 2 2 2 2 2 "
 903                                                 "2 2 2 2 2 2 2 2 "
 904                                                 "2 2 2 2 2 2 2 3 "
 905                                                 "3 3 3 3 3 3 3 3 "
 906                                                 "3 3 3 3 3 3 3 3 "
 907                                                 "3 3 3 4 4 4 4 4 "
 908                                                 "4 4 4 4 4 4 4"
 909                         }
 910                 }
 911         }, {
 912                 .name = "rpi-display",
 913                 .spi = &(struct spi_board_info) {
 914                         .modalias = "fb_ili9341",
 915                         .max_speed_hz = 32000000,
 916                         .mode = SPI_MODE_0,
 917                         .platform_data = &(struct fbtft_platform_data) {
 918                                 .display = {
 919                                         .buswidth = 8,
 920                                         .backlight = 1,
 921                                 },
 922                                 .bgr = true,
 923                                 .gpios = (const struct fbtft_gpio []) {
 924                                         { "reset", 23 },
 925                                         { "dc", 24 },
 926                                         { "led", 18 },
 927                                         {},
 928                                 },
 929                         }
 930                 }
 931         }, {
 932                 .name = "s6d02a1",
 933                 .spi = &(struct spi_board_info) {
 934                         .modalias = "fb_s6d02a1",
 935                         .max_speed_hz = 32000000,
 936                         .mode = SPI_MODE_0,
 937                         .platform_data = &(struct fbtft_platform_data) {
 938                                 .display = {
 939                                         .buswidth = 8,
 940                                         .backlight = 1,
 941                                 },
 942                                 .bgr = true,
 943                                 .gpios = (const struct fbtft_gpio []) {
 944                                         { "reset", 25 },
 945                                         { "dc", 24 },
 946                                         { "led", 23 },
 947                                         {},
 948                                 },
 949                         }
 950                 }
 951         }, {
 952                 .name = "sainsmart18",
 953                 .spi = &(struct spi_board_info) {
 954                         .modalias = "fb_st7735r",
 955                         .max_speed_hz = 32000000,
 956                         .mode = SPI_MODE_0,
 957                         .platform_data = &(struct fbtft_platform_data) {
 958                                 .display = {
 959                                         .buswidth = 8,
 960                                 },
 961                                 .gpios = (const struct fbtft_gpio []) {
 962                                         { "reset", 25 },
 963                                         { "dc", 24 },
 964                                         {},
 965                                 },
 966                         }
 967                 }
 968         }, {
 969                 .name = "sainsmart32",
 970                 .pdev = &(struct platform_device) {
 971                         .name = "fb_ssd1289",
 972                         .id = 0,
 973                         .dev = {
 974                         .release = fbtft_device_pdev_release,
 975                         .platform_data = &(struct fbtft_platform_data) {
 976                                 .display = {
 977                                         .buswidth = 16,
 978                                         .txbuflen = -2, /* disable buffer */
 979                                         .backlight = 1,
 980                                         .fbtftops.write = write_gpio16_wr_slow,
 981                                 },
 982                                 .bgr = true,
 983                                 .gpios = (const struct fbtft_gpio []) {
 984                                         {},
 985                                 },
 986                         },
 987                 },
 988                 }
 989         }, {
 990                 .name = "sainsmart32_fast",
 991                 .pdev = &(struct platform_device) {
 992                         .name = "fb_ssd1289",
 993                         .id = 0,
 994                         .dev = {
 995                         .release = fbtft_device_pdev_release,
 996                         .platform_data = &(struct fbtft_platform_data) {
 997                                 .display = {
 998                                         .buswidth = 16,
 999                                         .txbuflen = -2, /* disable buffer */
1000                                         .backlight = 1,
1001                                 },
1002                                 .bgr = true,
1003                                 .gpios = (const struct fbtft_gpio []) {
1004                                         {},
1005                                 },
1006                         },
1007                 },
1008                 }
1009         }, {
1010                 .name = "sainsmart32_latched",
1011                 .pdev = &(struct platform_device) {
1012                         .name = "fb_ssd1289",
1013                         .id = 0,
1014                         .dev = {
1015                         .release = fbtft_device_pdev_release,
1016                         .platform_data = &(struct fbtft_platform_data) {
1017                                 .display = {
1018                                         .buswidth = 16,
1019                                         .txbuflen = -2, /* disable buffer */
1020                                         .backlight = 1,
1021                                         .fbtftops.write =
1022                                                 fbtft_write_gpio16_wr_latched,
1023                                 },
1024                                 .bgr = true,
1025                                 .gpios = (const struct fbtft_gpio []) {
1026                                         {},
1027                                 },
1028                         },
1029                 },
1030                 }
1031         }, {
1032                 .name = "sainsmart32_spi",
1033                 .spi = &(struct spi_board_info) {
1034                         .modalias = "fb_ssd1289",
1035                         .max_speed_hz = 16000000,
1036                         .mode = SPI_MODE_0,
1037                         .platform_data = &(struct fbtft_platform_data) {
1038                                 .display = {
1039                                         .buswidth = 8,
1040                                         .backlight = 1,
1041                                 },
1042                                 .bgr = true,
1043                                 .gpios = (const struct fbtft_gpio []) {
1044                                         { "reset", 25 },
1045                                         { "dc", 24 },
1046                                         {},
1047                                 },
1048                         }
1049                 }
1050         }, {
1051                 .name = "spidev",
1052                 .spi = &(struct spi_board_info) {
1053                         .modalias = "spidev",
1054                         .max_speed_hz = 500000,
1055                         .bus_num = 0,
1056                         .chip_select = 0,
1057                         .mode = SPI_MODE_0,
1058                         .platform_data = &(struct fbtft_platform_data) {
1059                                 .gpios = (const struct fbtft_gpio []) {
1060                                         {},
1061                                 },
1062                         }
1063                 }
1064         }, {
1065                 .name = "ssd1331",
1066                 .spi = &(struct spi_board_info) {
1067                         .modalias = "fb_ssd1331",
1068                         .max_speed_hz = 20000000,
1069                         .mode = SPI_MODE_3,
1070                         .platform_data = &(struct fbtft_platform_data) {
1071                                 .display = {
1072                                         .buswidth = 8,
1073                                 },
1074                                 .gpios = (const struct fbtft_gpio []) {
1075                                         { "reset", 24 },
1076                                         { "dc", 25 },
1077                                         {},
1078                                 },
1079                         }
1080                 }
1081         }, {
1082                 .name = "tinylcd35",
1083                 .spi = &(struct spi_board_info) {
1084                         .modalias = "fb_tinylcd",
1085                         .max_speed_hz = 32000000,
1086                         .mode = SPI_MODE_0,
1087                         .platform_data = &(struct fbtft_platform_data) {
1088                                 .display = {
1089                                         .buswidth = 8,
1090                                         .backlight = 1,
1091                                 },
1092                                 .bgr = true,
1093                                 .gpios = (const struct fbtft_gpio []) {
1094                                         { "reset", 25 },
1095                                         { "dc", 24 },
1096                                         { "led", 18 },
1097                                         {},
1098                                 },
1099                         }
1100                 }
1101         }, {
1102                 .name = "tm022hdh26",
1103                 .spi = &(struct spi_board_info) {
1104                         .modalias = "fb_ili9341",
1105                         .max_speed_hz = 32000000,
1106                         .mode = SPI_MODE_0,
1107                         .platform_data = &(struct fbtft_platform_data) {
1108                                 .display = {
1109                                         .buswidth = 8,
1110                                         .backlight = 1,
1111                                 },
1112                                 .bgr = true,
1113                                 .gpios = (const struct fbtft_gpio []) {
1114                                         { "reset", 25 },
1115                                         { "dc", 24 },
1116                                         { "led", 18 },
1117                                         {},
1118                                 },
1119                         }
1120                 }
1121         }, {
1122                 .name = "tontec35_9481", /* boards before 02 July 2014 */
1123                 .spi = &(struct spi_board_info) {
1124                         .modalias = "fb_ili9481",
1125                         .max_speed_hz = 128000000,
1126                         .mode = SPI_MODE_3,
1127                         .platform_data = &(struct fbtft_platform_data) {
1128                                 .display = {
1129                                         .buswidth = 8,
1130                                         .backlight = 1,
1131                                 },
1132                                 .bgr = true,
1133                                 .gpios = (const struct fbtft_gpio []) {
1134                                         { "reset", 15 },
1135                                         { "dc", 25 },
1136                                         { "led_", 18 },
1137                                         {},
1138                                 },
1139                         }
1140                 }
1141         }, {
1142                 .name = "tontec35_9486", /* boards after 02 July 2014 */
1143                 .spi = &(struct spi_board_info) {
1144                         .modalias = "fb_ili9486",
1145                         .max_speed_hz = 128000000,
1146                         .mode = SPI_MODE_3,
1147                         .platform_data = &(struct fbtft_platform_data) {
1148                                 .display = {
1149                                         .buswidth = 8,
1150                                         .backlight = 1,
1151                                 },
1152                                 .bgr = true,
1153                                 .gpios = (const struct fbtft_gpio []) {
1154                                         { "reset", 15 },
1155                                         { "dc", 25 },
1156                                         { "led_", 18 },
1157                                         {},
1158                                 },
1159                         }
1160                 }
1161         }, {
1162                 .name = "upd161704",
1163                 .spi = &(struct spi_board_info) {
1164                         .modalias = "fb_upd161704",
1165                         .max_speed_hz = 32000000,
1166                         .mode = SPI_MODE_0,
1167                         .platform_data = &(struct fbtft_platform_data) {
1168                                 .display = {
1169                                         .buswidth = 8,
1170                                 },
1171                                 .gpios = (const struct fbtft_gpio []) {
1172                                         { "reset", 24 },
1173                                         { "dc", 25 },
1174                                         {},
1175                                 },
1176                         }
1177                 }
1178         }, {
1179                 .name = "waveshare32b",
1180                 .spi = &(struct spi_board_info) {
1181                         .modalias = "fb_ili9340",
1182                         .max_speed_hz = 48000000,
1183                         .mode = SPI_MODE_0,
1184                         .platform_data = &(struct fbtft_platform_data) {
1185                                 .display = {
1186                                         .buswidth = 8,
1187                                         .backlight = 1,
1188                                         .init_sequence =
1189                                                 waveshare32b_init_sequence,
1190                                 },
1191                                 .bgr = true,
1192                                 .gpios = (const struct fbtft_gpio []) {
1193                                         { "reset", 27 },
1194                                         { "dc", 22 },
1195                                         {},
1196                                 },
1197                         }
1198                 }
1199         }, {
1200                 .name = "waveshare22",
1201                 .spi = &(struct spi_board_info) {
1202                         .modalias = "fb_bd663474",
1203                         .max_speed_hz = 32000000,
1204                         .mode = SPI_MODE_3,
1205                         .platform_data = &(struct fbtft_platform_data) {
1206                                 .display = {
1207                                         .buswidth = 8,
1208                                 },
1209                                 .gpios = (const struct fbtft_gpio []) {
1210                                         { "reset", 24 },
1211                                         { "dc", 25 },
1212                                         {},
1213                                 },
1214                         }
1215                 }
1216         }, {
1217                 /* This should be the last item.
1218                    Used with the custom argument */
1219                 .name = "",
1220                 .spi = &(struct spi_board_info) {
1221                         .modalias = "",
1222                         .max_speed_hz = 0,
1223                         .mode = SPI_MODE_0,
1224                         .platform_data = &(struct fbtft_platform_data) {
1225                                 .gpios = (const struct fbtft_gpio []) {
1226                                         {},
1227                                 },
1228                         }
1229                 },
1230                 .pdev = &(struct platform_device) {
1231                         .name = "",
1232                         .id = 0,
1233                         .dev = {
1234                         .release = fbtft_device_pdev_release,
1235                         .platform_data = &(struct fbtft_platform_data) {
1236                                 .gpios = (const struct fbtft_gpio []) {
1237                                         {},
1238                                 },
1239                         },
1240                 },
1241                 },
1242         }
1243 };
1244
1245 static int write_gpio16_wr_slow(struct fbtft_par *par, void *buf, size_t len)
1246 {
1247         u16 data;
1248         int i;
1249 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
1250         static u16 prev_data;
1251 #endif
1252
1253         fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
1254                 "%s(len=%d): ", __func__, len);
1255
1256         while (len) {
1257                 data = *(u16 *)buf;
1258
1259                 /* Start writing by pulling down /WR */
1260                 gpio_set_value(par->gpio.wr, 0);
1261
1262                 /* Set data */
1263 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
1264                 if (data == prev_data) {
1265                         gpio_set_value(par->gpio.wr, 0); /* used as delay */
1266                 } else {
1267                         for (i = 0; i < 16; i++) {
1268                                 if ((data & 1) != (prev_data & 1))
1269                                         gpio_set_value(par->gpio.db[i],
1270                                                                 data & 1);
1271                                 data >>= 1;
1272                                 prev_data >>= 1;
1273                         }
1274                 }
1275 #else
1276                 for (i = 0; i < 16; i++) {
1277                         gpio_set_value(par->gpio.db[i], data & 1);
1278                         data >>= 1;
1279                 }
1280 #endif
1281
1282                 /* Pullup /WR */
1283                 gpio_set_value(par->gpio.wr, 1);
1284
1285 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
1286                 prev_data = *(u16 *)buf;
1287 #endif
1288                 buf += 2;
1289                 len -= 2;
1290         }
1291
1292         return 0;
1293 }
1294
1295 static void adafruit18_green_tab_set_addr_win(struct fbtft_par *par,
1296                                                 int xs, int ys, int xe, int ye)
1297 {
1298         write_reg(par, 0x2A, 0, xs + 2, 0, xe + 2);
1299         write_reg(par, 0x2B, 0, ys + 1, 0, ye + 1);
1300         write_reg(par, 0x2C);
1301 }
1302
1303 /* used if gpios parameter is present */
1304 static struct fbtft_gpio fbtft_device_param_gpios[MAX_GPIOS + 1] = { };
1305
1306 static void fbtft_device_pdev_release(struct device *dev)
1307 {
1308 /* Needed to silence this message:
1309 Device 'xxx' does not have a release() function, it is broken and must be fixed
1310 */
1311 }
1312
1313 static int spi_device_found(struct device *dev, void *data)
1314 {
1315         struct spi_device *spi = to_spi_device(dev);
1316
1317         dev_info(dev, "%s %s %dkHz %d bits mode=0x%02X\n", spi->modalias,
1318                  dev_name(dev), spi->max_speed_hz / 1000, spi->bits_per_word,
1319                  spi->mode);
1320
1321         return 0;
1322 }
1323
1324 static void pr_spi_devices(void)
1325 {
1326         pr_debug("SPI devices registered:\n");
1327         bus_for_each_dev(&spi_bus_type, NULL, NULL, spi_device_found);
1328 }
1329
1330 static int p_device_found(struct device *dev, void *data)
1331 {
1332         struct platform_device
1333         *pdev = to_platform_device(dev);
1334
1335         if (strstr(pdev->name, "fb"))
1336                 dev_info(dev, "%s id=%d pdata? %s\n", pdev->name, pdev->id,
1337                          pdev->dev.platform_data ? "yes" : "no");
1338
1339         return 0;
1340 }
1341
1342 static void pr_p_devices(void)
1343 {
1344         pr_debug("'fb' Platform devices registered:\n");
1345         bus_for_each_dev(&platform_bus_type, NULL, NULL, p_device_found);
1346 }
1347
1348 #ifdef MODULE
1349 static void fbtft_device_spi_delete(struct spi_master *master, unsigned cs)
1350 {
1351         struct device *dev;
1352         char str[32];
1353
1354         snprintf(str, sizeof(str), "%s.%u", dev_name(&master->dev), cs);
1355
1356         dev = bus_find_device_by_name(&spi_bus_type, NULL, str);
1357         if (dev) {
1358                 if (verbose)
1359                         dev_info(dev, "Deleting %s\n", str);
1360                 device_del(dev);
1361         }
1362 }
1363
1364 static int fbtft_device_spi_device_register(struct spi_board_info *spi)
1365 {
1366         struct spi_master *master;
1367
1368         master = spi_busnum_to_master(spi->bus_num);
1369         if (!master) {
1370                 pr_err("spi_busnum_to_master(%d) returned NULL\n",
1371                        spi->bus_num);
1372                 return -EINVAL;
1373         }
1374         /* make sure it's available */
1375         fbtft_device_spi_delete(master, spi->chip_select);
1376         spi_device = spi_new_device(master, spi);
1377         put_device(&master->dev);
1378         if (!spi_device) {
1379                 dev_err(&master->dev, "spi_new_device() returned NULL\n");
1380                 return -EPERM;
1381         }
1382         return 0;
1383 }
1384 #else
1385 static int fbtft_device_spi_device_register(struct spi_board_info *spi)
1386 {
1387         return spi_register_board_info(spi, 1);
1388 }
1389 #endif
1390
1391 static int __init fbtft_device_init(void)
1392 {
1393         struct spi_board_info *spi = NULL;
1394         struct fbtft_platform_data *pdata;
1395         const struct fbtft_gpio *gpio = NULL;
1396         char *p_gpio, *p_name, *p_num;
1397         bool found = false;
1398         int i = 0;
1399         long val;
1400         int ret = 0;
1401
1402         if (name == NULL) {
1403 #ifdef MODULE
1404                 pr_err("missing module parameter: 'name'\n");
1405                 return -EINVAL;
1406 #else
1407                 return 0;
1408 #endif
1409         }
1410
1411         if (init_num > FBTFT_MAX_INIT_SEQUENCE) {
1412                 pr_err("init parameter: exceeded max array size: %d\n",
1413                        FBTFT_MAX_INIT_SEQUENCE);
1414                 return -EINVAL;
1415         }
1416
1417         /* parse module parameter: gpios */
1418         while ((p_gpio = strsep(&gpios, ","))) {
1419                 if (strchr(p_gpio, ':') == NULL) {
1420                         pr_err("error: missing ':' in gpios parameter: %s\n",
1421                                p_gpio);
1422                         return -EINVAL;
1423                 }
1424                 p_num = p_gpio;
1425                 p_name = strsep(&p_num, ":");
1426                 if (p_name == NULL || p_num == NULL) {
1427                         pr_err("something bad happened parsing gpios parameter: %s\n",
1428                                p_gpio);
1429                         return -EINVAL;
1430                 }
1431                 ret = kstrtol(p_num, 10, &val);
1432                 if (ret) {
1433                         pr_err("could not parse number in gpios parameter: %s:%s\n",
1434                                p_name, p_num);
1435                         return -EINVAL;
1436                 }
1437                 strncpy(fbtft_device_param_gpios[i].name, p_name,
1438                         FBTFT_GPIO_NAME_SIZE - 1);
1439                 fbtft_device_param_gpios[i++].gpio = (int)val;
1440                 if (i == MAX_GPIOS) {
1441                         pr_err("gpios parameter: exceeded max array size: %d\n",
1442                                MAX_GPIOS);
1443                         return -EINVAL;
1444                 }
1445         }
1446         if (fbtft_device_param_gpios[0].name[0])
1447                 gpio = fbtft_device_param_gpios;
1448
1449         if (verbose > 2)
1450                 pr_spi_devices(); /* print list of registered SPI devices */
1451
1452         if (verbose > 2)
1453                 pr_p_devices(); /* print list of 'fb' platform devices */
1454
1455         pr_debug("name='%s', busnum=%d, cs=%d\n", name, busnum, cs);
1456
1457         if (rotate > 0 && rotate < 4) {
1458                 rotate = (4 - rotate) * 90;
1459                 pr_warn("argument 'rotate' should be an angle. Values 1-3 is deprecated. Setting it to %d.\n",
1460                         rotate);
1461         }
1462         if (rotate != 0 && rotate != 90 && rotate != 180 && rotate != 270) {
1463                 pr_warn("argument 'rotate' illegal value: %d. Setting it to 0.\n",
1464                         rotate);
1465                 rotate = 0;
1466         }
1467
1468         /* name=list lists all supported displays */
1469         if (strncmp(name, "list", FBTFT_GPIO_NAME_SIZE) == 0) {
1470                 pr_info("Supported displays:\n");
1471
1472                 for (i = 0; i < ARRAY_SIZE(displays); i++)
1473                         pr_info("%s\n", displays[i].name);
1474                 return -ECANCELED;
1475         }
1476
1477         if (custom) {
1478                 i = ARRAY_SIZE(displays) - 1;
1479                 displays[i].name = name;
1480                 if (speed == 0) {
1481                         displays[i].pdev->name = name;
1482                         displays[i].spi = NULL;
1483                 } else {
1484                         strncpy(displays[i].spi->modalias, name, SPI_NAME_SIZE);
1485                         displays[i].pdev = NULL;
1486                 }
1487         }
1488
1489         for (i = 0; i < ARRAY_SIZE(displays); i++) {
1490                 if (strncmp(name, displays[i].name, 32) == 0) {
1491                         if (displays[i].spi) {
1492                                 spi = displays[i].spi;
1493                                 spi->chip_select = cs;
1494                                 spi->bus_num = busnum;
1495                                 if (speed)
1496                                         spi->max_speed_hz = speed;
1497                                 if (mode != -1)
1498                                         spi->mode = mode;
1499                                 pdata = (void *)spi->platform_data;
1500                         } else if (displays[i].pdev) {
1501                                 p_device = displays[i].pdev;
1502                                 pdata = p_device->dev.platform_data;
1503                         } else {
1504                                 pr_err("broken displays array\n");
1505                                 return -EINVAL;
1506                         }
1507
1508                         pdata->rotate = rotate;
1509                         if (bgr == 0)
1510                                 pdata->bgr = false;
1511                         else if (bgr == 1)
1512                                 pdata->bgr = true;
1513                         if (startbyte)
1514                                 pdata->startbyte = startbyte;
1515                         if (gamma)
1516                                 pdata->gamma = gamma;
1517                         pdata->display.debug = debug;
1518                         if (fps)
1519                                 pdata->fps = fps;
1520                         if (txbuflen)
1521                                 pdata->txbuflen = txbuflen;
1522                         if (init_num)
1523                                 pdata->display.init_sequence = init;
1524                         if (gpio)
1525                                 pdata->gpios = gpio;
1526                         if (custom) {
1527                                 pdata->display.width = width;
1528                                 pdata->display.height = height;
1529                                 pdata->display.buswidth = buswidth;
1530                                 pdata->display.backlight = 1;
1531                         }
1532
1533                         if (displays[i].spi) {
1534                                 ret = fbtft_device_spi_device_register(spi);
1535                                 if (ret) {
1536                                         pr_err("failed to register SPI device\n");
1537                                         return ret;
1538                                 }
1539                         } else {
1540                                 ret = platform_device_register(p_device);
1541                                 if (ret < 0) {
1542                                         pr_err("platform_device_register() returned %d\n",
1543                                                ret);
1544                                         return ret;
1545                                 }
1546                         }
1547                         found = true;
1548                         break;
1549                 }
1550         }
1551
1552         if (!found) {
1553                 pr_err("display not supported: '%s'\n", name);
1554                 return -EINVAL;
1555         }
1556
1557         if (verbose && pdata && pdata->gpios) {
1558                 gpio = pdata->gpios;
1559                 pr_info("GPIOS used by '%s':\n", name);
1560                 found = false;
1561                 while (verbose && gpio->name[0]) {
1562                         pr_info("'%s' = GPIO%d\n", gpio->name, gpio->gpio);
1563                         gpio++;
1564                         found = true;
1565                 }
1566                 if (!found)
1567                         pr_info("(none)\n");
1568         }
1569
1570         if (spi_device && (verbose > 1))
1571                 pr_spi_devices();
1572         if (p_device && (verbose > 1))
1573                 pr_p_devices();
1574
1575         return 0;
1576 }
1577
1578 static void __exit fbtft_device_exit(void)
1579 {
1580         if (spi_device) {
1581                 device_del(&spi_device->dev);
1582                 kfree(spi_device);
1583         }
1584
1585         if (p_device)
1586                 platform_device_unregister(p_device);
1587
1588 }
1589
1590 arch_initcall(fbtft_device_init);
1591 module_exit(fbtft_device_exit);
1592
1593 MODULE_DESCRIPTION("Add a FBTFT device.");
1594 MODULE_AUTHOR("Noralf Tronnes");
1595 MODULE_LICENSE("GPL");