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