[deliverable/linux.git] / drivers / staging / fbtft / flexfb.c

/*
 * Generic FB driver for TFT LCD displays
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/vmalloc.h>
#include <linux/gpio.h>
#include <linux/spi/spi.h>
#include <linux/delay.h>

#include "fbtft.h"

#define DRVNAME	    "flexfb"

static char *chip;
module_param(chip, charp, 0);
MODULE_PARM_DESC(chip, "LCD controller");

static unsigned int width;
module_param(width, uint, 0);
MODULE_PARM_DESC(width, "Display width");

static unsigned int height;
module_param(height, uint, 0);
MODULE_PARM_DESC(height, "Display height");

static int init[512];
static int init_num;
module_param_array(init, int, &init_num, 0);
MODULE_PARM_DESC(init, "Init sequence");

static unsigned int setaddrwin;
module_param(setaddrwin, uint, 0);
MODULE_PARM_DESC(setaddrwin, "Which set_addr_win() implementation to use");

static unsigned int buswidth = 8;
module_param(buswidth, uint, 0);
MODULE_PARM_DESC(buswidth, "Width of databus (default: 8)");

static unsigned int regwidth = 8;
module_param(regwidth, uint, 0);
MODULE_PARM_DESC(regwidth, "Width of controller register (default: 8)");

static bool nobacklight;
module_param(nobacklight, bool, 0);
MODULE_PARM_DESC(nobacklight, "Turn off backlight functionality.");

static bool latched;
module_param(latched, bool, 0);
MODULE_PARM_DESC(latched, "Use with latched 16-bit databus");

static int *initp;
static int initp_num;

/* default init sequences */
static int st7735r_init[] = {
-1, 0x01, -2, 150, -1, 0x11, -2, 500, -1, 0xB1, 0x01, 0x2C, 0x2D, -1, 0xB2, 0x01, 0x2C, 0x2D, -1, 0xB3, 0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D,
-1, 0xB4, 0x07, -1, 0xC0, 0xA2, 0x02, 0x84, -1, 0xC1, 0xC5, -1, 0xC2, 0x0A, 0x00, -1, 0xC3, 0x8A, 0x2A, -1, 0xC4, 0x8A, 0xEE, -1, 0xC5, 0x0E,
-1, 0x20, -1, 0x36, 0xC0, -1, 0x3A, 0x05, -1, 0xE0, 0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22, 0x1f, 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10,
-1, 0xE1, 0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e, 0x30, 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10, -1, 0x29, -2, 100, -1, 0x13, -2, 10, -3 };

static int ssd1289_init[] = {
-1, 0x00, 0x0001, -1, 0x03, 0xA8A4, -1, 0x0C, 0x0000, -1, 0x0D, 0x080C, -1, 0x0E, 0x2B00, -1, 0x1E, 0x00B7, -1, 0x01, 0x2B3F, -1, 0x02, 0x0600,
-1, 0x10, 0x0000, -1, 0x11, 0x6070, -1, 0x05, 0x0000, -1, 0x06, 0x0000, -1, 0x16, 0xEF1C, -1, 0x17, 0x0003, -1, 0x07, 0x0233, -1, 0x0B, 0x0000,
-1, 0x0F, 0x0000, -1, 0x41, 0x0000, -1, 0x42, 0x0000, -1, 0x48, 0x0000, -1, 0x49, 0x013F, -1, 0x4A, 0x0000, -1, 0x4B, 0x0000, -1, 0x44, 0xEF00,
-1, 0x45, 0x0000, -1, 0x46, 0x013F, -1, 0x30, 0x0707, -1, 0x31, 0x0204, -1, 0x32, 0x0204, -1, 0x33, 0x0502, -1, 0x34, 0x0507, -1, 0x35, 0x0204,
-1, 0x36, 0x0204, -1, 0x37, 0x0502, -1, 0x3A, 0x0302, -1, 0x3B, 0x0302, -1, 0x23, 0x0000, -1, 0x24, 0x0000, -1, 0x25, 0x8000, -1, 0x4f, 0x0000,
-1, 0x4e, 0x0000, -1, 0x22, -3 };

static int hx8340bn_init[] = {
-1, 0xC1, 0xFF, 0x83, 0x40, -1, 0x11, -2, 150, -1, 0xCA, 0x70, 0x00, 0xD9, -1, 0xB0, 0x01, 0x11,
-1, 0xC9, 0x90, 0x49, 0x10, 0x28, 0x28, 0x10, 0x00, 0x06, -2, 20, -1, 0xC2, 0x60, 0x71, 0x01, 0x0E, 0x05, 0x02, 0x09, 0x31, 0x0A,
-1, 0xC3, 0x67, 0x30, 0x61, 0x17, 0x48, 0x07, 0x05, 0x33, -2, 10, -1, 0xB5, 0x35, 0x20, 0x45, -1, 0xB4, 0x33, 0x25, 0x4C, -2, 10,
-1, 0x3A, 0x05, -1, 0x29, -2, 10, -3 };

static int ili9225_init[] = {
-1, 0x0001, 0x011C, -1, 0x0002, 0x0100, -1, 0x0003, 0x1030, -1, 0x0008, 0x0808, -1, 0x000C, 0x0000, -1, 0x000F, 0x0A01, -1, 0x0020, 0x0000,
-1, 0x0021, 0x0000, -2, 50, -1, 0x0010, 0x0A00, -1, 0x0011, 0x1038, -2, 50, -1, 0x0012, 0x1121, -1, 0x0013, 0x004E, -1, 0x0014, 0x676F,
-1, 0x0030, 0x0000, -1, 0x0031, 0x00DB, -1, 0x0032, 0x0000, -1, 0x0033, 0x0000, -1, 0x0034, 0x00DB, -1, 0x0035, 0x0000, -1, 0x0036, 0x00AF,
-1, 0x0037, 0x0000, -1, 0x0038, 0x00DB, -1, 0x0039, 0x0000, -1, 0x0050, 0x0000, -1, 0x0051, 0x060A, -1, 0x0052, 0x0D0A, -1, 0x0053, 0x0303,
-1, 0x0054, 0x0A0D, -1, 0x0055, 0x0A06, -1, 0x0056, 0x0000, -1, 0x0057, 0x0303, -1, 0x0058, 0x0000, -1, 0x0059, 0x0000, -2, 50,
-1, 0x0007, 0x1017, -2, 50, -3 };

