yaffs: Change __uxx types to uxx

__u32 -> u32 and such.

Signed-off-by: Charles Manning <cdhmanning@gmail.com>

51 files changed, 472 insertions, 472 deletions

diff --git a/devextras.h b/devextras.h
index ce30c82..baadeff 100644
--- a/devextras.h
+++ b/devextras.h
@@ -29,9 +29,9 @@
 #if !(defined __KERNEL__)
 
 /* Definition of types */
-typedef unsigned char __u8;
-typedef unsigned short __u16;
-typedef unsigned __u32;
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned u32;
 
 #endif
 
diff --git a/direct/basic-test/dtest.c b/direct/basic-test/dtest.c
index 691ffe2..a0106a9 100644
--- a/direct/basic-test/dtest.c
+++ b/direct/basic-test/dtest.c
@@ -2516,7 +2516,7 @@ static void print_xattrib_val(const char *path, const char *name)
 
 	n = yaffs_getxattr(path,name,buffer,sizeof(buffer));
 	if(n >= 0){
-		__u8 *b = (__u8 *)buffer;
+		u8 *b = (u8 *)buffer;
 
 		printf("%d bytes:",n);
 		if(n > 10)
diff --git a/direct/basic-test/yaffs_fileem.c b/direct/basic-test/yaffs_fileem.c
index 419b16f..330e0dc 100644
--- a/direct/basic-test/yaffs_fileem.c
+++ b/direct/basic-test/yaffs_fileem.c
@@ -43,7 +43,7 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_fileem.c,v 1.7 2010-02-18 01:1
 
 typedef struct 
 {
-	__u8 data[528]; // Data + spare
+	u8 data[528]; // Data + spare
 } yflash_Page;
 
 typedef struct
@@ -118,7 +118,7 @@ static int  CheckInit(yaffs_dev_t *dev)
 	return 1;
 }
 
-int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare)
+int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare)
 {
 	int written;
 
@@ -148,7 +148,7 @@ int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, co
 }
 
 
-int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare)
+int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
 {
 	int nread;
 
diff --git a/direct/basic-test/yaffs_fileem2k.c b/direct/basic-test/yaffs_fileem2k.c
index 367003e..44a1e87 100644
--- a/direct/basic-test/yaffs_fileem2k.c
+++ b/direct/basic-test/yaffs_fileem2k.c
@@ -40,7 +40,7 @@ const char *yaffs_flashif2_c_version = "$Id: yaffs_fileem2k.c,v 1.24 2010-02-18
 
 typedef struct 
 {
-	__u8 data[PAGE_SIZE]; // Data + spare
+	u8 data[PAGE_SIZE]; // Data + spare
 } yflash_Page;
 
 typedef struct
@@ -93,7 +93,7 @@ static void yflash2_MaybePowerFail(unsigned int nand_chunk, int failPoint)
 
 
 
-static __u8 localBuffer[PAGE_SIZE];
+static u8 localBuffer[PAGE_SIZE];
 
 static char *NToName(char *buf,int n)
 {
@@ -171,7 +171,7 @@ int yflash2_GetNumberOfBlocks(void)
 	return filedisk.nBlocks;
 }
 
-int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags)
+int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags)
 {
 	int written;
 	int pos;
@@ -262,7 +262,7 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8
 			{
 				yaffs_packed_tags2 pt;
 				yaffs_pack_tags2(&pt,tags, !dev->param.no_tags_ecc);
-				__u8 * ptab = (__u8 *)&pt;
+				u8 * ptab = (u8 *)&pt;
 
 				nRead = read(h,localBuffer,sizeof(pt));
 				for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){
@@ -340,7 +340,7 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8
 			{
 				yaffs_packed_tags2 pt;
 				yaffs_pack_tags2(&pt,tags,!dev->param.no_tags_ecc);
-				__u8 * ptab = (__u8 *)&pt;
+				u8 * ptab = (u8 *)&pt;
 
 				nRead = read(h,localBuffer,sizeof(pt));
 				for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){
@@ -371,7 +371,7 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8
 
 }
 
-int yaffs_check_all_ff(const __u8 *ptr, int n)
+int yaffs_check_all_ff(const u8 *ptr, int n)
 {
 	while(n)
 	{
@@ -388,7 +388,7 @@ static int fail320 = 1;
 
 static int failRead10 = 2;
 
-int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags)
+int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags)
 {
 	int nread;
 	int pos;
@@ -461,7 +461,7 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *dat
 				nread= read(h,tags,sizeof(yaffs_ext_tags));
 				if(nread != sizeof(yaffs_ext_tags))
 					 retval =  YAFFS_FAIL;
-				if(yaffs_check_all_ff((__u8 *)tags,sizeof(yaffs_ext_tags)))
+				if(yaffs_check_all_ff((u8 *)tags,sizeof(yaffs_ext_tags)))
 				{
 					yaffs_init_tags(tags);
 				}
@@ -550,7 +550,7 @@ int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
 	else
 	{
 	
-		__u8 pg[PAGE_SIZE];
+		u8 pg[PAGE_SIZE];
 		int syz = PAGE_SIZE;
 		int pos;
 		
@@ -580,7 +580,7 @@ int yflash2_InitialiseNAND(yaffs_dev_t *dev)
 
 
 
-int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number)
+int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number)
 {
 	yaffs_ext_tags tags;
 	int chunkNo;
diff --git a/direct/basic-test/yaffs_norif1.c b/direct/basic-test/yaffs_norif1.c
index 5657c00..cde36a9 100644
--- a/direct/basic-test/yaffs_norif1.c
+++ b/direct/basic-test/yaffs_norif1.c
@@ -88,58 +88,58 @@ const char *yaffs_norif1_c_version = "$Id: yaffs_norif1.c,v 1.6 2010-02-18 01:18
 #define DEVICE_BASE     (32 * 1024 * 1024)
 #endif
 
-__u32 *Block2Addr(yaffs_dev_t *dev, int blockNumber)
+u32 *Block2Addr(yaffs_dev_t *dev, int blockNumber)
 {
-	__u32 addr;
+	u32 addr;
 	dev=dev;
 	
-	addr = (__u32) DEVICE_BASE;
+	addr = (u32) DEVICE_BASE;
 	addr += blockNumber * BLOCK_SIZE_IN_BYTES;
 	
-	return (__u32 *) addr;
+	return (u32 *) addr;
 }
 
-__u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber)
+u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber)
 {
-	__u32 addr;
+	u32 addr;
 
-	addr = (__u32) Block2Addr(dev,blockNumber);
+	addr = (u32) Block2Addr(dev,blockNumber);
 	addr += FORMAT_OFFSET;
 	
-	return (__u32 *)addr;
+	return (u32 *)addr;
 }
-__u32 *Chunk2DataAddr(yaffs_dev_t *dev,int chunk_id)
+u32 *Chunk2DataAddr(yaffs_dev_t *dev,int chunk_id)
 {
 	unsigned block;
 	unsigned chunkInBlock;
-	__u32  addr;
+	u32  addr;
 	
 	block = chunk_id/dev->param.chunks_per_block;
 	chunkInBlock = chunk_id % dev->param.chunks_per_block;
 	
-	addr = (__u32) Block2Addr(dev,block);
+	addr = (u32) Block2Addr(dev,block);
 	addr += chunkInBlock * DATA_BYTES_PER_CHUNK;
 	
-	return (__u32 *)addr;
+	return (u32 *)addr;
 }
 
-__u32 *Chunk2SpareAddr(yaffs_dev_t *dev,int chunk_id)
+u32 *Chunk2SpareAddr(yaffs_dev_t *dev,int chunk_id)
 {
 	unsigned block;
 	unsigned chunkInBlock;
-	__u32 addr;
+	u32 addr;
 	
 	block = chunk_id/dev->param.chunks_per_block;
 	chunkInBlock = chunk_id % dev->param.chunks_per_block;
 	
-	addr = (__u32) Block2Addr(dev,block);
+	addr = (u32) Block2Addr(dev,block);
 	addr += SPARE_AREA_OFFSET;
 	addr += chunkInBlock * (SPARE_BYTES_PER_CHUNK + M18_SKIP);
-	return (__u32 *)addr;
+	return (u32 *)addr;
 }
 
 
-void ynorif1_AndBytes(__u8*target, const __u8   *src, int nbytes)
+void ynorif1_AndBytes(u8*target, const u8   *src, int nbytes)
 {
         while(nbytes > 0){
                 *target &= *src;
@@ -149,10 +149,10 @@ void ynorif1_AndBytes(__u8*target, const __u8   *src, int nbytes)
         }
 }
 
-int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare)
+int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare)
 {
-        __u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
-        __u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
+        u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
+        u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
         
         yaffs_spare tmpSpare;
         
@@ -172,30 +172,30 @@ int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, c
                 /* Write a pre-marker */
                 memset(&tmpSpare,0xff,sizeof(tmpSpare));
                 tmpSpare.page_status = YNOR_PREMARKER;
-                ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_spare)/4);
+                ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(yaffs_spare)/4);
 
                 /* Write the data */            
-                ynorif1_FlashWrite32(dataAddr,(__u32 *)data,dev->param.total_bytes_per_chunk / 4);
+                ynorif1_FlashWrite32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4);
                 
                 
                 memcpy(&tmpSpare,spare,sizeof(yaffs_spare));
                 
                 /* Write the real tags, but override the premarker*/
                 tmpSpare.page_status = YNOR_PREMARKER;
-                ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_spare)/4);
+                ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(yaffs_spare)/4);
                 
                 /* Write a post-marker */
                 tmpSpare.page_status = YNOR_POSTMARKER;
-                ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(tmpSpare)/4);  
+                ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(tmpSpare)/4);  
 
         } else if(spare){
                 /* This has to be a read-modify-write operation to handle NOR-ness */
 
-                ynorif1_FlashRead32(spareAddr,(__u32 *)&tmpSpare,16/ 4);
+                ynorif1_FlashRead32(spareAddr,(u32 *)&tmpSpare,16/ 4);
                 
-                ynorif1_AndBytes((__u8 *)&tmpSpare,(__u8 *)spare,sizeof(yaffs_spare));
+                ynorif1_AndBytes((u8 *)&tmpSpare,(u8 *)spare,sizeof(yaffs_spare));
                 
-                ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,16/ 4);
+                ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,16/ 4);
         }
         else {
                 YBUG();
@@ -206,20 +206,20 @@ int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, c
 
 }
 
