]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/mtd/mtdswap.c
Merge tag 'irqchip-urgent-3.19' of git://git.infradead.org/users/jcooper/linux into...
[karo-tx-linux.git] / drivers / mtd / mtdswap.c
1 /*
2  * Swap block device support for MTDs
3  * Turns an MTD device into a swap device with block wear leveling
4  *
5  * Copyright © 2007,2011 Nokia Corporation. All rights reserved.
6  *
7  * Authors: Jarkko Lavinen <jarkko.lavinen@nokia.com>
8  *
9  * Based on Richard Purdie's earlier implementation in 2007. Background
10  * support and lock-less operation written by Adrian Hunter.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * version 2 as published by the Free Software Foundation.
15  *
16  * This program is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24  * 02110-1301 USA
25  */
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/mtd/mtd.h>
30 #include <linux/mtd/blktrans.h>
31 #include <linux/rbtree.h>
32 #include <linux/sched.h>
33 #include <linux/slab.h>
34 #include <linux/vmalloc.h>
35 #include <linux/genhd.h>
36 #include <linux/swap.h>
37 #include <linux/debugfs.h>
38 #include <linux/seq_file.h>
39 #include <linux/device.h>
40 #include <linux/math64.h>
41
42 #define MTDSWAP_PREFIX "mtdswap"
43
44 /*
45  * The number of free eraseblocks when GC should stop
46  */
47 #define CLEAN_BLOCK_THRESHOLD   20
48
49 /*
50  * Number of free eraseblocks below which GC can also collect low frag
51  * blocks.
52  */
53 #define LOW_FRAG_GC_TRESHOLD    5
54
55 /*
56  * Wear level cost amortization. We want to do wear leveling on the background
57  * without disturbing gc too much. This is made by defining max GC frequency.
58  * Frequency value 6 means 1/6 of the GC passes will pick an erase block based
59  * on the biggest wear difference rather than the biggest dirtiness.
60  *
61  * The lower freq2 should be chosen so that it makes sure the maximum erase
62  * difference will decrease even if a malicious application is deliberately
63  * trying to make erase differences large.
64  */
65 #define MAX_ERASE_DIFF          4000
66 #define COLLECT_NONDIRTY_BASE   MAX_ERASE_DIFF
67 #define COLLECT_NONDIRTY_FREQ1  6
68 #define COLLECT_NONDIRTY_FREQ2  4
69
70 #define PAGE_UNDEF              UINT_MAX
71 #define BLOCK_UNDEF             UINT_MAX
72 #define BLOCK_ERROR             (UINT_MAX - 1)
73 #define BLOCK_MAX               (UINT_MAX - 2)
74
75 #define EBLOCK_BAD              (1 << 0)
76 #define EBLOCK_NOMAGIC          (1 << 1)
77 #define EBLOCK_BITFLIP          (1 << 2)
78 #define EBLOCK_FAILED           (1 << 3)
79 #define EBLOCK_READERR          (1 << 4)
80 #define EBLOCK_IDX_SHIFT        5
81
82 struct swap_eb {
83         struct rb_node rb;
84         struct rb_root *root;
85
86         unsigned int flags;
87         unsigned int active_count;
88         unsigned int erase_count;
89         unsigned int pad;               /* speeds up pointer decrement */
90 };
91
92 #define MTDSWAP_ECNT_MIN(rbroot) (rb_entry(rb_first(rbroot), struct swap_eb, \
93                                 rb)->erase_count)
94 #define MTDSWAP_ECNT_MAX(rbroot) (rb_entry(rb_last(rbroot), struct swap_eb, \
95                                 rb)->erase_count)
96
97 struct mtdswap_tree {
98         struct rb_root root;
99         unsigned int count;
100 };
101
102 enum {
103         MTDSWAP_CLEAN,
104         MTDSWAP_USED,
105         MTDSWAP_LOWFRAG,
106         MTDSWAP_HIFRAG,
107         MTDSWAP_DIRTY,
108         MTDSWAP_BITFLIP,
109         MTDSWAP_FAILING,
110         MTDSWAP_TREE_CNT,
111 };
112
113 struct mtdswap_dev {
114         struct mtd_blktrans_dev *mbd_dev;
115         struct mtd_info *mtd;
116         struct device *dev;
117
118         unsigned int *page_data;
119         unsigned int *revmap;
120
121         unsigned int eblks;
122         unsigned int spare_eblks;
123         unsigned int pages_per_eblk;
124         unsigned int max_erase_count;
125         struct swap_eb *eb_data;
126
127         struct mtdswap_tree trees[MTDSWAP_TREE_CNT];
128
129         unsigned long long sect_read_count;
130         unsigned long long sect_write_count;
131         unsigned long long mtd_write_count;
132         unsigned long long mtd_read_count;
133         unsigned long long discard_count;
134         unsigned long long discard_page_count;
135
136         unsigned int curr_write_pos;
137         struct swap_eb *curr_write;
138
139         char *page_buf;
140         char *oob_buf;
141
142         struct dentry *debugfs_root;
143 };
144
145 struct mtdswap_oobdata {
146         __le16 magic;
147         __le32 count;
148 } __packed;
149
150 #define MTDSWAP_MAGIC_CLEAN     0x2095
151 #define MTDSWAP_MAGIC_DIRTY     (MTDSWAP_MAGIC_CLEAN + 1)
152 #define MTDSWAP_TYPE_CLEAN      0
153 #define MTDSWAP_TYPE_DIRTY      1
154 #define MTDSWAP_OOBSIZE         sizeof(struct mtdswap_oobdata)
155
156 #define MTDSWAP_ERASE_RETRIES   3 /* Before marking erase block bad */
157 #define MTDSWAP_IO_RETRIES      3
158
159 enum {
160         MTDSWAP_SCANNED_CLEAN,
161         MTDSWAP_SCANNED_DIRTY,
162         MTDSWAP_SCANNED_BITFLIP,
163         MTDSWAP_SCANNED_BAD,
164 };
165
166 /*
167  * In the worst case mtdswap_writesect() has allocated the last clean
168  * page from the current block and is then pre-empted by the GC
169  * thread. The thread can consume a full erase block when moving a
170  * block.
171  */
172 #define MIN_SPARE_EBLOCKS       2
173 #define MIN_ERASE_BLOCKS        (MIN_SPARE_EBLOCKS + 1)
174
175 #define TREE_ROOT(d, name) (&d->trees[MTDSWAP_ ## name].root)
176 #define TREE_EMPTY(d, name) (TREE_ROOT(d, name)->rb_node == NULL)
177 #define TREE_NONEMPTY(d, name) (!TREE_EMPTY(d, name))
178 #define TREE_COUNT(d, name) (d->trees[MTDSWAP_ ## name].count)
179
180 #define MTDSWAP_MBD_TO_MTDSWAP(dev) ((struct mtdswap_dev *)dev->priv)
181
182 static char partitions[128] = "";
183 module_param_string(partitions, partitions, sizeof(partitions), 0444);
184 MODULE_PARM_DESC(partitions, "MTD partition numbers to use as swap "
185                 "partitions=\"1,3,5\"");
186
187 static unsigned int spare_eblocks = 10;
188 module_param(spare_eblocks, uint, 0444);
189 MODULE_PARM_DESC(spare_eblocks, "Percentage of spare erase blocks for "
190                 "garbage collection (default 10%)");
191
192 static bool header; /* false */
193 module_param(header, bool, 0444);
194 MODULE_PARM_DESC(header,
195                 "Include builtin swap header (default 0, without header)");
196
197 static int mtdswap_gc(struct mtdswap_dev *d, unsigned int background);
198
199 static loff_t mtdswap_eb_offset(struct mtdswap_dev *d, struct swap_eb *eb)
200 {
201         return (loff_t)(eb - d->eb_data) * d->mtd->erasesize;
202 }
203
204 static void mtdswap_eb_detach(struct mtdswap_dev *d, struct swap_eb *eb)
205 {
206         unsigned int oldidx;
207         struct mtdswap_tree *tp;
208
209         if (eb->root) {
210                 tp = container_of(eb->root, struct mtdswap_tree, root);
211                 oldidx = tp - &d->trees[0];
212
213                 d->trees[oldidx].count--;
214                 rb_erase(&eb->rb, eb->root);
215         }
216 }
217
218 static void __mtdswap_rb_add(struct rb_root *root, struct swap_eb *eb)
219 {
220         struct rb_node **p, *parent = NULL;
221         struct swap_eb *cur;
222
223         p = &root->rb_node;
224         while (*p) {
225                 parent = *p;
226                 cur = rb_entry(parent, struct swap_eb, rb);
227                 if (eb->erase_count > cur->erase_count)
228                         p = &(*p)->rb_right;
229                 else
230                         p = &(*p)->rb_left;
231         }
232
233         rb_link_node(&eb->rb, parent, p);
234         rb_insert_color(&eb->rb, root);
235 }
236
237 static void mtdswap_rb_add(struct mtdswap_dev *d, struct swap_eb *eb, int idx)
238 {
239         struct rb_root *root;
240
241         if (eb->root == &d->trees[idx].root)
242                 return;
243
244         mtdswap_eb_detach(d, eb);
245         root = &d->trees[idx].root;
246         __mtdswap_rb_add(root, eb);
247         eb->root = root;
248         d->trees[idx].count++;
249 }
250
251 static struct rb_node *mtdswap_rb_index(struct rb_root *root, unsigned int idx)
252 {
253         struct rb_node *p;
254         unsigned int i;
255
256         p = rb_first(root);
257         i = 0;
258         while (i < idx && p) {
259                 p = rb_next(p);
260                 i++;
261         }
262
263         return p;
264 }
265
266 static int mtdswap_handle_badblock(struct mtdswap_dev *d, struct swap_eb *eb)
267 {
268         int ret;
269         loff_t offset;
270
271         d->spare_eblks--;
272         eb->flags |= EBLOCK_BAD;
273         mtdswap_eb_detach(d, eb);
274         eb->root = NULL;
275
276         /* badblocks not supported */
277         if (!mtd_can_have_bb(d->mtd))
278                 return 1;
279
280         offset = mtdswap_eb_offset(d, eb);
281         dev_warn(d->dev, "Marking bad block at %08llx\n", offset);
282         ret = mtd_block_markbad(d->mtd, offset);
283
284         if (ret) {
285                 dev_warn(d->dev, "Mark block bad failed for block at %08llx "
286                         "error %d\n", offset, ret);
287                 return ret;
288         }
289
290         return 1;
291
292 }
293
294 static int mtdswap_handle_write_error(struct mtdswap_dev *d, struct swap_eb *eb)
295 {
296         unsigned int marked = eb->flags & EBLOCK_FAILED;
297         struct swap_eb *curr_write = d->curr_write;
298
299         eb->flags |= EBLOCK_FAILED;
300         if (curr_write == eb) {
301                 d->curr_write = NULL;
302
303                 if (!marked && d->curr_write_pos != 0) {
304                         mtdswap_rb_add(d, eb, MTDSWAP_FAILING);
305                         return 0;
306                 }
307         }
308
309         return mtdswap_handle_badblock(d, eb);
310 }
311
312 static int mtdswap_read_oob(struct mtdswap_dev *d, loff_t from,
313                         struct mtd_oob_ops *ops)
314 {
315         int ret = mtd_read_oob(d->mtd, from, ops);
316
317         if (mtd_is_bitflip(ret))
318                 return ret;
319
320         if (ret) {
321                 dev_warn(d->dev, "Read OOB failed %d for block at %08llx\n",
322                         ret, from);
323                 return ret;
324         }
325
326         if (ops->oobretlen < ops->ooblen) {
327                 dev_warn(d->dev, "Read OOB return short read (%zd bytes not "
328                         "%zd) for block at %08llx\n",
329                         ops->oobretlen, ops->ooblen, from);
330                 return -EIO;
331         }
332
333         return 0;
334 }
335
336 static int mtdswap_read_markers(struct mtdswap_dev *d, struct swap_eb *eb)
337 {
338         struct mtdswap_oobdata *data, *data2;
339         int ret;
340         loff_t offset;
341         struct mtd_oob_ops ops;
342
343         offset = mtdswap_eb_offset(d, eb);
344
345         /* Check first if the block is bad. */
346         if (mtd_can_have_bb(d->mtd) && mtd_block_isbad(d->mtd, offset))
347                 return MTDSWAP_SCANNED_BAD;
348
349         ops.ooblen = 2 * d->mtd->ecclayout->oobavail;
350         ops.oobbuf = d->oob_buf;
351         ops.ooboffs = 0;
352         ops.datbuf = NULL;
353         ops.mode = MTD_OPS_AUTO_OOB;
354
355         ret = mtdswap_read_oob(d, offset, &ops);
356
357         if (ret && !mtd_is_bitflip(ret))
358                 return ret;
359
360         data = (struct mtdswap_oobdata *)d->oob_buf;
361         data2 = (struct mtdswap_oobdata *)
362                 (d->oob_buf + d->mtd->ecclayout->oobavail);
363
364         if (le16_to_cpu(data->magic) == MTDSWAP_MAGIC_CLEAN) {
365                 eb->erase_count = le32_to_cpu(data->count);
366                 if (mtd_is_bitflip(ret))
367                         ret = MTDSWAP_SCANNED_BITFLIP;
368                 else {
369                         if (le16_to_cpu(data2->magic) == MTDSWAP_MAGIC_DIRTY)
370                                 ret = MTDSWAP_SCANNED_DIRTY;
371                         else
372                                 ret = MTDSWAP_SCANNED_CLEAN;
373                 }
374         } else {
375                 eb->flags |= EBLOCK_NOMAGIC;
376                 ret = MTDSWAP_SCANNED_DIRTY;
377         }
378
379         return ret;
380 }
381
382 static int mtdswap_write_marker(struct mtdswap_dev *d, struct swap_eb *eb,
383                                 u16 marker)
384 {
385         struct mtdswap_oobdata n;
386         int ret;
387         loff_t offset;
388         struct mtd_oob_ops ops;
389
390         ops.ooboffs = 0;
391         ops.oobbuf = (uint8_t *)&n;
392         ops.mode = MTD_OPS_AUTO_OOB;
393         ops.datbuf = NULL;
394
395         if (marker == MTDSWAP_TYPE_CLEAN) {
396                 n.magic = cpu_to_le16(MTDSWAP_MAGIC_CLEAN);
397                 n.count = cpu_to_le32(eb->erase_count);
398                 ops.ooblen = MTDSWAP_OOBSIZE;
399                 offset = mtdswap_eb_offset(d, eb);
400         } else {
401                 n.magic = cpu_to_le16(MTDSWAP_MAGIC_DIRTY);
402                 ops.ooblen = sizeof(n.magic);
403                 offset = mtdswap_eb_offset(d, eb) + d->mtd->writesize;
404         }
405
406         ret = mtd_write_oob(d->mtd, offset, &ops);
407
408         if (ret) {
409                 dev_warn(d->dev, "Write OOB failed for block at %08llx "
410                         "error %d\n", offset, ret);
411                 if (ret == -EIO || mtd_is_eccerr(ret))
412                         mtdswap_handle_write_error(d, eb);
413                 return ret;
414         }
415
416         if (ops.oobretlen != ops.ooblen) {
417                 dev_warn(d->dev, "Short OOB write for block at %08llx: "
418                         "%zd not %zd\n",
419                         offset, ops.oobretlen, ops.ooblen);
420                 return ret;
421         }
422
423         return 0;
424 }
425
426 /*
427  * Are there any erase blocks without MAGIC_CLEAN header, presumably
428  * because power was cut off after erase but before header write? We
429  * need to guestimate the erase count.
430  */
431 static void mtdswap_check_counts(struct mtdswap_dev *d)
432 {
433         struct rb_root hist_root = RB_ROOT;
434         struct rb_node *medrb;
435         struct swap_eb *eb;
436         unsigned int i, cnt, median;
437
438         cnt = 0;
439         for (i = 0; i < d->eblks; i++) {
440                 eb = d->eb_data + i;
441
442                 if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_BAD | EBLOCK_READERR))
443                         continue;
444
445                 __mtdswap_rb_add(&hist_root, eb);
446                 cnt++;
447         }
448
449         if (cnt == 0)
450                 return;
451
452         medrb = mtdswap_rb_index(&hist_root, cnt / 2);
453         median = rb_entry(medrb, struct swap_eb, rb)->erase_count;
454
455         d->max_erase_count = MTDSWAP_ECNT_MAX(&hist_root);
456
457         for (i = 0; i < d->eblks; i++) {
458                 eb = d->eb_data + i;
459
460                 if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_READERR))
461                         eb->erase_count = median;
462
463                 if (eb->flags & (EBLOCK_NOMAGIC | EBLOCK_BAD | EBLOCK_READERR))
464                         continue;
465
466                 rb_erase(&eb->rb, &hist_root);
467         }
468 }
469
470 static void mtdswap_scan_eblks(struct mtdswap_dev *d)
471 {
472         int status;
473         unsigned int i, idx;
474         struct swap_eb *eb;
475
476         for (i = 0; i < d->eblks; i++) {
477                 eb = d->eb_data + i;
478
479                 status = mtdswap_read_markers(d, eb);
480                 if (status < 0)
481                         eb->flags |= EBLOCK_READERR;
482                 else if (status == MTDSWAP_SCANNED_BAD) {
483                         eb->flags |= EBLOCK_BAD;
484                         continue;
485                 }
486
487                 switch (status) {
488                 case MTDSWAP_SCANNED_CLEAN:
489                         idx = MTDSWAP_CLEAN;
490                         break;
491                 case MTDSWAP_SCANNED_DIRTY:
492                 case MTDSWAP_SCANNED_BITFLIP:
493                         idx = MTDSWAP_DIRTY;
494                         break;
495                 default:
496                         idx = MTDSWAP_FAILING;
497                 }
498
499                 eb->flags |= (idx << EBLOCK_IDX_SHIFT);
500         }
501
502         mtdswap_check_counts(d);
503
504         for (i = 0; i < d->eblks; i++) {
505                 eb = d->eb_data + i;
506
507                 if (eb->flags & EBLOCK_BAD)
508                         continue;
509
510                 idx = eb->flags >> EBLOCK_IDX_SHIFT;
511                 mtdswap_rb_add(d, eb, idx);
512         }
513 }
514
515 /*
516  * Place eblk into a tree corresponding to its number of active blocks
517  * it contains.
518  */
519 static void mtdswap_store_eb(struct mtdswap_dev *d, struct swap_eb *eb)
520 {
521         unsigned int weight = eb->active_count;
522         unsigned int maxweight = d->pages_per_eblk;
523
524         if (eb == d->curr_write)
525                 return;
526
527         if (eb->flags & EBLOCK_BITFLIP)
528                 mtdswap_rb_add(d, eb, MTDSWAP_BITFLIP);
529         else if (eb->flags & (EBLOCK_READERR | EBLOCK_FAILED))
530                 mtdswap_rb_add(d, eb, MTDSWAP_FAILING);
531         if (weight == maxweight)
532                 mtdswap_rb_add(d, eb, MTDSWAP_USED);
533         else if (weight == 0)
534                 mtdswap_rb_add(d, eb, MTDSWAP_DIRTY);
535         else if (weight > (maxweight/2))
536                 mtdswap_rb_add(d, eb, MTDSWAP_LOWFRAG);
537         else
538                 mtdswap_rb_add(d, eb, MTDSWAP_HIFRAG);
539 }
540
541
542 static void mtdswap_erase_callback(struct erase_info *done)
543 {
544         wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
545         wake_up(wait_q);
546 }
547
548 static int mtdswap_erase_block(struct mtdswap_dev *d, struct swap_eb *eb)
549 {
550         struct mtd_info *mtd = d->mtd;
551         struct erase_info erase;
552         wait_queue_head_t wq;
553         unsigned int retries = 0;
554         int ret;
555
556         eb->erase_count++;
557         if (eb->erase_count > d->max_erase_count)
558                 d->max_erase_count = eb->erase_count;
559
560 retry:
561         init_waitqueue_head(&wq);
562         memset(&erase, 0, sizeof(struct erase_info));
563
564         erase.mtd       = mtd;
565         erase.callback  = mtdswap_erase_callback;
566         erase.addr      = mtdswap_eb_offset(d, eb);
567         erase.len       = mtd->erasesize;
568         erase.priv      = (u_long)&wq;
569
570         ret = mtd_erase(mtd, &erase);
571         if (ret) {
572                 if (retries++ < MTDSWAP_ERASE_RETRIES) {
573                         dev_warn(d->dev,
574                                 "erase of erase block %#llx on %s failed",
575                                 erase.addr, mtd->name);
576                         yield();
577                         goto retry;
578                 }
579
580                 dev_err(d->dev, "Cannot erase erase block %#llx on %s\n",
581                         erase.addr, mtd->name);
582
583                 mtdswap_handle_badblock(d, eb);
584                 return -EIO;
585         }
586
587         ret = wait_event_interruptible(wq, erase.state == MTD_ERASE_DONE ||
588                                            erase.state == MTD_ERASE_FAILED);
589         if (ret) {
590                 dev_err(d->dev, "Interrupted erase block %#llx erassure on %s",
591                         erase.addr, mtd->name);
592                 return -EINTR;
593         }
594
595         if (erase.state == MTD_ERASE_FAILED) {
596                 if (retries++ < MTDSWAP_ERASE_RETRIES) {
597                         dev_warn(d->dev,
598                                 "erase of erase block %#llx on %s failed",
599                                 erase.addr, mtd->name);
600                         yield();
601                         goto retry;
602                 }
603
604                 mtdswap_handle_badblock(d, eb);
605                 return -EIO;
606         }
607
608         return 0;
609 }
610
611 static int mtdswap_map_free_block(struct mtdswap_dev *d, unsigned int page,
612                                 unsigned int *block)
613 {
614         int ret;
615         struct swap_eb *old_eb = d->curr_write;
616         struct rb_root *clean_root;
617         struct swap_eb *eb;
618
619         if (old_eb == NULL || d->curr_write_pos >= d->pages_per_eblk) {
620                 do {
621                         if (TREE_EMPTY(d, CLEAN))
622                                 return -ENOSPC;
623
624                         clean_root = TREE_ROOT(d, CLEAN);
625                         eb = rb_entry(rb_first(clean_root), struct swap_eb, rb);
626                         rb_erase(&eb->rb, clean_root);
627                         eb->root = NULL;
628                         TREE_COUNT(d, CLEAN)--;
629
630                         ret = mtdswap_write_marker(d, eb, MTDSWAP_TYPE_DIRTY);
631                 } while (ret == -EIO || mtd_is_eccerr(ret));
632
633                 if (ret)
634                         return ret;
635
636                 d->curr_write_pos = 0;
637                 d->curr_write = eb;
638                 if (old_eb)
639                         mtdswap_store_eb(d, old_eb);
640         }
641
642         *block = (d->curr_write - d->eb_data) * d->pages_per_eblk +
643                 d->curr_write_pos;
644
645         d->curr_write->active_count++;
646         d->revmap[*block] = page;
647         d->curr_write_pos++;
648
649         return 0;
650 }
651
652 static unsigned int mtdswap_free_page_cnt(struct mtdswap_dev *d)
653 {
654         return TREE_COUNT(d, CLEAN) * d->pages_per_eblk +
655                 d->pages_per_eblk - d->curr_write_pos;
656 }
657
658 static unsigned int mtdswap_enough_free_pages(struct mtdswap_dev *d)
659 {
660         return mtdswap_free_page_cnt(d) > d->pages_per_eblk;
661 }
662
663 static int mtdswap_write_block(struct mtdswap_dev *d, char *buf,
664                         unsigned int page, unsigned int *bp, int gc_context)
665 {
666         struct mtd_info *mtd = d->mtd;
667         struct swap_eb *eb;
668         size_t retlen;
669         loff_t writepos;
670         int ret;
671
672 retry:
673         if (!gc_context)
674                 while (!mtdswap_enough_free_pages(d))
675                         if (mtdswap_gc(d, 0) > 0)
676                                 return -ENOSPC;
677
678         ret = mtdswap_map_free_block(d, page, bp);
679         eb = d->eb_data + (*bp / d->pages_per_eblk);
680
681         if (ret == -EIO || mtd_is_eccerr(ret)) {
682                 d->curr_write = NULL;
683                 eb->active_count--;
684                 d->revmap[*bp] = PAGE_UNDEF;
685                 goto retry;
686         }
687
688         if (ret < 0)
689                 return ret;
690
691         writepos = (loff_t)*bp << PAGE_SHIFT;
692         ret =  mtd_write(mtd, writepos, PAGE_SIZE, &retlen, buf);
693         if (ret == -EIO || mtd_is_eccerr(ret)) {
694                 d->curr_write_pos--;
695                 eb->active_count--;
696                 d->revmap[*bp] = PAGE_UNDEF;
697                 mtdswap_handle_write_error(d, eb);
698                 goto retry;
699         }
700
701         if (ret < 0) {
702                 dev_err(d->dev, "Write to MTD device failed: %d (%zd written)",
703                         ret, retlen);
704                 goto err;
705         }
706
707         if (retlen != PAGE_SIZE) {
708                 dev_err(d->dev, "Short write to MTD device: %zd written",
709                         retlen);
710                 ret = -EIO;
711                 goto err;
712         }
713
714         return ret;
715
716 err:
717         d->curr_write_pos--;
718         eb->active_count--;
719         d->revmap[*bp] = PAGE_UNDEF;
720
721         return ret;
722 }
723
724 static int mtdswap_move_block(struct mtdswap_dev *d, unsigned int oldblock,
725                 unsigned int *newblock)
726 {
727         struct mtd_info *mtd = d->mtd;
728         struct swap_eb *eb, *oldeb;
729         int ret;
730         size_t retlen;
731         unsigned int page, retries;
732         loff_t readpos;
733
734         page = d->revmap[oldblock];
735         readpos = (loff_t) oldblock << PAGE_SHIFT;
736         retries = 0;
737
738 retry:
739         ret = mtd_read(mtd, readpos, PAGE_SIZE, &retlen, d->page_buf);
740
741         if (ret < 0 && !mtd_is_bitflip(ret)) {
742                 oldeb = d->eb_data + oldblock / d->pages_per_eblk;
743                 oldeb->flags |= EBLOCK_READERR;
744
745                 dev_err(d->dev, "Read Error: %d (block %u)\n", ret,
746                         oldblock);
747                 retries++;
748                 if (retries < MTDSWAP_IO_RETRIES)
749                         goto retry;
750
751                 goto read_error;
752         }
753
754         if (retlen != PAGE_SIZE) {
755                 dev_err(d->dev, "Short read: %zd (block %u)\n", retlen,
756                        oldblock);
757                 ret = -EIO;
758                 goto read_error;
759         }
760
761         ret = mtdswap_write_block(d, d->page_buf, page, newblock, 1);
762         if (ret < 0) {
763                 d->page_data[page] = BLOCK_ERROR;
764                 dev_err(d->dev, "Write error: %d\n", ret);
765                 return ret;
766         }
767
768         eb = d->eb_data + *newblock / d->pages_per_eblk;
769         d->page_data[page] = *newblock;
770         d->revmap[oldblock] = PAGE_UNDEF;
771         eb = d->eb_data + oldblock / d->pages_per_eblk;
772         eb->active_count--;
773
774         return 0;
775
776 read_error:
777         d->page_data[page] = BLOCK_ERROR;
778         d->revmap[oldblock] = PAGE_UNDEF;
779         return ret;
780 }
781
782 static int mtdswap_gc_eblock(struct mtdswap_dev *d, struct swap_eb *eb)
783 {
784         unsigned int i, block, eblk_base, newblock;
785         int ret, errcode;
786
787         errcode = 0;
788         eblk_base = (eb - d->eb_data) * d->pages_per_eblk;
789
790         for (i = 0; i < d->pages_per_eblk; i++) {
791                 if (d->spare_eblks < MIN_SPARE_EBLOCKS)
792                         return -ENOSPC;
793
794                 block = eblk_base + i;
795                 if (d->revmap[block] == PAGE_UNDEF)
796                         continue;
797
798                 ret = mtdswap_move_block(d, block, &newblock);
799                 if (ret < 0 && !errcode)
800                         errcode = ret;
801         }
802
803         return errcode;
804 }
805
806 static int __mtdswap_choose_gc_tree(struct mtdswap_dev *d)
807 {
808         int idx, stopat;
809
810         if (TREE_COUNT(d, CLEAN) < LOW_FRAG_GC_TRESHOLD)
811                 stopat = MTDSWAP_LOWFRAG;
812         else
813                 stopat = MTDSWAP_HIFRAG;
814
815         for (idx = MTDSWAP_BITFLIP; idx >= stopat; idx--)
816                 if (d->trees[idx].root.rb_node != NULL)
817                         return idx;
818
819         return -1;
820 }
821
822 static int mtdswap_wlfreq(unsigned int maxdiff)
823 {
824         unsigned int h, x, y, dist, base;
825
826         /*
827          * Calculate linear ramp down from f1 to f2 when maxdiff goes from
828          * MAX_ERASE_DIFF to MAX_ERASE_DIFF + COLLECT_NONDIRTY_BASE.  Similar
829          * to triangle with height f1 - f1 and width COLLECT_NONDIRTY_BASE.
830          */
831
832         dist = maxdiff - MAX_ERASE_DIFF;
833         if (dist > COLLECT_NONDIRTY_BASE)
834                 dist = COLLECT_NONDIRTY_BASE;
835
836         /*
837          * Modelling the slop as right angular triangle with base
838          * COLLECT_NONDIRTY_BASE and height freq1 - freq2. The ratio y/x is
839          * equal to the ratio h/base.
840          */
841         h = COLLECT_NONDIRTY_FREQ1 - COLLECT_NONDIRTY_FREQ2;
842         base = COLLECT_NONDIRTY_BASE;
843
844         x = dist - base;
845         y = (x * h + base / 2) / base;
846
847         return COLLECT_NONDIRTY_FREQ2 + y;
848 }
849
850 static int mtdswap_choose_wl_tree(struct mtdswap_dev *d)
851 {
852         static unsigned int pick_cnt;
853         unsigned int i, idx = -1, wear, max;
854         struct rb_root *root;
855
856         max = 0;
857         for (i = 0; i <= MTDSWAP_DIRTY; i++) {
858                 root = &d->trees[i].root;
859                 if (root->rb_node == NULL)
860                         continue;
861
862                 wear = d->max_erase_count - MTDSWAP_ECNT_MIN(root);
863                 if (wear > max) {
864                         max = wear;
865                         idx = i;
866                 }
867         }
868
869         if (max > MAX_ERASE_DIFF && pick_cnt >= mtdswap_wlfreq(max) - 1) {
870                 pick_cnt = 0;
871                 return idx;
872         }
873
874         pick_cnt++;
875         return -1;
876 }
877
878 static int mtdswap_choose_gc_tree(struct mtdswap_dev *d,
879                                 unsigned int background)
880 {
881         int idx;
882
883         if (TREE_NONEMPTY(d, FAILING) &&
884                 (background || (TREE_EMPTY(d, CLEAN) && TREE_EMPTY(d, DIRTY))))
885                 return MTDSWAP_FAILING;
886
887         idx = mtdswap_choose_wl_tree(d);
888         if (idx >= MTDSWAP_CLEAN)
889                 return idx;
890
891         return __mtdswap_choose_gc_tree(d);
892 }
893
894 static struct swap_eb *mtdswap_pick_gc_eblk(struct mtdswap_dev *d,
895                                         unsigned int background)
896 {
897         struct rb_root *rp = NULL;
898         struct swap_eb *eb = NULL;
899         int idx;
900
901         if (background && TREE_COUNT(d, CLEAN) > CLEAN_BLOCK_THRESHOLD &&
902                 TREE_EMPTY(d, DIRTY) && TREE_EMPTY(d, FAILING))
903                 return NULL;
904
905         idx = mtdswap_choose_gc_tree(d, background);
906         if (idx < 0)
907                 return NULL;
908
909         rp = &d->trees[idx].root;
910         eb = rb_entry(rb_first(rp), struct swap_eb, rb);
911
912         rb_erase(&eb->rb, rp);
913         eb->root = NULL;
914         d->trees[idx].count--;
915         return eb;
916 }
917
918 static unsigned int mtdswap_test_patt(unsigned int i)
919 {
920         return i % 2 ? 0x55555555 : 0xAAAAAAAA;
921 }
922
923 static unsigned int mtdswap_eblk_passes(struct mtdswap_dev *d,
924                                         struct swap_eb *eb)
925 {
926         struct mtd_info *mtd = d->mtd;
927         unsigned int test, i, j, patt, mtd_pages;
928         loff_t base, pos;
929         unsigned int *p1 = (unsigned int *)d->page_buf;
930         unsigned char *p2 = (unsigned char *)d->oob_buf;
931         struct mtd_oob_ops ops;
932         int ret;
933
934         ops.mode = MTD_OPS_AUTO_OOB;
935         ops.len = mtd->writesize;
936         ops.ooblen = mtd->ecclayout->oobavail;
937         ops.ooboffs = 0;
938         ops.datbuf = d->page_buf;
939         ops.oobbuf = d->oob_buf;
940         base = mtdswap_eb_offset(d, eb);
941         mtd_pages = d->pages_per_eblk * PAGE_SIZE / mtd->writesize;
942
943         for (test = 0; test < 2; test++) {
944                 pos = base;
945                 for (i = 0; i < mtd_pages; i++) {
946                         patt = mtdswap_test_patt(test + i);
947                         memset(d->page_buf, patt, mtd->writesize);
948                         memset(d->oob_buf, patt, mtd->ecclayout->oobavail);
949                         ret = mtd_write_oob(mtd, pos, &ops);
950                         if (ret)
951                                 goto error;
952
953                         pos += mtd->writesize;
954                 }
955
956                 pos = base;
957                 for (i = 0; i < mtd_pages; i++) {
958                         ret = mtd_read_oob(mtd, pos, &ops);
959                         if (ret)
960                                 goto error;
961
962                         patt = mtdswap_test_patt(test + i);
963                         for (j = 0; j < mtd->writesize/sizeof(int); j++)
964                                 if (p1[j] != patt)
965                                         goto error;
966
967                         for (j = 0; j < mtd->ecclayout->oobavail; j++)
968                                 if (p2[j] != (unsigned char)patt)
969                                         goto error;
970
971                         pos += mtd->writesize;
972                 }
973
974                 ret = mtdswap_erase_block(d, eb);
975                 if (ret)
976                         goto error;
977         }
978
979         eb->flags &= ~EBLOCK_READERR;
980         return 1;
981
982 error:
983         mtdswap_handle_badblock(d, eb);
984         return 0;
985 }
986
987 static int mtdswap_gc(struct mtdswap_dev *d, unsigned int background)
988 {
989         struct swap_eb *eb;
990         int ret;
991
992         if (d->spare_eblks < MIN_SPARE_EBLOCKS)
993                 return 1;
994
995         eb = mtdswap_pick_gc_eblk(d, background);
996         if (!eb)
997                 return 1;
998
999         ret = mtdswap_gc_eblock(d, eb);
1000         if (ret == -ENOSPC)
1001                 return 1;
1002
1003         if (eb->flags & EBLOCK_FAILED) {
1004                 mtdswap_handle_badblock(d, eb);
1005                 return 0;
1006         }
1007
1008         eb->flags &= ~EBLOCK_BITFLIP;
1009         ret = mtdswap_erase_block(d, eb);
1010         if ((eb->flags & EBLOCK_READERR) &&
1011                 (ret || !mtdswap_eblk_passes(d, eb)))
1012                 return 0;
1013
1014         if (ret == 0)
1015                 ret = mtdswap_write_marker(d, eb, MTDSWAP_TYPE_CLEAN);
1016
1017         if (ret == 0)
1018                 mtdswap_rb_add(d, eb, MTDSWAP_CLEAN);
1019         else if (ret != -EIO && !mtd_is_eccerr(ret))
1020                 mtdswap_rb_add(d, eb, MTDSWAP_DIRTY);
1021
1022         return 0;
1023 }
1024
1025 static void mtdswap_background(struct mtd_blktrans_dev *dev)
1026 {
1027         struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1028         int ret;
1029
1030         while (1) {
1031                 ret = mtdswap_gc(d, 1);
1032                 if (ret || mtd_blktrans_cease_background(dev))
1033                         return;
1034         }
1035 }
1036
1037 static void mtdswap_cleanup(struct mtdswap_dev *d)
1038 {
1039         vfree(d->eb_data);
1040         vfree(d->revmap);
1041         vfree(d->page_data);
1042         kfree(d->oob_buf);
1043         kfree(d->page_buf);
1044 }
1045
1046 static int mtdswap_flush(struct mtd_blktrans_dev *dev)
1047 {
1048         struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1049
1050         mtd_sync(d->mtd);
1051         return 0;
1052 }
1053
1054 static unsigned int mtdswap_badblocks(struct mtd_info *mtd, uint64_t size)
1055 {
1056         loff_t offset;
1057         unsigned int badcnt;
1058
1059         badcnt = 0;
1060
1061         if (mtd_can_have_bb(mtd))
1062                 for (offset = 0; offset < size; offset += mtd->erasesize)
1063                         if (mtd_block_isbad(mtd, offset))
1064                                 badcnt++;
1065
1066         return badcnt;
1067 }
1068
1069 static int mtdswap_writesect(struct mtd_blktrans_dev *dev,
1070                         unsigned long page, char *buf)
1071 {
1072         struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1073         unsigned int newblock, mapped;
1074         struct swap_eb *eb;
1075         int ret;
1076
1077         d->sect_write_count++;
1078
1079         if (d->spare_eblks < MIN_SPARE_EBLOCKS)
1080                 return -ENOSPC;
1081
1082         if (header) {
1083                 /* Ignore writes to the header page */
1084                 if (unlikely(page == 0))
1085                         return 0;
1086
1087                 page--;
1088         }
1089
1090         mapped = d->page_data[page];
1091         if (mapped <= BLOCK_MAX) {
1092                 eb = d->eb_data + (mapped / d->pages_per_eblk);
1093                 eb->active_count--;
1094                 mtdswap_store_eb(d, eb);
1095                 d->page_data[page] = BLOCK_UNDEF;
1096                 d->revmap[mapped] = PAGE_UNDEF;
1097         }
1098
1099         ret = mtdswap_write_block(d, buf, page, &newblock, 0);
1100         d->mtd_write_count++;
1101
1102         if (ret < 0)
1103                 return ret;
1104
1105         eb = d->eb_data + (newblock / d->pages_per_eblk);
1106         d->page_data[page] = newblock;
1107
1108         return 0;
1109 }
1110
1111 /* Provide a dummy swap header for the kernel */
1112 static int mtdswap_auto_header(struct mtdswap_dev *d, char *buf)
1113 {
1114         union swap_header *hd = (union swap_header *)(buf);
1115
1116         memset(buf, 0, PAGE_SIZE - 10);
1117
1118         hd->info.version = 1;
1119         hd->info.last_page = d->mbd_dev->size - 1;
1120         hd->info.nr_badpages = 0;
1121
1122         memcpy(buf + PAGE_SIZE - 10, "SWAPSPACE2", 10);
1123
1124         return 0;
1125 }
1126
1127 static int mtdswap_readsect(struct mtd_blktrans_dev *dev,
1128                         unsigned long page, char *buf)
1129 {
1130         struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1131         struct mtd_info *mtd = d->mtd;
1132         unsigned int realblock, retries;
1133         loff_t readpos;
1134         struct swap_eb *eb;
1135         size_t retlen;
1136         int ret;
1137
1138         d->sect_read_count++;
1139
1140         if (header) {
1141                 if (unlikely(page == 0))
1142                         return mtdswap_auto_header(d, buf);
1143
1144                 page--;
1145         }
1146
1147         realblock = d->page_data[page];
1148         if (realblock > BLOCK_MAX) {
1149                 memset(buf, 0x0, PAGE_SIZE);
1150                 if (realblock == BLOCK_UNDEF)
1151                         return 0;
1152                 else
1153                         return -EIO;
1154         }
1155
1156         eb = d->eb_data + (realblock / d->pages_per_eblk);
1157         BUG_ON(d->revmap[realblock] == PAGE_UNDEF);
1158
1159         readpos = (loff_t)realblock << PAGE_SHIFT;
1160         retries = 0;
1161
1162 retry:
1163         ret = mtd_read(mtd, readpos, PAGE_SIZE, &retlen, buf);
1164
1165         d->mtd_read_count++;
1166         if (mtd_is_bitflip(ret)) {
1167                 eb->flags |= EBLOCK_BITFLIP;
1168                 mtdswap_rb_add(d, eb, MTDSWAP_BITFLIP);
1169                 ret = 0;
1170         }
1171
1172         if (ret < 0) {
1173                 dev_err(d->dev, "Read error %d\n", ret);
1174                 eb->flags |= EBLOCK_READERR;
1175                 mtdswap_rb_add(d, eb, MTDSWAP_FAILING);
1176                 retries++;
1177                 if (retries < MTDSWAP_IO_RETRIES)
1178                         goto retry;
1179
1180                 return ret;
1181         }
1182
1183         if (retlen != PAGE_SIZE) {
1184                 dev_err(d->dev, "Short read %zd\n", retlen);
1185                 return -EIO;
1186         }
1187
1188         return 0;
1189 }
1190
1191 static int mtdswap_discard(struct mtd_blktrans_dev *dev, unsigned long first,
1192                         unsigned nr_pages)
1193 {
1194         struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1195         unsigned long page;
1196         struct swap_eb *eb;
1197         unsigned int mapped;
1198
1199         d->discard_count++;
1200
1201         for (page = first; page < first + nr_pages; page++) {
1202                 mapped = d->page_data[page];
1203                 if (mapped <= BLOCK_MAX) {
1204                         eb = d->eb_data + (mapped / d->pages_per_eblk);
1205                         eb->active_count--;
1206                         mtdswap_store_eb(d, eb);
1207                         d->page_data[page] = BLOCK_UNDEF;
1208                         d->revmap[mapped] = PAGE_UNDEF;
1209                         d->discard_page_count++;
1210                 } else if (mapped == BLOCK_ERROR) {
1211                         d->page_data[page] = BLOCK_UNDEF;
1212                         d->discard_page_count++;
1213                 }
1214         }
1215
1216         return 0;
1217 }
1218
1219 static int mtdswap_show(struct seq_file *s, void *data)
1220 {
1221         struct mtdswap_dev *d = (struct mtdswap_dev *) s->private;
1222         unsigned long sum;
1223         unsigned int count[MTDSWAP_TREE_CNT];
1224         unsigned int min[MTDSWAP_TREE_CNT];
1225         unsigned int max[MTDSWAP_TREE_CNT];
1226         unsigned int i, cw = 0, cwp = 0, cwecount = 0, bb_cnt, mapped, pages;
1227         uint64_t use_size;
1228         char *name[] = {"clean", "used", "low", "high", "dirty", "bitflip",
1229                         "failing"};
1230
1231         mutex_lock(&d->mbd_dev->lock);
1232
1233         for (i = 0; i < MTDSWAP_TREE_CNT; i++) {
1234                 struct rb_root *root = &d->trees[i].root;
1235
1236                 if (root->rb_node) {
1237                         count[i] = d->trees[i].count;
1238                         min[i] = rb_entry(rb_first(root), struct swap_eb,
1239                                         rb)->erase_count;
1240                         max[i] = rb_entry(rb_last(root), struct swap_eb,
1241                                         rb)->erase_count;
1242                 } else
1243                         count[i] = 0;
1244         }
1245
1246         if (d->curr_write) {
1247                 cw = 1;
1248                 cwp = d->curr_write_pos;
1249                 cwecount = d->curr_write->erase_count;
1250         }
1251
1252         sum = 0;
1253         for (i = 0; i < d->eblks; i++)
1254                 sum += d->eb_data[i].erase_count;
1255
1256         use_size = (uint64_t)d->eblks * d->mtd->erasesize;
1257         bb_cnt = mtdswap_badblocks(d->mtd, use_size);
1258
1259         mapped = 0;
1260         pages = d->mbd_dev->size;
1261         for (i = 0; i < pages; i++)
1262                 if (d->page_data[i] != BLOCK_UNDEF)
1263                         mapped++;
1264
1265         mutex_unlock(&d->mbd_dev->lock);
1266
1267         for (i = 0; i < MTDSWAP_TREE_CNT; i++) {
1268                 if (!count[i])
1269                         continue;
1270
1271                 if (min[i] != max[i])
1272                         seq_printf(s, "%s:\t%5d erase blocks, erased min %d, "
1273                                 "max %d times\n",
1274                                 name[i], count[i], min[i], max[i]);
1275                 else
1276                         seq_printf(s, "%s:\t%5d erase blocks, all erased %d "
1277                                 "times\n", name[i], count[i], min[i]);
1278         }
1279
1280         if (bb_cnt)
1281                 seq_printf(s, "bad:\t%5u erase blocks\n", bb_cnt);
1282
1283         if (cw)
1284                 seq_printf(s, "current erase block: %u pages used, %u free, "
1285                         "erased %u times\n",
1286                         cwp, d->pages_per_eblk - cwp, cwecount);
1287
1288         seq_printf(s, "total erasures: %lu\n", sum);
1289
1290         seq_puts(s, "\n");
1291
1292         seq_printf(s, "mtdswap_readsect count: %llu\n", d->sect_read_count);
1293         seq_printf(s, "mtdswap_writesect count: %llu\n", d->sect_write_count);
1294         seq_printf(s, "mtdswap_discard count: %llu\n", d->discard_count);
1295         seq_printf(s, "mtd read count: %llu\n", d->mtd_read_count);
1296         seq_printf(s, "mtd write count: %llu\n", d->mtd_write_count);
1297         seq_printf(s, "discarded pages count: %llu\n", d->discard_page_count);
1298
1299         seq_puts(s, "\n");
1300         seq_printf(s, "total pages: %u\n", pages);
1301         seq_printf(s, "pages mapped: %u\n", mapped);
1302
1303         return 0;
1304 }
1305
1306 static int mtdswap_open(struct inode *inode, struct file *file)
1307 {
1308         return single_open(file, mtdswap_show, inode->i_private);
1309 }
1310
1311 static const struct file_operations mtdswap_fops = {
1312         .open           = mtdswap_open,
1313         .read           = seq_read,
1314         .llseek         = seq_lseek,
1315         .release        = single_release,
1316 };
1317
1318 static int mtdswap_add_debugfs(struct mtdswap_dev *d)
1319 {
1320         struct gendisk *gd = d->mbd_dev->disk;
1321         struct device *dev = disk_to_dev(gd);
1322
1323         struct dentry *root;
1324         struct dentry *dent;
1325
1326         root = debugfs_create_dir(gd->disk_name, NULL);
1327         if (IS_ERR(root))
1328                 return 0;
1329
1330         if (!root) {
1331                 dev_err(dev, "failed to initialize debugfs\n");
1332                 return -1;
1333         }
1334
1335         d->debugfs_root = root;
1336
1337         dent = debugfs_create_file("stats", S_IRUSR, root, d,
1338                                 &mtdswap_fops);
1339         if (!dent) {
1340                 dev_err(d->dev, "debugfs_create_file failed\n");
1341                 debugfs_remove_recursive(root);
1342                 d->debugfs_root = NULL;
1343                 return -1;
1344         }
1345
1346         return 0;
1347 }
1348
1349 static int mtdswap_init(struct mtdswap_dev *d, unsigned int eblocks,
1350                         unsigned int spare_cnt)
1351 {
1352         struct mtd_info *mtd = d->mbd_dev->mtd;
1353         unsigned int i, eblk_bytes, pages, blocks;
1354         int ret = -ENOMEM;
1355
1356         d->mtd = mtd;
1357         d->eblks = eblocks;
1358         d->spare_eblks = spare_cnt;
1359         d->pages_per_eblk = mtd->erasesize >> PAGE_SHIFT;
1360
1361         pages = d->mbd_dev->size;
1362         blocks = eblocks * d->pages_per_eblk;
1363
1364         for (i = 0; i < MTDSWAP_TREE_CNT; i++)
1365                 d->trees[i].root = RB_ROOT;
1366
1367         d->page_data = vmalloc(sizeof(int)*pages);
1368         if (!d->page_data)
1369                 goto page_data_fail;
1370
1371         d->revmap = vmalloc(sizeof(int)*blocks);
1372         if (!d->revmap)
1373                 goto revmap_fail;
1374
1375         eblk_bytes = sizeof(struct swap_eb)*d->eblks;
1376         d->eb_data = vzalloc(eblk_bytes);
1377         if (!d->eb_data)
1378                 goto eb_data_fail;
1379
1380         for (i = 0; i < pages; i++)
1381                 d->page_data[i] = BLOCK_UNDEF;
1382
1383         for (i = 0; i < blocks; i++)
1384                 d->revmap[i] = PAGE_UNDEF;
1385
1386         d->page_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
1387         if (!d->page_buf)
1388                 goto page_buf_fail;
1389
1390         d->oob_buf = kmalloc(2 * mtd->ecclayout->oobavail, GFP_KERNEL);
1391         if (!d->oob_buf)
1392                 goto oob_buf_fail;
1393
1394         mtdswap_scan_eblks(d);
1395
1396         return 0;
1397
1398 oob_buf_fail:
1399         kfree(d->page_buf);
1400 page_buf_fail:
1401         vfree(d->eb_data);
1402 eb_data_fail:
1403         vfree(d->revmap);
1404 revmap_fail:
1405         vfree(d->page_data);
1406 page_data_fail:
1407         printk(KERN_ERR "%s: init failed (%d)\n", MTDSWAP_PREFIX, ret);
1408         return ret;
1409 }
1410
1411 static void mtdswap_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
1412 {
1413         struct mtdswap_dev *d;
1414         struct mtd_blktrans_dev *mbd_dev;
1415         char *parts;
1416         char *this_opt;
1417         unsigned long part;
1418         unsigned int eblocks, eavailable, bad_blocks, spare_cnt;
1419         uint64_t swap_size, use_size, size_limit;
1420         struct nand_ecclayout *oinfo;
1421         int ret;
1422
1423         parts = &partitions[0];
1424         if (!*parts)
1425                 return;
1426
1427         while ((this_opt = strsep(&parts, ",")) != NULL) {
1428                 if (kstrtoul(this_opt, 0, &part) < 0)
1429                         return;
1430
1431                 if (mtd->index == part)
1432                         break;
1433         }
1434
1435         if (mtd->index != part)
1436                 return;
1437
1438         if (mtd->erasesize < PAGE_SIZE || mtd->erasesize % PAGE_SIZE) {
1439                 printk(KERN_ERR "%s: Erase size %u not multiple of PAGE_SIZE "
1440                         "%lu\n", MTDSWAP_PREFIX, mtd->erasesize, PAGE_SIZE);
1441                 return;
1442         }
1443
1444         if (PAGE_SIZE % mtd->writesize || mtd->writesize > PAGE_SIZE) {
1445                 printk(KERN_ERR "%s: PAGE_SIZE %lu not multiple of write size"
1446                         " %u\n", MTDSWAP_PREFIX, PAGE_SIZE, mtd->writesize);
1447                 return;
1448         }
1449
1450         oinfo = mtd->ecclayout;
1451         if (!oinfo) {
1452                 printk(KERN_ERR "%s: mtd%d does not have OOB\n",
1453                         MTDSWAP_PREFIX, mtd->index);
1454                 return;
1455         }
1456
1457         if (!mtd->oobsize || oinfo->oobavail < MTDSWAP_OOBSIZE) {
1458                 printk(KERN_ERR "%s: Not enough free bytes in OOB, "
1459                         "%d available, %zu needed.\n",
1460                         MTDSWAP_PREFIX, oinfo->oobavail, MTDSWAP_OOBSIZE);
1461                 return;
1462         }
1463
1464         if (spare_eblocks > 100)
1465                 spare_eblocks = 100;
1466
1467         use_size = mtd->size;
1468         size_limit = (uint64_t) BLOCK_MAX * PAGE_SIZE;
1469
1470         if (mtd->size > size_limit) {
1471                 printk(KERN_WARNING "%s: Device too large. Limiting size to "
1472                         "%llu bytes\n", MTDSWAP_PREFIX, size_limit);
1473                 use_size = size_limit;
1474         }
1475
1476         eblocks = mtd_div_by_eb(use_size, mtd);
1477         use_size = (uint64_t)eblocks * mtd->erasesize;
1478         bad_blocks = mtdswap_badblocks(mtd, use_size);
1479         eavailable = eblocks - bad_blocks;
1480
1481         if (eavailable < MIN_ERASE_BLOCKS) {
1482                 printk(KERN_ERR "%s: Not enough erase blocks. %u available, "
1483                         "%d needed\n", MTDSWAP_PREFIX, eavailable,
1484                         MIN_ERASE_BLOCKS);
1485                 return;
1486         }
1487
1488         spare_cnt = div_u64((uint64_t)eavailable * spare_eblocks, 100);
1489
1490         if (spare_cnt < MIN_SPARE_EBLOCKS)
1491                 spare_cnt = MIN_SPARE_EBLOCKS;
1492
1493         if (spare_cnt > eavailable - 1)
1494                 spare_cnt = eavailable - 1;
1495
1496         swap_size = (uint64_t)(eavailable - spare_cnt) * mtd->erasesize +
1497                 (header ? PAGE_SIZE : 0);
1498
1499         printk(KERN_INFO "%s: Enabling MTD swap on device %lu, size %llu KB, "
1500                 "%u spare, %u bad blocks\n",
1501                 MTDSWAP_PREFIX, part, swap_size / 1024, spare_cnt, bad_blocks);
1502
1503         d = kzalloc(sizeof(struct mtdswap_dev), GFP_KERNEL);
1504         if (!d)
1505                 return;
1506
1507         mbd_dev = kzalloc(sizeof(struct mtd_blktrans_dev), GFP_KERNEL);
1508         if (!mbd_dev) {
1509                 kfree(d);
1510                 return;
1511         }
1512
1513         d->mbd_dev = mbd_dev;
1514         mbd_dev->priv = d;
1515
1516         mbd_dev->mtd = mtd;
1517         mbd_dev->devnum = mtd->index;
1518         mbd_dev->size = swap_size >> PAGE_SHIFT;
1519         mbd_dev->tr = tr;
1520
1521         if (!(mtd->flags & MTD_WRITEABLE))
1522                 mbd_dev->readonly = 1;
1523
1524         if (mtdswap_init(d, eblocks, spare_cnt) < 0)
1525                 goto init_failed;
1526
1527         if (add_mtd_blktrans_dev(mbd_dev) < 0)
1528                 goto cleanup;
1529
1530         d->dev = disk_to_dev(mbd_dev->disk);
1531
1532         ret = mtdswap_add_debugfs(d);
1533         if (ret < 0)
1534                 goto debugfs_failed;
1535
1536         return;
1537
1538 debugfs_failed:
1539         del_mtd_blktrans_dev(mbd_dev);
1540
1541 cleanup:
1542         mtdswap_cleanup(d);
1543
1544 init_failed:
1545         kfree(mbd_dev);
1546         kfree(d);
1547 }
1548
1549 static void mtdswap_remove_dev(struct mtd_blktrans_dev *dev)
1550 {
1551         struct mtdswap_dev *d = MTDSWAP_MBD_TO_MTDSWAP(dev);
1552
1553         debugfs_remove_recursive(d->debugfs_root);
1554         del_mtd_blktrans_dev(dev);
1555         mtdswap_cleanup(d);
1556         kfree(d);
1557 }
1558
1559 static struct mtd_blktrans_ops mtdswap_ops = {
1560         .name           = "mtdswap",
1561         .major          = 0,
1562         .part_bits      = 0,
1563         .blksize        = PAGE_SIZE,
1564         .flush          = mtdswap_flush,
1565         .readsect       = mtdswap_readsect,
1566         .writesect      = mtdswap_writesect,
1567         .discard        = mtdswap_discard,
1568         .background     = mtdswap_background,
1569         .add_mtd        = mtdswap_add_mtd,
1570         .remove_dev     = mtdswap_remove_dev,
1571         .owner          = THIS_MODULE,
1572 };
1573
1574 static int __init mtdswap_modinit(void)
1575 {
1576         return register_mtd_blktrans(&mtdswap_ops);
1577 }
1578
1579 static void __exit mtdswap_modexit(void)
1580 {
1581         deregister_mtd_blktrans(&mtdswap_ops);
1582 }
1583
1584 module_init(mtdswap_modinit);
1585 module_exit(mtdswap_modexit);
1586
1587
1588 MODULE_LICENSE("GPL");
1589 MODULE_AUTHOR("Jarkko Lavinen <jarkko.lavinen@nokia.com>");
1590 MODULE_DESCRIPTION("Block device access to an MTD suitable for using as "
1591                 "swap space");