static int ili9320_init[] = {
-1, 0x00E5, 0x8000, -1, 0x0000, 0x0001, -1, 0x0001, 0x0100, -1, 0x0002, 0x0700, -1, 0x0003, 0x1030, -1, 0x0004, 0x0000, -1, 0x0008, 0x0202,
-1, 0x0009, 0x0000, -1, 0x000A, 0x0000, -1, 0x000C, 0x0000, -1, 0x000D, 0x0000, -1, 0x000F, 0x0000, -1, 0x0010, 0x0000, -1, 0x0011, 0x0007,
-1, 0x0012, 0x0000, -1, 0x0013, 0x0000, -2, 200, -1, 0x0010, 0x17B0, -1, 0x0011, 0x0031, -2, 50, -1, 0x0012, 0x0138, -2, 50, -1, 0x0013, 0x1800,
-1, 0x0029, 0x0008, -2, 50, -1, 0x0020, 0x0000, -1, 0x0021, 0x0000, -1, 0x0030, 0x0000, -1, 0x0031, 0x0505, -1, 0x0032, 0x0004,
-1, 0x0035, 0x0006, -1, 0x0036, 0x0707, -1, 0x0037, 0x0105, -1, 0x0038, 0x0002, -1, 0x0039, 0x0707, -1, 0x003C, 0x0704, -1, 0x003D, 0x0807,
-1, 0x0050, 0x0000, -1, 0x0051, 0x00EF, -1, 0x0052, 0x0000, -1, 0x0053, 0x013F, -1, 0x0060, 0x2700, -1, 0x0061, 0x0001, -1, 0x006A, 0x0000,
-1, 0x0080, 0x0000, -1, 0x0081, 0x0000, -1, 0x0082, 0x0000, -1, 0x0083, 0x0000, -1, 0x0084, 0x0000, -1, 0x0085, 0x0000, -1, 0x0090, 0x0010,
-1, 0x0092, 0x0000, -1, 0x0093, 0x0003, -1, 0x0095, 0x0110, -1, 0x0097, 0x0000, -1, 0x0098, 0x0000, -1, 0x0007, 0x0173, -3 };

static int ili9325_init[] = {
-1, 0x00E3, 0x3008, -1, 0x00E7, 0x0012, -1, 0x00EF, 0x1231, -1, 0x0001, 0x0100, -1, 0x0002, 0x0700, -1, 0x0003, 0x1030, -1, 0x0004, 0x0000,
-1, 0x0008, 0x0207, -1, 0x0009, 0x0000, -1, 0x000A, 0x0000, -1, 0x000C, 0x0000, -1, 0x000D, 0x0000, -1, 0x000F, 0x0000, -1, 0x0010, 0x0000,
-1, 0x0011, 0x0007, -1, 0x0012, 0x0000, -1, 0x0013, 0x0000, -2, 200, -1, 0x0010, 0x1690, -1, 0x0011, 0x0223, -2, 50, -1, 0x0012, 0x000D, -2, 50,
-1, 0x0013, 0x1200, -1, 0x0029, 0x000A, -1, 0x002B, 0x000C, -2, 50, -1, 0x0020, 0x0000, -1, 0x0021, 0x0000, -1, 0x0030, 0x0000,
-1, 0x0031, 0x0506, -1, 0x0032, 0x0104, -1, 0x0035, 0x0207, -1, 0x0036, 0x000F, -1, 0x0037, 0x0306, -1, 0x0038, 0x0102, -1, 0x0039, 0x0707,
-1, 0x003C, 0x0702, -1, 0x003D, 0x1604, -1, 0x0050, 0x0000, -1, 0x0051, 0x00EF, -1, 0x0052, 0x0000, -1, 0x0053, 0x013F, -1, 0x0060, 0xA700,
-1, 0x0061, 0x0001, -1, 0x006A, 0x0000, -1, 0x0080, 0x0000, -1, 0x0081, 0x0000, -1, 0x0082, 0x0000, -1, 0x0083, 0x0000, -1, 0x0084, 0x0000,
-1, 0x0085, 0x0000, -1, 0x0090, 0x0010, -1, 0x0092, 0x0600, -1, 0x0007, 0x0133, -3 };

static int ili9341_init[] = {
-1, 0x28, -2, 20, -1, 0xCF, 0x00, 0x83, 0x30, -1, 0xED, 0x64, 0x03, 0x12, 0x81, -1, 0xE8, 0x85, 0x01, 0x79,
-1, 0xCB, 0x39, 0x2c, 0x00, 0x34, 0x02, -1, 0xF7, 0x20, -1, 0xEA, 0x00, 0x00, -1, 0xC0, 0x26, -1, 0xC1, 0x11,
-1, 0xC5, 0x35, 0x3E, -1, 0xC7, 0xBE, -1, 0xB1, 0x00, 0x1B, -1, 0xB6, 0x0a, 0x82, 0x27, 0x00, -1, 0xB7, 0x07,
-1, 0x3A, 0x55, -1, 0x36, 0x48, -1, 0x11, -2, 120, -1, 0x29, -2, 20, -3 };

static int ssd1351_init[] = { -1, 0xfd, 0x12, -1, 0xfd, 0xb1, -1, 0xae, -1, 0xb3, 0xf1, -1, 0xca, 0x7f, -1, 0xa0, 0x74,
			      -1, 0x15, 0x00, 0x7f, -1, 0x75, 0x00, 0x7f, -1, 0xa1, 0x00, -1, 0xa2, 0x00, -1, 0xb5, 0x00,
			      -1, 0xab, 0x01, -1, 0xb1, 0x32, -1, 0xb4, 0xa0, 0xb5, 0x55, -1, 0xbb, 0x17, -1, 0xbe, 0x05,
			      -1, 0xc1, 0xc8, 0x80, 0xc8, -1, 0xc7, 0x0f, -1, 0xb6, 0x01, -1, 0xa6, -1, 0xaf, -3 };

/* ili9320, ili9325 */
static void flexfb_set_addr_win_1(struct fbtft_par *par,
				  int xs, int ys, int xe, int ye)
{
	fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par, "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n",
		      __func__, xs, ys, xe, ye);
	switch (par->info->var.rotate) {
	/* R20h = Horizontal GRAM Start Address */
	/* R21h = Vertical GRAM Start Address */
	case 0:
		write_reg(par, 0x0020, xs);
		write_reg(par, 0x0021, ys);
		break;
	case 180:
		write_reg(par, 0x0020, width - 1 - xs);
		write_reg(par, 0x0021, height - 1 - ys);
		break;
	case 270:
		write_reg(par, 0x0020, width - 1 - ys);
		write_reg(par, 0x0021, xs);
		break;
	case 90:
		write_reg(par, 0x0020, ys);
		write_reg(par, 0x0021, height - 1 - xs);
		break;
	}
	write_reg(par, 0x0022); /* Write Data to GRAM */
}

/* ssd1289 */
static void flexfb_set_addr_win_2(struct fbtft_par *par,
				  int xs, int ys, int xe, int ye)
{
	fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
		      "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n",
		      __func__, xs, ys, xe, ye);

	switch (par->info->var.rotate) {
	/* R4Eh - Set GDDRAM X address counter */
	/* R4Fh - Set GDDRAM Y address counter */
	case 0:
		write_reg(par, 0x4e, xs);
		write_reg(par, 0x4f, ys);
		break;
	case 180:
		write_reg(par, 0x4e, par->info->var.xres - 1 - xs);
		write_reg(par, 0x4f, par->info->var.yres - 1 - ys);
		break;
	case 270:
		write_reg(par, 0x4e, par->info->var.yres - 1 - ys);
		write_reg(par, 0x4f, xs);
		break;
	case 90:
		write_reg(par, 0x4e, ys);
		write_reg(par, 0x4f, par->info->var.xres - 1 - xs);
		break;
	}

	/* R22h - RAM data write */
	write_reg(par, 0x22, 0);
}

