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/>.
23 #include <sandboxfs.h>
26 DECLARE_GLOBAL_DATA_PTR;
28 static block_dev_desc_t *fs_dev_desc;
29 static disk_partition_t fs_partition;
30 static int fs_type = FS_TYPE_ANY;
32 static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
33 disk_partition_t *fs_partition)
35 printf("** Unrecognized filesystem type **\n");
39 static inline int fs_ls_unsupported(const char *dirname)
44 static inline int fs_read_unsupported(const char *filename, void *buf,
50 static inline int fs_write_unsupported(const char *filename, void *buf,
56 static inline void fs_close_unsupported(void)
62 int (*probe)(block_dev_desc_t *fs_dev_desc,
63 disk_partition_t *fs_partition);
64 int (*ls)(const char *dirname);
65 int (*read)(const char *filename, void *buf, int offset, int len);
66 int (*write)(const char *filename, void *buf, int offset, int len);
70 static struct fstype_info fstypes[] = {
73 .fstype = FS_TYPE_FAT,
74 .probe = fat_set_blk_dev,
77 .read = fat_read_file,
82 .fstype = FS_TYPE_EXT,
83 .probe = ext4fs_probe,
84 .close = ext4fs_close,
86 .read = ext4_read_file,
91 .fstype = FS_TYPE_SANDBOX,
92 .probe = sandbox_fs_set_blk_dev,
93 .close = sandbox_fs_close,
95 .read = fs_read_sandbox,
99 .fstype = FS_TYPE_ANY,
100 .probe = fs_probe_unsupported,
101 .close = fs_close_unsupported,
102 .ls = fs_ls_unsupported,
103 .read = fs_read_unsupported,
104 .write = fs_write_unsupported,
108 static struct fstype_info *fs_get_info(int fstype)
110 struct fstype_info *info;
113 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
114 if (fstype == info->fstype)
118 /* Return the 'unsupported' sentinel */
122 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
124 struct fstype_info *info;
126 #ifdef CONFIG_NEEDS_MANUAL_RELOC
127 static int relocated;
130 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
132 info->probe += gd->reloc_off;
133 info->close += gd->reloc_off;
134 info->ls += gd->reloc_off;
135 info->read += gd->reloc_off;
136 info->write += gd->reloc_off;
142 part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc,
147 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
148 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
149 fstype != info->fstype)
152 if (!info->probe(fs_dev_desc, &fs_partition)) {
153 fs_type = info->fstype;
161 static void fs_close(void)
163 struct fstype_info *info = fs_get_info(fs_type);
167 fs_type = FS_TYPE_ANY;
170 int fs_ls(const char *dirname)
174 struct fstype_info *info = fs_get_info(fs_type);
176 ret = info->ls(dirname);
178 fs_type = FS_TYPE_ANY;
184 int fs_read(const char *filename, ulong addr, int offset, int len)
186 struct fstype_info *info = fs_get_info(fs_type);
191 * We don't actually know how many bytes are being read, since len==0
192 * means read the whole file.
194 buf = map_sysmem(addr, len);
195 ret = info->read(filename, buf, offset, len);
198 /* If we requested a specific number of bytes, check we got it */
199 if (ret >= 0 && len && ret != len) {
200 printf("** Unable to read file %s **\n", filename);
208 int fs_write(const char *filename, ulong addr, int offset, int len)
210 struct fstype_info *info = fs_get_info(fs_type);
215 * We don't actually know how many bytes are being read, since len==0
216 * means read the whole file.
218 buf = map_sysmem(addr, len);
219 ret = info->write(filename, buf, offset, len);
222 /* If we requested a specific number of bytes, check we got it */
223 if (ret >= 0 && len && ret != len) {
224 printf("** Unable to write file %s **\n", filename);
232 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
233 int fstype, int cmdline_base)
236 const char *addr_str;
237 const char *filename;
244 return CMD_RET_USAGE;
246 return CMD_RET_USAGE;
248 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
252 addr = simple_strtoul(argv[3], NULL, cmdline_base);
254 addr_str = getenv("loadaddr");
255 if (addr_str != NULL)
256 addr = simple_strtoul(addr_str, NULL, 16);
258 addr = CONFIG_SYS_LOAD_ADDR;
263 filename = getenv("bootfile");
265 puts("** No boot file defined **\n");
270 bytes = simple_strtoul(argv[5], NULL, cmdline_base);
274 pos = simple_strtoul(argv[6], NULL, cmdline_base);
279 len_read = fs_read(filename, addr, pos, bytes);
280 time = get_timer(time);
284 printf("%d bytes read in %lu ms", len_read, time);
287 print_size(len_read / time * 1000, "/s");
292 setenv_hex("filesize", len_read);
297 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
301 return CMD_RET_USAGE;
303 return CMD_RET_USAGE;
305 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
308 if (fs_ls(argc >= 4 ? argv[3] : "/"))
314 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
315 int fstype, int cmdline_base)
318 const char *filename;
324 if (argc < 6 || argc > 7)
325 return CMD_RET_USAGE;
327 if (fs_set_blk_dev(argv[1], argv[2], fstype))
331 addr = simple_strtoul(argv[4], NULL, cmdline_base);
332 bytes = simple_strtoul(argv[5], NULL, cmdline_base);
334 pos = simple_strtoul(argv[6], NULL, cmdline_base);
339 len = fs_write(filename, addr, pos, bytes);
340 time = get_timer(time);
344 printf("%d bytes written in %lu ms", len, time);
347 print_size(len / time * 1000, "/s");