]>
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 SW |
13 | * |
14 | * Copyright 2010 Freescale Semiconductor | |
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 SW |
44 | static loff_t last; |
45 | ||
46 | if (repeat) | |
47 | off = last + nand->writesize; | |
48 | ||
49 | last = off; | |
addb2e16 | 50 | |
9ad754fe WJ |
51 | datbuf = malloc(nand->writesize + nand->oobsize); |
52 | oobbuf = malloc(nand->oobsize); | |
53 | if (!datbuf || !oobbuf) { | |
addb2e16 BS |
54 | puts("No memory for page buffer\n"); |
55 | return 1; | |
56 | } | |
cfa460ad | 57 | off &= ~(nand->writesize - 1); |
cfa460ad | 58 | loff_t addr = (loff_t) off; |
9ad754fe WJ |
59 | struct mtd_oob_ops ops; |
60 | memset(&ops, 0, sizeof(ops)); | |
61 | ops.datbuf = datbuf; | |
62 | ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */ | |
63 | ops.len = nand->writesize; | |
64 | ops.ooblen = nand->oobsize; | |
65 | ops.mode = MTD_OOB_RAW; | |
66 | i = nand->read_oob(nand, addr, &ops); | |
addb2e16 | 67 | if (i < 0) { |
e870690b | 68 | printf("Error (%d) reading page %08lx\n", i, off); |
9ad754fe WJ |
69 | free(datbuf); |
70 | free(oobbuf); | |
addb2e16 BS |
71 | return 1; |
72 | } | |
e870690b | 73 | printf("Page %08lx dump:\n", off); |
9ad754fe WJ |
74 | i = nand->writesize >> 4; |
75 | p = datbuf; | |
4b070809 | 76 | |
addb2e16 | 77 | while (i--) { |
9ad754fe WJ |
78 | if (!only_oob) |
79 | printf("\t%02x %02x %02x %02x %02x %02x %02x %02x" | |
80 | " %02x %02x %02x %02x %02x %02x %02x %02x\n", | |
81 | p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], | |
dfbf617f SW |
82 | p[8], p[9], p[10], p[11], p[12], p[13], p[14], |
83 | p[15]); | |
addb2e16 BS |
84 | p += 16; |
85 | } | |
86 | puts("OOB:\n"); | |
87 | i = nand->oobsize >> 3; | |
88 | while (i--) { | |
cfa460ad WJ |
89 | printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n", |
90 | p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); | |
addb2e16 BS |
91 | p += 8; |
92 | } | |
9ad754fe WJ |
93 | free(datbuf); |
94 | free(oobbuf); | |
addb2e16 BS |
95 | |
96 | return 0; | |
97 | } | |
98 | ||
99 | /* ------------------------------------------------------------------------- */ | |
100 | ||
ea533c26 SW |
101 | static int set_dev(int dev) |
102 | { | |
103 | if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE || | |
104 | !nand_info[dev].name) { | |
105 | puts("No such device\n"); | |
106 | return -1; | |
107 | } | |
108 | ||
109 | if (nand_curr_device == dev) | |
110 | return 0; | |
111 | ||
112 | printf("Device %d: %s", dev, nand_info[dev].name); | |
113 | puts("... is now current device\n"); | |
114 | nand_curr_device = dev; | |
115 | ||
116 | #ifdef CONFIG_SYS_NAND_SELECT_DEVICE | |
117 | board_nand_select_device(nand_info[dev].priv, dev); | |
118 | #endif | |
119 | ||
120 | return 0; | |
121 | } | |
122 | ||
123 | static inline int str2off(const char *p, loff_t *num) | |
124 | { | |
125 | char *endptr; | |
126 | ||
127 | *num = simple_strtoull(p, &endptr, 16); | |
128 | return *p != '\0' && *endptr == '\0'; | |
129 | } | |
130 | ||
131 | static inline int str2long(const char *p, ulong *num) | |
addb2e16 | 132 | { |
856f0544 | 133 | char *endptr; |
addb2e16 | 134 | |
856f0544 | 135 | *num = simple_strtoul(p, &endptr, 16); |
ea533c26 | 136 | return *p != '\0' && *endptr == '\0'; |
856f0544 | 137 | } |
addb2e16 | 138 | |
ea533c26 | 139 | static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size) |
856f0544 | 140 | { |
ea533c26 | 141 | #ifdef CONFIG_CMD_MTDPARTS |
856f0544 SR |
142 | struct mtd_device *dev; |
143 | struct part_info *part; | |
144 | u8 pnum; | |
ea533c26 | 145 | int ret; |
856f0544 | 146 | |
ea533c26 SW |
147 | ret = mtdparts_init(); |
148 | if (ret) | |
149 | return ret; | |
150 | ||
151 | ret = find_dev_and_part(partname, &dev, &pnum, &part); | |
152 | if (ret) | |
153 | return ret; | |
154 | ||
155 | if (dev->id->type != MTD_DEV_TYPE_NAND) { | |
156 | puts("not a NAND device\n"); | |
157 | return -1; | |
856f0544 | 158 | } |
ea533c26 SW |
159 | |
160 | *off = part->offset; | |
161 | *size = part->size; | |
162 | *idx = dev->id->num; | |
163 | ||
164 | ret = set_dev(*idx); | |
165 | if (ret) | |
166 | return ret; | |
167 | ||
168 | return 0; | |
169 | #else | |
170 | puts("offset is not a number\n"); | |
171 | return -1; | |
addb2e16 | 172 | #endif |
ea533c26 | 173 | } |
addb2e16 | 174 | |
ea533c26 SW |
175 | static int arg_off(const char *arg, int *idx, loff_t *off, loff_t *maxsize) |
176 | { | |
177 | if (!str2off(arg, off)) | |
178 | return get_part(arg, idx, off, maxsize); | |
179 | ||
180 | if (*off >= nand_info[*idx].size) { | |
181 | puts("Offset exceeds device limit\n"); | |
182 | return -1; | |
183 | } | |
184 | ||
185 | *maxsize = nand_info[*idx].size - *off; | |
186 | return 0; | |
187 | } | |
188 | ||
189 | static int arg_off_size(int argc, char *const argv[], int *idx, | |
190 | loff_t *off, loff_t *size) | |
191 | { | |
192 | int ret; | |
193 | loff_t maxsize; | |
194 | ||
195 | if (argc == 0) { | |
856f0544 | 196 | *off = 0; |
ea533c26 SW |
197 | *size = nand_info[*idx].size; |
198 | goto print; | |
856f0544 | 199 | } |
addb2e16 | 200 | |
ea533c26 SW |
201 | ret = arg_off(argv[0], idx, off, &maxsize); |
202 | if (ret) | |
203 | return ret; | |
204 | ||
205 | if (argc == 1) { | |
206 | *size = maxsize; | |
207 | goto print; | |
addb2e16 BS |
208 | } |
209 | ||
ea533c26 SW |
210 | if (!str2off(argv[1], size)) { |
211 | printf("'%s' is not a number\n", argv[1]); | |
212 | return -1; | |
213 | } | |
214 | ||
215 | if (*size > maxsize) { | |
216 | puts("Size exceeds partition or device limit\n"); | |
217 | return -1; | |
218 | } | |
219 | ||
220 | print: | |
221 | printf("device %d ", *idx); | |
222 | if (*size == nand_info[*idx].size) | |
856f0544 SR |
223 | puts("whole chip\n"); |
224 | else | |
ea533c26 SW |
225 | printf("offset 0x%llx, size 0x%llx\n", |
226 | (unsigned long long)*off, (unsigned long long)*size); | |
856f0544 | 227 | return 0; |
addb2e16 BS |
228 | } |
229 | ||
50657c27 NM |
230 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
231 | static void print_status(ulong start, ulong end, ulong erasesize, int status) | |
232 | { | |
233 | printf("%08lx - %08lx: %08lx blocks %s%s%s\n", | |
234 | start, | |
235 | end - 1, | |
236 | (end - start) / erasesize, | |
237 | ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""), | |
238 | ((status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""), | |
239 | ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : "")); | |
240 | } | |
241 | ||
242 | static void do_nand_status(nand_info_t *nand) | |
243 | { | |
244 | ulong block_start = 0; | |
245 | ulong off; | |
246 | int last_status = -1; | |
247 | ||
248 | struct nand_chip *nand_chip = nand->priv; | |
249 | /* check the WP bit */ | |
250 | nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1); | |
251 | printf("device is %swrite protected\n", | |
252 | (nand_chip->read_byte(nand) & 0x80 ? | |
253 | "NOT " : "")); | |
254 | ||
255 | for (off = 0; off < nand->size; off += nand->erasesize) { | |
256 | int s = nand_get_lock_status(nand, off); | |
257 | ||
258 | /* print message only if status has changed */ | |
259 | if (s != last_status && off != 0) { | |
260 | print_status(block_start, off, nand->erasesize, | |
261 | last_status); | |
262 | block_start = off; | |
263 | } | |
264 | last_status = s; | |
265 | } | |
266 | /* Print the last block info */ | |
267 | print_status(block_start, off, nand->erasesize, last_status); | |
268 | } | |
269 | #endif | |
270 | ||
c9f7351b BG |
271 | #ifdef CONFIG_ENV_OFFSET_OOB |
272 | unsigned long nand_env_oob_offset; | |
273 | ||
ea533c26 | 274 | int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[]) |
c9f7351b BG |
275 | { |
276 | int ret; | |
277 | uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)]; | |
ea533c26 | 278 | nand_info_t *nand = &nand_info[0]; |
c9f7351b BG |
279 | char *cmd = argv[1]; |
280 | ||
ea533c26 SW |
281 | if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) { |
282 | puts("no devices available\n"); | |
283 | return 1; | |
284 | } | |
285 | ||
286 | set_dev(0); | |
287 | ||
c9f7351b BG |
288 | if (!strcmp(cmd, "get")) { |
289 | ret = get_nand_env_oob(nand, &nand_env_oob_offset); | |
53504a27 | 290 | if (ret) |
c9f7351b | 291 | return 1; |
53504a27 SW |
292 | |
293 | printf("0x%08lx\n", nand_env_oob_offset); | |
c9f7351b | 294 | } else if (!strcmp(cmd, "set")) { |
ea533c26 SW |
295 | loff_t addr; |
296 | loff_t maxsize; | |
c9f7351b | 297 | struct mtd_oob_ops ops; |
ea533c26 | 298 | int idx = 0; |
c9f7351b BG |
299 | |
300 | if (argc < 3) | |
301 | goto usage; | |
302 | ||
ea533c26 SW |
303 | if (arg_off(argv[2], &idx, &addr, &maxsize)) { |
304 | puts("Offset or partition name expected\n"); | |
305 | return 1; | |
306 | } | |
307 | ||
308 | if (idx != 0) { | |
309 | puts("Partition not on first NAND device\n"); | |
c9f7351b BG |
310 | return 1; |
311 | } | |
312 | ||
313 | if (nand->oobavail < ENV_OFFSET_SIZE) { | |
53504a27 SW |
314 | printf("Insufficient available OOB bytes:\n" |
315 | "%d OOB bytes available but %d required for " | |
316 | "env.oob support\n", | |
317 | nand->oobavail, ENV_OFFSET_SIZE); | |
c9f7351b BG |
318 | return 1; |
319 | } | |
320 | ||
321 | if ((addr & (nand->erasesize - 1)) != 0) { | |
322 | printf("Environment offset must be block-aligned\n"); | |
323 | return 1; | |
324 | } | |
325 | ||
326 | ops.datbuf = NULL; | |
327 | ops.mode = MTD_OOB_AUTO; | |
328 | ops.ooboffs = 0; | |
329 | ops.ooblen = ENV_OFFSET_SIZE; | |
330 | ops.oobbuf = (void *) oob_buf; | |
331 | ||
332 | oob_buf[0] = ENV_OOB_MARKER; | |
333 | oob_buf[1] = addr / nand->erasesize; | |
334 | ||
335 | ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops); | |
53504a27 | 336 | if (ret) { |
c9f7351b BG |
337 | printf("Error writing OOB block 0\n"); |
338 | return ret; | |
339 | } | |
53504a27 SW |
340 | |
341 | ret = get_nand_env_oob(nand, &nand_env_oob_offset); | |
342 | if (ret) { | |
343 | printf("Error reading env offset in OOB\n"); | |
344 | return ret; | |
345 | } | |
346 | ||
347 | if (addr != nand_env_oob_offset) { | |
348 | printf("Verification of env offset in OOB failed: " | |
ea533c26 SW |
349 | "0x%08llx expected but got 0x%08lx\n", |
350 | (unsigned long long)addr, nand_env_oob_offset); | |
53504a27 SW |
351 | return 1; |
352 | } | |
c9f7351b BG |
353 | } else { |
354 | goto usage; | |
355 | } | |
356 | ||
357 | return ret; | |
358 | ||
359 | usage: | |
47e26b1b | 360 | return cmd_usage(cmdtp); |
c9f7351b BG |
361 | } |
362 | ||
363 | #endif | |
364 | ||
672ed2ae WG |
365 | static void nand_print_info(int idx) |
366 | { | |
367 | nand_info_t *nand = &nand_info[idx]; | |
368 | struct nand_chip *chip = nand->priv; | |
369 | printf("Device %d: ", idx); | |
370 | if (chip->numchips > 1) | |
371 | printf("%dx ", chip->numchips); | |
372 | printf("%s, sector size %u KiB\n", | |
373 | nand->name, nand->erasesize >> 10); | |
374 | } | |
375 | ||
54841ab5 | 376 | int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[]) |
addb2e16 | 377 | { |
ea533c26 SW |
378 | int i, ret = 0; |
379 | ulong addr; | |
380 | loff_t off, size; | |
addb2e16 BS |
381 | char *cmd, *s; |
382 | nand_info_t *nand; | |
6d0f6bcf JCPV |
383 | #ifdef CONFIG_SYS_NAND_QUIET |
384 | int quiet = CONFIG_SYS_NAND_QUIET; | |
c750d2e6 | 385 | #else |
2255b2d2 | 386 | int quiet = 0; |
c750d2e6 | 387 | #endif |
2255b2d2 | 388 | const char *quiet_str = getenv("quiet"); |
ea533c26 | 389 | int dev = nand_curr_device; |
8c5659a6 | 390 | int repeat = flag & CMD_FLAG_REPEAT; |
addb2e16 BS |
391 | |
392 | /* at least two arguments please */ | |
393 | if (argc < 2) | |
394 | goto usage; | |
395 | ||
2255b2d2 SR |
396 | if (quiet_str) |
397 | quiet = simple_strtoul(quiet_str, NULL, 0) != 0; | |
398 | ||
addb2e16 BS |
399 | cmd = argv[1]; |
400 | ||
8c5659a6 SW |
401 | /* Only "dump" is repeatable. */ |
402 | if (repeat && strcmp(cmd, "dump")) | |
403 | return 0; | |
404 | ||
addb2e16 BS |
405 | if (strcmp(cmd, "info") == 0) { |
406 | ||
407 | putc('\n'); | |
6d0f6bcf | 408 | for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) { |
addb2e16 | 409 | if (nand_info[i].name) |
672ed2ae | 410 | nand_print_info(i); |
addb2e16 BS |
411 | } |
412 | return 0; | |
413 | } | |
414 | ||
415 | if (strcmp(cmd, "device") == 0) { | |
addb2e16 | 416 | if (argc < 3) { |
672ed2ae | 417 | putc('\n'); |
ea533c26 | 418 | if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE) |
672ed2ae | 419 | puts("no devices available\n"); |
addb2e16 | 420 | else |
ea533c26 | 421 | nand_print_info(dev); |
addb2e16 BS |
422 | return 0; |
423 | } | |
43a2b0e7 | 424 | |
ea533c26 SW |
425 | dev = (int)simple_strtoul(argv[2], NULL, 10); |
426 | set_dev(dev); | |
43a2b0e7 | 427 | |
addb2e16 BS |
428 | return 0; |
429 | } | |
430 | ||
c9f7351b BG |
431 | #ifdef CONFIG_ENV_OFFSET_OOB |
432 | /* this command operates only on the first nand device */ | |
ea533c26 SW |
433 | if (strcmp(cmd, "env.oob") == 0) |
434 | return do_nand_env_oob(cmdtp, argc - 1, argv + 1); | |
c9f7351b BG |
435 | #endif |
436 | ||
ea533c26 SW |
437 | /* The following commands operate on the current device, unless |
438 | * overridden by a partition specifier. Note that if somehow the | |
439 | * current device is invalid, it will have to be changed to a valid | |
440 | * one before these commands can run, even if a partition specifier | |
441 | * for another device is to be used. | |
442 | */ | |
443 | if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE || | |
444 | !nand_info[dev].name) { | |
addb2e16 BS |
445 | puts("\nno devices available\n"); |
446 | return 1; | |
447 | } | |
ea533c26 | 448 | nand = &nand_info[dev]; |
addb2e16 BS |
449 | |
450 | if (strcmp(cmd, "bad") == 0) { | |
ea533c26 | 451 | printf("\nDevice %d bad blocks:\n", dev); |
addb2e16 BS |
452 | for (off = 0; off < nand->size; off += nand->erasesize) |
453 | if (nand_block_isbad(nand, off)) | |
ea533c26 | 454 | printf(" %08llx\n", (unsigned long long)off); |
addb2e16 BS |
455 | return 0; |
456 | } | |
457 | ||
856f0544 SR |
458 | /* |
459 | * Syntax is: | |
460 | * 0 1 2 3 4 | |
461 | * nand erase [clean] [off size] | |
462 | */ | |
30486322 | 463 | if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) { |
2255b2d2 | 464 | nand_erase_options_t opts; |
856f0544 | 465 | /* "clean" at index 2 means request to write cleanmarker */ |
3043c045 | 466 | int clean = argc > 2 && !strcmp("clean", argv[2]); |
856f0544 | 467 | int o = clean ? 3 : 2; |
30486322 SW |
468 | int scrub = !strncmp(cmd, "scrub", 5); |
469 | int part = 0; | |
470 | int chip = 0; | |
471 | int spread = 0; | |
472 | int args = 2; | |
473 | ||
474 | if (cmd[5] != 0) { | |
475 | if (!strcmp(&cmd[5], ".spread")) { | |
476 | spread = 1; | |
477 | } else if (!strcmp(&cmd[5], ".part")) { | |
478 | part = 1; | |
479 | args = 1; | |
480 | } else if (!strcmp(&cmd[5], ".chip")) { | |
481 | chip = 1; | |
482 | args = 0; | |
483 | } else { | |
484 | goto usage; | |
485 | } | |
486 | } | |
487 | ||
488 | /* | |
489 | * Don't allow missing arguments to cause full chip/partition | |
490 | * erases -- easy to do accidentally, e.g. with a misspelled | |
491 | * variable name. | |
492 | */ | |
493 | if (argc != o + args) | |
494 | goto usage; | |
2255b2d2 | 495 | |
30486322 | 496 | printf("\nNAND %s: ", cmd); |
856f0544 | 497 | /* skip first two or three arguments, look for offset and size */ |
ea533c26 | 498 | if (arg_off_size(argc - o, argv + o, &dev, &off, &size) != 0) |
856f0544 | 499 | return 1; |
2255b2d2 | 500 | |
ea533c26 SW |
501 | nand = &nand_info[dev]; |
502 | ||
2255b2d2 SR |
503 | memset(&opts, 0, sizeof(opts)); |
504 | opts.offset = off; | |
505 | opts.length = size; | |
506 | opts.jffs2 = clean; | |
507 | opts.quiet = quiet; | |
30486322 | 508 | opts.spread = spread; |
2255b2d2 SR |
509 | |
510 | if (scrub) { | |
856f0544 SR |
511 | puts("Warning: " |
512 | "scrub option will erase all factory set " | |
513 | "bad blocks!\n" | |
514 | " " | |
515 | "There is no reliable way to recover them.\n" | |
516 | " " | |
517 | "Use this command only for testing purposes " | |
518 | "if you\n" | |
519 | " " | |
520 | "are sure of what you are doing!\n" | |
521 | "\nReally scrub this NAND flash? <y/N>\n"); | |
2255b2d2 | 522 | |
6b94b496 FF |
523 | if (getc() == 'y') { |
524 | puts("y"); | |
525 | if (getc() == '\r') | |
526 | opts.scrub = 1; | |
527 | else { | |
528 | puts("scrub aborted\n"); | |
529 | return -1; | |
530 | } | |
2255b2d2 | 531 | } else { |
856f0544 | 532 | puts("scrub aborted\n"); |
2255b2d2 SR |
533 | return -1; |
534 | } | |
535 | } | |
536 | ret = nand_erase_opts(nand, &opts); | |
addb2e16 BS |
537 | printf("%s\n", ret ? "ERROR" : "OK"); |
538 | ||
539 | return ret == 0 ? 0 : 1; | |
540 | } | |
541 | ||
542 | if (strncmp(cmd, "dump", 4) == 0) { | |
543 | if (argc < 3) | |
544 | goto usage; | |
545 | ||
addb2e16 | 546 | off = (int)simple_strtoul(argv[2], NULL, 16); |
8c5659a6 | 547 | ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat); |
addb2e16 BS |
548 | |
549 | return ret == 0 ? 1 : 0; | |
addb2e16 BS |
550 | } |
551 | ||
addb2e16 | 552 | if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) { |
ea533c26 | 553 | size_t rwsize; |
2255b2d2 SR |
554 | int read; |
555 | ||
addb2e16 BS |
556 | if (argc < 4) |
557 | goto usage; | |
2255b2d2 | 558 | |
addb2e16 BS |
559 | addr = (ulong)simple_strtoul(argv[2], NULL, 16); |
560 | ||
2255b2d2 | 561 | read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */ |
856f0544 | 562 | printf("\nNAND %s: ", read ? "read" : "write"); |
ea533c26 | 563 | if (arg_off_size(argc - 3, argv + 3, &dev, &off, &size) != 0) |
856f0544 | 564 | return 1; |
4cbb651b | 565 | |
ea533c26 SW |
566 | nand = &nand_info[dev]; |
567 | rwsize = size; | |
568 | ||
2255b2d2 | 569 | s = strchr(cmd, '.'); |
984e03cd SW |
570 | if (!s || !strcmp(s, ".jffs2") || |
571 | !strcmp(s, ".e") || !strcmp(s, ".i")) { | |
dfbf617f | 572 | if (read) |
ea533c26 | 573 | ret = nand_read_skip_bad(nand, off, &rwsize, |
4b070809 | 574 | (u_char *)addr); |
dfbf617f | 575 | else |
ea533c26 | 576 | ret = nand_write_skip_bad(nand, off, &rwsize, |
4b070809 | 577 | (u_char *)addr); |
dfc99e14 | 578 | } else if (!strcmp(s, ".oob")) { |
cfa460ad WJ |
579 | /* out-of-band data */ |
580 | mtd_oob_ops_t ops = { | |
581 | .oobbuf = (u8 *)addr, | |
ea533c26 | 582 | .ooblen = rwsize, |
cfa460ad WJ |
583 | .mode = MTD_OOB_RAW |
584 | }; | |
585 | ||
62d4f436 | 586 | if (read) |
cfa460ad | 587 | ret = nand->read_oob(nand, off, &ops); |
62d4f436 | 588 | else |
cfa460ad | 589 | ret = nand->write_oob(nand, off, &ops); |
856f0544 | 590 | } else { |
984e03cd SW |
591 | printf("Unknown nand command suffix '%s'.\n", s); |
592 | return 1; | |
2255b2d2 SR |
593 | } |
594 | ||
ea533c26 | 595 | printf(" %zu bytes %s: %s\n", rwsize, |
2255b2d2 | 596 | read ? "read" : "written", ret ? "ERROR" : "OK"); |
addb2e16 BS |
597 | |
598 | return ret == 0 ? 0 : 1; | |
599 | } | |
2255b2d2 | 600 | |
2255b2d2 | 601 | if (strcmp(cmd, "markbad") == 0) { |
8360b66b WD |
602 | argc -= 2; |
603 | argv += 2; | |
2255b2d2 | 604 | |
8360b66b WD |
605 | if (argc <= 0) |
606 | goto usage; | |
607 | ||
608 | while (argc > 0) { | |
609 | addr = simple_strtoul(*argv, NULL, 16); | |
610 | ||
611 | if (nand->block_markbad(nand, addr)) { | |
612 | printf("block 0x%08lx NOT marked " | |
613 | "as bad! ERROR %d\n", | |
614 | addr, ret); | |
615 | ret = 1; | |
616 | } else { | |
617 | printf("block 0x%08lx successfully " | |
618 | "marked as bad\n", | |
619 | addr); | |
620 | } | |
621 | --argc; | |
622 | ++argv; | |
2255b2d2 | 623 | } |
8360b66b | 624 | return ret; |
2255b2d2 | 625 | } |
dfbf617f | 626 | |
2255b2d2 SR |
627 | if (strcmp(cmd, "biterr") == 0) { |
628 | /* todo */ | |
629 | return 1; | |
630 | } | |
631 | ||
50657c27 | 632 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
2255b2d2 | 633 | if (strcmp(cmd, "lock") == 0) { |
50657c27 | 634 | int tight = 0; |
2255b2d2 SR |
635 | int status = 0; |
636 | if (argc == 3) { | |
637 | if (!strcmp("tight", argv[2])) | |
638 | tight = 1; | |
639 | if (!strcmp("status", argv[2])) | |
640 | status = 1; | |
641 | } | |
2255b2d2 | 642 | if (status) { |
50657c27 | 643 | do_nand_status(nand); |
cfa460ad | 644 | } else { |
5e1dae5c WJ |
645 | if (!nand_lock(nand, tight)) { |
646 | puts("NAND flash successfully locked\n"); | |
647 | } else { | |
648 | puts("Error locking NAND flash\n"); | |
649 | return 1; | |
650 | } | |
2255b2d2 SR |
651 | } |
652 | return 0; | |
653 | } | |
654 | ||
655 | if (strcmp(cmd, "unlock") == 0) { | |
16e00992 | 656 | if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size) < 0) |
856f0544 | 657 | return 1; |
2255b2d2 | 658 | |
ea533c26 | 659 | if (!nand_unlock(&nand_info[dev], off, size)) { |
5e1dae5c WJ |
660 | puts("NAND flash successfully unlocked\n"); |
661 | } else { | |
662 | puts("Error unlocking NAND flash, " | |
3043c045 | 663 | "write and erase will probably fail\n"); |
5e1dae5c WJ |
664 | return 1; |
665 | } | |
2255b2d2 SR |
666 | return 0; |
667 | } | |
50657c27 | 668 | #endif |
2255b2d2 | 669 | |
addb2e16 | 670 | usage: |
47e26b1b | 671 | return cmd_usage(cmdtp); |
addb2e16 BS |
672 | } |
673 | ||
388a29d0 FM |
674 | U_BOOT_CMD( |
675 | nand, CONFIG_SYS_MAXARGS, 1, do_nand, | |
a89c33db WD |
676 | "NAND sub-system", |
677 | "info - show available NAND devices\n" | |
678 | "nand device [dev] - show or set current device\n" | |
679 | "nand read - addr off|partition size\n" | |
680 | "nand write - addr off|partition size\n" | |
681 | " read/write 'size' bytes starting at offset 'off'\n" | |
682 | " to/from memory address 'addr', skipping bad blocks.\n" | |
30486322 SW |
683 | "nand erase[.spread] [clean] [off [size]] - erase 'size' bytes " |
684 | "from offset 'off'\n" | |
685 | " With '.spread', erase enough for given file size, otherwise,\n" | |
686 | " 'size' includes skipped bad blocks.\n" | |
687 | "nand erase.part [clean] partition - erase entire mtd partition'\n" | |
688 | "nand erase.chip [clean] - erase entire chip'\n" | |
a89c33db WD |
689 | "nand bad - show bad blocks\n" |
690 | "nand dump[.oob] off - dump page\n" | |
30486322 SW |
691 | "nand scrub off size | scrub.part partition | scrub.chip\n" |
692 | " really clean NAND erasing bad blocks (UNSAFE)\n" | |
a89c33db WD |
693 | "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n" |
694 | "nand biterr off - make a bit error at offset (UNSAFE)" | |
50657c27 | 695 | #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK |
a89c33db WD |
696 | "\n" |
697 | "nand lock [tight] [status]\n" | |
698 | " bring nand to lock state or display locked pages\n" | |
699 | "nand unlock [offset] [size] - unlock section" | |
50657c27 | 700 | #endif |
c9f7351b BG |
701 | #ifdef CONFIG_ENV_OFFSET_OOB |
702 | "\n" | |
703 | "nand env.oob - environment offset in OOB of block 0 of" | |
704 | " first device.\n" | |
705 | "nand env.oob set off|partition - set enviromnent offset\n" | |
706 | "nand env.oob get - get environment offset" | |
707 | #endif | |
50657c27 | 708 | ); |
addb2e16 | 709 | |
856f0544 | 710 | static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand, |
4b070809 | 711 | ulong offset, ulong addr, char *cmd) |
addb2e16 | 712 | { |
addb2e16 | 713 | int r; |
10e03893 | 714 | char *ep, *s; |
4ca79f47 | 715 | size_t cnt; |
addb2e16 | 716 | image_header_t *hdr; |
09475f75 | 717 | #if defined(CONFIG_FIT) |
3bab76a2 | 718 | const void *fit_hdr = NULL; |
09475f75 | 719 | #endif |
10e03893 TK |
720 | |
721 | s = strchr(cmd, '.'); | |
722 | if (s != NULL && | |
65d8bc94 | 723 | (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) { |
984e03cd SW |
724 | printf("Unknown nand load suffix '%s'\n", s); |
725 | show_boot_progress(-53); | |
726 | return 1; | |
727 | } | |
addb2e16 | 728 | |
856f0544 | 729 | printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset); |
addb2e16 | 730 | |
cfa460ad | 731 | cnt = nand->writesize; |
09875055 | 732 | r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr); |
addb2e16 | 733 | if (r) { |
856f0544 | 734 | puts("** Read error\n"); |
fad63407 | 735 | show_boot_progress (-56); |
addb2e16 BS |
736 | return 1; |
737 | } | |
fad63407 | 738 | show_boot_progress (56); |
addb2e16 | 739 | |
9a4daad0 | 740 | switch (genimg_get_format ((void *)addr)) { |
d5934ad7 MB |
741 | case IMAGE_FORMAT_LEGACY: |
742 | hdr = (image_header_t *)addr; | |
743 | ||
d5934ad7 | 744 | show_boot_progress (57); |
d5934ad7 | 745 | image_print_contents (hdr); |
addb2e16 | 746 | |
d5934ad7 MB |
747 | cnt = image_get_image_size (hdr); |
748 | break; | |
749 | #if defined(CONFIG_FIT) | |
750 | case IMAGE_FORMAT_FIT: | |
09475f75 | 751 | fit_hdr = (const void *)addr; |
09475f75 MB |
752 | puts ("Fit image detected...\n"); |
753 | ||
754 | cnt = fit_get_size (fit_hdr); | |
755 | break; | |
d5934ad7 MB |
756 | #endif |
757 | default: | |
09475f75 | 758 | show_boot_progress (-57); |
d5934ad7 | 759 | puts ("** Unknown image type\n"); |
addb2e16 BS |
760 | return 1; |
761 | } | |
3043c045 | 762 | show_boot_progress (57); |
addb2e16 | 763 | |
09875055 | 764 | r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr); |
addb2e16 | 765 | if (r) { |
856f0544 | 766 | puts("** Read error\n"); |
fad63407 | 767 | show_boot_progress (-58); |
addb2e16 BS |
768 | return 1; |
769 | } | |
fad63407 | 770 | show_boot_progress (58); |
addb2e16 | 771 | |
09475f75 MB |
772 | #if defined(CONFIG_FIT) |
773 | /* This cannot be done earlier, we need complete FIT image in RAM first */ | |
3bab76a2 MB |
774 | if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) { |
775 | if (!fit_check_format (fit_hdr)) { | |
776 | show_boot_progress (-150); | |
777 | puts ("** Bad FIT image format\n"); | |
778 | return 1; | |
779 | } | |
780 | show_boot_progress (151); | |
781 | fit_print_contents (fit_hdr); | |
782 | } | |
09475f75 MB |
783 | #endif |
784 | ||
addb2e16 BS |
785 | /* Loading ok, update default load address */ |
786 | ||
787 | load_addr = addr; | |
788 | ||
789 | /* Check if we should attempt an auto-start */ | |
790 | if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) { | |
791 | char *local_args[2]; | |
792 | extern int do_bootm(cmd_tbl_t *, int, int, char *[]); | |
793 | ||
856f0544 | 794 | local_args[0] = cmd; |
addb2e16 BS |
795 | local_args[1] = NULL; |
796 | ||
797 | printf("Automatic boot of image at addr 0x%08lx ...\n", addr); | |
798 | ||
799 | do_bootm(cmdtp, 0, 1, local_args); | |
800 | return 1; | |
801 | } | |
802 | return 0; | |
803 | } | |
804 | ||
54841ab5 | 805 | int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[]) |
856f0544 SR |
806 | { |
807 | char *boot_device = NULL; | |
808 | int idx; | |
809 | ulong addr, offset = 0; | |
0c8a8491 | 810 | #if defined(CONFIG_CMD_MTDPARTS) |
856f0544 SR |
811 | struct mtd_device *dev; |
812 | struct part_info *part; | |
813 | u8 pnum; | |
814 | ||
815 | if (argc >= 2) { | |
816 | char *p = (argc == 2) ? argv[1] : argv[2]; | |
817 | if (!(str2long(p, &addr)) && (mtdparts_init() == 0) && | |
818 | (find_dev_and_part(p, &dev, &pnum, &part) == 0)) { | |
819 | if (dev->id->type != MTD_DEV_TYPE_NAND) { | |
820 | puts("Not a NAND device\n"); | |
821 | return 1; | |
822 | } | |
823 | if (argc > 3) | |
824 | goto usage; | |
825 | if (argc == 3) | |
10e03893 | 826 | addr = simple_strtoul(argv[1], NULL, 16); |
856f0544 | 827 | else |
6d0f6bcf | 828 | addr = CONFIG_SYS_LOAD_ADDR; |
856f0544 | 829 | return nand_load_image(cmdtp, &nand_info[dev->id->num], |
4b070809 | 830 | part->offset, addr, argv[0]); |
856f0544 SR |
831 | } |
832 | } | |
833 | #endif | |
834 | ||
fad63407 | 835 | show_boot_progress(52); |
856f0544 SR |
836 | switch (argc) { |
837 | case 1: | |
6d0f6bcf | 838 | addr = CONFIG_SYS_LOAD_ADDR; |
856f0544 SR |
839 | boot_device = getenv("bootdevice"); |
840 | break; | |
841 | case 2: | |
842 | addr = simple_strtoul(argv[1], NULL, 16); | |
843 | boot_device = getenv("bootdevice"); | |
844 | break; | |
845 | case 3: | |
846 | addr = simple_strtoul(argv[1], NULL, 16); | |
847 | boot_device = argv[2]; | |
848 | break; | |
849 | case 4: | |
850 | addr = simple_strtoul(argv[1], NULL, 16); | |
851 | boot_device = argv[2]; | |
852 | offset = simple_strtoul(argv[3], NULL, 16); | |
853 | break; | |
854 | default: | |
0c8a8491 | 855 | #if defined(CONFIG_CMD_MTDPARTS) |
856f0544 SR |
856 | usage: |
857 | #endif | |
fad63407 | 858 | show_boot_progress(-53); |
47e26b1b | 859 | return cmd_usage(cmdtp); |
856f0544 SR |
860 | } |
861 | ||
fad63407 | 862 | show_boot_progress(53); |
856f0544 SR |
863 | if (!boot_device) { |
864 | puts("\n** No boot device **\n"); | |
fad63407 | 865 | show_boot_progress(-54); |
856f0544 SR |
866 | return 1; |
867 | } | |
fad63407 | 868 | show_boot_progress(54); |
addb2e16 | 869 | |
856f0544 SR |
870 | idx = simple_strtoul(boot_device, NULL, 16); |
871 | ||
6d0f6bcf | 872 | if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) { |
856f0544 | 873 | printf("\n** Device %d not available\n", idx); |
fad63407 | 874 | show_boot_progress(-55); |
856f0544 SR |
875 | return 1; |
876 | } | |
fad63407 | 877 | show_boot_progress(55); |
856f0544 SR |
878 | |
879 | return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]); | |
880 | } | |
881 | ||
882 | U_BOOT_CMD(nboot, 4, 1, do_nandboot, | |
2fb2604d | 883 | "boot from NAND device", |
a89c33db WD |
884 | "[partition] | [[[loadAddr] dev] offset]" |
885 | ); |