visus
/
teensy-serial-flash
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
36 Commits
1 Rama
Árbol: 006f654f14
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '006f654f14'
${ noResults }
teensy-serial-flash/examples/RawHardwareTest/RawHardwareTest.ino

489 líneas
13KB
Original Blame 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. 

  22. #include <SerialFlash.h>

  23. #include <SPI.h>

  24. 

  25. SerialFlashFile file;

  26. 

  27. const unsigned long testIncrement = 4096;

  28. 

  29. void setup() {

  30. 

  31.   //uncomment these if using Teensy audio shield

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

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

  34. 

  35.   while (!Serial) ;

  36.   delay(100);

  37. 

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

  39.   SerialFlash.begin();

  40. 

  41.   if (test()) {

  42.     Serial.println();

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

  44.   } else {

  45.     Serial.println();

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

  47.     Serial.println();

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

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

  50.   }

  51. }

  52. 

  53. 

  54. bool test() {

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

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

  57.   unsigned long usec;

  58.   bool first;

  59. 

  60.   // Read the chip identification

  61.   Serial.println();

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

  63.   SerialFlash.readID(buf);

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

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

  66.   Serial.print(" ");

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

  68.   Serial.print(" ");

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

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

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

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

  73.   chipsize = SerialFlash.capacity(buf);

  74.   Serial.print(chipsize);

  75.   Serial.println(" bytes");

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

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

  78.   blocksize = SerialFlash.blockSize();

  79.   Serial.print(blocksize);

  80.   Serial.println(" bytes");

  81. 

  82. 

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

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

  85.   Serial.println();

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

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

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

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

  90.   address = 0;

  91.   count = 0;

  92.   first = true;

  93.   while (address < chipsize) {

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

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

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

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

  98.     //printbuf(buf, 8);

  99.     create_signature(address, sig);

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

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

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

  103.         Serial.println(address);

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

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

  106.         printbuf(buf, 8);

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

  108.         printbuf(sig, 8);

  109.         return false;

  110.       }

  111.     } else {

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

  113.     }

  114.     if (first) {

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

  116.       first = false;

  117.     } else {

  118.       address = address + 8;

  119.       first = true;

  120.     }

  121.   }

  122. 

  123. 

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

  125.   if (count > 0) {

  126.     Serial.println();

  127.     Serial.print("Writing ");

  128.     Serial.print(count);

  129.     Serial.println(" signatures");

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

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

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

  133.     address = 0;

  134.     first = true;

  135.     while (address < chipsize) {

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

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

  138.         create_signature(address, sig);

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

  140.         //printbuf(sig, 8);

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

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

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

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

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

  146.           Serial.println(address);

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

  148.           printbuf(buf, 8);

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

  150.           printbuf(sig, 8);

  151.           return false;

  152.         }

  153.       }

  154.       if (first) {

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

  156.         first = false;

  157.       } else {

  158.         address = address + 8;

  159.         first = true;

  160.       }

  161.     }

  162.   } else {

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

  164.   }

  165. 

  166. 

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

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

  169.   Serial.println();

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

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

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

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

  174.   count = 0;

  175.   address = 0;

  176.   first = true;

  177.   while (address < chipsize) {

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

  179.     create_signature(address, sig);

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

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

  182.       Serial.println(address);

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

  184.       printbuf(buf, 8);

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

  186.       printbuf(sig, 8);

  187.       return false;

  188.     }

  189.     count = count + 1;

  190.     if (first) {

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

  192.       first = false;

  193.     } else {

  194.       address = address + 8;

  195.       first = true;

  196.     }

  197.   }

  198.   Serial.print("  all ");

  199.   Serial.print(count);

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

  201. 

  202. 

  203.   // Read pairs of adjacent signatures

  204.   // check read works across boundaries

  205.   Serial.println();

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

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

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

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

  210.   count = 0;

  211.   address = testIncrement - 8;

  212.   first = true;

  213.   while (address < chipsize - 8) {

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

  215.     create_signature(address, sig);

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

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

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

  219.       Serial.println(address);

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

  221.       printbuf(buf, 16);

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

  223.       printbuf(sig, 16);

  224.       return false;

  225.     }

  226.     count = count + 1;

  227.     address = address + testIncrement;

  228.   }

  229.   Serial.print("  all ");

  230.   Serial.print(count);

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

  232. 

  233. 

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

  235.   Serial.println();

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

  237.   address = 256;

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

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

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

  241.     address = address + 256;

  242.   }

  243.   if (address >= chipsize) {

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

  245.     return false;

  246.   }

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

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

  249.   }

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

  251.   Serial.println(address);

  252.   Serial.flush();

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

  254.   usec = micros();

  255.   if (SerialFlash.ready()) {

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

  257.     return false;

  258.   }

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

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

  261.   usec = micros() - usec;

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

  263.   Serial.print(usec);

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

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

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

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

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

  269.     printbuf(buf, 256);

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

  271.     printbuf(sig, 256);

  272.     return false;

  273.   }

  274.   create_signature(0, sig);

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

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

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

  278.     printbuf(buf2, 256);

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

  280.     printbuf(sig, 256);

  281.     return false;

  282.   }

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

  284.   printbuf(buf2, 8);

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

  286. 

  287. 

  288. 

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

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

  291.     Serial.println();

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

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

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

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

  296.     SerialFlash.eraseBlock(262144);

  297.     usec = micros();

  298.     delayMicroseconds(50);

  299.     if (SerialFlash.ready()) {

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

  301.       return false;

  302.     }

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

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

  305.     usec = micros() - usec;

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

  307.     Serial.print(usec);

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

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

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

  311.     address = 0;

  312.     first = true;

  313.     while (address < chipsize) {

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

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

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

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

  318.           Serial.println(address);

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

  320.           printbuf(buf, 8);

  321.           return false;

  322.         }

  323.       } else {

  324.         create_signature(address, sig);

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

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

  327.           Serial.println(address);

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

  329.           printbuf(buf, 8);

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

  331.           printbuf(sig, 8);

  332.           return false;

  333.         }

  334.       }

  335.       if (first) {

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

  337.         first = false;

  338.       } else {

  339.         address = address + 8;

  340.         first = true;

  341.       }

  342.     }

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

  344.     Serial.print(blocksize);

  345.     Serial.println(" bytes");

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

  347.     create_signature(0, sig);

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

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

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

  351.       printbuf(buf2, 256);

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

  353.       printbuf(sig, 256);

  354.       return false;

  355.     }

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

  357.     printbuf(buf2, 8);

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

  359. 

  360.   } else {

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

  362.   }

  363. 

  364. 

  365. 

  366. 

  367.   return true;

  368. }

  369. 

  370. 

  371. void loop() {

  372.   // do nothing after the test

  373. }

  374. 

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

  376. {

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

  378. 		// Winbond

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

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

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

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

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

  384. 		}

  385. 	}

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

  387. 		// Spansion

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

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

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

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

  392. 		}

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

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

  395. 		}

  396. 	}

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

  398. 		// Macronix

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

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

  401. 		}

  402. 	}

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

  404. 		// Micron

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

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

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

  408. 		}

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

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

  411. 		}

  412. 	}

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

  414. 		// SST

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

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

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

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

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

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

  421. 		}

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

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

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

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

  426. 		}

  427. 	}

  428. 	return "(unknown chip)";

  429. }

  430. 

  431. void print_signature(const unsigned char *data)

  432. {

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

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

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

  436. 		Serial.print(" ");

  437. 	}

  438. 	Serial.println();

  439. }

  440. 

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

  442. {

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

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

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

  446. 	data[3] = address;

  447. 	unsigned long hash = 2166136261ul;

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

  449. 		hash ^= data[i];

  450. 		hash *= 16777619ul;

  451. 	}

  452. 	data[4] = hash;

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

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

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

  456. }

  457. 

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

  459. {

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

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

  462. 	}

  463. 	return true;

  464. }

  465. 

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

  467. {

  468. 	while (len > 0) {

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

  470. 		len = len - 1;

  471. 	}

  472. 	return true;

  473. }

  474. 

  475. 

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

  477. {

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

  479.   do {

  480.     unsigned char b = *p++;

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

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

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

  484.     Serial.print(" ");

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

  486.   Serial.println();

  487. }