fix nand writing

12 files changed, 227 insertions, 81 deletions

diff --git a/.gitignore b/.gitignore
index 2cfddc28..2ad3fa0c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -97,3 +97,5 @@ bImage
 *.swp
 rootfs.cpio.gz
 drivers/arisc/binary/arisc
+
+*-hmod/
diff --git a/Makefile b/Makefile
index 0f1e1d7a..8f1793fe 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 3
 PATCHLEVEL = 4
 SUBLEVEL = 112
-EXTRAVERSION = .18-madmonkey
+EXTRAVERSION = .19-madmonkey
 NAME = Saber-toothed Squirrel
 
 # *DOCUMENTATION*
diff --git a/arch/arm/configs/sun_nontendocm_defconfig b/arch/arm/configs/sun_nontendocm_defconfig
index 58728f00..1a46a77e 100644
--- a/arch/arm/configs/sun_nontendocm_defconfig
+++ b/arch/arm/configs/sun_nontendocm_defconfig
@@ -98,8 +98,11 @@ CONFIG_BT_HCIBCM203X=m
 CONFIG_BT_MRVL=m
 CONFIG_BT_ATH3K=m
 CONFIG_CFG80211=m
-# CONFIG_CFG80211_DEFAULT_PS is not set
+CONFIG_CFG80211_INTERNAL_REGDB=y
+CONFIG_CFG80211_ALLOW_RECONNECT=y
 CONFIG_MAC80211=m
+CONFIG_MAC80211_RC_PID=y
+CONFIG_MAC80211_RC_DEFAULT_PID=y
 CONFIG_MAC80211_LEDS=y
 CONFIG_RFKILL=y
 CONFIG_SUNXI_ARISC=y
@@ -159,6 +162,7 @@ CONFIG_RT2800USB_RT53XX=y
 CONFIG_RTL8192CU=m
 # CONFIG_RTLWIFI_DEBUG is not set
 CONFIG_RTL8188EU=m
+CONFIG_RTL8192EU=m
 CONFIG_RTL8812AU=m
 CONFIG_INPUT_POLLDEV=y
 # CONFIG_INPUT_MOUSEDEV_PSAUX is not set
diff --git a/build_all.sh b/build_all.sh
index b2deb25d..7a36d82e 100755
--- a/build_all.sh
+++ b/build_all.sh
@@ -48,6 +48,7 @@ echo "return 0" > "$instdir/uninstall"
 echo "no-uninstall" >> "$instdir/uninstall"
 
 find "$instdir" -type f -name "*.ko" -print0 | xargs -0 -n1 "${CROSS_COMPILE}strip" --strip-unneeded
+echo "somebody set up us the bomb"
 exit 0
 makepack "$instdir"
 rm -rf "$instdir"
diff --git a/drivers/block/nand/lib/src/phy/nand_info_init.c b/drivers/block/nand/lib/src/phy/nand_info_init.c
index b0db605f..3977984d 100644
--- a/drivers/block/nand/lib/src/phy/nand_info_init.c
+++ b/drivers/block/nand/lib/src/phy/nand_info_init.c
@@ -298,6 +298,8 @@ int test_mbr(uchar* data)
     mbr_data->array[1].addr = 327680;
     mbr_data->array[1].len = 0;
     mbr_data->array[1].user_type = 0;
