drivers/fastboot/fb_nand.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2014 Broadcom Corporation.
   4  * Copyright 2015 Free Electrons.
   5  */
   6
   7 #include <config.h>
   8 #include <blk.h>
   9
  10 #include <fastboot.h>
  11 #include <image-sparse.h>
  12
  13 #include <linux/printk.h>
  14 #include <linux/mtd/mtd.h>
  15 #include <jffs2/jffs2.h>
  16 #include <nand.h>
  17
  18 struct fb_nand_sparse {
  19         struct mtd_info         *mtd;
  20         struct part_info        *part;
  21 };
  22
  23 __weak int board_fastboot_erase_partition_setup(char *name)
  24 {
  25         return 0;
  26 }
  27
  28 __weak int board_fastboot_write_partition_setup(char *name)
  29 {
  30         return 0;
  31 }
  32
  33 static int fb_nand_lookup(const char *partname,
  34                           struct mtd_info **mtd,
  35                           struct part_info **part,
  36                           char *response)
  37 {
  38         struct mtd_device *dev;
  39         int ret;
  40         u8 pnum;
  41
  42         ret = mtdparts_init();
  43         if (ret) {
  44                 pr_err("Cannot initialize MTD partitions\n");
  45                 fastboot_fail("cannot init mtdparts", response);
  46                 return ret;
  47         }
  48
  49         ret = find_dev_and_part(partname, &dev, &pnum, part);
  50         if (ret) {
  51                 pr_err("cannot find partition: '%s'", partname);
  52                 fastboot_fail("cannot find partition", response);
  53                 return ret;
  54         }
  55
  56         if (dev->id->type != MTD_DEV_TYPE_NAND) {
  57                 pr_err("partition '%s' is not stored on a NAND device",
  58                       partname);
  59                 fastboot_fail("not a NAND device", response);
  60                 return -EINVAL;
  61         }
  62
  63         *mtd = get_nand_dev_by_index(dev->id->num);
  64
  65         return 0;
  66 }
  67
  68 static int _fb_nand_erase(struct mtd_info *mtd, struct part_info *part)
  69 {
  70         nand_erase_options_t opts;
  71         int ret;
  72
  73         memset(&opts, 0, sizeof(opts));
  74         opts.offset = part->offset;
  75         opts.length = part->size;
  76         opts.quiet = 1;
  77
  78         printf("Erasing blocks 0x%llx to 0x%llx\n",
  79                part->offset, part->offset + part->size);
  80
  81         ret = nand_erase_opts(mtd, &opts);
  82         if (ret)
  83                 return ret;
  84
  85         printf("........ erased 0x%llx bytes from '%s'\n",
  86                part->size, part->name);
  87
  88         return 0;
  89 }
  90
  91 static int _fb_nand_write(struct mtd_info *mtd, struct part_info *part,
  92                           void *buffer, u32 offset,
  93                           size_t length, size_t *written)
  94 {
  95         int flags = WITH_WR_VERIFY;
  96
  97 #ifdef CONFIG_FASTBOOT_FLASH_NAND_TRIMFFS
  98         flags |= WITH_DROP_FFS;
  99 #endif
 100
 101         return nand_write_skip_bad(mtd, offset, &length, written,
 102                                    part->size - (offset - part->offset),
 103                                    buffer, flags);
 104 }
 105
 106 static lbaint_t fb_nand_sparse_write(struct sparse_storage *info,
 107                 lbaint_t blk, lbaint_t blkcnt, const void *buffer)
 108 {
 109         struct fb_nand_sparse *sparse = info->priv;
 110         size_t written;
 111         int ret;
 112
 113         ret = _fb_nand_write(sparse->mtd, sparse->part, (void *)buffer,
 114                              blk * info->blksz,
 115                              blkcnt * info->blksz, &written);
 116         if (ret < 0) {
 117                 printf("Failed to write sparse chunk\n");
 118                 return ret;
 119         }
 120
 121 /* TODO - verify that the value "written" includes the "bad-blocks" ... */
 122
 123         /*
 124          * the return value must be 'blkcnt' ("good-blocks") plus the
 125          * number of "bad-blocks" encountered within this space...
 126          */
 127         return written / info->blksz;
 128 }
 129
 130 static lbaint_t fb_nand_sparse_reserve(struct sparse_storage *info,
 131                 lbaint_t blk, lbaint_t blkcnt)
 132 {
 133         int bad_blocks = 0;
 134
 135 /*
 136  * TODO - implement a function to determine the total number
 137  * of blocks which must be used in order to reserve the specified
 138  * number ("blkcnt") of "good-blocks", starting at "blk"...
 139  * ( possibly something like the "check_skip_len()" function )
 140  */
 141
 142         /*
 143          * the return value must be 'blkcnt' ("good-blocks") plus the
 144          * number of "bad-blocks" encountered within this space...
 145          */
 146         return blkcnt + bad_blocks;
 147 }
 148
 149 /**
 150  * fastboot_nand_get_part_info() - Lookup NAND partion by name
 151  *
 152  * @part_name: Named device to lookup
 153  * @part_info: Pointer to returned part_info pointer
 154  * @response: Pointer to fastboot response buffer
 155  */
 156 int fastboot_nand_get_part_info(const char *part_name,
 157                                 struct part_info **part_info, char *response)
 158 {
 159         struct mtd_info *mtd = NULL;
 160
 161         return fb_nand_lookup(part_name, &mtd, part_info, response);
 162 }
 163
 164 /**
 165  * fastboot_nand_flash_write() - Write image to NAND for fastboot
 166  *
 167  * @cmd: Named device to write image to
 168  * @download_buffer: Pointer to image data
 169  * @download_bytes: Size of image data
 170  * @response: Pointer to fastboot response buffer
 171  */
 172 void fastboot_nand_flash_write(const char *cmd, void *download_buffer,
 173                                u32 download_bytes, char *response)
 174 {
 175         struct part_info *part;
 176         struct mtd_info *mtd = NULL;
 177         int ret;
 178
 179         ret = fb_nand_lookup(cmd, &mtd, &part, response);
 180         if (ret) {
 181                 pr_err("invalid NAND device");
 182                 fastboot_fail("invalid NAND device", response);
 183                 return;
 184         }
 185
 186         ret = board_fastboot_write_partition_setup(part->name);
 187         if (ret)
 188                 return;
 189
 190         if (is_sparse_image(download_buffer)) {
 191                 struct fb_nand_sparse sparse_priv;
 192                 struct sparse_storage sparse;
 193
 194                 sparse_priv.mtd = mtd;
 195                 sparse_priv.part = part;
 196
 197                 sparse.blksz = mtd->writesize;
 198                 sparse.start = part->offset / sparse.blksz;
 199                 sparse.size = part->size / sparse.blksz;
 200                 sparse.write = fb_nand_sparse_write;
 201                 sparse.reserve = fb_nand_sparse_reserve;
 202                 sparse.mssg = fastboot_fail;
 203
 204                 printf("Flashing sparse image at offset " LBAFU "\n",
 205                        sparse.start);
 206
 207                 sparse.priv = &sparse_priv;
 208                 ret = write_sparse_image(&sparse, cmd, download_buffer,
 209                                          response);
 210                 if (!ret)
 211                         fastboot_okay(NULL, response);
 212         } else {
 213                 printf("Flashing raw image at offset 0x%llx\n",
 214                        part->offset);
 215
 216                 ret = _fb_nand_write(mtd, part, download_buffer, part->offset,
 217                                      download_bytes, NULL);
 218
 219                 printf("........ wrote %u bytes to '%s'\n",
 220                        download_bytes, part->name);
 221         }
 222
 223         if (ret) {
 224                 fastboot_fail("error writing the image", response);
 225                 return;
 226         }
 227
 228         fastboot_okay(NULL, response);
 229 }
 230
 231 /**
 232  * fastboot_nand_flash_erase() - Erase NAND for fastboot
 233  *
 234  * @cmd: Named device to erase
 235  * @response: Pointer to fastboot response buffer
 236  */
 237 void fastboot_nand_erase(const char *cmd, char *response)
 238 {
 239         struct part_info *part;
 240         struct mtd_info *mtd = NULL;
 241         int ret;
 242
 243         ret = fb_nand_lookup(cmd, &mtd, &part, response);
 244         if (ret) {
 245                 pr_err("invalid NAND device");
 246                 fastboot_fail("invalid NAND device", response);
 247                 return;
 248         }
 249
 250         ret = board_fastboot_erase_partition_setup(part->name);
 251         if (ret)
 252                 return;
 253
 254         ret = _fb_nand_erase(mtd, part);
 255         if (ret) {
 256                 pr_err("failed erasing from device %s", mtd->name);
 257                 fastboot_fail("failed erasing from device", response);
 258                 return;
 259         }
 260
 261         fastboot_okay(NULL, response);
 262 }