mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Arnd Bergmann](/assets/img/avatar_default.png)
Having a local variable of 1024 bytes on 64-bit architectures is a bit too much, and I ran into this warning while trying to see what functions use the largest stack: drivers/staging/fbtft/fbtft-sysfs.c: In function 'store_gamma_curve': drivers/staging/fbtft/fbtft-sysfs.c:132:1: warning: the frame size of 1032 bytes is larger than 1024 bytes [-Wframe-larger-than=] As there is no need for 64-bit gamma values (on 32-bit architectures, we don't use those either), I'm changing the type from 'unsigned long' to 'u32' here, which cuts the required space in half everywhere. Signed-off-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
420 lines
16 KiB
C
420 lines
16 KiB
C
/*
|
|
* Copyright (C) 2013 Noralf Tronnes
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#ifndef __LINUX_FBTFT_H
|
|
#define __LINUX_FBTFT_H
|
|
|
|
#include <linux/fb.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#define FBTFT_ONBOARD_BACKLIGHT 2
|
|
|
|
#define FBTFT_GPIO_NO_MATCH 0xFFFF
|
|
#define FBTFT_GPIO_NAME_SIZE 32
|
|
#define FBTFT_MAX_INIT_SEQUENCE 512
|
|
#define FBTFT_GAMMA_MAX_VALUES_TOTAL 128
|
|
|
|
#define FBTFT_OF_INIT_CMD BIT(24)
|
|
#define FBTFT_OF_INIT_DELAY BIT(25)
|
|
|
|
/**
|
|
* struct fbtft_gpio - Structure that holds one pinname to gpio mapping
|
|
* @name: pinname (reset, dc, etc.)
|
|
* @gpio: GPIO number
|
|
*
|
|
*/
|
|
struct fbtft_gpio {
|
|
char name[FBTFT_GPIO_NAME_SIZE];
|
|
unsigned int gpio;
|
|
};
|
|
|
|
struct fbtft_par;
|
|
|
|
/**
|
|
* struct fbtft_ops - FBTFT operations structure
|
|
* @write: Writes to interface bus
|
|
* @read: Reads from interface bus
|
|
* @write_vmem: Writes video memory to display
|
|
* @write_reg: Writes to controller register
|
|
* @set_addr_win: Set the GRAM update window
|
|
* @reset: Reset the LCD controller
|
|
* @mkdirty: Marks display lines for update
|
|
* @update_display: Updates the display
|
|
* @init_display: Initializes the display
|
|
* @blank: Blank the display (optional)
|
|
* @request_gpios_match: Do pinname to gpio matching
|
|
* @request_gpios: Request gpios from the kernel
|
|
* @free_gpios: Free previously requested gpios
|
|
* @verify_gpios: Verify that necessary gpios is present (optional)
|
|
* @register_backlight: Used to register backlight device (optional)
|
|
* @unregister_backlight: Unregister backlight device (optional)
|
|
* @set_var: Configure LCD with values from variables like @rotate and @bgr
|
|
* (optional)
|
|
* @set_gamma: Set Gamma curve (optional)
|
|
*
|
|
* Most of these operations have default functions assigned to them in
|
|
* fbtft_framebuffer_alloc()
|
|
*/
|
|
struct fbtft_ops {
|
|
int (*write)(struct fbtft_par *par, void *buf, size_t len);
|
|
int (*read)(struct fbtft_par *par, void *buf, size_t len);
|
|
int (*write_vmem)(struct fbtft_par *par, size_t offset, size_t len);
|
|
void (*write_register)(struct fbtft_par *par, int len, ...);
|
|
|
|
void (*set_addr_win)(struct fbtft_par *par,
|
|
int xs, int ys, int xe, int ye);
|
|
void (*reset)(struct fbtft_par *par);
|
|
void (*mkdirty)(struct fb_info *info, int from, int to);
|
|
void (*update_display)(struct fbtft_par *par,
|
|
unsigned int start_line, unsigned int end_line);
|
|
int (*init_display)(struct fbtft_par *par);
|
|
int (*blank)(struct fbtft_par *par, bool on);
|
|
|
|
unsigned long (*request_gpios_match)(struct fbtft_par *par,
|
|
const struct fbtft_gpio *gpio);
|
|
int (*request_gpios)(struct fbtft_par *par);
|
|
int (*verify_gpios)(struct fbtft_par *par);
|
|
|
|
void (*register_backlight)(struct fbtft_par *par);
|
|
void (*unregister_backlight)(struct fbtft_par *par);
|
|
|
|
int (*set_var)(struct fbtft_par *par);
|
|
int (*set_gamma)(struct fbtft_par *par, u32 *curves);
|
|
};
|
|
|
|
/**
|
|
* struct fbtft_display - Describes the display properties
|
|
* @width: Width of display in pixels
|
|
* @height: Height of display in pixels
|
|
* @regwidth: LCD Controller Register width in bits
|
|
* @buswidth: Display interface bus width in bits
|
|
* @backlight: Backlight type.
|
|
* @fbtftops: FBTFT operations provided by driver or device (platform_data)
|
|
* @bpp: Bits per pixel
|
|
* @fps: Frames per second
|
|
* @txbuflen: Size of transmit buffer
|
|
* @init_sequence: Pointer to LCD initialization array
|
|
* @gamma: String representation of Gamma curve(s)
|
|
* @gamma_num: Number of Gamma curves
|
|
* @gamma_len: Number of values per Gamma curve
|
|
* @debug: Initial debug value
|
|
*
|
|
* This structure is not stored by FBTFT except for init_sequence.
|
|
*/
|
|
struct fbtft_display {
|
|
unsigned int width;
|
|
unsigned int height;
|
|
unsigned int regwidth;
|
|
unsigned int buswidth;
|
|
unsigned int backlight;
|
|
struct fbtft_ops fbtftops;
|
|
unsigned int bpp;
|
|
unsigned int fps;
|
|
int txbuflen;
|
|
s16 *init_sequence;
|
|
char *gamma;
|
|
int gamma_num;
|
|
int gamma_len;
|
|
unsigned long debug;
|
|
};
|
|
|
|
/**
|
|
* struct fbtft_platform_data - Passes display specific data to the driver
|
|
* @display: Display properties
|
|
* @gpios: Pointer to an array of pinname to gpio mappings
|
|
* @rotate: Display rotation angle
|
|
* @bgr: LCD Controller BGR bit
|
|
* @fps: Frames per second (this will go away, use @fps in @fbtft_display)
|
|
* @txbuflen: Size of transmit buffer
|
|
* @startbyte: When set, enables use of Startbyte in transfers
|
|
* @gamma: String representation of Gamma curve(s)
|
|
* @extra: A way to pass extra info
|
|
*/
|
|
struct fbtft_platform_data {
|
|
struct fbtft_display display;
|
|
const struct fbtft_gpio *gpios;
|
|
unsigned int rotate;
|
|
bool bgr;
|
|
unsigned int fps;
|
|
int txbuflen;
|
|
u8 startbyte;
|
|
char *gamma;
|
|
void *extra;
|
|
};
|
|
|
|
/**
|
|
* struct fbtft_par - Main FBTFT data structure
|
|
*
|
|
* This structure holds all relevant data to operate the display
|
|
*
|
|
* See sourcefile for documentation since nested structs is not
|
|
* supported by kernel-doc.
|
|
*
|
|
*/
|
|
/* @spi: Set if it is a SPI device
|
|
* @pdev: Set if it is a platform device
|
|
* @info: Pointer to framebuffer fb_info structure
|
|
* @pdata: Pointer to platform data
|
|
* @ssbuf: Not used
|
|
* @pseudo_palette: Used by fb_set_colreg()
|
|
* @txbuf.buf: Transmit buffer
|
|
* @txbuf.len: Transmit buffer length
|
|
* @buf: Small buffer used when writing init data over SPI
|
|
* @startbyte: Used by some controllers when in SPI mode.
|
|
* Format: 6 bit Device id + RS bit + RW bit
|
|
* @fbtftops: FBTFT operations provided by driver or device (platform_data)
|
|
* @dirty_lock: Protects dirty_lines_start and dirty_lines_end
|
|
* @dirty_lines_start: Where to begin updating display
|
|
* @dirty_lines_end: Where to end updating display
|
|
* @gpio.reset: GPIO used to reset display
|
|
* @gpio.dc: Data/Command signal, also known as RS
|
|
* @gpio.rd: Read latching signal
|
|
* @gpio.wr: Write latching signal
|
|
* @gpio.latch: Bus latch signal, eg. 16->8 bit bus latch
|
|
* @gpio.cs: LCD Chip Select with parallel interface bus
|
|
* @gpio.db[16]: Parallel databus
|
|
* @gpio.led[16]: Led control signals
|
|
* @gpio.aux[16]: Auxiliary signals, not used by core
|
|
* @init_sequence: Pointer to LCD initialization array
|
|
* @gamma.lock: Mutex for Gamma curve locking
|
|
* @gamma.curves: Pointer to Gamma curve array
|
|
* @gamma.num_values: Number of values per Gamma curve
|
|
* @gamma.num_curves: Number of Gamma curves
|
|
* @debug: Pointer to debug value
|
|
* @current_debug:
|
|
* @first_update_done: Used to only time the first display update
|
|
* @update_time: Used to calculate 'fps' in debug output
|
|
* @bgr: BGR mode/\n
|
|
* @extra: Extra info needed by driver
|
|
*/
|
|
struct fbtft_par {
|
|
struct spi_device *spi;
|
|
struct platform_device *pdev;
|
|
struct fb_info *info;
|
|
struct fbtft_platform_data *pdata;
|
|
u16 *ssbuf;
|
|
u32 pseudo_palette[16];
|
|
struct {
|
|
void *buf;
|
|
size_t len;
|
|
} txbuf;
|
|
u8 *buf;
|
|
u8 startbyte;
|
|
struct fbtft_ops fbtftops;
|
|
spinlock_t dirty_lock;
|
|
unsigned int dirty_lines_start;
|
|
unsigned int dirty_lines_end;
|
|
struct {
|
|
int reset;
|
|
int dc;
|
|
int rd;
|
|
int wr;
|
|
int latch;
|
|
int cs;
|
|
int db[16];
|
|
int led[16];
|
|
int aux[16];
|
|
} gpio;
|
|
s16 *init_sequence;
|
|
struct {
|
|
struct mutex lock;
|
|
u32 *curves;
|
|
int num_values;
|
|
int num_curves;
|
|
} gamma;
|
|
unsigned long debug;
|
|
bool first_update_done;
|
|
ktime_t update_time;
|
|
bool bgr;
|
|
void *extra;
|
|
};
|
|
|
|
#define NUMARGS(...) (sizeof((int[]){__VA_ARGS__})/sizeof(int))
|
|
|
|
#define write_reg(par, ...) \
|
|
par->fbtftops.write_register(par, NUMARGS(__VA_ARGS__), __VA_ARGS__)
|
|
|
|
/* fbtft-core.c */
|
|
void fbtft_dbg_hex(const struct device *dev, int groupsize,
|
|
void *buf, size_t len, const char *fmt, ...);
|
|
struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display,
|
|
struct device *dev,
|
|
struct fbtft_platform_data *pdata);
|
|
void fbtft_framebuffer_release(struct fb_info *info);
|
|
int fbtft_register_framebuffer(struct fb_info *fb_info);
|
|
int fbtft_unregister_framebuffer(struct fb_info *fb_info);
|
|
void fbtft_register_backlight(struct fbtft_par *par);
|
|
void fbtft_unregister_backlight(struct fbtft_par *par);
|
|
int fbtft_init_display(struct fbtft_par *par);
|
|
int fbtft_probe_common(struct fbtft_display *display, struct spi_device *sdev,
|
|
struct platform_device *pdev);
|
|
int fbtft_remove_common(struct device *dev, struct fb_info *info);
|
|
|
|
/* fbtft-io.c */
|
|
int fbtft_write_spi(struct fbtft_par *par, void *buf, size_t len);
|
|
int fbtft_write_spi_emulate_9(struct fbtft_par *par, void *buf, size_t len);
|
|
int fbtft_read_spi(struct fbtft_par *par, void *buf, size_t len);
|
|
int fbtft_write_gpio8_wr(struct fbtft_par *par, void *buf, size_t len);
|
|
int fbtft_write_gpio16_wr(struct fbtft_par *par, void *buf, size_t len);
|
|
int fbtft_write_gpio16_wr_latched(struct fbtft_par *par, void *buf, size_t len);
|
|
|
|
/* fbtft-bus.c */
|
|
int fbtft_write_vmem8_bus8(struct fbtft_par *par, size_t offset, size_t len);
|
|
int fbtft_write_vmem16_bus16(struct fbtft_par *par, size_t offset, size_t len);
|
|
int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len);
|
|
int fbtft_write_vmem16_bus9(struct fbtft_par *par, size_t offset, size_t len);
|
|
void fbtft_write_reg8_bus8(struct fbtft_par *par, int len, ...);
|
|
void fbtft_write_reg8_bus9(struct fbtft_par *par, int len, ...);
|
|
void fbtft_write_reg16_bus8(struct fbtft_par *par, int len, ...);
|
|
void fbtft_write_reg16_bus16(struct fbtft_par *par, int len, ...);
|
|
|
|
#define FBTFT_REGISTER_DRIVER(_name, _compatible, _display) \
|
|
\
|
|
static int fbtft_driver_probe_spi(struct spi_device *spi) \
|
|
{ \
|
|
return fbtft_probe_common(_display, spi, NULL); \
|
|
} \
|
|
\
|
|
static int fbtft_driver_remove_spi(struct spi_device *spi) \
|
|
{ \
|
|
struct fb_info *info = spi_get_drvdata(spi); \
|
|
\
|
|
return fbtft_remove_common(&spi->dev, info); \
|
|
} \
|
|
\
|
|
static int fbtft_driver_probe_pdev(struct platform_device *pdev) \
|
|
{ \
|
|
return fbtft_probe_common(_display, NULL, pdev); \
|
|
} \
|
|
\
|
|
static int fbtft_driver_remove_pdev(struct platform_device *pdev) \
|
|
{ \
|
|
struct fb_info *info = platform_get_drvdata(pdev); \
|
|
\
|
|
return fbtft_remove_common(&pdev->dev, info); \
|
|
} \
|
|
\
|
|
static const struct of_device_id dt_ids[] = { \
|
|
{ .compatible = _compatible }, \
|
|
{}, \
|
|
}; \
|
|
\
|
|
MODULE_DEVICE_TABLE(of, dt_ids); \
|
|
\
|
|
\
|
|
static struct spi_driver fbtft_driver_spi_driver = { \
|
|
.driver = { \
|
|
.name = _name, \
|
|
.of_match_table = of_match_ptr(dt_ids), \
|
|
}, \
|
|
.probe = fbtft_driver_probe_spi, \
|
|
.remove = fbtft_driver_remove_spi, \
|
|
}; \
|
|
\
|
|
static struct platform_driver fbtft_driver_platform_driver = { \
|
|
.driver = { \
|
|
.name = _name, \
|
|
.owner = THIS_MODULE, \
|
|
.of_match_table = of_match_ptr(dt_ids), \
|
|
}, \
|
|
.probe = fbtft_driver_probe_pdev, \
|
|
.remove = fbtft_driver_remove_pdev, \
|
|
}; \
|
|
\
|
|
static int __init fbtft_driver_module_init(void) \
|
|
{ \
|
|
int ret; \
|
|
\
|
|
ret = spi_register_driver(&fbtft_driver_spi_driver); \
|
|
if (ret < 0) \
|
|
return ret; \
|
|
return platform_driver_register(&fbtft_driver_platform_driver); \
|
|
} \
|
|
\
|
|
static void __exit fbtft_driver_module_exit(void) \
|
|
{ \
|
|
spi_unregister_driver(&fbtft_driver_spi_driver); \
|
|
platform_driver_unregister(&fbtft_driver_platform_driver); \
|
|
} \
|
|
\
|
|
module_init(fbtft_driver_module_init); \
|
|
module_exit(fbtft_driver_module_exit);
|
|
|
|
/* Debug macros */
|
|
|
|
/* shorthand debug levels */
|
|
#define DEBUG_LEVEL_1 DEBUG_REQUEST_GPIOS
|
|
#define DEBUG_LEVEL_2 (DEBUG_LEVEL_1 | DEBUG_DRIVER_INIT_FUNCTIONS | DEBUG_TIME_FIRST_UPDATE)
|
|
#define DEBUG_LEVEL_3 (DEBUG_LEVEL_2 | DEBUG_RESET | DEBUG_INIT_DISPLAY | DEBUG_BLANK | DEBUG_REQUEST_GPIOS | DEBUG_FREE_GPIOS | DEBUG_VERIFY_GPIOS | DEBUG_BACKLIGHT | DEBUG_SYSFS)
|
|
#define DEBUG_LEVEL_4 (DEBUG_LEVEL_2 | DEBUG_FB_READ | DEBUG_FB_WRITE | DEBUG_FB_FILLRECT | DEBUG_FB_COPYAREA | DEBUG_FB_IMAGEBLIT | DEBUG_FB_BLANK)
|
|
#define DEBUG_LEVEL_5 (DEBUG_LEVEL_3 | DEBUG_UPDATE_DISPLAY)
|
|
#define DEBUG_LEVEL_6 (DEBUG_LEVEL_4 | DEBUG_LEVEL_5)
|
|
#define DEBUG_LEVEL_7 0xFFFFFFFF
|
|
|
|
#define DEBUG_DRIVER_INIT_FUNCTIONS (1<<3)
|
|
#define DEBUG_TIME_FIRST_UPDATE (1<<4)
|
|
#define DEBUG_TIME_EACH_UPDATE (1<<5)
|
|
#define DEBUG_DEFERRED_IO (1<<6)
|
|
#define DEBUG_FBTFT_INIT_FUNCTIONS (1<<7)
|
|
|
|
/* fbops */
|
|
#define DEBUG_FB_READ (1<<8)
|
|
#define DEBUG_FB_WRITE (1<<9)
|
|
#define DEBUG_FB_FILLRECT (1<<10)
|
|
#define DEBUG_FB_COPYAREA (1<<11)
|
|
#define DEBUG_FB_IMAGEBLIT (1<<12)
|
|
#define DEBUG_FB_SETCOLREG (1<<13)
|
|
#define DEBUG_FB_BLANK (1<<14)
|
|
|
|
#define DEBUG_SYSFS (1<<16)
|
|
|
|
/* fbtftops */
|
|
#define DEBUG_BACKLIGHT (1<<17)
|
|
#define DEBUG_READ (1<<18)
|
|
#define DEBUG_WRITE (1<<19)
|
|
#define DEBUG_WRITE_VMEM (1<<20)
|
|
#define DEBUG_WRITE_REGISTER (1<<21)
|
|
#define DEBUG_SET_ADDR_WIN (1<<22)
|
|
#define DEBUG_RESET (1<<23)
|
|
#define DEBUG_MKDIRTY (1<<24)
|
|
#define DEBUG_UPDATE_DISPLAY (1<<25)
|
|
#define DEBUG_INIT_DISPLAY (1<<26)
|
|
#define DEBUG_BLANK (1<<27)
|
|
#define DEBUG_REQUEST_GPIOS (1<<28)
|
|
#define DEBUG_FREE_GPIOS (1<<29)
|
|
#define DEBUG_REQUEST_GPIOS_MATCH (1<<30)
|
|
#define DEBUG_VERIFY_GPIOS (1<<31)
|
|
|
|
#define fbtft_init_dbg(dev, format, arg...) \
|
|
do { \
|
|
if (unlikely((dev)->platform_data && \
|
|
(((struct fbtft_platform_data *)(dev)->platform_data)->display.debug & DEBUG_DRIVER_INIT_FUNCTIONS))) \
|
|
dev_info(dev, format, ##arg); \
|
|
} while (0)
|
|
|
|
#define fbtft_par_dbg(level, par, format, arg...) \
|
|
do { \
|
|
if (unlikely(par->debug & level)) \
|
|
dev_info(par->info->device, format, ##arg); \
|
|
} while (0)
|
|
|
|
#define fbtft_par_dbg_hex(level, par, dev, type, buf, num, format, arg...) \
|
|
do { \
|
|
if (unlikely(par->debug & level)) \
|
|
fbtft_dbg_hex(dev, sizeof(type), buf, num * sizeof(type), format, ##arg); \
|
|
} while (0)
|
|
|
|
#endif /* __LINUX_FBTFT_H */
|