+
+    return 0;
 }
 
 /*****************************************************************************
@@ -424,6 +426,7 @@ int print_factory_block_table(struct _nand_info*nand_info)
 	    }
 	}
 
+    return 0;
 }
 
 /*****************************************************************************
diff --git a/drivers/block/nand/lib/src/phy_v2/nand_info_init_v2.c b/drivers/block/nand/lib/src/phy_v2/nand_info_init_v2.c
index 289f0d8f..c61ba23f 100644
--- a/drivers/block/nand/lib/src/phy_v2/nand_info_init_v2.c
+++ b/drivers/block/nand/lib/src/phy_v2/nand_info_init_v2.c
@@ -86,7 +86,7 @@ int nand_info_init_v3(struct _nand_info*nand_info,uchar chip,uint16 start_block,
     unsigned int nDieNum,nBlkNum,nPage,i,nouse;
     unsigned int ret;
     struct _boot_info* boot;
-    unsigned int start_block_real;
+    unsigned int start_block_real=0;
 
     boot = nand_info->boot;
 
@@ -1236,6 +1236,7 @@ int print_factory_block_table_v2(struct _nand_info*nand_info)
         }
     }
 
+    return 0;
 }
 
 /*****************************************************************************
@@ -1936,7 +1937,6 @@ int build_all_phy_partition_v2(struct _nand_info*nand_info)
 *****************************************************************************/
 int print_mbr_data(uchar* mbr_data)
 {
-    
     PARTITION_MBR* mbr = (PARTITION_MBR*)mbr_data;
     NAND_PARTITION* part;
     NFTL_ERR("[NE]mbr->PartCount: %d!\n",mbr->PartCount);
@@ -1953,4 +1953,6 @@ int print_mbr_data(uchar* mbr_data)
         NFTL_ERR("[NE]part->keydata: %d !\n",part->keydata);
         NFTL_ERR("[NE]part->ro: %d !\n",part->ro);
     }
+
+    return 0;
 }
