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