1 // SPDX-License-Identifier: ISC
2 /*
3 * Copyright (c) 2005-2011 Atheros Communications Inc.
4 * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
5 */
6
7 #include "core.h"
8 #include "hif.h"
9 #include "debug.h"
10
11 /********/
12 /* Send */
13 /********/
14
ath10k_htc_control_tx_complete(struct ath10k * ar,struct sk_buff * skb)15 static void ath10k_htc_control_tx_complete(struct ath10k *ar,
16 struct sk_buff *skb)
17 {
18 kfree_skb(skb);
19 }
20
ath10k_htc_build_tx_ctrl_skb(void * ar)21 static struct sk_buff *ath10k_htc_build_tx_ctrl_skb(void *ar)
22 {
23 struct sk_buff *skb;
24 struct ath10k_skb_cb *skb_cb;
25
26 skb = dev_alloc_skb(ATH10K_HTC_CONTROL_BUFFER_SIZE);
27 if (!skb)
28 return NULL;
29
30 skb_reserve(skb, 20); /* FIXME: why 20 bytes? */
31 WARN_ONCE((unsigned long)skb->data & 3, "unaligned skb");
32
33 skb_cb = ATH10K_SKB_CB(skb);
34 memset(skb_cb, 0, sizeof(*skb_cb));
35
36 ath10k_dbg(ar, ATH10K_DBG_HTC, "%s: skb %pK\n", __func__, skb);
37 return skb;
38 }
39
ath10k_htc_restore_tx_skb(struct ath10k_htc * htc,struct sk_buff * skb)40 static inline void ath10k_htc_restore_tx_skb(struct ath10k_htc *htc,
41 struct sk_buff *skb)
42 {
43 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
44
45 if (htc->ar->bus_param.dev_type != ATH10K_DEV_TYPE_HL)
46 dma_unmap_single(htc->ar->dev, skb_cb->paddr, skb->len, DMA_TO_DEVICE);
47 skb_pull(skb, sizeof(struct ath10k_htc_hdr));
48 }
49
ath10k_htc_notify_tx_completion(struct ath10k_htc_ep * ep,struct sk_buff * skb)50 void ath10k_htc_notify_tx_completion(struct ath10k_htc_ep *ep,
51 struct sk_buff *skb)
52 {
53 struct ath10k *ar = ep->htc->ar;
54 struct ath10k_htc_hdr *hdr;
55
56 ath10k_dbg(ar, ATH10K_DBG_HTC, "%s: ep %d skb %pK\n", __func__,
57 ep->eid, skb);
58
59 /* A corner case where the copy completion is reaching to host but still
60 * copy engine is processing it due to which host unmaps corresponding
61 * memory and causes SMMU fault, hence as workaround adding delay
62 * the unmapping memory to avoid SMMU faults.
63 */
64 if (ar->hw_params.delay_unmap_buffer &&
65 ep->ul_pipe_id == 3)
66 mdelay(2);
67
68 hdr = (struct ath10k_htc_hdr *)skb->data;
69 ath10k_htc_restore_tx_skb(ep->htc, skb);
70
71 if (!ep->ep_ops.ep_tx_complete) {
72 ath10k_warn(ar, "no tx handler for eid %d\n", ep->eid);
73 dev_kfree_skb_any(skb);
74 return;
75 }
76
77 if (hdr->flags & ATH10K_HTC_FLAG_SEND_BUNDLE) {
78 dev_kfree_skb_any(skb);
79 return;
80 }
81
82 ep->ep_ops.ep_tx_complete(ep->htc->ar, skb);
83 }
84 EXPORT_SYMBOL(ath10k_htc_notify_tx_completion);
85
ath10k_htc_prepare_tx_skb(struct ath10k_htc_ep * ep,struct sk_buff * skb)86 static void ath10k_htc_prepare_tx_skb(struct ath10k_htc_ep *ep,
87 struct sk_buff *skb)
88 {
89 struct ath10k_htc_hdr *hdr;
90
91 hdr = (struct ath10k_htc_hdr *)skb->data;
92 memset(hdr, 0, sizeof(struct ath10k_htc_hdr));
93
94 hdr->eid = ep->eid;
95 hdr->len = __cpu_to_le16(skb->len - sizeof(*hdr));
96 hdr->flags = 0;
97 if (ep->tx_credit_flow_enabled && !ep->bundle_tx)
98 hdr->flags |= ATH10K_HTC_FLAG_NEED_CREDIT_UPDATE;
99
100 spin_lock_bh(&ep->htc->tx_lock);
101 hdr->seq_no = ep->seq_no++;
102 spin_unlock_bh(&ep->htc->tx_lock);
103 }
104
ath10k_htc_consume_credit(struct ath10k_htc_ep * ep,unsigned int len,bool consume)105 static int ath10k_htc_consume_credit(struct ath10k_htc_ep *ep,
106 unsigned int len,
107 bool consume)
108 {
109 struct ath10k_htc *htc = ep->htc;
110 struct ath10k *ar = htc->ar;
111 enum ath10k_htc_ep_id eid = ep->eid;
112 int credits, ret = 0;
113
114 if (!ep->tx_credit_flow_enabled)
115 return 0;
116
117 credits = DIV_ROUND_UP(len, ep->tx_credit_size);
118 spin_lock_bh(&htc->tx_lock);
119
120 if (ep->tx_credits < credits) {
121 ath10k_dbg(ar, ATH10K_DBG_HTC,
122 "htc insufficient credits ep %d required %d available %d consume %d\n",
123 eid, credits, ep->tx_credits, consume);
124 ret = -EAGAIN;
125 goto unlock;
126 }
127
128 if (consume) {
129 ep->tx_credits -= credits;
130 ath10k_dbg(ar, ATH10K_DBG_HTC,
131 "htc ep %d consumed %d credits total %d\n",
132 eid, credits, ep->tx_credits);
133 }
134
135 unlock:
136 spin_unlock_bh(&htc->tx_lock);
137 return ret;
138 }
139
ath10k_htc_release_credit(struct ath10k_htc_ep * ep,unsigned int len)140 static void ath10k_htc_release_credit(struct ath10k_htc_ep *ep, unsigned int len)
141 {
142 struct ath10k_htc *htc = ep->htc;
143 struct ath10k *ar = htc->ar;
144 enum ath10k_htc_ep_id eid = ep->eid;
145 int credits;
146
147 if (!ep->tx_credit_flow_enabled)
148 return;
149
150 credits = DIV_ROUND_UP(len, ep->tx_credit_size);
151 spin_lock_bh(&htc->tx_lock);
152 ep->tx_credits += credits;
153 ath10k_dbg(ar, ATH10K_DBG_HTC,
154 "htc ep %d reverted %d credits back total %d\n",
155 eid, credits, ep->tx_credits);
156 spin_unlock_bh(&htc->tx_lock);
157
158 if (ep->ep_ops.ep_tx_credits)
159 ep->ep_ops.ep_tx_credits(htc->ar);
160 }
161
ath10k_htc_send(struct ath10k_htc * htc,enum ath10k_htc_ep_id eid,struct sk_buff * skb)162 int ath10k_htc_send(struct ath10k_htc *htc,
163 enum ath10k_htc_ep_id eid,
164 struct sk_buff *skb)
165 {
166 struct ath10k *ar = htc->ar;
167 struct ath10k_htc_ep *ep = &htc->endpoint[eid];
168 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
169 struct ath10k_hif_sg_item sg_item;
170 struct device *dev = htc->ar->dev;
171 int ret;
172 unsigned int skb_len;
173
174 if (htc->ar->state == ATH10K_STATE_WEDGED)
175 return -ECOMM;
176
177 if (eid >= ATH10K_HTC_EP_COUNT) {
178 ath10k_warn(ar, "Invalid endpoint id: %d\n", eid);
179 return -ENOENT;
180 }
181
182 skb_push(skb, sizeof(struct ath10k_htc_hdr));
183
184 skb_len = skb->len;
185 ret = ath10k_htc_consume_credit(ep, skb_len, true);
186 if (ret)
187 goto err_pull;
188
189 ath10k_htc_prepare_tx_skb(ep, skb);
190
191 skb_cb->eid = eid;
192 if (ar->bus_param.dev_type != ATH10K_DEV_TYPE_HL) {
193 skb_cb->paddr = dma_map_single(dev, skb->data, skb->len,
194 DMA_TO_DEVICE);
195 ret = dma_mapping_error(dev, skb_cb->paddr);
196 if (ret) {
197 ret = -EIO;
198 goto err_credits;
199 }
200 }
201
202 sg_item.transfer_id = ep->eid;
203 sg_item.transfer_context = skb;
204 sg_item.vaddr = skb->data;
205 sg_item.paddr = skb_cb->paddr;
206 sg_item.len = skb->len;
207
208 ret = ath10k_hif_tx_sg(htc->ar, ep->ul_pipe_id, &sg_item, 1);
209 if (ret)
210 goto err_unmap;
211
212 return 0;
213
214 err_unmap:
215 if (ar->bus_param.dev_type != ATH10K_DEV_TYPE_HL)
216 dma_unmap_single(dev, skb_cb->paddr, skb->len, DMA_TO_DEVICE);
217 err_credits:
218 ath10k_htc_release_credit(ep, skb_len);
219 err_pull:
220 skb_pull(skb, sizeof(struct ath10k_htc_hdr));
221 return ret;
222 }
223
ath10k_htc_tx_completion_handler(struct ath10k * ar,struct sk_buff * skb)224 void ath10k_htc_tx_completion_handler(struct ath10k *ar, struct sk_buff *skb)
225 {
226 struct ath10k_htc *htc = &ar->htc;
227 struct ath10k_skb_cb *skb_cb;
228 struct ath10k_htc_ep *ep;
229
230 if (WARN_ON_ONCE(!skb))
231 return;
232
233 skb_cb = ATH10K_SKB_CB(skb);
234 ep = &htc->endpoint[skb_cb->eid];
235
236 ath10k_htc_notify_tx_completion(ep, skb);
237 /* the skb now belongs to the completion handler */
238 }
239 EXPORT_SYMBOL(ath10k_htc_tx_completion_handler);
240
241 /***********/
242 /* Receive */
243 /***********/
244
245 static void
ath10k_htc_process_credit_report(struct ath10k_htc * htc,const struct ath10k_htc_credit_report * report,int len,enum ath10k_htc_ep_id eid)246 ath10k_htc_process_credit_report(struct ath10k_htc *htc,
247 const struct ath10k_htc_credit_report *report,
248 int len,
249 enum ath10k_htc_ep_id eid)
250 {
251 struct ath10k *ar = htc->ar;
252 struct ath10k_htc_ep *ep;
253 int i, n_reports;
254
255 if (len % sizeof(*report))
256 ath10k_warn(ar, "Uneven credit report len %d", len);
257
258 n_reports = len / sizeof(*report);
259
260 spin_lock_bh(&htc->tx_lock);
261 for (i = 0; i < n_reports; i++, report++) {
262 if (report->eid >= ATH10K_HTC_EP_COUNT)
263 break;
264
265 ep = &htc->endpoint[report->eid];
266 ep->tx_credits += report->credits;
267
268 ath10k_dbg(ar, ATH10K_DBG_HTC, "htc ep %d got %d credits (total %d)\n",
269 report->eid, report->credits, ep->tx_credits);
270
271 if (ep->ep_ops.ep_tx_credits) {
272 spin_unlock_bh(&htc->tx_lock);
273 ep->ep_ops.ep_tx_credits(htc->ar);
274 spin_lock_bh(&htc->tx_lock);
275 }
276 }
277 spin_unlock_bh(&htc->tx_lock);
278 }
279
280 static int
ath10k_htc_process_lookahead(struct ath10k_htc * htc,const struct ath10k_htc_lookahead_report * report,int len,enum ath10k_htc_ep_id eid,void * next_lookaheads,int * next_lookaheads_len)281 ath10k_htc_process_lookahead(struct ath10k_htc *htc,
282 const struct ath10k_htc_lookahead_report *report,
283 int len,
284 enum ath10k_htc_ep_id eid,
285 void *next_lookaheads,
286 int *next_lookaheads_len)
287 {
288 struct ath10k *ar = htc->ar;
289
290 /* Invalid lookahead flags are actually transmitted by
291 * the target in the HTC control message.
292 * Since this will happen at every boot we silently ignore
293 * the lookahead in this case
294 */
295 if (report->pre_valid != ((~report->post_valid) & 0xFF))
296 return 0;
297
298 if (next_lookaheads && next_lookaheads_len) {
299 ath10k_dbg(ar, ATH10K_DBG_HTC,
300 "htc rx lookahead found pre_valid 0x%x post_valid 0x%x\n",
301 report->pre_valid, report->post_valid);
302
303 /* look ahead bytes are valid, copy them over */
304 memcpy((u8 *)next_lookaheads, report->lookahead, 4);
305
306 *next_lookaheads_len = 1;
307 }
308
309 return 0;
310 }
311
312 static int
ath10k_htc_process_lookahead_bundle(struct ath10k_htc * htc,const struct ath10k_htc_lookahead_bundle * report,int len,enum ath10k_htc_ep_id eid,void * next_lookaheads,int * next_lookaheads_len)313 ath10k_htc_process_lookahead_bundle(struct ath10k_htc *htc,
314 const struct ath10k_htc_lookahead_bundle *report,
315 int len,
316 enum ath10k_htc_ep_id eid,
317 void *next_lookaheads,
318 int *next_lookaheads_len)
319 {
320 struct ath10k *ar = htc->ar;
321 int bundle_cnt = len / sizeof(*report);
322
323 if (!bundle_cnt || (bundle_cnt > htc->max_msgs_per_htc_bundle)) {
324 ath10k_warn(ar, "Invalid lookahead bundle count: %d\n",
325 bundle_cnt);
326 return -EINVAL;
327 }
328
329 if (next_lookaheads && next_lookaheads_len) {
330 int i;
331
332 for (i = 0; i < bundle_cnt; i++) {
333 memcpy(((u8 *)next_lookaheads) + 4 * i,
334 report->lookahead, 4);
335 report++;
336 }
337
338 *next_lookaheads_len = bundle_cnt;
339 }
340
341 return 0;
342 }
343
ath10k_htc_process_trailer(struct ath10k_htc * htc,u8 * buffer,int length,enum ath10k_htc_ep_id src_eid,void * next_lookaheads,int * next_lookaheads_len)344 int ath10k_htc_process_trailer(struct ath10k_htc *htc,
345 u8 *buffer,
346 int length,
347 enum ath10k_htc_ep_id src_eid,
348 void *next_lookaheads,
349 int *next_lookaheads_len)
350 {
351 struct ath10k_htc_lookahead_bundle *bundle;
352 struct ath10k *ar = htc->ar;
353 int status = 0;
354 struct ath10k_htc_record *record;
355 u8 *orig_buffer;
356 int orig_length;
357 size_t len;
358
359 orig_buffer = buffer;
360 orig_length = length;
361
362 while (length > 0) {
363 record = (struct ath10k_htc_record *)buffer;
364
365 if (length < sizeof(record->hdr)) {
366 status = -EINVAL;
367 break;
368 }
369
370 if (record->hdr.len > length) {
371 /* no room left in buffer for record */
372 ath10k_warn(ar, "Invalid record length: %d\n",
373 record->hdr.len);
374 status = -EINVAL;
375 break;
376 }
377
378 switch (record->hdr.id) {
379 case ATH10K_HTC_RECORD_CREDITS:
380 len = sizeof(struct ath10k_htc_credit_report);
381 if (record->hdr.len < len) {
382 ath10k_warn(ar, "Credit report too long\n");
383 status = -EINVAL;
384 break;
385 }
386 ath10k_htc_process_credit_report(htc,
387 record->credit_report,
388 record->hdr.len,
389 src_eid);
390 break;
391 case ATH10K_HTC_RECORD_LOOKAHEAD:
392 len = sizeof(struct ath10k_htc_lookahead_report);
393 if (record->hdr.len < len) {
394 ath10k_warn(ar, "Lookahead report too long\n");
395 status = -EINVAL;
396 break;
397 }
398 status = ath10k_htc_process_lookahead(htc,
399 record->lookahead_report,
400 record->hdr.len,
401 src_eid,
402 next_lookaheads,
403 next_lookaheads_len);
404 break;
405 case ATH10K_HTC_RECORD_LOOKAHEAD_BUNDLE:
406 bundle = record->lookahead_bundle;
407 status = ath10k_htc_process_lookahead_bundle(htc,
408 bundle,
409 record->hdr.len,
410 src_eid,
411 next_lookaheads,
412 next_lookaheads_len);
413 break;
414 default:
415 ath10k_warn(ar, "Unhandled record: id:%d length:%d\n",
416 record->hdr.id, record->hdr.len);
417 break;
418 }
419
420 if (status)
421 break;
422
423 /* multiple records may be present in a trailer */
424 buffer += sizeof(record->hdr) + record->hdr.len;
425 length -= sizeof(record->hdr) + record->hdr.len;
426 }
427
428 if (status)
429 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc rx bad trailer", "",
430 orig_buffer, orig_length);
431
432 return status;
433 }
434 EXPORT_SYMBOL(ath10k_htc_process_trailer);
435
ath10k_htc_rx_completion_handler(struct ath10k * ar,struct sk_buff * skb)436 void ath10k_htc_rx_completion_handler(struct ath10k *ar, struct sk_buff *skb)
437 {
438 int status = 0;
439 struct ath10k_htc *htc = &ar->htc;
440 struct ath10k_htc_hdr *hdr;
441 struct ath10k_htc_ep *ep;
442 u16 payload_len;
443 u32 trailer_len = 0;
444 size_t min_len;
445 u8 eid;
446 bool trailer_present;
447
448 hdr = (struct ath10k_htc_hdr *)skb->data;
449 skb_pull(skb, sizeof(*hdr));
450
451 eid = hdr->eid;
452
453 if (eid >= ATH10K_HTC_EP_COUNT) {
454 ath10k_warn(ar, "HTC Rx: invalid eid %d\n", eid);
455 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad header", "",
456 hdr, sizeof(*hdr));
457 goto out;
458 }
459
460 ep = &htc->endpoint[eid];
461 if (ep->service_id == ATH10K_HTC_SVC_ID_UNUSED) {
462 ath10k_warn(ar, "htc rx endpoint %d is not connected\n", eid);
463 goto out;
464 }
465
466 payload_len = __le16_to_cpu(hdr->len);
467
468 if (payload_len + sizeof(*hdr) > ATH10K_HTC_MAX_LEN) {
469 ath10k_warn(ar, "HTC rx frame too long, len: %zu\n",
470 payload_len + sizeof(*hdr));
471 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad rx pkt len", "",
472 hdr, sizeof(*hdr));
473 goto out;
474 }
475
476 if (skb->len < payload_len) {
477 ath10k_dbg(ar, ATH10K_DBG_HTC,
478 "HTC Rx: insufficient length, got %d, expected %d\n",
479 skb->len, payload_len);
480 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad rx pkt len",
481 "", hdr, sizeof(*hdr));
482 goto out;
483 }
484
485 /* get flags to check for trailer */
486 trailer_present = hdr->flags & ATH10K_HTC_FLAG_TRAILER_PRESENT;
487 if (trailer_present) {
488 u8 *trailer;
489
490 trailer_len = hdr->trailer_len;
491 min_len = sizeof(struct ath10k_ath10k_htc_record_hdr);
492
493 if ((trailer_len < min_len) ||
494 (trailer_len > payload_len)) {
495 ath10k_warn(ar, "Invalid trailer length: %d\n",
496 trailer_len);
497 goto out;
498 }
499
500 trailer = (u8 *)hdr;
501 trailer += sizeof(*hdr);
502 trailer += payload_len;
503 trailer -= trailer_len;
504 status = ath10k_htc_process_trailer(htc, trailer,
505 trailer_len, hdr->eid,
506 NULL, NULL);
507 if (status)
508 goto out;
509
510 skb_trim(skb, skb->len - trailer_len);
511 }
512
513 if (((int)payload_len - (int)trailer_len) <= 0)
514 /* zero length packet with trailer data, just drop these */
515 goto out;
516
517 ath10k_dbg(ar, ATH10K_DBG_HTC, "htc rx completion ep %d skb %pK\n",
518 eid, skb);
519 ep->ep_ops.ep_rx_complete(ar, skb);
520
521 /* skb is now owned by the rx completion handler */
522 skb = NULL;
523 out:
524 kfree_skb(skb);
525 }
526 EXPORT_SYMBOL(ath10k_htc_rx_completion_handler);
527
ath10k_htc_control_rx_complete(struct ath10k * ar,struct sk_buff * skb)528 static void ath10k_htc_control_rx_complete(struct ath10k *ar,
529 struct sk_buff *skb)
530 {
531 struct ath10k_htc *htc = &ar->htc;
532 struct ath10k_htc_msg *msg = (struct ath10k_htc_msg *)skb->data;
533
534 switch (__le16_to_cpu(msg->hdr.message_id)) {
535 case ATH10K_HTC_MSG_READY_ID:
536 case ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID:
537 /* handle HTC control message */
538 if (completion_done(&htc->ctl_resp)) {
539 /* this is a fatal error, target should not be
540 * sending unsolicited messages on the ep 0
541 */
542 ath10k_warn(ar, "HTC rx ctrl still processing\n");
543 complete(&htc->ctl_resp);
544 goto out;
545 }
546
547 htc->control_resp_len =
548 min_t(int, skb->len,
549 ATH10K_HTC_MAX_CTRL_MSG_LEN);
550
551 memcpy(htc->control_resp_buffer, skb->data,
552 htc->control_resp_len);
553
554 complete(&htc->ctl_resp);
555 break;
556 case ATH10K_HTC_MSG_SEND_SUSPEND_COMPLETE:
557 htc->htc_ops.target_send_suspend_complete(ar);
558 break;
559 default:
560 ath10k_warn(ar, "ignoring unsolicited htc ep0 event\n");
561 break;
562 }
563
564 out:
565 kfree_skb(skb);
566 }
567
568 /***************/
569 /* Init/Deinit */
570 /***************/
571
htc_service_name(enum ath10k_htc_svc_id id)572 static const char *htc_service_name(enum ath10k_htc_svc_id id)
573 {
574 switch (id) {
575 case ATH10K_HTC_SVC_ID_RESERVED:
576 return "Reserved";
577 case ATH10K_HTC_SVC_ID_RSVD_CTRL:
578 return "Control";
579 case ATH10K_HTC_SVC_ID_WMI_CONTROL:
580 return "WMI";
581 case ATH10K_HTC_SVC_ID_WMI_DATA_BE:
582 return "DATA BE";
583 case ATH10K_HTC_SVC_ID_WMI_DATA_BK:
584 return "DATA BK";
585 case ATH10K_HTC_SVC_ID_WMI_DATA_VI:
586 return "DATA VI";
587 case ATH10K_HTC_SVC_ID_WMI_DATA_VO:
588 return "DATA VO";
589 case ATH10K_HTC_SVC_ID_NMI_CONTROL:
590 return "NMI Control";
591 case ATH10K_HTC_SVC_ID_NMI_DATA:
592 return "NMI Data";
593 case ATH10K_HTC_SVC_ID_HTT_DATA_MSG:
594 return "HTT Data";
595 case ATH10K_HTC_SVC_ID_HTT_DATA2_MSG:
596 return "HTT Data";
597 case ATH10K_HTC_SVC_ID_HTT_DATA3_MSG:
598 return "HTT Data";
599 case ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS:
600 return "RAW";
601 case ATH10K_HTC_SVC_ID_HTT_LOG_MSG:
602 return "PKTLOG";
603 }
604
605 return "Unknown";
606 }
607
ath10k_htc_reset_endpoint_states(struct ath10k_htc * htc)608 static void ath10k_htc_reset_endpoint_states(struct ath10k_htc *htc)
609 {
610 struct ath10k_htc_ep *ep;
611 int i;
612
613 for (i = ATH10K_HTC_EP_0; i < ATH10K_HTC_EP_COUNT; i++) {
614 ep = &htc->endpoint[i];
615 ep->service_id = ATH10K_HTC_SVC_ID_UNUSED;
616 ep->max_ep_message_len = 0;
617 ep->max_tx_queue_depth = 0;
618 ep->eid = i;
619 ep->htc = htc;
620 ep->tx_credit_flow_enabled = true;
621 }
622 }
623
ath10k_htc_get_credit_allocation(struct ath10k_htc * htc,u16 service_id)624 static u8 ath10k_htc_get_credit_allocation(struct ath10k_htc *htc,
625 u16 service_id)
626 {
627 u8 allocation = 0;
628
629 /* The WMI control service is the only service with flow control.
630 * Let it have all transmit credits.
631 */
632 if (service_id == ATH10K_HTC_SVC_ID_WMI_CONTROL)
633 allocation = htc->total_transmit_credits;
634
635 return allocation;
636 }
637
ath10k_htc_send_bundle(struct ath10k_htc_ep * ep,struct sk_buff * bundle_skb,struct sk_buff_head * tx_save_head)638 static int ath10k_htc_send_bundle(struct ath10k_htc_ep *ep,
639 struct sk_buff *bundle_skb,
640 struct sk_buff_head *tx_save_head)
641 {
642 struct ath10k_hif_sg_item sg_item;
643 struct ath10k_htc *htc = ep->htc;
644 struct ath10k *ar = htc->ar;
645 struct sk_buff *skb;
646 int ret, cn = 0;
647 unsigned int skb_len;
648
649 ath10k_dbg(ar, ATH10K_DBG_HTC, "bundle skb len %d\n", bundle_skb->len);
650 skb_len = bundle_skb->len;
651 ret = ath10k_htc_consume_credit(ep, skb_len, true);
652
653 if (!ret) {
654 sg_item.transfer_id = ep->eid;
655 sg_item.transfer_context = bundle_skb;
656 sg_item.vaddr = bundle_skb->data;
657 sg_item.len = bundle_skb->len;
658
659 ret = ath10k_hif_tx_sg(htc->ar, ep->ul_pipe_id, &sg_item, 1);
660 if (ret)
661 ath10k_htc_release_credit(ep, skb_len);
662 }
663
664 if (ret)
665 dev_kfree_skb_any(bundle_skb);
666
667 for (cn = 0; (skb = skb_dequeue_tail(tx_save_head)); cn++) {
668 if (ret) {
669 skb_pull(skb, sizeof(struct ath10k_htc_hdr));
670 skb_queue_head(&ep->tx_req_head, skb);
671 } else {
672 skb_queue_tail(&ep->tx_complete_head, skb);
673 }
674 }
675
676 if (!ret)
677 queue_work(ar->workqueue_tx_complete, &ar->tx_complete_work);
678
679 ath10k_dbg(ar, ATH10K_DBG_HTC,
680 "bundle tx status %d eid %d req count %d count %d len %d\n",
681 ret, ep->eid, skb_queue_len(&ep->tx_req_head), cn, skb_len);
682 return ret;
683 }
684
ath10k_htc_send_one_skb(struct ath10k_htc_ep * ep,struct sk_buff * skb)685 static void ath10k_htc_send_one_skb(struct ath10k_htc_ep *ep, struct sk_buff *skb)
686 {
687 struct ath10k_htc *htc = ep->htc;
688 struct ath10k *ar = htc->ar;
689 int ret;
690
691 ret = ath10k_htc_send(htc, ep->eid, skb);
692
693 if (ret)
694 skb_queue_head(&ep->tx_req_head, skb);
695
696 ath10k_dbg(ar, ATH10K_DBG_HTC, "tx one status %d eid %d len %d pending count %d\n",
697 ret, ep->eid, skb->len, skb_queue_len(&ep->tx_req_head));
698 }
699
ath10k_htc_send_bundle_skbs(struct ath10k_htc_ep * ep)700 static int ath10k_htc_send_bundle_skbs(struct ath10k_htc_ep *ep)
701 {
702 struct ath10k_htc *htc = ep->htc;
703 struct sk_buff *bundle_skb, *skb;
704 struct sk_buff_head tx_save_head;
705 struct ath10k_htc_hdr *hdr;
706 u8 *bundle_buf;
707 int ret = 0, credit_pad, credit_remainder, trans_len, bundles_left = 0;
708
709 if (htc->ar->state == ATH10K_STATE_WEDGED)
710 return -ECOMM;
711
712 if (ep->tx_credit_flow_enabled &&
713 ep->tx_credits < ATH10K_MIN_CREDIT_PER_HTC_TX_BUNDLE)
714 return 0;
715
716 bundles_left = ATH10K_MAX_MSG_PER_HTC_TX_BUNDLE * ep->tx_credit_size;
717 bundle_skb = dev_alloc_skb(bundles_left);
718
719 if (!bundle_skb)
720 return -ENOMEM;
721
722 bundle_buf = bundle_skb->data;
723 skb_queue_head_init(&tx_save_head);
724
725 while (true) {
726 skb = skb_dequeue(&ep->tx_req_head);
727 if (!skb)
728 break;
729
730 credit_pad = 0;
731 trans_len = skb->len + sizeof(*hdr);
732 credit_remainder = trans_len % ep->tx_credit_size;
733
734 if (credit_remainder != 0) {
735 credit_pad = ep->tx_credit_size - credit_remainder;
736 trans_len += credit_pad;
737 }
738
739 ret = ath10k_htc_consume_credit(ep,
740 bundle_buf + trans_len - bundle_skb->data,
741 false);
742 if (ret) {
743 skb_queue_head(&ep->tx_req_head, skb);
744 break;
745 }
746
747 if (bundles_left < trans_len) {
748 bundle_skb->len = bundle_buf - bundle_skb->data;
749 ret = ath10k_htc_send_bundle(ep, bundle_skb, &tx_save_head);
750
751 if (ret) {
752 skb_queue_head(&ep->tx_req_head, skb);
753 return ret;
754 }
755
756 if (skb_queue_len(&ep->tx_req_head) == 0) {
757 ath10k_htc_send_one_skb(ep, skb);
758 return ret;
759 }
760
761 if (ep->tx_credit_flow_enabled &&
762 ep->tx_credits < ATH10K_MIN_CREDIT_PER_HTC_TX_BUNDLE) {
763 skb_queue_head(&ep->tx_req_head, skb);
764 return 0;
765 }
766
767 bundles_left =
768 ATH10K_MAX_MSG_PER_HTC_TX_BUNDLE * ep->tx_credit_size;
769 bundle_skb = dev_alloc_skb(bundles_left);
770
771 if (!bundle_skb) {
772 skb_queue_head(&ep->tx_req_head, skb);
773 return -ENOMEM;
774 }
775 bundle_buf = bundle_skb->data;
776 skb_queue_head_init(&tx_save_head);
777 }
778
779 skb_push(skb, sizeof(struct ath10k_htc_hdr));
780 ath10k_htc_prepare_tx_skb(ep, skb);
781
782 memcpy(bundle_buf, skb->data, skb->len);
783 hdr = (struct ath10k_htc_hdr *)bundle_buf;
784 hdr->flags |= ATH10K_HTC_FLAG_SEND_BUNDLE;
785 hdr->pad_len = __cpu_to_le16(credit_pad);
786 bundle_buf += trans_len;
787 bundles_left -= trans_len;
788 skb_queue_tail(&tx_save_head, skb);
789 }
790
791 if (bundle_buf != bundle_skb->data) {
792 bundle_skb->len = bundle_buf - bundle_skb->data;
793 ret = ath10k_htc_send_bundle(ep, bundle_skb, &tx_save_head);
794 } else {
795 dev_kfree_skb_any(bundle_skb);
796 }
797
798 return ret;
799 }
800
ath10k_htc_bundle_tx_work(struct work_struct * work)801 static void ath10k_htc_bundle_tx_work(struct work_struct *work)
802 {
803 struct ath10k *ar = container_of(work, struct ath10k, bundle_tx_work);
804 struct ath10k_htc_ep *ep;
805 struct sk_buff *skb;
806 int i;
807
808 for (i = 0; i < ARRAY_SIZE(ar->htc.endpoint); i++) {
809 ep = &ar->htc.endpoint[i];
810
811 if (!ep->bundle_tx)
812 continue;
813
814 ath10k_dbg(ar, ATH10K_DBG_HTC, "bundle tx work eid %d count %d\n",
815 ep->eid, skb_queue_len(&ep->tx_req_head));
816
817 if (skb_queue_len(&ep->tx_req_head) >=
818 ATH10K_MIN_MSG_PER_HTC_TX_BUNDLE) {
819 ath10k_htc_send_bundle_skbs(ep);
820 } else {
821 skb = skb_dequeue(&ep->tx_req_head);
822
823 if (!skb)
824 continue;
825 ath10k_htc_send_one_skb(ep, skb);
826 }
827 }
828 }
829
ath10k_htc_tx_complete_work(struct work_struct * work)830 static void ath10k_htc_tx_complete_work(struct work_struct *work)
831 {
832 struct ath10k *ar = container_of(work, struct ath10k, tx_complete_work);
833 struct ath10k_htc_ep *ep;
834 enum ath10k_htc_ep_id eid;
835 struct sk_buff *skb;
836 int i;
837
838 for (i = 0; i < ARRAY_SIZE(ar->htc.endpoint); i++) {
839 ep = &ar->htc.endpoint[i];
840 eid = ep->eid;
841 if (ep->bundle_tx && eid == ar->htt.eid) {
842 ath10k_dbg(ar, ATH10K_DBG_HTC, "bundle tx complete eid %d pending complete count%d\n",
843 ep->eid, skb_queue_len(&ep->tx_complete_head));
844
845 while (true) {
846 skb = skb_dequeue(&ep->tx_complete_head);
847 if (!skb)
848 break;
849 ath10k_htc_notify_tx_completion(ep, skb);
850 }
851 }
852 }
853 }
854
ath10k_htc_send_hl(struct ath10k_htc * htc,enum ath10k_htc_ep_id eid,struct sk_buff * skb)855 int ath10k_htc_send_hl(struct ath10k_htc *htc,
856 enum ath10k_htc_ep_id eid,
857 struct sk_buff *skb)
858 {
859 struct ath10k_htc_ep *ep = &htc->endpoint[eid];
860 struct ath10k *ar = htc->ar;
861
862 if (sizeof(struct ath10k_htc_hdr) + skb->len > ep->tx_credit_size) {
863 ath10k_dbg(ar, ATH10K_DBG_HTC, "tx exceed max len %d\n", skb->len);
864 return -ENOMEM;
865 }
866
867 ath10k_dbg(ar, ATH10K_DBG_HTC, "htc send hl eid %d bundle %d tx count %d len %d\n",
868 eid, ep->bundle_tx, skb_queue_len(&ep->tx_req_head), skb->len);
869
870 if (ep->bundle_tx) {
871 skb_queue_tail(&ep->tx_req_head, skb);
872 queue_work(ar->workqueue, &ar->bundle_tx_work);
873 return 0;
874 } else {
875 return ath10k_htc_send(htc, eid, skb);
876 }
877 }
878
ath10k_htc_setup_tx_req(struct ath10k_htc_ep * ep)879 void ath10k_htc_setup_tx_req(struct ath10k_htc_ep *ep)
880 {
881 if (ep->htc->max_msgs_per_htc_bundle >= ATH10K_MIN_MSG_PER_HTC_TX_BUNDLE &&
882 !ep->bundle_tx) {
883 ep->bundle_tx = true;
884 skb_queue_head_init(&ep->tx_req_head);
885 skb_queue_head_init(&ep->tx_complete_head);
886 }
887 }
888
ath10k_htc_stop_hl(struct ath10k * ar)889 void ath10k_htc_stop_hl(struct ath10k *ar)
890 {
891 struct ath10k_htc_ep *ep;
892 int i;
893
894 cancel_work_sync(&ar->bundle_tx_work);
895 cancel_work_sync(&ar->tx_complete_work);
896
897 for (i = 0; i < ARRAY_SIZE(ar->htc.endpoint); i++) {
898 ep = &ar->htc.endpoint[i];
899
900 if (!ep->bundle_tx)
901 continue;
902
903 ath10k_dbg(ar, ATH10K_DBG_HTC, "stop tx work eid %d count %d\n",
904 ep->eid, skb_queue_len(&ep->tx_req_head));
905
906 skb_queue_purge(&ep->tx_req_head);
907 }
908 }
909
ath10k_htc_wait_target(struct ath10k_htc * htc)910 int ath10k_htc_wait_target(struct ath10k_htc *htc)
911 {
912 struct ath10k *ar = htc->ar;
913 int i, status = 0;
914 unsigned long time_left;
915 struct ath10k_htc_msg *msg;
916 u16 message_id;
917
918 time_left = wait_for_completion_timeout(&htc->ctl_resp,
919 ATH10K_HTC_WAIT_TIMEOUT_HZ);
920 if (!time_left) {
921 /* Workaround: In some cases the PCI HIF doesn't
922 * receive interrupt for the control response message
923 * even if the buffer was completed. It is suspected
924 * iomap writes unmasking PCI CE irqs aren't propagated
925 * properly in KVM PCI-passthrough sometimes.
926 */
927 ath10k_warn(ar, "failed to receive control response completion, polling..\n");
928
929 for (i = 0; i < CE_COUNT; i++)
930 ath10k_hif_send_complete_check(htc->ar, i, 1);
931
932 time_left =
933 wait_for_completion_timeout(&htc->ctl_resp,
934 ATH10K_HTC_WAIT_TIMEOUT_HZ);
935
936 if (!time_left)
937 status = -ETIMEDOUT;
938 }
939
940 if (status < 0) {
941 ath10k_err(ar, "ctl_resp never came in (%d)\n", status);
942 return status;
943 }
944
945 if (htc->control_resp_len < sizeof(msg->hdr) + sizeof(msg->ready)) {
946 ath10k_err(ar, "Invalid HTC ready msg len:%d\n",
947 htc->control_resp_len);
948 return -ECOMM;
949 }
950
951 msg = (struct ath10k_htc_msg *)htc->control_resp_buffer;
952 message_id = __le16_to_cpu(msg->hdr.message_id);
953
954 if (message_id != ATH10K_HTC_MSG_READY_ID) {
955 ath10k_err(ar, "Invalid HTC ready msg: 0x%x\n", message_id);
956 return -ECOMM;
957 }
958
959 if (ar->hw_params.use_fw_tx_credits)
960 htc->total_transmit_credits = __le16_to_cpu(msg->ready.credit_count);
961 else
962 htc->total_transmit_credits = 1;
963
964 htc->target_credit_size = __le16_to_cpu(msg->ready.credit_size);
965
966 ath10k_dbg(ar, ATH10K_DBG_HTC,
967 "Target ready! transmit resources: %d size:%d actual credits:%d\n",
968 htc->total_transmit_credits,
969 htc->target_credit_size,
970 msg->ready.credit_count);
971
972 if ((htc->total_transmit_credits == 0) ||
973 (htc->target_credit_size == 0)) {
974 ath10k_err(ar, "Invalid credit size received\n");
975 return -ECOMM;
976 }
977
978 /* The only way to determine if the ready message is an extended
979 * message is from the size.
980 */
981 if (htc->control_resp_len >=
982 sizeof(msg->hdr) + sizeof(msg->ready_ext)) {
983 htc->alt_data_credit_size =
984 __le16_to_cpu(msg->ready_ext.reserved) &
985 ATH10K_HTC_MSG_READY_EXT_ALT_DATA_MASK;
986 htc->max_msgs_per_htc_bundle =
987 min_t(u8, msg->ready_ext.max_msgs_per_htc_bundle,
988 HTC_HOST_MAX_MSG_PER_RX_BUNDLE);
989 ath10k_dbg(ar, ATH10K_DBG_HTC,
990 "Extended ready message RX bundle size %d alt size %d\n",
991 htc->max_msgs_per_htc_bundle,
992 htc->alt_data_credit_size);
993 }
994
995 INIT_WORK(&ar->bundle_tx_work, ath10k_htc_bundle_tx_work);
996 INIT_WORK(&ar->tx_complete_work, ath10k_htc_tx_complete_work);
997
998 return 0;
999 }
1000
ath10k_htc_change_tx_credit_flow(struct ath10k_htc * htc,enum ath10k_htc_ep_id eid,bool enable)1001 void ath10k_htc_change_tx_credit_flow(struct ath10k_htc *htc,
1002 enum ath10k_htc_ep_id eid,
1003 bool enable)
1004 {
1005 struct ath10k *ar = htc->ar;
1006 struct ath10k_htc_ep *ep = &ar->htc.endpoint[eid];
1007
1008 ep->tx_credit_flow_enabled = enable;
1009 }
1010
ath10k_htc_connect_service(struct ath10k_htc * htc,struct ath10k_htc_svc_conn_req * conn_req,struct ath10k_htc_svc_conn_resp * conn_resp)1011 int ath10k_htc_connect_service(struct ath10k_htc *htc,
1012 struct ath10k_htc_svc_conn_req *conn_req,
1013 struct ath10k_htc_svc_conn_resp *conn_resp)
1014 {
1015 struct ath10k *ar = htc->ar;
1016 struct ath10k_htc_msg *msg;
1017 struct ath10k_htc_conn_svc *req_msg;
1018 struct ath10k_htc_conn_svc_response resp_msg_dummy;
1019 struct ath10k_htc_conn_svc_response *resp_msg = &resp_msg_dummy;
1020 enum ath10k_htc_ep_id assigned_eid = ATH10K_HTC_EP_COUNT;
1021 struct ath10k_htc_ep *ep;
1022 struct sk_buff *skb;
1023 unsigned int max_msg_size = 0;
1024 int length, status;
1025 unsigned long time_left;
1026 bool disable_credit_flow_ctrl = false;
1027 u16 message_id, service_id, flags = 0;
1028 u8 tx_alloc = 0;
1029
1030 /* special case for HTC pseudo control service */
1031 if (conn_req->service_id == ATH10K_HTC_SVC_ID_RSVD_CTRL) {
1032 disable_credit_flow_ctrl = true;
1033 assigned_eid = ATH10K_HTC_EP_0;
1034 max_msg_size = ATH10K_HTC_MAX_CTRL_MSG_LEN;
1035 memset(&resp_msg_dummy, 0, sizeof(resp_msg_dummy));
1036 goto setup;
1037 }
1038
1039 tx_alloc = ath10k_htc_get_credit_allocation(htc,
1040 conn_req->service_id);
1041 if (!tx_alloc)
1042 ath10k_dbg(ar, ATH10K_DBG_BOOT,
1043 "boot htc service %s does not allocate target credits\n",
1044 htc_service_name(conn_req->service_id));
1045
1046 skb = ath10k_htc_build_tx_ctrl_skb(htc->ar);
1047 if (!skb) {
1048 ath10k_err(ar, "Failed to allocate HTC packet\n");
1049 return -ENOMEM;
1050 }
1051
1052 length = sizeof(msg->hdr) + sizeof(msg->connect_service);
1053 skb_put(skb, length);
1054 memset(skb->data, 0, length);
1055
1056 msg = (struct ath10k_htc_msg *)skb->data;
1057 msg->hdr.message_id =
1058 __cpu_to_le16(ATH10K_HTC_MSG_CONNECT_SERVICE_ID);
1059
1060 flags |= SM(tx_alloc, ATH10K_HTC_CONN_FLAGS_RECV_ALLOC);
1061
1062 /* Only enable credit flow control for WMI ctrl service */
1063 if (conn_req->service_id != ATH10K_HTC_SVC_ID_WMI_CONTROL) {
1064 flags |= ATH10K_HTC_CONN_FLAGS_DISABLE_CREDIT_FLOW_CTRL;
1065 disable_credit_flow_ctrl = true;
1066 }
1067
1068 req_msg = &msg->connect_service;
1069 req_msg->flags = __cpu_to_le16(flags);
1070 req_msg->service_id = __cpu_to_le16(conn_req->service_id);
1071
1072 reinit_completion(&htc->ctl_resp);
1073
1074 status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, skb);
1075 if (status) {
1076 kfree_skb(skb);
1077 return status;
1078 }
1079
1080 /* wait for response */
1081 time_left = wait_for_completion_timeout(&htc->ctl_resp,
1082 ATH10K_HTC_CONN_SVC_TIMEOUT_HZ);
1083 if (!time_left) {
1084 ath10k_err(ar, "Service connect timeout\n");
1085 return -ETIMEDOUT;
1086 }
1087
1088 /* we controlled the buffer creation, it's aligned */
1089 msg = (struct ath10k_htc_msg *)htc->control_resp_buffer;
1090 resp_msg = &msg->connect_service_response;
1091 message_id = __le16_to_cpu(msg->hdr.message_id);
1092 service_id = __le16_to_cpu(resp_msg->service_id);
1093
1094 if ((message_id != ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID) ||
1095 (htc->control_resp_len < sizeof(msg->hdr) +
1096 sizeof(msg->connect_service_response))) {
1097 ath10k_err(ar, "Invalid resp message ID 0x%x", message_id);
1098 return -EPROTO;
1099 }
1100
1101 ath10k_dbg(ar, ATH10K_DBG_HTC,
1102 "HTC Service %s connect response: status: 0x%x, assigned ep: 0x%x\n",
1103 htc_service_name(service_id),
1104 resp_msg->status, resp_msg->eid);
1105
1106 conn_resp->connect_resp_code = resp_msg->status;
1107
1108 /* check response status */
1109 if (resp_msg->status != ATH10K_HTC_CONN_SVC_STATUS_SUCCESS) {
1110 ath10k_err(ar, "HTC Service %s connect request failed: 0x%x)\n",
1111 htc_service_name(service_id),
1112 resp_msg->status);
1113 return -EPROTO;
1114 }
1115
1116 assigned_eid = (enum ath10k_htc_ep_id)resp_msg->eid;
1117 max_msg_size = __le16_to_cpu(resp_msg->max_msg_size);
1118
1119 setup:
1120
1121 if (assigned_eid >= ATH10K_HTC_EP_COUNT)
1122 return -EPROTO;
1123
1124 if (max_msg_size == 0)
1125 return -EPROTO;
1126
1127 ep = &htc->endpoint[assigned_eid];
1128 ep->eid = assigned_eid;
1129
1130 if (ep->service_id != ATH10K_HTC_SVC_ID_UNUSED)
1131 return -EPROTO;
1132
1133 /* return assigned endpoint to caller */
1134 conn_resp->eid = assigned_eid;
1135 conn_resp->max_msg_len = __le16_to_cpu(resp_msg->max_msg_size);
1136
1137 /* setup the endpoint */
1138 ep->service_id = conn_req->service_id;
1139 ep->max_tx_queue_depth = conn_req->max_send_queue_depth;
1140 ep->max_ep_message_len = __le16_to_cpu(resp_msg->max_msg_size);
1141 ep->tx_credits = tx_alloc;
1142 ep->tx_credit_size = htc->target_credit_size;
1143
1144 if (conn_req->service_id == ATH10K_HTC_SVC_ID_HTT_DATA_MSG &&
1145 htc->alt_data_credit_size != 0)
1146 ep->tx_credit_size = htc->alt_data_credit_size;
1147
1148 /* copy all the callbacks */
1149 ep->ep_ops = conn_req->ep_ops;
1150
1151 status = ath10k_hif_map_service_to_pipe(htc->ar,
1152 ep->service_id,
1153 &ep->ul_pipe_id,
1154 &ep->dl_pipe_id);
1155 if (status) {
1156 ath10k_dbg(ar, ATH10K_DBG_BOOT, "unsupported HTC service id: %d\n",
1157 ep->service_id);
1158 return status;
1159 }
1160
1161 ath10k_dbg(ar, ATH10K_DBG_BOOT,
1162 "boot htc service '%s' ul pipe %d dl pipe %d eid %d ready\n",
1163 htc_service_name(ep->service_id), ep->ul_pipe_id,
1164 ep->dl_pipe_id, ep->eid);
1165
1166 if (disable_credit_flow_ctrl && ep->tx_credit_flow_enabled) {
1167 ep->tx_credit_flow_enabled = false;
1168 ath10k_dbg(ar, ATH10K_DBG_BOOT,
1169 "boot htc service '%s' eid %d TX flow control disabled\n",
1170 htc_service_name(ep->service_id), assigned_eid);
1171 }
1172
1173 return status;
1174 }
1175
ath10k_htc_alloc_skb(struct ath10k * ar,int size)1176 struct sk_buff *ath10k_htc_alloc_skb(struct ath10k *ar, int size)
1177 {
1178 struct sk_buff *skb;
1179
1180 skb = dev_alloc_skb(size + sizeof(struct ath10k_htc_hdr));
1181 if (!skb)
1182 return NULL;
1183
1184 skb_reserve(skb, sizeof(struct ath10k_htc_hdr));
1185
1186 /* FW/HTC requires 4-byte aligned streams */
1187 if (!IS_ALIGNED((unsigned long)skb->data, 4))
1188 ath10k_warn(ar, "Unaligned HTC tx skb\n");
1189
1190 return skb;
1191 }
1192
ath10k_htc_pktlog_process_rx(struct ath10k * ar,struct sk_buff * skb)1193 static void ath10k_htc_pktlog_process_rx(struct ath10k *ar, struct sk_buff *skb)
1194 {
1195 trace_ath10k_htt_pktlog(ar, skb->data, skb->len);
1196 dev_kfree_skb_any(skb);
1197 }
1198
ath10k_htc_pktlog_connect(struct ath10k * ar)1199 static int ath10k_htc_pktlog_connect(struct ath10k *ar)
1200 {
1201 struct ath10k_htc_svc_conn_resp conn_resp;
1202 struct ath10k_htc_svc_conn_req conn_req;
1203 int status;
1204
1205 memset(&conn_req, 0, sizeof(conn_req));
1206 memset(&conn_resp, 0, sizeof(conn_resp));
1207
1208 conn_req.ep_ops.ep_tx_complete = NULL;
1209 conn_req.ep_ops.ep_rx_complete = ath10k_htc_pktlog_process_rx;
1210 conn_req.ep_ops.ep_tx_credits = NULL;
1211
1212 /* connect to control service */
1213 conn_req.service_id = ATH10K_HTC_SVC_ID_HTT_LOG_MSG;
1214 status = ath10k_htc_connect_service(&ar->htc, &conn_req, &conn_resp);
1215 if (status) {
1216 ath10k_warn(ar, "failed to connect to PKTLOG service: %d\n",
1217 status);
1218 return status;
1219 }
1220
1221 return 0;
1222 }
1223
ath10k_htc_pktlog_svc_supported(struct ath10k * ar)1224 static bool ath10k_htc_pktlog_svc_supported(struct ath10k *ar)
1225 {
1226 u8 ul_pipe_id;
1227 u8 dl_pipe_id;
1228 int status;
1229
1230 status = ath10k_hif_map_service_to_pipe(ar, ATH10K_HTC_SVC_ID_HTT_LOG_MSG,
1231 &ul_pipe_id,
1232 &dl_pipe_id);
1233 if (status) {
1234 ath10k_dbg(ar, ATH10K_DBG_BOOT, "unsupported HTC pktlog service id: %d\n",
1235 ATH10K_HTC_SVC_ID_HTT_LOG_MSG);
1236
1237 return false;
1238 }
1239
1240 return true;
1241 }
1242
ath10k_htc_start(struct ath10k_htc * htc)1243 int ath10k_htc_start(struct ath10k_htc *htc)
1244 {
1245 struct ath10k *ar = htc->ar;
1246 struct sk_buff *skb;
1247 int status = 0;
1248 struct ath10k_htc_msg *msg;
1249
1250 skb = ath10k_htc_build_tx_ctrl_skb(htc->ar);
1251 if (!skb)
1252 return -ENOMEM;
1253
1254 skb_put(skb, sizeof(msg->hdr) + sizeof(msg->setup_complete_ext));
1255 memset(skb->data, 0, skb->len);
1256
1257 msg = (struct ath10k_htc_msg *)skb->data;
1258 msg->hdr.message_id =
1259 __cpu_to_le16(ATH10K_HTC_MSG_SETUP_COMPLETE_EX_ID);
1260
1261 if (ar->hif.bus == ATH10K_BUS_SDIO) {
1262 /* Extra setup params used by SDIO */
1263 msg->setup_complete_ext.flags =
1264 __cpu_to_le32(ATH10K_HTC_SETUP_COMPLETE_FLAGS_RX_BNDL_EN);
1265 msg->setup_complete_ext.max_msgs_per_bundled_recv =
1266 htc->max_msgs_per_htc_bundle;
1267 }
1268 ath10k_dbg(ar, ATH10K_DBG_HTC, "HTC is using TX credit flow control\n");
1269
1270 status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, skb);
1271 if (status) {
1272 kfree_skb(skb);
1273 return status;
1274 }
1275
1276 if (ath10k_htc_pktlog_svc_supported(ar)) {
1277 status = ath10k_htc_pktlog_connect(ar);
1278 if (status) {
1279 ath10k_err(ar, "failed to connect to pktlog: %d\n", status);
1280 return status;
1281 }
1282 }
1283
1284 return 0;
1285 }
1286
1287 /* registered target arrival callback from the HIF layer */
ath10k_htc_init(struct ath10k * ar)1288 int ath10k_htc_init(struct ath10k *ar)
1289 {
1290 int status;
1291 struct ath10k_htc *htc = &ar->htc;
1292 struct ath10k_htc_svc_conn_req conn_req;
1293 struct ath10k_htc_svc_conn_resp conn_resp;
1294
1295 spin_lock_init(&htc->tx_lock);
1296
1297 ath10k_htc_reset_endpoint_states(htc);
1298
1299 htc->ar = ar;
1300
1301 /* setup our pseudo HTC control endpoint connection */
1302 memset(&conn_req, 0, sizeof(conn_req));
1303 memset(&conn_resp, 0, sizeof(conn_resp));
1304 conn_req.ep_ops.ep_tx_complete = ath10k_htc_control_tx_complete;
1305 conn_req.ep_ops.ep_rx_complete = ath10k_htc_control_rx_complete;
1306 conn_req.max_send_queue_depth = ATH10K_NUM_CONTROL_TX_BUFFERS;
1307 conn_req.service_id = ATH10K_HTC_SVC_ID_RSVD_CTRL;
1308
1309 /* connect fake service */
1310 status = ath10k_htc_connect_service(htc, &conn_req, &conn_resp);
1311 if (status) {
1312 ath10k_err(ar, "could not connect to htc service (%d)\n",
1313 status);
1314 return status;
1315 }
1316
1317 init_completion(&htc->ctl_resp);
1318
1319 return 0;
1320 }
1321