]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 LT |
2 | * Parse RedBoot-style Flash Image System (FIS) tables and |
3 | * produce a Linux partition array to match. | |
a1452a37 DW |
4 | * |
5 | * Copyright © 2001 Red Hat UK Limited | |
6 | * Copyright © 2001-2010 David Woodhouse <dwmw2@infradead.org> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
21 | * | |
1da177e4 LT |
22 | */ |
23 | ||
24 | #include <linux/kernel.h> | |
25 | #include <linux/slab.h> | |
26 | #include <linux/init.h> | |
27 | #include <linux/vmalloc.h> | |
28 | ||
29 | #include <linux/mtd/mtd.h> | |
30 | #include <linux/mtd/partitions.h> | |
a0e5cc58 | 31 | #include <linux/module.h> |
1da177e4 LT |
32 | |
33 | struct fis_image_desc { | |
34 | unsigned char name[16]; // Null terminated name | |
b020bb7d BD |
35 | uint32_t flash_base; // Address within FLASH of image |
36 | uint32_t mem_base; // Address in memory where it executes | |
37 | uint32_t size; // Length of image | |
38 | uint32_t entry_point; // Execution entry point | |
39 | uint32_t data_length; // Length of actual data | |
40 | unsigned char _pad[256-(16+7*sizeof(uint32_t))]; | |
41 | uint32_t desc_cksum; // Checksum over image descriptor | |
42 | uint32_t file_cksum; // Checksum over image data | |
1da177e4 LT |
43 | }; |
44 | ||
45 | struct fis_list { | |
46 | struct fis_image_desc *img; | |
47 | struct fis_list *next; | |
48 | }; | |
49 | ||
50 | static int directory = CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK; | |
51 | module_param(directory, int, 0); | |
52 | ||
53 | static inline int redboot_checksum(struct fis_image_desc *img) | |
54 | { | |
55 | /* RedBoot doesn't actually write the desc_cksum field yet AFAICT */ | |
56 | return 1; | |
57 | } | |
58 | ||
97894cda | 59 | static int parse_redboot_partitions(struct mtd_info *master, |
c7975330 DES |
60 | struct mtd_partition **pparts, |
61 | struct mtd_part_parser_data *data) | |
1da177e4 LT |
62 | { |
63 | int nrparts = 0; | |
64 | struct fis_image_desc *buf; | |
65 | struct mtd_partition *parts; | |
66 | struct fis_list *fl = NULL, *tmp_fl; | |
67 | int ret, i; | |
68 | size_t retlen; | |
69 | char *names; | |
70 | char *nullname; | |
71 | int namelen = 0; | |
72 | int nulllen = 0; | |
73 | int numslots; | |
74 | unsigned long offset; | |
75 | #ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED | |
76 | static char nullstring[] = "unallocated"; | |
77 | #endif | |
78 | ||
3c441baa DW |
79 | if ( directory < 0 ) { |
80 | offset = master->size + directory * master->erasesize; | |
81 | while (master->block_isbad && | |
82 | master->block_isbad(master, offset)) { | |
83 | if (!offset) { | |
84 | nogood: | |
85 | printk(KERN_NOTICE "Failed to find a non-bad block to check for RedBoot partition table\n"); | |
86 | return -EIO; | |
87 | } | |
88 | offset -= master->erasesize; | |
89 | } | |
90 | } else { | |
91 | offset = directory * master->erasesize; | |
92 | while (master->block_isbad && | |
93 | master->block_isbad(master, offset)) { | |
94 | offset += master->erasesize; | |
95 | if (offset == master->size) | |
96 | goto nogood; | |
97 | } | |
98 | } | |
1da177e4 LT |
99 | buf = vmalloc(master->erasesize); |
100 | ||
101 | if (!buf) | |
102 | return -ENOMEM; | |
103 | ||
1da177e4 LT |
104 | printk(KERN_NOTICE "Searching for RedBoot partition table in %s at offset 0x%lx\n", |
105 | master->name, offset); | |
106 | ||
329ad399 AB |
107 | ret = mtd_read(master, offset, master->erasesize, &retlen, |
108 | (void *)buf); | |
1da177e4 LT |
109 | |
110 | if (ret) | |
111 | goto out; | |
112 | ||
113 | if (retlen != master->erasesize) { | |
114 | ret = -EIO; | |
115 | goto out; | |
116 | } | |
117 | ||
118 | numslots = (master->erasesize / sizeof(struct fis_image_desc)); | |
119 | for (i = 0; i < numslots; i++) { | |
9cff3372 JB |
120 | if (!memcmp(buf[i].name, "FIS directory", 14)) { |
121 | /* This is apparently the FIS directory entry for the | |
122 | * FIS directory itself. The FIS directory size is | |
77a33135 | 123 | * one erase block; if the buf[i].size field is |
9cff3372 JB |
124 | * swab32(erasesize) then we know we are looking at |
125 | * a byte swapped FIS directory - swap all the entries! | |
77a33135 | 126 | * (NOTE: this is 'size' not 'data_length'; size is |
9cff3372 JB |
127 | * the full size of the entry.) |
128 | */ | |
7ca353a4 DW |
129 | |
130 | /* RedBoot can combine the FIS directory and | |
131 | config partitions into a single eraseblock; | |
132 | we assume wrong-endian if either the swapped | |
133 | 'size' matches the eraseblock size precisely, | |
134 | or if the swapped size actually fits in an | |
135 | eraseblock while the unswapped size doesn't. */ | |
136 | if (swab32(buf[i].size) == master->erasesize || | |
137 | (buf[i].size > master->erasesize | |
138 | && swab32(buf[i].size) < master->erasesize)) { | |
9cff3372 | 139 | int j; |
11192146 RW |
140 | /* Update numslots based on actual FIS directory size */ |
141 | numslots = swab32(buf[i].size) / sizeof (struct fis_image_desc); | |
f33665d9 RW |
142 | for (j = 0; j < numslots; ++j) { |
143 | ||
144 | /* A single 0xff denotes a deleted entry. | |
145 | * Two of them in a row is the end of the table. | |
146 | */ | |
147 | if (buf[j].name[0] == 0xff) { | |
148 | if (buf[j].name[1] == 0xff) { | |
149 | break; | |
150 | } else { | |
151 | continue; | |
152 | } | |
153 | } | |
154 | ||
9cff3372 JB |
155 | /* The unsigned long fields were written with the |
156 | * wrong byte sex, name and pad have no byte sex. | |
157 | */ | |
77a33135 JB |
158 | swab32s(&buf[j].flash_base); |
159 | swab32s(&buf[j].mem_base); | |
160 | swab32s(&buf[j].size); | |
161 | swab32s(&buf[j].entry_point); | |
162 | swab32s(&buf[j].data_length); | |
163 | swab32s(&buf[j].desc_cksum); | |
164 | swab32s(&buf[j].file_cksum); | |
9cff3372 | 165 | } |
7ca353a4 | 166 | } else if (buf[i].size < master->erasesize) { |
11192146 RW |
167 | /* Update numslots based on actual FIS directory size */ |
168 | numslots = buf[i].size / sizeof(struct fis_image_desc); | |
9cff3372 | 169 | } |
1da177e4 | 170 | break; |
9cff3372 | 171 | } |
1da177e4 LT |
172 | } |
173 | if (i == numslots) { | |
174 | /* Didn't find it */ | |
175 | printk(KERN_NOTICE "No RedBoot partition table detected in %s\n", | |
176 | master->name); | |
177 | ret = 0; | |
178 | goto out; | |
179 | } | |
180 | ||
181 | for (i = 0; i < numslots; i++) { | |
182 | struct fis_list *new_fl, **prev; | |
183 | ||
f33665d9 RW |
184 | if (buf[i].name[0] == 0xff) { |
185 | if (buf[i].name[1] == 0xff) { | |
186 | break; | |
187 | } else { | |
188 | continue; | |
189 | } | |
190 | } | |
1da177e4 LT |
191 | if (!redboot_checksum(&buf[i])) |
192 | break; | |
193 | ||
194 | new_fl = kmalloc(sizeof(struct fis_list), GFP_KERNEL); | |
195 | namelen += strlen(buf[i].name)+1; | |
196 | if (!new_fl) { | |
197 | ret = -ENOMEM; | |
198 | goto out; | |
199 | } | |
200 | new_fl->img = &buf[i]; | |
c7975330 DES |
201 | if (data && data->origin) |
202 | buf[i].flash_base -= data->origin; | |
203 | else | |
204 | buf[i].flash_base &= master->size-1; | |
1da177e4 LT |
205 | |
206 | /* I'm sure the JFFS2 code has done me permanent damage. | |
207 | * I now think the following is _normal_ | |
208 | */ | |
209 | prev = &fl; | |
210 | while(*prev && (*prev)->img->flash_base < new_fl->img->flash_base) | |
211 | prev = &(*prev)->next; | |
212 | new_fl->next = *prev; | |
213 | *prev = new_fl; | |
214 | ||
215 | nrparts++; | |
216 | } | |
217 | #ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED | |
218 | if (fl->img->flash_base) { | |
219 | nrparts++; | |
220 | nulllen = sizeof(nullstring); | |
221 | } | |
222 | ||
223 | for (tmp_fl = fl; tmp_fl->next; tmp_fl = tmp_fl->next) { | |
224 | if (tmp_fl->img->flash_base + tmp_fl->img->size + master->erasesize <= tmp_fl->next->img->flash_base) { | |
225 | nrparts++; | |
226 | nulllen = sizeof(nullstring); | |
227 | } | |
228 | } | |
229 | #endif | |
95b93a0c | 230 | parts = kzalloc(sizeof(*parts)*nrparts + nulllen + namelen, GFP_KERNEL); |
1da177e4 LT |
231 | |
232 | if (!parts) { | |
233 | ret = -ENOMEM; | |
234 | goto out; | |
235 | } | |
236 | ||
1da177e4 LT |
237 | nullname = (char *)&parts[nrparts]; |
238 | #ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED | |
239 | if (nulllen > 0) { | |
240 | strcpy(nullname, nullstring); | |
241 | } | |
242 | #endif | |
243 | names = nullname + nulllen; | |
244 | ||
245 | i=0; | |
246 | ||
247 | #ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED | |
248 | if (fl->img->flash_base) { | |
249 | parts[0].name = nullname; | |
250 | parts[0].size = fl->img->flash_base; | |
251 | parts[0].offset = 0; | |
252 | i++; | |
253 | } | |
254 | #endif | |
255 | for ( ; i<nrparts; i++) { | |
256 | parts[i].size = fl->img->size; | |
257 | parts[i].offset = fl->img->flash_base; | |
258 | parts[i].name = names; | |
259 | ||
260 | strcpy(names, fl->img->name); | |
261 | #ifdef CONFIG_MTD_REDBOOT_PARTS_READONLY | |
262 | if (!memcmp(names, "RedBoot", 8) || | |
263 | !memcmp(names, "RedBoot config", 15) || | |
264 | !memcmp(names, "FIS directory", 14)) { | |
265 | parts[i].mask_flags = MTD_WRITEABLE; | |
266 | } | |
267 | #endif | |
268 | names += strlen(names)+1; | |
269 | ||
270 | #ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED | |
271 | if(fl->next && fl->img->flash_base + fl->img->size + master->erasesize <= fl->next->img->flash_base) { | |
272 | i++; | |
273 | parts[i].offset = parts[i-1].size + parts[i-1].offset; | |
274 | parts[i].size = fl->next->img->flash_base - parts[i].offset; | |
275 | parts[i].name = nullname; | |
276 | } | |
277 | #endif | |
278 | tmp_fl = fl; | |
279 | fl = fl->next; | |
280 | kfree(tmp_fl); | |
281 | } | |
282 | ret = nrparts; | |
283 | *pparts = parts; | |
284 | out: | |
285 | while (fl) { | |
286 | struct fis_list *old = fl; | |
287 | fl = fl->next; | |
288 | kfree(old); | |
289 | } | |
290 | vfree(buf); | |
291 | return ret; | |
292 | } | |
293 | ||
294 | static struct mtd_part_parser redboot_parser = { | |
295 | .owner = THIS_MODULE, | |
296 | .parse_fn = parse_redboot_partitions, | |
297 | .name = "RedBoot", | |
298 | }; | |
299 | ||
d5de1907 AS |
300 | /* mtd parsers will request the module by parser name */ |
301 | MODULE_ALIAS("RedBoot"); | |
302 | ||
1da177e4 LT |
303 | static int __init redboot_parser_init(void) |
304 | { | |
305 | return register_mtd_parser(&redboot_parser); | |
306 | } | |
307 | ||
308 | static void __exit redboot_parser_exit(void) | |
309 | { | |
310 | deregister_mtd_parser(&redboot_parser); | |
311 | } | |
312 | ||
313 | module_init(redboot_parser_init); | |
314 | module_exit(redboot_parser_exit); | |
315 | ||
316 | MODULE_LICENSE("GPL"); | |
44d1b980 | 317 | MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); |
1da177e4 | 318 | MODULE_DESCRIPTION("Parsing code for RedBoot Flash Image System (FIS) tables"); |