-int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare)
+int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
 {
 
-	__u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
-	__u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
+	u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
+	u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
 	
 	if(data)
 	{
-		ynorif1_FlashRead32(dataAddr,(__u32 *)data,dev->param.total_bytes_per_chunk / 4);
+		ynorif1_FlashRead32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4);
 	}
 	
         if(spare)
         {
-                ynorif1_FlashRead32(spareAddr,(__u32 *)spare,16/ 4);
+                ynorif1_FlashRead32(spareAddr,(u32 *)spare,16/ 4);
                 
                 /* If the page status is YNOR_POSTMARKER then it was written properly
                  * so change that to 0xFF so that the rest of yaffs is happy.
@@ -238,9 +238,9 @@ int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs
 
 static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber)
 {
-	__u32 *blockAddr = Block2Addr(dev,blockNumber);
-	__u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
-	__u32 formatValue = FORMAT_VALUE;
+	u32 *blockAddr = Block2Addr(dev,blockNumber);
+	u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
+	u32 formatValue = FORMAT_VALUE;
 	
 	ynorif1_FlashEraseBlock(blockAddr);
 	ynorif1_FlashWrite32(formatAddr,&formatValue,1);
@@ -250,8 +250,8 @@ static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber)
 
 static int ynorif1_UnformatBlock(yaffs_dev_t *dev, int blockNumber)
 {
-	__u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
-	__u32 formatValue = 0;
+	u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
+	u32 formatValue = 0;
 	
 	ynorif1_FlashWrite32(formatAddr,&formatValue,1);
 	
@@ -260,8 +260,8 @@ static int ynorif1_UnformatBlock(yaffs_dev_t *dev, int blockNumber)
 
 static int ynorif1_IsBlockFormatted(yaffs_dev_t *dev, int blockNumber)
 {
-	__u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
-	__u32 formatValue;
+	u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
+	u32 formatValue;
 	
 	
 	ynorif1_FlashRead32(formatAddr,&formatValue,1);
diff --git a/direct/basic-test/yaffs_norif1.h b/direct/basic-test/yaffs_norif1.h
index ac78423..780b2d3 100644
--- a/direct/basic-test/yaffs_norif1.h
+++ b/direct/basic-test/yaffs_norif1.h
@@ -19,8 +19,8 @@
 
 #include "yaffs_guts.h"
 
-int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare);
-int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare);
+int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
+int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
 int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
 int ynorif1_InitialiseNAND(yaffs_dev_t *dev);
 int ynorif1_Deinitialise_flash_fn(yaffs_dev_t *dev);
diff --git a/direct/basic-test/yaffs_ramdisk.c b/direct/basic-test/yaffs_ramdisk.c
index 9834bb2..a65dcc8 100644
--- a/direct/basic-test/yaffs_ramdisk.c
+++ b/direct/basic-test/yaffs_ramdisk.c
@@ -42,7 +42,7 @@ const char *yaffs_ramdisk_c_version = "$Id: yaffs_ramdisk.c,v 1.6 2010-01-11 04:
 
 typedef struct 
 {
-	__u8 data[528]; // Data + spare
+	u8 data[528]; // Data + spare
 } yramdisk_page;
 
 typedef struct
@@ -119,7 +119,7 @@ static int  CheckInit(yaffs_dev_t *dev)
 	return 1;
 }
 
-int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags)
+int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags)
 {
 	int blk;
 	int pg;
@@ -150,7 +150,7 @@ int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const ya
 }
 
 
-int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags)
+int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags)
 {
 	int blk;
 	int pg;
diff --git a/direct/basic-test/yaffs_ramdisk.h b/direct/basic-test/yaffs_ramdisk.h
index c250bcc..88134f6 100644
--- a/direct/basic-test/yaffs_ramdisk.h
+++ b/direct/basic-test/yaffs_ramdisk.h
@@ -23,8 +23,8 @@
 
 #include "yaffs_guts.h"
 int yramdisk_erase(yaffs_dev_t *dev, int blockNumber);
-int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags);
-int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags);
+int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
+int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
 int yramdisk_initialise(yaffs_dev_t *dev);
 int yramdisk_mark_block_bad(yaffs_dev_t *dev,int blockNumber);
 int yramdisk_query_block(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, int *seq_number);
diff --git a/direct/basic-test/yaffs_ramem2k.c b/direct/basic-test/yaffs_ramem2k.c
index 1a9765d..7028a82 100644
--- a/direct/basic-test/yaffs_ramem2k.c
+++ b/direct/basic-test/yaffs_ramem2k.c
@@ -54,7 +54,7 @@ const char *yaffs_ramem2k_c_version = "$Id: yaffs_ramem2k.c,v 1.8 2010-02-18 01:
 
 typedef struct 
 {
-	__u8 data[PAGE_TOTAL_SIZE]; // Data + spare
+	u8 data[PAGE_TOTAL_SIZE]; // Data + spare
 	int empty;      // is this empty?
 } nandemul_Page;
 
@@ -190,13 +190,13 @@ static int  CheckInit(void)
 	return 1;
 }
 
-int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags)
+int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags)
 {
 	int blk;
 	int pg;
 	int i;
 	
-	__u8 *x;
+	u8 *x;
 
 	
 	blk = nand_chunk/PAGES_PER_BLOCK;
@@ -233,12 +233,12 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __
 }
 
 
-int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags)
+int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags)
 {
 	int blk;
 	int pg;
 	
-	__u8 *x;
+	u8 *x;
 
 	
 	
@@ -316,7 +316,7 @@ int nandemul2k_InitialiseNAND(yaffs_dev_t *dev)
 int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
 {
 	
-	__u8 *x;
+	u8 *x;
 	
 	x = &ned.block[block_no]->page[0]->data[PAGE_DATA_SIZE];
 	
@@ -327,7 +327,7 @@ int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
 	
 }
 
-int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32  *seq_number)
+int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32  *seq_number)
 {
 	yaffs_ext_tags tags;
 	int chunkNo;
diff --git a/direct/basic-test/yaffscfg.c b/direct/basic-test/yaffscfg.c
index 590cb87..250a113 100644
--- a/direct/basic-test/yaffscfg.c
+++ b/direct/basic-test/yaffscfg.c
@@ -42,7 +42,7 @@ void yaffsfs_Unlock(void)
 {
 }
 
-__u32 yaffsfs_CurrentTime(void)
+u32 yaffsfs_CurrentTime(void)
 {
 	return 0;
 }
diff --git a/direct/basic-test/yaffscfg2k.c b/direct/basic-test/yaffscfg2k.c
index de8953e..b05952f 100644
--- a/direct/basic-test/yaffscfg2k.c
+++ b/direct/basic-test/yaffscfg2k.c
@@ -65,7 +65,7 @@ void yaffsfs_Unlock(void)
 {
 }
 
-__u32 yaffsfs_CurrentTime(void)
+u32 yaffsfs_CurrentTime(void)
 {
 	return 0;
 }
diff --git a/direct/basic-test/yaffsnewcfg.c b/direct/basic-test/yaffsnewcfg.c
index a3548ef..60dcf02 100644
--- a/direct/basic-test/yaffsnewcfg.c
+++ b/direct/basic-test/yaffsnewcfg.c
@@ -59,7 +59,7 @@ void yaffsfs_Unlock(void)
 {
 }
 
-__u32 yaffsfs_CurrentTime(void)
+u32 yaffsfs_CurrentTime(void)
 {
 	return 0;
 }
diff --git a/direct/basic-test/ynorsim.c b/direct/basic-test/ynorsim.c
index ab72d28..3965101 100644
--- a/direct/basic-test/ynorsim.c
+++ b/direct/basic-test/ynorsim.c
@@ -48,7 +48,7 @@
 #define YNORSIM_DEV_SIZE_U32	(8*1024 * 1024/4)
 #endif
 
-static __u32 word[YNORSIM_DEV_SIZE_U32];
+static u32 word[YNORSIM_DEV_SIZE_U32];
 
 extern int random_seed;
 extern int simulate_power_failure;
@@ -111,7 +111,7 @@ static void ynorsim_ready(void)
   ynorsim_restore_image();
 }
 
-void ynorsim_rd32(__u32 *addr,__u32 *buf, int nwords)
+void ynorsim_rd32(u32 *addr,u32 *buf, int nwords)
 { 
    while(nwords > 0){
      *buf = *addr;
@@ -121,10 +121,10 @@ void ynorsim_rd32(__u32 *addr,__u32 *buf, int nwords)
    }
 }
 
-void ynorsim_wr_one_word32(__u32 *addr,__u32 val)
+void ynorsim_wr_one_word32(u32 *addr,u32 val)
 {
-  __u32 tmp;
-  __u32 m;
+  u32 tmp;
+  u32 m;
   int i;
 
   tmp = *addr;
@@ -148,7 +148,7 @@ void ynorsim_wr_one_word32(__u32 *addr,__u32 val)
   ynorsim_maybe_power_fail();
 }
 
-void ynorsim_wr32(__u32 *addr, __u32 *buf, int nwords)
+void ynorsim_wr32(u32 *addr, u32 *buf, int nwords)
 {
   while(nwords >0){
     ynorsim_wr_one_word32(addr,*buf);
@@ -158,7 +158,7 @@ void ynorsim_wr32(__u32 *addr, __u32 *buf, int nwords)
   }
 }
 
-void ynorsim_erase(__u32 *addr)
+void ynorsim_erase(u32 *addr)
 {
   /* Todo... bit flipping */
   memset(addr,0xFF,YNORSIM_BLOCK_SIZE_U32 * 4);
@@ -175,7 +175,7 @@ void ynorsim_shutdown(void)
   initialised=0;
 }
 
-__u32 *ynorsim_get_base(void)
+u32 *ynorsim_get_base(void)
 {
   return word;
 }
diff --git a/direct/basic-test/ynorsim.h b/direct/basic-test/ynorsim.h
index e0e92b1..ca5bdf1 100644
--- a/direct/basic-test/ynorsim.h
+++ b/direct/basic-test/ynorsim.h
@@ -18,11 +18,11 @@
 
 #include "yaffs_guts.h"
 
-void ynorsim_rd32(__u32 *addr, __u32 *data, int nwords);
-void ynorsim_wr32(__u32 *addr, __u32 *data, int nwords);
-void ynorsim_erase(__u32 *addr);
+void ynorsim_rd32(u32 *addr, u32 *data, int nwords);
+void ynorsim_wr32(u32 *addr, u32 *data, int nwords);
+void ynorsim_erase(u32 *addr);
 void ynorsim_shutdown(void);
 void ynorsim_initialise(void);
-__u32 * ynorsim_get_base(void);
+u32 * ynorsim_get_base(void);
 
 #endif
diff --git a/direct/basic-test/yramsim.c b/direct/basic-test/yramsim.c
index 74d5f73..05437ff 100644
--- a/direct/basic-test/yramsim.c
+++ b/direct/basic-test/yramsim.c
@@ -190,14 +190,14 @@ static int yramsim_mark_block_bad(yaffs_dev_t *dev,unsigned blockId)
 }
 
 
-static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks)
+static SimData *yramsim_alloc_sim_data(u32 devId, u32 nBlocks)
 {
 	int ok = 1;
 
 	Block **blockList;
 	SimData *sim;
 	Block *b;
-	__u32 i;
+	u32 i;
 
 	if(devId >= N_RAM_SIM_DEVS)
 		return NULL;
@@ -252,8 +252,8 @@ static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks)
 
 
 struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name,
-				__u32 devId, __u32 nBlocks,
-				__u32 start_block, __u32 end_block)
+				u32 devId, u32 nBlocks,
+				u32 start_block, u32 end_block)
 {
 	SimData *sim;
 	ynandif_Geometry *g;
diff --git a/direct/basic-test/yramsim.h b/direct/basic-test/yramsim.h
index 4f20364..d4e142f 100644
--- a/direct/basic-test/yramsim.h
+++ b/direct/basic-test/yramsim.h
@@ -24,8 +24,8 @@
 #define N_RAM_SIM_DEVS  2
 
 struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name,
-						__u32 devId, __u32 nBlocks,
-						__u32 start_block, __u32 end_block);
+						u32 devId, u32 nBlocks,
+						u32 start_block, u32 end_block);
 
 #endif
 
diff --git a/direct/yaffs_flashif.c b/direct/yaffs_flashif.c
index 79732a1..6747bfc 100644
--- a/direct/yaffs_flashif.c
+++ b/direct/yaffs_flashif.c
@@ -31,7 +31,7 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_flashif.c,v 1.3 2007-02-14 01:
 
 typedef struct 
 {
-	__u8 data[528]; // Data + spare
+	u8 data[528]; // Data + spare
 } yflash_Page;
 
 typedef struct
@@ -108,7 +108,7 @@ static int  CheckInit(yaffs_dev_t *dev)
 	return 1;
 }
 
-int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, yaffs_ext_tags *tags)
+int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, yaffs_ext_tags *tags)
 {
 	int blk;
 	int pg;
@@ -138,7 +138,7 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *
 }
 
 
-int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_tags_t *tags)
+int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_tags_t *tags)
 {
 	int blk;
 	int pg;
diff --git a/direct/yaffs_flashif.h b/direct/yaffs_flashif.h
index bc3ed70..ce7d968 100644
--- a/direct/yaffs_flashif.h
+++ b/direct/yaffs_flashif.h
@@ -19,12 +19,12 @@
 
 #include "yaffs_guts.h"
 int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare);
-int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags);
-int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare);
-int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags);
+int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
+int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
+int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
+int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
 int yflash_InitialiseNAND(yaffs_dev_t *dev);
 int yflash_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no);
-int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number);
+int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
diff --git a/direct/yaffs_flashif2.h b/direct/yaffs_flashif2.h
index de82085..3b704af 100644
--- a/direct/yaffs_flashif2.h
+++ b/direct/yaffs_flashif2.h
@@ -19,13 +19,13 @@
 
 #include "yaffs_guts.h"
 int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int yflash2_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare);
-int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags);
-int yflash2_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare);
-int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags);
+int yflash2_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
+int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
+int yflash2_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
+int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
 int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
 int yflash2_InitialiseNAND(yaffs_dev_t *dev);
 int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no);
-int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number);
+int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
diff --git a/direct/yaffs_nandemul2k.h b/direct/yaffs_nandemul2k.h
index 30b7cbd..23d876b 100644
--- a/direct/yaffs_nandemul2k.h
+++ b/direct/yaffs_nandemul2k.h
@@ -21,14 +21,14 @@
 #include "yaffs_guts.h"
 
 int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev_s *dev,
-					int nand_chunk, const __u8 *data,
+					int nand_chunk, const u8 *data,
 					const yaffs_ext_tags *tags);
 int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev_s *dev,
-					 int nand_chunk, __u8 *data,
+					 int nand_chunk, u8 *data,
 					 yaffs_ext_tags *tags);
 int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no);
 int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no,
-			      yaffs_block_state_t *state, __u32 *seq_number);
+			      yaffs_block_state_t *state, u32 *seq_number);
 int nandemul2k_EraseBlockInNAND(struct yaffs_dev_s *dev,
 				int flash_block);
 int nandemul2k_InitialiseNAND(struct yaffs_dev_s *dev);
diff --git a/direct/yaffs_nandif.c b/direct/yaffs_nandif.c
index 135e894..032017c 100644
--- a/direct/yaffs_nandif.c
+++ b/direct/yaffs_nandif.c
@@ -30,7 +30,7 @@
  * use it to load the tags.
  */
 int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
-				      const __u8 * data,
+				      const u8 * data,
 				      const yaffs_ext_tags * tags)
 {
 
@@ -71,7 +71,7 @@ int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
 }
 
 int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk,
-				       __u8 * data, yaffs_ext_tags * tags)
+				       u8 * data, yaffs_ext_tags * tags)
 {
 	yaffs_packed_tags2 pt;
 	int localData = 0;
@@ -162,7 +162,7 @@ static int ynandif_IsBlockOk(struct yaffs_dev_s *dev, int blockId)
 	return geometry->checkBlockOk(dev,blockId);
 }
 
