diff --git a/drivers/video/fbtft/fb_ssd1322.c b/drivers/video/fbtft/fb_ssd1322.c
new file mode 100755
index 000000000..43f61b3ec
--- /dev/null
+++ b/drivers/video/fbtft/fb_ssd1322.c
@@ -0,0 +1,442 @@
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/gpio.h>
+#include <linux/spi/spi.h>
+#include <linux/delay.h>
+
+#include "fbtft.h"
+
+extern int ekb2_sub_lcd_backlight_enable(void);
+
+#define OLED_DRIVER_NAME     		"fb_ssd1322"
+
+#define OLED_WIDTH					(589) /* display width pixel */
+#define OLED_WIDTH_PIXEL_PER_IC		(296) /* display width pixel per controller */
+#define OLED_CS0_WIDTH_MARGIN		(3) /* display cs0 width margin */
+#define OLED_CS0_WIDTH_PIXEL		(OLED_WIDTH_PIXEL_PER_IC - OLED_CS0_WIDTH_MARGIN) /* display cs0 width pixel  */
+#define OLED_CS1_WIDTH_PIXEL		(OLED_WIDTH_PIXEL_PER_IC) /* display cs1 width pixel */
+#define OLED_CS1_WIDTH_START_PIXEL	(OLED_CS0_WIDTH_PIXEL) /* display cs1 width start pixel */
+#define OLED_WIDTH_BYTE_PER_IC		(OLED_WIDTH_PIXEL_PER_IC / 2) /* display width byte number per controller */
+#define OLED_WIDTH_BYTE				(OLED_WIDTH_BYTE_PER_IC * 2) /* display width byte number */
+#define OLED_SEG_START_NUM			(92) /* display segment start number */
+#define OLED_SEG_END_NUM			(OLED_SEG_START_NUM + OLED_WIDTH_PIXEL_PER_IC - 1) /* display segment end number */
+#define OLED_COLUMN_START_ADDRESS	(OLED_SEG_START_NUM / 4) /* display column start address */
+#define OLED_COLUMN_END_ADDRESS		(((OLED_SEG_END_NUM + 1) / 4) - 1) /* display column end address */
+
+#define OLED_HEIGHT					(48) /* display height pixel */
+#define OLED_COM_START_NUM			(0) /* display common start number */
+#define OLED_COM_END_NUM			(OLED_COM_START_NUM + OLED_HEIGHT - 1) /* display common end number */
+#define OLED_ROW_START_ADDRESS		(OLED_COM_START_NUM) /* display row start address */
+#define OLED_ROW_END_ADDRESS		(OLED_COM_END_NUM) /* display row end address */
+
+#define OLED_REG_WIDTH				(8) /* display register width */
+#define OLED_BUS_WIDTH				(8) /* display bus width */
+#define OLED_TX_BUF_LEN				(OLED_WIDTH_BYTE_PER_IC * OLED_HEIGHT * 2) /* transmit buffer length */
+#define OLED_TX_BUF_LEN_PER_IC		(OLED_TX_BUF_LEN / 2) /* transmit buffer length per controller */
+#define OLED_BITS_PER_PIXEL			(4) /* display bits per pixel */
+#define OLED_FPS					(240) /* display frames per second */
+#define OLED_GRAY_SCALE_TABLE_LEN	(15) /* display gray scale table length */
+#define OLED_GRAY_SCALE_VAL_MAX		(180) /* display gray scale maximum value */
+#define OLED_BRIGHTNESS_NUM			(1) /* display gray scale table + contrast current number */
+#define OLED_BRIGHTNESS_LEN			(OLED_GRAY_SCALE_TABLE_LEN + 1) /* display gray scale table + contrast current length */
+#define OLED_BRIGHTNESS_DEF			"0x00 0x01 0x09 0x11 0x16 0x2A 0x2F 0x34 0x37 0x43 0x4A 0x51 0x59 0x60 0x6E 0x2C" /* display gray scale table + contrast current default */
+#define OLED_DEBUG_LEVEL			(0) /* debug level 0-7 */
+
+#define OLED_DC						par->gpio.dc /* display data/command control pin */
+#define OLED_CS0					par->gpio.aux[0] /* display chip select 0 pin */
+#define OLED_CS1					par->gpio.aux[1] /* display chip select 1 pin */
+
+static u8 buf_cs0[OLED_TX_BUF_LEN_PER_IC]; /* transmit buffer for cs0 */
+static u8 buf_cs1[OLED_TX_BUF_LEN_PER_IC]; /* transmit buffer for cs1 */
+static bool is_enter = false; /* prohibit flag of multiple function call */
+
+static int init_display(struct fbtft_par *par)
+{
+	par->fbtftops.reset(par); /* set reset signal */
+
+	ekb2_sub_lcd_backlight_enable();
+	msleep(200);
+
+	gpio_set_value(OLED_CS0, 0); /* set CS0 active */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+
+	write_reg(par, 0xAE); /* set display off */
+	write_reg(par, 0xFD, 0x12); /* set command lock */
+	write_reg(par, 0x15, OLED_COLUMN_START_ADDRESS, OLED_COLUMN_END_ADDRESS); /* set column address */
+	write_reg(par, 0x75, OLED_ROW_START_ADDRESS, OLED_ROW_END_ADDRESS); /* set row address */
+	write_reg(par, 0xB3, 0x01); /* set front clock divider / oscillator frequency */
+	write_reg(par, 0xCA, OLED_COM_END_NUM); /* set multiplex ratio */
+	write_reg(par, 0xA2, 0x00); /* set display offset */
+	write_reg(par, 0xA1, 0x00); /* set display start line */
+	write_reg(par, 0xAB, 0x01); /* function selection */
+	write_reg(par, 0xA0, 0x06, 0x11); /* set re-map & dual COM line mode */
+	write_reg(par, 0xB4, 0xA0, 0xB5); /* display enhancement A */
+	write_reg(par, 0xC1, 0x2C); /* set contrast current */
+	write_reg(par, 0xC7, 0x0F); /* master contrast current control */
+	write_reg(par, 0xB8, 0x00, 0x01, 0x09, 0x11, 0x16, 0x2A, 0x2F, 0x34, 0x37, 0x43, 0x4A, 0x51, 0x59, 0x60, 0x6E); /* set gray scale table */
+	write_reg(par, 0x00); /* enable gray scale table */
+	write_reg(par, 0xB1, 0x92); /* set phase length */
+	write_reg(par, 0xD1, 0xA2, 0x20); /* display enhancement B */
+	write_reg(par, 0xBB, 0x1E); /* set pre-charge voltage */
+	write_reg(par, 0xB6, 0x0F); /* set second precharge period */
+	write_reg(par, 0xBE, 0x03); /* set VCOMH */
+	write_reg(par, 0xA6); /* set display mode */
+	write_reg(par, 0x5C); /* write RAM command */
+
+	/* init RAM */
+	{
+		u8 *buf = par->txbuf.buf;
+		int x, y, ret = 0;
+
+		for (y = 0; y < OLED_HEIGHT; y++) {
+			for (x = 0; x < OLED_WIDTH_BYTE_PER_IC; x++) {
+				*buf++ = 0x00;
+			}
+		}
+		gpio_set_value(OLED_DC, 1); /* set data line */
+		ret = par->fbtftops.write(par, par->txbuf.buf, OLED_TX_BUF_LEN_PER_IC);
+		if (ret < 0)
+			dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	}
+
+	write_reg(par, 0xAF); /* set display on */
+	write_reg(par, 0x5C); /* write RAM command */
+
+	gpio_set_value(OLED_CS0, 1); /* set CS0 inactive */
+	gpio_set_value(OLED_CS1, 1); /* set CS1 inactive */
+
+	return 0;
+}
+
+static u8 conv_pixel_to_column_address_cs0(const u16 x){
+	return (u8)(OLED_COLUMN_START_ADDRESS + ((x + 3) / 4));
+}
+
+static u8 conv_pixel_to_column_address_cs1(const u16 x){
+	return (u8)(OLED_COLUMN_START_ADDRESS + ((x - OLED_CS0_WIDTH_PIXEL) / 4));
+}
+
+static void make_oled_image(u8 *src_buf, u8 *dest_buf, const int dest_buf_len)
+{
+	int i;
+	u8 dot_a, dot_b;
+	u8 *pos_src_buf = src_buf;
+	u8 *pos_dest_buf = dest_buf;
+
+	/* convert 8bit Grayscale include header to 4bit Grayscale exclude header */
+	pos_src_buf += FBTFT_HEADER_BYTE;
+	for (i = 0; i < dest_buf_len; i++) {
+		dot_a = *pos_src_buf++;
+		dot_b = *pos_src_buf++;
+		*pos_dest_buf++ = (dot_a & 0xF0) | (dot_b >> 4);
+	}
+}
+
+static void make_oled_image_both(u8 *src_buf, u8 *dest_buf_cs0, u8 *dest_buf_cs1, const u16 dest_x_len_cs0, const u16 dest_x_len_cs1, const u16 dest_y_len)
+{
+	int x, y;
+	u8 dot_a, dot_b;
+	u8 *pos_src_buf = src_buf;
+	u8 *pos_dest_buf_cs0 = dest_buf_cs0;
+	u8 *pos_dest_buf_cs1 = dest_buf_cs1;
+
+	/* convert 8bit Grayscale include header to 4bit Grayscale exclude header */
+	pos_src_buf += FBTFT_HEADER_BYTE;
+	for (y = 0; y < dest_y_len; y++) {
+		/* convert cs0 data */
+		for (x = 0; x < dest_x_len_cs0; x++) {
+			dot_a = *pos_src_buf++;
+			dot_b = *pos_src_buf++;
+			*pos_dest_buf_cs0++ = (dot_a & 0xF0) | (dot_b >> 4);
+		}
+
+		/* convert cs1 data */
+		for (x = 0; x < dest_x_len_cs1; x++) {
+			dot_a = *pos_src_buf++;
+			dot_b = *pos_src_buf++;
+			*pos_dest_buf_cs1++ = (dot_a & 0xF0) | (dot_b >> 4);
+		}
+	}
+}
+
+static void make_oled_image_all(u8 *src_buf, u8 *dest_buf_cs0, u8 *dest_buf_cs1)
+{
+	int x, y;
+	u8 dot_a, dot_b;
+	u8 *pos_src_buf = src_buf;
+	u8 *pos_dest_buf_cs0 = dest_buf_cs0;
+	u8 *pos_dest_buf_cs1 = dest_buf_cs1;
+
+	/* convert 8bit Grayscale include header to 4bit Grayscale exclude header */
+	pos_src_buf += FBTFT_HEADER_BYTE;
+	for (y = 0; y < OLED_HEIGHT; y++) {
+		/* add cs0 margin */
+		*pos_dest_buf_cs0++ = 0x00;
+		*pos_dest_buf_cs0 = 0x00;
+		dot_b = *pos_src_buf++;
+		*pos_dest_buf_cs0++ = (dot_b >> 4);
+
+		/* convert cs0 data */
+		for (x = 0; x < OLED_WIDTH_BYTE_PER_IC - 2; x++) {
+			dot_a = *pos_src_buf++;
+			dot_b = *pos_src_buf++;
+			*pos_dest_buf_cs0++ = (dot_a & 0xF0) | (dot_b >> 4);
+		}
+
+		/* convert cs1 data */
+		for (x = 0; x < OLED_WIDTH_BYTE_PER_IC; x++) {
+			dot_a = *pos_src_buf++;
+			dot_b = *pos_src_buf++;
+			*pos_dest_buf_cs1++ = (dot_a & 0xF0) | (dot_b >> 4);
+		}
+	}
+}
+
+static int write_vmem_cs0(struct fbtft_par *par, const u16 xs, const u16 xe, const u16 ys, const u16 ye)
+{
+	u8 *src_buf = (u8 *)(par->info->screen_base);
+	u8 *dest_buf = par->txbuf.buf;
+	int ret = 0;
+
+	/* make transmit data */
+	const int dest_buf_len = ((xe - xs + 1) / 2) * (ye - ys + 1);
+	make_oled_image(src_buf, dest_buf, dest_buf_len);
+
+	/* set column & row address */
+	gpio_set_value(OLED_CS0, 0); /* set CS0 active */
+	write_reg(par, 0x15, conv_pixel_to_column_address_cs0(xs), conv_pixel_to_column_address_cs0(xe)); /* set column address */
+	write_reg(par, 0x75, ys, ye); /* set row address */
+
+	/* write data */
+	write_reg(par, 0x5C); /* write RAM command */
+	gpio_set_value(OLED_DC, 1); /* set data line */
+	ret = par->fbtftops.write(par, par->txbuf.buf, dest_buf_len);
+	if (ret < 0)
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	gpio_set_value(OLED_CS0, 1); /* set CS0 inactive */
+
+	return ret;
+}
+
+static int write_vmem_cs1(struct fbtft_par *par, const u16 xs, const u16 xe, const u16 ys, const u16 ye)
+{
+	u8 *src_buf = (u8 *)(par->info->screen_base);
+	u8 *dest_buf = par->txbuf.buf;
+	int ret = 0;
+
+	/* make transmit data */
+	const int dest_buf_len = ((xe - xs + 1) / 2) * (ye - ys + 1);
+	make_oled_image(src_buf, dest_buf, dest_buf_len);
+
+	/* set column & row address */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+	write_reg(par, 0x15, conv_pixel_to_column_address_cs1(xs), conv_pixel_to_column_address_cs1(xe)); /* set column address */
+	write_reg(par, 0x75, ys, ye); /* set row address */
+
+	/* write data */
+	write_reg(par, 0x5C); /* write RAM command */
+	gpio_set_value(OLED_DC, 1); /* set data line */
+	ret = par->fbtftops.write(par, par->txbuf.buf, dest_buf_len);
+	if (ret < 0)
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	gpio_set_value(OLED_CS1, 1); /* set CS1 inactive */
+
+	return ret;
+}
+
+static int write_vmem_both(struct fbtft_par *par, const u16 xs, const u16 xe, const u16 ys, const u16 ye)
+{
+	u8 *src_buf = (u8 *)(par->info->screen_base);
+	u8 *dest_buf_cs0 = buf_cs0;
+	u8 *dest_buf_cs1 = buf_cs1;
+	int ret = 0;
+
+	/* make transmit data */
+	const u16 dest_x_len_cs0 = (OLED_CS0_WIDTH_PIXEL - xs) / 2;
+	const u16 dest_x_len_cs1 = (xe - OLED_CS0_WIDTH_PIXEL + 1) / 2;
+	const u16 dest_y_len = ye - ys + 1;
+	const int dest_buf_len_cs0 = dest_x_len_cs0 * dest_y_len;
+	const int dest_buf_len_cs1 = dest_x_len_cs1 * dest_y_len;
+	make_oled_image_both(src_buf, dest_buf_cs0, dest_buf_cs1, dest_x_len_cs0, dest_x_len_cs1, dest_y_len);
+
+	/* set column & row address cs0 */
+	gpio_set_value(OLED_CS0, 0); /* set CS0 active */
+	write_reg(par, 0x15, conv_pixel_to_column_address_cs0(xs), OLED_COLUMN_END_ADDRESS); /* set column address */
+	write_reg(par, 0x75, ys, ye); /* set row address */
+
+	/* write data cs0 */
+	write_reg(par, 0x5C); /* write RAM command */
+	gpio_set_value(OLED_DC, 1); /* set data line */
+	ret = par->fbtftops.write(par, buf_cs0, dest_buf_len_cs0);
+	if (ret < 0)
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	gpio_set_value(OLED_CS0, 1); /* set CS0 inactive */
+
+	/* set column & row address cs1 */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+	write_reg(par, 0x15, OLED_COLUMN_START_ADDRESS, conv_pixel_to_column_address_cs1(xe)); /* set column address */
+	write_reg(par, 0x75, ys, ye); /* set row address */
+
+	/* write data cs1 */
+	write_reg(par, 0x5C); /* write RAM command */
+	gpio_set_value(OLED_DC, 1); /* set data line */
+	ret = par->fbtftops.write(par, buf_cs1, dest_buf_len_cs1);
+	if (ret < 0)
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	gpio_set_value(OLED_CS1, 1); /* set CS0 inactive */
+
+	return ret;
+}
+
+static int write_vmem_all(struct fbtft_par *par)
+{
+	u8 *src_buf = (u8 *)(par->info->screen_base);
+	u8 *dest_buf_cs0 = buf_cs0;
+	u8 *dest_buf_cs1 = buf_cs1;
+	int ret = 0;
+
+	/* make transmit data */
+	make_oled_image_all(src_buf, dest_buf_cs0, dest_buf_cs1);
+
+	/* set column & row address */
+	gpio_set_value(OLED_CS0, 0); /* set CS0 active */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+	write_reg(par, 0x15, OLED_COLUMN_START_ADDRESS, OLED_COLUMN_END_ADDRESS); /* set column address */
+	write_reg(par, 0x75, OLED_ROW_START_ADDRESS, OLED_ROW_END_ADDRESS); /* set row address */
+
+	/* write data */
+	write_reg(par, 0x5C); /* write RAM command */
+	gpio_set_value(OLED_DC, 1); /* set data line */
+	gpio_set_value(OLED_CS1, 1); /* set CS1 inactive */
+	ret = par->fbtftops.write(par, buf_cs0, OLED_TX_BUF_LEN_PER_IC);
+	if (ret < 0)
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	gpio_set_value(OLED_CS0, 1); /* set CS0 inactive */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+	ret = par->fbtftops.write(par, buf_cs1, OLED_TX_BUF_LEN_PER_IC);
+	if (ret < 0)
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+	gpio_set_value(OLED_CS1, 1); /* set CS1 inactive */
+
+	return ret;
+}
+
+static int write_vmem_main(struct fbtft_par *par, size_t offset, size_t len)
+{
+	u16 xs, xe, ys, ye;
+	u16 *src_buf = (u16 *)(par->info->screen_base);
+	int ret = 0;
+
+	/* prohibit multiple function call */
+	if (is_enter) {
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+		return -ENOMEM;
+	}
+	is_enter = true;
+
+	/* get pixel range */
+	xs = src_buf[0];
+	xe = src_buf[1];
+	ys = src_buf[2];
+	ye = src_buf[3];
+
+	/* write data */
+	if (xe < OLED_CS1_WIDTH_START_PIXEL) {
+		ret = write_vmem_cs0(par, xs, xe, ys, ye);
+	} else if (xs >= OLED_CS1_WIDTH_START_PIXEL) {
+		ret = write_vmem_cs1(par, xs, xe, ys, ye);
+	} else if (xs != 0) {
+		ret = write_vmem_both(par, xs, xe, ys, ye);
+	} else if ( (xe == OLED_WIDTH - 1) &&
+				(ys == 0) &&
+				(ye == OLED_HEIGHT - 1) ) {
+		ret = write_vmem_all(par);
+	} else {
+		dev_err(par->info->device, "%s: write failed and returned: %d\n", __func__, ret);
+		ret = -EINVAL;
+	}
+
+	/* permit function call */
+	is_enter = false;
+
+	return ret;
+}
+
+static void set_addr_win(struct fbtft_par *par, int xs, int ys, int xe, int ye)
+{
+	/* do nothing */
+}
+
+static int set_brightness(struct fbtft_par *par, unsigned long *val)
+{
+	int i;
+
+	/* check illegal data */
+	for (i = 0; i < OLED_GRAY_SCALE_TABLE_LEN; i++) {
+		if (OLED_GRAY_SCALE_VAL_MAX < val[i]) {
+			dev_err(par->info->device, "%s: invalid value in gray scale table at index %d\n", __func__, i);
+			return -EINVAL;
+		}
+	}
+
+	/* set brightness */
+	gpio_set_value(OLED_CS0, 0); /* set CS0 active */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+	write_reg(par, 0xC1, val[15]); /* set contrast current */
+	write_reg(par, 0xB8, val[0], val[1], val[2], val[3], val[4], val[5], val[6], val[7], val[8], val[9], val[10], val[11], val[12], val[13], val[14]); /* set gray scale table */
+	write_reg(par, 0x00); /* enable gray scale table */
+	gpio_set_value(OLED_CS0, 1); /* set CS0 inactive */
+	gpio_set_value(OLED_CS1, 1); /* set CS1 inactive */
+
+	return 0;
+}
+
+static int blank(struct fbtft_par *par, bool is_blank)
+{
+	/* set display on/off */
+	gpio_set_value(OLED_CS0, 0); /* set CS0 active */
+	gpio_set_value(OLED_CS1, 0); /* set CS1 active */
+	if (is_blank) {
+		write_reg(par, 0xAE); /* set display off */
+	} else {
+		write_reg(par, 0xAF); /* set display on */
+	}
+	gpio_set_value(OLED_CS0, 1); /* set CS0 inactive */
+	gpio_set_value(OLED_CS1, 1); /* set CS1 inactive */
+
+	return 0;
+}
+
+static struct fbtft_display display = {
+	.width = OLED_WIDTH,
+	.height = OLED_HEIGHT,
+	.regwidth = OLED_REG_WIDTH,
+	.buswidth = OLED_BUS_WIDTH,
+	.txbuflen = OLED_TX_BUF_LEN_PER_IC,
+	.bpp = OLED_BITS_PER_PIXEL,
+	.fps = OLED_FPS,
+	.gamma_num = OLED_BRIGHTNESS_NUM,
+	.gamma_len = OLED_BRIGHTNESS_LEN,
+	.gamma = OLED_BRIGHTNESS_DEF,
+	.debug = OLED_DEBUG_LEVEL,
+	.fbtftops = {
+		.init_display = init_display,
+		.write_vmem = write_vmem_main,
+		.set_addr_win  = set_addr_win,
+		.set_gamma = set_brightness,
+		.blank = blank,
+	},
+};
+
+FBTFT_REGISTER_DRIVER(OLED_DRIVER_NAME, "solomon,ssd1322", &display);
+
+MODULE_ALIAS("spi:" OLED_DRIVER_NAME);
+MODULE_ALIAS("platform:" OLED_DRIVER_NAME);
+MODULE_ALIAS("spi:ssd1322");
+MODULE_ALIAS("platform:ssd1322");
+
+MODULE_DESCRIPTION("FB driver for the two SSD1322 OLED Controllers in the DP-0105 display");
+MODULE_AUTHOR("Yamaha Corporation");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 7e67f2743..10464fedd 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -56,5 +56,6 @@ if FB || SGI_NEWPORT_CONSOLE
 
 endif
 