/* ssd1351 */
static void set_addr_win_3(struct fbtft_par *par,
			   int xs, int ys, int xe, int ye)
{
	fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
		      "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n", __func__,
		      xs, ys, xe, ye);

	write_reg(par, 0x15, xs, xe);
	write_reg(par, 0x75, ys, ye);
	write_reg(par, 0x5C);
}

static int flexfb_verify_gpios_dc(struct fbtft_par *par)
{
	fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);

	if (par->gpio.dc < 0) {
		dev_err(par->info->device,
			"Missing info about 'dc' gpio. Aborting.\n");
		return -EINVAL;
	}

	return 0;
}

static int flexfb_verify_gpios_db(struct fbtft_par *par)
{
	int i;
	int num_db = buswidth;

	fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);

	if (par->gpio.dc < 0) {
		dev_err(par->info->device, "Missing info about 'dc' gpio. Aborting.\n");
		return -EINVAL;
	}
	if (par->gpio.wr < 0) {
		dev_err(par->info->device, "Missing info about 'wr' gpio. Aborting.\n");
		return -EINVAL;
	}
	if (latched && (par->gpio.latch < 0)) {
		dev_err(par->info->device, "Missing info about 'latch' gpio. Aborting.\n");
		return -EINVAL;
	}
	if (latched)
		num_db = buswidth / 2;
	for (i = 0; i < num_db; i++) {
		if (par->gpio.db[i] < 0) {
			dev_err(par->info->device,
				"Missing info about 'db%02d' gpio. Aborting.\n",
				i);
			return -EINVAL;
		}
	}

	return 0;
}

static struct fbtft_display flex_display = { };

static int flexfb_probe_common(struct spi_device *sdev,
			       struct platform_device *pdev)
{
	struct device *dev;
	struct fb_info *info;
	struct fbtft_par *par;
	int ret;

	initp = init;
	initp_num = init_num;

	if (sdev)
		dev = &sdev->dev;
	else
		dev = &pdev->dev;

	fbtft_init_dbg(dev, "%s(%s)\n", __func__,
		       sdev ? "'SPI device'" : "'Platform device'");

	if (chip) {

		if (!strcmp(chip, "st7735r")) {
			if (!width)
				width = 128;
			if (!height)
				height = 160;
			if (init_num == 0) {
				initp = st7735r_init;
				initp_num = ARRAY_SIZE(st7735r_init);
			}

		} else if (!strcmp(chip, "hx8340bn")) {
			if (!width)
				width = 176;
			if (!height)
				height = 220;
			setaddrwin = 0;
			if (init_num == 0) {
				initp = hx8340bn_init;
				initp_num = ARRAY_SIZE(hx8340bn_init);
			}

		} else if (!strcmp(chip, "ili9225")) {
			if (!width)
				width = 176;
			if (!height)
				height = 220;
			setaddrwin = 0;
			regwidth = 16;
			if (init_num == 0) {
				initp = ili9225_init;
				initp_num = ARRAY_SIZE(ili9225_init);
			}

		} else if (!strcmp(chip, "ili9320")) {
			if (!width)
				width = 240;
			if (!height)
				height = 320;
			setaddrwin = 1;
			regwidth = 16;
			if (init_num == 0) {
				initp = ili9320_init;
				initp_num = ARRAY_SIZE(ili9320_init);
			}

		} else if (!strcmp(chip, "ili9325")) {
			if (!width)
				width = 240;
			if (!height)
				height = 320;
			setaddrwin = 1;
			regwidth = 16;
			if (init_num == 0) {
				initp = ili9325_init;
				initp_num = ARRAY_SIZE(ili9325_init);
			}

		} else if (!strcmp(chip, "ili9341")) {
			if (!width)
				width = 240;
			if (!height)
				height = 320;
			setaddrwin = 0;
			regwidth = 8;
			if (init_num == 0) {
				initp = ili9341_init;
				initp_num = ARRAY_SIZE(ili9341_init);
			}

		} else if (!strcmp(chip, "ssd1289")) {
			if (!width)
				width = 240;
			if (!height)
				height = 320;
			setaddrwin = 2;
			regwidth = 16;
			if (init_num == 0) {
				initp = ssd1289_init;
				initp_num = ARRAY_SIZE(ssd1289_init);
			}

		} else if (!strcmp(chip, "ssd1351")) {
			if (!width)
				width = 128;
			if (!height)
				height = 128;
			setaddrwin = 3;
			if (init_num == 0) {
				initp = ssd1351_init;
				initp_num = ARRAY_SIZE(ssd1351_init);
			}
		} else {
			dev_err(dev, "chip=%s is not supported\n", chip);
			return -EINVAL;
		}
	}

	if (width == 0 || height == 0) {
		dev_err(dev, "argument(s) missing: width and height has to be set.\n");
		return -EINVAL;
	}
	flex_display.width = width;
	flex_display.height = height;
	fbtft_init_dbg(dev, "Display resolution: %dx%d\n", width, height);
	fbtft_init_dbg(dev, "chip = %s\n", chip ? chip : "not set");
	fbtft_init_dbg(dev, "setaddrwin = %d\n", setaddrwin);
	fbtft_init_dbg(dev, "regwidth = %d\n", regwidth);
	fbtft_init_dbg(dev, "buswidth = %d\n", buswidth);

	info = fbtft_framebuffer_alloc(&flex_display, dev, dev->platform_data);
	if (!info)
		return -ENOMEM;

	par = info->par;
	if (sdev)
		par->spi = sdev;
	else
		par->pdev = pdev;
	if (!par->init_sequence)
		par->init_sequence = initp;
	par->fbtftops.init_display = fbtft_init_display;

	/* registerwrite functions */
	switch (regwidth) {
	case 8:
		par->fbtftops.write_register = fbtft_write_reg8_bus8;
		break;
	case 16:
		par->fbtftops.write_register = fbtft_write_reg16_bus8;
		break;
	default:
		dev_err(dev,
			"argument 'regwidth': %d is not supported.\n",
			regwidth);
		return -EINVAL;
	}

