drivers/net/wireless/ath/ath10k/htc.c

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