-int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_state_t *state, __u32 *seq_number)
+int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_state_t *state, u32 *seq_number)
 {
 	unsigned chunkNo;
 	yaffs_ext_tags tags;
diff --git a/direct/yaffs_nandif.h b/direct/yaffs_nandif.h
index b8e3ba0..e7153aa 100644
--- a/direct/yaffs_nandif.h
+++ b/direct/yaffs_nandif.h
@@ -60,12 +60,12 @@ struct yaffs_dev_s *
 
 #if 0
 
-int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags);
-int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags);
+int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
+int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
 int ynandif_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
 int ynandif_InitialiseNAND(yaffs_dev_t *dev);
 int ynandif_MarkNANDBlockBad(yaffs_dev_t *dev,int blockNumber);
-int ynandif_QueryNANDBlock(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number);
+int ynandif_QueryNANDBlock(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
 int ynandif_GetGeometry(yaffs_dev_t *dev, ynandif_Geometry *geometry);
 #endif
 
diff --git a/direct/yaffscfg.h b/direct/yaffscfg.h
index c4cd48b..72687e2 100644
--- a/direct/yaffscfg.h
+++ b/direct/yaffscfg.h
@@ -38,7 +38,7 @@ typedef struct yaffsfs_DeviceConfigurationStruct {
 void yaffsfs_Lock(void);
 void yaffsfs_Unlock(void);
 
-__u32 yaffsfs_CurrentTime(void);
+u32 yaffsfs_CurrentTime(void);
 
 void yaffsfs_SetError(int err);
 
diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c
index 455e6dd..c7b5ed2 100644
--- a/direct/yaffsfs.c
+++ b/direct/yaffsfs.c
@@ -53,14 +53,14 @@ typedef struct {
 } yaffsfs_Inode;
 
 typedef struct{
-	__u8 	reading:1;
-	__u8 	writing:1;
-	__u8 	append:1;
-	__u8	shareRead:1;
-	__u8	shareWrite:1;
+	u8 	reading:1;
+	u8 	writing:1;
+	u8 	append:1;
+	u8	shareRead:1;
+	u8	shareWrite:1;
 	int	inodeId:12;	/* Index to corresponding yaffsfs_Inode */
 	int	useCount:10;	/* Use count for this handle */
-	__u32 position;		/* current position in file */
+	u32 position;		/* current position in file */
 }yaffsfs_Handle;
 
 static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
@@ -584,14 +584,14 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 	int symDepth = 0;
 	int errorReported = 0;
 	int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);
-	__u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
-	__u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
-	__u8 sharedReadAllowed;
-	__u8 sharedWriteAllowed;
-	__u8 alreadyReading;
-	__u8 alreadyWriting;
-	__u8 readRequested;
-	__u8 writeRequested;
+	u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
+	u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
+	u8 sharedReadAllowed;
+	u8 sharedWriteAllowed;
+	u8 alreadyReading;
+	u8 alreadyWriting;
+	u8 readRequested;
+	u8 writeRequested;
 
 	/* O_EXCL only has meaning if O_CREAT is specified */
 	if(!(oflag & O_CREAT))
@@ -824,7 +824,7 @@ int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int off
 	int nToRead = 0;
 	int totalRead = 0;
 	unsigned int maxRead;
-	__u8 *buf = (__u8 *)vbuf;
+	u8 *buf = (u8 *)vbuf;
 
 	yaffsfs_Lock();
 	h = yaffsfs_GetHandlePointer(fd);
@@ -920,7 +920,7 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite,
 	int totalWritten = 0;
 	int write_trhrough = 0;
 	int nToWrite = 0;
-	const __u8 *buf = (const __u8 *)vbuf;
+	const u8 *buf = (const u8 *)vbuf;
 
 	yaffsfs_Lock();
 	h = yaffsfs_GetHandlePointer(fd);
@@ -2049,7 +2049,7 @@ void yaffs_remove_device(yaffs_dev_t *dev)
 
 typedef struct
 {
-	__u32 magic;
+	u32 magic;
 	yaffs_dirent de;		/* directory entry being used by this dsc */
 	YCHAR name[NAME_MAX+1];		/* name of directory being searched */
         yaffs_obj_t *dirObj;           /* ptr to directory being searched */
diff --git a/mtdemul/nandemul2k.c b/mtdemul/nandemul2k.c
index 862b244..4cba57b 100644
--- a/mtdemul/nandemul2k.c
+++ b/mtdemul/nandemul2k.c
@@ -66,7 +66,7 @@ static struct mtd_info nandemul2k_mtd;
 
 typedef struct 
 {
-	__u8 data[PAGE_TOTAL_SIZE]; // Data + spare
+	u8 data[PAGE_TOTAL_SIZE]; // Data + spare
 	int empty;      // is this empty?
 } nandemul_Page;
 
@@ -114,8 +114,8 @@ static void nandemul2k_Program(const void *buffer, int page, int start, int n_by
 {
 	int pg = page%PAGES_PER_BLOCK;
 	int blk = page/PAGES_PER_BLOCK;
-	__u8 *p;
-	__u8 *b = (__u8 *)buffer;
+	u8 *p;
+	u8 *b = (u8 *)buffer;
 
 	p = &ned.block[blk]->page[pg]->data[start];
 	
@@ -255,7 +255,7 @@ int nandemul2k_GetNumberOfBlocks(void) {return nandemul2k_CalcNBlocks();}
 
 
 
-static int nandemul2k_ReadId(__u8 *vendorId, __u8 *deviceId)
+static int nandemul2k_ReadId(u8 *vendorId, u8 *deviceId)
 {
 	*vendorId = 'Y'; 
 	*deviceId = '2';
@@ -264,7 +264,7 @@ static int nandemul2k_ReadId(__u8 *vendorId, __u8 *deviceId)
 }
 
 
-static int nandemul2k_ReadStatus(__u8 *status)
+static int nandemul2k_ReadStatus(u8 *status)
 {
 		*status = 0;
 		return 1;
diff --git a/patches/yaffs_mtdif2.c b/patches/yaffs_mtdif2.c
index c105e45..019142b 100644
--- a/patches/yaffs_mtdif2.c
+++ b/patches/yaffs_mtdif2.c
@@ -31,7 +31,7 @@ const char *yaffs_mtdif2_c_version =
 void nandmtd2_pt2buf(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
 {
 	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-	__u8 *ptab = (__u8 *)pt; /* packed tags as bytes */
+	u8 *ptab = (u8 *)pt; /* packed tags as bytes */
 	
 	int	i, j = 0, k, n;
 
@@ -73,7 +73,7 @@ void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
 {
 	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 	int	i, j = 0, k, n;
-	__u8 *ptab = (__u8 *)pt; /* packed tags as bytes */
+	u8 *ptab = (u8 *)pt; /* packed tags as bytes */
 
 
 	if (!is_raw) {
@@ -108,7 +108,7 @@ void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
 }
 
 int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
-				      const __u8 * data,
+				      const u8 * data,
 				      const yaffs_ext_tags * tags)
 {
 	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
@@ -150,7 +150,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
 }
 
 int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk,
-				       __u8 * data, yaffs_ext_tags * tags)
+				       u8 * data, yaffs_ext_tags * tags)
 {
 	struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
 	size_t dummy;
diff --git a/utils/mkyaffs2image.c b/utils/mkyaffs2image.c
index 2d63908..1890427 100644
--- a/utils/mkyaffs2image.c
+++ b/utils/mkyaffs2image.c
@@ -179,7 +179,7 @@ static void shuffle_oob(char *spareData, yaffs_packed_tags2 *pt)
 	memcpy(spareData, pt, sizeof(*pt));
 }
 
-static int write_chunk(__u8 *data, __u32 id, __u32 chunk_id, __u32 n_bytes)
+static int write_chunk(u8 *data, u32 id, u32 chunk_id, u32 n_bytes)
 {
 	yaffs_ext_tags t;
 	yaffs_packed_tags2 pt;
@@ -233,7 +233,7 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh)
     int i;    
     oh->type = SWAP32(oh->type); // GCC makes enums 32 bits.
     oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int
-    oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // __u16 - Not used, but done for completeness.
+    oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // u16 - Not used, but done for completeness.
     // name = skip. Char array. Not swapped.
     oh->yst_mode = SWAP32(oh->yst_mode);
 #ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. 
@@ -278,7 +278,7 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh)
 
 static int write_object_header(int id, yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
 {
-	__u8 bytes[chunkSize];
+	u8 bytes[chunkSize];
 	
 	
 	yaffs_obj_header *oh = (yaffs_obj_header *)bytes;
@@ -342,7 +342,7 @@ static int write_object_header(int id, yaffs_obj_type t, struct stat *s, int par
 
 static void pad_image(void)
 {
-	__u8 data[chunkSize + spareSize];
+	u8 data[chunkSize + spareSize];
 	int padPages = (nPages % pagesPerBlock);
 
 	if (padPages)
@@ -444,7 +444,7 @@ static int process_directory(int parent, const char *path)
 							if(write_object_header(newObj, YAFFS_OBJECT_TYPE_FILE, &stats, parent, entry->d_name, -1, NULL) == 0)
 							{
 								int h;
-								__u8 bytes[chunkSize];
+								u8 bytes[chunkSize];
 								int n_bytes;
 								int chunk = 0;
 								
diff --git a/utils/mkyaffsimage.c b/utils/mkyaffsimage.c
index 94b0298..5d74940 100644
--- a/utils/mkyaffsimage.c
+++ b/utils/mkyaffsimage.c
@@ -113,12 +113,12 @@ static int find_obj_in_list(dev_t dev, ino_t ino)
 }
 
 // NCB added 10/9/2002
-static __u16 yaffs_calc_name_sum(const char *name)
+static u16 yaffs_calc_name_sum(const char *name)
 {
-	__u16 sum = 0;
-	__u16 i = 1;
+	u16 sum = 0;
+	u16 i = 1;
 	
-	__u8 *bname = (__u8 *)name;
+	u8 *bname = (u8 *)name;
 	
 	while (*bname)
 	{
@@ -130,7 +130,7 @@ static __u16 yaffs_calc_name_sum(const char *name)
 }
 
 
-static void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare)
+static void yaffs_calc_ecc(const u8 *data, yaffs_spare *spare)
 {
 	yaffs_ecc_cacl(data , spare->ecc1);
 	yaffs_ecc_cacl(&data[256] , spare->ecc2);
@@ -228,7 +228,7 @@ static void little_to_big_endian(yaffs_tags_t *tagsPtr)
     tags->as_bytes[7] = temp.as_bytes[7];
 }
 
-static int write_chunk(__u8 *data, __u32 obj_id, __u32 chunk_id, __u32 n_bytes)
+static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes)
 {
 	yaffs_tags_t t;
 	yaffs_spare s;
@@ -272,7 +272,7 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh)
 {
     oh->type = SWAP32(oh->type); // GCC makes enums 32 bits.
     oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int
-    oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // __u16 - Not used, but done for completeness.
+    oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // u16 - Not used, but done for completeness.
     // name = skip. Char array. Not swapped.
     oh->yst_mode = SWAP32(oh->yst_mode);
 #ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. 
@@ -327,7 +327,7 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh)
 
 static int write_object_header(int obj_id, yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
 {
-	__u8 bytes[512];
+	u8 bytes[512];
 	
 	
 	yaffs_obj_header *oh = (yaffs_obj_header *)bytes;
@@ -453,7 +453,7 @@ static int process_directory(int parent, const char *path)
 							if(error >= 0)
 							{
 								int h;
-								__u8 bytes[512];
+								u8 bytes[512];
 								int n_bytes;
 								int chunk = 0;
 								
diff --git a/yaffs_allocator.c b/yaffs_allocator.c
index 66ba5a6..6db9856 100644
--- a/yaffs_allocator.c
+++ b/yaffs_allocator.c
@@ -140,7 +140,7 @@ static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes)
 	struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
 	int i;
 	yaffs_tnode_t *new_tnodes;
-	__u8 *mem;
+	u8 *mem;
 	yaffs_tnode_t *curr;
 	yaffs_tnode_t *next;
 	yaffs_tnodelist_t *tnl;
@@ -157,7 +157,7 @@ static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes)
 	/* make these things */
 
 	new_tnodes = YMALLOC(n_tnodes * dev->tnode_size);
-	mem = (__u8 *)new_tnodes;
+	mem = (u8 *)new_tnodes;
 
 	if (!new_tnodes) {
 		T(YAFFS_TRACE_ERROR,
diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c
index 85c8c1d..53712d1 100644
--- a/yaffs_bitmap.c
+++ b/yaffs_bitmap.c
@@ -17,7 +17,7 @@
  * Chunk bitmap manipulations
  */
 
-static Y_INLINE __u8 *yaffs_block_bits(yaffs_dev_t *dev, int blk)
+static Y_INLINE u8 *yaffs_block_bits(yaffs_dev_t *dev, int blk)
 {
 	if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
 		T(YAFFS_TRACE_ERROR,
@@ -42,14 +42,14 @@ void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk)
 
 void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk)
 {
-	__u8 *blk_bits = yaffs_block_bits(dev, blk);
+	u8 *blk_bits = yaffs_block_bits(dev, blk);
 
 	memset(blk_bits, 0, dev->chunk_bit_stride);
 }
 
 void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
 {
-	__u8 *blk_bits = yaffs_block_bits(dev, blk);
+	u8 *blk_bits = yaffs_block_bits(dev, blk);
 
 	yaffs_verify_chunk_bit_id(dev, blk, chunk);
 
@@ -58,7 +58,7 @@ void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
 
 void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
 {
-	__u8 *blk_bits = yaffs_block_bits(dev, blk);
+	u8 *blk_bits = yaffs_block_bits(dev, blk);
 
 	yaffs_verify_chunk_bit_id(dev, blk, chunk);
 
@@ -67,7 +67,7 @@ void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
 
 int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
 {
-	__u8 *blk_bits = yaffs_block_bits(dev, blk);
+	u8 *blk_bits = yaffs_block_bits(dev, blk);
 	yaffs_verify_chunk_bit_id(dev, blk, chunk);
 
 	return (blk_bits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
@@ -75,7 +75,7 @@ int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
 
 int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk)
 {
-	__u8 *blk_bits = yaffs_block_bits(dev, blk);
+	u8 *blk_bits = yaffs_block_bits(dev, blk);
 	int i;
 	for (i = 0; i < dev->chunk_bit_stride; i++) {
 		if (*blk_bits)
@@ -87,11 +87,11 @@ int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk)
 
 int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk)
 {
-	__u8 *blk_bits = yaffs_block_bits(dev, blk);
+	u8 *blk_bits = yaffs_block_bits(dev, blk);
 	int i;
 	int n = 0;
 	for (i = 0; i < dev->chunk_bit_stride; i++) {
-		__u8 x = *blk_bits;
+		u8 x = *blk_bits;
 		while (x) {
 			if (x & 1)
 				n++;
diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c
index 82d6874..519f406 100644
--- a/yaffs_checkptrw.c
+++ b/yaffs_checkptrw.c
@@ -177,9 +177,9 @@ int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing)
 	return 1;
 }
 
-int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum)
+int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, u32 *sum)
 {
-	__u32 composite_sum;
+	u32 composite_sum;
 	composite_sum =  (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
 	*sum = composite_sum;
 	return 1;
@@ -244,7 +244,7 @@ int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes)
 	int ok = 1;
 
 
-	__u8 * data_bytes = (__u8 *)data;
+	u8 * data_bytes = (u8 *)data;
 
 
 
@@ -283,7 +283,7 @@ int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes)
 	int chunk;
 	int realigned_chunk;
 
-	__u8 *data_bytes = (__u8 *)data;
+	u8 *data_bytes = (u8 *)data;
 
 	if (!dev->checkpt_buffer)
 		return 0;
diff --git a/yaffs_checkptrw.h b/yaffs_checkptrw.h
index 582b89c..3e446a1 100644
--- a/yaffs_checkptrw.h
+++ b/yaffs_checkptrw.h
@@ -24,7 +24,7 @@ int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes);
 
 int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes);
 
-int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum);
+int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, u32 *sum);
 
 int yaffs_checkpt_close(yaffs_dev_t *dev);
 
diff --git a/yaffs_guts.c b/yaffs_guts.c
index 7a4081d..a88f4d0 100644
--- a/yaffs_guts.c
+++ b/yaffs_guts.c
@@ -46,7 +46,7 @@ static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block);
 static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk,
 		int erased_ok);
 static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk,
-				const __u8 *data,
+				const u8 *data,
 				const yaffs_ext_tags *tags);
 static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk,
 				const yaffs_ext_tags *tags);
@@ -57,7 +57,7 @@ static int yaffs_unlink_obj(yaffs_obj_t *obj);
 static int yaffs_obj_cache_dirty(yaffs_obj_t *obj);
 
 static int yaffs_write_new_chunk(yaffs_dev_t *dev,
-					const __u8 *buffer,
+					const u8 *buffer,
 					yaffs_ext_tags *tags,
 					int use_reserver);
 
@@ -93,7 +93,7 @@ static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
 
 static int yaffs_verify_chunk_written(yaffs_dev_t *dev,
 					int nand_chunk,
-					const __u8 *data,
+					const u8 *data,
 					yaffs_ext_tags *tags);
 
 
@@ -104,16 +104,16 @@ static void yaffs_load_oh_from_name(yaffs_dev_t *dev,YCHAR *oh_name, const YCHAR
 /* Function to calculate chunk and offset */
 
 static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out,
-		__u32 *offset_out)
+		u32 *offset_out)
 {
 	int chunk;
-	__u32 offset;
+	u32 offset;
 
-	chunk  = (__u32)(addr >> dev->chunk_shift);
+	chunk  = (u32)(addr >> dev->chunk_shift);
 
 	if (dev->chunk_div == 1) {
 		/* easy power of 2 case */
-		offset = (__u32)(addr & dev->chunk_mask);
+		offset = (u32)(addr & dev->chunk_mask);
 	} else {
 		/* Non power-of-2 case */
 
@@ -122,7 +122,7 @@ static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out,
 		chunk /= dev->chunk_div;
 
 		chunk_base = ((loff_t)chunk) * dev->data_bytes_per_chunk;
-		offset = (__u32)(addr - chunk_base);
+		offset = (u32)(addr - chunk_base);
 	}
 
 	*chunk_out = chunk;
@@ -135,7 +135,7 @@ static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out,
  * be hellishly efficient.
  */
 
-static __u32 calc_shifts_ceiling(__u32 x)
+static u32 calc_shifts_ceiling(u32 x)
 {
 	int extra_bits;
 	int shifts;
@@ -158,9 +158,9 @@ static __u32 calc_shifts_ceiling(__u32 x)
 /* Function to return the number of shifts to get a 1 in bit 0
  */
 
-static __u32 calc_shifts(__u32 x)
+static u32 calc_shifts(u32 x)
 {
-	__u32 shifts;
+	u32 shifts;
 
 	shifts =  0;
 
@@ -184,7 +184,7 @@ static __u32 calc_shifts(__u32 x)
 static int yaffs_init_tmp_buffers(yaffs_dev_t *dev)
 {
 	int i;
-	__u8 *buf = (__u8 *)1;
+	u8 *buf = (u8 *)1;
 
 	memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer));
 
@@ -197,7 +197,7 @@ static int yaffs_init_tmp_buffers(yaffs_dev_t *dev)
 	return buf ? YAFFS_OK : YAFFS_FAIL;
 }
 
-__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no)
+u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no)
 {
 	int i, j;
 
@@ -237,7 +237,7 @@ __u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no)
 
 }
 
-void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer,
+void yaffs_release_temp_buffer(yaffs_dev_t *dev, u8 *buffer,
 				    int line_no)
 {
 	int i;
@@ -265,7 +265,7 @@ void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer,
 /*
  * Determine if we have a managed buffer.
  */
-int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const __u8 *buffer)
+int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const u8 *buffer)
 {
 	int i;
 
@@ -324,7 +324,7 @@ yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev)
  *  Erased NAND checking functions
  */
 
