git.sur5r.net Git - u-boot/blob - drivers/fastboot/fb_command.c

   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