вот там в самом конце ответ с оринтацие осей ))

А как драйвер компилировать куда кидать и подгружать?

как вывести консоль на него(она дублируется с UART или как?)

Вскором времени попробую переписать драйвер под себя.

Не моглибы протестить как видео воспроизводит

/*
* Copyright (C) 2009, Alexander Kudjashev <Kudjashev@gmail.com>
*
* 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 lph88fb lcd
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/kthread.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/dma-mapping.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)


static u8 lcd_init_data[] __devinitdata = {0x00,0x00,0x01,
0x07,0x00,0x00, 0x02,0x04,0x00, 0x04,0x00,0x00,
0x0C,0x00,0x01, 0x0D,0x06,0x16, 0x0E,0x10,0x10,
0x03,0x00,0x0C, 0x0E,0x2D,0x1F, 0x0D,0x06,0x16,
0x01,0x03,0x15, 0x0F,0x00,0x00, 0x0B,0x00,0x00,
0x11,0x00,0x00, 0x06,0x00,0x00, 0x05,0x00,0x38,
0x14,0xAF,0x00, 0x15,0x00,0x00, 0x16,0x83,0x00,
0x17,0xAF,0x00, 0x20,0x00,0x00, 0x30,0x00,0x00,
0x31,0x04,0x00, 0x32,0x02,0x07, 0x33,0x07,0x00,
0x34,0x00,0x05, 0x35,0x07,0x03, 0x36,0x07,0x07,
0x37,0x00,0x07, 0x3A,0x12,0x00, 0x3B,0x00,0x09,
0x07,0x00,0x05, 0x07,0x00,0x25, 0x07,0x00,0x27,
0x07,0x00,0x37};

static void lcd_comtype(struct spi_device *spi, u8 type)
{
u8 buff[3];

buff[0] = 0x74;
buff[1] = 0x00;
buff[2] = type;

spi_write(spi, buff, 3);
}

static void lcd_comdata(struct spi_device *spi, u8 data1, u8 data2)
{
u8 buff[3];

buff[0] = 0x76;
buff[1] = data1;
buff[2] = data2;

spi_write(spi, buff, 3);
}

static void lcd_command(struct spi_device *spi, u8 *data)
{
lcd_comtype(spi, data[0]);
lcd_comdata(spi, data[1], data[2]);

switch(data[0]) {
/* Power Control - need delay */
case 0x03:
case 0x04:
case 0x0c:
case 0x0d:
case 0x0e:
mdelay(40);
}
}

struct lph88fb_par {
struct spi_message msg;
struct spi_transfer xfer1;
struct spi_transfer xfer2;
struct spi_device *spi;
struct task_struct *lph88fb_thread_task;
u8 *fb_virt;
dma_addr_t fb_phys;
u32 pseudo_palette[16];
};

static struct fb_fix_screeninfo lph88fb_fix __devinitdata = {
.id = "lph88fb",
.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 lph88fb_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 lph88fb_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 lph88fb_ops = {
.owner = THIS_MODULE,
.fb_setcolreg = lph88fb_setcolreg,
.fb_fillrect = cfb_fillrect,
.fb_copyarea = cfb_copyarea,
.fb_imageblit = cfb_imageblit,
};

static int lph88fb_thread(void *param)
{
struct lph88fb_par *par = (struct lph88fb_par *)param;

while(!kthread_should_stop()) {

lcd_comtype(par->spi, 0x21);
lcd_comdata(par->spi, 0x00, 0x00);
lcd_comtype(par->spi, 0x22);

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

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

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

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

/* reset lcd controller */
at91_set_gpio_output(AT91_PIN_PB4, 1);
mdelay(10);
at91_set_gpio_value(AT91_PIN_PB4, 0);
mdelay(1);
at91_set_gpio_value(AT91_PIN_PB4, 1);
mdelay(10);

for(i = 0; i < sizeof(lcd_init_data); i += 3)
lcd_command(spi, &lcd_init_data[i]);

retval = -ENOMEM;

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

par = info->par;
par->spi = spi;

par->fb_virt = dma_alloc_coherent(NULL, (MEM_LEN + 1) << 1, &par->fb_phys,
GFP_KERNEL | __GFP_ZERO);
if(!par->fb_virt)
goto err;

info->screen_base = (void __iomem *)par->fb_virt;
info->fbops = &lph88fb_ops;
info->var = lph88fb_var;
info->fix = lph88fb_fix;
info->fix.smem_len = MEM_LEN;
info->fix.smem_start = par->fb_phys;
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 err1;

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

dev_set_drvdata(&spi->dev, info);

m = &par->msg;
spi_message_init(m);
m->is_dma_mapped = 1;

x = &par->xfer1;
x->tx_buf = par->fb_virt + MEM_LEN;
x->tx_dma = par->fb_phys + MEM_LEN;
x->rx_buf = par->fb_virt + MEM_LEN + 1;
x->rx_dma = par->fb_phys + MEM_LEN + 1;
x->len = 1;
par->fb_virt[MEM_LEN] = 0x76;
spi_message_add_tail(x, m);

x = &par->xfer2;
x->tx_buf = par->fb_virt;
x->tx_dma = par->fb_phys;
x->rx_buf = par->fb_virt + MEM_LEN + 1;
x->rx_dma = par->fb_phys + MEM_LEN + 1;
x->len = MEM_LEN;
x->bits_per_word = 16;
spi_message_add_tail(x, m);

par->lph88fb_thread_task = kthread_run(lph88fb_thread, par, "lph88fb");
retval = -EIO;
if(IS_ERR(par->lph88fb_thread_task))
goto err3;

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;

err3:
unregister_framebuffer(info);
err2:
fb_dealloc_cmap(&info->cmap);
err1:
dma_free_coherent(NULL, (MEM_LEN + 1) << 1, par->fb_virt, par->fb_phys);
err:
framebuffer_release(info);

return retval;
}

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

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

kthread_stop(par->lph88fb_thread_task);
unregister_framebuffer(info);
fb_dealloc_cmap(&info->cmap);
dma_free_coherent(NULL, (MEM_LEN + 1) << 1, par->fb_virt, par->fb_phys);
framebuffer_release(info);
}
return 0;
}

/* Power down display on reboot, poweroff or halt */
static void lph88fb_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 lph88fb_driver = {
.driver = {
.name = "lph88fb",
.bus = &spi_bus_type,
.owner = THIS_MODULE,
},
.probe = lph88fb_probe,
.remove = __devexit_p(lph88fb_remove),
.shutdown = lph88fb_shutdown,
};

static int __init lph88fb_init(void)
{
printk("lph88fb spi fb driver\n");
return spi_register_driver(&lph88fb_driver);
}

static void __exit lph88fb_exit(void)
{
spi_unregister_driver(&lph88fb_driver);
}

module_init(lph88fb_init);
module_exit(lph88fb_exit);

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