/*
+* Copyright (C) 2009, Alexander Kudjashev <Kudjashev@gmail.com> and Dmitri Zavrazhnov <mesh3d@mail.ru>
+*
+* This file is subject to the terms and conditions of the GNU General Public
+* License. See the file COPYING in the main directory of this archive for
+* more details.
+*
+* Layout is based on skeletonfb.c by James Simmons and Geert Uytterhoeven
+*
+* This driver was written to be used with s65 ls020 lcd using source of driver lph88fb
+*
+*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/kthread.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/uaccess.h>
#include <mach/gpio.h>

/* lcd resolution */
#define X_RES 176
#define Y_RES 132
#define B_PP 16
#define MEM_LEN (X_RES * Y_RES * B_PP / 8)
#define LCD_RS AT91_PIN_PA29
#define LCD_CS AT91_PIN_PA25

// init LS020
static u16 INIT1[2]={0xFDFD, 0xFDFD};
static u16 INIT2[10]={0xEF00, 0xEE0F, 0x1B04, 0xFEFE,0xFEFE, 0xEF90, 0x4A04, 0x7F3F, 0xEE04, 0x4306};
static u16 INIT3[20]={0xEF90, 0x0983, 0x0800, 0x0BAF, 0x0A00, 0x0500, 0x0600,0x0700, 0xEF00, 0xEE0C, 0xEF90, 0x0080, 0xEFB0, 0x4902,0xEF00, 0x7F01, 0xE181, 0xE202, 0xE276, 0xE183};
static u16 INIT4[3]={0x8001,0xEF90,0x0000};



void lcd_wrcmd(struct spi_device *spi, u8 type)
{
at91_set_gpio_output(LCD_CS,1); // CS
at91_set_gpio_output(LCD_RS,1); // RS
spi_write(spi, &type, 1); // Data
at91_set_gpio_output(LCD_RS,0); // RS
at91_set_gpio_output(LCD_CS,0); // CX
}

void lcd_wrdata(struct spi_device *spi, u8 type)
{
at91_set_gpio_output(LCD_CS,0);
at91_set_gpio_output(LCD_RS,0);
spi_write(spi, &type, 1);
at91_set_gpio_output(LCD_RS,1);
at91_set_gpio_output(LCD_CS,1);

}


struct ls020fb_par {
struct spi_message msg;
struct spi_transfer xfer;
struct spi_device *spi;
struct task_struct *ls020fb_thread_task;
unsigned int *buffer;
unsigned int *screen;
unsigned int *rx;
u32 pseudo_palette[16];
};

static struct fb_fix_screeninfo ls020fb_fix __devinitdata = {
.id = "ls020fb",
.type = FB_TYPE_PACKED_PIXELS,
.visual = FB_VISUAL_TRUECOLOR,
.xpanstep = 0,
.ypanstep = 0,
.ywrapstep = 0,
.line_length = X_RES * B_PP / 8,
.accel = FB_ACCEL_NONE,
};

static struct fb_var_screeninfo ls020fb_var __devinitdata = {
.xres = X_RES,
.yres = Y_RES,
.xres_virtual = X_RES,
.yres_virtual = Y_RES,
.activate = FB_ACTIVATE_NOW,
.vmode = FB_VMODE_NONINTERLACED,
.bits_per_pixel = B_PP,
.red = { 11, 5, 0 },
.green = { 5, 6, 0 },
.blue = { 0, 5, 0 },
.nonstd = 0,
};

static int ls020fb_setcolreg(unsigned regno, unsigned r, unsigned g,
unsigned b, unsigned transp,
struct fb_info *info)
{

if (regno >= 16)
return -EINVAL;

((u32 *) info->pseudo_palette)[regno] =
(r & 0xf800) | (g & 0xfc00) >> 5 | (b & 0xf800) >> 11;

return 0;
}


static struct fb_ops ls020fb_ops = {
.owner = THIS_MODULE,
.fb_setcolreg = ls020fb_setcolreg,
.fb_read = fb_sys_read,
.fb_write = fb_sys_write,
.fb_fillrect = sys_fillrect,
.fb_copyarea = sys_copyarea,
.fb_imageblit = sys_imageblit,
};

void lcd_wrcmd16(struct spi_device *spi, uint16_t dat)
{
lcd_wrcmd(spi,(dat>>8));
lcd_wrcmd(spi, dat);
}

static int ls020fb_thread(void *param)
{
struct ls020fb_par *par = (struct ls020fb_par *)param;
par->screen[0] = 0x76;
while(!kthread_should_stop())
{
lcd_wrcmd16(par->spi,0x0504);
lcd_wrcmd16(par->spi,0x0800+0);
lcd_wrcmd16(par->spi,0x0A00+0);
lcd_wrcmd16(par->spi,0x0900+176);
lcd_wrcmd16(par->spi,0x0B00+132);

spi_sync(par->spi, &par->msg);
}
return 0;
}