-int yaffs_check_ff(__u8 *buffer, int n_bytes)
+int yaffs_check_ff(u8 *buffer, int n_bytes)
 {
 	/* Horrible, slow implementation */
 	while (n_bytes--) {
@@ -339,7 +339,7 @@ static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev,
 				int nand_chunk)
 {
 	int retval = YAFFS_OK;
-	__u8 *data = yaffs_get_temp_buffer(dev, __LINE__);
+	u8 *data = yaffs_get_temp_buffer(dev, __LINE__);
 	yaffs_ext_tags tags;
 	int result;
 
@@ -363,12 +363,12 @@ static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev,
 
 static int yaffs_verify_chunk_written(yaffs_dev_t *dev,
 					int nand_chunk,
-					const __u8 *data,
+					const u8 *data,
 					yaffs_ext_tags *tags)
 {
 	int retval = YAFFS_OK;
 	yaffs_ext_tags temp_tags;
-	__u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__);
+	u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__);
 	int result;
 	
 	result = yaffs_rd_chunk_tags_nand(dev,nand_chunk,buffer,&temp_tags);
@@ -384,7 +384,7 @@ static int yaffs_verify_chunk_written(yaffs_dev_t *dev,
 }
 
 static int yaffs_write_new_chunk(struct yaffs_dev_s *dev,
-					const __u8 *data,
+					const u8 *data,
 					yaffs_ext_tags *tags,
 					int use_reserver)
 {
@@ -508,7 +508,7 @@ static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block)
 			yaffs_ext_tags tags;
 			int chunk_id = flash_block * dev->param.chunks_per_block;
 
-			__u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+			u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
 			memset(buffer, 0xff, dev->data_bytes_per_chunk);
 			yaffs_init_tags(&tags);
@@ -536,7 +536,7 @@ static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block)
  */
 
 static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk,
-				const __u8 *data,
+				const u8 *data,
 				const yaffs_ext_tags *tags)
 {
 	dev=dev;
@@ -591,10 +591,10 @@ static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk,
 
 /*---------------- Name handling functions ------------*/
 
-static __u16 yaffs_calc_name_sum(const YCHAR *name)
+static u16 yaffs_calc_name_sum(const YCHAR *name)
 {
-	__u16 sum = 0;
-	__u16 i = 1;
+	u16 sum = 0;
+	u16 i = 1;
 
 	const YUCHAR *bname = (const YUCHAR *) name;
 	if (bname) {
@@ -673,11 +673,11 @@ static void yaffs_deinit_tnodes_and_objs(yaffs_dev_t *dev)
 void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos,
 		unsigned val)
 {
-	__u32 *map = (__u32 *)tn;
-	__u32 bit_in_map;
-	__u32 bit_in_word;
-	__u32 word_in_map;
-	__u32 mask;
+	u32 *map = (u32 *)tn;
+	u32 bit_in_map;
+	u32 bit_in_word;
+	u32 word_in_map;
+	u32 mask;
 
 	pos &= YAFFS_TNODES_LEVEL0_MASK;
 	val >>= dev->chunk_grp_bits;
@@ -700,14 +700,14 @@ void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos,
 	}
 }
 
-__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn,
+u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn,
 		unsigned pos)
 {
-	__u32 *map = (__u32 *)tn;
-	__u32 bit_in_map;
-	__u32 bit_in_word;
-	__u32 word_in_map;
-	__u32 val;
+	u32 *map = (u32 *)tn;
+	u32 bit_in_map;
+	u32 bit_in_word;
+	u32 word_in_map;
+	u32 val;
 
 	pos &= YAFFS_TNODES_LEVEL0_MASK;
 
@@ -739,10 +739,10 @@ __u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn,
 /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
 yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev,
 					yaffs_file_s *file_struct,
-					__u32 chunk_id)
+					u32 chunk_id)
 {
 	yaffs_tnode_t *tn = file_struct->top;
-	__u32 i;
+	u32 i;
 	int required_depth;
 	int level = file_struct->top_level;
 
@@ -793,7 +793,7 @@ yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev,
 
 yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev,
 					yaffs_file_s *file_struct,
-					__u32 chunk_id,
+					u32 chunk_id,
 					yaffs_tnode_t *passed_tn)
 {
 	int required_depth;
@@ -801,7 +801,7 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev,
 	int l;
 	yaffs_tnode_t *tn;
 
-	__u32 x;
+	u32 x;
 
 
 	/* Check sane level and page Id */
@@ -937,7 +937,7 @@ static void yaffs_soft_del_chunk(yaffs_dev_t *dev, int chunk)
  */
 
 static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
-				  __u32 level, int chunk_offset)
+				  u32 level, int chunk_offset)
 {
 	int i;
 	int the_chunk;
@@ -1033,7 +1033,7 @@ static void yaffs_soft_del_file(yaffs_obj_t *obj)
  */
 
 static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn,
-				__u32 level, int del0)
+				u32 level, int del0)
 {
 	int i;
 	int has_data;
@@ -1054,8 +1054,8 @@ static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn,
 					has_data++;
 			}
 		} else {
-			int tnode_size_u32 = dev->tnode_size/sizeof(__u32);
-			__u32 *map = (__u32 *)tn;
+			int tnode_size_u32 = dev->tnode_size/sizeof(u32);
+			u32 *map = (u32 *)tn;
 
                         for(i = 0; !has_data && i < tnode_size_u32; i++){
                                 if(map[i])
@@ -1163,7 +1163,7 @@ static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev)
 }
 
 static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number,
-					       __u32 mode)
+					       u32 mode)
 {
 
 	yaffs_obj_t *obj =
@@ -1283,7 +1283,7 @@ static int yaffs_new_obj_id(yaffs_dev_t *dev)
 	int found = 0;
 	struct ylist_head *i;
 
-	__u32 n = (__u32) bucket;
+	u32 n = (u32) bucket;
 
 	/* yaffs_check_obj_hash_sane();  */
 
@@ -1313,7 +1313,7 @@ static void yaffs_hash_obj(yaffs_obj_t *in)
 	dev->obj_bucket[bucket].count++;
 }
 
-yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number)
+yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, u32 number)
 {
 	int bucket = yaffs_hash_fn(number);
 	struct ylist_head *i;
@@ -1383,7 +1383,7 @@ yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number,
 		case YAFFS_OBJECT_TYPE_FILE:
 			the_obj->variant.file_variant.file_size = 0;
 			the_obj->variant.file_variant.scanned_size = 0;
-			the_obj->variant.file_variant.shrink_size = 0xFFFFFFFF;	/* max __u32 */
+			the_obj->variant.file_variant.shrink_size = 0xFFFFFFFF;	/* max u32 */
 			the_obj->variant.file_variant.top_level = 0;
 			the_obj->variant.file_variant.top = tn;
 			break;
@@ -1452,11 +1452,11 @@ YCHAR *yaffs_clone_str(const YCHAR *str)
 static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type,
 				       yaffs_obj_t *parent,
 				       const YCHAR *name,
-				       __u32 mode,
-				       __u32 uid,
-				       __u32 gid,
+				       u32 mode,
+				       u32 uid,
+				       u32 gid,
 				       yaffs_obj_t *equiv_obj,
-				       const YCHAR *alias_str, __u32 rdev)
+				       const YCHAR *alias_str, u32 rdev)
 {
 	yaffs_obj_t *in;
 	YCHAR *str = NULL;
@@ -1545,28 +1545,28 @@ static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type,
 }
 
 yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name,
-			__u32 mode, __u32 uid, __u32 gid)
+			u32 mode, u32 uid, u32 gid)
 {
 	return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
 				uid, gid, NULL, NULL, 0);
 }
 
 yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name,
-				__u32 mode, __u32 uid, __u32 gid)
+				u32 mode, u32 uid, u32 gid)
 {
 	return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
 				 mode, uid, gid, NULL, NULL, 0);
 }
 
 yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name,
-				__u32 mode, __u32 uid, __u32 gid, __u32 rdev)
+				u32 mode, u32 uid, u32 gid, u32 rdev)
 {
 	return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
 				 uid, gid, NULL, NULL, rdev);
 }
 
 yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name,
-				__u32 mode, __u32 uid, __u32 gid,
+				u32 mode, u32 uid, u32 gid,
 				const YCHAR *alias)
 {
 	return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode,
@@ -2046,7 +2046,7 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block,
 		yaffs_block_became_dirty(dev, block);
 	} else {
 
-		__u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+		u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
 		yaffs_verify_blk(dev, bi, block);
 
@@ -2180,7 +2180,7 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block,
 
 						yaffs_verify_oh(object, oh, &tags, 1);
 						new_chunk =
-						    yaffs_write_new_chunk(dev,(__u8 *) oh, &tags, 1);
+						    yaffs_write_new_chunk(dev,(u8 *) oh, &tags, 1);
 					} else
 						new_chunk =
 						    yaffs_write_new_chunk(dev, buffer, &tags, 1);
@@ -2749,7 +2749,7 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
 }
 
 static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk,
-					__u8 *buffer)
+					u8 *buffer)
 {
 	int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL);
 
@@ -2832,7 +2832,7 @@ void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn)
 }
 
 static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk,
-					const __u8 *buffer, int n_bytes,
+					const u8 *buffer, int n_bytes,
 					int use_reserve)
 {
 	/* Find old chunk Need to do this to get serial number
@@ -2911,7 +2911,7 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force,
 	yaffs_ext_tags old_tags;
 	const YCHAR *alias = NULL;
 
-	__u8 *buffer = NULL;
+	u8 *buffer = NULL;
 	YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1];
 
 	yaffs_obj_header *oh = NULL;
@@ -3335,12 +3335,12 @@ static void yaffs_invalidate_whole_cache(yaffs_obj_t *in)
  * Curve-balls: the first chunk might also be the last chunk.
  */
 
-int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset,
+int yaffs_file_rd(yaffs_obj_t *in, u8 *buffer, loff_t offset,
 			int n_bytes)
 {
 
 	int chunk;
-	__u32 start;
+	u32 start;
 	int n_copy;
 	int n = n_bytes;
 	int n_done = 0;
@@ -3398,7 +3398,7 @@ int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset,
 			} else {
 				/* Read into the local buffer then copy..*/
 
-				__u8 *local_buffer =
+				u8 *local_buffer =
 				    yaffs_get_temp_buffer(dev, __LINE__);
 				yaffs_rd_data_obj(in, chunk,
 							      local_buffer);
@@ -3427,20 +3427,20 @@ int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset,
 	return n_done;
 }
 
-int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset,
+int yaffs_do_file_wr(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
 			int n_bytes, int write_trhrough)
 {
 
 	int chunk;
-	__u32 start;
+	u32 start;
 	int n_copy;
 	int n = n_bytes;
 	int n_done = 0;
 	int n_writeback;
 	int start_write = offset;
 	int chunk_written = 0;
-	__u32 n_bytes_read;
-	__u32 chunk_start;
+	u32 n_bytes_read;
+	u32 chunk_start;
 
 	yaffs_dev_t *dev;
 
@@ -3549,7 +3549,7 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset,
 				 * Read into the local buffer then copy, then copy over and write back.
 				 */
 
-				__u8 *local_buffer =
+				u8 *local_buffer =
 				    yaffs_get_temp_buffer(dev, __LINE__);
 
 				yaffs_rd_data_obj(in, chunk,
@@ -3603,7 +3603,7 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset,
 	return n_done;
 }
 
-int yaffs_wr_file(yaffs_obj_t *in, const __u8 *buffer, loff_t offset,
+int yaffs_wr_file(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
 			int n_bytes, int write_trhrough)
 {
 	yaffs2_handle_hole(in,offset);
@@ -3659,7 +3659,7 @@ static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size)
 void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size)
 {
 	int new_full;
-	__u32 new_partial;
+	u32 new_partial;
 	yaffs_dev_t *dev = obj->my_dev;
 
 	yaffs_addr_to_chunk(dev, new_size, &new_full, &new_partial);
@@ -3668,7 +3668,7 @@ void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size)
 
 	if (new_partial != 0) {
 		int last_chunk = 1 + new_full;
-		__u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
+		u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
 		/* Got to read and rewrite the last chunk with its new size and zero pad */
 		yaffs_rd_data_obj(obj, last_chunk, local_buffer);
@@ -4245,7 +4245,7 @@ static void yaffs_empty_l_n_f(yaffs_dev_t *dev)
 
 static void yaffs_check_obj_details_loaded(yaffs_obj_t *in)
 {
-	__u8 *chunk_data;
+	u8 *chunk_data;
 	yaffs_obj_header *oh;
 	yaffs_dev_t *dev;
 	yaffs_ext_tags tags;
@@ -4616,7 +4616,7 @@ int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size)
 #endif
 	else if(obj->hdr_chunk > 0) {
 		int result;
-		__u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__);
+		u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__);
 
 		yaffs_obj_header *oh = (yaffs_obj_header *) buffer;
 
@@ -4847,7 +4847,7 @@ static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *val
 	if(!buffer)
 		return -ENOMEM;
 
-	result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (__u8 *)buffer, &tags);
+	result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (u8 *)buffer, &tags);
 
 	if(result != YAFFS_OK)
 		retval = -ENOENT;
@@ -4864,7 +4864,7 @@ static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *val
 		else
 			retval = nval_list(x_buffer, x_size, value,size);
 	}
-	yaffs_release_temp_buffer(dev,(__u8 *)buffer,__LINE__);
+	yaffs_release_temp_buffer(dev,(u8 *)buffer,__LINE__);
 	return retval;
 }
 
@@ -5145,7 +5145,7 @@ int yaffs_guts_initialise(yaffs_dev_t *dev)
 
 		dev->cache =  YMALLOC(cache_bytes);
 
-		buf = (__u8 *) dev->cache;
+		buf = (u8 *) dev->cache;
 
 		if (dev->cache)
 			memset(dev->cache, 0, cache_bytes);
@@ -5165,7 +5165,7 @@ int yaffs_guts_initialise(yaffs_dev_t *dev)
 	dev->cache_hits = 0;
 
 	if (!init_failed) {
-		dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(__u32));
+		dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(u32));
 		if (!dev->gc_cleanup_list)
 			init_failed = 1;
 	}
diff --git a/yaffs_guts.h b/yaffs_guts.h
index 3a819ab..1c9515c 100644
--- a/yaffs_guts.h
+++ b/yaffs_guts.h
@@ -119,7 +119,7 @@ typedef struct {
 	int dirty;
 	int n_bytes;		/* Only valid if the cache is dirty */
 	int locked;		/* Can't push out or flush while locked. */
-	__u8 *data;
+	u8 *data;
 } yaffs_cache_t;
 
 
