1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
// SPDX-License-Identifier: GPL-2.0+
/*
* (C) Copyright 2008 - 2009
* Windriver, <www.windriver.com>
* Tom Rix <Tom.Rix@windriver.com>
*
* Copyright 2011 Sebastian Andrzej Siewior <bigeasy@linutronix.de>
*
* Copyright 2014 Linaro, Ltd.
* Rob Herring <robh@kernel.org>
*/
#include <common.h>
#include <fastboot.h>
#include <net/fastboot.h>
/**
* fastboot_buf_addr - base address of the fastboot download buffer
*/
void *fastboot_buf_addr;
/**
* fastboot_buf_size - size of the fastboot download buffer
*/
u32 fastboot_buf_size;
/**
* fastboot_progress_callback - callback executed during long operations
*/
void (*fastboot_progress_callback)(const char *msg);
/**
* fastboot_response() - Writes a response of the form "$tag$reason".
*
* @tag: The first part of the response
* @response: Pointer to fastboot response buffer
* @format: printf style format string
*/
void fastboot_response(const char *tag, char *response,
const char *format, ...)
{
va_list args;
strlcpy(response, tag, FASTBOOT_RESPONSE_LEN);
if (format) {
va_start(args, format);
vsnprintf(response + strlen(response),
FASTBOOT_RESPONSE_LEN - strlen(response) - 1,
format, args);
va_end(args);
}
}
/**
* fastboot_fail() - Write a FAIL response of the form "FAIL$reason".
*
* @reason: Pointer to returned reason string
* @response: Pointer to fastboot response buffer
*/
void fastboot_fail(const char *reason, char *response)
{
fastboot_response("FAIL", response, "%s", reason);
}
/**
* fastboot_okay() - Write an OKAY response of the form "OKAY$reason".
*
* @reason: Pointer to returned reason string, or NULL to send a bare "OKAY"
* @response: Pointer to fastboot response buffer
*/
void fastboot_okay(const char *reason, char *response)
{
if (reason)
fastboot_response("OKAY", response, "%s", reason);
else
fastboot_response("OKAY", response, NULL);
}
/**
* fastboot_set_reboot_flag() - Set flag to indicate reboot-bootloader
*
* Set flag which indicates that we should reboot into the bootloader
* following the reboot that fastboot executes after this function.
*
* This function should be overridden in your board file with one
* which sets whatever flag your board specific Android bootloader flow
* requires in order to re-enter the bootloader.
*/
int __weak fastboot_set_reboot_flag(void)
{
return -ENOSYS;
}
/**
* fastboot_get_progress_callback() - Return progress callback
*
* Return: Pointer to function called during long operations
*/
void (*fastboot_get_progress_callback(void))(const char *)
{
return fastboot_progress_callback;
}
/**
* fastboot_boot() - Execute fastboot boot command
*
* If ${fastboot_bootcmd} is set, run that command to execute the boot
* process, if that returns, then exit the fastboot server and return
* control to the caller.
*
* Otherwise execute "bootm <fastboot_buf_addr>", if that fails, reset
* the board.
*/
void fastboot_boot(void)
{
char *s;
s = env_get("fastboot_bootcmd");
if (s) {
run_command(s, CMD_FLAG_ENV);
} else {
static char boot_addr_start[20];
static char *const bootm_args[] = {
"bootm", boot_addr_start, NULL
};
snprintf(boot_addr_start, sizeof(boot_addr_start) - 1,
"0x%p", fastboot_buf_addr);
printf("Booting kernel at %s...\n\n\n", boot_addr_start);
do_bootm(NULL, 0, 2, bootm_args);
/*
* This only happens if image is somehow faulty so we start
* over. We deliberately leave this policy to the invocation
* of fastbootcmd if that's what's being run
*/
do_reset(NULL, 0, 0, NULL);
}
}
/**
* fastboot_set_progress_callback() - set progress callback
*
* @progress: Pointer to progress callback
*
* Set a callback which is invoked periodically during long running operations
* (flash and erase). This can be used (for example) by the UDP transport to
* send INFO responses to keep the client alive whilst those commands are
* executing.
*/
void fastboot_set_progress_callback(void (*progress)(const char *msg))
{
fastboot_progress_callback = progress;
}
/*
* fastboot_init() - initialise new fastboot protocol session
*
* @buf_addr: Pointer to download buffer, or NULL for default
* @buf_size: Size of download buffer, or zero for default
*/
void fastboot_init(void *buf_addr, u32 buf_size)
{
fastboot_buf_addr = buf_addr ? buf_addr :
(void *)CONFIG_FASTBOOT_BUF_ADDR;
fastboot_buf_size = buf_size ? buf_size : CONFIG_FASTBOOT_BUF_SIZE;
fastboot_set_progress_callback(NULL);
}
|
