Doug / smarc-fsl-linux-kernel

Download as
Browse Code »

Commit 9e0606fc4ea27fb275f6987751224c60ee055ef1

Authored by Artem Bityutskiy
Committed by David Woodhouse
1 parent 3cf7f1314e
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

mtd: cmdlinepart: revise error handling 

This patch revises and fixes error handling in the command line mtd
partitions parser. Namely:
1. we ignored return code of 'mtdpart_setup_real()'.
2. instead of returning 0 for failure and 1 for success, teach
   'mtdpart_setup_real()' to return real error codes.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>

Showing 1 changed file with 18 additions and 16 deletions Inline Diff

drivers/mtd/cmdlinepart.c
Diff comments   View file @ 9e0606f
1 /* 1 /*
2 * Read flash partition table from command line 2 * Read flash partition table from command line
3 * 3 *
4 * Copyright © 2002 SYSGO Real-Time Solutions GmbH 4 * Copyright © 2002 SYSGO Real-Time Solutions GmbH
5 * Copyright © 2002-2010 David Woodhouse <dwmw2@infradead.org> 5 * Copyright © 2002-2010 David Woodhouse <dwmw2@infradead.org>
6 * 6 *
7 * This program is free software; you can redistribute it and/or modify 7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by 8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or 9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version. 10 * (at your option) any later version.
11 * 11 *
12 * This program is distributed in the hope that it will be useful, 12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details. 15 * GNU General Public License for more details.
16 * 16 *
17 * You should have received a copy of the GNU General Public License 17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software 18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 * 20 *
21 * The format for the command line is as follows: 21 * The format for the command line is as follows:
22 * 22 *
23 * mtdparts=<mtddef>[;<mtddef] 23 * mtdparts=<mtddef>[;<mtddef]
24 * <mtddef> := <mtd-id>:<partdef>[,<partdef>] 24 * <mtddef> := <mtd-id>:<partdef>[,<partdef>]
25 * where <mtd-id> is the name from the "cat /proc/mtd" command 25 * where <mtd-id> is the name from the "cat /proc/mtd" command
26 * <partdef> := <size>[@offset][<name>][ro][lk] 26 * <partdef> := <size>[@offset][<name>][ro][lk]
27 * <mtd-id> := unique name used in mapping driver/device (mtd->name) 27 * <mtd-id> := unique name used in mapping driver/device (mtd->name)
28 * <size> := standard linux memsize OR "-" to denote all remaining space 28 * <size> := standard linux memsize OR "-" to denote all remaining space
29 * <name> := '(' NAME ')' 29 * <name> := '(' NAME ')'
30 * 30 *
31 * Examples: 31 * Examples:
32 * 32 *
33 * 1 NOR Flash, with 1 single writable partition: 33 * 1 NOR Flash, with 1 single writable partition:
34 * edb7312-nor:- 34 * edb7312-nor:-
35 * 35 *
36 * 1 NOR Flash with 2 partitions, 1 NAND with one 36 * 1 NOR Flash with 2 partitions, 1 NAND with one
37 * edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home) 37 * edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home)
38 */ 38 */
39 39
40 #include <linux/kernel.h> 40 #include <linux/kernel.h>
41 #include <linux/slab.h> 41 #include <linux/slab.h>
42
43 #include <linux/mtd/mtd.h> 42 #include <linux/mtd/mtd.h>
44 #include <linux/mtd/partitions.h> 43 #include <linux/mtd/partitions.h>
45 #include <linux/bootmem.h>
46 #include <linux/module.h> 44 #include <linux/module.h>
45 #include <linux/err.h>
47 46
48 /* error message prefix */ 47 /* error message prefix */
49 #define ERRP "mtd: " 48 #define ERRP "mtd: "
50 49
51 /* debug macro */ 50 /* debug macro */
52 #if 0 51 #if 0
53 #define dbg(x) do { printk("DEBUG-CMDLINE-PART: "); printk x; } while(0) 52 #define dbg(x) do { printk("DEBUG-CMDLINE-PART: "); printk x; } while(0)
54 #else 53 #else
55 #define dbg(x) 54 #define dbg(x)
56 #endif 55 #endif
57 56
58 57
59 /* special size referring to all the remaining space in a partition */ 58 /* special size referring to all the remaining space in a partition */
60 #define SIZE_REMAINING UINT_MAX 59 #define SIZE_REMAINING UINT_MAX
61 #define OFFSET_CONTINUOUS UINT_MAX 60 #define OFFSET_CONTINUOUS UINT_MAX
62 61
63 struct cmdline_mtd_partition { 62 struct cmdline_mtd_partition {
64 struct cmdline_mtd_partition *next; 63 struct cmdline_mtd_partition *next;
65 char *mtd_id; 64 char *mtd_id;
66 int num_parts; 65 int num_parts;
67 struct mtd_partition *parts; 66 struct mtd_partition *parts;
68 }; 67 };
69 68
70 /* mtdpart_setup() parses into here */ 69 /* mtdpart_setup() parses into here */
71 static struct cmdline_mtd_partition *partitions; 70 static struct cmdline_mtd_partition *partitions;
72 71
73 /* the command line passed to mtdpart_setup() */ 72 /* the command line passed to mtdpart_setup() */
74 static char *cmdline; 73 static char *cmdline;
75 static int cmdline_parsed; 74 static int cmdline_parsed;
76 75
77 /* 76 /*
78 * Parse one partition definition for an MTD. Since there can be many 77 * Parse one partition definition for an MTD. Since there can be many
79 * comma separated partition definitions, this function calls itself 78 * comma separated partition definitions, this function calls itself
80 * recursively until no more partition definitions are found. Nice side 79 * recursively until no more partition definitions are found. Nice side
81 * effect: the memory to keep the mtd_partition structs and the names 80 * effect: the memory to keep the mtd_partition structs and the names
82 * is allocated upon the last definition being found. At that point the 81 * is allocated upon the last definition being found. At that point the
83 * syntax has been verified ok. 82 * syntax has been verified ok.
84 */ 83 */
85 static struct mtd_partition * newpart(char *s, 84 static struct mtd_partition * newpart(char *s,
86 char **retptr, 85 char **retptr,
87 int *num_parts, 86 int *num_parts,
88 int this_part, 87 int this_part,
89 unsigned char **extra_mem_ptr, 88 unsigned char **extra_mem_ptr,
90 int extra_mem_size) 89 int extra_mem_size)
91 { 90 {
92 struct mtd_partition *parts; 91 struct mtd_partition *parts;
93 unsigned long size; 92 unsigned long size;
94 unsigned long offset = OFFSET_CONTINUOUS; 93 unsigned long offset = OFFSET_CONTINUOUS;
95 char *name; 94 char *name;
96 int name_len; 95 int name_len;
97 unsigned char *extra_mem; 96 unsigned char *extra_mem;
98 char delim; 97 char delim;
99 unsigned int mask_flags; 98 unsigned int mask_flags;
100 99
101 /* fetch the partition size */ 100 /* fetch the partition size */
102 if (*s == '-') 101 if (*s == '-')
103 { /* assign all remaining space to this partition */ 102 { /* assign all remaining space to this partition */
104 size = SIZE_REMAINING; 103 size = SIZE_REMAINING;
105 s++; 104 s++;
106 } 105 }
107 else 106 else
108 { 107 {
109 size = memparse(s, &s); 108 size = memparse(s, &s);
110 if (size < PAGE_SIZE) 109 if (size < PAGE_SIZE)
111 { 110 {
112 printk(KERN_ERR ERRP "partition size too small (%lx)\n", size); 111 printk(KERN_ERR ERRP "partition size too small (%lx)\n", size);
113 return NULL; 112 return ERR_PTR(-EINVAL);
114 } 113 }
115 } 114 }
116 115
117 /* fetch partition name and flags */ 116 /* fetch partition name and flags */
118 mask_flags = 0; /* this is going to be a regular partition */ 117 mask_flags = 0; /* this is going to be a regular partition */
119 delim = 0; 118 delim = 0;
120 /* check for offset */ 119 /* check for offset */
121 if (*s == '@') 120 if (*s == '@')
122 { 121 {
123 s++; 122 s++;
124 offset = memparse(s, &s); 123 offset = memparse(s, &s);
125 } 124 }
126 /* now look for name */ 125 /* now look for name */
127 if (*s == '(') 126 if (*s == '(')
128 { 127 {
129 delim = ')'; 128 delim = ')';
130 } 129 }
131 130
132 if (delim) 131 if (delim)
133 { 132 {
134 char *p; 133 char *p;
135 134
136 name = ++s; 135 name = ++s;
137 p = strchr(name, delim); 136 p = strchr(name, delim);
138 if (!p) 137 if (!p)
139 { 138 {
140 printk(KERN_ERR ERRP "no closing %c found in partition name\n", delim); 139 printk(KERN_ERR ERRP "no closing %c found in partition name\n", delim);
141 return NULL; 140 return ERR_PTR(-EINVAL);
142 } 141 }
143 name_len = p - name; 142 name_len = p - name;
144 s = p + 1; 143 s = p + 1;
145 } 144 }
146 else 145 else
147 { 146 {
148 name = NULL; 147 name = NULL;
149 name_len = 13; /* Partition_000 */ 148 name_len = 13; /* Partition_000 */
150 } 149 }
151 150
152 /* record name length for memory allocation later */ 151 /* record name length for memory allocation later */
153 extra_mem_size += name_len + 1; 152 extra_mem_size += name_len + 1;
154 153
155 /* test for options */ 154 /* test for options */
156 if (strncmp(s, "ro", 2) == 0) 155 if (strncmp(s, "ro", 2) == 0)
157 { 156 {
158 mask_flags |= MTD_WRITEABLE; 157 mask_flags |= MTD_WRITEABLE;
159 s += 2; 158 s += 2;
160 } 159 }
161 160
162 /* if lk is found do NOT unlock the MTD partition*/ 161 /* if lk is found do NOT unlock the MTD partition*/
163 if (strncmp(s, "lk", 2) == 0) 162 if (strncmp(s, "lk", 2) == 0)
164 { 163 {
165 mask_flags |= MTD_POWERUP_LOCK; 164 mask_flags |= MTD_POWERUP_LOCK;
166 s += 2; 165 s += 2;
167 } 166 }
168 167
169 /* test if more partitions are following */ 168 /* test if more partitions are following */
170 if (*s == ',') 169 if (*s == ',')
171 { 170 {
172 if (size == SIZE_REMAINING) 171 if (size == SIZE_REMAINING)
173 { 172 {
174 printk(KERN_ERR ERRP "no partitions allowed after a fill-up partition\n"); 173 printk(KERN_ERR ERRP "no partitions allowed after a fill-up partition\n");
175 return NULL; 174 return ERR_PTR(-EINVAL);
176 } 175 }
177 /* more partitions follow, parse them */ 176 /* more partitions follow, parse them */
178 parts = newpart(s + 1, &s, num_parts, this_part + 1, 177 parts = newpart(s + 1, &s, num_parts, this_part + 1,
179 &extra_mem, extra_mem_size); 178 &extra_mem, extra_mem_size);
180 if (!parts) 179 if (IS_ERR(parts))
181 return NULL; 180 return parts;
182 } 181 }
183 else 182 else
184 { /* this is the last partition: allocate space for all */ 183 { /* this is the last partition: allocate space for all */
185 int alloc_size; 184 int alloc_size;
186 185
187 *num_parts = this_part + 1; 186 *num_parts = this_part + 1;
188 alloc_size = *num_parts * sizeof(struct mtd_partition) + 187 alloc_size = *num_parts * sizeof(struct mtd_partition) +
189 extra_mem_size; 188 extra_mem_size;
190 parts = kzalloc(alloc_size, GFP_KERNEL); 189 parts = kzalloc(alloc_size, GFP_KERNEL);
191 if (!parts) 190 if (!parts)
192 return NULL; 191 return ERR_PTR(-ENOMEM);
193 extra_mem = (unsigned char *)(parts + *num_parts); 192 extra_mem = (unsigned char *)(parts + *num_parts);
194 } 193 }
195 /* enter this partition (offset will be calculated later if it is zero at this point) */ 194 /* enter this partition (offset will be calculated later if it is zero at this point) */
196 parts[this_part].size = size; 195 parts[this_part].size = size;
197 parts[this_part].offset = offset; 196 parts[this_part].offset = offset;
198 parts[this_part].mask_flags = mask_flags; 197 parts[this_part].mask_flags = mask_flags;
199 if (name) 198 if (name)
200 { 199 {
201 strlcpy(extra_mem, name, name_len + 1); 200 strlcpy(extra_mem, name, name_len + 1);
202 } 201 }
203 else 202 else
204 { 203 {
205 sprintf(extra_mem, "Partition_%03d", this_part); 204 sprintf(extra_mem, "Partition_%03d", this_part);
206 } 205 }
207 parts[this_part].name = extra_mem; 206 parts[this_part].name = extra_mem;
208 extra_mem += name_len + 1; 207 extra_mem += name_len + 1;
209 208
210 dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n", 209 dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n",
211 this_part, 210 this_part,
212 parts[this_part].name, 211 parts[this_part].name,
213 parts[this_part].offset, 212 parts[this_part].offset,
214 parts[this_part].size, 213 parts[this_part].size,
215 parts[this_part].mask_flags)); 214 parts[this_part].mask_flags));
216 215
217 /* return (updated) pointer to extra_mem memory */ 216 /* return (updated) pointer to extra_mem memory */
218 if (extra_mem_ptr) 217 if (extra_mem_ptr)
219 *extra_mem_ptr = extra_mem; 218 *extra_mem_ptr = extra_mem;
220 219
221 /* return (updated) pointer command line string */ 220 /* return (updated) pointer command line string */
222 *retptr = s; 221 *retptr = s;
223 222
224 /* return partition table */ 223 /* return partition table */
225 return parts; 224 return parts;
226 } 225 }
227 226
228 /* 227 /*
229 * Parse the command line. 228 * Parse the command line.
230 */ 229 */
231 static int mtdpart_setup_real(char *s) 230 static int mtdpart_setup_real(char *s)
232 { 231 {
233 cmdline_parsed = 1; 232 cmdline_parsed = 1;
234 233
235 for( ; s != NULL; ) 234 for( ; s != NULL; )
236 { 235 {
237 struct cmdline_mtd_partition *this_mtd; 236 struct cmdline_mtd_partition *this_mtd;
238 struct mtd_partition *parts; 237 struct mtd_partition *parts;
239 int mtd_id_len; 238 int mtd_id_len;
240 int num_parts; 239 int num_parts;
241 char *p, *mtd_id; 240 char *p, *mtd_id;
242 241
243 mtd_id = s; 242 mtd_id = s;
244 /* fetch <mtd-id> */ 243 /* fetch <mtd-id> */
245 if (!(p = strchr(s, ':'))) 244 if (!(p = strchr(s, ':')))
246 { 245 {
247 printk(KERN_ERR ERRP "no mtd-id\n"); 246 printk(KERN_ERR ERRP "no mtd-id\n");
248 return 0; 247 return -EINVAL;
249 } 248 }
250 mtd_id_len = p - mtd_id; 249 mtd_id_len = p - mtd_id;
251 250
252 dbg(("parsing <%s>\n", p+1)); 251 dbg(("parsing <%s>\n", p+1));
253 252
254 /* 253 /*
255 * parse one mtd. have it reserve memory for the 254 * parse one mtd. have it reserve memory for the
256 * struct cmdline_mtd_partition and the mtd-id string. 255 * struct cmdline_mtd_partition and the mtd-id string.
257 */ 256 */
258 parts = newpart(p + 1, /* cmdline */ 257 parts = newpart(p + 1, /* cmdline */
259 &s, /* out: updated cmdline ptr */ 258 &s, /* out: updated cmdline ptr */
260 &num_parts, /* out: number of parts */ 259 &num_parts, /* out: number of parts */
261 0, /* first partition */ 260 0, /* first partition */
262 (unsigned char**)&this_mtd, /* out: extra mem */ 261 (unsigned char**)&this_mtd, /* out: extra mem */
263 mtd_id_len + 1 + sizeof(*this_mtd) + 262 mtd_id_len + 1 + sizeof(*this_mtd) +
264 sizeof(void*)-1 /*alignment*/); 263 sizeof(void*)-1 /*alignment*/);
265 if(!parts) 264 if (IS_ERR(parts))
266 { 265 {
267 /* 266 /*
268 * An error occurred. We're either: 267 * An error occurred. We're either:
269 * a) out of memory, or 268 * a) out of memory, or
270 * b) in the middle of the partition spec 269 * b) in the middle of the partition spec
271 * Either way, this mtd is hosed and we're 270 * Either way, this mtd is hosed and we're
272 * unlikely to succeed in parsing any more 271 * unlikely to succeed in parsing any more
273 */ 272 */
274 return 0; 273 return PTR_ERR(parts);
275 } 274 }
276 275
277 /* align this_mtd */ 276 /* align this_mtd */
278 this_mtd = (struct cmdline_mtd_partition *) 277 this_mtd = (struct cmdline_mtd_partition *)
279 ALIGN((unsigned long)this_mtd, sizeof(void*)); 278 ALIGN((unsigned long)this_mtd, sizeof(void*));
280 /* enter results */ 279 /* enter results */
281 this_mtd->parts = parts; 280 this_mtd->parts = parts;
282 this_mtd->num_parts = num_parts; 281 this_mtd->num_parts = num_parts;
283 this_mtd->mtd_id = (char*)(this_mtd + 1); 282 this_mtd->mtd_id = (char*)(this_mtd + 1);
284 strlcpy(this_mtd->mtd_id, mtd_id, mtd_id_len + 1); 283 strlcpy(this_mtd->mtd_id, mtd_id, mtd_id_len + 1);
285 284
286 /* link into chain */ 285 /* link into chain */
287 this_mtd->next = partitions; 286 this_mtd->next = partitions;
288 partitions = this_mtd; 287 partitions = this_mtd;
289 288
290 dbg(("mtdid=<%s> num_parts=<%d>\n", 289 dbg(("mtdid=<%s> num_parts=<%d>\n",
291 this_mtd->mtd_id, this_mtd->num_parts)); 290 this_mtd->mtd_id, this_mtd->num_parts));
292 291
293 292
294 /* EOS - we're done */ 293 /* EOS - we're done */
295 if (*s == 0) 294 if (*s == 0)
296 break; 295 break;
297 296
298 /* does another spec follow? */ 297 /* does another spec follow? */
299 if (*s != ';') 298 if (*s != ';')
300 { 299 {
301 printk(KERN_ERR ERRP "bad character after partition (%c)\n", *s); 300 printk(KERN_ERR ERRP "bad character after partition (%c)\n", *s);
302 return 0; 301 return -EINVAL;
303 } 302 }
304 s++; 303 s++;
305 } 304 }
306 return 1; 305 return 0;
307 } 306 }
308 307
309 /* 308 /*
310 * Main function to be called from the MTD mapping driver/device to 309 * Main function to be called from the MTD mapping driver/device to
311 * obtain the partitioning information. At this point the command line 310 * obtain the partitioning information. At this point the command line
312 * arguments will actually be parsed and turned to struct mtd_partition 311 * arguments will actually be parsed and turned to struct mtd_partition
313 * information. It returns partitions for the requested mtd device, or 312 * information. It returns partitions for the requested mtd device, or
314 * the first one in the chain if a NULL mtd_id is passed in. 313 * the first one in the chain if a NULL mtd_id is passed in.
315 */ 314 */
316 static int parse_cmdline_partitions(struct mtd_info *master, 315 static int parse_cmdline_partitions(struct mtd_info *master,
317 struct mtd_partition **pparts, 316 struct mtd_partition **pparts,
318 struct mtd_part_parser_data *data) 317 struct mtd_part_parser_data *data)
319 { 318 {
320 unsigned long offset; 319 unsigned long offset;
321 int i; 320 int i, err;
322 struct cmdline_mtd_partition *part; 321 struct cmdline_mtd_partition *part;
323 const char *mtd_id = master->name; 322 const char *mtd_id = master->name;
324 323
325 /* parse command line */ 324 /* parse command line */
326 if (!cmdline_parsed) 325 if (!cmdline_parsed) {
327 mtdpart_setup_real(cmdline); 326 err = mtdpart_setup_real(cmdline);
327 if (err)
328 return err;
329 }
328 330
329 for(part = partitions; part; part = part->next) 331 for(part = partitions; part; part = part->next)
330 { 332 {
331 if ((!mtd_id) || (!strcmp(part->mtd_id, mtd_id))) 333 if ((!mtd_id) || (!strcmp(part->mtd_id, mtd_id)))
332 { 334 {
333 for(i = 0, offset = 0; i < part->num_parts; i++) 335 for(i = 0, offset = 0; i < part->num_parts; i++)
334 { 336 {
335 if (part->parts[i].offset == OFFSET_CONTINUOUS) 337 if (part->parts[i].offset == OFFSET_CONTINUOUS)
336 part->parts[i].offset = offset; 338 part->parts[i].offset = offset;
337 else 339 else
338 offset = part->parts[i].offset; 340 offset = part->parts[i].offset;
339 if (part->parts[i].size == SIZE_REMAINING) 341 if (part->parts[i].size == SIZE_REMAINING)
340 part->parts[i].size = master->size - offset; 342 part->parts[i].size = master->size - offset;
341 if (offset + part->parts[i].size > master->size) 343 if (offset + part->parts[i].size > master->size)
342 { 344 {
343 printk(KERN_WARNING ERRP 345 printk(KERN_WARNING ERRP
344 "%s: partitioning exceeds flash size, truncating\n", 346 "%s: partitioning exceeds flash size, truncating\n",
345 part->mtd_id); 347 part->mtd_id);
346 part->parts[i].size = master->size - offset; 348 part->parts[i].size = master->size - offset;
347 part->num_parts = i; 349 part->num_parts = i;
348 } 350 }
349 offset += part->parts[i].size; 351 offset += part->parts[i].size;
350 } 352 }
351 *pparts = kmemdup(part->parts, 353 *pparts = kmemdup(part->parts,
352 sizeof(*part->parts) * part->num_parts, 354 sizeof(*part->parts) * part->num_parts,
353 GFP_KERNEL); 355 GFP_KERNEL);
354 if (!*pparts) 356 if (!*pparts)
355 return -ENOMEM; 357 return -ENOMEM;
356 return part->num_parts; 358 return part->num_parts;
357 } 359 }
358 } 360 }
359 return 0; 361 return 0;
360 } 362 }
361 363
362 364
363 /* 365 /*
364 * This is the handler for our kernel parameter, called from 366 * This is the handler for our kernel parameter, called from
365 * main.c::checksetup(). Note that we can not yet kmalloc() anything, 367 * main.c::checksetup(). Note that we can not yet kmalloc() anything,
366 * so we only save the commandline for later processing. 368 * so we only save the commandline for later processing.
367 * 369 *
368 * This function needs to be visible for bootloaders. 370 * This function needs to be visible for bootloaders.
369 */ 371 */
370 static int mtdpart_setup(char *s) 372 static int mtdpart_setup(char *s)
371 { 373 {
372 cmdline = s; 374 cmdline = s;
373 return 1; 375 return 1;
374 } 376 }
375 377
376 __setup("mtdparts=", mtdpart_setup); 378 __setup("mtdparts=", mtdpart_setup);
377 379
378 static struct mtd_part_parser cmdline_parser = { 380 static struct mtd_part_parser cmdline_parser = {
379 .owner = THIS_MODULE, 381 .owner = THIS_MODULE,
380 .parse_fn = parse_cmdline_partitions, 382 .parse_fn = parse_cmdline_partitions,
381 .name = "cmdlinepart", 383 .name = "cmdlinepart",
382 }; 384 };
383 385
384 static int __init cmdline_parser_init(void) 386 static int __init cmdline_parser_init(void)
385 { 387 {
386 return register_mtd_parser(&cmdline_parser); 388 return register_mtd_parser(&cmdline_parser);
387 } 389 }
388 390
389 module_init(cmdline_parser_init); 391 module_init(cmdline_parser_init);
390 392
391 MODULE_LICENSE("GPL"); 393 MODULE_LICENSE("GPL");
392 MODULE_AUTHOR("Marius Groeger <mag@sysgo.de>"); 394 MODULE_AUTHOR("Marius Groeger <mag@sysgo.de>");