1 /* 2 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 3 * 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. 7 * 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 11 * more details. 12 * 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/>. 15 */ 16 17 #include <config.h> 18 #include <common.h> 19 #include <part.h> 20 #include <ext4fs.h> 21 #include <fat.h> 22 #include <fs.h> 23 24 DECLARE_GLOBAL_DATA_PTR; 25 26 static block_dev_desc_t *fs_dev_desc; 27 static disk_partition_t fs_partition; 28 static int fs_type = FS_TYPE_ANY; 29 30 static inline int fs_ls_unsupported(const char *dirname) 31 { 32 printf("** Unrecognized filesystem type **\n"); 33 return -1; 34 } 35 36 static inline int fs_read_unsupported(const char *filename, ulong addr, 37 int offset, int len) 38 { 39 printf("** Unrecognized filesystem type **\n"); 40 return -1; 41 } 42 43 #ifdef CONFIG_FS_FAT 44 static int fs_probe_fat(void) 45 { 46 return fat_set_blk_dev(fs_dev_desc, &fs_partition); 47 } 48 49 static void fs_close_fat(void) 50 { 51 } 52 53 #define fs_ls_fat file_fat_ls 54 55 static int fs_read_fat(const char *filename, ulong addr, int offset, int len) 56 { 57 int len_read; 58 59 len_read = file_fat_read_at(filename, offset, 60 (unsigned char *)addr, len); 61 if (len_read == -1) { 62 printf("** Unable to read file %s **\n", filename); 63 return -1; 64 } 65 66 return len_read; 67 } 68 #else 69 static inline int fs_probe_fat(void) 70 { 71 return -1; 72 } 73 74 static inline void fs_close_fat(void) 75 { 76 } 77 78 #define fs_ls_fat fs_ls_unsupported 79 #define fs_read_fat fs_read_unsupported 80 #endif 81 82 #ifdef CONFIG_FS_EXT4 83 static int fs_probe_ext(void) 84 { 85 ext4fs_set_blk_dev(fs_dev_desc, &fs_partition); 86 87 if (!ext4fs_mount(fs_partition.size)) { 88 ext4fs_close(); 89 return -1; 90 } 91 92 return 0; 93 } 94 95 static void fs_close_ext(void) 96 { 97 ext4fs_close(); 98 } 99 100 #define fs_ls_ext ext4fs_ls 101 102 static int fs_read_ext(const char *filename, ulong addr, int offset, int len) 103 { 104 int file_len; 105 int len_read; 106 107 if (offset != 0) { 108 printf("** Cannot support non-zero offset **\n"); 109 return -1; 110 } 111 112 file_len = ext4fs_open(filename); 113 if (file_len < 0) { 114 printf("** File not found %s **\n", filename); 115 ext4fs_close(); 116 return -1; 117 } 118 119 if (len == 0) 120 len = file_len; 121 122 len_read = ext4fs_read((char *)addr, len); 123 ext4fs_close(); 124 125 if (len_read != len) { 126 printf("** Unable to read file %s **\n", filename); 127 return -1; 128 } 129 130 return len_read; 131 } 132 #else 133 static inline int fs_probe_ext(void) 134 { 135 return -1; 136 } 137 138 static inline void fs_close_ext(void) 139 { 140 } 141 142 #define fs_ls_ext fs_ls_unsupported 143 #define fs_read_ext fs_read_unsupported 144 #endif 145 146 static struct { 147 int fstype; 148 int (*probe)(void); 149 } fstypes[] = { 150 { 151 .fstype = FS_TYPE_FAT, 152 .probe = fs_probe_fat, 153 }, 154 { 155 .fstype = FS_TYPE_EXT, 156 .probe = fs_probe_ext, 157 }, 158 }; 159 160 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype) 161 { 162 int part, i; 163 #ifdef CONFIG_NEEDS_MANUAL_RELOC 164 static int relocated; 165 166 if (!relocated) { 167 for (i = 0; i < ARRAY_SIZE(fstypes); i++) 168 fstypes[i].probe += gd->reloc_off; 169 relocated = 1; 170 } 171 #endif 172 173 part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc, 174 &fs_partition, 1); 175 if (part < 0) 176 return -1; 177 178 for (i = 0; i < ARRAY_SIZE(fstypes); i++) { 179 if ((fstype != FS_TYPE_ANY) && (fstype != fstypes[i].fstype)) 180 continue; 181 182 if (!fstypes[i].probe()) { 183 fs_type = fstypes[i].fstype; 184 return 0; 185 } 186 } 187 188 printf("** Unrecognized filesystem type **\n"); 189 return -1; 190 } 191 192 static void fs_close(void) 193 { 194 switch (fs_type) { 195 case FS_TYPE_FAT: 196 fs_close_fat(); 197 break; 198 case FS_TYPE_EXT: 199 fs_close_ext(); 200 break; 201 default: 202 break; 203 } 204 205 fs_type = FS_TYPE_ANY; 206 } 207 208 int fs_ls(const char *dirname) 209 { 210 int ret; 211 212 switch (fs_type) { 213 case FS_TYPE_FAT: 214 ret = fs_ls_fat(dirname); 215 break; 216 case FS_TYPE_EXT: 217 ret = fs_ls_ext(dirname); 218 break; 219 default: 220 ret = fs_ls_unsupported(dirname); 221 break; 222 } 223 224 fs_close(); 225 226 return ret; 227 } 228 229 int fs_read(const char *filename, ulong addr, int offset, int len) 230 { 231 int ret; 232 233 switch (fs_type) { 234 case FS_TYPE_FAT: 235 ret = fs_read_fat(filename, addr, offset, len); 236 break; 237 case FS_TYPE_EXT: 238 ret = fs_read_ext(filename, addr, offset, len); 239 break; 240 default: 241 ret = fs_read_unsupported(filename, addr, offset, len); 242 break; 243 } 244 245 fs_close(); 246 247 return ret; 248 } 249 250 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[], 251 int fstype, int cmdline_base) 252 { 253 unsigned long addr; 254 const char *addr_str; 255 const char *filename; 256 unsigned long bytes; 257 unsigned long pos; 258 int len_read; 259 char buf[12]; 260 261 if (argc < 2) 262 return CMD_RET_USAGE; 263 if (argc > 7) 264 return CMD_RET_USAGE; 265 266 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype)) 267 return 1; 268 269 if (argc >= 4) { 270 addr = simple_strtoul(argv[3], NULL, cmdline_base); 271 } else { 272 addr_str = getenv("loadaddr"); 273 if (addr_str != NULL) 274 addr = simple_strtoul(addr_str, NULL, 16); 275 else 276 addr = CONFIG_SYS_LOAD_ADDR; 277 } 278 if (argc >= 5) { 279 filename = argv[4]; 280 } else { 281 filename = getenv("bootfile"); 282 if (!filename) { 283 puts("** No boot file defined **\n"); 284 return 1; 285 } 286 } 287 if (argc >= 6) 288 bytes = simple_strtoul(argv[5], NULL, cmdline_base); 289 else 290 bytes = 0; 291 if (argc >= 7) 292 pos = simple_strtoul(argv[6], NULL, cmdline_base); 293 else 294 pos = 0; 295 296 len_read = fs_read(filename, addr, pos, bytes); 297 if (len_read <= 0) 298 return 1; 299 300 printf("%d bytes read\n", len_read); 301 302 sprintf(buf, "0x%x", len_read); 303 setenv("filesize", buf); 304 305 return 0; 306 } 307 308 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[], 309 int fstype) 310 { 311 if (argc < 2) 312 return CMD_RET_USAGE; 313 if (argc > 4) 314 return CMD_RET_USAGE; 315 316 if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype)) 317 return 1; 318 319 if (fs_ls(argc >= 4 ? argv[3] : "/")) 320 return 1; 321 322 return 0; 323 } 324