common/fb_nand.c

   1 /*
   2  * Copyright 2014 Broadcom Corporation.
   3  * Copyright 2015 Free Electrons.
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <config.h>
   9 #include <common.h>
  10
  11 #include <fastboot.h>
  12 #include <image-sparse.h>
  13
  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 {
  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");
  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");
  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");
  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                           unsigned int 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 void fb_nand_flash_write(const char *cmd, void *download_buffer,
 149                          unsigned int download_bytes)
 150 {
 151         struct part_info *part;
 152         struct mtd_info *mtd = NULL;
 153         int ret;
 154
 155         ret = fb_nand_lookup(cmd, &mtd, &part);
 156         if (ret) {
 157                 pr_err("invalid NAND device");
 158                 fastboot_fail("invalid NAND device");
 159                 return;
 160         }
 161
 162         ret = board_fastboot_write_partition_setup(part->name);
 163         if (ret)
 164                 return;
 165
 166         if (is_sparse_image(download_buffer)) {
 167                 struct fb_nand_sparse sparse_priv;
 168                 struct sparse_storage sparse;
 169
 170                 sparse_priv.mtd = mtd;
 171                 sparse_priv.part = part;
 172
 173                 sparse.blksz = mtd->writesize;
 174                 sparse.start = part->offset / sparse.blksz;
 175                 sparse.size = part->size / sparse.blksz;
 176                 sparse.write = fb_nand_sparse_write;
 177                 sparse.reserve = fb_nand_sparse_reserve;
 178
 179                 printf("Flashing sparse image at offset " LBAFU "\n",
 180                        sparse.start);
 181
 182                 sparse.priv = &sparse_priv;
 183                 write_sparse_image(&sparse, cmd, download_buffer,
 184                                    download_bytes);
 185         } else {
 186                 printf("Flashing raw image at offset 0x%llx\n",
 187                        part->offset);
 188
 189                 ret = _fb_nand_write(mtd, part, download_buffer, part->offset,
 190                                      download_bytes, NULL);
 191
 192                 printf("........ wrote %u bytes to '%s'\n",
 193                        download_bytes, part->name);
 194         }
 195
 196         if (ret) {
 197                 fastboot_fail("error writing the image");
 198                 return;
 199         }
 200
 201         fastboot_okay("");
 202 }
 203
 204 void fb_nand_erase(const char *cmd)
 205 {
 206         struct part_info *part;
 207         struct mtd_info *mtd = NULL;
 208         int ret;
 209
 210         ret = fb_nand_lookup(cmd, &mtd, &part);
 211         if (ret) {
 212                 pr_err("invalid NAND device");
 213                 fastboot_fail("invalid NAND device");
 214                 return;
 215         }
 216
 217         ret = board_fastboot_erase_partition_setup(part->name);
 218         if (ret)
 219                 return;
 220
 221         ret = _fb_nand_erase(mtd, part);
 222         if (ret) {
 223                 pr_err("failed erasing from device %s", mtd->name);
 224                 fastboot_fail("failed erasing from device");
 225                 return;
 226         }
 227
 228         fastboot_okay("");
 229 }