add support for the Sharp SL-C3100 (Borzoi)

1 files changed, 1506 insertions, 0 deletions

diff --git a/packages/linux/openzaurus-pxa27x-2.4.20-rmk2-embedix20050602/P17-bvdd_050222.patch b/packages/linux/openzaurus-pxa27x-2.4.20-rmk2-embedix20050602/P17-bvdd_050222.patch
new file mode 100644
index 0000000000..785470a6aa
--- /dev/null
+++ b/packages/linux/openzaurus-pxa27x-2.4.20-rmk2-embedix20050602/P17-bvdd_050222.patch
@@ -0,0 +1,1506 @@
+diff -Nur c3000_pre/linux/drivers/video/Config.in c3000_work/linux/drivers/video/Config.in
+--- c3000_pre/linux/drivers/video/Config.in	2005-02-22 00:14:45.000000000 +0900
++++ c3000_work/linux/drivers/video/Config.in	2005-02-21 23:36:35.000000000 +0900
+@@ -86,6 +86,7 @@
+      dep_bool '  Sharp SL-Series PXA LCD support' CONFIG_FB_SHARPSL_PXA $CONFIG_ARCH_SHARP_SL
+      if [ "$CONFIG_FB_SHARPSL_PXA" = "y" ]; then
+ 	dep_bool '    Cached FB support for Sharp SL PXA LCDC' CONFIG_SHARPSL_PXA_CONSISTENT_ALLOC $CONFIG_FB_SHARPSL_PXA
++	dep_tristate '    PXA270 overlay(bvdd) support(EXPERIMENTAL)' CONFIG_FB_SHARPSL_PXA_BVDD $CONFIG_FB_SHARPSL_PXA
+      fi
+      dep_bool '  SHARP LOGO screen support' CONFIG_SHARP_LOGO_SCREEN $CONFIG_ARCH_SHARP_SL
+      if [ "$CONFIG_FB_PXA" != "n" -a "$CONFIG_ARCH_LUBBOCK" = "y" ]; then
+diff -Nur c3000_pre/linux/drivers/video/Makefile c3000_work/linux/drivers/video/Makefile
+--- c3000_pre/linux/drivers/video/Makefile	2005-02-22 00:14:45.000000000 +0900
++++ c3000_work/linux/drivers/video/Makefile	2005-02-21 23:40:57.000000000 +0900
+@@ -160,6 +160,7 @@
+ obj-$(CONFIG_FB_CORGI)            += w100fb.o fbgen.o corgi_backlight.o
+ obj-$(CONFIG_FB_TOSA)             += tc6393fb.o fbgen.o tosa_backlight.o
+ obj-$(CONFIG_FB_SHARPSL_PXA)      += sharpsl_pxafb.o fbgen.o corgi_backlight.o
++obj-$(CONFIG_FB_SHARPSL_PXA_BVDD) += bvdd.o
+ 
+ # Generic Low Level Drivers
+ 
+diff -Nur c3000_pre/linux/drivers/video/bvdd.c c3000_work/linux/drivers/video/bvdd.c
+--- c3000_pre/linux/drivers/video/bvdd.c	1970-01-01 09:00:00.000000000 +0900
++++ c3000_work/linux/drivers/video/bvdd.c	2005-02-22 00:05:24.000000000 +0900
+@@ -0,0 +1,1124 @@
++/*  bvdd.c - Create an input/output character device
++ */
++
++#include <linux/kernel.h>   /* We're doing kernel work */
++#include <linux/module.h>   /* Specifically, a module */
++
++#if CONFIG_MODVERSIONS==1
++#define MODVERSIONS
++#include <linux/modversions.h>
++#endif
++
++#include <linux/fs.h>  /* The character device definitions are here */
++#include <linux/wrapper.h>
++#include <linux/mm.h>
++#include <linux/sched.h>
++#include <asm/system.h>
++#include <asm/hardware.h>
++#include <asm/uaccess.h>	/* for get_user and put_user */
++#include <asm/io.h>
++
++/* Our own ioctl numbers */
++#include "bvdd.h"
++#include "bvdd_p.h"
++
++#define SUCCESS 0
++
++#define DEVICE_NAME "bvdd"	/* The name for our device */
++
++#ifdef DEBUG
++# define PRINT_DEBUG(x...) printk(KERN_WARNING DEVICE_NAME ": " x)
++# define PRINT_INFO(x...) printk(KERN_WARNING DEVICE_NAME ": " x)
++# define PRINT_WARN(x...) printk(KERN_WARNING DEVICE_NAME ": " x)
++# define PRINT_ERROR(x...) printk(KERN_ERROR DEVICE_NAME ": " x)
++# define PRINT_FATAL(x...) printk(KERN_FATAL DEVICE_NAME ": " x)
++#else
++# define PRINT_DEBUG(x...)
++# define PRINT_INFO(x...)
++# define PRINT_WARN(x...) printk(KERN_WARNING DEVICE_NAME ": " x)
++# define PRINT_ERROR(x...) printk(KERN_ERROR DEVICE_NAME ": " x)
++# define PRINT_FATAL(x...) printk(KERN_FATAL DEVICE_NAME ": " x)
++#endif
++
++/* Is the device open right now? Used to prevent concurent access into the same device */
++static int device_open = 0;
++
++static dma_addr_t vram_sharpsl_pxafb_phys;
++static void *vram_virt = NULL; /* virtual address of VRAM (if NULL, VRAM is not allocated) */
++static dma_addr_t vram_phys = 0; /* physical address of VRAM */
++static u32 vram_size = 0;	/* VRAM size */
++
++#undef FDADR
++// ----------------------------------------------------------------
++// ディスクリプタ
++// aligned on a 16-byte boundary
++
++typedef struct {
++    unsigned long FDADR;	/* frame descriptor address */
++    unsigned long FSADR;      /* DMA Frame Source Address Registers */
++    unsigned long FIDR;		/* frame id reg */
++    unsigned long LDCMD;	/* LCD command reg */
++} descriptor_t;
++
++static descriptor_t *descriptors = NULL;
++#ifndef USE_PXAFB_DESCRIPTOR_AREA
++# define MAX_DESCRIPTORS (PAGE_SIZE / 16)
++static descriptor_t *descriptor_virt; /* ディスクリプタ配列の仮想アドレス */
++static dma_addr_t descriptor_phys; /* ディスクリプタ配列の物理アドレス */
++static u32 descriptor_size;	/* ディスクリプタ配列のサイズ */
++#else
++# define MAX_DESCRIPTORS ((PAGE_SIZE - 16) / 16)
++#endif
++
++// Physical addresses, offsets & lengths
++#define	SRAM_BASE	0xfe100000
++#define	SRAM_BASE_PHYS	0x5c000000
++#define MAX_VRAM_SIZE (1024 * 4)
++static unsigned long offset2phys_map[MAX_VRAM_SIZE >> PAGE_SHIFT];
++#define OFFSET2PHYS_MAP_SRAM_INDEX 0
++
++// vram manager
++typedef struct {
++    unsigned long start_phys;
++    void *start_virt;
++    unsigned long end_phys;
++    unsigned long offset;
++} vram_area_t;
++#define MAX_VRAM_AREAS 128
++static vram_area_t vram_areas[MAX_VRAM_AREAS];
++
++// test
++static volatile unsigned int next_fbr2 = 0;
++static volatile unsigned int next_fbr3 = 0;
++static volatile unsigned int next_fbr4 = 0;
++static wait_queue_head_t fbr2_wait;
++static wait_queue_head_t fbr3_wait;
++static wait_queue_head_t fbr4_wait;
++static wait_queue_head_t wq_lcd_quick_disable_done;
++static wait_queue_head_t wq_lcd_disable_done;
++
++
++#if defined(CONFIG_SL_CCCR_CHANGE)
++extern int read_cccr(void);
++extern void write_cccr(int);
++#endif
++#if defined(CONFIG_CHANGE_CORE_VOLT)
++extern int read_vcore(void);
++extern void write_vcore(int);
++#endif
++
++// ----------------------------------------------------------------
++static void bvdd_vsync();
++
++// ----------------------------------------------------------------
++#if 1
++static void *consistent_alloc(int gfp, size_t size, dma_addr_t *dma_handle);
++static void *l_consistent_alloc2(int gfp, size_t size, dma_addr_t *dma_handle, int pte);
++static void consistent_free(void *vaddr, size_t size, dma_addr_t handle);
++#endif
++
++
++static void inttest(int irq, void *dev_id, struct pt_regs *regs)
++{
++    static int count = 0;
++    static int start = 0;
++    LCSR0_u lcsr0;
++    LCSR1_u lcsr1;
++    int st = 0;
++
++    lcsr1.val = REG_LCSR1;
++    if (lcsr1.f.EOF2 == 1) {
++	LCSR1_u v;
++/* 	if ((next_fbr2 != 0) && ((REG_FBR2 & 1) == 0)) { */
++	if ((next_fbr2 != 0)) {
++	    REG_FBR2 = next_fbr2 | 3;
++/* 	    REG_FDADR2 = next_fbr2; */
++/* 	    wake_up_interruptible(&fbr2_wait); */
++	}
++	v.val = 0;
++	v.f.EOF2 = 1;
++	REG_LCSR1 = v.val;
++    }
++    else if (lcsr1.f.EOF3 == 1) {
++	LCSR1_u v;
++/* 	if ((next_fbr3 != 0) && ((REG_FBR3 & 1) == 0)) { */
++	if ((next_fbr3 != 0)) {
++	    REG_FBR3 = next_fbr3 | 3;
++/* 	    REG_FDADR3 = next_fbr3; */
++/* 	    next_fbr3 = 0; */
++/* 	    wake_up_interruptible(&fbr3_wait); */
++	}
++	v.val = 0;
++	v.f.EOF3 = 1;
++	REG_LCSR1 = v.val;
++    }
++    else if (lcsr1.f.EOF4 == 1) {
++	LCSR1_u v;
++/* 	if ((next_fbr4 != 0) && ((REG_FBR4 & 1) == 0)) { */
++	if ((next_fbr4 != 0)) {
++	    REG_FBR4 = next_fbr4 | 3;
++/* 	    REG_FDADR4 = next_fbr4; */
++/* 	    next_fbr4 = 0; */
++/* 	    wake_up_interruptible(&fbr4_wait); */
++	}
++	v.val = 0;
++	v.f.EOF4 = 1;
++	REG_LCSR1 = v.val;
++    }
++    if (REG_LCSR1 & 0x20000) {	/* BS2 */
++	next_fbr2 = 0;
++	wake_up_interruptible(&fbr2_wait);
++	REG_LCSR1 = 0x20000;
++    }
++    if (REG_LCSR1 & 0x40000) {	/* BS3 */
++	next_fbr3 = 0;
++	wake_up_interruptible(&fbr3_wait);
++	REG_LCSR1 = 0x40000;
++    }
++    if (REG_LCSR1 & 0x80000) {	/* BS4 */
++	next_fbr4 = 0;
++	wake_up_interruptible(&fbr4_wait);
++	REG_LCSR1 = 0x80000;
++    }
++
++#if 0
++    lcsr0.val = REG_LCSR0;
++    if (lcsr0.f.QD == 1) {
++	LCSR0_u v;
++	v.val = 0;
++	v.f.QD = 1;
++	REG_LCSR0 = v.val;
++	wake_up_interruptible(&wq_lcd_quick_disable_done);
++    }
++    if (lcsr0.f.LDD == 1) {
++	LCSR0_u v;
++	v.val = 0;
++	v.f.LDD = 1;
++	REG_LCSR0 = v.val;
++	wake_up_interruptible(&wq_lcd_disable_done);
++    }
++#endif
++}
++
++static int setup_vram(int size)
++{
++    int order, i;
++    unsigned int offset = BVDD_VRAM_OFFSET_USER;
++
++    size = PAGE_ALIGN(size);
++    order = get_order(size);
++    PRINT_DEBUG("setup_vram(size=%d)\n", size);
++
++    for (i = 2; i < MAX_VRAM_AREAS - 2; ++i) {
++	vram_area_t *va = &vram_areas[i];
++	va->start_virt = NULL;
++	do {
++/* 	    if (order > 3) { */
++/* 		order --; */
++/* 		continue; */
++/* 	    } */
++	    va->start_virt = consistent_alloc(GFP_KERNEL|GFP_DMA, PAGE_SIZE << order, (dma_addr_t *)&va->start_phys);
++	    if (va->start_virt == NULL) {
++		order --;
++		if (order < 1)
++		    return -1;
++	    }
++	} while (va->start_virt == NULL);
++	va->end_phys = va->start_phys + (PAGE_SIZE << order);
++	va->offset = offset;
++	offset += PAGE_SIZE << order;
++	size -= PAGE_SIZE << order;
++	PRINT_DEBUG("  vram_area[%2d] : 0x%p, %d, 0x%p\n", i, va->start_phys, PAGE_SIZE << order, va->offset);
++	if (size <= 0)
++	    break;
++    }
++
++    if (size > 0)
++	return -1;
++    else
++	return 0;
++}
++
++static int free_vram(void)
++{
++    int i;
++    for (i = 2; i < MAX_VRAM_AREAS - 2; ++i) {
++	vram_area_t *va = &vram_areas[i];
++	if (va->start_virt != NULL) {
++	    consistent_free(va->start_virt, va->end_phys - va->start_phys, va->start_phys);
++	    memset(va, 0, sizeof(vram_area_t));
++	}
++    }
++}
++
++// ----------------------------------------------------------------
++static lcdc_state_t lcdc_state_orig;
++static lcdc_state_t lcdc_state;
++
++static void lcdc_state_read(lcdc_state_t *ls)
++{
++    ls->cken20_intmem = (CKEN & CKEN20_INTMEM) ? 1 : 0;
++    ls->lccr0.val = REG_LCCR0;
++    ls->lccr0.f.reserved1 = 0;
++    ls->lccr0.f.reserved2 = 0;
++    ls->lccr1.val = REG_LCCR1;
++    ls->lccr2.val = REG_LCCR2;
++    ls->lccr3.val = REG_LCCR3;
++    ls->lccr3.f.reserved1 = 0;
++    ls->lccr4.val = REG_LCCR4;
++    ls->lccr4.f.reserved1 = 0;
++    ls->lccr4.f.reserved2 = 0;
++    ls->ovl1c1.val = REG_OVL1C1;
++    ls->ovl1c1.f.reserved1 = 0;
++    ls->ovl1c2.val = REG_OVL1C2;
++    ls->ovl1c2.f.reserved1 = 0;
++    ls->ovl2c1.val = REG_OVL2C1;
++    ls->ovl2c1.f.reserved1 = 0;
++    ls->ovl2c2.val = REG_OVL2C2;
++    ls->ovl2c2.f.reserved1 = 0;
++    ls->fdadr0 = REG_FDADR0;
++    ls->fdadr1 = REG_FDADR1;
++    ls->fdadr2 = REG_FDADR2;
++    ls->fdadr3 = REG_FDADR3;
++    ls->fdadr4 = REG_FDADR4;
++    ls->fdadr5 = REG_FDADR5;
++    ls->fdadr6 = REG_FDADR6;
++}
++
++static void lcdc_state_write(lcdc_state_t *ls)
++{
++    int i;
++
++    ls->cken20_intmem = (CKEN & CKEN20_INTMEM) ? 1 : 0;
++    if (ls->cken20_intmem)
++	CKEN |= CKEN20_INTMEM;
++    else
++	CKEN &= ~CKEN20_INTMEM;
++
++/*     { */
++/* 	LCCR0_u v; */
++/* 	v.val = 0; */
++/* 	v.f.QDM = 1; */
++/* 	v.f.LDM = 1; */
++/* 	REG_LCCR0 &= ~v.val; */
++/*     } */
++
++    ls->lccr2.f.EFW = 64;
++    ls->lccr2.f.VSW = 64;
++    for (i = 0; i < 2; ++i) {
++	bvdd_vsync();
++	REG_LCCR0 |= 0x400;	/* Disable LCD controller */
++/* 	interruptible_sleep_on(&wq_lcd_disable_done); */
++
++	bvdd_vsync();		/* Wait for disabled */
++	REG_LCCR0 &= ~1;	/* Do a quick disable */
++
++	REG_OVL2C1 = ls->ovl2c1.val;
++	REG_OVL2C2 = ls->ovl2c2.val;
++	REG_OVL1C1 = ls->ovl1c1.val;
++	REG_OVL1C2 = ls->ovl1c2.val;
++	REG_LCCR1 = ls->lccr1.val;
++	REG_LCCR2 = ls->lccr2.val;
++	REG_LCCR3 = ls->lccr3.val;
++	REG_LCCR4 = ls->lccr4.val;
++/* 	REG_LCCR5 = 0x3F3F3F31; */
++/* 	REG_LCCR5 = 0x3F3F313F;	/\* EOF *\/ */
++	REG_LCCR5 = 0x3F31313F;	/* BSM/EOF */
++
++	REG_LCDBSCNTR = 5;
++
++	REG_LCSR0 = 0x00001FFF;
++	REG_LCSR1 = 0x3E3F3F3F;
++
++	ls->lccr0.f.ENB = 1;
++	REG_LCCR0 = ls->lccr0.val; /* Enable LCD controller */
++
++	REG_LCCR0 &= ~1;	/* Do a quick disable */
++/* 	interruptible_sleep_on(&wq_lcd_quick_disable_done); */
++
++	REG_FDADR0 = ls->fdadr0;
++	REG_FDADR1 = ls->fdadr1;
++	REG_FDADR2 = ls->fdadr2;
++	REG_FDADR3 = ls->fdadr3;
++	REG_FDADR4 = ls->fdadr4;
++	REG_FDADR5 = ls->fdadr5;
++	REG_FDADR6 = ls->fdadr6;
++
++	REG_LCCR0 = ls->lccr0.val;
++    }
++}
++
++static void lcdc_state_print_descriptor(int n, unsigned long addr)
++{
++    PRINT_DEBUG("  FDADR%d : 0x%08x         FDADR      FSADR       FIDR      LDCMD\n", n, addr);
++    if (addr == 0)
++	PRINT_DEBUG("                         ---------- ---------- ---------- ----------\n");
++    else {
++	PRINT_DEBUG("                         0x%08x 0x%08x 0x%08x 0x%08x\n",
++		    ((unsigned long *)__phys_to_virt(addr))[0],
++		    ((unsigned long *)__phys_to_virt(addr))[1],
++		    ((unsigned long *)__phys_to_virt(addr))[2],
++		    ((unsigned long *)__phys_to_virt(addr))[3]);
++    }
++}
++
++static void lcdc_state_print(lcdc_state_t *ls)
++{
++    PRINT_DEBUG("lcdc_state_print(lcdc_state_t * = 0x%p)\n", ls);
++    PRINT_DEBUG("  CKEN20_INTMEM : %d\n", ls->cken20_intmem);
++    PRINT_DEBUG("  LCCR0 : 0x%08x\n", ls->lccr0.val);
++    PRINT_DEBUG("    ENB CMS SDS LDM SOFM0 IUM EOFM0 PAS DPD DIS QDM PDD BSM0 OUM LCDT\n");
++    PRINT_DEBUG("    %3d %3d %3d %3d   %3d %3d   %3d %3d %3d %3d %3d %3d  %3d %3d  %3d\n",
++		ls->lccr0.f.ENB, ls->lccr0.f.CMS, ls->lccr0.f.SDS, ls->lccr0.f.LDM, ls->lccr0.f.SOFM0,
++		ls->lccr0.f.IUM, ls->lccr0.f.EOFM0, ls->lccr0.f.PAS, ls->lccr0.f.DPD, ls->lccr0.f.DIS,
++		ls->lccr0.f.QDM, ls->lccr0.f.PDD, ls->lccr0.f.BSM0, ls->lccr0.f.OUM, ls->lccr0.f.LCDT);
++    PRINT_DEBUG("    RDSTM CMDIM OUC LDDALT\n");
++    PRINT_DEBUG("      %3d   %3d %3d    %3d\n",
++		ls->lccr0.f.RDSTM, ls->lccr0.f.CMDIM, ls->lccr0.f.OUC, ls->lccr0.f.LDDALT);
++    PRINT_DEBUG("  LCCR1 : 0x%08x\n", ls->lccr1.val);
++    PRINT_DEBUG("     PPL HSW ELW BLW\n");
++    PRINT_DEBUG("    %4d %3d %3d %3d\n",
++		ls->lccr1.f.PPL, ls->lccr1.f.HSW, ls->lccr1.f.ELW, ls->lccr1.f.BLW);
++    PRINT_DEBUG("  LCCR2 : 0x%08x\n", ls->lccr2.val);
++    PRINT_DEBUG("     LPP VSW EFW BFW\n");
++    PRINT_DEBUG("    %4d %3d %3d %3d\n",
++		ls->lccr2.f.LPP, ls->lccr2.f.VSW, ls->lccr2.f.EFW, ls->lccr2.f.BFW);
++    PRINT_DEBUG("  LCCR3 : 0x%08x\n", ls->lccr3.val);
++    PRINT_DEBUG("    PCD ACB API VSP HSP PCP OEP BPP DPC BPP3 PDFOR\n");
++    PRINT_DEBUG("    %3d %3d %3d %3d %3d %3d %3d %3d %3d  %3d   %3d\n",
++		ls->lccr3.f.PCD, ls->lccr3.f.ACB, ls->lccr3.f.API, ls->lccr3.f.VSP,
++		ls->lccr3.f.HSP, ls->lccr3.f.PCP, ls->lccr3.f.OEP, ls->lccr3.f.BPP,
++		ls->lccr3.f.DPC, ls->lccr3.f.BPP3, ls->lccr3.f.PDFOR);
++    PRINT_DEBUG("  LCCR4 : 0x%08x\n", ls->lccr4.val);
++    PRINT_DEBUG("    K1 K2 K3 PAL_FOR PCDDIV\n");
++    PRINT_DEBUG("    %2d %2d %2d     %3d    %3d\n",
++		ls->lccr4.f.K1, ls->lccr4.f.K2, ls->lccr4.f.K3, ls->lccr4.f.PAL_FOR,
++		ls->lccr4.f.PCDDIV);
++    PRINT_DEBUG("  OVL1C1 : 0x%08x\n", ls->ovl1c1.val);
++    PRINT_DEBUG("    PPL1 LPO1 BPP1 O1EN\n");
++    PRINT_DEBUG("     %3d  %3d  %3d  %3d\n",
++		ls->ovl1c1.f.PPL1, ls->ovl1c1.f.LPO1, ls->ovl1c1.f.BPP1, ls->ovl1c1.f.O1EN);
++    PRINT_DEBUG("  OVL1C2 : 0x%08x\n", ls->ovl1c2.val);
++    PRINT_DEBUG("    O1XPOS O1YPOS\n");
++    PRINT_DEBUG("      %4d   %4d\n",
++		ls->ovl1c2.f.O1XPOS, ls->ovl1c2.f.O1YPOS);
++    PRINT_DEBUG("  OVL2C1 : 0x%08x\n", ls->ovl2c1.val);
++    PRINT_DEBUG("    PPL2 LPO2 BPP2 O2EN\n");
++    PRINT_DEBUG("     %3d  %3d  %3d  %3d\n",
++		ls->ovl2c1.f.PPL2, ls->ovl2c1.f.LPO2, ls->ovl2c1.f.BPP2, ls->ovl2c1.f.O2EN);
++    PRINT_DEBUG("  OVL2C2 : 0x%08x\n", ls->ovl2c2.val);
++    PRINT_DEBUG("    O2XPOS O2YPOS FOR\n");
++    PRINT_DEBUG("      %4d   %4d %3d\n",
++		ls->ovl2c2.f.O2XPOS, ls->ovl2c2.f.O2YPOS, ls->ovl2c2.f.FOR);
++    lcdc_state_print_descriptor(0, ls->fdadr0);
++    lcdc_state_print_descriptor(1, ls->fdadr1);
++    lcdc_state_print_descriptor(2, ls->fdadr2);
++    lcdc_state_print_descriptor(3, ls->fdadr3);
++    lcdc_state_print_descriptor(4, ls->fdadr4);
++    lcdc_state_print_descriptor(5, ls->fdadr5);
++    lcdc_state_print_descriptor(6, ls->fdadr6);
++}
++
++typedef struct {
++    unsigned int offset;
++    int size;
++    unsigned int desc_phys;
++} desc_cache_t;
++
++#define MAX_DESC_CACHE 256
++desc_cache_t desc_cache[MAX_DESC_CACHE];
++int desc_cache_index = 0;
++
++static unsigned int lcdc_set_descriptor(unsigned long offset, int size)
++{
++    descriptor_t *desc, *desc_prev = NULL, *desc_prev2, *desc_first = NULL;
++    int i, count = 0, is_first_desc = 1;
++    unsigned int desc_phys, desc_first_phys;
++    unsigned int offset_orig = offset, size_orig = size;
++
++    PRINT_DEBUG("lcdc_set_descriptor(offset=0x%08x, size=0x%08x)\n", offset, size);
++
++    for (i = 0; i < desc_cache_index; ++i) {
++	if (desc_cache[i].offset == offset && desc_cache[i].size == size)
++	    return desc_cache[i].desc_phys;
++    }
++
++    /* build descriptor */
++    while (size > 0) {
++	vram_area_t *va = NULL;
++	unsigned int alen, aoff;
++
++	desc = NULL;
++	for (i = 0; i < MAX_DESCRIPTORS; ++i) {
++	    unsigned int fdadr = *(unsigned int *)(&descriptors[i]);
++	    if (fdadr == 0) {
++		desc = &descriptors[i];
++		desc_phys = descriptor_phys + (sizeof(descriptor_t) * i);
++		break;
++	    }
++	}
++	if (desc == NULL) {
++	    // empty
++	    return 0;
++	}
++
++	for (i = 0; i < MAX_VRAM_AREAS; ++i) {
++	    va = &vram_areas[i];
++	    if (va->offset <= offset && offset < (va->offset + (va->end_phys - va->start_phys)))
++		break;
++	}
++	if (i == MAX_VRAM_AREAS) {
++	    return 0;
++	}
++
++	aoff = offset - va->offset;
++	if (is_first_desc) {
++	    alen = 4 * 1024;
++	    is_first_desc = 0;
++	} else {
++	    alen = va->end_phys - va->start_phys - aoff;
++	    if (alen > size)
++		alen = size;
++	}
++
++	desc->FDADR = desc_phys;
++	desc->FSADR = va->start_phys + aoff;
++	desc->FIDR = 0;
++	desc->LDCMD = alen;
++
++	if (desc_prev != NULL)
++	    desc_prev->FDADR = desc_phys;
++	desc_prev2 = desc_prev;
++	desc_prev = desc;
++
++	if (desc_first == NULL) {
++	    desc_first = desc;
++	    desc_first_phys = desc_phys;
++	}
++
++	size -= alen;
++	offset += alen;
++    }
++
++    /* 先頭のディスクリプタへリンクさせる */
++    desc->FDADR = desc_first_phys;
++
++    /* 末尾のディスクリプタはSOF/EOF割り込みを発生させる */
++/*     desc->LDCMD = desc->LDCMD | 0x400000; */
++/*     desc->LDCMD = desc->LDCMD | 0x200000; */
++    desc_prev2->LDCMD |= 0x200000;
++
++    desc_cache[desc_cache_index].offset = offset_orig;
++    desc_cache[desc_cache_index].size = size_orig;
++    desc_cache[desc_cache_index].desc_phys = desc_first_phys;
++    ++ desc_cache_index;	/* FIXME: buffer overflow */
++
++#if 0
++    desc = desc_first;
++    desc_phys = desc_first_phys;
++    do {
++	lcdc_state_print_descriptor(count++, desc_phys);
++	if (count >= MAX_DESCRIPTORS)
++	    break;
++	desc_prev = desc;
++	desc_phys = desc->FDADR;
++    } while (desc_prev->FDADR != desc_first_phys);
++#endif
++
++    return desc_first_phys;
++}
++
++// ----------------------------------------------------------------
++
++static int bvdd_open(struct inode *inode,
++		     struct file *file)
++{
++    int i;
++    printk(DEVICE_NAME ": bvdd_open(0x%p, 0x%p)\n", inode, file);
++
++    if (device_open)
++	return -EBUSY;
++
++    lcdc_state_read(&lcdc_state_orig);
++    lcdc_state_orig.fdadr1 = 0;
++    lcdc_state_orig.fdadr2 = 0;
++    lcdc_state_orig.fdadr3 = 0;
++    lcdc_state_orig.fdadr4 = 0;
++    lcdc_state_orig.fdadr5 = 0;
++    lcdc_state_orig.fdadr6 = 0;
++/*     lcdc_state_print(&lcdc_state_orig); */
++
++    memcpy(&lcdc_state, &lcdc_state_orig, sizeof(lcdc_state));
++    lcdc_state.cken20_intmem = 1;
++
++#ifndef USE_PXAFB_DESCRIPTOR_AREA
++    descriptor_size = PAGE_ALIGN(sizeof(descriptor_t) * MAX_DESCRIPTORS);
++    descriptors = consistent_alloc(GFP_KERNEL|GFP_DMA, descriptor_size, &descriptor_phys);
++    memset(descriptors, 0, sizeof(descriptor_t) * MAX_DESCRIPTORS);
++    printk(DEVICE_NAME ":   descriptor: virt=0x%p, phys=0x%p, size=%d\n",
++	   descriptors, descriptor_phys, descriptor_size);
++#else
++    // SHARPSL_PXAFBが確保している領域を借用する。
++    // 頭の16バイトはSLARPSL_PXAFBが使っているのでスキップする。
++    descriptors = (descriptor_t *)__phys_to_virt((lcdc_state_orig.fdadr0 + 16));
++    PRINT_DEBUG("  descriptors : phys=0x%p, virt=0x%p\n", lcdc_state_orig.fdadr0 + 16, descriptors);
++    memset(descriptors, 0, sizeof(descriptor_t) * MAX_DESCRIPTORS);
++    PRINT_DEBUG("  descriptors : 0x%p, 0x%p\n", &descriptors[0], &descriptors[1]);
++#endif
++
++    init_waitqueue_head(&fbr2_wait);
++    init_waitqueue_head(&fbr3_wait);
++    init_waitqueue_head(&fbr4_wait);
++    init_waitqueue_head(&wq_lcd_quick_disable_done);
++    init_waitqueue_head(&wq_lcd_disable_done);
++
++    next_fbr2 = 0;
++    next_fbr3 = 0;
++    next_fbr4 = 0;
++
++    request_irq(17, inttest, SA_INTERRUPT|SA_SHIRQ, "bvdd", (void *)0xDEADBEAF);
++
++    device_open++;
++
++    MOD_INC_USE_COUNT;
++
++    return 0;
++}
++
++
++static int bvdd_release(struct inode *inode,
++			struct file *file)
++{
++    PRINT_DEBUG("bvdd_release(0x%p, 0x%p)\n", inode, file);
++    PRINT_DEBUG("  ***** %d\n", REG_LCSR1 & 0x200);
++
++    free_irq(17, (void *)0xDEADBEAF);
++
++    /* restore lcdc state */
++    lcdc_state_write(&lcdc_state_orig);
++    lcdc_state_write(&lcdc_state_orig);
++
++    // free vram
++    if (vram_virt != NULL) {
++	printk(DEVICE_NAME ":  Now freeing vram.\n");
++	consistent_free(vram_virt, vram_size, vram_phys);
++	vram_virt = NULL;
++    } else {
++	printk(DEVICE_NAME ":  vram is not allocated.\n");
++    }
++    free_vram();
++
++#ifndef USE_PXAFB_DESCRIPTOR_AREA
++    // free descriptor
++    consistent_free(descriptors, descriptor_size, descriptor_phys);
++    descriptors = NULL;
++    descriptor_size = 0;
++    descriptor_phys = 0;
++#else
++    descriptors = NULL;
++#endif
++
++    // free descriptor cache
++    desc_cache_index = 0;
++
++    __asm__ __volatile__ ("mcr p15, 0, %0, c15, c1, 0" : :"r"(0));
++
++    /* We're now ready for our next caller */
++    device_open --;
++
++    MOD_DEC_USE_COUNT;
++
++    return 0;
++}
++
++#define SHARPSL_PXA_VSYNC_TIMEOUT 30000 // timeout = 30[ms] > 16.8[ms]
++//
++static void bvdd_vsync()
++{
++    int timeout = SHARPSL_PXA_VSYNC_TIMEOUT;
++
++    while(timeout > 0)
++    {
++	if ((GPLR(GPIO74_LCD_FCLK) & GPIO_bit(GPIO74_LCD_FCLK)))
++	    break;
++	udelay(1);
++	timeout--;
++    }
++    while(timeout > 0)
++    {
++	if (!(GPLR(GPIO74_LCD_FCLK) & GPIO_bit(GPIO74_LCD_FCLK)))
++	    break;
++	udelay(1);
++	timeout--;
++    }
++}
++
++static int bvdd_setup_frame(int type, bvdd_frame_t *frame_user, int is_branch)
++{
++    bvdd_frame_t frame;
++    int i;
++
++    copy_from_user(&frame, (void *)frame_user, sizeof(frame));
++
++#if 0
++    PRINT_DEBUG("bvdd_setup_frame(type=%d,bvdd_frame_t*=0x%p)\n", type, frame_user);
++    printk(DEVICE_NAME ":   bvdd_frame_t {\n");
++    printk(DEVICE_NAME ":     format=%d\n", frame.format);
++    printk(DEVICE_NAME ":     width=%d\n", frame.width);
++    printk(DEVICE_NAME ":     height=%d\n", frame.height);
++    printk(DEVICE_NAME ":     x=%d\n", frame.x);
++    printk(DEVICE_NAME ":     y=%d\n", frame.y);
++    printk(DEVICE_NAME ":     offset=0x%p\n", frame.offset);
++    printk(DEVICE_NAME ":     u_offset=0x%p\n", frame.u_offset);
++    printk(DEVICE_NAME ":     v_offset=0x%p\n", frame.v_offset);
++    printk(DEVICE_NAME ":   }\n");
++#endif
++
++    if (frame.format > 16) {
++	unsigned int desc, y_stride, uv_stride;
++
++	y_stride = (frame.width + 15) & ~15;
++	uv_stride = y_stride / 2;
++
++/* 	lcdc_state.lccr3.f.PDFOR = 3; */
++
++	lcdc_state.ovl2c1.f.O2EN = 1;
++	lcdc_state.ovl2c1.f.LPO2 = frame.height - 1;
++	lcdc_state.ovl2c1.f.PPL2 = y_stride - 1;
++	lcdc_state.ovl2c1.f.BPP2 = 0;
++	lcdc_state.ovl2c2.f.FOR = frame.format - 16;
++/* 	lcdc_state.ovl2c2.f.FOR = 4; */
++	lcdc_state.ovl2c2.f.O2XPOS = frame.x;
++	lcdc_state.ovl2c2.f.O2YPOS = frame.y;
++
++	desc = lcdc_set_descriptor(frame.offset, y_stride * frame.height);
++	if (desc == 0) {
++	    PRINT_DEBUG("  couldn't set descriptors.\n");
++	    return -1;
++	}
++	lcdc_state.fdadr2 = desc;
++
++	desc = lcdc_set_descriptor(frame.u_offset, uv_stride * (frame.height / 2));
++	if (desc == 0) {
++	    PRINT_DEBUG("  couldn't set descriptors.\n");
++	    lcdc_state.fdadr2 = 0;
++	    return -1;
++	}
++	lcdc_state.fdadr3 = desc;
++
++	desc = lcdc_set_descriptor(frame.v_offset, uv_stride * (frame.height / 2));
++	if (desc == 0) {
++	    PRINT_DEBUG("  couldn't set descriptors.\n");
++	    lcdc_state.fdadr2 = 0;
++	    lcdc_state.fdadr3 = 0;
++	    return -1;
++	}
++	lcdc_state.fdadr4 = desc;
++
++	if (is_branch) {
++/* 	    interruptible_sleep_on(&fbr2_wait); */
++/* 	    interruptible_sleep_on(&fbr3_wait); */
++/* 	    interruptible_sleep_on(&fbr4_wait); */
++	    wait_event_interruptible(fbr2_wait, (next_fbr2 == 0));
++	    wait_event_interruptible(fbr3_wait, (next_fbr3 == 0));
++	    wait_event_interruptible(fbr4_wait, (next_fbr4 == 0));
++	    disable_irq(17);
++	    next_fbr2 = lcdc_state.fdadr2;
++	    next_fbr3 = lcdc_state.fdadr3;
++	    next_fbr4 = lcdc_state.fdadr4;
++	    enable_irq(17);
++	} else {
++	    lcdc_state_print(&lcdc_state);
++	    lcdc_state_write(&lcdc_state);
++	}
++    }
++}
++
++static int bvdd_ioctl(struct inode *inode, struct file *file,
++		      unsigned int ioctl_num, unsigned long ioctl_param)
++{
++    int i;
++    char *temp;
++    char ch;
++
++    switch (ioctl_num) {
++    case BVDD_IOCTL_SETUP_VRAM: {
++	printk(DEVICE_NAME ": BVDD_IOCTL_SETUP_VRAM(0x%08x)\n", ioctl_param);
++#if 0
++	// 既にVRAMが確保されていれば解放する
++	if (vram_virt != NULL) {
++	    printk(DEVICE_NAME ":   now freeing allocated vram\n");
++	    consistent_free(vram_virt, vram_size, vram_phys);
++	}
++
++	vram_size = PAGE_ALIGN(ioctl_param + PAGE_SIZE);
++	vram_virt = consistent_alloc(GFP_KERNEL /* | GFP_DMA */, vram_size, &vram_phys);
++	if (vram_virt == NULL) {
++	    printk(DEVICE_NAME ":   consistent_alloc failed\n");
++	    return -EINVAL;
++	}
++
++	printk(DEVICE_NAME ":   vram_virt=0x%p\n", vram_virt);
++	printk(DEVICE_NAME ":   vram_phys=0x%p\n", vram_phys);
++	printk(DEVICE_NAME ":   vram_size=%d\n", vram_size);
++	vram_areas[2].start_virt = vram_virt;
++	vram_areas[2].start_phys = vram_phys;
++	vram_areas[2].end_phys = vram_phys + vram_size;
++	vram_areas[2].offset = BVDD_VRAM_OFFSET_USER;
++#endif
++	free_vram();
++	if (setup_vram(ioctl_param) < 0)
++	    return -EINVAL;
++
++	break;
++    }
++
++    case BVDD_IOCTL_SETUP_BASE_FRAME: {
++	printk(DEVICE_NAME ": BVDD_IOCTL_SETUP_BASE_FRAME(0x%08x)\n", ioctl_param);
++	break;
++    }
++    case BVDD_IOCTL_SETUP_OVERLAY1_FRAME: {
++	break;
++    }
++    case BVDD_IOCTL_SETUP_OVERLAY2_FRAME: {
++	bvdd_frame_t frame;
++	printk(DEVICE_NAME ": BVDD_IOCTL_SETUP_OVERLAY2_FRAME(0x%08x)\n", ioctl_param);
++	bvdd_setup_frame(2, (bvdd_frame_t *)ioctl_param, 0);
++	break;
++    }
++
++    case BVDD_IOCTL_BRANCH_OVERLAY2_FRAME: {
++	bvdd_frame_t frame;
++/* 	PRINT_DEBUG("BVDD_IOCTL_BRANCH_OVERLAY2_FRAME(0x%08x)\n", ioctl_param); */
++	bvdd_setup_frame(2, (bvdd_frame_t *)ioctl_param, 1);
++	break;
++    }
++
++    case BVDD_IOCTL_SET_IWMMXT_STATE: {
++	__asm__ __volatile__ ("mcr p15, 0, %0, c15, c1, 0" : :"r"(ioctl_param ? 3 : 0));
++	break;
++    }
++
++#if defined(CONFIG_SL_CCCR_CHANGE)
++    case BVDD_IOCTL_GET_CCCR: {
++      *((int *)ioctl_param) = read_cccr();
++      printk(DEVICE_NAME ": Read CCCR = %x.\n", *((int *)ioctl_param));
++      break;
++    }
++    case BVDD_IOCTL_SET_CCCR: {
++      write_cccr((int)ioctl_param);
++      printk(DEVICE_NAME ": Change CCCR = %x.\n", (int)ioctl_param);
++      break;
++    }
++#endif
++#if defined(CONFIG_CHANGE_CORE_VOLT)
++    case BVDD_IOCTL_GET_VCORE: {
++      *((int *)ioctl_param) = read_vcore();
++      printk(DEVICE_NAME ": Read VCORE = %x.\n", *((int *)ioctl_param));
++      break;
++    }
++    case BVDD_IOCTL_SET_VCORE: {
++      write_vcore((int)ioctl_param);
++      printk(DEVICE_NAME ": Change VCORE = %x.\n", (int)ioctl_param);
++      break;
++    }
++#endif
++
++    case BVDD_IOCTL_DEBUG: {
++	printk(DEVICE_NAME ": BVDD_IOCTL_DEBUG\n");
++	break;
++    }
++    }
++
++    return 0;
++}
++
++/*
++  vma->vm_start, vma->vm_end は、mmap引数がページ境界でなくともアラインされたものがこの関数に渡る。
++  vma->vm_pgoff は、mmap引数がページ境界でなければエラーになる。
++*/
++static int bvdd_mmap(struct file *file, struct vm_area_struct *vma)
++{
++    unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
++    struct page *map, *mapend;
++    int i, size;
++    unsigned long vma_start;
++
++    PRINT_DEBUG("bvdd_mmap(file=0x%p, vma=0x%p)\n", file, vma);
++
++/*     if (vram_virt == NULL) { */
++/* 	printk(DEVICE_NAME ":   vram is not allocated.\n"); */
++/* 	return -EINVAL; */
++/*     } */
++
++    printk(DEVICE_NAME ":   vm_start = 0x%p\n", (uint32_t)vma->vm_start);
++    printk(DEVICE_NAME ":   vm_end   = 0x%p\n", (uint32_t)vma->vm_end);
++    printk(DEVICE_NAME ":   vm_pgoff = 0x%p\n", (uint32_t)vma->vm_pgoff);
++    printk(DEVICE_NAME ":   vm_page_prot.pgprot = 0x%08u\n", (uint32_t)vma->vm_page_prot.pgprot);
++    printk(DEVICE_NAME ":   PAGE_OFFSET = %x\n", (int)PAGE_OFFSET);
++    printk(DEVICE_NAME ":   offset = %x\n", (int)offset);
++    printk(DEVICE_NAME ":   vram_phys = 0x%p\n", vram_phys);
++
++    if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
++	return -EINVAL;
++
++#if 0
++    if ((vma->vm_end - vma->vm_start + offset) > vram_size) {
++	printk(DEVICE_NAME ":   mmap length is too large (vram_size=%d, len=%d\n",
++	       vram_size, vma->vm_end - vma->vm_start + offset);
++	return -EINVAL;
++    }
++#endif
++
++    // from fbmem.c
++    vma->vm_flags |= VM_IO;
++    vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) | L_PTE_CACHEABLE);
++
++#if 0
++    for (i = vma->vm_pgoff; i < vma->vm_pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT); ++i) {
++	if (offset2phys_map[i] == 0) {
++	    printk(DEVICE_NAME ":   io_remap_page_range failed.\n");
++	    return -EAGAIN;
++	}
++	if (io_remap_page_range(vma->vm_start + (i << PAGE_SHIFT),
++				offset2phys_map[i],
++				PAGE_SIZE, vma->vm_page_prot)) {
++	    printk(DEVICE_NAME ":   io_remap_page_range failed.\n");
++	    return -EAGAIN;
++	}
++    }
++#endif
++
++#if 1
++    vma_start = vma->vm_start;
++    size = vma->vm_end - vma->vm_start;
++    while (size > 0) {
++	vram_area_t *va = NULL;
++	int aoff, alen;
++
++	for (i = 0; i < MAX_VRAM_AREAS; ++i) {
++	    va = &vram_areas[i];
++	    if (va->offset <= offset && offset < va->offset + (va->end_phys - va->start_phys))
++		break;
++	}
++	if (i == MAX_VRAM_AREAS) {
++	    return -EAGAIN;
++	}
++
++	aoff = offset - va->offset;
++	alen = va->end_phys - va->start_phys - aoff;
++	if (alen > size)
++	    alen = size;
++	PRINT_DEBUG("io_remap_page_range(0x%p, 0x%p, %d)\n", vma_start, va->start_phys + aoff, alen);
++	if (io_remap_page_range(vma_start, va->start_phys + aoff, alen, vma->vm_page_prot)) {
++	    printk(DEVICE_NAME ":   io_remap_page_range failed.\n");
++	    return -EAGAIN;
++	}
++	vma_start += alen;
++	size -= alen;
++	offset += alen;
++    }
++
++    printk(DEVICE_NAME ":   successed.\n");
++    return 0;
++#endif
++}
++
++/* Module Declarations *************************** */
++
++
++/* This structure will hold the functions to be called
++ * when a process does something to the device we
++ * created. Since a pointer to this structure is kept in
++ * the devices table, it can't be local to
++ * init_module. NULL is for unimplemented functions. */
++struct file_operations fops = {
++    ioctl : bvdd_ioctl,
++    mmap : bvdd_mmap,
++    open : bvdd_open,
++    release : bvdd_release,
++};
++
++
++/* Initialize the module - Register the character device */
++int init_module()
++{
++    int i, ret;
++    unsigned long *p;
++
++    /* Register the character device (atleast try) */
++    ret = register_chrdev(BVDD_MAJOR_NUM, DEVICE_NAME, &fops);
++
++    /* Negative values signify an error */
++    if (ret < 0) {
++	printk (DEVICE_NAME ": Registering the device failed with %d\n", ret);
++	return ret;
++    }
++
++    printk (DEVICE_NAME ": Registeration is a success. \n");
++
++    /* TODO */
++/*     vram_sharpsl_pxafb_phys = ((descriptor_t *)__phys_to_virt(FDADR0))->FSADR; */
++    vram_sharpsl_pxafb_phys = (dma_addr_t)0xA3E00000UL;
++
++#if 0
++    p = offset2phys_map;
++    for (i = 0; i < ((256 * 1024) >> PAGE_SHIFT); ++i) {
++	*p++ = SRAM_BASE_PHYS + (i << PAGE_SHIFT);
++    }
++    for (i = 0; i < ((PAGE_ALIGN(640 * 480 * 2)) >> PAGE_SHIFT); ++i) {
++	*p++ = vram_sharpsl_pxafb_phys + (i << PAGE_SHIFT);
++    }
++#endif
++
++    memset(vram_areas, 0, sizeof(vram_areas));
++    vram_areas[0].start_phys = vram_sharpsl_pxafb_phys;
++    vram_areas[0].start_virt = (void *)__phys_to_virt(vram_sharpsl_pxafb_phys);
++    vram_areas[0].end_phys = vram_areas[0].start_phys + PAGE_ALIGN(480 * 640 * 2);
++    vram_areas[0].offset = 0;
++    vram_areas[1].start_phys = SRAM_BASE_PHYS;
++    vram_areas[1].start_virt = (void *)SRAM_BASE;
++    vram_areas[1].end_phys = vram_areas[1].start_phys + 256 * 1024;
++    vram_areas[1].offset = PAGE_ALIGN(480 * 640 * 2);
++
++    return 0;
++}
++
++
++/* Cleanup - unregister the appropriate file from /proc */
++void cleanup_module()
++{
++    int ret;
++
++    /* Unregister the device */
++    ret = unregister_chrdev(BVDD_MAJOR_NUM, DEVICE_NAME);
++
++    /* If there's an error, report it */
++    if (ret < 0)
++	printk(DEVICE_NAME ": Error in unregister_chrdev: %d\n", ret);
++    printk (DEVICE_NAME ": Unregisteration is a success. \n");
++}
++
++#if 1
++//////////////////////////////////////////////
++#include <linux/interrupt.h>
++
++/*
++ * This allocates one page of cache-coherent memory space and returns
++ * both the virtual and a "dma" address to that space.  It is not clear
++ * whether this could be called from an interrupt context or not.  For
++ * now, we expressly forbid it, especially as some of the stuff we do
++ * here is not interrupt context safe.
++ *
++ * We should allow this function to be called from interrupt context.
++ * However, we call ioremap, which needs to fiddle around with various
++ * things (like the vmlist_lock, and allocating page tables).  These
++ * things aren't interrupt safe (yet).
++ *
++ * Note that this does *not* zero the allocated area!
++ */
++static void *consistent_alloc(int gfp, size_t size, dma_addr_t *dma_handle)
++{
++    return l_consistent_alloc2(gfp, size, dma_handle, L_PTE_CACHEABLE);
++}
++
++static void *l_consistent_alloc2(int gfp, size_t size, dma_addr_t *dma_handle, int pte)
++{
++    struct page *page, *end, *free;
++    unsigned long order;
++    void *ret;
++
++    /* FIXME */
++    if (in_interrupt())
++	BUG();
++
++    size = PAGE_ALIGN(size);
++    order = get_order(size);
++
++    page = alloc_pages(gfp, order);
++    if (!page) {
++	printk("size:%d, order:%d\n", size, order);
++	goto no_page;
++    }
++
++    *dma_handle = page_to_bus(page);
++    //ret = __ioremap(page_to_pfn(page) << PAGE_SHIFT, size, 0);
++    ret = __ioremap(page_to_pfn(page) << PAGE_SHIFT, size, pte);
++    if (!ret) {
++	goto no_remap;
++    }
++
++#if 0 /* ioremap_does_flush_cache_all */
++    {
++	void *virt = page_address(page);
++
++	/*
++	 * we need to ensure that there are no cachelines in use, or
++	 * worse dirty in this area.  Really, we don't need to do
++	 * this since __ioremap does a flush_cache_all() anyway. --rmk
++	 */
++	invalidate_dcache_range(virt, virt + size);
++    }
++#endif
++
++    /*
++     * free wasted pages.  We skip the first page since we know
++     * that it will have count = 1 and won't require freeing.
++     * We also mark the pages in use as reserved so that
++     * remap_page_range works.
++     */
++    free = page + (size >> PAGE_SHIFT);
++    end  = page + (1 << order);
++
++    for (; page < end; page++) {
++	set_page_count(page, 1);
++	if (page >= free)
++	    __free_page(page);
++	else
++	    SetPageReserved(page);
++    }
++    return ret;
++
++ no_remap:
++    __free_pages(page, order);
++ no_page:
++    return NULL;
++}
++
++/*
++ * free a page as defined by the above mapping.  We expressly forbid
++ * calling this from interrupt context.
++ */
++static void consistent_free(void *vaddr, size_t size, dma_addr_t handle)
++{
++    struct page *page, *end;
++
++    if (in_interrupt())
++	BUG();
++
++    /*
++     * More messing around with the MM internals.  This is
++     * sick, but then so is remap_page_range().
++     */
++    size = PAGE_ALIGN(size);
++    page = virt_to_page(bus_to_virt(handle));
++    end = page + (size >> PAGE_SHIFT);
++
++    for (; page < end; page++)
++	ClearPageReserved(page);
++
++    __iounmap(vaddr);
++}
++
++#endif
++
++/*
++
++document
++
++- Do not change resolution (VGA, QVGA) while bvdd device opened. (TODO)
++- open()するときとclose()するときの解像度が同じでないといけません。
++  状態が違ったときの動作は未保証です。
++
++
++*/
+diff -Nur c3000_pre/linux/drivers/video/bvdd.h c3000_work/linux/drivers/video/bvdd.h
+--- c3000_pre/linux/drivers/video/bvdd.h	1970-01-01 09:00:00.000000000 +0900
++++ c3000_work/linux/drivers/video/bvdd.h	2005-02-21 23:48:01.000000000 +0900
+@@ -0,0 +1,64 @@
++/*  bulverded.h - bulverde(PXA27x) display driver
++BulVerDD
++ */
++
++#ifndef CHARDEV_H
++#define CHARDEV_H
++
++#include <linux/ioctl.h>
++
++#define BVDD_VRAM_OFFSET_PXAFB (0)
++#define BVDD_VRAM_OFFSET_SRAM (480 * 640 * 2)
++#define BVDD_VRAM_OFFSET_USER (BVDD_VRAM_OFFSET_SRAM + (256 * 1024))
++
++#define BVDD_FORMAT_RGB2 1	/* 2-bits/pixel [4 entry palette] */
++#define BVDD_FORMAT_RGB4 2	/* 4-bits/pixel [16 entry palette] */
++#define BVDD_FORMAT_RGB8 3	/* 8-bits/pixel [256 entry palette] */
++#define BVDD_FORMAT_RGB16 4	/* 16-bits/pixel */
++#define BVDD_FORMAT_RGB18 5	/* 18-bits/pixel, unpacked */
++#define BVDD_FORMAT_RGB18P 6	/* 18-bits/pixel, packed */
++#define BVDD_FORMAT_RGB19 7	/* 19-bits/pixel, unpacked */
++#define BVDD_FORMAT_RGB19P 8	/* 19-bits/pixel, packed */
++#define BVDD_FORMAT_RGB24 9	/* 24-bits/pixel */
++#define BVDD_FORMAT_RGB25 10	/* 25-bits/pixel */
++#define BVDD_FORMAT_YUV444P 17	/* YCbCr4:4:4 Packed */
++#define BVDD_FORMAT_YUV444 18	/* YCbCr4:4:4 Planar */
++#define BVDD_FORMAT_YUV422 19	/* YCbCr4:2:2 Planar */
++#define BVDD_FORMAT_YUV420 20	/* YCbCr4:2:0 Planar */
++
++
++typedef struct {
++    unsigned char format;
++    unsigned short width;
++    unsigned short height;
++    unsigned short x;
++    unsigned short y;
++    unsigned long offset;	/* aligned on a 16-byte boundary */
++    unsigned long u_offset;	/* aligned on a 16-byte boundary */
++    unsigned long v_offset;	/* aligned on a 16-byte boundary */
++} bvdd_frame_t;
++
++/* The major device number. We can't rely on dynamic 
++ * registration any more, because ioctls need to know 
++ * it. */
++#define BVDD_MAJOR_NUM 240
++
++/* Set the message of the device driver */
++#define BVDD_IOCTL_SETUP_VRAM _IOR(BVDD_MAJOR_NUM, 0, uint32_t)
++#define BVDD_IOCTL_SETUP_BASE_FRAME _IOR(BVDD_MAJOR_NUM, 1, bvdd_frame_t *)
++#define BVDD_IOCTL_SETUP_OVERLAY1_FRAME _IOR(BVDD_MAJOR_NUM, 2, bvdd_frame_t *)
++#define BVDD_IOCTL_SETUP_OVERLAY2_FRAME _IOR(BVDD_MAJOR_NUM, 3, bvdd_frame_t *)
++#define BVDD_IOCTL_BRANCH_OVERLAY2_FRAME _IOR(BVDD_MAJOR_NUM, 6, bvdd_frame_t *)
++#define BVDD_IOCTL_SET_IWMMXT_STATE _IOR(BVDD_MAJOR_NUM, 7, int)
++#define BVDD_IOCTL_GET_CCCR _IOR(BVDD_MAJOR_NUM, 11, int *)
++#define BVDD_IOCTL_SET_CCCR _IOR(BVDD_MAJOR_NUM, 12, int)
++#define BVDD_IOCTL_GET_VCORE _IOR(BVDD_MAJOR_NUM, 13, int *)
++#define BVDD_IOCTL_SET_VCORE _IOR(BVDD_MAJOR_NUM, 14, int)
++
++#define BVDD_IOCTL_DEBUG _IO(BVDD_MAJOR_NUM, 10)
++
++/* The name of the device file */
++#define BVDD_DEVICE_FILE_NAME "bvdd"
++
++
++#endif
+diff -Nur c3000_pre/linux/drivers/video/bvdd_p.h c3000_work/linux/drivers/video/bvdd_p.h
+--- c3000_pre/linux/drivers/video/bvdd_p.h	1970-01-01 09:00:00.000000000 +0900
++++ c3000_work/linux/drivers/video/bvdd_p.h	2005-02-21 23:41:29.000000000 +0900
+@@ -0,0 +1,284 @@
++#ifndef BVDD_P_INCLUDED
++#define BVDD_P_INCLUDED
++
++#include <asm/hardware.h>
++
++#define REG_LCCR0	__REG(0x44000000) /* LCD Controller Control register 0 */
++#define REG_LCCR1	__REG(0x44000004) /* LCD Controller Control register 1 */
++#define REG_LCCR2	__REG(0x44000008) /* LCD Controller Control register 2 */
++#define REG_LCCR3	__REG(0x4400000C) /* LCD Controller Control register 3 */
++#define REG_LCCR4	__REG(0x44000010) /* LCD Controller Control register 4 */
++#define REG_LCCR5	__REG(0x44000014) /* LCD Controller Control register 5 */
++#define REG_FBR0	__REG(0x44000020)
++#define REG_FBR1	__REG(0x44000024)
++#define REG_FBR2	__REG(0x44000028)
++#define REG_FBR3	__REG(0x4400002C)
++#define REG_FBR4	__REG(0x44000030)
++#define REG_LCSR1	__REG(0x44000034)
++#define REG_LCSR0	__REG(0x44000038)
++#define REG_LIIDR	__REG(0x4400003C)
++#define REG_TRGBR	__REG(0x44000040)
++#define REG_TCR		__REG(0x44000044)
++#define REG_OVL1C1	__REG(0x44000050)
++#define REG_OVL1C2	__REG(0x44000060)
++#define REG_OVL2C1	__REG(0x44000070)
++#define REG_OVL2C2	__REG(0x44000080)
++#define REG_CCR		__REG(0x44000090)
++#define REG_CMDCR	__REG(0x44000100)
++#define REG_PRSR	__REG(0x44000104)
++#define REG_FBR5	__REG(0x44000110)
++#define REG_FBR6	__REG(0x44000114)
++#define REG_FDADR0	__REG(0x44000200)
++#define REG_FSADR0	__REG(0x44000204)
++#define REG_FIDR0	__REG(0x44000208)
++#define REG_LDCMD0	__REG(0x4400020C)
++#define REG_FDADR1	__REG(0x44000210)
++#define REG_FSADR1	__REG(0x44000214)
++#define REG_FIDR1	__REG(0x44000218)
++#define REG_LDCMD1	__REG(0x4400021C)
++#define REG_FDADR2	__REG(0x44000220)
++#define REG_FSADR2	__REG(0x44000224)
++#define REG_FIDR2	__REG(0x44000228)
++#define REG_LDCMD2	__REG(0x4400022C)
++#define REG_FDADR3	__REG(0x44000230)
++#define REG_FSADR3	__REG(0x44000234)
++#define REG_FIDR3	__REG(0x44000238)
++#define REG_LDCMD3	__REG(0x4400023C)
++#define REG_FDADR4	__REG(0x44000240)
++#define REG_FSADR4	__REG(0x44000244)
++#define REG_FIDR4	__REG(0x44000248)
++#define REG_LDCMD4	__REG(0x4400024C)
++#define REG_FDADR5	__REG(0x44000250)
++#define REG_FSADR5	__REG(0x44000254)
++#define REG_FIDR5	__REG(0x44000258)
++#define REG_LDCMD5	__REG(0x4400025C)
++#define REG_FDADR6	__REG(0x44000260)
++#define REG_FSADR6	__REG(0x44000264)
++#define REG_FIDR6	__REG(0x44000268)
++#define REG_LDCMD6	__REG(0x4400026C)
++#define REG_LCDBSCNTR	__REG(0x48000054)
++
++typedef struct {
++    unsigned long ENB		: 1; /* LCD Controller Enable */
++    unsigned long CMS		: 1; /* Color/Monochrome Select */
++    unsigned long SDS		: 1; /* Single-Scan/dual-scan Display Select */
++    unsigned long LDM		: 1; /* LCD Disable Done Mask */
++    unsigned long SOFM0		: 1; /* Start of Frame Mask for Channel 0 and Channel 1 (Dual Scan) */
++    unsigned long IUM		: 1; /* Input FIFO Underrun Mask */
++    unsigned long EOFM0		: 1; /* End of Frame Mask for Channel 0 and for Channel 1 (Dual Scan) */
++    unsigned long PAS		: 1; /* Passive/Active Display Select */
++    unsigned long reserved2	: 1;
++    unsigned long DPD		: 1; /* Double-Pixel Data (DPD) Pin Mode */
++    unsigned long DIS		: 1; /* LCD Disable */
++    unsigned long QDM		: 1; /* LCD Quick Disable Mask */
++    unsigned long PDD		: 8; /* Palette DMA Request Delay */
++    unsigned long BSM0		: 1; /* Branch Status Mask */
++    unsigned long OUM		: 1; /* Output FIFO Underrun Mask */
++    unsigned long LCDT		: 1; /* LCD Panel Type */
++    unsigned long RDSTM		: 1; /* LCD Read Status Interrupt Mask */
++    unsigned long CMDIM		: 1; /* LCD Command Interrupt Mask */
++    unsigned long OUC		: 1; /* Overlay Underlay Control Bit */
++    unsigned long LDDALT	: 1; /* LDD Alternate Mapping Control Bit */
++    unsigned long reserved1     : 5;
++} LCCR0_t;
++typedef union {
++    LCCR0_t f;
++    unsigned long val;
++} LCCR0_u;
++
++typedef struct {
++    unsigned long PPL		:10; /* Pixels per Line for the Base Frame */
++    unsigned long HSW		: 6; /* Horizontal Sync Pulse Width */
++    unsigned long ELW		: 8; /* End-of-Line Pixel Clock Wait Count */
++    unsigned long BLW		: 8; /* Beginning-of-Line Pixel Clock Wait Count */
++} LCCR1_t;
++typedef union {
++    LCCR1_t f;
++    unsigned long val;
++} LCCR1_u;
++
++typedef struct {
++    unsigned long LPP		:10; /* Lines per Panel for the Base Frame */
++    unsigned long VSW		: 6; /* Vertical Sync Pulse Width */
++    unsigned long EFW		: 8; /* End-of-Frame Line Clock Wait Count */
++    unsigned long BFW		: 8; /* Beginning-of-Frame Line Clock Wait Count */
++} LCCR2_t;
++typedef union {
++    LCCR2_t f;
++    unsigned long val;
++} LCCR2_u;
++
++typedef struct {
++    unsigned long PCD		: 8; /* Pixel Clock Divisor */
++    unsigned long ACB		: 8; /* AC Bias Pin Frequency */
++    unsigned long API		: 4; /* AC Bias Pin Transitions per Interrupt */
++    unsigned long VSP		: 1; /* Vertical Sync Polarity */
++    unsigned long HSP		: 1; /* Horizontal Sync Polarity */
++    unsigned long PCP		: 1; /* Pixel Clock Polarity */
++    unsigned long OEP		: 1; /* Output Enable Polarity */
++    unsigned long BPP		: 3; /* Bits per Pixel */
++    unsigned long DPC		: 1; /* Double Pixel Clock Mode */
++    unsigned long reserved1	: 1;
++    unsigned long BPP3		: 1; /* Bits per Pixel */
++    unsigned long PDFOR		: 2; /* Pixel Data Format */
++} LCCR3_t;
++typedef union {
++    LCCR3_t f;
++    unsigned long val;
++} LCCR3_u;
++
++typedef struct {
++    unsigned long K1		: 3; /* Multiplication Constant for Red for Half Transparency */
++    unsigned long K2		: 3; /* Multiplication Constant for Blue for Half Transparency */
++    unsigned long K3		: 3; /* Multiplication Constant for Green for Half Transparency */
++    unsigned long reserved2	: 6;
++    unsigned long PAL_FOR	: 2; /* Palette Data Format */
++    unsigned long reserved1	:12;
++    unsigned long PCDDIV	: 1; /* PCD Divisor Selection */
++} LCCR4_t;
++typedef union {
++    LCCR4_t f;
++    unsigned long val;
++} LCCR4_u;
++
++/* LCCR5 unused */
++
++typedef struct {
++    unsigned long PPL1		:10; /* Pixels per Line for Overlay 1 Frame */
++    unsigned long LPO1		:10; /* Number of Lines for Overlay 1 */
++    unsigned long BPP1		: 4; /* Bits per Pixel for Overlay 1 */
++    unsigned long reserved1	: 7;
++    unsigned long O1EN		: 1; /* Enable bit for Overlay 1 */
++} OVL1C1_t;
++typedef union {
++    OVL1C1_t f;
++    unsigned long val;
++} OVL1C1_u;
++
++typedef struct {
++    unsigned long O1XPOS	:10; /* Horizontal Position of the Upper Left-Most Pixel of Overlay 1 Window */
++    unsigned long O1YPOS	:10; /* Vertical Position of the Upper Left-Most Pixel of Overlay 1 Window */
++    unsigned long reserved1	:12;
++} OVL1C2_t;
++typedef union {
++    OVL1C2_t f;
++    unsigned long val;
++} OVL1C2_u;
++
++typedef struct {
++    unsigned long PPL2		:10; /* Pixels per Line for Overlay 2 Frame */
++    unsigned long LPO2		:10; /* Number of Lines for Overlay 2 Frame */
++    unsigned long BPP2		: 4; /* Bits per Pixel for Overlay 2 */
++    unsigned long reserved1	: 7;
++    unsigned long O2EN		: 1; /* Overlay 2 Enable */
++} OVL2C1_t;
++typedef union {
++    OVL2C1_t f;
++    unsigned long val;
++} OVL2C1_u;
++
++typedef struct {
++    unsigned long O2XPOS	:10; /* Horizontal Position of the Upper Left Most Pixel of Overlay 2 */
++    unsigned long O2YPOS	:10; /* Vertical Position of the Upper Left Most Pixel of Overlay 2 */
++    unsigned long FOR		: 3; /* Format */
++    unsigned long reserved1	: 9;
++} OVL2C2_t;
++typedef union {
++    OVL2C2_t f;
++    unsigned long val;
++} OVL2C2_u;
++
++#undef BS0
++typedef struct {
++    unsigned long LDD		: 1; /* LCD Disable Done Flag */
++    unsigned long SOF0		: 1; /* Start of Frame Status for Base */
++    unsigned long BER		: 1; /* Bus Error Status */
++    unsigned long ABC		: 1; /* AC Bias Count Status */
++    unsigned long IU0		: 1; /* Input FIFO Underrun for Channel 0 */
++    unsigned long IU1		: 1; /* Input FIFO Underrun for Channel 1 */
++    unsigned long OU		: 1; /* Output FIFO Underrun */
++    unsigned long QD		: 1; /* LCD Quick Disable Status */
++    unsigned long EOF0		: 1; /* End of Frame Status for Base (Channel 0) */
++    unsigned long BS0		: 1; /* Branch Status for Base */
++    unsigned long SINT		: 1; /* Subsequent Interrupt Status */
++    unsigned long RD_ST		: 1; /* Read Status */
++    unsigned long CMD_INT	: 1; /* Command Interrupt Status */
++    unsigned long reserved2	:15;
++    unsigned long BER_CH	: 3; /* Bus Error Channel Number */
++    unsigned long reserved1	: 1;
++} LCSR0_t;
++typedef union {
++    LCSR0_t f;
++    unsigned long val;
++} LCSR0_u;
++
++#undef BS1
++typedef struct {
++    unsigned long SOF1		: 1; /* Start of Frame Status for Channel 1 */
++    unsigned long SOF2		: 1; /* Start of Frame Status for Channel 2 */
++    unsigned long SOF3		: 1; /* Start of Frame Status for Channel 3 */
++    unsigned long SOF4		: 1; /* Start of Frame Status for Channel 4 */
++    unsigned long SOF5		: 1; /* Start of Frame Status for Channel 5 */
++    unsigned long SOF6		: 1; /* Start of Frame Status for Channel 6 */
++    unsigned long reserved4	: 2;
++    unsigned long EOF1		: 1; /* End of Frame Status for Channel 1 */
++    unsigned long EOF2		: 1; /* End of Frame Status for Channel 2 */
++    unsigned long EOF3		: 1; /* End of Frame Status for Channel 3 */
++    unsigned long EOF4		: 1; /* End of Frame Status for Channel 4 */
++    unsigned long EOF5		: 1; /* End of Frame Status for Channel 5 */
++    unsigned long EOF6		: 1; /* End of Frame Status for Channel 6 */
++    unsigned long reserved3	: 2;
++    unsigned long BS1		: 1; /* Branch Status for Channel 1 (Command Register) */
++    unsigned long BS2		: 1; /* Branch Status for Channel 2 (Command Register) */
++    unsigned long BS3		: 1; /* Branch Status for Channel 3 (Command Register) */
++    unsigned long BS4		: 1; /* Branch Status for Channel 4 (Command Register) */
++    unsigned long BS5		: 1; /* Branch Status for Channel 5 (Command Register) */
++    unsigned long BS6		: 1; /* Branch Status for Channel 6 (Command Register) */
++    unsigned long reserved2	: 3;
++    unsigned long IU2		: 1; /* Input FIFO Underrun for Channel 2 */
++    unsigned long IU3		: 1; /* Input FIFO Underrun for Channel 3 */
++    unsigned long IU4		: 1; /* Input FIFO Underrun for Channel 4 */
++    unsigned long IU5		: 1; /* Input FIFO Underrun for Channel 5 */
++    unsigned long IU6		: 1; /* Input FIFO Underrun for Channel 6 */
++    unsigned long reserved1	: 2;
++} LCSR1_t;
++typedef union {
++    LCSR1_t f;
++    unsigned long val;
++} LCSR1_u;
++
++/* CCR unused */
++/* CMDCR unused */
++/* TRGBR unused */
++/* TCR unused */
++
++typedef struct {
++    unsigned long LCDBS		: 4; /* LCD Buffer Strength */
++    unsigned long reserved1	:28;
++} LCDBSCNTR_t;
++typedef union {
++    LCDBSCNTR_t f;
++    unsigned long val;
++} LCDBSCNTR_u;
++
++typedef struct {
++    LCCR0_u lccr0;
++    LCCR1_u lccr1;
++    LCCR2_u lccr2;
++    LCCR3_u lccr3;
++    LCCR4_u lccr4;
++    OVL1C1_u ovl1c1;
++    OVL1C2_u ovl1c2;
++    OVL2C1_u ovl2c1;
++    OVL2C2_u ovl2c2;
++    unsigned long fdadr0;
++    unsigned long fdadr1;
++    unsigned long fdadr2;
++    unsigned long fdadr3;
++    unsigned long fdadr4;
++    unsigned long fdadr5;
++    unsigned long fdadr6;
++    char cken20_intmem;
++} lcdc_state_t;
++
++#endif /* BVDD_P_INCLUDED */