blob: 2113b6c3723978f31372e1562010e76defb6f800 [file] [log] [blame]
Steve Raec0aebb32014-08-26 11:47:27 -07001/*
2 * Copyright 2014 Broadcom Corporation.
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 */
6
Steve Rae0ff7e582014-12-12 15:51:54 -08007#include <config.h>
Steve Raec0aebb32014-08-26 11:47:27 -07008#include <common.h>
Simon Glass2a981dc2016-02-29 15:25:52 -07009#include <blk.h>
Maxime Ripard3c8f98f2015-10-15 14:34:13 +020010#include <fastboot.h>
Steve Raec0aebb32014-08-26 11:47:27 -070011#include <fb_mmc.h>
Maxime Ripard3d4ef382015-10-15 14:34:19 +020012#include <image-sparse.h>
Steve Raec0aebb32014-08-26 11:47:27 -070013#include <part.h>
Dileep Katta89792382015-02-17 18:48:23 +053014#include <mmc.h>
Siarhei Siamashka5e0efc12015-10-28 06:24:16 +020015#include <div64.h>
Sam Protsenkoefeccfe2017-05-18 15:04:59 +030016#include <linux/compat.h>
17#include <android_image.h>
Steve Raec0aebb32014-08-26 11:47:27 -070018
Petr Kulhavy6f6c8632016-09-09 10:27:18 +020019/*
20 * FIXME: Ensure we always set these names via Kconfig once xxx_PARTITION is
21 * migrated
22 */
23#ifndef CONFIG_FASTBOOT_GPT_NAME
24#define CONFIG_FASTBOOT_GPT_NAME "gpt"
Steve Rae0ff7e582014-12-12 15:51:54 -080025#endif
26
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +020027
Petr Kulhavy6f6c8632016-09-09 10:27:18 +020028#ifndef CONFIG_FASTBOOT_MBR_NAME
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +020029#define CONFIG_FASTBOOT_MBR_NAME "mbr"
30#endif
31
Sam Protsenkoefeccfe2017-05-18 15:04:59 +030032#define BOOT_PARTITION_NAME "boot"
33
Maxime Riparda5d1e042015-10-15 14:34:14 +020034struct fb_mmc_sparse {
Simon Glass4101f682016-02-29 15:25:34 -070035 struct blk_desc *dev_desc;
Maxime Riparda5d1e042015-10-15 14:34:14 +020036};
37
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +020038static int part_get_info_by_name_or_alias(struct blk_desc *dev_desc,
Michael Scott8a418022015-03-11 10:02:31 -070039 const char *name, disk_partition_t *info)
40{
41 int ret;
42
Petr Kulhavy87b85302016-09-09 10:27:15 +020043 ret = part_get_info_by_name(dev_desc, name, info);
Alex Deymo88b63292017-04-02 01:49:50 -070044 if (ret < 0) {
Michael Scott8a418022015-03-11 10:02:31 -070045 /* strlen("fastboot_partition_alias_") + 32(part_name) + 1 */
46 char env_alias_name[25 + 32 + 1];
47 char *aliased_part_name;
48
49 /* check for alias */
50 strcpy(env_alias_name, "fastboot_partition_alias_");
51 strncat(env_alias_name, name, 32);
52 aliased_part_name = getenv(env_alias_name);
53 if (aliased_part_name != NULL)
Petr Kulhavy87b85302016-09-09 10:27:15 +020054 ret = part_get_info_by_name(dev_desc,
Michael Scott8a418022015-03-11 10:02:31 -070055 aliased_part_name, info);
56 }
57 return ret;
58}
59
Steve Raecc0f08cd2016-06-07 11:19:36 -070060static lbaint_t fb_mmc_sparse_write(struct sparse_storage *info,
61 lbaint_t blk, lbaint_t blkcnt, const void *buffer)
Maxime Riparda5d1e042015-10-15 14:34:14 +020062{
Steve Raecc0f08cd2016-06-07 11:19:36 -070063 struct fb_mmc_sparse *sparse = info->priv;
Simon Glass4101f682016-02-29 15:25:34 -070064 struct blk_desc *dev_desc = sparse->dev_desc;
Maxime Riparda5d1e042015-10-15 14:34:14 +020065
Steve Raecc0f08cd2016-06-07 11:19:36 -070066 return blk_dwrite(dev_desc, blk, blkcnt, buffer);
Maxime Riparda5d1e042015-10-15 14:34:14 +020067}
68
Steve Rae2c724042016-06-07 11:19:38 -070069static lbaint_t fb_mmc_sparse_reserve(struct sparse_storage *info,
70 lbaint_t blk, lbaint_t blkcnt)
71{
72 return blkcnt;
73}
74
Simon Glass4101f682016-02-29 15:25:34 -070075static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
Steve Raec0aebb32014-08-26 11:47:27 -070076 const char *part_name, void *buffer,
77 unsigned int download_bytes)
78{
79 lbaint_t blkcnt;
80 lbaint_t blks;
81
82 /* determine number of blocks to write */
83 blkcnt = ((download_bytes + (info->blksz - 1)) & ~(info->blksz - 1));
Siarhei Siamashka5e0efc12015-10-28 06:24:16 +020084 blkcnt = lldiv(blkcnt, info->blksz);
Steve Raec0aebb32014-08-26 11:47:27 -070085
86 if (blkcnt > info->size) {
87 error("too large for partition: '%s'\n", part_name);
Steve Rae9bc34792016-06-07 11:19:37 -070088 fastboot_fail("too large for partition");
Steve Raec0aebb32014-08-26 11:47:27 -070089 return;
90 }
91
92 puts("Flashing Raw Image\n");
93
Simon Glass2a981dc2016-02-29 15:25:52 -070094 blks = blk_dwrite(dev_desc, info->start, blkcnt, buffer);
Steve Raec0aebb32014-08-26 11:47:27 -070095 if (blks != blkcnt) {
Simon Glassbcce53d2016-02-29 15:25:51 -070096 error("failed writing to device %d\n", dev_desc->devnum);
Steve Rae9bc34792016-06-07 11:19:37 -070097 fastboot_fail("failed writing to device");
Steve Raec0aebb32014-08-26 11:47:27 -070098 return;
99 }
100
101 printf("........ wrote " LBAFU " bytes to '%s'\n", blkcnt * info->blksz,
102 part_name);
Steve Rae9bc34792016-06-07 11:19:37 -0700103 fastboot_okay("");
Steve Raec0aebb32014-08-26 11:47:27 -0700104}
105
Sam Protsenkoefeccfe2017-05-18 15:04:59 +0300106#ifdef CONFIG_ANDROID_BOOT_IMAGE
107/**
108 * Read Android boot image header from boot partition.
109 *
110 * @param[in] dev_desc MMC device descriptor
111 * @param[in] info Boot partition info
112 * @param[out] hdr Where to store read boot image header
113 *
114 * @return Boot image header sectors count or 0 on error
115 */
116static lbaint_t fb_mmc_get_boot_header(struct blk_desc *dev_desc,
117 disk_partition_t *info,
118 struct andr_img_hdr *hdr)
119{
120 ulong sector_size; /* boot partition sector size */
121 lbaint_t hdr_sectors; /* boot image header sectors count */
122 int res;
123
124 /* Calculate boot image sectors count */
125 sector_size = info->blksz;
126 hdr_sectors = DIV_ROUND_UP(sizeof(struct andr_img_hdr), sector_size);
127 if (hdr_sectors == 0) {
128 error("invalid number of boot sectors: 0");
129 fastboot_fail("invalid number of boot sectors: 0");
130 return 0;
131 }
132
133 /* Read the boot image header */
134 res = blk_dread(dev_desc, info->start, hdr_sectors, (void *)hdr);
135 if (res == 0) {
136 error("cannot read header from boot partition");
137 fastboot_fail("cannot read header from boot partition");
138 return 0;
139 }
140
141 /* Check boot header magic string */
142 res = android_image_check_header(hdr);
143 if (res != 0) {
144 error("bad boot image magic");
145 fastboot_fail("boot partition not initialized");
146 return 0;
147 }
148
149 return hdr_sectors;
150}
151
152/**
153 * Write downloaded zImage to boot partition and repack it properly.
154 *
155 * @param dev_desc MMC device descriptor
156 * @param download_buffer Address to fastboot buffer with zImage in it
157 * @param download_bytes Size of fastboot buffer, in bytes
158 *
159 * @return 0 on success or -1 on error
160 */
161static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
162 void *download_buffer,
163 unsigned int download_bytes)
164{
165 u32 hdr_addr; /* boot image header address */
166 struct andr_img_hdr *hdr; /* boot image header */
167 lbaint_t hdr_sectors; /* boot image header sectors */
168 u8 *ramdisk_buffer;
169 u32 ramdisk_sector_start;
170 u32 ramdisk_sectors;
171 u32 kernel_sector_start;
172 u32 kernel_sectors;
173 u32 sectors_per_page;
174 disk_partition_t info;
175 int res;
176
177 puts("Flashing zImage\n");
178
179 /* Get boot partition info */
180 res = part_get_info_by_name(dev_desc, BOOT_PARTITION_NAME, &info);
181 if (res < 0) {
182 error("cannot find boot partition");
183 fastboot_fail("cannot find boot partition");
184 return -1;
185 }
186
187 /* Put boot image header in fastboot buffer after downloaded zImage */
188 hdr_addr = (u32)download_buffer + ALIGN(download_bytes, PAGE_SIZE);
189 hdr = (struct andr_img_hdr *)hdr_addr;
190
191 /* Read boot image header */
192 hdr_sectors = fb_mmc_get_boot_header(dev_desc, &info, hdr);
193 if (hdr_sectors == 0) {
194 error("unable to read boot image header");
195 fastboot_fail("unable to read boot image header");
196 return -1;
197 }
198
199 /* Check if boot image has second stage in it (we don't support it) */
200 if (hdr->second_size > 0) {
201 error("moving second stage is not supported yet");
202 fastboot_fail("moving second stage is not supported yet");
203 return -1;
204 }
205
206 /* Extract ramdisk location */
207 sectors_per_page = hdr->page_size / info.blksz;
208 ramdisk_sector_start = info.start + sectors_per_page;
209 ramdisk_sector_start += DIV_ROUND_UP(hdr->kernel_size, hdr->page_size) *
210 sectors_per_page;
211 ramdisk_sectors = DIV_ROUND_UP(hdr->ramdisk_size, hdr->page_size) *
212 sectors_per_page;
213
214 /* Read ramdisk and put it in fastboot buffer after boot image header */
215 ramdisk_buffer = (u8 *)hdr + (hdr_sectors * info.blksz);
216 res = blk_dread(dev_desc, ramdisk_sector_start, ramdisk_sectors,
217 ramdisk_buffer);
218 if (res == 0) {
219 error("cannot read ramdisk from boot partition");
220 fastboot_fail("cannot read ramdisk from boot partition");
221 return -1;
222 }
223
224 /* Write new kernel size to boot image header */
225 hdr->kernel_size = download_bytes;
226 res = blk_dwrite(dev_desc, info.start, hdr_sectors, (void *)hdr);
227 if (res == 0) {
228 error("cannot writeback boot image header");
229 fastboot_fail("cannot write back boot image header");
230 return -1;
231 }
232
233 /* Write the new downloaded kernel */
234 kernel_sector_start = info.start + sectors_per_page;
235 kernel_sectors = DIV_ROUND_UP(hdr->kernel_size, hdr->page_size) *
236 sectors_per_page;
237 res = blk_dwrite(dev_desc, kernel_sector_start, kernel_sectors,
238 download_buffer);
239 if (res == 0) {
240 error("cannot write new kernel");
241 fastboot_fail("cannot write new kernel");
242 return -1;
243 }
244
245 /* Write the saved ramdisk back */
246 ramdisk_sector_start = info.start + sectors_per_page;
247 ramdisk_sector_start += DIV_ROUND_UP(hdr->kernel_size, hdr->page_size) *
248 sectors_per_page;
249 res = blk_dwrite(dev_desc, ramdisk_sector_start, ramdisk_sectors,
250 ramdisk_buffer);
251 if (res == 0) {
252 error("cannot write back original ramdisk");
253 fastboot_fail("cannot write back original ramdisk");
254 return -1;
255 }
256
257 puts("........ zImage was updated in boot partition\n");
258 fastboot_okay("");
259 return 0;
260}
261#endif
262
Steve Rae64ece842016-06-07 11:19:35 -0700263void fb_mmc_flash_write(const char *cmd, void *download_buffer,
Steve Rae9bc34792016-06-07 11:19:37 -0700264 unsigned int download_bytes)
Steve Raec0aebb32014-08-26 11:47:27 -0700265{
Simon Glass4101f682016-02-29 15:25:34 -0700266 struct blk_desc *dev_desc;
Steve Raec0aebb32014-08-26 11:47:27 -0700267 disk_partition_t info;
268
Simon Glassdb1d9e72016-02-29 15:25:42 -0700269 dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
Steve Raec0aebb32014-08-26 11:47:27 -0700270 if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
271 error("invalid mmc device\n");
Steve Rae9bc34792016-06-07 11:19:37 -0700272 fastboot_fail("invalid mmc device");
Steve Raec0aebb32014-08-26 11:47:27 -0700273 return;
274 }
275
Patrick Delaunaybd42a942017-01-27 11:00:41 +0100276#if CONFIG_IS_ENABLED(EFI_PARTITION)
Steve Rae0ff7e582014-12-12 15:51:54 -0800277 if (strcmp(cmd, CONFIG_FASTBOOT_GPT_NAME) == 0) {
278 printf("%s: updating MBR, Primary and Backup GPT(s)\n",
279 __func__);
280 if (is_valid_gpt_buf(dev_desc, download_buffer)) {
281 printf("%s: invalid GPT - refusing to write to flash\n",
282 __func__);
Steve Rae9bc34792016-06-07 11:19:37 -0700283 fastboot_fail("invalid GPT partition");
Steve Rae0ff7e582014-12-12 15:51:54 -0800284 return;
285 }
286 if (write_mbr_and_gpt_partitions(dev_desc, download_buffer)) {
287 printf("%s: writing GPT partitions failed\n", __func__);
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +0200288 fastboot_fail("writing GPT partitions failed");
Steve Rae0ff7e582014-12-12 15:51:54 -0800289 return;
290 }
291 printf("........ success\n");
Steve Rae9bc34792016-06-07 11:19:37 -0700292 fastboot_okay("");
Steve Rae0ff7e582014-12-12 15:51:54 -0800293 return;
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +0200294 }
295#endif
296
Patrick Delaunayb0cf7332017-01-27 11:00:37 +0100297#if CONFIG_IS_ENABLED(DOS_PARTITION)
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +0200298 if (strcmp(cmd, CONFIG_FASTBOOT_MBR_NAME) == 0) {
299 printf("%s: updating MBR\n", __func__);
300 if (is_valid_dos_buf(download_buffer)) {
301 printf("%s: invalid MBR - refusing to write to flash\n",
302 __func__);
303 fastboot_fail("invalid MBR partition");
304 return;
305 }
306 if (write_mbr_partition(dev_desc, download_buffer)) {
307 printf("%s: writing MBR partition failed\n", __func__);
308 fastboot_fail("writing MBR partition failed");
309 return;
310 }
311 printf("........ success\n");
312 fastboot_okay("");
313 return;
314 }
315#endif
316
Sam Protsenkoefeccfe2017-05-18 15:04:59 +0300317#ifdef CONFIG_ANDROID_BOOT_IMAGE
318 if (strncasecmp(cmd, "zimage", 6) == 0) {
319 fb_mmc_update_zimage(dev_desc, download_buffer, download_bytes);
320 return;
321 }
322#endif
323
Alex Deymo88b63292017-04-02 01:49:50 -0700324 if (part_get_info_by_name_or_alias(dev_desc, cmd, &info) < 0) {
Steve Raec0aebb32014-08-26 11:47:27 -0700325 error("cannot find partition: '%s'\n", cmd);
Steve Rae9bc34792016-06-07 11:19:37 -0700326 fastboot_fail("cannot find partition");
Steve Raec0aebb32014-08-26 11:47:27 -0700327 return;
328 }
329
Maxime Riparda5d1e042015-10-15 14:34:14 +0200330 if (is_sparse_image(download_buffer)) {
331 struct fb_mmc_sparse sparse_priv;
Steve Raecc0f08cd2016-06-07 11:19:36 -0700332 struct sparse_storage sparse;
Maxime Riparda5d1e042015-10-15 14:34:14 +0200333
334 sparse_priv.dev_desc = dev_desc;
335
Steve Raecc0f08cd2016-06-07 11:19:36 -0700336 sparse.blksz = info.blksz;
Maxime Riparda5d1e042015-10-15 14:34:14 +0200337 sparse.start = info.start;
338 sparse.size = info.size;
Maxime Riparda5d1e042015-10-15 14:34:14 +0200339 sparse.write = fb_mmc_sparse_write;
Steve Rae2c724042016-06-07 11:19:38 -0700340 sparse.reserve = fb_mmc_sparse_reserve;
Maxime Riparda5d1e042015-10-15 14:34:14 +0200341
342 printf("Flashing sparse image at offset " LBAFU "\n",
Steve Raecc0f08cd2016-06-07 11:19:36 -0700343 sparse.start);
Maxime Riparda5d1e042015-10-15 14:34:14 +0200344
Steve Raecc0f08cd2016-06-07 11:19:36 -0700345 sparse.priv = &sparse_priv;
346 write_sparse_image(&sparse, cmd, download_buffer,
Steve Rae9bc34792016-06-07 11:19:37 -0700347 download_bytes);
Maxime Riparda5d1e042015-10-15 14:34:14 +0200348 } else {
Steve Raee5bf9872014-08-26 11:47:30 -0700349 write_raw_image(dev_desc, &info, cmd, download_buffer,
350 download_bytes);
Maxime Riparda5d1e042015-10-15 14:34:14 +0200351 }
Steve Raec0aebb32014-08-26 11:47:27 -0700352}
Dileep Katta89792382015-02-17 18:48:23 +0530353
Steve Rae9bc34792016-06-07 11:19:37 -0700354void fb_mmc_erase(const char *cmd)
Dileep Katta89792382015-02-17 18:48:23 +0530355{
356 int ret;
Simon Glass4101f682016-02-29 15:25:34 -0700357 struct blk_desc *dev_desc;
Dileep Katta89792382015-02-17 18:48:23 +0530358 disk_partition_t info;
359 lbaint_t blks, blks_start, blks_size, grp_size;
360 struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
361
362 if (mmc == NULL) {
363 error("invalid mmc device");
Steve Rae9bc34792016-06-07 11:19:37 -0700364 fastboot_fail("invalid mmc device");
Dileep Katta89792382015-02-17 18:48:23 +0530365 return;
366 }
367
Simon Glassdb1d9e72016-02-29 15:25:42 -0700368 dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
Dileep Katta89792382015-02-17 18:48:23 +0530369 if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
370 error("invalid mmc device");
Steve Rae9bc34792016-06-07 11:19:37 -0700371 fastboot_fail("invalid mmc device");
Dileep Katta89792382015-02-17 18:48:23 +0530372 return;
373 }
374
Petr Kulhavyb6dd69a2016-09-09 10:27:16 +0200375 ret = part_get_info_by_name_or_alias(dev_desc, cmd, &info);
Alex Deymo88b63292017-04-02 01:49:50 -0700376 if (ret < 0) {
Dileep Katta89792382015-02-17 18:48:23 +0530377 error("cannot find partition: '%s'", cmd);
Steve Rae9bc34792016-06-07 11:19:37 -0700378 fastboot_fail("cannot find partition");
Dileep Katta89792382015-02-17 18:48:23 +0530379 return;
380 }
381
382 /* Align blocks to erase group size to avoid erasing other partitions */
383 grp_size = mmc->erase_grp_size;
384 blks_start = (info.start + grp_size - 1) & ~(grp_size - 1);
385 if (info.size >= grp_size)
386 blks_size = (info.size - (blks_start - info.start)) &
387 (~(grp_size - 1));
388 else
389 blks_size = 0;
390
391 printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n",
392 blks_start, blks_start + blks_size);
393
Xu Ziyuanec3cde12016-06-15 16:56:18 +0800394 blks = blk_derase(dev_desc, blks_start, blks_size);
Dileep Katta89792382015-02-17 18:48:23 +0530395 if (blks != blks_size) {
Simon Glassbcce53d2016-02-29 15:25:51 -0700396 error("failed erasing from device %d", dev_desc->devnum);
Steve Rae9bc34792016-06-07 11:19:37 -0700397 fastboot_fail("failed erasing from device");
Dileep Katta89792382015-02-17 18:48:23 +0530398 return;
399 }
400
401 printf("........ erased " LBAFU " bytes from '%s'\n",
402 blks_size * info.blksz, cmd);
Steve Rae9bc34792016-06-07 11:19:37 -0700403 fastboot_okay("");
Dileep Katta89792382015-02-17 18:48:23 +0530404}