2 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
25 DECLARE_GLOBAL_DATA_PTR;
27 static block_dev_desc_t *fs_dev_desc;
28 static disk_partition_t fs_partition;
29 static int fs_type = FS_TYPE_ANY;
31 static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
32 disk_partition_t *fs_partition)
34 printf("** Unrecognized filesystem type **\n");
38 static inline int fs_ls_unsupported(const char *dirname)
43 static inline int fs_read_unsupported(const char *filename, void *buf,
49 static inline void fs_close_unsupported(void)
54 static int fs_probe_fat(block_dev_desc_t *fs_dev_desc,
55 disk_partition_t *fs_partition)
57 return fat_set_blk_dev(fs_dev_desc, fs_partition);
60 static void fs_close_fat(void)
64 #define fs_ls_fat file_fat_ls
66 static int fs_read_fat(const char *filename, void *buf, int offset, int len)
70 len_read = file_fat_read_at(filename, offset, buf, len);
72 printf("** Unable to read file %s **\n", filename);
79 static inline int fs_probe_fat(void)
84 static inline void fs_close_fat(void)
88 #define fs_ls_fat fs_ls_unsupported
89 #define fs_read_fat fs_read_unsupported
93 static int fs_probe_ext(block_dev_desc_t *fs_dev_desc,
94 disk_partition_t *fs_partition)
96 ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
98 if (!ext4fs_mount(fs_partition->size)) {
106 static void fs_close_ext(void)
111 #define fs_ls_ext ext4fs_ls
113 static int fs_read_ext(const char *filename, void *buf, int offset, int len)
119 printf("** Cannot support non-zero offset **\n");
123 file_len = ext4fs_open(filename);
125 printf("** File not found %s **\n", filename);
133 len_read = ext4fs_read(buf, len);
136 if (len_read != len) {
137 printf("** Unable to read file %s **\n", filename);
144 static inline int fs_probe_ext(void)
149 static inline void fs_close_ext(void)
153 #define fs_ls_ext fs_ls_unsupported
154 #define fs_read_ext fs_read_unsupported
159 int (*probe)(block_dev_desc_t *fs_dev_desc,
160 disk_partition_t *fs_partition);
161 int (*ls)(const char *dirname);
162 int (*read)(const char *filename, void *buf, int offset, int len);
166 static struct fstype_info fstypes[] = {
169 .fstype = FS_TYPE_FAT,
170 .probe = fs_probe_fat,
171 .close = fs_close_fat,
176 #ifdef CONFIG_FS_EXT4
178 .fstype = FS_TYPE_EXT,
179 .probe = fs_probe_ext,
180 .close = fs_close_ext,
186 .fstype = FS_TYPE_ANY,
187 .probe = fs_probe_unsupported,
188 .close = fs_close_unsupported,
189 .ls = fs_ls_unsupported,
190 .read = fs_read_unsupported,
194 static struct fstype_info *fs_get_info(int fstype)
196 struct fstype_info *info;
199 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
200 if (fstype == info->fstype)
204 /* Return the 'unsupported' sentinel */
208 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
210 struct fstype_info *info;
212 #ifdef CONFIG_NEEDS_MANUAL_RELOC
213 static int relocated;
216 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
218 info->probe += gd->reloc_off;
219 info->close += gd->reloc_off;
220 info->ls += gd->reloc_off;
221 info->read += gd->reloc_off;
227 part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc,
232 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
233 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
234 fstype != info->fstype)
237 if (!info->probe(fs_dev_desc, &fs_partition)) {
238 fs_type = info->fstype;
246 static void fs_close(void)
248 struct fstype_info *info = fs_get_info(fs_type);
251 fs_type = FS_TYPE_ANY;
254 int fs_ls(const char *dirname)
258 struct fstype_info *info = fs_get_info(fs_type);
260 ret = info->ls(dirname);
267 int fs_read(const char *filename, ulong addr, int offset, int len)
269 struct fstype_info *info = fs_get_info(fs_type);
274 * We don't actually know how many bytes are being read, since len==0
275 * means read the whole file.
277 buf = map_sysmem(addr, len);
278 ret = info->read(filename, buf, offset, len);
281 /* If we requested a specific number of bytes, check we got it */
282 if (ret >= 0 && len && ret != len) {
283 printf("** Unable to read file %s **\n", filename);
291 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
292 int fstype, int cmdline_base)
295 const char *addr_str;
296 const char *filename;
303 return CMD_RET_USAGE;
305 return CMD_RET_USAGE;
307 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
311 addr = simple_strtoul(argv[3], NULL, cmdline_base);
313 addr_str = getenv("loadaddr");
314 if (addr_str != NULL)
315 addr = simple_strtoul(addr_str, NULL, 16);
317 addr = CONFIG_SYS_LOAD_ADDR;
322 filename = getenv("bootfile");
324 puts("** No boot file defined **\n");
329 bytes = simple_strtoul(argv[5], NULL, cmdline_base);
333 pos = simple_strtoul(argv[6], NULL, cmdline_base);
338 len_read = fs_read(filename, addr, pos, bytes);
339 time = get_timer(time);
343 printf("%d bytes read in %lu ms", len_read, time);
346 print_size(len_read / time * 1000, "/s");
351 setenv_hex("filesize", len_read);
356 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
360 return CMD_RET_USAGE;
362 return CMD_RET_USAGE;
364 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
367 if (fs_ls(argc >= 4 ? argv[3] : "/"))