1e76ac2bfSKalle Valo /*
2e76ac2bfSKalle Valo * Copyright (c) 2007-2011 Atheros Communications Inc.
3e76ac2bfSKalle Valo * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
4e76ac2bfSKalle Valo *
5e76ac2bfSKalle Valo * Permission to use, copy, modify, and/or distribute this software for any
6e76ac2bfSKalle Valo * purpose with or without fee is hereby granted, provided that the above
7e76ac2bfSKalle Valo * copyright notice and this permission notice appear in all copies.
8e76ac2bfSKalle Valo *
9e76ac2bfSKalle Valo * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10e76ac2bfSKalle Valo * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11e76ac2bfSKalle Valo * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12e76ac2bfSKalle Valo * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13e76ac2bfSKalle Valo * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14e76ac2bfSKalle Valo * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15e76ac2bfSKalle Valo * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16e76ac2bfSKalle Valo */
17e76ac2bfSKalle Valo
18e76ac2bfSKalle Valo #include "core.h"
19e76ac2bfSKalle Valo #include "hif.h"
20e76ac2bfSKalle Valo #include "debug.h"
21e76ac2bfSKalle Valo #include "hif-ops.h"
224771979aSKalle Valo #include "trace.h"
234771979aSKalle Valo
24e76ac2bfSKalle Valo #include <asm/unaligned.h>
25e76ac2bfSKalle Valo
26e76ac2bfSKalle Valo #define CALC_TXRX_PADDED_LEN(dev, len) (__ALIGN_MASK((len), (dev)->block_mask))
27e76ac2bfSKalle Valo
28e76ac2bfSKalle Valo static void ath6kl_htc_mbox_cleanup(struct htc_target *target);
29e76ac2bfSKalle Valo static void ath6kl_htc_mbox_stop(struct htc_target *target);
30e76ac2bfSKalle Valo static int ath6kl_htc_mbox_add_rxbuf_multiple(struct htc_target *target,
31e76ac2bfSKalle Valo struct list_head *pkt_queue);
32e76ac2bfSKalle Valo static void ath6kl_htc_set_credit_dist(struct htc_target *target,
33e76ac2bfSKalle Valo struct ath6kl_htc_credit_info *cred_info,
34e76ac2bfSKalle Valo u16 svc_pri_order[], int len);
35e76ac2bfSKalle Valo
36e76ac2bfSKalle Valo /* threshold to re-enable Tx bundling for an AC*/
37e76ac2bfSKalle Valo #define TX_RESUME_BUNDLE_THRESHOLD 1500
38e76ac2bfSKalle Valo
39e76ac2bfSKalle Valo /* Functions for Tx credit handling */
ath6kl_credit_deposit(struct ath6kl_htc_credit_info * cred_info,struct htc_endpoint_credit_dist * ep_dist,int credits)40e76ac2bfSKalle Valo static void ath6kl_credit_deposit(struct ath6kl_htc_credit_info *cred_info,
41e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *ep_dist,
42e76ac2bfSKalle Valo int credits)
43e76ac2bfSKalle Valo {
44e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT, "credit deposit ep %d credits %d\n",
45e76ac2bfSKalle Valo ep_dist->endpoint, credits);
46e76ac2bfSKalle Valo
47e76ac2bfSKalle Valo ep_dist->credits += credits;
48e76ac2bfSKalle Valo ep_dist->cred_assngd += credits;
49e76ac2bfSKalle Valo cred_info->cur_free_credits -= credits;
50e76ac2bfSKalle Valo }
51e76ac2bfSKalle Valo
ath6kl_credit_init(struct ath6kl_htc_credit_info * cred_info,struct list_head * ep_list,int tot_credits)52e76ac2bfSKalle Valo static void ath6kl_credit_init(struct ath6kl_htc_credit_info *cred_info,
53e76ac2bfSKalle Valo struct list_head *ep_list,
54e76ac2bfSKalle Valo int tot_credits)
55e76ac2bfSKalle Valo {
56e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *cur_ep_dist;
57e76ac2bfSKalle Valo int count;
58e76ac2bfSKalle Valo
59e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT, "credit init total %d\n", tot_credits);
60e76ac2bfSKalle Valo
61e76ac2bfSKalle Valo cred_info->cur_free_credits = tot_credits;
62e76ac2bfSKalle Valo cred_info->total_avail_credits = tot_credits;
63e76ac2bfSKalle Valo
64e76ac2bfSKalle Valo list_for_each_entry(cur_ep_dist, ep_list, list) {
65e76ac2bfSKalle Valo if (cur_ep_dist->endpoint == ENDPOINT_0)
66e76ac2bfSKalle Valo continue;
67e76ac2bfSKalle Valo
68e76ac2bfSKalle Valo cur_ep_dist->cred_min = cur_ep_dist->cred_per_msg;
69e76ac2bfSKalle Valo
70e76ac2bfSKalle Valo if (tot_credits > 4) {
71e76ac2bfSKalle Valo if ((cur_ep_dist->svc_id == WMI_DATA_BK_SVC) ||
72e76ac2bfSKalle Valo (cur_ep_dist->svc_id == WMI_DATA_BE_SVC)) {
73e76ac2bfSKalle Valo ath6kl_credit_deposit(cred_info,
74e76ac2bfSKalle Valo cur_ep_dist,
75e76ac2bfSKalle Valo cur_ep_dist->cred_min);
76e76ac2bfSKalle Valo cur_ep_dist->dist_flags |= HTC_EP_ACTIVE;
77e76ac2bfSKalle Valo }
78e76ac2bfSKalle Valo }
79e76ac2bfSKalle Valo
80e76ac2bfSKalle Valo if (cur_ep_dist->svc_id == WMI_CONTROL_SVC) {
81e76ac2bfSKalle Valo ath6kl_credit_deposit(cred_info, cur_ep_dist,
82e76ac2bfSKalle Valo cur_ep_dist->cred_min);
83e76ac2bfSKalle Valo /*
84e76ac2bfSKalle Valo * Control service is always marked active, it
85e76ac2bfSKalle Valo * never goes inactive EVER.
86e76ac2bfSKalle Valo */
87e76ac2bfSKalle Valo cur_ep_dist->dist_flags |= HTC_EP_ACTIVE;
88f5f7ba25SKevin Fang }
89e76ac2bfSKalle Valo
90e76ac2bfSKalle Valo /*
91e76ac2bfSKalle Valo * Streams have to be created (explicit | implicit) for all
92e76ac2bfSKalle Valo * kinds of traffic. BE endpoints are also inactive in the
93e76ac2bfSKalle Valo * beginning. When BE traffic starts it creates implicit
94e76ac2bfSKalle Valo * streams that redistributes credits.
95e76ac2bfSKalle Valo *
96e76ac2bfSKalle Valo * Note: all other endpoints have minimums set but are
97e76ac2bfSKalle Valo * initially given NO credits. credits will be distributed
98e76ac2bfSKalle Valo * as traffic activity demands
99e76ac2bfSKalle Valo */
100e76ac2bfSKalle Valo }
101e76ac2bfSKalle Valo
102f5f7ba25SKevin Fang /*
103f5f7ba25SKevin Fang * For ath6kl_credit_seek function,
104f5f7ba25SKevin Fang * it use list_for_each_entry_reverse to walk around the whole ep list.
105f5f7ba25SKevin Fang * Therefore assign this lowestpri_ep_dist after walk around the ep_list
106f5f7ba25SKevin Fang */
107f5f7ba25SKevin Fang cred_info->lowestpri_ep_dist = cur_ep_dist->list;
108f5f7ba25SKevin Fang
109e76ac2bfSKalle Valo WARN_ON(cred_info->cur_free_credits <= 0);
110e76ac2bfSKalle Valo
111e76ac2bfSKalle Valo list_for_each_entry(cur_ep_dist, ep_list, list) {
112e76ac2bfSKalle Valo if (cur_ep_dist->endpoint == ENDPOINT_0)
113e76ac2bfSKalle Valo continue;
114e76ac2bfSKalle Valo
115a5d8f9dfSKalle Valo if (cur_ep_dist->svc_id == WMI_CONTROL_SVC) {
116e76ac2bfSKalle Valo cur_ep_dist->cred_norm = cur_ep_dist->cred_per_msg;
117a5d8f9dfSKalle Valo } else {
118e76ac2bfSKalle Valo /*
119e76ac2bfSKalle Valo * For the remaining data endpoints, we assume that
120e76ac2bfSKalle Valo * each cred_per_msg are the same. We use a simple
121e76ac2bfSKalle Valo * calculation here, we take the remaining credits
122e76ac2bfSKalle Valo * and determine how many max messages this can
123e76ac2bfSKalle Valo * cover and then set each endpoint's normal value
124e76ac2bfSKalle Valo * equal to 3/4 this amount.
125e76ac2bfSKalle Valo */
126e76ac2bfSKalle Valo count = (cred_info->cur_free_credits /
127e76ac2bfSKalle Valo cur_ep_dist->cred_per_msg)
128e76ac2bfSKalle Valo * cur_ep_dist->cred_per_msg;
129e76ac2bfSKalle Valo count = (count * 3) >> 2;
130e76ac2bfSKalle Valo count = max(count, cur_ep_dist->cred_per_msg);
131e76ac2bfSKalle Valo cur_ep_dist->cred_norm = count;
132e76ac2bfSKalle Valo }
133e76ac2bfSKalle Valo
134e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT,
135e76ac2bfSKalle Valo "credit ep %d svc_id %d credits %d per_msg %d norm %d min %d\n",
136e76ac2bfSKalle Valo cur_ep_dist->endpoint,
137e76ac2bfSKalle Valo cur_ep_dist->svc_id,
138e76ac2bfSKalle Valo cur_ep_dist->credits,
139e76ac2bfSKalle Valo cur_ep_dist->cred_per_msg,
140e76ac2bfSKalle Valo cur_ep_dist->cred_norm,
141e76ac2bfSKalle Valo cur_ep_dist->cred_min);
142e76ac2bfSKalle Valo }
143e76ac2bfSKalle Valo }
144e76ac2bfSKalle Valo
145e76ac2bfSKalle Valo /* initialize and setup credit distribution */
ath6kl_htc_mbox_credit_setup(struct htc_target * htc_target,struct ath6kl_htc_credit_info * cred_info)146e76ac2bfSKalle Valo static int ath6kl_htc_mbox_credit_setup(struct htc_target *htc_target,
147e76ac2bfSKalle Valo struct ath6kl_htc_credit_info *cred_info)
148e76ac2bfSKalle Valo {
149e76ac2bfSKalle Valo u16 servicepriority[5];
150e76ac2bfSKalle Valo
151e76ac2bfSKalle Valo memset(cred_info, 0, sizeof(struct ath6kl_htc_credit_info));
152e76ac2bfSKalle Valo
153e76ac2bfSKalle Valo servicepriority[0] = WMI_CONTROL_SVC; /* highest */
154e76ac2bfSKalle Valo servicepriority[1] = WMI_DATA_VO_SVC;
155e76ac2bfSKalle Valo servicepriority[2] = WMI_DATA_VI_SVC;
156e76ac2bfSKalle Valo servicepriority[3] = WMI_DATA_BE_SVC;
157e76ac2bfSKalle Valo servicepriority[4] = WMI_DATA_BK_SVC; /* lowest */
158e76ac2bfSKalle Valo
159e76ac2bfSKalle Valo /* set priority list */
160e76ac2bfSKalle Valo ath6kl_htc_set_credit_dist(htc_target, cred_info, servicepriority, 5);
161e76ac2bfSKalle Valo
162e76ac2bfSKalle Valo return 0;
163e76ac2bfSKalle Valo }
164e76ac2bfSKalle Valo
165e76ac2bfSKalle Valo /* reduce an ep's credits back to a set limit */
ath6kl_credit_reduce(struct ath6kl_htc_credit_info * cred_info,struct htc_endpoint_credit_dist * ep_dist,int limit)166e76ac2bfSKalle Valo static void ath6kl_credit_reduce(struct ath6kl_htc_credit_info *cred_info,
167e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *ep_dist,
168e76ac2bfSKalle Valo int limit)
169e76ac2bfSKalle Valo {
170e76ac2bfSKalle Valo int credits;
171e76ac2bfSKalle Valo
172e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT, "credit reduce ep %d limit %d\n",
173e76ac2bfSKalle Valo ep_dist->endpoint, limit);
174e76ac2bfSKalle Valo
175e76ac2bfSKalle Valo ep_dist->cred_assngd = limit;
176e76ac2bfSKalle Valo
177e76ac2bfSKalle Valo if (ep_dist->credits <= limit)
178e76ac2bfSKalle Valo return;
179e76ac2bfSKalle Valo
180e76ac2bfSKalle Valo credits = ep_dist->credits - limit;
181e76ac2bfSKalle Valo ep_dist->credits -= credits;
182e76ac2bfSKalle Valo cred_info->cur_free_credits += credits;
183e76ac2bfSKalle Valo }
184e76ac2bfSKalle Valo
ath6kl_credit_update(struct ath6kl_htc_credit_info * cred_info,struct list_head * epdist_list)185e76ac2bfSKalle Valo static void ath6kl_credit_update(struct ath6kl_htc_credit_info *cred_info,
186e76ac2bfSKalle Valo struct list_head *epdist_list)
187e76ac2bfSKalle Valo {
188e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *cur_list;
189e76ac2bfSKalle Valo
190e76ac2bfSKalle Valo list_for_each_entry(cur_list, epdist_list, list) {
191e76ac2bfSKalle Valo if (cur_list->endpoint == ENDPOINT_0)
192e76ac2bfSKalle Valo continue;
193e76ac2bfSKalle Valo
194e76ac2bfSKalle Valo if (cur_list->cred_to_dist > 0) {
195e76ac2bfSKalle Valo cur_list->credits += cur_list->cred_to_dist;
196e76ac2bfSKalle Valo cur_list->cred_to_dist = 0;
197e76ac2bfSKalle Valo
198e76ac2bfSKalle Valo if (cur_list->credits > cur_list->cred_assngd)
199e76ac2bfSKalle Valo ath6kl_credit_reduce(cred_info,
200e76ac2bfSKalle Valo cur_list,
201e76ac2bfSKalle Valo cur_list->cred_assngd);
202e76ac2bfSKalle Valo
203e76ac2bfSKalle Valo if (cur_list->credits > cur_list->cred_norm)
204e76ac2bfSKalle Valo ath6kl_credit_reduce(cred_info, cur_list,
205e76ac2bfSKalle Valo cur_list->cred_norm);
206e76ac2bfSKalle Valo
207e76ac2bfSKalle Valo if (!(cur_list->dist_flags & HTC_EP_ACTIVE)) {
208e76ac2bfSKalle Valo if (cur_list->txq_depth == 0)
209e76ac2bfSKalle Valo ath6kl_credit_reduce(cred_info,
210e76ac2bfSKalle Valo cur_list, 0);
211e76ac2bfSKalle Valo }
212e76ac2bfSKalle Valo }
213e76ac2bfSKalle Valo }
214e76ac2bfSKalle Valo }
215e76ac2bfSKalle Valo
216e76ac2bfSKalle Valo /*
217e76ac2bfSKalle Valo * HTC has an endpoint that needs credits, ep_dist is the endpoint in
218e76ac2bfSKalle Valo * question.
219e76ac2bfSKalle Valo */
ath6kl_credit_seek(struct ath6kl_htc_credit_info * cred_info,struct htc_endpoint_credit_dist * ep_dist)220e76ac2bfSKalle Valo static void ath6kl_credit_seek(struct ath6kl_htc_credit_info *cred_info,
221e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *ep_dist)
222e76ac2bfSKalle Valo {
223e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *curdist_list;
224e76ac2bfSKalle Valo int credits = 0;
225e76ac2bfSKalle Valo int need;
226e76ac2bfSKalle Valo
227e76ac2bfSKalle Valo if (ep_dist->svc_id == WMI_CONTROL_SVC)
228e76ac2bfSKalle Valo goto out;
229e76ac2bfSKalle Valo
230e76ac2bfSKalle Valo if ((ep_dist->svc_id == WMI_DATA_VI_SVC) ||
231e76ac2bfSKalle Valo (ep_dist->svc_id == WMI_DATA_VO_SVC))
232e76ac2bfSKalle Valo if ((ep_dist->cred_assngd >= ep_dist->cred_norm))
233e76ac2bfSKalle Valo goto out;
234e76ac2bfSKalle Valo
235e76ac2bfSKalle Valo /*
236e76ac2bfSKalle Valo * For all other services, we follow a simple algorithm of:
237e76ac2bfSKalle Valo *
238e76ac2bfSKalle Valo * 1. checking the free pool for credits
239e76ac2bfSKalle Valo * 2. checking lower priority endpoints for credits to take
240e76ac2bfSKalle Valo */
241e76ac2bfSKalle Valo
242e76ac2bfSKalle Valo credits = min(cred_info->cur_free_credits, ep_dist->seek_cred);
243e76ac2bfSKalle Valo
244e76ac2bfSKalle Valo if (credits >= ep_dist->seek_cred)
245e76ac2bfSKalle Valo goto out;
246e76ac2bfSKalle Valo
247e76ac2bfSKalle Valo /*
248e76ac2bfSKalle Valo * We don't have enough in the free pool, try taking away from
249e76ac2bfSKalle Valo * lower priority services The rule for taking away credits:
250e76ac2bfSKalle Valo *
251e76ac2bfSKalle Valo * 1. Only take from lower priority endpoints
252e76ac2bfSKalle Valo * 2. Only take what is allocated above the minimum (never
253e76ac2bfSKalle Valo * starve an endpoint completely)
254e76ac2bfSKalle Valo * 3. Only take what you need.
255e76ac2bfSKalle Valo */
256e76ac2bfSKalle Valo
257e76ac2bfSKalle Valo list_for_each_entry_reverse(curdist_list,
258e76ac2bfSKalle Valo &cred_info->lowestpri_ep_dist,
259e76ac2bfSKalle Valo list) {
260e76ac2bfSKalle Valo if (curdist_list == ep_dist)
261e76ac2bfSKalle Valo break;
262e76ac2bfSKalle Valo
263e76ac2bfSKalle Valo need = ep_dist->seek_cred - cred_info->cur_free_credits;
264e76ac2bfSKalle Valo
265e76ac2bfSKalle Valo if ((curdist_list->cred_assngd - need) >=
266e76ac2bfSKalle Valo curdist_list->cred_min) {
267e76ac2bfSKalle Valo /*
268e76ac2bfSKalle Valo * The current one has been allocated more than
269e76ac2bfSKalle Valo * it's minimum and it has enough credits assigned
270e76ac2bfSKalle Valo * above it's minimum to fulfill our need try to
271e76ac2bfSKalle Valo * take away just enough to fulfill our need.
272e76ac2bfSKalle Valo */
273e76ac2bfSKalle Valo ath6kl_credit_reduce(cred_info, curdist_list,
274e76ac2bfSKalle Valo curdist_list->cred_assngd - need);
275e76ac2bfSKalle Valo
276e76ac2bfSKalle Valo if (cred_info->cur_free_credits >=
277e76ac2bfSKalle Valo ep_dist->seek_cred)
278e76ac2bfSKalle Valo break;
279e76ac2bfSKalle Valo }
280e76ac2bfSKalle Valo
281e76ac2bfSKalle Valo if (curdist_list->endpoint == ENDPOINT_0)
282e76ac2bfSKalle Valo break;
283e76ac2bfSKalle Valo }
284e76ac2bfSKalle Valo
285e76ac2bfSKalle Valo credits = min(cred_info->cur_free_credits, ep_dist->seek_cred);
286e76ac2bfSKalle Valo
287e76ac2bfSKalle Valo out:
288e76ac2bfSKalle Valo /* did we find some credits? */
289e76ac2bfSKalle Valo if (credits)
290e76ac2bfSKalle Valo ath6kl_credit_deposit(cred_info, ep_dist, credits);
291e76ac2bfSKalle Valo
292e76ac2bfSKalle Valo ep_dist->seek_cred = 0;
293e76ac2bfSKalle Valo }
294e76ac2bfSKalle Valo
295e76ac2bfSKalle Valo /* redistribute credits based on activity change */
ath6kl_credit_redistribute(struct ath6kl_htc_credit_info * info,struct list_head * ep_dist_list)296e76ac2bfSKalle Valo static void ath6kl_credit_redistribute(struct ath6kl_htc_credit_info *info,
297e76ac2bfSKalle Valo struct list_head *ep_dist_list)
298e76ac2bfSKalle Valo {
299e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *curdist_list;
300e76ac2bfSKalle Valo
301e76ac2bfSKalle Valo list_for_each_entry(curdist_list, ep_dist_list, list) {
302e76ac2bfSKalle Valo if (curdist_list->endpoint == ENDPOINT_0)
303e76ac2bfSKalle Valo continue;
304e76ac2bfSKalle Valo
305e76ac2bfSKalle Valo if ((curdist_list->svc_id == WMI_DATA_BK_SVC) ||
306e76ac2bfSKalle Valo (curdist_list->svc_id == WMI_DATA_BE_SVC))
307e76ac2bfSKalle Valo curdist_list->dist_flags |= HTC_EP_ACTIVE;
308e76ac2bfSKalle Valo
309e76ac2bfSKalle Valo if ((curdist_list->svc_id != WMI_CONTROL_SVC) &&
310e76ac2bfSKalle Valo !(curdist_list->dist_flags & HTC_EP_ACTIVE)) {
311e76ac2bfSKalle Valo if (curdist_list->txq_depth == 0)
312e76ac2bfSKalle Valo ath6kl_credit_reduce(info, curdist_list, 0);
313e76ac2bfSKalle Valo else
314e76ac2bfSKalle Valo ath6kl_credit_reduce(info,
315e76ac2bfSKalle Valo curdist_list,
316e76ac2bfSKalle Valo curdist_list->cred_min);
317e76ac2bfSKalle Valo }
318e76ac2bfSKalle Valo }
319e76ac2bfSKalle Valo }
320e76ac2bfSKalle Valo
321e76ac2bfSKalle Valo /*
322e76ac2bfSKalle Valo *
323e76ac2bfSKalle Valo * This function is invoked whenever endpoints require credit
324e76ac2bfSKalle Valo * distributions. A lock is held while this function is invoked, this
325e76ac2bfSKalle Valo * function shall NOT block. The ep_dist_list is a list of distribution
326e76ac2bfSKalle Valo * structures in prioritized order as defined by the call to the
327e76ac2bfSKalle Valo * htc_set_credit_dist() api.
328e76ac2bfSKalle Valo */
ath6kl_credit_distribute(struct ath6kl_htc_credit_info * cred_info,struct list_head * ep_dist_list,enum htc_credit_dist_reason reason)329e76ac2bfSKalle Valo static void ath6kl_credit_distribute(struct ath6kl_htc_credit_info *cred_info,
330e76ac2bfSKalle Valo struct list_head *ep_dist_list,
331e76ac2bfSKalle Valo enum htc_credit_dist_reason reason)
332e76ac2bfSKalle Valo {
333e76ac2bfSKalle Valo switch (reason) {
334e76ac2bfSKalle Valo case HTC_CREDIT_DIST_SEND_COMPLETE:
335e76ac2bfSKalle Valo ath6kl_credit_update(cred_info, ep_dist_list);
336e76ac2bfSKalle Valo break;
337e76ac2bfSKalle Valo case HTC_CREDIT_DIST_ACTIVITY_CHANGE:
338e76ac2bfSKalle Valo ath6kl_credit_redistribute(cred_info, ep_dist_list);
339e76ac2bfSKalle Valo break;
340e76ac2bfSKalle Valo default:
341e76ac2bfSKalle Valo break;
342e76ac2bfSKalle Valo }
343e76ac2bfSKalle Valo
344e76ac2bfSKalle Valo WARN_ON(cred_info->cur_free_credits > cred_info->total_avail_credits);
345e76ac2bfSKalle Valo WARN_ON(cred_info->cur_free_credits < 0);
346e76ac2bfSKalle Valo }
347e76ac2bfSKalle Valo
ath6kl_htc_tx_buf_align(u8 ** buf,unsigned long len)348e76ac2bfSKalle Valo static void ath6kl_htc_tx_buf_align(u8 **buf, unsigned long len)
349e76ac2bfSKalle Valo {
350e76ac2bfSKalle Valo u8 *align_addr;
351e76ac2bfSKalle Valo
352e76ac2bfSKalle Valo if (!IS_ALIGNED((unsigned long) *buf, 4)) {
353e76ac2bfSKalle Valo align_addr = PTR_ALIGN(*buf - 4, 4);
354e76ac2bfSKalle Valo memmove(align_addr, *buf, len);
355e76ac2bfSKalle Valo *buf = align_addr;
356e76ac2bfSKalle Valo }
357e76ac2bfSKalle Valo }
358e76ac2bfSKalle Valo
ath6kl_htc_tx_prep_pkt(struct htc_packet * packet,u8 flags,int ctrl0,int ctrl1)359e76ac2bfSKalle Valo static void ath6kl_htc_tx_prep_pkt(struct htc_packet *packet, u8 flags,
360e76ac2bfSKalle Valo int ctrl0, int ctrl1)
361e76ac2bfSKalle Valo {
362e76ac2bfSKalle Valo struct htc_frame_hdr *hdr;
363e76ac2bfSKalle Valo
364e76ac2bfSKalle Valo packet->buf -= HTC_HDR_LENGTH;
365e76ac2bfSKalle Valo hdr = (struct htc_frame_hdr *)packet->buf;
366e76ac2bfSKalle Valo
367e76ac2bfSKalle Valo /* Endianess? */
368e76ac2bfSKalle Valo put_unaligned((u16)packet->act_len, &hdr->payld_len);
369e76ac2bfSKalle Valo hdr->flags = flags;
370e76ac2bfSKalle Valo hdr->eid = packet->endpoint;
371e76ac2bfSKalle Valo hdr->ctrl[0] = ctrl0;
372e76ac2bfSKalle Valo hdr->ctrl[1] = ctrl1;
373e76ac2bfSKalle Valo }
374e76ac2bfSKalle Valo
htc_reclaim_txctrl_buf(struct htc_target * target,struct htc_packet * pkt)375e76ac2bfSKalle Valo static void htc_reclaim_txctrl_buf(struct htc_target *target,
376e76ac2bfSKalle Valo struct htc_packet *pkt)
377e76ac2bfSKalle Valo {
378e76ac2bfSKalle Valo spin_lock_bh(&target->htc_lock);
379e76ac2bfSKalle Valo list_add_tail(&pkt->list, &target->free_ctrl_txbuf);
380e76ac2bfSKalle Valo spin_unlock_bh(&target->htc_lock);
381e76ac2bfSKalle Valo }
382e76ac2bfSKalle Valo
htc_get_control_buf(struct htc_target * target,bool tx)383e76ac2bfSKalle Valo static struct htc_packet *htc_get_control_buf(struct htc_target *target,
384e76ac2bfSKalle Valo bool tx)
385e76ac2bfSKalle Valo {
386e76ac2bfSKalle Valo struct htc_packet *packet = NULL;
387e76ac2bfSKalle Valo struct list_head *buf_list;
388e76ac2bfSKalle Valo
389e76ac2bfSKalle Valo buf_list = tx ? &target->free_ctrl_txbuf : &target->free_ctrl_rxbuf;
390e76ac2bfSKalle Valo
391e76ac2bfSKalle Valo spin_lock_bh(&target->htc_lock);
392e76ac2bfSKalle Valo
393e76ac2bfSKalle Valo if (list_empty(buf_list)) {
394e76ac2bfSKalle Valo spin_unlock_bh(&target->htc_lock);
395e76ac2bfSKalle Valo return NULL;
396e76ac2bfSKalle Valo }
397e76ac2bfSKalle Valo
398e76ac2bfSKalle Valo packet = list_first_entry(buf_list, struct htc_packet, list);
399e76ac2bfSKalle Valo list_del(&packet->list);
400e76ac2bfSKalle Valo spin_unlock_bh(&target->htc_lock);
401e76ac2bfSKalle Valo
402e76ac2bfSKalle Valo if (tx)
403e76ac2bfSKalle Valo packet->buf = packet->buf_start + HTC_HDR_LENGTH;
404e76ac2bfSKalle Valo
405e76ac2bfSKalle Valo return packet;
406e76ac2bfSKalle Valo }
407e76ac2bfSKalle Valo
htc_tx_comp_update(struct htc_target * target,struct htc_endpoint * endpoint,struct htc_packet * packet)408e76ac2bfSKalle Valo static void htc_tx_comp_update(struct htc_target *target,
409e76ac2bfSKalle Valo struct htc_endpoint *endpoint,
410e76ac2bfSKalle Valo struct htc_packet *packet)
411e76ac2bfSKalle Valo {
412e76ac2bfSKalle Valo packet->completion = NULL;
413e76ac2bfSKalle Valo packet->buf += HTC_HDR_LENGTH;
414e76ac2bfSKalle Valo
415e76ac2bfSKalle Valo if (!packet->status)
416e76ac2bfSKalle Valo return;
417e76ac2bfSKalle Valo
418e76ac2bfSKalle Valo ath6kl_err("req failed (status:%d, ep:%d, len:%d creds:%d)\n",
419e76ac2bfSKalle Valo packet->status, packet->endpoint, packet->act_len,
420e76ac2bfSKalle Valo packet->info.tx.cred_used);
421e76ac2bfSKalle Valo
422e76ac2bfSKalle Valo /* on failure to submit, reclaim credits for this packet */
423e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
424e76ac2bfSKalle Valo endpoint->cred_dist.cred_to_dist +=
425e76ac2bfSKalle Valo packet->info.tx.cred_used;
426e76ac2bfSKalle Valo endpoint->cred_dist.txq_depth = get_queue_depth(&endpoint->txq);
427e76ac2bfSKalle Valo
428e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC, "htc tx ctxt 0x%p dist 0x%p\n",
429e76ac2bfSKalle Valo target->credit_info, &target->cred_dist_list);
430e76ac2bfSKalle Valo
431e76ac2bfSKalle Valo ath6kl_credit_distribute(target->credit_info,
432e76ac2bfSKalle Valo &target->cred_dist_list,
433e76ac2bfSKalle Valo HTC_CREDIT_DIST_SEND_COMPLETE);
434e76ac2bfSKalle Valo
435e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
436e76ac2bfSKalle Valo }
437e76ac2bfSKalle Valo
htc_tx_complete(struct htc_endpoint * endpoint,struct list_head * txq)438e76ac2bfSKalle Valo static void htc_tx_complete(struct htc_endpoint *endpoint,
439e76ac2bfSKalle Valo struct list_head *txq)
440e76ac2bfSKalle Valo {
441e76ac2bfSKalle Valo if (list_empty(txq))
442e76ac2bfSKalle Valo return;
443e76ac2bfSKalle Valo
444e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
445e76ac2bfSKalle Valo "htc tx complete ep %d pkts %d\n",
446e76ac2bfSKalle Valo endpoint->eid, get_queue_depth(txq));
447e76ac2bfSKalle Valo
448e76ac2bfSKalle Valo ath6kl_tx_complete(endpoint->target, txq);
449e76ac2bfSKalle Valo }
450e76ac2bfSKalle Valo
htc_tx_comp_handler(struct htc_target * target,struct htc_packet * packet)451e76ac2bfSKalle Valo static void htc_tx_comp_handler(struct htc_target *target,
452e76ac2bfSKalle Valo struct htc_packet *packet)
453e76ac2bfSKalle Valo {
454e76ac2bfSKalle Valo struct htc_endpoint *endpoint = &target->endpoint[packet->endpoint];
455e76ac2bfSKalle Valo struct list_head container;
456e76ac2bfSKalle Valo
457e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC, "htc tx complete seqno %d\n",
458e76ac2bfSKalle Valo packet->info.tx.seqno);
459e76ac2bfSKalle Valo
460e76ac2bfSKalle Valo htc_tx_comp_update(target, endpoint, packet);
461e76ac2bfSKalle Valo INIT_LIST_HEAD(&container);
462e76ac2bfSKalle Valo list_add_tail(&packet->list, &container);
463e76ac2bfSKalle Valo /* do completion */
464e76ac2bfSKalle Valo htc_tx_complete(endpoint, &container);
465e76ac2bfSKalle Valo }
466e76ac2bfSKalle Valo
htc_async_tx_scat_complete(struct htc_target * target,struct hif_scatter_req * scat_req)467e76ac2bfSKalle Valo static void htc_async_tx_scat_complete(struct htc_target *target,
468e76ac2bfSKalle Valo struct hif_scatter_req *scat_req)
469e76ac2bfSKalle Valo {
470e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
471e76ac2bfSKalle Valo struct htc_packet *packet;
472e76ac2bfSKalle Valo struct list_head tx_compq;
473e76ac2bfSKalle Valo int i;
474e76ac2bfSKalle Valo
475e76ac2bfSKalle Valo INIT_LIST_HEAD(&tx_compq);
476e76ac2bfSKalle Valo
477e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
478e76ac2bfSKalle Valo "htc tx scat complete len %d entries %d\n",
479e76ac2bfSKalle Valo scat_req->len, scat_req->scat_entries);
480e76ac2bfSKalle Valo
481e76ac2bfSKalle Valo if (scat_req->status)
482e76ac2bfSKalle Valo ath6kl_err("send scatter req failed: %d\n", scat_req->status);
483e76ac2bfSKalle Valo
484e76ac2bfSKalle Valo packet = scat_req->scat_list[0].packet;
485e76ac2bfSKalle Valo endpoint = &target->endpoint[packet->endpoint];
486e76ac2bfSKalle Valo
487e76ac2bfSKalle Valo /* walk through the scatter list and process */
488e76ac2bfSKalle Valo for (i = 0; i < scat_req->scat_entries; i++) {
489e76ac2bfSKalle Valo packet = scat_req->scat_list[i].packet;
490e76ac2bfSKalle Valo if (!packet) {
491e76ac2bfSKalle Valo WARN_ON(1);
492e76ac2bfSKalle Valo return;
493e76ac2bfSKalle Valo }
494e76ac2bfSKalle Valo
495e76ac2bfSKalle Valo packet->status = scat_req->status;
496e76ac2bfSKalle Valo htc_tx_comp_update(target, endpoint, packet);
497e76ac2bfSKalle Valo list_add_tail(&packet->list, &tx_compq);
498e76ac2bfSKalle Valo }
499e76ac2bfSKalle Valo
500e76ac2bfSKalle Valo /* free scatter request */
501e76ac2bfSKalle Valo hif_scatter_req_add(target->dev->ar, scat_req);
502e76ac2bfSKalle Valo
503e76ac2bfSKalle Valo /* complete all packets */
504e76ac2bfSKalle Valo htc_tx_complete(endpoint, &tx_compq);
505e76ac2bfSKalle Valo }
506e76ac2bfSKalle Valo
ath6kl_htc_tx_issue(struct htc_target * target,struct htc_packet * packet)507e76ac2bfSKalle Valo static int ath6kl_htc_tx_issue(struct htc_target *target,
508e76ac2bfSKalle Valo struct htc_packet *packet)
509e76ac2bfSKalle Valo {
510e76ac2bfSKalle Valo int status;
511e76ac2bfSKalle Valo bool sync = false;
512e76ac2bfSKalle Valo u32 padded_len, send_len;
513e76ac2bfSKalle Valo
514e76ac2bfSKalle Valo if (!packet->completion)
515e76ac2bfSKalle Valo sync = true;
516e76ac2bfSKalle Valo
517e76ac2bfSKalle Valo send_len = packet->act_len + HTC_HDR_LENGTH;
518e76ac2bfSKalle Valo
519e76ac2bfSKalle Valo padded_len = CALC_TXRX_PADDED_LEN(target, send_len);
520e76ac2bfSKalle Valo
521e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
522e76ac2bfSKalle Valo "htc tx issue len %d seqno %d padded_len %d mbox 0x%X %s\n",
523e76ac2bfSKalle Valo send_len, packet->info.tx.seqno, padded_len,
524e76ac2bfSKalle Valo target->dev->ar->mbox_info.htc_addr,
525e76ac2bfSKalle Valo sync ? "sync" : "async");
526e76ac2bfSKalle Valo
527e76ac2bfSKalle Valo if (sync) {
528e76ac2bfSKalle Valo status = hif_read_write_sync(target->dev->ar,
529e76ac2bfSKalle Valo target->dev->ar->mbox_info.htc_addr,
530e76ac2bfSKalle Valo packet->buf, padded_len,
531e76ac2bfSKalle Valo HIF_WR_SYNC_BLOCK_INC);
532e76ac2bfSKalle Valo
533e76ac2bfSKalle Valo packet->status = status;
534e76ac2bfSKalle Valo packet->buf += HTC_HDR_LENGTH;
535e76ac2bfSKalle Valo } else
536e76ac2bfSKalle Valo status = hif_write_async(target->dev->ar,
537e76ac2bfSKalle Valo target->dev->ar->mbox_info.htc_addr,
538e76ac2bfSKalle Valo packet->buf, padded_len,
539e76ac2bfSKalle Valo HIF_WR_ASYNC_BLOCK_INC, packet);
540e76ac2bfSKalle Valo
5414771979aSKalle Valo trace_ath6kl_htc_tx(status, packet->endpoint, packet->buf, send_len);
5424771979aSKalle Valo
543e76ac2bfSKalle Valo return status;
544e76ac2bfSKalle Valo }
545e76ac2bfSKalle Valo
htc_check_credits(struct htc_target * target,struct htc_endpoint * ep,u8 * flags,enum htc_endpoint_id eid,unsigned int len,int * req_cred)546e76ac2bfSKalle Valo static int htc_check_credits(struct htc_target *target,
547e76ac2bfSKalle Valo struct htc_endpoint *ep, u8 *flags,
548e76ac2bfSKalle Valo enum htc_endpoint_id eid, unsigned int len,
549e76ac2bfSKalle Valo int *req_cred)
550e76ac2bfSKalle Valo {
551e76ac2bfSKalle Valo *req_cred = (len > target->tgt_cred_sz) ?
552e76ac2bfSKalle Valo DIV_ROUND_UP(len, target->tgt_cred_sz) : 1;
553e76ac2bfSKalle Valo
554e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT, "credit check need %d got %d\n",
555e76ac2bfSKalle Valo *req_cred, ep->cred_dist.credits);
556e76ac2bfSKalle Valo
557e76ac2bfSKalle Valo if (ep->cred_dist.credits < *req_cred) {
558e76ac2bfSKalle Valo if (eid == ENDPOINT_0)
559e76ac2bfSKalle Valo return -EINVAL;
560e76ac2bfSKalle Valo
561e76ac2bfSKalle Valo /* Seek more credits */
562e76ac2bfSKalle Valo ep->cred_dist.seek_cred = *req_cred - ep->cred_dist.credits;
563e76ac2bfSKalle Valo
564e76ac2bfSKalle Valo ath6kl_credit_seek(target->credit_info, &ep->cred_dist);
565e76ac2bfSKalle Valo
566e76ac2bfSKalle Valo ep->cred_dist.seek_cred = 0;
567e76ac2bfSKalle Valo
568e76ac2bfSKalle Valo if (ep->cred_dist.credits < *req_cred) {
569e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT,
570e76ac2bfSKalle Valo "credit not found for ep %d\n",
571e76ac2bfSKalle Valo eid);
572e76ac2bfSKalle Valo return -EINVAL;
573e76ac2bfSKalle Valo }
574e76ac2bfSKalle Valo }
575e76ac2bfSKalle Valo
576e76ac2bfSKalle Valo ep->cred_dist.credits -= *req_cred;
577e76ac2bfSKalle Valo ep->ep_st.cred_cosumd += *req_cred;
578e76ac2bfSKalle Valo
579e76ac2bfSKalle Valo /* When we are getting low on credits, ask for more */
580e76ac2bfSKalle Valo if (ep->cred_dist.credits < ep->cred_dist.cred_per_msg) {
581e76ac2bfSKalle Valo ep->cred_dist.seek_cred =
582e76ac2bfSKalle Valo ep->cred_dist.cred_per_msg - ep->cred_dist.credits;
583e76ac2bfSKalle Valo
584e76ac2bfSKalle Valo ath6kl_credit_seek(target->credit_info, &ep->cred_dist);
585e76ac2bfSKalle Valo
586e76ac2bfSKalle Valo /* see if we were successful in getting more */
587e76ac2bfSKalle Valo if (ep->cred_dist.credits < ep->cred_dist.cred_per_msg) {
588e76ac2bfSKalle Valo /* tell the target we need credits ASAP! */
589e76ac2bfSKalle Valo *flags |= HTC_FLAGS_NEED_CREDIT_UPDATE;
590e76ac2bfSKalle Valo ep->ep_st.cred_low_indicate += 1;
591e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT,
592e76ac2bfSKalle Valo "credit we need credits asap\n");
593e76ac2bfSKalle Valo }
594e76ac2bfSKalle Valo }
595e76ac2bfSKalle Valo
596e76ac2bfSKalle Valo return 0;
597e76ac2bfSKalle Valo }
598e76ac2bfSKalle Valo
ath6kl_htc_tx_pkts_get(struct htc_target * target,struct htc_endpoint * endpoint,struct list_head * queue)599e76ac2bfSKalle Valo static void ath6kl_htc_tx_pkts_get(struct htc_target *target,
600e76ac2bfSKalle Valo struct htc_endpoint *endpoint,
601e76ac2bfSKalle Valo struct list_head *queue)
602e76ac2bfSKalle Valo {
603e76ac2bfSKalle Valo int req_cred;
604e76ac2bfSKalle Valo u8 flags;
605e76ac2bfSKalle Valo struct htc_packet *packet;
606e76ac2bfSKalle Valo unsigned int len;
607e76ac2bfSKalle Valo
608e76ac2bfSKalle Valo while (true) {
609e76ac2bfSKalle Valo flags = 0;
610e76ac2bfSKalle Valo
611e76ac2bfSKalle Valo if (list_empty(&endpoint->txq))
612e76ac2bfSKalle Valo break;
613e76ac2bfSKalle Valo packet = list_first_entry(&endpoint->txq, struct htc_packet,
614e76ac2bfSKalle Valo list);
615e76ac2bfSKalle Valo
616e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
617e76ac2bfSKalle Valo "htc tx got packet 0x%p queue depth %d\n",
618e76ac2bfSKalle Valo packet, get_queue_depth(&endpoint->txq));
619e76ac2bfSKalle Valo
620e76ac2bfSKalle Valo len = CALC_TXRX_PADDED_LEN(target,
621e76ac2bfSKalle Valo packet->act_len + HTC_HDR_LENGTH);
622e76ac2bfSKalle Valo
623e76ac2bfSKalle Valo if (htc_check_credits(target, endpoint, &flags,
624e76ac2bfSKalle Valo packet->endpoint, len, &req_cred))
625e76ac2bfSKalle Valo break;
626e76ac2bfSKalle Valo
627e76ac2bfSKalle Valo /* now we can fully move onto caller's queue */
628e76ac2bfSKalle Valo packet = list_first_entry(&endpoint->txq, struct htc_packet,
629e76ac2bfSKalle Valo list);
630e76ac2bfSKalle Valo list_move_tail(&packet->list, queue);
631e76ac2bfSKalle Valo
632e76ac2bfSKalle Valo /* save the number of credits this packet consumed */
633e76ac2bfSKalle Valo packet->info.tx.cred_used = req_cred;
634e76ac2bfSKalle Valo
635e76ac2bfSKalle Valo /* all TX packets are handled asynchronously */
636e76ac2bfSKalle Valo packet->completion = htc_tx_comp_handler;
637e76ac2bfSKalle Valo packet->context = target;
638e76ac2bfSKalle Valo endpoint->ep_st.tx_issued += 1;
639e76ac2bfSKalle Valo
640e76ac2bfSKalle Valo /* save send flags */
641e76ac2bfSKalle Valo packet->info.tx.flags = flags;
642e76ac2bfSKalle Valo packet->info.tx.seqno = endpoint->seqno;
643e76ac2bfSKalle Valo endpoint->seqno++;
644e76ac2bfSKalle Valo }
645e76ac2bfSKalle Valo }
646e76ac2bfSKalle Valo
647e76ac2bfSKalle Valo /* See if the padded tx length falls on a credit boundary */
htc_get_credit_padding(unsigned int cred_sz,int * len,struct htc_endpoint * ep)648e76ac2bfSKalle Valo static int htc_get_credit_padding(unsigned int cred_sz, int *len,
649e76ac2bfSKalle Valo struct htc_endpoint *ep)
650e76ac2bfSKalle Valo {
651e76ac2bfSKalle Valo int rem_cred, cred_pad;
652e76ac2bfSKalle Valo
653e76ac2bfSKalle Valo rem_cred = *len % cred_sz;
654e76ac2bfSKalle Valo
655e76ac2bfSKalle Valo /* No padding needed */
656e76ac2bfSKalle Valo if (!rem_cred)
657e76ac2bfSKalle Valo return 0;
658e76ac2bfSKalle Valo
659e76ac2bfSKalle Valo if (!(ep->conn_flags & HTC_FLGS_TX_BNDL_PAD_EN))
660e76ac2bfSKalle Valo return -1;
661e76ac2bfSKalle Valo
662e76ac2bfSKalle Valo /*
663e76ac2bfSKalle Valo * The transfer consumes a "partial" credit, this
664e76ac2bfSKalle Valo * packet cannot be bundled unless we add
665e76ac2bfSKalle Valo * additional "dummy" padding (max 255 bytes) to
666e76ac2bfSKalle Valo * consume the entire credit.
667e76ac2bfSKalle Valo */
668e76ac2bfSKalle Valo cred_pad = *len < cred_sz ? (cred_sz - *len) : rem_cred;
669e76ac2bfSKalle Valo
670e76ac2bfSKalle Valo if ((cred_pad > 0) && (cred_pad <= 255))
671e76ac2bfSKalle Valo *len += cred_pad;
672e76ac2bfSKalle Valo else
673e76ac2bfSKalle Valo /* The amount of padding is too large, send as non-bundled */
674e76ac2bfSKalle Valo return -1;
675e76ac2bfSKalle Valo
676e76ac2bfSKalle Valo return cred_pad;
677e76ac2bfSKalle Valo }
678e76ac2bfSKalle Valo
ath6kl_htc_tx_setup_scat_list(struct htc_target * target,struct htc_endpoint * endpoint,struct hif_scatter_req * scat_req,int n_scat,struct list_head * queue)679e76ac2bfSKalle Valo static int ath6kl_htc_tx_setup_scat_list(struct htc_target *target,
680e76ac2bfSKalle Valo struct htc_endpoint *endpoint,
681e76ac2bfSKalle Valo struct hif_scatter_req *scat_req,
682e76ac2bfSKalle Valo int n_scat,
683e76ac2bfSKalle Valo struct list_head *queue)
684e76ac2bfSKalle Valo {
685e76ac2bfSKalle Valo struct htc_packet *packet;
686e76ac2bfSKalle Valo int i, len, rem_scat, cred_pad;
687e76ac2bfSKalle Valo int status = 0;
688e76ac2bfSKalle Valo u8 flags;
689e76ac2bfSKalle Valo
690e76ac2bfSKalle Valo rem_scat = target->max_tx_bndl_sz;
691e76ac2bfSKalle Valo
692e76ac2bfSKalle Valo for (i = 0; i < n_scat; i++) {
693e76ac2bfSKalle Valo scat_req->scat_list[i].packet = NULL;
694e76ac2bfSKalle Valo
695e76ac2bfSKalle Valo if (list_empty(queue))
696e76ac2bfSKalle Valo break;
697e76ac2bfSKalle Valo
698e76ac2bfSKalle Valo packet = list_first_entry(queue, struct htc_packet, list);
699e76ac2bfSKalle Valo len = CALC_TXRX_PADDED_LEN(target,
700e76ac2bfSKalle Valo packet->act_len + HTC_HDR_LENGTH);
701e76ac2bfSKalle Valo
702e76ac2bfSKalle Valo cred_pad = htc_get_credit_padding(target->tgt_cred_sz,
703e76ac2bfSKalle Valo &len, endpoint);
704e76ac2bfSKalle Valo if (cred_pad < 0 || rem_scat < len) {
705e76ac2bfSKalle Valo status = -ENOSPC;
706e76ac2bfSKalle Valo break;
707e76ac2bfSKalle Valo }
708e76ac2bfSKalle Valo
709e76ac2bfSKalle Valo rem_scat -= len;
710e76ac2bfSKalle Valo /* now remove it from the queue */
711e76ac2bfSKalle Valo list_del(&packet->list);
712e76ac2bfSKalle Valo
713e76ac2bfSKalle Valo scat_req->scat_list[i].packet = packet;
714e76ac2bfSKalle Valo /* prepare packet and flag message as part of a send bundle */
715e76ac2bfSKalle Valo flags = packet->info.tx.flags | HTC_FLAGS_SEND_BUNDLE;
716e76ac2bfSKalle Valo ath6kl_htc_tx_prep_pkt(packet, flags,
717e76ac2bfSKalle Valo cred_pad, packet->info.tx.seqno);
718e76ac2bfSKalle Valo /* Make sure the buffer is 4-byte aligned */
719e76ac2bfSKalle Valo ath6kl_htc_tx_buf_align(&packet->buf,
720e76ac2bfSKalle Valo packet->act_len + HTC_HDR_LENGTH);
721e76ac2bfSKalle Valo scat_req->scat_list[i].buf = packet->buf;
722e76ac2bfSKalle Valo scat_req->scat_list[i].len = len;
723e76ac2bfSKalle Valo
724e76ac2bfSKalle Valo scat_req->len += len;
725e76ac2bfSKalle Valo scat_req->scat_entries++;
726e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
727e76ac2bfSKalle Valo "htc tx adding (%d) pkt 0x%p seqno %d len %d remaining %d\n",
728e76ac2bfSKalle Valo i, packet, packet->info.tx.seqno, len, rem_scat);
729e76ac2bfSKalle Valo }
730e76ac2bfSKalle Valo
731e76ac2bfSKalle Valo /* Roll back scatter setup in case of any failure */
732e76ac2bfSKalle Valo if (scat_req->scat_entries < HTC_MIN_HTC_MSGS_TO_BUNDLE) {
733e76ac2bfSKalle Valo for (i = scat_req->scat_entries - 1; i >= 0; i--) {
734e76ac2bfSKalle Valo packet = scat_req->scat_list[i].packet;
735e76ac2bfSKalle Valo if (packet) {
736e76ac2bfSKalle Valo packet->buf += HTC_HDR_LENGTH;
737e76ac2bfSKalle Valo list_add(&packet->list, queue);
738e76ac2bfSKalle Valo }
739e76ac2bfSKalle Valo }
740e76ac2bfSKalle Valo return -EAGAIN;
741e76ac2bfSKalle Valo }
742e76ac2bfSKalle Valo
743e76ac2bfSKalle Valo return status;
744e76ac2bfSKalle Valo }
745e76ac2bfSKalle Valo
746e76ac2bfSKalle Valo /*
747e76ac2bfSKalle Valo * Drain a queue and send as bundles this function may return without fully
748e76ac2bfSKalle Valo * draining the queue when
749e76ac2bfSKalle Valo *
750e76ac2bfSKalle Valo * 1. scatter resources are exhausted
751e76ac2bfSKalle Valo * 2. a message that will consume a partial credit will stop the
752e76ac2bfSKalle Valo * bundling process early
753e76ac2bfSKalle Valo * 3. we drop below the minimum number of messages for a bundle
754e76ac2bfSKalle Valo */
ath6kl_htc_tx_bundle(struct htc_endpoint * endpoint,struct list_head * queue,int * sent_bundle,int * n_bundle_pkts)755e76ac2bfSKalle Valo static void ath6kl_htc_tx_bundle(struct htc_endpoint *endpoint,
756e76ac2bfSKalle Valo struct list_head *queue,
757e76ac2bfSKalle Valo int *sent_bundle, int *n_bundle_pkts)
758e76ac2bfSKalle Valo {
759e76ac2bfSKalle Valo struct htc_target *target = endpoint->target;
760e76ac2bfSKalle Valo struct hif_scatter_req *scat_req = NULL;
7614771979aSKalle Valo int n_scat, n_sent_bundle = 0, tot_pkts_bundle = 0, i;
7624771979aSKalle Valo struct htc_packet *packet;
763e76ac2bfSKalle Valo int status;
764e76ac2bfSKalle Valo u32 txb_mask;
765e76ac2bfSKalle Valo u8 ac = WMM_NUM_AC;
766e76ac2bfSKalle Valo
7673acabc88SDan Carpenter if ((HTC_CTRL_RSVD_SVC != endpoint->svc_id) &&
768e76ac2bfSKalle Valo (WMI_CONTROL_SVC != endpoint->svc_id))
769e76ac2bfSKalle Valo ac = target->dev->ar->ep2ac_map[endpoint->eid];
770e76ac2bfSKalle Valo
771e76ac2bfSKalle Valo while (true) {
772e76ac2bfSKalle Valo status = 0;
773e76ac2bfSKalle Valo n_scat = get_queue_depth(queue);
774e76ac2bfSKalle Valo n_scat = min(n_scat, target->msg_per_bndl_max);
775e76ac2bfSKalle Valo
776e76ac2bfSKalle Valo if (n_scat < HTC_MIN_HTC_MSGS_TO_BUNDLE)
777e76ac2bfSKalle Valo /* not enough to bundle */
778e76ac2bfSKalle Valo break;
779e76ac2bfSKalle Valo
780e76ac2bfSKalle Valo scat_req = hif_scatter_req_get(target->dev->ar);
781e76ac2bfSKalle Valo
782e76ac2bfSKalle Valo if (!scat_req) {
783e76ac2bfSKalle Valo /* no scatter resources */
784e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
785e76ac2bfSKalle Valo "htc tx no more scatter resources\n");
786e76ac2bfSKalle Valo break;
787e76ac2bfSKalle Valo }
788e76ac2bfSKalle Valo
789e76ac2bfSKalle Valo if ((ac < WMM_NUM_AC) && (ac != WMM_AC_BK)) {
790e76ac2bfSKalle Valo if (WMM_AC_BE == ac)
791e76ac2bfSKalle Valo /*
792e76ac2bfSKalle Valo * BE, BK have priorities and bit
793e76ac2bfSKalle Valo * positions reversed
794e76ac2bfSKalle Valo */
795e76ac2bfSKalle Valo txb_mask = (1 << WMM_AC_BK);
796e76ac2bfSKalle Valo else
797e76ac2bfSKalle Valo /*
798e76ac2bfSKalle Valo * any AC with priority lower than
799e76ac2bfSKalle Valo * itself
800e76ac2bfSKalle Valo */
801e76ac2bfSKalle Valo txb_mask = ((1 << ac) - 1);
802b86aeb50SDan Carpenter
803e76ac2bfSKalle Valo /*
804e76ac2bfSKalle Valo * when the scatter request resources drop below a
805e76ac2bfSKalle Valo * certain threshold, disable Tx bundling for all
806e76ac2bfSKalle Valo * AC's with priority lower than the current requesting
807e76ac2bfSKalle Valo * AC. Otherwise re-enable Tx bundling for them
808e76ac2bfSKalle Valo */
809e76ac2bfSKalle Valo if (scat_req->scat_q_depth < ATH6KL_SCATTER_REQS)
810e76ac2bfSKalle Valo target->tx_bndl_mask &= ~txb_mask;
811e76ac2bfSKalle Valo else
812e76ac2bfSKalle Valo target->tx_bndl_mask |= txb_mask;
813e76ac2bfSKalle Valo }
814e76ac2bfSKalle Valo
815e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC, "htc tx pkts to scatter: %d\n",
816e76ac2bfSKalle Valo n_scat);
817e76ac2bfSKalle Valo
818e76ac2bfSKalle Valo scat_req->len = 0;
819e76ac2bfSKalle Valo scat_req->scat_entries = 0;
820e76ac2bfSKalle Valo
821e76ac2bfSKalle Valo status = ath6kl_htc_tx_setup_scat_list(target, endpoint,
822e76ac2bfSKalle Valo scat_req, n_scat,
823e76ac2bfSKalle Valo queue);
824e76ac2bfSKalle Valo if (status == -EAGAIN) {
825e76ac2bfSKalle Valo hif_scatter_req_add(target->dev->ar, scat_req);
826e76ac2bfSKalle Valo break;
827e76ac2bfSKalle Valo }
828e76ac2bfSKalle Valo
829e76ac2bfSKalle Valo /* send path is always asynchronous */
830e76ac2bfSKalle Valo scat_req->complete = htc_async_tx_scat_complete;
831e76ac2bfSKalle Valo n_sent_bundle++;
832e76ac2bfSKalle Valo tot_pkts_bundle += scat_req->scat_entries;
833e76ac2bfSKalle Valo
834e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
835e76ac2bfSKalle Valo "htc tx scatter bytes %d entries %d\n",
836e76ac2bfSKalle Valo scat_req->len, scat_req->scat_entries);
8374771979aSKalle Valo
8384771979aSKalle Valo for (i = 0; i < scat_req->scat_entries; i++) {
8394771979aSKalle Valo packet = scat_req->scat_list[i].packet;
8404771979aSKalle Valo trace_ath6kl_htc_tx(packet->status, packet->endpoint,
8414771979aSKalle Valo packet->buf, packet->act_len);
8424771979aSKalle Valo }
8434771979aSKalle Valo
844e76ac2bfSKalle Valo ath6kl_hif_submit_scat_req(target->dev, scat_req, false);
845e76ac2bfSKalle Valo
846e76ac2bfSKalle Valo if (status)
847e76ac2bfSKalle Valo break;
848e76ac2bfSKalle Valo }
849e76ac2bfSKalle Valo
850e76ac2bfSKalle Valo *sent_bundle = n_sent_bundle;
851e76ac2bfSKalle Valo *n_bundle_pkts = tot_pkts_bundle;
852e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC, "htc tx bundle sent %d pkts\n",
853e76ac2bfSKalle Valo n_sent_bundle);
854e76ac2bfSKalle Valo
855e76ac2bfSKalle Valo return;
856e76ac2bfSKalle Valo }
857e76ac2bfSKalle Valo
ath6kl_htc_tx_from_queue(struct htc_target * target,struct htc_endpoint * endpoint)858e76ac2bfSKalle Valo static void ath6kl_htc_tx_from_queue(struct htc_target *target,
859e76ac2bfSKalle Valo struct htc_endpoint *endpoint)
860e76ac2bfSKalle Valo {
861e76ac2bfSKalle Valo struct list_head txq;
862e76ac2bfSKalle Valo struct htc_packet *packet;
863e76ac2bfSKalle Valo int bundle_sent;
864e76ac2bfSKalle Valo int n_pkts_bundle;
865e76ac2bfSKalle Valo u8 ac = WMM_NUM_AC;
86693b42caeSVasanthakumar Thiagarajan int status;
867e76ac2bfSKalle Valo
868e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
869e76ac2bfSKalle Valo
870e76ac2bfSKalle Valo endpoint->tx_proc_cnt++;
871e76ac2bfSKalle Valo if (endpoint->tx_proc_cnt > 1) {
872e76ac2bfSKalle Valo endpoint->tx_proc_cnt--;
873e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
874e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC, "htc tx busy\n");
875e76ac2bfSKalle Valo return;
876e76ac2bfSKalle Valo }
877e76ac2bfSKalle Valo
878e76ac2bfSKalle Valo /*
879e76ac2bfSKalle Valo * drain the endpoint TX queue for transmission as long
880e76ac2bfSKalle Valo * as we have enough credits.
881e76ac2bfSKalle Valo */
882e76ac2bfSKalle Valo INIT_LIST_HEAD(&txq);
883e76ac2bfSKalle Valo
8843acabc88SDan Carpenter if ((HTC_CTRL_RSVD_SVC != endpoint->svc_id) &&
885e76ac2bfSKalle Valo (WMI_CONTROL_SVC != endpoint->svc_id))
886e76ac2bfSKalle Valo ac = target->dev->ar->ep2ac_map[endpoint->eid];
887e76ac2bfSKalle Valo
888e76ac2bfSKalle Valo while (true) {
889e76ac2bfSKalle Valo if (list_empty(&endpoint->txq))
890e76ac2bfSKalle Valo break;
891e76ac2bfSKalle Valo
892e76ac2bfSKalle Valo ath6kl_htc_tx_pkts_get(target, endpoint, &txq);
893e76ac2bfSKalle Valo
894e76ac2bfSKalle Valo if (list_empty(&txq))
895e76ac2bfSKalle Valo break;
896e76ac2bfSKalle Valo
897e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
898e76ac2bfSKalle Valo
899e76ac2bfSKalle Valo bundle_sent = 0;
900e76ac2bfSKalle Valo n_pkts_bundle = 0;
901e76ac2bfSKalle Valo
902e76ac2bfSKalle Valo while (true) {
903e76ac2bfSKalle Valo /* try to send a bundle on each pass */
904e76ac2bfSKalle Valo if ((target->tx_bndl_mask) &&
905e76ac2bfSKalle Valo (get_queue_depth(&txq) >=
906e76ac2bfSKalle Valo HTC_MIN_HTC_MSGS_TO_BUNDLE)) {
907e76ac2bfSKalle Valo int temp1 = 0, temp2 = 0;
908e76ac2bfSKalle Valo
909e76ac2bfSKalle Valo /* check if bundling is enabled for an AC */
910e76ac2bfSKalle Valo if (target->tx_bndl_mask & (1 << ac)) {
911e76ac2bfSKalle Valo ath6kl_htc_tx_bundle(endpoint, &txq,
912e76ac2bfSKalle Valo &temp1, &temp2);
913e76ac2bfSKalle Valo bundle_sent += temp1;
914e76ac2bfSKalle Valo n_pkts_bundle += temp2;
915e76ac2bfSKalle Valo }
916e76ac2bfSKalle Valo }
917e76ac2bfSKalle Valo
918e76ac2bfSKalle Valo if (list_empty(&txq))
919e76ac2bfSKalle Valo break;
920e76ac2bfSKalle Valo
921e76ac2bfSKalle Valo packet = list_first_entry(&txq, struct htc_packet,
922e76ac2bfSKalle Valo list);
923e76ac2bfSKalle Valo list_del(&packet->list);
924e76ac2bfSKalle Valo
925e76ac2bfSKalle Valo ath6kl_htc_tx_prep_pkt(packet, packet->info.tx.flags,
926e76ac2bfSKalle Valo 0, packet->info.tx.seqno);
92793b42caeSVasanthakumar Thiagarajan status = ath6kl_htc_tx_issue(target, packet);
92893b42caeSVasanthakumar Thiagarajan
92993b42caeSVasanthakumar Thiagarajan if (status) {
93093b42caeSVasanthakumar Thiagarajan packet->status = status;
93193b42caeSVasanthakumar Thiagarajan packet->completion(packet->context, packet);
93293b42caeSVasanthakumar Thiagarajan }
933e76ac2bfSKalle Valo }
934e76ac2bfSKalle Valo
935e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
936e76ac2bfSKalle Valo
937e76ac2bfSKalle Valo endpoint->ep_st.tx_bundles += bundle_sent;
938e76ac2bfSKalle Valo endpoint->ep_st.tx_pkt_bundled += n_pkts_bundle;
939e76ac2bfSKalle Valo
940e76ac2bfSKalle Valo /*
941e76ac2bfSKalle Valo * if an AC has bundling disabled and no tx bundling
942e76ac2bfSKalle Valo * has occured continously for a certain number of TX,
943e76ac2bfSKalle Valo * enable tx bundling for this AC
944e76ac2bfSKalle Valo */
945e76ac2bfSKalle Valo if (!bundle_sent) {
946e76ac2bfSKalle Valo if (!(target->tx_bndl_mask & (1 << ac)) &&
947e76ac2bfSKalle Valo (ac < WMM_NUM_AC)) {
948e76ac2bfSKalle Valo if (++target->ac_tx_count[ac] >=
949e76ac2bfSKalle Valo TX_RESUME_BUNDLE_THRESHOLD) {
950e76ac2bfSKalle Valo target->ac_tx_count[ac] = 0;
951e76ac2bfSKalle Valo target->tx_bndl_mask |= (1 << ac);
952e76ac2bfSKalle Valo }
953e76ac2bfSKalle Valo }
954e76ac2bfSKalle Valo } else {
955e76ac2bfSKalle Valo /* tx bundling will reset the counter */
956e76ac2bfSKalle Valo if (ac < WMM_NUM_AC)
957e76ac2bfSKalle Valo target->ac_tx_count[ac] = 0;
958e76ac2bfSKalle Valo }
959e76ac2bfSKalle Valo }
960e76ac2bfSKalle Valo
961e76ac2bfSKalle Valo endpoint->tx_proc_cnt = 0;
962e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
963e76ac2bfSKalle Valo }
964e76ac2bfSKalle Valo
ath6kl_htc_tx_try(struct htc_target * target,struct htc_endpoint * endpoint,struct htc_packet * tx_pkt)965e76ac2bfSKalle Valo static bool ath6kl_htc_tx_try(struct htc_target *target,
966e76ac2bfSKalle Valo struct htc_endpoint *endpoint,
967e76ac2bfSKalle Valo struct htc_packet *tx_pkt)
968e76ac2bfSKalle Valo {
969e76ac2bfSKalle Valo struct htc_ep_callbacks ep_cb;
970e76ac2bfSKalle Valo int txq_depth;
971e76ac2bfSKalle Valo bool overflow = false;
972e76ac2bfSKalle Valo
973e76ac2bfSKalle Valo ep_cb = endpoint->ep_cb;
974e76ac2bfSKalle Valo
975e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
976e76ac2bfSKalle Valo txq_depth = get_queue_depth(&endpoint->txq);
977e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
978e76ac2bfSKalle Valo
979e76ac2bfSKalle Valo if (txq_depth >= endpoint->max_txq_depth)
980e76ac2bfSKalle Valo overflow = true;
981e76ac2bfSKalle Valo
982e76ac2bfSKalle Valo if (overflow)
983e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
984e76ac2bfSKalle Valo "htc tx overflow ep %d depth %d max %d\n",
985e76ac2bfSKalle Valo endpoint->eid, txq_depth,
986e76ac2bfSKalle Valo endpoint->max_txq_depth);
987e76ac2bfSKalle Valo
988e76ac2bfSKalle Valo if (overflow && ep_cb.tx_full) {
989e76ac2bfSKalle Valo if (ep_cb.tx_full(endpoint->target, tx_pkt) ==
990e76ac2bfSKalle Valo HTC_SEND_FULL_DROP) {
991e76ac2bfSKalle Valo endpoint->ep_st.tx_dropped += 1;
992e76ac2bfSKalle Valo return false;
993e76ac2bfSKalle Valo }
994e76ac2bfSKalle Valo }
995e76ac2bfSKalle Valo
996e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
997e76ac2bfSKalle Valo list_add_tail(&tx_pkt->list, &endpoint->txq);
998e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
999e76ac2bfSKalle Valo
1000e76ac2bfSKalle Valo ath6kl_htc_tx_from_queue(target, endpoint);
1001e76ac2bfSKalle Valo
1002e76ac2bfSKalle Valo return true;
1003e76ac2bfSKalle Valo }
1004e76ac2bfSKalle Valo
htc_chk_ep_txq(struct htc_target * target)1005e76ac2bfSKalle Valo static void htc_chk_ep_txq(struct htc_target *target)
1006e76ac2bfSKalle Valo {
1007e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
1008e76ac2bfSKalle Valo struct htc_endpoint_credit_dist *cred_dist;
1009e76ac2bfSKalle Valo
1010e76ac2bfSKalle Valo /*
1011e76ac2bfSKalle Valo * Run through the credit distribution list to see if there are
1012e76ac2bfSKalle Valo * packets queued. NOTE: no locks need to be taken since the
1013e76ac2bfSKalle Valo * distribution list is not dynamic (cannot be re-ordered) and we
1014e76ac2bfSKalle Valo * are not modifying any state.
1015e76ac2bfSKalle Valo */
1016e76ac2bfSKalle Valo list_for_each_entry(cred_dist, &target->cred_dist_list, list) {
1017e76ac2bfSKalle Valo endpoint = cred_dist->htc_ep;
1018e76ac2bfSKalle Valo
1019e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
1020e76ac2bfSKalle Valo if (!list_empty(&endpoint->txq)) {
1021e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1022e76ac2bfSKalle Valo "htc creds ep %d credits %d pkts %d\n",
1023e76ac2bfSKalle Valo cred_dist->endpoint,
1024e76ac2bfSKalle Valo endpoint->cred_dist.credits,
1025e76ac2bfSKalle Valo get_queue_depth(&endpoint->txq));
1026e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
1027e76ac2bfSKalle Valo /*
1028e76ac2bfSKalle Valo * Try to start the stalled queue, this list is
1029e76ac2bfSKalle Valo * ordered by priority. If there are credits
1030e76ac2bfSKalle Valo * available the highest priority queue will get a
1031e76ac2bfSKalle Valo * chance to reclaim credits from lower priority
1032e76ac2bfSKalle Valo * ones.
1033e76ac2bfSKalle Valo */
1034e76ac2bfSKalle Valo ath6kl_htc_tx_from_queue(target, endpoint);
1035e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
1036e76ac2bfSKalle Valo }
1037e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
1038e76ac2bfSKalle Valo }
1039e76ac2bfSKalle Valo }
1040e76ac2bfSKalle Valo
htc_setup_tx_complete(struct htc_target * target)1041e76ac2bfSKalle Valo static int htc_setup_tx_complete(struct htc_target *target)
1042e76ac2bfSKalle Valo {
1043e76ac2bfSKalle Valo struct htc_packet *send_pkt = NULL;
1044e76ac2bfSKalle Valo int status;
1045e76ac2bfSKalle Valo
1046e76ac2bfSKalle Valo send_pkt = htc_get_control_buf(target, true);
1047e76ac2bfSKalle Valo
1048e76ac2bfSKalle Valo if (!send_pkt)
1049e76ac2bfSKalle Valo return -ENOMEM;
1050e76ac2bfSKalle Valo
1051e76ac2bfSKalle Valo if (target->htc_tgt_ver >= HTC_VERSION_2P1) {
1052e76ac2bfSKalle Valo struct htc_setup_comp_ext_msg *setup_comp_ext;
1053e76ac2bfSKalle Valo u32 flags = 0;
1054e76ac2bfSKalle Valo
1055e76ac2bfSKalle Valo setup_comp_ext =
1056e76ac2bfSKalle Valo (struct htc_setup_comp_ext_msg *)send_pkt->buf;
1057e76ac2bfSKalle Valo memset(setup_comp_ext, 0, sizeof(*setup_comp_ext));
1058e76ac2bfSKalle Valo setup_comp_ext->msg_id =
1059e76ac2bfSKalle Valo cpu_to_le16(HTC_MSG_SETUP_COMPLETE_EX_ID);
1060e76ac2bfSKalle Valo
1061e76ac2bfSKalle Valo if (target->msg_per_bndl_max > 0) {
1062e76ac2bfSKalle Valo /* Indicate HTC bundling to the target */
1063e76ac2bfSKalle Valo flags |= HTC_SETUP_COMP_FLG_RX_BNDL_EN;
1064e76ac2bfSKalle Valo setup_comp_ext->msg_per_rxbndl =
1065e76ac2bfSKalle Valo target->msg_per_bndl_max;
1066e76ac2bfSKalle Valo }
1067e76ac2bfSKalle Valo
1068e76ac2bfSKalle Valo memcpy(&setup_comp_ext->flags, &flags,
1069e76ac2bfSKalle Valo sizeof(setup_comp_ext->flags));
1070e76ac2bfSKalle Valo set_htc_pkt_info(send_pkt, NULL, (u8 *) setup_comp_ext,
1071e76ac2bfSKalle Valo sizeof(struct htc_setup_comp_ext_msg),
1072e76ac2bfSKalle Valo ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
1073e76ac2bfSKalle Valo
1074e76ac2bfSKalle Valo } else {
1075e76ac2bfSKalle Valo struct htc_setup_comp_msg *setup_comp;
1076e76ac2bfSKalle Valo setup_comp = (struct htc_setup_comp_msg *)send_pkt->buf;
1077e76ac2bfSKalle Valo memset(setup_comp, 0, sizeof(struct htc_setup_comp_msg));
1078e76ac2bfSKalle Valo setup_comp->msg_id = cpu_to_le16(HTC_MSG_SETUP_COMPLETE_ID);
1079e76ac2bfSKalle Valo set_htc_pkt_info(send_pkt, NULL, (u8 *) setup_comp,
1080e76ac2bfSKalle Valo sizeof(struct htc_setup_comp_msg),
1081e76ac2bfSKalle Valo ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
1082e76ac2bfSKalle Valo }
1083e76ac2bfSKalle Valo
1084e76ac2bfSKalle Valo /* we want synchronous operation */
1085e76ac2bfSKalle Valo send_pkt->completion = NULL;
1086e76ac2bfSKalle Valo ath6kl_htc_tx_prep_pkt(send_pkt, 0, 0, 0);
1087e76ac2bfSKalle Valo status = ath6kl_htc_tx_issue(target, send_pkt);
1088e76ac2bfSKalle Valo htc_reclaim_txctrl_buf(target, send_pkt);
1089e76ac2bfSKalle Valo
1090e76ac2bfSKalle Valo return status;
1091e76ac2bfSKalle Valo }
1092e76ac2bfSKalle Valo
ath6kl_htc_set_credit_dist(struct htc_target * target,struct ath6kl_htc_credit_info * credit_info,u16 srvc_pri_order[],int list_len)1093e76ac2bfSKalle Valo static void ath6kl_htc_set_credit_dist(struct htc_target *target,
1094e76ac2bfSKalle Valo struct ath6kl_htc_credit_info *credit_info,
1095e76ac2bfSKalle Valo u16 srvc_pri_order[], int list_len)
1096e76ac2bfSKalle Valo {
1097e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
1098e76ac2bfSKalle Valo int i, ep;
1099e76ac2bfSKalle Valo
1100e76ac2bfSKalle Valo target->credit_info = credit_info;
1101e76ac2bfSKalle Valo
1102e76ac2bfSKalle Valo list_add_tail(&target->endpoint[ENDPOINT_0].cred_dist.list,
1103e76ac2bfSKalle Valo &target->cred_dist_list);
1104e76ac2bfSKalle Valo
1105e76ac2bfSKalle Valo for (i = 0; i < list_len; i++) {
1106e76ac2bfSKalle Valo for (ep = ENDPOINT_1; ep < ENDPOINT_MAX; ep++) {
1107e76ac2bfSKalle Valo endpoint = &target->endpoint[ep];
1108e76ac2bfSKalle Valo if (endpoint->svc_id == srvc_pri_order[i]) {
1109e76ac2bfSKalle Valo list_add_tail(&endpoint->cred_dist.list,
1110e76ac2bfSKalle Valo &target->cred_dist_list);
1111e76ac2bfSKalle Valo break;
1112e76ac2bfSKalle Valo }
1113e76ac2bfSKalle Valo }
1114e76ac2bfSKalle Valo if (ep >= ENDPOINT_MAX) {
1115e76ac2bfSKalle Valo WARN_ON(1);
1116e76ac2bfSKalle Valo return;
1117e76ac2bfSKalle Valo }
1118e76ac2bfSKalle Valo }
1119e76ac2bfSKalle Valo }
1120e76ac2bfSKalle Valo
ath6kl_htc_mbox_tx(struct htc_target * target,struct htc_packet * packet)1121e76ac2bfSKalle Valo static int ath6kl_htc_mbox_tx(struct htc_target *target,
1122e76ac2bfSKalle Valo struct htc_packet *packet)
1123e76ac2bfSKalle Valo {
1124e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
1125e76ac2bfSKalle Valo struct list_head queue;
1126e76ac2bfSKalle Valo
1127e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1128e76ac2bfSKalle Valo "htc tx ep id %d buf 0x%p len %d\n",
1129e76ac2bfSKalle Valo packet->endpoint, packet->buf, packet->act_len);
1130e76ac2bfSKalle Valo
1131e76ac2bfSKalle Valo if (packet->endpoint >= ENDPOINT_MAX) {
1132e76ac2bfSKalle Valo WARN_ON(1);
1133e76ac2bfSKalle Valo return -EINVAL;
1134e76ac2bfSKalle Valo }
1135e76ac2bfSKalle Valo
1136e76ac2bfSKalle Valo endpoint = &target->endpoint[packet->endpoint];
1137e76ac2bfSKalle Valo
1138e76ac2bfSKalle Valo if (!ath6kl_htc_tx_try(target, endpoint, packet)) {
1139e76ac2bfSKalle Valo packet->status = (target->htc_flags & HTC_OP_STATE_STOPPING) ?
1140e76ac2bfSKalle Valo -ECANCELED : -ENOSPC;
1141e76ac2bfSKalle Valo INIT_LIST_HEAD(&queue);
1142e76ac2bfSKalle Valo list_add(&packet->list, &queue);
1143e76ac2bfSKalle Valo htc_tx_complete(endpoint, &queue);
1144e76ac2bfSKalle Valo }
1145e76ac2bfSKalle Valo
1146e76ac2bfSKalle Valo return 0;
1147e76ac2bfSKalle Valo }
1148e76ac2bfSKalle Valo
1149e76ac2bfSKalle Valo /* flush endpoint TX queue */
ath6kl_htc_mbox_flush_txep(struct htc_target * target,enum htc_endpoint_id eid,u16 tag)1150e76ac2bfSKalle Valo static void ath6kl_htc_mbox_flush_txep(struct htc_target *target,
1151e76ac2bfSKalle Valo enum htc_endpoint_id eid, u16 tag)
1152e76ac2bfSKalle Valo {
1153e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_pkt;
1154e76ac2bfSKalle Valo struct list_head discard_q, container;
1155e76ac2bfSKalle Valo struct htc_endpoint *endpoint = &target->endpoint[eid];
1156e76ac2bfSKalle Valo
1157e76ac2bfSKalle Valo if (!endpoint->svc_id) {
1158e76ac2bfSKalle Valo WARN_ON(1);
1159e76ac2bfSKalle Valo return;
1160e76ac2bfSKalle Valo }
1161e76ac2bfSKalle Valo
1162e76ac2bfSKalle Valo /* initialize the discard queue */
1163e76ac2bfSKalle Valo INIT_LIST_HEAD(&discard_q);
1164e76ac2bfSKalle Valo
1165e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
1166e76ac2bfSKalle Valo
1167e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, &endpoint->txq, list) {
1168e76ac2bfSKalle Valo if ((tag == HTC_TX_PACKET_TAG_ALL) ||
1169e76ac2bfSKalle Valo (tag == packet->info.tx.tag))
1170e76ac2bfSKalle Valo list_move_tail(&packet->list, &discard_q);
1171e76ac2bfSKalle Valo }
1172e76ac2bfSKalle Valo
1173e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
1174e76ac2bfSKalle Valo
1175e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, &discard_q, list) {
1176e76ac2bfSKalle Valo packet->status = -ECANCELED;
1177e76ac2bfSKalle Valo list_del(&packet->list);
1178e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1179e76ac2bfSKalle Valo "htc tx flushing pkt 0x%p len %d ep %d tag 0x%x\n",
1180e76ac2bfSKalle Valo packet, packet->act_len,
1181e76ac2bfSKalle Valo packet->endpoint, packet->info.tx.tag);
1182e76ac2bfSKalle Valo
1183e76ac2bfSKalle Valo INIT_LIST_HEAD(&container);
1184e76ac2bfSKalle Valo list_add_tail(&packet->list, &container);
1185e76ac2bfSKalle Valo htc_tx_complete(endpoint, &container);
1186e76ac2bfSKalle Valo }
1187e76ac2bfSKalle Valo }
1188e76ac2bfSKalle Valo
ath6kl_htc_flush_txep_all(struct htc_target * target)1189e76ac2bfSKalle Valo static void ath6kl_htc_flush_txep_all(struct htc_target *target)
1190e76ac2bfSKalle Valo {
1191e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
1192e76ac2bfSKalle Valo int i;
1193e76ac2bfSKalle Valo
1194e76ac2bfSKalle Valo dump_cred_dist_stats(target);
1195e76ac2bfSKalle Valo
1196e76ac2bfSKalle Valo for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
1197e76ac2bfSKalle Valo endpoint = &target->endpoint[i];
1198e76ac2bfSKalle Valo if (endpoint->svc_id == 0)
1199e76ac2bfSKalle Valo /* not in use.. */
1200e76ac2bfSKalle Valo continue;
1201e76ac2bfSKalle Valo ath6kl_htc_mbox_flush_txep(target, i, HTC_TX_PACKET_TAG_ALL);
1202e76ac2bfSKalle Valo }
1203e76ac2bfSKalle Valo }
1204e76ac2bfSKalle Valo
ath6kl_htc_mbox_activity_changed(struct htc_target * target,enum htc_endpoint_id eid,bool active)1205e76ac2bfSKalle Valo static void ath6kl_htc_mbox_activity_changed(struct htc_target *target,
1206e76ac2bfSKalle Valo enum htc_endpoint_id eid,
1207e76ac2bfSKalle Valo bool active)
1208e76ac2bfSKalle Valo {
1209e76ac2bfSKalle Valo struct htc_endpoint *endpoint = &target->endpoint[eid];
1210e76ac2bfSKalle Valo bool dist = false;
1211e76ac2bfSKalle Valo
1212e76ac2bfSKalle Valo if (endpoint->svc_id == 0) {
1213e76ac2bfSKalle Valo WARN_ON(1);
1214e76ac2bfSKalle Valo return;
1215e76ac2bfSKalle Valo }
1216e76ac2bfSKalle Valo
1217e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
1218e76ac2bfSKalle Valo
1219e76ac2bfSKalle Valo if (active) {
1220e76ac2bfSKalle Valo if (!(endpoint->cred_dist.dist_flags & HTC_EP_ACTIVE)) {
1221e76ac2bfSKalle Valo endpoint->cred_dist.dist_flags |= HTC_EP_ACTIVE;
1222e76ac2bfSKalle Valo dist = true;
1223e76ac2bfSKalle Valo }
1224e76ac2bfSKalle Valo } else {
1225e76ac2bfSKalle Valo if (endpoint->cred_dist.dist_flags & HTC_EP_ACTIVE) {
1226e76ac2bfSKalle Valo endpoint->cred_dist.dist_flags &= ~HTC_EP_ACTIVE;
1227e76ac2bfSKalle Valo dist = true;
1228e76ac2bfSKalle Valo }
1229e76ac2bfSKalle Valo }
1230e76ac2bfSKalle Valo
1231e76ac2bfSKalle Valo if (dist) {
1232e76ac2bfSKalle Valo endpoint->cred_dist.txq_depth =
1233e76ac2bfSKalle Valo get_queue_depth(&endpoint->txq);
1234e76ac2bfSKalle Valo
1235e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1236e76ac2bfSKalle Valo "htc tx activity ctxt 0x%p dist 0x%p\n",
1237e76ac2bfSKalle Valo target->credit_info, &target->cred_dist_list);
1238e76ac2bfSKalle Valo
1239e76ac2bfSKalle Valo ath6kl_credit_distribute(target->credit_info,
1240e76ac2bfSKalle Valo &target->cred_dist_list,
1241e76ac2bfSKalle Valo HTC_CREDIT_DIST_ACTIVITY_CHANGE);
1242e76ac2bfSKalle Valo }
1243e76ac2bfSKalle Valo
1244e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
1245e76ac2bfSKalle Valo
1246e76ac2bfSKalle Valo if (dist && !active)
1247e76ac2bfSKalle Valo htc_chk_ep_txq(target);
1248e76ac2bfSKalle Valo }
1249e76ac2bfSKalle Valo
1250e76ac2bfSKalle Valo /* HTC Rx */
1251e76ac2bfSKalle Valo
ath6kl_htc_rx_update_stats(struct htc_endpoint * endpoint,int n_look_ahds)1252e76ac2bfSKalle Valo static inline void ath6kl_htc_rx_update_stats(struct htc_endpoint *endpoint,
1253e76ac2bfSKalle Valo int n_look_ahds)
1254e76ac2bfSKalle Valo {
1255e76ac2bfSKalle Valo endpoint->ep_st.rx_pkts++;
1256e76ac2bfSKalle Valo if (n_look_ahds == 1)
1257e76ac2bfSKalle Valo endpoint->ep_st.rx_lkahds++;
1258e76ac2bfSKalle Valo else if (n_look_ahds > 1)
1259e76ac2bfSKalle Valo endpoint->ep_st.rx_bundle_lkahd++;
1260e76ac2bfSKalle Valo }
1261e76ac2bfSKalle Valo
htc_valid_rx_frame_len(struct htc_target * target,enum htc_endpoint_id eid,int len)1262e76ac2bfSKalle Valo static inline bool htc_valid_rx_frame_len(struct htc_target *target,
1263e76ac2bfSKalle Valo enum htc_endpoint_id eid, int len)
1264e76ac2bfSKalle Valo {
1265e76ac2bfSKalle Valo return (eid == target->dev->ar->ctrl_ep) ?
1266e76ac2bfSKalle Valo len <= ATH6KL_BUFFER_SIZE : len <= ATH6KL_AMSDU_BUFFER_SIZE;
1267e76ac2bfSKalle Valo }
1268e76ac2bfSKalle Valo
htc_add_rxbuf(struct htc_target * target,struct htc_packet * packet)1269e76ac2bfSKalle Valo static int htc_add_rxbuf(struct htc_target *target, struct htc_packet *packet)
1270e76ac2bfSKalle Valo {
1271e76ac2bfSKalle Valo struct list_head queue;
1272e76ac2bfSKalle Valo
1273e76ac2bfSKalle Valo INIT_LIST_HEAD(&queue);
1274e76ac2bfSKalle Valo list_add_tail(&packet->list, &queue);
1275e76ac2bfSKalle Valo return ath6kl_htc_mbox_add_rxbuf_multiple(target, &queue);
1276e76ac2bfSKalle Valo }
1277e76ac2bfSKalle Valo
htc_reclaim_rxbuf(struct htc_target * target,struct htc_packet * packet,struct htc_endpoint * ep)1278e76ac2bfSKalle Valo static void htc_reclaim_rxbuf(struct htc_target *target,
1279e76ac2bfSKalle Valo struct htc_packet *packet,
1280e76ac2bfSKalle Valo struct htc_endpoint *ep)
1281e76ac2bfSKalle Valo {
1282e76ac2bfSKalle Valo if (packet->info.rx.rx_flags & HTC_RX_PKT_NO_RECYCLE) {
1283e76ac2bfSKalle Valo htc_rxpkt_reset(packet);
1284e76ac2bfSKalle Valo packet->status = -ECANCELED;
1285e76ac2bfSKalle Valo ep->ep_cb.rx(ep->target, packet);
1286e76ac2bfSKalle Valo } else {
1287e76ac2bfSKalle Valo htc_rxpkt_reset(packet);
1288e76ac2bfSKalle Valo htc_add_rxbuf((void *)(target), packet);
1289e76ac2bfSKalle Valo }
1290e76ac2bfSKalle Valo }
1291e76ac2bfSKalle Valo
reclaim_rx_ctrl_buf(struct htc_target * target,struct htc_packet * packet)1292e76ac2bfSKalle Valo static void reclaim_rx_ctrl_buf(struct htc_target *target,
1293e76ac2bfSKalle Valo struct htc_packet *packet)
1294e76ac2bfSKalle Valo {
1295e76ac2bfSKalle Valo spin_lock_bh(&target->htc_lock);
1296e76ac2bfSKalle Valo list_add_tail(&packet->list, &target->free_ctrl_rxbuf);
1297e76ac2bfSKalle Valo spin_unlock_bh(&target->htc_lock);
1298e76ac2bfSKalle Valo }
1299e76ac2bfSKalle Valo
ath6kl_htc_rx_packet(struct htc_target * target,struct htc_packet * packet,u32 rx_len)1300e76ac2bfSKalle Valo static int ath6kl_htc_rx_packet(struct htc_target *target,
1301e76ac2bfSKalle Valo struct htc_packet *packet,
1302e76ac2bfSKalle Valo u32 rx_len)
1303e76ac2bfSKalle Valo {
1304e76ac2bfSKalle Valo struct ath6kl_device *dev = target->dev;
1305e76ac2bfSKalle Valo u32 padded_len;
1306e76ac2bfSKalle Valo int status;
1307e76ac2bfSKalle Valo
1308e76ac2bfSKalle Valo padded_len = CALC_TXRX_PADDED_LEN(target, rx_len);
1309e76ac2bfSKalle Valo
1310e76ac2bfSKalle Valo if (padded_len > packet->buf_len) {
1311e76ac2bfSKalle Valo ath6kl_err("not enough receive space for packet - padlen %d recvlen %d bufferlen %d\n",
1312e76ac2bfSKalle Valo padded_len, rx_len, packet->buf_len);
1313e76ac2bfSKalle Valo return -ENOMEM;
1314e76ac2bfSKalle Valo }
1315e76ac2bfSKalle Valo
1316e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1317df6a7072SRaja Mani "htc rx 0x%p hdr 0x%x len %d mbox 0x%x\n",
1318e76ac2bfSKalle Valo packet, packet->info.rx.exp_hdr,
1319e76ac2bfSKalle Valo padded_len, dev->ar->mbox_info.htc_addr);
1320e76ac2bfSKalle Valo
1321e76ac2bfSKalle Valo status = hif_read_write_sync(dev->ar,
1322e76ac2bfSKalle Valo dev->ar->mbox_info.htc_addr,
1323e76ac2bfSKalle Valo packet->buf, padded_len,
1324e76ac2bfSKalle Valo HIF_RD_SYNC_BLOCK_FIX);
1325e76ac2bfSKalle Valo
1326e76ac2bfSKalle Valo packet->status = status;
1327e76ac2bfSKalle Valo
1328e76ac2bfSKalle Valo return status;
1329e76ac2bfSKalle Valo }
1330e76ac2bfSKalle Valo
1331e76ac2bfSKalle Valo /*
1332e76ac2bfSKalle Valo * optimization for recv packets, we can indicate a
1333e76ac2bfSKalle Valo * "hint" that there are more single-packets to fetch
1334e76ac2bfSKalle Valo * on this endpoint.
1335e76ac2bfSKalle Valo */
ath6kl_htc_rx_set_indicate(u32 lk_ahd,struct htc_endpoint * endpoint,struct htc_packet * packet)1336e76ac2bfSKalle Valo static void ath6kl_htc_rx_set_indicate(u32 lk_ahd,
1337e76ac2bfSKalle Valo struct htc_endpoint *endpoint,
1338e76ac2bfSKalle Valo struct htc_packet *packet)
1339e76ac2bfSKalle Valo {
1340e76ac2bfSKalle Valo struct htc_frame_hdr *htc_hdr = (struct htc_frame_hdr *)&lk_ahd;
1341e76ac2bfSKalle Valo
1342e76ac2bfSKalle Valo if (htc_hdr->eid == packet->endpoint) {
1343e76ac2bfSKalle Valo if (!list_empty(&endpoint->rx_bufq))
1344e76ac2bfSKalle Valo packet->info.rx.indicat_flags |=
1345e76ac2bfSKalle Valo HTC_RX_FLAGS_INDICATE_MORE_PKTS;
1346e76ac2bfSKalle Valo }
1347e76ac2bfSKalle Valo }
1348e76ac2bfSKalle Valo
ath6kl_htc_rx_chk_water_mark(struct htc_endpoint * endpoint)1349e76ac2bfSKalle Valo static void ath6kl_htc_rx_chk_water_mark(struct htc_endpoint *endpoint)
1350e76ac2bfSKalle Valo {
1351e76ac2bfSKalle Valo struct htc_ep_callbacks ep_cb = endpoint->ep_cb;
1352e76ac2bfSKalle Valo
1353e76ac2bfSKalle Valo if (ep_cb.rx_refill_thresh > 0) {
1354e76ac2bfSKalle Valo spin_lock_bh(&endpoint->target->rx_lock);
1355e76ac2bfSKalle Valo if (get_queue_depth(&endpoint->rx_bufq)
1356e76ac2bfSKalle Valo < ep_cb.rx_refill_thresh) {
1357e76ac2bfSKalle Valo spin_unlock_bh(&endpoint->target->rx_lock);
1358e76ac2bfSKalle Valo ep_cb.rx_refill(endpoint->target, endpoint->eid);
1359e76ac2bfSKalle Valo return;
1360e76ac2bfSKalle Valo }
1361e76ac2bfSKalle Valo spin_unlock_bh(&endpoint->target->rx_lock);
1362e76ac2bfSKalle Valo }
1363e76ac2bfSKalle Valo }
1364e76ac2bfSKalle Valo
1365e76ac2bfSKalle Valo /* This function is called with rx_lock held */
ath6kl_htc_rx_setup(struct htc_target * target,struct htc_endpoint * ep,u32 * lk_ahds,struct list_head * queue,int n_msg)1366e76ac2bfSKalle Valo static int ath6kl_htc_rx_setup(struct htc_target *target,
1367e76ac2bfSKalle Valo struct htc_endpoint *ep,
1368e76ac2bfSKalle Valo u32 *lk_ahds, struct list_head *queue, int n_msg)
1369e76ac2bfSKalle Valo {
1370e76ac2bfSKalle Valo struct htc_packet *packet;
1371e76ac2bfSKalle Valo /* FIXME: type of lk_ahds can't be right */
1372e76ac2bfSKalle Valo struct htc_frame_hdr *htc_hdr = (struct htc_frame_hdr *)lk_ahds;
1373e76ac2bfSKalle Valo struct htc_ep_callbacks ep_cb;
1374e76ac2bfSKalle Valo int status = 0, j, full_len;
1375e76ac2bfSKalle Valo bool no_recycle;
1376e76ac2bfSKalle Valo
1377e76ac2bfSKalle Valo full_len = CALC_TXRX_PADDED_LEN(target,
1378e76ac2bfSKalle Valo le16_to_cpu(htc_hdr->payld_len) +
1379e76ac2bfSKalle Valo sizeof(*htc_hdr));
1380e76ac2bfSKalle Valo
1381e76ac2bfSKalle Valo if (!htc_valid_rx_frame_len(target, ep->eid, full_len)) {
1382e76ac2bfSKalle Valo ath6kl_warn("Rx buffer requested with invalid length htc_hdr:eid %d, flags 0x%x, len %d\n",
1383e76ac2bfSKalle Valo htc_hdr->eid, htc_hdr->flags,
1384e76ac2bfSKalle Valo le16_to_cpu(htc_hdr->payld_len));
1385e76ac2bfSKalle Valo return -EINVAL;
1386e76ac2bfSKalle Valo }
1387e76ac2bfSKalle Valo
1388e76ac2bfSKalle Valo ep_cb = ep->ep_cb;
1389e76ac2bfSKalle Valo for (j = 0; j < n_msg; j++) {
1390e76ac2bfSKalle Valo /*
1391e76ac2bfSKalle Valo * Reset flag, any packets allocated using the
1392e76ac2bfSKalle Valo * rx_alloc() API cannot be recycled on
1393e76ac2bfSKalle Valo * cleanup,they must be explicitly returned.
1394e76ac2bfSKalle Valo */
1395e76ac2bfSKalle Valo no_recycle = false;
1396e76ac2bfSKalle Valo
1397e76ac2bfSKalle Valo if (ep_cb.rx_allocthresh &&
1398e76ac2bfSKalle Valo (full_len > ep_cb.rx_alloc_thresh)) {
1399e76ac2bfSKalle Valo ep->ep_st.rx_alloc_thresh_hit += 1;
1400e76ac2bfSKalle Valo ep->ep_st.rxalloc_thresh_byte +=
1401e76ac2bfSKalle Valo le16_to_cpu(htc_hdr->payld_len);
1402e76ac2bfSKalle Valo
1403e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
1404e76ac2bfSKalle Valo no_recycle = true;
1405e76ac2bfSKalle Valo
1406e76ac2bfSKalle Valo packet = ep_cb.rx_allocthresh(ep->target, ep->eid,
1407e76ac2bfSKalle Valo full_len);
1408e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
1409e76ac2bfSKalle Valo } else {
1410e76ac2bfSKalle Valo /* refill handler is being used */
1411e76ac2bfSKalle Valo if (list_empty(&ep->rx_bufq)) {
1412e76ac2bfSKalle Valo if (ep_cb.rx_refill) {
1413e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
1414e76ac2bfSKalle Valo ep_cb.rx_refill(ep->target, ep->eid);
1415e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
1416e76ac2bfSKalle Valo }
1417e76ac2bfSKalle Valo }
1418e76ac2bfSKalle Valo
1419a5d8f9dfSKalle Valo if (list_empty(&ep->rx_bufq)) {
1420e76ac2bfSKalle Valo packet = NULL;
1421a5d8f9dfSKalle Valo } else {
1422e76ac2bfSKalle Valo packet = list_first_entry(&ep->rx_bufq,
1423e76ac2bfSKalle Valo struct htc_packet, list);
1424e76ac2bfSKalle Valo list_del(&packet->list);
1425e76ac2bfSKalle Valo }
1426e76ac2bfSKalle Valo }
1427e76ac2bfSKalle Valo
1428e76ac2bfSKalle Valo if (!packet) {
1429e76ac2bfSKalle Valo target->rx_st_flags |= HTC_RECV_WAIT_BUFFERS;
1430e76ac2bfSKalle Valo target->ep_waiting = ep->eid;
1431e76ac2bfSKalle Valo return -ENOSPC;
1432e76ac2bfSKalle Valo }
1433e76ac2bfSKalle Valo
1434e76ac2bfSKalle Valo /* clear flags */
1435e76ac2bfSKalle Valo packet->info.rx.rx_flags = 0;
1436e76ac2bfSKalle Valo packet->info.rx.indicat_flags = 0;
1437e76ac2bfSKalle Valo packet->status = 0;
1438e76ac2bfSKalle Valo
1439e76ac2bfSKalle Valo if (no_recycle)
1440e76ac2bfSKalle Valo /*
1441e76ac2bfSKalle Valo * flag that these packets cannot be
1442e76ac2bfSKalle Valo * recycled, they have to be returned to
1443e76ac2bfSKalle Valo * the user
1444e76ac2bfSKalle Valo */
1445e76ac2bfSKalle Valo packet->info.rx.rx_flags |= HTC_RX_PKT_NO_RECYCLE;
1446e76ac2bfSKalle Valo
1447e76ac2bfSKalle Valo /* Caller needs to free this upon any failure */
1448e76ac2bfSKalle Valo list_add_tail(&packet->list, queue);
1449e76ac2bfSKalle Valo
1450e76ac2bfSKalle Valo if (target->htc_flags & HTC_OP_STATE_STOPPING) {
1451e76ac2bfSKalle Valo status = -ECANCELED;
1452e76ac2bfSKalle Valo break;
1453e76ac2bfSKalle Valo }
1454e76ac2bfSKalle Valo
1455e76ac2bfSKalle Valo if (j) {
1456e76ac2bfSKalle Valo packet->info.rx.rx_flags |= HTC_RX_PKT_REFRESH_HDR;
1457e76ac2bfSKalle Valo packet->info.rx.exp_hdr = 0xFFFFFFFF;
1458e76ac2bfSKalle Valo } else
1459e76ac2bfSKalle Valo /* set expected look ahead */
1460e76ac2bfSKalle Valo packet->info.rx.exp_hdr = *lk_ahds;
1461e76ac2bfSKalle Valo
1462e76ac2bfSKalle Valo packet->act_len = le16_to_cpu(htc_hdr->payld_len) +
1463e76ac2bfSKalle Valo HTC_HDR_LENGTH;
1464e76ac2bfSKalle Valo }
1465e76ac2bfSKalle Valo
1466e76ac2bfSKalle Valo return status;
1467e76ac2bfSKalle Valo }
1468e76ac2bfSKalle Valo
ath6kl_htc_rx_alloc(struct htc_target * target,u32 lk_ahds[],int msg,struct htc_endpoint * endpoint,struct list_head * queue)1469e76ac2bfSKalle Valo static int ath6kl_htc_rx_alloc(struct htc_target *target,
1470e76ac2bfSKalle Valo u32 lk_ahds[], int msg,
1471e76ac2bfSKalle Valo struct htc_endpoint *endpoint,
1472e76ac2bfSKalle Valo struct list_head *queue)
1473e76ac2bfSKalle Valo {
1474e76ac2bfSKalle Valo int status = 0;
1475e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_pkt;
1476e76ac2bfSKalle Valo struct htc_frame_hdr *htc_hdr;
1477e76ac2bfSKalle Valo int i, n_msg;
1478e76ac2bfSKalle Valo
1479e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
1480e76ac2bfSKalle Valo
1481e76ac2bfSKalle Valo for (i = 0; i < msg; i++) {
1482e76ac2bfSKalle Valo htc_hdr = (struct htc_frame_hdr *)&lk_ahds[i];
1483e76ac2bfSKalle Valo
1484e76ac2bfSKalle Valo if (htc_hdr->eid >= ENDPOINT_MAX) {
1485e76ac2bfSKalle Valo ath6kl_err("invalid ep in look-ahead: %d\n",
1486e76ac2bfSKalle Valo htc_hdr->eid);
1487e76ac2bfSKalle Valo status = -ENOMEM;
1488e76ac2bfSKalle Valo break;
1489e76ac2bfSKalle Valo }
1490e76ac2bfSKalle Valo
1491e76ac2bfSKalle Valo if (htc_hdr->eid != endpoint->eid) {
1492e76ac2bfSKalle Valo ath6kl_err("invalid ep in look-ahead: %d should be : %d (index:%d)\n",
1493e76ac2bfSKalle Valo htc_hdr->eid, endpoint->eid, i);
1494e76ac2bfSKalle Valo status = -ENOMEM;
1495e76ac2bfSKalle Valo break;
1496e76ac2bfSKalle Valo }
1497e76ac2bfSKalle Valo
1498e76ac2bfSKalle Valo if (le16_to_cpu(htc_hdr->payld_len) > HTC_MAX_PAYLOAD_LENGTH) {
1499e76ac2bfSKalle Valo ath6kl_err("payload len %d exceeds max htc : %d !\n",
1500e76ac2bfSKalle Valo htc_hdr->payld_len,
1501e76ac2bfSKalle Valo (u32) HTC_MAX_PAYLOAD_LENGTH);
1502e76ac2bfSKalle Valo status = -ENOMEM;
1503e76ac2bfSKalle Valo break;
1504e76ac2bfSKalle Valo }
1505e76ac2bfSKalle Valo
1506e76ac2bfSKalle Valo if (endpoint->svc_id == 0) {
1507e76ac2bfSKalle Valo ath6kl_err("ep %d is not connected !\n", htc_hdr->eid);
1508e76ac2bfSKalle Valo status = -ENOMEM;
1509e76ac2bfSKalle Valo break;
1510e76ac2bfSKalle Valo }
1511e76ac2bfSKalle Valo
1512e76ac2bfSKalle Valo if (htc_hdr->flags & HTC_FLG_RX_BNDL_CNT) {
1513e76ac2bfSKalle Valo /*
1514e76ac2bfSKalle Valo * HTC header indicates that every packet to follow
1515e76ac2bfSKalle Valo * has the same padded length so that it can be
1516e76ac2bfSKalle Valo * optimally fetched as a full bundle.
1517e76ac2bfSKalle Valo */
1518e76ac2bfSKalle Valo n_msg = (htc_hdr->flags & HTC_FLG_RX_BNDL_CNT) >>
1519e76ac2bfSKalle Valo HTC_FLG_RX_BNDL_CNT_S;
1520e76ac2bfSKalle Valo
1521e76ac2bfSKalle Valo /* the count doesn't include the starter frame */
1522e76ac2bfSKalle Valo n_msg++;
1523e76ac2bfSKalle Valo if (n_msg > target->msg_per_bndl_max) {
1524e76ac2bfSKalle Valo status = -ENOMEM;
1525e76ac2bfSKalle Valo break;
1526e76ac2bfSKalle Valo }
1527e76ac2bfSKalle Valo
1528e76ac2bfSKalle Valo endpoint->ep_st.rx_bundle_from_hdr += 1;
1529e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1530e76ac2bfSKalle Valo "htc rx bundle pkts %d\n",
1531e76ac2bfSKalle Valo n_msg);
1532e76ac2bfSKalle Valo } else
1533e76ac2bfSKalle Valo /* HTC header only indicates 1 message to fetch */
1534e76ac2bfSKalle Valo n_msg = 1;
1535e76ac2bfSKalle Valo
1536e76ac2bfSKalle Valo /* Setup packet buffers for each message */
1537e76ac2bfSKalle Valo status = ath6kl_htc_rx_setup(target, endpoint, &lk_ahds[i],
1538e76ac2bfSKalle Valo queue, n_msg);
1539e76ac2bfSKalle Valo
1540e76ac2bfSKalle Valo /*
1541*b7d17447SJulia Lawall * This is due to unavailability of buffers to rx entire data.
1542e76ac2bfSKalle Valo * Return no error so that free buffers from queue can be used
1543e76ac2bfSKalle Valo * to receive partial data.
1544e76ac2bfSKalle Valo */
1545e76ac2bfSKalle Valo if (status == -ENOSPC) {
1546e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
1547e76ac2bfSKalle Valo return 0;
1548e76ac2bfSKalle Valo }
1549e76ac2bfSKalle Valo
1550e76ac2bfSKalle Valo if (status)
1551e76ac2bfSKalle Valo break;
1552e76ac2bfSKalle Valo }
1553e76ac2bfSKalle Valo
1554e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
1555e76ac2bfSKalle Valo
1556e76ac2bfSKalle Valo if (status) {
1557e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, queue, list) {
1558e76ac2bfSKalle Valo list_del(&packet->list);
1559e76ac2bfSKalle Valo htc_reclaim_rxbuf(target, packet,
1560e76ac2bfSKalle Valo &target->endpoint[packet->endpoint]);
1561e76ac2bfSKalle Valo }
1562e76ac2bfSKalle Valo }
1563e76ac2bfSKalle Valo
1564e76ac2bfSKalle Valo return status;
1565e76ac2bfSKalle Valo }
1566e76ac2bfSKalle Valo
htc_ctrl_rx(struct htc_target * context,struct htc_packet * packets)1567e76ac2bfSKalle Valo static void htc_ctrl_rx(struct htc_target *context, struct htc_packet *packets)
1568e76ac2bfSKalle Valo {
1569e76ac2bfSKalle Valo if (packets->endpoint != ENDPOINT_0) {
1570e76ac2bfSKalle Valo WARN_ON(1);
1571e76ac2bfSKalle Valo return;
1572e76ac2bfSKalle Valo }
1573e76ac2bfSKalle Valo
1574e76ac2bfSKalle Valo if (packets->status == -ECANCELED) {
1575e76ac2bfSKalle Valo reclaim_rx_ctrl_buf(context, packets);
1576e76ac2bfSKalle Valo return;
1577e76ac2bfSKalle Valo }
1578e76ac2bfSKalle Valo
1579e76ac2bfSKalle Valo if (packets->act_len > 0) {
1580e76ac2bfSKalle Valo ath6kl_err("htc_ctrl_rx, got message with len:%zu\n",
1581e76ac2bfSKalle Valo packets->act_len + HTC_HDR_LENGTH);
1582e76ac2bfSKalle Valo
1583e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC,
1584e76ac2bfSKalle Valo "htc rx unexpected endpoint 0 message", "",
1585e76ac2bfSKalle Valo packets->buf - HTC_HDR_LENGTH,
1586e76ac2bfSKalle Valo packets->act_len + HTC_HDR_LENGTH);
1587e76ac2bfSKalle Valo }
1588e76ac2bfSKalle Valo
1589e76ac2bfSKalle Valo htc_reclaim_rxbuf(context, packets, &context->endpoint[0]);
1590e76ac2bfSKalle Valo }
1591e76ac2bfSKalle Valo
htc_proc_cred_rpt(struct htc_target * target,struct htc_credit_report * rpt,int n_entries,enum htc_endpoint_id from_ep)1592e76ac2bfSKalle Valo static void htc_proc_cred_rpt(struct htc_target *target,
1593e76ac2bfSKalle Valo struct htc_credit_report *rpt,
1594e76ac2bfSKalle Valo int n_entries,
1595e76ac2bfSKalle Valo enum htc_endpoint_id from_ep)
1596e76ac2bfSKalle Valo {
1597e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
1598e76ac2bfSKalle Valo int tot_credits = 0, i;
1599e76ac2bfSKalle Valo bool dist = false;
1600e76ac2bfSKalle Valo
1601e76ac2bfSKalle Valo spin_lock_bh(&target->tx_lock);
1602e76ac2bfSKalle Valo
1603e76ac2bfSKalle Valo for (i = 0; i < n_entries; i++, rpt++) {
1604e76ac2bfSKalle Valo if (rpt->eid >= ENDPOINT_MAX) {
1605e76ac2bfSKalle Valo WARN_ON(1);
1606e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
1607e76ac2bfSKalle Valo return;
1608e76ac2bfSKalle Valo }
1609e76ac2bfSKalle Valo
1610e76ac2bfSKalle Valo endpoint = &target->endpoint[rpt->eid];
1611e76ac2bfSKalle Valo
1612e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_CREDIT,
1613e76ac2bfSKalle Valo "credit report ep %d credits %d\n",
1614e76ac2bfSKalle Valo rpt->eid, rpt->credits);
1615e76ac2bfSKalle Valo
1616e76ac2bfSKalle Valo endpoint->ep_st.tx_cred_rpt += 1;
1617e76ac2bfSKalle Valo endpoint->ep_st.cred_retnd += rpt->credits;
1618e76ac2bfSKalle Valo
1619e76ac2bfSKalle Valo if (from_ep == rpt->eid) {
1620e76ac2bfSKalle Valo /*
1621e76ac2bfSKalle Valo * This credit report arrived on the same endpoint
1622e76ac2bfSKalle Valo * indicating it arrived in an RX packet.
1623e76ac2bfSKalle Valo */
1624e76ac2bfSKalle Valo endpoint->ep_st.cred_from_rx += rpt->credits;
1625e76ac2bfSKalle Valo endpoint->ep_st.cred_rpt_from_rx += 1;
1626e76ac2bfSKalle Valo } else if (from_ep == ENDPOINT_0) {
1627e76ac2bfSKalle Valo /* credit arrived on endpoint 0 as a NULL message */
1628e76ac2bfSKalle Valo endpoint->ep_st.cred_from_ep0 += rpt->credits;
1629e76ac2bfSKalle Valo endpoint->ep_st.cred_rpt_ep0 += 1;
1630e76ac2bfSKalle Valo } else {
1631e76ac2bfSKalle Valo endpoint->ep_st.cred_from_other += rpt->credits;
1632e76ac2bfSKalle Valo endpoint->ep_st.cred_rpt_from_other += 1;
1633e76ac2bfSKalle Valo }
1634e76ac2bfSKalle Valo
1635e76ac2bfSKalle Valo if (rpt->eid == ENDPOINT_0)
1636e76ac2bfSKalle Valo /* always give endpoint 0 credits back */
1637e76ac2bfSKalle Valo endpoint->cred_dist.credits += rpt->credits;
1638e76ac2bfSKalle Valo else {
1639e76ac2bfSKalle Valo endpoint->cred_dist.cred_to_dist += rpt->credits;
1640e76ac2bfSKalle Valo dist = true;
1641e76ac2bfSKalle Valo }
1642e76ac2bfSKalle Valo
1643e76ac2bfSKalle Valo /*
1644e76ac2bfSKalle Valo * Refresh tx depth for distribution function that will
1645e76ac2bfSKalle Valo * recover these credits NOTE: this is only valid when
1646e76ac2bfSKalle Valo * there are credits to recover!
1647e76ac2bfSKalle Valo */
1648e76ac2bfSKalle Valo endpoint->cred_dist.txq_depth =
1649e76ac2bfSKalle Valo get_queue_depth(&endpoint->txq);
1650e76ac2bfSKalle Valo
1651e76ac2bfSKalle Valo tot_credits += rpt->credits;
1652e76ac2bfSKalle Valo }
1653e76ac2bfSKalle Valo
1654e76ac2bfSKalle Valo if (dist) {
1655e76ac2bfSKalle Valo /*
1656e76ac2bfSKalle Valo * This was a credit return based on a completed send
1657e76ac2bfSKalle Valo * operations note, this is done with the lock held
1658e76ac2bfSKalle Valo */
1659e76ac2bfSKalle Valo ath6kl_credit_distribute(target->credit_info,
1660e76ac2bfSKalle Valo &target->cred_dist_list,
1661e76ac2bfSKalle Valo HTC_CREDIT_DIST_SEND_COMPLETE);
1662e76ac2bfSKalle Valo }
1663e76ac2bfSKalle Valo
1664e76ac2bfSKalle Valo spin_unlock_bh(&target->tx_lock);
1665e76ac2bfSKalle Valo
1666e76ac2bfSKalle Valo if (tot_credits)
1667e76ac2bfSKalle Valo htc_chk_ep_txq(target);
1668e76ac2bfSKalle Valo }
1669e76ac2bfSKalle Valo
htc_parse_trailer(struct htc_target * target,struct htc_record_hdr * record,u8 * record_buf,u32 * next_lk_ahds,enum htc_endpoint_id endpoint,int * n_lk_ahds)1670e76ac2bfSKalle Valo static int htc_parse_trailer(struct htc_target *target,
1671e76ac2bfSKalle Valo struct htc_record_hdr *record,
1672e76ac2bfSKalle Valo u8 *record_buf, u32 *next_lk_ahds,
1673e76ac2bfSKalle Valo enum htc_endpoint_id endpoint,
1674e76ac2bfSKalle Valo int *n_lk_ahds)
1675e76ac2bfSKalle Valo {
1676e76ac2bfSKalle Valo struct htc_bundle_lkahd_rpt *bundle_lkahd_rpt;
1677e76ac2bfSKalle Valo struct htc_lookahead_report *lk_ahd;
1678e76ac2bfSKalle Valo int len;
1679e76ac2bfSKalle Valo
1680e76ac2bfSKalle Valo switch (record->rec_id) {
1681e76ac2bfSKalle Valo case HTC_RECORD_CREDITS:
1682e76ac2bfSKalle Valo len = record->len / sizeof(struct htc_credit_report);
1683e76ac2bfSKalle Valo if (!len) {
1684e76ac2bfSKalle Valo WARN_ON(1);
1685e76ac2bfSKalle Valo return -EINVAL;
1686e76ac2bfSKalle Valo }
1687e76ac2bfSKalle Valo
1688e76ac2bfSKalle Valo htc_proc_cred_rpt(target,
1689e76ac2bfSKalle Valo (struct htc_credit_report *) record_buf,
1690e76ac2bfSKalle Valo len, endpoint);
1691e76ac2bfSKalle Valo break;
1692e76ac2bfSKalle Valo case HTC_RECORD_LOOKAHEAD:
1693e76ac2bfSKalle Valo len = record->len / sizeof(*lk_ahd);
1694e76ac2bfSKalle Valo if (!len) {
1695e76ac2bfSKalle Valo WARN_ON(1);
1696e76ac2bfSKalle Valo return -EINVAL;
1697e76ac2bfSKalle Valo }
1698e76ac2bfSKalle Valo
1699e76ac2bfSKalle Valo lk_ahd = (struct htc_lookahead_report *) record_buf;
1700e76ac2bfSKalle Valo if ((lk_ahd->pre_valid == ((~lk_ahd->post_valid) & 0xFF)) &&
1701e76ac2bfSKalle Valo next_lk_ahds) {
1702e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1703e76ac2bfSKalle Valo "htc rx lk_ahd found pre_valid 0x%x post_valid 0x%x\n",
1704e76ac2bfSKalle Valo lk_ahd->pre_valid, lk_ahd->post_valid);
1705e76ac2bfSKalle Valo
1706e76ac2bfSKalle Valo /* look ahead bytes are valid, copy them over */
1707e76ac2bfSKalle Valo memcpy((u8 *)&next_lk_ahds[0], lk_ahd->lk_ahd, 4);
1708e76ac2bfSKalle Valo
1709e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC,
1710e76ac2bfSKalle Valo "htc rx next look ahead",
1711e76ac2bfSKalle Valo "", next_lk_ahds, 4);
1712e76ac2bfSKalle Valo
1713e76ac2bfSKalle Valo *n_lk_ahds = 1;
1714e76ac2bfSKalle Valo }
1715e76ac2bfSKalle Valo break;
1716e76ac2bfSKalle Valo case HTC_RECORD_LOOKAHEAD_BUNDLE:
1717e76ac2bfSKalle Valo len = record->len / sizeof(*bundle_lkahd_rpt);
1718e76ac2bfSKalle Valo if (!len || (len > HTC_HOST_MAX_MSG_PER_BUNDLE)) {
1719e76ac2bfSKalle Valo WARN_ON(1);
1720e76ac2bfSKalle Valo return -EINVAL;
1721e76ac2bfSKalle Valo }
1722e76ac2bfSKalle Valo
1723e76ac2bfSKalle Valo if (next_lk_ahds) {
1724e76ac2bfSKalle Valo int i;
1725e76ac2bfSKalle Valo
1726e76ac2bfSKalle Valo bundle_lkahd_rpt =
1727e76ac2bfSKalle Valo (struct htc_bundle_lkahd_rpt *) record_buf;
1728e76ac2bfSKalle Valo
1729e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC, "htc rx bundle lk_ahd",
1730e76ac2bfSKalle Valo "", record_buf, record->len);
1731e76ac2bfSKalle Valo
1732e76ac2bfSKalle Valo for (i = 0; i < len; i++) {
1733e76ac2bfSKalle Valo memcpy((u8 *)&next_lk_ahds[i],
1734e76ac2bfSKalle Valo bundle_lkahd_rpt->lk_ahd, 4);
1735e76ac2bfSKalle Valo bundle_lkahd_rpt++;
1736e76ac2bfSKalle Valo }
1737e76ac2bfSKalle Valo
1738e76ac2bfSKalle Valo *n_lk_ahds = i;
1739e76ac2bfSKalle Valo }
1740e76ac2bfSKalle Valo break;
1741e76ac2bfSKalle Valo default:
1742e76ac2bfSKalle Valo ath6kl_err("unhandled record: id:%d len:%d\n",
1743e76ac2bfSKalle Valo record->rec_id, record->len);
1744e76ac2bfSKalle Valo break;
1745e76ac2bfSKalle Valo }
1746e76ac2bfSKalle Valo
1747e76ac2bfSKalle Valo return 0;
1748e76ac2bfSKalle Valo }
1749e76ac2bfSKalle Valo
htc_proc_trailer(struct htc_target * target,u8 * buf,int len,u32 * next_lk_ahds,int * n_lk_ahds,enum htc_endpoint_id endpoint)1750e76ac2bfSKalle Valo static int htc_proc_trailer(struct htc_target *target,
1751e76ac2bfSKalle Valo u8 *buf, int len, u32 *next_lk_ahds,
1752e76ac2bfSKalle Valo int *n_lk_ahds, enum htc_endpoint_id endpoint)
1753e76ac2bfSKalle Valo {
1754e76ac2bfSKalle Valo struct htc_record_hdr *record;
1755e76ac2bfSKalle Valo int orig_len;
1756e76ac2bfSKalle Valo int status;
1757e76ac2bfSKalle Valo u8 *record_buf;
1758e76ac2bfSKalle Valo u8 *orig_buf;
1759e76ac2bfSKalle Valo
1760e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC, "htc rx trailer len %d\n", len);
1761e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC, NULL, "", buf, len);
1762e76ac2bfSKalle Valo
1763e76ac2bfSKalle Valo orig_buf = buf;
1764e76ac2bfSKalle Valo orig_len = len;
1765e76ac2bfSKalle Valo status = 0;
1766e76ac2bfSKalle Valo
1767e76ac2bfSKalle Valo while (len > 0) {
1768e76ac2bfSKalle Valo if (len < sizeof(struct htc_record_hdr)) {
1769e76ac2bfSKalle Valo status = -ENOMEM;
1770e76ac2bfSKalle Valo break;
1771e76ac2bfSKalle Valo }
1772e76ac2bfSKalle Valo /* these are byte aligned structs */
1773e76ac2bfSKalle Valo record = (struct htc_record_hdr *) buf;
1774e76ac2bfSKalle Valo len -= sizeof(struct htc_record_hdr);
1775e76ac2bfSKalle Valo buf += sizeof(struct htc_record_hdr);
1776e76ac2bfSKalle Valo
1777e76ac2bfSKalle Valo if (record->len > len) {
1778e76ac2bfSKalle Valo ath6kl_err("invalid record len: %d (id:%d) buf has: %d bytes left\n",
1779e76ac2bfSKalle Valo record->len, record->rec_id, len);
1780e76ac2bfSKalle Valo status = -ENOMEM;
1781e76ac2bfSKalle Valo break;
1782e76ac2bfSKalle Valo }
1783e76ac2bfSKalle Valo record_buf = buf;
1784e76ac2bfSKalle Valo
1785e76ac2bfSKalle Valo status = htc_parse_trailer(target, record, record_buf,
1786e76ac2bfSKalle Valo next_lk_ahds, endpoint, n_lk_ahds);
1787e76ac2bfSKalle Valo
1788e76ac2bfSKalle Valo if (status)
1789e76ac2bfSKalle Valo break;
1790e76ac2bfSKalle Valo
1791e76ac2bfSKalle Valo /* advance buffer past this record for next time around */
1792e76ac2bfSKalle Valo buf += record->len;
1793e76ac2bfSKalle Valo len -= record->len;
1794e76ac2bfSKalle Valo }
1795e76ac2bfSKalle Valo
1796e76ac2bfSKalle Valo if (status)
1797e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC, "htc rx bad trailer",
1798e76ac2bfSKalle Valo "", orig_buf, orig_len);
1799e76ac2bfSKalle Valo
1800e76ac2bfSKalle Valo return status;
1801e76ac2bfSKalle Valo }
1802e76ac2bfSKalle Valo
ath6kl_htc_rx_process_hdr(struct htc_target * target,struct htc_packet * packet,u32 * next_lkahds,int * n_lkahds)1803e76ac2bfSKalle Valo static int ath6kl_htc_rx_process_hdr(struct htc_target *target,
1804e76ac2bfSKalle Valo struct htc_packet *packet,
1805e76ac2bfSKalle Valo u32 *next_lkahds, int *n_lkahds)
1806e76ac2bfSKalle Valo {
1807e76ac2bfSKalle Valo int status = 0;
1808e76ac2bfSKalle Valo u16 payload_len;
1809e76ac2bfSKalle Valo u32 lk_ahd;
1810e76ac2bfSKalle Valo struct htc_frame_hdr *htc_hdr = (struct htc_frame_hdr *)packet->buf;
1811e76ac2bfSKalle Valo
1812e76ac2bfSKalle Valo if (n_lkahds != NULL)
1813e76ac2bfSKalle Valo *n_lkahds = 0;
1814e76ac2bfSKalle Valo
1815e76ac2bfSKalle Valo /*
1816e76ac2bfSKalle Valo * NOTE: we cannot assume the alignment of buf, so we use the safe
1817e76ac2bfSKalle Valo * macros to retrieve 16 bit fields.
1818e76ac2bfSKalle Valo */
1819e76ac2bfSKalle Valo payload_len = le16_to_cpu(get_unaligned(&htc_hdr->payld_len));
1820e76ac2bfSKalle Valo
1821e76ac2bfSKalle Valo memcpy((u8 *)&lk_ahd, packet->buf, sizeof(lk_ahd));
1822e76ac2bfSKalle Valo
1823e76ac2bfSKalle Valo if (packet->info.rx.rx_flags & HTC_RX_PKT_REFRESH_HDR) {
1824e76ac2bfSKalle Valo /*
1825e76ac2bfSKalle Valo * Refresh the expected header and the actual length as it
1826e76ac2bfSKalle Valo * was unknown when this packet was grabbed as part of the
1827e76ac2bfSKalle Valo * bundle.
1828e76ac2bfSKalle Valo */
1829e76ac2bfSKalle Valo packet->info.rx.exp_hdr = lk_ahd;
1830e76ac2bfSKalle Valo packet->act_len = payload_len + HTC_HDR_LENGTH;
1831e76ac2bfSKalle Valo
1832e76ac2bfSKalle Valo /* validate the actual header that was refreshed */
1833e76ac2bfSKalle Valo if (packet->act_len > packet->buf_len) {
1834e76ac2bfSKalle Valo ath6kl_err("refreshed hdr payload len (%d) in bundled recv is invalid (hdr: 0x%X)\n",
1835e76ac2bfSKalle Valo payload_len, lk_ahd);
1836e76ac2bfSKalle Valo /*
1837e76ac2bfSKalle Valo * Limit this to max buffer just to print out some
1838e76ac2bfSKalle Valo * of the buffer.
1839e76ac2bfSKalle Valo */
1840e76ac2bfSKalle Valo packet->act_len = min(packet->act_len, packet->buf_len);
1841e76ac2bfSKalle Valo status = -ENOMEM;
1842e76ac2bfSKalle Valo goto fail_rx;
1843e76ac2bfSKalle Valo }
1844e76ac2bfSKalle Valo
1845e76ac2bfSKalle Valo if (packet->endpoint != htc_hdr->eid) {
1846e76ac2bfSKalle Valo ath6kl_err("refreshed hdr ep (%d) does not match expected ep (%d)\n",
1847e76ac2bfSKalle Valo htc_hdr->eid, packet->endpoint);
1848e76ac2bfSKalle Valo status = -ENOMEM;
1849e76ac2bfSKalle Valo goto fail_rx;
1850e76ac2bfSKalle Valo }
1851e76ac2bfSKalle Valo }
1852e76ac2bfSKalle Valo
1853e76ac2bfSKalle Valo if (lk_ahd != packet->info.rx.exp_hdr) {
1854e76ac2bfSKalle Valo ath6kl_err("%s(): lk_ahd mismatch! (pPkt:0x%p flags:0x%X)\n",
1855e76ac2bfSKalle Valo __func__, packet, packet->info.rx.rx_flags);
1856e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC, "htc rx expected lk_ahd",
1857e76ac2bfSKalle Valo "", &packet->info.rx.exp_hdr, 4);
1858e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC, "htc rx current header",
1859e76ac2bfSKalle Valo "", (u8 *)&lk_ahd, sizeof(lk_ahd));
1860e76ac2bfSKalle Valo status = -ENOMEM;
1861e76ac2bfSKalle Valo goto fail_rx;
1862e76ac2bfSKalle Valo }
1863e76ac2bfSKalle Valo
1864e76ac2bfSKalle Valo if (htc_hdr->flags & HTC_FLG_RX_TRAILER) {
1865e76ac2bfSKalle Valo if (htc_hdr->ctrl[0] < sizeof(struct htc_record_hdr) ||
1866e76ac2bfSKalle Valo htc_hdr->ctrl[0] > payload_len) {
1867e76ac2bfSKalle Valo ath6kl_err("%s(): invalid hdr (payload len should be :%d, CB[0] is:%d)\n",
1868e76ac2bfSKalle Valo __func__, payload_len, htc_hdr->ctrl[0]);
1869e76ac2bfSKalle Valo status = -ENOMEM;
1870e76ac2bfSKalle Valo goto fail_rx;
1871e76ac2bfSKalle Valo }
1872e76ac2bfSKalle Valo
1873e76ac2bfSKalle Valo if (packet->info.rx.rx_flags & HTC_RX_PKT_IGNORE_LOOKAHEAD) {
1874e76ac2bfSKalle Valo next_lkahds = NULL;
1875e76ac2bfSKalle Valo n_lkahds = NULL;
1876e76ac2bfSKalle Valo }
1877e76ac2bfSKalle Valo
1878e76ac2bfSKalle Valo status = htc_proc_trailer(target, packet->buf + HTC_HDR_LENGTH
1879e76ac2bfSKalle Valo + payload_len - htc_hdr->ctrl[0],
1880e76ac2bfSKalle Valo htc_hdr->ctrl[0], next_lkahds,
1881e76ac2bfSKalle Valo n_lkahds, packet->endpoint);
1882e76ac2bfSKalle Valo
1883e76ac2bfSKalle Valo if (status)
1884e76ac2bfSKalle Valo goto fail_rx;
1885e76ac2bfSKalle Valo
1886e76ac2bfSKalle Valo packet->act_len -= htc_hdr->ctrl[0];
1887e76ac2bfSKalle Valo }
1888e76ac2bfSKalle Valo
1889e76ac2bfSKalle Valo packet->buf += HTC_HDR_LENGTH;
1890e76ac2bfSKalle Valo packet->act_len -= HTC_HDR_LENGTH;
1891e76ac2bfSKalle Valo
1892e76ac2bfSKalle Valo fail_rx:
1893e76ac2bfSKalle Valo if (status)
1894e76ac2bfSKalle Valo ath6kl_dbg_dump(ATH6KL_DBG_HTC, "htc rx bad packet",
1895e76ac2bfSKalle Valo "", packet->buf, packet->act_len);
1896e76ac2bfSKalle Valo
1897e76ac2bfSKalle Valo return status;
1898e76ac2bfSKalle Valo }
1899e76ac2bfSKalle Valo
ath6kl_htc_rx_complete(struct htc_endpoint * endpoint,struct htc_packet * packet)1900e76ac2bfSKalle Valo static void ath6kl_htc_rx_complete(struct htc_endpoint *endpoint,
1901e76ac2bfSKalle Valo struct htc_packet *packet)
1902e76ac2bfSKalle Valo {
1903e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1904e76ac2bfSKalle Valo "htc rx complete ep %d packet 0x%p\n",
1905e76ac2bfSKalle Valo endpoint->eid, packet);
19064771979aSKalle Valo
1907e76ac2bfSKalle Valo endpoint->ep_cb.rx(endpoint->target, packet);
1908e76ac2bfSKalle Valo }
1909e76ac2bfSKalle Valo
ath6kl_htc_rx_bundle(struct htc_target * target,struct list_head * rxq,struct list_head * sync_compq,int * n_pkt_fetched,bool part_bundle)1910e76ac2bfSKalle Valo static int ath6kl_htc_rx_bundle(struct htc_target *target,
1911e76ac2bfSKalle Valo struct list_head *rxq,
1912e76ac2bfSKalle Valo struct list_head *sync_compq,
1913e76ac2bfSKalle Valo int *n_pkt_fetched, bool part_bundle)
1914e76ac2bfSKalle Valo {
1915e76ac2bfSKalle Valo struct hif_scatter_req *scat_req;
1916e76ac2bfSKalle Valo struct htc_packet *packet;
1917e76ac2bfSKalle Valo int rem_space = target->max_rx_bndl_sz;
1918e76ac2bfSKalle Valo int n_scat_pkt, status = 0, i, len;
1919e76ac2bfSKalle Valo
1920e76ac2bfSKalle Valo n_scat_pkt = get_queue_depth(rxq);
1921e76ac2bfSKalle Valo n_scat_pkt = min(n_scat_pkt, target->msg_per_bndl_max);
1922e76ac2bfSKalle Valo
1923e76ac2bfSKalle Valo if ((get_queue_depth(rxq) - n_scat_pkt) > 0) {
1924e76ac2bfSKalle Valo /*
1925e76ac2bfSKalle Valo * We were forced to split this bundle receive operation
1926e76ac2bfSKalle Valo * all packets in this partial bundle must have their
1927e76ac2bfSKalle Valo * lookaheads ignored.
1928e76ac2bfSKalle Valo */
1929e76ac2bfSKalle Valo part_bundle = true;
1930e76ac2bfSKalle Valo
1931e76ac2bfSKalle Valo /*
1932e76ac2bfSKalle Valo * This would only happen if the target ignored our max
1933e76ac2bfSKalle Valo * bundle limit.
1934e76ac2bfSKalle Valo */
1935e76ac2bfSKalle Valo ath6kl_warn("%s(): partial bundle detected num:%d , %d\n",
1936e76ac2bfSKalle Valo __func__, get_queue_depth(rxq), n_scat_pkt);
1937e76ac2bfSKalle Valo }
1938e76ac2bfSKalle Valo
1939e76ac2bfSKalle Valo len = 0;
1940e76ac2bfSKalle Valo
1941e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
1942e76ac2bfSKalle Valo "htc rx bundle depth %d pkts %d\n",
1943e76ac2bfSKalle Valo get_queue_depth(rxq), n_scat_pkt);
1944e76ac2bfSKalle Valo
1945e76ac2bfSKalle Valo scat_req = hif_scatter_req_get(target->dev->ar);
1946e76ac2bfSKalle Valo
1947e76ac2bfSKalle Valo if (scat_req == NULL)
1948e76ac2bfSKalle Valo goto fail_rx_pkt;
1949e76ac2bfSKalle Valo
1950e76ac2bfSKalle Valo for (i = 0; i < n_scat_pkt; i++) {
1951e76ac2bfSKalle Valo int pad_len;
1952e76ac2bfSKalle Valo
1953e76ac2bfSKalle Valo packet = list_first_entry(rxq, struct htc_packet, list);
1954e76ac2bfSKalle Valo list_del(&packet->list);
1955e76ac2bfSKalle Valo
1956e76ac2bfSKalle Valo pad_len = CALC_TXRX_PADDED_LEN(target,
1957e76ac2bfSKalle Valo packet->act_len);
1958e76ac2bfSKalle Valo
1959e76ac2bfSKalle Valo if ((rem_space - pad_len) < 0) {
1960e76ac2bfSKalle Valo list_add(&packet->list, rxq);
1961e76ac2bfSKalle Valo break;
1962e76ac2bfSKalle Valo }
1963e76ac2bfSKalle Valo
1964e76ac2bfSKalle Valo rem_space -= pad_len;
1965e76ac2bfSKalle Valo
1966e76ac2bfSKalle Valo if (part_bundle || (i < (n_scat_pkt - 1)))
1967e76ac2bfSKalle Valo /*
1968e76ac2bfSKalle Valo * Packet 0..n-1 cannot be checked for look-aheads
1969e76ac2bfSKalle Valo * since we are fetching a bundle the last packet
1970e76ac2bfSKalle Valo * however can have it's lookahead used
1971e76ac2bfSKalle Valo */
1972e76ac2bfSKalle Valo packet->info.rx.rx_flags |=
1973e76ac2bfSKalle Valo HTC_RX_PKT_IGNORE_LOOKAHEAD;
1974e76ac2bfSKalle Valo
1975e76ac2bfSKalle Valo /* NOTE: 1 HTC packet per scatter entry */
1976e76ac2bfSKalle Valo scat_req->scat_list[i].buf = packet->buf;
1977e76ac2bfSKalle Valo scat_req->scat_list[i].len = pad_len;
1978e76ac2bfSKalle Valo
1979e76ac2bfSKalle Valo packet->info.rx.rx_flags |= HTC_RX_PKT_PART_OF_BUNDLE;
1980e76ac2bfSKalle Valo
1981e76ac2bfSKalle Valo list_add_tail(&packet->list, sync_compq);
1982e76ac2bfSKalle Valo
1983e76ac2bfSKalle Valo WARN_ON(!scat_req->scat_list[i].len);
1984e76ac2bfSKalle Valo len += scat_req->scat_list[i].len;
1985e76ac2bfSKalle Valo }
1986e76ac2bfSKalle Valo
1987e76ac2bfSKalle Valo scat_req->len = len;
1988e76ac2bfSKalle Valo scat_req->scat_entries = i;
1989e76ac2bfSKalle Valo
1990e76ac2bfSKalle Valo status = ath6kl_hif_submit_scat_req(target->dev, scat_req, true);
1991e76ac2bfSKalle Valo
1992e76ac2bfSKalle Valo if (!status)
1993e76ac2bfSKalle Valo *n_pkt_fetched = i;
1994e76ac2bfSKalle Valo
1995e76ac2bfSKalle Valo /* free scatter request */
1996e76ac2bfSKalle Valo hif_scatter_req_add(target->dev->ar, scat_req);
1997e76ac2bfSKalle Valo
1998e76ac2bfSKalle Valo fail_rx_pkt:
1999e76ac2bfSKalle Valo
2000e76ac2bfSKalle Valo return status;
2001e76ac2bfSKalle Valo }
2002e76ac2bfSKalle Valo
ath6kl_htc_rx_process_packets(struct htc_target * target,struct list_head * comp_pktq,u32 lk_ahds[],int * n_lk_ahd)2003e76ac2bfSKalle Valo static int ath6kl_htc_rx_process_packets(struct htc_target *target,
2004e76ac2bfSKalle Valo struct list_head *comp_pktq,
2005e76ac2bfSKalle Valo u32 lk_ahds[],
2006e76ac2bfSKalle Valo int *n_lk_ahd)
2007e76ac2bfSKalle Valo {
2008e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_pkt;
2009e76ac2bfSKalle Valo struct htc_endpoint *ep;
2010e76ac2bfSKalle Valo int status = 0;
2011e76ac2bfSKalle Valo
2012e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, comp_pktq, list) {
2013e76ac2bfSKalle Valo ep = &target->endpoint[packet->endpoint];
2014e76ac2bfSKalle Valo
20154771979aSKalle Valo trace_ath6kl_htc_rx(packet->status, packet->endpoint,
20164771979aSKalle Valo packet->buf, packet->act_len);
20174771979aSKalle Valo
2018e76ac2bfSKalle Valo /* process header for each of the recv packet */
2019e76ac2bfSKalle Valo status = ath6kl_htc_rx_process_hdr(target, packet, lk_ahds,
2020e76ac2bfSKalle Valo n_lk_ahd);
2021e76ac2bfSKalle Valo if (status)
2022e76ac2bfSKalle Valo return status;
2023e76ac2bfSKalle Valo
2024e76ac2bfSKalle Valo list_del(&packet->list);
2025e76ac2bfSKalle Valo
2026e76ac2bfSKalle Valo if (list_empty(comp_pktq)) {
2027e76ac2bfSKalle Valo /*
2028e76ac2bfSKalle Valo * Last packet's more packet flag is set
2029e76ac2bfSKalle Valo * based on the lookahead.
2030e76ac2bfSKalle Valo */
2031e76ac2bfSKalle Valo if (*n_lk_ahd > 0)
2032e76ac2bfSKalle Valo ath6kl_htc_rx_set_indicate(lk_ahds[0],
2033e76ac2bfSKalle Valo ep, packet);
2034e76ac2bfSKalle Valo } else
2035e76ac2bfSKalle Valo /*
2036e76ac2bfSKalle Valo * Packets in a bundle automatically have
2037e76ac2bfSKalle Valo * this flag set.
2038e76ac2bfSKalle Valo */
2039e76ac2bfSKalle Valo packet->info.rx.indicat_flags |=
2040e76ac2bfSKalle Valo HTC_RX_FLAGS_INDICATE_MORE_PKTS;
2041e76ac2bfSKalle Valo
2042e76ac2bfSKalle Valo ath6kl_htc_rx_update_stats(ep, *n_lk_ahd);
2043e76ac2bfSKalle Valo
2044e76ac2bfSKalle Valo if (packet->info.rx.rx_flags & HTC_RX_PKT_PART_OF_BUNDLE)
2045e76ac2bfSKalle Valo ep->ep_st.rx_bundl += 1;
2046e76ac2bfSKalle Valo
2047e76ac2bfSKalle Valo ath6kl_htc_rx_complete(ep, packet);
2048e76ac2bfSKalle Valo }
2049e76ac2bfSKalle Valo
2050e76ac2bfSKalle Valo return status;
2051e76ac2bfSKalle Valo }
2052e76ac2bfSKalle Valo
ath6kl_htc_rx_fetch(struct htc_target * target,struct list_head * rx_pktq,struct list_head * comp_pktq)2053e76ac2bfSKalle Valo static int ath6kl_htc_rx_fetch(struct htc_target *target,
2054e76ac2bfSKalle Valo struct list_head *rx_pktq,
2055e76ac2bfSKalle Valo struct list_head *comp_pktq)
2056e76ac2bfSKalle Valo {
2057e76ac2bfSKalle Valo int fetched_pkts;
2058e76ac2bfSKalle Valo bool part_bundle = false;
2059e76ac2bfSKalle Valo int status = 0;
2060e76ac2bfSKalle Valo struct list_head tmp_rxq;
2061e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_pkt;
2062e76ac2bfSKalle Valo
2063e76ac2bfSKalle Valo /* now go fetch the list of HTC packets */
2064e76ac2bfSKalle Valo while (!list_empty(rx_pktq)) {
2065e76ac2bfSKalle Valo fetched_pkts = 0;
2066e76ac2bfSKalle Valo
2067e76ac2bfSKalle Valo INIT_LIST_HEAD(&tmp_rxq);
2068e76ac2bfSKalle Valo
2069e76ac2bfSKalle Valo if (target->rx_bndl_enable && (get_queue_depth(rx_pktq) > 1)) {
2070e76ac2bfSKalle Valo /*
2071e76ac2bfSKalle Valo * There are enough packets to attempt a
2072e76ac2bfSKalle Valo * bundle transfer and recv bundling is
2073e76ac2bfSKalle Valo * allowed.
2074e76ac2bfSKalle Valo */
2075e76ac2bfSKalle Valo status = ath6kl_htc_rx_bundle(target, rx_pktq,
2076e76ac2bfSKalle Valo &tmp_rxq,
2077e76ac2bfSKalle Valo &fetched_pkts,
2078e76ac2bfSKalle Valo part_bundle);
2079e76ac2bfSKalle Valo if (status)
2080e76ac2bfSKalle Valo goto fail_rx;
2081e76ac2bfSKalle Valo
2082e76ac2bfSKalle Valo if (!list_empty(rx_pktq))
2083e76ac2bfSKalle Valo part_bundle = true;
2084e76ac2bfSKalle Valo
2085e76ac2bfSKalle Valo list_splice_tail_init(&tmp_rxq, comp_pktq);
2086e76ac2bfSKalle Valo }
2087e76ac2bfSKalle Valo
2088e76ac2bfSKalle Valo if (!fetched_pkts) {
2089e76ac2bfSKalle Valo packet = list_first_entry(rx_pktq, struct htc_packet,
2090e76ac2bfSKalle Valo list);
2091e76ac2bfSKalle Valo
2092e76ac2bfSKalle Valo /* fully synchronous */
2093e76ac2bfSKalle Valo packet->completion = NULL;
2094e76ac2bfSKalle Valo
2095e76ac2bfSKalle Valo if (!list_is_singular(rx_pktq))
2096e76ac2bfSKalle Valo /*
2097e76ac2bfSKalle Valo * look_aheads in all packet
2098e76ac2bfSKalle Valo * except the last one in the
2099e76ac2bfSKalle Valo * bundle must be ignored
2100e76ac2bfSKalle Valo */
2101e76ac2bfSKalle Valo packet->info.rx.rx_flags |=
2102e76ac2bfSKalle Valo HTC_RX_PKT_IGNORE_LOOKAHEAD;
2103e76ac2bfSKalle Valo
2104e76ac2bfSKalle Valo /* go fetch the packet */
2105e76ac2bfSKalle Valo status = ath6kl_htc_rx_packet(target, packet,
2106e76ac2bfSKalle Valo packet->act_len);
2107e76ac2bfSKalle Valo
2108e76ac2bfSKalle Valo list_move_tail(&packet->list, &tmp_rxq);
2109e76ac2bfSKalle Valo
2110e76ac2bfSKalle Valo if (status)
2111e76ac2bfSKalle Valo goto fail_rx;
2112e76ac2bfSKalle Valo
2113e76ac2bfSKalle Valo list_splice_tail_init(&tmp_rxq, comp_pktq);
2114e76ac2bfSKalle Valo }
2115e76ac2bfSKalle Valo }
2116e76ac2bfSKalle Valo
2117e76ac2bfSKalle Valo return 0;
2118e76ac2bfSKalle Valo
2119e76ac2bfSKalle Valo fail_rx:
2120e76ac2bfSKalle Valo
2121e76ac2bfSKalle Valo /*
2122e76ac2bfSKalle Valo * Cleanup any packets we allocated but didn't use to
2123e76ac2bfSKalle Valo * actually fetch any packets.
2124e76ac2bfSKalle Valo */
2125e76ac2bfSKalle Valo
2126e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, rx_pktq, list) {
2127e76ac2bfSKalle Valo list_del(&packet->list);
2128e76ac2bfSKalle Valo htc_reclaim_rxbuf(target, packet,
2129e76ac2bfSKalle Valo &target->endpoint[packet->endpoint]);
2130e76ac2bfSKalle Valo }
2131e76ac2bfSKalle Valo
2132e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, &tmp_rxq, list) {
2133e76ac2bfSKalle Valo list_del(&packet->list);
2134e76ac2bfSKalle Valo htc_reclaim_rxbuf(target, packet,
2135e76ac2bfSKalle Valo &target->endpoint[packet->endpoint]);
2136e76ac2bfSKalle Valo }
2137e76ac2bfSKalle Valo
2138e76ac2bfSKalle Valo return status;
2139e76ac2bfSKalle Valo }
2140e76ac2bfSKalle Valo
ath6kl_htc_rxmsg_pending_handler(struct htc_target * target,u32 msg_look_ahead,int * num_pkts)2141e76ac2bfSKalle Valo int ath6kl_htc_rxmsg_pending_handler(struct htc_target *target,
2142e76ac2bfSKalle Valo u32 msg_look_ahead, int *num_pkts)
2143e76ac2bfSKalle Valo {
2144e76ac2bfSKalle Valo struct htc_packet *packets, *tmp_pkt;
2145e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
2146e76ac2bfSKalle Valo struct list_head rx_pktq, comp_pktq;
2147e76ac2bfSKalle Valo int status = 0;
2148e76ac2bfSKalle Valo u32 look_aheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
2149e76ac2bfSKalle Valo int num_look_ahead = 1;
2150e76ac2bfSKalle Valo enum htc_endpoint_id id;
2151e76ac2bfSKalle Valo int n_fetched = 0;
2152e76ac2bfSKalle Valo
2153e76ac2bfSKalle Valo INIT_LIST_HEAD(&comp_pktq);
2154e76ac2bfSKalle Valo *num_pkts = 0;
2155e76ac2bfSKalle Valo
2156e76ac2bfSKalle Valo /*
2157e76ac2bfSKalle Valo * On first entry copy the look_aheads into our temp array for
2158e76ac2bfSKalle Valo * processing
2159e76ac2bfSKalle Valo */
2160e76ac2bfSKalle Valo look_aheads[0] = msg_look_ahead;
2161e76ac2bfSKalle Valo
2162e76ac2bfSKalle Valo while (true) {
2163e76ac2bfSKalle Valo /*
2164e76ac2bfSKalle Valo * First lookahead sets the expected endpoint IDs for all
2165e76ac2bfSKalle Valo * packets in a bundle.
2166e76ac2bfSKalle Valo */
2167e76ac2bfSKalle Valo id = ((struct htc_frame_hdr *)&look_aheads[0])->eid;
2168e76ac2bfSKalle Valo endpoint = &target->endpoint[id];
2169e76ac2bfSKalle Valo
2170e76ac2bfSKalle Valo if (id >= ENDPOINT_MAX) {
2171e76ac2bfSKalle Valo ath6kl_err("MsgPend, invalid endpoint in look-ahead: %d\n",
2172e76ac2bfSKalle Valo id);
2173e76ac2bfSKalle Valo status = -ENOMEM;
2174e76ac2bfSKalle Valo break;
2175e76ac2bfSKalle Valo }
2176e76ac2bfSKalle Valo
2177e76ac2bfSKalle Valo INIT_LIST_HEAD(&rx_pktq);
2178e76ac2bfSKalle Valo INIT_LIST_HEAD(&comp_pktq);
2179e76ac2bfSKalle Valo
2180e76ac2bfSKalle Valo /*
2181e76ac2bfSKalle Valo * Try to allocate as many HTC RX packets indicated by the
2182e76ac2bfSKalle Valo * look_aheads.
2183e76ac2bfSKalle Valo */
2184e76ac2bfSKalle Valo status = ath6kl_htc_rx_alloc(target, look_aheads,
2185e76ac2bfSKalle Valo num_look_ahead, endpoint,
2186e76ac2bfSKalle Valo &rx_pktq);
2187e76ac2bfSKalle Valo if (status)
2188e76ac2bfSKalle Valo break;
2189e76ac2bfSKalle Valo
2190e76ac2bfSKalle Valo if (get_queue_depth(&rx_pktq) >= 2)
2191e76ac2bfSKalle Valo /*
2192e76ac2bfSKalle Valo * A recv bundle was detected, force IRQ status
2193e76ac2bfSKalle Valo * re-check again
2194e76ac2bfSKalle Valo */
2195e76ac2bfSKalle Valo target->chk_irq_status_cnt = 1;
2196e76ac2bfSKalle Valo
2197e76ac2bfSKalle Valo n_fetched += get_queue_depth(&rx_pktq);
2198e76ac2bfSKalle Valo
2199e76ac2bfSKalle Valo num_look_ahead = 0;
2200e76ac2bfSKalle Valo
2201e76ac2bfSKalle Valo status = ath6kl_htc_rx_fetch(target, &rx_pktq, &comp_pktq);
2202e76ac2bfSKalle Valo
2203e76ac2bfSKalle Valo if (!status)
2204e76ac2bfSKalle Valo ath6kl_htc_rx_chk_water_mark(endpoint);
2205e76ac2bfSKalle Valo
2206e76ac2bfSKalle Valo /* Process fetched packets */
2207e76ac2bfSKalle Valo status = ath6kl_htc_rx_process_packets(target, &comp_pktq,
2208e76ac2bfSKalle Valo look_aheads,
2209e76ac2bfSKalle Valo &num_look_ahead);
2210e76ac2bfSKalle Valo
2211e76ac2bfSKalle Valo if (!num_look_ahead || status)
2212e76ac2bfSKalle Valo break;
2213e76ac2bfSKalle Valo
2214e76ac2bfSKalle Valo /*
2215e76ac2bfSKalle Valo * For SYNCH processing, if we get here, we are running
2216e76ac2bfSKalle Valo * through the loop again due to a detected lookahead. Set
2217e76ac2bfSKalle Valo * flag that we should re-check IRQ status registers again
2218e76ac2bfSKalle Valo * before leaving IRQ processing, this can net better
2219e76ac2bfSKalle Valo * performance in high throughput situations.
2220e76ac2bfSKalle Valo */
2221e76ac2bfSKalle Valo target->chk_irq_status_cnt = 1;
2222e76ac2bfSKalle Valo }
2223e76ac2bfSKalle Valo
2224e76ac2bfSKalle Valo if (status) {
222579fd1709SSteve deRosier if (status != -ECANCELED)
2226e76ac2bfSKalle Valo ath6kl_err("failed to get pending recv messages: %d\n",
2227e76ac2bfSKalle Valo status);
2228e76ac2bfSKalle Valo
2229e76ac2bfSKalle Valo /* cleanup any packets in sync completion queue */
2230e76ac2bfSKalle Valo list_for_each_entry_safe(packets, tmp_pkt, &comp_pktq, list) {
2231e76ac2bfSKalle Valo list_del(&packets->list);
2232e76ac2bfSKalle Valo htc_reclaim_rxbuf(target, packets,
2233e76ac2bfSKalle Valo &target->endpoint[packets->endpoint]);
2234e76ac2bfSKalle Valo }
2235e76ac2bfSKalle Valo
2236e76ac2bfSKalle Valo if (target->htc_flags & HTC_OP_STATE_STOPPING) {
2237e76ac2bfSKalle Valo ath6kl_warn("host is going to stop blocking receiver for htc_stop\n");
2238e76ac2bfSKalle Valo ath6kl_hif_rx_control(target->dev, false);
2239e76ac2bfSKalle Valo }
2240e76ac2bfSKalle Valo }
2241e76ac2bfSKalle Valo
2242e76ac2bfSKalle Valo /*
2243e76ac2bfSKalle Valo * Before leaving, check to see if host ran out of buffers and
2244e76ac2bfSKalle Valo * needs to stop the receiver.
2245e76ac2bfSKalle Valo */
2246e76ac2bfSKalle Valo if (target->rx_st_flags & HTC_RECV_WAIT_BUFFERS) {
2247e76ac2bfSKalle Valo ath6kl_warn("host has no rx buffers blocking receiver to prevent overrun\n");
2248e76ac2bfSKalle Valo ath6kl_hif_rx_control(target->dev, false);
2249e76ac2bfSKalle Valo }
2250e76ac2bfSKalle Valo *num_pkts = n_fetched;
2251e76ac2bfSKalle Valo
2252e76ac2bfSKalle Valo return status;
2253e76ac2bfSKalle Valo }
2254e76ac2bfSKalle Valo
2255e76ac2bfSKalle Valo /*
2256e76ac2bfSKalle Valo * Synchronously wait for a control message from the target,
2257e76ac2bfSKalle Valo * This function is used at initialization time ONLY. At init messages
2258e76ac2bfSKalle Valo * on ENDPOINT 0 are expected.
2259e76ac2bfSKalle Valo */
htc_wait_for_ctrl_msg(struct htc_target * target)2260e76ac2bfSKalle Valo static struct htc_packet *htc_wait_for_ctrl_msg(struct htc_target *target)
2261e76ac2bfSKalle Valo {
2262e76ac2bfSKalle Valo struct htc_packet *packet = NULL;
2263e3128a9dSKees Cook struct htc_frame_look_ahead look_ahead;
2264e76ac2bfSKalle Valo
2265e3128a9dSKees Cook if (ath6kl_hif_poll_mboxmsg_rx(target->dev, &look_ahead.word,
2266e76ac2bfSKalle Valo HTC_TARGET_RESPONSE_TIMEOUT))
2267e76ac2bfSKalle Valo return NULL;
2268e76ac2bfSKalle Valo
2269e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
2270e3128a9dSKees Cook "htc rx wait ctrl look_ahead 0x%X\n", look_ahead.word);
2271e76ac2bfSKalle Valo
2272e3128a9dSKees Cook if (look_ahead.eid != ENDPOINT_0)
2273e76ac2bfSKalle Valo return NULL;
2274e76ac2bfSKalle Valo
2275e76ac2bfSKalle Valo packet = htc_get_control_buf(target, false);
2276e76ac2bfSKalle Valo
2277e76ac2bfSKalle Valo if (!packet)
2278e76ac2bfSKalle Valo return NULL;
2279e76ac2bfSKalle Valo
2280e76ac2bfSKalle Valo packet->info.rx.rx_flags = 0;
2281e3128a9dSKees Cook packet->info.rx.exp_hdr = look_ahead.word;
2282e3128a9dSKees Cook packet->act_len = le16_to_cpu(look_ahead.payld_len) + HTC_HDR_LENGTH;
2283e76ac2bfSKalle Valo
2284e76ac2bfSKalle Valo if (packet->act_len > packet->buf_len)
2285e76ac2bfSKalle Valo goto fail_ctrl_rx;
2286e76ac2bfSKalle Valo
2287e76ac2bfSKalle Valo /* we want synchronous operation */
2288e76ac2bfSKalle Valo packet->completion = NULL;
2289e76ac2bfSKalle Valo
2290e76ac2bfSKalle Valo /* get the message from the device, this will block */
2291e76ac2bfSKalle Valo if (ath6kl_htc_rx_packet(target, packet, packet->act_len))
2292e76ac2bfSKalle Valo goto fail_ctrl_rx;
2293e76ac2bfSKalle Valo
22944771979aSKalle Valo trace_ath6kl_htc_rx(packet->status, packet->endpoint,
22954771979aSKalle Valo packet->buf, packet->act_len);
22964771979aSKalle Valo
2297e76ac2bfSKalle Valo /* process receive header */
2298e76ac2bfSKalle Valo packet->status = ath6kl_htc_rx_process_hdr(target, packet, NULL, NULL);
2299e76ac2bfSKalle Valo
2300e76ac2bfSKalle Valo if (packet->status) {
2301e76ac2bfSKalle Valo ath6kl_err("htc_wait_for_ctrl_msg, ath6kl_htc_rx_process_hdr failed (status = %d)\n",
2302e76ac2bfSKalle Valo packet->status);
2303e76ac2bfSKalle Valo goto fail_ctrl_rx;
2304e76ac2bfSKalle Valo }
2305e76ac2bfSKalle Valo
2306e76ac2bfSKalle Valo return packet;
2307e76ac2bfSKalle Valo
2308e76ac2bfSKalle Valo fail_ctrl_rx:
2309e76ac2bfSKalle Valo if (packet != NULL) {
2310e76ac2bfSKalle Valo htc_rxpkt_reset(packet);
2311e76ac2bfSKalle Valo reclaim_rx_ctrl_buf(target, packet);
2312e76ac2bfSKalle Valo }
2313e76ac2bfSKalle Valo
2314e76ac2bfSKalle Valo return NULL;
2315e76ac2bfSKalle Valo }
2316e76ac2bfSKalle Valo
ath6kl_htc_mbox_add_rxbuf_multiple(struct htc_target * target,struct list_head * pkt_queue)2317e76ac2bfSKalle Valo static int ath6kl_htc_mbox_add_rxbuf_multiple(struct htc_target *target,
2318e76ac2bfSKalle Valo struct list_head *pkt_queue)
2319e76ac2bfSKalle Valo {
2320e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
2321e76ac2bfSKalle Valo struct htc_packet *first_pkt;
2322e76ac2bfSKalle Valo bool rx_unblock = false;
2323e76ac2bfSKalle Valo int status = 0, depth;
2324e76ac2bfSKalle Valo
2325e76ac2bfSKalle Valo if (list_empty(pkt_queue))
2326e76ac2bfSKalle Valo return -ENOMEM;
2327e76ac2bfSKalle Valo
2328e76ac2bfSKalle Valo first_pkt = list_first_entry(pkt_queue, struct htc_packet, list);
2329e76ac2bfSKalle Valo
2330e76ac2bfSKalle Valo if (first_pkt->endpoint >= ENDPOINT_MAX)
2331e76ac2bfSKalle Valo return status;
2332e76ac2bfSKalle Valo
2333e76ac2bfSKalle Valo depth = get_queue_depth(pkt_queue);
2334e76ac2bfSKalle Valo
2335e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
2336e76ac2bfSKalle Valo "htc rx add multiple ep id %d cnt %d len %d\n",
2337e76ac2bfSKalle Valo first_pkt->endpoint, depth, first_pkt->buf_len);
2338e76ac2bfSKalle Valo
2339e76ac2bfSKalle Valo endpoint = &target->endpoint[first_pkt->endpoint];
2340e76ac2bfSKalle Valo
2341e76ac2bfSKalle Valo if (target->htc_flags & HTC_OP_STATE_STOPPING) {
2342e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_pkt;
2343e76ac2bfSKalle Valo
2344e76ac2bfSKalle Valo /* walk through queue and mark each one canceled */
2345e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) {
2346e76ac2bfSKalle Valo packet->status = -ECANCELED;
2347e76ac2bfSKalle Valo list_del(&packet->list);
2348e76ac2bfSKalle Valo ath6kl_htc_rx_complete(endpoint, packet);
2349e76ac2bfSKalle Valo }
2350e76ac2bfSKalle Valo
2351e76ac2bfSKalle Valo return status;
2352e76ac2bfSKalle Valo }
2353e76ac2bfSKalle Valo
2354e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
2355e76ac2bfSKalle Valo
2356e76ac2bfSKalle Valo list_splice_tail_init(pkt_queue, &endpoint->rx_bufq);
2357e76ac2bfSKalle Valo
2358e76ac2bfSKalle Valo /* check if we are blocked waiting for a new buffer */
2359e76ac2bfSKalle Valo if (target->rx_st_flags & HTC_RECV_WAIT_BUFFERS) {
2360e76ac2bfSKalle Valo if (target->ep_waiting == first_pkt->endpoint) {
2361e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
2362e76ac2bfSKalle Valo "htc rx blocked on ep %d, unblocking\n",
2363e76ac2bfSKalle Valo target->ep_waiting);
2364e76ac2bfSKalle Valo target->rx_st_flags &= ~HTC_RECV_WAIT_BUFFERS;
2365e76ac2bfSKalle Valo target->ep_waiting = ENDPOINT_MAX;
2366e76ac2bfSKalle Valo rx_unblock = true;
2367e76ac2bfSKalle Valo }
2368e76ac2bfSKalle Valo }
2369e76ac2bfSKalle Valo
2370e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
2371e76ac2bfSKalle Valo
2372e76ac2bfSKalle Valo if (rx_unblock && !(target->htc_flags & HTC_OP_STATE_STOPPING))
2373e76ac2bfSKalle Valo /* TODO : implement a buffer threshold count? */
2374e76ac2bfSKalle Valo ath6kl_hif_rx_control(target->dev, true);
2375e76ac2bfSKalle Valo
2376e76ac2bfSKalle Valo return status;
2377e76ac2bfSKalle Valo }
2378e76ac2bfSKalle Valo
ath6kl_htc_mbox_flush_rx_buf(struct htc_target * target)2379e76ac2bfSKalle Valo static void ath6kl_htc_mbox_flush_rx_buf(struct htc_target *target)
2380e76ac2bfSKalle Valo {
2381e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
2382e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_pkt;
2383e76ac2bfSKalle Valo int i;
2384e76ac2bfSKalle Valo
2385e76ac2bfSKalle Valo for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
2386e76ac2bfSKalle Valo endpoint = &target->endpoint[i];
2387e76ac2bfSKalle Valo if (!endpoint->svc_id)
2388e76ac2bfSKalle Valo /* not in use.. */
2389e76ac2bfSKalle Valo continue;
2390e76ac2bfSKalle Valo
2391e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
2392e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_pkt,
2393e76ac2bfSKalle Valo &endpoint->rx_bufq, list) {
2394e76ac2bfSKalle Valo list_del(&packet->list);
2395e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
2396e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
2397e76ac2bfSKalle Valo "htc rx flush pkt 0x%p len %d ep %d\n",
2398e76ac2bfSKalle Valo packet, packet->buf_len,
2399e76ac2bfSKalle Valo packet->endpoint);
2400e76ac2bfSKalle Valo /*
2401e76ac2bfSKalle Valo * packets in rx_bufq of endpoint 0 have originally
2402e76ac2bfSKalle Valo * been queued from target->free_ctrl_rxbuf where
2403e76ac2bfSKalle Valo * packet and packet->buf_start are allocated
2404e76ac2bfSKalle Valo * separately using kmalloc(). For other endpoint
2405e76ac2bfSKalle Valo * rx_bufq, it is allocated as skb where packet is
2406e76ac2bfSKalle Valo * skb->head. Take care of this difference while freeing
2407e76ac2bfSKalle Valo * the memory.
2408e76ac2bfSKalle Valo */
2409e76ac2bfSKalle Valo if (packet->endpoint == ENDPOINT_0) {
2410e76ac2bfSKalle Valo kfree(packet->buf_start);
2411e76ac2bfSKalle Valo kfree(packet);
2412e76ac2bfSKalle Valo } else {
2413e76ac2bfSKalle Valo dev_kfree_skb(packet->pkt_cntxt);
2414e76ac2bfSKalle Valo }
2415e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
2416e76ac2bfSKalle Valo }
2417e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
2418e76ac2bfSKalle Valo }
2419e76ac2bfSKalle Valo }
2420e76ac2bfSKalle Valo
ath6kl_htc_mbox_conn_service(struct htc_target * target,struct htc_service_connect_req * conn_req,struct htc_service_connect_resp * conn_resp)2421e76ac2bfSKalle Valo static int ath6kl_htc_mbox_conn_service(struct htc_target *target,
2422e76ac2bfSKalle Valo struct htc_service_connect_req *conn_req,
2423e76ac2bfSKalle Valo struct htc_service_connect_resp *conn_resp)
2424e76ac2bfSKalle Valo {
2425e76ac2bfSKalle Valo struct htc_packet *rx_pkt = NULL;
2426e76ac2bfSKalle Valo struct htc_packet *tx_pkt = NULL;
2427e76ac2bfSKalle Valo struct htc_conn_service_resp *resp_msg;
2428e76ac2bfSKalle Valo struct htc_conn_service_msg *conn_msg;
2429e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
2430e76ac2bfSKalle Valo enum htc_endpoint_id assigned_ep = ENDPOINT_MAX;
2431e76ac2bfSKalle Valo unsigned int max_msg_sz = 0;
2432e76ac2bfSKalle Valo int status = 0;
2433e76ac2bfSKalle Valo u16 msg_id;
2434e76ac2bfSKalle Valo
2435e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_HTC,
2436e76ac2bfSKalle Valo "htc connect service target 0x%p service id 0x%x\n",
2437e76ac2bfSKalle Valo target, conn_req->svc_id);
2438e76ac2bfSKalle Valo
2439e76ac2bfSKalle Valo if (conn_req->svc_id == HTC_CTRL_RSVD_SVC) {
2440e76ac2bfSKalle Valo /* special case for pseudo control service */
2441e76ac2bfSKalle Valo assigned_ep = ENDPOINT_0;
2442e76ac2bfSKalle Valo max_msg_sz = HTC_MAX_CTRL_MSG_LEN;
2443e76ac2bfSKalle Valo } else {
2444e76ac2bfSKalle Valo /* allocate a packet to send to the target */
2445e76ac2bfSKalle Valo tx_pkt = htc_get_control_buf(target, true);
2446e76ac2bfSKalle Valo
2447e76ac2bfSKalle Valo if (!tx_pkt)
2448e76ac2bfSKalle Valo return -ENOMEM;
2449e76ac2bfSKalle Valo
2450e76ac2bfSKalle Valo conn_msg = (struct htc_conn_service_msg *)tx_pkt->buf;
2451e76ac2bfSKalle Valo memset(conn_msg, 0, sizeof(*conn_msg));
2452e76ac2bfSKalle Valo conn_msg->msg_id = cpu_to_le16(HTC_MSG_CONN_SVC_ID);
2453e76ac2bfSKalle Valo conn_msg->svc_id = cpu_to_le16(conn_req->svc_id);
2454e76ac2bfSKalle Valo conn_msg->conn_flags = cpu_to_le16(conn_req->conn_flags);
2455e76ac2bfSKalle Valo
2456e76ac2bfSKalle Valo set_htc_pkt_info(tx_pkt, NULL, (u8 *) conn_msg,
2457e76ac2bfSKalle Valo sizeof(*conn_msg) + conn_msg->svc_meta_len,
2458e76ac2bfSKalle Valo ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
2459e76ac2bfSKalle Valo
2460e76ac2bfSKalle Valo /* we want synchronous operation */
2461e76ac2bfSKalle Valo tx_pkt->completion = NULL;
2462e76ac2bfSKalle Valo ath6kl_htc_tx_prep_pkt(tx_pkt, 0, 0, 0);
2463e76ac2bfSKalle Valo status = ath6kl_htc_tx_issue(target, tx_pkt);
2464e76ac2bfSKalle Valo
2465e76ac2bfSKalle Valo if (status)
2466e76ac2bfSKalle Valo goto fail_tx;
2467e76ac2bfSKalle Valo
2468e76ac2bfSKalle Valo /* wait for response */
2469e76ac2bfSKalle Valo rx_pkt = htc_wait_for_ctrl_msg(target);
2470e76ac2bfSKalle Valo
2471e76ac2bfSKalle Valo if (!rx_pkt) {
2472e76ac2bfSKalle Valo status = -ENOMEM;
2473e76ac2bfSKalle Valo goto fail_tx;
2474e76ac2bfSKalle Valo }
2475e76ac2bfSKalle Valo
2476e76ac2bfSKalle Valo resp_msg = (struct htc_conn_service_resp *)rx_pkt->buf;
2477e76ac2bfSKalle Valo msg_id = le16_to_cpu(resp_msg->msg_id);
2478e76ac2bfSKalle Valo
2479e76ac2bfSKalle Valo if ((msg_id != HTC_MSG_CONN_SVC_RESP_ID) ||
2480e76ac2bfSKalle Valo (rx_pkt->act_len < sizeof(*resp_msg))) {
2481e76ac2bfSKalle Valo status = -ENOMEM;
2482e76ac2bfSKalle Valo goto fail_tx;
2483e76ac2bfSKalle Valo }
2484e76ac2bfSKalle Valo
2485e76ac2bfSKalle Valo conn_resp->resp_code = resp_msg->status;
2486e76ac2bfSKalle Valo /* check response status */
2487e76ac2bfSKalle Valo if (resp_msg->status != HTC_SERVICE_SUCCESS) {
2488e76ac2bfSKalle Valo ath6kl_err("target failed service 0x%X connect request (status:%d)\n",
2489e76ac2bfSKalle Valo resp_msg->svc_id, resp_msg->status);
2490e76ac2bfSKalle Valo status = -ENOMEM;
2491e76ac2bfSKalle Valo goto fail_tx;
2492e76ac2bfSKalle Valo }
2493e76ac2bfSKalle Valo
2494e76ac2bfSKalle Valo assigned_ep = (enum htc_endpoint_id)resp_msg->eid;
2495e76ac2bfSKalle Valo max_msg_sz = le16_to_cpu(resp_msg->max_msg_sz);
2496e76ac2bfSKalle Valo }
2497e76ac2bfSKalle Valo
249886aa7c1eSPandiyarajan Pitchaimuthu if (WARN_ON_ONCE(assigned_ep == ENDPOINT_UNUSED ||
249986aa7c1eSPandiyarajan Pitchaimuthu assigned_ep >= ENDPOINT_MAX || !max_msg_sz)) {
2500e76ac2bfSKalle Valo status = -ENOMEM;
2501e76ac2bfSKalle Valo goto fail_tx;
2502e76ac2bfSKalle Valo }
2503e76ac2bfSKalle Valo
2504e76ac2bfSKalle Valo endpoint = &target->endpoint[assigned_ep];
2505e76ac2bfSKalle Valo endpoint->eid = assigned_ep;
2506e76ac2bfSKalle Valo if (endpoint->svc_id) {
2507e76ac2bfSKalle Valo status = -ENOMEM;
2508e76ac2bfSKalle Valo goto fail_tx;
2509e76ac2bfSKalle Valo }
2510e76ac2bfSKalle Valo
2511e76ac2bfSKalle Valo /* return assigned endpoint to caller */
2512e76ac2bfSKalle Valo conn_resp->endpoint = assigned_ep;
2513e76ac2bfSKalle Valo conn_resp->len_max = max_msg_sz;
2514e76ac2bfSKalle Valo
2515e76ac2bfSKalle Valo /* setup the endpoint */
2516e76ac2bfSKalle Valo
2517e76ac2bfSKalle Valo /* this marks the endpoint in use */
2518e76ac2bfSKalle Valo endpoint->svc_id = conn_req->svc_id;
2519e76ac2bfSKalle Valo
2520e76ac2bfSKalle Valo endpoint->max_txq_depth = conn_req->max_txq_depth;
2521e76ac2bfSKalle Valo endpoint->len_max = max_msg_sz;
2522e76ac2bfSKalle Valo endpoint->ep_cb = conn_req->ep_cb;
2523e76ac2bfSKalle Valo endpoint->cred_dist.svc_id = conn_req->svc_id;
2524e76ac2bfSKalle Valo endpoint->cred_dist.htc_ep = endpoint;
2525e76ac2bfSKalle Valo endpoint->cred_dist.endpoint = assigned_ep;
2526e76ac2bfSKalle Valo endpoint->cred_dist.cred_sz = target->tgt_cred_sz;
2527e76ac2bfSKalle Valo
2528e76ac2bfSKalle Valo switch (endpoint->svc_id) {
2529e76ac2bfSKalle Valo case WMI_DATA_BK_SVC:
2530e76ac2bfSKalle Valo endpoint->tx_drop_packet_threshold = MAX_DEF_COOKIE_NUM / 3;
2531e76ac2bfSKalle Valo break;
2532e76ac2bfSKalle Valo default:
2533e76ac2bfSKalle Valo endpoint->tx_drop_packet_threshold = MAX_HI_COOKIE_NUM;
2534e76ac2bfSKalle Valo break;
2535e76ac2bfSKalle Valo }
2536e76ac2bfSKalle Valo
2537e76ac2bfSKalle Valo if (conn_req->max_rxmsg_sz) {
2538e76ac2bfSKalle Valo /*
2539e76ac2bfSKalle Valo * Override cred_per_msg calculation, this optimizes
2540e76ac2bfSKalle Valo * the credit-low indications since the host will actually
2541e76ac2bfSKalle Valo * issue smaller messages in the Send path.
2542e76ac2bfSKalle Valo */
2543e76ac2bfSKalle Valo if (conn_req->max_rxmsg_sz > max_msg_sz) {
2544e76ac2bfSKalle Valo status = -ENOMEM;
2545e76ac2bfSKalle Valo goto fail_tx;
2546e76ac2bfSKalle Valo }
2547e76ac2bfSKalle Valo endpoint->cred_dist.cred_per_msg =
2548e76ac2bfSKalle Valo conn_req->max_rxmsg_sz / target->tgt_cred_sz;
2549e76ac2bfSKalle Valo } else
2550e76ac2bfSKalle Valo endpoint->cred_dist.cred_per_msg =
2551e76ac2bfSKalle Valo max_msg_sz / target->tgt_cred_sz;
2552e76ac2bfSKalle Valo
2553e76ac2bfSKalle Valo if (!endpoint->cred_dist.cred_per_msg)
2554e76ac2bfSKalle Valo endpoint->cred_dist.cred_per_msg = 1;
2555e76ac2bfSKalle Valo
2556e76ac2bfSKalle Valo /* save local connection flags */
2557e76ac2bfSKalle Valo endpoint->conn_flags = conn_req->flags;
2558e76ac2bfSKalle Valo
2559e76ac2bfSKalle Valo fail_tx:
2560e76ac2bfSKalle Valo if (tx_pkt)
2561e76ac2bfSKalle Valo htc_reclaim_txctrl_buf(target, tx_pkt);
2562e76ac2bfSKalle Valo
2563e76ac2bfSKalle Valo if (rx_pkt) {
2564e76ac2bfSKalle Valo htc_rxpkt_reset(rx_pkt);
2565e76ac2bfSKalle Valo reclaim_rx_ctrl_buf(target, rx_pkt);
2566e76ac2bfSKalle Valo }
2567e76ac2bfSKalle Valo
2568e76ac2bfSKalle Valo return status;
2569e76ac2bfSKalle Valo }
2570e76ac2bfSKalle Valo
reset_ep_state(struct htc_target * target)2571e76ac2bfSKalle Valo static void reset_ep_state(struct htc_target *target)
2572e76ac2bfSKalle Valo {
2573e76ac2bfSKalle Valo struct htc_endpoint *endpoint;
2574e76ac2bfSKalle Valo int i;
2575e76ac2bfSKalle Valo
2576e76ac2bfSKalle Valo for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
2577e76ac2bfSKalle Valo endpoint = &target->endpoint[i];
2578e76ac2bfSKalle Valo memset(&endpoint->cred_dist, 0, sizeof(endpoint->cred_dist));
2579e76ac2bfSKalle Valo endpoint->svc_id = 0;
2580e76ac2bfSKalle Valo endpoint->len_max = 0;
2581e76ac2bfSKalle Valo endpoint->max_txq_depth = 0;
2582e76ac2bfSKalle Valo memset(&endpoint->ep_st, 0,
2583e76ac2bfSKalle Valo sizeof(endpoint->ep_st));
2584e76ac2bfSKalle Valo INIT_LIST_HEAD(&endpoint->rx_bufq);
2585e76ac2bfSKalle Valo INIT_LIST_HEAD(&endpoint->txq);
2586e76ac2bfSKalle Valo endpoint->target = target;
2587e76ac2bfSKalle Valo }
2588e76ac2bfSKalle Valo
2589e76ac2bfSKalle Valo /* reset distribution list */
2590e76ac2bfSKalle Valo /* FIXME: free existing entries */
2591e76ac2bfSKalle Valo INIT_LIST_HEAD(&target->cred_dist_list);
2592e76ac2bfSKalle Valo }
2593e76ac2bfSKalle Valo
ath6kl_htc_mbox_get_rxbuf_num(struct htc_target * target,enum htc_endpoint_id endpoint)2594e76ac2bfSKalle Valo static int ath6kl_htc_mbox_get_rxbuf_num(struct htc_target *target,
2595e76ac2bfSKalle Valo enum htc_endpoint_id endpoint)
2596e76ac2bfSKalle Valo {
2597e76ac2bfSKalle Valo int num;
2598e76ac2bfSKalle Valo
2599e76ac2bfSKalle Valo spin_lock_bh(&target->rx_lock);
2600e76ac2bfSKalle Valo num = get_queue_depth(&(target->endpoint[endpoint].rx_bufq));
2601e76ac2bfSKalle Valo spin_unlock_bh(&target->rx_lock);
2602e76ac2bfSKalle Valo return num;
2603e76ac2bfSKalle Valo }
2604e76ac2bfSKalle Valo
htc_setup_msg_bndl(struct htc_target * target)2605e76ac2bfSKalle Valo static void htc_setup_msg_bndl(struct htc_target *target)
2606e76ac2bfSKalle Valo {
2607e76ac2bfSKalle Valo /* limit what HTC can handle */
2608e76ac2bfSKalle Valo target->msg_per_bndl_max = min(HTC_HOST_MAX_MSG_PER_BUNDLE,
2609e76ac2bfSKalle Valo target->msg_per_bndl_max);
2610e76ac2bfSKalle Valo
2611e76ac2bfSKalle Valo if (ath6kl_hif_enable_scatter(target->dev->ar)) {
2612e76ac2bfSKalle Valo target->msg_per_bndl_max = 0;
2613e76ac2bfSKalle Valo return;
2614e76ac2bfSKalle Valo }
2615e76ac2bfSKalle Valo
2616e76ac2bfSKalle Valo /* limit bundle what the device layer can handle */
2617e76ac2bfSKalle Valo target->msg_per_bndl_max = min(target->max_scat_entries,
2618e76ac2bfSKalle Valo target->msg_per_bndl_max);
2619e76ac2bfSKalle Valo
2620e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_BOOT,
2621e76ac2bfSKalle Valo "htc bundling allowed msg_per_bndl_max %d\n",
2622e76ac2bfSKalle Valo target->msg_per_bndl_max);
2623e76ac2bfSKalle Valo
2624e76ac2bfSKalle Valo /* Max rx bundle size is limited by the max tx bundle size */
2625e76ac2bfSKalle Valo target->max_rx_bndl_sz = target->max_xfer_szper_scatreq;
2626e76ac2bfSKalle Valo /* Max tx bundle size if limited by the extended mbox address range */
2627e76ac2bfSKalle Valo target->max_tx_bndl_sz = min(HIF_MBOX0_EXT_WIDTH,
2628e76ac2bfSKalle Valo target->max_xfer_szper_scatreq);
2629e76ac2bfSKalle Valo
2630e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_BOOT, "htc max_rx_bndl_sz %d max_tx_bndl_sz %d\n",
2631e76ac2bfSKalle Valo target->max_rx_bndl_sz, target->max_tx_bndl_sz);
2632e76ac2bfSKalle Valo
2633e76ac2bfSKalle Valo if (target->max_tx_bndl_sz)
2634e76ac2bfSKalle Valo /* tx_bndl_mask is enabled per AC, each has 1 bit */
2635e76ac2bfSKalle Valo target->tx_bndl_mask = (1 << WMM_NUM_AC) - 1;
2636e76ac2bfSKalle Valo
2637e76ac2bfSKalle Valo if (target->max_rx_bndl_sz)
2638e76ac2bfSKalle Valo target->rx_bndl_enable = true;
2639e76ac2bfSKalle Valo
2640e76ac2bfSKalle Valo if ((target->tgt_cred_sz % target->block_sz) != 0) {
2641e76ac2bfSKalle Valo ath6kl_warn("credit size: %d is not block aligned! Disabling send bundling\n",
2642e76ac2bfSKalle Valo target->tgt_cred_sz);
2643e76ac2bfSKalle Valo
2644e76ac2bfSKalle Valo /*
2645e76ac2bfSKalle Valo * Disallow send bundling since the credit size is
2646e76ac2bfSKalle Valo * not aligned to a block size the I/O block
2647e76ac2bfSKalle Valo * padding will spill into the next credit buffer
2648e76ac2bfSKalle Valo * which is fatal.
2649e76ac2bfSKalle Valo */
2650e76ac2bfSKalle Valo target->tx_bndl_mask = 0;
2651e76ac2bfSKalle Valo }
2652e76ac2bfSKalle Valo }
2653e76ac2bfSKalle Valo
ath6kl_htc_mbox_wait_target(struct htc_target * target)2654e76ac2bfSKalle Valo static int ath6kl_htc_mbox_wait_target(struct htc_target *target)
2655e76ac2bfSKalle Valo {
2656e76ac2bfSKalle Valo struct htc_packet *packet = NULL;
2657e76ac2bfSKalle Valo struct htc_ready_ext_msg *rdy_msg;
2658e76ac2bfSKalle Valo struct htc_service_connect_req connect;
2659e76ac2bfSKalle Valo struct htc_service_connect_resp resp;
2660e76ac2bfSKalle Valo int status;
2661e76ac2bfSKalle Valo
2662e76ac2bfSKalle Valo /* we should be getting 1 control message that the target is ready */
2663e76ac2bfSKalle Valo packet = htc_wait_for_ctrl_msg(target);
2664e76ac2bfSKalle Valo
2665e76ac2bfSKalle Valo if (!packet)
2666e76ac2bfSKalle Valo return -ENOMEM;
2667e76ac2bfSKalle Valo
2668e76ac2bfSKalle Valo /* we controlled the buffer creation so it's properly aligned */
2669e76ac2bfSKalle Valo rdy_msg = (struct htc_ready_ext_msg *)packet->buf;
2670e76ac2bfSKalle Valo
2671e76ac2bfSKalle Valo if ((le16_to_cpu(rdy_msg->ver2_0_info.msg_id) != HTC_MSG_READY_ID) ||
2672e76ac2bfSKalle Valo (packet->act_len < sizeof(struct htc_ready_msg))) {
2673e76ac2bfSKalle Valo status = -ENOMEM;
2674e76ac2bfSKalle Valo goto fail_wait_target;
2675e76ac2bfSKalle Valo }
2676e76ac2bfSKalle Valo
2677e76ac2bfSKalle Valo if (!rdy_msg->ver2_0_info.cred_cnt || !rdy_msg->ver2_0_info.cred_sz) {
2678e76ac2bfSKalle Valo status = -ENOMEM;
2679e76ac2bfSKalle Valo goto fail_wait_target;
2680e76ac2bfSKalle Valo }
2681e76ac2bfSKalle Valo
2682e76ac2bfSKalle Valo target->tgt_creds = le16_to_cpu(rdy_msg->ver2_0_info.cred_cnt);
2683e76ac2bfSKalle Valo target->tgt_cred_sz = le16_to_cpu(rdy_msg->ver2_0_info.cred_sz);
2684e76ac2bfSKalle Valo
2685e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_BOOT,
2686e76ac2bfSKalle Valo "htc target ready credits %d size %d\n",
2687e76ac2bfSKalle Valo target->tgt_creds, target->tgt_cred_sz);
2688e76ac2bfSKalle Valo
2689e76ac2bfSKalle Valo /* check if this is an extended ready message */
2690e76ac2bfSKalle Valo if (packet->act_len >= sizeof(struct htc_ready_ext_msg)) {
2691e76ac2bfSKalle Valo /* this is an extended message */
2692e76ac2bfSKalle Valo target->htc_tgt_ver = rdy_msg->htc_ver;
2693e76ac2bfSKalle Valo target->msg_per_bndl_max = rdy_msg->msg_per_htc_bndl;
2694e76ac2bfSKalle Valo } else {
2695e76ac2bfSKalle Valo /* legacy */
2696e76ac2bfSKalle Valo target->htc_tgt_ver = HTC_VERSION_2P0;
2697e76ac2bfSKalle Valo target->msg_per_bndl_max = 0;
2698e76ac2bfSKalle Valo }
2699e76ac2bfSKalle Valo
2700e76ac2bfSKalle Valo ath6kl_dbg(ATH6KL_DBG_BOOT, "htc using protocol %s (%d)\n",
2701e76ac2bfSKalle Valo (target->htc_tgt_ver == HTC_VERSION_2P0) ? "2.0" : ">= 2.1",
2702e76ac2bfSKalle Valo target->htc_tgt_ver);
2703e76ac2bfSKalle Valo
2704e76ac2bfSKalle Valo if (target->msg_per_bndl_max > 0)
2705e76ac2bfSKalle Valo htc_setup_msg_bndl(target);
2706e76ac2bfSKalle Valo
2707e76ac2bfSKalle Valo /* setup our pseudo HTC control endpoint connection */
2708e76ac2bfSKalle Valo memset(&connect, 0, sizeof(connect));
2709e76ac2bfSKalle Valo memset(&resp, 0, sizeof(resp));
2710e76ac2bfSKalle Valo connect.ep_cb.rx = htc_ctrl_rx;
2711e76ac2bfSKalle Valo connect.ep_cb.rx_refill = NULL;
2712e76ac2bfSKalle Valo connect.ep_cb.tx_full = NULL;
2713e76ac2bfSKalle Valo connect.max_txq_depth = NUM_CONTROL_BUFFERS;
2714e76ac2bfSKalle Valo connect.svc_id = HTC_CTRL_RSVD_SVC;
2715e76ac2bfSKalle Valo
2716e76ac2bfSKalle Valo /* connect fake service */
2717e76ac2bfSKalle Valo status = ath6kl_htc_mbox_conn_service((void *)target, &connect, &resp);
2718e76ac2bfSKalle Valo
2719e76ac2bfSKalle Valo if (status)
2720e76ac2bfSKalle Valo /*
2721e76ac2bfSKalle Valo * FIXME: this call doesn't make sense, the caller should
2722e76ac2bfSKalle Valo * call ath6kl_htc_mbox_cleanup() when it wants remove htc
2723e76ac2bfSKalle Valo */
2724e76ac2bfSKalle Valo ath6kl_hif_cleanup_scatter(target->dev->ar);
2725e76ac2bfSKalle Valo
2726e76ac2bfSKalle Valo fail_wait_target:
2727e76ac2bfSKalle Valo if (packet) {
2728e76ac2bfSKalle Valo htc_rxpkt_reset(packet);
2729e76ac2bfSKalle Valo reclaim_rx_ctrl_buf(target, packet);
2730e76ac2bfSKalle Valo }
2731e76ac2bfSKalle Valo
2732e76ac2bfSKalle Valo return status;
2733e76ac2bfSKalle Valo }
2734e76ac2bfSKalle Valo
2735e76ac2bfSKalle Valo /*
2736e76ac2bfSKalle Valo * Start HTC, enable interrupts and let the target know
2737e76ac2bfSKalle Valo * host has finished setup.
2738e76ac2bfSKalle Valo */
ath6kl_htc_mbox_start(struct htc_target * target)2739e76ac2bfSKalle Valo static int ath6kl_htc_mbox_start(struct htc_target *target)
2740e76ac2bfSKalle Valo {
2741e76ac2bfSKalle Valo struct htc_packet *packet;
2742e76ac2bfSKalle Valo int status;
2743e76ac2bfSKalle Valo
2744e76ac2bfSKalle Valo memset(&target->dev->irq_proc_reg, 0,
2745e76ac2bfSKalle Valo sizeof(target->dev->irq_proc_reg));
2746e76ac2bfSKalle Valo
2747e76ac2bfSKalle Valo /* Disable interrupts at the chip level */
2748e76ac2bfSKalle Valo ath6kl_hif_disable_intrs(target->dev);
2749e76ac2bfSKalle Valo
2750e76ac2bfSKalle Valo target->htc_flags = 0;
2751e76ac2bfSKalle Valo target->rx_st_flags = 0;
2752e76ac2bfSKalle Valo
2753e76ac2bfSKalle Valo /* Push control receive buffers into htc control endpoint */
2754e76ac2bfSKalle Valo while ((packet = htc_get_control_buf(target, false)) != NULL) {
2755e76ac2bfSKalle Valo status = htc_add_rxbuf(target, packet);
2756e76ac2bfSKalle Valo if (status)
2757e76ac2bfSKalle Valo return status;
2758e76ac2bfSKalle Valo }
2759e76ac2bfSKalle Valo
2760e76ac2bfSKalle Valo /* NOTE: the first entry in the distribution list is ENDPOINT_0 */
2761e76ac2bfSKalle Valo ath6kl_credit_init(target->credit_info, &target->cred_dist_list,
2762e76ac2bfSKalle Valo target->tgt_creds);
2763e76ac2bfSKalle Valo
2764e76ac2bfSKalle Valo dump_cred_dist_stats(target);
2765e76ac2bfSKalle Valo
2766e76ac2bfSKalle Valo /* Indicate to the target of the setup completion */
2767e76ac2bfSKalle Valo status = htc_setup_tx_complete(target);
2768e76ac2bfSKalle Valo
2769e76ac2bfSKalle Valo if (status)
2770e76ac2bfSKalle Valo return status;
2771e76ac2bfSKalle Valo
2772e76ac2bfSKalle Valo /* unmask interrupts */
2773e76ac2bfSKalle Valo status = ath6kl_hif_unmask_intrs(target->dev);
2774e76ac2bfSKalle Valo
2775e76ac2bfSKalle Valo if (status)
2776e76ac2bfSKalle Valo ath6kl_htc_mbox_stop(target);
2777e76ac2bfSKalle Valo
2778e76ac2bfSKalle Valo return status;
2779e76ac2bfSKalle Valo }
2780e76ac2bfSKalle Valo
ath6kl_htc_reset(struct htc_target * target)2781e76ac2bfSKalle Valo static int ath6kl_htc_reset(struct htc_target *target)
2782e76ac2bfSKalle Valo {
2783e76ac2bfSKalle Valo u32 block_size, ctrl_bufsz;
2784e76ac2bfSKalle Valo struct htc_packet *packet;
2785e76ac2bfSKalle Valo int i;
2786e76ac2bfSKalle Valo
2787e76ac2bfSKalle Valo reset_ep_state(target);
2788e76ac2bfSKalle Valo
2789e76ac2bfSKalle Valo block_size = target->dev->ar->mbox_info.block_size;
2790e76ac2bfSKalle Valo
2791e76ac2bfSKalle Valo ctrl_bufsz = (block_size > HTC_MAX_CTRL_MSG_LEN) ?
2792e76ac2bfSKalle Valo (block_size + HTC_HDR_LENGTH) :
2793e76ac2bfSKalle Valo (HTC_MAX_CTRL_MSG_LEN + HTC_HDR_LENGTH);
2794e76ac2bfSKalle Valo
2795e76ac2bfSKalle Valo for (i = 0; i < NUM_CONTROL_BUFFERS; i++) {
2796e76ac2bfSKalle Valo packet = kzalloc(sizeof(*packet), GFP_KERNEL);
2797e76ac2bfSKalle Valo if (!packet)
2798e76ac2bfSKalle Valo return -ENOMEM;
2799e76ac2bfSKalle Valo
2800e76ac2bfSKalle Valo packet->buf_start = kzalloc(ctrl_bufsz, GFP_KERNEL);
2801e76ac2bfSKalle Valo if (!packet->buf_start) {
2802e76ac2bfSKalle Valo kfree(packet);
2803e76ac2bfSKalle Valo return -ENOMEM;
2804e76ac2bfSKalle Valo }
2805e76ac2bfSKalle Valo
2806e76ac2bfSKalle Valo packet->buf_len = ctrl_bufsz;
2807e76ac2bfSKalle Valo if (i < NUM_CONTROL_RX_BUFFERS) {
2808e76ac2bfSKalle Valo packet->act_len = 0;
2809e76ac2bfSKalle Valo packet->buf = packet->buf_start;
2810e76ac2bfSKalle Valo packet->endpoint = ENDPOINT_0;
2811e76ac2bfSKalle Valo list_add_tail(&packet->list, &target->free_ctrl_rxbuf);
2812a5d8f9dfSKalle Valo } else {
2813e76ac2bfSKalle Valo list_add_tail(&packet->list, &target->free_ctrl_txbuf);
2814e76ac2bfSKalle Valo }
2815a5d8f9dfSKalle Valo }
2816e76ac2bfSKalle Valo
2817e76ac2bfSKalle Valo return 0;
2818e76ac2bfSKalle Valo }
2819e76ac2bfSKalle Valo
2820e76ac2bfSKalle Valo /* htc_stop: stop interrupt reception, and flush all queued buffers */
ath6kl_htc_mbox_stop(struct htc_target * target)2821e76ac2bfSKalle Valo static void ath6kl_htc_mbox_stop(struct htc_target *target)
2822e76ac2bfSKalle Valo {
2823e76ac2bfSKalle Valo spin_lock_bh(&target->htc_lock);
2824e76ac2bfSKalle Valo target->htc_flags |= HTC_OP_STATE_STOPPING;
2825e76ac2bfSKalle Valo spin_unlock_bh(&target->htc_lock);
2826e76ac2bfSKalle Valo
2827e76ac2bfSKalle Valo /*
2828e76ac2bfSKalle Valo * Masking interrupts is a synchronous operation, when this
2829e76ac2bfSKalle Valo * function returns all pending HIF I/O has completed, we can
2830e76ac2bfSKalle Valo * safely flush the queues.
2831e76ac2bfSKalle Valo */
2832e76ac2bfSKalle Valo ath6kl_hif_mask_intrs(target->dev);
2833e76ac2bfSKalle Valo
2834e76ac2bfSKalle Valo ath6kl_htc_flush_txep_all(target);
2835e76ac2bfSKalle Valo
2836e76ac2bfSKalle Valo ath6kl_htc_mbox_flush_rx_buf(target);
2837e76ac2bfSKalle Valo
2838e76ac2bfSKalle Valo ath6kl_htc_reset(target);
2839e76ac2bfSKalle Valo }
2840e76ac2bfSKalle Valo
ath6kl_htc_mbox_create(struct ath6kl * ar)2841e76ac2bfSKalle Valo static void *ath6kl_htc_mbox_create(struct ath6kl *ar)
2842e76ac2bfSKalle Valo {
2843e76ac2bfSKalle Valo struct htc_target *target = NULL;
2844e76ac2bfSKalle Valo int status = 0;
2845e76ac2bfSKalle Valo
2846e76ac2bfSKalle Valo target = kzalloc(sizeof(*target), GFP_KERNEL);
2847e76ac2bfSKalle Valo if (!target) {
2848e76ac2bfSKalle Valo ath6kl_err("unable to allocate memory\n");
2849e76ac2bfSKalle Valo return NULL;
2850e76ac2bfSKalle Valo }
2851e76ac2bfSKalle Valo
2852e76ac2bfSKalle Valo target->dev = kzalloc(sizeof(*target->dev), GFP_KERNEL);
2853e76ac2bfSKalle Valo if (!target->dev) {
2854e76ac2bfSKalle Valo ath6kl_err("unable to allocate memory\n");
28550e7bf23eSJia-Ju Bai kfree(target);
28560e7bf23eSJia-Ju Bai return NULL;
2857e76ac2bfSKalle Valo }
2858e76ac2bfSKalle Valo
2859e76ac2bfSKalle Valo spin_lock_init(&target->htc_lock);
2860e76ac2bfSKalle Valo spin_lock_init(&target->rx_lock);
2861e76ac2bfSKalle Valo spin_lock_init(&target->tx_lock);
2862e76ac2bfSKalle Valo
2863e76ac2bfSKalle Valo INIT_LIST_HEAD(&target->free_ctrl_txbuf);
2864e76ac2bfSKalle Valo INIT_LIST_HEAD(&target->free_ctrl_rxbuf);
2865e76ac2bfSKalle Valo INIT_LIST_HEAD(&target->cred_dist_list);
2866e76ac2bfSKalle Valo
2867e76ac2bfSKalle Valo target->dev->ar = ar;
2868e76ac2bfSKalle Valo target->dev->htc_cnxt = target;
2869e76ac2bfSKalle Valo target->ep_waiting = ENDPOINT_MAX;
2870e76ac2bfSKalle Valo
2871e76ac2bfSKalle Valo status = ath6kl_hif_setup(target->dev);
2872e76ac2bfSKalle Valo if (status)
2873e76ac2bfSKalle Valo goto err_htc_cleanup;
2874e76ac2bfSKalle Valo
2875e76ac2bfSKalle Valo status = ath6kl_htc_reset(target);
2876e76ac2bfSKalle Valo if (status)
2877e76ac2bfSKalle Valo goto err_htc_cleanup;
2878e76ac2bfSKalle Valo
2879e76ac2bfSKalle Valo return target;
2880e76ac2bfSKalle Valo
2881e76ac2bfSKalle Valo err_htc_cleanup:
2882e76ac2bfSKalle Valo ath6kl_htc_mbox_cleanup(target);
2883e76ac2bfSKalle Valo
2884e76ac2bfSKalle Valo return NULL;
2885e76ac2bfSKalle Valo }
2886e76ac2bfSKalle Valo
2887e76ac2bfSKalle Valo /* cleanup the HTC instance */
ath6kl_htc_mbox_cleanup(struct htc_target * target)2888e76ac2bfSKalle Valo static void ath6kl_htc_mbox_cleanup(struct htc_target *target)
2889e76ac2bfSKalle Valo {
2890e76ac2bfSKalle Valo struct htc_packet *packet, *tmp_packet;
2891e76ac2bfSKalle Valo
2892e76ac2bfSKalle Valo ath6kl_hif_cleanup_scatter(target->dev->ar);
2893e76ac2bfSKalle Valo
2894e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_packet,
2895e76ac2bfSKalle Valo &target->free_ctrl_txbuf, list) {
2896e76ac2bfSKalle Valo list_del(&packet->list);
2897e76ac2bfSKalle Valo kfree(packet->buf_start);
2898e76ac2bfSKalle Valo kfree(packet);
2899e76ac2bfSKalle Valo }
2900e76ac2bfSKalle Valo
2901e76ac2bfSKalle Valo list_for_each_entry_safe(packet, tmp_packet,
2902e76ac2bfSKalle Valo &target->free_ctrl_rxbuf, list) {
2903e76ac2bfSKalle Valo list_del(&packet->list);
2904e76ac2bfSKalle Valo kfree(packet->buf_start);
2905e76ac2bfSKalle Valo kfree(packet);
2906e76ac2bfSKalle Valo }
2907e76ac2bfSKalle Valo
2908e76ac2bfSKalle Valo kfree(target->dev);
2909e76ac2bfSKalle Valo kfree(target);
2910e76ac2bfSKalle Valo }
2911e76ac2bfSKalle Valo
2912e76ac2bfSKalle Valo static const struct ath6kl_htc_ops ath6kl_htc_mbox_ops = {
2913e76ac2bfSKalle Valo .create = ath6kl_htc_mbox_create,
2914e76ac2bfSKalle Valo .wait_target = ath6kl_htc_mbox_wait_target,
2915e76ac2bfSKalle Valo .start = ath6kl_htc_mbox_start,
2916e76ac2bfSKalle Valo .conn_service = ath6kl_htc_mbox_conn_service,
2917e76ac2bfSKalle Valo .tx = ath6kl_htc_mbox_tx,
2918e76ac2bfSKalle Valo .stop = ath6kl_htc_mbox_stop,
2919e76ac2bfSKalle Valo .cleanup = ath6kl_htc_mbox_cleanup,
2920e76ac2bfSKalle Valo .flush_txep = ath6kl_htc_mbox_flush_txep,
2921e76ac2bfSKalle Valo .flush_rx_buf = ath6kl_htc_mbox_flush_rx_buf,
2922e76ac2bfSKalle Valo .activity_changed = ath6kl_htc_mbox_activity_changed,
2923e76ac2bfSKalle Valo .get_rxbuf_num = ath6kl_htc_mbox_get_rxbuf_num,
2924e76ac2bfSKalle Valo .add_rxbuf_multiple = ath6kl_htc_mbox_add_rxbuf_multiple,
2925e76ac2bfSKalle Valo .credit_setup = ath6kl_htc_mbox_credit_setup,
2926e76ac2bfSKalle Valo };
2927e76ac2bfSKalle Valo
ath6kl_htc_mbox_attach(struct ath6kl * ar)2928e76ac2bfSKalle Valo void ath6kl_htc_mbox_attach(struct ath6kl *ar)
2929e76ac2bfSKalle Valo {
2930e76ac2bfSKalle Valo ar->htc_ops = &ath6kl_htc_mbox_ops;
2931e76ac2bfSKalle Valo }
2932