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