visus
/
teensy-serial-flash
Observar 1
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
104 Commits
1 Branch
Tag: 276d37396f
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 276d37396f
${ noResults }
teensy-serial-flash/examples/RawHardwareTest/RawHardwareTest.ino

508 linhas
14KB
Original Anotar Histórico 

  1. // RawHardwareTest - Check if a SPI Flash chip is compatible

  2. // with SerialFlash by performing many read and write tests

  3. // to its memory.

  4. //

  5. // The chip should be fully erased before running this test.

  6. // Use the EraseEverything to do a (slow) full chip erase.

  7. //

  8. // Normally you should NOT access the flash memory directly,

  9. // as this test program does.  You should create files and

  10. // read and write the files.  File creation allocates space

  11. // with program & erase boundaries within the chip, to allow

  12. // reading from any other files while a file is busy writing

  13. // or erasing (if created as erasable).

  14. //

  15. // If you discover an incompatible chip, please report it here:

  16. // https://github.com/PaulStoffregen/SerialFlash/issues

  17. // You MUST post the complete output of this program, and

  18. // the exact part number and manufacturer of the chip.

  19. 

  20. 

  21. #include <SerialFlash.h>

  22. #include <SPI.h>

  23. 

  24. const int FlashChipSelect = 6; // digital pin for flash chip CS pin

  25. //const int FlashChipSelect = 21; // Arduino 101 built-in SPI Flash

  26. 

  27. SerialFlashFile file;

  28. 

  29. const unsigned long testIncrement = 4096;

  30. 

  31. void setup() {

  32. 

  33.   //uncomment these if using Teensy audio shield

  34.   //SPI.setSCK(14);  // Audio shield has SCK on pin 14

  35.   //SPI.setMOSI(7);  // Audio shield has MOSI on pin 7

  36. 

  37.   //uncomment these if you have other SPI chips connected

  38.   //to keep them disabled while using only SerialFlash

  39.   //pinMode(4, INPUT_PULLUP);

  40.   //pinMode(10, INPUT_PULLUP);

  41. 

  42.   Serial.begin(9600);

  43. 

  44.   while (!Serial) ;

  45.   delay(100);

  46. 

  47.   Serial.println("Raw SerialFlash Hardware Test");

  48.   SerialFlash.begin(FlashChipSelect); // proceed even if begin() fails

  49. 

  50.   if (test()) {

  51.     Serial.println();

  52.     Serial.println("All Tests Passed  :-)");

  53.     Serial.println();

  54.     Serial.println("Test data was written to your chip.  You must run");

  55.     Serial.println("EraseEverything before using this chip for files.");

  56.   } else {

  57.     Serial.println();

  58.     Serial.println("Tests Failed  :{");

  59.     Serial.println();

  60.     Serial.println("The flash chip may be left in an improper state.");

  61.     Serial.println("You might need to power cycle to return to normal.");

  62.   }

  63. }

  64. 

  65. 

  66. bool test() {

  67.   unsigned char buf[256], sig[256], buf2[8];

  68.   unsigned long address, count, chipsize, blocksize;

  69.   unsigned long usec;

  70.   bool first;

  71. 

  72.   // Read the chip identification

  73.   Serial.println();

  74.   Serial.println("Read Chip Identification:");

  75.   SerialFlash.readID(buf);

  76.   Serial.print("  JEDEC ID:     ");

  77.   Serial.print(buf[0], HEX);

  78.   Serial.print(" ");

  79.   Serial.print(buf[1], HEX);

  80.   Serial.print(" ");

  81.   Serial.println(buf[2], HEX);

  82.   Serial.print("  Part Number: ");

  83.   Serial.println(id2chip(buf));

  84.   Serial.print("  Memory Size:  ");

  85.   chipsize = SerialFlash.capacity(buf);

  86.   Serial.print(chipsize);

  87.   Serial.println(" bytes");

  88.   if (chipsize == 0) return false;

  89.   Serial.print("  Block Size:   ");

  90.   blocksize = SerialFlash.blockSize();

  91.   Serial.print(blocksize);

  92.   Serial.println(" bytes");

  93. 

  94. 

  95.   // Read the entire chip.  Every test location must be

  96.   // erased, or have a previously tested signature

  97.   Serial.println();

  98.   Serial.println("Reading Chip...");

  99.   memset(buf, 0, sizeof(buf));

  100.   memset(sig, 0, sizeof(sig));

  101.   memset(buf2, 0, sizeof(buf2));

  102.   address = 0;

  103.   count = 0;

  104.   first = true;

  105.   while (address < chipsize) {

  106.     SerialFlash.read(address, buf, 8);

  107.     //Serial.print("  addr = ");

  108.     //Serial.print(address, HEX);

  109.     //Serial.print(", data = ");

  110.     //printbuf(buf, 8);

  111.     create_signature(address, sig);

  112.     if (is_erased(buf, 8) == false) {

  113.       if (equal_signatures(buf, sig) == false) {

  114.         Serial.print("  Previous data found at address ");

  115.         Serial.println(address);

  116.         Serial.println("  You must fully erase the chip before this test");

  117.         Serial.print("  found this: ");

  118.         printbuf(buf, 8);

  119.         Serial.print("     correct: ");

  120.         printbuf(sig, 8);

  121.         return false;

  122.       }

  123.     } else {

  124.       count = count + 1; // number of blank signatures

  125.     }

  126.     if (first) {

  127.       address = address + (testIncrement - 8);

  128.       first = false;

  129.     } else {

  130.       address = address + 8;

  131.       first = true;

  132.     }

  133.   }

  134. 

  135. 

  136.   // Write any signatures that were blank on the original check

  137.   if (count > 0) {

  138.     Serial.println();

  139.     Serial.print("Writing ");

  140.     Serial.print(count);

  141.     Serial.println(" signatures");

  142.     memset(buf, 0, sizeof(buf));

  143.     memset(sig, 0, sizeof(sig));

  144.     memset(buf2, 0, sizeof(buf2));

  145.     address = 0;

  146.     first = true;

  147.     while (address < chipsize) {

  148.       SerialFlash.read(address, buf, 8);

  149.       if (is_erased(buf, 8)) {

  150.         create_signature(address, sig);

  151.         //Serial.printf("write %08X: data: ", address);

  152.         //printbuf(sig, 8);

  153.         SerialFlash.write(address, sig, 8);

  154.         while (!SerialFlash.ready()) ; // wait

  155.         SerialFlash.read(address, buf, 8);

  156.         if (equal_signatures(buf, sig) == false) {

  157.           Serial.print("  error writing signature at ");

  158.           Serial.println(address);

  159.           Serial.print("  Read this: ");

  160.           printbuf(buf, 8);

  161.           Serial.print("  Expected:  ");

  162.           printbuf(sig, 8);

  163.           return false;

  164.         }

  165.       }

  166.       if (first) {

  167.         address = address + (testIncrement - 8);

  168.         first = false;

  169.       } else {

  170.         address = address + 8;

  171.         first = true;

  172.       }

  173.     }

  174.   } else {

  175.     Serial.println("  all signatures present from prior tests");

  176.   }

  177. 

  178. 

  179.   // Read all the signatures again, just to be sure

  180.   // checks prior writing didn't corrupt any other data

  181.   Serial.println();

  182.   Serial.println("Double Checking All Signatures:");

  183.   memset(buf, 0, sizeof(buf));

  184.   memset(sig, 0, sizeof(sig));

  185.   memset(buf2, 0, sizeof(buf2));

  186.   count = 0;

  187.   address = 0;

  188.   first = true;

  189.   while (address < chipsize) {

  190.     SerialFlash.read(address, buf, 8);

  191.     create_signature(address, sig);

  192.     if (equal_signatures(buf, sig) == false) {

  193.       Serial.print("  error in signature at ");

  194.       Serial.println(address);

  195.       Serial.print("  Read this: ");

  196.       printbuf(buf, 8);

  197.       Serial.print("  Expected:  ");

  198.       printbuf(sig, 8);

  199.       return false;

  200.     }

  201.     count = count + 1;

  202.     if (first) {

  203.       address = address + (testIncrement - 8);

  204.       first = false;

  205.     } else {

  206.       address = address + 8;

  207.       first = true;

  208.     }

  209.   }

  210.   Serial.print("  all ");

  211.   Serial.print(count);

  212.   Serial.println(" signatures read ok");

  213. 

  214. 

  215.   // Read pairs of adjacent signatures

  216.   // check read works across boundaries

  217.   Serial.println();

  218.   Serial.println("Checking Signature Pairs");

  219.   memset(buf, 0, sizeof(buf));

  220.   memset(sig, 0, sizeof(sig));

  221.   memset(buf2, 0, sizeof(buf2));

  222.   count = 0;

  223.   address = testIncrement - 8;

  224.   first = true;

  225.   while (address < chipsize - 8) {

  226.     SerialFlash.read(address, buf, 16);

  227.     create_signature(address, sig);

  228.     create_signature(address + 8, sig + 8);

  229.     if (memcmp(buf, sig, 16) != 0) {

  230.       Serial.print("  error in signature pair at ");

  231.       Serial.println(address);

  232.       Serial.print("  Read this: ");

  233.       printbuf(buf, 16);

  234.       Serial.print("  Expected:  ");

  235.       printbuf(sig, 16);

  236.       return false;

  237.     }

  238.     count = count + 1;

  239.     address = address + testIncrement;

  240.   }

  241.   Serial.print("  all ");

  242.   Serial.print(count);

  243.   Serial.println(" signature pairs read ok");

  244. 

  245. 

  246.   // Write data and read while write in progress

  247.   Serial.println();

  248.   Serial.println("Checking Read-While-Write (Program Suspend)");

  249.   address = 256;

  250.   while (address < chipsize) { // find a blank space

  251.     SerialFlash.read(address, buf, 256);

  252.     if (is_erased(buf, 256)) break;

  253.     address = address + 256;

  254.   }

  255.   if (address >= chipsize) {

  256.     Serial.println("  error, unable to find any blank space!");

  257.     return false;

  258.   }

  259.   for (int i=0; i < 256; i += 8) {

  260.     create_signature(address + i, sig + i);

  261.   }

  262.   Serial.print("  write 256 bytes at ");

  263.   Serial.println(address);

  264.   Serial.flush();

  265.   SerialFlash.write(address, sig, 256);

  266.   usec = micros();

  267.   if (SerialFlash.ready()) {

  268.     Serial.println("  error, chip did not become busy after write");

  269.     return false;

  270.   }

  271.   SerialFlash.read(0, buf2, 8); // read while busy writing

  272.   while (!SerialFlash.ready()) ; // wait

  273.   usec = micros() - usec;

  274.   Serial.print("  write time was ");

  275.   Serial.print(usec);

  276.   Serial.println(" microseconds.");

  277.   SerialFlash.read(address, buf, 256);

  278.   if (memcmp(buf, sig, 256) != 0) {

  279.     Serial.println("  error writing to flash");

  280.     Serial.print("  Read this: ");

  281.     printbuf(buf, 256);

  282.     Serial.print("  Expected:  ");

  283.     printbuf(sig, 256);

  284.     return false;

  285.   }

  286.   create_signature(0, sig);

  287.   if (memcmp(buf2, sig, 8) != 0) {

  288.     Serial.println("  error, incorrect read while writing");

  289.     Serial.print("  Read this: ");

  290.     printbuf(buf2, 256);

  291.     Serial.print("  Expected:  ");

  292.     printbuf(sig, 256);

  293.     return false;

  294.   }

  295.   Serial.print("  read-while-writing: ");

  296.   printbuf(buf2, 8);

  297.   Serial.println("  test passed, good read while writing");

  298. 

  299. 

  300. 

  301.   // Erase a block and read while erase in progress

  302.   if (chipsize >= 262144 + blocksize + testIncrement) {

  303.     Serial.println();

  304.     Serial.println("Checking Read-While-Erase (Erase Suspend)");

  305.     memset(buf, 0, sizeof(buf));

  306.     memset(sig, 0, sizeof(sig));

  307.     memset(buf2, 0, sizeof(buf2));

  308.     SerialFlash.eraseBlock(262144);

  309.     usec = micros();

  310.     delayMicroseconds(50);

  311.     if (SerialFlash.ready()) {

  312.       Serial.println("  error, chip did not become busy after erase");

  313.       return false;

  314.     }

  315.     SerialFlash.read(0, buf2, 8); // read while busy writing

  316.     while (!SerialFlash.ready()) ; // wait

  317.     usec = micros() - usec;

  318.     Serial.print("  erase time was ");

  319.     Serial.print(usec);

  320.     Serial.println(" microseconds.");

  321.     // read all signatures, check ones in this block got

  322.     // erased, and all the others are still intact

  323.     address = 0;

  324.     first = true;

  325.     while (address < chipsize) {

  326.       SerialFlash.read(address, buf, 8);

  327.       if (address >= 262144 && address < 262144 + blocksize) {

  328.         if (is_erased(buf, 8) == false) {

  329.           Serial.print("  error in erasing at ");

  330.           Serial.println(address);

  331.           Serial.print("  Read this: ");

  332.           printbuf(buf, 8);

  333.           return false;

  334.         }

  335.       } else {

  336.         create_signature(address, sig);

  337.         if (equal_signatures(buf, sig) == false) {

  338.           Serial.print("  error in signature at ");

  339.           Serial.println(address);

  340.           Serial.print("  Read this: ");

  341.           printbuf(buf, 8);

  342.           Serial.print("  Expected:  ");

  343.           printbuf(sig, 8);

  344.           return false;

  345.         }

  346.       }

  347.       if (first) {

  348.         address = address + (testIncrement - 8);

  349.         first = false;

  350.       } else {

  351.         address = address + 8;

  352.         first = true;

  353.       }

  354.     }

  355.     Serial.print("  erase correctly erased ");

  356.     Serial.print(blocksize);

  357.     Serial.println(" bytes");

  358.     // now check if the data we read during erase is good

  359.     create_signature(0, sig);

  360.     if (memcmp(buf2, sig, 8) != 0) {

  361.       Serial.println("  error, incorrect read while erasing");

  362.       Serial.print("  Read this: ");

  363.       printbuf(buf2, 256);

  364.       Serial.print("  Expected:  ");

  365.       printbuf(sig, 256);

  366.       return false;

  367.     }

  368.     Serial.print("  read-while-erasing: ");

  369.     printbuf(buf2, 8);

  370.     Serial.println("  test passed, good read while erasing");

  371. 

  372.   } else {

  373.     Serial.println("Skip Read-While-Erase, this chip is too small");

  374.   }

  375. 

  376. 

  377. 

  378. 

  379.   return true;

  380. }

  381. 

  382. 

  383. void loop() {

  384.   // do nothing after the test

  385. }

  386. 

  387. const char * id2chip(const unsigned char *id)

  388. {

  389. 	if (id[0] == 0xEF) {

  390. 		// Winbond

  391. 		if (id[1] == 0x40) {

  392. 			if (id[2] == 0x14) return "W25Q80BV";

  393. 			if (id[2] == 0x15) return "W25Q16DV";

  394. 			if (id[2] == 0x17) return "W25Q64FV";

  395. 			if (id[2] == 0x18) return "W25Q128FV";

  396. 			if (id[2] == 0x19) return "W25Q256FV";

  397. 		}

  398. 	}

  399. 	if (id[0] == 0x01) {

  400. 		// Spansion

  401. 		if (id[1] == 0x02) {

  402. 			if (id[2] == 0x16) return "S25FL064A";

  403. 			if (id[2] == 0x19) return "S25FL256S";

  404. 			if (id[2] == 0x20) return "S25FL512S";

  405. 		}

  406. 		if (id[1] == 0x20) {

  407. 			if (id[2] == 0x18) return "S25FL127S";

  408. 		}

  409. 	}

  410. 	if (id[0] == 0xC2) {

  411. 		// Macronix

  412. 		if (id[1] == 0x20) {

  413. 			if (id[2] == 0x18) return "MX25L12805D";

  414. 		}

  415. 	}

  416. 	if (id[0] == 0x20) {

  417. 		// Micron

  418. 		if (id[1] == 0xBA) {

  419. 			if (id[2] == 0x20) return "N25Q512A";

  420. 			if (id[2] == 0x21) return "N25Q00AA";

  421. 		}

  422. 		if (id[1] == 0xBB) {

  423. 			if (id[2] == 0x22) return "MT25QL02GC";

  424. 		}

  425. 	}

  426. 	if (id[0] == 0xBF) {

  427. 		// SST

  428. 		if (id[1] == 0x25) {

  429. 			if (id[2] == 0x02) return "SST25WF010";

  430. 			if (id[2] == 0x03) return "SST25WF020";

  431. 			if (id[2] == 0x04) return "SST25WF040";

  432. 			if (id[2] == 0x41) return "SST25VF016B";

  433. 			if (id[2] == 0x4A) return "SST25VF032";

  434. 		}

  435. 		if (id[1] == 0x25) {

  436. 			if (id[2] == 0x01) return "SST26VF016";

  437. 			if (id[2] == 0x02) return "SST26VF032";

  438. 			if (id[2] == 0x43) return "SST26VF064";

  439. 		}

  440. 	}

  441.   	if (id[0] == 0x1F) {

  442.     		// Adesto

  443.    		if (id[1] == 0x89) {

  444.       			if (id[2] == 0x01) return "AT25SF128A";

  445.     		}  

  446.   	} 	

  447. 	return "(unknown chip)";

  448. }

  449. 

  450. void print_signature(const unsigned char *data)

  451. {

  452. 	Serial.print("data=");

  453. 	for (unsigned char i=0; i < 8; i++) {

  454. 		Serial.print(data[i]);

  455. 		Serial.print(" ");

  456. 	}

  457. 	Serial.println();

  458. }

  459. 

  460. void create_signature(unsigned long address, unsigned char *data)

  461. {

  462. 	data[0] = address >> 24;

  463. 	data[1] = address >> 16;

  464. 	data[2] = address >> 8;

  465. 	data[3] = address;

  466. 	unsigned long hash = 2166136261ul;

  467. 	for (unsigned char i=0; i < 4; i++) {

  468. 		hash ^= data[i];

  469. 		hash *= 16777619ul;

  470. 	}

  471. 	data[4] = hash;

  472. 	data[5] = hash >> 8;

  473. 	data[6] = hash >> 16;

  474. 	data[7] = hash >> 24;

  475. }

  476. 

  477. bool equal_signatures(const unsigned char *data1, const unsigned char *data2)

  478. {

  479. 	for (unsigned char i=0; i < 8; i++) {

  480. 		if (data1[i] != data2[i]) return false;

  481. 	}

  482. 	return true;

  483. }

  484. 

  485. bool is_erased(const unsigned char *data, unsigned int len)

  486. {

  487. 	while (len > 0) {

  488. 		if (*data++ != 255) return false;

  489. 		len = len - 1;

  490. 	}

  491. 	return true;

  492. }

  493. 

  494. 

  495. void printbuf(const void *buf, uint32_t len)

  496. {

  497.   const uint8_t *p = (const uint8_t *)buf;

  498.   do {

  499.     unsigned char b = *p++;

  500.     Serial.print(b >> 4, HEX);

  501.     Serial.print(b & 15, HEX);

  502.     //Serial.printf("%02X", *p++);

  503.     Serial.print(" ");

  504.   } while (--len > 0);

  505.   Serial.println();

  506. }