/*
 * drivers/drivers/video/ambarella/ambarella_fb.c
 *
 *	2008/07/22 - [linnsong] Create
 *	2009/03/03 - [Anthony Ginger] Port to 2.6.28
 *	2009/12/15 - [Zhenwu Xue] Change fb_setcmap
 *
 * Copyright (C) 2004-2009, Ambarella, Inc.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/mm.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/list.h>
#include <linux/amba/bus.h>
#include <linux/amba/clcd.h>
#include <linux/clk.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_fdt.h>

#include <asm/sizes.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/page.h>
#include <asm/pgtable.h>

#include <mach/init.h>
#include <plat/fb.h>

/* video=amb0fb:<x_res>x<y_res>,<x_virtual>x<y_virtual>,
   <color_format>,<conversion_buffer>[,<prealloc_start>,<prealloc_length>] */

#include "ambarella_fb_tbl.c"

/* ========================================================================== */
#ifdef CONFIG_PROC_FS
static int ambarella_fb_proc_show(struct seq_file *m, void *v)
{
        int len;
        struct ambarella_platform_fb *ambfb_data;
        struct fb_info *info;

        ambfb_data = (struct ambarella_platform_fb *)m->private;
        info = ambfb_data->proc_fb_info;

        wait_event_interruptible(ambfb_data->proc_wait,
                                 (ambfb_data->proc_wait_flag > 0));
        ambfb_data->proc_wait_flag = 0;
        dev_dbg(info->device, "%s:%d %d.\n", __func__, __LINE__,
                ambfb_data->proc_wait_flag);
        len = seq_printf(m, "%04d %04d %04d %04d %04d %04d\n",
                         info->var.xres, info->var.yres,
                         info->fix.line_length,
                         info->var.xoffset, info->var.yoffset,
                         ambfb_data->color_format);

        return len;
}

static int ambarella_fb_proc_open(struct inode *inode, struct file *file)
{
        return single_open(file, ambarella_fb_proc_show, PDE_DATA(inode));
}

static const struct file_operations ambarella_fb_fops = {
        .open = ambarella_fb_proc_open,
        .read = seq_read,
        .llseek = seq_lseek,
};
#endif

/* ========================================================================== */
static int ambfb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
        int					errorCode = 0;
        struct ambarella_platform_fb		*ambfb_data;
        int					pos;
        u16					*r, *g, *b, *t;
        u8					*pclut_table, *pblend_table;

        if (cmap == &info->cmap) {
                errorCode = 0;
                goto ambfb_setcmap_exit;
        }

        if (cmap->start != 0 || cmap->len != 256) {
                dev_dbg(info->device,
                        "%s: Incorrect parameters: start = %d, len = %d\n",
                        __func__, cmap->start, cmap->len);
                errorCode = -1;
                goto ambfb_setcmap_exit;
        }

        if (!cmap->red || !cmap->green || !cmap->blue) {
                dev_dbg(info->device, "%s: Incorrect rgb pointers!\n",
                        __func__);
                errorCode = -1;
                goto ambfb_setcmap_exit;
        }

        ambfb_data = (struct ambarella_platform_fb *)info->par;

        mutex_lock(&ambfb_data->lock);

        r = cmap->red;
        g = cmap->green;
        b = cmap->blue;
        t = cmap->transp;
        pclut_table = ambfb_data->clut_table;
        pblend_table = ambfb_data->blend_table;
        for (pos = 0; pos < 256; pos++) {
                *pclut_table++ = *r++;
                *pclut_table++ = *g++;
                *pclut_table++ = *b++;
                if (t) *pblend_table++ = *t++;
        }

        if (ambfb_data->setcmap) {
                mutex_unlock(&ambfb_data->lock);
                errorCode = ambfb_data->setcmap(cmap, info);
        } else {
                mutex_unlock(&ambfb_data->lock);
        }

ambfb_setcmap_exit:
        dev_dbg(info->device, "%s:%d %d.\n", __func__, __LINE__, errorCode);
        return errorCode;
}