	/* bus functions */
	if (sdev) {
		par->fbtftops.write = fbtft_write_spi;
		switch (buswidth) {
		case 8:
			par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
			if (!par->startbyte)
				par->fbtftops.verify_gpios = flexfb_verify_gpios_dc;
			break;
		case 9:
			if (regwidth == 16) {
				dev_err(dev, "argument 'regwidth': %d is not supported with buswidth=%d and SPI.\n", regwidth, buswidth);
				return -EINVAL;
			}
			par->fbtftops.write_register = fbtft_write_reg8_bus9;
			par->fbtftops.write_vmem = fbtft_write_vmem16_bus9;
			sdev->bits_per_word = 9;
			ret = sdev->master->setup(sdev);
			if (ret) {
				dev_warn(dev,
					"9-bit SPI not available, emulating using 8-bit.\n");
				sdev->bits_per_word = 8;
				ret = sdev->master->setup(sdev);
				if (ret)
					goto out_release;
				/* 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;
			}
			break;
		default:
			dev_err(dev, "argument 'buswidth': %d is not supported with SPI.\n", buswidth);
			return -EINVAL;
		}
	} else {
		par->fbtftops.verify_gpios = flexfb_verify_gpios_db;
		switch (buswidth) {
		case 8:
			par->fbtftops.write = fbtft_write_gpio8_wr;
			par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
			break;
		case 16:
			par->fbtftops.write_register = fbtft_write_reg16_bus16;
			if (latched)
				par->fbtftops.write = fbtft_write_gpio16_wr_latched;
			else
				par->fbtftops.write = fbtft_write_gpio16_wr;
			par->fbtftops.write_vmem = fbtft_write_vmem16_bus16;
			break;
		default:
			dev_err(dev, "argument 'buswidth': %d is not supported with parallel.\n", buswidth);
			return -EINVAL;
		}
	}

	/* set_addr_win function */
	switch (setaddrwin) {
	case 0:
		/* use default */
		break;
	case 1:
		par->fbtftops.set_addr_win = flexfb_set_addr_win_1;
		break;
	case 2:
		par->fbtftops.set_addr_win = flexfb_set_addr_win_2;
		break;
	case 3:
		par->fbtftops.set_addr_win = set_addr_win_3;
		break;
	default:
		dev_err(dev, "argument 'setaddrwin': unknown value %d.\n",
			setaddrwin);
		return -EINVAL;
	}

	if (!nobacklight)
		par->fbtftops.register_backlight = fbtft_register_backlight;

	ret = fbtft_register_framebuffer(info);
	if (ret < 0)
		goto out_release;

	return 0;

out_release:
	fbtft_framebuffer_release(info);

	return ret;
}

static int flexfb_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;
}

static int flexfb_probe_spi(struct spi_device *spi)
{
	return flexfb_probe_common(spi, NULL);
}

static int flexfb_remove_spi(struct spi_device *spi)
{
	struct fb_info *info = spi_get_drvdata(spi);

	return flexfb_remove_common(&spi->dev, info);
}

static int flexfb_probe_pdev(struct platform_device *pdev)
{
	return flexfb_probe_common(NULL, pdev);
}

static int flexfb_remove_pdev(struct platform_device *pdev)
{
	struct fb_info *info = platform_get_drvdata(pdev);

	return flexfb_remove_common(&pdev->dev, info);
}

static struct spi_driver flexfb_spi_driver = {
	.driver = {
		.name   = DRVNAME,
		.owner  = THIS_MODULE,
	},
	.probe  = flexfb_probe_spi,
	.remove = flexfb_remove_spi,
};

static const struct platform_device_id flexfb_platform_ids[] = {
	{ "flexpfb", 0 },
	{ },
};

static struct platform_driver flexfb_platform_driver = {
	.driver = {
		.name   = DRVNAME,
	},
	.id_table = flexfb_platform_ids,
	.probe  = flexfb_probe_pdev,
	.remove = flexfb_remove_pdev,
};

static int __init flexfb_init(void)
{
	int ret, ret2;

	ret = spi_register_driver(&flexfb_spi_driver);
	ret2 = platform_driver_register(&flexfb_platform_driver);
	if (ret < 0)
		return ret;
	return ret2;
}

static void __exit flexfb_exit(void)
{
	spi_unregister_driver(&flexfb_spi_driver);
	platform_driver_unregister(&flexfb_platform_driver);
}

/* ------------------------------------------------------------------------- */

module_init(flexfb_init);
module_exit(flexfb_exit);

MODULE_DESCRIPTION("Generic FB driver for TFT LCD displays");
MODULE_AUTHOR("Noralf Tronnes");
MODULE_LICENSE("GPL");
Commit	Line	Data
27837e11 TP	1	/*
	2	* Generic FB driver for TFT LCD displays
	3	*
	4	* Copyright (C) 2013 Noralf Tronnes
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
27837e11 TP	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/kernel.h>
	19	#include <linux/init.h>
	20	#include <linux/vmalloc.h>
	21	#include <linux/gpio.h>
	22	#include <linux/spi/spi.h>
	23	#include <linux/delay.h>
	24
	25	#include "fbtft.h"
	26
	27	#define DRVNAME "flexfb"
	28
462125b4	29	static char *chip;
27837e11 TP	30	module_param(chip, charp, 0);
	31	MODULE_PARM_DESC(chip, "LCD controller");
	32
462125b4	33	static unsigned int width;
27837e11 TP	34	module_param(width, uint, 0);
	35	MODULE_PARM_DESC(width, "Display width");
	36
462125b4	37	static unsigned int height;
27837e11 TP	38	module_param(height, uint, 0);
	39	MODULE_PARM_DESC(height, "Display height");
	40
	41	static int init[512];
462125b4	42	static int init_num;
27837e11 TP	43	module_param_array(init, int, &init_num, 0);
	44	MODULE_PARM_DESC(init, "Init sequence");
	45
462125b4	46	static unsigned int setaddrwin;
27837e11 TP	47	module_param(setaddrwin, uint, 0);
	48	MODULE_PARM_DESC(setaddrwin, "Which set_addr_win() implementation to use");
	49
	50	static unsigned int buswidth = 8;
	51	module_param(buswidth, uint, 0);
	52	MODULE_PARM_DESC(buswidth, "Width of databus (default: 8)");
	53
	54	static unsigned int regwidth = 8;
	55	module_param(regwidth, uint, 0);
	56	MODULE_PARM_DESC(regwidth, "Width of controller register (default: 8)");
	57
462125b4	58	static bool nobacklight;
27837e11 TP	59	module_param(nobacklight, bool, 0);
	60	MODULE_PARM_DESC(nobacklight, "Turn off backlight functionality.");
	61
462125b4	62	static bool latched;
27837e11 TP	63	module_param(latched, bool, 0);
	64	MODULE_PARM_DESC(latched, "Use with latched 16-bit databus");
	65
462125b4 MS	66	static int *initp;
462125b4 MS	67	static int initp_num;
27837e11 TP	68
27837e11 TP	69	/* default init sequences */
6684d0c4 AG	70	static int st7735r_init[] = {
	71	-1, 0x01, -2, 150, -1, 0x11, -2, 500, -1, 0xB1, 0x01, 0x2C, 0x2D, -1, 0xB2, 0x01, 0x2C, 0x2D, -1, 0xB3, 0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D,
	72	-1, 0xB4, 0x07, -1, 0xC0, 0xA2, 0x02, 0x84, -1, 0xC1, 0xC5, -1, 0xC2, 0x0A, 0x00, -1, 0xC3, 0x8A, 0x2A, -1, 0xC4, 0x8A, 0xEE, -1, 0xC5, 0x0E,
	73	-1, 0x20, -1, 0x36, 0xC0, -1, 0x3A, 0x05, -1, 0xE0, 0x0f, 0x1a, 0x0f, 0x18, 0x2f, 0x28, 0x20, 0x22, 0x1f, 0x1b, 0x23, 0x37, 0x00, 0x07, 0x02, 0x10,
	74	-1, 0xE1, 0x0f, 0x1b, 0x0f, 0x17, 0x33, 0x2c, 0x29, 0x2e, 0x30, 0x30, 0x39, 0x3f, 0x00, 0x07, 0x03, 0x10, -1, 0x29, -2, 100, -1, 0x13, -2, 10, -3 };
	75
	76	static int ssd1289_init[] = {
	77	-1, 0x00, 0x0001, -1, 0x03, 0xA8A4, -1, 0x0C, 0x0000, -1, 0x0D, 0x080C, -1, 0x0E, 0x2B00, -1, 0x1E, 0x00B7, -1, 0x01, 0x2B3F, -1, 0x02, 0x0600,
	78	-1, 0x10, 0x0000, -1, 0x11, 0x6070, -1, 0x05, 0x0000, -1, 0x06, 0x0000, -1, 0x16, 0xEF1C, -1, 0x17, 0x0003, -1, 0x07, 0x0233, -1, 0x0B, 0x0000,
	79	-1, 0x0F, 0x0000, -1, 0x41, 0x0000, -1, 0x42, 0x0000, -1, 0x48, 0x0000, -1, 0x49, 0x013F, -1, 0x4A, 0x0000, -1, 0x4B, 0x0000, -1, 0x44, 0xEF00,
	80	-1, 0x45, 0x0000, -1, 0x46, 0x013F, -1, 0x30, 0x0707, -1, 0x31, 0x0204, -1, 0x32, 0x0204, -1, 0x33, 0x0502, -1, 0x34, 0x0507, -1, 0x35, 0x0204,
	81	-1, 0x36, 0x0204, -1, 0x37, 0x0502, -1, 0x3A, 0x0302, -1, 0x3B, 0x0302, -1, 0x23, 0x0000, -1, 0x24, 0x0000, -1, 0x25, 0x8000, -1, 0x4f, 0x0000,
	82	-1, 0x4e, 0x0000, -1, 0x22, -3 };
	83
	84	static int hx8340bn_init[] = {
	85	-1, 0xC1, 0xFF, 0x83, 0x40, -1, 0x11, -2, 150, -1, 0xCA, 0x70, 0x00, 0xD9, -1, 0xB0, 0x01, 0x11,
	86	-1, 0xC9, 0x90, 0x49, 0x10, 0x28, 0x28, 0x10, 0x00, 0x06, -2, 20, -1, 0xC2, 0x60, 0x71, 0x01, 0x0E, 0x05, 0x02, 0x09, 0x31, 0x0A,
	87	-1, 0xC3, 0x67, 0x30, 0x61, 0x17, 0x48, 0x07, 0x05, 0x33, -2, 10, -1, 0xB5, 0x35, 0x20, 0x45, -1, 0xB4, 0x33, 0x25, 0x4C, -2, 10,
	88	-1, 0x3A, 0x05, -1, 0x29, -2, 10, -3 };
	89
	90	static int ili9225_init[] = {
	91	-1, 0x0001, 0x011C, -1, 0x0002, 0x0100, -1, 0x0003, 0x1030, -1, 0x0008, 0x0808, -1, 0x000C, 0x0000, -1, 0x000F, 0x0A01, -1, 0x0020, 0x0000,
	92	-1, 0x0021, 0x0000, -2, 50, -1, 0x0010, 0x0A00, -1, 0x0011, 0x1038, -2, 50, -1, 0x0012, 0x1121, -1, 0x0013, 0x004E, -1, 0x0014, 0x676F,
	93	-1, 0x0030, 0x0000, -1, 0x0031, 0x00DB, -1, 0x0032, 0x0000, -1, 0x0033, 0x0000, -1, 0x0034, 0x00DB, -1, 0x0035, 0x0000, -1, 0x0036, 0x00AF,
	94	-1, 0x0037, 0x0000, -1, 0x0038, 0x00DB, -1, 0x0039, 0x0000, -1, 0x0050, 0x0000, -1, 0x0051, 0x060A, -1, 0x0052, 0x0D0A, -1, 0x0053, 0x0303,
	95	-1, 0x0054, 0x0A0D, -1, 0x0055, 0x0A06, -1, 0x0056, 0x0000, -1, 0x0057, 0x0303, -1, 0x0058, 0x0000, -1, 0x0059, 0x0000, -2, 50,
	96	-1, 0x0007, 0x1017, -2, 50, -3 };
	97
	98	static int ili9320_init[] = {
	99	-1, 0x00E5, 0x8000, -1, 0x0000, 0x0001, -1, 0x0001, 0x0100, -1, 0x0002, 0x0700, -1, 0x0003, 0x1030, -1, 0x0004, 0x0000, -1, 0x0008, 0x0202,
	100	-1, 0x0009, 0x0000, -1, 0x000A, 0x0000, -1, 0x000C, 0x0000, -1, 0x000D, 0x0000, -1, 0x000F, 0x0000, -1, 0x0010, 0x0000, -1, 0x0011, 0x0007,
	101	-1, 0x0012, 0x0000, -1, 0x0013, 0x0000, -2, 200, -1, 0x0010, 0x17B0, -1, 0x0011, 0x0031, -2, 50, -1, 0x0012, 0x0138, -2, 50, -1, 0x0013, 0x1800,
	102	-1, 0x0029, 0x0008, -2, 50, -1, 0x0020, 0x0000, -1, 0x0021, 0x0000, -1, 0x0030, 0x0000, -1, 0x0031, 0x0505, -1, 0x0032, 0x0004,
	103	-1, 0x0035, 0x0006, -1, 0x0036, 0x0707, -1, 0x0037, 0x0105, -1, 0x0038, 0x0002, -1, 0x0039, 0x0707, -1, 0x003C, 0x0704, -1, 0x003D, 0x0807,
	104	-1, 0x0050, 0x0000, -1, 0x0051, 0x00EF, -1, 0x0052, 0x0000, -1, 0x0053, 0x013F, -1, 0x0060, 0x2700, -1, 0x0061, 0x0001, -1, 0x006A, 0x0000,
	105	-1, 0x0080, 0x0000, -1, 0x0081, 0x0000, -1, 0x0082, 0x0000, -1, 0x0083, 0x0000, -1, 0x0084, 0x0000, -1, 0x0085, 0x0000, -1, 0x0090, 0x0010,
	106	-1, 0x0092, 0x0000, -1, 0x0093, 0x0003, -1, 0x0095, 0x0110, -1, 0x0097, 0x0000, -1, 0x0098, 0x0000, -1, 0x0007, 0x0173, -3 };
	107
	108	static int ili9325_init[] = {
	109	-1, 0x00E3, 0x3008, -1, 0x00E7, 0x0012, -1, 0x00EF, 0x1231, -1, 0x0001, 0x0100, -1, 0x0002, 0x0700, -1, 0x0003, 0x1030, -1, 0x0004, 0x0000,
	110	-1, 0x0008, 0x0207, -1, 0x0009, 0x0000, -1, 0x000A, 0x0000, -1, 0x000C, 0x0000, -1, 0x000D, 0x0000, -1, 0x000F, 0x0000, -1, 0x0010, 0x0000,
	111	-1, 0x0011, 0x0007, -1, 0x0012, 0x0000, -1, 0x0013, 0x0000, -2, 200, -1, 0x0010, 0x1690, -1, 0x0011, 0x0223, -2, 50, -1, 0x0012, 0x000D, -2, 50,
	112	-1, 0x0013, 0x1200, -1, 0x0029, 0x000A, -1, 0x002B, 0x000C, -2, 50, -1, 0x0020, 0x0000, -1, 0x0021, 0x0000, -1, 0x0030, 0x0000,
	113	-1, 0x0031, 0x0506, -1, 0x0032, 0x0104, -1, 0x0035, 0x0207, -1, 0x0036, 0x000F, -1, 0x0037, 0x0306, -1, 0x0038, 0x0102, -1, 0x0039, 0x0707,
	114	-1, 0x003C, 0x0702, -1, 0x003D, 0x1604, -1, 0x0050, 0x0000, -1, 0x0051, 0x00EF, -1, 0x0052, 0x0000, -1, 0x0053, 0x013F, -1, 0x0060, 0xA700,
	115	-1, 0x0061, 0x0001, -1, 0x006A, 0x0000, -1, 0x0080, 0x0000, -1, 0x0081, 0x0000, -1, 0x0082, 0x0000, -1, 0x0083, 0x0000, -1, 0x0084, 0x0000,
	116	-1, 0x0085, 0x0000, -1, 0x0090, 0x0010, -1, 0x0092, 0x0600, -1, 0x0007, 0x0133, -3 };
	117
	118	static int ili9341_init[] = {
	119	-1, 0x28, -2, 20, -1, 0xCF, 0x00, 0x83, 0x30, -1, 0xED, 0x64, 0x03, 0x12, 0x81, -1, 0xE8, 0x85, 0x01, 0x79,
	120	-1, 0xCB, 0x39, 0x2c, 0x00, 0x34, 0x02, -1, 0xF7, 0x20, -1, 0xEA, 0x00, 0x00, -1, 0xC0, 0x26, -1, 0xC1, 0x11,
	121	-1, 0xC5, 0x35, 0x3E, -1, 0xC7, 0xBE, -1, 0xB1, 0x00, 0x1B, -1, 0xB6, 0x0a, 0x82, 0x27, 0x00, -1, 0xB7, 0x07,
	122	-1, 0x3A, 0x55, -1, 0x36, 0x48, -1, 0x11, -2, 120, -1, 0x29, -2, 20, -3 };
	123
	124	static int ssd1351_init[] = { -1, 0xfd, 0x12, -1, 0xfd, 0xb1, -1, 0xae, -1, 0xb3, 0xf1, -1, 0xca, 0x7f, -1, 0xa0, 0x74,
	125	-1, 0x15, 0x00, 0x7f, -1, 0x75, 0x00, 0x7f, -1, 0xa1, 0x00, -1, 0xa2, 0x00, -1, 0xb5, 0x00,
	126	-1, 0xab, 0x01, -1, 0xb1, 0x32, -1, 0xb4, 0xa0, 0xb5, 0x55, -1, 0xbb, 0x17, -1, 0xbe, 0x05,
	127	-1, 0xc1, 0xc8, 0x80, 0xc8, -1, 0xc7, 0x0f, -1, 0xb6, 0x01, -1, 0xa6, -1, 0xaf, -3 };
27837e11	128
27837e11	129	/* ili9320, ili9325 */
3c588452 AG	130	static void flexfb_set_addr_win_1(struct fbtft_par *par,
3c588452 AG	131	int xs, int ys, int xe, int ye)
27837e11	132	{
4906c43a FF	133	fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par, "%s(xs=%d, ys=%d, xe=%d, ye=%d)\n",
4906c43a FF	134	__func__, xs, ys, xe, ye);
27837e11 TP	135	switch (par->info->var.rotate) {
	136	/* R20h = Horizontal GRAM Start Address */
	137	/* R21h = Vertical GRAM Start Address */
	138	case 0:
	139	write_reg(par, 0x0020, xs);
	140	write_reg(par, 0x0021, ys);
	141	break;
	142	case 180:
	143	write_reg(par, 0x0020, width - 1 - xs);
	144	write_reg(par, 0x0021, height - 1 - ys);
	145	break;
	146	case 270:
	147	write_reg(par, 0x0020, width - 1 - ys);
	148	write_reg(par, 0x0021, xs);
	149	break;
	150	case 90:
	151	write_reg(par, 0x0020, ys);
	152	write_reg(par, 0x0021, height - 1 - xs);
	153	break;
	154	}
	155	write_reg(par, 0x0022); /* Write Data to GRAM */
	156	}
	157
	158	/* ssd1289 */
3c588452 AG	159	static void flexfb_set_addr_win_2(struct fbtft_par *par,
3c588452 AG	160	int xs, int ys, int xe, int ye)
27837e11	161	{
3c588452 AG	162	fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
	163	"%s(xs=%d, ys=%d, xe=%d, ye=%d)\n",
	164	__func__, xs, ys, xe, ye);
27837e11 TP	165
	166	switch (par->info->var.rotate) {
	167	/* R4Eh - Set GDDRAM X address counter */
	168	/* R4Fh - Set GDDRAM Y address counter */
	169	case 0:
	170	write_reg(par, 0x4e, xs);
	171	write_reg(par, 0x4f, ys);
	172	break;
	173	case 180:
	174	write_reg(par, 0x4e, par->info->var.xres - 1 - xs);
	175	write_reg(par, 0x4f, par->info->var.yres - 1 - ys);
	176	break;
	177	case 270:
	178	write_reg(par, 0x4e, par->info->var.yres - 1 - ys);
	179	write_reg(par, 0x4f, xs);
	180	break;
	181	case 90:
	182	write_reg(par, 0x4e, ys);
	183	write_reg(par, 0x4f, par->info->var.xres - 1 - xs);
	184	break;
	185	}
	186
	187	/* R22h - RAM data write */
	188	write_reg(par, 0x22, 0);
	189	}
	190
	191	/* ssd1351 */
