karo: tx6: add support for TX6 HW Rev. 3
[karo-tx-uboot.git] / fs / fs.c
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 #include <sandboxfs.h>
24 #include <asm/io.h>
25
26 DECLARE_GLOBAL_DATA_PTR;
27
28 static block_dev_desc_t *fs_dev_desc;
29 static disk_partition_t fs_partition;
30 static int fs_type = FS_TYPE_ANY;
31
32 static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
33                                       disk_partition_t *fs_partition)
34 {
35         printf("** Unrecognized filesystem type **\n");
36         return -1;
37 }
38
39 static inline int fs_ls_unsupported(const char *dirname)
40 {
41         return -1;
42 }
43
44 static inline int fs_read_unsupported(const char *filename, void *buf,
45                                       int offset, int len)
46 {
47         return -1;
48 }
49
50 static inline int fs_write_unsupported(const char *filename, void *buf,
51                                       int offset, int len)
52 {
53         return -1;
54 }
55
56 static inline void fs_close_unsupported(void)
57 {
58 }
59
60 struct fstype_info {
61         int fstype;
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);
67         void (*close)(void);
68 };
69
70 static struct fstype_info fstypes[] = {
71 #ifdef CONFIG_FS_FAT
72         {
73                 .fstype = FS_TYPE_FAT,
74                 .probe = fat_set_blk_dev,
75                 .close = fat_close,
76                 .ls = file_fat_ls,
77                 .read = fat_read_file,
78         },
79 #endif
80 #ifdef CONFIG_FS_EXT4
81         {
82                 .fstype = FS_TYPE_EXT,
83                 .probe = ext4fs_probe,
84                 .close = ext4fs_close,
85                 .ls = ext4fs_ls,
86                 .read = ext4_read_file,
87         },
88 #endif
89 #ifdef CONFIG_SANDBOX
90         {
91                 .fstype = FS_TYPE_SANDBOX,
92                 .probe = sandbox_fs_set_blk_dev,
93                 .close = sandbox_fs_close,
94                 .ls = sandbox_fs_ls,
95                 .read = fs_read_sandbox,
96                 .write = fs_write_sandbox,
97         },
98 #endif
99         {
100                 .fstype = FS_TYPE_ANY,
101                 .probe = fs_probe_unsupported,
102                 .close = fs_close_unsupported,
103                 .ls = fs_ls_unsupported,
104                 .read = fs_read_unsupported,
105                 .write = fs_write_unsupported,
106         },
107 };
108
109 static struct fstype_info *fs_get_info(int fstype)
110 {
111         struct fstype_info *info;
112         int i;
113
114         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
115                 if (fstype == info->fstype)
116                         return info;
117         }
118
119         /* Return the 'unsupported' sentinel */
120         return info;
121 }
122
123 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
124 {
125         struct fstype_info *info;
126         int part, i;
127 #ifdef CONFIG_NEEDS_MANUAL_RELOC
128         static int relocated;
129
130         if (!relocated) {
131                 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
132                                 i++, info++) {
133                         info->probe += gd->reloc_off;
134                         info->close += gd->reloc_off;
135                         info->ls += gd->reloc_off;
136                         info->read += gd->reloc_off;
137                         info->write += gd->reloc_off;
138                 }
139                 relocated = 1;
140         }
141 #endif
142
143         part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc,
144                                         &fs_partition, 1);
145         if (part < 0)
146                 return -1;
147
148         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
149                 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
150                                 fstype != info->fstype)
151                         continue;
152
153                 if (!info->probe(fs_dev_desc, &fs_partition)) {
154                         fs_type = info->fstype;
155                         return 0;
156                 }
157         }
158
159         return -1;
160 }
161
162 static void fs_close(void)
163 {
164         struct fstype_info *info = fs_get_info(fs_type);
165
166         info->close();
167
168         fs_type = FS_TYPE_ANY;
169 }
170
171 int fs_ls(const char *dirname)
172 {
173         int ret;
174
175         struct fstype_info *info = fs_get_info(fs_type);
176
177         ret = info->ls(dirname);
178
179         fs_type = FS_TYPE_ANY;
180         fs_close();
181
182         return ret;
183 }
184
185 int fs_read(const char *filename, ulong addr, int offset, int len)
186 {
187         struct fstype_info *info = fs_get_info(fs_type);
188         void *buf;
189         int ret;
190
191         /*
192          * We don't actually know how many bytes are being read, since len==0
193          * means read the whole file.
194          */
195         buf = map_sysmem(addr, len);
196         ret = info->read(filename, buf, offset, len);
197         unmap_sysmem(buf);
198
199         /* If we requested a specific number of bytes, check we got it */
200         if (ret >= 0 && len && ret != len) {
201                 printf("** Unable to read file %s **\n", filename);
202                 ret = -1;
203         }
204         fs_close();
205
206         return ret;
207 }
208
209 int fs_write(const char *filename, ulong addr, int offset, int len)
210 {
211         struct fstype_info *info = fs_get_info(fs_type);
212         void *buf;
213         int ret;
214
215         /*
216          * We don't actually know how many bytes are being read, since len==0
217          * means read the whole file.
218          */
219         buf = map_sysmem(addr, len);
220         ret = info->write(filename, buf, offset, len);
221         unmap_sysmem(buf);
222
223         /* If we requested a specific number of bytes, check we got it */
224         if (ret >= 0 && len && ret != len) {
225                 printf("** Unable to write file %s **\n", filename);
226                 ret = -1;
227         }
228         fs_close();
229
230         return ret;
231 }
232
233 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
234                 int fstype, int cmdline_base)
235 {
236         unsigned long addr;
237         const char *addr_str;
238         const char *filename;
239         unsigned long bytes;
240         unsigned long pos;
241         int len_read;
242         unsigned long time;
243
244         if (argc < 2)
245                 return CMD_RET_USAGE;
246         if (argc > 7)
247                 return CMD_RET_USAGE;
248
249         if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
250                 return 1;
251
252         if (argc >= 4) {
253                 addr = simple_strtoul(argv[3], NULL, cmdline_base);
254         } else {
255                 addr_str = getenv("loadaddr");
256                 if (addr_str != NULL)
257                         addr = simple_strtoul(addr_str, NULL, 16);
258                 else
259                         addr = CONFIG_SYS_LOAD_ADDR;
260         }
261         if (argc >= 5) {
262                 filename = argv[4];
263         } else {
264                 filename = getenv("bootfile");
265                 if (!filename) {
266                         puts("** No boot file defined **\n");
267                         return 1;
268                 }
269         }
270         if (argc >= 6)
271                 bytes = simple_strtoul(argv[5], NULL, cmdline_base);
272         else
273                 bytes = 0;
274         if (argc >= 7)
275                 pos = simple_strtoul(argv[6], NULL, cmdline_base);
276         else
277                 pos = 0;
278
279         time = get_timer(0);
280         len_read = fs_read(filename, addr, pos, bytes);
281         time = get_timer(time);
282         if (len_read <= 0)
283                 return 1;
284
285         printf("%d bytes read in %lu ms", len_read, time);
286         if (time > 0) {
287                 puts(" (");
288                 print_size(len_read / time * 1000, "/s");
289                 puts(")");
290         }
291         puts("\n");
292
293         setenv_hex("filesize", len_read);
294
295         return 0;
296 }
297
298 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
299         int fstype)
300 {
301         if (argc < 2)
302                 return CMD_RET_USAGE;
303         if (argc > 4)
304                 return CMD_RET_USAGE;
305
306         if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
307                 return 1;
308
309         if (fs_ls(argc >= 4 ? argv[3] : "/"))
310                 return 1;
311
312         return 0;
313 }
314
315 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
316                 int fstype, int cmdline_base)
317 {
318         unsigned long addr;
319         const char *filename;
320         unsigned long bytes;
321         unsigned long pos;
322         int len;
323         unsigned long time;
324
325         if (argc < 6 || argc > 7)
326                 return CMD_RET_USAGE;
327
328         if (fs_set_blk_dev(argv[1], argv[2], fstype))
329                 return 1;
330
331         filename = argv[3];
332         addr = simple_strtoul(argv[4], NULL, cmdline_base);
333         bytes = simple_strtoul(argv[5], NULL, cmdline_base);
334         if (argc >= 7)
335                 pos = simple_strtoul(argv[6], NULL, cmdline_base);
336         else
337                 pos = 0;
338
339         time = get_timer(0);
340         len = fs_write(filename, addr, pos, bytes);
341         time = get_timer(time);
342         if (len <= 0)
343                 return 1;
344
345         printf("%d bytes written in %lu ms", len, time);
346         if (time > 0) {
347                 puts(" (");
348                 print_size(len / time * 1000, "/s");
349                 puts(")");
350         }
351         puts("\n");
352
353         return 0;
354 }