1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (C) 2016 The Android Open Source Project 4 */ 5 6 #include <common.h> 7 #include <fastboot.h> 8 #include <fastboot-internal.h> 9 #include <fb_mmc.h> 10 #include <fb_nand.h> 11 #include <part.h> 12 #include <stdlib.h> 13 14 /** 15 * image_size - final fastboot image size 16 */ 17 static u32 image_size; 18 19 /** 20 * fastboot_bytes_received - number of bytes received in the current download 21 */ 22 static u32 fastboot_bytes_received; 23 24 /** 25 * fastboot_bytes_expected - number of bytes expected in the current download 26 */ 27 static u32 fastboot_bytes_expected; 28 29 static void okay(char *, char *); 30 static void getvar(char *, char *); 31 static void download(char *, char *); 32 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH) 33 static void flash(char *, char *); 34 static void erase(char *, char *); 35 #endif 36 static void reboot_bootloader(char *, char *); 37 #if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT) 38 static void oem_format(char *, char *); 39 #endif 40 41 static const struct { 42 const char *command; 43 void (*dispatch)(char *cmd_parameter, char *response); 44 } commands[FASTBOOT_COMMAND_COUNT] = { 45 [FASTBOOT_COMMAND_GETVAR] = { 46 .command = "getvar", 47 .dispatch = getvar 48 }, 49 [FASTBOOT_COMMAND_DOWNLOAD] = { 50 .command = "download", 51 .dispatch = download 52 }, 53 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH) 54 [FASTBOOT_COMMAND_FLASH] = { 55 .command = "flash", 56 .dispatch = flash 57 }, 58 [FASTBOOT_COMMAND_ERASE] = { 59 .command = "erase", 60 .dispatch = erase 61 }, 62 #endif 63 [FASTBOOT_COMMAND_BOOT] = { 64 .command = "boot", 65 .dispatch = okay 66 }, 67 [FASTBOOT_COMMAND_CONTINUE] = { 68 .command = "continue", 69 .dispatch = okay 70 }, 71 [FASTBOOT_COMMAND_REBOOT] = { 72 .command = "reboot", 73 .dispatch = okay 74 }, 75 [FASTBOOT_COMMAND_REBOOT_BOOTLOADER] = { 76 .command = "reboot-bootloader", 77 .dispatch = reboot_bootloader 78 }, 79 [FASTBOOT_COMMAND_SET_ACTIVE] = { 80 .command = "set_active", 81 .dispatch = okay 82 }, 83 #if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT) 84 [FASTBOOT_COMMAND_OEM_FORMAT] = { 85 .command = "oem format", 86 .dispatch = oem_format, 87 }, 88 #endif 89 }; 90 91 /** 92 * fastboot_handle_command - Handle fastboot command 93 * 94 * @cmd_string: Pointer to command string 95 * @response: Pointer to fastboot response buffer 96 * 97 * Return: Executed command, or -1 if not recognized 98 */ 99 int fastboot_handle_command(char *cmd_string, char *response) 100 { 101 int i; 102 char *cmd_parameter; 103 104 cmd_parameter = cmd_string; 105 strsep(&cmd_parameter, ":"); 106 107 for (i = 0; i < FASTBOOT_COMMAND_COUNT; i++) { 108 if (!strcmp(commands[i].command, cmd_string)) { 109 if (commands[i].dispatch) { 110 commands[i].dispatch(cmd_parameter, 111 response); 112 return i; 113 } else { 114 break; 115 } 116 } 117 } 118 119 pr_err("command %s not recognized.\n", cmd_string); 120 fastboot_fail("unrecognized command", response); 121 return -1; 122 } 123 124 /** 125 * okay() - Send bare OKAY response 126 * 127 * @cmd_parameter: Pointer to command parameter 128 * @response: Pointer to fastboot response buffer 129 * 130 * Send a bare OKAY fastboot response. This is used where the command is 131 * valid, but all the work is done after the response has been sent (e.g. 132 * boot, reboot etc.) 133 */ 134 static void okay(char *cmd_parameter, char *response) 135 { 136 fastboot_okay(NULL, response); 137 } 138 139 /** 140 * getvar() - Read a config/version variable 141 * 142 * @cmd_parameter: Pointer to command parameter 143 * @response: Pointer to fastboot response buffer 144 */ 145 static void getvar(char *cmd_parameter, char *response) 146 { 147 fastboot_getvar(cmd_parameter, response); 148 } 149 150 /** 151 * fastboot_download() - Start a download transfer from the client 152 * 153 * @cmd_parameter: Pointer to command parameter 154 * @response: Pointer to fastboot response buffer 155 */ 156 static void download(char *cmd_parameter, char *response) 157 { 158 char *tmp; 159 160 if (!cmd_parameter) { 161 fastboot_fail("Expected command parameter", response); 162 return; 163 } 164 fastboot_bytes_received = 0; 165 fastboot_bytes_expected = simple_strtoul(cmd_parameter, &tmp, 16); 166 if (fastboot_bytes_expected == 0) { 167 fastboot_fail("Expected nonzero image size", response); 168 return; 169 } 170 /* 171 * Nothing to download yet. Response is of the form: 172 * [DATA|FAIL]$cmd_parameter 173 * 174 * where cmd_parameter is an 8 digit hexadecimal number 175 */ 176 if (fastboot_bytes_expected > fastboot_buf_size) { 177 fastboot_fail(cmd_parameter, response); 178 } else { 179 printf("Starting download of %d bytes\n", 180 fastboot_bytes_expected); 181 fastboot_response("DATA", response, "%s", cmd_parameter); 182 } 183 } 184 185 /** 186 * fastboot_data_remaining() - return bytes remaining in current transfer 187 * 188 * Return: Number of bytes left in the current download 189 */ 190 u32 fastboot_data_remaining(void) 191 { 192 return fastboot_bytes_expected - fastboot_bytes_received; 193 } 194 195 /** 196 * fastboot_data_download() - Copy image data to fastboot_buf_addr. 197 * 198 * @fastboot_data: Pointer to received fastboot data 199 * @fastboot_data_len: Length of received fastboot data 200 * @response: Pointer to fastboot response buffer 201 * 202 * Copies image data from fastboot_data to fastboot_buf_addr. Writes to 203 * response. fastboot_bytes_received is updated to indicate the number 204 * of bytes that have been transferred. 205 * 206 * On completion sets image_size and ${filesize} to the total size of the 207 * downloaded image. 208 */ 209 void fastboot_data_download(const void *fastboot_data, 210 unsigned int fastboot_data_len, 211 char *response) 212 { 213 #define BYTES_PER_DOT 0x20000 214 u32 pre_dot_num, now_dot_num; 215 216 if (fastboot_data_len == 0 || 217 (fastboot_bytes_received + fastboot_data_len) > 218 fastboot_bytes_expected) { 219 fastboot_fail("Received invalid data length", 220 response); 221 return; 222 } 223 /* Download data to fastboot_buf_addr */ 224 memcpy(fastboot_buf_addr + fastboot_bytes_received, 225 fastboot_data, fastboot_data_len); 226 227 pre_dot_num = fastboot_bytes_received / BYTES_PER_DOT; 228 fastboot_bytes_received += fastboot_data_len; 229 now_dot_num = fastboot_bytes_received / BYTES_PER_DOT; 230 231 if (pre_dot_num != now_dot_num) { 232 putc('.'); 233 if (!(now_dot_num % 74)) 234 putc('\n'); 235 } 236 *response = '\0'; 237 } 238 239 /** 240 * fastboot_data_complete() - Mark current transfer complete 241 * 242 * @response: Pointer to fastboot response buffer 243 * 244 * Set image_size and ${filesize} to the total size of the downloaded image. 245 */ 246 void fastboot_data_complete(char *response) 247 { 248 /* Download complete. Respond with "OKAY" */ 249 fastboot_okay(NULL, response); 250 printf("\ndownloading of %d bytes finished\n", fastboot_bytes_received); 251 image_size = fastboot_bytes_received; 252 env_set_hex("filesize", image_size); 253 fastboot_bytes_expected = 0; 254 fastboot_bytes_received = 0; 255 } 256 257 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH) 258 /** 259 * flash() - write the downloaded image to the indicated partition. 260 * 261 * @cmd_parameter: Pointer to partition name 262 * @response: Pointer to fastboot response buffer 263 * 264 * Writes the previously downloaded image to the partition indicated by 265 * cmd_parameter. Writes to response. 266 */ 267 static void flash(char *cmd_parameter, char *response) 268 { 269 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC) 270 fastboot_mmc_flash_write(cmd_parameter, fastboot_buf_addr, image_size, 271 response); 272 #endif 273 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH_NAND) 274 fastboot_nand_flash_write(cmd_parameter, fastboot_buf_addr, image_size, 275 response); 276 #endif 277 } 278 279 /** 280 * erase() - erase the indicated partition. 281 * 282 * @cmd_parameter: Pointer to partition name 283 * @response: Pointer to fastboot response buffer 284 * 285 * Erases the partition indicated by cmd_parameter (clear to 0x00s). Writes 286 * to response. 287 */ 288 static void erase(char *cmd_parameter, char *response) 289 { 290 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH_MMC) 291 fastboot_mmc_erase(cmd_parameter, response); 292 #endif 293 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH_NAND) 294 fastboot_nand_erase(cmd_parameter, response); 295 #endif 296 } 297 #endif 298 299 /** 300 * reboot_bootloader() - Sets reboot bootloader flag. 301 * 302 * @cmd_parameter: Pointer to command parameter 303 * @response: Pointer to fastboot response buffer 304 */ 305 static void reboot_bootloader(char *cmd_parameter, char *response) 306 { 307 if (fastboot_set_reboot_flag()) 308 fastboot_fail("Cannot set reboot flag", response); 309 else 310 fastboot_okay(NULL, response); 311 } 312 313 #if CONFIG_IS_ENABLED(FASTBOOT_CMD_OEM_FORMAT) 314 /** 315 * oem_format() - Execute the OEM format command 316 * 317 * @cmd_parameter: Pointer to command parameter 318 * @response: Pointer to fastboot response buffer 319 */ 320 static void oem_format(char *cmd_parameter, char *response) 321 { 322 char cmdbuf[32]; 323 324 if (!env_get("partitions")) { 325 fastboot_fail("partitions not set", response); 326 } else { 327 sprintf(cmdbuf, "gpt write mmc %x $partitions", 328 CONFIG_FASTBOOT_FLASH_MMC_DEV); 329 if (run_command(cmdbuf, 0)) 330 fastboot_fail("", response); 331 else 332 fastboot_okay(NULL, response); 333 } 334 } 335 #endif 336