3c588452 AG	192	static void set_addr_win_3(struct fbtft_par *par,
3c588452 AG	193	int xs, int ys, int xe, int ye)
27837e11	194	{
3c588452 AG	195	fbtft_par_dbg(DEBUG_SET_ADDR_WIN, par,
	196	"%s(xs=%d, ys=%d, xe=%d, ye=%d)\n", __func__,
	197	xs, ys, xe, ye);
27837e11 TP	198
	199	write_reg(par, 0x15, xs, xe);
	200	write_reg(par, 0x75, ys, ye);
	201	write_reg(par, 0x5C);
	202	}
	203
	204	static int flexfb_verify_gpios_dc(struct fbtft_par *par)
	205	{
	206	fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
	207
	208	if (par->gpio.dc < 0) {
3c588452 AG	209	dev_err(par->info->device,
3c588452 AG	210	"Missing info about 'dc' gpio. Aborting.\n");
27837e11 TP	211	return -EINVAL;
	212	}
	213
	214	return 0;
	215	}
	216
	217	static int flexfb_verify_gpios_db(struct fbtft_par *par)
	218	{
	219	int i;
	220	int num_db = buswidth;
	221
	222	fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
	223
	224	if (par->gpio.dc < 0) {
	225	dev_err(par->info->device, "Missing info about 'dc' gpio. Aborting.\n");
	226	return -EINVAL;
	227	}
	228	if (par->gpio.wr < 0) {
	229	dev_err(par->info->device, "Missing info about 'wr' gpio. Aborting.\n");
	230	return -EINVAL;
	231	}
	232	if (latched && (par->gpio.latch < 0)) {
	233	dev_err(par->info->device, "Missing info about 'latch' gpio. Aborting.\n");
	234	return -EINVAL;
	235	}
	236	if (latched)
a1bf5205	237	num_db = buswidth / 2;
1e6acab0	238	for (i = 0; i < num_db; i++) {
27837e11	239	if (par->gpio.db[i] < 0) {
3c588452 AG	240	dev_err(par->info->device,
	241	"Missing info about 'db%02d' gpio. Aborting.\n",
	242	i);
27837e11 TP	243	return -EINVAL;
	244	}
	245	}
	246
	247	return 0;
	248	}
	249
	250	static struct fbtft_display flex_display = { };
	251
