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

498 lines
13KB
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.   while (!Serial) ;

  42.   delay(100);

  43. 

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

  45.   SerialFlash.begin(FlashChipSelect);

  46. 

  47.   if (test()) {

  48.     Serial.println();

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

  50.     Serial.println();

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

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

  53.   } else {

  54.     Serial.println();

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

  56.     Serial.println();

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

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

  59.   }

  60. }

  61. 

  62. 

  63. bool test() {

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

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

  66.   unsigned long usec;

  67.   bool first;

  68. 

  69.   // Read the chip identification

  70.   Serial.println();

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

  72.   SerialFlash.readID(buf);

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

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

  75.   Serial.print(" ");

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

  77.   Serial.print(" ");

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

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

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

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

  82.   chipsize = SerialFlash.capacity(buf);

  83.   Serial.print(chipsize);

  84.   Serial.println(" bytes");

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

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

  87.   blocksize = SerialFlash.blockSize();

  88.   Serial.print(blocksize);

  89.   Serial.println(" bytes");

  90. 

  91. 

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

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

  94.   Serial.println();

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

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

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

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

  99.   address = 0;

  100.   count = 0;

  101.   first = true;

  102.   while (address < chipsize) {

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

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

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

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

  107.     //printbuf(buf, 8);

  108.     create_signature(address, sig);

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

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

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

  112.         Serial.println(address);

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

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

  115.         printbuf(buf, 8);

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

  117.         printbuf(sig, 8);

  118.         return false;

  119.       }

  120.     } else {

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

  122.     }

  123.     if (first) {

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

  125.       first = false;

  126.     } else {

  127.       address = address + 8;

  128.       first = true;

  129.     }

  130.   }

  131. 

  132. 

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

  134.   if (count > 0) {

  135.     Serial.println();

  136.     Serial.print("Writing ");

  137.     Serial.print(count);

  138.     Serial.println(" signatures");

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

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

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

  142.     address = 0;

  143.     first = true;

  144.     while (address < chipsize) {

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

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

  147.         create_signature(address, sig);

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

  149.         //printbuf(sig, 8);

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

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

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

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

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

  155.           Serial.println(address);

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

  157.           printbuf(buf, 8);

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

  159.           printbuf(sig, 8);

  160.           return false;

  161.         }

  162.       }

  163.       if (first) {

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

  165.         first = false;

  166.       } else {

  167.         address = address + 8;

  168.         first = true;

  169.       }

  170.     }

  171.   } else {

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

  173.   }

  174. 

  175. 

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

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

  178.   Serial.println();

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

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

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

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

  183.   count = 0;

  184.   address = 0;

  185.   first = true;

  186.   while (address < chipsize) {

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

  188.     create_signature(address, sig);

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

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

  191.       Serial.println(address);

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

  193.       printbuf(buf, 8);

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

  195.       printbuf(sig, 8);

  196.       return false;

  197.     }

  198.     count = count + 1;

  199.     if (first) {

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

  201.       first = false;

  202.     } else {

  203.       address = address + 8;

  204.       first = true;

  205.     }

  206.   }

  207.   Serial.print("  all ");

  208.   Serial.print(count);

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

  210. 

  211. 

  212.   // Read pairs of adjacent signatures

  213.   // check read works across boundaries

  214.   Serial.println();

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

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

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

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

  219.   count = 0;

  220.   address = testIncrement - 8;

  221.   first = true;

  222.   while (address < chipsize - 8) {

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

  224.     create_signature(address, sig);

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

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

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

  228.       Serial.println(address);

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

  230.       printbuf(buf, 16);

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

  232.       printbuf(sig, 16);

  233.       return false;

  234.     }

  235.     count = count + 1;

  236.     address = address + testIncrement;

  237.   }

  238.   Serial.print("  all ");

  239.   Serial.print(count);

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

  241. 

  242. 

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

  244.   Serial.println();

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

  246.   address = 256;

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

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

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

  250.     address = address + 256;

  251.   }

  252.   if (address >= chipsize) {

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

  254.     return false;

  255.   }

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

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

  258.   }

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

  260.   Serial.println(address);

  261.   Serial.flush();

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

  263.   usec = micros();

  264.   if (SerialFlash.ready()) {

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

  266.     return false;

  267.   }

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

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

  270.   usec = micros() - usec;

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

  272.   Serial.print(usec);

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

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

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

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

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

  278.     printbuf(buf, 256);

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

  280.     printbuf(sig, 256);

  281.     return false;

  282.   }

  283.   create_signature(0, sig);

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

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

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

  287.     printbuf(buf2, 256);

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

  289.     printbuf(sig, 256);

  290.     return false;

  291.   }

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

  293.   printbuf(buf2, 8);

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

  295. 

  296. 

  297. 

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

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

  300.     Serial.println();

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

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

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

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

  305.     SerialFlash.eraseBlock(262144);

  306.     usec = micros();

  307.     delayMicroseconds(50);

  308.     if (SerialFlash.ready()) {

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

  310.       return false;

  311.     }

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

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

  314.     usec = micros() - usec;

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

  316.     Serial.print(usec);

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

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

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

  320.     address = 0;

  321.     first = true;

  322.     while (address < chipsize) {

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

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

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

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

  327.           Serial.println(address);

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

  329.           printbuf(buf, 8);

  330.           return false;

  331.         }

  332.       } else {

  333.         create_signature(address, sig);

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

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

  336.           Serial.println(address);

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

  338.           printbuf(buf, 8);

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

  340.           printbuf(sig, 8);

  341.           return false;

  342.         }

  343.       }

  344.       if (first) {

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

  346.         first = false;

  347.       } else {

  348.         address = address + 8;

  349.         first = true;

  350.       }

  351.     }

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

  353.     Serial.print(blocksize);

  354.     Serial.println(" bytes");

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

  356.     create_signature(0, sig);

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

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

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

  360.       printbuf(buf2, 256);

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

  362.       printbuf(sig, 256);

  363.       return false;

  364.     }

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

  366.     printbuf(buf2, 8);

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

  368. 

  369.   } else {

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

  371.   }

  372. 

  373. 

  374. 

  375. 

  376.   return true;

  377. }

  378. 

  379. 

  380. void loop() {

  381.   // do nothing after the test

  382. }

  383. 

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

  385. {

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

  387. 		// Winbond

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

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

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

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

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

  393. 		}

  394. 	}

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

  396. 		// Spansion

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

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

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

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

  401. 		}

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

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

  404. 		}

  405. 	}

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

  407. 		// Macronix

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

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

  410. 		}

  411. 	}

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

  413. 		// Micron

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

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

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

  417. 		}

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

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

  420. 		}

  421. 	}

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

  423. 		// SST

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

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

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

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

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

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

  430. 		}

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

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

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

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

  435. 		}

  436. 	}

  437. 	return "(unknown chip)";

  438. }

  439. 

  440. void print_signature(const unsigned char *data)

  441. {

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

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

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

  445. 		Serial.print(" ");

  446. 	}

  447. 	Serial.println();

  448. }

  449. 

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

  451. {

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

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

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

  455. 	data[3] = address;

  456. 	unsigned long hash = 2166136261ul;

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

  458. 		hash ^= data[i];

  459. 		hash *= 16777619ul;

  460. 	}

  461. 	data[4] = hash;

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

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

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

  465. }

  466. 

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

  468. {

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

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

  471. 	}

  472. 	return true;

  473. }

  474. 

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

  476. {

  477. 	while (len > 0) {

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

  479. 		len = len - 1;

  480. 	}

  481. 	return true;

  482. }

  483. 

  484. 

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

  486. {

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

  488.   do {

  489.     unsigned char b = *p++;

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

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

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

  493.     Serial.print(" ");

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

  495.   Serial.println();

  496. }