diff --git a/drivers/block/nand/lib/src/physic/nand_format.c b/drivers/block/nand/lib/src/physic/nand_format.c
index 84e8458e..6b21726c 100644
--- a/drivers/block/nand/lib/src/physic/nand_format.c
+++ b/drivers/block/nand/lib/src/physic/nand_format.c
@@ -833,7 +833,7 @@ __s32 PHY_VirtualBlockErase(__u32 nDieNum, __u32 nBlkNum)
 
 __s32 FMT_NandSorting_IsBadblk(__u32 nDieNum, __u32 nBlkNum, __u32 nPage)
 {
-	__s32 result;
+	__s32 result = 0;
 	__u32 bad_flag = 0;
 	__u32 tmpBnkNum,tmpPage;
 	struct __PhysicOpPara_t tmpPhyPage;
diff --git a/drivers/block/nand/lib/src/physic/nand_phy.c b/drivers/block/nand/lib/src/physic/nand_phy.c
index 6a697c7d..0699d7f2 100644
--- a/drivers/block/nand/lib/src/physic/nand_phy.c
+++ b/drivers/block/nand/lib/src/physic/nand_phy.c
@@ -569,7 +569,7 @@ __s32 _read_single_page_spare(struct boot_physical_param *readop,__u8 dma_wait_m
 	__u8 default_value[16];
 	__u8 addr[5];
 	NFC_CMD_LIST cmd_list[4];
-	__u32 list_len,i,n,m;
+	__u32 list_len,i,n,m = 0;
 	__u32 free_page_flag = 0;
 	//__s32 err, cnt;
 
@@ -1356,7 +1356,7 @@ __s32  PHY_BlockErase(struct __PhysicOpPara_t *pBlkAdr)
 	__u32 rb;
 	__u8 addr[4][5];
 	__s32 ret=0;
-	__u32 plane_cnt,i,list_len;
+	__u32 plane_cnt,i,list_len=0;
 	__u32 block_in_chip;
 	NFC_CMD_LIST cmd_list[8];
 
@@ -1444,7 +1444,7 @@ __s32 _read_sectors(struct boot_physical_param *readop,__u8 dma_wait_mode)
 	__u8 default_value[16];
 	__u8 addr[5];
 	NFC_CMD_LIST cmd_list[4];
-	__u32 list_len,i,n,m;
+	__u32 list_len,i,n,m=0;
 	__u8 *data_buf;
 	__u32 data_size;
 
@@ -2100,7 +2100,7 @@ __s32 _read_sectors_first(struct boot_physical_param *readop,__u8 dma_wait_mode)
 	__u8 default_value[16];
 	__u8 addr[5];
 	NFC_CMD_LIST cmd_list[4];
-	__u32 list_len,i,n,m;
+	__u32 list_len,i,n,m=0;
 	__u8 *data_buf;
 	__u32 data_size;
 
@@ -2509,7 +2509,7 @@ __s32 _read_sectors_v2_first(struct boot_physical_param *readop, __u8 dma_wait_m
 	__u8 default_value[16];
 	__u8 addr[5];
 	NFC_CMD_LIST cmd_list[4];
-	__u32 list_len,i,n,m;
+	__u32 list_len,i,n,m=0;
 	//__u8 *data_buf;
 
 	//data_buf = PageCachePool.TmpPageCache;
diff --git a/drivers/block/nand/lib/src/physic/nand_physic_interface.c b/drivers/block/nand/lib/src/physic/nand_physic_interface.c
index feaddbc3..9ad80b52 100644
--- a/drivers/block/nand/lib/src/physic/nand_physic_interface.c
+++ b/drivers/block/nand/lib/src/physic/nand_physic_interface.c
@@ -1284,7 +1284,7 @@ int nand_check_uboot(unsigned char *buf,unsigned char *sbuf)
 *****************************************************************************/
 int nand_read_nboot_one(unsigned char *buf,unsigned int len,unsigned int counter)
 {
-
+    return 0;
 }
 
 /*****************************************************************************
@@ -1296,7 +1296,7 @@ int nand_read_nboot_one(unsigned char *buf,unsigned int len,unsigned int counter
 *****************************************************************************/
 int nand_write_nboot_one(unsigned char *buf,unsigned int len,unsigned int counter)
 {
-
+    return 0;
 }
 
 /*****************************************************************************
diff --git a/drivers/block/nand/lib/src/physic/nand_simple_r.c b/drivers/block/nand/lib/src/physic/nand_simple_r.c
index dfda7ce0..72838f95 100644
--- a/drivers/block/nand/lib/src/physic/nand_simple_r.c
+++ b/drivers/block/nand/lib/src/physic/nand_simple_r.c
@@ -1543,7 +1543,7 @@ __s32 _read_single_page(struct boot_physical_param *readop,__u8 dma_wait_mode)
 	__u8 addr[5];
 	NFC_CMD_LIST cmd_list[4];
 	__u32 list_len;
-	__s32 i, n,m; //, err, cnt;
+	__s32 i, n,m=0; //, err, cnt;
 
 	for (i=0; i<4*64; i++)
 		sparebuf[i] = 0x55;
@@ -3304,7 +3304,7 @@ int _get_secure_uboot_offset(void *buf)
 
 int _get_uboot_offset(int sys_mode, void *buf)
 {
-	int length;
+	int length = 0;
 
 	if(0 == sys_mode)
 		length = _get_normal_uboot_offset(buf);
@@ -3348,7 +3348,7 @@ int _is_secure_uboot_magic(void *buf)
 
 int _is_uboot_magic(int sys_mode, void *buf)
 {
-	int ret;
+	int ret=0;
 
 	if(0 == sys_mode)
 		ret = _is_normal_uboot_magic(buf);
@@ -3654,6 +3654,7 @@ __s32 Physic_Info_Get_One_Copy(__u32 start_block,__u32 pages_offset,__u32 *block
 	if(tempbuf1)
 		FREE(tempbuf1,size_per_page);
 
+	return 0;
 }
 
 __s32 Clean_Physic_Info(void)
diff --git a/drivers/block/nand/lib/src/physic/nfc_w.c b/drivers/block/nand/lib/src/physic/nfc_w.c
index a1772e17..cd93f8b3 100644
--- a/drivers/block/nand/lib/src/physic/nfc_w.c
+++ b/drivers/block/nand/lib/src/physic/nfc_w.c
@@ -1801,7 +1801,7 @@ __s32 _read_in_page_mode_1st_1K_normal_ecc(NFC_CMD_LIST  *rcmd,void *mainbuf,voi
 		NDFC_WRITE_REG_SECTOR_NUM(data_size/1024); //1024-->4096
 	} else if (NdfcVersion == NDFC_VERSION_V2) {
 		/*set NFC_REG_BLOCK_MASK*/
-		NDFC_WRITE_REG_BLOCK_MASK( ( 0x1U<<(data_size/1024) -1) ); //0x1U-->0xF
+		NDFC_WRITE_REG_BLOCK_MASK( ( (0x1U<<(data_size/1024)) -1) ); //0x1U-->0xF
 	} else
 		PHY_ERR("_read_in_page_mode_1st_1K_normal_ecc: wrong ndfc version, %d\n", NdfcVersion);
 
diff --git a/drivers/block/nand/nfd/nand_blk.c b/drivers/block/nand/nfd/nand_blk.c
index 7a28cede..566690b7 100644
--- a/drivers/block/nand/nfd/nand_blk.c
+++ b/drivers/block/nand/nfd/nand_blk.c
@@ -17,13 +17,48 @@ static unsigned int dragonboard_test_flag = 0;
 
 //#define NAND_IO_RESPONSE_TEST
 
-struct burn_param_t{
-    void* buffer;
-    long length;
-    long offset;
-    long unused;
+#pragma pack(push,1)
+
+struct burn_param_b
+{
+    void*buffer;
+    uint32_t length;
 };
 
+struct burn_param_t
+{
+    void*buffer;
+    uint32_t length;
+    uint32_t offset;
+    union
+    {
+        uint32_t flags;
+        struct
+        {
+            uint32_t raw:2;
+            uint32_t getoob:1;
+            uint32_t unused:29;
+        } in;
+        struct
+        {
+            uint32_t unused;
+        } out;
+    };
+    struct burn_param_b oob;
+    uint32_t badblocks;
+};
+
+struct hakchi_nandinfo
+{
+    char str[8];
+    __u32 size;
+    __u32 page_size;
+    __u32 pages_per_block;
+    __u32 block_count;
+};
+
+#pragma pack(pop)
+
 /*****************************************************************************/
 
 extern int NAND_BurnBoot0(uint length, void *buf);
@@ -399,15 +434,91 @@ extern __s32 NAND_GetBlkCntOfDie(void);
 
 extern int NAND_ReadBoot0(unsigned int length,void*buf);
 
-static uint NAND_UbootSimpleRead(uint start, uint blocks, void* buffer)
+int mark_bad_block( uint chip_num, uint blk_num)
+{
+    boot_flash_info_t info;
+    struct boot_physical_param para;
+    unsigned char oob_buf[OOB_BUF_SIZE];
+    unsigned char* page_buf;
+    int page_index[4];
+    uint page_with_bad_block, page_per_block;
+    uint i;
+    int mark_err_flag = -1;
+    if( NAND_GetFlashInfo( &info ))
+    {
+        nand_dbg_err("get flash info failed.\n");
+        return -1;
+    }
+    //cal nand parameters
+    //page_buf = (unsigned char*)(MARK_BAD_BLK_BUF_ADR);
+    page_buf = (unsigned char*)kmalloc(32 * 1024, GFP_KERNEL);
+    if(!page_buf)
+    {
+        nand_dbg_err("malloc memory for page buf fail\n");
+        return -1;
+    }
+    memset(page_buf,0xff,32*1024);
+    page_with_bad_block = info.pagewithbadflag;
+    page_per_block = info.blocksize/info.pagesize;
+    //read the first, second, last, last-1 page for check bad blocks
+    page_index[0] = 0;
+    page_index[1] = 0xEE;
+    page_index[2] = 0xEE;
+    page_index[3] = 0xEE;
+    switch(page_with_bad_block & 0x03)
+    {
+    case 0x00:
+        //the bad block flag is in the first page, same as the logical information, just read 1 page is ok
+        break;
+    case 0x01:
+        //the bad block flag is in the first page or the second page, need read the first page and the second page
+        page_index[1] = 1;
+        break;
+    case 0x02:
+        //the bad block flag is in the last page, need read the first page and the last page
+        page_index[1] = page_per_block - 1;
+        break;
+    case 0x03:
+        //the bad block flag is in the last 2 page, so, need read the first page, the last page and the last-1 page
+        page_index[1] = page_per_block - 1;
+        page_index[2] = page_per_block - 2;
+        break;
+    }
+    for(i =0; i<4; i++)
+    {
+        oob_buf[0] = 0x0;
+        oob_buf[1] = 0x1;
+        oob_buf[2] = 0x2;
+        oob_buf[3] = 0x3;
+        oob_buf[4] = 0x89;
+        oob_buf[5] = 0xab;
+        oob_buf[6] = 0xcd;
+        oob_buf[7] = 0xef;
+        para.chip = chip_num;
+        para.block = blk_num;
+        para.page = page_index[i];
+        para.mainbuf = page_buf;
+        para.oobbuf = oob_buf;
+        if(para.page == 0xEE)
+            continue;
+        PHY_SimpleWrite( &para );
+        PHY_SimpleRead( &para );
+        if(oob_buf[0] !=0xff)
+            mark_err_flag = 0;
+    }
+    kfree(page_buf);
+    return mark_err_flag;
+}
+
+static uint NAND_UbootSimpleRead(uint start, uint blocks, void* buffer, struct burn_param_t*burn_param)
 {
-    __u32 i, k, block;
+    __u32 i, k, block, badblock;
     __u32 page_size, pages_per_block, block_size, block_count;
     unsigned char oob_buf[OOB_BUF_SIZE];
     struct boot_physical_param para;
 
-    for (i = 0; i < 32; i++)
-        oob_buf[i] = 0xff;
+    const int raw=burn_param->in.raw;
+    burn_param->flags=0;
 
     page_size = NAND_GetPageSize();
     pages_per_block = NAND_GetPageCntPerBlk();
@@ -417,6 +528,7 @@ static uint NAND_UbootSimpleRead(uint start, uint blocks, void* buffer)
     block = 0;
     for (i = start; i < block_count && block < blocks; i++)
     {
+        badblock=0;
         for (k = 0; k < pages_per_block; k++)
         {
             para.chip  = 0;
@@ -424,34 +536,48 @@ static uint NAND_UbootSimpleRead(uint start, uint blocks, void* buffer)
             para.page  = k;
             para.mainbuf = (void *) ((__u32)buffer + block * block_size + k * page_size);
             para.oobbuf = oob_buf;
+            memset(oob_buf,0xff,OOB_BUF_SIZE);
 
-            if (PHY_SimpleRead(&para) < 0 || oob_buf[0] != 0xff)
+            if(PHY_SimpleRead(&para)<0)
+            {
+                nand_dbg_err("Warning. Fail in read page %x in block %x.\n", k, i);
+                memset(para.mainbuf,'X',page_size);
+                badblock=1;
+            }
+            if(oob_buf[0]!=0xff)
             {
-                nand_dbg_err("Warning. Fail in read page %d in block %d.\n", k, i);
-                // retry to read data block from next NAND block
-                block--;
-                break;
+                badblock=1;
             }
+            if(badblock)
+            {
+                //0 - logical, 1 - break, 2 - read all pages, 3 - unused
+                if(raw<2)
+                    break;
+            }
+        }
+
+        if(badblock)
+        {
+            ++burn_param->badblocks;
+            if(raw==0)//retry to read data block on next NAND block
+                --block;
         }
 
         ++block;
     }
 
-    if (block < blocks)
-        return 0;
-
     return blocks;
 }
 
-static uint NAND_UbootSimpleWrite(uint start, uint blocks, void *buffer)
+static uint NAND_UbootSimpleWrite(uint start, uint blocks, void *buffer, struct burn_param_t*burn_param)
 {
-    __u32 i, k, block;
+    __u32 i, k, block, badblock;
     __u32 page_size, pages_per_block, block_size, block_count;
     unsigned char oob_buf[OOB_BUF_SIZE];
     struct boot_physical_param para;
 
-    for (i = 0; i < 32; i++)
-        oob_buf[i] = 0xff;
+    const int raw=burn_param->in.raw;
+    burn_param->flags=0;
 
     page_size = NAND_GetPageSize();
     pages_per_block = NAND_GetPageCntPerBlk();
@@ -465,11 +591,15 @@ static uint NAND_UbootSimpleWrite(uint start, uint blocks, void *buffer)
         para.block = i;
         if (PHY_SimpleErase(&para) < 0)
         {
-            nand_dbg_err("Fail in erasing block %d.\n", i);
-            //mark_bad_block(para.chip, para.block);
+            nand_dbg_err("Fail in erasing block %x.\n", i);
+            mark_bad_block(para.chip, para.block);
+            ++burn_param->badblocks;
+            if(raw>0)
+              ++block;
             continue;
         }
 
+        badblock=0;
         for (k = 0; k < pages_per_block; k++)
         {
             para.chip  = 0;
@@ -477,48 +607,47 @@ static uint NAND_UbootSimpleWrite(uint start, uint blocks, void *buffer)
             para.page  = k;
             para.mainbuf = (void *) ((__u32)buffer + block * block_size + k * page_size);
             para.oobbuf = oob_buf;
+            memset(oob_buf,0xff,OOB_BUF_SIZE);
 
             if (PHY_SimpleWrite(&para) < 0)
             {
-                nand_dbg_err("Warning. Fail in write page %d in block %d.\n", k, i);
-                //mark_bad_block(para.chip, para.block);
-                // retry to write data block on next NAND block
-                block--;
-                break;
+                nand_dbg_err("Warning. Fail in write page %x in block %x.\n", k, i);
+                badblock=1;
+                //0 - logical, 1 - break, 2 - write all pages, 3 - unused
+                if(raw<2)
+                    break;
             }
         }
 
+        if(badblock)
+        {
+            mark_bad_block(para.chip, para.block);
+            ++burn_param->badblocks;
+            if(raw==0)//retry to write data block on next NAND block
+                --block;
+        }
+
         ++block;
     }
 
-    if (block < blocks)
-        return 0;
-
     return blocks;
 }
 
-struct hakchi_nandinfo
-{
-    char str[8];
-    __u32 size;
-    __u32 page_size;
-    __u32 pages_per_block;
-    __u32 block_count;
-};
-
-static int NAND_ioctlRW(unsigned int cmd,unsigned int offset,unsigned int length,void*buf)
+static int NAND_ioctlRW(unsigned int cmd, struct burn_param_t*burn_param)
 {
     void*buffer;
     struct hakchi_nandinfo htn;
     __u32 block_size;
 
-    if(length==0)
+    burn_param->badblocks=0;
+
+    if(burn_param->length==0)
     {
         buffer=0;
     }
     else
     {
-        buffer=(void*)kmalloc(length,GFP_KERNEL);
+        buffer=(void*)kmalloc(burn_param->length,GFP_KERNEL);
         if(buffer==NULL)
         {
             nand_dbg_err("no memory!\n");
@@ -536,11 +665,12 @@ static int NAND_ioctlRW(unsigned int cmd,unsigned int offset,unsigned int length
     switch(cmd)
     {
     case hakchi_test:
+        burn_param->flags=0;
         htn.block_count=NAND_GetBlkCntPerChip();
         memcpy(htn.str,"hakchi",7);
         htn.str[7]=0;
         htn.size=sizeof(htn);
-        if(copy_to_user(buf,&htn,sizeof(htn)))
+        if(copy_to_user(burn_param->buffer,&htn,sizeof(htn)))
         {
             nand_dbg_err("copy_to_user error!\n");
             goto error;
@@ -548,18 +678,18 @@ static int NAND_ioctlRW(unsigned int cmd,unsigned int offset,unsigned int length
         break;
 
     case phy_read:
-        if((length%block_size)||(offset%block_size))
+        if((burn_param->length%block_size)||(burn_param->offset%block_size))
         {
-            nand_dbg_err("phy_read: requested %x at %x, block_size %x\n",length,offset,block_size);
+            nand_dbg_err("phy_read: requested %x at %x, block_size %x\n",burn_param->length,burn_param->offset,block_size);
             goto error;
         }
-        memset(buffer,0,length);
-        if(NAND_UbootSimpleRead(offset/block_size,length/block_size,buffer)!=(length/block_size))
+        memset(buffer,'X',burn_param->length);
+        if(NAND_UbootSimpleRead(burn_param->offset/block_size,burn_param->length/block_size,buffer,burn_param)!=(burn_param->length/block_size))
         {
-            nand_dbg_err("phy_read: requested %x at %x, cannot read\n",length,offset);
+            nand_dbg_err("phy_read: requested %x at %x, cannot read\n",burn_param->length,burn_param->offset);
             goto error;
         }
-        if(copy_to_user(buf,buffer,length))
+        if(copy_to_user(burn_param->buffer,buffer,burn_param->length))
         {
             nand_dbg_err("copy_to_user error!\n");
             goto error;
@@ -567,31 +697,31 @@ static int NAND_ioctlRW(unsigned int cmd,unsigned int offset,unsigned int length
         break;
 
     case phy_write:
-        if(copy_from_user(buffer,(const void*)buf,length))
+        if(copy_from_user(buffer,(const void*)burn_param->buffer,burn_param->length))
         {
             nand_dbg_err("copy_from_user error!\n");
             goto error;
         }
-        if((length%block_size)||(offset%block_size))
+        if((burn_param->length%block_size)||(burn_param->offset%block_size))
         {
-            nand_dbg_err("phy_write: requested %x at %x, block_size %x\n",length,offset,block_size);
+            nand_dbg_err("phy_write: requested %x at %x, block_size %x\n",burn_param->length,burn_param->offset,block_size);
             goto error;
         }
-        if(NAND_UbootSimpleWrite(offset/block_size,length/block_size,buffer)!=(length/block_size))
+        if(NAND_UbootSimpleWrite(burn_param->offset/block_size,burn_param->length/block_size,buffer,burn_param)!=(burn_param->length/block_size))
         {
-            nand_dbg_err("phy_write: requested %x at %x, cannot write\n",length,offset);
+            nand_dbg_err("phy_write: requested %x at %x, cannot write\n",burn_param->length,burn_param->offset);
             goto error;
         }
         break;
 
     case read_boot0:
-        memset(buffer,0,length);
-        if(NAND_ReadBoot0(length,buffer))
+        memset(buffer,'X',burn_param->length);
+        if(NAND_ReadBoot0(burn_param->length,buffer))
         {
-            nand_dbg_err("NAND_ReadBoot0() error!\n");
+            nand_dbg_err("NAND_ReadBoot0 error!\n");
             goto error;
         }
-        if(copy_to_user(buf,buffer,length))
+        if(copy_to_user(burn_param->buffer,buffer,burn_param->length))
         {
             nand_dbg_err("copy_to_user error!\n");
             goto error;
@@ -616,7 +746,7 @@ static int nand_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
     struct nand_blk_dev *dev = bdev->bd_disk->private_data;
     struct nand_blk_ops *nandr = dev->nandr;
     struct burn_param_t burn_param;
-    int ret=0;
+    int ret=-EFAULT;
 
     switch (cmd) {
     case BLKFLSBUF:
@@ -671,7 +801,7 @@ static int nand_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         if (copy_from_user(&burn_param, (const void*)arg, sizeof (struct burn_param_t)))
                 return -EFAULT;
 
-        if (0 == down_trylock(&(nandr->nand_ops_mutex)))
+        down(&(nandr->nand_ops_mutex));
         {
             IS_IDLE = 0;
             ret = NAND_BurnBoot0(burn_param.length, burn_param.buffer);
@@ -684,7 +814,7 @@ static int nand_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         if (copy_from_user(&burn_param, (const void*)arg, sizeof (struct burn_param_t)))
                 return -EFAULT;
 
-        if (0 == down_trylock(&(nandr->nand_ops_mutex)))
+        down(&(nandr->nand_ops_mutex));
         {
             IS_IDLE = 0;
             ret = NAND_BurnBoot1(burn_param.length, burn_param.buffer);
@@ -700,18 +830,19 @@ static int nand_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         if (copy_from_user(&burn_param, (const void*)arg, sizeof (struct burn_param_t)))
                 return -EFAULT;
 
-        if (0 == down_trylock(&(nandr->nand_ops_mutex)))
+        down(&(nandr->nand_ops_mutex));
         {
             IS_IDLE = 0;
-            ret = NAND_ioctlRW(cmd, burn_param.offset, burn_param.length, burn_param.buffer);
+            ret = NAND_ioctlRW(cmd, &burn_param);
             up(&(nandr->nand_ops_mutex));
             IS_IDLE = 1;
         }
+        copy_to_user((void*)arg, &burn_param, sizeof (struct burn_param_t));
         return ret;
 
     case DRAGON_BOARD_TEST:
 
-        if (0 == down_trylock(&(nandr->nand_ops_mutex)))
+        down(&(nandr->nand_ops_mutex));
         {
             IS_IDLE = 0;
             ret = NAND_DragonboardTest();
@@ -723,6 +854,8 @@ static int nand_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
     default:
         return -ENOTTY;
     }
+
+    return ret;
 }
 
 /*****************************************************************************