+source "drivers/video/fbtft/Kconfig"
 
 endmenu
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index aaaa78753..3878960b2 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -5,6 +5,7 @@ obj-$(CONFIG_VT)		  += console/
 obj-$(CONFIG_LOGO)		  += logo/
 obj-y				  += backlight/
 obj-y				  += fbdev/
+obj-y += fbtft/
 
 #video output switch sysfs driver
 obj-$(CONFIG_VIDEO_OUTPUT_CONTROL) += output.o
diff --git a/drivers/video/fbtft/Kconfig b/drivers/video/fbtft/Kconfig
index 995a9101a..5ac99d51b 100755
--- a/drivers/video/fbtft/Kconfig
+++ b/drivers/video/fbtft/Kconfig
@@ -110,6 +110,12 @@ config FB_TFT_SSD1306
 	help
 	  Framebuffer support for SSD1306
 
+config FB_TFT_SSD1322
+	tristate "FB driver for the SSD1322 OLED Controller"
+	depends on FB_TFT
+	help
+	  Framebuffer support for SSD1322
+
 config FB_TFT_SSD1331
 	tristate "FB driver for the SSD1331 LCD Controller"
 	depends on FB_TFT
diff --git a/drivers/video/fbtft/Makefile b/drivers/video/fbtft/Makefile
index 71c755dce..91b52171c 100755
--- a/drivers/video/fbtft/Makefile
+++ b/drivers/video/fbtft/Makefile
@@ -26,6 +26,7 @@ obj-$(CONFIG_FB_TFT_S6D02A1)     += fb_s6d02a1.o
 obj-$(CONFIG_FB_TFT_S6D1121)     += fb_s6d1121.o
 obj-$(CONFIG_FB_TFT_SSD1289)     += fb_ssd1289.o
 obj-$(CONFIG_FB_TFT_SSD1306)     += fb_ssd1306.o
