ENGR00126260-2 - EPDC fb: Support 9.7" panel

Add support for 9.7" E Ink panel.
Expand driver support for multiple panels by storing platform data
containing all variable panel parameters. Removed hard-coded reg values
for 6" panel.

Signed-off-by: Danny Nold <dannynold@freescale.com>

1 files changed, 161 insertions, 142 deletions

diff --git a/drivers/video/mxc/mxc_epdc_fb.c b/drivers/video/mxc/mxc_epdc_fb.c
index fd4a53517579..7a49cd980353 100644
--- a/drivers/video/mxc/mxc_epdc_fb.c
+++ b/drivers/video/mxc/mxc_epdc_fb.c
@@ -71,15 +71,6 @@
 
 static unsigned long default_bpp = 16;
 
-struct mxc_epdc_platform_fb_entry {
-	char name[16];
-	u16 x_res;
-	u16 y_res;
-	u16 bpp;
-	u32 cycle_time_ns;
-	struct list_head link;
-};
-
 struct update_marker_data {
 	u32 update_marker;
 	struct completion update_completion;
@@ -106,13 +97,15 @@ struct update_data_list {
 struct mxc_epdc_fb_data {
 	struct fb_info info;
 	u32 pseudo_palette[16];
+	char *fb_panel_str;
 	struct list_head list;
-	struct mxc_epdc_platform_fb_entry *cur;
+	struct mxc_epdc_fb_mode *cur_mode;
 	struct mxc_epdc_fb_platform_data *pdata;
 	int blank;
 	ssize_t map_size;
 	dma_addr_t phys_start;
 	u32 fb_offset;
+	int default_bpp;
 	int native_width;
 	int native_height;
 	int epdc_irq;
@@ -196,30 +189,6 @@ struct mxcfb_waveform_data_file {
 
 void __iomem *epdc_base;
 
-#define NUM_PANELS 1
-
-static struct fb_videomode panel_modes[NUM_PANELS] = {
-	{
-	 /* 800x600 @ 60 Hz , pixel clk @ 20MHz */
-	 "E-INK SVGA", 60, 800, 600, 50000, 10, 217, 4, 10, 20, 4,
-	 0,
-	 FB_VMODE_NONINTERLACED,
-	 0,},
-};
-
-/*
- * This is a temporary placeholder
- * Ultimately, this declaration will be off in a panel-specific file,
- * and will include implementations for all of the panel functions
- */
-static struct mxc_epdc_platform_fb_entry ed060sc4_fb_entry = {
-	.name = "ed060sc4",
-	.x_res = 800,
-	.y_res = 600,
-	.bpp = 16,
-	.cycle_time_ns = 200,
-};
-
 /* forward declaration */
 static int mxc_epdc_fb_blank(int blank, struct fb_info *info);
 static int mxc_epdc_fb_init_hw(struct fb_info *info);
@@ -420,30 +389,6 @@ static inline void dump_all_updates(struct mxc_epdc_fb_data *fb_data) {}
 
 #endif
 
-static struct fb_var_screeninfo mxc_epdc_fb_default __devinitdata = {
-	.activate = FB_ACTIVATE_TEST,
-	.height = -1,
-	.width = -1,
-	.pixclock = 20000,
-	.left_margin = 8,
-	.right_margin = 142,
-	.upper_margin = 4,
-	.lower_margin = 10,
-	.hsync_len = 20,
-	.vsync_len = 4,
-	.vmode = FB_VMODE_NONINTERLACED,
-};
-
-static struct fb_fix_screeninfo mxc_epdc_fb_fix __devinitdata = {
-	.id = "mxc_epdc_fb",
-	.type = FB_TYPE_PACKED_PIXELS,
-	.visual = FB_VISUAL_TRUECOLOR,
-	.xpanstep = 0,
-	.ypanstep = 0,
-	.ywrapstep = 0,
-	.accel = FB_ACCEL_NONE,
-	.line_length = 800 * 2,
-};
 
 /********************************************************
  * Start Low-Level EPDC Functions
@@ -631,9 +576,10 @@ static void epdc_set_vertical_timing(u32 vert_start, u32 vert_end,
 
 void epdc_init_settings(struct mxc_epdc_fb_data *fb_data)
 {
-	struct mxc_epdc_platform_fb_entry *pentry = fb_data->cur;
+	struct mxc_epdc_fb_mode *epdc_mode = fb_data->cur_mode;
 	struct fb_var_screeninfo *screeninfo = &fb_data->info.var;
 	u32 reg_val;
+	int num_ce;
 
 	/* Reset */
 	__raw_writel(EPDC_CTRL_SFTRST, EPDC_CTRL_SET);
@@ -675,7 +621,7 @@ void epdc_init_settings(struct mxc_epdc_fb_data *fb_data)
 	epdc_set_temp(8);
 
 	/* EPDC_RES */
-	epdc_set_screen_res(pentry->x_res, pentry->y_res);
+	epdc_set_screen_res(epdc_mode->vmode->xres, epdc_mode->vmode->yres);
 
 	/*
 	 * EPDC_TCE_CTRL
@@ -690,7 +636,7 @@ void epdc_init_settings(struct mxc_epdc_fb_data *fb_data)
 	 * PIXELS_PER_SDCLK = 4
 	 */
 	reg_val =
-	    ((4 << EPDC_TCE_CTRL_VSCAN_HOLDOFF_OFFSET) &
+	    ((epdc_mode->vscan_holdoff << EPDC_TCE_CTRL_VSCAN_HOLDOFF_OFFSET) &
 	     EPDC_TCE_CTRL_VSCAN_HOLDOFF_MASK)
 	    | EPDC_TCE_CTRL_PIXELS_PER_SDCLK_4;
 	__raw_writel(reg_val, EPDC_TCE_CTRL);
@@ -708,13 +654,13 @@ void epdc_init_settings(struct mxc_epdc_fb_data *fb_data)
 
 	/* EPDC_TCE_OE */
 	reg_val =
-	    ((10 << EPDC_TCE_OE_SDOED_WIDTH_OFFSET) &
+	    ((epdc_mode->sdoed_width << EPDC_TCE_OE_SDOED_WIDTH_OFFSET) &
 	     EPDC_TCE_OE_SDOED_WIDTH_MASK)
-	    | ((20 << EPDC_TCE_OE_SDOED_DLY_OFFSET) &
+	    | ((epdc_mode->sdoed_delay << EPDC_TCE_OE_SDOED_DLY_OFFSET) &
 	       EPDC_TCE_OE_SDOED_DLY_MASK)
-	    | ((10 << EPDC_TCE_OE_SDOEZ_WIDTH_OFFSET) &
+	    | ((epdc_mode->sdoez_width << EPDC_TCE_OE_SDOEZ_WIDTH_OFFSET) &
 	       EPDC_TCE_OE_SDOEZ_WIDTH_MASK)
-	    | ((20 << EPDC_TCE_OE_SDOEZ_DLY_OFFSET) &
+	    | ((epdc_mode->sdoez_delay << EPDC_TCE_OE_SDOEZ_DLY_OFFSET) &
 	       EPDC_TCE_OE_SDOEZ_DLY_MASK);
 	__raw_writel(reg_val, EPDC_TCE_OE);
 
@@ -723,17 +669,17 @@ void epdc_init_settings(struct mxc_epdc_fb_data *fb_data)
 
 	/* EPDC_TCE_TIMING2 */
 	reg_val =
-	    ((480 << EPDC_TCE_TIMING2_GDCLK_HP_OFFSET) &
+	    ((epdc_mode->gdclk_hp_offs << EPDC_TCE_TIMING2_GDCLK_HP_OFFSET) &
 	     EPDC_TCE_TIMING2_GDCLK_HP_MASK)
-	    | ((20 << EPDC_TCE_TIMING2_GDSP_OFFSET_OFFSET) &
+	    | ((epdc_mode->gdsp_offs << EPDC_TCE_TIMING2_GDSP_OFFSET_OFFSET) &
 	       EPDC_TCE_TIMING2_GDSP_OFFSET_MASK);
 	__raw_writel(reg_val, EPDC_TCE_TIMING2);
 
 	/* EPDC_TCE_TIMING3 */
 	reg_val =
-	    ((0 << EPDC_TCE_TIMING3_GDOE_OFFSET_OFFSET) &
+	    ((epdc_mode->gdoe_offs << EPDC_TCE_TIMING3_GDOE_OFFSET_OFFSET) &
 	     EPDC_TCE_TIMING3_GDOE_OFFSET_MASK)
-	    | ((1 << EPDC_TCE_TIMING3_GDCLK_OFFSET_OFFSET) &
+	    | ((epdc_mode->gdclk_offs << EPDC_TCE_TIMING3_GDCLK_OFFSET_OFFSET) &
 	       EPDC_TCE_TIMING3_GDCLK_OFFSET_MASK);
 	__raw_writel(reg_val, EPDC_TCE_TIMING3);
 
@@ -746,10 +692,14 @@ void epdc_init_settings(struct mxc_epdc_fb_data *fb_data)
 	 * SDDO_INVERT = DISABLED
 	 * PIXELS_PER_CE = display horizontal resolution
 	 */
+	num_ce = epdc_mode->num_ce;
+	if (num_ce == 0)
+		num_ce = 1;
 	reg_val = EPDC_TCE_SDCFG_SDCLK_HOLD | EPDC_TCE_SDCFG_SDSHR
-	    | ((1 << EPDC_TCE_SDCFG_NUM_CE_OFFSET) & EPDC_TCE_SDCFG_NUM_CE_MASK)
+	    | ((num_ce << EPDC_TCE_SDCFG_NUM_CE_OFFSET) &
+	       EPDC_TCE_SDCFG_NUM_CE_MASK)
 	    | EPDC_TCE_SDCFG_SDDO_REFORMAT_FLIP_PIXELS
-	    | ((pentry->x_res << EPDC_TCE_SDCFG_PIXELS_PER_CE_OFFSET) &
+	    | ((epdc_mode->vmode->xres/num_ce << EPDC_TCE_SDCFG_PIXELS_PER_CE_OFFSET) &
 	       EPDC_TCE_SDCFG_PIXELS_PER_CE_MASK);
 	__raw_writel(reg_val, EPDC_TCE_SDCFG);
 
@@ -1079,19 +1029,24 @@ static int mxc_epdc_fb_set_par(struct fb_info *info)
 	 * an initialization request.
 	 */
 	if (!fb_data->hw_ready) {
-		for (i = 0; i < NUM_PANELS; i++) {
-			/* Check resolution for a match with supported panel types */
-			if ((screeninfo->xres != panel_modes[i].xres) ||
-				(screeninfo->yres != panel_modes[i].yres))
+		for (i = 0; i < fb_data->pdata->num_modes; i++) {
+			struct fb_videomode *vmode =
+				fb_data->pdata->epdc_mode[i].vmode;
+			/* Check resolution for a match
+			   with supported panel types */
+			if ((screeninfo->xres != vmode->xres) ||
+				(screeninfo->yres != vmode->yres))
 				continue;
 
+			fb_data->cur_mode = &fb_data->pdata->epdc_mode[i];
+
 			/* Found a match - Grab timing params */
-			screeninfo->left_margin = panel_modes[i].left_margin;
-			screeninfo->right_margin = panel_modes[i].right_margin;
-			screeninfo->upper_margin = panel_modes[i].upper_margin;
-			screeninfo->lower_margin = panel_modes[i].lower_margin;
-			screeninfo->hsync_len = panel_modes[i].hsync_len;
-			screeninfo->vsync_len = panel_modes[i].vsync_len;
+			screeninfo->left_margin = vmode->left_margin;
+			screeninfo->right_margin = vmode->right_margin;
+			screeninfo->upper_margin = vmode->upper_margin;
+			screeninfo->lower_margin = vmode->lower_margin;
+			screeninfo->hsync_len = vmode->hsync_len;
+			screeninfo->vsync_len = vmode->vsync_len;
 
 			/* Initialize EPDC settings and init panel */
 			ret =
@@ -1225,12 +1180,12 @@ static int mxc_epdc_fb_check_var(struct fb_var_screeninfo *var,
 	switch (var->rotate) {
 	case FB_ROTATE_UR:
 	case FB_ROTATE_UD:
-		var->xres = var->xres_virtual = fb_data->native_width;
+		var->xres = fb_data->native_width;
 		var->yres = fb_data->native_height;
 		break;
 	case FB_ROTATE_CW:
 	case FB_ROTATE_CCW:
-		var->xres = var->xres_virtual = fb_data->native_height;
+		var->xres = fb_data->native_height;
 		var->yres = fb_data->native_width;
 		break;
 	default:
@@ -1679,7 +1634,6 @@ static int mxc_epdc_fb_set_pwrdown_delay(u32 pwrdown_delay,
 					    struct fb_info *info)
 {
 	struct mxc_epdc_fb_data *fb_data = (struct mxc_epdc_fb_data *)info;
-	int ret;
 
 	fb_data->pwrdown_delay = pwrdown_delay;
 
@@ -1946,14 +1900,15 @@ static struct fb_ops mxc_epdc_fb_ops = {
 };
 
 static struct fb_deferred_io mxc_epdc_fb_defio = {
-	.delay = HZ / 2,
+	.delay = HZ,
 	.deferred_io = mxc_epdc_fb_deferred_io,
 };
 
 static void epdc_done_work_func(struct work_struct *work)
 {
 	struct mxc_epdc_fb_data *fb_data =
-		container_of(work, struct mxc_epdc_fb_data, epdc_done_work);
+		container_of(work, struct mxc_epdc_fb_data,
+			epdc_done_work.work);
 	epdc_powerdown(fb_data);
 }
 
@@ -2294,13 +2249,24 @@ static int mxc_epdc_fb_init_hw(struct fb_info *info)
 {
 	struct mxc_epdc_fb_data *fb_data = (struct mxc_epdc_fb_data *)info;
 	const struct firmware *fw;
+	char *fw_str = "imx/epdc";
 	struct mxcfb_update_data update;
 	struct mxcfb_waveform_data_file *wv_file;
 	int wv_data_offs;
 	int ret;
 	int i;
 
-	ret = request_firmware(&fw, "imx/epdc.fw", fb_data->dev);
+	/*
+	 * Create fw search string based on ID string in selected videomode.
+	 * Format is "imx/epdc_[panel string].fw"
+	 */
+	if (fb_data->cur_mode) {
+		strcat(fw_str, "_");
+		strcat(fw_str, fb_data->cur_mode->vmode->name);
+		strcat(fw_str, ".fw");
+	}
+
+	ret = request_firmware(&fw, fw_str, fb_data->dev);
 	if (ret) {
 		printk(KERN_ERR "Failed to load image imx/epdc.ihex err %d\n",
 		       ret);
@@ -2343,7 +2309,7 @@ static int mxc_epdc_fb_init_hw(struct fb_info *info)
 
 	/* Enable pix clk for EPDC */
 	clk_enable(fb_data->epdc_clk_pix);
-	clk_set_rate(fb_data->epdc_clk_pix, 20000000);
+	clk_set_rate(fb_data->epdc_clk_pix, fb_data->cur_mode->vmode->pixclock);
 
 	epdc_init_sequence(fb_data);
 
@@ -2414,8 +2380,13 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 	struct mxc_epdc_fb_data *fb_data;
 	struct resource *res;
 	struct fb_info *info;
-	struct mxc_epdc_platform_fb_entry *pentry;
+	char *options, *opt;
+	char *panel_str = NULL;
+	char name[] = "mxcepdcfb";
+	struct fb_videomode *vmode;
 	int xres_virt, yres_virt, buf_size;
+	struct fb_var_screeninfo *var_info;
+	struct fb_fix_screeninfo *fix_info;
 	struct pxp_config_data *pxp_conf;
 	struct pxp_proc_data *proc_data;
 	struct scatterlist *sg;
@@ -2433,27 +2404,58 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 		goto out;
 	}
 
-	fb_data->dev = &pdev->dev;
-	/* We want to use hard-coded structure defined in this file */
-	pentry = &ed060sc4_fb_entry;
-	fb_data->cur = pentry;
-	platform_set_drvdata(pdev, fb_data);
-	info = &fb_data->info;
-
 	/* Get platform data */
 	fb_data->pdata = pdev->dev.platform_data;
-	if (fb_data->pdata == NULL) {
+	if ((fb_data->pdata == NULL) || (fb_data->pdata->num_modes < 1)) {
 		ret = -EINVAL;
 		goto out_fbdata;
 	}
 
+	if (fb_get_options(name, &options)) {
+		ret = -ENODEV;
+		goto out_fbdata;
+	}
+
+	if (options)
+		while ((opt = strsep(&options, ",")) != NULL) {
+			if (!*opt)
+				continue;
+
+			if (!strncmp(opt, "bpp=", 4))
+				fb_data->default_bpp =
+					simple_strtoul(opt + 4, NULL, 0);
+			else
+				panel_str = opt;
+		}
+
+	fb_data->dev = &pdev->dev;
+
+	if (!fb_data->default_bpp)
+		fb_data->default_bpp = 16;
+
+	/* Set default (first defined mode) before searching for a match */
+	fb_data->cur_mode = &fb_data->pdata->epdc_mode[0];
+
+	for (i = 0; i < fb_data->pdata->num_modes; i++)
+		if (!strcmp(fb_data->pdata->epdc_mode[i].vmode->name,
+					panel_str)) {
+			fb_data->cur_mode = &fb_data->pdata->epdc_mode[i];
+			break;
+		}
+
+	vmode = fb_data->cur_mode->vmode;
+
+	platform_set_drvdata(pdev, fb_data);
+	info = &fb_data->info;
+
 	/* Allocate color map for the FB */
 	ret = fb_alloc_cmap(&info->cmap, 256, 0);
 	if (ret)
 		goto out_fbdata;
 
-	dev_dbg(&pdev->dev, "resolution %dx%d, bpp %d\n", pentry->x_res,
-		pentry->y_res, pentry->bpp);
+	dev_dbg(&pdev->dev, "resolution %dx%d, bpp %d\n",
+		fb_data->cur_mode->vmode->xres,
+		fb_data->cur_mode->vmode->yres, fb_data->default_bpp);
 
 	/*
 	 * GPU alignment restrictions dictate framebuffer parameters:
@@ -2461,9 +2463,9 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 	 * - 128-byte alignment for buffer height
 	 * => 4K buffer alignment for buffer start
 	 */
-	xres_virt = ALIGN(pentry->x_res, 32);
-	yres_virt = ALIGN(pentry->y_res, 128);
-	buf_size = xres_virt * yres_virt * pentry->bpp/8;
+	xres_virt = ALIGN(vmode->xres, 32);
+	yres_virt = ALIGN(vmode->yres, 128);
+	buf_size = xres_virt * yres_virt * fb_data->default_bpp/8;
 
 	fb_data->map_size = PAGE_ALIGN(buf_size) * NUM_SCREENS;
 	dev_dbg(&pdev->dev, "memory to allocate: %d\n", fb_data->map_size);
@@ -2493,49 +2495,69 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 	dev_dbg(&pdev->dev, "allocated at %p:0x%x\n", info->screen_base,
 		fb_data->phys_start);
 
-	mxc_epdc_fb_default.bits_per_pixel = pentry->bpp;
-	mxc_epdc_fb_default.xres = pentry->x_res;
-	mxc_epdc_fb_default.yres = pentry->y_res;
-	mxc_epdc_fb_default.xres_virtual = xres_virt;
-	/* Additional screens allow for panning  and buffer flipping */
-	mxc_epdc_fb_default.yres_virtual = yres_virt * NUM_SCREENS;
+	var_info = &info->var;
 
-	mxc_epdc_fb_fix.smem_start = fb_data->phys_start;
-	mxc_epdc_fb_fix.smem_len = fb_data->map_size;
-	mxc_epdc_fb_fix.ypanstep = 0;
-
-	switch (pentry->bpp) {
+	var_info->activate = FB_ACTIVATE_TEST;
+	var_info->bits_per_pixel = fb_data->default_bpp;
+	var_info->xres = vmode->xres;
+	var_info->yres = vmode->yres;
+	var_info->xres_virtual = xres_virt;
+	/* Additional screens allow for panning  and buffer flipping */
+	var_info->yres_virtual = yres_virt * NUM_SCREENS;
+
+	var_info->pixclock = vmode->pixclock;
+	var_info->left_margin = vmode->left_margin;
+	var_info->right_margin = vmode->right_margin;
+	var_info->upper_margin = vmode->upper_margin;
+	var_info->lower_margin = vmode->lower_margin;
+	var_info->hsync_len = vmode->hsync_len;
+	var_info->vsync_len = vmode->vsync_len;
+	var_info->vmode = FB_VMODE_NONINTERLACED;
+
+	switch (fb_data->default_bpp) {
 	case 32:
 	case 24:
-		mxc_epdc_fb_default.red.offset = 16;
-		mxc_epdc_fb_default.red.length = 8;
-		mxc_epdc_fb_default.green.offset = 8;
-		mxc_epdc_fb_default.green.length = 8;
-		mxc_epdc_fb_default.blue.offset = 0;
-		mxc_epdc_fb_default.blue.length = 8;
+		var_info->red.offset = 16;
+		var_info->red.length = 8;
+		var_info->green.offset = 8;
+		var_info->green.length = 8;
+		var_info->blue.offset = 0;
+		var_info->blue.length = 8;
 		break;
 
 	case 16:
-		mxc_epdc_fb_default.red.offset = 11;
-		mxc_epdc_fb_default.red.length = 5;
-		mxc_epdc_fb_default.green.offset = 5;
-		mxc_epdc_fb_default.green.length = 6;
-		mxc_epdc_fb_default.blue.offset = 0;
-		mxc_epdc_fb_default.blue.length = 5;
+		var_info->red.offset = 11;
+		var_info->red.length = 5;
+		var_info->green.offset = 5;
+		var_info->green.length = 6;
+		var_info->blue.offset = 0;
+		var_info->blue.length = 5;
 		break;
 
 	default:
-		dev_err(&pdev->dev, "unsupported bitwidth %d\n", pentry->bpp);
+		dev_err(&pdev->dev, "unsupported bitwidth %d\n",
+			fb_data->default_bpp);
 		ret = -EINVAL;
 		goto out_dma_fb;
 	}
 
-	fb_data->native_width = pentry->x_res;
-	fb_data->native_height = pentry->y_res;
+	fix_info = &info->fix;
+
+	strcpy(fix_info->id, "mxc_epdc_fb");
+	fix_info->type = FB_TYPE_PACKED_PIXELS;
+	fix_info->visual = FB_VISUAL_TRUECOLOR;
+	fix_info->xpanstep = 0;
+	fix_info->ypanstep = 0;
+	fix_info->ywrapstep = 0;
+	fix_info->accel = FB_ACCEL_NONE;
+	fix_info->smem_start = fb_data->phys_start;
+	fix_info->smem_len = fb_data->map_size;
+	fix_info->ypanstep = 0;
+
+	fb_data->native_width = vmode->xres;
+	fb_data->native_height = vmode->yres;
 
 	info->fbops = &mxc_epdc_fb_ops;
-	info->var = mxc_epdc_fb_default;
-	info->fix = mxc_epdc_fb_fix;
 	info->var.activate = FB_ACTIVATE_NOW;
 	info->pseudo_palette = fb_data->pseudo_palette;
 	info->screen_size = info->fix.smem_len;
@@ -2607,7 +2629,7 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 			upd_list->size, upd_list->phys_addr);
 	}
 
-	fb_data->working_buffer_size = pentry->y_res * pentry->x_res * 2;
+	fb_data->working_buffer_size = vmode->yres * vmode->xres * 2;
 	/* Allocate memory for EPDC working buffer */
 	fb_data->working_buffer_virt =
 	    dma_alloc_coherent(&pdev->dev, fb_data->working_buffer_size,
@@ -2680,17 +2702,17 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 	fb_data->display_regulator = regulator_get(NULL, "DISPLAY");
 	if (IS_ERR(fb_data->display_regulator)) {
 		dev_err(&pdev->dev, "Unable to get display PMIC regulator."
-			"err = 0x%x\n", fb_data->display_regulator);
+			"err = 0x%x\n", (int)fb_data->display_regulator);
 		ret = -ENODEV;
-		goto out_dma_work_buf;
+		goto out_irq;
 	}
 	fb_data->vcom_regulator = regulator_get(NULL, "VCOM");
 	if (IS_ERR(fb_data->vcom_regulator)) {
 		regulator_put(fb_data->display_regulator);
 		dev_err(&pdev->dev, "Unable to get VCOM regulator."
-			"err = 0x%x\n", fb_data->vcom_regulator);
+			"err = 0x%x\n", (int)fb_data->vcom_regulator);
 		ret = -ENODEV;
-		goto out_dma_work_buf;
+		goto out_irq;
 	}
 
 	if (device_create_file(info->dev, &fb_attrs[0]))
@@ -2797,14 +2819,13 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 	if (ret) {
 		dev_err(&pdev->dev,
 			"register_framebuffer failed with error %d\n", ret);
-		goto out_irq;
+		goto out_dmaengine;
 	}
 
 #ifdef DEFAULT_PANEL_HW_INIT
 	ret = mxc_epdc_fb_init_hw((struct fb_info *)fb_data);
 	if (ret) {
-		dev_err(&pdev->dev, "Failed to read firmware!\n");
-		goto out_dmaengine;
+		dev_err(&pdev->dev, "Failed to initialize HW!\n");
 	}
 #endif
 
@@ -2832,7 +2853,6 @@ int __devinit mxc_epdc_fb_probe(struct platform_device *pdev)
 
 out_dmaengine:
 	dmaengine_put();
-	unregister_framebuffer(&fb_data->info);
 out_irq:
 	free_irq(fb_data->epdc_irq, fb_data);
 out_dma_work_buf:
@@ -2987,8 +3007,6 @@ static int pxp_chan_init(struct mxc_epdc_fb_data *fb_data)
 
 	fb_data->pxp_chan = to_pxp_channel(chan);
 
-	dev_dbg(fb_data->dev, "dma_chan = 0x%x\n", fb_data->pxp_chan->dma_chan);
-
 	fb_data->pxp_chan->client = fb_data;
 
 	init_completion(&fb_data->pxp_tx_cmpl);
@@ -3012,6 +3030,7 @@ static int pxp_process_update(struct mxc_epdc_fb_data *fb_data,
 	struct pxp_config_data *pxp_conf = &fb_data->pxp_conf;
 	struct pxp_proc_data *proc_data = &fb_data->pxp_conf.proc_data;
 	int i, ret;
+	int length;
 
 	dev_dbg(fb_data->dev, "Starting PxP Send Buffer\n");
 
@@ -3084,7 +3103,7 @@ static int pxp_process_update(struct mxc_epdc_fb_data *fb_data,
 	pxp_conf->out_param.height = update_region->height;
 
 	desc = to_tx_desc(txd);
-	int length = desc->len;
+	length = desc->len;
 	for (i = 0; i < length; i++) {
 		if (i == 0) {/* S0 */
 			memcpy(&desc->proc_data, proc_data, sizeof(struct pxp_proc_data));