static int ambfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
{
        int					errorCode = 0;
        struct ambarella_platform_fb		*ambfb_data;
        u32					framesize = 0;

        ambfb_data = (struct ambarella_platform_fb *)info->par;

        mutex_lock(&ambfb_data->lock);
        if (ambfb_data->check_var) {
                errorCode = ambfb_data->check_var(var, info);
        }
        mutex_unlock(&ambfb_data->lock);

        if (var->xres_virtual * var->bits_per_pixel / 8 > info->fix.line_length) {
                errorCode = -ENOMEM;
                dev_err(info->device, "%s: xres_virtual[%d] too big [%d]!\n",
                        __func__, var->xres_virtual * var->bits_per_pixel / 8,
                        info->fix.line_length);
        }

        framesize = info->fix.line_length * var->yres_virtual;
        if (framesize > info->fix.smem_len) {
                errorCode = -ENOMEM;
                dev_err(info->device, "%s: framesize[%d] too big [%d]!\n",
                        __func__, framesize, info->fix.smem_len);
        }

        dev_dbg(info->device, "%s:%d %d.\n", __func__, __LINE__, errorCode);

        return errorCode;
}

static int ambfb_set_par(struct fb_info *info)
{
        int					errorCode = 0, i;
        struct ambarella_platform_fb		*ambfb_data;
        struct fb_var_screeninfo		*pvar;
        static struct fb_var_screeninfo		*cur_var;
        int					res_changed = 0;
        int					color_format_changed = 0;
        enum ambarella_fb_color_format		new_color_format;
        const struct ambarella_fb_color_table	*pTable;

        ambfb_data = (struct ambarella_platform_fb *)info->par;
        mutex_lock(&ambfb_data->lock);
        cur_var = &ambfb_data->screen_var;
        pvar = &info->var;

        if (!ambfb_data->set_par)
                goto ambfb_set_par_quick_exit;

        /* Resolution changed */
        if (pvar->xres != cur_var->xres || pvar->yres != cur_var->yres) {
                res_changed = 1;
        }

        /* Color format changed */
        if (pvar->bits_per_pixel != cur_var->bits_per_pixel ||
            pvar->red.offset != cur_var->red.offset ||
            pvar->red.length != cur_var->red.length ||
            pvar->red.msb_right != cur_var->red.msb_right ||
            pvar->green.offset != cur_var->green.offset ||
            pvar->green.length != cur_var->green.length ||
            pvar->green.msb_right != cur_var->green.msb_right ||
            pvar->blue.offset != cur_var->blue.offset ||
            pvar->blue.length != cur_var->blue.length ||
            pvar->blue.msb_right != cur_var->blue.msb_right ||
            pvar->transp.offset != cur_var->transp.offset ||
            pvar->transp.length != cur_var->transp.length ||
            pvar->transp.msb_right != cur_var->transp.msb_right) {

                color_format_changed = 1;
        }

        if (!res_changed && !color_format_changed)
                goto ambfb_set_par_quick_exit;

        /* Find color format */
        new_color_format = ambfb_data->color_format;
        pTable = ambarella_fb_color_format_table;
        for (i = 0; i < ARRAY_SIZE(ambarella_fb_color_format_table); i++) {
                if (pTable->bits_per_pixel == pvar->bits_per_pixel &&
                    pTable->red.offset == pvar->red.offset &&
                    pTable->red.length == pvar->red.length &&
                    pTable->red.msb_right == pvar->red.msb_right &&
                    pTable->green.offset == pvar->green.offset &&
                    pTable->green.length == pvar->green.length &&
                    pTable->green.msb_right == pvar->green.msb_right &&
                    pTable->blue.offset == pvar->blue.offset &&
                    pTable->blue.length == pvar->blue.length &&
                    pTable->blue.msb_right == pvar->blue.msb_right &&
                    pTable->transp.offset == pvar->transp.offset &&
                    pTable->transp.length == pvar->transp.length &&
                    pTable->transp.msb_right == pvar->transp.msb_right) {

                        new_color_format = pTable->color_format;
                        break;
                }
                pTable++;
        }

        ambfb_data->color_format = new_color_format;
        memcpy(cur_var, pvar, sizeof(*pvar));
        mutex_unlock(&ambfb_data->lock);

        errorCode = ambfb_data->set_par(info);
        goto ambfb_set_par_normal_exit;

ambfb_set_par_quick_exit:
        memcpy(cur_var, pvar, sizeof(*pvar));
        mutex_unlock(&ambfb_data->lock);

ambfb_set_par_normal_exit:
        dev_dbg(info->device, "%s:%d %d.\n", __func__, __LINE__, errorCode);

        return errorCode;
}

