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         /* 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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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 */
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 }