eda001e1d8516313782bd317a6ab01d92b953b02
[openwrt.git] / package / system / mtd / src / mtd.c
1 /*
2  * mtd - simple memory technology device manipulation tool
3  *
4  * Copyright (C) 2005      Waldemar Brodkorb <wbx@dass-it.de>,
5  * Copyright (C) 2005-2009 Felix Fietkau <nbd@openwrt.org>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License v2
9  * as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  *
20  *
21  * The code is based on the linux-mtd examples.
22  */
23
24 #define _GNU_SOURCE
25 #include <byteswap.h>
26 #include <limits.h>
27 #include <unistd.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <stdint.h>
31 #include <signal.h>
32 #include <sys/ioctl.h>
33 #include <sys/syscall.h>
34 #include <fcntl.h>
35 #include <errno.h>
36 #include <time.h>
37 #include <string.h>
38 #include <sys/ioctl.h>
39 #include <sys/types.h>
40 #include <sys/param.h>
41 #include <sys/mount.h>
42 #include <sys/stat.h>
43 #include <sys/reboot.h>
44 #include <linux/reboot.h>
45 #include <mtd/mtd-user.h>
46 #include "fis.h"
47 #include "mtd.h"
48
49 #include <libubox/md5.h>
50
51 #define MAX_ARGS 8
52 #define JFFS2_DEFAULT_DIR       "" /* directory name without /, empty means root dir */
53
54 #define TRX_MAGIC               0x48445230      /* "HDR0" */
55 #define SEAMA_MAGIC             0x5ea3a417
56
57 #if !defined(__BYTE_ORDER)
58 #error "Unknown byte order"
59 #endif
60
61 #if __BYTE_ORDER == __BIG_ENDIAN
62 #define cpu_to_be32(x)  (x)
63 #define be32_to_cpu(x)  (x)
64 #elif __BYTE_ORDER == __LITTLE_ENDIAN
65 #define cpu_to_be32(x)  bswap_32(x)
66 #define be32_to_cpu(x)  bswap_32(x)
67 #else
68 #error "Unsupported endianness"
69 #endif
70
71 enum mtd_image_format {
72         MTD_IMAGE_FORMAT_UNKNOWN,
73         MTD_IMAGE_FORMAT_TRX,
74         MTD_IMAGE_FORMAT_SEAMA,
75 };
76
77 static char *buf = NULL;
78 static char *imagefile = NULL;
79 static enum mtd_image_format imageformat = MTD_IMAGE_FORMAT_UNKNOWN;
80 static char *jffs2file = NULL, *jffs2dir = JFFS2_DEFAULT_DIR;
81 static int buflen = 0;
82 int quiet;
83 int no_erase;
84 int mtdsize = 0;
85 int erasesize = 0;
86 int jffs2_skip_bytes=0;
87 int mtdtype = 0;
88
89 int mtd_open(const char *mtd, bool block)
90 {
91         FILE *fp;
92         char dev[PATH_MAX];
93         int i;
94         int ret;
95         int flags = O_RDWR | O_SYNC;
96         char name[PATH_MAX];
97
98         snprintf(name, sizeof(name), "\"%s\"", mtd);
99         if ((fp = fopen("/proc/mtd", "r"))) {
100                 while (fgets(dev, sizeof(dev), fp)) {
101                         if (sscanf(dev, "mtd%d:", &i) && strstr(dev, name)) {
102                                 snprintf(dev, sizeof(dev), "/dev/mtd%s/%d", (block ? "block" : ""), i);
103                                 if ((ret=open(dev, flags))<0) {
104                                         snprintf(dev, sizeof(dev), "/dev/mtd%s%d", (block ? "block" : ""), i);
105                                         ret=open(dev, flags);
106                                 }
107                                 fclose(fp);
108                                 return ret;
109                         }
110                 }
111                 fclose(fp);
112         }
113
114         return open(mtd, flags);
115 }
116
117 int mtd_check_open(const char *mtd)
118 {
119         struct mtd_info_user mtdInfo;
120         int fd;
121
122         fd = mtd_open(mtd, false);
123         if(fd < 0) {
124                 fprintf(stderr, "Could not open mtd device: %s\n", mtd);
125                 return -1;
126         }
127
128         if(ioctl(fd, MEMGETINFO, &mtdInfo)) {
129                 fprintf(stderr, "Could not get MTD device info from %s\n", mtd);
130                 close(fd);
131                 return -1;
132         }
133         mtdsize = mtdInfo.size;
134         erasesize = mtdInfo.erasesize;
135         mtdtype = mtdInfo.type;
136
137         return fd;
138 }
139
140 int mtd_block_is_bad(int fd, int offset)
141 {
142         int r = 0;
143         loff_t o = offset;
144
145         if (mtdtype == MTD_NANDFLASH)
146         {
147                 r = ioctl(fd, MEMGETBADBLOCK, &o);
148                 if (r < 0)
149                 {
150                         fprintf(stderr, "Failed to get erase block status\n");
151                         exit(1);
152                 }
153         }
154         return r;
155 }
156
157 int mtd_erase_block(int fd, int offset)
158 {
159         struct erase_info_user mtdEraseInfo;
160
161         mtdEraseInfo.start = offset;
162         mtdEraseInfo.length = erasesize;
163         ioctl(fd, MEMUNLOCK, &mtdEraseInfo);
164         if (ioctl (fd, MEMERASE, &mtdEraseInfo) < 0)
165                 return -1;
166
167         return 0;
168 }
169
170 int mtd_write_buffer(int fd, const char *buf, int offset, int length)
171 {
172         lseek(fd, offset, SEEK_SET);
173         write(fd, buf, length);
174         return 0;
175 }
176
177 static int
178 image_check(int imagefd, const char *mtd)
179 {
180         uint32_t magic;
181         int ret = 1;
182
183         if (buflen < sizeof(magic)) {
184                 buflen += read(imagefd, buf + buflen, sizeof(magic) - buflen);
185                 if (buflen < sizeof(magic)) {
186                         fprintf(stdout, "Could not get image magic\n");
187                         return 0;
188                 }
189         }
190         magic = ((uint32_t *)buf)[0];
191
192         if (be32_to_cpu(magic) == TRX_MAGIC)
193                 imageformat = MTD_IMAGE_FORMAT_TRX;
194         else if (be32_to_cpu(magic) == SEAMA_MAGIC)
195                 imageformat = MTD_IMAGE_FORMAT_SEAMA;
196
197         switch (imageformat) {
198         case MTD_IMAGE_FORMAT_TRX:
199                 if (trx_check)
200                         ret = trx_check(imagefd, mtd, buf, &buflen);
201                 break;
202         case MTD_IMAGE_FORMAT_SEAMA:
203                 break;
204         default:
205 #ifdef target_brcm
206                 if (!strcmp(mtd, "firmware"))
207                         ret = 0;
208 #endif
209                 break;
210         }
211
212         return ret;
213 }
214
215 static int mtd_check(const char *mtd)
216 {
217         char *next = NULL;
218         char *str = NULL;
219         int fd;
220
221         if (strchr(mtd, ':')) {
222                 str = strdup(mtd);
223                 mtd = str;
224         }
225
226         do {
227                 next = strchr(mtd, ':');
228                 if (next) {
229                         *next = 0;
230                         next++;
231                 }
232
233                 fd = mtd_check_open(mtd);
234                 if (fd < 0)
235                         return 0;
236
237                 if (!buf)
238                         buf = malloc(erasesize);
239
240                 close(fd);
241                 mtd = next;
242         } while (next);
243
244         if (str)
245                 free(str);
246
247         return 1;
248 }
249
250 static int
251 mtd_unlock(const char *mtd)
252 {
253         struct erase_info_user mtdLockInfo;
254         char *next = NULL;
255         char *str = NULL;
256         int fd;
257
258         if (strchr(mtd, ':')) {
259                 str = strdup(mtd);
260                 mtd = str;
261         }
262
263         do {
264                 next = strchr(mtd, ':');
265                 if (next) {
266                         *next = 0;
267                         next++;
268                 }
269
270                 fd = mtd_check_open(mtd);
271                 if(fd < 0) {
272                         fprintf(stderr, "Could not open mtd device: %s\n", mtd);
273                         exit(1);
274                 }
275
276                 if (quiet < 2)
277                         fprintf(stderr, "Unlocking %s ...\n", mtd);
278
279                 mtdLockInfo.start = 0;
280                 mtdLockInfo.length = mtdsize;
281                 ioctl(fd, MEMUNLOCK, &mtdLockInfo);
282                 close(fd);
283                 mtd = next;
284         } while (next);
285
286         if (str)
287                 free(str);
288
289         return 0;
290 }
291
292 static int
293 mtd_erase(const char *mtd)
294 {
295         int fd;
296         struct erase_info_user mtdEraseInfo;
297
298         if (quiet < 2)
299                 fprintf(stderr, "Erasing %s ...\n", mtd);
300
301         fd = mtd_check_open(mtd);
302         if(fd < 0) {
303                 fprintf(stderr, "Could not open mtd device: %s\n", mtd);
304                 exit(1);
305         }
306
307         mtdEraseInfo.length = erasesize;
308
309         for (mtdEraseInfo.start = 0;
310                  mtdEraseInfo.start < mtdsize;
311                  mtdEraseInfo.start += erasesize) {
312                 if (mtd_block_is_bad(fd, mtdEraseInfo.start)) {
313                         if (!quiet)
314                                 fprintf(stderr, "\nSkipping bad block at 0x%x   ", mtdEraseInfo.start);
315                 } else {
316                         ioctl(fd, MEMUNLOCK, &mtdEraseInfo);
317                         if(ioctl(fd, MEMERASE, &mtdEraseInfo))
318                                 fprintf(stderr, "Failed to erase block on %s at 0x%x\n", mtd, mtdEraseInfo.start);
319                 }
320         }
321
322         close(fd);
323         return 0;
324
325 }
326
327 static int
328 mtd_dump(const char *mtd, int part_offset, int size)
329 {
330         int ret = 0, offset = 0;
331         int fd;
332         char *buf;
333
334         if (quiet < 2)
335                 fprintf(stderr, "Dumping %s ...\n", mtd);
336
337         fd = mtd_check_open(mtd);
338         if(fd < 0) {
339                 fprintf(stderr, "Could not open mtd device: %s\n", mtd);
340                 return -1;
341         }
342
343         if (!size)
344                 size = mtdsize;
345
346         if (part_offset)
347                 lseek(fd, part_offset, SEEK_SET);
348
349         buf = malloc(erasesize);
350         if (!buf)
351                 return -1;
352
353         do {
354                 int len = (size > erasesize) ? (erasesize) : (size);
355                 int rlen = read(fd, buf, len);
356
357                 if (rlen < 0) {
358                         if (errno == EINTR)
359                                 continue;
360                         ret = -1;
361                         goto out;
362                 }
363                 if (!rlen || rlen != len)
364                         break;
365                 if (mtd_block_is_bad(fd, offset)) {
366                         fprintf(stderr, "skipping bad block at 0x%08x\n", offset);
367                 } else {
368                         size -= rlen;
369                         write(1, buf, rlen);
370                 }
371                 offset += rlen;
372         } while (size > 0);
373
374 out:
375         close(fd);
376         return ret;
377 }
378
379 static int
380 mtd_verify(const char *mtd, char *file)
381 {
382         uint32_t f_md5[4], m_md5[4];
383         struct stat s;
384         md5_ctx_t ctx;
385         int ret = 0;
386         int fd;
387
388         if (quiet < 2)
389                 fprintf(stderr, "Verifying %s against %s ...\n", mtd, file);
390
391         if (stat(file, &s) || md5sum(file, f_md5) < 0) {
392                 fprintf(stderr, "Failed to hash %s\n", file);
393                 return -1;
394         }
395
396         fd = mtd_check_open(mtd);
397         if(fd < 0) {
398                 fprintf(stderr, "Could not open mtd device: %s\n", mtd);
399                 return -1;
400         }
401
402         md5_begin(&ctx);
403         do {
404                 char buf[256];
405                 int len = (s.st_size > sizeof(buf)) ? (sizeof(buf)) : (s.st_size);
406                 int rlen = read(fd, buf, len);
407
408                 if (rlen < 0) {
409                         if (errno == EINTR)
410                                 continue;
411                         ret = -1;
412                         goto out;
413                 }
414                 if (!rlen)
415                         break;
416                 md5_hash(buf, rlen, &ctx);
417                 s.st_size -= rlen;
418         } while (s.st_size > 0);
419
420         md5_end(m_md5, &ctx);
421
422         fprintf(stderr, "%08x%08x%08x%08x - %s\n", m_md5[0], m_md5[1], m_md5[2], m_md5[3], mtd);
423         fprintf(stderr, "%08x%08x%08x%08x - %s\n", f_md5[0], f_md5[1], f_md5[2], f_md5[3], file);
424
425         ret = memcmp(f_md5, m_md5, sizeof(m_md5));
426         if (!ret)
427                 fprintf(stderr, "Success\n");
428         else
429                 fprintf(stderr, "Failed\n");
430
431 out:
432         close(fd);
433         return ret;
434 }
435
436 static void
437 indicate_writing(const char *mtd)
438 {
439         if (quiet < 2)
440                 fprintf(stderr, "\nWriting from %s to %s ... ", imagefile, mtd);
441
442         if (!quiet)
443                 fprintf(stderr, " [ ]");
444 }
445
446 static int
447 mtd_write(int imagefd, const char *mtd, char *fis_layout, size_t part_offset)
448 {
449         char *next = NULL;
450         char *str = NULL;
451         int fd, result;
452         ssize_t r, w, e;
453         ssize_t skip = 0;
454         uint32_t offset = 0;
455         int jffs2_replaced = 0;
456         int skip_bad_blocks = 0;
457
458 #ifdef FIS_SUPPORT
459         static struct fis_part new_parts[MAX_ARGS];
460         static struct fis_part old_parts[MAX_ARGS];
461         int n_new = 0, n_old = 0;
462
463         if (fis_layout) {
464                 const char *tmp = mtd;
465                 char *word, *brkt;
466                 int ret;
467
468                 memset(&old_parts, 0, sizeof(old_parts));
469                 memset(&new_parts, 0, sizeof(new_parts));
470
471                 do {
472                         next = strchr(tmp, ':');
473                         if (!next)
474                                 next = (char *) tmp + strlen(tmp);
475
476                         memcpy(old_parts[n_old].name, tmp, next - tmp);
477
478                         n_old++;
479                         tmp = next + 1;
480                 } while(*next);
481
482                 for (word = strtok_r(fis_layout, ",", &brkt);
483                      word;
484                          word = strtok_r(NULL, ",", &brkt)) {
485
486                         tmp = strtok(word, ":");
487                         strncpy((char *) new_parts[n_new].name, tmp, sizeof(new_parts[n_new].name) - 1);
488
489                         tmp = strtok(NULL, ":");
490                         if (!tmp)
491                                 goto next;
492
493                         new_parts[n_new].size = strtoul(tmp, NULL, 0);
494
495                         tmp = strtok(NULL, ":");
496                         if (!tmp)
497                                 goto next;
498
499                         new_parts[n_new].loadaddr = strtoul(tmp, NULL, 16);
500 next:
501                         n_new++;
502                 }
503                 ret = fis_validate(old_parts, n_old, new_parts, n_new);
504                 if (ret < 0) {
505                         fprintf(stderr, "Failed to validate the new FIS partition table\n");
506                         exit(1);
507                 }
508                 if (ret == 0)
509                         fis_layout = NULL;
510         }
511 #endif
512
513         if (strchr(mtd, ':')) {
514                 str = strdup(mtd);
515                 mtd = str;
516         }
517
518         r = 0;
519
520 resume:
521         next = strchr(mtd, ':');
522         if (next) {
523                 *next = 0;
524                 next++;
525         }
526
527         fd = mtd_check_open(mtd);
528         if(fd < 0) {
529                 fprintf(stderr, "Could not open mtd device: %s\n", mtd);
530                 exit(1);
531         }
532         if (part_offset > 0) {
533                 fprintf(stderr, "Seeking on mtd device '%s' to: %zu\n", mtd, part_offset);
534                 lseek(fd, part_offset, SEEK_SET);
535         }
536
537         indicate_writing(mtd);
538
539         w = e = 0;
540         for (;;) {
541                 /* buffer may contain data already (from trx check or last mtd partition write attempt) */
542                 while (buflen < erasesize) {
543                         r = read(imagefd, buf + buflen, erasesize - buflen);
544                         if (r < 0) {
545                                 if ((errno == EINTR) || (errno == EAGAIN))
546                                         continue;
547                                 else {
548                                         perror("read");
549                                         break;
550                                 }
551                         }
552
553                         if (r == 0)
554                                 break;
555
556                         buflen += r;
557                 }
558
559                 if (buflen == 0)
560                         break;
561
562                 if (buflen < erasesize) {
563                         /* Pad block to eraseblock size */
564                         memset(&buf[buflen], 0xff, erasesize - buflen);
565                         buflen = erasesize;
566                 }
567
568                 if (skip > 0) {
569                         skip -= buflen;
570                         buflen = 0;
571                         if (skip <= 0)
572                                 indicate_writing(mtd);
573
574                         continue;
575                 }
576
577                 if (jffs2file && w >= jffs2_skip_bytes) {
578                         if (memcmp(buf, JFFS2_EOF, sizeof(JFFS2_EOF) - 1) == 0) {
579                                 if (!quiet)
580                                         fprintf(stderr, "\b\b\b   ");
581                                 if (quiet < 2)
582                                         fprintf(stderr, "\nAppending jffs2 data from %s to %s...", jffs2file, mtd);
583                                 /* got an EOF marker - this is the place to add some jffs2 data */
584                                 skip = mtd_replace_jffs2(mtd, fd, e, jffs2file);
585                                 jffs2_replaced = 1;
586
587                                 /* don't add it again */
588                                 jffs2file = NULL;
589
590                                 w += skip;
591                                 e += skip;
592                                 skip -= buflen;
593                                 buflen = 0;
594                                 offset = 0;
595                                 continue;
596                         }
597                         /* no EOF marker, make sure we figure out the last inode number
598                          * before appending some data */
599                         mtd_parse_jffs2data(buf, jffs2dir);
600                 }
601
602                 /* need to erase the next block before writing data to it */
603                 if(!no_erase)
604                 {
605                         while (w + buflen > e - skip_bad_blocks) {
606                                 if (!quiet)
607                                         fprintf(stderr, "\b\b\b[e]");
608
609                                 if (mtd_block_is_bad(fd, e)) {
610                                         if (!quiet)
611                                                 fprintf(stderr, "\nSkipping bad block at 0x%08zx   ", e);
612
613                                         skip_bad_blocks += erasesize;
614                                         e += erasesize;
615
616                                         // Move the file pointer along over the bad block.
617                                         lseek(fd, erasesize, SEEK_CUR);
618                                         continue;
619                                 }
620
621                                 if (mtd_erase_block(fd, e) < 0) {
622                                         if (next) {
623                                                 if (w < e) {
624                                                         write(fd, buf + offset, e - w);
625                                                         offset = e - w;
626                                                 }
627                                                 w = 0;
628                                                 e = 0;
629                                                 close(fd);
630                                                 mtd = next;
631                                                 fprintf(stderr, "\b\b\b   \n");
632                                                 goto resume;
633                                         } else {
634                                                 fprintf(stderr, "Failed to erase block\n");
635                                                 exit(1);
636                                         }
637                                 }
638
639                                 /* erase the chunk */
640                                 e += erasesize;
641                         }
642                 }
643
644                 if (!quiet)
645                         fprintf(stderr, "\b\b\b[w]");
646
647                 if ((result = write(fd, buf + offset, buflen)) < buflen) {
648                         if (result < 0) {
649                                 fprintf(stderr, "Error writing image.\n");
650                                 exit(1);
651                         } else {
652                                 fprintf(stderr, "Insufficient space.\n");
653                                 exit(1);
654                         }
655                 }
656                 w += buflen;
657
658                 buflen = 0;
659                 offset = 0;
660         }
661
662         if (jffs2_replaced) {
663                 switch (imageformat) {
664                 case MTD_IMAGE_FORMAT_TRX:
665                         if (trx_fixup)
666                                 trx_fixup(fd, mtd);
667                         break;
668                 case MTD_IMAGE_FORMAT_SEAMA:
669                         if (mtd_fixseama)
670                                 mtd_fixseama(mtd, 0);
671                         break;
672                 default:
673                         break;
674                 }
675         }
676
677         if (!quiet)
678                 fprintf(stderr, "\b\b\b\b    ");
679
680         if (quiet < 2)
681                 fprintf(stderr, "\n");
682
683 #ifdef FIS_SUPPORT
684         if (fis_layout) {
685                 if (fis_remap(old_parts, n_old, new_parts, n_new) < 0)
686                         fprintf(stderr, "Failed to update the FIS partition table\n");
687         }
688 #endif
689
690         close(fd);
691         return 0;
692 }
693
694 static void usage(void)
695 {
696         fprintf(stderr, "Usage: mtd [<options> ...] <command> [<arguments> ...] <device>[:<device>...]\n\n"
697         "The device is in the format of mtdX (eg: mtd4) or its label.\n"
698         "mtd recognizes these commands:\n"
699         "        unlock                  unlock the device\n"
700         "        refresh                 refresh mtd partition\n"
701         "        erase                   erase all data on device\n"
702         "        verify <imagefile>|-    verify <imagefile> (use - for stdin) to device\n"
703         "        write <imagefile>|-     write <imagefile> (use - for stdin) to device\n"
704         "        jffs2write <file>       append <file> to the jffs2 partition on the device\n");
705         if (mtd_resetbc) {
706             fprintf(stderr,
707         "        resetbc <device>        reset the uboot boot counter\n");
708         }
709         if (mtd_fixtrx) {
710             fprintf(stderr,
711         "        fixtrx                  fix the checksum in a trx header on first boot\n");
712         }
713         if (mtd_fixseama) {
714             fprintf(stderr,
715         "        fixseama                fix the checksum in a seama header on first boot\n");
716         }
717         fprintf(stderr,
718         "Following options are available:\n"
719         "        -q                      quiet mode (once: no [w] on writing,\n"
720         "                                           twice: no status messages)\n"
721         "        -n                      write without first erasing the blocks\n"
722         "        -r                      reboot after successful command\n"
723         "        -f                      force write without trx checks\n"
724         "        -e <device>             erase <device> before executing the command\n"
725         "        -d <name>               directory for jffs2write, defaults to \"tmp\"\n"
726         "        -j <name>               integrate <file> into jffs2 data when writing an image\n"
727         "        -s <number>             skip the first n bytes when appending data to the jffs2 partiton, defaults to \"0\"\n"
728         "        -p                      write beginning at partition offset\n"
729         "        -l <length>             the length of data that we want to dump\n");
730         if (mtd_fixtrx) {
731             fprintf(stderr,
732         "        -o offset               offset of the image header in the partition(for fixtrx)\n");
733         }
734         fprintf(stderr,
735 #ifdef FIS_SUPPORT
736         "        -F <part>[:<size>[:<entrypoint>]][,<part>...]\n"
737         "                                alter the fis partition table to create new partitions replacing\n"
738         "                                the partitions provided as argument to the write command\n"
739         "                                (only valid together with the write command)\n"
740 #endif
741         "\n"
742         "Example: To write linux.trx to mtd4 labeled as linux and reboot afterwards\n"
743         "         mtd -r write linux.trx linux\n\n");
744         exit(1);
745 }
746
747 static void do_reboot(void)
748 {
749         fprintf(stderr, "Rebooting ...\n");
750         fflush(stderr);
751
752         /* try regular reboot method first */
753         system("/sbin/reboot");
754         sleep(2);
755
756         /* if we're still alive at this point, force the kernel to reboot */
757         syscall(SYS_reboot,LINUX_REBOOT_MAGIC1,LINUX_REBOOT_MAGIC2,LINUX_REBOOT_CMD_RESTART,NULL);
758 }
759
760 int main (int argc, char **argv)
761 {
762         int ch, i, boot, imagefd = 0, force, unlocked;
763         char *erase[MAX_ARGS], *device = NULL;
764         char *fis_layout = NULL;
765         size_t offset = 0, part_offset = 0, dump_len = 0;
766         enum {
767                 CMD_ERASE,
768                 CMD_WRITE,
769                 CMD_UNLOCK,
770                 CMD_JFFS2WRITE,
771                 CMD_FIXTRX,
772                 CMD_FIXSEAMA,
773                 CMD_VERIFY,
774                 CMD_DUMP,
775                 CMD_RESETBC,
776         } cmd = -1;
777
778         erase[0] = NULL;
779         boot = 0;
780         force = 0;
781         buflen = 0;
782         quiet = 0;
783         no_erase = 0;
784
785         while ((ch = getopt(argc, argv,
786 #ifdef FIS_SUPPORT
787                         "F:"
788 #endif
789                         "frnqe:d:s:j:p:o:l:")) != -1)
790                 switch (ch) {
791                         case 'f':
792                                 force = 1;
793                                 break;
794                         case 'r':
795                                 boot = 1;
796                                 break;
797                         case 'n':
798                                 no_erase = 1;
799                                 break;
800                         case 'j':
801                                 jffs2file = optarg;
802                                 break;
803                         case 's':
804                                 errno = 0;
805                                 jffs2_skip_bytes = strtoul(optarg, 0, 0);
806                                 if (errno) {
807                                                 fprintf(stderr, "-s: illegal numeric string\n");
808                                                 usage();
809                                 }
810                                 break;
811                         case 'q':
812                                 quiet++;
813                                 break;
814                         case 'e':
815                                 i = 0;
816                                 while ((erase[i] != NULL) && ((i + 1) < MAX_ARGS))
817                                         i++;
818
819                                 erase[i++] = optarg;
820                                 erase[i] = NULL;
821                                 break;
822                         case 'd':
823                                 jffs2dir = optarg;
824                                 break;
825                         case 'p':
826                                 errno = 0;
827                                 part_offset = strtoul(optarg, 0, 0);
828                                 if (errno) {
829                                         fprintf(stderr, "-p: illegal numeric string\n");
830                                         usage();
831                                 }
832                                 break;
833                         case 'l':
834                                 errno = 0;
835                                 dump_len = strtoul(optarg, 0, 0);
836                                 if (errno) {
837                                         fprintf(stderr, "-l: illegal numeric string\n");
838                                         usage();
839                                 }
840                                 break;
841                         case 'o':
842                                 errno = 0;
843                                 offset = strtoul(optarg, 0, 0);
844                                 if (errno) {
845                                         fprintf(stderr, "-o: illegal numeric string\n");
846                                         usage();
847                                 }
848                                 break;
849 #ifdef FIS_SUPPORT
850                         case 'F':
851                                 fis_layout = optarg;
852                                 break;
853 #endif
854                         case '?':
855                         default:
856                                 usage();
857                 }
858         argc -= optind;
859         argv += optind;
860
861         if (argc < 2)
862                 usage();
863
864         if ((strcmp(argv[0], "unlock") == 0) && (argc == 2)) {
865                 cmd = CMD_UNLOCK;
866                 device = argv[1];
867         } else if ((strcmp(argv[0], "erase") == 0) && (argc == 2)) {
868                 cmd = CMD_ERASE;
869                 device = argv[1];
870         } else if (((strcmp(argv[0], "resetbc") == 0) && (argc == 2)) && mtd_resetbc) {
871                 cmd = CMD_RESETBC;
872                 device = argv[1];
873         } else if (((strcmp(argv[0], "fixtrx") == 0) && (argc == 2)) && mtd_fixtrx) {
874                 cmd = CMD_FIXTRX;
875                 device = argv[1];
876         } else if (((strcmp(argv[0], "fixseama") == 0) && (argc == 2)) && mtd_fixseama) {
877                 cmd = CMD_FIXSEAMA;
878                 device = argv[1];
879         } else if ((strcmp(argv[0], "verify") == 0) && (argc == 3)) {
880                 cmd = CMD_VERIFY;
881                 imagefile = argv[1];
882                 device = argv[2];
883         } else if ((strcmp(argv[0], "dump") == 0) && (argc == 2)) {
884                 cmd = CMD_DUMP;
885                 device = argv[1];
886         } else if ((strcmp(argv[0], "write") == 0) && (argc == 3)) {
887                 cmd = CMD_WRITE;
888                 device = argv[2];
889
890                 if (strcmp(argv[1], "-") == 0) {
891                         imagefile = "<stdin>";
892                         imagefd = 0;
893                 } else {
894                         imagefile = argv[1];
895                         if ((imagefd = open(argv[1], O_RDONLY)) < 0) {
896                                 fprintf(stderr, "Couldn't open image file: %s!\n", imagefile);
897                                 exit(1);
898                         }
899                 }
900
901                 if (!mtd_check(device)) {
902                         fprintf(stderr, "Can't open device for writing!\n");
903                         exit(1);
904                 }
905                 /* check trx file before erasing or writing anything */
906                 if (!image_check(imagefd, device) && !force) {
907                         fprintf(stderr, "Image check failed.\n");
908                         exit(1);
909                 }
910         } else if ((strcmp(argv[0], "jffs2write") == 0) && (argc == 3)) {
911                 cmd = CMD_JFFS2WRITE;
912                 device = argv[2];
913
914                 imagefile = argv[1];
915                 if (!mtd_check(device)) {
916                         fprintf(stderr, "Can't open device for writing!\n");
917                         exit(1);
918                 }
919         } else {
920                 usage();
921         }
922
923         sync();
924
925         i = 0;
926         unlocked = 0;
927         while (erase[i] != NULL) {
928                 mtd_unlock(erase[i]);
929                 mtd_erase(erase[i]);
930                 if (strcmp(erase[i], device) == 0)
931                         unlocked = 1;
932                 i++;
933         }
934
935         switch (cmd) {
936                 case CMD_UNLOCK:
937                         if (!unlocked)
938                                 mtd_unlock(device);
939                         break;
940                 case CMD_VERIFY:
941                         mtd_verify(device, imagefile);
942                         break;
943                 case CMD_DUMP:
944                         mtd_dump(device, offset, dump_len);
945                         break;
946                 case CMD_ERASE:
947                         if (!unlocked)
948                                 mtd_unlock(device);
949                         mtd_erase(device);
950                         break;
951                 case CMD_WRITE:
952                         if (!unlocked)
953                                 mtd_unlock(device);
954                         mtd_write(imagefd, device, fis_layout, part_offset);
955                         break;
956                 case CMD_JFFS2WRITE:
957                         if (!unlocked)
958                                 mtd_unlock(device);
959                         mtd_write_jffs2(device, imagefile, jffs2dir);
960                         break;
961                 case CMD_FIXTRX:
962                     if (mtd_fixtrx) {
963                             mtd_fixtrx(device, offset);
964             }
965                 case CMD_RESETBC:
966                     if (mtd_resetbc) {
967                             mtd_resetbc(device);
968             }
969                 case CMD_FIXSEAMA:
970                         if (mtd_fixseama)
971                             mtd_fixseama(device, 0);
972                         break;
973         }
974
975         sync();
976
977         if (boot)
978                 do_reboot();
979
980         return 0;
981 }