static int ambfb_pan_display(struct fb_var_screeninfo *var,
                             struct fb_info *info)
{
        int					errorCode = 0;
        struct ambarella_platform_fb		*ambfb_data;

        ambfb_data = (struct ambarella_platform_fb *)info->par;

        ambfb_data->proc_wait_flag++;
        wake_up(&(ambfb_data->proc_wait));
        mutex_lock(&ambfb_data->lock);
        ambfb_data->screen_var.xoffset = var->xoffset;
        ambfb_data->screen_var.yoffset = var->yoffset;
        if (ambfb_data->pan_display) {
                errorCode = ambfb_data->pan_display(var, info);
        }
        mutex_unlock(&ambfb_data->lock);

        dev_dbg(info->device, "%s:%d %d.\n", __func__, __LINE__, errorCode);

        return 0;
}

static int ambfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
{
        unsigned long size = vma->vm_end - vma->vm_start;
        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
        struct ambarella_platform_fb *ambfb_data = NULL;

        ambfb_data = ambfb_data_ptr[info->dev->id];

        if (offset + size > info->fix.smem_len)
                return -EINVAL;

        offset += info->fix.smem_start;

        if(ambfb_data->conversion_buf.available)
                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
        if (remap_pfn_range(vma, vma->vm_start, offset >> PAGE_SHIFT,
                            size, vma->vm_page_prot))
                return -EAGAIN;

        dev_dbg(info->device, "%s: P(0x%08lx)->V(0x%08lx), size = 0x%08lx.\n",
                __func__, offset, vma->vm_start, size);

        return 0;
}

static int ambfb_blank(int blank_mode, struct fb_info *info)
{
        int					errorCode = 0;
        struct ambarella_platform_fb		*ambfb_data;

        ambfb_data = (struct ambarella_platform_fb *)info->par;

        mutex_lock(&ambfb_data->lock);
        if (ambfb_data->set_blank) {
                errorCode = ambfb_data->set_blank(blank_mode, info);
        }
        mutex_unlock(&ambfb_data->lock);

        dev_dbg(info->device, "%s:%d %d.\n", __func__, __LINE__, errorCode);

        return errorCode;
}

static struct fb_ops ambfb_ops = {
        .owner          = THIS_MODULE,
        .fb_check_var	= ambfb_check_var,
        .fb_set_par	= ambfb_set_par,
        .fb_pan_display	= ambfb_pan_display,
        .fb_fillrect	= sys_fillrect,
        .fb_copyarea	= sys_copyarea,
        .fb_imageblit	= sys_imageblit,
        .fb_mmap	= ambfb_mmap,
        .fb_setcmap	= ambfb_setcmap,
        .fb_blank	= ambfb_blank,
};

static int ambfb_setup(struct device *dev, char *options,
                       struct ambarella_platform_fb *ambfb_data)
{
        int					retval = -1;
        int					ssret;
        int					cl_xres;
        int					cl_yres;
        int					cl_xvirtual;
        int					cl_yvirtual;
        int					cl_format;
        int					cl_cvs_buf;
        unsigned int				cl_prealloc_start;
        unsigned int				cl_prealloc_length;

        if (!options || !*options) {
                goto ambfb_setup_exit;
        }

