miscutils/nandwrite.c

   1 /*
   2  * nandwrite and nanddump ported to busybox from mtd-utils
   3  *
   4  * Author: Baruch Siach <baruch@tkos.co.il>, Orex Computed Radiography
   5  *
   6  * Licensed under GPLv2, see file LICENSE in this source tree.
   7  *
   8  * TODO: add support for large (>4GB) MTD devices
   9  */
  10
  11 //applet:IF_NANDWRITE(APPLET(nandwrite, BB_DIR_USR_SBIN, BB_SUID_DROP))
  12 //applet:IF_NANDWRITE(APPLET_ODDNAME(nanddump, nandwrite, BB_DIR_USR_SBIN, BB_SUID_DROP, nanddump))
  13
  14 //kbuild:lib-$(CONFIG_NANDWRITE) += nandwrite.o
  15 //kbuild:lib-$(CONFIG_NANDDUMP) += nandwrite.o
  16
  17 //config:config NANDWRITE
  18 //config:       bool "nandwrite"
  19 //config:       default n
  20 //config:       select PLATFORM_LINUX
  21 //config:       help
  22 //config:         Write to the specified MTD device, with bad blocks awareness
  23 //config:
  24 //config:config NANDDUMP
  25 //config:       bool "nanddump"
  26 //config:       default n
  27 //config:       select PLATFORM_LINUX
  28 //config:       help
  29 //config:         Dump the content of raw NAND chip
  30
  31 //usage:#define nandwrite_trivial_usage
  32 //usage:        "[-p] [-s ADDR] MTD_DEVICE [FILE]"
  33 //usage:#define nandwrite_full_usage "\n\n"
  34 //usage:        "Write to the specified MTD device\n"
  35 //usage:     "\nOptions:"
  36 //usage:     "\n        -p      Pad to page size"
  37 //usage:     "\n        -s ADDR Start address"
  38
  39 //usage:#define nanddump_trivial_usage
  40 //usage:        "[-o] [-b] [-s ADDR] [-f FILE] MTD_DEVICE"
  41 //usage:#define nanddump_full_usage "\n\n"
  42 //usage:        "Dump the sepcified MTD device\n"
  43 //usage:     "\nOptions:"
  44 //usage:     "\n        -o      Omit oob data"
  45 //usage:     "\n        -b      Omit bad block from the dump"
  46 //usage:     "\n        -s ADDR Start address"
  47 //usage:     "\n        -l LEN  Length"
  48 //usage:     "\n        -f FILE Dump to file ('-' for stdout)"
  49
  50 #include "libbb.h"
  51 #include <mtd/mtd-user.h>
  52
  53 #define IS_NANDDUMP  (ENABLE_NANDDUMP && (!ENABLE_NANDWRITE || (applet_name[4] == 'd')))
  54 #define IS_NANDWRITE (ENABLE_NANDWRITE && (!ENABLE_NANDDUMP || (applet_name[4] != 'd')))
  55
  56 #define OPT_p  (1 << 0) /* nandwrite only */
  57 #define OPT_o  (1 << 0) /* nanddump only */
  58 #define OPT_s  (1 << 1)
  59 #define OPT_b  (1 << 2)
  60 #define OPT_f  (1 << 3)
  61 #define OPT_l  (1 << 4)
  62
  63 /* helper for writing out 0xff for bad blocks pad */
  64 static void dump_bad(struct mtd_info_user *meminfo, unsigned len, int oob)
  65 {
  66         unsigned char buf[meminfo->writesize];
  67         unsigned count;
  68
  69         /* round len to the next page */
  70         len = (len | ~(meminfo->writesize - 1)) + 1;
  71
  72         memset(buf, 0xff, sizeof(buf));
  73         for (count = 0; count < len; count += meminfo->writesize) {
  74                 xwrite(STDOUT_FILENO, buf, meminfo->writesize);
  75                 if (oob)
  76                         xwrite(STDOUT_FILENO, buf, meminfo->oobsize);
  77         }
  78 }
  79
  80 static unsigned next_good_eraseblock(int fd, struct mtd_info_user *meminfo,
  81                 unsigned block_offset)
  82 {
  83         while (1) {
  84                 loff_t offs;
  85
  86                 if (block_offset >= meminfo->size) {
  87                         if (IS_NANDWRITE)
  88                                 bb_error_msg_and_die("not enough space in MTD device");
  89                         return block_offset; /* let the caller exit */
  90                 }
  91                 offs = block_offset;
  92                 if (xioctl(fd, MEMGETBADBLOCK, &offs) == 0)
  93                         return block_offset;
  94                 /* ioctl returned 1 => "bad block" */
  95                 if (IS_NANDWRITE)
  96                         printf("Skipping bad block at 0x%08x\n", block_offset);
  97                 block_offset += meminfo->erasesize;
  98         }
  99 }
 100
 101 int nandwrite_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 102 int nandwrite_main(int argc UNUSED_PARAM, char **argv)
 103 {
 104         /* Buffer for OOB data */
 105         unsigned char *oobbuf;
 106         unsigned opts;
 107         int fd;
 108         ssize_t cnt;
 109         unsigned mtdoffset, meminfo_writesize, blockstart, limit;
 110         unsigned end_addr = ~0;
 111         struct mtd_info_user meminfo;
 112         struct mtd_oob_buf oob;
 113         unsigned char *filebuf;
 114         const char *opt_s = "0", *opt_f = "-", *opt_l;
 115
 116         if (IS_NANDDUMP) {
 117                 opt_complementary = "=1";
 118                 opts = getopt32(argv, "os:bf:l:", &opt_s, &opt_f, &opt_l);
 119         } else { /* nandwrite */
 120                 opt_complementary = "-1:?2";
 121                 opts = getopt32(argv, "ps:", &opt_s);
 122         }
 123         argv += optind;
 124
 125         if (IS_NANDWRITE && argv[1])
 126                 opt_f = argv[1];
 127         if (!LONE_DASH(opt_f)) {
 128                 int tmp_fd = xopen(opt_f,
 129                         IS_NANDDUMP ? O_WRONLY | O_TRUNC | O_CREAT : O_RDONLY
 130                 );
 131                 xmove_fd(tmp_fd, IS_NANDDUMP ? STDOUT_FILENO : STDIN_FILENO);
 132         }
 133
 134         fd = xopen(argv[0], O_RDWR);
 135         xioctl(fd, MEMGETINFO, &meminfo);
 136
 137         mtdoffset = xstrtou(opt_s, 0);
 138         if (IS_NANDDUMP && (opts & OPT_l)) {
 139                 unsigned length = xstrtou(opt_l, 0);
 140                 if (length < meminfo.size - mtdoffset)
 141                         end_addr = mtdoffset + length;
 142         }
 143
 144         /* Pull it into a CPU register (hopefully) - smaller code that way */
 145         meminfo_writesize = meminfo.writesize;
 146
 147         if (mtdoffset & (meminfo_writesize - 1))
 148                 bb_error_msg_and_die("start address is not page aligned");
 149
 150         filebuf = xmalloc(meminfo_writesize);
 151         oobbuf = xmalloc(meminfo.oobsize);
 152
 153         oob.start  = 0;
 154         oob.length = meminfo.oobsize;
 155         oob.ptr    = oobbuf;
 156
 157         blockstart = mtdoffset & ~(meminfo.erasesize - 1);
 158         if (blockstart != mtdoffset) {
 159                 unsigned tmp;
 160                 /* mtdoffset is in the middle of an erase block, verify that
 161                  * this block is OK. Advance mtdoffset only if this block is
 162                  * bad.
 163                  */
 164                 tmp = next_good_eraseblock(fd, &meminfo, blockstart);
 165                 if (tmp != blockstart) {
 166                         /* bad block(s), advance mtdoffset */
 167                         if (IS_NANDDUMP & !(opts & OPT_b)) {
 168                                 int bad_len = MIN(tmp, end_addr) - mtdoffset;
 169                                 dump_bad(&meminfo, bad_len, !(opts & OPT_o));
 170                         }
 171                         mtdoffset = tmp;
 172                 }
 173         }
 174
 175         cnt = -1;
 176         limit = MIN(meminfo.size, end_addr);
 177         while (mtdoffset < limit) {
 178                 int input_fd = IS_NANDWRITE ? STDIN_FILENO : fd;
 179                 int output_fd = IS_NANDWRITE ? fd : STDOUT_FILENO;
 180
 181                 blockstart = mtdoffset & ~(meminfo.erasesize - 1);
 182                 if (blockstart == mtdoffset) {
 183                         /* starting a new eraseblock */
 184                         mtdoffset = next_good_eraseblock(fd, &meminfo, blockstart);
 185                         if (IS_NANDWRITE)
 186                                 printf("Writing at 0x%08x\n", mtdoffset);
 187                         else if (mtdoffset > blockstart) {
 188                                 int bad_len = MIN(mtdoffset, limit) - blockstart;
 189                                 dump_bad(&meminfo, bad_len, !(opts & OPT_o));
 190                         }
 191                         if (mtdoffset >= limit)
 192                                 break;
 193                 }
 194                 xlseek(fd, mtdoffset, SEEK_SET);
 195
 196                 /* get some more data from input */
 197                 cnt = full_read(input_fd, filebuf, meminfo_writesize);
 198                 if (cnt == 0) {
 199                         /* even with -p, we do not pad past the end of input
 200                          * (-p only zero-pads last incomplete page)
 201                          */
 202                         break;
 203                 }
 204                 if (cnt < meminfo_writesize) {
 205                         if (IS_NANDDUMP)
 206                                 bb_error_msg_and_die("short read");
 207                         if (!(opts & OPT_p))
 208                                 bb_error_msg_and_die("input size is not rounded up to page size, "
 209                                                 "use -p to zero pad");
 210                         /* zero pad to end of write block */
 211                         memset(filebuf + cnt, 0, meminfo_writesize - cnt);
 212                 }
 213                 xwrite(output_fd, filebuf, meminfo_writesize);
 214
 215                 if (IS_NANDDUMP && !(opts & OPT_o)) {
 216                         /* Dump OOB data */
 217                         oob.start = mtdoffset;
 218                         xioctl(fd, MEMREADOOB, &oob);
 219                         xwrite(output_fd, oobbuf, meminfo.oobsize);
 220                 }
 221
 222                 mtdoffset += meminfo_writesize;
 223                 if (cnt < meminfo_writesize)
 224                         break;
 225         }
 226
 227         if (IS_NANDWRITE && cnt != 0) {
 228                 /* We filled entire MTD, but did we reach EOF on input? */
 229                 if (full_read(STDIN_FILENO, filebuf, meminfo_writesize) != 0) {
 230                         /* no */
 231                         bb_error_msg_and_die("not enough space in MTD device");
 232                 }
 233         }
 234
 235         if (ENABLE_FEATURE_CLEAN_UP) {
 236                 free(filebuf);
 237                 close(fd);
 238         }
 239
 240         return EXIT_SUCCESS;
 241 }