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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
/*
* FIRMWARE Greybus driver.
*
* Copyright 2015 Google Inc.
* Copyright 2015 Linaro Ltd.
*
* Released under the GPLv2 only.
*/
#include <linux/firmware.h>
#include "greybus.h"
struct gb_firmware {
struct gb_connection *connection;
const struct firmware *fw;
};
static void free_firmware(struct gb_firmware *firmware)
{
release_firmware(firmware->fw);
firmware->fw = NULL;
}
/* This returns path of the firmware blob on the disk */
static int download_firmware(struct gb_firmware *firmware, u8 stage)
{
struct gb_connection *connection = firmware->connection;
struct gb_interface *intf = connection->bundle->intf;
char firmware_name[48];
/* Already have a firmware, free it */
if (firmware->fw)
free_firmware(firmware);
/*
* Create firmware name
*
* XXX Name it properly..
*/
snprintf(firmware_name, sizeof(firmware_name),
"ara:%08x:%08x:%08x:%08x:%02x.tftf",
intf->unipro_mfg_id, intf->unipro_prod_id,
intf->ara_vend_id, intf->ara_prod_id, stage);
return request_firmware(&firmware->fw, firmware_name, &connection->dev);
}
static int gb_firmware_size_request(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_firmware *firmware = connection->private;
struct gb_firmware_size_request *size_request = op->request->payload;
struct gb_firmware_size_response *size_response;
struct device *dev = &connection->dev;
int ret;
if (op->request->payload_size != sizeof(*size_request)) {
dev_err(dev, "%s: illegal size of firmware size request (%zu != %zu)\n",
__func__, op->request->payload_size,
sizeof(*size_request));
return -EINVAL;
}
ret = download_firmware(firmware, size_request->stage);
if (ret) {
dev_err(dev, "%s: failed to download firmware (%d)\n", __func__,
ret);
return ret;
}
if (!gb_operation_response_alloc(op, sizeof(*size_response),
GFP_KERNEL)) {
dev_err(dev, "%s: error allocating response\n", __func__);
free_firmware(firmware);
return -ENOMEM;
}
size_response = op->response->payload;
size_response->size = cpu_to_le32(firmware->fw->size);
return 0;
}
static int gb_firmware_get_firmware(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_firmware *firmware = connection->private;
struct gb_firmware_get_firmware_request *firmware_request = op->request->payload;
struct gb_firmware_get_firmware_response *firmware_response;
struct device *dev = &connection->dev;
unsigned int offset, size;
if (op->request->payload_size != sizeof(*firmware_request)) {
dev_err(dev, "%s: Illegal size of get firmware request (%zu %zu)\n",
__func__, op->request->payload_size,
sizeof(*firmware_request));
return -EINVAL;
}
if (!firmware->fw) {
dev_err(dev, "%s: firmware not available\n", __func__);
return -EINVAL;
}
offset = le32_to_cpu(firmware_request->offset);
size = le32_to_cpu(firmware_request->size);
if (!gb_operation_response_alloc(op, sizeof(*firmware_response) + size,
GFP_KERNEL)) {
dev_err(dev, "%s: error allocating response\n", __func__);
return -ENOMEM;
}
firmware_response = op->response->payload;
memcpy(firmware_response->data, firmware->fw->data + offset, size);
return 0;
}
static int gb_firmware_ready_to_boot(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_firmware_ready_to_boot_request *rtb_request = op->request->payload;
struct device *dev = &connection->dev;
u8 status;
if (op->request->payload_size != sizeof(*rtb_request)) {
dev_err(dev, "%s: Illegal size of ready to boot request (%zu %zu)\n",
__func__, op->request->payload_size,
sizeof(*rtb_request));
return -EINVAL;
}
status = rtb_request->status;
/* Return error if the blob was invalid */
if (status == GB_FIRMWARE_BOOT_STATUS_INVALID)
return -EINVAL;
/*
* XXX Should we return error for insecure firmware?
*/
return 0;
}
static int gb_firmware_request_recv(u8 type, struct gb_operation *op)
{
switch (type) {
case GB_FIRMWARE_TYPE_FIRMWARE_SIZE:
return gb_firmware_size_request(op);
case GB_FIRMWARE_TYPE_GET_FIRMWARE:
return gb_firmware_get_firmware(op);
case GB_FIRMWARE_TYPE_READY_TO_BOOT:
return gb_firmware_ready_to_boot(op);
default:
dev_err(&op->connection->dev,
"unsupported request: %hhu\n", type);
return -EINVAL;
}
}
static int gb_firmware_connection_init(struct gb_connection *connection)
{
struct gb_firmware *firmware;
int ret;
firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
if (!firmware)
return -ENOMEM;
firmware->connection = connection;
connection->private = firmware;
/*
* Module's Bootrom needs a way to know (currently), when to start
* sending requests to the AP. The version request is sent before this
* routine is called, and if the module sends the request right after
* receiving version request, the connection->private field will be
* NULL.
*
* Fix this TEMPORARILY by sending an AP_READY request.
*/
ret = gb_operation_sync(connection, GB_FIRMWARE_TYPE_AP_READY, NULL, 0,
NULL, 0);
if (ret)
dev_err(&connection->dev, "Failed to send AP READY (%d)\n", ret);
return 0;
}
static void gb_firmware_connection_exit(struct gb_connection *connection)
{
struct gb_firmware *firmware = connection->private;
/* Release firmware */
if (firmware->fw)
free_firmware(firmware);
connection->private = NULL;
kfree(firmware);
}
static struct gb_protocol firmware_protocol = {
.name = "firmware",
.id = GREYBUS_PROTOCOL_FIRMWARE,
.major = GB_FIRMWARE_VERSION_MAJOR,
.minor = GB_FIRMWARE_VERSION_MINOR,
.connection_init = gb_firmware_connection_init,
.connection_exit = gb_firmware_connection_exit,
.request_recv = gb_firmware_request_recv,
.flags = GB_PROTOCOL_SKIP_CONTROL_DISCONNECTED,
};
gb_builtin_protocol_driver(firmware_protocol);
|
