target/linux/generic/pending-4.9/411-mtd-partial_eraseblock_write.patch

   1 From: Felix Fietkau <nbd@nbd.name>
   2 Subject: mtd: implement write support for partitions covering only a part of an eraseblock (buffer data that would otherwise be erased)
   3
   4 lede-commit: 87a8e8ac1067f58ba831c4aae443f3655c31cd80
   5 Signed-off-by: Felix Fietkau <nbd@nbd.name>
   6 ---
   7  drivers/mtd/mtdpart.c   | 90 ++++++++++++++++++++++++++++++++++++++++++++-----
   8  include/linux/mtd/mtd.h |  4 +++
   9  2 files changed, 85 insertions(+), 9 deletions(-)
  10
  11 --- a/drivers/mtd/mtdpart.c
  12 +++ b/drivers/mtd/mtdpart.c
  13 @@ -36,6 +36,8 @@
  14  #include "mtdcore.h"
  15  #include "mtdsplit/mtdsplit.h"
  16
  17 +#define MTD_ERASE_PARTIAL      0x8000 /* partition only covers parts of an erase block */
  18 +
  19  /* Our partition linked list */
  20  static LIST_HEAD(mtd_partitions);
  21  static DEFINE_MUTEX(mtd_partitions_mutex);
  22 @@ -235,13 +237,60 @@ static int part_erase(struct mtd_info *m
  23         struct mtd_part *part = mtd_to_part(mtd);
  24         int ret;
  25
  26 +       instr->partial_start = false;
  27 +       if (mtd->flags & MTD_ERASE_PARTIAL) {
  28 +               size_t readlen = 0;
  29 +               u64 mtd_ofs;
  30 +
  31 +               instr->erase_buf = kmalloc(part->master->erasesize, GFP_ATOMIC);
  32 +               if (!instr->erase_buf)
  33 +                       return -ENOMEM;
  34 +
  35 +               mtd_ofs = part->offset + instr->addr;
  36 +               instr->erase_buf_ofs = do_div(mtd_ofs, part->master->erasesize);
  37 +
  38 +               if (instr->erase_buf_ofs > 0) {
  39 +                       instr->addr -= instr->erase_buf_ofs;
  40 +                       ret = mtd_read(part->master,
  41 +                               instr->addr + part->offset,
  42 +                               part->master->erasesize,
  43 +                               &readlen, instr->erase_buf);
  44 +
  45 +                       instr->len += instr->erase_buf_ofs;
  46 +                       instr->partial_start = true;
  47 +               } else {
  48 +                       mtd_ofs = part->offset + part->mtd.size;
  49 +                       instr->erase_buf_ofs = part->master->erasesize -
  50 +                               do_div(mtd_ofs, part->master->erasesize);
  51 +
  52 +                       if (instr->erase_buf_ofs > 0) {
  53 +                               instr->len += instr->erase_buf_ofs;
  54 +                               ret = mtd_read(part->master,
  55 +                                       part->offset + instr->addr +
  56 +                                       instr->len - part->master->erasesize,
  57 +                                       part->master->erasesize, &readlen,
  58 +                                       instr->erase_buf);
  59 +                       } else {
  60 +                               ret = 0;
  61 +                       }
  62 +               }
  63 +               if (ret < 0) {
  64 +                       kfree(instr->erase_buf);
  65 +                       return ret;
  66 +               }
  67 +
  68 +       }
  69 +
  70         instr->addr += part->offset;
  71         ret = part->master->_erase(part->master, instr);
  72         if (ret) {
  73                 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
  74                         instr->fail_addr -= part->offset;
  75                 instr->addr -= part->offset;
  76 +               if (mtd->flags & MTD_ERASE_PARTIAL)
  77 +                       kfree(instr->erase_buf);
  78         }
  79 +
  80         return ret;
  81  }
  82
  83 @@ -249,6 +298,25 @@ void mtd_erase_callback(struct erase_inf
  84  {
  85         if (instr->mtd->_erase == part_erase) {
  86                 struct mtd_part *part = mtd_to_part(instr->mtd);
  87 +               size_t wrlen = 0;
  88 +
  89 +               if (instr->mtd->flags & MTD_ERASE_PARTIAL) {
  90 +                       if (instr->partial_start) {
  91 +                               part->master->_write(part->master,
  92 +                                       instr->addr, instr->erase_buf_ofs,
  93 +                                       &wrlen, instr->erase_buf);
  94 +                               instr->addr += instr->erase_buf_ofs;
  95 +                       } else {
  96 +                               instr->len -= instr->erase_buf_ofs;
  97 +                               part->master->_write(part->master,
  98 +                                       instr->addr + instr->len,
  99 +                                       instr->erase_buf_ofs, &wrlen,
 100 +                                       instr->erase_buf +
 101 +                                       part->master->erasesize -
 102 +                                       instr->erase_buf_ofs);
 103 +                       }
 104 +                       kfree(instr->erase_buf);
 105 +               }
 106
 107                 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
 108                         instr->fail_addr -= part->offset;
 109 @@ -564,17 +632,20 @@ static struct mtd_part *allocate_partiti
 110         if ((slave->mtd.flags & MTD_WRITEABLE) &&
 111             mtd_mod_by_eb(slave->offset, &slave->mtd)) {
 112                 /* Doesn't start on a boundary of major erase size */
 113 -               /* FIXME: Let it be writable if it is on a boundary of
 114 -                * _minor_ erase size though */
 115 -               slave->mtd.flags &= ~MTD_WRITEABLE;
 116 -               printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
 117 -                       part->name);
 118 +               slave->mtd.flags |= MTD_ERASE_PARTIAL;
 119 +               if (((u32)slave->mtd.size) > master->erasesize)
 120 +                       slave->mtd.flags &= ~MTD_WRITEABLE;
 121 +               else
 122 +                       slave->mtd.erasesize = slave->mtd.size;
 123         }
 124         if ((slave->mtd.flags & MTD_WRITEABLE) &&
 125 -           mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
 126 -               slave->mtd.flags &= ~MTD_WRITEABLE;
 127 -               printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
 128 -                       part->name);
 129 +           mtd_mod_by_eb(slave->offset + slave->mtd.size, &slave->mtd)) {
 130 +               slave->mtd.flags |= MTD_ERASE_PARTIAL;
 131 +
 132 +               if ((u32) slave->mtd.size > master->erasesize)
 133 +                       slave->mtd.flags &= ~MTD_WRITEABLE;
 134 +               else
 135 +                       slave->mtd.erasesize = slave->mtd.size;
 136         }
 137
 138         mtd_set_ooblayout(&slave->mtd, &part_ooblayout_ops);
 139 --- a/include/linux/mtd/mtd.h
 140 +++ b/include/linux/mtd/mtd.h
 141 @@ -55,6 +55,10 @@ struct erase_info {
 142         u_long priv;
 143         u_char state;
 144         struct erase_info *next;
 145 +
 146 +       u8 *erase_buf;
 147 +       u32 erase_buf_ofs;
 148 +       bool partial_start;
 149  };
 150
 151  struct mtd_erase_region_info {