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