path: root/packages/linux/linux-ezx/ezx_roflash.patch

Roflash driver (don't think it will be needed for 2.6.x)

diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/drivers/block/Kconfig linux-2.6.16.5-exz/drivers/block/Kconfig
--- linux-2.6.16.5/drivers/block/Kconfig	2006-04-12 22:27:57.000000000 +0200
+++ linux-2.6.16.5-exz/drivers/block/Kconfig	2006-04-16 18:49:29.000000000 +0200
@@ -453,4 +453,6 @@
 	This driver provides Support for ATA over Ethernet block
 	devices like the Coraid EtherDrive (R) Storage Blade.
 
+source "drivers/block/roflash/Kconfig"
+
 endmenu
diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/drivers/block/Makefile linux-2.6.16.5-exz/drivers/block/Makefile
--- linux-2.6.16.5/drivers/block/Makefile	2006-04-12 22:27:57.000000000 +0200
+++ linux-2.6.16.5-exz/drivers/block/Makefile	2006-04-16 18:49:29.000000000 +0200
@@ -31,3 +31,4 @@
 obj-$(CONFIG_BLK_DEV_SX8)	+= sx8.o
 obj-$(CONFIG_BLK_DEV_UB)	+= ub.o
 
+obj-$(CONFIG_ARCH_EZX_ROFLASH)	+= roflash/
diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/drivers/block/roflash/Kconfig linux-2.6.16.5-exz/drivers/block/roflash/Kconfig
--- linux-2.6.16.5/drivers/block/roflash/Kconfig	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.16.5-exz/drivers/block/roflash/Kconfig	2006-04-16 18:49:29.000000000 +0200
@@ -0,0 +1,7 @@
+#
+# Emualting Flash Chip driver configuration
+#
+config ARCH_EZX_ROFLASH
+	tristate 'ROFLASH Device'
+
+#tristate 'Debug for ROFLASH device?'  ROFLASH_DEBUG_ERR
diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/drivers/block/roflash/Makefile linux-2.6.16.5-exz/drivers/block/roflash/Makefile
--- linux-2.6.16.5/drivers/block/roflash/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.16.5-exz/drivers/block/roflash/Makefile	2006-04-16 18:49:29.000000000 +0200
@@ -0,0 +1,15 @@
+#
+# Makefile for VFM
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+# Note 2! The CFLAGS definitions are now inherited from the
+# parent makes..
+
+#
+# Makefile for the kernel VSB driver.
+#
+
+obj-$(CONFIG_ARCH_EZX_ROFLASH) += roflash.o ezx_parts.o
diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/drivers/block/roflash/ezx_parts.c linux-2.6.16.5-exz/drivers/block/roflash/ezx_parts.c
--- linux-2.6.16.5/drivers/block/roflash/ezx_parts.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.16.5-exz/drivers/block/roflash/ezx_parts.c	2006-04-16 18:49:29.000000000 +0200
@@ -0,0 +1,198 @@
+/*
+ * drivers/mtd/maps/ezx_parts.c
+ *
+ * Parse multiple flash partitions in Ezx project into mtd_table or into act_roflash_table
+ *
+ * Created by Susan Gu  Oct, 22  2002
+ * 
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <asm/io.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/map.h>
+#include <linux/mtd/partitions.h>
+#include <linux/ezx_roflash.h>
+
+extern int roflash_init(void);
+
+extern int cfi_intelext_read_roflash(void *priv_map, unsigned long from, size_t len, size_t *retlen, u_char *buf);
+extern int cfi_intelext_read_roflash_c(void *priv_map, unsigned long from, size_t len, size_t *retlen, u_char *buf);
+roflash_area **roflash_table_pptr = NULL;
+
+static DECLARE_MUTEX(roflash_table_mutex);
+
+/* I know what I am doing, so setup l_x_b flag */
+#ifdef CONFIG_ARCH_EZX_A780
+static roflash_area  fix_roflash_table[]= 
+{
+	{
+		name:		"rootfs",
+		size:		0x018E0000,  /* rootfs size is 24.875MB */
+		offset:		0x00120000,
+		roflash_read:   NULL,  /* force read-only in cacheable mapping*/
+		l_x_b:		ROFLASH_LINEAR,
+		phys_addr:	0x00000000,
+	},{
+		name:		"NO-USE",  /* language package is moved to MDOC */
+		size:		0x00000000,
+		offset:		0x01A00000,  //Susan -- correspond to the beginning of the second flash chip //
+		roflash_read:  cfi_intelext_read_roflash,
+		l_x_b:		ROFLASH_BLOCK,
+		phys_addr:  0xffffffff, // not use for block cramfs mount
+	},{
+		name:		"setup",
+		size:		0x00020000,
+		offset:         0x01FA0000,
+		roflash_read:  cfi_intelext_read_roflash,
+		l_x_b:		ROFLASH_BLOCK,
+		phys_addr:  0xffffffff, // not use for block cramfs mount
+	}
+};
+#if (0)
+static roflash_area  fix_roflash_table[]= 
+{
+	{
+		name:		"rootfs",
+		size:		0x00f00000,  /* rootfs size is 15MB */
+		offset:		0x00100000,
+		roflash_read:  NULL,  /* force read-only in cacheable mapping*/
+		l_x_b:		ROFLASH_LINEAR_XIP,
+		phys_addr:	0x00000000,
+	},{
+		name:		"nxipapp",  /* old language area is 0xAA0000 */
+		size:		0x00AA0000,
+		offset:		0x00500000,
+		roflash_read:  cfi_intelext_read_roflash,
+		l_x_b:		ROFLASH_BLOCK,
+		phys_addr:  0xffffffff, // not use for block cramfs mount
+	},{
+		name:		"setup",     /* setup stuff is 1MB */
+		size:		0x00020000,
+		offset:         0x00FA0000,
+		roflash_read:  cfi_intelext_read_roflash,
+		l_x_b:		ROFLASH_BLOCK,
+		phys_addr:  0xffffffff, //phys_addr is not useful for block cramfs mount
+	}
+};
+#endif
+
+#endif
+
+#ifdef CONFIG_ARCH_EZX_E680
+static roflash_area  fix_roflash_table[]= 
+{
+	{
+		name:		"rootfs",
+		size:		0x018E0000,  /* rootfs size is 15MB */
+		offset:		0x00120000,
+		roflash_read:   NULL,  /* force read-only in cacheable mapping*/
+		l_x_b:		ROFLASH_LINEAR,
+		phys_addr:	0x00000000,
+	},{
+		name:		"NO-USE",  /* language package is 2MB */
+		size:		0x00000000,
+		offset:		0x01A00000,  //Susan -- correspond to the beginning of the second flash chip //
+		roflash_read:  cfi_intelext_read_roflash,
+		l_x_b:		ROFLASH_BLOCK,
+		phys_addr:  0xffffffff, // not use for block cramfs mount
+	},{
+		name:		"setup",     /* setup stuff is 1MB */
+		size:		0x00020000,
+		offset:         0x01FA0000,  //Susan -- correspond to the beginning of the second flash chip //
+		roflash_read:  cfi_intelext_read_roflash,
+		l_x_b:		ROFLASH_BLOCK,
+		phys_addr:  0xffffffff, // not use for block cramfs mount
+	}
+};
+#endif
+
+roflash_area *act_roflash_table[MAX_ROFLASH] = {0};
+unsigned short roflash_partitions = 0;
+
+/* If we decide to use flash partition parse table, this function will parse the fpt - flash partition table,
+*  the beginning address of fpt is defined in CONFIG_FPT_OFFSET.  This function will parser out all roflash areas
+*  and animation area( or re-fresh code area).   
+*  For roflash areas, registered them into act_roflash_table, for animation region, register it into mtd_table[6].
+*  Note 
+*  6 is fixed for animation region -- /dev/mtd6 c 90 12
+*  /dev/roflash b 62 0  -- root file system
+*  /dev/roflash1 b 62 1 -- language package
+*  /dev/roflash2 b 62 2 -- setup stuff
+*/  
+int ezx_parse(struct map_info *chip_map)
+{
+	return 0;  // depends on discussion about DC tool
+}
+
+int ezx_parts_parser(void)
+{
+	int ret = 0;
+	int nrparts = 0;
+	int i = 0;
+
+//#ifdef CONFIG_EZX_PARSER_TABLE
+//	ret = ezx_parse(chip_map);
+//#else
+	down(&roflash_table_mutex);
+
+	nrparts = sizeof(fix_roflash_table) / sizeof(roflash_area);
+
+#ifdef ROFLASH_DEBUG_ERR
+	printk("ezx_parts_parser:  nrparts is %d\n", nrparts);
+#endif
+	for ( i = 0; i < nrparts; i ++ )
+	{
+		if (act_roflash_table[i])
+			return -1;
+		act_roflash_table[i] = (roflash_area *)(&(fix_roflash_table[i]));
+#ifdef ROFLASH_DEBUG_ERR
+		printk(KERN_ERR "ezx_parts_parser: act_roflash_table[%d] = %d\n",i,(unsigned long)(act_roflash_table[i]));
+#endif
+	}
+	roflash_partitions = i;
+
+#ifdef ROFLASH_DEBUG_ERR
+	printk("ezx_parts_parser:  roflash_partitions is %d\n", roflash_partitions);
+#endif
+	
+	up(&roflash_table_mutex);
+	
+	return ret;
+}
+			
+int ezx_partition_init(void)
+{
+	int ret = 0;
+
+	
+#ifdef ROFLASH_DEBUG_ERR
+	printk(KERN_ERR "ezx_partition_init: roflash_table_pptr = %d\n",(unsigned long)(act_roflash_table));
+#endif
+	roflash_table_pptr = (roflash_area **)(act_roflash_table);
+
+	if ( ret = ezx_parts_parser() )
+	{
+		printk(KERN_NOTICE "invoke ezx_parts_parser, return %d\n", ret);
+		return -EIO;
+	}
+
+#ifdef ROFLASH_DEBUG_ERR
+	printk("ezx_partition_init:  ret of ezx_parts_parser is %d\n", ret);
+#endif
+
+	if ( ret = roflash_init() )
+	{
+		printk(KERN_NOTICE "invoke roflash_init, return %d\n", ret);
+		return -EIO;
+	}
+	return 0 ;
+}
+
+
+
+
+
+
diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/drivers/block/roflash/roflash.c linux-2.6.16.5-exz/drivers/block/roflash/roflash.c
--- linux-2.6.16.5/drivers/block/roflash/roflash.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.16.5-exz/drivers/block/roflash/roflash.c	2006-04-16 18:49:29.000000000 +0200
@@ -0,0 +1,593 @@
+/*
+ * Linux Flash read-only block device driver For Cramfs file system, support simultaneous linear + block device mounting.  -- Susan Gu  Mar, 15 2002
+ * In order to resolve logo area in cachable flash mapping, add roflash_c_fops methods, that is stolen from mtdchar.c (dwmw2)
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/config.h>
+#include <linux/kmod.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/vmalloc.h>
+
+#include <asm/uaccess.h>
+#include <linux/mtd/map.h>
+#include <linux/ezx_roflash.h>
+
+#ifdef	CONFIG_PROC_FS
+#include <linux/proc_fs.h>	/* For /proc/roflash_info */
+#endif	/* CONFIG_PROC_FS */
+
+#define MAJOR_NR	ROFLASH_MAJOR
+#define DEVICE_NAME "roflash"
+#define DEVICE_REQUEST roflash_request
+#define DEVICE_NR(device) (MINOR(device))
+#define DEVICE_ON(device)
+#define DEVICE_OFF(device)
+#define DEVICE_NO_RANDOM
+
+#define MAJOR_NR_C 101
+#define DEVICE_NAME_C "roflash_c"
+#include <linux/blkdev.h>
+
+
+/* K3 flash lowlevel */
+#define FLASH_WORD_ALIGN_MASK 0xFFFFFFFE
+#define WIDTH_ADJUST	0x0001L		/* I.E. Converts 0x90 to 0x90 */
+#define FlashCommandRead        (unsigned short)(0xFF * WIDTH_ADJUST)
+#define FlashCommandStatus       (unsigned short)(0x70 * WIDTH_ADJUST)
+#define FlashStatusReady          (unsigned short)(0x80 * WIDTH_ADJUST)
+
+/* Variables used to track operational state of ROFLASH */
+#define ROFLASH_STATUS_READY			0
+#define ROFLASH_STATUS_NOT_READY    -1
+#define ROFLASH_BLOCK_SIZE (4096)
+static unsigned long flash_blocksizes[MAX_ROFLASH];
+static unsigned long flash_sizes[MAX_ROFLASH];
+
+#ifdef	CONFIG_PROC_FS
+static struct proc_dir_entry *roflash_proc_entry;
+static int roflash_read_procmem(char *, char **, off_t, int, int *, void *);
+#endif	/* CONFIG_PROC_FS */
+
+
+extern unsigned short roflash_partitions;
+extern struct map_info bulverde_map;
+extern unsigned long bulverde_map_cacheable;
+
+static DEFINE_SPINLOCK(roflash_lock);
+static struct request_queue *xd_queue;
+
+#define __KERNEL_SYSCALLS__
+#include <linux/unistd.h>
+#include <asm/unaligned.h>
+
+
+void fmemoryCopy (void * dest, void * src, unsigned long bytes)
+{
+	unsigned char *new_dest;
+	unsigned char *new_src;
+	new_dest = (unsigned char *)dest;
+	new_src = (unsigned char *)src;
+	/* while bytes to modify is not complete */
+	while (bytes-- != 0)
+	{
+		/* update destination byte to equal src byte */
+		*new_dest = *new_src;
+		new_dest++;
+		new_src++;
+	}
+}
+void memorySet (void * buff, unsigned long bytes, unsigned char value)
+{
+	unsigned char * new_buff;
+	new_buff = (unsigned char *)buff;
+	/* while not at end of modification */
+	while (bytes-- != 0)
+	{
+		/* set contents of buffer to value specified */
+		*new_buff = value;
+
+		/* increment to next byte */
+		new_buff++;
+	}
+}
+
+#if (0)
+unsigned short IntelSCSRead(unsigned long CardAddress, unsigned long Length, unsigned char * Buffer)
+{
+	unsigned long volatile pointer;
+	unsigned short * volatile pointer0ed;
+
+#ifdef VFM_DEBUG2
+	if ( roflash_status == ROFLASH_STATUS_READY )
+	{
+		printk("IntelSCSRead:  PositionPtr(pointer, CardAddress);\n");
+		printk("IntelSCSRead: pointer=%d, CardAddress=%d\n", (DWORD)pointer, (DWORD)CardAddress);
+	}
+#endif
+	pointer = (unsigned long)(DALHART_K3_BASE_ADDR + CardAddress);
+
+	pointer0ed = (unsigned short *)((unsigned long)pointer & FLASH_WORD_ALIGN_MASK);
+#ifdef CONFIG_K3_DEBUG
+	printk("IntelSCSRead(): Reading %d bytes at 0x%lx\n",Length, pointer);
+#endif
+
+	*pointer0ed = FlashCommandRead;  /* Ensure it is in read mode */
+
+	/* This is assumimg that farmemory copy performs at a byte at a time */
+	fmemoryCopy(Buffer, pointer, Length);
+
+	return(0);
+}
+#endif
+
+void roflash_request(request_queue_t *q)
+{
+    unsigned short minor;
+    unsigned long offset, len, retlen;
+	unsigned short err = 0;
+	unsigned char *tmpBufPtr;
+	unsigned short nrSectors;
+	struct request *req;
+	
+#ifdef ROFLASH_DEBUG_ERR
+	    printk(KERN_ERR "Roflash_request(): Entered\n");
+#endif
+
+	while ((req = elv_next_request(q)) != NULL) {
+		unsigned block = req->sector;
+		unsigned count = req->nr_sectors;
+		struct gendisk *disk = req->rq_disk;
+		int rw = rq_data_dir(req);
+
+		if (!(req->flags & REQ_CMD)) {
+			end_request(req, 0);
+			continue;
+		}
+
+		if (rw != READ) {
+			printk(KERN_ERR "roflash_request(): WARNING! Unknown Request\n");
+			end_request(req, 0);
+		}
+
+		/* Verify minor number is in range */
+		minor = MINOR(req->rq_dev);
+		if (minor >= roflash_partitions) 
+		{
+#ifdef ROFLASH_DEBUG_ERR
+		    printk(KERN_ERR "roflash_request(): ERROR! Out of partition range (minor = %d)\n", minor );
+#endif
+			end_request(req, 0);
+		    continue;
+		}
+
+		/* Check if writting-request is demanded */
+		if ( req->cmd == WRITE )
+		{
+			printk(KERN_ERR "roflash_request: write-accessing is not allowed!\n");
+			end_request(req, 0);
+			break;
+		}
+
+		/* Verify sector is in range */
+		offset = req->sector << 9;	// 512 bytes per sector
+		len = req->nr_sectors << 9;	// 512 bytes per sector
+		if ((offset + len) > (flash_sizes[minor] << BLOCK_SIZE_BITS)) 
+		{
+#ifdef ROFLASH_DEBUG_ERR
+		    printk(KERN_ERR "roflash_request(): ERROR! Access beyond end of partition\n" );
+#endif
+		    end_request(req, 0);
+		    continue;
+		}
+
+#ifdef ROFLASH_DEBUG_ERR
+		printk(KERN_ERR "roflash_request(): minor=%d, %d sectors at sector %ld\n", minor, req->nr_sectors, req->sector);
+#endif
+
+		/* Prepare to move data to/from the Linux buffer */	
+		nrSectors = req->nr_sectors;
+		tmpBufPtr = req->buffer;
+//		blockTempBufPtr = roflashTempBuffer; -- this may cause race-condition in multiple cramfs
+
+		roflash_area *this_area = NULL;
+#ifdef ROFLASH_DEBUG_ERR
+	    	printk(KERN_ERR "roflash_request: READ\n");
+#endif
+//		memorySet(roflashTempBuffer, len, 0x00); -- don't use the internal buffer, may exist race-conditions.
+				
+		this_area = (roflash_area *)(roflash_table_pptr[minor]);
+		err = (*this_area->roflash_read)((void *)(this_area->priv_map),(offset + this_area->offset), len, &retlen, tmpBufPtr);
+		if (err == 0) {
+#ifdef ROFLASH_DEBUG_ERR
+			printk(KERN_ERR " < %x %x %x %x ...>\n",req->buffer[0],req->buffer[1],req->buffer[2],req->buffer[3]);
+#endif
+			end_request(req, 1);
+		} else {
+#ifdef ROFLASH_DEBUG_ERR
+			printk(KERN_ERR "roflash_request(): ERROR READ %d sectors at sector %d\n", req->nr_sectors, req->sector);
+#endif
+			end_request(req, 0);
+		}
+	}
+} 
+
+static int roflash_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+// What is the requirements? -- todo list
+    return 0;
+}
+
+
+static int roflash_open(struct inode * inode, struct file * filp)
+{
+#ifdef ROFLASH_DEBUG_ERR
+    printk(KERN_ERR "roflash_open() called, minor = %d\n", DEVICE_NR(inode->i_rdev));
+#endif
+    if (DEVICE_NR(inode->i_rdev) >= roflash_partitions)
+	{
+#ifdef ROFLASH_DEBUG_ERR
+    printk(KERN_ERR "vfm_open() Failed!\n");
+#endif
+		return -ENXIO;
+	}
+    return 0;
+}
+
+static int roflash_release(struct inode * inode, struct file * filp)
+{
+#ifdef ROFLASH_DEBUG_ERR
+    printk(KERN_ERR "roflash_release() called\n");
+#endif
+    return 0;
+}
+
+
+/*Susan 2.4.6 */
+static struct block_device_operations roflash_fops = {
+    open:	roflash_open,
+    release:	roflash_release,
+    ioctl:	roflash_ioctl,
+};
+
+static loff_t roflash_c_lseek (struct file *file, loff_t offset, int orig)
+{
+	roflash_area *dev_def = (roflash_area *)(file->private_data);
+	
+	switch (orig) {
+	case 0:
+		/* SEEK_SET */
+		file->f_pos = offset;
+		break;
+	case 1:
+		/* SEEK_CUR */
+		file->f_pos += offset;
+		break;
+	case 2:
+		/* SEEK_END */
+		file->f_pos = (unsigned long)(dev_def->size + offset);
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (file->f_pos < 0)
+		file->f_pos = 0;
+	else if (file->f_pos >= dev_def->size)
+		file->f_pos = dev_def->size - 1;
+
+	return file->f_pos;
+}
+
+static int roflash_c_open(struct inode *inode, struct file *file)
+{
+	int minor = MINOR(inode->i_rdev);
+	roflash_area *dev_def;
+
+	if (minor >= MAX_ROFLASH)
+		return -EACCES;
+
+	dev_def = (roflash_area *)(roflash_table_pptr[minor]);
+
+	/* Sanity check */
+	if (dev_def->l_x_b != ROFLASH_CHAR)
+		return -EACCES;
+
+	/* You can't open the RO devices RW */
+	if (file->f_mode & 2)
+		return -EACCES;
+	
+	file->private_data = dev_def;
+		
+	return 0;
+} /* mtd_open */
+
+static int roflash_c_close(struct inode *inode, struct file *file)
+{
+	return 0;
+} /* mtd_close */
+
+/* FIXME: This _really_ needs to die. In 2.5, we should lock the
+   userspace buffer down and use it directly with readv/writev.
+*/
+#define MAX_KMALLOC_SIZE 0x20000
+
+static int roflash_c_read(struct file *file, char *buf, size_t count,loff_t *ppos)
+{
+	roflash_area *dev_def = (roflash_area *)file->private_data;
+	size_t retlen=0;
+	size_t total_retlen=0;
+	int ret=0;
+	int len;
+	char *kbuf;
+	unsigned long virt_dev_start = 0;
+	
+	if (*ppos + count > dev_def->size)
+		count = dev_def->size - *ppos;
+
+	if (!count)
+		return 0;
+	
+	/* FIXME: Use kiovec in 2.5 to lock down the user's buffers
+	   and pass them directly to the MTD functions */
+	while (count) 
+	{
+		if (count > MAX_KMALLOC_SIZE) 
+			len = MAX_KMALLOC_SIZE;
+		else
+			len = count;
+
+		kbuf=kmalloc(len,GFP_KERNEL);
+		if (!kbuf)
+			return -ENOMEM;
+		
+		//ret = (dev_def->roflash_read)( (void *)(dev_def->priv_map),(*ppos + dev_def->offset), len, &retlen, kbuf);
+		virt_dev_start = (unsigned long)(dev_def->priv_map) + dev_def->offset;
+		memcpy(kbuf,virt_dev_start + *ppos,len);
+
+		*ppos += len;
+		if (copy_to_user(buf, kbuf, len)) 
+		{
+			kfree(kbuf);
+			return -EFAULT;
+		}
+		else
+			total_retlen += len;
+
+		count -= len;
+		buf += len;
+
+		
+		kfree(kbuf);
+	}
+	
+	return total_retlen;
+} /* mtd_read */
+
+
+static struct file_operations roflash_c_fops = {
+	owner:		THIS_MODULE,
+	llseek:		roflash_c_lseek,     	/* lseek */
+	read:		roflash_c_read,	/* read */
+	open:		roflash_c_open,	/* open */
+	release:	roflash_c_close,	/* release */
+};
+
+roflash_area *roflash_get_dev(unsigned char minor)
+{
+	roflash_area *ret = NULL;
+	
+	if (minor < MAX_ROFLASH)
+		ret = (roflash_area *)(roflash_table_pptr[minor]);
+
+	return ret;
+}
+	
+int __init roflash_init(void)
+{
+        int i, size = 0;
+
+#ifdef ROFLASH_DEBUG_ERR
+	printk(KERN_ERR "roflash_init(): Enter into this API.\n");
+#endif
+	
+/* We should do initialization for flash chips, however, we don't need to do it
+ * twice after __init_lubbock has initialized K3 flash device */
+	
+#ifdef ROFLASH_DEBUG_ERR
+	printk(KERN_ERR "roflash_init: Registering device major %d [%s]\n",ROFLASH_MAJOR,DEVICE_NAME);
+#endif
+
+	if (register_blkdev(ROFLASH_MAJOR, DEVICE_NAME)) {
+#ifdef ROFLASH_DEBUG_ERR
+		printk(KERN_ERR "roflash_init(): Could not get major %d", ROFLASH_MAJOR);
+#endif
+		return -EIO;
+	}
+#ifdef ROFLASH_DEBUG_ERR
+	printk(KERN_ERR "roflash_init(): register_blkdev success\n");
+#endif
+
+	roflash_queue = blk_init_queue(&roflash_request, &roflash_lock);
+	if (!roflash_queue)
+		return -ENOMEM;
+
+	struct gendisk *disk = alloc_disk(64);
+	if (!disk)
+		return -ENOMEM;
+
+	disk->major = ROFLASH_MAJOR;
+	disk->first_minor = 0;
+	sprintf(disk->disk_name, "roflash0");
+	sprintf(disk->devfs_name, "roflash/target0");
+	disk->fops = &roflash_fops;
+	disk->queue = roflash_queue;
+	// set_capacity(disk, );
+	
+	add_disk(disk);
+
+
+	/* We know this is invoked only once during kernel booting up, so there
+	 * is not race-conditions */
+	for (i = 0; i < roflash_partitions; i++) {
+		unsigned short lxb_flag = ((roflash_area *)(roflash_table_pptr[i]))->l_x_b;
+
+		switch (lxb_flag) {
+		case ROFLASH_LINEAR:
+		case ROFLASH_LINEAR_XIP:
+			flash_blocksizes[i] = ROFLASH_BLOCK_SIZE;
+			size = ((roflash_area *)(roflash_table_pptr[i]))->size;
+			flash_sizes[i] = size >> BLOCK_SIZE_BITS ;
+  			// The virtual address of the cacheable mapping //
+			((roflash_area *)(roflash_table_pptr[i]))->priv_map = 
+							(void *)(bulverde_map_cacheable);
+#ifdef ROFLASH_DEBUG_ERR
+			printk(KERN_ERR "roflash_init(): not-char "
+				"roflash_table_pptr[%d]->size = %d\n",i,size);
+#endif
+			break;
+		case ROFLASH_BLOCK:
+			if (bulverde_map.size == 0) {
+				unregister_blkdev(ROFLASH_MAJOR, DEVICE_NAME);
+				return -EACCES;
+			}
+
+			flash_blocksizes[i] = ROFLASH_BLOCK_SIZE;
+			size = ((roflash_area *)(roflash_table_pptr[i]))->size;
+			flash_sizes[i] = size >> BLOCK_SIZE_BITS ;
+			//The pointer to struct map_info of the noncacheable mapping //
+			((roflash_area *)(roflash_table_pptr[i]))->priv_map = 
+								(void *)(&bulverde_map);  
+#ifdef ROFLASH_DEBUG_ERR
+			printk(KERN_ERR "roflash_init(): not-char roflash_table_pptr[%d]->size = %d\n",i,size);
+#endif
+			break;
+		case ROFLASH_CHAR:
+			if (register_chrdev(MAJOR_NR_C, DEVICE_NAME_C, &roflash_c_fops)) {
+				printk(KERN_NOTICE "Can't allocate major number %d for "
+				       "Memory Technology Devices.\n", MAJOR_NR_C);
+
+				unregister_blkdev(ROFLASH_MAJOR, DEVICE_NAME);
+				return -EAGAIN;
+			}
+			//The virtual address of the cacheable mapping //
+			((roflash_area *)(roflash_table_pptr[i]))->priv_map = 
+							(void *)(bulverde_map_cacheable);  
+#ifdef ROFLASH_DEBUG_ERR
+			printk(KERN_ERR "roflash_init(): char roflash_table_pptr[%d]->size "
+				"= %d\n",i,size);
+#endif
+			break;
+		}
+	}
+		
+	blksize_size[ROFLASH_MAJOR] = flash_blocksizes;
+	blk_size[ROFLASH_MAJOR] = flash_sizes;
+#ifdef ROFLASH_DEBUG_ERR
+	printk(KERN_ERR "roflash_init(): fill in blksize_size[] and blk_size[] "
+		"success\n");
+#endif
+	//blk_init_queue(BLK_DEFAULT_QUEUE(ROFLASH_MAJOR),&roflash_request);
+	roflash_queue = blk_init_queue(&roflash_request, &roflash_lock);
+	if (!roflash_queue)
+		return -ENOMEM;
+
+#ifdef ROFLASH_DEBUG_ERR
+	printk(KERN_ERR "roflash_init(): ROFLASH Block device: blksize_size = %d"
+		", blk_size = %d\n",flash_blocksizes[0],flash_sizes[0]);
+#endif
+
+#ifdef	CONFIG_PROC_FS
+	/* register procfs device */
+	if (roflash_proc_entry = create_proc_entry("roflash_info", 0, 0)) {
+			roflash_proc_entry->read_proc = roflash_read_procmem;
+	}
+
+#endif	/* CONFIG_PROC_FS */
+	
+	for ( i = 0; i < roflash_partitions; i ++ ) {
+		printk(KERN_NOTICE "ROFLASH Driver initialized and ready for use."
+		       "Size: %d Offset: %d\n", 
+		       ((roflash_area*)(roflash_table_pptr[i]))->size, 
+		       ((roflash_area*)(roflash_table_pptr[i]))->offset);
+	}
+
+	return (0);	
+}
+
+
+#ifdef CONFIG_PROC_FS
+static int roflash_read_procmem(char *buf, char **start, off_t offset, int len,
+				int *eof, void *data)
+{
+	#define LIMIT (PAGE_SIZE-80)	/* don't print anymore after this size */
+
+	int i;
+	
+	len=0;
+	
+#if (0)
+	switch (roflash_status)
+	{
+		case ROFLASH_STATUS_NOT_READY:
+			strcpy(roflash_status_str,"Not-ready");
+			break;
+		case ROFLASH_STATUS_READY:
+			strcpy(roflash_status_str,"Ready");
+			break;
+		default:
+			strcpy(roflash_status_str,"Unknown!");
+			break;
+	}
+#endif
+
+	len += sprintf(buf+len, "ROFLASH Driver status: %s\n\n","Ready");
+	for ( i = 0; i < roflash_partitions; i ++ )
+	{
+		len += sprintf(buf+len, "ROFLASH area name is %s\n",((roflash_area*)(roflash_table_pptr[i]))->name);
+		len += sprintf(buf+len, "ROFLASH area size = %d bytes\n",((roflash_area*)(roflash_table_pptr[i]))->size);
+		len += sprintf(buf+len, "ROFLASH area offset = %ld bytes\n",((roflash_area*)(roflash_table_pptr[i]))->offset);
+		len += sprintf(buf+len, "ROFLASH area l_x_b(%x)\n",((roflash_area*)(roflash_table_pptr[i]))->l_x_b);
+	}
+	return len;
+}
+#endif	/* CONFIG_PROC_FS */
+
+#ifdef MODULE
+static void __exit roflash_cleanup(void)  //Susan//
+{
+    int i;
+    int err_info = 0;
+
+    /* For read-only flash device, we don't need to invoke fsync_dev */
+ 
+    unregister_blkdev(ROFLASH_MAJOR, DEVICE_NAME);
+	blk_cleanup_queue(BLK_DEFAULT_QUEUE(ROFLASH_MAJOR));
+    blk_size[ROFLASH_MAJOR] = NULL;
+    blksize_size[ROFLASH_MAJOR] = NULL;
+
+    /* For roflash char device  -- sometimes, we don't have char roflash devices */
+	for (i = 0; i < roflash_partitions; i++) 
+	{
+		unsigned short lxb_flag = ((roflash_area *)(roflash_table_pptr[i]))->l_x_b;
+
+		if (lxb_flag == ROFLASH_CHAR)
+		{
+			unregister_chrdev(MAJOR_NR_C, DEVICE_NAME_C);
+			break;
+		}
+	}
+
+    remove_proc_entry("roflash_info",NULL);
+
+    printk(KERN_ERR "remove roflash_info\n");
+
+}
+
+module_init(roflash_init);
+module_exit(roflash_cleanup);
+
+#endif
diff -Nru --exclude-from=/sunbeam/home/laforge/scripts/dontdiff linux-2.6.16.5/include/linux/ezx_roflash.h linux-2.6.16.5-exz/include/linux/ezx_roflash.h
--- linux-2.6.16.5/include/linux/ezx_roflash.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.16.5-exz/include/linux/ezx_roflash.h	2006-04-16 18:49:29.000000000 +0200
@@ -0,0 +1,41 @@
+/*
+ *  linux/include/linux/ezx_roflash.h 
+ *
+ *  Created by Susan Gu    0ct, 22 2002
+ *  
+ *  For multiple cramfs partitions in ezx project
+ *  At repsent, there are three cramfs partitions in ezx project, they are: 
+ *  1.  root file system
+ *  2.  Language package
+ *  3.  setup package 
+*/
+
+#ifndef EZX_ROFLASH_FS_H
+#define EZX_ROFLASH_FS_H
+
+#include <asm/ioctl.h>
+
+#define ROFLASH_MAJOR  62
+
+#define ROFLASH_LINEAR  0x0010
+#define ROFLASH_LINEAR_XIP     0x0011
+#define ROFLASH_BLOCK   0x1000
+#define ROFLASH_CHAR    0x1100
+#define MAX_ROFLASH  4
+
+typedef struct
+{
+	char name[16];  /* This length should be enough for DC stuff */
+	unsigned long offset;
+	unsigned long size;
+	int (*roflash_read)(void *, unsigned long, size_t, size_t *, u_char *);
+	/* Added by Susan for multiple Linear or block cramfs */
+	void *priv_map;
+	unsigned long phys_addr;
+	unsigned short l_x_b;
+}roflash_area;
+
+extern roflash_area *roflash_get_dev(unsigned char minor);
+extern roflash_area **roflash_table_pptr;
+
+#endif