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 diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
  12 index fce83882fd4e..0238b0babe2f 100644
  13 --- a/drivers/mtd/mtdpart.c
  14 +++ b/drivers/mtd/mtdpart.c
  15 @@ -36,6 +36,8 @@
  16  #include "mtdcore.h"
  17  #include "mtdsplit/mtdsplit.h"
  18
  19 +#define MTD_ERASE_PARTIAL      0x8000 /* partition only covers parts of an erase block */
  20 +
  21  /* Our partition linked list */
  22  static LIST_HEAD(mtd_partitions);
  23  static DEFINE_MUTEX(mtd_partitions_mutex);
  24 @@ -241,13 +243,61 @@ static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
  25         struct mtd_part *part = mtd_to_part(mtd);
  26         int ret;
  27
  28 +
  29 +       instr->partial_start = false;
  30 +       if (mtd->flags & MTD_ERASE_PARTIAL) {
  31 +               size_t readlen = 0;
  32 +               u64 mtd_ofs;
  33 +
  34 +               instr->erase_buf = kmalloc(part->parent->erasesize, GFP_ATOMIC);
  35 +               if (!instr->erase_buf)
  36 +                       return -ENOMEM;
  37 +
  38 +               mtd_ofs = part->offset + instr->addr;
  39 +               instr->erase_buf_ofs = do_div(mtd_ofs, part->parent->erasesize);
  40 +
  41 +               if (instr->erase_buf_ofs > 0) {
  42 +                       instr->addr -= instr->erase_buf_ofs;
  43 +                       ret = mtd_read(part->parent,
  44 +                               instr->addr + part->offset,
  45 +                               part->parent->erasesize,
  46 +                               &readlen, instr->erase_buf);
  47 +
  48 +                       instr->len += instr->erase_buf_ofs;
  49 +                       instr->partial_start = true;
  50 +               } else {
  51 +                       mtd_ofs = part->offset + part->mtd.size;
  52 +                       instr->erase_buf_ofs = part->parent->erasesize -
  53 +                               do_div(mtd_ofs, part->parent->erasesize);
  54 +
  55 +                       if (instr->erase_buf_ofs > 0) {
  56 +                               instr->len += instr->erase_buf_ofs;
  57 +                               ret = mtd_read(part->parent,
  58 +                                       part->offset + instr->addr +
  59 +                                       instr->len - part->parent->erasesize,
  60 +                                       part->parent->erasesize, &readlen,
  61 +                                       instr->erase_buf);
  62 +                       } else {
  63 +                               ret = 0;
  64 +                       }
  65 +               }
  66 +               if (ret < 0) {
  67 +                       kfree(instr->erase_buf);
  68 +                       return ret;
  69 +               }
  70 +
  71 +       }
  72 +
  73         instr->addr += part->offset;
  74         ret = part->parent->_erase(part->parent, instr);
  75         if (ret) {
  76                 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
  77                         instr->fail_addr -= part->offset;
  78                 instr->addr -= part->offset;
  79 +               if (mtd->flags & MTD_ERASE_PARTIAL)
  80 +                       kfree(instr->erase_buf);
  81         }
  82 +
  83         return ret;
  84  }
  85
  86 @@ -255,6 +305,25 @@ void mtd_erase_callback(struct erase_info *instr)
  87  {
  88         if (instr->mtd->_erase == part_erase) {
  89                 struct mtd_part *part = mtd_to_part(instr->mtd);
  90 +               size_t wrlen = 0;
  91 +
  92 +               if (instr->mtd->flags & MTD_ERASE_PARTIAL) {
  93 +                       if (instr->partial_start) {
  94 +                               part->parent->_write(part->parent,
  95 +                                       instr->addr, instr->erase_buf_ofs,
  96 +                                       &wrlen, instr->erase_buf);
  97 +                               instr->addr += instr->erase_buf_ofs;
  98 +                       } else {
  99 +                               instr->len -= instr->erase_buf_ofs;
 100 +                               part->parent->_write(part->parent,
 101 +                                       instr->addr + instr->len,
 102 +                                       instr->erase_buf_ofs, &wrlen,
 103 +                                       instr->erase_buf +
 104 +                                       part->parent->erasesize -
 105 +                                       instr->erase_buf_ofs);
 106 +                       }
 107 +                       kfree(instr->erase_buf);
 108 +               }
 109
 110                 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
 111                         instr->fail_addr -= part->offset;
 112 @@ -590,19 +659,22 @@ static struct mtd_part *allocate_partition(struct mtd_info *parent,
 113         remainder = do_div(tmp, wr_alignment);
 114         if ((slave->mtd.flags & MTD_WRITEABLE) && remainder) {
 115                 /* Doesn't start on a boundary of major erase size */
 116 -               /* FIXME: Let it be writable if it is on a boundary of
 117 -                * _minor_ erase size though */
 118 -               slave->mtd.flags &= ~MTD_WRITEABLE;
 119 -               printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase/write block boundary -- force read-only\n",
 120 -                       part->name);
 121 +               slave->mtd.flags |= MTD_ERASE_PARTIAL;
 122 +               if (((u32)slave->mtd.size) > parent->erasesize)
 123 +                       slave->mtd.flags &= ~MTD_WRITEABLE;
 124 +               else
 125 +                       slave->mtd.erasesize = slave->mtd.size;
 126         }
 127
 128 -       tmp = slave->mtd.size;
 129 +       tmp = slave->offset + slave->mtd.size;
 130         remainder = do_div(tmp, wr_alignment);
 131         if ((slave->mtd.flags & MTD_WRITEABLE) && remainder) {
 132 -               slave->mtd.flags &= ~MTD_WRITEABLE;
 133 -               printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase/write block -- force read-only\n",
 134 -                       part->name);
 135 +               slave->mtd.flags |= MTD_ERASE_PARTIAL;
 136 +
 137 +               if ((u32)slave->mtd.size > parent->erasesize)
 138 +                       slave->mtd.flags &= ~MTD_WRITEABLE;
 139 +               else
 140 +                       slave->mtd.erasesize = slave->mtd.size;
 141         }
 142
 143         mtd_set_ooblayout(&slave->mtd, &part_ooblayout_ops);
 144 diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
 145 index e7d5091bb447..0db85491f085 100644
 146 --- a/include/linux/mtd/mtd.h
 147 +++ b/include/linux/mtd/mtd.h
 148 @@ -55,6 +55,10 @@ struct erase_info {
 149         u_long priv;
 150         u_char state;
 151         struct erase_info *next;
 152 +
 153 +       u8 *erase_buf;
 154 +       u32 erase_buf_ofs;
 155 +       bool partial_start;
 156  };
 157
 158  struct mtd_erase_region_info {
 159 --
 160 2.11.0
 161