1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * This file is part of wl1271
4  *
5  * Copyright (C) 2008-2010 Nokia Corporation
6  *
7  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8  */
9 
10 #include <linux/slab.h>
11 #include <linux/export.h>
12 
13 #include "debug.h"
14 #include "acx.h"
15 #include "boot.h"
16 #include "io.h"
17 #include "event.h"
18 #include "rx.h"
19 #include "hw_ops.h"
20 
wl1271_boot_set_ecpu_ctrl(struct wl1271 * wl,u32 flag)21 static int wl1271_boot_set_ecpu_ctrl(struct wl1271 *wl, u32 flag)
22 {
23 	u32 cpu_ctrl;
24 	int ret;
25 
26 	/* 10.5.0 run the firmware (I) */
27 	ret = wlcore_read_reg(wl, REG_ECPU_CONTROL, &cpu_ctrl);
28 	if (ret < 0)
29 		goto out;
30 
31 	/* 10.5.1 run the firmware (II) */
32 	cpu_ctrl |= flag;
33 	ret = wlcore_write_reg(wl, REG_ECPU_CONTROL, cpu_ctrl);
34 
35 out:
36 	return ret;
37 }
38 
wlcore_boot_parse_fw_ver(struct wl1271 * wl,struct wl1271_static_data * static_data)39 static int wlcore_boot_parse_fw_ver(struct wl1271 *wl,
40 				    struct wl1271_static_data *static_data)
41 {
42 	int ret;
43 
44 	strncpy(wl->chip.fw_ver_str, static_data->fw_version,
45 		sizeof(wl->chip.fw_ver_str));
46 
47 	/* make sure the string is NULL-terminated */
48 	wl->chip.fw_ver_str[sizeof(wl->chip.fw_ver_str) - 1] = '\0';
49 
50 	ret = sscanf(wl->chip.fw_ver_str + 4, "%u.%u.%u.%u.%u",
51 		     &wl->chip.fw_ver[0], &wl->chip.fw_ver[1],
52 		     &wl->chip.fw_ver[2], &wl->chip.fw_ver[3],
53 		     &wl->chip.fw_ver[4]);
54 
55 	if (ret != 5) {
56 		wl1271_warning("fw version incorrect value");
57 		memset(wl->chip.fw_ver, 0, sizeof(wl->chip.fw_ver));
58 		ret = -EINVAL;
59 		goto out;
60 	}
61 
62 	ret = wlcore_identify_fw(wl);
63 	if (ret < 0)
64 		goto out;
65 out:
66 	return ret;
67 }
68 
wlcore_validate_fw_ver(struct wl1271 * wl)69 static int wlcore_validate_fw_ver(struct wl1271 *wl)
70 {
71 	unsigned int *fw_ver = wl->chip.fw_ver;
72 	unsigned int *min_ver = (wl->fw_type == WL12XX_FW_TYPE_MULTI) ?
73 		wl->min_mr_fw_ver : wl->min_sr_fw_ver;
74 	char min_fw_str[32] = "";
75 	int off = 0;
76 	int i;
77 
78 	/* the chip must be exactly equal */
79 	if ((min_ver[FW_VER_CHIP] != WLCORE_FW_VER_IGNORE) &&
80 	    (min_ver[FW_VER_CHIP] != fw_ver[FW_VER_CHIP]))
81 		goto fail;
82 
83 	/* the firmware type must be equal */
84 	if ((min_ver[FW_VER_IF_TYPE] != WLCORE_FW_VER_IGNORE) &&
85 	    (min_ver[FW_VER_IF_TYPE] != fw_ver[FW_VER_IF_TYPE]))
86 		goto fail;
87 
88 	/* the project number must be equal */
89 	if ((min_ver[FW_VER_SUBTYPE] != WLCORE_FW_VER_IGNORE) &&
90 	    (min_ver[FW_VER_SUBTYPE] != fw_ver[FW_VER_SUBTYPE]))
91 		goto fail;
92 
93 	/* the API version must be greater or equal */
94 	if ((min_ver[FW_VER_MAJOR] != WLCORE_FW_VER_IGNORE) &&
95 		 (min_ver[FW_VER_MAJOR] > fw_ver[FW_VER_MAJOR]))
96 		goto fail;
97 
98 	/* if the API version is equal... */
99 	if (((min_ver[FW_VER_MAJOR] == WLCORE_FW_VER_IGNORE) ||
100 	     (min_ver[FW_VER_MAJOR] == fw_ver[FW_VER_MAJOR])) &&
101 	    /* ...the minor must be greater or equal */
102 	    ((min_ver[FW_VER_MINOR] != WLCORE_FW_VER_IGNORE) &&
103 	     (min_ver[FW_VER_MINOR] > fw_ver[FW_VER_MINOR])))
104 		goto fail;
105 
106 	return 0;
107 
108 fail:
109 	for (i = 0; i < NUM_FW_VER && off < sizeof(min_fw_str); i++)
110 		if (min_ver[i] == WLCORE_FW_VER_IGNORE)
111 			off += snprintf(min_fw_str + off,
112 					sizeof(min_fw_str) - off,
113 					"*.");
114 		else
115 			off += snprintf(min_fw_str + off,
116 					sizeof(min_fw_str) - off,
117 					"%u.", min_ver[i]);
118 
119 	wl1271_error("Your WiFi FW version (%u.%u.%u.%u.%u) is invalid.\n"
120 		     "Please use at least FW %s\n"
121 		     "You can get the latest firmwares at:\n"
122 		     "git://git.ti.com/wilink8-wlan/wl18xx_fw.git",
123 		     fw_ver[FW_VER_CHIP], fw_ver[FW_VER_IF_TYPE],
124 		     fw_ver[FW_VER_MAJOR], fw_ver[FW_VER_SUBTYPE],
125 		     fw_ver[FW_VER_MINOR], min_fw_str);
126 	return -EINVAL;
127 }
128 
wlcore_boot_static_data(struct wl1271 * wl)129 static int wlcore_boot_static_data(struct wl1271 *wl)
130 {
131 	struct wl1271_static_data *static_data;
132 	size_t len = sizeof(*static_data) + wl->static_data_priv_len;
133 	int ret;
134 
135 	static_data = kmalloc(len, GFP_KERNEL);
136 	if (!static_data) {
137 		ret = -ENOMEM;
138 		goto out;
139 	}
140 
141 	ret = wlcore_read(wl, wl->cmd_box_addr, static_data, len, false);
142 	if (ret < 0)
143 		goto out_free;
144 
145 	ret = wlcore_boot_parse_fw_ver(wl, static_data);
146 	if (ret < 0)
147 		goto out_free;
148 
149 	ret = wlcore_validate_fw_ver(wl);
150 	if (ret < 0)
151 		goto out_free;
152 
153 	ret = wlcore_handle_static_data(wl, static_data);
154 	if (ret < 0)
155 		goto out_free;
156 
157 out_free:
158 	kfree(static_data);
159 out:
160 	return ret;
161 }
162 
wl1271_boot_upload_firmware_chunk(struct wl1271 * wl,void * buf,size_t fw_data_len,u32 dest)163 static int wl1271_boot_upload_firmware_chunk(struct wl1271 *wl, void *buf,
164 					     size_t fw_data_len, u32 dest)
165 {
166 	struct wlcore_partition_set partition;
167 	int addr, chunk_num, partition_limit;
168 	u8 *p, *chunk;
169 	int ret;
170 
171 	/* whal_FwCtrl_LoadFwImageSm() */
172 
173 	wl1271_debug(DEBUG_BOOT, "starting firmware upload");
174 
175 	wl1271_debug(DEBUG_BOOT, "fw_data_len %zd chunk_size %d",
176 		     fw_data_len, CHUNK_SIZE);
177 
178 	if ((fw_data_len % 4) != 0) {
179 		wl1271_error("firmware length not multiple of four");
180 		return -EIO;
181 	}
182 
183 	chunk = kmalloc(CHUNK_SIZE, GFP_KERNEL);
184 	if (!chunk) {
185 		wl1271_error("allocation for firmware upload chunk failed");
186 		return -ENOMEM;
187 	}
188 
189 	memcpy(&partition, &wl->ptable[PART_DOWN], sizeof(partition));
190 	partition.mem.start = dest;
191 	ret = wlcore_set_partition(wl, &partition);
192 	if (ret < 0)
193 		goto out;
194 
195 	/* 10.1 set partition limit and chunk num */
196 	chunk_num = 0;
197 	partition_limit = wl->ptable[PART_DOWN].mem.size;
198 
199 	while (chunk_num < fw_data_len / CHUNK_SIZE) {
200 		/* 10.2 update partition, if needed */
201 		addr = dest + (chunk_num + 2) * CHUNK_SIZE;
202 		if (addr > partition_limit) {
203 			addr = dest + chunk_num * CHUNK_SIZE;
204 			partition_limit = chunk_num * CHUNK_SIZE +
205 				wl->ptable[PART_DOWN].mem.size;
206 			partition.mem.start = addr;
207 			ret = wlcore_set_partition(wl, &partition);
208 			if (ret < 0)
209 				goto out;
210 		}
211 
212 		/* 10.3 upload the chunk */
213 		addr = dest + chunk_num * CHUNK_SIZE;
214 		p = buf + chunk_num * CHUNK_SIZE;
215 		memcpy(chunk, p, CHUNK_SIZE);
216 		wl1271_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x",
217 			     p, addr);
218 		ret = wlcore_write(wl, addr, chunk, CHUNK_SIZE, false);
219 		if (ret < 0)
220 			goto out;
221 
222 		chunk_num++;
223 	}
224 
225 	/* 10.4 upload the last chunk */
226 	addr = dest + chunk_num * CHUNK_SIZE;
227 	p = buf + chunk_num * CHUNK_SIZE;
228 	memcpy(chunk, p, fw_data_len % CHUNK_SIZE);
229 	wl1271_debug(DEBUG_BOOT, "uploading fw last chunk (%zd B) 0x%p to 0x%x",
230 		     fw_data_len % CHUNK_SIZE, p, addr);
231 	ret = wlcore_write(wl, addr, chunk, fw_data_len % CHUNK_SIZE, false);
232 
233 out:
234 	kfree(chunk);
235 	return ret;
236 }
237 
wlcore_boot_upload_firmware(struct wl1271 * wl)238 int wlcore_boot_upload_firmware(struct wl1271 *wl)
239 {
240 	u32 chunks, addr, len;
241 	int ret = 0;
242 	u8 *fw;
243 
244 	fw = wl->fw;
245 	chunks = be32_to_cpup((__be32 *) fw);
246 	fw += sizeof(u32);
247 
248 	wl1271_debug(DEBUG_BOOT, "firmware chunks to be uploaded: %u", chunks);
249 
250 	while (chunks--) {
251 		addr = be32_to_cpup((__be32 *) fw);
252 		fw += sizeof(u32);
253 		len = be32_to_cpup((__be32 *) fw);
254 		fw += sizeof(u32);
255 
256 		if (len > 300000) {
257 			wl1271_info("firmware chunk too long: %u", len);
258 			return -EINVAL;
259 		}
260 		wl1271_debug(DEBUG_BOOT, "chunk %d addr 0x%x len %u",
261 			     chunks, addr, len);
262 		ret = wl1271_boot_upload_firmware_chunk(wl, fw, len, addr);
263 		if (ret != 0)
264 			break;
265 		fw += len;
266 	}
267 
268 	return ret;
269 }
270 EXPORT_SYMBOL_GPL(wlcore_boot_upload_firmware);
271 
wlcore_boot_upload_nvs(struct wl1271 * wl)272 int wlcore_boot_upload_nvs(struct wl1271 *wl)
273 {
274 	struct platform_device *pdev = wl->pdev;
275 	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
276 	const char *nvs_name = "unknown";
277 	size_t nvs_len, burst_len;
278 	int i;
279 	u32 dest_addr, val;
280 	u8 *nvs_ptr, *nvs_aligned;
281 	int ret;
282 
283 	if (wl->nvs == NULL) {
284 		wl1271_error("NVS file is needed during boot");
285 		return -ENODEV;
286 	}
287 
288 	if (pdev_data && pdev_data->family)
289 		nvs_name = pdev_data->family->nvs_name;
290 
291 	if (wl->quirks & WLCORE_QUIRK_LEGACY_NVS) {
292 		struct wl1271_nvs_file *nvs =
293 			(struct wl1271_nvs_file *)wl->nvs;
294 		/*
295 		 * FIXME: the LEGACY NVS image support (NVS's missing the 5GHz
296 		 * band configurations) can be removed when those NVS files stop
297 		 * floating around.
298 		 */
299 		if (wl->nvs_len == sizeof(struct wl1271_nvs_file) ||
300 		    wl->nvs_len == WL1271_INI_LEGACY_NVS_FILE_SIZE) {
301 			if (nvs->general_params.dual_mode_select)
302 				wl->enable_11a = true;
303 		}
304 
305 		if (wl->nvs_len != sizeof(struct wl1271_nvs_file) &&
306 		    (wl->nvs_len != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
307 		     wl->enable_11a)) {
308 			wl1271_error("%s size is not as expected: %zu != %zu",
309 				     nvs_name, wl->nvs_len,
310 				     sizeof(struct wl1271_nvs_file));
311 			kfree(wl->nvs);
312 			wl->nvs = NULL;
313 			wl->nvs_len = 0;
314 			return -EILSEQ;
315 		}
316 
317 		/* only the first part of the NVS needs to be uploaded */
318 		nvs_len = sizeof(nvs->nvs);
319 		nvs_ptr = (u8 *) nvs->nvs;
320 	} else {
321 		struct wl128x_nvs_file *nvs = (struct wl128x_nvs_file *)wl->nvs;
322 
323 		if (wl->nvs_len == sizeof(struct wl128x_nvs_file)) {
324 			if (nvs->general_params.dual_mode_select)
325 				wl->enable_11a = true;
326 		} else {
327 			wl1271_error("%s size is not as expected: %zu != %zu",
328 				     nvs_name, wl->nvs_len,
329 				     sizeof(struct wl128x_nvs_file));
330 			kfree(wl->nvs);
331 			wl->nvs = NULL;
332 			wl->nvs_len = 0;
333 			return -EILSEQ;
334 		}
335 
336 		/* only the first part of the NVS needs to be uploaded */
337 		nvs_len = sizeof(nvs->nvs);
338 		nvs_ptr = (u8 *)nvs->nvs;
339 	}
340 
341 	/* update current MAC address to NVS */
342 	nvs_ptr[11] = wl->addresses[0].addr[0];
343 	nvs_ptr[10] = wl->addresses[0].addr[1];
344 	nvs_ptr[6] = wl->addresses[0].addr[2];
345 	nvs_ptr[5] = wl->addresses[0].addr[3];
346 	nvs_ptr[4] = wl->addresses[0].addr[4];
347 	nvs_ptr[3] = wl->addresses[0].addr[5];
348 
349 	/*
350 	 * Layout before the actual NVS tables:
351 	 * 1 byte : burst length.
352 	 * 2 bytes: destination address.
353 	 * n bytes: data to burst copy.
354 	 *
355 	 * This is ended by a 0 length, then the NVS tables.
356 	 */
357 
358 	/* FIXME: Do we need to check here whether the LSB is 1? */
359 	while (nvs_ptr[0]) {
360 		burst_len = nvs_ptr[0];
361 		dest_addr = (nvs_ptr[1] & 0xfe) | ((u32)(nvs_ptr[2] << 8));
362 
363 		/*
364 		 * Due to our new wl1271_translate_reg_addr function,
365 		 * we need to add the register partition start address
366 		 * to the destination
367 		 */
368 		dest_addr += wl->curr_part.reg.start;
369 
370 		/* We move our pointer to the data */
371 		nvs_ptr += 3;
372 
373 		for (i = 0; i < burst_len; i++) {
374 			if (nvs_ptr + 3 >= (u8 *) wl->nvs + nvs_len)
375 				goto out_badnvs;
376 
377 			val = (nvs_ptr[0] | (nvs_ptr[1] << 8)
378 			       | (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));
379 
380 			wl1271_debug(DEBUG_BOOT,
381 				     "nvs burst write 0x%x: 0x%x",
382 				     dest_addr, val);
383 			ret = wlcore_write32(wl, dest_addr, val);
384 			if (ret < 0)
385 				return ret;
386 
387 			nvs_ptr += 4;
388 			dest_addr += 4;
389 		}
390 
391 		if (nvs_ptr >= (u8 *) wl->nvs + nvs_len)
392 			goto out_badnvs;
393 	}
394 
395 	/*
396 	 * We've reached the first zero length, the first NVS table
397 	 * is located at an aligned offset which is at least 7 bytes further.
398 	 * NOTE: The wl->nvs->nvs element must be first, in order to
399 	 * simplify the casting, we assume it is at the beginning of
400 	 * the wl->nvs structure.
401 	 */
402 	nvs_ptr = (u8 *)wl->nvs +
403 			ALIGN(nvs_ptr - (u8 *)wl->nvs + 7, 4);
404 
405 	if (nvs_ptr >= (u8 *) wl->nvs + nvs_len)
406 		goto out_badnvs;
407 
408 	nvs_len -= nvs_ptr - (u8 *)wl->nvs;
409 
410 	/* Now we must set the partition correctly */
411 	ret = wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
412 	if (ret < 0)
413 		return ret;
414 
415 	/* Copy the NVS tables to a new block to ensure alignment */
416 	nvs_aligned = kmemdup(nvs_ptr, nvs_len, GFP_KERNEL);
417 	if (!nvs_aligned)
418 		return -ENOMEM;
419 
420 	/* And finally we upload the NVS tables */
421 	ret = wlcore_write_data(wl, REG_CMD_MBOX_ADDRESS, nvs_aligned, nvs_len,
422 				false);
423 
424 	kfree(nvs_aligned);
425 	return ret;
426 
427 out_badnvs:
428 	wl1271_error("nvs data is malformed");
429 	return -EILSEQ;
430 }
431 EXPORT_SYMBOL_GPL(wlcore_boot_upload_nvs);
432 
wlcore_boot_run_firmware(struct wl1271 * wl)433 int wlcore_boot_run_firmware(struct wl1271 *wl)
434 {
435 	int loop, ret;
436 	u32 chip_id, intr;
437 
438 	/* Make sure we have the boot partition */
439 	ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
440 	if (ret < 0)
441 		return ret;
442 
443 	ret = wl1271_boot_set_ecpu_ctrl(wl, ECPU_CONTROL_HALT);
444 	if (ret < 0)
445 		return ret;
446 
447 	ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &chip_id);
448 	if (ret < 0)
449 		return ret;
450 
451 	wl1271_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id);
452 
453 	if (chip_id != wl->chip.id) {
454 		wl1271_error("chip id doesn't match after firmware boot");
455 		return -EIO;
456 	}
457 
458 	/* wait for init to complete */
459 	loop = 0;
460 	while (loop++ < INIT_LOOP) {
461 		udelay(INIT_LOOP_DELAY);
462 		ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &intr);
463 		if (ret < 0)
464 			return ret;
465 
466 		if (intr == 0xffffffff) {
467 			wl1271_error("error reading hardware complete "
468 				     "init indication");
469 			return -EIO;
470 		}
471 		/* check that ACX_INTR_INIT_COMPLETE is enabled */
472 		else if (intr & WL1271_ACX_INTR_INIT_COMPLETE) {
473 			ret = wlcore_write_reg(wl, REG_INTERRUPT_ACK,
474 					       WL1271_ACX_INTR_INIT_COMPLETE);
475 			if (ret < 0)
476 				return ret;
477 			break;
478 		}
479 	}
480 
481 	if (loop > INIT_LOOP) {
482 		wl1271_error("timeout waiting for the hardware to "
483 			     "complete initialization");
484 		return -EIO;
485 	}
486 
487 	/* get hardware config command mail box */
488 	ret = wlcore_read_reg(wl, REG_COMMAND_MAILBOX_PTR, &wl->cmd_box_addr);
489 	if (ret < 0)
490 		return ret;
491 
492 	wl1271_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x", wl->cmd_box_addr);
493 
494 	/* get hardware config event mail box */
495 	ret = wlcore_read_reg(wl, REG_EVENT_MAILBOX_PTR, &wl->mbox_ptr[0]);
496 	if (ret < 0)
497 		return ret;
498 
499 	wl->mbox_ptr[1] = wl->mbox_ptr[0] + wl->mbox_size;
500 
501 	wl1271_debug(DEBUG_MAILBOX, "MBOX ptrs: 0x%x 0x%x",
502 		     wl->mbox_ptr[0], wl->mbox_ptr[1]);
503 
504 	ret = wlcore_boot_static_data(wl);
505 	if (ret < 0) {
506 		wl1271_error("error getting static data");
507 		return ret;
508 	}
509 
510 	/*
511 	 * in case of full asynchronous mode the firmware event must be
512 	 * ready to receive event from the command mailbox
513 	 */
514 
515 	/* unmask required mbox events  */
516 	ret = wl1271_event_unmask(wl);
517 	if (ret < 0) {
518 		wl1271_error("EVENT mask setting failed");
519 		return ret;
520 	}
521 
522 	/* set the working partition to its "running" mode offset */
523 	ret = wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
524 
525 	/* firmware startup completed */
526 	return ret;
527 }
528 EXPORT_SYMBOL_GPL(wlcore_boot_run_firmware);
529