xref: /openbmc/linux/drivers/net/wireless/ath/ath10k/bmi.c (revision b8a71b95)
1 // SPDX-License-Identifier: ISC
2 /*
3  * Copyright (c) 2005-2011 Atheros Communications Inc.
4  * Copyright (c) 2011-2014,2016-2017 Qualcomm Atheros, Inc.
5  */
6 
7 #include "bmi.h"
8 #include "hif.h"
9 #include "debug.h"
10 #include "htc.h"
11 #include "hw.h"
12 
ath10k_bmi_start(struct ath10k * ar)13 void ath10k_bmi_start(struct ath10k *ar)
14 {
15 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi start\n");
16 
17 	ar->bmi.done_sent = false;
18 }
19 EXPORT_SYMBOL(ath10k_bmi_start);
20 
ath10k_bmi_done(struct ath10k * ar)21 int ath10k_bmi_done(struct ath10k *ar)
22 {
23 	struct bmi_cmd cmd;
24 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.done);
25 	int ret;
26 
27 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi done\n");
28 
29 	if (ar->bmi.done_sent) {
30 		ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi skipped\n");
31 		return 0;
32 	}
33 
34 	ar->bmi.done_sent = true;
35 	cmd.id = __cpu_to_le32(BMI_DONE);
36 
37 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL);
38 	if (ret) {
39 		ath10k_warn(ar, "unable to write to the device: %d\n", ret);
40 		return ret;
41 	}
42 
43 	return 0;
44 }
45 
ath10k_bmi_get_target_info(struct ath10k * ar,struct bmi_target_info * target_info)46 int ath10k_bmi_get_target_info(struct ath10k *ar,
47 			       struct bmi_target_info *target_info)
48 {
49 	struct bmi_cmd cmd;
50 	union bmi_resp resp;
51 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.get_target_info);
52 	u32 resplen = sizeof(resp.get_target_info);
53 	int ret;
54 
55 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi get target info\n");
56 
57 	if (ar->bmi.done_sent) {
58 		ath10k_warn(ar, "BMI Get Target Info Command disallowed\n");
59 		return -EBUSY;
60 	}
61 
62 	cmd.id = __cpu_to_le32(BMI_GET_TARGET_INFO);
63 
64 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &resp, &resplen);
65 	if (ret) {
66 		ath10k_warn(ar, "unable to get target info from device\n");
67 		return ret;
68 	}
69 
70 	if (resplen < sizeof(resp.get_target_info)) {
71 		ath10k_warn(ar, "invalid get_target_info response length (%d)\n",
72 			    resplen);
73 		return -EIO;
74 	}
75 
76 	target_info->version = __le32_to_cpu(resp.get_target_info.version);
77 	target_info->type    = __le32_to_cpu(resp.get_target_info.type);
78 
79 	return 0;
80 }
81 
82 #define TARGET_VERSION_SENTINAL 0xffffffffu
83 
ath10k_bmi_get_target_info_sdio(struct ath10k * ar,struct bmi_target_info * target_info)84 int ath10k_bmi_get_target_info_sdio(struct ath10k *ar,
85 				    struct bmi_target_info *target_info)
86 {
87 	struct bmi_cmd cmd;
88 	union bmi_resp resp;
89 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.get_target_info);
90 	u32 resplen, ver_len;
91 	__le32 tmp;
92 	int ret;
93 
94 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi get target info SDIO\n");
95 
96 	if (ar->bmi.done_sent) {
97 		ath10k_warn(ar, "BMI Get Target Info Command disallowed\n");
98 		return -EBUSY;
99 	}
100 
101 	cmd.id = __cpu_to_le32(BMI_GET_TARGET_INFO);
102 
103 	/* Step 1: Read 4 bytes of the target info and check if it is
104 	 * the special sentinel version word or the first word in the
105 	 * version response.
106 	 */
107 	resplen = sizeof(u32);
108 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &tmp, &resplen);
109 	if (ret) {
110 		ath10k_warn(ar, "unable to read from device\n");
111 		return ret;
112 	}
113 
114 	/* Some SDIO boards have a special sentinel byte before the real
115 	 * version response.
116 	 */
117 	if (__le32_to_cpu(tmp) == TARGET_VERSION_SENTINAL) {
118 		/* Step 1b: Read the version length */
119 		resplen = sizeof(u32);
120 		ret = ath10k_hif_exchange_bmi_msg(ar, NULL, 0, &tmp,
121 						  &resplen);
122 		if (ret) {
123 			ath10k_warn(ar, "unable to read from device\n");
124 			return ret;
125 		}
126 	}
127 
128 	ver_len = __le32_to_cpu(tmp);
129 
130 	/* Step 2: Check the target info length */
131 	if (ver_len != sizeof(resp.get_target_info)) {
132 		ath10k_warn(ar, "Unexpected target info len: %u. Expected: %zu\n",
133 			    ver_len, sizeof(resp.get_target_info));
134 		return -EINVAL;
135 	}
136 
137 	/* Step 3: Read the rest of the version response */
138 	resplen = sizeof(resp.get_target_info) - sizeof(u32);
139 	ret = ath10k_hif_exchange_bmi_msg(ar, NULL, 0,
140 					  &resp.get_target_info.version,
141 					  &resplen);
142 	if (ret) {
143 		ath10k_warn(ar, "unable to read from device\n");
144 		return ret;
145 	}
146 
147 	target_info->version = __le32_to_cpu(resp.get_target_info.version);
148 	target_info->type    = __le32_to_cpu(resp.get_target_info.type);
149 
150 	return 0;
151 }
152 
ath10k_bmi_read_memory(struct ath10k * ar,u32 address,void * buffer,u32 length)153 int ath10k_bmi_read_memory(struct ath10k *ar,
154 			   u32 address, void *buffer, u32 length)
155 {
156 	struct bmi_cmd cmd;
157 	union bmi_resp resp;
158 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.read_mem);
159 	u32 rxlen;
160 	int ret;
161 
162 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi read address 0x%x length %d\n",
163 		   address, length);
164 
165 	if (ar->bmi.done_sent) {
166 		ath10k_warn(ar, "command disallowed\n");
167 		return -EBUSY;
168 	}
169 
170 	while (length) {
171 		rxlen = min_t(u32, length, BMI_MAX_DATA_SIZE);
172 
173 		cmd.id            = __cpu_to_le32(BMI_READ_MEMORY);
174 		cmd.read_mem.addr = __cpu_to_le32(address);
175 		cmd.read_mem.len  = __cpu_to_le32(rxlen);
176 
177 		ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen,
178 						  &resp, &rxlen);
179 		if (ret) {
180 			ath10k_warn(ar, "unable to read from the device (%d)\n",
181 				    ret);
182 			return ret;
183 		}
184 
185 		memcpy(buffer, resp.read_mem.payload, rxlen);
186 		address += rxlen;
187 		buffer  += rxlen;
188 		length  -= rxlen;
189 	}
190 
191 	return 0;
192 }
193 EXPORT_SYMBOL(ath10k_bmi_read_memory);
194 
ath10k_bmi_write_soc_reg(struct ath10k * ar,u32 address,u32 reg_val)195 int ath10k_bmi_write_soc_reg(struct ath10k *ar, u32 address, u32 reg_val)
196 {
197 	struct bmi_cmd cmd;
198 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.write_soc_reg);
199 	int ret;
200 
201 	ath10k_dbg(ar, ATH10K_DBG_BMI,
202 		   "bmi write soc register 0x%08x val 0x%08x\n",
203 		   address, reg_val);
204 
205 	if (ar->bmi.done_sent) {
206 		ath10k_warn(ar, "bmi write soc register command in progress\n");
207 		return -EBUSY;
208 	}
209 
210 	cmd.id = __cpu_to_le32(BMI_WRITE_SOC_REGISTER);
211 	cmd.write_soc_reg.addr = __cpu_to_le32(address);
212 	cmd.write_soc_reg.value = __cpu_to_le32(reg_val);
213 
214 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL);
215 	if (ret) {
216 		ath10k_warn(ar, "Unable to write soc register to device: %d\n",
217 			    ret);
218 		return ret;
219 	}
220 
221 	return 0;
222 }
223 
ath10k_bmi_read_soc_reg(struct ath10k * ar,u32 address,u32 * reg_val)224 int ath10k_bmi_read_soc_reg(struct ath10k *ar, u32 address, u32 *reg_val)
225 {
226 	struct bmi_cmd cmd;
227 	union bmi_resp resp;
228 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.read_soc_reg);
229 	u32 resplen = sizeof(resp.read_soc_reg);
230 	int ret;
231 
232 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi read soc register 0x%08x\n",
233 		   address);
234 
235 	if (ar->bmi.done_sent) {
236 		ath10k_warn(ar, "bmi read soc register command in progress\n");
237 		return -EBUSY;
238 	}
239 
240 	cmd.id = __cpu_to_le32(BMI_READ_SOC_REGISTER);
241 	cmd.read_soc_reg.addr = __cpu_to_le32(address);
242 
243 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &resp, &resplen);
244 	if (ret) {
245 		ath10k_warn(ar, "Unable to read soc register from device: %d\n",
246 			    ret);
247 		return ret;
248 	}
249 
250 	*reg_val = __le32_to_cpu(resp.read_soc_reg.value);
251 
252 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi read soc register value 0x%08x\n",
253 		   *reg_val);
254 
255 	return 0;
256 }
257 
ath10k_bmi_write_memory(struct ath10k * ar,u32 address,const void * buffer,u32 length)258 int ath10k_bmi_write_memory(struct ath10k *ar,
259 			    u32 address, const void *buffer, u32 length)
260 {
261 	struct bmi_cmd cmd;
262 	u32 hdrlen = sizeof(cmd.id) + sizeof(cmd.write_mem);
263 	u32 txlen;
264 	int ret;
265 
266 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi write address 0x%x length %d\n",
267 		   address, length);
268 
269 	if (ar->bmi.done_sent) {
270 		ath10k_warn(ar, "command disallowed\n");
271 		return -EBUSY;
272 	}
273 
274 	while (length) {
275 		txlen = min(length, BMI_MAX_DATA_SIZE - hdrlen);
276 
277 		/* copy before roundup to avoid reading beyond buffer*/
278 		memcpy(cmd.write_mem.payload, buffer, txlen);
279 		txlen = roundup(txlen, 4);
280 
281 		cmd.id             = __cpu_to_le32(BMI_WRITE_MEMORY);
282 		cmd.write_mem.addr = __cpu_to_le32(address);
283 		cmd.write_mem.len  = __cpu_to_le32(txlen);
284 
285 		ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, hdrlen + txlen,
286 						  NULL, NULL);
287 		if (ret) {
288 			ath10k_warn(ar, "unable to write to the device (%d)\n",
289 				    ret);
290 			return ret;
291 		}
292 
293 		/* fixup roundup() so `length` zeroes out for last chunk */
294 		txlen = min(txlen, length);
295 
296 		address += txlen;
297 		buffer  += txlen;
298 		length  -= txlen;
299 	}
300 
301 	return 0;
302 }
303 
ath10k_bmi_execute(struct ath10k * ar,u32 address,u32 param,u32 * result)304 int ath10k_bmi_execute(struct ath10k *ar, u32 address, u32 param, u32 *result)
305 {
306 	struct bmi_cmd cmd;
307 	union bmi_resp resp;
308 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.execute);
309 	u32 resplen = sizeof(resp.execute);
310 	int ret;
311 
312 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi execute address 0x%x param 0x%x\n",
313 		   address, param);
314 
315 	if (ar->bmi.done_sent) {
316 		ath10k_warn(ar, "command disallowed\n");
317 		return -EBUSY;
318 	}
319 
320 	cmd.id            = __cpu_to_le32(BMI_EXECUTE);
321 	cmd.execute.addr  = __cpu_to_le32(address);
322 	cmd.execute.param = __cpu_to_le32(param);
323 
324 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, &resp, &resplen);
325 	if (ret) {
326 		ath10k_warn(ar, "unable to read from the device\n");
327 		return ret;
328 	}
329 
330 	if (resplen < sizeof(resp.execute)) {
331 		ath10k_warn(ar, "invalid execute response length (%d)\n",
332 			    resplen);
333 		return -EIO;
334 	}
335 
336 	*result = __le32_to_cpu(resp.execute.result);
337 
338 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi execute result 0x%x\n", *result);
339 
340 	return 0;
341 }
342 
ath10k_bmi_lz_data_large(struct ath10k * ar,const void * buffer,u32 length)343 static int ath10k_bmi_lz_data_large(struct ath10k *ar, const void *buffer, u32 length)
344 {
345 	struct bmi_cmd *cmd;
346 	u32 hdrlen = sizeof(cmd->id) + sizeof(cmd->lz_data);
347 	u32 txlen;
348 	int ret;
349 	size_t buf_len;
350 
351 	ath10k_dbg(ar, ATH10K_DBG_BMI, "large bmi lz data buffer 0x%pK length %d\n",
352 		   buffer, length);
353 
354 	if (ar->bmi.done_sent) {
355 		ath10k_warn(ar, "command disallowed\n");
356 		return -EBUSY;
357 	}
358 
359 	buf_len = sizeof(*cmd) + BMI_MAX_LARGE_DATA_SIZE - BMI_MAX_DATA_SIZE;
360 	cmd = kzalloc(buf_len, GFP_KERNEL);
361 	if (!cmd)
362 		return -ENOMEM;
363 
364 	while (length) {
365 		txlen = min(length, BMI_MAX_LARGE_DATA_SIZE - hdrlen);
366 
367 		WARN_ON_ONCE(txlen & 3);
368 
369 		cmd->id          = __cpu_to_le32(BMI_LZ_DATA);
370 		cmd->lz_data.len = __cpu_to_le32(txlen);
371 		memcpy(cmd->lz_data.payload, buffer, txlen);
372 
373 		ret = ath10k_hif_exchange_bmi_msg(ar, cmd, hdrlen + txlen,
374 						  NULL, NULL);
375 		if (ret) {
376 			ath10k_warn(ar, "unable to write to the device\n");
377 			kfree(cmd);
378 			return ret;
379 		}
380 
381 		buffer += txlen;
382 		length -= txlen;
383 	}
384 
385 	kfree(cmd);
386 
387 	return 0;
388 }
389 
ath10k_bmi_lz_data(struct ath10k * ar,const void * buffer,u32 length)390 int ath10k_bmi_lz_data(struct ath10k *ar, const void *buffer, u32 length)
391 {
392 	struct bmi_cmd cmd;
393 	u32 hdrlen = sizeof(cmd.id) + sizeof(cmd.lz_data);
394 	u32 txlen;
395 	int ret;
396 
397 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi lz data buffer 0x%pK length %d\n",
398 		   buffer, length);
399 
400 	if (ar->bmi.done_sent) {
401 		ath10k_warn(ar, "command disallowed\n");
402 		return -EBUSY;
403 	}
404 
405 	while (length) {
406 		txlen = min(length, BMI_MAX_DATA_SIZE - hdrlen);
407 
408 		WARN_ON_ONCE(txlen & 3);
409 
410 		cmd.id          = __cpu_to_le32(BMI_LZ_DATA);
411 		cmd.lz_data.len = __cpu_to_le32(txlen);
412 		memcpy(cmd.lz_data.payload, buffer, txlen);
413 
414 		ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, hdrlen + txlen,
415 						  NULL, NULL);
416 		if (ret) {
417 			ath10k_warn(ar, "unable to write to the device\n");
418 			return ret;
419 		}
420 
421 		buffer += txlen;
422 		length -= txlen;
423 	}
424 
425 	return 0;
426 }
427 
ath10k_bmi_lz_stream_start(struct ath10k * ar,u32 address)428 int ath10k_bmi_lz_stream_start(struct ath10k *ar, u32 address)
429 {
430 	struct bmi_cmd cmd;
431 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.lz_start);
432 	int ret;
433 
434 	ath10k_dbg(ar, ATH10K_DBG_BMI, "bmi lz stream start address 0x%x\n",
435 		   address);
436 
437 	if (ar->bmi.done_sent) {
438 		ath10k_warn(ar, "command disallowed\n");
439 		return -EBUSY;
440 	}
441 
442 	cmd.id            = __cpu_to_le32(BMI_LZ_STREAM_START);
443 	cmd.lz_start.addr = __cpu_to_le32(address);
444 
445 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL);
446 	if (ret) {
447 		ath10k_warn(ar, "unable to Start LZ Stream to the device\n");
448 		return ret;
449 	}
450 
451 	return 0;
452 }
453 
ath10k_bmi_fast_download(struct ath10k * ar,u32 address,const void * buffer,u32 length)454 int ath10k_bmi_fast_download(struct ath10k *ar,
455 			     u32 address, const void *buffer, u32 length)
456 {
457 	u8 trailer[4] = {};
458 	u32 head_len = rounddown(length, 4);
459 	u32 trailer_len = length - head_len;
460 	int ret;
461 
462 	ath10k_dbg(ar, ATH10K_DBG_BMI,
463 		   "bmi fast download address 0x%x buffer 0x%pK length %d\n",
464 		   address, buffer, length);
465 
466 	ret = ath10k_bmi_lz_stream_start(ar, address);
467 	if (ret)
468 		return ret;
469 
470 	/* copy the last word into a zero padded buffer */
471 	if (trailer_len > 0)
472 		memcpy(trailer, buffer + head_len, trailer_len);
473 
474 	if (ar->hw_params.bmi_large_size_download)
475 		ret = ath10k_bmi_lz_data_large(ar, buffer, head_len);
476 	else
477 		ret = ath10k_bmi_lz_data(ar, buffer, head_len);
478 
479 	if (ret)
480 		return ret;
481 
482 	if (trailer_len > 0)
483 		ret = ath10k_bmi_lz_data(ar, trailer, 4);
484 
485 	if (ret != 0)
486 		return ret;
487 
488 	/*
489 	 * Close compressed stream and open a new (fake) one.
490 	 * This serves mainly to flush Target caches.
491 	 */
492 	ret = ath10k_bmi_lz_stream_start(ar, 0x00);
493 
494 	return ret;
495 }
496 
ath10k_bmi_set_start(struct ath10k * ar,u32 address)497 int ath10k_bmi_set_start(struct ath10k *ar, u32 address)
498 {
499 	struct bmi_cmd cmd;
500 	u32 cmdlen = sizeof(cmd.id) + sizeof(cmd.set_app_start);
501 	int ret;
502 
503 	if (ar->bmi.done_sent) {
504 		ath10k_warn(ar, "bmi set start command disallowed\n");
505 		return -EBUSY;
506 	}
507 
508 	cmd.id = __cpu_to_le32(BMI_SET_APP_START);
509 	cmd.set_app_start.addr = __cpu_to_le32(address);
510 
511 	ret = ath10k_hif_exchange_bmi_msg(ar, &cmd, cmdlen, NULL, NULL);
512 	if (ret) {
513 		ath10k_warn(ar, "unable to set start to the device:%d\n", ret);
514 		return ret;
515 	}
516 
517 	return 0;
518 }
519