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.
69 Commity
1 Gałąź
Drzewo: 875885a985
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '875885a985'
${ noResults }
teensy-serial-flash/examples/RawHardwareTest/RawHardwareTest.ino

500 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. 

  26. SerialFlashFile file;

  27. 

  28. const unsigned long testIncrement = 4096;

  29. 

  30. void setup() {

  31. 

  32.   //uncomment these if using Teensy audio shield

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

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

  35. 

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

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

  38.   //pinMode(4, INPUT_PULLUP);

  39.   //pinMode(10, INPUT_PULLUP);

  40. 

  41.   Serial.begin(9600);

  42. 

  43.   while (!Serial) ;

  44.   delay(100);

  45. 

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

  47.   SerialFlash.begin(FlashChipSelect);

  48. 

  49.   if (test()) {

  50.     Serial.println();

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

  52.     Serial.println();

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

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

  55.   } else {

  56.     Serial.println();

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

  58.     Serial.println();

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

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

  61.   }

  62. }

  63. 

  64. 

  65. bool test() {

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

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

  68.   unsigned long usec;

  69.   bool first;

  70. 

  71.   // Read the chip identification

  72.   Serial.println();

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

  74.   SerialFlash.readID(buf);

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

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

  77.   Serial.print(" ");

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

  79.   Serial.print(" ");

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

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

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

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

  84.   chipsize = SerialFlash.capacity(buf);

  85.   Serial.print(chipsize);

  86.   Serial.println(" bytes");

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

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

  89.   blocksize = SerialFlash.blockSize();

  90.   Serial.print(blocksize);

  91.   Serial.println(" bytes");

  92. 

  93. 

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

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

  96.   Serial.println();

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

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

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

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

  101.   address = 0;

  102.   count = 0;

  103.   first = true;

  104.   while (address < chipsize) {

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

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

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

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

  109.     //printbuf(buf, 8);

  110.     create_signature(address, sig);

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

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

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

  114.         Serial.println(address);

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

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

  117.         printbuf(buf, 8);

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

  119.         printbuf(sig, 8);

  120.         return false;

  121.       }

  122.     } else {

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

  124.     }

  125.     if (first) {

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

  127.       first = false;

  128.     } else {

  129.       address = address + 8;

  130.       first = true;

  131.     }

  132.   }

  133. 

  134. 

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

  136.   if (count > 0) {

  137.     Serial.println();

  138.     Serial.print("Writing ");

  139.     Serial.print(count);

  140.     Serial.println(" signatures");

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

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

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

  144.     address = 0;

  145.     first = true;

  146.     while (address < chipsize) {

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

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

  149.         create_signature(address, sig);

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

  151.         //printbuf(sig, 8);

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

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

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

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

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

  157.           Serial.println(address);

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

  159.           printbuf(buf, 8);

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

  161.           printbuf(sig, 8);

  162.           return false;

  163.         }

  164.       }

  165.       if (first) {

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

  167.         first = false;

  168.       } else {

  169.         address = address + 8;

  170.         first = true;

  171.       }

  172.     }

  173.   } else {

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

  175.   }

  176. 

  177. 

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

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

  180.   Serial.println();

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

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

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

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

  185.   count = 0;

  186.   address = 0;

  187.   first = true;

  188.   while (address < chipsize) {

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

  190.     create_signature(address, sig);

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

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

  193.       Serial.println(address);

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

  195.       printbuf(buf, 8);

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

  197.       printbuf(sig, 8);

  198.       return false;

  199.     }

  200.     count = count + 1;

  201.     if (first) {

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

  203.       first = false;

  204.     } else {

  205.       address = address + 8;

  206.       first = true;

  207.     }

  208.   }

  209.   Serial.print("  all ");

  210.   Serial.print(count);

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

  212. 

  213. 

  214.   // Read pairs of adjacent signatures

  215.   // check read works across boundaries

  216.   Serial.println();

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

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

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

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

  221.   count = 0;

  222.   address = testIncrement - 8;

  223.   first = true;

  224.   while (address < chipsize - 8) {

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

  226.     create_signature(address, sig);

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

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

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

  230.       Serial.println(address);

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

  232.       printbuf(buf, 16);

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

  234.       printbuf(sig, 16);

  235.       return false;

  236.     }

  237.     count = count + 1;

  238.     address = address + testIncrement;

  239.   }

  240.   Serial.print("  all ");

  241.   Serial.print(count);

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

  243. 

  244. 

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

  246.   Serial.println();

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

  248.   address = 256;

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

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

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

  252.     address = address + 256;

  253.   }

  254.   if (address >= chipsize) {

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

  256.     return false;

  257.   }

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

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

  260.   }

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

  262.   Serial.println(address);

  263.   Serial.flush();

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

  265.   usec = micros();

  266.   if (SerialFlash.ready()) {

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

  268.     return false;

  269.   }

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

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

  272.   usec = micros() - usec;

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

  274.   Serial.print(usec);

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

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

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

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

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

  280.     printbuf(buf, 256);

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

  282.     printbuf(sig, 256);

  283.     return false;

  284.   }

  285.   create_signature(0, sig);

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

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

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

  289.     printbuf(buf2, 256);

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

  291.     printbuf(sig, 256);

  292.     return false;

  293.   }

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

  295.   printbuf(buf2, 8);

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

  297. 

  298. 

  299. 

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

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

  302.     Serial.println();

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

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

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

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

  307.     SerialFlash.eraseBlock(262144);

  308.     usec = micros();

  309.     delayMicroseconds(50);

  310.     if (SerialFlash.ready()) {

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

  312.       return false;

  313.     }

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

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

  316.     usec = micros() - usec;

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

  318.     Serial.print(usec);

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

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

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

  322.     address = 0;

  323.     first = true;

  324.     while (address < chipsize) {

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

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

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

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

  329.           Serial.println(address);

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

  331.           printbuf(buf, 8);

  332.           return false;

  333.         }

  334.       } else {

  335.         create_signature(address, sig);

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

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

  338.           Serial.println(address);

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

  340.           printbuf(buf, 8);

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

  342.           printbuf(sig, 8);

  343.           return false;

  344.         }

  345.       }

  346.       if (first) {

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

  348.         first = false;

  349.       } else {

  350.         address = address + 8;

  351.         first = true;

  352.       }

  353.     }

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

  355.     Serial.print(blocksize);

  356.     Serial.println(" bytes");

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

  358.     create_signature(0, sig);

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

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

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

  362.       printbuf(buf2, 256);

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

  364.       printbuf(sig, 256);

  365.       return false;

  366.     }

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

  368.     printbuf(buf2, 8);

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

  370. 

  371.   } else {

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

  373.   }

  374. 

  375. 

  376. 

  377. 

  378.   return true;

  379. }

  380. 

  381. 

  382. void loop() {

  383.   // do nothing after the test

  384. }

  385. 

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

  387. {

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

  389. 		// Winbond

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

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

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

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

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

  395. 		}

  396. 	}

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

  398. 		// Spansion

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

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

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

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

  403. 		}

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

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

  406. 		}

  407. 	}

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

  409. 		// Macronix

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

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

  412. 		}

  413. 	}

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

  415. 		// Micron

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

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

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

  419. 		}

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

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

  422. 		}

  423. 	}

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

  425. 		// SST

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

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

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

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

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

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

  432. 		}

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

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

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

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

  437. 		}

  438. 	}

  439. 	return "(unknown chip)";

  440. }

  441. 

  442. void print_signature(const unsigned char *data)

  443. {

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

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

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

  447. 		Serial.print(" ");

  448. 	}

  449. 	Serial.println();

  450. }

  451. 

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

  453. {

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

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

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

  457. 	data[3] = address;

  458. 	unsigned long hash = 2166136261ul;

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

  460. 		hash ^= data[i];

  461. 		hash *= 16777619ul;

  462. 	}

  463. 	data[4] = hash;

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

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

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

  467. }

  468. 

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

  470. {

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

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

  473. 	}

  474. 	return true;

  475. }

  476. 

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

  478. {

  479. 	while (len > 0) {

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

  481. 		len = len - 1;

  482. 	}

  483. 	return true;

  484. }

  485. 

  486. 

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

  488. {

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

  490.   do {

  491.     unsigned char b = *p++;

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

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

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

  495.     Serial.print(" ");

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

  497.   Serial.println();

  498. }