@@ -141,7 +141,7 @@ typedef struct {
 
 typedef union {
 	yaffs_tags_t as_tags;
-	__u8 as_bytes[8];
+	u8 as_bytes[8];
 } yaffs_tags_union_t;
 
 #endif
@@ -203,18 +203,18 @@ typedef struct {
 
 /* Spare structure for YAFFS1 */
 typedef struct {
-	__u8 tb0;
-	__u8 tb1;
-	__u8 tb2;
-	__u8 tb3;
-	__u8 page_status;	/* set to 0 to delete the chunk */
-	__u8 block_status;
-	__u8 tb4;
-	__u8 tb5;
-	__u8 ecc1[3];
-	__u8 tb6;
-	__u8 tb7;
-	__u8 ecc2[3];
+	u8 tb0;
+	u8 tb1;
+	u8 tb2;
+	u8 tb3;
+	u8 page_status;	/* set to 0 to delete the chunk */
+	u8 block_status;
+	u8 tb4;
+	u8 tb5;
+	u8 ecc1[3];
+	u8 tb6;
+	u8 tb7;
+	u8 ecc2[3];
 } yaffs_spare;
 
 /*Special structure for passing through to mtd */
@@ -280,16 +280,16 @@ typedef struct {
 	int soft_del_pages:10;	/* number of soft deleted pages */
 	int pages_in_use:10;	/* number of pages in use */
 	unsigned block_state:4;	/* One of the above block states. NB use unsigned because enum is sometimes an int */
-	__u32 needs_retiring:1;	/* Data has failed on this block, need to get valid data off */
+	u32 needs_retiring:1;	/* Data has failed on this block, need to get valid data off */
 				/* and retire the block. */
-	__u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */
-	__u32 gc_prioritise:1; 	/* An ECC check or blank check has failed on this block.
+	u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */
+	u32 gc_prioritise:1; 	/* An ECC check or blank check has failed on this block.
 				   It should be prioritised for GC */
-	__u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
+	u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
 
 #ifdef CONFIG_YAFFS_YAFFS2
-	__u32 has_shrink_hdr:1; /* This block has at least one shrink object header */
-	__u32 seq_number;	 /* block sequence number for yaffs2 */
+	u32 has_shrink_hdr:1; /* This block has at least one shrink object header */
+	u32 seq_number;	 /* block sequence number for yaffs2 */
 #endif
 
 } yaffs_block_info_t;
@@ -302,20 +302,20 @@ typedef struct {
 
 	/* Apply to everything  */
 	int parent_obj_id;
-	__u16 sum_no_longer_used;        /* checksum of name. No longer used */
+	u16 sum_no_longer_used;        /* checksum of name. No longer used */
 	YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
 	/* The following apply to directories, files, symlinks - not hard links */
-	__u32 yst_mode;         /* protection */
+	u32 yst_mode;         /* protection */
 
 #ifdef CONFIG_YAFFS_WINCE
-	__u32 not_for_wince[5];
+	u32 not_for_wince[5];
 #else
-	__u32 yst_uid;
-	__u32 yst_gid;
-	__u32 yst_atime;
-	__u32 yst_mtime;
-	__u32 yst_ctime;
+	u32 yst_uid;
+	u32 yst_gid;
+	u32 yst_atime;
+	u32 yst_mtime;
+	u32 yst_ctime;
 #endif
 
 	/* File size  applies to files only */
@@ -327,24 +327,24 @@ typedef struct {
 	/* Alias is for symlinks only. */
 	YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1];
 
-	__u32 yst_rdev;		/* device stuff for block and char devices (major/min) */
+	u32 yst_rdev;		/* device stuff for block and char devices (major/min) */
 
 #ifdef CONFIG_YAFFS_WINCE
-	__u32 win_ctime[2];
-	__u32 win_atime[2];
-	__u32 win_mtime[2];
+	u32 win_ctime[2];
+	u32 win_atime[2];
+	u32 win_mtime[2];
 #else
-	__u32 room_to_grow[6];
+	u32 room_to_grow[6];
 
 #endif
-	__u32 inband_shadowed_obj_id;
-	__u32 inband_is_shrink;
+	u32 inband_shadowed_obj_id;
+	u32 inband_is_shrink;
 
-	__u32 reserved[2];
+	u32 reserved[2];
 	int shadows_obj;	/* This object header shadows the specified object if > 0 */
 
 	/* is_shrink applies to object headers written when we shrink the file (ie resize) */
-	__u32 is_shrink;
+	u32 is_shrink;
 
 } yaffs_obj_header;
 
@@ -367,9 +367,9 @@ typedef union yaffs_tnode_union yaffs_tnode_t;
  */
 
 typedef struct {
-	__u32 file_size;
-	__u32 scanned_size;
-	__u32 shrink_size;
+	u32 file_size;
+	u32 scanned_size;
+	u32 shrink_size;
 	int top_level;
 	yaffs_tnode_t *top;
 } yaffs_file_s;
@@ -385,7 +385,7 @@ typedef struct {
 
 typedef struct {
 	struct yaffs_obj_s *equiv_obj;
-	__u32 equiv_id;
+	u32 equiv_id;
 } yaffs_hard_link_s;
 
 typedef union {
@@ -398,31 +398,31 @@ typedef union {
 
 
 struct yaffs_obj_s {
-	__u8 deleted:1;		/* This should only apply to unlinked files. */
-	__u8 soft_del:1;	/* it has also been soft deleted */
-	__u8 unlinked:1;	/* An unlinked file. The file should be in the unlinked directory.*/
-	__u8 fake:1;		/* A fake object has no presence on NAND. */
-	__u8 rename_allowed:1;	/* Some objects are not allowed to be renamed. */
-	__u8 unlink_allowed:1;
-	__u8 dirty:1;		/* the object needs to be written to flash */
-	__u8 valid:1;		/* When the file system is being loaded up, this
+	u8 deleted:1;		/* This should only apply to unlinked files. */
+	u8 soft_del:1;	/* it has also been soft deleted */
+	u8 unlinked:1;	/* An unlinked file. The file should be in the unlinked directory.*/
+	u8 fake:1;		/* A fake object has no presence on NAND. */
+	u8 rename_allowed:1;	/* Some objects are not allowed to be renamed. */
+	u8 unlink_allowed:1;
+	u8 dirty:1;		/* the object needs to be written to flash */
+	u8 valid:1;		/* When the file system is being loaded up, this
 				 * object might be created before the data
 				 * is available (ie. file data records appear before the header).
 				 */
-	__u8 lazy_loaded:1;	/* This object has been lazy loaded and is missing some detail */
+	u8 lazy_loaded:1;	/* This object has been lazy loaded and is missing some detail */
 
-	__u8 defered_free:1;	/* For Linux kernel. Object is removed from NAND, but is
+	u8 defered_free:1;	/* For Linux kernel. Object is removed from NAND, but is
 				 * still in the inode cache. Free of object is defered.
 				 * until the inode is released.
 				 */
-	__u8 being_created:1;	/* This object is still being created so skip some checks. */
-	__u8 is_shadowed:1;	/* This object is shadowed on the way to being renamed. */
+	u8 being_created:1;	/* This object is still being created so skip some checks. */
+	u8 is_shadowed:1;	/* This object is shadowed on the way to being renamed. */
 
-	__u8 xattr_known:1;	/* We know if this has object has xattribs or not. */
-	__u8 has_xattr:1;	/* This object has xattribs. Valid if xattr_known. */
+	u8 xattr_known:1;	/* We know if this has object has xattribs or not. */
+	u8 has_xattr:1;	/* This object has xattribs. Valid if xattr_known. */
 
-	__u8 serial;		/* serial number of chunk in NAND. Cached here */
-	__u16 sum;		/* sum of the name to speed searching */
+	u8 serial;		/* serial number of chunk in NAND. Cached here */
+	u16 sum;		/* sum of the name to speed searching */
 
 	struct yaffs_dev_s *my_dev;       /* The device I'm on */
 
@@ -440,27 +440,27 @@ struct yaffs_obj_s {
 
 	int n_data_chunks;	/* Number of data chunks attached to the file. */
 
-	__u32 obj_id;		/* the object id value */
+	u32 obj_id;		/* the object id value */
 
-	__u32 yst_mode;
+	u32 yst_mode;
 
 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
 	YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1];
 #endif
 
 #ifdef CONFIG_YAFFS_WINCE
-	__u32 win_ctime[2];
-	__u32 win_mtime[2];
-	__u32 win_atime[2];
+	u32 win_ctime[2];
+	u32 win_mtime[2];
+	u32 win_atime[2];
 #else
-	__u32 yst_uid;
-	__u32 yst_gid;
-	__u32 yst_atime;
-	__u32 yst_mtime;
-	__u32 yst_ctime;
+	u32 yst_uid;
+	u32 yst_gid;
+	u32 yst_atime;
+	u32 yst_mtime;
+	u32 yst_ctime;
 #endif
 
-	__u32 yst_rdev;
+	u32 yst_rdev;
 
 	void *my_inode;
 
@@ -484,20 +484,20 @@ typedef struct {
 
 typedef struct {
 	int struct_type;
-	__u32 obj_id;
-	__u32 parent_id;
+	u32 obj_id;
+	u32 parent_id;
 	int hdr_chunk;
 	yaffs_obj_type variant_type:3;
-	__u8 deleted:1;
-	__u8 soft_del:1;
-	__u8 unlinked:1;
-	__u8 fake:1;
-	__u8 rename_allowed:1;
-	__u8 unlink_allowed:1;
-	__u8 serial;
+	u8 deleted:1;
+	u8 soft_del:1;
+	u8 unlinked:1;
+	u8 fake:1;
+	u8 rename_allowed:1;
+	u8 unlink_allowed:1;
+	u8 serial;
 
 	int n_data_chunks;
-	__u32 size_or_equiv_obj;
+	u32 size_or_equiv_obj;
 } yaffs_checkpt_obj_t;
 
 /*--------------------- Temporary buffers ----------------
@@ -506,7 +506,7 @@ typedef struct {
  */
 
 typedef struct {
-	__u8 *buffer;
+	u8 *buffer;
 	int line;	/* track from whence this buffer was allocated */
 	int max_line;
 } yaffs_buffer_t;
@@ -524,7 +524,7 @@ struct yaffs_param_s {
          */
 
 	int inband_tags;          /* Use unband tags */
-	__u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */
+	u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */
 	int chunks_per_block;	/* does not need to be a power of 2 */
 	int spare_bytes_per_chunk;	/* spare area size */
 	int start_block;		/* Start block we're allowed to use */
@@ -547,18 +547,18 @@ struct yaffs_param_s {
 	int refresh_period;	/* How often we should check to do a block refresh */
 
 	/* Checkpoint control. Can be set before or after initialisation */
-	__u8 skip_checkpt_rd;
-	__u8 skip_checkpt_wr;
+	u8 skip_checkpt_rd;
+	u8 skip_checkpt_wr;
 
 	int enable_xattr;	/* Enable xattribs */
 
 	/* NAND access functions (Must be set before calling YAFFS)*/
 
 	int (*write_chunk_fn) (struct yaffs_dev_s *dev,
-					int nand_chunk, const __u8 *data,
+					int nand_chunk, const u8 *data,
 					const yaffs_spare *spare);
 	int (*read_chunk_fn) (struct yaffs_dev_s *dev,
-					int nand_chunk, __u8 *data,
+					int nand_chunk, u8 *data,
 					yaffs_spare *spare);
 	int (*erase_fn) (struct yaffs_dev_s *dev,
 					int flash_block);
@@ -567,14 +567,14 @@ struct yaffs_param_s {
 
 #ifdef CONFIG_YAFFS_YAFFS2
 	int (*write_chunk_tags_fn) (struct yaffs_dev_s *dev,
-					 int nand_chunk, const __u8 *data,
+					 int nand_chunk, const u8 *data,
 					 const yaffs_ext_tags *tags);
 	int (*read_chunk_tags_fn) (struct yaffs_dev_s *dev,
-					  int nand_chunk, __u8 *data,
+					  int nand_chunk, u8 *data,
 					  yaffs_ext_tags *tags);
 	int (*bad_block_fn) (struct yaffs_dev_s *dev, int block_no);
 	int (*query_block_fn) (struct yaffs_dev_s *dev, int block_no,
-			       yaffs_block_state_t *state, __u32 *seq_number);
+			       yaffs_block_state_t *state, u32 *seq_number);
 #endif
 
 	/* The remove_obj_fn function must be supplied by OS flavours that
@@ -620,20 +620,20 @@ struct yaffs_dev_s {
 	int data_bytes_per_chunk;	
 
         /* Non-wide tnode stuff */
-	__u16 chunk_grp_bits;	/* Number of bits that need to be resolved if
+	u16 chunk_grp_bits;	/* Number of bits that need to be resolved if
                                  * the tnodes are not wide enough.
                                  */
-	__u16 chunk_grp_size;	/* == 2^^chunk_grp_bits */
+	u16 chunk_grp_size;	/* == 2^^chunk_grp_bits */
 
 	/* Stuff to support wide tnodes */
-	__u32 tnode_width;
-	__u32 tnode_mask;
-	__u32 tnode_size;
+	u32 tnode_width;
+	u32 tnode_mask;
+	u32 tnode_size;
 
 	/* Stuff for figuring out file offset to chunk conversions */
-	__u32 chunk_shift; /* Shift value */
-	__u32 chunk_div;   /* Divisor after shifting: 1 for power-of-2 sizes */
-	__u32 chunk_mask;  /* Mask to use for power-of-2 case */
+	u32 chunk_shift; /* Shift value */
+	u32 chunk_div;   /* Divisor after shifting: 1 for power-of-2 sizes */
+	u32 chunk_mask;  /* Mask to use for power-of-2 case */
 
 
 
@@ -653,7 +653,7 @@ struct yaffs_dev_s {
 	int checkpt_page_seq;   /* running sequence number of checkpoint pages */
 	int checkpt_byte_count;
 	int checkpt_byte_offs;
-	__u8 *checkpt_buffer;
+	u8 *checkpt_buffer;
 	int checkpt_open_write;
 	int blocks_in_checkpt;
 	int checkpt_cur_chunk;
@@ -661,14 +661,14 @@ struct yaffs_dev_s {
 	int checkpt_next_block;
 	int *checkpt_block_list;
 	int checkpt_max_blocks;
-	__u32 checkpt_sum;
-	__u32 checkpt_xor;
+	u32 checkpt_sum;
+	u32 checkpt_xor;
 
 	int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */
 
 	/* Block Info */
 	yaffs_block_info_t *block_info;
-	__u8 *chunk_bits;	/* bitmap of chunks in use */
+	u8 *chunk_bits;	/* bitmap of chunks in use */
 	unsigned block_info_alt:1;	/* was allocated using alternative strategy */
 	unsigned chunk_bits_alt:1;	/* was allocated using alternative strategy */
 	int chunk_bit_stride;	/* Number of bytes of chunk_bits per block.
@@ -677,7 +677,7 @@ struct yaffs_dev_s {
 
 	int n_erased_blocks;
 	int alloc_block;	/* Current block being allocated off */
-	__u32 alloc_page;
+	u32 alloc_page;
 	int alloc_block_finder;	/* Used to search for next allocation block */
 
 	/* Object and Tnode memory management */
@@ -688,13 +688,13 @@ struct yaffs_dev_s {
 	int n_hardlinks;
 
 	yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS];
-	__u32 bucket_finder;
+	u32 bucket_finder;
 
 	int n_free_chunks;
 
 	/* Garbage collection control */
-	__u32 *gc_cleanup_list;	/* objects to delete at the end of a GC. */
-	__u32 n_clean_ups;
+	u32 *gc_cleanup_list;	/* objects to delete at the end of a GC. */
+	u32 n_clean_ups;
 
 	unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */
 	unsigned gc_disable;
@@ -711,7 +711,7 @@ struct yaffs_dev_s {
 	yaffs_obj_t *lost_n_found;
 
 	/* Buffer areas for storing data to recover from write failures TODO
-	 *      __u8            buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
+	 *      u8            buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
 	 *      yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK];
 	 */
 
@@ -749,26 +749,26 @@ struct yaffs_dev_s {
 
 
 	/* Statistcs */
-	__u32 n_page_writes;
-	__u32 n_page_reads;
-	__u32 n_erasures;
-	__u32 n_erase_failures;
-	__u32 n_gc_copies;
-	__u32 all_gcs;
-	__u32 passive_gc_count;
-	__u32 oldest_dirty_gc_count;
-	__u32 n_gc_blocks;
-	__u32 bg_gcs;
-	__u32 n_retired_writes;
-	__u32 n_retired_blocks;
-	__u32 n_ecc_fixed;
-	__u32 n_ecc_unfixed;
-	__u32 n_tags_ecc_fixed;
-	__u32 n_tags_ecc_unfixed;
-	__u32 n_deletions;
-	__u32 n_unmarked_deletions;
-	__u32 refresh_count;
-	__u32 cache_hits;
+	u32 n_page_writes;
+	u32 n_page_reads;
+	u32 n_erasures;
+	u32 n_erase_failures;
+	u32 n_gc_copies;
+	u32 all_gcs;
+	u32 passive_gc_count;
+	u32 oldest_dirty_gc_count;
+	u32 n_gc_blocks;
+	u32 bg_gcs;
+	u32 n_retired_writes;
+	u32 n_retired_blocks;
+	u32 n_ecc_fixed;
+	u32 n_ecc_unfixed;
+	u32 n_tags_ecc_fixed;
+	u32 n_tags_ecc_unfixed;
+	u32 n_deletions;
+	u32 n_unmarked_deletions;
+	u32 refresh_count;
+	u32 cache_hits;
 
 };
 
@@ -792,7 +792,7 @@ typedef struct {
 	int struct_type;
 	int n_erased_blocks;
 	int alloc_block;	/* Current block being allocated off */
-	__u32 alloc_page;
+	u32 alloc_page;
 	int n_free_chunks;
 
 	int n_deleted_files;		/* Count of files awaiting deletion;*/
@@ -807,9 +807,9 @@ typedef struct {
 
 typedef struct {
 	int struct_type;
-	__u32 magic;
-	__u32 version;
-	__u32 head;
+	u32 magic;
+	u32 version;
+	u32 head;
 } yaffs_checkpt_validty_t;
 
 
@@ -853,14 +853,14 @@ int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr);
 int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr);
 
 /* File operations */
-int yaffs_file_rd(yaffs_obj_t *obj, __u8 *buffer, loff_t offset,
+int yaffs_file_rd(yaffs_obj_t *obj, u8 *buffer, loff_t offset,
 				int n_bytes);
-int yaffs_wr_file(yaffs_obj_t *obj, const __u8 *buffer, loff_t offset,
+int yaffs_wr_file(yaffs_obj_t *obj, const u8 *buffer, loff_t offset,
 				int n_bytes, int write_trhrough);
 int yaffs_resize_file(yaffs_obj_t *obj, loff_t new_size);
 
 yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name,
-				__u32 mode, __u32 uid, __u32 gid);
+				u32 mode, u32 uid, u32 gid);
 
 int yaffs_flush_file(yaffs_obj_t *obj, int update_time, int data_sync);
 
@@ -872,9 +872,9 @@ int yaffs_checkpoint_restore(yaffs_dev_t *dev);
 
 /* Directory operations */
 yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name,
-				__u32 mode, __u32 uid, __u32 gid);
+				u32 mode, u32 uid, u32 gid);
 yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *the_dir, const YCHAR *name);
-yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number);
+yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, u32 number);
 
 /* Link operations */
 yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name,
@@ -884,13 +884,13 @@ yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj);
 
 /* Symlink operations */
 yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name,
-				 __u32 mode, __u32 uid, __u32 gid,
+				 u32 mode, u32 uid, u32 gid,
 				 const YCHAR *alias);
 YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj);
 
 /* Special inodes (fifos, sockets and devices) */
 yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name,
-				 __u32 mode, __u32 uid, __u32 gid, __u32 rdev);
+				 u32 mode, u32 uid, u32 gid, u32 rdev);
 
 
 int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags);
@@ -904,7 +904,7 @@ yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev);
 
 #ifdef CONFIG_YAFFS_WINCE
 /* CONFIG_YAFFS_WINCE special stuff */