+obj-$(CONFIG_FB_TFT_SSD1322)     += fb_ssd1322.o
 obj-$(CONFIG_FB_TFT_SSD1331)     += fb_ssd1331.o
 obj-$(CONFIG_FB_TFT_SSD1351)     += fb_ssd1351.o
 obj-$(CONFIG_FB_TFT_ST7735R)     += fb_st7735r.o
diff --git a/drivers/video/fbtft/fbtft-core.c b/drivers/video/fbtft/fbtft-core.c
index 873e2c72a..91726a177 100755
--- a/drivers/video/fbtft/fbtft-core.c
+++ b/drivers/video/fbtft/fbtft-core.c
@@ -52,7 +52,7 @@ static unsigned long debug;
 module_param(debug, ulong , 0);
 MODULE_PARM_DESC(debug, "override device debug level");
 
-static bool dma = true;
+static bool dma = false;
 module_param(dma, bool, 0);
 MODULE_PARM_DESC(dma, "Use DMA buffer");
 
@@ -360,10 +360,8 @@ 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(par->gpio.reset, 0);
-	udelay(20);
-	gpio_set_value(par->gpio.reset, 1);
-	mdelay(120);
+
+	printk("[fbtft-core.c] fbtft_reset called. bat not reseted.\n");
 }
 
 
@@ -453,7 +451,7 @@ void fbtft_mkdirty(struct fb_info *info, int y, int height)
 	/* special case, needed ? */
 	if (y == -1) {
 		y = 0;
-		height = info->var.yres - 1;
+		height = info->var.yres;
 	}
 
 	/* Mark display lines/area as dirty */
@@ -755,7 +753,7 @@ struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display,
 		height = display->height;
 	}
 
-	vmem_size = display->width * display->height * bpp / 8;
+	vmem_size = (display->width * display->height) + FBTFT_HEADER_BYTE;
 	vmem = vzalloc(vmem_size);
 	if (!vmem)
 		goto alloc_fail;
