target/linux/generic/pending-4.19/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 @@ -37,6 +37,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 @@ -221,6 +223,53 @@ static int part_erase(struct mtd_info *m
  23  {
  24         struct mtd_part *part = mtd_to_part(mtd);
  25         int ret;
  26 +       size_t wrlen = 0;
  27 +       u8 *erase_buf = NULL;
  28 +       u32 erase_buf_ofs = 0;
  29 +       bool partial_start = false;
  30 +
  31 +       if (mtd->flags & MTD_ERASE_PARTIAL) {
  32 +               size_t readlen = 0;
  33 +               u64 mtd_ofs;
  34 +
  35 +               erase_buf = kmalloc(part->parent->erasesize, GFP_ATOMIC);
  36 +               if (!erase_buf)
  37 +                       return -ENOMEM;
  38 +
  39 +               mtd_ofs = part->offset + instr->addr;
  40 +               erase_buf_ofs = do_div(mtd_ofs, part->parent->erasesize);
  41 +
  42 +               if (erase_buf_ofs > 0) {
  43 +                       instr->addr -= erase_buf_ofs;
  44 +                       ret = mtd_read(part->parent,
  45 +                               instr->addr + part->offset,
  46 +                               part->parent->erasesize,
  47 +                               &readlen, erase_buf);
  48 +
  49 +                       instr->len += erase_buf_ofs;
  50 +                       partial_start = true;
  51 +               } else {
  52 +                       mtd_ofs = part->offset + part->mtd.size;
  53 +                       erase_buf_ofs = part->parent->erasesize -
  54 +                               do_div(mtd_ofs, part->parent->erasesize);
  55 +
  56 +                       if (erase_buf_ofs > 0) {
  57 +                               instr->len += erase_buf_ofs;
  58 +                               ret = mtd_read(part->parent,
  59 +                                       part->offset + instr->addr +
  60 +                                       instr->len - part->parent->erasesize,
  61 +                                       part->parent->erasesize, &readlen,
  62 +                                       erase_buf);
  63 +                       } else {
  64 +                               ret = 0;
  65 +                       }
  66 +               }
  67 +               if (ret < 0) {
  68 +                       kfree(erase_buf);
  69 +                       return ret;
  70 +               }
  71 +
  72 +       }
  73
  74         instr->addr += part->offset;
  75         ret = part->parent->_erase(part->parent, instr);
  76 @@ -228,6 +277,24 @@ static int part_erase(struct mtd_info *m
  77                 instr->fail_addr -= part->offset;
  78         instr->addr -= part->offset;
  79
  80 +       if (mtd->flags & MTD_ERASE_PARTIAL) {
  81 +               if (partial_start) {
  82 +                       part->parent->_write(part->parent,
  83 +                               instr->addr, erase_buf_ofs,
  84 +                               &wrlen, erase_buf);
  85 +                       instr->addr += erase_buf_ofs;
  86 +               } else {
  87 +                       instr->len -= erase_buf_ofs;
  88 +                       part->parent->_write(part->parent,
  89 +                               instr->addr + instr->len,
  90 +                               erase_buf_ofs, &wrlen,
  91 +                               erase_buf +
  92 +                               part->parent->erasesize -
  93 +                               erase_buf_ofs);
  94 +               }
  95 +               kfree(erase_buf);
  96 +       }
  97 +
  98         return ret;
  99  }
 100
 101 @@ -536,19 +603,22 @@ static struct mtd_part *allocate_partiti
 102         remainder = do_div(tmp, wr_alignment);
 103         if ((slave->mtd.flags & MTD_WRITEABLE) && remainder) {
 104                 /* Doesn't start on a boundary of major erase size */
 105 -               /* FIXME: Let it be writable if it is on a boundary of
 106 -                * _minor_ erase size though */
 107 -               slave->mtd.flags &= ~MTD_WRITEABLE;
 108 -               printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase/write block boundary -- force read-only\n",
 109 -                       part->name);
 110 +               slave->mtd.flags |= MTD_ERASE_PARTIAL;
 111 +               if (((u32)slave->mtd.size) > parent->erasesize)
 112 +                       slave->mtd.flags &= ~MTD_WRITEABLE;
 113 +               else
 114 +                       slave->mtd.erasesize = slave->mtd.size;
 115         }
 116
 117 -       tmp = part_absolute_offset(parent) + slave->mtd.size;
 118 +       tmp = part_absolute_offset(parent) + slave->offset + slave->mtd.size;
 119         remainder = do_div(tmp, wr_alignment);
 120         if ((slave->mtd.flags & MTD_WRITEABLE) && remainder) {
 121 -               slave->mtd.flags &= ~MTD_WRITEABLE;
 122 -               printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase/write block -- force read-only\n",
 123 -                       part->name);
 124 +               slave->mtd.flags |= MTD_ERASE_PARTIAL;
 125 +
 126 +               if ((u32)slave->mtd.size > parent->erasesize)
 127 +                       slave->mtd.flags &= ~MTD_WRITEABLE;
 128 +               else
 129 +                       slave->mtd.erasesize = slave->mtd.size;
 130         }
 131
 132         mtd_set_ooblayout(&slave->mtd, &part_ooblayout_ops);