net/fastboot.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 <net.h>
   9 #include <net/fastboot.h>
  10
  11 /* Fastboot port # defined in spec */
  12 #define WELL_KNOWN_PORT 5554
  13
  14 enum {
  15         FASTBOOT_ERROR = 0,
  16         FASTBOOT_QUERY = 1,
  17         FASTBOOT_INIT = 2,
  18         FASTBOOT_FASTBOOT = 3,
  19 };
  20
  21 struct __packed fastboot_header {
  22         uchar id;
  23         uchar flags;
  24         unsigned short seq;
  25 };
  26
  27 #define PACKET_SIZE 1024
  28 #define DATA_SIZE (PACKET_SIZE - sizeof(struct fastboot_header))
  29
  30 /* Sequence number sent for every packet */
  31 static unsigned short sequence_number = 1;
  32 static const unsigned short packet_size = PACKET_SIZE;
  33 static const unsigned short udp_version = 1;
  34
  35 /* Keep track of last packet for resubmission */
  36 static uchar last_packet[PACKET_SIZE];
  37 static unsigned int last_packet_len;
  38
  39 static struct in_addr fastboot_remote_ip;
  40 /* The UDP port at their end */
  41 static int fastboot_remote_port;
  42 /* The UDP port at our end */
  43 static int fastboot_our_port;
  44
  45 static void boot_downloaded_image(void);
  46
  47 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
  48 /**
  49  * fastboot_udp_send_info() - Send an INFO packet during long commands.
  50  *
  51  * @msg: String describing the reason for waiting
  52  */
  53 static void fastboot_udp_send_info(const char *msg)
  54 {
  55         uchar *packet;
  56         uchar *packet_base;
  57         int len = 0;
  58         char response[FASTBOOT_RESPONSE_LEN] = {0};
  59
  60         struct fastboot_header response_header = {
  61                 .id = FASTBOOT_FASTBOOT,
  62                 .flags = 0,
  63                 .seq = htons(sequence_number)
  64         };
  65         ++sequence_number;
  66         packet = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
  67         packet_base = packet;
  68
  69         /* Write headers */
  70         memcpy(packet, &response_header, sizeof(response_header));
  71         packet += sizeof(response_header);
  72         /* Write response */
  73         fastboot_response("INFO", response, "%s", msg);
  74         memcpy(packet, response, strlen(response));
  75         packet += strlen(response);
  76
  77         len = packet - packet_base;
  78
  79         /* Save packet for retransmitting */
  80         last_packet_len = len;
  81         memcpy(last_packet, packet_base, last_packet_len);
  82
  83         net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
  84                             fastboot_remote_port, fastboot_our_port, len);
  85 }
  86
  87 /**
  88  * fastboot_timed_send_info() - Send INFO packet every 30 seconds
  89  *
  90  * @msg: String describing the reason for waiting
  91  *
  92  * Send an INFO packet during long commands based on timer. An INFO packet
  93  * is sent if the time is 30 seconds after start. Else, noop.
  94  */
  95 static void fastboot_timed_send_info(const char *msg)
  96 {
  97         static ulong start;
  98
  99         /* Initialize timer */
 100         if (start == 0)
 101                 start = get_timer(0);
 102         ulong time = get_timer(start);
 103         /* Send INFO packet to host every 30 seconds */
 104         if (time >= 30000) {
 105                 start = get_timer(0);
 106                 fastboot_udp_send_info(msg);
 107         }
 108 }
 109 #endif
 110
 111 /**
 112  * fastboot_send() - Sends a packet in response to received fastboot packet
 113  *
 114  * @header: Header for response packet
 115  * @fastboot_data: Pointer to received fastboot data
 116  * @fastboot_data_len: Length of received fastboot data
 117  * @retransmit: Nonzero if sending last sent packet
 118  */
 119 static void fastboot_send(struct fastboot_header header, char *fastboot_data,
 120                           unsigned int fastboot_data_len, uchar retransmit)
 121 {
 122         uchar *packet;
 123         uchar *packet_base;
 124         int len = 0;
 125         const char *error_msg = "An error occurred.";
 126         short tmp;
 127         struct fastboot_header response_header = header;
 128         static char command[FASTBOOT_COMMAND_LEN];
 129         static int cmd = -1;
 130         static bool pending_command;
 131         char response[FASTBOOT_RESPONSE_LEN] = {0};
 132
 133         /*
 134          * We will always be sending some sort of packet, so
 135          * cobble together the packet headers now.
 136          */
 137         packet = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
 138         packet_base = packet;
 139
 140         /* Resend last packet */
 141         if (retransmit) {
 142                 memcpy(packet, last_packet, last_packet_len);
 143                 net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
 144                                     fastboot_remote_port, fastboot_our_port,
 145                                     last_packet_len);
 146                 return;
 147         }
 148
 149         response_header.seq = htons(response_header.seq);
 150         memcpy(packet, &response_header, sizeof(response_header));
 151         packet += sizeof(response_header);
 152
 153         switch (header.id) {
 154         case FASTBOOT_QUERY:
 155                 tmp = htons(sequence_number);
 156                 memcpy(packet, &tmp, sizeof(tmp));
 157                 packet += sizeof(tmp);
 158                 break;
 159         case FASTBOOT_INIT:
 160                 tmp = htons(udp_version);
 161                 memcpy(packet, &tmp, sizeof(tmp));
 162                 packet += sizeof(tmp);
 163                 tmp = htons(packet_size);
 164                 memcpy(packet, &tmp, sizeof(tmp));
 165                 packet += sizeof(tmp);
 166                 break;
 167         case FASTBOOT_ERROR:
 168                 memcpy(packet, error_msg, strlen(error_msg));
 169                 packet += strlen(error_msg);
 170                 break;
 171         case FASTBOOT_FASTBOOT:
 172                 if (cmd == FASTBOOT_COMMAND_DOWNLOAD) {
 173                         if (!fastboot_data_len && !fastboot_data_remaining()) {
 174                                 fastboot_data_complete(response);
 175                         } else {
 176                                 fastboot_data_download(fastboot_data,
 177                                                        fastboot_data_len,
 178                                                        response);
 179                         }
 180                 } else if (!pending_command) {
 181                         strlcpy(command, fastboot_data,
 182                                 min((size_t)fastboot_data_len + 1,
 183                                     sizeof(command)));
 184                         pending_command = true;
 185                 } else {
 186                         cmd = fastboot_handle_command(command, response);
 187                         pending_command = false;
 188                 }
 189                 /*
 190                  * Sent some INFO packets, need to update sequence number in
 191                  * header
 192                  */
 193                 if (header.seq != sequence_number) {
 194                         response_header.seq = htons(sequence_number);
 195                         memcpy(packet_base, &response_header,
 196                                sizeof(response_header));
 197                 }
 198                 /* Write response to packet */
 199                 memcpy(packet, response, strlen(response));
 200                 packet += strlen(response);
 201                 break;
 202         default:
 203                 pr_err("ID %d not implemented.\n", header.id);
 204                 return;
 205         }
 206
 207         len = packet - packet_base;
 208
 209         /* Save packet for retransmitting */
 210         last_packet_len = len;
 211         memcpy(last_packet, packet_base, last_packet_len);
 212
 213         net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
 214                             fastboot_remote_port, fastboot_our_port, len);
 215
 216         /* Continue boot process after sending response */
 217         if (!strncmp("OKAY", response, 4)) {
 218                 switch (cmd) {
 219                 case FASTBOOT_COMMAND_BOOT:
 220                         boot_downloaded_image();
 221                         break;
 222
 223                 case FASTBOOT_COMMAND_CONTINUE:
 224                         net_set_state(NETLOOP_SUCCESS);
 225                         break;
 226
 227                 case FASTBOOT_COMMAND_REBOOT:
 228                 case FASTBOOT_COMMAND_REBOOT_BOOTLOADER:
 229                         do_reset(NULL, 0, 0, NULL);
 230                         break;
 231                 }
 232         }
 233
 234         if (!strncmp("OKAY", response, 4) || !strncmp("FAIL", response, 4))
 235                 cmd = -1;
 236 }
 237
 238 /**
 239  * boot_downloaded_image() - Boots into downloaded image.
 240  */
 241 static void boot_downloaded_image(void)
 242 {
 243         fastboot_boot();
 244         net_set_state(NETLOOP_SUCCESS);
 245 }
 246
 247 /**
 248  * fastboot_handler() - Incoming UDP packet handler.
 249  *
 250  * @packet: Pointer to incoming UDP packet
 251  * @dport: Destination UDP port
 252  * @sip: Source IP address
 253  * @sport: Source UDP port
 254  * @len: Packet length
 255  */
 256 static void fastboot_handler(uchar *packet, unsigned int dport,
 257                              struct in_addr sip, unsigned int sport,
 258                              unsigned int len)
 259 {
 260         struct fastboot_header header;
 261         char fastboot_data[DATA_SIZE] = {0};
 262         unsigned int fastboot_data_len = 0;
 263
 264         if (dport != fastboot_our_port)
 265                 return;
 266
 267         fastboot_remote_ip = sip;
 268         fastboot_remote_port = sport;
 269
 270         if (len < sizeof(struct fastboot_header) || len > PACKET_SIZE)
 271                 return;
 272         memcpy(&header, packet, sizeof(header));
 273         header.flags = 0;
 274         header.seq = ntohs(header.seq);
 275         packet += sizeof(header);
 276         len -= sizeof(header);
 277
 278         switch (header.id) {
 279         case FASTBOOT_QUERY:
 280                 fastboot_send(header, fastboot_data, 0, 0);
 281                 break;
 282         case FASTBOOT_INIT:
 283         case FASTBOOT_FASTBOOT:
 284                 fastboot_data_len = len;
 285                 if (len > 0)
 286                         memcpy(fastboot_data, packet, len);
 287                 if (header.seq == sequence_number) {
 288                         fastboot_send(header, fastboot_data,
 289                                       fastboot_data_len, 0);
 290                         sequence_number++;
 291                 } else if (header.seq == sequence_number - 1) {
 292                         /* Retransmit last sent packet */
 293                         fastboot_send(header, fastboot_data,
 294                                       fastboot_data_len, 1);
 295                 }
 296                 break;
 297         default:
 298                 pr_err("ID %d not implemented.\n", header.id);
 299                 header.id = FASTBOOT_ERROR;
 300                 fastboot_send(header, fastboot_data, 0, 0);
 301                 break;
 302         }
 303 }
 304
 305 void fastboot_start_server(void)
 306 {
 307         printf("Using %s device\n", eth_get_name());
 308         printf("Listening for fastboot command on %pI4\n", &net_ip);
 309
 310         fastboot_our_port = WELL_KNOWN_PORT;
 311
 312 #if CONFIG_IS_ENABLED(FASTBOOT_FLASH)
 313         fastboot_set_progress_callback(fastboot_timed_send_info);
 314 #endif
 315         net_set_udp_handler(fastboot_handler);
 316
 317         /* zero out server ether in case the server ip has changed */
 318         memset(net_server_ethaddr, 0, 6);
 319 }