        ssret = sscanf(options, "%dx%d,%dx%d,%d,%d,%x,%x", &cl_xres, &cl_yres,
                       &cl_xvirtual, &cl_yvirtual, &cl_format, &cl_cvs_buf,
                       &cl_prealloc_start, &cl_prealloc_length);
        if (ssret == 6) {
                ambfb_data->screen_var.xres = cl_xres;
                ambfb_data->screen_var.yres = cl_yres;
                ambfb_data->screen_var.xres_virtual = cl_xvirtual;
                ambfb_data->screen_var.yres_virtual = cl_yvirtual;
                ambfb_data->color_format = cl_format;
                ambfb_data->conversion_buf.available = cl_cvs_buf;
                dev_dbg(dev, "%dx%d,%dx%d,%d,%d\n", cl_xres, cl_yres,
                        cl_xvirtual, cl_yvirtual, cl_format, cl_cvs_buf);
                retval = 0;
        } else if (ssret == 8) {
                ambfb_data->screen_var.xres = cl_xres;
                ambfb_data->screen_var.yres = cl_yres;
                ambfb_data->screen_var.xres_virtual = cl_xvirtual;
                ambfb_data->screen_var.yres_virtual = cl_yvirtual;
                ambfb_data->color_format = cl_format;
                ambfb_data->conversion_buf.available = cl_cvs_buf;

                ambfb_data->screen_fix.smem_start = cl_prealloc_start;
                ambfb_data->screen_fix.smem_len = cl_prealloc_length;
                ambfb_data->use_prealloc = 1;
                dev_dbg(dev, "%dx%d,%dx%d,%d,%d,%x,%x\n", cl_xres, cl_yres,
                        cl_xvirtual, cl_yvirtual, cl_format, cl_cvs_buf,
                        cl_prealloc_start, cl_prealloc_length);
                retval = 0;
        } else {
                dev_err(dev, "Can not support %s@%d!\n", options, ssret);
        }

ambfb_setup_exit:
        return retval;
}

