| // SPDX-License-Identifier: GPL-2.0+ | |
| /* | |
| * Copyright (C) 2013 Noralf Tronnes | |
| * | |
| * This driver is inspired by: | |
| * st7735fb.c, Copyright (C) 2011, Matt Porter | |
| * broadsheetfb.c, Copyright (C) 2008, Jaya Kumar | |
| */ | |
| #include <linux/module.h> | |
| #include <linux/kernel.h> | |
| #include <linux/errno.h> | |
| #include <linux/string.h> | |
| #include <linux/mm.h> | |
| #include <linux/vmalloc.h> | |
| #include <linux/slab.h> | |
| #include <linux/init.h> | |
| #include <linux/fb.h> | |
| #include <linux/gpio.h> | |
| #include <linux/spi/spi.h> | |
| #include <linux/delay.h> | |
| #include <linux/uaccess.h> | |
| #include <linux/backlight.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/spinlock.h> | |
| #include <linux/of.h> | |
| #include <linux/of_gpio.h> | |
| #include <video/mipi_display.h> | |
| #include "fbtft.h" | |
| #include "internal.h" | |
| static unsigned long debug; | |
| module_param(debug, ulong, 0000); | |
| MODULE_PARM_DESC(debug, "override device debug level"); | |
| int fbtft_write_buf_dc(struct fbtft_par *par, void *buf, size_t len, int dc) | |
| { | |
| int ret; | |
| if (gpio_is_valid(par->gpio.dc)) | |
| gpio_set_value(par->gpio.dc, dc); | |
| ret = par->fbtftops.write(par, buf, len); | |
| if (ret < 0) | |
| dev_err(par->info->device, | |
| "write() failed and returned %d\n", ret); | |
| return ret; | |
| } | |
| EXPORT_SYMBOL(fbtft_write_buf_dc); | |
| void fbtft_dbg_hex(const struct device *dev, int groupsize, | |
| void *buf, size_t len, const char *fmt, ...) | |
| { | |
| va_list args; | |
| static char textbuf[512]; | |
| char *text = textbuf; | |
| size_t text_len; | |
| va_start(args, fmt); | |
| text_len = vscnprintf(text, sizeof(textbuf), fmt, args); | |
| va_end(args); | |
| hex_dump_to_buffer(buf, len, 32, groupsize, text + text_len, | |
| 512 - text_len, false); | |
| if (len > 32) | |
| dev_info(dev, "%s ...\n", text); | |
| else | |
| dev_info(dev, "%s\n", text); | |
| } | |
| EXPORT_SYMBOL(fbtft_dbg_hex); | |
| static unsigned long fbtft_request_gpios_match(struct fbtft_par *par, | |
| const struct fbtft_gpio *gpio) | |
| { | |
| int ret; | |
| unsigned int val; | |
| fbtft_par_dbg(DEBUG_REQUEST_GPIOS_MATCH, par, "%s('%s')\n", | |
| __func__, gpio->name); | |
| if (strcasecmp(gpio->name, "reset") == 0) { | |
| par->gpio.reset = gpio->gpio; | |
| return GPIOF_OUT_INIT_HIGH; | |
| } else if (strcasecmp(gpio->name, "dc") == 0) { | |
| par->gpio.dc = gpio->gpio; | |
| return GPIOF_OUT_INIT_LOW; | |
| } else if (strcasecmp(gpio->name, "cs") == 0) { | |
| par->gpio.cs = gpio->gpio; | |
| return GPIOF_OUT_INIT_HIGH; | |
| } else if (strcasecmp(gpio->name, "wr") == 0) { | |
| par->gpio.wr = gpio->gpio; | |
| return GPIOF_OUT_INIT_HIGH; | |
| } else if (strcasecmp(gpio->name, "rd") == 0) { | |
| par->gpio.rd = gpio->gpio; | |
| return GPIOF_OUT_INIT_HIGH; | |
| } else if (strcasecmp(gpio->name, "latch") == 0) { | |
| par->gpio.latch = gpio->gpio; | |
| return GPIOF_OUT_INIT_LOW; | |
| } else if (gpio->name[0] == 'd' && gpio->name[1] == 'b') { | |
| ret = kstrtouint(&gpio->name[2], 10, &val); | |
| if (ret == 0 && val < 16) { | |
| par->gpio.db[val] = gpio->gpio; | |
| return GPIOF_OUT_INIT_LOW; | |
| } | |
| } else if (strcasecmp(gpio->name, "led") == 0) { | |
| par->gpio.led[0] = gpio->gpio; | |
| return GPIOF_OUT_INIT_LOW; | |
| } else if (strcasecmp(gpio->name, "led_") == 0) { | |
| par->gpio.led[0] = gpio->gpio; | |
| return GPIOF_OUT_INIT_HIGH; | |
| } | |
| return FBTFT_GPIO_NO_MATCH; | |
| } | |
| static int fbtft_request_gpios(struct fbtft_par *par) | |
| { | |
| struct fbtft_platform_data *pdata = par->pdata; | |
| const struct fbtft_gpio *gpio; | |
| unsigned long flags; | |
| int ret; | |
| if (!(pdata && pdata->gpios)) | |
| return 0; | |
| gpio = pdata->gpios; | |
| while (gpio->name[0]) { | |
| flags = FBTFT_GPIO_NO_MATCH; | |
| /* if driver provides match function, try it first, | |
| * if no match use our own | |
| */ | |
| if (par->fbtftops.request_gpios_match) | |
| flags = par->fbtftops.request_gpios_match(par, gpio); | |
| if (flags == FBTFT_GPIO_NO_MATCH) | |
| flags = fbtft_request_gpios_match(par, gpio); | |
| if (flags != FBTFT_GPIO_NO_MATCH) { | |
| ret = devm_gpio_request_one(par->info->device, | |
| gpio->gpio, flags, | |
| par->info->device->driver->name); | |
| if (ret < 0) { | |
| dev_err(par->info->device, | |
| "%s: gpio_request_one('%s'=%d) failed with %d\n", | |
| __func__, gpio->name, | |
| gpio->gpio, ret); | |
| return ret; | |
| } | |
| fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, | |
| "%s: '%s' = GPIO%d\n", | |
| __func__, gpio->name, gpio->gpio); | |
| } | |
| gpio++; | |
| } | |
| return 0; | |
| } | |
| #ifdef CONFIG_OF | |
| static int fbtft_request_one_gpio(struct fbtft_par *par, | |
| const char *name, int index, int *gpiop) | |
| { | |
| struct device *dev = par->info->device; | |
| struct device_node *node = dev->of_node; | |
| int gpio, flags, ret = 0; | |
| enum of_gpio_flags of_flags; | |
| if (of_find_property(node, name, NULL)) { | |
| gpio = of_get_named_gpio_flags(node, name, index, &of_flags); | |
| if (gpio == -ENOENT) | |
| return 0; | |
| if (gpio == -EPROBE_DEFER) | |
| return gpio; | |
| if (gpio < 0) { | |
| dev_err(dev, | |
| "failed to get '%s' from DT\n", name); | |
| return gpio; | |
| } | |
| /* active low translates to initially low */ | |
| flags = (of_flags & OF_GPIO_ACTIVE_LOW) ? GPIOF_OUT_INIT_LOW : | |
| GPIOF_OUT_INIT_HIGH; | |
| ret = devm_gpio_request_one(dev, gpio, flags, | |
| dev->driver->name); | |
| if (ret) { | |
| dev_err(dev, | |
| "gpio_request_one('%s'=%d) failed with %d\n", | |
| name, gpio, ret); | |
| return ret; | |
| } | |
| if (gpiop) | |
| *gpiop = gpio; | |
| fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' = GPIO%d\n", | |
| __func__, name, gpio); | |
| } | |
| return ret; | |
| } | |
| static int fbtft_request_gpios_dt(struct fbtft_par *par) | |
| { | |
| int i; | |
| int ret; | |
| if (!par->info->device->of_node) | |
| return -EINVAL; | |
| ret = fbtft_request_one_gpio(par, "reset-gpios", 0, &par->gpio.reset); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "dc-gpios", 0, &par->gpio.dc); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "rd-gpios", 0, &par->gpio.rd); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "wr-gpios", 0, &par->gpio.wr); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "cs-gpios", 0, &par->gpio.cs); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "latch-gpios", 0, &par->gpio.latch); | |
| if (ret) | |
| return ret; | |
| for (i = 0; i < 16; i++) { | |
| ret = fbtft_request_one_gpio(par, "db-gpios", i, | |
| &par->gpio.db[i]); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "led-gpios", i, | |
| &par->gpio.led[i]); | |
| if (ret) | |
| return ret; | |
| ret = fbtft_request_one_gpio(par, "aux-gpios", i, | |
| &par->gpio.aux[i]); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| #endif | |
| #ifdef CONFIG_FB_BACKLIGHT | |
| static int fbtft_backlight_update_status(struct backlight_device *bd) | |
| { | |
| struct fbtft_par *par = bl_get_data(bd); | |
| bool polarity = par->polarity; | |
| fbtft_par_dbg(DEBUG_BACKLIGHT, par, | |
| "%s: polarity=%d, power=%d, fb_blank=%d\n", | |
| __func__, polarity, bd->props.power, bd->props.fb_blank); | |
| if ((bd->props.power == FB_BLANK_UNBLANK) && | |
| (bd->props.fb_blank == FB_BLANK_UNBLANK)) | |
| gpio_set_value(par->gpio.led[0], polarity); | |
| else | |
| gpio_set_value(par->gpio.led[0], !polarity); | |
| return 0; | |
| } | |
| static int fbtft_backlight_get_brightness(struct backlight_device *bd) | |
| { | |
| return bd->props.brightness; | |
| } | |
| void fbtft_unregister_backlight(struct fbtft_par *par) | |
| { | |
| if (par->info->bl_dev) { | |
| par->info->bl_dev->props.power = FB_BLANK_POWERDOWN; | |
| backlight_update_status(par->info->bl_dev); | |
| backlight_device_unregister(par->info->bl_dev); | |
| par->info->bl_dev = NULL; | |
| } | |
| } | |
| static const struct backlight_ops fbtft_bl_ops = { | |
| .get_brightness = fbtft_backlight_get_brightness, | |
| .update_status = fbtft_backlight_update_status, | |
| }; | |
| void fbtft_register_backlight(struct fbtft_par *par) | |
| { | |
| struct backlight_device *bd; | |
| struct backlight_properties bl_props = { 0, }; | |
| if (par->gpio.led[0] == -1) { | |
| fbtft_par_dbg(DEBUG_BACKLIGHT, par, | |
| "%s(): led pin not set, exiting.\n", __func__); | |
| return; | |
| } | |
| bl_props.type = BACKLIGHT_RAW; | |
| /* Assume backlight is off, get polarity from current state of pin */ | |
| bl_props.power = FB_BLANK_POWERDOWN; | |
| if (!gpio_get_value(par->gpio.led[0])) | |
| par->polarity = true; | |
| bd = backlight_device_register(dev_driver_string(par->info->device), | |
| par->info->device, par, | |
| &fbtft_bl_ops, &bl_props); | |
| if (IS_ERR(bd)) { | |
| dev_err(par->info->device, | |
| "cannot register backlight device (%ld)\n", | |
| PTR_ERR(bd)); | |
| return; | |
| } | |
| par->info->bl_dev = bd; | |
| if (!par->fbtftops.unregister_backlight) | |
| par->fbtftops.unregister_backlight = fbtft_unregister_backlight; | |
| } | |
| #else | |
| void fbtft_register_backlight(struct fbtft_par *par) { }; | |
| void fbtft_unregister_backlight(struct fbtft_par *par) { }; | |
| #endif | |
| EXPORT_SYMBOL(fbtft_register_backlight); | |
| EXPORT_SYMBOL(fbtft_unregister_backlight); | |
| static void fbtft_set_addr_win(struct fbtft_par *par, int xs, int ys, int xe, | |
| int ye) | |
| { | |
| write_reg(par, MIPI_DCS_SET_COLUMN_ADDRESS, | |
| (xs >> 8) & 0xFF, xs & 0xFF, (xe >> 8) & 0xFF, xe & 0xFF); | |
| write_reg(par, MIPI_DCS_SET_PAGE_ADDRESS, | |
| (ys >> 8) & 0xFF, ys & 0xFF, (ye >> 8) & 0xFF, ye & 0xFF); | |
| write_reg(par, MIPI_DCS_WRITE_MEMORY_START); | |
| } | |
| static void fbtft_reset(struct fbtft_par *par) | |
| { | |
| if (par->gpio.reset == -1) | |
| return; | |
| fbtft_par_dbg(DEBUG_RESET, par, "%s()\n", __func__); | |
| gpio_set_value_cansleep(par->gpio.reset, 0); | |
| usleep_range(20, 40); | |
| gpio_set_value_cansleep(par->gpio.reset, 1); | |
| msleep(120); | |
| } | |
| static void fbtft_update_display(struct fbtft_par *par, unsigned int start_line, | |
| unsigned int end_line) | |
| { | |
| size_t offset, len; | |
| ktime_t ts_start, ts_end; | |
| long fps, throughput; | |
| bool timeit = false; | |
| int ret = 0; | |
| if (unlikely(par->debug & (DEBUG_TIME_FIRST_UPDATE | | |
| DEBUG_TIME_EACH_UPDATE))) { | |
| if ((par->debug & DEBUG_TIME_EACH_UPDATE) || | |
| ((par->debug & DEBUG_TIME_FIRST_UPDATE) && | |
| !par->first_update_done)) { | |
| ts_start = ktime_get(); | |
| timeit = true; | |
| } | |
| } | |
| /* Sanity checks */ | |
| if (start_line > end_line) { | |
| dev_warn(par->info->device, | |
| "%s: start_line=%u is larger than end_line=%u. Shouldn't happen, will do full display update\n", | |
| __func__, start_line, end_line); | |
| start_line = 0; | |
| end_line = par->info->var.yres - 1; | |
| } | |
| if (start_line > par->info->var.yres - 1 || | |
| end_line > par->info->var.yres - 1) { | |
| dev_warn(par->info->device, | |
| "%s: start_line=%u or end_line=%u is larger than max=%d. Shouldn't happen, will do full display update\n", | |
| __func__, start_line, | |
| end_line, par->info->var.yres - 1); | |
| start_line = 0; | |
| end_line = par->info->var.yres - 1; | |
| } | |
| fbtft_par_dbg(DEBUG_UPDATE_DISPLAY, par, "%s(start_line=%u, end_line=%u)\n", | |
| __func__, start_line, end_line); | |
| if (par->fbtftops.set_addr_win) | |
| par->fbtftops.set_addr_win(par, 0, start_line, | |
| par->info->var.xres - 1, end_line); | |
| offset = start_line * par->info->fix.line_length; | |
| len = (end_line - start_line + 1) * par->info->fix.line_length; | |
| ret = par->fbtftops.write_vmem(par, offset, len); | |
| if (ret < 0) | |
| dev_err(par->info->device, | |
| "%s: write_vmem failed to update display buffer\n", | |
| __func__); | |
| if (unlikely(timeit)) { | |
| ts_end = ktime_get(); | |
| if (!ktime_to_ns(par->update_time)) | |
| par->update_time = ts_start; | |
| fps = ktime_us_delta(ts_start, par->update_time); | |
| par->update_time = ts_start; | |
| fps = fps ? 1000000 / fps : 0; | |
| throughput = ktime_us_delta(ts_end, ts_start); | |
| throughput = throughput ? (len * 1000) / throughput : 0; | |
| throughput = throughput * 1000 / 1024; | |
| dev_info(par->info->device, | |
| "Display update: %ld kB/s, fps=%ld\n", | |
| throughput, fps); | |
| par->first_update_done = true; | |
| } | |
| } | |
| static void fbtft_mkdirty(struct fb_info *info, int y, int height) | |
| { | |
| struct fbtft_par *par = info->par; | |
| struct fb_deferred_io *fbdefio = info->fbdefio; | |
| /* special case, needed ? */ | |
| if (y == -1) { | |
| y = 0; | |
| height = info->var.yres - 1; | |
| } | |
| /* Mark display lines/area as dirty */ | |
| spin_lock(&par->dirty_lock); | |
| if (y < par->dirty_lines_start) | |
| par->dirty_lines_start = y; | |
| if (y + height - 1 > par->dirty_lines_end) | |
| par->dirty_lines_end = y + height - 1; | |
| spin_unlock(&par->dirty_lock); | |
| /* Schedule deferred_io to update display (no-op if already on queue)*/ | |
| schedule_delayed_work(&info->deferred_work, fbdefio->delay); | |
| } | |
| static void fbtft_deferred_io(struct fb_info *info, struct list_head *pagelist) | |
| { | |
| struct fbtft_par *par = info->par; | |
| unsigned int dirty_lines_start, dirty_lines_end; | |
| struct page *page; | |
| unsigned long index; | |
| unsigned int y_low = 0, y_high = 0; | |
| int count = 0; | |
| spin_lock(&par->dirty_lock); | |
| dirty_lines_start = par->dirty_lines_start; | |
| dirty_lines_end = par->dirty_lines_end; | |
| /* set display line markers as clean */ | |
| par->dirty_lines_start = par->info->var.yres - 1; | |
| par->dirty_lines_end = 0; | |
| spin_unlock(&par->dirty_lock); | |
| /* Mark display lines as dirty */ | |
| list_for_each_entry(page, pagelist, lru) { | |
| count++; | |
| index = page->index << PAGE_SHIFT; | |
| y_low = index / info->fix.line_length; | |
| y_high = (index + PAGE_SIZE - 1) / info->fix.line_length; | |
| dev_dbg(info->device, | |
| "page->index=%lu y_low=%d y_high=%d\n", | |
| page->index, y_low, y_high); | |
| if (y_high > info->var.yres - 1) | |
| y_high = info->var.yres - 1; | |
| if (y_low < dirty_lines_start) | |
| dirty_lines_start = y_low; | |
| if (y_high > dirty_lines_end) | |
| dirty_lines_end = y_high; | |
| } | |
| par->fbtftops.update_display(info->par, | |
| dirty_lines_start, dirty_lines_end); | |
| } | |
| static void fbtft_fb_fillrect(struct fb_info *info, | |
| const struct fb_fillrect *rect) | |
| { | |
| struct fbtft_par *par = info->par; | |
| dev_dbg(info->dev, | |
| "%s: dx=%d, dy=%d, width=%d, height=%d\n", | |
| __func__, rect->dx, rect->dy, rect->width, rect->height); | |
| sys_fillrect(info, rect); | |
| par->fbtftops.mkdirty(info, rect->dy, rect->height); | |
| } | |
| static void fbtft_fb_copyarea(struct fb_info *info, | |
| const struct fb_copyarea *area) | |
| { | |
| struct fbtft_par *par = info->par; | |
| dev_dbg(info->dev, | |
| "%s: dx=%d, dy=%d, width=%d, height=%d\n", | |
| __func__, area->dx, area->dy, area->width, area->height); | |
| sys_copyarea(info, area); | |
| par->fbtftops.mkdirty(info, area->dy, area->height); | |
| } | |
| static void fbtft_fb_imageblit(struct fb_info *info, | |
| const struct fb_image *image) | |
| { | |
| struct fbtft_par *par = info->par; | |
| dev_dbg(info->dev, | |
| "%s: dx=%d, dy=%d, width=%d, height=%d\n", | |
| __func__, image->dx, image->dy, image->width, image->height); | |
| sys_imageblit(info, image); | |
| par->fbtftops.mkdirty(info, image->dy, image->height); | |
| } | |
| static ssize_t fbtft_fb_write(struct fb_info *info, const char __user *buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct fbtft_par *par = info->par; | |
| ssize_t res; | |
| dev_dbg(info->dev, | |
| "%s: count=%zd, ppos=%llu\n", __func__, count, *ppos); | |
| res = fb_sys_write(info, buf, count, ppos); | |
| /* TODO: only mark changed area update all for now */ | |
| par->fbtftops.mkdirty(info, -1, 0); | |
| return res; | |
| } | |
| /* from pxafb.c */ | |
| static unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf) | |
| { | |
| chan &= 0xffff; | |
| chan >>= 16 - bf->length; | |
| return chan << bf->offset; | |
| } | |
| static int fbtft_fb_setcolreg(unsigned int regno, unsigned int red, unsigned int green, | |
| unsigned int blue, unsigned int transp, | |
| struct fb_info *info) | |
| { | |
| unsigned int val; | |
| int ret = 1; | |
| dev_dbg(info->dev, | |
| "%s(regno=%u, red=0x%X, green=0x%X, blue=0x%X, trans=0x%X)\n", | |
| __func__, regno, red, green, blue, transp); | |
| switch (info->fix.visual) { | |
| case FB_VISUAL_TRUECOLOR: | |
| if (regno < 16) { | |
| u32 *pal = info->pseudo_palette; | |
| val = chan_to_field(red, &info->var.red); | |
| val |= chan_to_field(green, &info->var.green); | |
| val |= chan_to_field(blue, &info->var.blue); | |
| pal[regno] = val; | |
| ret = 0; | |
| } | |
| break; | |
| } | |
| return ret; | |
| } | |
| static int fbtft_fb_blank(int blank, struct fb_info *info) | |
| { | |
| struct fbtft_par *par = info->par; | |
| int ret = -EINVAL; | |
| dev_dbg(info->dev, "%s(blank=%d)\n", | |
| __func__, blank); | |
| if (!par->fbtftops.blank) | |
| return ret; | |
| switch (blank) { | |
| case FB_BLANK_POWERDOWN: | |
| case FB_BLANK_VSYNC_SUSPEND: | |
| case FB_BLANK_HSYNC_SUSPEND: | |
| case FB_BLANK_NORMAL: | |
| ret = par->fbtftops.blank(par, true); | |
| break; | |
| case FB_BLANK_UNBLANK: | |
| ret = par->fbtftops.blank(par, false); | |
| break; | |
| } | |
| return ret; | |
| } | |
| static void fbtft_merge_fbtftops(struct fbtft_ops *dst, struct fbtft_ops *src) | |
| { | |
| if (src->write) | |
| dst->write = src->write; | |
| if (src->read) | |
| dst->read = src->read; | |
| if (src->write_vmem) | |
| dst->write_vmem = src->write_vmem; | |
| if (src->write_register) | |
| dst->write_register = src->write_register; | |
| if (src->set_addr_win) | |
| dst->set_addr_win = src->set_addr_win; | |
| if (src->reset) | |
| dst->reset = src->reset; | |
| if (src->mkdirty) | |
| dst->mkdirty = src->mkdirty; | |
| if (src->update_display) | |
| dst->update_display = src->update_display; | |
| if (src->init_display) | |
| dst->init_display = src->init_display; | |
| if (src->blank) | |
| dst->blank = src->blank; | |
| if (src->request_gpios_match) | |
| dst->request_gpios_match = src->request_gpios_match; | |
| if (src->request_gpios) | |
| dst->request_gpios = src->request_gpios; | |
| if (src->verify_gpios) | |
| dst->verify_gpios = src->verify_gpios; | |
| if (src->register_backlight) | |
| dst->register_backlight = src->register_backlight; | |
| if (src->unregister_backlight) | |
| dst->unregister_backlight = src->unregister_backlight; | |
| if (src->set_var) | |
| dst->set_var = src->set_var; | |
| if (src->set_gamma) | |
| dst->set_gamma = src->set_gamma; | |
| } | |
| /** | |
| * fbtft_framebuffer_alloc - creates a new frame buffer info structure | |
| * | |
| * @display: pointer to structure describing the display | |
| * @dev: pointer to the device for this fb, this can be NULL | |
| * | |
| * Creates a new frame buffer info structure. | |
| * | |
| * Also creates and populates the following structures: | |
| * info->fbops | |
| * info->fbdefio | |
| * info->pseudo_palette | |
| * par->fbtftops | |
| * par->txbuf | |
| * | |
| * Returns the new structure, or NULL if an error occurred. | |
| * | |
| */ | |
| struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display, | |
| struct device *dev, | |
| struct fbtft_platform_data *pdata) | |
| { | |
| struct fb_info *info; | |
| struct fbtft_par *par; | |
| struct fb_ops *fbops = NULL; | |
| struct fb_deferred_io *fbdefio = NULL; | |
| u8 *vmem = NULL; | |
| void *txbuf = NULL; | |
| void *buf = NULL; | |
| unsigned int width; | |
| unsigned int height; | |
| int txbuflen = display->txbuflen; | |
| unsigned int bpp = display->bpp; | |
| unsigned int fps = display->fps; | |
| int vmem_size, i; | |
| const s16 *init_sequence = display->init_sequence; | |
| char *gamma = display->gamma; | |
| u32 *gamma_curves = NULL; | |
| /* sanity check */ | |
| if (display->gamma_num * display->gamma_len > | |
| FBTFT_GAMMA_MAX_VALUES_TOTAL) { | |
| dev_err(dev, "FBTFT_GAMMA_MAX_VALUES_TOTAL=%d is exceeded\n", | |
| FBTFT_GAMMA_MAX_VALUES_TOTAL); | |
| return NULL; | |
| } | |
| /* defaults */ | |
| if (!fps) | |
| fps = 20; | |
| if (!bpp) | |
| bpp = 16; | |
| if (!pdata) { | |
| dev_err(dev, "platform data is missing\n"); | |
| return NULL; | |
| } | |
| /* override driver values? */ | |
| if (pdata->fps) | |
| fps = pdata->fps; | |
| if (pdata->txbuflen) | |
| txbuflen = pdata->txbuflen; | |
| if (pdata->display.init_sequence) | |
| init_sequence = pdata->display.init_sequence; | |
| if (pdata->gamma) | |
| gamma = pdata->gamma; | |
| if (pdata->display.debug) | |
| display->debug = pdata->display.debug; | |
| if (pdata->display.backlight) | |
| display->backlight = pdata->display.backlight; | |
| if (pdata->display.width) | |
| display->width = pdata->display.width; | |
| if (pdata->display.height) | |
| display->height = pdata->display.height; | |
| if (pdata->display.buswidth) | |
| display->buswidth = pdata->display.buswidth; | |
| if (pdata->display.regwidth) | |
| display->regwidth = pdata->display.regwidth; | |
| display->debug |= debug; | |
| fbtft_expand_debug_value(&display->debug); | |
| switch (pdata->rotate) { | |
| case 90: | |
| case 270: | |
| width = display->height; | |
| height = display->width; | |
| break; | |
| default: | |
| width = display->width; | |
| height = display->height; | |
| } | |
| vmem_size = display->width * display->height * bpp / 8; | |
| vmem = vzalloc(vmem_size); | |
| if (!vmem) | |
| goto alloc_fail; | |
| fbops = devm_kzalloc(dev, sizeof(struct fb_ops), GFP_KERNEL); | |
| if (!fbops) | |
| goto alloc_fail; | |
| fbdefio = devm_kzalloc(dev, sizeof(struct fb_deferred_io), GFP_KERNEL); | |
| if (!fbdefio) | |
| goto alloc_fail; | |
| buf = devm_kzalloc(dev, 128, GFP_KERNEL); | |
| if (!buf) | |
| goto alloc_fail; | |
| if (display->gamma_num && display->gamma_len) { | |
| gamma_curves = devm_kcalloc(dev, | |
| display->gamma_num * | |
| display->gamma_len, | |
| sizeof(gamma_curves[0]), | |
| GFP_KERNEL); | |
| if (!gamma_curves) | |
| goto alloc_fail; | |
| } | |
| info = framebuffer_alloc(sizeof(struct fbtft_par), dev); | |
| if (!info) | |
| goto alloc_fail; | |
| info->screen_buffer = vmem; | |
| info->fbops = fbops; | |
| info->fbdefio = fbdefio; | |
| fbops->owner = dev->driver->owner; | |
| fbops->fb_read = fb_sys_read; | |
| fbops->fb_write = fbtft_fb_write; | |
| fbops->fb_fillrect = fbtft_fb_fillrect; | |
| fbops->fb_copyarea = fbtft_fb_copyarea; | |
| fbops->fb_imageblit = fbtft_fb_imageblit; | |
| fbops->fb_setcolreg = fbtft_fb_setcolreg; | |
| fbops->fb_blank = fbtft_fb_blank; | |
| fbdefio->delay = HZ / fps; | |
| fbdefio->deferred_io = fbtft_deferred_io; | |
| fb_deferred_io_init(info); | |
| snprintf(info->fix.id, sizeof(info->fix.id), "%s", dev->driver->name); | |
| info->fix.type = FB_TYPE_PACKED_PIXELS; | |
| info->fix.visual = FB_VISUAL_TRUECOLOR; | |
| info->fix.xpanstep = 0; | |
| info->fix.ypanstep = 0; | |
| info->fix.ywrapstep = 0; | |
| info->fix.line_length = width * bpp / 8; | |
| info->fix.accel = FB_ACCEL_NONE; | |
| info->fix.smem_len = vmem_size; | |
| info->var.rotate = pdata->rotate; | |
| info->var.xres = width; | |
| info->var.yres = height; | |
| info->var.xres_virtual = info->var.xres; | |
| info->var.yres_virtual = info->var.yres; | |
| info->var.bits_per_pixel = bpp; | |
| info->var.nonstd = 1; | |
| /* RGB565 */ | |
| info->var.red.offset = 11; | |
| info->var.red.length = 5; | |
| info->var.green.offset = 5; | |
| info->var.green.length = 6; | |
| info->var.blue.offset = 0; | |
| info->var.blue.length = 5; | |
| info->var.transp.offset = 0; | |
| info->var.transp.length = 0; | |
| info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB; | |
| par = info->par; | |
| par->info = info; | |
| par->pdata = pdata; | |
| par->debug = display->debug; | |
| par->buf = buf; | |
| spin_lock_init(&par->dirty_lock); | |
| par->bgr = pdata->bgr; | |
| par->startbyte = pdata->startbyte; | |
| par->init_sequence = init_sequence; | |
| par->gamma.curves = gamma_curves; | |
| par->gamma.num_curves = display->gamma_num; | |
| par->gamma.num_values = display->gamma_len; | |
| mutex_init(&par->gamma.lock); | |
| info->pseudo_palette = par->pseudo_palette; | |
| if (par->gamma.curves && gamma) { | |
| if (fbtft_gamma_parse_str(par, par->gamma.curves, gamma, | |
| strlen(gamma))) | |
| goto release_framebuf; | |
| } | |
| /* Transmit buffer */ | |
| if (txbuflen == -1) | |
| txbuflen = vmem_size + 2; /* add in case startbyte is used */ | |
| if (txbuflen >= vmem_size + 2) | |
| txbuflen = 0; | |
| #ifdef __LITTLE_ENDIAN | |
| if ((!txbuflen) && (bpp > 8)) | |
| txbuflen = PAGE_SIZE; /* need buffer for byteswapping */ | |
| #endif | |
| if (txbuflen > 0) { | |
| txbuf = devm_kzalloc(par->info->device, txbuflen, GFP_KERNEL); | |
| if (!txbuf) | |
| goto release_framebuf; | |
| par->txbuf.buf = txbuf; | |
| par->txbuf.len = txbuflen; | |
| } | |
| /* Initialize gpios to disabled */ | |
| par->gpio.reset = -1; | |
| par->gpio.dc = -1; | |
| par->gpio.rd = -1; | |
| par->gpio.wr = -1; | |
| par->gpio.cs = -1; | |
| par->gpio.latch = -1; | |
| for (i = 0; i < 16; i++) { | |
| par->gpio.db[i] = -1; | |
| par->gpio.led[i] = -1; | |
| par->gpio.aux[i] = -1; | |
| } | |
| /* default fbtft operations */ | |
| par->fbtftops.write = fbtft_write_spi; | |
| par->fbtftops.read = fbtft_read_spi; | |
| par->fbtftops.write_vmem = fbtft_write_vmem16_bus8; | |
| par->fbtftops.write_register = fbtft_write_reg8_bus8; | |
| par->fbtftops.set_addr_win = fbtft_set_addr_win; | |
| par->fbtftops.reset = fbtft_reset; | |
| par->fbtftops.mkdirty = fbtft_mkdirty; | |
| par->fbtftops.update_display = fbtft_update_display; | |
| par->fbtftops.request_gpios = fbtft_request_gpios; | |
| if (display->backlight) | |
| par->fbtftops.register_backlight = fbtft_register_backlight; | |
| /* use driver provided functions */ | |
| fbtft_merge_fbtftops(&par->fbtftops, &display->fbtftops); | |
| return info; | |
| release_framebuf: | |
| framebuffer_release(info); | |
| alloc_fail: | |
| vfree(vmem); | |
| return NULL; | |
| } | |
| EXPORT_SYMBOL(fbtft_framebuffer_alloc); | |
| /** | |
| * fbtft_framebuffer_release - frees up all memory used by the framebuffer | |
| * | |
| * @info: frame buffer info structure | |
| * | |
| */ | |
| void fbtft_framebuffer_release(struct fb_info *info) | |
| { | |
| fb_deferred_io_cleanup(info); | |
| vfree(info->screen_buffer); | |
| framebuffer_release(info); | |
| } | |
| EXPORT_SYMBOL(fbtft_framebuffer_release); | |
| /** | |
| * fbtft_register_framebuffer - registers a tft frame buffer device | |
| * @fb_info: frame buffer info structure | |
| * | |
| * Sets SPI driverdata if needed | |
| * Requests needed gpios. | |
| * Initializes display | |
| * Updates display. | |
| * Registers a frame buffer device @fb_info. | |
| * | |
| * Returns negative errno on error, or zero for success. | |
| * | |
| */ | |
| int fbtft_register_framebuffer(struct fb_info *fb_info) | |
| { | |
| int ret; | |
| char text1[50] = ""; | |
| char text2[50] = ""; | |
| struct fbtft_par *par = fb_info->par; | |
| struct spi_device *spi = par->spi; | |
| /* sanity checks */ | |
| if (!par->fbtftops.init_display) { | |
| dev_err(fb_info->device, "missing fbtftops.init_display()\n"); | |
| return -EINVAL; | |
| } | |
| if (spi) | |
| spi_set_drvdata(spi, fb_info); | |
| if (par->pdev) | |
| platform_set_drvdata(par->pdev, fb_info); | |
| ret = par->fbtftops.request_gpios(par); | |
| if (ret < 0) | |
| goto reg_fail; | |
| if (par->fbtftops.verify_gpios) { | |
| ret = par->fbtftops.verify_gpios(par); | |
| if (ret < 0) | |
| goto reg_fail; | |
| } | |
| ret = par->fbtftops.init_display(par); | |
| if (ret < 0) | |
| goto reg_fail; | |
| if (par->fbtftops.set_var) { | |
| ret = par->fbtftops.set_var(par); | |
| if (ret < 0) | |
| goto reg_fail; | |
| } | |
| /* update the entire display */ | |
| par->fbtftops.update_display(par, 0, par->info->var.yres - 1); | |
| if (par->fbtftops.set_gamma && par->gamma.curves) { | |
| ret = par->fbtftops.set_gamma(par, par->gamma.curves); | |
| if (ret) | |
| goto reg_fail; | |
| } | |
| if (par->fbtftops.register_backlight) | |
| par->fbtftops.register_backlight(par); | |
| ret = register_framebuffer(fb_info); | |
| if (ret < 0) | |
| goto reg_fail; | |
| fbtft_sysfs_init(par); | |
| if (par->txbuf.buf && par->txbuf.len >= 1024) | |
| sprintf(text1, ", %zu KiB buffer memory", par->txbuf.len >> 10); | |
| if (spi) | |
| sprintf(text2, ", spi%d.%d at %d MHz", spi->master->bus_num, | |
| spi->chip_select, spi->max_speed_hz / 1000000); | |
| dev_info(fb_info->dev, | |
| "%s frame buffer, %dx%d, %d KiB video memory%s, fps=%lu%s\n", | |
| fb_info->fix.id, fb_info->var.xres, fb_info->var.yres, | |
| fb_info->fix.smem_len >> 10, text1, | |
| HZ / fb_info->fbdefio->delay, text2); | |
| #ifdef CONFIG_FB_BACKLIGHT | |
| /* Turn on backlight if available */ | |
| if (fb_info->bl_dev) { | |
| fb_info->bl_dev->props.power = FB_BLANK_UNBLANK; | |
| fb_info->bl_dev->ops->update_status(fb_info->bl_dev); | |
| } | |
| #endif | |
| return 0; | |
| reg_fail: | |
| if (par->fbtftops.unregister_backlight) | |
| par->fbtftops.unregister_backlight(par); | |
| return ret; | |
| } | |
| EXPORT_SYMBOL(fbtft_register_framebuffer); | |
| /** | |
| * fbtft_unregister_framebuffer - releases a tft frame buffer device | |
| * @fb_info: frame buffer info structure | |
| * | |
| * Frees SPI driverdata if needed | |
| * Frees gpios. | |
| * Unregisters frame buffer device. | |
| * | |
| */ | |
| int fbtft_unregister_framebuffer(struct fb_info *fb_info) | |
| { | |
| struct fbtft_par *par = fb_info->par; | |
| if (par->fbtftops.unregister_backlight) | |
| par->fbtftops.unregister_backlight(par); | |
| fbtft_sysfs_exit(par); | |
| return unregister_framebuffer(fb_info); | |
| } | |
| EXPORT_SYMBOL(fbtft_unregister_framebuffer); | |
| #ifdef CONFIG_OF | |
| /** | |
| * fbtft_init_display_dt() - Device Tree init_display() function | |
| * @par: Driver data | |
| * | |
| * Return: 0 if successful, negative if error | |
| */ | |
| static int fbtft_init_display_dt(struct fbtft_par *par) | |
| { | |
| struct device_node *node = par->info->device->of_node; | |
| struct property *prop; | |
| const __be32 *p; | |
| u32 val; | |
| int buf[64], i, j; | |
| if (!node) | |
| return -EINVAL; | |
| prop = of_find_property(node, "init", NULL); | |
| p = of_prop_next_u32(prop, NULL, &val); | |
| if (!p) | |
| return -EINVAL; | |
| par->fbtftops.reset(par); | |
| if (par->gpio.cs != -1) | |
| gpio_set_value(par->gpio.cs, 0); /* Activate chip */ | |
| while (p) { | |
| if (val & FBTFT_OF_INIT_CMD) { | |
| val &= 0xFFFF; | |
| i = 0; | |
| while (p && !(val & 0xFFFF0000)) { | |
| if (i > 63) { | |
| dev_err(par->info->device, | |
| "%s: Maximum register values exceeded\n", | |
| __func__); | |
| return -EINVAL; | |
| } | |
| buf[i++] = val; | |
| p = of_prop_next_u32(prop, p, &val); | |
| } | |
| /* make debug message */ | |
| fbtft_par_dbg(DEBUG_INIT_DISPLAY, par, | |
| "init: write_register:\n"); | |
| for (j = 0; j < i; j++) | |
| fbtft_par_dbg(DEBUG_INIT_DISPLAY, par, | |
| "buf[%d] = %02X\n", j, buf[j]); | |
| par->fbtftops.write_register(par, i, | |
| buf[0], buf[1], buf[2], buf[3], | |
| buf[4], buf[5], buf[6], buf[7], | |
| buf[8], buf[9], buf[10], buf[11], | |
| buf[12], buf[13], buf[14], buf[15], | |
| buf[16], buf[17], buf[18], buf[19], | |
| buf[20], buf[21], buf[22], buf[23], | |
| buf[24], buf[25], buf[26], buf[27], | |
| buf[28], buf[29], buf[30], buf[31], | |
| buf[32], buf[33], buf[34], buf[35], | |
| buf[36], buf[37], buf[38], buf[39], | |
| buf[40], buf[41], buf[42], buf[43], | |
| buf[44], buf[45], buf[46], buf[47], | |
| buf[48], buf[49], buf[50], buf[51], | |
| buf[52], buf[53], buf[54], buf[55], | |
| buf[56], buf[57], buf[58], buf[59], | |
| buf[60], buf[61], buf[62], buf[63]); | |
| } else if (val & FBTFT_OF_INIT_DELAY) { | |
| fbtft_par_dbg(DEBUG_INIT_DISPLAY, par, | |
| "init: msleep(%u)\n", val & 0xFFFF); | |
| msleep(val & 0xFFFF); | |
| p = of_prop_next_u32(prop, p, &val); | |
| } else { | |
| dev_err(par->info->device, "illegal init value 0x%X\n", | |
| val); | |
| return -EINVAL; | |
| } | |
| } | |
| return 0; | |
| } | |
| #endif | |
| /** | |
| * fbtft_init_display() - Generic init_display() function | |
| * @par: Driver data | |
| * | |
| * Uses par->init_sequence to do the initialization | |
| * | |
| * Return: 0 if successful, negative if error | |
| */ | |
| int fbtft_init_display(struct fbtft_par *par) | |
| { | |
| int buf[64]; | |
| char msg[128]; | |
| char str[16]; | |
| int i = 0; | |
| int j; | |
| /* sanity check */ | |
| if (!par->init_sequence) { | |
| dev_err(par->info->device, | |
| "error: init_sequence is not set\n"); | |
| return -EINVAL; | |
| } | |
| /* make sure stop marker exists */ | |
| for (i = 0; i < FBTFT_MAX_INIT_SEQUENCE; i++) | |
| if (par->init_sequence[i] == -3) | |
| break; | |
| if (i == FBTFT_MAX_INIT_SEQUENCE) { | |
| dev_err(par->info->device, | |
| "missing stop marker at end of init sequence\n"); | |
| return -EINVAL; | |
| } | |
| par->fbtftops.reset(par); | |
| if (par->gpio.cs != -1) | |
| gpio_set_value(par->gpio.cs, 0); /* Activate chip */ | |
| i = 0; | |
| while (i < FBTFT_MAX_INIT_SEQUENCE) { | |
| if (par->init_sequence[i] == -3) { | |
| /* done */ | |
| return 0; | |
| } | |
| if (par->init_sequence[i] >= 0) { | |
| dev_err(par->info->device, | |
| "missing delimiter at position %d\n", i); | |
| return -EINVAL; | |
| } | |
| if (par->init_sequence[i + 1] < 0) { | |
| dev_err(par->info->device, | |
| "missing value after delimiter %d at position %d\n", | |
| par->init_sequence[i], i); | |
| return -EINVAL; | |
| } | |
| switch (par->init_sequence[i]) { | |
| case -1: | |
| i++; | |
| /* make debug message */ | |
| strcpy(msg, ""); | |
| j = i + 1; | |
| while (par->init_sequence[j] >= 0) { | |
| sprintf(str, "0x%02X ", par->init_sequence[j]); | |
| strcat(msg, str); | |
| j++; | |
| } | |
| fbtft_par_dbg(DEBUG_INIT_DISPLAY, par, | |
| "init: write(0x%02X) %s\n", | |
| par->init_sequence[i], msg); | |
| /* Write */ | |
| j = 0; | |
| while (par->init_sequence[i] >= 0) { | |
| if (j > 63) { | |
| dev_err(par->info->device, | |
| "%s: Maximum register values exceeded\n", | |
| __func__); | |
| return -EINVAL; | |
| } | |
| buf[j++] = par->init_sequence[i++]; | |
| } | |
| par->fbtftops.write_register(par, j, | |
| buf[0], buf[1], buf[2], buf[3], | |
| buf[4], buf[5], buf[6], buf[7], | |
| buf[8], buf[9], buf[10], buf[11], | |
| buf[12], buf[13], buf[14], buf[15], | |
| buf[16], buf[17], buf[18], buf[19], | |
| buf[20], buf[21], buf[22], buf[23], | |
| buf[24], buf[25], buf[26], buf[27], | |
| buf[28], buf[29], buf[30], buf[31], | |
| buf[32], buf[33], buf[34], buf[35], | |
| buf[36], buf[37], buf[38], buf[39], | |
| buf[40], buf[41], buf[42], buf[43], | |
| buf[44], buf[45], buf[46], buf[47], | |
| buf[48], buf[49], buf[50], buf[51], | |
| buf[52], buf[53], buf[54], buf[55], | |
| buf[56], buf[57], buf[58], buf[59], | |
| buf[60], buf[61], buf[62], buf[63]); | |
| break; | |
| case -2: | |
| i++; | |
| fbtft_par_dbg(DEBUG_INIT_DISPLAY, par, | |
| "init: mdelay(%d)\n", | |
| par->init_sequence[i]); | |
| mdelay(par->init_sequence[i++]); | |
| break; | |
| default: | |
| dev_err(par->info->device, | |
| "unknown delimiter %d at position %d\n", | |
| par->init_sequence[i], i); | |
| return -EINVAL; | |
| } | |
| } | |
| dev_err(par->info->device, | |
| "%s: something is wrong. Shouldn't get here.\n", __func__); | |
| return -EINVAL; | |
| } | |
| EXPORT_SYMBOL(fbtft_init_display); | |
| /** | |
| * fbtft_verify_gpios() - Generic verify_gpios() function | |
| * @par: Driver data | |
| * | |
| * Uses @spi, @pdev and @buswidth to determine which GPIOs is needed | |
| * | |
| * Return: 0 if successful, negative if error | |
| */ | |
| static int fbtft_verify_gpios(struct fbtft_par *par) | |
| { | |
| struct fbtft_platform_data *pdata = par->pdata; | |
| int i; | |
| fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__); | |
| if (pdata->display.buswidth != 9 && par->startbyte == 0 && | |
| par->gpio.dc < 0) { | |
| dev_err(par->info->device, | |
| "Missing info about 'dc' gpio. Aborting.\n"); | |
| return -EINVAL; | |
| } | |
| if (!par->pdev) | |
| return 0; | |
| if (par->gpio.wr < 0) { | |
| dev_err(par->info->device, "Missing 'wr' gpio. Aborting.\n"); | |
| return -EINVAL; | |
| } | |
| for (i = 0; i < pdata->display.buswidth; i++) { | |
| if (par->gpio.db[i] < 0) { | |
| dev_err(par->info->device, | |
| "Missing 'db%02d' gpio. Aborting.\n", i); | |
| return -EINVAL; | |
| } | |
| } | |
| return 0; | |
| } | |
| #ifdef CONFIG_OF | |
| /* returns 0 if the property is not present */ | |
| static u32 fbtft_of_value(struct device_node *node, const char *propname) | |
| { | |
| int ret; | |
| u32 val = 0; | |
| ret = of_property_read_u32(node, propname, &val); | |
| if (ret == 0) | |
| pr_info("%s: %s = %u\n", __func__, propname, val); | |
| return val; | |
| } | |
| static struct fbtft_platform_data *fbtft_probe_dt(struct device *dev) | |
| { | |
| struct device_node *node = dev->of_node; | |
| struct fbtft_platform_data *pdata; | |
| if (!node) { | |
| dev_err(dev, "Missing platform data or DT\n"); | |
| return ERR_PTR(-EINVAL); | |
| } | |
| pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); | |
| if (!pdata) | |
| return ERR_PTR(-ENOMEM); | |
| pdata->display.width = fbtft_of_value(node, "width"); | |
| pdata->display.height = fbtft_of_value(node, "height"); | |
| pdata->display.regwidth = fbtft_of_value(node, "regwidth"); | |
| pdata->display.buswidth = fbtft_of_value(node, "buswidth"); | |
| pdata->display.backlight = fbtft_of_value(node, "backlight"); | |
| pdata->display.bpp = fbtft_of_value(node, "bpp"); | |
| pdata->display.debug = fbtft_of_value(node, "debug"); | |
| pdata->rotate = fbtft_of_value(node, "rotate"); | |
| pdata->bgr = of_property_read_bool(node, "bgr"); | |
| pdata->fps = fbtft_of_value(node, "fps"); | |
| pdata->txbuflen = fbtft_of_value(node, "txbuflen"); | |
| pdata->startbyte = fbtft_of_value(node, "startbyte"); | |
| of_property_read_string(node, "gamma", (const char **)&pdata->gamma); | |
| if (of_find_property(node, "led-gpios", NULL)) | |
| pdata->display.backlight = 1; | |
| if (of_find_property(node, "init", NULL)) | |
| pdata->display.fbtftops.init_display = fbtft_init_display_dt; | |
| pdata->display.fbtftops.request_gpios = fbtft_request_gpios_dt; | |
| return pdata; | |
| } | |
| #else | |
| static struct fbtft_platform_data *fbtft_probe_dt(struct device *dev) | |
| { | |
| dev_err(dev, "Missing platform data\n"); | |
| return ERR_PTR(-EINVAL); | |
| } | |
| #endif | |
| /** | |
| * fbtft_probe_common() - Generic device probe() helper function | |
| * @display: Display properties | |
| * @sdev: SPI device | |
| * @pdev: Platform device | |
| * | |
| * Allocates, initializes and registers a framebuffer | |
| * | |
| * Either @sdev or @pdev should be NULL | |
| * | |
| * Return: 0 if successful, negative if error | |
| */ | |
| int fbtft_probe_common(struct fbtft_display *display, | |
| struct spi_device *sdev, | |
| struct platform_device *pdev) | |
| { | |
| struct device *dev; | |
| struct fb_info *info; | |
| struct fbtft_par *par; | |
| struct fbtft_platform_data *pdata; | |
| int ret; | |
| if (sdev) | |
| dev = &sdev->dev; | |
| else | |
| dev = &pdev->dev; | |
| if (unlikely(display->debug & DEBUG_DRIVER_INIT_FUNCTIONS)) | |
| dev_info(dev, "%s()\n", __func__); | |
| pdata = dev->platform_data; | |
| if (!pdata) { | |
| pdata = fbtft_probe_dt(dev); | |
| if (IS_ERR(pdata)) | |
| return PTR_ERR(pdata); | |
| } | |
| info = fbtft_framebuffer_alloc(display, dev, pdata); | |
| if (!info) | |
| return -ENOMEM; | |
| par = info->par; | |
| par->spi = sdev; | |
| par->pdev = pdev; | |
| if (display->buswidth == 0) { | |
| dev_err(dev, "buswidth is not set\n"); | |
| return -EINVAL; | |
| } | |
| /* write register functions */ | |
| if (display->regwidth == 8 && display->buswidth == 8) | |
| par->fbtftops.write_register = fbtft_write_reg8_bus8; | |
| else if (display->regwidth == 8 && display->buswidth == 9 && par->spi) | |
| par->fbtftops.write_register = fbtft_write_reg8_bus9; | |
| else if (display->regwidth == 16 && display->buswidth == 8) | |
| par->fbtftops.write_register = fbtft_write_reg16_bus8; | |
| else if (display->regwidth == 16 && display->buswidth == 16) | |
| par->fbtftops.write_register = fbtft_write_reg16_bus16; | |
| else | |
| dev_warn(dev, | |
| "no default functions for regwidth=%d and buswidth=%d\n", | |
| display->regwidth, display->buswidth); | |
| /* write_vmem() functions */ | |
| if (display->buswidth == 8) | |
| par->fbtftops.write_vmem = fbtft_write_vmem16_bus8; | |
| else if (display->buswidth == 9) | |
| par->fbtftops.write_vmem = fbtft_write_vmem16_bus9; | |
| else if (display->buswidth == 16) | |
| par->fbtftops.write_vmem = fbtft_write_vmem16_bus16; | |
| /* GPIO write() functions */ | |
| if (par->pdev) { | |
| if (display->buswidth == 8) | |
| par->fbtftops.write = fbtft_write_gpio8_wr; | |
| else if (display->buswidth == 16) | |
| par->fbtftops.write = fbtft_write_gpio16_wr; | |
| } | |
| /* 9-bit SPI setup */ | |
| if (par->spi && display->buswidth == 9) { | |
| if (par->spi->master->bits_per_word_mask & SPI_BPW_MASK(9)) { | |
| par->spi->bits_per_word = 9; | |
| } else { | |
| dev_warn(&par->spi->dev, | |
| "9-bit SPI not available, emulating using 8-bit.\n"); | |
| /* allocate buffer with room for dc bits */ | |
| par->extra = devm_kzalloc(par->info->device, | |
| par->txbuf.len + | |
| (par->txbuf.len / 8) + 8, | |
| GFP_KERNEL); | |
| if (!par->extra) { | |
| ret = -ENOMEM; | |
| goto out_release; | |
| } | |
| par->fbtftops.write = fbtft_write_spi_emulate_9; | |
| } | |
| } | |
| if (!par->fbtftops.verify_gpios) | |
| par->fbtftops.verify_gpios = fbtft_verify_gpios; | |
| /* make sure we still use the driver provided functions */ | |
| fbtft_merge_fbtftops(&par->fbtftops, &display->fbtftops); | |
| /* use init_sequence if provided */ | |
| if (par->init_sequence) | |
| par->fbtftops.init_display = fbtft_init_display; | |
| /* use platform_data provided functions above all */ | |
| fbtft_merge_fbtftops(&par->fbtftops, &pdata->display.fbtftops); | |
| ret = fbtft_register_framebuffer(info); | |
| if (ret < 0) | |
| goto out_release; | |
| return 0; | |
| out_release: | |
| fbtft_framebuffer_release(info); | |
| return ret; | |
| } | |
| EXPORT_SYMBOL(fbtft_probe_common); | |
| /** | |
| * fbtft_remove_common() - Generic device remove() helper function | |
| * @dev: Device | |
| * @info: Framebuffer | |
| * | |
| * Unregisters and releases the framebuffer | |
| * | |
| * Return: 0 if successful, negative if error | |
| */ | |
| int fbtft_remove_common(struct device *dev, struct fb_info *info) | |
| { | |
| struct fbtft_par *par; | |
| if (!info) | |
| return -EINVAL; | |
| par = info->par; | |
| if (par) | |
| fbtft_par_dbg(DEBUG_DRIVER_INIT_FUNCTIONS, par, | |
| "%s()\n", __func__); | |
| fbtft_unregister_framebuffer(info); | |
| fbtft_framebuffer_release(info); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(fbtft_remove_common); | |
| MODULE_LICENSE("GPL"); |