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 const 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_DT_TABLE(_compatible) \ 276 static const struct of_device_id dt_ids[] = { \ 277 { .compatible = _compatible }, \ 278 {}, \ 279 }; \ 280 MODULE_DEVICE_TABLE(of, dt_ids); 281 282 #define FBTFT_SPI_DRIVER(_name, _compatible, _display, _spi_ids) \ 283 \ 284 static int fbtft_driver_probe_spi(struct spi_device *spi) \ 285 { \ 286 return fbtft_probe_common(_display, spi, NULL); \ 287 } \ 288 \ 289 static void fbtft_driver_remove_spi(struct spi_device *spi) \ 290 { \ 291 struct fb_info *info = spi_get_drvdata(spi); \ 292 \ 293 fbtft_remove_common(&spi->dev, info); \ 294 } \ 295 \ 296 static struct spi_driver fbtft_driver_spi_driver = { \ 297 .driver = { \ 298 .name = _name, \ 299 .of_match_table = dt_ids, \ 300 }, \ 301 .id_table = _spi_ids, \ 302 .probe = fbtft_driver_probe_spi, \ 303 .remove = fbtft_driver_remove_spi, \ 304 }; 305 306 #define FBTFT_REGISTER_DRIVER(_name, _compatible, _display) \ 307 \ 308 static int fbtft_driver_probe_pdev(struct platform_device *pdev) \ 309 { \ 310 return fbtft_probe_common(_display, NULL, pdev); \ 311 } \ 312 \ 313 static void fbtft_driver_remove_pdev(struct platform_device *pdev) \ 314 { \ 315 struct fb_info *info = platform_get_drvdata(pdev); \ 316 \ 317 fbtft_remove_common(&pdev->dev, info); \ 318 } \ 319 \ 320 FBTFT_DT_TABLE(_compatible) \ 321 \ 322 FBTFT_SPI_DRIVER(_name, _compatible, _display, NULL) \ 323 \ 324 static struct platform_driver fbtft_driver_platform_driver = { \ 325 .driver = { \ 326 .name = _name, \ 327 .owner = THIS_MODULE, \ 328 .of_match_table = dt_ids, \ 329 }, \ 330 .probe = fbtft_driver_probe_pdev, \ 331 .remove_new = fbtft_driver_remove_pdev, \ 332 }; \ 333 \ 334 static int __init fbtft_driver_module_init(void) \ 335 { \ 336 int ret; \ 337 \ 338 ret = spi_register_driver(&fbtft_driver_spi_driver); \ 339 if (ret < 0) \ 340 return ret; \ 341 ret = platform_driver_register(&fbtft_driver_platform_driver); \ 342 if (ret < 0) \ 343 spi_unregister_driver(&fbtft_driver_spi_driver); \ 344 return ret; \ 345 } \ 346 \ 347 static void __exit fbtft_driver_module_exit(void) \ 348 { \ 349 spi_unregister_driver(&fbtft_driver_spi_driver); \ 350 platform_driver_unregister(&fbtft_driver_platform_driver); \ 351 } \ 352 \ 353 module_init(fbtft_driver_module_init); \ 354 module_exit(fbtft_driver_module_exit); 355 356 #define FBTFT_REGISTER_SPI_DRIVER(_name, _comp_vend, _comp_dev, _display) \ 357 \ 358 FBTFT_DT_TABLE(_comp_vend "," _comp_dev) \ 359 \ 360 static const struct spi_device_id spi_ids[] = { \ 361 { .name = _comp_dev }, \ 362 {}, \ 363 }; \ 364 MODULE_DEVICE_TABLE(spi, spi_ids); \ 365 \ 366 FBTFT_SPI_DRIVER(_name, _comp_vend "," _comp_dev, _display, spi_ids) \ 367 \ 368 module_spi_driver(fbtft_driver_spi_driver); 369 370 /* Debug macros */ 371 372 /* shorthand debug levels */ 373 #define DEBUG_LEVEL_1 DEBUG_REQUEST_GPIOS 374 #define DEBUG_LEVEL_2 (DEBUG_LEVEL_1 | DEBUG_DRIVER_INIT_FUNCTIONS \ 375 | DEBUG_TIME_FIRST_UPDATE) 376 #define DEBUG_LEVEL_3 (DEBUG_LEVEL_2 | DEBUG_RESET | DEBUG_INIT_DISPLAY \ 377 | DEBUG_BLANK | DEBUG_REQUEST_GPIOS \ 378 | DEBUG_FREE_GPIOS \ 379 | DEBUG_VERIFY_GPIOS \ 380 | DEBUG_BACKLIGHT | DEBUG_SYSFS) 381 #define DEBUG_LEVEL_4 (DEBUG_LEVEL_2 | DEBUG_FB_READ | DEBUG_FB_WRITE \ 382 | DEBUG_FB_FILLRECT \ 383 | DEBUG_FB_COPYAREA \ 384 | DEBUG_FB_IMAGEBLIT | DEBUG_FB_BLANK) 385 #define DEBUG_LEVEL_5 (DEBUG_LEVEL_3 | DEBUG_UPDATE_DISPLAY) 386 #define DEBUG_LEVEL_6 (DEBUG_LEVEL_4 | DEBUG_LEVEL_5) 387 #define DEBUG_LEVEL_7 0xFFFFFFFF 388 389 #define DEBUG_DRIVER_INIT_FUNCTIONS BIT(3) 390 #define DEBUG_TIME_FIRST_UPDATE BIT(4) 391 #define DEBUG_TIME_EACH_UPDATE BIT(5) 392 #define DEBUG_DEFERRED_IO BIT(6) 393 #define DEBUG_FBTFT_INIT_FUNCTIONS BIT(7) 394 395 /* fbops */ 396 #define DEBUG_FB_READ BIT(8) 397 #define DEBUG_FB_WRITE BIT(9) 398 #define DEBUG_FB_FILLRECT BIT(10) 399 #define DEBUG_FB_COPYAREA BIT(11) 400 #define DEBUG_FB_IMAGEBLIT BIT(12) 401 #define DEBUG_FB_SETCOLREG BIT(13) 402 #define DEBUG_FB_BLANK BIT(14) 403 404 #define DEBUG_SYSFS BIT(16) 405 406 /* fbtftops */ 407 #define DEBUG_BACKLIGHT BIT(17) 408 #define DEBUG_READ BIT(18) 409 #define DEBUG_WRITE BIT(19) 410 #define DEBUG_WRITE_VMEM BIT(20) 411 #define DEBUG_WRITE_REGISTER BIT(21) 412 #define DEBUG_SET_ADDR_WIN BIT(22) 413 #define DEBUG_RESET BIT(23) 414 #define DEBUG_MKDIRTY BIT(24) 415 #define DEBUG_UPDATE_DISPLAY BIT(25) 416 #define DEBUG_INIT_DISPLAY BIT(26) 417 #define DEBUG_BLANK BIT(27) 418 #define DEBUG_REQUEST_GPIOS BIT(28) 419 #define DEBUG_FREE_GPIOS BIT(29) 420 #define DEBUG_REQUEST_GPIOS_MATCH BIT(30) 421 #define DEBUG_VERIFY_GPIOS BIT(31) 422 423 #define fbtft_init_dbg(dev, format, arg...) \ 424 do { \ 425 if (unlikely((dev)->platform_data && \ 426 (((struct fbtft_platform_data *)(dev)->platform_data)->display.debug & DEBUG_DRIVER_INIT_FUNCTIONS))) \ 427 dev_info(dev, format, ##arg); \ 428 } while (0) 429 430 #define fbtft_par_dbg(level, par, format, arg...) \ 431 do { \ 432 if (unlikely((par)->debug & (level))) \ 433 dev_info((par)->info->device, format, ##arg); \ 434 } while (0) 435 436 #define fbtft_par_dbg_hex(level, par, dev, type, buf, num, format, arg...) \ 437 do { \ 438 if (unlikely((par)->debug & (level))) \ 439 fbtft_dbg_hex(dev, sizeof(type), buf,\ 440 (num) * sizeof(type), format, ##arg); \ 441 } while (0) 442 443 #endif /* __LINUX_FBTFT_H */ 444