static int ambfb_probe(struct platform_device *pdev)
{
        int                                errorCode = 0;
        struct fb_info                     *info;
        char                               fb_name[64];
        char                               *option;
        struct ambarella_platform_fb       *ambfb_data = NULL;
        u32                                i, framesize, line_length;

        ambfb_data = ambfb_data_ptr[pdev->id];

        snprintf(fb_name, sizeof(fb_name), "amb%dfb", pdev->id);
        if (fb_get_options(fb_name, &option)) {
                dev_err(&pdev->dev, "%s: get fb options fail!\n", __func__);
                errorCode = -ENODEV;
                goto ambfb_probe_exit;
        }
        if (ambfb_setup(&pdev->dev, option, ambfb_data)) {
                errorCode = -ENODEV;
                goto ambfb_probe_exit;
        }

        info = framebuffer_alloc(sizeof(ambfb_data), &pdev->dev);
        if (info == NULL) {
                dev_err(&pdev->dev, "%s: framebuffer_alloc fail!\n", __func__);
                errorCode = -ENOMEM;
                goto ambfb_probe_exit;
        }

        if(get_ambarella_fbmem_size()) {
                ambfb_data->use_prealloc = 1;
                ambfb_data->conversion_buf.available = 1;
                if((ambfb_data->screen_fix.smem_start == 0) ||
                        (ambfb_data->screen_fix.smem_len == 0) ||
                        (ambfb_data->screen_fix.smem_len > get_ambarella_fbmem_size())) {
                        errorCode = -EINVAL;
                        dev_err(&pdev->dev, "please set right fbmem start address in dts file\n");
                        goto ambfb_probe_release_framebuffer;
                }
        } else {
                ambfb_data->use_prealloc = 0;
                ambfb_data->conversion_buf.available = 0;
        }

        mutex_lock(&ambfb_data->lock);

        info->fbops = &ambfb_ops;
        info->par = ambfb_data;
        info->var = ambfb_data->screen_var;
        info->fix = ambfb_data->screen_fix;
        info->flags = FBINFO_FLAG_DEFAULT;

        /* Fill Color-related Variables */
        for (i = 0; i < ARRAY_SIZE(ambarella_fb_color_format_table); i++) {
                if (ambarella_fb_color_format_table[i].color_format ==
                    ambfb_data->color_format)
                        break;
        }
        if (i < ARRAY_SIZE(ambarella_fb_color_format_table)) {
                info->var.bits_per_pixel =
                        ambarella_fb_color_format_table[i].bits_per_pixel;
                info->var.red = ambarella_fb_color_format_table[i].red;
                info->var.green = ambarella_fb_color_format_table[i].green;
                info->var.blue = ambarella_fb_color_format_table[i].blue;
                info->var.transp = ambarella_fb_color_format_table[i].transp;
        } else {
                dev_err(&pdev->dev, "%s: do not support color formate:%d!\n",
                        __func__, ambfb_data->color_format);
                errorCode = -EINVAL;
                goto ambfb_probe_release_framebuffer;
        }

        /* Malloc Framebuffer Memory */
        line_length = (info->var.xres_virtual *
                       (info->var.bits_per_pixel / 8) + 31) & 0xffffffe0;
        if (ambfb_data->use_prealloc == 0) {
                info->fix.line_length = line_length;
        } else {
                info->fix.line_length =
                        (line_length > ambfb_data->prealloc_line_length) ?
                        line_length : ambfb_data->prealloc_line_length;
        }

        framesize = info->fix.line_length * info->var.yres_virtual;
        if (framesize % PAGE_SIZE) {
                framesize /= PAGE_SIZE;
                framesize++;
                framesize *= PAGE_SIZE;
        }

        if (ambfb_data->use_prealloc == 0) {
                info->screen_base = kzalloc(framesize, GFP_KERNEL);
                if (info->screen_base == NULL) {
                        dev_err(&pdev->dev, "%s(%d): Can't get %d bytes fbmem!\n",
                                __func__, __LINE__, framesize);
                        errorCode = -ENOMEM;
                        goto ambfb_probe_release_framebuffer;
                }
                info->fix.smem_start = virt_to_phys(info->screen_base);
                info->fix.smem_len = framesize;
        } else {
                if ((info->fix.smem_start == 0) ||
                    (info->fix.smem_len < framesize)) {
                        dev_err(&pdev->dev, "%s: prealloc[0x%08x < 0x%08x]!\n",
                                __func__, info->fix.smem_len, framesize);
                        errorCode = -ENOMEM;
                        goto ambfb_probe_release_framebuffer;
                }

                info->screen_base = ioremap(info->fix.smem_start, info->fix.smem_len);
                memset(info->screen_base, 0, info->fix.smem_len);
                if (!info->screen_base) {
                        dev_err(&pdev->dev, "%s: ioremap() failed\n", __func__);
                        errorCode = -ENOMEM;
                        goto ambfb_probe_exit;
                }

                if (ambfb_data->conversion_buf.available) {
                        ambfb_data->conversion_buf.base_buf_phy =
                                ambfb_data->screen_fix.smem_start;
                }
        }

        errorCode = fb_alloc_cmap(&info->cmap, 256, 1);
        if (errorCode < 0) {
                dev_err(&pdev->dev, "%s: fb_alloc_cmap fail!\n", __func__);
                errorCode = -ENOMEM;
                goto ambfb_probe_release_framebuffer;
        }
        for (i = info->cmap.start; i < info->cmap.len; i++) {
                info->cmap.red[i] = i << 8;
                info->cmap.green[i] = 128 << 8;
                info->cmap.blue[i] = 128 << 8;
                if (info->cmap.transp)
                        info->cmap.transp[i] = 12 << 8;
        }

        platform_set_drvdata(pdev, info);
        ambfb_data->fb_status = AMBFB_ACTIVE_MODE;
        mutex_unlock(&ambfb_data->lock);

        errorCode = register_framebuffer(info);
        if (errorCode < 0) {
                dev_err(&pdev->dev, "%s: register_framebuffer fail!\n",
                        __func__);
                errorCode = -ENOMEM;
                mutex_lock(&ambfb_data->lock);
                goto ambfb_probe_dealloc_cmap;
        }

        ambfb_data->proc_fb_info = info;

#ifdef CONFIG_PROC_FS
        ambfb_data->proc_file = proc_create_data(dev_name(&pdev->dev),
                                                 (S_IRUGO | S_IWUSR), get_ambarella_proc_dir(),
                                                 &ambarella_fb_fops, ambfb_data);
        if (ambfb_data->proc_file == NULL) {
                errorCode = -ENOMEM;
                goto ambfb_probe_unregister_framebuffer;
        }
#endif

        mutex_lock(&ambfb_data->lock);
        ambfb_data->screen_var = info->var;
        ambfb_data->screen_fix = info->fix;
        mutex_unlock(&ambfb_data->lock);

        dev_info(&pdev->dev,
                 "probe p[%dx%d] v[%dx%d] c[%d] b[%d] l[%d] @ [0x%08lx:0x%08x],base:0x%p!\n",
                 info->var.xres, info->var.yres, info->var.xres_virtual,
                 info->var.yres_virtual, ambfb_data->color_format,
                 ambfb_data->conversion_buf.available,
                 info->fix.line_length,
                 info->fix.smem_start, info->fix.smem_len, info->screen_base);
        goto ambfb_probe_exit;

ambfb_probe_unregister_framebuffer:
        unregister_framebuffer(info);

ambfb_probe_dealloc_cmap:
        fb_dealloc_cmap(&info->cmap);

ambfb_probe_release_framebuffer:
        framebuffer_release(info);
        ambfb_data->fb_status = AMBFB_STOP_MODE;
        mutex_unlock(&ambfb_data->lock);

ambfb_probe_exit:
        return errorCode;
}

