visus
/
teensy-serial-flash
Obserwuj 1
Polub 0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
74 Commity
1 Gałąź
Drzewo: 826da1a177
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '826da1a177'
${ noResults }
teensy-serial-flash/examples/RawHardwareTest/RawHardwareTest.ino

503 lines
14KB
Czysty Wina Historia 

  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. // Uncomment this line if using the built-in SPI Flash device

  26. // on an Arduino 101 board

  27. //const int FlashChipSelect = 21;

  28. 

  29. SerialFlashFile file;

  30. 

  31. const unsigned long testIncrement = 4096;

  32. 

  33. void setup() {

  34. 

  35.   //uncomment these if using Teensy audio shield

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

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

  38. 

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

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

  41.   //pinMode(4, INPUT_PULLUP);

  42.   //pinMode(10, INPUT_PULLUP);

  43. 

  44.   Serial.begin(9600);

  45. 

  46.   while (!Serial) ;

  47.   delay(100);

  48. 

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

  50.   SerialFlash.begin(FlashChipSelect);

  51. 

  52.   if (test()) {

  53.     Serial.println();

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

  55.     Serial.println();

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

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

  58.   } else {

  59.     Serial.println();

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

  61.     Serial.println();

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

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

  64.   }

  65. }

  66. 

  67. 

  68. bool test() {

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

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

  71.   unsigned long usec;

  72.   bool first;

  73. 

  74.   // Read the chip identification

  75.   Serial.println();

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

  77.   SerialFlash.readID(buf);

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

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

  80.   Serial.print(" ");

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

  82.   Serial.print(" ");

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

  84.   Serial.print("  Part Nummber: ");

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

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

  87.   chipsize = SerialFlash.capacity(buf);

  88.   Serial.print(chipsize);

  89.   Serial.println(" bytes");

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

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

  92.   blocksize = SerialFlash.blockSize();

  93.   Serial.print(blocksize);

  94.   Serial.println(" bytes");

  95. 

  96. 

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

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

  99.   Serial.println();

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

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

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

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

  104.   address = 0;

  105.   count = 0;

  106.   first = true;

  107.   while (address < chipsize) {

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

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

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

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

  112.     //printbuf(buf, 8);

  113.     create_signature(address, sig);

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

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

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

  117.         Serial.println(address);

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

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

  120.         printbuf(buf, 8);

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

  122.         printbuf(sig, 8);

  123.         return false;

  124.       }

  125.     } else {

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

  127.     }

  128.     if (first) {

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

  130.       first = false;

  131.     } else {

  132.       address = address + 8;

  133.       first = true;

  134.     }

  135.   }

  136. 

  137. 

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

  139.   if (count > 0) {

  140.     Serial.println();

  141.     Serial.print("Writing ");

  142.     Serial.print(count);

  143.     Serial.println(" signatures");

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

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

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

  147.     address = 0;

  148.     first = true;

  149.     while (address < chipsize) {

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

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

  152.         create_signature(address, sig);

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

  154.         //printbuf(sig, 8);

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

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

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

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

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

  160.           Serial.println(address);

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

  162.           printbuf(buf, 8);

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

  164.           printbuf(sig, 8);

  165.           return false;

  166.         }

  167.       }

  168.       if (first) {

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

  170.         first = false;

  171.       } else {

  172.         address = address + 8;

  173.         first = true;

  174.       }

  175.     }

  176.   } else {

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

  178.   }

  179. 

  180. 

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

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

  183.   Serial.println();

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

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

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

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

  188.   count = 0;

  189.   address = 0;

  190.   first = true;

  191.   while (address < chipsize) {

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

  193.     create_signature(address, sig);

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

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

  196.       Serial.println(address);

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

  198.       printbuf(buf, 8);

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

  200.       printbuf(sig, 8);

  201.       return false;

  202.     }

  203.     count = count + 1;

  204.     if (first) {

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

  206.       first = false;

  207.     } else {

  208.       address = address + 8;

  209.       first = true;

  210.     }

  211.   }

  212.   Serial.print("  all ");

  213.   Serial.print(count);

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

  215. 

  216. 

  217.   // Read pairs of adjacent signatures

  218.   // check read works across boundaries

  219.   Serial.println();

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

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

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

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

  224.   count = 0;

  225.   address = testIncrement - 8;

  226.   first = true;

  227.   while (address < chipsize - 8) {

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

  229.     create_signature(address, sig);

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

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

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

  233.       Serial.println(address);

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

  235.       printbuf(buf, 16);

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

  237.       printbuf(sig, 16);

  238.       return false;

  239.     }

  240.     count = count + 1;

  241.     address = address + testIncrement;

  242.   }

  243.   Serial.print("  all ");

  244.   Serial.print(count);

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

  246. 

  247. 

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

  249.   Serial.println();

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

  251.   address = 256;

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

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

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

  255.     address = address + 256;

  256.   }

  257.   if (address >= chipsize) {

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

  259.     return false;

  260.   }

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

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

  263.   }

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

  265.   Serial.println(address);

  266.   Serial.flush();

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

  268.   usec = micros();

  269.   if (SerialFlash.ready()) {

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

  271.     return false;

  272.   }

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

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

  275.   usec = micros() - usec;

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

  277.   Serial.print(usec);

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

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

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

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

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

  283.     printbuf(buf, 256);

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

  285.     printbuf(sig, 256);

  286.     return false;

  287.   }

  288.   create_signature(0, sig);

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

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

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

  292.     printbuf(buf2, 256);

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

  294.     printbuf(sig, 256);

  295.     return false;

  296.   }

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

  298.   printbuf(buf2, 8);

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

  300. 

  301. 

  302. 

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

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

  305.     Serial.println();

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

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

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

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

  310.     SerialFlash.eraseBlock(262144);

  311.     usec = micros();

  312.     delayMicroseconds(50);

  313.     if (SerialFlash.ready()) {

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

  315.       return false;

  316.     }

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

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

  319.     usec = micros() - usec;

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

  321.     Serial.print(usec);

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

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

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

  325.     address = 0;

  326.     first = true;

  327.     while (address < chipsize) {

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

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

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

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

  332.           Serial.println(address);

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

  334.           printbuf(buf, 8);

  335.           return false;

  336.         }

  337.       } else {

  338.         create_signature(address, sig);

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

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

  341.           Serial.println(address);

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

  343.           printbuf(buf, 8);

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

  345.           printbuf(sig, 8);

  346.           return false;

  347.         }

  348.       }

  349.       if (first) {

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

  351.         first = false;

  352.       } else {

  353.         address = address + 8;

  354.         first = true;

  355.       }

  356.     }

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

  358.     Serial.print(blocksize);

  359.     Serial.println(" bytes");

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

  361.     create_signature(0, sig);

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

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

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

  365.       printbuf(buf2, 256);

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

  367.       printbuf(sig, 256);

  368.       return false;

  369.     }

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

  371.     printbuf(buf2, 8);

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

  373. 

  374.   } else {

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

  376.   }

  377. 

  378. 

  379. 

  380. 

  381.   return true;

  382. }

  383. 

  384. 

  385. void loop() {

  386.   // do nothing after the test

  387. }

  388. 

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

  390. {

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

  392. 		// Winbond

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

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

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

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

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

  398. 		}

  399. 	}

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

  401. 		// Spansion

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

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

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

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

  406. 		}

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

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

  409. 		}

  410. 	}

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

  412. 		// Macronix

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

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

  415. 		}

  416. 	}

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

  418. 		// Micron

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

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

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

  422. 		}

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

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

  425. 		}

  426. 	}

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

  428. 		// SST

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

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

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

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

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

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

  435. 		}

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

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

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

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

  440. 		}

  441. 	}

  442. 	return "(unknown chip)";

  443. }

  444. 

  445. void print_signature(const unsigned char *data)

  446. {

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

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

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

  450. 		Serial.print(" ");

  451. 	}

  452. 	Serial.println();

  453. }

  454. 

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

  456. {

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

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

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

  460. 	data[3] = address;

  461. 	unsigned long hash = 2166136261ul;

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

  463. 		hash ^= data[i];

  464. 		hash *= 16777619ul;

  465. 	}

  466. 	data[4] = hash;

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

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

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

  470. }

  471. 

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

  473. {

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

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

  476. 	}

  477. 	return true;

  478. }

  479. 

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

  481. {

  482. 	while (len > 0) {

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

  484. 		len = len - 1;

  485. 	}

  486. 	return true;

  487. }

  488. 

  489. 

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

  491. {

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

  493.   do {

  494.     unsigned char b = *p++;

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

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

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

  498.     Serial.print(" ");

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

  500.   Serial.println();

  501. }