-void yfsd_win_file_time_now(__u32 target[2]);
+void yfsd_win_file_time_now(u32 target[2]);
 #endif
 
 void yaffs_handle_defered_free(yaffs_obj_t *obj);
@@ -920,11 +920,11 @@ void yaffs_guts_test(yaffs_dev_t *dev);
 
 /* A few useful functions to be used within the core files*/
 void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn);
-int yaffs_check_ff(__u8 *buffer, int n_bytes);
+int yaffs_check_ff(u8 *buffer, int n_bytes);
 void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi);
 
-__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no);
-void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, int line_no);
+u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no);
+void yaffs_release_temp_buffer(yaffs_dev_t *dev, u8 *buffer, int line_no);
 
 yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev,
 					        int number,
@@ -947,10 +947,10 @@ int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks);
 yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev);
 yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev,
 					yaffs_file_s *file_struct,
-					__u32 chunk_id,
+					u32 chunk_id,
 					yaffs_tnode_t *passed_tn);
 
-int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset,
+int yaffs_do_file_wr(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
 			int n_bytes, int write_trhrough);
 void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size);
 void yaffs_skip_rest_of_block(yaffs_dev_t *dev);
@@ -959,8 +959,8 @@ int yaffs_count_free_chunks(yaffs_dev_t *dev);
 
 yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev,
 				yaffs_file_s *file_struct,
-				__u32 chunk_id);
+				u32 chunk_id);
 
-__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos);
+u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos);
 
 #endif
diff --git a/yaffs_linux.h b/yaffs_linux.h
index a8e3f85..254a76e 100644
--- a/yaffs_linux.h
+++ b/yaffs_linux.h
@@ -26,7 +26,7 @@ struct yaffs_linux_context {
 	struct task_struct *bg_thread; /* Background thread for this device */
 	int bg_running;
         struct semaphore gross_lock;     /* Gross locking semaphore */
-	__u8 *spare_buffer;      /* For mtdif2 use. Don't know the size of the buffer
+	u8 *spare_buffer;      /* For mtdif2 use. Don't know the size of the buffer
 				 * at compile time so we have to allocate it.
 				 */
 	struct ylist_head search_contexts;
diff --git a/yaffs_mtd1f1_single.c b/yaffs_mtd1f1_single.c
index 698e083..8d0eb19 100644
--- a/yaffs_mtd1f1_single.c
+++ b/yaffs_mtd1f1_single.c
@@ -65,7 +65,7 @@
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_write_chunk_tags(yaffs_dev_t *dev,
-	int nand_chunk, const __u8 *data, const yaffs_ext_tags *etags)
+	int nand_chunk, const u8 *data, const yaffs_ext_tags *etags)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 	int chunk_bytes = dev->data_bytes_per_chunk;
@@ -94,11 +94,11 @@ int nandmtd1_write_chunk_tags(yaffs_dev_t *dev,
 		pt1.deleted = 0;
 	}
 #else
-	((__u8 *)&pt1)[8] = 0xff;
+	((u8 *)&pt1)[8] = 0xff;
 	if (etags->is_deleted) {
 		memset(&pt1, 0xff, 8);
 		/* zero page_status byte to indicate deleted */
-		((__u8 *)&pt1)[8] = 0;
+		((u8 *)&pt1)[8] = 0;
 	}
 #endif
 
@@ -106,8 +106,8 @@ int nandmtd1_write_chunk_tags(yaffs_dev_t *dev,
 	ops.mode = MTD_OOB_AUTO;
 	ops.len = (data) ? chunk_bytes : 0;
 	ops.ooblen = YTAG1_SIZE;
-	ops.datbuf = (__u8 *)data;
-	ops.oobbuf = (__u8 *)&pt1;
+	ops.datbuf = (u8 *)data;
+	ops.oobbuf = (u8 *)&pt1;
 
 	retval = mtd->write_oob(mtd, addr, &ops);
 	if (retval) {
@@ -143,7 +143,7 @@ static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval)
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
 int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
-	int nand_chunk, __u8 *data, yaffs_ext_tags *etags)
+	int nand_chunk, u8 *data, yaffs_ext_tags *etags)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 	int chunk_bytes = dev->data_bytes_per_chunk;
@@ -159,7 +159,7 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
 	ops.len = (data) ? chunk_bytes : 0;
 	ops.ooblen = YTAG1_SIZE;
 	ops.datbuf = data;
-	ops.oobbuf = (__u8 *)&pt1;
+	ops.oobbuf = (u8 *)&pt1;
 
 	/* Read page and oob using MTD.
 	 * Check status and determine ECC result.
@@ -194,7 +194,7 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
 
 	/* Check for a blank/erased chunk.
 	 */
-	if (yaffs_check_ff((__u8 *)&pt1, 8)) {
+	if (yaffs_check_ff((u8 *)&pt1, 8)) {
 		/* when blank, upper layers want ecc_result to be <= NO_ERROR */
 		return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
 	}
@@ -207,7 +207,7 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
 	deleted = !pt1.deleted;
 	pt1.deleted = 1;
 #else
-	deleted = (yaffs_count_bits(((__u8 *)&pt1)[8]) < 7);
+	deleted = (yaffs_count_bits(((u8 *)&pt1)[8]) < 7);
 #endif
 
 	/* Check the packed tags mini-ECC and correct if necessary/possible.
@@ -289,7 +289,7 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
  * Always returns YAFFS_OK.
  */
 int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no,
-	yaffs_block_state_t *state_ptr, __u32 *seq_ptr)
+	yaffs_block_state_t *state_ptr, u32 *seq_ptr)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 	int chunk_num = block_no * dev->param.chunks_per_block;
diff --git a/yaffs_mtd1f2_single.c b/yaffs_mtd1f2_single.c
index af54c18..53ba308 100644
--- a/yaffs_mtd1f2_single.c
+++ b/yaffs_mtd1f2_single.c
@@ -31,7 +31,7 @@
  * use it to load the tags.
  */
 int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-				      const __u8 *data,
+				      const u8 *data,
 				      const yaffs_ext_tags *tags)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
@@ -70,7 +70,7 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
 	ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size;
 	ops.len = dev->param.total_bytes_per_chunk;
 	ops.ooboffs = 0;
-	ops.datbuf = (__u8 *)data;
+	ops.datbuf = (u8 *)data;
 	ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr;
 	retval = mtd->write_oob(mtd, addr, &ops);
 
@@ -82,7 +82,7 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
 }
 
 int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-				       __u8 *data, yaffs_ext_tags *tags)
+				       u8 *data, yaffs_ext_tags *tags)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 	struct mtd_oob_ops ops;
@@ -177,7 +177,7 @@ int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no)
 }
 
 int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no,
-			    yaffs_block_state_t *state, __u32 *seq_number)
+			    yaffs_block_state_t *state, u32 *seq_number)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
 	int retval;
diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c
index 4fd8994..968109a 100644
--- a/yaffs_mtdif.c
+++ b/yaffs_mtdif.c
@@ -26,7 +26,7 @@
 int nandmtd_erase_block(yaffs_dev_t *dev, int block_no)
 {
 	struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
-	__u32 addr =
+	u32 addr =
 	    ((loff_t) block_no) * dev->param.total_bytes_per_chunk
 		* dev->param.chunks_per_block;
 	struct erase_info ei;
diff --git a/yaffs_mtdif1.h b/yaffs_mtdif1.h
index 01a8ec4..83e93e2 100644
--- a/yaffs_mtdif1.h
+++ b/yaffs_mtdif1.h
@@ -15,14 +15,14 @@
 #define __YAFFS_MTDIF1_H__
 
 int nandmtd1_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-	const __u8 *data, const yaffs_ext_tags *tags);
+	const u8 *data, const yaffs_ext_tags *tags);
 
 int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-	__u8 *data, yaffs_ext_tags *tags);
+	u8 *data, yaffs_ext_tags *tags);
 
 int nandmtd1_mark_block_bad(struct yaffs_dev_s *dev, int block_no);
 
 int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no,
-	yaffs_block_state_t *state, __u32 *seq_number);
+	yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
diff --git a/yaffs_mtdif2.h b/yaffs_mtdif2.h
index b33b84d..4cce67b 100644
--- a/yaffs_mtdif2.h
+++ b/yaffs_mtdif2.h
@@ -18,12 +18,12 @@
 
 #include "yaffs_guts.h"
 int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-				const __u8 *data,
+				const u8 *data,
 				const yaffs_ext_tags *tags);
 int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-				__u8 *data, yaffs_ext_tags *tags);
+				u8 *data, yaffs_ext_tags *tags);
 int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no);
 int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no,
-			yaffs_block_state_t *state, __u32 *seq_number);
+			yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
diff --git a/yaffs_nand.c b/yaffs_nand.c
index d721fa6..5fee1a3 100644
--- a/yaffs_nand.c
+++ b/yaffs_nand.c
@@ -18,7 +18,7 @@
 #include "yaffs_getblockinfo.h"
 
 int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
-					   __u8 *buffer,
+					   u8 *buffer,
 					   yaffs_ext_tags *tags)
 {
 	int result;
@@ -53,7 +53,7 @@ int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
 
 int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev,
 						   int nand_chunk,
-						   const __u8 *buffer,
+						   const u8 *buffer,
 						   yaffs_ext_tags *tags)
 {
 
@@ -102,7 +102,7 @@ int yaffs_mark_bad(yaffs_dev_t *dev, int block_no)
 int yaffs_query_init_block_state(yaffs_dev_t *dev,
 						 int block_no,
 						 yaffs_block_state_t *state,
-						 __u32 *seq_number)
+						 u32 *seq_number)
 {
 	block_no -= dev->block_offset;
 
diff --git a/yaffs_nand.h b/yaffs_nand.h
index 24cd147..127b129 100644
--- a/yaffs_nand.h
+++ b/yaffs_nand.h
@@ -20,12 +20,12 @@
 
 
 int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
-					__u8 *buffer,
+					u8 *buffer,
 					yaffs_ext_tags *tags);
 
 int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev,
 						int nand_chunk,
-						const __u8 *buffer,
+						const u8 *buffer,
 						yaffs_ext_tags *tags);
 
 int yaffs_mark_bad(yaffs_dev_t *dev, int block_no);
