drivers/staging/fbtft/fbtft.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /* Copyright (C) 2013 Noralf Tronnes */
   3
   4 #ifndef __LINUX_FBTFT_H
   5 #define __LINUX_FBTFT_H
   6
   7 #include <linux/fb.h>
   8 #include <linux/spinlock.h>
   9 #include <linux/spi/spi.h>
  10 #include <linux/platform_device.h>
  11
  12 #define FBTFT_ONBOARD_BACKLIGHT 2
  13
  14 #define FBTFT_GPIO_NO_MATCH             0xFFFF
  15 #define FBTFT_GPIO_NAME_SIZE    32
  16 #define FBTFT_MAX_INIT_SEQUENCE      512
  17 #define FBTFT_GAMMA_MAX_VALUES_TOTAL 128
  18
  19 #define FBTFT_OF_INIT_CMD       BIT(24)
  20 #define FBTFT_OF_INIT_DELAY     BIT(25)
  21
  22 /**
  23  * struct fbtft_gpio - Structure that holds one pinname to gpio mapping
  24  * @name: pinname (reset, dc, etc.)
  25  * @gpio: GPIO number
  26  *
  27  */
  28 struct fbtft_gpio {
  29         char name[FBTFT_GPIO_NAME_SIZE];
  30         struct gpio_desc *gpio;
  31 };
  32
  33 struct fbtft_par;
  34
  35 /**
  36  * struct fbtft_ops - FBTFT operations structure
  37  * @write: Writes to interface bus
  38  * @read: Reads from interface bus
  39  * @write_vmem: Writes video memory to display
  40  * @write_reg: Writes to controller register
  41  * @set_addr_win: Set the GRAM update window
  42  * @reset: Reset the LCD controller
  43  * @mkdirty: Marks display lines for update
  44  * @update_display: Updates the display
  45  * @init_display: Initializes the display
  46  * @blank: Blank the display (optional)
  47  * @request_gpios_match: Do pinname to gpio matching
  48  * @request_gpios: Request gpios from the kernel
  49  * @free_gpios: Free previously requested gpios
  50  * @verify_gpios: Verify that necessary gpios is present (optional)
  51  * @register_backlight: Used to register backlight device (optional)
  52  * @unregister_backlight: Unregister backlight device (optional)
  53  * @set_var: Configure LCD with values from variables like @rotate and @bgr
  54  *           (optional)
  55  * @set_gamma: Set Gamma curve (optional)
  56  *
  57  * Most of these operations have default functions assigned to them in
  58  *     fbtft_framebuffer_alloc()
  59  */
  60 struct fbtft_ops {
  61         int (*write)(struct fbtft_par *par, void *buf, size_t len);
  62         int (*read)(struct fbtft_par *par, void *buf, size_t len);
  63         int (*write_vmem)(struct fbtft_par *par, size_t offset, size_t len);
  64         void (*write_register)(struct fbtft_par *par, int len, ...);
  65
  66         void (*set_addr_win)(struct fbtft_par *par,
  67                              int xs, int ys, int xe, int ye);
  68         void (*reset)(struct fbtft_par *par);
  69         void (*mkdirty)(struct fb_info *info, int from, int to);
  70         void (*update_display)(struct fbtft_par *par,
  71                                unsigned int start_line, unsigned int end_line);
  72         int (*init_display)(struct fbtft_par *par);
  73         int (*blank)(struct fbtft_par *par, bool on);
  74
  75         unsigned long (*request_gpios_match)(struct fbtft_par *par,
  76                                              const struct fbtft_gpio *gpio);
  77         int (*request_gpios)(struct fbtft_par *par);
  78         int (*verify_gpios)(struct fbtft_par *par);
  79
  80         void (*register_backlight)(struct fbtft_par *par);
  81         void (*unregister_backlight)(struct fbtft_par *par);
  82
  83         int (*set_var)(struct fbtft_par *par);
  84         int (*set_gamma)(struct fbtft_par *par, u32 *curves);
  85 };
  86
  87 /**
  88  * struct fbtft_display - Describes the display properties
  89  * @width: Width of display in pixels
  90  * @height: Height of display in pixels
  91  * @regwidth: LCD Controller Register width in bits
  92  * @buswidth: Display interface bus width in bits
  93  * @backlight: Backlight type.
  94  * @fbtftops: FBTFT operations provided by driver or device (platform_data)
  95  * @bpp: Bits per pixel
  96  * @fps: Frames per second
  97  * @txbuflen: Size of transmit buffer
  98  * @init_sequence: Pointer to LCD initialization array
  99  * @gamma: String representation of Gamma curve(s)
 100  * @gamma_num: Number of Gamma curves
 101  * @gamma_len: Number of values per Gamma curve
 102  * @debug: Initial debug value
 103  *
 104  * This structure is not stored by FBTFT except for init_sequence.
 105  */
 106 struct fbtft_display {
 107         unsigned int width;
 108         unsigned int height;
 109         unsigned int regwidth;
 110         unsigned int buswidth;
 111         unsigned int backlight;
 112         struct fbtft_ops fbtftops;
 113         unsigned int bpp;
 114         unsigned int fps;
 115         int txbuflen;
 116         const s16 *init_sequence;
 117         char *gamma;
 118         int gamma_num;
 119         int gamma_len;
 120         unsigned long debug;
 121 };
 122
 123 /**
 124  * struct fbtft_platform_data - Passes display specific data to the driver
 125  * @display: Display properties
 126  * @gpios: Pointer to an array of pinname to gpio mappings
 127  * @rotate: Display rotation angle
 128  * @bgr: LCD Controller BGR bit
 129  * @fps: Frames per second (this will go away, use @fps in @fbtft_display)
 130  * @txbuflen: Size of transmit buffer
 131  * @startbyte: When set, enables use of Startbyte in transfers
 132  * @gamma: String representation of Gamma curve(s)
 133  * @extra: A way to pass extra info
 134  */
 135 struct fbtft_platform_data {
 136         struct fbtft_display display;
 137         unsigned int rotate;
 138         bool bgr;
 139         unsigned int fps;
 140         int txbuflen;
 141         u8 startbyte;
 142         char *gamma;
 143         void *extra;
 144 };
 145
 146 /**
 147  * struct fbtft_par - Main FBTFT data structure
 148  *
 149  * This structure holds all relevant data to operate the display
 150  *
 151  * See sourcefile for documentation since nested structs is not
 152  * supported by kernel-doc.
 153  *
 154  */
 155 /* @spi: Set if it is a SPI device
 156  * @pdev: Set if it is a platform device
 157  * @info: Pointer to framebuffer fb_info structure
 158  * @pdata: Pointer to platform data
 159  * @ssbuf: Not used
 160  * @pseudo_palette: Used by fb_set_colreg()
 161  * @txbuf.buf: Transmit buffer
 162  * @txbuf.len: Transmit buffer length
 163  * @buf: Small buffer used when writing init data over SPI
 164  * @startbyte: Used by some controllers when in SPI mode.
 165  *             Format: 6 bit Device id + RS bit + RW bit
 166  * @fbtftops: FBTFT operations provided by driver or device (platform_data)
 167  * @dirty_lock: Protects dirty_lines_start and dirty_lines_end
 168  * @dirty_lines_start: Where to begin updating display
 169  * @dirty_lines_end: Where to end updating display
 170  * @gpio.reset: GPIO used to reset display
 171  * @gpio.dc: Data/Command signal, also known as RS
 172  * @gpio.rd: Read latching signal
 173  * @gpio.wr: Write latching signal
 174  * @gpio.latch: Bus latch signal, eg. 16->8 bit bus latch
 175  * @gpio.cs: LCD Chip Select with parallel interface bus
 176  * @gpio.db[16]: Parallel databus
 177  * @gpio.led[16]: Led control signals
 178  * @gpio.aux[16]: Auxiliary signals, not used by core
 179  * @init_sequence: Pointer to LCD initialization array
 180  * @gamma.lock: Mutex for Gamma curve locking
 181  * @gamma.curves: Pointer to Gamma curve array
 182  * @gamma.num_values: Number of values per Gamma curve
 183  * @gamma.num_curves: Number of Gamma curves
 184  * @debug: Pointer to debug value
 185  * @current_debug:
 186  * @first_update_done: Used to only time the first display update
 187  * @update_time: Used to calculate 'fps' in debug output
 188  * @bgr: BGR mode/\n
 189  * @extra: Extra info needed by driver
 190  */
 191 struct fbtft_par {
 192         struct spi_device *spi;
 193         struct platform_device *pdev;
 194         struct fb_info *info;
 195         struct fbtft_platform_data *pdata;
 196         u16 *ssbuf;
 197         u32 pseudo_palette[16];
 198         struct {
 199                 void *buf;
 200                 size_t len;
 201         } txbuf;
 202         u8 *buf;
 203         u8 startbyte;
 204         struct fbtft_ops fbtftops;
 205         spinlock_t dirty_lock;
 206         unsigned int dirty_lines_start;
 207         unsigned int dirty_lines_end;
 208         struct {
 209                 struct gpio_desc *reset;
 210                 struct gpio_desc *dc;
 211                 struct gpio_desc *rd;
 212                 struct gpio_desc *wr;
 213                 struct gpio_desc *latch;
 214                 struct gpio_desc *cs;
 215                 struct gpio_desc *db[16];
 216                 struct gpio_desc *led[16];
 217                 struct gpio_desc *aux[16];
 218         } gpio;
 219         const s16 *init_sequence;
 220         struct {
 221                 struct mutex lock;
 222                 u32 *curves;
 223                 int num_values;
 224                 int num_curves;
 225         } gamma;
 226         unsigned long debug;
 227         bool first_update_done;
 228         ktime_t update_time;
 229         bool bgr;
 230         void *extra;
 231         bool polarity;
 232 };
 233
 234 #define NUMARGS(...)  (sizeof((int[]){__VA_ARGS__}) / sizeof(int))
 235
 236 #define write_reg(par, ...)                                            \
 237         ((par)->fbtftops.write_register(par, NUMARGS(__VA_ARGS__), __VA_ARGS__))
 238
 239 /* fbtft-core.c */
 240 int fbtft_write_buf_dc(struct fbtft_par *par, void *buf, size_t len, int dc);
 241 __printf(5, 6)
 242 void fbtft_dbg_hex(const struct device *dev, int groupsize,
 243                    void *buf, size_t len, const char *fmt, ...);
 244 struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display,
 245                                         struct device *dev,
 246                                         struct fbtft_platform_data *pdata);
 247 void fbtft_framebuffer_release(struct fb_info *info);
 248 int fbtft_register_framebuffer(struct fb_info *fb_info);
 249 int fbtft_unregister_framebuffer(struct fb_info *fb_info);
 250 void fbtft_register_backlight(struct fbtft_par *par);
 251 void fbtft_unregister_backlight(struct fbtft_par *par);
 252 int fbtft_init_display(struct fbtft_par *par);
 253 int fbtft_probe_common(struct fbtft_display *display, struct spi_device *sdev,
 254                        struct platform_device *pdev);
 255 void fbtft_remove_common(struct device *dev, struct fb_info *info);
 256
 257 /* fbtft-io.c */
 258 int fbtft_write_spi(struct fbtft_par *par, void *buf, size_t len);
 259 int fbtft_write_spi_emulate_9(struct fbtft_par *par, void *buf, size_t len);
 260 int fbtft_read_spi(struct fbtft_par *par, void *buf, size_t len);
 261 int fbtft_write_gpio8_wr(struct fbtft_par *par, void *buf, size_t len);
 262 int fbtft_write_gpio16_wr(struct fbtft_par *par, void *buf, size_t len);
 263 int fbtft_write_gpio16_wr_latched(struct fbtft_par *par, void *buf, size_t len);
 264
 265 /* fbtft-bus.c */
 266 int fbtft_write_vmem8_bus8(struct fbtft_par *par, size_t offset, size_t len);
 267 int fbtft_write_vmem16_bus16(struct fbtft_par *par, size_t offset, size_t len);
 268 int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len);
 269 int fbtft_write_vmem16_bus9(struct fbtft_par *par, size_t offset, size_t len);
 270 void fbtft_write_reg8_bus8(struct fbtft_par *par, int len, ...);
 271 void fbtft_write_reg8_bus9(struct fbtft_par *par, int len, ...);
 272 void fbtft_write_reg16_bus8(struct fbtft_par *par, int len, ...);
 273 void fbtft_write_reg16_bus16(struct fbtft_par *par, int len, ...);
 274
 275 #define FBTFT_REGISTER_DRIVER(_name, _compatible, _display)                \
 276                                                                            \
 277 static int fbtft_driver_probe_spi(struct spi_device *spi)                  \
 278 {                                                                          \
 279         return fbtft_probe_common(_display, spi, NULL);                    \
 280 }                                                                          \
 281                                                                            \
 282 static int fbtft_driver_remove_spi(struct spi_device *spi)                 \
 283 {                                                                          \
 284         struct fb_info *info = spi_get_drvdata(spi);                       \
 285                                                                            \
 286         fbtft_remove_common(&spi->dev, info);                              \
 287         return 0;                                                          \
 288 }                                                                          \
 289                                                                            \
 290 static int fbtft_driver_probe_pdev(struct platform_device *pdev)           \
 291 {                                                                          \
 292         return fbtft_probe_common(_display, NULL, pdev);                   \
 293 }                                                                          \
 294                                                                            \
 295 static int fbtft_driver_remove_pdev(struct platform_device *pdev)          \
 296 {                                                                          \
 297         struct fb_info *info = platform_get_drvdata(pdev);                 \
 298                                                                            \
 299         fbtft_remove_common(&pdev->dev, info);                             \
 300         return 0;                                                          \
 301 }                                                                          \
 302                                                                            \
 303 static const struct of_device_id dt_ids[] = {                              \
 304         { .compatible = _compatible },                                     \
 305         {},                                                                \
 306 };                                                                         \
 307                                                                            \
 308 MODULE_DEVICE_TABLE(of, dt_ids);                                           \
 309                                                                            \
 310                                                                            \
 311 static struct spi_driver fbtft_driver_spi_driver = {                       \
 312         .driver = {                                                        \
 313                 .name   = _name,                                           \
 314                 .of_match_table = dt_ids,                                  \
 315         },                                                                 \
 316         .probe  = fbtft_driver_probe_spi,                                  \
 317         .remove = fbtft_driver_remove_spi,                                 \
 318 };                                                                         \
 319                                                                            \
 320 static struct platform_driver fbtft_driver_platform_driver = {             \
 321         .driver = {                                                        \
 322                 .name   = _name,                                           \
 323                 .owner  = THIS_MODULE,                                     \
 324                 .of_match_table = dt_ids,                                  \
 325         },                                                                 \
 326         .probe  = fbtft_driver_probe_pdev,                                 \
 327         .remove = fbtft_driver_remove_pdev,                                \
 328 };                                                                         \
 329                                                                            \
 330 static int __init fbtft_driver_module_init(void)                           \
 331 {                                                                          \
 332         int ret;                                                           \
 333                                                                            \
 334         ret = spi_register_driver(&fbtft_driver_spi_driver);               \
 335         if (ret < 0)                                                       \
 336                 return ret;                                                \
 337         return platform_driver_register(&fbtft_driver_platform_driver);    \
 338 }                                                                          \
 339                                                                            \
 340 static void __exit fbtft_driver_module_exit(void)                          \
 341 {                                                                          \
 342         spi_unregister_driver(&fbtft_driver_spi_driver);                   \
 343         platform_driver_unregister(&fbtft_driver_platform_driver);         \
 344 }                                                                          \
 345                                                                            \
 346 module_init(fbtft_driver_module_init);                                     \
 347 module_exit(fbtft_driver_module_exit);
 348
 349 #define FBTFT_REGISTER_SPI_DRIVER(_name, _comp_vend, _comp_dev, _display)       \
 350                                                                                 \
 351 static int fbtft_driver_probe_spi(struct spi_device *spi)                       \
 352 {                                                                               \
 353         return fbtft_probe_common(_display, spi, NULL);                         \
 354 }                                                                               \
 355                                                                                 \
 356 static int fbtft_driver_remove_spi(struct spi_device *spi)                      \
 357 {                                                                               \
 358         struct fb_info *info = spi_get_drvdata(spi);                            \
 359                                                                                 \
 360         fbtft_remove_common(&spi->dev, info);                                   \
 361         return 0;                                                               \
 362 }                                                                               \
 363                                                                                 \
 364 static const struct of_device_id dt_ids[] = {                                   \
 365         { .compatible = _comp_vend "," _comp_dev },                             \
 366         {},                                                                     \
 367 };                                                                              \
 368                                                                                 \
 369 MODULE_DEVICE_TABLE(of, dt_ids);                                                \
 370                                                                                 \
 371 static const struct spi_device_id spi_ids[] = {                                 \
 372         { .name = _comp_dev },                                                  \
 373         {},                                                                     \
 374 };                                                                              \
 375                                                                                 \
 376 MODULE_DEVICE_TABLE(spi, spi_ids);                                              \
 377                                                                                 \
 378 static struct spi_driver fbtft_driver_spi_driver = {                            \
 379         .driver = {                                                             \
 380                 .name  = _name,                                                 \
 381                 .of_match_table = dt_ids,                                       \
 382         },                                                                      \
 383         .id_table = spi_ids,                                                    \
 384         .probe  = fbtft_driver_probe_spi,                                       \
 385         .remove = fbtft_driver_remove_spi,                                      \
 386 };                                                                              \
 387                                                                                 \
 388 module_spi_driver(fbtft_driver_spi_driver);
 389
 390 /* Debug macros */
 391
 392 /* shorthand debug levels */
 393 #define DEBUG_LEVEL_1   DEBUG_REQUEST_GPIOS
 394 #define DEBUG_LEVEL_2   (DEBUG_LEVEL_1 | DEBUG_DRIVER_INIT_FUNCTIONS        \
 395                                        | DEBUG_TIME_FIRST_UPDATE)
 396 #define DEBUG_LEVEL_3   (DEBUG_LEVEL_2 | DEBUG_RESET | DEBUG_INIT_DISPLAY   \
 397                                        | DEBUG_BLANK | DEBUG_REQUEST_GPIOS  \
 398                                        | DEBUG_FREE_GPIOS                   \
 399                                        | DEBUG_VERIFY_GPIOS                 \
 400                                        | DEBUG_BACKLIGHT | DEBUG_SYSFS)
 401 #define DEBUG_LEVEL_4   (DEBUG_LEVEL_2 | DEBUG_FB_READ | DEBUG_FB_WRITE     \
 402                                        | DEBUG_FB_FILLRECT                  \
 403                                        | DEBUG_FB_COPYAREA                  \
 404                                        | DEBUG_FB_IMAGEBLIT | DEBUG_FB_BLANK)
 405 #define DEBUG_LEVEL_5   (DEBUG_LEVEL_3 | DEBUG_UPDATE_DISPLAY)
 406 #define DEBUG_LEVEL_6   (DEBUG_LEVEL_4 | DEBUG_LEVEL_5)
 407 #define DEBUG_LEVEL_7   0xFFFFFFFF
 408
 409 #define DEBUG_DRIVER_INIT_FUNCTIONS BIT(3)
 410 #define DEBUG_TIME_FIRST_UPDATE     BIT(4)
 411 #define DEBUG_TIME_EACH_UPDATE      BIT(5)
 412 #define DEBUG_DEFERRED_IO           BIT(6)
 413 #define DEBUG_FBTFT_INIT_FUNCTIONS  BIT(7)
 414
 415 /* fbops */
 416 #define DEBUG_FB_READ               BIT(8)
 417 #define DEBUG_FB_WRITE              BIT(9)
 418 #define DEBUG_FB_FILLRECT           BIT(10)
 419 #define DEBUG_FB_COPYAREA           BIT(11)
 420 #define DEBUG_FB_IMAGEBLIT          BIT(12)
 421 #define DEBUG_FB_SETCOLREG          BIT(13)
 422 #define DEBUG_FB_BLANK              BIT(14)
 423
 424 #define DEBUG_SYSFS                 BIT(16)
 425
 426 /* fbtftops */
 427 #define DEBUG_BACKLIGHT             BIT(17)
 428 #define DEBUG_READ                  BIT(18)
 429 #define DEBUG_WRITE                 BIT(19)
 430 #define DEBUG_WRITE_VMEM            BIT(20)
 431 #define DEBUG_WRITE_REGISTER        BIT(21)
 432 #define DEBUG_SET_ADDR_WIN          BIT(22)
 433 #define DEBUG_RESET                 BIT(23)
 434 #define DEBUG_MKDIRTY               BIT(24)
 435 #define DEBUG_UPDATE_DISPLAY        BIT(25)
 436 #define DEBUG_INIT_DISPLAY          BIT(26)
 437 #define DEBUG_BLANK                 BIT(27)
 438 #define DEBUG_REQUEST_GPIOS         BIT(28)
 439 #define DEBUG_FREE_GPIOS            BIT(29)
 440 #define DEBUG_REQUEST_GPIOS_MATCH   BIT(30)
 441 #define DEBUG_VERIFY_GPIOS          BIT(31)
 442
 443 #define fbtft_init_dbg(dev, format, arg...)                  \
 444 do {                                                         \
 445         if (unlikely((dev)->platform_data &&                 \
 446             (((struct fbtft_platform_data *)(dev)->platform_data)->display.debug & DEBUG_DRIVER_INIT_FUNCTIONS))) \
 447                 dev_info(dev, format, ##arg);                \
 448 } while (0)
 449
 450 #define fbtft_par_dbg(level, par, format, arg...)            \
 451 do {                                                         \
 452         if (unlikely((par)->debug & (level)))                    \
 453                 dev_info((par)->info->device, format, ##arg);  \
 454 } while (0)
 455
 456 #define fbtft_par_dbg_hex(level, par, dev, type, buf, num, format, arg...) \
 457 do {                                                                       \
 458         if (unlikely((par)->debug & (level)))                                  \
 459                 fbtft_dbg_hex(dev, sizeof(type), buf,\
 460                               (num) * sizeof(type), format, ##arg); \
 461 } while (0)
 462
 463 #endif /* __LINUX_FBTFT_H */