int flash_write_buf(WORD sector, int offset, byte *buffer, int numbytes) { int ret = -1; int i; unsigned char *p = flash_get_memptr(sector) + offset; /* After writing the flash block, compare the contents to the source * buffer. Try to write the sector successfully up to three times. */ //Pan.Liu //1. Erase flash //2. program flash //3. Verify for( i = 0; i < 3; i++ ) { ret = flash_write(sector, offset, buffer, numbytes); if( !memcmp( p, buffer, numbytes ) ) break; #ifdef DEBUGMSG //Pan.liu for debuging printk("****Erase flash and rewrite again!****\n"); printk("Error sector number:%d offset:%x ptr:%x\n",sector,offset,p); flash_sector_erase_int(sector); #endif ret = -1; } if( ret == -1 ) printk( "Flash write error. Verify failed\n" ); return( ret ); }
// Set the pTempBuf to flash from start_blk for num_blks // return: // 0 -- ok // -1 -- fail static int setSharedBlks(int start_blk, int num_blks, char *pTempBuf) { int i = 0; int sect_size = 0; int sts = 0; char *pBuf = pTempBuf; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30) /* not allowed to ignore the return of down_interruptible in new kernel */ if (down_interruptible(&semflash) ) { return -1; } #else down_interruptible(&semflash); #endif for (i = start_blk; i < (start_blk + num_blks); i++) { sect_size = flash_get_sector_size((unsigned short) i); flash_sector_erase_int(i); if (flash_write_buf(i, 0, pBuf, sect_size) != sect_size) { printk("Error writing flash sector %d.", i); sts = -1; break; } #if defined(DEBUG_FLASH) printk("setShareBlks: blk=%d, sect_size=%d\n", i, sect_size); #endif pBuf += sect_size; } up(&semflash); return sts; }
static int cfi_flash_write_buf(unsigned short sector, int offset, unsigned char *buffer, int numbytes) { int ret = FLASH_API_ERROR; int i; unsigned char *p = cfi_flash_get_memptr(sector) + offset; /* After writing the flash block, compare the contents to the source * buffer. Try to write the sector successfully up to three times. */ for( i = 0; i < 3; i++ ) { ret = cfi_flash_write(sector, offset, buffer, numbytes); if( !memcmp( p, buffer, numbytes ) ) break; /* Erase and try again */ flash_sector_erase_int(sector); ret = FLASH_API_ERROR; } if( ret == FLASH_API_ERROR ) printk( "Flash write error. Verify failed\n" ); return( ret ); }
void main(void) { byte test; byte manuf_id; word device_id; byte far *str; word test2,i; dword sec_size=0; long count=0; printf("Beginning test.....\n\n"); /* First, poke around the memory map to see what kind of flash is installed in the socket...assume a DL800B */ /* The purpose of init_flash is to perform any system memory mapping required, and to set up pointers to those region(s). init_flash() also selects the proper sector organization table defined in flash.c Note: init_flash() will need to be provided by users of the flash.c routines */ if(!init_flash(AM29DL800B)) { exit(1); } /* Verify the manufacturer code is indeed 0x01 for AMD */ manuf_id = flash_get_manuf_code(0); switch(manuf_id) { case AMDPART: printf("AMD Flash found in socket...\n"); break; default: printf("Non AMD part found in socket...exiting.\n"); exit(1); break; } /* Poll the device id so that the proper sector layout table is used for the device in the socket */ printf("Polling part for Device ID..."); /* Retrieve the device ID for this AMD flash part. All device id's are stored in flash.h */ device_id = flash_get_device_id(0); switch(device_id) { case ID_AM29DL800T: printf("found an Am29DL800T\n"); if(!init_flash(AM29DL800T)) exit(1); break; case ID_AM29DL800B: printf("found an Am29DL800B\n"); if(!init_flash(AM29DL800B)) exit(1); break; case ID_AM29LV800T: printf("found an Am29LV800T\n"); if(!init_flash(AM29LV800T)) exit(1); break; case ID_AM29LV800B: printf("found an Am29LV800B\n"); if(!init_flash(AM29LV800B)) exit(1); break; case ID_AM29LV160B: printf( "found an Am29LV160B\n"); if(!init_flash(AM29LV160B)) exit(1); break; case ID_AM29LV400B: printf( "found an Am29LV400B\n"); if(!init_flash(AM29LV400B)) exit(1); break; default: printf("error reading Device ID...exiting.\n"); exit(1); break; } randomize(); /* flash_get_status uses DQ7, DQ5, and DQ2 polling to get the status of the flash. All status codes are defined in flash.h Also note that for the DL parts, status is bank dependent */ printf("Checking current flash status...flash is "); test = flash_get_status(0); switch(test) { case STATUS_READY: printf("[Ready]\n");break; case STATUS_BUSY: printf("[Busy]\n");break; case STATUS_ERSUSP: printf("[Erase Suspended]\n");break; case STATUS_TIMEOUT: printf("[Timed Out]\n");break; default: printf("Error!\n"); exit(1);break; } printf("Performing API tests...\n\n"); /* flash_sector_erase_int() is the function which erases a single sector. It is different from flash_sector_erase() in that it 'interrupts' execution of the program until the erase is completed. For erasing a sector without pausing use flash_sector_erase(). */ flash_reset(); /* Quick safe check */ printf("Erasing sector 8..."); flash_sector_erase_int(8); printf("done.\n"); printf("Verifying erase..."); flash_get_sector_size(8, &sec_size); /* Get # of byte */ /* A simple test which reads every word from the flash, and checks to see if every word contains the data 0xFFFF, which indicates an erased word. */ for (count=0 ; count < (sec_size/2); count++) { if(count%2048 == 0) printf("."); /*print out some dots to show the program hasn't frozen */ if (flash_read_word(8,count) != 0xFFFF) { printf("erase not completed sucessfully!\n"); exit(1); } } printf("erase successful.\n"); /* flash_write_word() takes word data and programs it to the flash at the indicated offset. Note that this data must be *word aligned*, or else programming errors can result. It is also good to check the word for 0xFFFF data before programming. */ printf("Writing a single word [0xABCD]\n"); flash_write_word(8,0,0xABCD); /* flash_read_word() returns a single word of data at the specified sector/offset . Must also be word aligned */ printf("After write(0xABCD): %4x\n", flash_read_word(8,0)); str = (byte far *) calloc(0x7FFF, sizeof(byte)); /* Randomize the string with random ASCII characters */ for(i=0; i<0x7FFF; i++) { str[i] = (byte) (41 + (rand() % 26)); } printf("Erasing sector 9..."); flash_sector_erase_int(9); printf("done.\n"); /* flash_write_string() is a function to program bulk data from a C buffer. It is a bit faster than looping techniques using flash_write_word() because function overhead is eliminated. */ printf("Writing 32 kbyte string..."); flash_write_string(9,0,str,0x7FFE); printf("done.\n\n"); printf("Testing erase suspend\n"); printf("Beginning erase...\n"); /* This is an example of flash_sector_erase(). Note that the program will simply issue the command, and execution will continue while the flash is erasing. */ flash_sector_erase(10); /* flash_erase_suspend will suspend an erase in progress. The application can then do any reading of data from that sector, or another sector. */ printf("Suspending erase..."); flash_erase_suspend(10); printf("done.\n"); /* The current flash status should now be STATUS_ERSUSP */ printf("Checking current flash status...flash is "); test = flash_get_status(10); switch(test) { case STATUS_READY: printf("[Ready]\n");break; case STATUS_BUSY: printf("[Busy]\n");break; case STATUS_ERSUSP: printf("[Erase Suspended]\n");break; case STATUS_TIMEOUT: printf("[Timed Out]\n");break; default: printf("Error!\n"); exit(1);break; } /* Now we can resume the erase previously suspended */ printf("Resuming erase after status check.."); flash_erase_resume(10); printf("done.\n"); /* Now for a test of unlock bypass mode */ /* Unlock bypass allows for faster programming of flash data in that the number of required bus cycles is cut in half. The most benefit can be realized when programming large amounts of data using flash_write_string_ub() */ printf("Entering unlock bypass mode...\n"); flash_sector_erase_int(11); flash_ub(11); /* Enter unlock bypass mode */ printf("Programming a string in unlock bypass mode.."); flash_write_string_ub(11,0,str,0x7FFE); printf("done.\n"); printf("Exiting unlock bypass mode..\n"); flash_reset_ub(); flash_reset(); /* Last thing is a quick loop through all the sectors to check for sector protection. */ printf("\nVerifying sector protection...\n"); flash_get_numsectors(&test2); printf("This device contains %3i sectors: \n", test2); for(i=0; i < test2; i++) { test = flash_sector_protect_verify(i); flash_get_sector_size(i, &size); printf("Verify sector #%2i, size [%-5li]: ", i, size); if (test == 0x01) printf("sector is protected[%2i].\n", test); else printf("sector is not protected[%2i].\n", test); flash_reset(); } printf("Test drive done!\n"); free(str); exit(0); }
// flash bcm image // return: // 0 - ok // !0 - the sector number fail to be flashed (should not be 0) int kerSysBcmImageSet( int flash_start_addr, char *string, int size) { int sts; int sect_size; int blk_start; int savedSize = size; int whole_image = 0; if( bootFromNand ) return( nandImageSet( flash_start_addr, string, size ) ); if (flash_start_addr == FLASH_BASE) whole_image = 1; #if defined(DEBUG_FLASH) printk("kerSysBcmImageSet: flash_start_addr=0x%x string=%p len=%d whole_image=%d\n", flash_start_addr, string, size, whole_image); #endif blk_start = flash_get_blk(flash_start_addr); if( blk_start < 0 ) return( -1 ); // Disable other tasks from this point on #if defined(CONFIG_SMP) smp_send_stop(); udelay(20); #endif local_bh_disable(); /* write image to flash memory */ do { sect_size = flash_get_sector_size(blk_start); flash_sector_erase_int(blk_start); // erase blk before flash if (sect_size > size) { if (size & 1) size++; sect_size = size; } if (flash_write_buf(blk_start, 0, string, sect_size) != sect_size) { break; } printk("."); blk_start++; string += sect_size; size -= sect_size; } while (size > 0); if (whole_image && savedSize > fInfo.flash_rootfs_start_offset) { // If flashing a whole image, erase to end of flash. int total_blks = flash_get_numsectors(); while( blk_start < total_blks ) { flash_sector_erase_int(blk_start); printk("."); blk_start++; } } printk("\n\n"); if( size == 0 ) sts = 0; // ok else sts = blk_start; // failed to flash this sector local_bh_enable(); return sts; }