diff --git a/yaffs_packedtags1.c b/yaffs_packedtags1.c
index 2ce873f..77df13f 100644
--- a/yaffs_packedtags1.c
+++ b/yaffs_packedtags1.c
@@ -29,7 +29,7 @@ void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t)
 
 void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt)
 {
-	static const __u8 all_ff[] =
+	static const u8 all_ff[] =
 	    { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 0xff };
 
diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c
index 9d2472d..5af3a33 100644
--- a/yaffs_tagscompat.c
+++ b/yaffs_tagscompat.c
@@ -39,7 +39,7 @@ static const char yaffs_count_bits_table[256] = {
 	4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
 };
 
-int yaffs_count_bits(__u8 x)
+int yaffs_count_bits(u8 x)
 {
 	int ret_val;
 	ret_val = yaffs_count_bits_table[x];
@@ -48,7 +48,7 @@ int yaffs_count_bits(__u8 x)
 
 /********** Tags ECC calculations  *********/
 
-void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare)
+void yaffs_calc_ecc(const u8 *data, yaffs_spare *spare)
 {
 	yaffs_ecc_cacl(data, spare->ecc1);
 	yaffs_ecc_cacl(&data[256], spare->ecc2);
@@ -153,7 +153,7 @@ static void yaffs_spare_init(yaffs_spare *spare)
 }
 
 static int yaffs_wr_nand(struct yaffs_dev_s *dev,
-				int nand_chunk, const __u8 *data,
+				int nand_chunk, const u8 *data,
 				yaffs_spare *spare)
 {
 	if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
@@ -168,7 +168,7 @@ static int yaffs_wr_nand(struct yaffs_dev_s *dev,
 
 static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev,
 				   int nand_chunk,
-				   __u8 *data,
+				   u8 *data,
 				   yaffs_spare *spare,
 				   yaffs_ecc_result *ecc_result,
 				   int correct_errors)
@@ -188,7 +188,7 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev,
 			/* Do ECC correction */
 			/* Todo handle any errors */
 			int ecc_result1, ecc_result2;
-			__u8 calc_ecc[3];
+			u8 calc_ecc[3];
 
 			yaffs_ecc_cacl(data, calc_ecc);
 			ecc_result1 =
@@ -313,7 +313,7 @@ static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk)
 
 int yaffs_tags_compat_wr(yaffs_dev_t *dev,
 						int nand_chunk,
-						const __u8 *data,
+						const u8 *data,
 						const yaffs_ext_tags *ext_tags)
 {
 	yaffs_spare spare;
@@ -349,7 +349,7 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev,
 
 int yaffs_tags_compat_rd(yaffs_dev_t *dev,
 						     int nand_chunk,
-						     __u8 *data,
+						     u8 *data,
 						     yaffs_ext_tags *ext_tags)
 {
 
@@ -423,7 +423,7 @@ int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev,
 int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev,
 					  int block_no,
 					  yaffs_block_state_t *state,
-					  __u32 *seq_number)
+					  u32 *seq_number)
 {
 
 	yaffs_spare spare0, spare1;
diff --git a/yaffs_tagscompat.h b/yaffs_tagscompat.h
index 889bf5f..9f0fc5d 100644
--- a/yaffs_tagscompat.h
+++ b/yaffs_tagscompat.h
@@ -19,21 +19,21 @@
 #include "yaffs_guts.h"
 int yaffs_tags_compat_wr(yaffs_dev_t *dev,
 						int nand_chunk,
-						const __u8 *data,
+						const u8 *data,
 						const yaffs_ext_tags *tags);
 int yaffs_tags_compat_rd(yaffs_dev_t *dev,
 						int nand_chunk,
-						__u8 *data,
+						u8 *data,
 						yaffs_ext_tags *tags);
 int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev,
 					    int block_no);
 int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev,
 					  int block_no,
 					  yaffs_block_state_t *state,
-					  __u32 *seq_number);
+					  u32 *seq_number);
 
 void yaffs_calc_tags_ecc(yaffs_tags_t *tags);
 int yaffs_check_tags_ecc(yaffs_tags_t *tags);
-int yaffs_count_bits(__u8 byte);
+int yaffs_count_bits(u8 byte);
 
 #endif
diff --git a/yaffs_verify.c b/yaffs_verify.c
index 32aaadc..5bdddc0 100644
--- a/yaffs_verify.c
+++ b/yaffs_verify.c
@@ -209,7 +209,7 @@ void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tag
 			(TSTR("Obj %d header name is NULL"TENDSTR),
 			obj->obj_id));
 
-	if (tags->obj_id > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
+	if (tags->obj_id > 1 && ((u8)(oh->name[0])) == 0xff) /* Trashed name */
 		T(YAFFS_TRACE_VERIFY,
 			(TSTR("Obj %d header name is 0xFF"TENDSTR),
 			obj->obj_id));
@@ -221,13 +221,13 @@ void yaffs_verify_file(yaffs_obj_t *obj)
 {
 	int required_depth;
 	int actual_depth;
-	__u32 last_chunk;
-	__u32 x;
-	__u32 i;
+	u32 last_chunk;
+	u32 x;
+	u32 i;
 	yaffs_dev_t *dev;
 	yaffs_ext_tags tags;
 	yaffs_tnode_t *tn;
-	__u32 obj_id;
+	u32 obj_id;
 
 	if (!obj)
 		return;
@@ -261,7 +261,7 @@ void yaffs_verify_file(yaffs_obj_t *obj)
 		tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i);
 
 		if (tn) {
-			__u32 the_chunk = yaffs_get_group_base(dev, tn, i);
+			u32 the_chunk = yaffs_get_group_base(dev, tn, i);
 			if (the_chunk > 0) {
 				/* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */
 				yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags);
@@ -302,13 +302,13 @@ void yaffs_verify_obj(yaffs_obj_t *obj)
 {
 	yaffs_dev_t *dev;
 
-	__u32 chunk_min;
-	__u32 chunk_max;
+	u32 chunk_min;
+	u32 chunk_max;
 
-	__u32 chunk_id_ok;
-	__u32 chunk_in_range;
-	__u32 chunk_wrongly_deleted;
-	__u32 chunk_valid;
+	u32 chunk_id_ok;
+	u32 chunk_in_range;
+	u32 chunk_wrongly_deleted;
+	u32 chunk_valid;
 
 	if (!obj)
 		return;
@@ -347,7 +347,7 @@ void yaffs_verify_obj(yaffs_obj_t *obj)
 	if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
 		yaffs_ext_tags tags;
 		yaffs_obj_header *oh;
-		__u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
+		u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
 		oh = (yaffs_obj_header *)buffer;
 
diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c
index 3bd5aea..8230537 100644
--- a/yaffs_vfs_multi.c
+++ b/yaffs_vfs_multi.c
@@ -1309,7 +1309,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
 
 
 		/* Check mode against the variant type and attempt to repair if broken. */
-		__u32 mode = obj->yst_mode;
+		u32 mode = obj->yst_mode;
 		switch (obj->variant_type) {
 		case YAFFS_OBJECT_TYPE_FILE:
 			if (!S_ISREG(mode)) {
diff --git a/yaffs_vfs_single.c b/yaffs_vfs_single.c
index 63f0e3d..9bceaa3 100644
--- a/yaffs_vfs_single.c
+++ b/yaffs_vfs_single.c
@@ -926,7 +926,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
 
 
 		/* Check mode against the variant type and attempt to repair if broken. */
-		__u32 mode = obj->yst_mode;
+		u32 mode = obj->yst_mode;
 		switch (obj->variant_type) {
 		case YAFFS_OBJECT_TYPE_FILE:
 			if (!S_ISREG(mode)) {
diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c
index 21933dc..8a1712c 100644
--- a/yaffs_yaffs1.c
+++ b/yaffs_yaffs1.c
@@ -31,7 +31,7 @@ int yaffs1_scan(yaffs_dev_t *dev)
 	yaffs_block_state_t state;
 	yaffs_obj_t *hard_list = NULL;
 	yaffs_block_info_t *bi;
-	__u32 seq_number;
+	u32 seq_number;
 	yaffs_obj_header *oh;
 	yaffs_obj_t *in;
 	yaffs_obj_t *parent;
@@ -41,7 +41,7 @@ int yaffs1_scan(yaffs_dev_t *dev)
 	struct yaffs_shadow_fixer_s *shadow_fixers = NULL;
 
 
-	__u8 *chunk_data;
+	u8 *chunk_data;
 
 
 
diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c
index 76623ad..12c0830 100644
--- a/yaffs_yaffs2.c
+++ b/yaffs_yaffs2.c
@@ -140,12 +140,12 @@ int yaffs_block_ok_for_gc(yaffs_dev_t *dev,
  * periodically finds the oldest full block by sequence number for refreshing.
  * Only for yaffs2.
  */
-__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev)
+u32 yaffs2_find_refresh_block(yaffs_dev_t *dev)
 {
-	__u32 b ;
+	u32 b ;
 
-	__u32 oldest = 0;
-	__u32 oldest_seq = 0;
+	u32 oldest = 0;
+	u32 oldest_seq = 0;
 
 	yaffs_block_info_t *bi;
 
@@ -229,10 +229,10 @@ int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev)
 		n_bytes += sizeof(yaffs_checkpt_dev_t);
 		n_bytes += dev_blocks * sizeof(yaffs_block_info_t);
 		n_bytes += dev_blocks * dev->chunk_bit_stride;
-		n_bytes += (sizeof(yaffs_checkpt_obj_t) + sizeof(__u32)) * (dev->n_obj);
-		n_bytes += (dev->tnode_size + sizeof(__u32)) * (dev->n_tnodes);
+		n_bytes += (sizeof(yaffs_checkpt_obj_t) + sizeof(u32)) * (dev->n_obj);
+		n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes);
 		n_bytes += sizeof(yaffs_checkpt_validty_t);
-		n_bytes += sizeof(__u32); /* checksum*/
+		n_bytes += sizeof(u32); /* checksum*/
 
 		/* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
 
@@ -313,8 +313,8 @@ static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev,
 static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev)
 {
 	yaffs_checkpt_dev_t cp;
-	__u32 n_bytes;
-	__u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
+	u32 n_bytes;
+	u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
 
 	int ok;
 
@@ -342,8 +342,8 @@ static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev)
 static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev)
 {
 	yaffs_checkpt_dev_t cp;
-	__u32 n_bytes;
-	__u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
+	u32 n_bytes;
+	u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
 
 	int ok;
 
@@ -452,7 +452,7 @@ static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp)
 
 
 static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
-					__u32 level, int chunk_offset)
+					u32 level, int chunk_offset)
 {
 	int i;
 	yaffs_dev_t *dev = in->my_dev;
@@ -470,7 +470,7 @@ static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
 				}
 			}
 		} else if (level == 0) {
-			__u32 base_offset = chunk_offset <<  YAFFS_TNODES_LEVEL0_BITS;
+			u32 base_offset = chunk_offset <<  YAFFS_TNODES_LEVEL0_BITS;
 			ok = (yaffs2_checkpt_wr(dev, &base_offset, sizeof(base_offset)) == 
 			        sizeof(base_offset));
 			if (ok)
@@ -484,7 +484,7 @@ static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
 
 static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj)
 {
-	__u32 end_marker = ~0;
+	u32 end_marker = ~0;
 	int ok = 1;
 
 	if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) {
@@ -502,7 +502,7 @@ static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj)
 
 static int yaffs2_rd_checkpt_tnodes(yaffs_obj_t *obj)
 {
-	__u32 base_chunk;
+	u32 base_chunk;
 	int ok = 1;
 	yaffs_dev_t *dev = obj->my_dev;
 	yaffs_file_s *file_stuct_ptr = &obj->variant.file_variant;
@@ -632,7 +632,7 @@ static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev)
 
 static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev)
 {
-	__u32 checkpt_sum;
+	u32 checkpt_sum;
 	int ok;
 
 	yaffs2_get_checkpt_sum(dev, &checkpt_sum);
@@ -647,8 +647,8 @@ static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev)
 
 static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev)
 {
-	__u32 checkpt_sum0;
-	__u32 checkpt_sum1;
+	u32 checkpt_sum0;
+	u32 checkpt_sum1;
 	int ok;
 
 	yaffs2_get_checkpt_sum(dev, &checkpt_sum0);
@@ -820,7 +820,7 @@ int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size)
 	int result = YAFFS_OK;
 	yaffs_dev_t *dev = NULL;
 
-	__u8 *local_buffer = NULL;
+	u8 *local_buffer = NULL;
 	
 	int small_increase_ok = 0;
 	
@@ -926,13 +926,13 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev)
 	yaffs_block_state_t state;
 	yaffs_obj_t *hard_list = NULL;
 	yaffs_block_info_t *bi;
-	__u32 seq_number;
+	u32 seq_number;
 	yaffs_obj_header *oh;
 	yaffs_obj_t *in;
 	yaffs_obj_t *parent;
 	int n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
 	int is_unlinked;
-	__u8 *chunk_data;
+	u8 *chunk_data;
 
 	int file_size;
 	int is_shrink;
@@ -1146,7 +1146,7 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev)
 			} else if (tags.chunk_id > 0) {
 				/* chunk_id > 0 so it is a data chunk... */
 				unsigned int endpos;
-				__u32 chunk_base =
+				u32 chunk_base =
 				    (tags.chunk_id - 1) * dev->data_bytes_per_chunk;
 
 				found_chunks = 1;
@@ -1262,10 +1262,10 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev)
 					       oh->type == YAFFS_OBJECT_TYPE_FILE) ||
 					      (tags.extra_available  &&
 					       tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) {
-						__u32 this_size =
+						u32 this_size =
 						    (oh) ? oh->file_size : tags.
 						    extra_length;
-						__u32 parent_obj_id =
+						u32 parent_obj_id =
 						    (oh) ? oh->
 						    parent_obj_id : tags.
 						    extra_parent_id;
diff --git a/yaffs_yaffs2.h b/yaffs_yaffs2.h
index ce1fa9d..dce9042 100644
--- a/yaffs_yaffs2.h
+++ b/yaffs_yaffs2.h
@@ -23,7 +23,7 @@ void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev);
 void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi);
 void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi);
 int yaffs_block_ok_for_gc(yaffs_dev_t *dev, yaffs_block_info_t *bi);
-__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev);
+u32 yaffs2_find_refresh_block(yaffs_dev_t *dev);
 int yaffs2_checkpt_required(yaffs_dev_t *dev);
 int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev);