mtd: denali.c: fixed all open brace { check-patch errors
[linux-2.6.git] / drivers / mtd / rfd_ftl.c
1 /*
2  * rfd_ftl.c -- resident flash disk (flash translation layer)
3  *
4  * Copyright (C) 2005  Sean Young <sean@mess.org>
5  *
6  * This type of flash translation layer (FTL) is used by the Embedded BIOS
7  * by General Software. It is known as the Resident Flash Disk (RFD), see:
8  *
9  *      http://www.gensw.com/pages/prod/bios/rfd.htm
10  *
11  * based on ftl.c
12  */
13
14 #include <linux/hdreg.h>
15 #include <linux/init.h>
16 #include <linux/mtd/blktrans.h>
17 #include <linux/mtd/mtd.h>
18 #include <linux/vmalloc.h>
19 #include <linux/slab.h>
20 #include <linux/jiffies.h>
21
22 #include <asm/types.h>
23
24 static int block_size = 0;
25 module_param(block_size, int, 0);
26 MODULE_PARM_DESC(block_size, "Block size to use by RFD, defaults to erase unit size");
27
28 #define PREFIX "rfd_ftl: "
29
30 /* This major has been assigned by device@lanana.org */
31 #ifndef RFD_FTL_MAJOR
32 #define RFD_FTL_MAJOR           256
33 #endif
34
35 /* Maximum number of partitions in an FTL region */
36 #define PART_BITS               4
37
38 /* An erase unit should start with this value */
39 #define RFD_MAGIC               0x9193
40
41 /* the second value is 0xffff or 0xffc8; function unknown */
42
43 /* the third value is always 0xffff, ignored */
44
45 /* next is an array of mapping for each corresponding sector */
46 #define HEADER_MAP_OFFSET       3
47 #define SECTOR_DELETED          0x0000
48 #define SECTOR_ZERO             0xfffe
49 #define SECTOR_FREE             0xffff
50
51 #define SECTOR_SIZE             512
52
53 #define SECTORS_PER_TRACK       63
54
55 struct block {
56         enum {
57                 BLOCK_OK,
58                 BLOCK_ERASING,
59                 BLOCK_ERASED,
60                 BLOCK_UNUSED,
61                 BLOCK_FAILED
62         } state;
63         int free_sectors;
64         int used_sectors;
65         int erases;
66         u_long offset;
67 };
68
69 struct partition {
70         struct mtd_blktrans_dev mbd;
71
72         u_int block_size;               /* size of erase unit */
73         u_int total_blocks;             /* number of erase units */
74         u_int header_sectors_per_block; /* header sectors in erase unit */
75         u_int data_sectors_per_block;   /* data sectors in erase unit */
76         u_int sector_count;             /* sectors in translated disk */
77         u_int header_size;              /* bytes in header sector */
78         int reserved_block;             /* block next up for reclaim */
79         int current_block;              /* block to write to */
80         u16 *header_cache;              /* cached header */
81
82         int is_reclaiming;
83         int cylinders;
84         int errors;
85         u_long *sector_map;
86         struct block *blocks;
87 };
88
89 static int rfd_ftl_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf);
90
91 static int build_block_map(struct partition *part, int block_no)
92 {
93         struct block *block = &part->blocks[block_no];
94         int i;
95
96         block->offset = part->block_size * block_no;
97
98         if (le16_to_cpu(part->header_cache[0]) != RFD_MAGIC) {
99                 block->state = BLOCK_UNUSED;
100                 return -ENOENT;
101         }
102
103         block->state = BLOCK_OK;
104
105         for (i=0; i<part->data_sectors_per_block; i++) {
106                 u16 entry;
107
108                 entry = le16_to_cpu(part->header_cache[HEADER_MAP_OFFSET + i]);
109
110                 if (entry == SECTOR_DELETED)
111                         continue;
112
113                 if (entry == SECTOR_FREE) {
114                         block->free_sectors++;
115                         continue;
116                 }
117
118                 if (entry == SECTOR_ZERO)
119                         entry = 0;
120
121                 if (entry >= part->sector_count) {
122                         printk(KERN_WARNING PREFIX
123                                 "'%s': unit #%d: entry %d corrupt, "
124                                 "sector %d out of range\n",
125                                 part->mbd.mtd->name, block_no, i, entry);
126                         continue;
127                 }
128
129                 if (part->sector_map[entry] != -1) {
130                         printk(KERN_WARNING PREFIX
131                                 "'%s': more than one entry for sector %d\n",
132                                 part->mbd.mtd->name, entry);
133                         part->errors = 1;
134                         continue;
135                 }
136
137                 part->sector_map[entry] = block->offset +
138                         (i + part->header_sectors_per_block) * SECTOR_SIZE;
139
140                 block->used_sectors++;
141         }
142
143         if (block->free_sectors == part->data_sectors_per_block)
144                 part->reserved_block = block_no;
145
146         return 0;
147 }
148
149 static int scan_header(struct partition *part)
150 {
151         int sectors_per_block;
152         int i, rc = -ENOMEM;
153         int blocks_found;
154         size_t retlen;
155
156         sectors_per_block = part->block_size / SECTOR_SIZE;
157         part->total_blocks = (u32)part->mbd.mtd->size / part->block_size;
158
159         if (part->total_blocks < 2)
160                 return -ENOENT;
161
162         /* each erase block has three bytes header, followed by the map */
163         part->header_sectors_per_block =
164                         ((HEADER_MAP_OFFSET + sectors_per_block) *
165                         sizeof(u16) + SECTOR_SIZE - 1) / SECTOR_SIZE;
166
167         part->data_sectors_per_block = sectors_per_block -
168                         part->header_sectors_per_block;
169
170         part->header_size = (HEADER_MAP_OFFSET +
171                         part->data_sectors_per_block) * sizeof(u16);
172
173         part->cylinders = (part->data_sectors_per_block *
174                         (part->total_blocks - 1) - 1) / SECTORS_PER_TRACK;
175
176         part->sector_count = part->cylinders * SECTORS_PER_TRACK;
177
178         part->current_block = -1;
179         part->reserved_block = -1;
180         part->is_reclaiming = 0;
181
182         part->header_cache = kmalloc(part->header_size, GFP_KERNEL);
183         if (!part->header_cache)
184                 goto err;
185
186         part->blocks = kcalloc(part->total_blocks, sizeof(struct block),
187                         GFP_KERNEL);
188         if (!part->blocks)
189                 goto err;
190
191         part->sector_map = vmalloc(part->sector_count * sizeof(u_long));
192         if (!part->sector_map) {
193                 printk(KERN_ERR PREFIX "'%s': unable to allocate memory for "
194                         "sector map", part->mbd.mtd->name);
195                 goto err;
196         }
197
198         for (i=0; i<part->sector_count; i++)
199                 part->sector_map[i] = -1;
200
201         for (i=0, blocks_found=0; i<part->total_blocks; i++) {
202                 rc = part->mbd.mtd->read(part->mbd.mtd,
203                                 i * part->block_size, part->header_size,
204                                 &retlen, (u_char*)part->header_cache);
205
206                 if (!rc && retlen != part->header_size)
207                         rc = -EIO;
208
209                 if (rc)
210                         goto err;
211
212                 if (!build_block_map(part, i))
213                         blocks_found++;
214         }
215
216         if (blocks_found == 0) {
217                 printk(KERN_NOTICE PREFIX "no RFD magic found in '%s'\n",
218                                 part->mbd.mtd->name);
219                 rc = -ENOENT;
220                 goto err;
221         }
222
223         if (part->reserved_block == -1) {
224                 printk(KERN_WARNING PREFIX "'%s': no empty erase unit found\n",
225                                 part->mbd.mtd->name);
226
227                 part->errors = 1;
228         }
229
230         return 0;
231
232 err:
233         vfree(part->sector_map);
234         kfree(part->header_cache);
235         kfree(part->blocks);
236
237         return rc;
238 }
239
240 static int rfd_ftl_readsect(struct mtd_blktrans_dev *dev, u_long sector, char *buf)
241 {
242         struct partition *part = (struct partition*)dev;
243         u_long addr;
244         size_t retlen;
245         int rc;
246
247         if (sector >= part->sector_count)
248                 return -EIO;
249
250         addr = part->sector_map[sector];
251         if (addr != -1) {
252                 rc = part->mbd.mtd->read(part->mbd.mtd, addr, SECTOR_SIZE,
253                                                 &retlen, (u_char*)buf);
254                 if (!rc && retlen != SECTOR_SIZE)
255                         rc = -EIO;
256
257                 if (rc) {
258                         printk(KERN_WARNING PREFIX "error reading '%s' at "
259                                 "0x%lx\n", part->mbd.mtd->name, addr);
260                         return rc;
261                 }
262         } else
263                 memset(buf, 0, SECTOR_SIZE);
264
265         return 0;
266 }
267
268 static void erase_callback(struct erase_info *erase)
269 {
270         struct partition *part;
271         u16 magic;
272         int i, rc;
273         size_t retlen;
274
275         part = (struct partition*)erase->priv;
276
277         i = (u32)erase->addr / part->block_size;
278         if (i >= part->total_blocks || part->blocks[i].offset != erase->addr ||
279             erase->addr > UINT_MAX) {
280                 printk(KERN_ERR PREFIX "erase callback for unknown offset %llx "
281                                 "on '%s'\n", (unsigned long long)erase->addr, part->mbd.mtd->name);
282                 return;
283         }
284
285         if (erase->state != MTD_ERASE_DONE) {
286                 printk(KERN_WARNING PREFIX "erase failed at 0x%llx on '%s', "
287                                 "state %d\n", (unsigned long long)erase->addr,
288                                 part->mbd.mtd->name, erase->state);
289
290                 part->blocks[i].state = BLOCK_FAILED;
291                 part->blocks[i].free_sectors = 0;
292                 part->blocks[i].used_sectors = 0;
293
294                 kfree(erase);
295
296                 return;
297         }
298
299         magic = cpu_to_le16(RFD_MAGIC);
300
301         part->blocks[i].state = BLOCK_ERASED;
302         part->blocks[i].free_sectors = part->data_sectors_per_block;
303         part->blocks[i].used_sectors = 0;
304         part->blocks[i].erases++;
305
306         rc = part->mbd.mtd->write(part->mbd.mtd,
307                 part->blocks[i].offset, sizeof(magic), &retlen,
308                 (u_char*)&magic);
309
310         if (!rc && retlen != sizeof(magic))
311                 rc = -EIO;
312
313         if (rc) {
314                 printk(KERN_ERR PREFIX "'%s': unable to write RFD "
315                                 "header at 0x%lx\n",
316                                 part->mbd.mtd->name,
317                                 part->blocks[i].offset);
318                 part->blocks[i].state = BLOCK_FAILED;
319         }
320         else
321                 part->blocks[i].state = BLOCK_OK;
322
323         kfree(erase);
324 }
325
326 static int erase_block(struct partition *part, int block)
327 {
328         struct erase_info *erase;
329         int rc = -ENOMEM;
330
331         erase = kmalloc(sizeof(struct erase_info), GFP_KERNEL);
332         if (!erase)
333                 goto err;
334
335         erase->mtd = part->mbd.mtd;
336         erase->callback = erase_callback;
337         erase->addr = part->blocks[block].offset;
338         erase->len = part->block_size;
339         erase->priv = (u_long)part;
340
341         part->blocks[block].state = BLOCK_ERASING;
342         part->blocks[block].free_sectors = 0;
343
344         rc = part->mbd.mtd->erase(part->mbd.mtd, erase);
345
346         if (rc) {
347                 printk(KERN_ERR PREFIX "erase of region %llx,%llx on '%s' "
348                                 "failed\n", (unsigned long long)erase->addr,
349                                 (unsigned long long)erase->len, part->mbd.mtd->name);
350                 kfree(erase);
351         }
352
353 err:
354         return rc;
355 }
356
357 static int move_block_contents(struct partition *part, int block_no, u_long *old_sector)
358 {
359         void *sector_data;
360         u16 *map;
361         size_t retlen;
362         int i, rc = -ENOMEM;
363
364         part->is_reclaiming = 1;
365
366         sector_data = kmalloc(SECTOR_SIZE, GFP_KERNEL);
367         if (!sector_data)
368                 goto err3;
369
370         map = kmalloc(part->header_size, GFP_KERNEL);
371         if (!map)
372                 goto err2;
373
374         rc = part->mbd.mtd->read(part->mbd.mtd,
375                 part->blocks[block_no].offset, part->header_size,
376                 &retlen, (u_char*)map);
377
378         if (!rc && retlen != part->header_size)
379                 rc = -EIO;
380
381         if (rc) {
382                 printk(KERN_ERR PREFIX "error reading '%s' at "
383                         "0x%lx\n", part->mbd.mtd->name,
384                         part->blocks[block_no].offset);
385
386                 goto err;
387         }
388
389         for (i=0; i<part->data_sectors_per_block; i++) {
390                 u16 entry = le16_to_cpu(map[HEADER_MAP_OFFSET + i]);
391                 u_long addr;
392
393
394                 if (entry == SECTOR_FREE || entry == SECTOR_DELETED)
395                         continue;
396
397                 if (entry == SECTOR_ZERO)
398                         entry = 0;
399
400                 /* already warned about and ignored in build_block_map() */
401                 if (entry >= part->sector_count)
402                         continue;
403
404                 addr = part->blocks[block_no].offset +
405                         (i + part->header_sectors_per_block) * SECTOR_SIZE;
406
407                 if (*old_sector == addr) {
408                         *old_sector = -1;
409                         if (!part->blocks[block_no].used_sectors--) {
410                                 rc = erase_block(part, block_no);
411                                 break;
412                         }
413                         continue;
414                 }
415                 rc = part->mbd.mtd->read(part->mbd.mtd, addr,
416                         SECTOR_SIZE, &retlen, sector_data);
417
418                 if (!rc && retlen != SECTOR_SIZE)
419                         rc = -EIO;
420
421                 if (rc) {
422                         printk(KERN_ERR PREFIX "'%s': Unable to "
423                                 "read sector for relocation\n",
424                                 part->mbd.mtd->name);
425
426                         goto err;
427                 }
428
429                 rc = rfd_ftl_writesect((struct mtd_blktrans_dev*)part,
430                                 entry, sector_data);
431
432                 if (rc)
433                         goto err;
434         }
435
436 err:
437         kfree(map);
438 err2:
439         kfree(sector_data);
440 err3:
441         part->is_reclaiming = 0;
442
443         return rc;
444 }
445
446 static int reclaim_block(struct partition *part, u_long *old_sector)
447 {
448         int block, best_block, score, old_sector_block;
449         int rc;
450
451         /* we have a race if sync doesn't exist */
452         if (part->mbd.mtd->sync)
453                 part->mbd.mtd->sync(part->mbd.mtd);
454
455         score = 0x7fffffff; /* MAX_INT */
456         best_block = -1;
457         if (*old_sector != -1)
458                 old_sector_block = *old_sector / part->block_size;
459         else
460                 old_sector_block = -1;
461
462         for (block=0; block<part->total_blocks; block++) {
463                 int this_score;
464
465                 if (block == part->reserved_block)
466                         continue;
467
468                 /*
469                  * Postpone reclaiming if there is a free sector as
470                  * more removed sectors is more efficient (have to move
471                  * less).
472                  */
473                 if (part->blocks[block].free_sectors)
474                         return 0;
475
476                 this_score = part->blocks[block].used_sectors;
477
478                 if (block == old_sector_block)
479                         this_score--;
480                 else {
481                         /* no point in moving a full block */
482                         if (part->blocks[block].used_sectors ==
483                                         part->data_sectors_per_block)
484                                 continue;
485                 }
486
487                 this_score += part->blocks[block].erases;
488
489                 if (this_score < score) {
490                         best_block = block;
491                         score = this_score;
492                 }
493         }
494
495         if (best_block == -1)
496                 return -ENOSPC;
497
498         part->current_block = -1;
499         part->reserved_block = best_block;
500
501         pr_debug("reclaim_block: reclaiming block #%d with %d used "
502                  "%d free sectors\n", best_block,
503                  part->blocks[best_block].used_sectors,
504                  part->blocks[best_block].free_sectors);
505
506         if (part->blocks[best_block].used_sectors)
507                 rc = move_block_contents(part, best_block, old_sector);
508         else
509                 rc = erase_block(part, best_block);
510
511         return rc;
512 }
513
514 /*
515  * IMPROVE: It would be best to choose the block with the most deleted sectors,
516  * because if we fill that one up first it'll have the most chance of having
517  * the least live sectors at reclaim.
518  */
519 static int find_free_block(struct partition *part)
520 {
521         int block, stop;
522
523         block = part->current_block == -1 ?
524                         jiffies % part->total_blocks : part->current_block;
525         stop = block;
526
527         do {
528                 if (part->blocks[block].free_sectors &&
529                                 block != part->reserved_block)
530                         return block;
531
532                 if (part->blocks[block].state == BLOCK_UNUSED)
533                         erase_block(part, block);
534
535                 if (++block >= part->total_blocks)
536                         block = 0;
537
538         } while (block != stop);
539
540         return -1;
541 }
542
543 static int find_writable_block(struct partition *part, u_long *old_sector)
544 {
545         int rc, block;
546         size_t retlen;
547
548         block = find_free_block(part);
549
550         if (block == -1) {
551                 if (!part->is_reclaiming) {
552                         rc = reclaim_block(part, old_sector);
553                         if (rc)
554                                 goto err;
555
556                         block = find_free_block(part);
557                 }
558
559                 if (block == -1) {
560                         rc = -ENOSPC;
561                         goto err;
562                 }
563         }
564
565         rc = part->mbd.mtd->read(part->mbd.mtd, part->blocks[block].offset,
566                 part->header_size, &retlen, (u_char*)part->header_cache);
567
568         if (!rc && retlen != part->header_size)
569                 rc = -EIO;
570
571         if (rc) {
572                 printk(KERN_ERR PREFIX "'%s': unable to read header at "
573                                 "0x%lx\n", part->mbd.mtd->name,
574                                 part->blocks[block].offset);
575                 goto err;
576         }
577
578         part->current_block = block;
579
580 err:
581         return rc;
582 }
583
584 static int mark_sector_deleted(struct partition *part, u_long old_addr)
585 {
586         int block, offset, rc;
587         u_long addr;
588         size_t retlen;
589         u16 del = cpu_to_le16(SECTOR_DELETED);
590
591         block = old_addr / part->block_size;
592         offset = (old_addr % part->block_size) / SECTOR_SIZE -
593                 part->header_sectors_per_block;
594
595         addr = part->blocks[block].offset +
596                         (HEADER_MAP_OFFSET + offset) * sizeof(u16);
597         rc = part->mbd.mtd->write(part->mbd.mtd, addr,
598                 sizeof(del), &retlen, (u_char*)&del);
599
600         if (!rc && retlen != sizeof(del))
601                 rc = -EIO;
602
603         if (rc) {
604                 printk(KERN_ERR PREFIX "error writing '%s' at "
605                         "0x%lx\n", part->mbd.mtd->name, addr);
606                 if (rc)
607                         goto err;
608         }
609         if (block == part->current_block)
610                 part->header_cache[offset + HEADER_MAP_OFFSET] = del;
611
612         part->blocks[block].used_sectors--;
613
614         if (!part->blocks[block].used_sectors &&
615             !part->blocks[block].free_sectors)
616                 rc = erase_block(part, block);
617
618 err:
619         return rc;
620 }
621
622 static int find_free_sector(const struct partition *part, const struct block *block)
623 {
624         int i, stop;
625
626         i = stop = part->data_sectors_per_block - block->free_sectors;
627
628         do {
629                 if (le16_to_cpu(part->header_cache[HEADER_MAP_OFFSET + i])
630                                 == SECTOR_FREE)
631                         return i;
632
633                 if (++i == part->data_sectors_per_block)
634                         i = 0;
635         }
636         while(i != stop);
637
638         return -1;
639 }
640
641 static int do_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf, ulong *old_addr)
642 {
643         struct partition *part = (struct partition*)dev;
644         struct block *block;
645         u_long addr;
646         int i;
647         int rc;
648         size_t retlen;
649         u16 entry;
650
651         if (part->current_block == -1 ||
652                 !part->blocks[part->current_block].free_sectors) {
653
654                 rc = find_writable_block(part, old_addr);
655                 if (rc)
656                         goto err;
657         }
658
659         block = &part->blocks[part->current_block];
660
661         i = find_free_sector(part, block);
662
663         if (i < 0) {
664                 rc = -ENOSPC;
665                 goto err;
666         }
667
668         addr = (i + part->header_sectors_per_block) * SECTOR_SIZE +
669                 block->offset;
670         rc = part->mbd.mtd->write(part->mbd.mtd,
671                 addr, SECTOR_SIZE, &retlen, (u_char*)buf);
672
673         if (!rc && retlen != SECTOR_SIZE)
674                 rc = -EIO;
675
676         if (rc) {
677                 printk(KERN_ERR PREFIX "error writing '%s' at 0x%lx\n",
678                                 part->mbd.mtd->name, addr);
679                 if (rc)
680                         goto err;
681         }
682
683         part->sector_map[sector] = addr;
684
685         entry = cpu_to_le16(sector == 0 ? SECTOR_ZERO : sector);
686
687         part->header_cache[i + HEADER_MAP_OFFSET] = entry;
688
689         addr = block->offset + (HEADER_MAP_OFFSET + i) * sizeof(u16);
690         rc = part->mbd.mtd->write(part->mbd.mtd, addr,
691                         sizeof(entry), &retlen, (u_char*)&entry);
692
693         if (!rc && retlen != sizeof(entry))
694                 rc = -EIO;
695
696         if (rc) {
697                 printk(KERN_ERR PREFIX "error writing '%s' at 0x%lx\n",
698                                 part->mbd.mtd->name, addr);
699                 if (rc)
700                         goto err;
701         }
702         block->used_sectors++;
703         block->free_sectors--;
704
705 err:
706         return rc;
707 }
708
709 static int rfd_ftl_writesect(struct mtd_blktrans_dev *dev, u_long sector, char *buf)
710 {
711         struct partition *part = (struct partition*)dev;
712         u_long old_addr;
713         int i;
714         int rc = 0;
715
716         pr_debug("rfd_ftl_writesect(sector=0x%lx)\n", sector);
717
718         if (part->reserved_block == -1) {
719                 rc = -EACCES;
720                 goto err;
721         }
722
723         if (sector >= part->sector_count) {
724                 rc = -EIO;
725                 goto err;
726         }
727
728         old_addr = part->sector_map[sector];
729
730         for (i=0; i<SECTOR_SIZE; i++) {
731                 if (!buf[i])
732                         continue;
733
734                 rc = do_writesect(dev, sector, buf, &old_addr);
735                 if (rc)
736                         goto err;
737                 break;
738         }
739
740         if (i == SECTOR_SIZE)
741                 part->sector_map[sector] = -1;
742
743         if (old_addr != -1)
744                 rc = mark_sector_deleted(part, old_addr);
745
746 err:
747         return rc;
748 }
749
750 static int rfd_ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
751 {
752         struct partition *part = (struct partition*)dev;
753
754         geo->heads = 1;
755         geo->sectors = SECTORS_PER_TRACK;
756         geo->cylinders = part->cylinders;
757
758         return 0;
759 }
760
761 static void rfd_ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
762 {
763         struct partition *part;
764
765         if (mtd->type != MTD_NORFLASH || mtd->size > UINT_MAX)
766                 return;
767
768         part = kzalloc(sizeof(struct partition), GFP_KERNEL);
769         if (!part)
770                 return;
771
772         part->mbd.mtd = mtd;
773
774         if (block_size)
775                 part->block_size = block_size;
776         else {
777                 if (!mtd->erasesize) {
778                         printk(KERN_WARNING PREFIX "please provide block_size");
779                         goto out;
780                 } else
781                         part->block_size = mtd->erasesize;
782         }
783
784         if (scan_header(part) == 0) {
785                 part->mbd.size = part->sector_count;
786                 part->mbd.tr = tr;
787                 part->mbd.devnum = -1;
788                 if (!(mtd->flags & MTD_WRITEABLE))
789                         part->mbd.readonly = 1;
790                 else if (part->errors) {
791                         printk(KERN_WARNING PREFIX "'%s': errors found, "
792                                         "setting read-only\n", mtd->name);
793                         part->mbd.readonly = 1;
794                 }
795
796                 printk(KERN_INFO PREFIX "name: '%s' type: %d flags %x\n",
797                                 mtd->name, mtd->type, mtd->flags);
798
799                 if (!add_mtd_blktrans_dev((void*)part))
800                         return;
801         }
802 out:
803         kfree(part);
804 }
805
806 static void rfd_ftl_remove_dev(struct mtd_blktrans_dev *dev)
807 {
808         struct partition *part = (struct partition*)dev;
809         int i;
810
811         for (i=0; i<part->total_blocks; i++) {
812                 pr_debug("rfd_ftl_remove_dev:'%s': erase unit #%02d: %d erases\n",
813                         part->mbd.mtd->name, i, part->blocks[i].erases);
814         }
815
816         del_mtd_blktrans_dev(dev);
817         vfree(part->sector_map);
818         kfree(part->header_cache);
819         kfree(part->blocks);
820 }
821
822 static struct mtd_blktrans_ops rfd_ftl_tr = {
823         .name           = "rfd",
824         .major          = RFD_FTL_MAJOR,
825         .part_bits      = PART_BITS,
826         .blksize        = SECTOR_SIZE,
827
828         .readsect       = rfd_ftl_readsect,
829         .writesect      = rfd_ftl_writesect,
830         .getgeo         = rfd_ftl_getgeo,
831         .add_mtd        = rfd_ftl_add_mtd,
832         .remove_dev     = rfd_ftl_remove_dev,
833         .owner          = THIS_MODULE,
834 };
835
836 static int __init init_rfd_ftl(void)
837 {
838         return register_mtd_blktrans(&rfd_ftl_tr);
839 }
840
841 static void __exit cleanup_rfd_ftl(void)
842 {
843         deregister_mtd_blktrans(&rfd_ftl_tr);
844 }
845
846 module_init(init_rfd_ftl);
847 module_exit(cleanup_rfd_ftl);
848
849 MODULE_LICENSE("GPL");
850 MODULE_AUTHOR("Sean Young <sean@mess.org>");
851 MODULE_DESCRIPTION("Support code for RFD Flash Translation Layer, "
852                 "used by General Software's Embedded BIOS");
853