drivers/dfu/dfu_nand.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * dfu_nand.c -- DFU for NAND routines.
   4  *
   5  * Copyright (C) 2012-2013 Texas Instruments, Inc.
   6  *
   7  * Based on dfu_mmc.c which is:
   8  * Copyright (C) 2012 Samsung Electronics
   9  * author: Lukasz Majewski <l.majewski@samsung.com>
  10  */
  11
  12 #include <common.h>
  13 #include <log.h>
  14 #include <malloc.h>
  15 #include <errno.h>
  16 #include <div64.h>
  17 #include <dfu.h>
  18 #include <linux/mtd/mtd.h>
  19 #include <jffs2/load_kernel.h>
  20 #include <nand.h>
  21
  22 static int nand_block_op(enum dfu_op op, struct dfu_entity *dfu,
  23                         u64 offset, void *buf, long *len)
  24 {
  25         loff_t start, lim;
  26         size_t count, actual;
  27         int ret;
  28         struct mtd_info *mtd;
  29
  30         /* if buf == NULL return total size of the area */
  31         if (buf == NULL) {
  32                 *len = dfu->data.nand.size;
  33                 return 0;
  34         }
  35
  36         start = dfu->data.nand.start + offset + dfu->bad_skip;
  37         lim = dfu->data.nand.start + dfu->data.nand.size - start;
  38         count = *len;
  39
  40         mtd = get_nand_dev_by_index(nand_curr_device);
  41
  42         if (nand_curr_device < 0 ||
  43             nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
  44             !mtd) {
  45                 printf("%s: invalid nand device\n", __func__);
  46                 return -1;
  47         }
  48
  49         if (op == DFU_OP_READ) {
  50                 ret = nand_read_skip_bad(mtd, start, &count, &actual,
  51                                          lim, buf);
  52         } else {
  53                 nand_erase_options_t opts;
  54                 int write_flags = WITH_WR_VERIFY;
  55
  56                 memset(&opts, 0, sizeof(opts));
  57                 opts.offset = start;
  58                 opts.length = count;
  59                 opts.spread = 1;
  60                 opts.quiet = 1;
  61                 opts.lim = lim;
  62                 /* first erase */
  63                 ret = nand_erase_opts(mtd, &opts);
  64                 if (ret)
  65                         return ret;
  66                 /* then write */
  67 #ifdef CONFIG_DFU_NAND_TRIMFFS
  68                 if (dfu->data.nand.ubi)
  69                         write_flags |= WITH_DROP_FFS;
  70 #endif
  71                 ret = nand_write_skip_bad(mtd, start, &count, &actual,
  72                                           lim, buf, write_flags);
  73         }
  74
  75         if (ret != 0) {
  76                 printf("%s: nand_%s_skip_bad call failed at %llx!\n",
  77                        __func__, op == DFU_OP_READ ? "read" : "write",
  78                        start);
  79                 return ret;
  80         }
  81
  82         /*
  83          * Find out where we stopped writing data.  This can be deeper into
  84          * the NAND than we expected due to having to skip bad blocks.  So
  85          * we must take this into account for the next write, if any.
  86          */
  87         if (actual > count)
  88                 dfu->bad_skip += actual - count;
  89
  90         return ret;
  91 }
  92
  93 static inline int nand_block_write(struct dfu_entity *dfu,
  94                 u64 offset, void *buf, long *len)
  95 {
  96         return nand_block_op(DFU_OP_WRITE, dfu, offset, buf, len);
  97 }
  98
  99 static inline int nand_block_read(struct dfu_entity *dfu,
 100                 u64 offset, void *buf, long *len)
 101 {
 102         return nand_block_op(DFU_OP_READ, dfu, offset, buf, len);
 103 }
 104
 105 static int dfu_write_medium_nand(struct dfu_entity *dfu,
 106                 u64 offset, void *buf, long *len)
 107 {
 108         int ret = -1;
 109
 110         switch (dfu->layout) {
 111         case DFU_RAW_ADDR:
 112                 ret = nand_block_write(dfu, offset, buf, len);
 113                 break;
 114         default:
 115                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 116                        dfu_get_layout(dfu->layout));
 117         }
 118
 119         return ret;
 120 }
 121
 122 int dfu_get_medium_size_nand(struct dfu_entity *dfu, u64 *size)
 123 {
 124         *size = dfu->data.nand.size;
 125
 126         return 0;
 127 }
 128
 129 static int dfu_read_medium_nand(struct dfu_entity *dfu, u64 offset, void *buf,
 130                 long *len)
 131 {
 132         int ret = -1;
 133
 134         switch (dfu->layout) {
 135         case DFU_RAW_ADDR:
 136                 ret = nand_block_read(dfu, offset, buf, len);
 137                 break;
 138         default:
 139                 printf("%s: Layout (%s) not (yet) supported!\n", __func__,
 140                        dfu_get_layout(dfu->layout));
 141         }
 142
 143         return ret;
 144 }
 145
 146 static int dfu_flush_medium_nand(struct dfu_entity *dfu)
 147 {
 148         int ret = 0;
 149         u64 off;
 150
 151         /* in case of ubi partition, erase rest of the partition */
 152         if (dfu->data.nand.ubi) {
 153                 struct mtd_info *mtd = get_nand_dev_by_index(nand_curr_device);
 154                 nand_erase_options_t opts;
 155
 156                 if (nand_curr_device < 0 ||
 157                     nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
 158                     !mtd) {
 159                         printf("%s: invalid nand device\n", __func__);
 160                         return -1;
 161                 }
 162
 163                 memset(&opts, 0, sizeof(opts));
 164                 off = dfu->offset;
 165                 if ((off & (mtd->erasesize - 1)) != 0) {
 166                         /*
 167                          * last write ended with unaligned length
 168                          * sector is erased, jump to next
 169                          */
 170                         off = off & ~((mtd->erasesize - 1));
 171                         off += mtd->erasesize;
 172                 }
 173                 opts.offset = dfu->data.nand.start + off +
 174                                 dfu->bad_skip;
 175                 opts.length = dfu->data.nand.start +
 176                                 dfu->data.nand.size - opts.offset;
 177                 ret = nand_erase_opts(mtd, &opts);
 178                 if (ret != 0)
 179                         printf("Failure erase: %d\n", ret);
 180         }
 181
 182         return ret;
 183 }
 184
 185 unsigned int dfu_polltimeout_nand(struct dfu_entity *dfu)
 186 {
 187         /*
 188          * Currently, Poll Timeout != 0 is only needed on nand
 189          * ubi partition, as the not used sectors need an erase
 190          */
 191         if (dfu->data.nand.ubi)
 192                 return DFU_MANIFEST_POLL_TIMEOUT;
 193
 194         return DFU_DEFAULT_POLL_TIMEOUT;
 195 }
 196
 197 int dfu_fill_entity_nand(struct dfu_entity *dfu, char *devstr, char *s)
 198 {
 199         char *st;
 200         int ret, dev, part;
 201
 202         dfu->data.nand.ubi = 0;
 203         dfu->dev_type = DFU_DEV_NAND;
 204         st = strsep(&s, " ");
 205         if (!strcmp(st, "raw")) {
 206                 dfu->layout = DFU_RAW_ADDR;
 207                 dfu->data.nand.start = simple_strtoul(s, &s, 16);
 208                 s++;
 209                 dfu->data.nand.size = simple_strtoul(s, &s, 16);
 210         } else if ((!strcmp(st, "part")) || (!strcmp(st, "partubi"))) {
 211                 char mtd_id[32];
 212                 struct mtd_device *mtd_dev;
 213                 u8 part_num;
 214                 struct part_info *pi;
 215
 216                 dfu->layout = DFU_RAW_ADDR;
 217
 218                 dev = simple_strtoul(s, &s, 10);
 219                 s++;
 220                 part = simple_strtoul(s, &s, 10);
 221
 222                 sprintf(mtd_id, "%s%d,%d", "nand", dev, part - 1);
 223                 debug("using id '%s'\n", mtd_id);
 224
 225                 mtdparts_init();
 226
 227                 ret = find_dev_and_part(mtd_id, &mtd_dev, &part_num, &pi);
 228                 if (ret != 0) {
 229                         printf("Could not locate '%s'\n", mtd_id);
 230                         return -1;
 231                 }
 232
 233                 dfu->data.nand.start = pi->offset;
 234                 dfu->data.nand.size = pi->size;
 235                 if (!strcmp(st, "partubi"))
 236                         dfu->data.nand.ubi = 1;
 237         } else {
 238                 printf("%s: Memory layout (%s) not supported!\n", __func__, st);
 239                 return -1;
 240         }
 241
 242         dfu->get_medium_size = dfu_get_medium_size_nand;
 243         dfu->read_medium = dfu_read_medium_nand;
 244         dfu->write_medium = dfu_write_medium_nand;
 245         dfu->flush_medium = dfu_flush_medium_nand;
 246         dfu->poll_timeout = dfu_polltimeout_nand;
 247
 248         /* initial state */
 249         dfu->inited = 0;
 250
 251         return 0;
 252 }