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_exists_unsupported(const char *filename)
49 static inline int fs_read_unsupported(const char *filename, void *buf,
55 static inline int fs_write_unsupported(const char *filename, void *buf,
61 static inline void fs_close_unsupported(void)
67 int (*probe)(block_dev_desc_t *fs_dev_desc,
68 disk_partition_t *fs_partition);
69 int (*ls)(const char *dirname);
70 int (*exists)(const char *filename);
71 int (*read)(const char *filename, void *buf, int offset, int len);
72 int (*write)(const char *filename, void *buf, int offset, int len);
76 static struct fstype_info fstypes[] = {
79 .fstype = FS_TYPE_FAT,
80 .probe = fat_set_blk_dev,
83 .exists = fs_exists_unsupported,
84 .read = fat_read_file,
85 .write = fs_write_unsupported,
90 .fstype = FS_TYPE_EXT,
91 .probe = ext4fs_probe,
92 .close = ext4fs_close,
94 .exists = fs_exists_unsupported,
95 .read = ext4_read_file,
96 .write = fs_write_unsupported,
101 .fstype = FS_TYPE_SANDBOX,
102 .probe = sandbox_fs_set_blk_dev,
103 .close = sandbox_fs_close,
105 .exists = fs_exists_unsupported,
106 .read = fs_read_sandbox,
107 .write = fs_write_sandbox,
111 .fstype = FS_TYPE_ANY,
112 .probe = fs_probe_unsupported,
113 .close = fs_close_unsupported,
114 .ls = fs_ls_unsupported,
115 .exists = fs_exists_unsupported,
116 .read = fs_read_unsupported,
117 .write = fs_write_unsupported,
121 static struct fstype_info *fs_get_info(int fstype)
123 struct fstype_info *info;
126 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
127 if (fstype == info->fstype)
131 /* Return the 'unsupported' sentinel */
135 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
137 struct fstype_info *info;
139 #ifdef CONFIG_NEEDS_MANUAL_RELOC
140 static int relocated;
143 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
145 info->probe += gd->reloc_off;
146 info->close += gd->reloc_off;
147 info->ls += gd->reloc_off;
148 info->read += gd->reloc_off;
149 info->write += gd->reloc_off;
155 part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc,
160 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
161 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
162 fstype != info->fstype)
165 if (!info->probe(fs_dev_desc, &fs_partition)) {
166 fs_type = info->fstype;
174 static void fs_close(void)
176 struct fstype_info *info = fs_get_info(fs_type);
180 fs_type = FS_TYPE_ANY;
183 int fs_ls(const char *dirname)
187 struct fstype_info *info = fs_get_info(fs_type);
189 ret = info->ls(dirname);
191 fs_type = FS_TYPE_ANY;
197 int fs_exists(const char *filename)
201 struct fstype_info *info = fs_get_info(fs_type);
203 ret = info->exists(filename);
210 int fs_read(const char *filename, ulong addr, int offset, int len)
212 struct fstype_info *info = fs_get_info(fs_type);
217 * We don't actually know how many bytes are being read, since len==0
218 * means read the whole file.
220 buf = map_sysmem(addr, len);
221 ret = info->read(filename, buf, offset, len);
224 /* If we requested a specific number of bytes, check we got it */
225 if (ret >= 0 && len && ret != len) {
226 printf("** Unable to read file %s **\n", filename);
234 int fs_write(const char *filename, ulong addr, int offset, int len)
236 struct fstype_info *info = fs_get_info(fs_type);
240 buf = map_sysmem(addr, len);
241 ret = info->write(filename, buf, offset, len);
244 if (ret >= 0 && ret != len) {
245 printf("** Unable to write file %s **\n", filename);
253 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
257 const char *addr_str;
258 const char *filename;
265 return CMD_RET_USAGE;
267 return CMD_RET_USAGE;
269 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
273 addr = simple_strtoul(argv[3], NULL, 16);
275 addr_str = getenv("loadaddr");
276 if (addr_str != NULL)
277 addr = simple_strtoul(addr_str, NULL, 16);
279 addr = CONFIG_SYS_LOAD_ADDR;
284 filename = getenv("bootfile");
286 puts("** No boot file defined **\n");
291 bytes = simple_strtoul(argv[5], NULL, 16);
295 pos = simple_strtoul(argv[6], NULL, 16);
300 len_read = fs_read(filename, addr, pos, bytes);
301 time = get_timer(time);
305 printf("%d bytes read in %lu ms", len_read, time);
308 print_size(len_read / time * 1000, "/s");
313 setenv_hex("filesize", len_read);
318 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
322 return CMD_RET_USAGE;
324 return CMD_RET_USAGE;
326 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
329 if (fs_ls(argc >= 4 ? argv[3] : "/"))
335 int file_exists(const char *dev_type, const char *dev_part, const char *file,
338 if (fs_set_blk_dev(dev_type, dev_part, fstype))
341 return fs_exists(file);
344 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
348 const char *filename;
354 if (argc < 6 || argc > 7)
355 return CMD_RET_USAGE;
357 if (fs_set_blk_dev(argv[1], argv[2], fstype))
361 addr = simple_strtoul(argv[4], NULL, 16);
362 bytes = simple_strtoul(argv[5], NULL, 16);
364 pos = simple_strtoul(argv[6], NULL, 16);
369 len = fs_write(filename, addr, pos, bytes);
370 time = get_timer(time);
374 printf("%d bytes written in %lu ms", len, time);
377 print_size(len / time * 1000, "/s");