static int ambfb_remove(struct platform_device *pdev)
{
        struct fb_info				*info;
        struct ambarella_platform_fb		*ambfb_data = NULL;

        info = platform_get_drvdata(pdev);
        if (info) {
                ambfb_data = (struct ambarella_platform_fb *)info->par;

#ifdef CONFIG_PROC_FS
                proc_remove(ambfb_data->proc_file);
#endif
                unregister_framebuffer(info);

                mutex_lock(&ambfb_data->lock);
                ambfb_data->fb_status = AMBFB_STOP_MODE;
                fb_dealloc_cmap(&info->cmap);
                if (ambfb_data->use_prealloc == 0) {
                        if (info->screen_base) {
                                kfree(info->screen_base);
                        }
                        if (ambfb_data->conversion_buf.available) {
                                if (ambfb_data->conversion_buf.ping_buf) {
                                        kfree(ambfb_data->conversion_buf.ping_buf);
                                }
                                if (ambfb_data->conversion_buf.pong_buf) {
                                        kfree(ambfb_data->conversion_buf.pong_buf);
                                }
                        }
                        ambfb_data->screen_fix.smem_start = 0;
                        ambfb_data->screen_fix.smem_len = 0;
                }
                framebuffer_release(info);
                mutex_unlock(&ambfb_data->lock);
        }

        return 0;
}

#ifdef CONFIG_PM
static int ambfb_suspend(struct platform_device *pdev, pm_message_t state)
{
        int					errorCode = 0;

        dev_dbg(&pdev->dev, "%s exit with %d @ %d\n",
                __func__, errorCode, state.event);

        return errorCode;
}

static int ambfb_resume(struct platform_device *pdev)
{
        int					errorCode = 0;

        dev_dbg(&pdev->dev, "%s exit with %d\n", __func__, errorCode);

        return errorCode;
}
#endif

static struct platform_driver ambfb_driver = {
        .probe		= ambfb_probe,
        .remove 	= ambfb_remove,
#ifdef CONFIG_PM
        .suspend        = ambfb_suspend,
        .resume		= ambfb_resume,
#endif
        .driver = {
                .name	= "ambarella-fb",
        },
};

static struct platform_device ambarella_fb0 = {
        .name			= "ambarella-fb",
        .id			= 0,
};

static struct platform_device ambarella_fb1 = {
        .name			= "ambarella-fb",
        .id			= 1,
};

static int __init ambavoutfb_init(void)
{
        platform_device_register(&ambarella_fb0);
        platform_device_register(&ambarella_fb1);
        return platform_driver_register(&ambfb_driver);
}

static void __exit ambavoutfb_exit(void)
{
        platform_driver_unregister(&ambfb_driver);
        platform_device_unregister(&ambarella_fb1);
        platform_device_unregister(&ambarella_fb0);
}

MODULE_LICENSE("GPL");
module_init(ambavoutfb_init);
module_exit(ambavoutfb_exit);