]>
Commit | Line | Data |
---|---|---|
dc7c9a1a WD |
1 | /* |
2 | * Driver for NAND support, Rick Bronson | |
3 | * borrowed heavily from: | |
4 | * (c) 1999 Machine Vision Holdings, Inc. | |
5 | * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org> | |
384cc687 | 6 | * |
c9f7351b BG |
7 | * Ported 'dynenv' to 'nand env.oob' command |
8 | * (C) 2010 Nanometrics, Inc. | |
9 | * 'dynenv' -- Dynamic environment offset in NAND OOB | |
10 | * (C) Copyright 2006-2007 OpenMoko, Inc. | |
384cc687 WD |
11 | * Added 16-bit nand support |
12 | * (C) 2004 Texas Instruments | |
ea533c26 | 13 | * |
418396e2 | 14 | * Copyright 2010, 2012 Freescale Semiconductor |
ea533c26 SW |
15 | * The portions of this file whose copyright is held by Freescale and which |
16 | * are not considered a derived work of GPL v2-only code may be distributed | |
17 | * and/or modified under the terms of the GNU General Public License as | |
18 | * published by the Free Software Foundation; either version 2 of the | |
19 | * License, or (at your option) any later version. | |
dc7c9a1a WD |
20 | */ |
21 | ||
22 | #include <common.h> | |
cfa460ad | 23 | #include <linux/mtd/mtd.h> |
addb2e16 BS |
24 | #include <command.h> |
25 | #include <watchdog.h> | |
26 | #include <malloc.h> | |
27 | #include <asm/byteorder.h> | |
addb2e16 BS |
28 | #include <jffs2/jffs2.h> |
29 | #include <nand.h> | |
30 | ||
0c8a8491 | 31 | #if defined(CONFIG_CMD_MTDPARTS) |
856f0544 | 32 | |
445093d1 | 33 | /* partition handling routines */ |
856f0544 SR |
34 | int mtdparts_init(void); |
35 | int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num); | |
36 | int find_dev_and_part(const char *id, struct mtd_device **dev, | |
4b070809 | 37 | u8 *part_num, struct part_info **part); |
856f0544 SR |
38 | #endif |
39 | ||
8c5659a6 | 40 | static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat) |
addb2e16 BS |
41 | { |
42 | int i; | |
9ad754fe | 43 | u_char *datbuf, *oobbuf, *p; |
8c5659a6 | 44 | static loff_t last; |
e40520b5 | 45 | int ret = 0; |
8c5659a6 SW |
46 | |
47 | if (repeat) | |
48 | off = last + nand->writesize; | |
49 | ||
50 | last = off; | |
addb2e16 | 51 | |
62fd66f3 | 52 | datbuf = memalign(ARCH_DMA_MINALIGN, nand->writesize); |
e40520b5 | 53 | if (!datbuf) { |
addb2e16 BS |
54 | puts("No memory for page buffer\n"); |
55 | return 1; | |
56 | } | |
e40520b5 MY |
57 | |
58 | oobbuf = memalign(ARCH_DMA_MINALIGN, nand->oobsize); | |
59 | if (!oobbuf) { | |
60 | puts("No memory for page buffer\n"); | |
61 | ret = 1; | |
62 | goto free_dat; | |
63 | } | |
cfa460ad | 64 | off &= ~(nand->writesize - 1); |
cfa460ad | 65 | loff_t addr = (loff_t) off; |
9ad754fe WJ |
66 | struct mtd_oob_ops ops; |
67 | memset(&ops, 0, sizeof(ops)); | |
68 | ops.datbuf = datbuf; | |
cfdae12f | 69 | ops.oobbuf = oobbuf; |
9ad754fe WJ |
70 | ops.len = nand->writesize; |
71 | ops.ooblen = nand->oobsize; | |
dfe64e2c SL |
72 | ops.mode = MTD_OPS_RAW; |
73 | i = mtd_read_oob(nand, addr, &ops); | |
addb2e16 | 74 | if (i < 0) { |
e870690b | 75 | printf("Error (%d) reading page %08lx\n", i, off); |
e40520b5 MY |
76 | ret = 1; |
77 | goto free_all; | |
addb2e16 | 78 | } |
e870690b | 79 | printf("Page %08lx dump:\n", off); |
4b070809 | 80 | |
7d25cd34 MY |
81 | if (!only_oob) { |
82 | i = nand->writesize >> 4; | |
83 | p = datbuf; | |
84 | ||
85 | while (i--) { | |
9ad754fe WJ |
86 | printf("\t%02x %02x %02x %02x %02x %02x %02x %02x" |
87 | " %02x %02x %02x %02x %02x %02x %02x %02x\n", | |
88 | p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], | |
dfbf617f SW |
89 | p[8], p[9], p[10], p[11], p[12], p[13], p[14], |
90 | p[15]); | |
7d25cd34 MY |
91 | p += 16; |
92 | } | |
addb2e16 | 93 | } |
7d25cd34 | 94 | |
addb2e16 BS |
95 | puts("OOB:\n"); |
96 | i = nand->oobsize >> 3; | |
cfdae12f | 97 | p = oobbuf; |
addb2e16 | 98 | while (i--) { |
cfa460ad WJ |
99 | printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n", |
100 | p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); | |
addb2e16 BS |
101 | p += 8; |
102 | } | |
e40520b5 MY |
103 | |
104 | free_all: | |
9ad754fe | 105 | free(oobbuf); |
e40520b5 MY |
106 | free_dat: |
107 | free(datbuf); | |
addb2e16 | 108 | |
e40520b5 | 109 | return ret; |
addb2e16 BS |
110 | } |
111 | ||
112 | /* ------------------------------------------------------------------------- */ | |
113 | ||
ea533c26 SW |
114 | static int set_dev(int dev) |
115 | { | |
116 | if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE || | |
117 | !nand_info[dev].name) { | |
118 | puts("No such device\n"); | |
119 | return -1; | |
120 | } | |
121 | ||
122 | if (nand_curr_device == dev) | |
123 | return 0; | |
124 | ||
125 | printf("Device %d: %s", dev, nand_info[dev].name); | |
126 | puts("... is now current device\n"); | |
127 | nand_curr_device = dev; | |
128 | ||
129 | #ifdef CONFIG_SYS_NAND_SELECT_DEVICE | |
130 | board_nand_select_device(nand_info[dev].priv, dev); | |
131 | #endif | |
132 | ||
133 | return 0; | |
134 | } | |
135 | ||
136 | static inline int str2off(const char *p, loff_t *num) | |
137 | { | |
138 | char *endptr; | |
139 | ||
140 | *num = simple_strtoull(p, &endptr, 16); | |
141 | return *p != '\0' && *endptr == '\0'; | |
142 | } | |
143 | ||
144 | static inline int str2long(const char *p, ulong *num) | |
addb2e16 | 145 | { |
856f0544 | 146 | char *endptr; |
addb2e16 | 147 | |
856f0544 | 148 | *num = simple_strtoul(p, &endptr, 16); |
ea533c26 | 149 | return *p != '\0' && *endptr == '\0'; |
856f0544 | 150 | } |
addb2e16 | 151 | |
c39d6a0e TR |
152 | static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size, |
153 | loff_t *maxsize) | |
856f0544 | 154 | { |
ea533c26 | 155 | #ifdef CONFIG_CMD_MTDPARTS |
856f0544 SR |
156 | struct mtd_device *dev; |
157 | struct part_info *part; | |
158 | u8 pnum; | |
ea533c26 | 159 | int ret; |
856f0544 | 160 | |
ea533c26 SW |
161 | ret = mtdparts_init(); |
162 | if (ret) | |
163 | return ret; | |
164 | ||
165 | ret = find_dev_and_part(partname, &dev, &pnum, &part); | |
166 | if (ret) | |
167 | return ret; | |
168 | ||
169 | if (dev->id->type != MTD_DEV_TYPE_NAND) { | |
170 | puts("not a NAND device\n"); | |
171 | return -1; | |
856f0544 | 172 | } |
ea533c26 SW |
173 | |
174 | *off = part->offset; | |
175 | *size = part->size; | |
c39d6a0e | 176 | *maxsize = part->size; |
ea533c26 SW |
177 | *idx = dev->id->num; |
178 | ||
179 | ret = set_dev(*idx); | |
180 | if (ret) | |
181 | return ret; | |
182 | ||
183 | return 0; | |
184 | #else | |
185 | puts("offset is not a number\n"); | |
186 | return -1; | |
addb2e16 | 187 | #endif |
ea533c26 | 188 | } |
addb2e16 | 189 | |
c39d6a0e TR |
190 | static int arg_off(const char *arg, int *idx, loff_t *off, loff_t *size, |
191 | loff_t *maxsize) | |
ea533c26 SW |
192 | { |
193 | if (!str2off(arg, off)) | |
c39d6a0e | 194 | return get_part(arg, idx, off, size, maxsize); |
ea533c26 SW |
195 | |
196 | if (*off >= nand_info[*idx].size) { | |
197 | puts("Offset exceeds device limit\n"); | |
198 | return -1; | |
199 | } | |
200 | ||
201 | *maxsize = nand_info[*idx].size - *off; | |
c39d6a0e | 202 | *size = *maxsize; |
ea533c26 SW |
203 | return 0; |
204 | } | |
205 | ||
206 | static int arg_off_size(int argc, char *const argv[], int *idx, | |
c39d6a0e | 207 | loff_t *off, loff_t *size, loff_t *maxsize) |
ea533c26 SW |
208 | { |
209 | int ret; | |
ea533c26 SW |
210 | |
211 | if (argc == 0) { | |
856f0544 | 212 | *off = 0; |
ea533c26 | 213 | *size = nand_info[*idx].size; |
c39d6a0e | 214 | *maxsize = *size; |
ea533c26 | 215 | goto print; |
856f0544 | 216 | } |
addb2e16 | 217 | |
c39d6a0e | 218 | ret = arg_off(argv[0], idx, off, size, maxsize); |
ea533c26 SW |
219 | if (ret) |
220 | return ret; | |
221 | ||
c39d6a0e | 222 | if (argc == 1) |
ea533c26 | 223 | goto print; |
addb2e16 | 224 | |
ea533c26 SW |
225 | if (!str2off(argv[1], size)) { |
226 | printf("'%s' is not a number\n", argv[1]); | |
227 | return -1; | |
228 | } | |
229 | ||
c39d6a0e | 230 | if (*size > *maxsize) { |
ea533c26 SW |
231 | puts("Size exceeds partition or device limit\n"); |
232 | return -1; | |
233 | } | |
234 | ||
235 | print: | |
236 | printf("device %d ", *idx); | |
237 | if (*size == nand_info[*idx].size) | |
856f0544 SR |
238 | puts("whole chip\n"); |
239 | else | |
ea533c26 SW |
240 | printf("offset 0x%llx, size 0x%llx\n", |
241 | (unsigned long long)*off, (unsigned long long)*size); | |
856f0544 | 242 | return 0; |
addb2e16 BS |
243 | } |
244 | ||
50657c27 NM |
245 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
246 | static void print_status(ulong start, ulong end, ulong erasesize, int status) | |
247 | { | |
e70bfa29 JH |
248 | /* |
249 | * Micron NAND flash (e.g. MT29F4G08ABADAH4) BLOCK LOCK READ STATUS is | |
250 | * not the same as others. Instead of bit 1 being lock, it is | |
251 | * #lock_tight. To make the driver support either format, ignore bit 1 | |
252 | * and use only bit 0 and bit 2. | |
253 | */ | |
50657c27 NM |
254 | printf("%08lx - %08lx: %08lx blocks %s%s%s\n", |
255 | start, | |
256 | end - 1, | |
257 | (end - start) / erasesize, | |
258 | ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""), | |
e70bfa29 | 259 | (!(status & NAND_LOCK_STATUS_UNLOCK) ? "LOCK " : ""), |
50657c27 NM |
260 | ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : "")); |
261 | } | |
262 | ||
263 | static void do_nand_status(nand_info_t *nand) | |
264 | { | |
265 | ulong block_start = 0; | |
266 | ulong off; | |
267 | int last_status = -1; | |
268 | ||
269 | struct nand_chip *nand_chip = nand->priv; | |
270 | /* check the WP bit */ | |
271 | nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1); | |
272 | printf("device is %swrite protected\n", | |
273 | (nand_chip->read_byte(nand) & 0x80 ? | |
274 | "NOT " : "")); | |
275 | ||
276 | for (off = 0; off < nand->size; off += nand->erasesize) { | |
277 | int s = nand_get_lock_status(nand, off); | |
278 | ||
279 | /* print message only if status has changed */ | |
280 | if (s != last_status && off != 0) { | |
281 | print_status(block_start, off, nand->erasesize, | |
282 | last_status); | |
283 | block_start = off; | |
284 | } | |
285 | last_status = s; | |
286 | } | |
287 | /* Print the last block info */ | |
288 | print_status(block_start, off, nand->erasesize, last_status); | |
289 | } | |
290 | #endif | |
291 | ||
c9f7351b BG |
292 | #ifdef CONFIG_ENV_OFFSET_OOB |
293 | unsigned long nand_env_oob_offset; | |
294 | ||
ea533c26 | 295 | int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[]) |
c9f7351b BG |
296 | { |
297 | int ret; | |
298 | uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)]; | |
ea533c26 | 299 | nand_info_t *nand = &nand_info[0]; |
c9f7351b BG |
300 | char *cmd = argv[1]; |
301 | ||
ea533c26 SW |
302 | if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) { |
303 | puts("no devices available\n"); | |
304 | return 1; | |
305 | } | |
306 | ||
307 | set_dev(0); | |
308 | ||
c9f7351b BG |
309 | if (!strcmp(cmd, "get")) { |
310 | ret = get_nand_env_oob(nand, &nand_env_oob_offset); | |
53504a27 | 311 | if (ret) |
c9f7351b | 312 | return 1; |
53504a27 SW |
313 | |
314 | printf("0x%08lx\n", nand_env_oob_offset); | |
c9f7351b | 315 | } else if (!strcmp(cmd, "set")) { |
ea533c26 SW |
316 | loff_t addr; |
317 | loff_t maxsize; | |
c9f7351b | 318 | struct mtd_oob_ops ops; |
ea533c26 | 319 | int idx = 0; |
c9f7351b BG |
320 | |
321 | if (argc < 3) | |
322 | goto usage; | |
323 | ||
c39d6a0e TR |
324 | /* We don't care about size, or maxsize. */ |
325 | if (arg_off(argv[2], &idx, &addr, &maxsize, &maxsize)) { | |
ea533c26 SW |
326 | puts("Offset or partition name expected\n"); |
327 | return 1; | |
328 | } | |
329 | ||
330 | if (idx != 0) { | |
331 | puts("Partition not on first NAND device\n"); | |
c9f7351b BG |
332 | return 1; |
333 | } | |
334 | ||
335 | if (nand->oobavail < ENV_OFFSET_SIZE) { | |
53504a27 SW |
336 | printf("Insufficient available OOB bytes:\n" |
337 | "%d OOB bytes available but %d required for " | |
338 | "env.oob support\n", | |
339 | nand->oobavail, ENV_OFFSET_SIZE); | |
c9f7351b BG |
340 | return 1; |
341 | } | |
342 | ||
343 | if ((addr & (nand->erasesize - 1)) != 0) { | |
344 | printf("Environment offset must be block-aligned\n"); | |
345 | return 1; | |
346 | } | |
347 | ||
348 | ops.datbuf = NULL; | |
349 | ops.mode = MTD_OOB_AUTO; | |
350 | ops.ooboffs = 0; | |
351 | ops.ooblen = ENV_OFFSET_SIZE; | |
352 | ops.oobbuf = (void *) oob_buf; | |
353 | ||
354 | oob_buf[0] = ENV_OOB_MARKER; | |
355 | oob_buf[1] = addr / nand->erasesize; | |
356 | ||
357 | ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops); | |
53504a27 | 358 | if (ret) { |
c9f7351b BG |
359 | printf("Error writing OOB block 0\n"); |
360 | return ret; | |
361 | } | |
53504a27 SW |
362 | |
363 | ret = get_nand_env_oob(nand, &nand_env_oob_offset); | |
364 | if (ret) { | |
365 | printf("Error reading env offset in OOB\n"); | |
366 | return ret; | |
367 | } | |
368 | ||
369 | if (addr != nand_env_oob_offset) { | |
370 | printf("Verification of env offset in OOB failed: " | |
ea533c26 SW |
371 | "0x%08llx expected but got 0x%08lx\n", |
372 | (unsigned long long)addr, nand_env_oob_offset); | |
53504a27 SW |
373 | return 1; |
374 | } | |
c9f7351b BG |
375 | } else { |
376 | goto usage; | |
377 | } | |
378 | ||
379 | return ret; | |
380 | ||
381 | usage: | |
4c12eeb8 | 382 | return CMD_RET_USAGE; |
c9f7351b BG |
383 | } |
384 | ||
385 | #endif | |
386 | ||
ce80ddc1 | 387 | static void nand_print_and_set_info(int idx) |
672ed2ae WG |
388 | { |
389 | nand_info_t *nand = &nand_info[idx]; | |
390 | struct nand_chip *chip = nand->priv; | |
ce80ddc1 | 391 | |
672ed2ae WG |
392 | printf("Device %d: ", idx); |
393 | if (chip->numchips > 1) | |
394 | printf("%dx ", chip->numchips); | |
395 | printf("%s, sector size %u KiB\n", | |
396 | nand->name, nand->erasesize >> 10); | |
ce80ddc1 MV |
397 | printf(" Page size %8d b\n", nand->writesize); |
398 | printf(" OOB size %8d b\n", nand->oobsize); | |
399 | printf(" Erase size %8d b\n", nand->erasesize); | |
400 | ||
401 | /* Set geometry info */ | |
41ef372c SG |
402 | setenv_hex("nand_writesize", nand->writesize); |
403 | setenv_hex("nand_oobsize", nand->oobsize); | |
404 | setenv_hex("nand_erasesize", nand->erasesize); | |
672ed2ae WG |
405 | } |
406 | ||
418396e2 SW |
407 | static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count, |
408 | int read) | |
409 | { | |
410 | int ret = 0; | |
418396e2 SW |
411 | |
412 | while (count--) { | |
413 | /* Raw access */ | |
414 | mtd_oob_ops_t ops = { | |
415 | .datbuf = (u8 *)addr, | |
416 | .oobbuf = ((u8 *)addr) + nand->writesize, | |
417 | .len = nand->writesize, | |
418 | .ooblen = nand->oobsize, | |
dfe64e2c | 419 | .mode = MTD_OPS_RAW |
418396e2 SW |
420 | }; |
421 | ||
418396e2 | 422 | if (read) |
dfe64e2c | 423 | ret = mtd_read_oob(nand, off, &ops); |
418396e2 | 424 | else |
dfe64e2c | 425 | ret = mtd_write_oob(nand, off, &ops); |
418396e2 SW |
426 | |
427 | if (ret) { | |
428 | printf("%s: error at offset %llx, ret %d\n", | |
429 | __func__, (long long)off, ret); | |
430 | break; | |
431 | } | |
432 | ||
433 | addr += nand->writesize + nand->oobsize; | |
434 | off += nand->writesize; | |
435 | } | |
436 | ||
437 | return ret; | |
438 | } | |
439 | ||
e834402f | 440 | /* Adjust a chip/partition size down for bad blocks so we don't |
9b80aa8e | 441 | * read/write past the end of a chip/partition by accident. |
e834402f HC |
442 | */ |
443 | static void adjust_size_for_badblocks(loff_t *size, loff_t offset, int dev) | |
444 | { | |
445 | /* We grab the nand info object here fresh because this is usually | |
446 | * called after arg_off_size() which can change the value of dev. | |
447 | */ | |
448 | nand_info_t *nand = &nand_info[dev]; | |
449 | loff_t maxoffset = offset + *size; | |
450 | int badblocks = 0; | |
451 | ||
452 | /* count badblocks in NAND from offset to offset + size */ | |
453 | for (; offset < maxoffset; offset += nand->erasesize) { | |
454 | if (nand_block_isbad(nand, offset)) | |
455 | badblocks++; | |
456 | } | |
457 | /* adjust size if any bad blocks found */ | |
458 | if (badblocks) { | |
459 | *size -= badblocks * nand->erasesize; | |
460 | printf("size adjusted to 0x%llx (%d bad blocks)\n", | |
461 | (unsigned long long)*size, badblocks); | |
462 | } | |
463 | } | |
464 | ||
088f1b19 | 465 | static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
addb2e16 | 466 | { |
ea533c26 SW |
467 | int i, ret = 0; |
468 | ulong addr; | |
c39d6a0e | 469 | loff_t off, size, maxsize; |
addb2e16 BS |
470 | char *cmd, *s; |
471 | nand_info_t *nand; | |
6d0f6bcf JCPV |
472 | #ifdef CONFIG_SYS_NAND_QUIET |
473 | int quiet = CONFIG_SYS_NAND_QUIET; | |
c750d2e6 | 474 | #else |
2255b2d2 | 475 | int quiet = 0; |
c750d2e6 | 476 | #endif |
2255b2d2 | 477 | const char *quiet_str = getenv("quiet"); |
ea533c26 | 478 | int dev = nand_curr_device; |
8c5659a6 | 479 | int repeat = flag & CMD_FLAG_REPEAT; |
addb2e16 BS |
480 | |
481 | /* at least two arguments please */ | |
482 | if (argc < 2) | |
483 | goto usage; | |
484 | ||
2255b2d2 SR |
485 | if (quiet_str) |
486 | quiet = simple_strtoul(quiet_str, NULL, 0) != 0; | |
487 | ||
addb2e16 BS |
488 | cmd = argv[1]; |
489 | ||
8c5659a6 SW |
490 | /* Only "dump" is repeatable. */ |
491 | if (repeat && strcmp(cmd, "dump")) | |
492 | return 0; | |
493 | ||
addb2e16 BS |
494 | if (strcmp(cmd, "info") == 0) { |
495 | ||
496 | putc('\n'); | |
6d0f6bcf | 497 | for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) { |
addb2e16 | 498 | if (nand_info[i].name) |
ce80ddc1 | 499 | nand_print_and_set_info(i); |
addb2e16 BS |
500 | } |
501 | return 0; | |
502 | } | |
503 | ||
504 | if (strcmp(cmd, "device") == 0) { | |
addb2e16 | 505 | if (argc < 3) { |
672ed2ae | 506 | putc('\n'); |
ea533c26 | 507 | if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE) |
672ed2ae | 508 | puts("no devices available\n"); |
addb2e16 | 509 | else |
ce80ddc1 | 510 | nand_print_and_set_info(dev); |
addb2e16 BS |
511 | return 0; |
512 | } | |
43a2b0e7 | 513 | |
ea533c26 SW |
514 | dev = (int)simple_strtoul(argv[2], NULL, 10); |
515 | set_dev(dev); | |
43a2b0e7 | 516 | |
addb2e16 BS |
517 | return 0; |
518 | } | |
519 | ||
c9f7351b BG |
520 | #ifdef CONFIG_ENV_OFFSET_OOB |
521 | /* this command operates only on the first nand device */ | |
ea533c26 SW |
522 | if (strcmp(cmd, "env.oob") == 0) |
523 | return do_nand_env_oob(cmdtp, argc - 1, argv + 1); | |
c9f7351b BG |
524 | #endif |
525 | ||
ea533c26 SW |
526 | /* The following commands operate on the current device, unless |
527 | * overridden by a partition specifier. Note that if somehow the | |
528 | * current device is invalid, it will have to be changed to a valid | |
529 | * one before these commands can run, even if a partition specifier | |
530 | * for another device is to be used. | |
531 | */ | |
532 | if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE || | |
533 | !nand_info[dev].name) { | |
addb2e16 BS |
534 | puts("\nno devices available\n"); |
535 | return 1; | |
536 | } | |
ea533c26 | 537 | nand = &nand_info[dev]; |
addb2e16 BS |
538 | |
539 | if (strcmp(cmd, "bad") == 0) { | |
ea533c26 | 540 | printf("\nDevice %d bad blocks:\n", dev); |
addb2e16 BS |
541 | for (off = 0; off < nand->size; off += nand->erasesize) |
542 | if (nand_block_isbad(nand, off)) | |
ea533c26 | 543 | printf(" %08llx\n", (unsigned long long)off); |
addb2e16 BS |
544 | return 0; |
545 | } | |
546 | ||
856f0544 SR |
547 | /* |
548 | * Syntax is: | |
549 | * 0 1 2 3 4 | |
550 | * nand erase [clean] [off size] | |
551 | */ | |
30486322 | 552 | if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) { |
2255b2d2 | 553 | nand_erase_options_t opts; |
856f0544 | 554 | /* "clean" at index 2 means request to write cleanmarker */ |
3043c045 | 555 | int clean = argc > 2 && !strcmp("clean", argv[2]); |
60899816 MV |
556 | int scrub_yes = argc > 2 && !strcmp("-y", argv[2]); |
557 | int o = (clean || scrub_yes) ? 3 : 2; | |
30486322 | 558 | int scrub = !strncmp(cmd, "scrub", 5); |
30486322 SW |
559 | int spread = 0; |
560 | int args = 2; | |
60899816 MV |
561 | const char *scrub_warn = |
562 | "Warning: " | |
563 | "scrub option will erase all factory set bad blocks!\n" | |
564 | " " | |
565 | "There is no reliable way to recover them.\n" | |
566 | " " | |
567 | "Use this command only for testing purposes if you\n" | |
568 | " " | |
569 | "are sure of what you are doing!\n" | |
570 | "\nReally scrub this NAND flash? <y/N>\n"; | |
30486322 SW |
571 | |
572 | if (cmd[5] != 0) { | |
573 | if (!strcmp(&cmd[5], ".spread")) { | |
574 | spread = 1; | |
575 | } else if (!strcmp(&cmd[5], ".part")) { | |
30486322 SW |
576 | args = 1; |
577 | } else if (!strcmp(&cmd[5], ".chip")) { | |
30486322 SW |
578 | args = 0; |
579 | } else { | |
580 | goto usage; | |
581 | } | |
582 | } | |
583 | ||
584 | /* | |
585 | * Don't allow missing arguments to cause full chip/partition | |
586 | * erases -- easy to do accidentally, e.g. with a misspelled | |
587 | * variable name. | |
588 | */ | |
589 | if (argc != o + args) | |
590 | goto usage; | |
2255b2d2 | 591 | |
30486322 | 592 | printf("\nNAND %s: ", cmd); |
856f0544 | 593 | /* skip first two or three arguments, look for offset and size */ |
c39d6a0e TR |
594 | if (arg_off_size(argc - o, argv + o, &dev, &off, &size, |
595 | &maxsize) != 0) | |
856f0544 | 596 | return 1; |
2255b2d2 | 597 | |
ea533c26 SW |
598 | nand = &nand_info[dev]; |
599 | ||
2255b2d2 SR |
600 | memset(&opts, 0, sizeof(opts)); |
601 | opts.offset = off; | |
602 | opts.length = size; | |
603 | opts.jffs2 = clean; | |
604 | opts.quiet = quiet; | |
30486322 | 605 | opts.spread = spread; |
2255b2d2 SR |
606 | |
607 | if (scrub) { | |
a5dffa4b | 608 | if (scrub_yes) { |
60899816 | 609 | opts.scrub = 1; |
a5dffa4b PA |
610 | } else { |
611 | puts(scrub_warn); | |
612 | if (confirm_yesno()) { | |
6b94b496 | 613 | opts.scrub = 1; |
a5dffa4b | 614 | } else { |
6b94b496 | 615 | puts("scrub aborted\n"); |
46aabcc4 | 616 | return 1; |
6b94b496 | 617 | } |
2255b2d2 SR |
618 | } |
619 | } | |
620 | ret = nand_erase_opts(nand, &opts); | |
addb2e16 BS |
621 | printf("%s\n", ret ? "ERROR" : "OK"); |
622 | ||
623 | return ret == 0 ? 0 : 1; | |
624 | } | |
625 | ||
626 | if (strncmp(cmd, "dump", 4) == 0) { | |
627 | if (argc < 3) | |
628 | goto usage; | |
629 | ||
addb2e16 | 630 | off = (int)simple_strtoul(argv[2], NULL, 16); |
8c5659a6 | 631 | ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat); |
addb2e16 BS |
632 | |
633 | return ret == 0 ? 1 : 0; | |
addb2e16 BS |
634 | } |
635 | ||
addb2e16 | 636 | if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) { |
ea533c26 | 637 | size_t rwsize; |
418396e2 | 638 | ulong pagecount = 1; |
2255b2d2 | 639 | int read; |
ced199dc | 640 | int raw = 0; |
2255b2d2 | 641 | |
addb2e16 BS |
642 | if (argc < 4) |
643 | goto usage; | |
2255b2d2 | 644 | |
addb2e16 BS |
645 | addr = (ulong)simple_strtoul(argv[2], NULL, 16); |
646 | ||
2255b2d2 | 647 | read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */ |
856f0544 | 648 | printf("\nNAND %s: ", read ? "read" : "write"); |
4cbb651b | 649 | |
2255b2d2 | 650 | s = strchr(cmd, '.'); |
418396e2 | 651 | |
8d75c896 | 652 | if (s && !strcmp(s, ".raw")) { |
418396e2 SW |
653 | raw = 1; |
654 | ||
c39d6a0e | 655 | if (arg_off(argv[3], &dev, &off, &size, &maxsize)) |
418396e2 SW |
656 | return 1; |
657 | ||
93d3232d RL |
658 | nand = &nand_info[dev]; |
659 | ||
418396e2 SW |
660 | if (argc > 4 && !str2long(argv[4], &pagecount)) { |
661 | printf("'%s' is not a number\n", argv[4]); | |
662 | return 1; | |
663 | } | |
664 | ||
665 | if (pagecount * nand->writesize > size) { | |
666 | puts("Size exceeds partition or device limit\n"); | |
667 | return -1; | |
668 | } | |
669 | ||
670 | rwsize = pagecount * (nand->writesize + nand->oobsize); | |
671 | } else { | |
672 | if (arg_off_size(argc - 3, argv + 3, &dev, | |
c39d6a0e | 673 | &off, &size, &maxsize) != 0) |
418396e2 SW |
674 | return 1; |
675 | ||
e834402f HC |
676 | /* size is unspecified */ |
677 | if (argc < 5) | |
678 | adjust_size_for_badblocks(&size, off, dev); | |
418396e2 SW |
679 | rwsize = size; |
680 | } | |
681 | ||
93d3232d RL |
682 | nand = &nand_info[dev]; |
683 | ||
984e03cd SW |
684 | if (!s || !strcmp(s, ".jffs2") || |
685 | !strcmp(s, ".e") || !strcmp(s, ".i")) { | |
dfbf617f | 686 | if (read) |
ea533c26 | 687 | ret = nand_read_skip_bad(nand, off, &rwsize, |
c39d6a0e | 688 | NULL, maxsize, |
4b070809 | 689 | (u_char *)addr); |
dfbf617f | 690 | else |
ea533c26 | 691 | ret = nand_write_skip_bad(nand, off, &rwsize, |
c39d6a0e | 692 | NULL, maxsize, |
47fc18f1 | 693 | (u_char *)addr, 0); |
c9494866 BG |
694 | #ifdef CONFIG_CMD_NAND_TRIMFFS |
695 | } else if (!strcmp(s, ".trimffs")) { | |
696 | if (read) { | |
697 | printf("Unknown nand command suffix '%s'\n", s); | |
698 | return 1; | |
699 | } | |
c39d6a0e TR |
700 | ret = nand_write_skip_bad(nand, off, &rwsize, NULL, |
701 | maxsize, (u_char *)addr, | |
c9494866 BG |
702 | WITH_DROP_FFS); |
703 | #endif | |
47fc18f1 LW |
704 | #ifdef CONFIG_CMD_NAND_YAFFS |
705 | } else if (!strcmp(s, ".yaffs")) { | |
706 | if (read) { | |
707 | printf("Unknown nand command suffix '%s'.\n", s); | |
708 | return 1; | |
709 | } | |
c39d6a0e TR |
710 | ret = nand_write_skip_bad(nand, off, &rwsize, NULL, |
711 | maxsize, (u_char *)addr, | |
c4df2f41 | 712 | WITH_YAFFS_OOB); |
47fc18f1 | 713 | #endif |
dfc99e14 | 714 | } else if (!strcmp(s, ".oob")) { |
cfa460ad WJ |
715 | /* out-of-band data */ |
716 | mtd_oob_ops_t ops = { | |
717 | .oobbuf = (u8 *)addr, | |
ea533c26 | 718 | .ooblen = rwsize, |
dfe64e2c | 719 | .mode = MTD_OPS_RAW |
cfa460ad WJ |
720 | }; |
721 | ||
fb3659ac | 722 | if (read) |
dfe64e2c | 723 | ret = mtd_read_oob(nand, off, &ops); |
fb3659ac | 724 | else |
dfe64e2c | 725 | ret = mtd_write_oob(nand, off, &ops); |
418396e2 SW |
726 | } else if (raw) { |
727 | ret = raw_access(nand, addr, off, pagecount, read); | |
856f0544 | 728 | } else { |
984e03cd SW |
729 | printf("Unknown nand command suffix '%s'.\n", s); |
730 | return 1; | |
2255b2d2 SR |
731 | } |
732 | ||
ea533c26 | 733 | printf(" %zu bytes %s: %s\n", rwsize, |
2255b2d2 | 734 | read ? "read" : "written", ret ? "ERROR" : "OK"); |
addb2e16 BS |
735 | |
736 | return ret == 0 ? 0 : 1; | |
737 | } | |
2255b2d2 | 738 | |
3287f6d3 BT |
739 | #ifdef CONFIG_CMD_NAND_TORTURE |
740 | if (strcmp(cmd, "torture") == 0) { | |
741 | if (argc < 3) | |
742 | goto usage; | |
743 | ||
744 | if (!str2off(argv[2], &off)) { | |
745 | puts("Offset is not a valid number\n"); | |
746 | return 1; | |
747 | } | |
748 | ||
749 | printf("\nNAND torture: device %d offset 0x%llx size 0x%x\n", | |
750 | dev, off, nand->erasesize); | |
751 | ret = nand_torture(nand, off); | |
752 | printf(" %s\n", ret ? "Failed" : "Passed"); | |
753 | ||
754 | return ret == 0 ? 0 : 1; | |
755 | } | |
756 | #endif | |
757 | ||
2255b2d2 | 758 | if (strcmp(cmd, "markbad") == 0) { |
8360b66b WD |
759 | argc -= 2; |
760 | argv += 2; | |
2255b2d2 | 761 | |
8360b66b WD |
762 | if (argc <= 0) |
763 | goto usage; | |
764 | ||
765 | while (argc > 0) { | |
766 | addr = simple_strtoul(*argv, NULL, 16); | |
767 | ||
dfe64e2c | 768 | if (mtd_block_markbad(nand, addr)) { |
8360b66b WD |
769 | printf("block 0x%08lx NOT marked " |
770 | "as bad! ERROR %d\n", | |
771 | addr, ret); | |
772 | ret = 1; | |
773 | } else { | |
774 | printf("block 0x%08lx successfully " | |
775 | "marked as bad\n", | |
776 | addr); | |
777 | } | |
778 | --argc; | |
779 | ++argv; | |
2255b2d2 | 780 | } |
8360b66b | 781 | return ret; |
2255b2d2 | 782 | } |
dfbf617f | 783 | |
2255b2d2 SR |
784 | if (strcmp(cmd, "biterr") == 0) { |
785 | /* todo */ | |
786 | return 1; | |
787 | } | |
788 | ||
50657c27 | 789 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
2255b2d2 | 790 | if (strcmp(cmd, "lock") == 0) { |
50657c27 | 791 | int tight = 0; |
2255b2d2 SR |
792 | int status = 0; |
793 | if (argc == 3) { | |
794 | if (!strcmp("tight", argv[2])) | |
795 | tight = 1; | |
796 | if (!strcmp("status", argv[2])) | |
797 | status = 1; | |
798 | } | |
2255b2d2 | 799 | if (status) { |
50657c27 | 800 | do_nand_status(nand); |
cfa460ad | 801 | } else { |
5e1dae5c WJ |
802 | if (!nand_lock(nand, tight)) { |
803 | puts("NAND flash successfully locked\n"); | |
804 | } else { | |
805 | puts("Error locking NAND flash\n"); | |
806 | return 1; | |
807 | } | |
2255b2d2 SR |
808 | } |
809 | return 0; | |
810 | } | |
811 | ||
eee623a5 JH |
812 | if (strncmp(cmd, "unlock", 5) == 0) { |
813 | int allexcept = 0; | |
814 | ||
815 | s = strchr(cmd, '.'); | |
816 | ||
817 | if (s && !strcmp(s, ".allexcept")) | |
818 | allexcept = 1; | |
819 | ||
c39d6a0e TR |
820 | if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size, |
821 | &maxsize) < 0) | |
856f0544 | 822 | return 1; |
2255b2d2 | 823 | |
eee623a5 | 824 | if (!nand_unlock(&nand_info[dev], off, size, allexcept)) { |
5e1dae5c WJ |
825 | puts("NAND flash successfully unlocked\n"); |
826 | } else { | |
827 | puts("Error unlocking NAND flash, " | |
3043c045 | 828 | "write and erase will probably fail\n"); |
5e1dae5c WJ |
829 | return 1; |
830 | } | |
2255b2d2 SR |
831 | return 0; |
832 | } | |
50657c27 | 833 | #endif |
2255b2d2 | 834 | |
addb2e16 | 835 | usage: |
4c12eeb8 | 836 | return CMD_RET_USAGE; |
addb2e16 BS |
837 | } |
838 | ||
088f1b19 KP |
839 | #ifdef CONFIG_SYS_LONGHELP |
840 | static char nand_help_text[] = | |
a89c33db WD |
841 | "info - show available NAND devices\n" |
842 | "nand device [dev] - show or set current device\n" | |
843 | "nand read - addr off|partition size\n" | |
844 | "nand write - addr off|partition size\n" | |
845 | " read/write 'size' bytes starting at offset 'off'\n" | |
846 | " to/from memory address 'addr', skipping bad blocks.\n" | |
418396e2 SW |
847 | "nand read.raw - addr off|partition [count]\n" |
848 | "nand write.raw - addr off|partition [count]\n" | |
849 | " Use read.raw/write.raw to avoid ECC and access the flash as-is.\n" | |
c9494866 BG |
850 | #ifdef CONFIG_CMD_NAND_TRIMFFS |
851 | "nand write.trimffs - addr off|partition size\n" | |
852 | " write 'size' bytes starting at offset 'off' from memory address\n" | |
853 | " 'addr', skipping bad blocks and dropping any pages at the end\n" | |
854 | " of eraseblocks that contain only 0xFF\n" | |
855 | #endif | |
47fc18f1 LW |
856 | #ifdef CONFIG_CMD_NAND_YAFFS |
857 | "nand write.yaffs - addr off|partition size\n" | |
858 | " write 'size' bytes starting at offset 'off' with yaffs format\n" | |
859 | " from memory address 'addr', skipping bad blocks.\n" | |
860 | #endif | |
eb3abce8 | 861 | "nand erase[.spread] [clean] off size - erase 'size' bytes " |
30486322 SW |
862 | "from offset 'off'\n" |
863 | " With '.spread', erase enough for given file size, otherwise,\n" | |
864 | " 'size' includes skipped bad blocks.\n" | |
865 | "nand erase.part [clean] partition - erase entire mtd partition'\n" | |
866 | "nand erase.chip [clean] - erase entire chip'\n" | |
a89c33db WD |
867 | "nand bad - show bad blocks\n" |
868 | "nand dump[.oob] off - dump page\n" | |
3287f6d3 BT |
869 | #ifdef CONFIG_CMD_NAND_TORTURE |
870 | "nand torture off - torture block at offset\n" | |
871 | #endif | |
60899816 | 872 | "nand scrub [-y] off size | scrub.part partition | scrub.chip\n" |
30486322 | 873 | " really clean NAND erasing bad blocks (UNSAFE)\n" |
a89c33db WD |
874 | "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n" |
875 | "nand biterr off - make a bit error at offset (UNSAFE)" | |
50657c27 | 876 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
a89c33db WD |
877 | "\n" |
878 | "nand lock [tight] [status]\n" | |
879 | " bring nand to lock state or display locked pages\n" | |
eee623a5 | 880 | "nand unlock[.allexcept] [offset] [size] - unlock section" |
50657c27 | 881 | #endif |
c9f7351b BG |
882 | #ifdef CONFIG_ENV_OFFSET_OOB |
883 | "\n" | |
884 | "nand env.oob - environment offset in OOB of block 0 of" | |
885 | " first device.\n" | |
886 | "nand env.oob set off|partition - set enviromnent offset\n" | |
887 | "nand env.oob get - get environment offset" | |
888 | #endif | |
088f1b19 KP |
889 | ""; |
890 | #endif | |
891 | ||
892 | U_BOOT_CMD( | |
893 | nand, CONFIG_SYS_MAXARGS, 1, do_nand, | |
894 | "NAND sub-system", nand_help_text | |
50657c27 | 895 | ); |
addb2e16 | 896 | |
856f0544 | 897 | static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand, |
4b070809 | 898 | ulong offset, ulong addr, char *cmd) |
addb2e16 | 899 | { |
addb2e16 | 900 | int r; |
67d668bf | 901 | char *s; |
4ca79f47 | 902 | size_t cnt; |
21d29f7f | 903 | #if defined(CONFIG_IMAGE_FORMAT_LEGACY) |
addb2e16 | 904 | image_header_t *hdr; |
21d29f7f | 905 | #endif |
09475f75 | 906 | #if defined(CONFIG_FIT) |
3bab76a2 | 907 | const void *fit_hdr = NULL; |
09475f75 | 908 | #endif |
10e03893 TK |
909 | |
910 | s = strchr(cmd, '.'); | |
911 | if (s != NULL && | |
65d8bc94 | 912 | (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) { |
984e03cd | 913 | printf("Unknown nand load suffix '%s'\n", s); |
770605e4 | 914 | bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX); |
984e03cd SW |
915 | return 1; |
916 | } | |
addb2e16 | 917 | |
856f0544 | 918 | printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset); |
addb2e16 | 919 | |
cfa460ad | 920 | cnt = nand->writesize; |
c39d6a0e TR |
921 | r = nand_read_skip_bad(nand, offset, &cnt, NULL, nand->size, |
922 | (u_char *)addr); | |
addb2e16 | 923 | if (r) { |
856f0544 | 924 | puts("** Read error\n"); |
770605e4 | 925 | bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ); |
addb2e16 BS |
926 | return 1; |
927 | } | |
770605e4 | 928 | bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ); |
addb2e16 | 929 | |
9a4daad0 | 930 | switch (genimg_get_format ((void *)addr)) { |
21d29f7f | 931 | #if defined(CONFIG_IMAGE_FORMAT_LEGACY) |
d5934ad7 MB |
932 | case IMAGE_FORMAT_LEGACY: |
933 | hdr = (image_header_t *)addr; | |
934 | ||
770605e4 | 935 | bootstage_mark(BOOTSTAGE_ID_NAND_TYPE); |
d5934ad7 | 936 | image_print_contents (hdr); |
addb2e16 | 937 | |
d5934ad7 MB |
938 | cnt = image_get_image_size (hdr); |
939 | break; | |
21d29f7f | 940 | #endif |
d5934ad7 MB |
941 | #if defined(CONFIG_FIT) |
942 | case IMAGE_FORMAT_FIT: | |
09475f75 | 943 | fit_hdr = (const void *)addr; |
09475f75 MB |
944 | puts ("Fit image detected...\n"); |
945 | ||
946 | cnt = fit_get_size (fit_hdr); | |
947 | break; | |
d5934ad7 MB |
948 | #endif |
949 | default: | |
770605e4 | 950 | bootstage_error(BOOTSTAGE_ID_NAND_TYPE); |
d5934ad7 | 951 | puts ("** Unknown image type\n"); |
addb2e16 BS |
952 | return 1; |
953 | } | |
770605e4 | 954 | bootstage_mark(BOOTSTAGE_ID_NAND_TYPE); |
addb2e16 | 955 | |
c39d6a0e TR |
956 | r = nand_read_skip_bad(nand, offset, &cnt, NULL, nand->size, |
957 | (u_char *)addr); | |
addb2e16 | 958 | if (r) { |
856f0544 | 959 | puts("** Read error\n"); |
770605e4 | 960 | bootstage_error(BOOTSTAGE_ID_NAND_READ); |
addb2e16 BS |
961 | return 1; |
962 | } | |
770605e4 | 963 | bootstage_mark(BOOTSTAGE_ID_NAND_READ); |
addb2e16 | 964 | |
09475f75 MB |
965 | #if defined(CONFIG_FIT) |
966 | /* This cannot be done earlier, we need complete FIT image in RAM first */ | |
3bab76a2 MB |
967 | if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) { |
968 | if (!fit_check_format (fit_hdr)) { | |
770605e4 | 969 | bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ); |
3bab76a2 MB |
970 | puts ("** Bad FIT image format\n"); |
971 | return 1; | |
972 | } | |
770605e4 | 973 | bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK); |
3bab76a2 MB |
974 | fit_print_contents (fit_hdr); |
975 | } | |
09475f75 MB |
976 | #endif |
977 | ||
addb2e16 BS |
978 | /* Loading ok, update default load address */ |
979 | ||
980 | load_addr = addr; | |
981 | ||
67d668bf | 982 | return bootm_maybe_autostart(cmdtp, cmd); |
addb2e16 BS |
983 | } |
984 | ||
088f1b19 KP |
985 | static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc, |
986 | char * const argv[]) | |
856f0544 SR |
987 | { |
988 | char *boot_device = NULL; | |
989 | int idx; | |
990 | ulong addr, offset = 0; | |
0c8a8491 | 991 | #if defined(CONFIG_CMD_MTDPARTS) |
856f0544 SR |
992 | struct mtd_device *dev; |
993 | struct part_info *part; | |
994 | u8 pnum; | |
995 | ||
996 | if (argc >= 2) { | |
997 | char *p = (argc == 2) ? argv[1] : argv[2]; | |
998 | if (!(str2long(p, &addr)) && (mtdparts_init() == 0) && | |
999 | (find_dev_and_part(p, &dev, &pnum, &part) == 0)) { | |
1000 | if (dev->id->type != MTD_DEV_TYPE_NAND) { | |
1001 | puts("Not a NAND device\n"); | |
1002 | return 1; | |
1003 | } | |
1004 | if (argc > 3) | |
1005 | goto usage; | |
1006 | if (argc == 3) | |
10e03893 | 1007 | addr = simple_strtoul(argv[1], NULL, 16); |
856f0544 | 1008 | else |
6d0f6bcf | 1009 | addr = CONFIG_SYS_LOAD_ADDR; |
856f0544 | 1010 | return nand_load_image(cmdtp, &nand_info[dev->id->num], |
4b070809 | 1011 | part->offset, addr, argv[0]); |
856f0544 SR |
1012 | } |
1013 | } | |
1014 | #endif | |
1015 | ||
770605e4 | 1016 | bootstage_mark(BOOTSTAGE_ID_NAND_PART); |
856f0544 SR |
1017 | switch (argc) { |
1018 | case 1: | |
6d0f6bcf | 1019 | addr = CONFIG_SYS_LOAD_ADDR; |
856f0544 SR |
1020 | boot_device = getenv("bootdevice"); |
1021 | break; | |
1022 | case 2: | |
1023 | addr = simple_strtoul(argv[1], NULL, 16); | |
1024 | boot_device = getenv("bootdevice"); | |
1025 | break; | |
1026 | case 3: | |
1027 | addr = simple_strtoul(argv[1], NULL, 16); | |
1028 | boot_device = argv[2]; | |
1029 | break; | |
1030 | case 4: | |
1031 | addr = simple_strtoul(argv[1], NULL, 16); | |
1032 | boot_device = argv[2]; | |
1033 | offset = simple_strtoul(argv[3], NULL, 16); | |
1034 | break; | |
1035 | default: | |
0c8a8491 | 1036 | #if defined(CONFIG_CMD_MTDPARTS) |
856f0544 SR |
1037 | usage: |
1038 | #endif | |
770605e4 | 1039 | bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX); |
4c12eeb8 | 1040 | return CMD_RET_USAGE; |
856f0544 | 1041 | } |
770605e4 | 1042 | bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX); |
856f0544 SR |
1043 | |
1044 | if (!boot_device) { | |
1045 | puts("\n** No boot device **\n"); | |
770605e4 | 1046 | bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE); |
856f0544 SR |
1047 | return 1; |
1048 | } | |
770605e4 | 1049 | bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE); |
addb2e16 | 1050 | |
856f0544 SR |
1051 | idx = simple_strtoul(boot_device, NULL, 16); |
1052 | ||
6d0f6bcf | 1053 | if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) { |
856f0544 | 1054 | printf("\n** Device %d not available\n", idx); |
770605e4 | 1055 | bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE); |
856f0544 SR |
1056 | return 1; |
1057 | } | |
770605e4 | 1058 | bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE); |
856f0544 SR |
1059 | |
1060 | return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]); | |
1061 | } | |
1062 | ||
1063 | U_BOOT_CMD(nboot, 4, 1, do_nandboot, | |
2fb2604d | 1064 | "boot from NAND device", |
a89c33db WD |
1065 | "[partition] | [[[loadAddr] dev] offset]" |
1066 | ); |