]>
Commit | Line | Data |
---|---|---|
c609719b WD |
1 | /* |
2 | * (C) Copyright 2002 | |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
700a0c64 | 4 | * |
dd875c76 WD |
5 | * (C) Copyright 2002 |
6 | * Robert Schwebel, Pengutronix, <r.schwebel@pengutronix.de> | |
700a0c64 | 7 | * |
dd875c76 WD |
8 | * (C) Copyright 2003 |
9 | * Kai-Uwe Bloem, Auerswald GmbH & Co KG, <linux-development@auerswald.de> | |
c609719b | 10 | * |
700a0c64 WD |
11 | * (C) Copyright 2005 |
12 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
13 | * | |
14 | * Added support for reading flash partition table from environment. | |
15 | * Parsing routines are based on driver/mtd/cmdline.c from the linux 2.4 | |
16 | * kernel tree. | |
17 | * | |
18 | * $Id: cmdlinepart.c,v 1.17 2004/11/26 11:18:47 lavinen Exp $ | |
19 | * Copyright 2002 SYSGO Real-Time Solutions GmbH | |
20 | * | |
1a459660 | 21 | * SPDX-License-Identifier: GPL-2.0+ |
700a0c64 WD |
22 | */ |
23 | ||
24 | /* | |
25 | * Three environment variables are used by the parsing routines: | |
26 | * | |
27 | * 'partition' - keeps current partition identifier | |
28 | * | |
29 | * partition := <part-id> | |
30 | * <part-id> := <dev-id>,part_num | |
31 | * | |
8f79e4c2 | 32 | * |
700a0c64 WD |
33 | * 'mtdids' - linux kernel mtd device id <-> u-boot device id mapping |
34 | * | |
35 | * mtdids=<idmap>[,<idmap>,...] | |
36 | * | |
37 | * <idmap> := <dev-id>=<mtd-id> | |
1a7f8cce | 38 | * <dev-id> := 'nand'|'nor'|'onenand'<dev-num> |
700a0c64 WD |
39 | * <dev-num> := mtd device number, 0... |
40 | * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) | |
41 | * | |
42 | * | |
43 | * 'mtdparts' - partition list | |
44 | * | |
45 | * mtdparts=mtdparts=<mtd-def>[;<mtd-def>...] | |
46 | * | |
47 | * <mtd-def> := <mtd-id>:<part-def>[,<part-def>...] | |
48 | * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) | |
49 | * <part-def> := <size>[@<offset>][<name>][<ro-flag>] | |
50 | * <size> := standard linux memsize OR '-' to denote all remaining space | |
51 | * <offset> := partition start offset within the device | |
52 | * <name> := '(' NAME ')' | |
53 | * <ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel) | |
54 | * | |
55 | * Notes: | |
56 | * - each <mtd-id> used in mtdparts must albo exist in 'mtddis' mapping | |
57 | * - if the above variables are not set defaults for a given target are used | |
58 | * | |
59 | * Examples: | |
60 | * | |
61 | * 1 NOR Flash, with 1 single writable partition: | |
62 | * mtdids=nor0=edb7312-nor | |
63 | * mtdparts=mtdparts=edb7312-nor:- | |
64 | * | |
65 | * 1 NOR Flash with 2 partitions, 1 NAND with one | |
66 | * mtdids=nor0=edb7312-nor,nand0=edb7312-nand | |
67 | * mtdparts=mtdparts=edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home) | |
68 | * | |
69 | */ | |
70 | ||
71 | /* | |
991b089d | 72 | * JFFS2/CRAMFS support |
700a0c64 WD |
73 | */ |
74 | #include <common.h> | |
75 | #include <command.h> | |
76 | #include <malloc.h> | |
77 | #include <jffs2/jffs2.h> | |
700a0c64 WD |
78 | #include <linux/list.h> |
79 | #include <linux/ctype.h> | |
700a0c64 WD |
80 | #include <cramfs/cramfs_fs.h> |
81 | ||
c76fe474 | 82 | #if defined(CONFIG_CMD_NAND) |
addb2e16 | 83 | #include <linux/mtd/nand.h> |
ac7eb8a3 | 84 | #include <nand.h> |
c76fe474 | 85 | #endif |
1a7f8cce KP |
86 | |
87 | #if defined(CONFIG_CMD_ONENAND) | |
88 | #include <linux/mtd/mtd.h> | |
89 | #include <linux/mtd/onenand.h> | |
90 | #include <onenand_uboot.h> | |
91 | #endif | |
92 | ||
700a0c64 | 93 | /* enable/disable debugging messages */ |
038ccac5 BS |
94 | #define DEBUG_JFFS |
95 | #undef DEBUG_JFFS | |
700a0c64 | 96 | |
ab4b956d | 97 | #ifdef DEBUG_JFFS |
700a0c64 WD |
98 | # define DEBUGF(fmt, args...) printf(fmt ,##args) |
99 | #else | |
100 | # define DEBUGF(fmt, args...) | |
101 | #endif | |
102 | ||
103 | /* special size referring to all the remaining space in a partition */ | |
104 | #define SIZE_REMAINING 0xFFFFFFFF | |
105 | ||
106 | /* special offset value, it is used when not provided by user | |
107 | * | |
108 | * this value is used temporarily during parsing, later such offests | |
109 | * are recalculated */ | |
110 | #define OFFSET_NOT_SPECIFIED 0xFFFFFFFF | |
111 | ||
112 | /* minimum partition size */ | |
113 | #define MIN_PART_SIZE 4096 | |
114 | ||
115 | /* this flag needs to be set in part_info struct mask_flags | |
116 | * field for read-only partitions */ | |
038ccac5 | 117 | #define MTD_WRITEABLE_CMD 1 |
700a0c64 | 118 | |
68d7d651 | 119 | /* current active device and partition number */ |
76b5883d SR |
120 | #ifdef CONFIG_CMD_MTDPARTS |
121 | /* Use the ones declared in cmd_mtdparts.c */ | |
122 | extern struct mtd_device *current_mtd_dev; | |
123 | extern u8 current_mtd_partnum; | |
124 | #else | |
125 | /* Use local ones */ | |
126 | struct mtd_device *current_mtd_dev = NULL; | |
127 | u8 current_mtd_partnum = 0; | |
128 | #endif | |
700a0c64 | 129 | |
68d7d651 SR |
130 | #if defined(CONFIG_CMD_CRAMFS) |
131 | extern int cramfs_check (struct part_info *info); | |
132 | extern int cramfs_load (char *loadoffset, struct part_info *info, char *filename); | |
133 | extern int cramfs_ls (struct part_info *info, char *filename); | |
134 | extern int cramfs_info (struct part_info *info); | |
135 | #else | |
136 | /* defining empty macros for function names is ugly but avoids ifdef clutter | |
137 | * all over the code */ | |
138 | #define cramfs_check(x) (0) | |
139 | #define cramfs_load(x,y,z) (-1) | |
140 | #define cramfs_ls(x,y) (0) | |
141 | #define cramfs_info(x) (0) | |
142 | #endif | |
700a0c64 | 143 | |
68d7d651 | 144 | #ifndef CONFIG_CMD_MTDPARTS |
700a0c64 | 145 | /** |
68d7d651 | 146 | * Check device number to be within valid range for given device type. |
700a0c64 | 147 | * |
68d7d651 SR |
148 | * @param dev device to validate |
149 | * @return 0 if device is valid, 1 otherwise | |
c609719b | 150 | */ |
68d7d651 | 151 | static int mtd_device_validate(u8 type, u8 num, u32 *size) |
700a0c64 | 152 | { |
68d7d651 SR |
153 | if (type == MTD_DEV_TYPE_NOR) { |
154 | #if defined(CONFIG_CMD_FLASH) | |
155 | if (num < CONFIG_SYS_MAX_FLASH_BANKS) { | |
156 | extern flash_info_t flash_info[]; | |
157 | *size = flash_info[num].size; | |
180d3f74 | 158 | |
68d7d651 | 159 | return 0; |
700a0c64 | 160 | } |
c609719b | 161 | |
68d7d651 SR |
162 | printf("no such FLASH device: %s%d (valid range 0 ... %d\n", |
163 | MTD_DEV_TYPE(type), num, CONFIG_SYS_MAX_FLASH_BANKS - 1); | |
164 | #else | |
165 | printf("support for FLASH devices not present\n"); | |
166 | #endif | |
167 | } else if (type == MTD_DEV_TYPE_NAND) { | |
168 | #if defined(CONFIG_JFFS2_NAND) && defined(CONFIG_CMD_NAND) | |
bfdba68e GS |
169 | struct mtd_info *mtd = get_nand_dev_by_index(num); |
170 | if (mtd) { | |
171 | *size = mtd->size; | |
68d7d651 | 172 | return 0; |
700a0c64 | 173 | } |
6705d81e | 174 | |
68d7d651 SR |
175 | printf("no such NAND device: %s%d (valid range 0 ... %d)\n", |
176 | MTD_DEV_TYPE(type), num, CONFIG_SYS_MAX_NAND_DEVICE - 1); | |
177 | #else | |
178 | printf("support for NAND devices not present\n"); | |
179 | #endif | |
180 | } else if (type == MTD_DEV_TYPE_ONENAND) { | |
181 | #if defined(CONFIG_CMD_ONENAND) | |
182 | *size = onenand_mtd.size; | |
183 | return 0; | |
184 | #else | |
185 | printf("support for OneNAND devices not present\n"); | |
186 | #endif | |
187 | } else | |
188 | printf("Unknown defice type %d\n", type); | |
c609719b | 189 | |
68d7d651 | 190 | return 1; |
700a0c64 | 191 | } |
998eaaec | 192 | |
700a0c64 | 193 | /** |
68d7d651 SR |
194 | * Parse device id string <dev-id> := 'nand'|'nor'|'onenand'<dev-num>, |
195 | * return device type and number. | |
700a0c64 | 196 | * |
68d7d651 SR |
197 | * @param id string describing device id |
198 | * @param ret_id output pointer to next char after parse completes (output) | |
199 | * @param dev_type parsed device type (output) | |
200 | * @param dev_num parsed device number (output) | |
700a0c64 WD |
201 | * @return 0 on success, 1 otherwise |
202 | */ | |
68d7d651 | 203 | static int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num) |
c609719b | 204 | { |
68d7d651 | 205 | const char *p = id; |
700a0c64 | 206 | |
68d7d651 SR |
207 | *dev_type = 0; |
208 | if (strncmp(p, "nand", 4) == 0) { | |
209 | *dev_type = MTD_DEV_TYPE_NAND; | |
210 | p += 4; | |
211 | } else if (strncmp(p, "nor", 3) == 0) { | |
212 | *dev_type = MTD_DEV_TYPE_NOR; | |
213 | p += 3; | |
214 | } else if (strncmp(p, "onenand", 7) == 0) { | |
215 | *dev_type = MTD_DEV_TYPE_ONENAND; | |
216 | p += 7; | |
217 | } else { | |
218 | printf("incorrect device type in %s\n", id); | |
700a0c64 WD |
219 | return 1; |
220 | } | |
c609719b | 221 | |
68d7d651 SR |
222 | if (!isdigit(*p)) { |
223 | printf("incorrect device number in %s\n", id); | |
700a0c64 WD |
224 | return 1; |
225 | } | |
226 | ||
68d7d651 SR |
227 | *dev_num = simple_strtoul(p, (char **)&p, 0); |
228 | if (ret_id) | |
229 | *ret_id = p; | |
700a0c64 WD |
230 | return 0; |
231 | } | |
68d7d651 | 232 | |
700a0c64 WD |
233 | /* |
234 | * 'Static' version of command line mtdparts_init() routine. Single partition on | |
235 | * a single device configuration. | |
236 | */ | |
237 | ||
b5b004ad TF |
238 | /** |
239 | * Calculate sector size. | |
240 | * | |
241 | * @return sector size | |
242 | */ | |
243 | static inline u32 get_part_sector_size_nand(struct mtdids *id) | |
244 | { | |
245 | #if defined(CONFIG_JFFS2_NAND) && defined(CONFIG_CMD_NAND) | |
151c06ec | 246 | struct mtd_info *mtd; |
b5b004ad | 247 | |
bfdba68e | 248 | mtd = get_nand_dev_by_index(id->num); |
b5b004ad | 249 | |
151c06ec | 250 | return mtd->erasesize; |
b5b004ad TF |
251 | #else |
252 | BUG(); | |
253 | return 0; | |
254 | #endif | |
255 | } | |
256 | ||
257 | static inline u32 get_part_sector_size_nor(struct mtdids *id, struct part_info *part) | |
258 | { | |
259 | #if defined(CONFIG_CMD_FLASH) | |
260 | extern flash_info_t flash_info[]; | |
261 | ||
262 | u32 end_phys, start_phys, sector_size = 0, size = 0; | |
263 | int i; | |
264 | flash_info_t *flash; | |
265 | ||
266 | flash = &flash_info[id->num]; | |
267 | ||
268 | start_phys = flash->start[0] + part->offset; | |
141053d6 | 269 | end_phys = start_phys + part->size - 1; |
b5b004ad TF |
270 | |
271 | for (i = 0; i < flash->sector_count; i++) { | |
272 | if (flash->start[i] >= end_phys) | |
273 | break; | |
274 | ||
275 | if (flash->start[i] >= start_phys) { | |
276 | if (i == flash->sector_count - 1) { | |
277 | size = flash->start[0] + flash->size - flash->start[i]; | |
278 | } else { | |
279 | size = flash->start[i+1] - flash->start[i]; | |
280 | } | |
281 | ||
282 | if (sector_size < size) | |
283 | sector_size = size; | |
284 | } | |
285 | } | |
286 | ||
287 | return sector_size; | |
288 | #else | |
289 | BUG(); | |
290 | return 0; | |
291 | #endif | |
292 | } | |
293 | ||
294 | static inline u32 get_part_sector_size_onenand(void) | |
295 | { | |
296 | #if defined(CONFIG_CMD_ONENAND) | |
297 | struct mtd_info *mtd; | |
298 | ||
299 | mtd = &onenand_mtd; | |
300 | ||
301 | return mtd->erasesize; | |
302 | #else | |
303 | BUG(); | |
304 | return 0; | |
305 | #endif | |
306 | } | |
307 | ||
308 | static inline u32 get_part_sector_size(struct mtdids *id, struct part_info *part) | |
309 | { | |
310 | if (id->type == MTD_DEV_TYPE_NAND) | |
311 | return get_part_sector_size_nand(id); | |
312 | else if (id->type == MTD_DEV_TYPE_NOR) | |
313 | return get_part_sector_size_nor(id, part); | |
314 | else if (id->type == MTD_DEV_TYPE_ONENAND) | |
315 | return get_part_sector_size_onenand(); | |
316 | else | |
317 | DEBUGF("Error: Unknown device type.\n"); | |
318 | ||
319 | return 0; | |
320 | } | |
321 | ||
700a0c64 WD |
322 | /** |
323 | * Parse and initialize global mtdids mapping and create global | |
8f79e4c2 | 324 | * device/partition list. |
700a0c64 | 325 | * |
76b5883d SR |
326 | * 'Static' version of command line mtdparts_init() routine. Single partition on |
327 | * a single device configuration. | |
328 | * | |
700a0c64 WD |
329 | * @return 0 on success, 1 otherwise |
330 | */ | |
331 | int mtdparts_init(void) | |
332 | { | |
333 | static int initialized = 0; | |
334 | u32 size; | |
335 | char *dev_name; | |
336 | ||
337 | DEBUGF("\n---mtdparts_init---\n"); | |
338 | if (!initialized) { | |
c4e0e686 WD |
339 | struct mtdids *id; |
340 | struct part_info *part; | |
341 | ||
700a0c64 | 342 | initialized = 1; |
76b5883d | 343 | current_mtd_dev = (struct mtd_device *) |
700a0c64 WD |
344 | malloc(sizeof(struct mtd_device) + |
345 | sizeof(struct part_info) + | |
346 | sizeof(struct mtdids)); | |
76b5883d | 347 | if (!current_mtd_dev) { |
700a0c64 WD |
348 | printf("out of memory\n"); |
349 | return 1; | |
350 | } | |
76b5883d SR |
351 | memset(current_mtd_dev, 0, sizeof(struct mtd_device) + |
352 | sizeof(struct part_info) + sizeof(struct mtdids)); | |
700a0c64 | 353 | |
76b5883d | 354 | id = (struct mtdids *)(current_mtd_dev + 1); |
c4e0e686 | 355 | part = (struct part_info *)(id + 1); |
c609719b | 356 | |
700a0c64 WD |
357 | /* id */ |
358 | id->mtd_id = "single part"; | |
c609719b | 359 | |
700a0c64 WD |
360 | #if defined(CONFIG_JFFS2_DEV) |
361 | dev_name = CONFIG_JFFS2_DEV; | |
c609719b | 362 | #else |
700a0c64 | 363 | dev_name = "nor0"; |
c609719b WD |
364 | #endif |
365 | ||
68d7d651 SR |
366 | if ((mtd_id_parse(dev_name, NULL, &id->type, &id->num) != 0) || |
367 | (mtd_device_validate(id->type, id->num, &size) != 0)) { | |
700a0c64 | 368 | printf("incorrect device: %s%d\n", MTD_DEV_TYPE(id->type), id->num); |
76b5883d | 369 | free(current_mtd_dev); |
700a0c64 WD |
370 | return 1; |
371 | } | |
372 | id->size = size; | |
373 | INIT_LIST_HEAD(&id->link); | |
374 | ||
375 | DEBUGF("dev id: type = %d, num = %d, size = 0x%08lx, mtd_id = %s\n", | |
376 | id->type, id->num, id->size, id->mtd_id); | |
377 | ||
378 | /* partition */ | |
379 | part->name = "static"; | |
380 | part->auto_name = 0; | |
381 | ||
382 | #if defined(CONFIG_JFFS2_PART_SIZE) | |
383 | part->size = CONFIG_JFFS2_PART_SIZE; | |
384 | #else | |
385 | part->size = SIZE_REMAINING; | |
386 | #endif | |
c609719b | 387 | |
700a0c64 WD |
388 | #if defined(CONFIG_JFFS2_PART_OFFSET) |
389 | part->offset = CONFIG_JFFS2_PART_OFFSET; | |
390 | #else | |
391 | part->offset = 0x00000000; | |
c609719b WD |
392 | #endif |
393 | ||
76b5883d | 394 | part->dev = current_mtd_dev; |
700a0c64 WD |
395 | INIT_LIST_HEAD(&part->link); |
396 | ||
397 | /* recalculate size if needed */ | |
398 | if (part->size == SIZE_REMAINING) | |
399 | part->size = id->size - part->offset; | |
c609719b | 400 | |
2903ad33 MF |
401 | part->sector_size = get_part_sector_size(id, part); |
402 | ||
700a0c64 WD |
403 | DEBUGF("part : name = %s, size = 0x%08lx, offset = 0x%08lx\n", |
404 | part->name, part->size, part->offset); | |
405 | ||
406 | /* device */ | |
76b5883d SR |
407 | current_mtd_dev->id = id; |
408 | INIT_LIST_HEAD(¤t_mtd_dev->link); | |
409 | current_mtd_dev->num_parts = 1; | |
410 | INIT_LIST_HEAD(¤t_mtd_dev->parts); | |
411 | list_add(&part->link, ¤t_mtd_dev->parts); | |
c609719b | 412 | } |
700a0c64 | 413 | |
c609719b WD |
414 | return 0; |
415 | } | |
68d7d651 | 416 | #endif /* #ifndef CONFIG_CMD_MTDPARTS */ |
998eaaec | 417 | |
700a0c64 WD |
418 | /** |
419 | * Return pointer to the partition of a requested number from a requested | |
420 | * device. | |
421 | * | |
422 | * @param dev device that is to be searched for a partition | |
423 | * @param part_num requested partition number | |
424 | * @return pointer to the part_info, NULL otherwise | |
425 | */ | |
426 | static struct part_info* jffs2_part_info(struct mtd_device *dev, unsigned int part_num) | |
998eaaec | 427 | { |
700a0c64 WD |
428 | struct list_head *entry; |
429 | struct part_info *part; | |
430 | int num; | |
998eaaec | 431 | |
700a0c64 WD |
432 | if (!dev) |
433 | return NULL; | |
998eaaec | 434 | |
700a0c64 WD |
435 | DEBUGF("\n--- jffs2_part_info: partition number %d for device %s%d (%s)\n", |
436 | part_num, MTD_DEV_TYPE(dev->id->type), | |
437 | dev->id->num, dev->id->mtd_id); | |
998eaaec | 438 | |
700a0c64 WD |
439 | if (part_num >= dev->num_parts) { |
440 | printf("invalid partition number %d for device %s%d (%s)\n", | |
441 | part_num, MTD_DEV_TYPE(dev->id->type), | |
442 | dev->id->num, dev->id->mtd_id); | |
443 | return NULL; | |
444 | } | |
998eaaec | 445 | |
700a0c64 WD |
446 | /* locate partition number, return it */ |
447 | num = 0; | |
448 | list_for_each(entry, &dev->parts) { | |
449 | part = list_entry(entry, struct part_info, link); | |
450 | ||
451 | if (part_num == num++) { | |
452 | return part; | |
453 | } | |
998eaaec | 454 | } |
700a0c64 WD |
455 | |
456 | return NULL; | |
998eaaec WD |
457 | } |
458 | ||
ab4b956d | 459 | /***************************************************/ |
a187559e | 460 | /* U-Boot commands */ |
ab4b956d | 461 | /***************************************************/ |
dd875c76 | 462 | |
700a0c64 WD |
463 | /** |
464 | * Routine implementing fsload u-boot command. This routine tries to load | |
465 | * a requested file from jffs2/cramfs filesystem on a current partition. | |
466 | * | |
467 | * @param cmdtp command internal data | |
468 | * @param flag command flag | |
469 | * @param argc number of arguments supplied to the command | |
470 | * @param argv arguments list | |
471 | * @return 0 on success, 1 otherwise | |
472 | */ | |
54841ab5 | 473 | int do_jffs2_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
c609719b | 474 | { |
39539887 | 475 | char *fsname; |
f39748ae | 476 | char *filename; |
39539887 WD |
477 | int size; |
478 | struct part_info *part; | |
479 | ulong offset = load_addr; | |
f39748ae WD |
480 | |
481 | /* pre-set Boot file name */ | |
00caae6d SG |
482 | filename = env_get("bootfile"); |
483 | if (!filename) | |
f39748ae | 484 | filename = "uImage"; |
f39748ae | 485 | |
c609719b WD |
486 | if (argc == 2) { |
487 | filename = argv[1]; | |
488 | } | |
489 | if (argc == 3) { | |
490 | offset = simple_strtoul(argv[1], NULL, 16); | |
4b9206ed | 491 | load_addr = offset; |
c609719b WD |
492 | filename = argv[2]; |
493 | } | |
494 | ||
700a0c64 WD |
495 | /* make sure we are in sync with env variables */ |
496 | if (mtdparts_init() !=0) | |
497 | return 1; | |
498 | ||
76b5883d | 499 | if ((part = jffs2_part_info(current_mtd_dev, current_mtd_partnum))){ |
c609719b | 500 | |
991b089d MS |
501 | /* check partition type for cramfs */ |
502 | fsname = (cramfs_check(part) ? "CRAMFS" : "JFFS2"); | |
dd875c76 WD |
503 | printf("### %s loading '%s' to 0x%lx\n", fsname, filename, offset); |
504 | ||
505 | if (cramfs_check(part)) { | |
506 | size = cramfs_load ((char *) offset, part, filename); | |
507 | } else { | |
991b089d | 508 | /* if this is not cramfs assume jffs2 */ |
dd875c76 WD |
509 | size = jffs2_1pass_load((char *)offset, part, filename); |
510 | } | |
c609719b WD |
511 | |
512 | if (size > 0) { | |
dd875c76 WD |
513 | printf("### %s load complete: %d bytes loaded to 0x%lx\n", |
514 | fsname, size, offset); | |
018f5303 | 515 | env_set_hex("filesize", size); |
c609719b | 516 | } else { |
dd875c76 | 517 | printf("### %s LOAD ERROR<%x> for %s!\n", fsname, size, filename); |
c609719b WD |
518 | } |
519 | ||
520 | return !(size > 0); | |
521 | } | |
87b8bd5a | 522 | return 1; |
c609719b WD |
523 | } |
524 | ||
700a0c64 WD |
525 | /** |
526 | * Routine implementing u-boot ls command which lists content of a given | |
527 | * directory on a current partition. | |
528 | * | |
529 | * @param cmdtp command internal data | |
530 | * @param flag command flag | |
531 | * @param argc number of arguments supplied to the command | |
532 | * @param argv arguments list | |
533 | * @return 0 on success, 1 otherwise | |
534 | */ | |
54841ab5 | 535 | int do_jffs2_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
c609719b | 536 | { |
a87589da | 537 | char *filename = "/"; |
c609719b WD |
538 | int ret; |
539 | struct part_info *part; | |
540 | ||
541 | if (argc == 2) | |
542 | filename = argv[1]; | |
543 | ||
700a0c64 WD |
544 | /* make sure we are in sync with env variables */ |
545 | if (mtdparts_init() !=0) | |
546 | return 1; | |
547 | ||
76b5883d | 548 | if ((part = jffs2_part_info(current_mtd_dev, current_mtd_partnum))){ |
c609719b | 549 | |
dd875c76 WD |
550 | /* check partition type for cramfs */ |
551 | if (cramfs_check(part)) { | |
552 | ret = cramfs_ls (part, filename); | |
553 | } else { | |
991b089d | 554 | /* if this is not cramfs assume jffs2 */ |
dd875c76 WD |
555 | ret = jffs2_1pass_ls(part, filename); |
556 | } | |
c609719b | 557 | |
87b8bd5a | 558 | return ret ? 0 : 1; |
c609719b | 559 | } |
87b8bd5a | 560 | return 1; |
c609719b WD |
561 | } |
562 | ||
700a0c64 WD |
563 | /** |
564 | * Routine implementing u-boot fsinfo command. This routine prints out | |
565 | * miscellaneous filesystem informations/statistics. | |
566 | * | |
567 | * @param cmdtp command internal data | |
568 | * @param flag command flag | |
569 | * @param argc number of arguments supplied to the command | |
570 | * @param argv arguments list | |
571 | * @return 0 on success, 1 otherwise | |
572 | */ | |
54841ab5 | 573 | int do_jffs2_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
c609719b | 574 | { |
c609719b | 575 | struct part_info *part; |
991b089d | 576 | char *fsname; |
dd875c76 | 577 | int ret; |
c609719b | 578 | |
700a0c64 WD |
579 | /* make sure we are in sync with env variables */ |
580 | if (mtdparts_init() !=0) | |
581 | return 1; | |
8f79e4c2 | 582 | |
76b5883d | 583 | if ((part = jffs2_part_info(current_mtd_dev, current_mtd_partnum))){ |
dd875c76 WD |
584 | |
585 | /* check partition type for cramfs */ | |
991b089d MS |
586 | fsname = (cramfs_check(part) ? "CRAMFS" : "JFFS2"); |
587 | printf("### filesystem type is %s\n", fsname); | |
c609719b | 588 | |
dd875c76 WD |
589 | if (cramfs_check(part)) { |
590 | ret = cramfs_info (part); | |
591 | } else { | |
991b089d | 592 | /* if this is not cramfs assume jffs2 */ |
dd875c76 WD |
593 | ret = jffs2_1pass_info(part); |
594 | } | |
c609719b | 595 | |
87b8bd5a | 596 | return ret ? 0 : 1; |
c609719b | 597 | } |
87b8bd5a | 598 | return 1; |
c609719b WD |
599 | } |
600 | ||
700a0c64 | 601 | /***************************************************/ |
0d498393 WD |
602 | U_BOOT_CMD( |
603 | fsload, 3, 0, do_jffs2_fsload, | |
2fb2604d | 604 | "load binary file from a filesystem image", |
8bde7f77 WD |
605 | "[ off ] [ filename ]\n" |
606 | " - load binary file from flash bank\n" | |
a89c33db | 607 | " with offset 'off'" |
8bde7f77 | 608 | ); |
700a0c64 | 609 | U_BOOT_CMD( |
314f6362 | 610 | fsls, 2, 1, do_jffs2_ls, |
2fb2604d | 611 | "list files in a directory (default /)", |
a89c33db | 612 | "[ directory ]" |
700a0c64 | 613 | ); |
8bde7f77 | 614 | |
0d498393 WD |
615 | U_BOOT_CMD( |
616 | fsinfo, 1, 1, do_jffs2_fsinfo, | |
2fb2604d | 617 | "print information about filesystems", |
a89c33db | 618 | "" |
8bde7f77 | 619 | ); |
700a0c64 | 620 | /***************************************************/ |