1 // SPDX-License-Identifier: GPL-2.0-only
3 * Intel Wireless UWB Link 1480
4 * MAC Firmware upload implementation
6 * Copyright (C) 2005-2006 Intel Corporation
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9 * Implementation of the code for parsing the firmware file (extract
10 * the headers and binary code chunks) in the fw_*() functions. The
11 * code to upload pre and mac firmwares is the same, so it uses a
12 * common entry point in __mac_fw_upload(), which uses the i1480
13 * function pointers to push the firmware to the device.
15 #include <linux/delay.h>
16 #include <linux/firmware.h>
17 #include <linux/slab.h>
18 #include "../../uwb.h"
19 #include "i1480-dfu.h"
22 * Descriptor for a continuous segment of MAC fw data
25 unsigned long address;
32 /* Free a chain of firmware headers */
34 void fw_hdrs_free(struct fw_hdr *hdr)
46 /* Fill a firmware header descriptor from a memory buffer */
48 int fw_hdr_load(struct i1480 *i1480, struct fw_hdr *hdr, unsigned hdr_cnt,
49 const char *_data, const u32 *data_itr, const u32 *data_top)
51 size_t hdr_offset = (const char *) data_itr - _data;
52 size_t remaining_size = (void *) data_top - (void *) data_itr;
53 if (data_itr + 2 > data_top) {
54 dev_err(i1480->dev, "fw hdr #%u/%zu: EOF reached in header at "
55 "offset %zu, limit %zu\n",
57 (const char *) data_itr + 2 - _data,
58 (const char *) data_top - _data);
62 hdr->address = le32_to_cpu(*data_itr++);
63 hdr->length = le32_to_cpu(*data_itr++);
65 if (hdr->length > remaining_size) {
66 dev_err(i1480->dev, "fw hdr #%u/%zu: EOF reached in data; "
67 "chunk too long (%zu bytes), only %zu left\n",
68 hdr_cnt, hdr_offset, hdr->length, remaining_size);
76 * Get a buffer where the firmware is supposed to be and create a
77 * chain of headers linking them together.
79 * @phdr: where to place the pointer to the first header (headers link
80 * to the next via the @hdr->next ptr); need to free the whole
83 * @_data: Pointer to the data buffer.
85 * @_data_size: Size of the data buffer (bytes); data size has to be a
86 * multiple of 4. Function will fail if not.
88 * Goes over the whole binary blob; reads the first chunk and creates
89 * a fw hdr from it (which points to where the data is in @_data and
90 * the length of the chunk); then goes on to the next chunk until
91 * done. Each header is linked to the next.
94 int fw_hdrs_load(struct i1480 *i1480, struct fw_hdr **phdr,
95 const char *_data, size_t data_size)
99 u32 *data = (u32 *) _data, *data_itr, *data_top;
100 struct fw_hdr *hdr, **prev_hdr = phdr;
103 /* Check size is ok and pointer is aligned */
104 if (data_size % sizeof(u32) != 0)
106 if ((unsigned long) _data % sizeof(u16) != 0)
110 data_top = (u32 *) (_data + data_size);
111 while (data_itr < data_top) {
113 hdr = kmalloc(sizeof(*hdr), GFP_KERNEL);
115 dev_err(i1480->dev, "Cannot allocate fw header "
116 "for chunk #%u\n", hdr_cnt);
119 result = fw_hdr_load(i1480, hdr, hdr_cnt,
120 _data, data_itr, data_top);
123 data_itr += 2 + hdr->length;
125 prev_hdr = &hdr->next;
141 * Compares a chunk of fw with one in the devices's memory
143 * @i1480: Device instance
144 * @hdr: Pointer to the firmware chunk
145 * @returns: 0 if equal, < 0 errno on error. If > 0, it is the offset
146 * where the difference was found (plus one).
148 * Kind of dirty and simplistic, but does the trick in both the PCI
149 * and USB version. We do a quick[er] memcmp(), and if it fails, we do
150 * a byte-by-byte to find the offset.
153 ssize_t i1480_fw_cmp(struct i1480 *i1480, struct fw_hdr *hdr)
156 u32 src_itr = 0, cnt;
157 size_t size = hdr->length*sizeof(hdr->bin[0]);
159 u8 *bin = (u8 *) hdr->bin;
162 chunk_size = size < i1480->buf_size ? size : i1480->buf_size;
163 result = i1480->read(i1480, hdr->address + src_itr, chunk_size);
165 dev_err(i1480->dev, "error reading for verification: "
169 if (memcmp(i1480->cmd_buf, bin + src_itr, result)) {
170 u8 *buf = i1480->cmd_buf;
171 for (cnt = 0; cnt < result; cnt++)
172 if (bin[src_itr + cnt] != buf[cnt]) {
173 dev_err(i1480->dev, "byte failed at "
174 "src_itr %u cnt %u [0x%02x "
175 "vs 0x%02x]\n", src_itr, cnt,
176 bin[src_itr + cnt], buf[cnt]);
177 result = src_itr + cnt + 1;
192 * Writes firmware headers to the device.
195 * @hdr: Processed firmware
196 * @returns: 0 if ok, < 0 errno on error.
199 int mac_fw_hdrs_push(struct i1480 *i1480, struct fw_hdr *hdr,
200 const char *fw_name, const char *fw_tag)
202 struct device *dev = i1480->dev;
204 struct fw_hdr *hdr_itr;
205 int verif_retry_count;
207 /* Now, header by header, push them to the hw */
208 for (hdr_itr = hdr; hdr_itr != NULL; hdr_itr = hdr_itr->next) {
209 verif_retry_count = 0;
211 dev_dbg(dev, "fw chunk (%zu @ 0x%08lx)\n",
212 hdr_itr->length * sizeof(hdr_itr->bin[0]),
214 result = i1480->write(i1480, hdr_itr->address, hdr_itr->bin,
215 hdr_itr->length*sizeof(hdr_itr->bin[0]));
217 dev_err(dev, "%s fw '%s': write failed (%zuB @ 0x%lx):"
218 " %zd\n", fw_tag, fw_name,
219 hdr_itr->length * sizeof(hdr_itr->bin[0]),
220 hdr_itr->address, result);
223 result = i1480_fw_cmp(i1480, hdr_itr);
225 dev_err(dev, "%s fw '%s': verification read "
226 "failed (%zuB @ 0x%lx): %zd\n",
228 hdr_itr->length * sizeof(hdr_itr->bin[0]),
229 hdr_itr->address, result);
232 if (result > 0) { /* Offset where it failed + 1 */
234 dev_err(dev, "%s fw '%s': WARNING: verification "
235 "failed at 0x%lx: retrying\n",
236 fw_tag, fw_name, hdr_itr->address + result);
237 if (++verif_retry_count < 3)
238 goto retry; /* write this block again! */
239 dev_err(dev, "%s fw '%s': verification failed at 0x%lx: "
240 "tried %d times\n", fw_tag, fw_name,
241 hdr_itr->address + result, verif_retry_count);
250 /** Puts the device in firmware upload mode.*/
252 int mac_fw_upload_enable(struct i1480 *i1480)
255 u32 reg = 0x800000c0;
256 u32 *buffer = (u32 *)i1480->cmd_buf;
258 if (i1480->hw_rev > 1)
260 result = i1480->read(i1480, reg, sizeof(u32));
263 *buffer &= ~i1480_FW_UPLOAD_MODE_MASK;
264 result = i1480->write(i1480, reg, buffer, sizeof(u32));
269 dev_err(i1480->dev, "can't enable fw upload mode: %d\n", result);
274 /** Gets the device out of firmware upload mode. */
276 int mac_fw_upload_disable(struct i1480 *i1480)
279 u32 reg = 0x800000c0;
280 u32 *buffer = (u32 *)i1480->cmd_buf;
282 if (i1480->hw_rev > 1)
284 result = i1480->read(i1480, reg, sizeof(u32));
287 *buffer |= i1480_FW_UPLOAD_MODE_MASK;
288 result = i1480->write(i1480, reg, buffer, sizeof(u32));
293 dev_err(i1480->dev, "can't disable fw upload mode: %d\n", result);
300 * Generic function for uploading a MAC firmware.
302 * @i1480: Device instance
303 * @fw_name: Name of firmware file to upload.
304 * @fw_tag: Name of the firmware type (for messages)
306 * @do_wait: Wait for device to emit initialization done message (0
307 * for PRE fws, 1 for MAC fws).
308 * @returns: 0 if ok, < 0 errno on error.
311 int __mac_fw_upload(struct i1480 *i1480, const char *fw_name,
315 const struct firmware *fw;
316 struct fw_hdr *fw_hdrs;
318 result = reject_firmware(&fw, fw_name, i1480->dev);
319 if (result < 0) /* Up to caller to complain on -ENOENT */
321 result = fw_hdrs_load(i1480, &fw_hdrs, fw->data, fw->size);
323 dev_err(i1480->dev, "%s fw '%s': failed to parse firmware "
324 "file: %d\n", fw_tag, fw_name, result);
327 result = mac_fw_upload_enable(i1480);
329 goto out_hdrs_release;
330 result = mac_fw_hdrs_push(i1480, fw_hdrs, fw_name, fw_tag);
331 mac_fw_upload_disable(i1480);
334 dev_info(i1480->dev, "%s fw '%s': uploaded\n", fw_tag, fw_name);
336 dev_err(i1480->dev, "%s fw '%s': failed to upload (%d), "
337 "power cycle device\n", fw_tag, fw_name, result);
338 fw_hdrs_free(fw_hdrs);
340 release_firmware(fw);
347 * Upload a pre-PHY firmware
350 int i1480_pre_fw_upload(struct i1480 *i1480)
353 result = __mac_fw_upload(i1480, i1480->pre_fw_name, "PRE");
361 * Reset a the MAC and PHY
363 * @i1480: Device's instance
364 * @returns: 0 if ok, < 0 errno code on error
366 * We put the command on kmalloc'ed memory as some arches cannot do
367 * USB from the stack. The reply event is copied from an stage buffer,
368 * so it can be in the stack. See WUSB1.0[8.6.2.4] for more details.
370 * We issue the reset to make sure the UWB controller reinits the PHY;
371 * this way we can now if the PHY init went ok.
374 int i1480_cmd_reset(struct i1480 *i1480)
377 struct uwb_rccb *cmd = (void *) i1480->cmd_buf;
378 struct i1480_evt_reset {
379 struct uwb_rceb rceb;
381 } __attribute__((packed)) *reply = (void *) i1480->evt_buf;
384 cmd->bCommandType = UWB_RC_CET_GENERAL;
385 cmd->wCommand = cpu_to_le16(UWB_RC_CMD_RESET);
386 reply->rceb.bEventType = UWB_RC_CET_GENERAL;
387 reply->rceb.wEvent = UWB_RC_CMD_RESET;
388 result = i1480_cmd(i1480, "RESET", sizeof(*cmd), sizeof(*reply));
391 if (reply->bResultCode != UWB_RC_RES_SUCCESS) {
392 dev_err(i1480->dev, "RESET: command execution failed: %u\n",
402 /* Wait for the MAC FW to start running */
404 int i1480_fw_is_running_q(struct i1480 *i1480)
408 u32 *val = (u32 *) i1480->cmd_buf;
410 for (cnt = 0; cnt < 10; cnt++) {
412 result = i1480->read(i1480, 0x80080000, 4);
414 dev_err(i1480->dev, "Can't read 0x8008000: %d\n", result);
417 if (*val == 0x55555555UL) /* fw running? cool */
420 dev_err(i1480->dev, "Timed out waiting for fw to start\n");
429 * Upload MAC firmware, wait for it to start
431 * @i1480: Device instance
432 * @fw_name: Name of the file that contains the firmware
434 * This has to be called after the pre fw has been uploaded (if
437 int i1480_mac_fw_upload(struct i1480 *i1480)
439 int result = 0, deprecated_name = 0;
440 struct i1480_rceb *rcebe = (void *) i1480->evt_buf;
442 result = __mac_fw_upload(i1480, i1480->mac_fw_name, "MAC");
443 if (result == -ENOENT) {
444 result = __mac_fw_upload(i1480, i1480->mac_fw_name_deprecate,
450 if (deprecated_name == 1)
452 "WARNING: firmware file name %s is deprecated, "
453 "please rename to %s\n",
454 i1480->mac_fw_name_deprecate, i1480->mac_fw_name);
455 result = i1480_fw_is_running_q(i1480);
457 goto error_fw_not_running;
458 result = i1480->rc_setup ? i1480->rc_setup(i1480) : 0;
460 dev_err(i1480->dev, "Cannot setup after MAC fw upload: %d\n",
464 result = i1480->wait_init_done(i1480); /* wait init'on */
466 dev_err(i1480->dev, "MAC fw '%s': Initialization timed out "
467 "(%d)\n", i1480->mac_fw_name, result);
468 goto error_init_timeout;
470 /* verify we got the right initialization done event */
471 if (i1480->evt_result != sizeof(*rcebe)) {
472 dev_err(i1480->dev, "MAC fw '%s': initialization event returns "
473 "wrong size (%zu bytes vs %zu needed)\n",
474 i1480->mac_fw_name, i1480->evt_result, sizeof(*rcebe));
478 if (i1480_rceb_check(i1480, &rcebe->rceb, NULL, 0, i1480_CET_VS1,
479 i1480_EVT_RM_INIT_DONE) < 0) {
480 dev_err(i1480->dev, "wrong initialization event 0x%02x/%04x/%02x "
481 "received; expected 0x%02x/%04x/00\n",
482 rcebe->rceb.bEventType, le16_to_cpu(rcebe->rceb.wEvent),
483 rcebe->rceb.bEventContext, i1480_CET_VS1,
484 i1480_EVT_RM_INIT_DONE);
485 goto error_init_timeout;
487 result = i1480_cmd_reset(i1480);
489 dev_err(i1480->dev, "MAC fw '%s': MBOA reset failed (%d)\n",
490 i1480->mac_fw_name, result);
491 error_fw_not_running: