]>
git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/mtd/mtdpart.c
9a3bf6f39d236107b19afb68bc0c8822aa08aa55
2 * Simple MTD partitioning layer
4 * (C) 2000 Nicolas Pitre <nico@cam.org>
8 * 02-21-2002 Thomas Gleixner <gleixner@autronix.de>
9 * added support for read_oob, write_oob
14 #include <asm/errno.h>
16 #include <linux/types.h>
17 #include <linux/list.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/mtd/partitions.h>
20 #include <linux/mtd/compat.h>
22 /* Our partition linked list */
23 static LIST_HEAD(mtd_partitions
);
25 /* Our partition node structure */
28 struct mtd_info
*master
;
31 struct list_head list
;
36 * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
37 * the pointer to that structure with this macro.
39 #define PART(x) ((struct mtd_part *)(x))
43 * MTD methods which simply translate the effective address and pass through
44 * to the _real_ device.
47 static int part_read (struct mtd_info
*mtd
, loff_t from
, size_t len
,
48 size_t *retlen
, u_char
*buf
)
50 struct mtd_part
*part
= PART(mtd
);
53 if (from
>= mtd
->size
)
55 else if (from
+ len
> mtd
->size
)
56 len
= mtd
->size
- from
;
57 res
= part
->master
->read (part
->master
, from
+ part
->offset
,
61 mtd
->ecc_stats
.corrected
++;
63 mtd
->ecc_stats
.failed
++;
69 static int part_point (struct mtd_info
*mtd
, loff_t from
, size_t len
,
70 size_t *retlen
, void **virt
, resource_size_t
*phys
)
72 struct mtd_part
*part
= PART(mtd
);
73 if (from
>= mtd
->size
)
75 else if (from
+ len
> mtd
->size
)
76 len
= mtd
->size
- from
;
77 return part
->master
->point (part
->master
, from
+ part
->offset
,
78 len
, retlen
, virt
, phys
);
81 static void part_unpoint(struct mtd_info
*mtd
, loff_t from
, size_t len
)
83 struct mtd_part
*part
= PART(mtd
);
85 part
->master
->unpoint(part
->master
, from
+ part
->offset
, len
);
89 static int part_read_oob(struct mtd_info
*mtd
, loff_t from
,
90 struct mtd_oob_ops
*ops
)
92 struct mtd_part
*part
= PART(mtd
);
95 if (from
>= mtd
->size
)
97 if (ops
->datbuf
&& from
+ ops
->len
> mtd
->size
)
99 res
= part
->master
->read_oob(part
->master
, from
+ part
->offset
, ops
);
103 mtd
->ecc_stats
.corrected
++;
105 mtd
->ecc_stats
.failed
++;
110 static int part_read_user_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
,
111 size_t *retlen
, u_char
*buf
)
113 struct mtd_part
*part
= PART(mtd
);
114 return part
->master
->read_user_prot_reg (part
->master
, from
,
118 static int part_get_user_prot_info (struct mtd_info
*mtd
,
119 struct otp_info
*buf
, size_t len
)
121 struct mtd_part
*part
= PART(mtd
);
122 return part
->master
->get_user_prot_info (part
->master
, buf
, len
);
125 static int part_read_fact_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
,
126 size_t *retlen
, u_char
*buf
)
128 struct mtd_part
*part
= PART(mtd
);
129 return part
->master
->read_fact_prot_reg (part
->master
, from
,
133 static int part_get_fact_prot_info (struct mtd_info
*mtd
,
134 struct otp_info
*buf
, size_t len
)
136 struct mtd_part
*part
= PART(mtd
);
137 return part
->master
->get_fact_prot_info (part
->master
, buf
, len
);
140 static int part_write (struct mtd_info
*mtd
, loff_t to
, size_t len
,
141 size_t *retlen
, const u_char
*buf
)
143 struct mtd_part
*part
= PART(mtd
);
144 if (!(mtd
->flags
& MTD_WRITEABLE
))
148 else if (to
+ len
> mtd
->size
)
149 len
= mtd
->size
- to
;
150 return part
->master
->write (part
->master
, to
+ part
->offset
,
155 static int part_panic_write (struct mtd_info
*mtd
, loff_t to
, size_t len
,
156 size_t *retlen
, const u_char
*buf
)
158 struct mtd_part
*part
= PART(mtd
);
159 if (!(mtd
->flags
& MTD_WRITEABLE
))
163 else if (to
+ len
> mtd
->size
)
164 len
= mtd
->size
- to
;
165 return part
->master
->panic_write (part
->master
, to
+ part
->offset
,
170 static int part_write_oob(struct mtd_info
*mtd
, loff_t to
,
171 struct mtd_oob_ops
*ops
)
173 struct mtd_part
*part
= PART(mtd
);
175 if (!(mtd
->flags
& MTD_WRITEABLE
))
180 if (ops
->datbuf
&& to
+ ops
->len
> mtd
->size
)
182 return part
->master
->write_oob(part
->master
, to
+ part
->offset
, ops
);
185 static int part_write_user_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
,
186 size_t *retlen
, u_char
*buf
)
188 struct mtd_part
*part
= PART(mtd
);
189 return part
->master
->write_user_prot_reg (part
->master
, from
,
193 static int part_lock_user_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
)
195 struct mtd_part
*part
= PART(mtd
);
196 return part
->master
->lock_user_prot_reg (part
->master
, from
, len
);
200 static int part_writev (struct mtd_info
*mtd
, const struct kvec
*vecs
,
201 unsigned long count
, loff_t to
, size_t *retlen
)
203 struct mtd_part
*part
= PART(mtd
);
204 if (!(mtd
->flags
& MTD_WRITEABLE
))
206 return part
->master
->writev (part
->master
, vecs
, count
,
207 to
+ part
->offset
, retlen
);
211 static int part_erase (struct mtd_info
*mtd
, struct erase_info
*instr
)
213 struct mtd_part
*part
= PART(mtd
);
215 if (!(mtd
->flags
& MTD_WRITEABLE
))
217 if (instr
->addr
>= mtd
->size
)
219 instr
->addr
+= part
->offset
;
220 ret
= part
->master
->erase(part
->master
, instr
);
222 if (instr
->fail_addr
!= 0xffffffff)
223 instr
->fail_addr
-= part
->offset
;
224 instr
->addr
-= part
->offset
;
229 void mtd_erase_callback(struct erase_info
*instr
)
231 if (instr
->mtd
->erase
== part_erase
) {
232 struct mtd_part
*part
= PART(instr
->mtd
);
234 if (instr
->fail_addr
!= 0xffffffff)
235 instr
->fail_addr
-= part
->offset
;
236 instr
->addr
-= part
->offset
;
239 instr
->callback(instr
);
242 EXPORT_SYMBOL_GPL(mtd_erase_callback
);
246 static int part_lock (struct mtd_info
*mtd
, loff_t ofs
, size_t len
)
248 struct mtd_part
*part
= PART(mtd
);
249 if ((len
+ ofs
) > mtd
->size
)
251 return part
->master
->lock(part
->master
, ofs
+ part
->offset
, len
);
254 static int part_unlock (struct mtd_info
*mtd
, loff_t ofs
, size_t len
)
256 struct mtd_part
*part
= PART(mtd
);
257 if ((len
+ ofs
) > mtd
->size
)
259 return part
->master
->unlock(part
->master
, ofs
+ part
->offset
, len
);
263 static void part_sync(struct mtd_info
*mtd
)
265 struct mtd_part
*part
= PART(mtd
);
266 part
->master
->sync(part
->master
);
270 static int part_suspend(struct mtd_info
*mtd
)
272 struct mtd_part
*part
= PART(mtd
);
273 return part
->master
->suspend(part
->master
);
276 static void part_resume(struct mtd_info
*mtd
)
278 struct mtd_part
*part
= PART(mtd
);
279 part
->master
->resume(part
->master
);
283 static int part_block_isbad (struct mtd_info
*mtd
, loff_t ofs
)
285 struct mtd_part
*part
= PART(mtd
);
286 if (ofs
>= mtd
->size
)
289 return part
->master
->block_isbad(part
->master
, ofs
);
292 static int part_block_markbad (struct mtd_info
*mtd
, loff_t ofs
)
294 struct mtd_part
*part
= PART(mtd
);
297 if (!(mtd
->flags
& MTD_WRITEABLE
))
299 if (ofs
>= mtd
->size
)
302 res
= part
->master
->block_markbad(part
->master
, ofs
);
305 mtd
->ecc_stats
.badblocks
++;
311 * This function unregisters and destroy all slave MTD objects which are
312 * attached to the given master MTD object.
315 int del_mtd_partitions(struct mtd_info
*master
)
317 struct list_head
*node
;
318 struct mtd_part
*slave
;
320 for (node
= mtd_partitions
.next
;
321 node
!= &mtd_partitions
;
323 slave
= list_entry(node
, struct mtd_part
, list
);
324 if (slave
->master
== master
) {
325 struct list_head
*prev
= node
->prev
;
326 __list_del(prev
, node
->next
);
327 if(slave
->registered
)
328 del_mtd_device(&slave
->mtd
);
338 * This function, given a master MTD object and a partition table, creates
339 * and registers slave MTD objects which are bound to the master according to
340 * the partition definitions.
341 * (Q: should we register the master MTD object as well?)
344 int add_mtd_partitions(struct mtd_info
*master
,
345 const struct mtd_partition
*parts
,
348 struct mtd_part
*slave
;
349 u_int32_t cur_offset
= 0;
352 printk (KERN_NOTICE
"Creating %d MTD partitions on \"%s\":\n", nbparts
, master
->name
);
354 for (i
= 0; i
< nbparts
; i
++) {
356 /* allocate the partition structure */
357 slave
= kzalloc (sizeof(*slave
), GFP_KERNEL
);
359 printk ("memory allocation error while creating partitions for \"%s\"\n",
361 del_mtd_partitions(master
);
364 list_add(&slave
->list
, &mtd_partitions
);
366 /* set up the MTD object for this partition */
367 slave
->mtd
.type
= master
->type
;
368 slave
->mtd
.flags
= master
->flags
& ~parts
[i
].mask_flags
;
369 slave
->mtd
.size
= parts
[i
].size
;
370 slave
->mtd
.writesize
= master
->writesize
;
371 slave
->mtd
.oobsize
= master
->oobsize
;
372 slave
->mtd
.oobavail
= master
->oobavail
;
373 slave
->mtd
.subpage_sft
= master
->subpage_sft
;
375 slave
->mtd
.name
= parts
[i
].name
;
376 slave
->mtd
.owner
= master
->owner
;
378 slave
->mtd
.read
= part_read
;
379 slave
->mtd
.write
= part_write
;
382 if (master
->panic_write
)
383 slave
->mtd
.panic_write
= part_panic_write
;
385 if(master
->point
&& master
->unpoint
){
386 slave
->mtd
.point
= part_point
;
387 slave
->mtd
.unpoint
= part_unpoint
;
391 if (master
->read_oob
)
392 slave
->mtd
.read_oob
= part_read_oob
;
393 if (master
->write_oob
)
394 slave
->mtd
.write_oob
= part_write_oob
;
395 if(master
->read_user_prot_reg
)
396 slave
->mtd
.read_user_prot_reg
= part_read_user_prot_reg
;
397 if(master
->read_fact_prot_reg
)
398 slave
->mtd
.read_fact_prot_reg
= part_read_fact_prot_reg
;
399 if(master
->write_user_prot_reg
)
400 slave
->mtd
.write_user_prot_reg
= part_write_user_prot_reg
;
401 if(master
->lock_user_prot_reg
)
402 slave
->mtd
.lock_user_prot_reg
= part_lock_user_prot_reg
;
403 if(master
->get_user_prot_info
)
404 slave
->mtd
.get_user_prot_info
= part_get_user_prot_info
;
405 if(master
->get_fact_prot_info
)
406 slave
->mtd
.get_fact_prot_info
= part_get_fact_prot_info
;
408 slave
->mtd
.sync
= part_sync
;
410 if (!i
&& master
->suspend
&& master
->resume
) {
411 slave
->mtd
.suspend
= part_suspend
;
412 slave
->mtd
.resume
= part_resume
;
415 slave
->mtd
.writev
= part_writev
;
417 slave
->mtd
.lock
= part_lock
;
419 slave
->mtd
.unlock
= part_unlock
;
421 if (master
->block_isbad
)
422 slave
->mtd
.block_isbad
= part_block_isbad
;
423 if (master
->block_markbad
)
424 slave
->mtd
.block_markbad
= part_block_markbad
;
425 slave
->mtd
.erase
= part_erase
;
426 slave
->master
= master
;
427 slave
->offset
= parts
[i
].offset
;
430 if (slave
->offset
== MTDPART_OFS_APPEND
)
431 slave
->offset
= cur_offset
;
432 if (slave
->offset
== MTDPART_OFS_NXTBLK
) {
433 slave
->offset
= cur_offset
;
434 if ((cur_offset
% master
->erasesize
) != 0) {
435 /* Round up to next erasesize */
436 slave
->offset
= ((cur_offset
/ master
->erasesize
) + 1) * master
->erasesize
;
437 printk(KERN_NOTICE
"Moving partition %d: "
438 "0x%08x -> 0x%08x\n", i
,
439 cur_offset
, slave
->offset
);
442 if (slave
->mtd
.size
== MTDPART_SIZ_FULL
)
443 slave
->mtd
.size
= master
->size
- slave
->offset
;
444 cur_offset
= slave
->offset
+ slave
->mtd
.size
;
446 printk (KERN_NOTICE
"0x%08x-0x%08x : \"%s\"\n", slave
->offset
,
447 slave
->offset
+ slave
->mtd
.size
, slave
->mtd
.name
);
449 /* let's do some sanity checks */
450 if (slave
->offset
>= master
->size
) {
451 /* let's register it anyway to preserve ordering */
454 printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
457 if (slave
->offset
+ slave
->mtd
.size
> master
->size
) {
458 slave
->mtd
.size
= master
->size
- slave
->offset
;
459 printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
460 parts
[i
].name
, master
->name
, slave
->mtd
.size
);
462 if (master
->numeraseregions
>1) {
463 /* Deal with variable erase size stuff */
465 struct mtd_erase_region_info
*regions
= master
->eraseregions
;
467 /* Find the first erase regions which is part of this partition. */
468 for (i
=0; i
< master
->numeraseregions
&& slave
->offset
>= regions
[i
].offset
; i
++)
471 for (i
--; i
< master
->numeraseregions
&& slave
->offset
+ slave
->mtd
.size
> regions
[i
].offset
; i
++) {
472 if (slave
->mtd
.erasesize
< regions
[i
].erasesize
) {
473 slave
->mtd
.erasesize
= regions
[i
].erasesize
;
477 /* Single erase size */
478 slave
->mtd
.erasesize
= master
->erasesize
;
481 if ((slave
->mtd
.flags
& MTD_WRITEABLE
) &&
482 (slave
->offset
% slave
->mtd
.erasesize
)) {
483 /* Doesn't start on a boundary of major erase size */
484 /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
485 slave
->mtd
.flags
&= ~MTD_WRITEABLE
;
486 printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
489 if ((slave
->mtd
.flags
& MTD_WRITEABLE
) &&
490 (slave
->mtd
.size
% slave
->mtd
.erasesize
)) {
491 slave
->mtd
.flags
&= ~MTD_WRITEABLE
;
492 printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
496 slave
->mtd
.ecclayout
= master
->ecclayout
;
497 if (master
->block_isbad
) {
500 while(offs
< slave
->mtd
.size
) {
501 if (master
->block_isbad(master
,
502 offs
+ slave
->offset
))
503 slave
->mtd
.ecc_stats
.badblocks
++;
504 offs
+= slave
->mtd
.erasesize
;
510 /* store the object pointer
511 * (caller may or may not register it */
512 *parts
[i
].mtdp
= &slave
->mtd
;
513 slave
->registered
= 0;
515 /* register our partition */
516 add_mtd_device(&slave
->mtd
);
517 slave
->registered
= 1;
520 /* register our partition */
521 add_mtd_device(&slave
->mtd
);
522 slave
->registered
= 1;
530 EXPORT_SYMBOL(add_mtd_partitions
);
531 EXPORT_SYMBOL(del_mtd_partitions
);