1 /*
2 * Copyright (c) 2004-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include "core.h"
19 #include "hif-ops.h"
20 #include "target.h"
21 #include "debug.h"
22
ath6kl_bmi_done(struct ath6kl * ar)23 int ath6kl_bmi_done(struct ath6kl *ar)
24 {
25 int ret;
26 u32 cid = BMI_DONE;
27
28 if (ar->bmi.done_sent) {
29 ath6kl_dbg(ATH6KL_DBG_BMI, "bmi done skipped\n");
30 return 0;
31 }
32
33 ar->bmi.done_sent = true;
34
35 ret = ath6kl_hif_bmi_write(ar, (u8 *)&cid, sizeof(cid));
36 if (ret) {
37 ath6kl_err("Unable to send bmi done: %d\n", ret);
38 return ret;
39 }
40
41 return 0;
42 }
43
ath6kl_bmi_get_target_info(struct ath6kl * ar,struct ath6kl_bmi_target_info * targ_info)44 int ath6kl_bmi_get_target_info(struct ath6kl *ar,
45 struct ath6kl_bmi_target_info *targ_info)
46 {
47 int ret;
48 u32 cid = BMI_GET_TARGET_INFO;
49
50 if (ar->bmi.done_sent) {
51 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
52 return -EACCES;
53 }
54
55 ret = ath6kl_hif_bmi_write(ar, (u8 *)&cid, sizeof(cid));
56 if (ret) {
57 ath6kl_err("Unable to send get target info: %d\n", ret);
58 return ret;
59 }
60
61 if (ar->hif_type == ATH6KL_HIF_TYPE_USB) {
62 ret = ath6kl_hif_bmi_read(ar, (u8 *)targ_info,
63 sizeof(*targ_info));
64 } else {
65 ret = ath6kl_hif_bmi_read(ar, (u8 *)&targ_info->version,
66 sizeof(targ_info->version));
67 }
68
69 if (ret) {
70 ath6kl_err("Unable to recv target info: %d\n", ret);
71 return ret;
72 }
73
74 if (le32_to_cpu(targ_info->version) == TARGET_VERSION_SENTINAL) {
75 /* Determine how many bytes are in the Target's targ_info */
76 ret = ath6kl_hif_bmi_read(ar,
77 (u8 *)&targ_info->byte_count,
78 sizeof(targ_info->byte_count));
79 if (ret) {
80 ath6kl_err("unable to read target info byte count: %d\n",
81 ret);
82 return ret;
83 }
84
85 /*
86 * The target's targ_info doesn't match the host's targ_info.
87 * We need to do some backwards compatibility to make this work.
88 */
89 if (le32_to_cpu(targ_info->byte_count) != sizeof(*targ_info)) {
90 WARN_ON(1);
91 return -EINVAL;
92 }
93
94 /* Read the remainder of the targ_info */
95 ret = ath6kl_hif_bmi_read(ar,
96 ((u8 *)targ_info) +
97 sizeof(targ_info->byte_count),
98 sizeof(*targ_info) -
99 sizeof(targ_info->byte_count));
100
101 if (ret) {
102 ath6kl_err("Unable to read target info (%d bytes): %d\n",
103 targ_info->byte_count, ret);
104 return ret;
105 }
106 }
107
108 ath6kl_dbg(ATH6KL_DBG_BMI, "target info (ver: 0x%x type: 0x%x)\n",
109 targ_info->version, targ_info->type);
110
111 return 0;
112 }
113
ath6kl_bmi_read(struct ath6kl * ar,u32 addr,u8 * buf,u32 len)114 int ath6kl_bmi_read(struct ath6kl *ar, u32 addr, u8 *buf, u32 len)
115 {
116 u32 cid = BMI_READ_MEMORY;
117 int ret;
118 u32 offset;
119 u32 len_remain, rx_len;
120 u16 size;
121
122 if (ar->bmi.done_sent) {
123 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
124 return -EACCES;
125 }
126
127 size = ar->bmi.max_data_size + sizeof(cid) + sizeof(addr) + sizeof(len);
128 if (size > ar->bmi.max_cmd_size) {
129 WARN_ON(1);
130 return -EINVAL;
131 }
132 memset(ar->bmi.cmd_buf, 0, size);
133
134 ath6kl_dbg(ATH6KL_DBG_BMI,
135 "bmi read memory: device: addr: 0x%x, len: %d\n",
136 addr, len);
137
138 len_remain = len;
139
140 while (len_remain) {
141 rx_len = (len_remain < ar->bmi.max_data_size) ?
142 len_remain : ar->bmi.max_data_size;
143 offset = 0;
144 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
145 offset += sizeof(cid);
146 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
147 offset += sizeof(addr);
148 memcpy(&(ar->bmi.cmd_buf[offset]), &rx_len, sizeof(rx_len));
149 offset += sizeof(len);
150
151 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
152 if (ret) {
153 ath6kl_err("Unable to write to the device: %d\n",
154 ret);
155 return ret;
156 }
157 ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, rx_len);
158 if (ret) {
159 ath6kl_err("Unable to read from the device: %d\n",
160 ret);
161 return ret;
162 }
163 memcpy(&buf[len - len_remain], ar->bmi.cmd_buf, rx_len);
164 len_remain -= rx_len; addr += rx_len;
165 }
166
167 return 0;
168 }
169
ath6kl_bmi_write(struct ath6kl * ar,u32 addr,u8 * buf,u32 len)170 int ath6kl_bmi_write(struct ath6kl *ar, u32 addr, u8 *buf, u32 len)
171 {
172 u32 cid = BMI_WRITE_MEMORY;
173 int ret;
174 u32 offset;
175 u32 len_remain, tx_len;
176 const u32 header = sizeof(cid) + sizeof(addr) + sizeof(len);
177 u8 aligned_buf[400];
178 u8 *src;
179
180 if (ar->bmi.done_sent) {
181 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
182 return -EACCES;
183 }
184
185 if ((ar->bmi.max_data_size + header) > ar->bmi.max_cmd_size) {
186 WARN_ON(1);
187 return -EINVAL;
188 }
189
190 if (WARN_ON(ar->bmi.max_data_size > sizeof(aligned_buf)))
191 return -E2BIG;
192
193 memset(ar->bmi.cmd_buf, 0, ar->bmi.max_data_size + header);
194
195 ath6kl_dbg(ATH6KL_DBG_BMI,
196 "bmi write memory: addr: 0x%x, len: %d\n", addr, len);
197
198 len_remain = len;
199 while (len_remain) {
200 src = &buf[len - len_remain];
201
202 if (len_remain < (ar->bmi.max_data_size - header)) {
203 if (len_remain & 3) {
204 /* align it with 4 bytes */
205 len_remain = len_remain +
206 (4 - (len_remain & 3));
207 memcpy(aligned_buf, src, len_remain);
208 src = aligned_buf;
209 }
210 tx_len = len_remain;
211 } else {
212 tx_len = (ar->bmi.max_data_size - header);
213 }
214
215 offset = 0;
216 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
217 offset += sizeof(cid);
218 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
219 offset += sizeof(addr);
220 memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len));
221 offset += sizeof(tx_len);
222 memcpy(&(ar->bmi.cmd_buf[offset]), src, tx_len);
223 offset += tx_len;
224
225 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
226 if (ret) {
227 ath6kl_err("Unable to write to the device: %d\n",
228 ret);
229 return ret;
230 }
231 len_remain -= tx_len; addr += tx_len;
232 }
233
234 return 0;
235 }
236
ath6kl_bmi_execute(struct ath6kl * ar,u32 addr,u32 * param)237 int ath6kl_bmi_execute(struct ath6kl *ar, u32 addr, u32 *param)
238 {
239 u32 cid = BMI_EXECUTE;
240 int ret;
241 u32 offset;
242 u16 size;
243
244 if (ar->bmi.done_sent) {
245 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
246 return -EACCES;
247 }
248
249 size = sizeof(cid) + sizeof(addr) + sizeof(*param);
250 if (size > ar->bmi.max_cmd_size) {
251 WARN_ON(1);
252 return -EINVAL;
253 }
254 memset(ar->bmi.cmd_buf, 0, size);
255
256 ath6kl_dbg(ATH6KL_DBG_BMI, "bmi execute: addr: 0x%x, param: %d)\n",
257 addr, *param);
258
259 offset = 0;
260 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
261 offset += sizeof(cid);
262 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
263 offset += sizeof(addr);
264 memcpy(&(ar->bmi.cmd_buf[offset]), param, sizeof(*param));
265 offset += sizeof(*param);
266
267 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
268 if (ret) {
269 ath6kl_err("Unable to write to the device: %d\n", ret);
270 return ret;
271 }
272
273 ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, sizeof(*param));
274 if (ret) {
275 ath6kl_err("Unable to read from the device: %d\n", ret);
276 return ret;
277 }
278
279 memcpy(param, ar->bmi.cmd_buf, sizeof(*param));
280
281 return 0;
282 }
283
ath6kl_bmi_set_app_start(struct ath6kl * ar,u32 addr)284 int ath6kl_bmi_set_app_start(struct ath6kl *ar, u32 addr)
285 {
286 u32 cid = BMI_SET_APP_START;
287 int ret;
288 u32 offset;
289 u16 size;
290
291 if (ar->bmi.done_sent) {
292 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
293 return -EACCES;
294 }
295
296 size = sizeof(cid) + sizeof(addr);
297 if (size > ar->bmi.max_cmd_size) {
298 WARN_ON(1);
299 return -EINVAL;
300 }
301 memset(ar->bmi.cmd_buf, 0, size);
302
303 ath6kl_dbg(ATH6KL_DBG_BMI, "bmi set app start: addr: 0x%x\n", addr);
304
305 offset = 0;
306 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
307 offset += sizeof(cid);
308 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
309 offset += sizeof(addr);
310
311 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
312 if (ret) {
313 ath6kl_err("Unable to write to the device: %d\n", ret);
314 return ret;
315 }
316
317 return 0;
318 }
319
ath6kl_bmi_reg_read(struct ath6kl * ar,u32 addr,u32 * param)320 int ath6kl_bmi_reg_read(struct ath6kl *ar, u32 addr, u32 *param)
321 {
322 u32 cid = BMI_READ_SOC_REGISTER;
323 int ret;
324 u32 offset;
325 u16 size;
326
327 if (ar->bmi.done_sent) {
328 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
329 return -EACCES;
330 }
331
332 size = sizeof(cid) + sizeof(addr);
333 if (size > ar->bmi.max_cmd_size) {
334 WARN_ON(1);
335 return -EINVAL;
336 }
337 memset(ar->bmi.cmd_buf, 0, size);
338
339 ath6kl_dbg(ATH6KL_DBG_BMI, "bmi read SOC reg: addr: 0x%x\n", addr);
340
341 offset = 0;
342 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
343 offset += sizeof(cid);
344 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
345 offset += sizeof(addr);
346
347 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
348 if (ret) {
349 ath6kl_err("Unable to write to the device: %d\n", ret);
350 return ret;
351 }
352
353 ret = ath6kl_hif_bmi_read(ar, ar->bmi.cmd_buf, sizeof(*param));
354 if (ret) {
355 ath6kl_err("Unable to read from the device: %d\n", ret);
356 return ret;
357 }
358 memcpy(param, ar->bmi.cmd_buf, sizeof(*param));
359
360 return 0;
361 }
362
ath6kl_bmi_reg_write(struct ath6kl * ar,u32 addr,u32 param)363 int ath6kl_bmi_reg_write(struct ath6kl *ar, u32 addr, u32 param)
364 {
365 u32 cid = BMI_WRITE_SOC_REGISTER;
366 int ret;
367 u32 offset;
368 u16 size;
369
370 if (ar->bmi.done_sent) {
371 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
372 return -EACCES;
373 }
374
375 size = sizeof(cid) + sizeof(addr) + sizeof(param);
376 if (size > ar->bmi.max_cmd_size) {
377 WARN_ON(1);
378 return -EINVAL;
379 }
380 memset(ar->bmi.cmd_buf, 0, size);
381
382 ath6kl_dbg(ATH6KL_DBG_BMI,
383 "bmi write SOC reg: addr: 0x%x, param: %d\n",
384 addr, param);
385
386 offset = 0;
387 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
388 offset += sizeof(cid);
389 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
390 offset += sizeof(addr);
391 memcpy(&(ar->bmi.cmd_buf[offset]), ¶m, sizeof(param));
392 offset += sizeof(param);
393
394 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
395 if (ret) {
396 ath6kl_err("Unable to write to the device: %d\n", ret);
397 return ret;
398 }
399
400 return 0;
401 }
402
ath6kl_bmi_lz_data(struct ath6kl * ar,u8 * buf,u32 len)403 int ath6kl_bmi_lz_data(struct ath6kl *ar, u8 *buf, u32 len)
404 {
405 u32 cid = BMI_LZ_DATA;
406 int ret;
407 u32 offset;
408 u32 len_remain, tx_len;
409 const u32 header = sizeof(cid) + sizeof(len);
410 u16 size;
411
412 if (ar->bmi.done_sent) {
413 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
414 return -EACCES;
415 }
416
417 size = ar->bmi.max_data_size + header;
418 if (size > ar->bmi.max_cmd_size) {
419 WARN_ON(1);
420 return -EINVAL;
421 }
422 memset(ar->bmi.cmd_buf, 0, size);
423
424 ath6kl_dbg(ATH6KL_DBG_BMI, "bmi send LZ data: len: %d)\n",
425 len);
426
427 len_remain = len;
428 while (len_remain) {
429 tx_len = (len_remain < (ar->bmi.max_data_size - header)) ?
430 len_remain : (ar->bmi.max_data_size - header);
431
432 offset = 0;
433 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
434 offset += sizeof(cid);
435 memcpy(&(ar->bmi.cmd_buf[offset]), &tx_len, sizeof(tx_len));
436 offset += sizeof(tx_len);
437 memcpy(&(ar->bmi.cmd_buf[offset]), &buf[len - len_remain],
438 tx_len);
439 offset += tx_len;
440
441 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
442 if (ret) {
443 ath6kl_err("Unable to write to the device: %d\n",
444 ret);
445 return ret;
446 }
447
448 len_remain -= tx_len;
449 }
450
451 return 0;
452 }
453
ath6kl_bmi_lz_stream_start(struct ath6kl * ar,u32 addr)454 int ath6kl_bmi_lz_stream_start(struct ath6kl *ar, u32 addr)
455 {
456 u32 cid = BMI_LZ_STREAM_START;
457 int ret;
458 u32 offset;
459 u16 size;
460
461 if (ar->bmi.done_sent) {
462 ath6kl_err("bmi done sent already, cmd %d disallowed\n", cid);
463 return -EACCES;
464 }
465
466 size = sizeof(cid) + sizeof(addr);
467 if (size > ar->bmi.max_cmd_size) {
468 WARN_ON(1);
469 return -EINVAL;
470 }
471 memset(ar->bmi.cmd_buf, 0, size);
472
473 ath6kl_dbg(ATH6KL_DBG_BMI,
474 "bmi LZ stream start: addr: 0x%x)\n",
475 addr);
476
477 offset = 0;
478 memcpy(&(ar->bmi.cmd_buf[offset]), &cid, sizeof(cid));
479 offset += sizeof(cid);
480 memcpy(&(ar->bmi.cmd_buf[offset]), &addr, sizeof(addr));
481 offset += sizeof(addr);
482
483 ret = ath6kl_hif_bmi_write(ar, ar->bmi.cmd_buf, offset);
484 if (ret) {
485 ath6kl_err("Unable to start LZ stream to the device: %d\n",
486 ret);
487 return ret;
488 }
489
490 return 0;
491 }
492
ath6kl_bmi_fast_download(struct ath6kl * ar,u32 addr,u8 * buf,u32 len)493 int ath6kl_bmi_fast_download(struct ath6kl *ar, u32 addr, u8 *buf, u32 len)
494 {
495 int ret;
496 u32 last_word = 0;
497 u32 last_word_offset = len & ~0x3;
498 u32 unaligned_bytes = len & 0x3;
499
500 ret = ath6kl_bmi_lz_stream_start(ar, addr);
501 if (ret)
502 return ret;
503
504 if (unaligned_bytes) {
505 /* copy the last word into a zero padded buffer */
506 memcpy(&last_word, &buf[last_word_offset], unaligned_bytes);
507 }
508
509 ret = ath6kl_bmi_lz_data(ar, buf, last_word_offset);
510 if (ret)
511 return ret;
512
513 if (unaligned_bytes)
514 ret = ath6kl_bmi_lz_data(ar, (u8 *)&last_word, 4);
515
516 if (!ret) {
517 /* Close compressed stream and open a new (fake) one.
518 * This serves mainly to flush Target caches. */
519 ret = ath6kl_bmi_lz_stream_start(ar, 0x00);
520 }
521 return ret;
522 }
523
ath6kl_bmi_reset(struct ath6kl * ar)524 void ath6kl_bmi_reset(struct ath6kl *ar)
525 {
526 ar->bmi.done_sent = false;
527 }
528
ath6kl_bmi_init(struct ath6kl * ar)529 int ath6kl_bmi_init(struct ath6kl *ar)
530 {
531 if (WARN_ON(ar->bmi.max_data_size == 0))
532 return -EINVAL;
533
534 /* cmd + addr + len + data_size */
535 ar->bmi.max_cmd_size = ar->bmi.max_data_size + (sizeof(u32) * 3);
536
537 ar->bmi.cmd_buf = kzalloc(ar->bmi.max_cmd_size, GFP_KERNEL);
538 if (!ar->bmi.cmd_buf)
539 return -ENOMEM;
540
541 return 0;
542 }
543
ath6kl_bmi_cleanup(struct ath6kl * ar)544 void ath6kl_bmi_cleanup(struct ath6kl *ar)
545 {
546 kfree(ar->bmi.cmd_buf);
547 ar->bmi.cmd_buf = NULL;
548 }
549