3c588452 AG	252	static int flexfb_probe_common(struct spi_device *sdev,
3c588452 AG	253	struct platform_device *pdev)
27837e11 TP	254	{
	255	struct device *dev;
	256	struct fb_info *info;
	257	struct fbtft_par *par;
	258	int ret;
	259
	260	initp = init;
	261	initp_num = init_num;
	262
	263	if (sdev)
	264	dev = &sdev->dev;
	265	else
	266	dev = &pdev->dev;
	267
3c588452 AG	268	fbtft_init_dbg(dev, "%s(%s)\n", __func__,
3c588452 AG	269	sdev ? "'SPI device'" : "'Platform device'");
27837e11 TP	270
	271	if (chip) {
	272
	273	if (!strcmp(chip, "st7735r")) {
	274	if (!width)
	275	width = 128;
	276	if (!height)
	277	height = 160;
	278	if (init_num == 0) {
	279	initp = st7735r_init;
	280	initp_num = ARRAY_SIZE(st7735r_init);
	281	}
	282
27837e11 TP	283	} else if (!strcmp(chip, "hx8340bn")) {
	284	if (!width)
	285	width = 176;
	286	if (!height)
	287	height = 220;
	288	setaddrwin = 0;
	289	if (init_num == 0) {
	290	initp = hx8340bn_init;
	291	initp_num = ARRAY_SIZE(hx8340bn_init);
	292	}
	293
27837e11 TP	294	} else if (!strcmp(chip, "ili9225")) {
	295	if (!width)
	296	width = 176;
	297	if (!height)
	298	height = 220;
	299	setaddrwin = 0;
	300	regwidth = 16;
	301	if (init_num == 0) {
	302	initp = ili9225_init;
	303	initp_num = ARRAY_SIZE(ili9225_init);
	304	}
	305
27837e11 TP	306	} else if (!strcmp(chip, "ili9320")) {
	307	if (!width)
	308	width = 240;
	309	if (!height)
	310	height = 320;
	311	setaddrwin = 1;
	312	regwidth = 16;
	313	if (init_num == 0) {
	314	initp = ili9320_init;
	315	initp_num = ARRAY_SIZE(ili9320_init);
	316	}
	317
27837e11 TP	318	} else if (!strcmp(chip, "ili9325")) {
	319	if (!width)
	320	width = 240;
	321	if (!height)
	322	height = 320;
	323	setaddrwin = 1;
	324	regwidth = 16;
	325	if (init_num == 0) {
	326	initp = ili9325_init;
	327	initp_num = ARRAY_SIZE(ili9325_init);
	328	}
	329
	330	} else if (!strcmp(chip, "ili9341")) {
	331	if (!width)
	332	width = 240;
	333	if (!height)
	334	height = 320;
	335	setaddrwin = 0;
	336	regwidth = 8;
	337	if (init_num == 0) {
	338	initp = ili9341_init;
	339	initp_num = ARRAY_SIZE(ili9341_init);
	340	}
	341
27837e11 TP	342	} else if (!strcmp(chip, "ssd1289")) {
	343	if (!width)
	344	width = 240;
	345	if (!height)
	346	height = 320;
	347	setaddrwin = 2;
	348	regwidth = 16;
	349	if (init_num == 0) {
	350	initp = ssd1289_init;
	351	initp_num = ARRAY_SIZE(ssd1289_init);
	352	}
	353
27837e11 TP	354	} else if (!strcmp(chip, "ssd1351")) {
	355	if (!width)
	356	width = 128;
	357	if (!height)
	358	height = 128;
	359	setaddrwin = 3;
	360	if (init_num == 0) {
	361	initp = ssd1351_init;
	362	initp_num = ARRAY_SIZE(ssd1351_init);
	363	}
	364	} else {
	365	dev_err(dev, "chip=%s is not supported\n", chip);
	366	return -EINVAL;
	367	}
	368	}
	369
	370	if (width == 0 \|\| height == 0) {
	371	dev_err(dev, "argument(s) missing: width and height has to be set.\n");
	372	return -EINVAL;
	373	}
	374	flex_display.width = width;
	375	flex_display.height = height;
	376	fbtft_init_dbg(dev, "Display resolution: %dx%d\n", width, height);
	377	fbtft_init_dbg(dev, "chip = %s\n", chip ? chip : "not set");
	378	fbtft_init_dbg(dev, "setaddrwin = %d\n", setaddrwin);
	379	fbtft_init_dbg(dev, "regwidth = %d\n", regwidth);
	380	fbtft_init_dbg(dev, "buswidth = %d\n", buswidth);
	381
ad6d8812	382	info = fbtft_framebuffer_alloc(&flex_display, dev, dev->platform_data);
27837e11 TP	383	if (!info)
	384	return -ENOMEM;
	385
	386	par = info->par;
	387	if (sdev)
	388	par->spi = sdev;
	389	else
	390	par->pdev = pdev;
	391	if (!par->init_sequence)
	392	par->init_sequence = initp;
	393	par->fbtftops.init_display = fbtft_init_display;
	394
	395	/* registerwrite functions */
	396	switch (regwidth) {
	397	case 8:
	398	par->fbtftops.write_register = fbtft_write_reg8_bus8;
	399	break;
	400	case 16:
	401	par->fbtftops.write_register = fbtft_write_reg16_bus8;
	402	break;
	403	default:
3c588452 AG	404	dev_err(dev,
	405	"argument 'regwidth': %d is not supported.\n",
	406	regwidth);
27837e11 TP	407	return -EINVAL;
	408	}
	409
	410	/* bus functions */
	411	if (sdev) {
	412	par->fbtftops.write = fbtft_write_spi;
	413	switch (buswidth) {
	414	case 8:
	415	par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
	416	if (!par->startbyte)
	417	par->fbtftops.verify_gpios = flexfb_verify_gpios_dc;
	418	break;
	419	case 9:
	420	if (regwidth == 16) {
	421	dev_err(dev, "argument 'regwidth': %d is not supported with buswidth=%d and SPI.\n", regwidth, buswidth);
	422	return -EINVAL;
	423	}
	424	par->fbtftops.write_register = fbtft_write_reg8_bus9;
	425	par->fbtftops.write_vmem = fbtft_write_vmem16_bus9;
1f5f636c	426	sdev->bits_per_word = 9;
27837e11 TP	427	ret = sdev->master->setup(sdev);
	428	if (ret) {
	429	dev_warn(dev,
	430	"9-bit SPI not available, emulating using 8-bit.\n");
	431	sdev->bits_per_word = 8;
	432	ret = sdev->master->setup(sdev);
	433	if (ret)
	434	goto out_release;
	435	/* allocate buffer with room for dc bits */
	436	par->extra = devm_kzalloc(par->info->device,
	437	par->txbuf.len + (par->txbuf.len / 8) + 8,
	438	GFP_KERNEL);
	439	if (!par->extra) {
	440	ret = -ENOMEM;
	441	goto out_release;
	442	}
	443	par->fbtftops.write = fbtft_write_spi_emulate_9;
	444	}
	445	break;
	446	default:
	447	dev_err(dev, "argument 'buswidth': %d is not supported with SPI.\n", buswidth);
	448	return -EINVAL;
	449	}
	450	} else {
	451	par->fbtftops.verify_gpios = flexfb_verify_gpios_db;
	452	switch (buswidth) {
	453	case 8:
	454	par->fbtftops.write = fbtft_write_gpio8_wr;
	455	par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
	456	break;
	457	case 16:
	458	par->fbtftops.write_register = fbtft_write_reg16_bus16;
	459	if (latched)
	460	par->fbtftops.write = fbtft_write_gpio16_wr_latched;
	461	else
	462	par->fbtftops.write = fbtft_write_gpio16_wr;
	463	par->fbtftops.write_vmem = fbtft_write_vmem16_bus16;
	464	break;
	465	default:
	466	dev_err(dev, "argument 'buswidth': %d is not supported with parallel.\n", buswidth);
	467	return -EINVAL;
	468	}
	469	}
	470
	471	/* set_addr_win function */
	472	switch (setaddrwin) {
	473	case 0:
	474	/* use default */
	475	break;
	476	case 1:
	477	par->fbtftops.set_addr_win = flexfb_set_addr_win_1;
	478	break;
	479	case 2:
	480	par->fbtftops.set_addr_win = flexfb_set_addr_win_2;
	481	break;
	482	case 3:
	483	par->fbtftops.set_addr_win = set_addr_win_3;
	484	break;
	485	default:
3c588452 AG	486	dev_err(dev, "argument 'setaddrwin': unknown value %d.\n",
3c588452 AG	487	setaddrwin);
27837e11 TP	488	return -EINVAL;
	489	}
	490
	491	if (!nobacklight)
	492	par->fbtftops.register_backlight = fbtft_register_backlight;
	493
	494	ret = fbtft_register_framebuffer(info);
	495	if (ret < 0)
	496	goto out_release;
	497
	498	return 0;
	499
	500	out_release:
	501	fbtft_framebuffer_release(info);
	502
	503	return ret;
	504	}
	505
	506	static int flexfb_remove_common(struct device dev, struct fb_info info)
	507	{
	508	struct fbtft_par *par;
	509
	510	if (!info)
	511	return -EINVAL;
	512	par = info->par;
	513	if (par)
4906c43a FF	514	fbtft_par_dbg(DEBUG_DRIVER_INIT_FUNCTIONS, par, "%s()\n",
4906c43a FF	515	__func__);
27837e11 TP	516	fbtft_unregister_framebuffer(info);
	517	fbtft_framebuffer_release(info);
	518
	519	return 0;
	520	}
	521
	522	static int flexfb_probe_spi(struct spi_device *spi)
	523	{
	524	return flexfb_probe_common(spi, NULL);
	525	}
	526
	527	static int flexfb_remove_spi(struct spi_device *spi)
	528	{
	529	struct fb_info *info = spi_get_drvdata(spi);
	530
	531	return flexfb_remove_common(&spi->dev, info);
	532	}
	533
	534	static int flexfb_probe_pdev(struct platform_device *pdev)
	535	{
	536	return flexfb_probe_common(NULL, pdev);
	537	}
	538
	539	static int flexfb_remove_pdev(struct platform_device *pdev)
	540	{
	541	struct fb_info *info = platform_get_drvdata(pdev);
	542
	543	return flexfb_remove_common(&pdev->dev, info);
	544	}
	545
	546	static struct spi_driver flexfb_spi_driver = {
	547	.driver = {
	548	.name = DRVNAME,
	549	.owner = THIS_MODULE,
	550	},
	551	.probe = flexfb_probe_spi,
	552	.remove = flexfb_remove_spi,
	553	};
	554
	555	static const struct platform_device_id flexfb_platform_ids[] = {
	556	{ "flexpfb", 0 },
	557	{ },
	558	};
	559
	560	static struct platform_driver flexfb_platform_driver = {
	561	.driver = {
	562	.name = DRVNAME,
27837e11 TP	563	},
	564	.id_table = flexfb_platform_ids,
	565	.probe = flexfb_probe_pdev,
	566	.remove = flexfb_remove_pdev,
	567	};
	568
	569	static int __init flexfb_init(void)
	570	{
	571	int ret, ret2;
	572
	573	ret = spi_register_driver(&flexfb_spi_driver);
	574	ret2 = platform_driver_register(&flexfb_platform_driver);
	575	if (ret < 0)
	576	return ret;
	577	return ret2;
	578	}
	579
	580	static void __exit flexfb_exit(void)
	581	{
	582	spi_unregister_driver(&flexfb_spi_driver);
	583	platform_driver_unregister(&flexfb_platform_driver);
	584	}
	585
	586	/* ------------------------------------------------------------------------- */
	587
	588	module_init(flexfb_init);
	589	module_exit(flexfb_exit);
	590
	591	MODULE_DESCRIPTION("Generic FB driver for TFT LCD displays");
	592	MODULE_AUTHOR("Noralf Tronnes");
	593	MODULE_LICENSE("GPL");