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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
/*
* Copyright 2018 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*
* A reference implementation for AP (and supporting images) firmware updater.
*/
#include <assert.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include "futility.h"
#include "host_misc.h"
#include "utility.h"
/* flashrom programmers. */
static const char * const PROG_HOST = "host",
* const PROG_EC = "ec",
* const PROG_PD = "ec:dev=1";
struct firmware_image {
const char *programmer;
uint32_t size;
uint8_t *data;
char *file_name;
char *ro_version, *rw_version_a, *rw_version_b;
};
struct updater_config {
struct firmware_image image, image_current;
struct firmware_image ec_image, pd_image;
};
/*
* Loads a firmware image from file.
* Returns 0 on success, otherwise failure.
*/
static int load_image(const char *file_name, struct firmware_image *image)
{
Debug("%s: Load image file from %s...\n", __FUNCTION__, file_name);
if (vb2_read_file(file_name, &image->data, &image->size) != VB2_SUCCESS)
{
Error("%s: Failed to load %s\n", __FUNCTION__, file_name);
return -1;
}
Debug("%s: Image size: %d\n", __FUNCTION__, image->size);
assert(image->data);
image->file_name = strdup(file_name);
return 0;
}
/*
* Frees the allocated resource from a firmware image object.
*/
static void free_image(struct firmware_image *image)
{
free(image->data);
free(image->file_name);
free(image->ro_version);
free(image->rw_version_a);
free(image->rw_version_b);
memset(image, 0, sizeof(*image));
}
enum updater_error_codes {
UPDATE_ERR_DONE,
UPDATE_ERR_UNKNOWN,
};
static const char * const updater_error_messages[] = {
[UPDATE_ERR_DONE] = "Done (no error)",
[UPDATE_ERR_UNKNOWN] = "Unknown error.",
};
/*
* The main updater to update system firmware using the configuration parameter.
* Returns UPDATE_ERR_DONE if success, otherwise failure.
*/
static enum updater_error_codes update_firmware(struct updater_config *cfg)
{
return UPDATE_ERR_DONE;
}
/*
* Releases all loaded images in an updater configuration object.
*/
static void unload_updater_config(struct updater_config *cfg)
{
free_image(&cfg->image);
free_image(&cfg->image_current);
free_image(&cfg->ec_image);
free_image(&cfg->pd_image);
}
/* Command line options */
static struct option const long_opts[] = {
/* name has_arg *flag val */
{"image", 1, NULL, 'i'},
{"ec_image", 1, NULL, 'e'},
{"pd_image", 1, NULL, 'P'},
{"help", 0, NULL, 'h'},
{NULL, 0, NULL, 0},
};
static const char * const short_opts = "hi:e:";
static void print_help(int argc, char *argv[])
{
printf("\n"
"Usage: " MYNAME " %s [OPTIONS]\n"
"\n"
"-i, --image=FILE \tAP (host) firmware image (image.bin)\n"
"-e, --ec_image=FILE \tEC firmware image (i.e, ec.bin)\n"
" --pd_image=FILE \tPD firmware image (i.e, pd.bin)\n"
"",
argv[0]);
}
static int do_update(int argc, char *argv[])
{
int i, errorcnt = 0;
struct updater_config cfg = {
.image = { .programmer = PROG_HOST, },
.image_current = { .programmer = PROG_HOST, },
.ec_image = { .programmer = PROG_EC, },
.pd_image = { .programmer = PROG_PD, },
};
printf(">> Firmware updater started.\n");
opterr = 0;
while ((i = getopt_long(argc, argv, short_opts, long_opts, 0)) != -1) {
switch (i) {
case 'i':
errorcnt += load_image(optarg, &cfg.image);
break;
case 'e':
errorcnt += load_image(optarg, &cfg.ec_image);
break;
case 'P':
errorcnt += load_image(optarg, &cfg.pd_image);
break;
case 'h':
print_help(argc, argv);
return !!errorcnt;
case '?':
errorcnt++;
if (optopt)
Error("Unrecognized option: -%c\n", optopt);
else if (argv[optind - 1])
Error("Unrecognized option (possibly '%s')\n",
argv[optind - 1]);
else
Error("Unrecognized option.\n");
break;
default:
errorcnt++;
Error("Failed parsing options.\n");
}
}
if (optind < argc) {
errorcnt++;
Error("Unexpected arguments.\n");
}
if (!errorcnt) {
int r = update_firmware(&cfg);
if (r != UPDATE_ERR_DONE) {
r = Min(r, UPDATE_ERR_UNKNOWN);
Error("%s\n", updater_error_messages[r]);
errorcnt++;
}
}
printf(">> %s: Firmware updater %s.\n",
errorcnt ? "FAILED": "DONE",
errorcnt ? "stopped due to error" : "exited successfully");
unload_updater_config(&cfg);
return !!errorcnt;
}
DECLARE_FUTIL_COMMAND(update, do_update, VBOOT_VERSION_ALL,
"Update system firmware");
|
