653 lines
16 KiB
C
653 lines
16 KiB
C
/*
|
|
* GSC3280 SoC LCD framebuffer driver
|
|
*
|
|
* Copyright (C) 2013 BLX IC Design Corp.,Ltd.
|
|
* Author: Davied, apple_guet@126.com
|
|
*
|
|
*/
|
|
#include <linux/fb.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/console.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include <linux/pm_wakeup.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <video/gsc3280_lcdfb.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
|
|
#ifdef GSC3280_VIDEO_DEBUG
|
|
#define DBG(msg...) do { \
|
|
printk(KERN_INFO msg); \
|
|
} while (0)
|
|
#else
|
|
#define DBG(msg...) do { } while(0)
|
|
#endif
|
|
|
|
typedef union {
|
|
/* raw register data */
|
|
u32 w32;
|
|
/* register bits */
|
|
struct {
|
|
unsigned reserved:1;
|
|
unsigned cd:1; /* 0:16bpp, 1:8bpp */
|
|
unsigned hsl:1; /* 0:high, 1:low */
|
|
unsigned vsl:1; /* 0:high, 1:low */
|
|
unsigned vml:1; /* 0:high, 1:low */
|
|
unsigned reseved:1;
|
|
unsigned hce:1; /* hard cursor, 0:disable, 1:enable */
|
|
unsigned reserved7_31:25;
|
|
} b;
|
|
} lcd_ctrl_u;
|
|
|
|
typedef union {
|
|
/* raw register data */
|
|
u32 w32;
|
|
/* register bits */
|
|
struct {
|
|
unsigned thgate0_15:16;
|
|
unsigned thgdel16_23:8;
|
|
unsigned thsync24_31:8;
|
|
} b;
|
|
} lcd_htim_u;
|
|
|
|
typedef union {
|
|
/* raw register data */
|
|
u32 w32;
|
|
/* register bits */
|
|
struct {
|
|
unsigned tvgate0_15:16;
|
|
unsigned tvgdel16_23:8;
|
|
unsigned tvsync24_31:8;
|
|
} b;
|
|
} lcd_vtim_u;
|
|
|
|
typedef union {
|
|
/* raw register data */
|
|
u32 w32;
|
|
/* register bits */
|
|
struct {
|
|
unsigned tvlen0_15:16;
|
|
unsigned thlen16_31:16;
|
|
} b;
|
|
} lcd_hvlen_u;
|
|
|
|
typedef union {
|
|
/* raw register data */
|
|
u32 w32;
|
|
/* register bits */
|
|
struct {
|
|
unsigned ven0:1; /* 0:close, 1:start */
|
|
unsigned reserved1_31:31;
|
|
} b;
|
|
} lcd_cen_u;
|
|
|
|
struct gsc3280_fb {
|
|
unsigned is_enabled:1;
|
|
unsigned suspend_flg:1;
|
|
lcd_ctrl_u ctrl;
|
|
lcd_htim_u htim;
|
|
lcd_vtim_u vtim;
|
|
lcd_hvlen_u hvlen;
|
|
|
|
struct clk *clk;
|
|
void *vidmem;
|
|
spinlock_t slock;
|
|
struct fb_info *fb;
|
|
struct device *dev;
|
|
size_t vidmem_size;
|
|
void __iomem *base;
|
|
struct resource *mem;
|
|
dma_addr_t dma_addr;
|
|
struct fb_cursor *cursor;
|
|
uint32_t __iomem *pseudo_palette;
|
|
struct gsc3280_fb_platform_data *pdata;
|
|
};
|
|
|
|
|
|
static const struct fb_fix_screeninfo gsc3280fb_fix __devinitdata = {
|
|
.id = "GSC3280FB",
|
|
.type = FB_TYPE_PACKED_PIXELS,
|
|
.visual = FB_VISUAL_TRUECOLOR,
|
|
.xpanstep = 0,
|
|
.ypanstep = 0,
|
|
.ywrapstep = 0,
|
|
.accel = FB_ACCEL_NONE,
|
|
};
|
|
|
|
/* set or change the hardware cursor parameters */
|
|
static inline int gsc3280fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
|
|
{
|
|
lcd_ctrl_u ctrl;
|
|
struct gsc3280_fb *gsc = info->par;
|
|
unsigned long bg = 0, fg = 0, hwc_addr = 0;
|
|
|
|
dev_dbg(NULL, "%s(%p,%p)\n", __func__, info, cursor);
|
|
/* check not being asked to exceed capabilities */
|
|
if (cursor->image.width > 64)
|
|
return -EINVAL;
|
|
if (cursor->image.height > 64)
|
|
return -EINVAL;
|
|
if (cursor->image.depth > 16)
|
|
return -EINVAL;
|
|
ctrl.w32= readl(gsc->base + GSC3280_REG_LCD_CTRL);
|
|
hwc_addr = readl(gsc->base + GSC3280_REG_LCD_CBAR);
|
|
if (cursor->enable) {
|
|
ctrl.b.hce = 1;
|
|
writel(ctrl.w32, gsc->base + GSC3280_REG_LCD_CTRL);
|
|
//writel(fbi->cursor.k_addr, base + GSC3280_REG_LCD_FB_CABR);
|
|
}
|
|
else {
|
|
ctrl.b.hce = 0;
|
|
writel(ctrl.w32, gsc->base + GSC3280_REG_LCD_CTRL);
|
|
}
|
|
/* set data */
|
|
if (cursor->set & FB_CUR_SETPOS) {
|
|
unsigned int x = cursor->image.dx;
|
|
unsigned int y = cursor->image.dy;
|
|
if ((x >= 2048) || (y >= 2048))
|
|
return -EINVAL;
|
|
//y += cursor->image.height;
|
|
writel(x | (y << 16), gsc->base + GSC3280_REG_LCD_XYPOS);
|
|
}
|
|
if (cursor->set & FB_CUR_SETCMAP) {
|
|
unsigned int bg_col = cursor->image.bg_color;
|
|
unsigned int fg_col = cursor->image.fg_color;
|
|
bg = ((info->cmap.red[bg_col] & 0xF8) << 8) | ((info->cmap.green[bg_col] & 0xFC) << 3)
|
|
| ((info->cmap.blue[bg_col] & 0xF8) >> 3);
|
|
|
|
fg = ((info->cmap.red[fg_col] & 0xF8) << 8) | ((info->cmap.green[fg_col] & 0xFC) << 3)
|
|
| ((info->cmap.blue[fg_col] & 0xF8) >> 3);
|
|
memset((char *)hwc_addr, bg, cursor->image.dx * cursor->image.dy);
|
|
//memset(hwc_addr, fg, cursor->image.dx * cursor->image.dy);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int gsc3280fb_get_controller_bpp(struct gsc3280_fb *gsc)
|
|
{
|
|
switch (gsc->pdata->bpp) {
|
|
case 8:
|
|
return 8;
|
|
case 15:
|
|
case 16:
|
|
return 16;
|
|
default:
|
|
return gsc->pdata->bpp;
|
|
}
|
|
}
|
|
|
|
static struct fb_videomode *gsc3280fb_get_mode(struct gsc3280_fb *gsc, struct fb_var_screeninfo *var)
|
|
{
|
|
size_t i = 0;
|
|
struct fb_videomode *mode = gsc->pdata->modes;
|
|
|
|
for (i = 0; i < gsc->pdata->num_modes && mode != NULL; ++i, ++mode) {
|
|
if ((mode->xres == var->xres) && (mode->yres == var->yres)) {
|
|
return mode;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int gsc3280fb_check_var(struct fb_var_screeninfo *var, struct fb_info *fb)
|
|
{
|
|
int ret = 0;
|
|
struct fb_videomode *mode;
|
|
struct gsc3280_fb *gsc = fb->par;
|
|
|
|
if (var->bits_per_pixel != gsc3280fb_get_controller_bpp(gsc) &&
|
|
var->bits_per_pixel != gsc->pdata->bpp) {
|
|
ret = -EINVAL;
|
|
goto quit;
|
|
}
|
|
mode = gsc3280fb_get_mode(gsc, var);
|
|
if (mode == NULL) {
|
|
ret = -EINVAL;
|
|
goto quit;
|
|
}
|
|
fb_videomode_to_var(var, mode);
|
|
switch (gsc->pdata->bpp) {
|
|
case 8:
|
|
break;
|
|
case 15:
|
|
var->red.offset = 10;
|
|
var->red.length = 5;
|
|
var->green.offset = 6;
|
|
var->green.length = 5;
|
|
var->blue.offset = 0;
|
|
var->blue.length = 5;
|
|
break;
|
|
case 16:
|
|
var->red.offset = 11;
|
|
var->red.length = 5;
|
|
var->green.offset = 5;
|
|
var->green.length = 6;
|
|
var->blue.offset = 0;
|
|
var->blue.length = 5;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
quit:
|
|
return ret;
|
|
}
|
|
|
|
//set lcd control register
|
|
static int gsc3280fb_set_par(struct fb_info *info)
|
|
{
|
|
int ret = 0;
|
|
struct fb_videomode *mode;
|
|
struct gsc3280_fb *gsc = info->par;
|
|
struct fb_var_screeninfo *var = &info->var;
|
|
|
|
gsc->ctrl.w32 = 0;
|
|
switch (gsc->pdata->bpp) {
|
|
case 16:
|
|
gsc->ctrl.b.cd = 0;
|
|
break;
|
|
case 8:
|
|
gsc->ctrl.b.cd = 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!(gsc->pdata->modes->sync & FB_SYNC_HOR_HIGH_ACT))
|
|
gsc->ctrl.b.hsl = 1;
|
|
if (!(gsc->pdata->modes->sync & FB_SYNC_VERT_HIGH_ACT))
|
|
gsc->ctrl.b.vsl = 1;
|
|
gsc->ctrl.b.vml = 1;
|
|
writel(gsc->ctrl.w32, gsc->base + GSC3280_REG_LCD_CTRL);
|
|
|
|
mode = gsc3280fb_get_mode(gsc, var);
|
|
if (mode == NULL) {
|
|
ret = -EINVAL;
|
|
goto quit;
|
|
}
|
|
if (mode == info->mode) {
|
|
goto quit;
|
|
}
|
|
info->mode = mode;
|
|
gsc->htim.w32 = 0;
|
|
gsc->vtim.w32 = 0;
|
|
gsc->hvlen.w32 = 0;
|
|
gsc->htim.b.thgate0_15 = mode->xres - 1;
|
|
gsc->htim.b.thgdel16_23 = mode->left_margin;
|
|
gsc->htim.b.thsync24_31 = mode->hsync_len;
|
|
gsc->vtim.b.tvgate0_15 = mode->yres - 1;
|
|
gsc->vtim.b.tvgdel16_23 = mode->upper_margin;
|
|
gsc->vtim.b.tvsync24_31 = mode->vsync_len;
|
|
gsc->hvlen.b.tvlen0_15 = mode->vsync_len + mode->upper_margin + mode->lower_margin + mode->yres- 1;
|
|
gsc->hvlen.b.thlen16_31 = mode->hsync_len + mode->left_margin + mode->right_margin + mode->xres -1;
|
|
writel(gsc->htim.w32, gsc->base + GSC3280_REG_LCD_HTIM);
|
|
writel(gsc->vtim.w32, gsc->base + GSC3280_REG_LCD_VTIM);
|
|
writel(gsc->hvlen.w32, gsc->base + GSC3280_REG_LCD_HVLEN);
|
|
quit:
|
|
return 0;
|
|
}
|
|
|
|
static void gsc3280fb_enable(struct gsc3280_fb *gsc)
|
|
{
|
|
lcd_cen_u cen;
|
|
|
|
cen.w32 = 0;
|
|
cen.b.ven0 = 1;
|
|
writel(cen.w32, gsc->base + GSC3280_REG_LCD_CEN);
|
|
}
|
|
|
|
static void gsc3280fb_disable(struct gsc3280_fb *gsc)
|
|
{
|
|
lcd_cen_u cen;
|
|
u32 cnt = 1000;
|
|
|
|
cen.w32= readl(gsc->base + GSC3280_REG_LCD_CEN);
|
|
cen.b.ven0 = 0;
|
|
writel(cen.w32, gsc->base + GSC3280_REG_LCD_CEN);
|
|
do {
|
|
cen.w32 = readl(gsc->base + GSC3280_REG_LCD_CEN);
|
|
} while ((cen.b.ven0 == 1) && (cnt-- != 0));
|
|
}
|
|
|
|
static int gsc3280fb_blank(int blank_mode, struct fb_info *info)
|
|
{
|
|
unsigned long flags = 0;
|
|
struct gsc3280_fb *gsc = info->par;
|
|
|
|
spin_lock_irqsave(&gsc->slock, flags);
|
|
switch (blank_mode) {
|
|
case FB_BLANK_UNBLANK:
|
|
if (gsc->is_enabled) {
|
|
goto exit;
|
|
}
|
|
gsc3280fb_enable(gsc);
|
|
gsc->is_enabled = 1;
|
|
break;
|
|
default:
|
|
if (!gsc->is_enabled) {
|
|
goto exit;
|
|
}
|
|
gsc3280fb_disable(gsc);
|
|
gsc->is_enabled = 0;
|
|
break;
|
|
}
|
|
exit:
|
|
spin_unlock_irqrestore(&gsc->slock, flags);
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
static int gsc3280fb_pan_display(struct fb_var_screeninfo *var,
|
|
struct fb_info *info)
|
|
{
|
|
struct gsc3280_fb *par = info->par;
|
|
u32 vram_addr = par->vram_addr + (var->yoffset * info->fix.line_length
|
|
+ var->xoffset * info->var.bits_per_pixel / 8) ;
|
|
DEBUG_MSG(KERN_DEBUG "viafb_pan_display, address = %d\n", vram_addr);
|
|
if (is_first_display) {
|
|
//gsc3280_set_primary_address(vram_addr);
|
|
}
|
|
else
|
|
//gsc3280_set_secondary_address(vram_addr);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static struct fb_ops gsc3280fb_ops = {
|
|
.owner = THIS_MODULE,
|
|
.fb_check_var = gsc3280fb_check_var,
|
|
.fb_set_par = gsc3280fb_set_par,
|
|
.fb_blank = gsc3280fb_blank,
|
|
//.fb_pan_display = gsc3280_pan_display,
|
|
.fb_cursor = gsc3280fb_cursor,
|
|
.fb_fillrect = sys_fillrect,
|
|
.fb_copyarea = sys_copyarea,
|
|
.fb_imageblit = sys_imageblit,
|
|
};
|
|
|
|
static int __devinit gsc3280fb_alloc_dmamem(struct gsc3280_fb *gsc)
|
|
{
|
|
u32 i = 0, max_videosize = 0;
|
|
struct fb_videomode *mode = gsc->pdata->modes;
|
|
|
|
for (i = 0; i < gsc->pdata->num_modes; mode++, i++) {
|
|
if (max_videosize < mode->xres * mode->yres)
|
|
max_videosize = mode->xres * mode->yres;
|
|
}
|
|
max_videosize *= gsc3280fb_get_controller_bpp(gsc) >> 3;
|
|
gsc->vidmem_size = PAGE_ALIGN(max_videosize);
|
|
gsc->vidmem = dma_alloc_coherent(gsc->dev, gsc->vidmem_size, &gsc->dma_addr, GFP_KERNEL);
|
|
if (!gsc->vidmem)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
static void gsc3280fb_free_devmem(struct gsc3280_fb *gsc)
|
|
{
|
|
dma_free_coherent(gsc->dev, gsc->vidmem_size, gsc->vidmem, gsc->dma_addr);
|
|
}
|
|
|
|
static int __devinit gsc3280fb_probe(struct platform_device *pdev)
|
|
{
|
|
int ret = 0;
|
|
struct fb_info *fb = NULL;
|
|
struct gsc3280_fb *gsc = NULL;
|
|
struct gsc3280_fb_platform_data *pdata = pdev->dev.platform_data;
|
|
|
|
DBG("############\n");
|
|
printk(KERN_INFO "gsc3280_lcdfb_probe start.\n");
|
|
if (!pdata) {
|
|
DBG("Missing platform data\n");
|
|
return -ENXIO;
|
|
}
|
|
|
|
#ifdef CONFIG_FB_GSC3280_SVGA
|
|
*(volatile unsigned int *)0xbc04a024 = 0x04;
|
|
#else
|
|
*(volatile unsigned int *)0xbc04a024 = 0x05;
|
|
#endif
|
|
|
|
fb = framebuffer_alloc(sizeof(struct gsc3280_fb), &pdev->dev);
|
|
if (!fb) {
|
|
DBG("Failed to allocate framebuffer device!!!!\n");
|
|
return -ENOMEM;
|
|
}
|
|
fb->flags = FBINFO_DEFAULT;
|
|
fb->fbops = &gsc3280fb_ops;
|
|
gsc = fb->par;
|
|
gsc->pdata = pdata;
|
|
gsc->dev = &pdev->dev;
|
|
|
|
gsc->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
if (!gsc->mem) {
|
|
DBG("Failed to get register memory resource!!!!\n");
|
|
ret = -ENXIO;
|
|
goto err_framebuffer_alloc;
|
|
}
|
|
gsc->mem = request_mem_region(gsc->mem->start, resource_size(gsc->mem), pdev->name);
|
|
if (!gsc->mem) {
|
|
DBG("Failed to request register memory region!!!!\n");
|
|
ret = -EBUSY;
|
|
goto err_framebuffer_alloc;
|
|
}
|
|
|
|
gsc->base = ioremap(gsc->mem->start, resource_size(gsc->mem));
|
|
if (!gsc->base) {
|
|
DBG("Failed to ioremap register memory region!!!!\n");
|
|
ret = -EBUSY;
|
|
goto err_release_mem_region;
|
|
}
|
|
DBG("gsc->base = %p\n", gsc->base);
|
|
gsc->pseudo_palette = gsc->base + GSC3280_REG_LCD_PLATE;
|
|
DBG("gsc->pseudo_palette = %p\n", gsc->pseudo_palette);
|
|
|
|
gsc->clk = clk_get(NULL, "lcd");
|
|
if (IS_ERR(gsc->clk)) {
|
|
DBG("failed to find watchdog clock source!!!!\n");
|
|
ret = -ENXIO;
|
|
goto err_iounmap;
|
|
}
|
|
DBG("lcd clk rate is %ld\n", clk_get_rate(gsc->clk));
|
|
clk_enable(gsc->clk);
|
|
platform_set_drvdata(pdev, gsc);
|
|
spin_lock_init(&gsc->slock);
|
|
fb_videomode_to_modelist(pdata->modes, pdata->num_modes, &fb->modelist);
|
|
fb_videomode_to_var(&fb->var, pdata->modes);
|
|
fb->var.bits_per_pixel = pdata->bpp;
|
|
ret = gsc3280fb_check_var(&fb->var, fb);
|
|
if (ret < 0) {
|
|
DBG("gsc3280fb_check_var error!!!!\n");
|
|
goto err_put_lpclk;
|
|
}
|
|
ret = gsc3280fb_alloc_dmamem(gsc);
|
|
if (ret) {
|
|
DBG("Failed to allocate video memory!!!!\n");
|
|
goto err_put_lpclk;
|
|
}
|
|
fb->fix = gsc3280fb_fix;
|
|
fb->fix.line_length = fb->var.bits_per_pixel * fb->var.xres / 8;
|
|
fb->fix.mmio_start = gsc->mem->start;
|
|
fb->fix.mmio_len = resource_size(gsc->mem);
|
|
fb->fix.smem_start = gsc->dma_addr;
|
|
fb->fix.smem_len = fb->fix.line_length * fb->var.yres;
|
|
fb->screen_base = gsc->vidmem;
|
|
fb->pseudo_palette = gsc->pseudo_palette;
|
|
fb_alloc_cmap(&fb->cmap, 256, 0);
|
|
gsc->is_enabled = 1;
|
|
gsc->suspend_flg = 0;
|
|
writel(gsc->dma_addr, gsc->base + GSC3280_REG_LCD_VBAR);
|
|
fb->mode = NULL;
|
|
ret = register_framebuffer(fb);
|
|
if (ret) {
|
|
DBG("Failed to register framebuffer!!!!\n");
|
|
goto err_free_devmem;
|
|
}
|
|
gsc->fb = fb;
|
|
gsc3280fb_set_par(fb);
|
|
|
|
#ifdef CONFIG_PM
|
|
/* set pm runtime power state and register with power system */
|
|
pm_runtime_set_active(gsc->dev);
|
|
pm_runtime_enable(gsc->dev);
|
|
pm_runtime_resume(gsc->dev);
|
|
//device_init_wakeup(gsc->dev, 1);
|
|
#endif
|
|
|
|
#ifdef CONFIG_FB_GSC3280_VGA
|
|
DBG("init vga mode");
|
|
my_vga_mode = 1;
|
|
writel(0xd78704ff, gsc->base + GSC3280_REG_LCD_HTIM);
|
|
writel(0x1d0203bf, gsc->base + GSC3280_REG_LCD_VTIM);
|
|
writel(0x06b003e2, gsc->base + GSC3280_REG_LCD_HVLEN);
|
|
#endif
|
|
|
|
gsc3280fb_enable(gsc);
|
|
printk(KERN_INFO "gsc3280_lcdfb_probe success\n");
|
|
DBG("############\n");
|
|
return 0;
|
|
|
|
err_free_devmem:
|
|
fb_dealloc_cmap(&fb->cmap);
|
|
gsc3280fb_free_devmem(gsc);
|
|
err_put_lpclk:
|
|
clk_put(gsc->clk);
|
|
err_iounmap:
|
|
iounmap(gsc->base);
|
|
iounmap(gsc->pseudo_palette);
|
|
err_release_mem_region:
|
|
release_mem_region(gsc->mem->start, resource_size(gsc->mem));
|
|
err_framebuffer_alloc:
|
|
framebuffer_release(fb);
|
|
printk(KERN_INFO "!!!!!!gsc3280_lcdfb_probe error!!!!!!\n");
|
|
return ret;
|
|
}
|
|
|
|
static int __devexit gsc3280fb_remove(struct platform_device *pdev)
|
|
{
|
|
struct gsc3280_fb *gsc = platform_get_drvdata(pdev);
|
|
|
|
gsc3280fb_blank(FB_BLANK_POWERDOWN, gsc->fb);
|
|
iounmap(gsc->base);
|
|
release_mem_region(gsc->mem->start, resource_size(gsc->mem));
|
|
fb_dealloc_cmap(&gsc->fb->cmap);
|
|
gsc3280fb_free_devmem(gsc);
|
|
platform_set_drvdata(pdev, NULL);
|
|
clk_put(gsc->clk);
|
|
framebuffer_release(gsc->fb);
|
|
return 0;
|
|
}
|
|
|
|
static void gsc3280fb_shutdown(struct platform_device *pdev)
|
|
{
|
|
//struct gsc3280_fb *gsc = platform_get_drvdata(pdev);
|
|
|
|
DBG("gsc3280fb_shutdown\n");
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int gsc3280fb_suspend(struct device *dev)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct gsc3280_fb *gsc = platform_get_drvdata(pdev);
|
|
|
|
printk(KERN_INFO "gsc3280 fb suspend\n");
|
|
if (gsc->suspend_flg == 1) {
|
|
#ifdef CONFIG_GSC3280_1WIRE_TS
|
|
wire1_backlight_control(0); //close backlight
|
|
#endif
|
|
gsc3280fb_disable(gsc);
|
|
clk_disable(gsc->clk);
|
|
} else {
|
|
gsc->suspend_flg = 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int gsc3280fb_resume(struct device *dev)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(dev);
|
|
struct gsc3280_fb *gsc = platform_get_drvdata(pdev);
|
|
|
|
printk(KERN_INFO "gsc3280 fb resume\n");
|
|
|
|
#ifdef CONFIG_FB_GSC3280_SVGA
|
|
*(volatile unsigned int *)0xbc04a024 = 0x04;
|
|
#else
|
|
*(volatile unsigned int *)0xbc04a024 = 0x05;
|
|
#endif
|
|
|
|
clk_enable(gsc->clk);
|
|
//soft reset
|
|
*(volatile unsigned int *)0xbc04a014 = *(volatile unsigned int *)0xbc04a014 | (1 << 1);
|
|
mdelay(5);
|
|
*(volatile unsigned int *)0xbc04a014 = *(volatile unsigned int *)0xbc04a014 & (~(1 << 1));
|
|
mdelay(1);
|
|
writel(gsc->dma_addr, gsc->base + GSC3280_REG_LCD_VBAR);
|
|
writel(gsc->ctrl.w32, gsc->base + GSC3280_REG_LCD_CTRL);
|
|
writel(gsc->htim.w32, gsc->base + GSC3280_REG_LCD_HTIM);
|
|
writel(gsc->vtim.w32, gsc->base + GSC3280_REG_LCD_VTIM);
|
|
writel(gsc->hvlen.w32, gsc->base + GSC3280_REG_LCD_HVLEN);
|
|
|
|
#ifdef CONFIG_FB_GSC3280_VGA
|
|
DBG("init vga mode");
|
|
my_vga_mode = 1;
|
|
writel(0xd78704ff, gsc->base + GSC3280_REG_LCD_HTIM);
|
|
writel(0x1d0203bf, gsc->base + GSC3280_REG_LCD_VTIM);
|
|
writel(0x06b003e2, gsc->base + GSC3280_REG_LCD_HVLEN);
|
|
#endif
|
|
|
|
mdelay(2);
|
|
gsc3280fb_enable(gsc);
|
|
|
|
#ifdef CONFIG_GSC3280_1WIRE_TS
|
|
wire1_backlight_control(127); //open backlight
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
#define gsc3280fb_suspend NULL
|
|
#define gsc3280fb_resume NULL
|
|
#endif //end #ifdef CONFIG_PM
|
|
|
|
|
|
static const struct dev_pm_ops gsc3280fb_pm_ops = {
|
|
.suspend = gsc3280fb_suspend,
|
|
.resume = gsc3280fb_resume,
|
|
.runtime_suspend = gsc3280fb_suspend,
|
|
.runtime_resume = gsc3280fb_resume,
|
|
};
|
|
|
|
static struct platform_driver gsc3280fb_driver = {
|
|
.probe = gsc3280fb_probe,
|
|
.remove = __devexit_p(gsc3280fb_remove),
|
|
.shutdown = gsc3280fb_shutdown,
|
|
.driver = {
|
|
.name = "gsc3280-lcdfb",
|
|
.pm = &gsc3280fb_pm_ops,
|
|
},
|
|
};
|
|
|
|
static int __init gsc3280fb_init(void)
|
|
{
|
|
return platform_driver_register(&gsc3280fb_driver);
|
|
}
|
|
static void __exit gsc3280fb_exit(void)
|
|
{
|
|
platform_driver_unregister(&gsc3280fb_driver);
|
|
}
|
|
subsys_initcall(gsc3280fb_init);
|
|
device_exit(gsc3280fb_exit);
|
|
|
|
//device_init(gsc3280fb_init);
|
|
//device_exit(gsc3280fb_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Davie <apple_guet@126.com>");
|
|
MODULE_DESCRIPTION("GSC3280 SoC LCD framebuffer driver");
|
|
MODULE_ALIAS("platform:gsc3280-fb");
|
|
|