static int __devinit ls020fb_probe(struct spi_device *spi)
{
struct fb_info *info;
struct ls020fb_par *par;
struct spi_message *m;
struct spi_transfer *x;
int retval, i;

spi->max_speed_hz = 20 * 1000 * 1000;
spi->bits_per_word = 8;
spi->mode = SPI_MODE_0;

retval = spi_setup(spi);
if(retval < 0)
return retval;


for(i = 0; i < 1;i++)

lcd_wrcmd16(spi,INIT1[i]);
mdelay(80);
for(i = 0; i < 10; i++)
lcd_wrcmd16(spi,INIT2[i]);
mdelay(50);
for(i = 0; i < 20; i++)
lcd_wrcmd16(spi,INIT3[i]);
mdelay(50);
for(i = 0; i < 3; i++)
lcd_wrcmd16(spi,INIT4[i]);


retval = -ENOMEM;

info = framebuffer_alloc(sizeof(struct ls020fb_par), &spi->dev);
if(!info)
return retval;

par = info->par;
par->spi = spi;
par->buffer = alloc_pages_exact(MEM_LEN, GFP_KERNEL | __GFP_ZERO);
if(!par->buffer)
goto err;

par->screen = kmalloc(MEM_LEN + 1, GFP_KERNEL);
if(!par->screen)
goto err1;

par->rx = kmalloc(MEM_LEN + 1, GFP_KERNEL);
if(!par->rx)
goto err2;

info->fbops = &ls020fb_ops;
info->var = ls020fb_var;
info->fix = ls020fb_fix;
info->fix.smem_len = MEM_LEN;
info->fix.smem_start = (unsigned long)virt_to_phys(info->screen_base);
info->screen_size = MEM_LEN;
info->flags = FBINFO_FLAG_DEFAULT;
info->pseudo_palette = par->pseudo_palette;

retval = fb_alloc_cmap(&(info->cmap), 256, 0);
if (retval < 0)
goto err3;

retval = register_framebuffer(info);
if (retval < 0)
goto err4;

dev_set_drvdata(&spi->dev, info);

m = &par->msg;
x = &par->xfer;

spi_message_init(m);

x->tx_buf = par->screen;
x->rx_buf = par->rx;
x->len = MEM_LEN + 1;

spi_message_add_tail(x, m);

par->ls020fb_thread_task = kthread_run(ls020fb_thread, par, "ls020fb");
retval = -EIO;
if(IS_ERR(par->ls020fb_thread_task))
goto err5;

printk(KERN_INFO "fb%d: %s frame buffer device, %dK of video memory\n",
info->node, info->fix.id, info->fix.smem_len >> 10);

return 0;

err5:
unregister_framebuffer(info);
err4:
fb_dealloc_cmap(&info->cmap);
err3:
kfree(par->rx);
err2:
kfree(par->screen);
err1:
free_pages_exact(par->buffer, MEM_LEN);
err:
framebuffer_release(info);

return retval;
}

static int __devexit ls020fb_remove(struct spi_device *spi)
{
struct fb_info *info = dev_get_drvdata(&spi->dev);

if (info) {
struct ls020fb_par *par = info->par;

kthread_stop(par->ls020fb_thread_task);
unregister_framebuffer(info);
fb_dealloc_cmap(&info->cmap);
kfree(par->rx);
kfree(par->screen);
free_pages_exact(par->buffer, MEM_LEN);
framebuffer_release(info);
}
return 0;
}

/* Power down display on reboot, poweroff or halt */
static void ls020fb_shutdown(struct spi_device *spi)
{
//at91_set_gpio_value(AT91_PIN_PB4, 0);
//mdelay(1);
//at91_set_gpio_value(AT91_PIN_PB4, 1);
//mdelay(10);
}

static struct spi_driver ls020fb_driver = {
.driver = {
.name = "ls020fb",
.bus = &spi_bus_type,
.owner = THIS_MODULE,
},
.probe = ls020fb_probe,
.remove = __devexit_p(ls020fb_remove),
.shutdown = ls020fb_shutdown,
};

static int __init ls020fb_init(void)
{
printk("ls020fb spi fb driver\n");
return spi_register_driver(&ls020fb_driver);
}

static void __exit ls020fb_exit(void)
{
printk("ls020 exti do... \n");
spi_unregister_driver(&ls020fb_driver);
}

module_init(ls020fb_init);
module_exit(ls020fb_exit);

MODULE_AUTHOR("Alexander Kudjashev");
MODULE_DESCRIPTION("ls020 spi fb driver");
MODULE_LICENSE("GPL");

/*
* SPI devices.
*/
static struct spi_board_info ek_spi_devices[] = {
#if !defined(CONFIG_MMC_AT91)
{ /* DataFlash chip */
.modalias = "mtd_dataflash",
.chip_select = 1,
.max_speed_hz = 15 * 1000 * 1000,
.bus_num = 0,
},
#if defined(CONFIG_MTD_AT91_DATAFLASH_CARD)
{ /* DataFlash card */
.modalias = "mtd_dataflash",
.chip_select = 0,
.max_speed_hz = 15 * 1000 * 1000,
.bus_num = 0,
},
#endif
#endif
#if defined(CONFIG_SND_AT73C213) || defined(CONFIG_SND_AT73C213_MODULE)
{ /* AT73C213 DAC */
.modalias = "at73c213",
.chip_select = 1,
.max_speed_hz = 10 * 1000 * 1000,
.bus_num = 1,
.mode = SPI_MODE_1,
.platform_data = &at73c213_data,
},
#endif
#if defined(CONFIG_FB_LS020) || defined(CONFIG_FB_LS020_MODULE)
{ /* s65 lcd */
.modalias = "ls020",
.bus_num = 1,
.chip_select = 4,
},
#endif
};