Category
Home > Category > Code/Resource > Embeded-SCM Develop > View Code

nandwrite.c

Package [view]: mtd-snapshot-2004102
Upload User: allywll
Upload Date: 2007-11-10
Package Size: 1288k
Code Size: 10k
Category: Embeded-SCM Develop
Development Platform: Others
nandwrite.c：Code Content
  1. /*
  2.  *  nandwrite.c
  3.  *
  4.  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
  5.  *      2003 Thomas Gleixner (tglx@linutronix.de)
  6.  *
  7.  * $Id: nandwrite.c,v 1.17 2004/10/24 14:57:20 gleixner Exp $
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License version 2 as
  11.  * published by the Free Software Foundation.
  12.  *
  13.  * Overview:
  14.  *   This utility writes a binary image directly to a NAND flash
  15.  *   chip or NAND chips contained in DoC devices. This is the
  16.  *   "inverse operation" of nanddump.
  17.  *
  18.  * tglx: Major rewrite to handle bad blocks, write data with or without ECC
  19.  *  write oob data only on request
  20.  *
  21.  * Bug/ToDo:
  22.  */
  24. #define _GNU_SOURCE
  25. #include <ctype.h>
  26. #include <fcntl.h>
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <time.h>
  31. #include <unistd.h>
  32. #include <sys/stat.h>
  33. #include <sys/ioctl.h>
  34. #include <sys/types.h>
  35. #include <getopt.h>
  37. #include <asm/types.h>
  38. #include "mtd/mtd-user.h"
  40. #define PROGRAM "nandwrite"
  41. #define VERSION "1.14"
  43. /*
  44.  * Buffer array used for writing data
  45.  */
  46. unsigned char writebuf[512];
  47. unsigned char oobbuf[16];
  49. // oob layouts to pass into the kernel as default
  50. struct nand_oobinfo none_oobinfo = { 
  51. .useecc = MTD_NANDECC_OFF,
  52. };
  54. struct nand_oobinfo jffs2_oobinfo = { 
  55. .useecc = MTD_NANDECC_PLACE,
  56. .eccbytes = 6,
  57. .eccpos = { 0, 1, 2, 3, 6, 7 }
  58. };
  60. struct nand_oobinfo yaffs_oobinfo = { 
  61. .useecc = MTD_NANDECC_PLACE,
  62. .eccbytes = 6,
  63. .eccpos = { 8, 9, 10, 13, 14, 15}
  64. };
  66. struct nand_oobinfo autoplace_oobinfo = {
  67. .useecc = MTD_NANDECC_AUTOPLACE
  68. };
  70. void display_help (void)
  71. {
  72. printf("Usage: nandwrite [OPTION] MTD_DEVICE INPUTFILEn"
  73.        "Writes to the specified MTD device.n"
  74.        "n"
  75.        "  -a, --autoplace   Use auto oob layoutn"
  76.        "  -j, --jffs2     force jffs2 oob layoutn"
  77.        "  -y, --yaffs     force yaffs oob layoutn"
  78.        "  -n, --noecc write without eccn"
  79.        "  -o, --oob       image contains oob datan"
  80.        "  -s addr, --start=addr set start address (default is 0)n"
  81.        "  -p, --pad             pad to page sizen"
  82.        "  -b, --blockalign=1|2|4 set multiple of eraseblocks to align ton"
  83.        "  -q, --quiet     don't display progress messagesn"
  84.        "      --help      display this help and exitn"
  85.        "      --version   output version information and exitn");
  86. exit(0);
  87. }
  89. void display_version (void)
  90. {
  91. printf(PROGRAM " " VERSION "n"
  92.        "n"
  93.        "Copyright (C) 2003 Thomas Gleixner n"
  94.        "n"
  95.        PROGRAM " comes with NO WARRANTYn"
  96.        "to the extent permitted by law.n"
  97.        "n"
  98.        "You may redistribute copies of " PROGRAM "n"
  99.        "under the terms of the GNU General Public Licence.n"
  100.        "See the file `COPYING' for more information.n");
  101. exit(0);
  102. }
  104. char  *mtd_device, *img;
  105. int  mtdoffset = 0;
  106. int  quiet = 0;
  107. int writeoob = 0;
  108. int autoplace = 0;
  109. int forcejffs2 = 0;
  110. int forceyaffs = 0;
  111. int noecc = 0;
  112. int pad = 0;
  113. int blockalign = 1; /*default to using 16K block size */
  115. void process_options (int argc, char *argv[])
  116. {
  117. int error = 0;
  119. for (;;) {
  120. int option_index = 0;
  121. static const char *short_options = "os:ajynqp";
  122. static const struct option long_options[] = {
  123. {"help", no_argument, 0, 0},
  124. {"version", no_argument, 0, 0},
  125. {"oob", no_argument, 0, 'o'},
  126. {"start", required_argument, 0, 's'},
  127. {"autoplace", no_argument, 0, 'a'},
  128. {"jffs2", no_argument, 0, 'j'},
  129. {"yaffs", no_argument, 0, 'y'},
  130. {"noecc", no_argument, 0, 'n'},
  131. {"quiet", no_argument, 0, 'q'},
  132. {"pad", no_argument, 0, 'p'},
  133.     {"blockalign", required_argument, 0, 'b'},
  134. {0, 0, 0, 0},
  135. };
  137. int c = getopt_long(argc, argv, short_options,
  138.     long_options, &option_index);
  139. if (c == EOF) {
  140. break;
  141. }
  143. switch (c) {
  144. case 0:
  145. switch (option_index) {
  146. case 0:
  147. display_help();
  148. break;
  149. case 1:
  150. display_version();
  151. break;
  152. }
  153. break;
  154. case 'q':
  155. quiet = 1;
  156. break;
  157. case 'a':
  158. autoplace = 1;
  159. break;
  160. case 'j':
  161. forcejffs2 = 1;
  162. break;
  163. case 'y':
  164. forceyaffs = 1;
  165. break;
  166. case 'n':
  167. noecc = 1;
  168. break;
  169. case 'o':
  170. writeoob = 1;
  171. break;
  172. case 'p':
  173. pad = 1;
  174. break;
  175. case 's':
  176. mtdoffset = atoi (optarg);
  177. break;
  178. case 'b':
  179. blockalign = atoi (optarg);
  180. break;
  181. case '?':
  182. error = 1;
  183. break;
  184. }
  185. }
  187. if ((argc - optind) != 2 || error) 
  188. display_help ();
  190. mtd_device = argv[optind++];
  191. img = argv[optind];
  192. }
  194. /*
  195.  * Main program
  196.  */
  197. int main(int argc, char **argv)
  198. {
  199. int cnt, fd, ifd, imglen = 0, pagelen, baderaseblock, blockstart = -1;
  200. struct mtd_info_user meminfo;
  201. struct mtd_oob_buf oob;
  202. loff_t offs;
  203. int ret, readlen;
  204. int oobinfochanged = 0;
  205. struct nand_oobinfo old_oobinfo;
  207. process_options(argc, argv);
  209. if (pad && writeoob) {
  210. fprintf(stderr, "Can't pad when oob data is present.n");
  211. exit(1);
  212. }
  214. /* Open the device */
  215. if ((fd = open(mtd_device, O_RDWR)) == -1) {
  216. perror("open flash");
  217. exit(1);
  218. }
  220. /* Fill in MTD device capability structure */  
  221. if (ioctl(fd, MEMGETINFO, &meminfo) != 0) {
  222. perror("MEMGETINFO");
  223. close(fd);
  224. exit(1);
  225. }
  227.         /* Set erasesize to specified number of blocks - to match jffs2 (virtual) block size */
  228.         meminfo.erasesize *= blockalign;
  229.      
  230. /* Make sure device page sizes are valid */
  231. if (!(meminfo.oobsize == 16 && meminfo.oobblock == 512) &&
  232.     !(meminfo.oobsize == 8 && meminfo.oobblock == 256) && 
  233.     !(meminfo.oobsize == 64 && meminfo.oobblock == 2048)) {
  234. fprintf(stderr, "Unknown flash (not normal NAND)n");
  235. close(fd);
  236. exit(1);
  237. }
  239. /* Read the current oob info */
  240. if (ioctl (fd, MEMGETOOBSEL, &old_oobinfo) != 0) {
  241. perror ("MEMGETOOBSEL");
  242. close (fd);
  243. exit (1);
  244. } 
  246. // write without ecc ?
  247. if (noecc) {
  248. if (ioctl (fd, MEMSETOOBSEL, &none_oobinfo) != 0) {
  249. perror ("MEMSETOOBSEL");
  250. close (fd);
  251. exit (1);
  252. }
  253. oobinfochanged = 1;
  254. }
  256. // autoplace ECC ?
  257. if (autoplace && (old_oobinfo.useecc != MTD_NANDECC_AUTOPLACE)) {
  259. if (ioctl (fd, MEMSETOOBSEL, &autoplace_oobinfo) != 0) {
  260. perror ("MEMSETOOBSEL");
  261. close (fd);
  262. exit (1);
  263. } 
  264. oobinfochanged = 1;
  265. }
  267. // force oob layout for jffs2 or yaffs ?
  268. if (forcejffs2 || forceyaffs) {
  269. struct nand_oobinfo *oobsel = forcejffs2 ? &jffs2_oobinfo : &yaffs_oobinfo;
  271. if (forceyaffs && meminfo.oobsize == 8) {
  272.      if (forceyaffs) {
  273. fprintf (stderr, "YAFSS cannot operate on 256 Byte page size");
  274. goto restoreoob;
  275. }
  276. /* Adjust number of ecc bytes */
  277. jffs2_oobinfo.eccbytes = 3;
  278. }
  280. if (ioctl (fd, MEMSETOOBSEL, oobsel) != 0) {
  281. perror ("MEMSETOOBSEL");
  282. goto restoreoob;
  283. } 
  284. }
  286. oob.length = meminfo.oobsize;
  287. oob.ptr = oobbuf;
  289. /* Open the input file */
  290. if ((ifd = open(img, O_RDONLY)) == -1) {
  291. perror("open input file");
  292. goto restoreoob;
  293. }
  295. // get image length
  296.     imglen = lseek(ifd, 0, SEEK_END);
  297. lseek (ifd, 0, SEEK_SET);
  299. pagelen = meminfo.oobblock + ((writeoob == 1) ? meminfo.oobsize : 0);
  301. // Check, if file is pagealigned
  302. if ((!pad) && ((imglen % pagelen) != 0)) {
  303. perror ("Input file is not page aligned");
  304. goto closeall;
  305. }
  307. // Check, if length fits into device
  308. if ( ((imglen / pagelen) * meminfo.oobblock) > (meminfo.size - mtdoffset)) {
  309. perror ("Input file does not fit into device");
  310. goto closeall;
  311. }
  313. /* Get data from input and write to the device */
  314. while (imglen && (mtdoffset < meminfo.size)) {
  315. // new eraseblock , check for bad block(s)
  316. // Stay in the loop to be sure if the mtdoffset changes because
  317. // of a bad block, that the next block that will be written to
  318. // is also checked. Thus avoiding errors if the block(s) after the 
  319. // skipped block(s) is also bad (number of blocks depending on 
  320. // the blockalign
  321. while (blockstart != (mtdoffset & (~meminfo.erasesize + 1))) {
  322. blockstart = mtdoffset & (~meminfo.erasesize + 1);
  323. offs = blockstart;
  324.         baderaseblock = 0;
  325. if (!quiet)
  326. fprintf (stdout, "Writing data to block %xn", blockstart);
  327.    
  328.         /* Check all the blocks in an erase block for bad blocks */
  329. do {
  330.     if ((ret = ioctl(fd, MEMGETBADBLOCK, &offs)) < 0) {
  331. perror("ioctl(MEMGETBADBLOCK)");
  332. goto closeall;
  333. }
  334. if (ret == 1) {
  335. baderaseblock = 1;
  336.     if (!quiet)
  337. fprintf (stderr, "Bad block at %x, %u block(s) from %x will be skippedn", (int) offs, blockalign, blockstart);
  338. }
  339.    
  340. if (baderaseblock) {    
  341. mtdoffset = blockstart + meminfo.erasesize;
  342. }
  343.         offs +=  meminfo.erasesize / blockalign ;
  344. } while ( offs < blockstart + meminfo.erasesize );
  345.  
  346. }
  348. readlen = meminfo.oobblock;
  349. if (pad && (imglen < readlen))
  350. {
  351. readlen = imglen;
  352. memset(writebuf + readlen, 0xff, meminfo.oobblock - readlen);
  353. }
  355. /* Read Page Data from input file */
  356. if ((cnt = read(ifd, writebuf, readlen)) != readlen) {
  357. if (cnt == 0) // EOF
  358. break;
  359. perror ("File I/O error on input file");
  360. goto closeall;
  361. }
  363. if (writeoob) {
  364. /* Read OOB data from input file, exit on failure */
  365. if ((cnt = read(ifd, oobbuf, meminfo.oobsize)) != meminfo.oobsize) {
  366. perror ("File I/O error on input file");
  367. goto closeall;
  368. }
  369. /* Write OOB data first, as ecc will be placed in there*/
  370. oob.start = mtdoffset;
  371. if (ioctl(fd, MEMWRITEOOB, &oob) != 0) {
  372. perror ("ioctl(MEMWRITEOOB)");
  373. goto closeall;
  374. }
  375. imglen -= meminfo.oobsize;
  376. }
  378. /* Write out the Page data */
  379. if (pwrite(fd, writebuf, meminfo.oobblock, mtdoffset) != meminfo.oobblock) {
  380. perror ("pwrite");
  381. goto closeall;
  382. }
  383. imglen -= readlen;
  384. mtdoffset += meminfo.oobblock;
  385. }
  387.  closeall:
  388. close(ifd);
  390.  restoreoob:
  391. if (oobinfochanged) {
  392. if (ioctl (fd, MEMSETOOBSEL, &old_oobinfo) != 0) {
  393. perror ("MEMSETOOBSEL");
  394. close (fd);
  395. exit (1);
  396. } 
  397. }
  399. close(fd);
  401. if (imglen > 0) {
  402. perror ("Data did not fit into device, due to bad blocksn");
  403. exit (1);
  404. }
  406. /* Return happy */
  407. return 0;
  408. }