drivers/staging/csr/csr_wifi_hip_card_sdio_intr.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2012
   4             All rights reserved and confidential information of CSR
   5
   6             Refer to LICENSE.txt included with this source for details
   7             on the license terms.
   8
   9 *****************************************************************************/
  10
  11 /*
  12  * ---------------------------------------------------------------------------
  13  *  FILE:     csr_wifi_hip_card_sdio_intr.c
  14  *
  15  *  PURPOSE:
  16  *      Interrupt processing for the UniFi SDIO driver.
  17  *
  18  *      We may need another signal queue of responses to UniFi to hold
  19  *      bulk data commands generated by read_to_host_signals().
  20  *
  21  * ---------------------------------------------------------------------------
  22  */
  23 #undef CSR_WIFI_HIP_NOISY
  24
  25 #include "csr_wifi_hip_unifi.h"
  26 #include "csr_wifi_hip_conversions.h"
  27 #include "csr_wifi_hip_card.h"
  28 #include "csr_wifi_hip_xbv.h"
  29
  30
  31 /*
  32  * If the SDIO link is idle for this time (in milliseconds),
  33  * signal UniFi to go into Deep Sleep.
  34  * Valid return value of unifi_bh().
  35  */
  36 #define UNIFI_DEFAULT_HOST_IDLE_TIMEOUT 5
  37 /*
  38  * If the UniFi has not woken up for this time (in milliseconds),
  39  * signal the bottom half to take action.
  40  * Valid return value of unifi_bh().
  41  */
  42 #define UNIFI_DEFAULT_WAKE_TIMEOUT      1000
  43
  44
  45 static CsrResult process_bh(card_t *card);
  46 static CsrResult handle_host_protocol(card_t *card, u8 *processed_something);
  47
  48 static CsrResult flush_fh_buffer(card_t *card);
  49
  50 static CsrResult check_fh_sig_slots(card_t *card, u16 needed, s32 *space);
  51
  52 static CsrResult read_to_host_signals(card_t *card, s32 *processed);
  53 static CsrResult process_to_host_signals(card_t *card, s32 *processed);
  54
  55 static CsrResult process_bulk_data_command(card_t *card,
  56                                            const u8 *cmdptr,
  57                                            s16 cmd, u16 len);
  58 static CsrResult process_clear_slot_command(card_t         *card,
  59                                             const u8 *cmdptr);
  60 static CsrResult process_fh_cmd_queue(card_t *card, s32 *processed);
  61 static CsrResult process_fh_traffic_queue(card_t *card, s32 *processed);
  62 static void restart_packet_flow(card_t *card);
  63 static CsrResult process_clock_request(card_t *card);
  64
  65 #ifdef CSR_WIFI_HIP_NOISY
  66 s16 dump_fh_buf = 0;
  67 #endif /* CSR_WIFI_HIP_NOISY */
  68
  69 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
  70
  71 /*
  72  * The unifi_debug_output buffer can be used to debug the HIP behaviour offline
  73  * i.e. without using the tracing functions that change the timing.
  74  *
  75  * Call unifi_debug_log_to_buf() with printf arguments to store a string into
  76  * unifi_debug_output. When unifi_debug_buf_dump() is called, the contents of the
  77  * buffer are dumped with dump_str() which has to be implemented in the
  78  * OS layer, during the porting exercise. The offset printed, holds the
  79  * offset where the last character is (always a zero).
  80  *
  81  */
  82
  83 #define UNIFI_DEBUG_GBUFFER_SIZE       8192
  84 static char unifi_debug_output[UNIFI_DEBUG_GBUFFER_SIZE];
  85 static char *unifi_dbgbuf_ptr = unifi_debug_output;
  86 static char *unifi_dbgbuf_start = unifi_debug_output;
  87
  88 static void append_char(char c)
  89 {
  90     /* write char and advance pointer */
  91     *unifi_dbgbuf_ptr++ = c;
  92     /* wrap pointer at end of buffer */
  93     if ((unifi_dbgbuf_ptr - unifi_debug_output) >= UNIFI_DEBUG_GBUFFER_SIZE)
  94     {
  95         unifi_dbgbuf_ptr = unifi_debug_output;
  96     }
  97 } /* append_char() */
  98
  99
 100 void unifi_debug_string_to_buf(const char *str)
 101 {
 102     const char *p = str;
 103     while (*p)
 104     {
 105         append_char(*p);
 106         p++;
 107     }
 108     /* Update start-of-buffer pointer */
 109     unifi_dbgbuf_start = unifi_dbgbuf_ptr + 1;
 110     if ((unifi_dbgbuf_start - unifi_debug_output) >= UNIFI_DEBUG_GBUFFER_SIZE)
 111     {
 112         unifi_dbgbuf_start = unifi_debug_output;
 113     }
 114 }
 115
 116
 117 void unifi_debug_log_to_buf(const char *fmt, ...)
 118 {
 119 #define DEBUG_BUFFER_SIZE       80
 120     static char s[DEBUG_BUFFER_SIZE];
 121     va_list args;
 122
 123     va_start(args, fmt);
 124     vsnprintf(s, DEBUG_BUFFER_SIZE, fmt, args);
 125     va_end(args);
 126
 127     unifi_debug_string_to_buf(s);
 128 } /* unifi_debug_log_to_buf() */
 129
 130
 131 /* Convert signed 32 bit (or less) integer to string */
 132 static void CsrUInt16ToHex(u16 number, char *str)
 133 {
 134     u16 index;
 135     u16 currentValue;
 136
 137     for (index = 0; index < 4; index++)
 138     {
 139         currentValue = (u16) (number & 0x000F);
 140         number >>= 4;
 141         str[3 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
 142     }
 143     str[4] = '\0';
 144 }
 145
 146
 147 /*
 148  * ---------------------------------------------------------------------------
 149  *  unifi_debug_hex_to_buf
 150  *
 151  *  puts the contents of the passed buffer into the debug buffer as a hex string
 152  *
 153  *  Arguments:
 154  *      buff         buffer to print as hex
 155  *      length       number of chars to print
 156  *
 157  *  Returns:
 158  *      None.
 159  *
 160  * ---------------------------------------------------------------------------
 161  */
 162 void unifi_debug_hex_to_buf(const char *buff, u16 length)
 163 {
 164     char s[5];
 165     u16 i;
 166
 167     for (i = 0; i < length; i = i + 2)
 168     {
 169         CsrUInt16ToHex(*((u16 *)(buff + i)), s);
 170         unifi_debug_string_to_buf(s);
 171     }
 172 }
 173
 174
 175 void unifi_debug_buf_dump(void)
 176 {
 177     s32 offset = unifi_dbgbuf_ptr - unifi_debug_output;
 178
 179     unifi_error(NULL, "HIP debug buffer offset=%d\n", offset);
 180     dump_str(unifi_debug_output + offset, UNIFI_DEBUG_GBUFFER_SIZE - offset);
 181     dump_str(unifi_debug_output, offset);
 182 } /* unifi_debug_buf_dump() */
 183
 184
 185 #endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
 186
 187 #ifdef CSR_PRE_ALLOC_NET_DATA
 188 #define NETDATA_PRE_ALLOC_BUF_SIZE 8000
 189
 190 void prealloc_netdata_free(card_t *card)
 191 {
 192     unifi_warning(card->ospriv, "prealloc_netdata_free: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
 193
 194     while (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length != 0)
 195     {
 196         unifi_warning(card->ospriv, "prealloc_netdata_free: r=%d\n", card->prealloc_netdata_r);
 197
 198         unifi_net_data_free(card->ospriv, &card->bulk_data_desc_list[card->prealloc_netdata_r]);
 199         card->prealloc_netdata_r++;
 200         card->prealloc_netdata_r %= BULK_DATA_PRE_ALLOC_NUM;
 201     }
 202     card->prealloc_netdata_r = card->prealloc_netdata_w = 0;
 203
 204     unifi_warning(card->ospriv, "prealloc_netdata_free: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
 205 }
 206
 207
 208 CsrResult prealloc_netdata_alloc(card_t *card)
 209 {
 210     CsrResult r;
 211
 212     unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_alloc: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
 213
 214     while (card->bulk_data_desc_list[card->prealloc_netdata_w].data_length == 0)
 215     {
 216         r = unifi_net_data_malloc(card->ospriv, &card->bulk_data_desc_list[card->prealloc_netdata_w], NETDATA_PRE_ALLOC_BUF_SIZE);
 217         if (r != CSR_RESULT_SUCCESS)
 218         {
 219             unifi_error(card->ospriv, "prealloc_netdata_alloc: Failed to allocate t-h bulk data\n");
 220             return CSR_RESULT_FAILURE;
 221         }
 222         card->prealloc_netdata_w++;
 223         card->prealloc_netdata_w %= BULK_DATA_PRE_ALLOC_NUM;
 224     }
 225     unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_alloc: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
 226
 227     return CSR_RESULT_SUCCESS;
 228 }
 229
 230
 231 static CsrResult prealloc_netdata_get(card_t *card, bulk_data_desc_t *bulk_data_slot, u32 size)
 232 {
 233     CsrResult r;
 234
 235     unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_get: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
 236
 237     if (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length == 0)
 238     {
 239         unifi_error(card->ospriv, "prealloc_netdata_get: data_length = 0\n");
 240     }
 241
 242     if ((size > NETDATA_PRE_ALLOC_BUF_SIZE) || (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length == 0))
 243     {
 244         unifi_warning(card->ospriv, "prealloc_netdata_get: Calling net_data_malloc\n");
 245
 246         r = unifi_net_data_malloc(card->ospriv, bulk_data_slot, size);
 247         if (r != CSR_RESULT_SUCCESS)
 248         {
 249             unifi_error(card->ospriv, "prealloc_netdata_get: Failed to allocate t-h bulk data\n");
 250             return CSR_RESULT_FAILURE;
 251         }
 252         return CSR_RESULT_SUCCESS;
 253     }
 254
 255     *bulk_data_slot = card->bulk_data_desc_list[card->prealloc_netdata_r];
 256     card->bulk_data_desc_list[card->prealloc_netdata_r].os_data_ptr = NULL;
 257     card->bulk_data_desc_list[card->prealloc_netdata_r].os_net_buf_ptr = NULL;
 258     card->bulk_data_desc_list[card->prealloc_netdata_r].net_buf_length = 0;
 259     card->bulk_data_desc_list[card->prealloc_netdata_r].data_length = 0;
 260
 261     card->prealloc_netdata_r++;
 262     card->prealloc_netdata_r %= BULK_DATA_PRE_ALLOC_NUM;
 263
 264     unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_get: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
 265
 266     return CSR_RESULT_SUCCESS;
 267 }
 268
 269
 270 #endif
 271
 272 /*
 273  * ---------------------------------------------------------------------------
 274  *  unifi_sdio_interrupt_handler
 275  *
 276  *      This function should be called by the OS-dependent code to handle
 277  *      an SDIO interrupt from the UniFi.
 278  *
 279  *  Arguments:
 280  *      card            Pointer to card context structure.
 281  *
 282  *  Returns:
 283  *      None.
 284  *
 285  *  Notes: This function may be called in DRS context. In this case,
 286  *         tracing with the unifi_trace(), etc, is not allowed.
 287  * ---------------------------------------------------------------------------
 288  */
 289 void unifi_sdio_interrupt_handler(card_t *card)
 290 {
 291     /*
 292      * Set the flag to say reason for waking was SDIO interrupt.
 293      * Then ask the OS layer to run the unifi_bh to give attention to the UniFi.
 294      */
 295     card->bh_reason_unifi = 1;
 296     (void)unifi_run_bh(card->ospriv);
 297 } /*  sdio_interrupt_handler() */
 298
 299
 300 /*
 301  * ---------------------------------------------------------------------------
 302  *  unifi_configure_low_power_mode
 303  *
 304  *      This function should be called by the OS-dependent when
 305  *      the deep sleep signaling needs to be enabled or disabled.
 306  *
 307  *  Arguments:
 308  *      card            Pointer to card context structure.
 309  *      low_power_mode  Disable/Enable the deep sleep signaling
 310  *      periodic_wake_mode UniFi wakes host periodically.
 311  *
 312  *  Returns:
 313  *      CSR_RESULT_SUCCESS on success or a CSR error code.
 314  * ---------------------------------------------------------------------------
 315  */
 316 CsrResult unifi_configure_low_power_mode(card_t                       *card,
 317                                          enum unifi_low_power_mode     low_power_mode,
 318                                          enum unifi_periodic_wake_mode periodic_wake_mode)
 319 {
 320     card->low_power_mode = low_power_mode;
 321     card->periodic_wake_mode = periodic_wake_mode;
 322
 323     unifi_trace(card->ospriv, UDBG1,
 324                 "unifi_configure_low_power_mode: new mode = %s, wake_host = %s\n",
 325                 (low_power_mode == UNIFI_LOW_POWER_DISABLED)?"disabled" : "enabled",
 326                 (periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_DISABLED)?"FALSE" : "TRUE");
 327
 328     (void)unifi_run_bh(card->ospriv);
 329     return CSR_RESULT_SUCCESS;
 330 } /* unifi_configure_low_power_mode() */
 331
 332
 333 /*
 334  * ---------------------------------------------------------------------------
 335  *  unifi_force_low_power_mode
 336  *
 337  *      This function should be called by the OS-dependent when
 338  *      UniFi needs to be set to the low power mode (e.g. on suspend)
 339  *
 340  *  Arguments:
 341  *      card            Pointer to card context structure.
 342  *
 343  *  Returns:
 344  *      CSR_RESULT_SUCCESS on success or a CSR error code.
 345  * ---------------------------------------------------------------------------
 346  */
 347 CsrResult unifi_force_low_power_mode(card_t *card)
 348 {
 349     if (card->low_power_mode == UNIFI_LOW_POWER_DISABLED)
 350     {
 351         unifi_error(card->ospriv, "Attempt to set mode to TORPID when lower power mode is disabled\n");
 352         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 353     }
 354
 355     return unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID);
 356 } /* unifi_force_low_power_mode() */
 357
 358
 359 /*
 360  * ---------------------------------------------------------------------------
 361  *  unifi_bh
 362  *
 363  *      This function should be called by the OS-dependent code when
 364  *      host and/or UniFi has requested an exchange of messages.
 365  *
 366  *  Arguments:
 367  *      card            Pointer to card context structure.
 368  *
 369  *  Returns:
 370  *      CSR_RESULT_SUCCESS on success or a CSR error code.
 371  * ---------------------------------------------------------------------------
 372  */
 373 CsrResult unifi_bh(card_t *card, u32 *remaining)
 374 {
 375     CsrResult r;
 376     CsrResult csrResult;
 377     u8 pending;
 378     s32 iostate, j;
 379     const enum unifi_low_power_mode low_power_mode = card->low_power_mode;
 380     u16 data_slots_used = 0;
 381
 382
 383     /* Process request to raise the maximum SDIO clock */
 384     r = process_clock_request(card);
 385     if (r != CSR_RESULT_SUCCESS)
 386     {
 387         unifi_error(card->ospriv, "Error setting maximum SDIO clock\n");
 388         goto exit;
 389     }
 390
 391     /*
 392      * Why was the BH thread woken?
 393      * If it was an SDIO interrupt, UniFi is awake and we need to process it.
 394      * If it was a host process queueing data, then we need to awaken UniFi.
 395      *
 396      * Priority of flags is top down.
 397      *
 398      * ----------------------------------------------------------+
 399      *    \state|   AWAKE      |    DROWSY      |    TORPID      |
 400      * flag\    |              |                |                |
 401      * ---------+--------------+----------------+----------------|
 402      *          | do the host  | go to AWAKE and| go to AWAKE and|
 403      *   unifi  | protocol     | do the host    | do the host    |
 404      *          |              | protocol       | protocol       |
 405      * ---------+--------------+----------------+----------------|
 406      *          | do the host  |                |                |
 407      *   host   | protocol     |  do nothing    | go to DROWSY   |
 408      *          |              |                |                |
 409      * ---------+--------------+----------------+----------------|
 410      *          |              |                | should not     |
 411      *  timeout | go to TORPID | error, unifi   | occur          |
 412      *          |              | didn't wake up | do nothing     |
 413      * ----------------------------------------------------------+
 414      *
 415      * Note that if we end up in the AWAKE state we always do the host protocol.
 416      */
 417
 418     do
 419     {
 420         /*
 421          * When the host state is set to DROWSY, then we can not disable the
 422          * interrupts as UniFi can generate an interrupt even when the INT_ENABLE
 423          * register has the interrupts disabled. This interrupt will be lost.
 424          */
 425         if (card->host_state == UNIFI_HOST_STATE_DROWSY || card->host_state == UNIFI_HOST_STATE_TORPID)
 426         {
 427             u8 reason_unifi;
 428
 429             /*
 430              * An interrupt may occur while or after we cache the reason.
 431              * This interrupt will cause the unifi_bh() to be scheduled again.
 432              * Any interrupt that has happened before the register is read
 433              * and is considered spurious has to acknowledged.
 434              */
 435             reason_unifi = card->bh_reason_unifi;
 436
 437             /*
 438              * If an interrupt is received, check if it was a real one,
 439              * set the host state to AWAKE and run the BH.
 440              */
 441             r = CardPendingInt(card, &pending);
 442             if (r != CSR_RESULT_SUCCESS)
 443             {
 444                 goto exit;
 445             }
 446
 447             if (pending)
 448             {
 449                 unifi_trace(card->ospriv, UDBG5,
 450                             "UNIFI_HOST_STATE_%s: Set state to AWAKE.\n",
 451                             (card->host_state == UNIFI_HOST_STATE_TORPID)?"TORPID" : "DROWSY");
 452
 453                 r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
 454                 if (r == CSR_RESULT_SUCCESS)
 455                 {
 456                     (*remaining) = 0;
 457                     break;
 458                 }
 459             }
 460             else if (reason_unifi)
 461             {
 462                 CsrSdioInterruptAcknowledge(card->sdio_if);
 463             }
 464
 465             /*
 466              * If an chip is in TORPID, and the host wants to wake it up,
 467              * set the host state to DROWSY and wait for the wake-up interrupt.
 468              */
 469             if ((card->host_state == UNIFI_HOST_STATE_TORPID) && card->bh_reason_host)
 470             {
 471                 r = unifi_set_host_state(card, UNIFI_HOST_STATE_DROWSY);
 472                 if (r == CSR_RESULT_SUCCESS)
 473                 {
 474                     /*
 475                      * set the timeout value to UNIFI_DEFAULT_WAKE_TIMEOUT
 476                      * to capture a wake error.
 477                      */
 478                     card->bh_reason_host = 0;
 479                     (*remaining) = UNIFI_DEFAULT_WAKE_TIMEOUT;
 480                     return CSR_RESULT_SUCCESS;
 481                 }
 482
 483                 goto exit;
 484             }
 485
 486             /*
 487              * If the chip is in DROWSY, and the timeout expires,
 488              * we need to reset the chip. This should never occur.
 489              * (If it does, check that the calling thread set "remaining"
 490              * according to the time remaining when unifi_bh() was called).
 491              */
 492             if ((card->host_state == UNIFI_HOST_STATE_DROWSY) && ((*remaining) == 0))
 493             {
 494                 unifi_error(card->ospriv, "UniFi did not wake up on time...\n");
 495
 496                 /*
 497                  * Check if Function1 has gone away or
 498                  * if we missed an SDIO interrupt.
 499                  */
 500                 r = unifi_check_io_status(card, &iostate);
 501                 if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
 502                 {
 503                     goto exit;
 504                 }
 505                 /* Need to reset and reboot */
 506                 return CSR_RESULT_FAILURE;
 507             }
 508         }
 509         else
 510         {
 511             if (card->bh_reason_unifi || card->bh_reason_host)
 512             {
 513                 break;
 514             }
 515
 516             if (((*remaining) == 0) && (low_power_mode == UNIFI_LOW_POWER_ENABLED))
 517             {
 518                 r = unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID);
 519                 if (r == CSR_RESULT_SUCCESS)
 520                 {
 521                     (*remaining) = 0;
 522                     return CSR_RESULT_SUCCESS;
 523                 }
 524
 525                 goto exit;
 526             }
 527         }
 528
 529         /* No need to run the host protocol */
 530         return CSR_RESULT_SUCCESS;
 531     } while (0);
 532
 533
 534     /* Disable the SDIO interrupts while doing SDIO ops */
 535     csrResult = CsrSdioInterruptDisable(card->sdio_if);
 536     if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
 537     {
 538         r = CSR_WIFI_HIP_RESULT_NO_DEVICE;
 539         goto exit;
 540     }
 541     if (csrResult != CSR_RESULT_SUCCESS)
 542     {
 543         r = ConvertCsrSdioToCsrHipResult(card, csrResult);
 544         unifi_error(card->ospriv, "Failed to disable SDIO interrupts. unifi_bh queues error.\n");
 545         goto exit;
 546     }
 547
 548     /* Now that the interrupts are disabled, ack the interrupt */
 549     CsrSdioInterruptAcknowledge(card->sdio_if);
 550
 551     /* Run the HIP */
 552     r = process_bh(card);
 553     if (r != CSR_RESULT_SUCCESS)
 554     {
 555         goto exit;
 556     }
 557
 558     /*
 559      * If host is now idle, schedule a timer for the delay before we
 560      * let UniFi go into deep sleep.
 561      * If the timer goes off, we will move to TORPID state.
 562      * If UniFi raises an interrupt in the meantime, we will cancel
 563      * the timer and start a new one when we become idle.
 564      */
 565     for (j = 0; j < UNIFI_NO_OF_TX_QS; j++)
 566     {
 567         data_slots_used += CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_traffic_queue[j]);
 568     }
 569
 570     if ((low_power_mode == UNIFI_LOW_POWER_ENABLED) && (data_slots_used == 0))
 571     {
 572 #ifndef CSR_WIFI_HIP_TA_DISABLE
 573         if (card->ta_sampling.traffic_type != CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC)
 574         {
 575 #endif
 576         /* return the UNIFI_DEFAULT_HOST_IDLE_TIMEOUT, so we can go to sleep. */
 577         unifi_trace(card->ospriv, UDBG5,
 578                     "Traffic is not periodic, set timer for TORPID.\n");
 579         (*remaining) = UNIFI_DEFAULT_HOST_IDLE_TIMEOUT;
 580 #ifndef CSR_WIFI_HIP_TA_DISABLE
 581     }
 582     else
 583     {
 584         unifi_trace(card->ospriv, UDBG5,
 585                     "Traffic is periodic, set unifi to TORPID immediately.\n");
 586         if (CardAreAllFromHostDataSlotsEmpty(card) == 1)
 587         {
 588             r = unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID);
 589             if (r != CSR_RESULT_SUCCESS)
 590             {
 591                 goto exit;
 592             }
 593         }
 594     }
 595 #endif
 596     }
 597
 598     csrResult = CsrSdioInterruptEnable(card->sdio_if);
 599     if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
 600     {
 601         r = CSR_WIFI_HIP_RESULT_NO_DEVICE;
 602     }
 603     if (csrResult != CSR_RESULT_SUCCESS)
 604     {
 605         r = ConvertCsrSdioToCsrHipResult(card, csrResult);
 606         unifi_error(card->ospriv, "Failed to enable SDIO interrupt\n");
 607     }
 608
 609 exit:
 610
 611     unifi_trace(card->ospriv, UDBG4, "New state=%d\n", card->host_state);
 612
 613     if (r != CSR_RESULT_SUCCESS)
 614     {
 615 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 616         unifi_debug_buf_dump();
 617 #endif
 618         /* If an interrupt has been raised, ack it here */
 619         if (card->bh_reason_unifi)
 620         {
 621             CsrSdioInterruptAcknowledge(card->sdio_if);
 622         }
 623
 624         unifi_error(card->ospriv,
 625                     "unifi_bh: state=%d %c, clock=%dkHz, interrupt=%d host=%d, power_save=%s\n",
 626                     card->host_state,
 627                     (card->host_state == UNIFI_HOST_STATE_AWAKE)?'A' : (card->host_state == UNIFI_HOST_STATE_DROWSY)?'D' : 'T',
 628                     card->sdio_clock_speed / 1000,
 629                     card->bh_reason_unifi, card->bh_reason_host,
 630                     (low_power_mode == UNIFI_LOW_POWER_DISABLED)?"disabled" : "enabled");
 631
 632         /* Try to capture firmware panic codes */
 633         (void)unifi_capture_panic(card);
 634
 635         /* Ask for a mini-coredump when the driver has reset UniFi */
 636         (void)unifi_coredump_request_at_next_reset(card, 1);
 637     }
 638
 639     return r;
 640 } /* unifi_bh() */
 641
 642
 643 /*
 644  * ---------------------------------------------------------------------------
 645  *  process_clock_request
 646  *
 647  *      Handle request from the OS layer to increase the SDIO clock speed.
 648  *      The fast clock is limited until the firmware has indicated that it has
 649  *      completed initialisation to the OS layer.
 650  *
 651  *  Arguments:
 652  *      card            Pointer to card context structure.
 653  *
 654  *  Returns:
 655  *      CSR_RESULT_SUCCESS on success or CSR error code.
 656  * ---------------------------------------------------------------------------
 657  */
 658 static CsrResult process_clock_request(card_t *card)
 659 {
 660     CsrResult r = CSR_RESULT_SUCCESS;
 661     CsrResult csrResult;
 662
 663     if (!card->request_max_clock)
 664     {
 665         return CSR_RESULT_SUCCESS;   /* No pending request */
 666     }
 667
 668     /*
 669      * The SDIO clock speed request from the OS layer is only acted upon if
 670      * the UniFi is awake. If it was in any other state, the clock speed will
 671      * transition through SAFE to MAX while the host wakes it up, and the
 672      * final speed reached will be UNIFI_SDIO_CLOCK_MAX_HZ.
 673      * This assumes that the SME never requests low power mode while the f/w
 674      * initialisation takes place.
 675      */
 676     if (card->host_state == UNIFI_HOST_STATE_AWAKE)
 677     {
 678         unifi_trace(card->ospriv, UDBG1, "Set SDIO max clock\n");
 679         csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_MAX_HZ);
 680         if (csrResult != CSR_RESULT_SUCCESS)
 681         {
 682             r = ConvertCsrSdioToCsrHipResult(card, csrResult);
 683         }
 684         else
 685         {
 686             card->sdio_clock_speed = UNIFI_SDIO_CLOCK_MAX_HZ;  /* log the new freq */
 687         }
 688     }
 689     else
 690     {
 691         unifi_trace(card->ospriv, UDBG1, "Will set SDIO max clock after wakeup\n");
 692     }
 693
 694     /* Cancel the request now that it has been acted upon, or is about to be
 695      * by the wakeup mechanism
 696      */
 697     card->request_max_clock = 0;
 698
 699     return r;
 700 }
 701
 702
 703 /*
 704  * ---------------------------------------------------------------------------
 705  *  process_bh
 706  *
 707  *      Exchange messages with UniFi
 708  *
 709  *  Arguments:
 710  *      card            Pointer to card context structure.
 711  *
 712  *  Returns:
 713  *      CSR_RESULT_SUCCESS on success or CSR error code.
 714  * ---------------------------------------------------------------------------
 715  */
 716 static CsrResult process_bh(card_t *card)
 717 {
 718     CsrResult r;
 719     u8 more;
 720     more = FALSE;
 721
 722     /* Process the reasons (interrupt, signals) */
 723     do
 724     {
 725         /*
 726          * Run in a while loop, to save clearing the interrupts
 727          * every time around the outside loop.
 728          */
 729         do
 730         {
 731             /* If configured to run the HIP just once, skip first loop */
 732             if (card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE)
 733             {
 734                 break;
 735             }
 736
 737             r = handle_host_protocol(card, &more);
 738             if (r != CSR_RESULT_SUCCESS)
 739             {
 740                 return r;
 741             }
 742
 743 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
 744             unifi_debug_log_to_buf("c52=%d c53=%d tx=%d txc=%d rx=%d s=%d t=%d fc=%d\n",
 745                                    card->cmd_prof.cmd52_count,
 746                                    card->cmd_prof.cmd53_count,
 747                                    card->cmd_prof.tx_count,
 748                                    card->cmd_prof.tx_cfm_count,
 749                                    card->cmd_prof.rx_count,
 750                                    card->cmd_prof.sdio_cmd_signal,
 751                                    card->cmd_prof.sdio_cmd_to_host,
 752                                    card->cmd_prof.sdio_cmd_from_host_and_clear
 753                                    );
 754
 755             card->cmd_prof.cmd52_count = card->cmd_prof.cmd53_count = 0;
 756             card->cmd_prof.tx_count = card->cmd_prof.tx_cfm_count = card->cmd_prof.rx_count = 0;
 757
 758             card->cmd_prof.cmd52_f0_r_count = 0;
 759             card->cmd_prof.cmd52_f0_w_count = 0;
 760             card->cmd_prof.cmd52_r8or16_count = 0;
 761             card->cmd_prof.cmd52_w8or16_count = 0;
 762             card->cmd_prof.cmd52_r16_count = 0;
 763             card->cmd_prof.cmd52_w16_count = 0;
 764             card->cmd_prof.cmd52_r32_count = 0;
 765
 766             card->cmd_prof.sdio_cmd_signal = 0;
 767             card->cmd_prof.sdio_cmd_clear_slot = 0;
 768             card->cmd_prof.sdio_cmd_to_host = 0;
 769             card->cmd_prof.sdio_cmd_from_host = 0;
 770             card->cmd_prof.sdio_cmd_from_host_and_clear = 0;
 771 #endif
 772
 773
 774         } while (more || card->bh_reason_unifi || card->bh_reason_host);
 775
 776         /* Acknowledge the h/w interrupt */
 777         r = CardClearInt(card);
 778         if (r != CSR_RESULT_SUCCESS)
 779         {
 780             unifi_error(card->ospriv, "Failed to acknowledge interrupt.\n");
 781             return r;
 782         }
 783
 784         /*
 785          * UniFi may have tried to generate an interrupt during the
 786          * CardClearInt() was running. So, we need to run the host
 787          * protocol again, to check if there are any pending requests.
 788          */
 789         r = handle_host_protocol(card, &more);
 790         if (r != CSR_RESULT_SUCCESS)
 791         {
 792             return r;
 793         }
 794
 795 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
 796         unifi_debug_log_to_buf("c52=%d c53=%d tx=%d txc=%d rx=%d s=%d t=%d fc=%d\n",
 797                                card->cmd_prof.cmd52_count,
 798                                card->cmd_prof.cmd53_count,
 799                                card->cmd_prof.tx_count,
 800                                card->cmd_prof.tx_cfm_count,
 801                                card->cmd_prof.rx_count,
 802                                card->cmd_prof.sdio_cmd_signal,
 803                                card->cmd_prof.sdio_cmd_to_host,
 804                                card->cmd_prof.sdio_cmd_from_host_and_clear
 805                                );
 806
 807         card->cmd_prof.cmd52_count = card->cmd_prof.cmd53_count = 0;
 808         card->cmd_prof.tx_count = card->cmd_prof.tx_cfm_count = card->cmd_prof.rx_count = 0;
 809
 810         card->cmd_prof.cmd52_f0_r_count = 0;
 811         card->cmd_prof.cmd52_f0_w_count = 0;
 812         card->cmd_prof.cmd52_r8or16_count = 0;
 813         card->cmd_prof.cmd52_w8or16_count = 0;
 814         card->cmd_prof.cmd52_r16_count = 0;
 815         card->cmd_prof.cmd52_w16_count = 0;
 816         card->cmd_prof.cmd52_r32_count = 0;
 817
 818         card->cmd_prof.sdio_cmd_signal = 0;
 819         card->cmd_prof.sdio_cmd_clear_slot = 0;
 820         card->cmd_prof.sdio_cmd_to_host = 0;
 821         card->cmd_prof.sdio_cmd_from_host = 0;
 822         card->cmd_prof.sdio_cmd_from_host_and_clear = 0;
 823 #endif
 824         /* If configured to run the HIP just once, work is now done */
 825         if (card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE)
 826         {
 827             break;
 828         }
 829
 830     } while (more || card->bh_reason_unifi || card->bh_reason_host);
 831
 832 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
 833     if ((card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE) == 0)
 834     {
 835         unifi_debug_log_to_buf("proc=%d\n",
 836                                card->cmd_prof.process_count);
 837     }
 838 #endif
 839
 840     return CSR_RESULT_SUCCESS;
 841 } /* process_bh() */
 842
 843
 844 /*
 845  * ---------------------------------------------------------------------------
 846  *  handle_host_protocol
 847  *
 848  *      This function implements the Host Interface Protocol (HIP) as
 849  *      described in the Host Interface Protocol Specification.
 850  *
 851  *  Arguments:
 852  *      card                 Pointer to card context structure.
 853  *      processed_something  Pointer to location to update processing status:
 854  *                              TRUE when data was transferred
 855  *                              FALSE when no data was transferred (queues empty)
 856  *
 857  *  Returns:
 858  *      CSR_RESULT_SUCCESS on success or CSR error code.
 859  * ---------------------------------------------------------------------------
 860  */
 861 static CsrResult handle_host_protocol(card_t *card, u8 *processed_something)
 862 {
 863     CsrResult r;
 864     s32 done;
 865
 866     *processed_something = FALSE;
 867
 868 #ifdef CSR_WIFI_HIP_NOISY
 869     unifi_error(card->ospriv, "   ========================     \n");
 870 #endif /* CSR_WIFI_HIP_NOISY */
 871
 872 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
 873     card->cmd_prof.process_count++;
 874 #endif
 875
 876     card->bh_reason_unifi = card->bh_reason_host = 0;
 877     card->generate_interrupt = 0;
 878
 879
 880     /*
 881      * (Re)fill the T-H signal buffer
 882      */
 883     r = read_to_host_signals(card, &done);
 884     if (r != CSR_RESULT_SUCCESS)
 885     {
 886         unifi_error(card->ospriv, "Error occured reading to-host signals\n");
 887         return r;
 888     }
 889     if (done > 0)
 890     {
 891         *processed_something = TRUE;
 892     }
 893
 894     /*
 895      * Process any to-host signals.
 896      * Perform any requested CMD53 transfers here, but just queue any
 897      * bulk data command responses.
 898      */
 899     r = process_to_host_signals(card, &done);
 900     if (r != CSR_RESULT_SUCCESS)
 901     {
 902         unifi_error(card->ospriv, "Error occured processing to-host signals\n");
 903         return r;
 904     }
 905
 906     /* Now send any signals in the F-H queues */
 907     /* Give precedence to the command queue */
 908     r = process_fh_cmd_queue(card, &done);
 909     if (r != CSR_RESULT_SUCCESS)
 910     {
 911         unifi_error(card->ospriv, "Error occured processing from-host signals\n");
 912         return r;
 913     }
 914     if (done > 0)
 915     {
 916         *processed_something = TRUE;
 917     }
 918
 919     r = process_fh_traffic_queue(card, &done);
 920     if (r != CSR_RESULT_SUCCESS)
 921     {
 922         unifi_error(card->ospriv, "Error occured processing from-host data signals\n");
 923         return r;
 924     }
 925     if (done > 0)
 926     {
 927         *processed_something = TRUE;
 928     }
 929
 930     /* Flush out the batch of signals to the UniFi. */
 931     r = flush_fh_buffer(card);
 932     if (r != CSR_RESULT_SUCCESS)
 933     {
 934         unifi_error(card->ospriv, "Failed to copy from-host signals to UniFi\n");
 935         return r;
 936     }
 937
 938
 939     /*
 940      * Send the host interrupt to say the queues have been modified.
 941      */
 942     if (card->generate_interrupt)
 943     {
 944         r = CardGenInt(card);
 945         if (r != CSR_RESULT_SUCCESS)
 946         {
 947             unifi_error(card->ospriv, "Failed to notify UniFi that queues have been modified.\n");
 948             return r;
 949         }
 950     }
 951
 952 #ifdef CSR_WIFI_RX_PATH_SPLIT
 953 #ifdef CSR_WIFI_RX_PATH_SPLIT_DONT_USE_WQ
 954     unifi_rx_queue_flush(card->ospriv);
 955 #endif
 956 #endif
 957
 958     /* See if we can re-enable transmission now */
 959     restart_packet_flow(card);
 960
 961 #ifdef CSR_PRE_ALLOC_NET_DATA
 962     r = prealloc_netdata_alloc(card);
 963     if (r != CSR_RESULT_SUCCESS)
 964     {
 965         unifi_error(card->ospriv, "prealloc_netdata failed\n");
 966         return r;
 967     }
 968 #endif
 969
 970     /*
 971      * Don't put the thread sleep if we just interacted with the chip,
 972      * there might be more to do if we look again.
 973      */
 974     return r;
 975 } /* handle_host_protocol() */
 976
 977
 978 /*
 979  *      Rounds the given signal length in bytes to a whole number
 980  *      of sig_frag_size.
 981  */
 982 #define GET_CHUNKS_FOR(SIG_FRAG_SIZE, LENGTH) (((LENGTH) + ((SIG_FRAG_SIZE)-1)) / (SIG_FRAG_SIZE))
 983
 984
 985 /*
 986  * ---------------------------------------------------------------------------
 987  *  read_to_host_signals
 988  *
 989  *      Read everything pending in the UniFi TH signal buffer.
 990  *      Only do it if the local buffer is empty.
 991  *
 992  *  Arguments:
 993  *      card        Pointer to card context struct
 994  *      processed   Number of signals read:
 995  *                      0 if there were no signals pending,
 996  *                      1 if we read at least one signal
 997  *  Returns:
 998  *      CSR error code if an error occurred.
 999  * ---------------------------------------------------------------------------
1000  */
1001 static CsrResult read_to_host_signals(card_t *card, s32 *processed)
1002 {
1003     s32 count_thw, count_thr;
1004     s32 unread_chunks, unread_bytes;
1005     CsrResult r;
1006
1007     *processed = 0;
1008
1009     /* Read any pending signals or bulk data commands */
1010     count_thw = unifi_read_shared_count(card, card->sdio_ctrl_addr + 4);
1011     if (count_thw < 0)
1012     {
1013         unifi_error(card->ospriv, "Failed to read to-host sig written count\n");
1014         return CSR_RESULT_FAILURE;
1015     }
1016     card->to_host_signals_w = count_thw; /* diag */
1017
1018     count_thr = card->to_host_signals_r;
1019
1020     if (count_thw == count_thr)
1021     {
1022         return CSR_RESULT_SUCCESS;
1023     }
1024
1025     unread_chunks =
1026         (((count_thw - count_thr) + 128) % 128) - card->th_buffer.count;
1027
1028     if (unread_chunks == 0)
1029     {
1030         return CSR_RESULT_SUCCESS;
1031     }
1032
1033     unread_bytes = card->config_data.sig_frag_size * unread_chunks;
1034
1035
1036     r = unifi_bulk_rw(card,
1037                       card->config_data.tohost_sigbuf_handle,
1038                       card->th_buffer.ptr,
1039                       unread_bytes,
1040                       UNIFI_SDIO_READ);
1041     if (r != CSR_RESULT_SUCCESS)
1042     {
1043         unifi_error(card->ospriv, "Failed to read ToHost signal\n");
1044         return r;
1045     }
1046
1047     card->th_buffer.ptr += unread_bytes;
1048     card->th_buffer.count += (u16)unread_chunks;
1049
1050     *processed = 1;
1051
1052     return CSR_RESULT_SUCCESS;
1053 } /* read_to_host_signals() */
1054
1055
1056 /*
1057  * ---------------------------------------------------------------------------
1058  *  update_to_host_signals_r
1059  *
1060  *      Advance the shared-memory count of chunks read from the to-host
1061  *      signal buffer.
1062  *      Raise a UniFi internal interrupt to tell the firmware that the
1063  *      count has changed.
1064  *
1065  *  Arguments:
1066  *      card            Pointer to card context struct
1067  *      pending         Number of chunks remaining
1068  *
1069  *  Returns:
1070  *      CSR_RESULT_SUCCESS on success or CSR error code
1071  * ---------------------------------------------------------------------------
1072  */
1073 static CsrResult update_to_host_signals_r(card_t *card, s16 pending)
1074 {
1075     CsrResult r;
1076
1077     card->to_host_signals_r =
1078         (card->to_host_signals_r + (card->th_buffer.count - pending)) % 128;
1079     card->th_buffer.count = pending;
1080
1081     /* Update the count of signals read */
1082     r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 6,
1083                             (u8)card->to_host_signals_r);
1084     if (r != CSR_RESULT_SUCCESS)
1085     {
1086         unifi_error(card->ospriv, "Failed to update to-host signals read\n");
1087         return r;
1088     }
1089
1090     r = CardGenInt(card);
1091     if (r != CSR_RESULT_SUCCESS)
1092     {
1093         unifi_error(card->ospriv, "Failed to notify UniFi that we processed to-host signals.\n");
1094         return r;
1095     }
1096
1097     card->generate_interrupt = 0;
1098
1099     return CSR_RESULT_SUCCESS;
1100 } /* update_to_host_signals_r() */
1101
1102
1103 /*
1104  * ---------------------------------------------------------------------------
1105  *  read_unpack_cmd
1106  *
1107  *      Converts a wire-formatted command to the host bulk_data_cmd_t structure.
1108  *
1109  *  Arguments:
1110  *      ptr             Pointer to the command
1111  *      bulk_data_cmd   Pointer to the host structure
1112  *
1113  *  Returns:
1114  *      None.
1115  * ---------------------------------------------------------------------------
1116  */
1117 static void read_unpack_cmd(const u8 *ptr, bulk_data_cmd_t *bulk_data_cmd)
1118 {
1119     s16 index = 0;
1120     bulk_data_cmd->cmd_and_len = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
1121     index += SIZEOF_UINT16;
1122     bulk_data_cmd->data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
1123     index += SIZEOF_UINT16;
1124     bulk_data_cmd->offset = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
1125     index += SIZEOF_UINT16;
1126     bulk_data_cmd->buffer_handle = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
1127     index += SIZEOF_UINT16;
1128 } /* read_unpack_cmd */
1129
1130
1131 /*
1132  * ---------------------------------------------------------------------------
1133  *  process_to_host_signals
1134  *
1135  *      Read and dispatch signals from the UniFi
1136  *
1137  *  Arguments:
1138  *      card        Pointer to card context struct
1139  *      processed   Pointer to location to write processing result:
1140  *                      0 if there were no signals pending,
1141  *                      1 if we read at least one signal
1142  *
1143  *  Returns:
1144  *      CSR error code if there was an error
1145  *
1146  *  Notes:
1147  *      Since bulk data transfers can take a long time, if we wait until
1148  *      all are done before we acknowledge the signals, the UniFi runs out
1149  *      of buffer space. Therefore we keep a count of the bytes transferred
1150  *      in bulk data commands, and update the to-host-signals-read count
1151  *      if we've done a large transfer.
1152  *
1153  *      All data in the f/w is stored in a little endian format, without any
1154  *      padding bytes. Every read from the memory has to be transformed in
1155  *      host (cpu specific) format, before we can process it. Therefore we
1156  *      use read_unpack_cmd() and read_unpack_signal() to convert the raw data
1157  *      contained in the card->th_buffer.buf to host structures.
1158  *      Important: UDI clients use wire-formatted structures, so we need to
1159  *      indicate all data, as we have read it from the device.
1160  * ---------------------------------------------------------------------------
1161  */
1162 static CsrResult process_to_host_signals(card_t *card, s32 *processed)
1163 {
1164     s16 pending;
1165     s16 remaining;
1166     u8 *bufptr;
1167     bulk_data_param_t data_ptrs;
1168     s16 cmd;
1169     u16 sig_len;
1170     s16 i;
1171     u16 chunks_in_buf;
1172     u16 bytes_transferred = 0;
1173     CsrResult r = CSR_RESULT_SUCCESS;
1174
1175     *processed = 0;
1176
1177     pending = card->th_buffer.count;
1178
1179     /* Are there new to-host signals? */
1180     unifi_trace(card->ospriv, UDBG4, "handling %d to-host chunks\n", pending);
1181
1182     if (!pending)
1183     {
1184         return CSR_RESULT_SUCCESS;
1185     }
1186
1187     /*
1188      * This is a pointer to the raw data we have read from the f/w.
1189      * Can be a signal or a command. Note that we need to convert
1190      * it to a host structure before we process it.
1191      */
1192     bufptr = card->th_buffer.buf;
1193
1194     while (pending > 0)
1195     {
1196         s16 f_flush_count = 0;
1197
1198         /*
1199          * Command and length are common to signal and bulk data msgs.
1200          * If command == 0 (i.e. a signal), len is number of bytes
1201          * *following* the 2-byte header.
1202          */
1203         cmd = bufptr[1] >> 4;
1204         sig_len = bufptr[0] + ((bufptr[1] & 0x0F) << 8);
1205
1206 #ifdef CSR_WIFI_HIP_NOISY
1207         unifi_error(card->ospriv, "Received UniFi msg cmd=%d, len=%d\n",
1208                     cmd, sig_len);
1209 #endif  /* CSR_WIFI_HIP_NOISY */
1210
1211         if ((sig_len == 0) &&
1212             ((cmd != SDIO_CMD_CLEAR_SLOT) && (cmd != SDIO_CMD_PADDING)))
1213         {
1214             unifi_error(card->ospriv, "incomplete signal or command: has size zero\n");
1215             return CSR_RESULT_FAILURE;
1216         }
1217         /*
1218          * Make sure the buffer contains a complete message.
1219          * Signals may occupy multiple chunks, bulk-data commands occupy
1220          * one chunk.
1221          */
1222         if (cmd == SDIO_CMD_SIGNAL)
1223         {
1224             chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(sig_len + 2));
1225         }
1226         else
1227         {
1228             chunks_in_buf = 1;
1229         }
1230
1231         if (chunks_in_buf > (u16)pending)
1232         {
1233             unifi_error(card->ospriv, "incomplete signal (0x%x?): need %d chunks, got %d\n",
1234                         GET_SIGNAL_ID(bufptr + 2),
1235                         chunks_in_buf, pending);
1236             unifi_error(card->ospriv, " thsw=%d, thsr=%d\n",
1237                         card->to_host_signals_w,
1238                         card->to_host_signals_r);
1239             return CSR_RESULT_FAILURE;
1240         }
1241
1242
1243         switch (cmd)
1244         {
1245             case SDIO_CMD_SIGNAL:
1246                 /* This is a signal. Read the rest of it and then handle it. */
1247 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1248                 card->cmd_prof.sdio_cmd_signal++;
1249 #endif
1250
1251                 for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
1252                 {
1253                     /* Retrieve dataRefs[i].DataLength */
1254                     u16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i);
1255
1256                     /*
1257                      * The bulk data length in the signal can not be greater than
1258                      * the maximun length allowed by the SDIO config structure.
1259                      */
1260                     if (data_len > card->config_data.data_slot_size)
1261                     {
1262                         unifi_error(card->ospriv,
1263                                     "Bulk Data length (%d) exceeds Maximum Bulk Data length (%d)\n",
1264                                     data_len, card->config_data.data_slot_size);
1265                         return CSR_RESULT_FAILURE;
1266                     }
1267
1268                     /*
1269                      * Len here might not be the same as the length in the
1270                      * bulk data slot.  The slot length will always be even,
1271                      * but len could be odd.
1272                      */
1273                     if (data_len != 0)
1274                     {
1275                     /* Retrieve dataRefs[i].SlotNumber */
1276                         s16 slot = GET_PACKED_DATAREF_SLOT(bufptr + 2, i);
1277
1278                         if (slot >= card->config_data.num_tohost_data_slots)
1279                         {
1280                             unifi_error(card->ospriv, "!!!bad slot number in to-host signal: %d, sig 0x%X\n",
1281                                         slot, cmd);
1282                             return CSR_RESULT_FAILURE;
1283                         }
1284
1285                         data_ptrs.d[i].os_data_ptr = card->to_host_data[slot].os_data_ptr;
1286                         data_ptrs.d[i].os_net_buf_ptr = card->to_host_data[slot].os_net_buf_ptr;
1287                         data_ptrs.d[i].net_buf_length = card->to_host_data[slot].net_buf_length;
1288                         data_ptrs.d[i].data_length = data_len;
1289                     }
1290                     else
1291                     {
1292                         UNIFI_INIT_BULK_DATA(&data_ptrs.d[i]);
1293                     }
1294                 }
1295
1296             /*
1297              * Log the signal to the UDI, before call unifi_receive_event() as
1298              * it can modify the bulk data.
1299              */
1300                 if (card->udi_hook)
1301                 {
1302                     (*card->udi_hook)(card->ospriv, bufptr + 2, sig_len,
1303                                       &data_ptrs, UDI_LOG_TO_HOST);
1304                 }
1305
1306 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
1307                 if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID)
1308                 {
1309                     card->cmd_prof.tx_cfm_count++;
1310                 }
1311                 else if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_INDICATION_ID)
1312                 {
1313                     if (data_ptrs.d[0].os_data_ptr)
1314                     {
1315                         if ((*data_ptrs.d[0].os_data_ptr) & 0x08)
1316                         {
1317                             card->cmd_prof.rx_count++;
1318                         }
1319                     }
1320                 }
1321 #endif
1322                 /*
1323                  * Check if the signal is MA-PACKET.cfm and if so check the status.
1324                  * If the status is failure, search through the slot records to find
1325                  * if any slots are occupied for this host tag. This can happen if
1326                  * f/w has not downloaded the bulkdata and before that itself it has
1327                  * signalled the confirm with failure. If it finds a slot with that
1328                  * host tag then, it clears the corresponding slot
1329                  */
1330
1331                 if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID)
1332                 {
1333                     /* Get host tag and transmission status */
1334                     u32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2);
1335                     u16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(bufptr + 2);
1336
1337                     unifi_trace(card->ospriv, UDBG4, "process_to_host_signals signal ID=%x host Tag=%x status=%x\n",
1338                                 GET_SIGNAL_ID(bufptr + 2), host_tag, status);
1339
1340                     /* If transmission status is failure then search through the slot records
1341                      * and if for any slot records the clear slot is not done then do it now
1342                      */
1343
1344                     if (status && (card->fh_slot_host_tag_record))
1345                     {
1346                         u16 num_fh_slots = card->config_data.num_fromhost_data_slots;
1347
1348                         /* search through the list of slot records and match with host tag
1349                          * If a slot is not yet cleared then clear the slot from here
1350                          */
1351                         for (i = 0; i < num_fh_slots; i++)
1352                         {
1353                             if (card->fh_slot_host_tag_record[i] == host_tag)
1354                             {
1355 #ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
1356                                 /* Invoke the HAL module function to requeue it back to HAL Queues */
1357                                 r = unifi_reque_ma_packet_request(card->ospriv, host_tag, status, &card->from_host_data[i].bd);
1358                                 card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
1359                                 if (CSR_RESULT_SUCCESS != r)
1360                                 {
1361                                     unifi_trace(card->ospriv, UDBG5, "process_to_host_signals: Failed to requeue Packet(hTag:%x) back to HAL \n", host_tag);
1362                                     CardClearFromHostDataSlot(card, i);
1363                                 }
1364                                 else
1365                                 {
1366                                     CardClearFromHostDataSlotWithoutFreeingBulkData(card, i);
1367                                 }
1368
1369 #else
1370                                 unifi_trace(card->ospriv, UDBG4, "process_to_host_signals Clear slot=%x host tag=%x\n", i, host_tag);
1371                                 card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
1372
1373                                 /* Set length field in from_host_data array to 0 */
1374                                 CardClearFromHostDataSlot(card, i);
1375 #endif
1376                                 break;
1377                             }
1378                         }
1379                     }
1380                 }
1381
1382                 /* Pass event to OS layer */
1383                 unifi_receive_event(card->ospriv, bufptr + 2, sig_len, &data_ptrs);
1384
1385                 /* Initialise the to_host data, so it can be re-used. */
1386                 for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
1387                 {
1388                 /* The slot is only valid if the length is non-zero. */
1389                     if (GET_PACKED_DATAREF_LEN(bufptr + 2, i) != 0)
1390                     {
1391                         s16 slot = GET_PACKED_DATAREF_SLOT(bufptr + 2, i);
1392                         if (slot < card->config_data.num_tohost_data_slots)
1393                         {
1394                             UNIFI_INIT_BULK_DATA(&card->to_host_data[slot]);
1395                         }
1396                     }
1397                 }
1398
1399 #ifndef CSR_WIFI_DEFER_TH_FLUSH
1400                 /*
1401                  * If we have previously transferred a lot of data, ack
1402                  * the signals read so far, so f/w can reclaim the buffer
1403                  * memory sooner.
1404                  */
1405                 if (bytes_transferred >= TO_HOST_FLUSH_THRESHOLD)
1406                 {
1407                     f_flush_count = 1;
1408                 }
1409 #endif
1410                 break;
1411
1412
1413             case SDIO_CMD_CLEAR_SLOT:
1414 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1415                 card->cmd_prof.sdio_cmd_clear_slot++;
1416 #endif
1417                 /* This is a clear slot command. */
1418                 if (sig_len != 0)
1419                 {
1420                     unifi_error(card->ospriv, "process_to_host_signals: clear slot, bad data len: 0x%X at offset %d\n",
1421                                 sig_len, bufptr - card->th_buffer.buf);
1422                     return CSR_RESULT_FAILURE;
1423                 }
1424
1425                 r = process_clear_slot_command(card, bufptr);
1426                 if (r != CSR_RESULT_SUCCESS)
1427                 {
1428                     unifi_error(card->ospriv, "Failed to process clear slot\n");
1429                     return r;
1430                 }
1431                 break;
1432
1433             case SDIO_CMD_TO_HOST_TRANSFER:
1434             case SDIO_CMD_FROM_HOST_TRANSFER:
1435             case SDIO_CMD_FROM_HOST_AND_CLEAR:
1436             case SDIO_CMD_OVERLAY_TRANSFER:
1437                 /* This is a bulk data command. */
1438                 if (sig_len & 1)
1439                 {
1440                     unifi_error(card->ospriv, "process_to_host_signals: bulk data, bad data len: 0x%X at offset %d\n",
1441                                 sig_len, bufptr - card->th_buffer.buf);
1442                     return CSR_RESULT_FAILURE;
1443                 }
1444
1445                 r = process_bulk_data_command(card, bufptr, cmd, sig_len);
1446                 if (r != CSR_RESULT_SUCCESS)
1447                 {
1448                     unifi_error(card->ospriv, "Failed to process bulk cmd\n");
1449                     return r;
1450                 }
1451                 /* Count the bytes transferred */
1452                 bytes_transferred += sig_len;
1453
1454                 if (cmd == SDIO_CMD_FROM_HOST_AND_CLEAR)
1455                 {
1456 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1457                     card->cmd_prof.sdio_cmd_from_host_and_clear++;
1458 #endif
1459 #ifndef CSR_WIFI_DEFER_TH_FLUSH
1460                     f_flush_count = 1;
1461 #endif
1462                 }
1463 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1464                 else if (cmd == SDIO_CMD_FROM_HOST_TRANSFER)
1465                 {
1466                     card->cmd_prof.sdio_cmd_from_host++;
1467                 }
1468                 else if (cmd == SDIO_CMD_TO_HOST_TRANSFER)
1469                 {
1470                     card->cmd_prof.sdio_cmd_to_host++;
1471                 }
1472 #endif
1473                 break;
1474
1475             case SDIO_CMD_PADDING:
1476                 break;
1477
1478             default:
1479                 unifi_error(card->ospriv, "Unrecognised to-host command: %d\n", cmd);
1480                 break;
1481         }
1482
1483         bufptr += chunks_in_buf * card->config_data.sig_frag_size;
1484         pending -= chunks_in_buf;
1485
1486         /*
1487          * Write out the host signal count when a significant
1488          * number of bytes of bulk data have been transferred or
1489          * when we have performed a CopyFromHostAndClear.
1490          */
1491         if (f_flush_count)
1492         {
1493             r = update_to_host_signals_r(card, pending);
1494             if (r != CSR_RESULT_SUCCESS)
1495             {
1496                 return r;
1497             }
1498             bytes_transferred = 0;
1499         }
1500     }
1501
1502     if (pending)
1503     {
1504         unifi_warning(card->ospriv, "proc_th_sigs: %d unprocessed\n", pending);
1505     }
1506
1507     /* If we processed any signals, write the updated count to UniFi */
1508     if (card->th_buffer.count != pending)
1509     {
1510         r = update_to_host_signals_r(card, pending);
1511         if (r != CSR_RESULT_SUCCESS)
1512         {
1513             return r;
1514         }
1515     }
1516
1517     /*
1518      * Reset the buffer pointer, copying down any un-processed signals.
1519      * This can happen if we enable the optimisation in read_to_host_signals()
1520      * that limits the length to whole blocks.
1521      */
1522     remaining = card->th_buffer.ptr - bufptr;
1523     if (remaining < 0)
1524     {
1525         unifi_error(card->ospriv, "Processing TH signals overran the buffer\n");
1526         return CSR_RESULT_FAILURE;
1527     }
1528     if (remaining > 0)
1529     {
1530         /* Use a safe copy because source and destination may overlap */
1531         u8 *d = card->th_buffer.buf;
1532         u8 *s = bufptr;
1533         s32 n = remaining;
1534         while (n--)
1535         {
1536             *d++ = *s++;
1537         }
1538     }
1539     card->th_buffer.ptr = card->th_buffer.buf + remaining;
1540
1541
1542     /* If we reach here then we processed something */
1543     *processed = 1;
1544     return CSR_RESULT_SUCCESS;
1545 } /* process_to_host_signals() */
1546
1547
1548 /*
1549  * ---------------------------------------------------------------------------
1550  *  process_clear_slot_command
1551  *
1552  *      Process a clear slot command fom the UniFi.
1553  *
1554  *  Arguments:
1555  *   card       Pointer to card context struct
1556  *   bdcmd      Pointer to bulk-data command msg from UniFi
1557  *
1558  *  Returns:
1559  *      0 on success, CSR error code on error
1560  * ---------------------------------------------------------------------------
1561  */
1562 static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr)
1563 {
1564     u16 data_slot;
1565     s16 slot;
1566
1567     data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cmdptr + SIZEOF_UINT16);
1568
1569     unifi_trace(card->ospriv, UDBG4, "Processing clear slot cmd, slot=0x%X\n",
1570                 data_slot);
1571
1572     slot = data_slot & 0x7FFF;
1573
1574 #ifdef CSR_WIFI_HIP_NOISY
1575     unifi_error(card->ospriv, "CMD clear data slot 0x%04x\n", data_slot);
1576 #endif /* CSR_WIFI_HIP_NOISY */
1577
1578     if (data_slot & SLOT_DIR_TO_HOST)
1579     {
1580         if (slot >= card->config_data.num_tohost_data_slots)
1581         {
1582             unifi_error(card->ospriv,
1583                         "Invalid to-host data slot in SDIO_CMD_CLEAR_SLOT: %d\n",
1584                         slot);
1585             return CSR_RESULT_FAILURE;
1586         }
1587         /* clear to-host data slot */
1588         unifi_warning(card->ospriv, "Unexpected clear to-host data slot cmd: 0x%04x\n",
1589                       data_slot);
1590     }
1591     else
1592     {
1593         if (slot >= card->config_data.num_fromhost_data_slots)
1594         {
1595             unifi_error(card->ospriv,
1596                         "Invalid from-host data slot in SDIO_CMD_CLEAR_SLOT: %d\n",
1597                         slot);
1598             return CSR_RESULT_FAILURE;
1599         }
1600
1601         /*
1602          * The driver is the owner to clear all slots now
1603          * Ref - comment in process_fh_traffic_queue
1604          * so it will just ignore the clear slot command from firmware
1605          * and return success
1606          */
1607         return CSR_RESULT_SUCCESS;
1608
1609         /* Set length field in from_host_data array to 0 */
1610         /* CardClearFromHostDataSlot(card, slot); */
1611     }
1612
1613     return CSR_RESULT_SUCCESS;
1614 } /* process_clear_slot_command() */
1615
1616
1617 /*
1618  * ---------------------------------------------------------------------------
1619  *  process_bulk_data_command
1620  *
1621  *      Process a bulk data request from the UniFi.
1622  *
1623  *  Arguments:
1624  *   card       Pointer to card context struct
1625  *   bdcmd      Pointer to bulk-data command msg from UniFi
1626  *   cmd, len   Decoded values of command and length from the msg header
1627  *              Cmd will only be one of:
1628  *                      SDIO_CMD_TO_HOST_TRANSFER
1629  *                      SDIO_CMD_FROM_HOST_TRANSFER
1630  *                      SDIO_CMD_FROM_HOST_AND_CLEAR
1631  *                      SDIO_CMD_OVERLAY_TRANSFER
1632  *
1633  *  Returns:
1634  *      CSR_RESULT_SUCCESS on success, CSR error code on error
1635  * ---------------------------------------------------------------------------
1636  */
1637 static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr,
1638                                            s16 cmd, u16 len)
1639 {
1640     bulk_data_desc_t *bdslot;
1641 #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
1642     u8 *host_bulk_data_slot;
1643 #endif
1644     bulk_data_cmd_t bdcmd;
1645     s16 offset;
1646     s16 slot;
1647     s16 dir;
1648     CsrResult r;
1649
1650     read_unpack_cmd(cmdptr, &bdcmd);
1651
1652     unifi_trace(card->ospriv, UDBG4, "Processing bulk data cmd %d %s, len=%d, slot=0x%X\n",
1653                 cmd, lookup_bulkcmd_name(cmd), len, bdcmd.data_slot);
1654
1655     /*
1656      * Round up the transfer length if required.
1657      * This is useful to force all transfers to be a multiple of the SDIO block
1658      * size, so the SDIO driver won't try to use a byte-mode CMD53. These are
1659      * broken on some hardware platforms.
1660      */
1661     if (card->sdio_io_block_pad)
1662     {
1663         len = (len + card->sdio_io_block_size - 1) & ~(card->sdio_io_block_size - 1);
1664         unifi_trace(card->ospriv, UDBG4, "Rounded bulk data length up to %d\n", len);
1665     }
1666
1667     slot = bdcmd.data_slot & 0x7FFF;
1668
1669     if (cmd == SDIO_CMD_OVERLAY_TRANSFER)
1670     {
1671         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;     /* Not used on CSR6xxx */
1672     }
1673     else
1674     {
1675         if (bdcmd.data_slot & SLOT_DIR_TO_HOST)
1676         {
1677             /* Request is for to-host bulk data */
1678
1679             /* Check sanity of slot number */
1680             if (slot >= card->config_data.num_tohost_data_slots)
1681             {
1682                 unifi_error(card->ospriv,
1683                             "Invalid to-host data slot in SDIO bulk xfr req: %d\n",
1684                             slot);
1685                 return CSR_RESULT_FAILURE;
1686             }
1687
1688             /* Allocate memory for card->to_host_data[slot] bulk data here. */
1689 #ifdef CSR_PRE_ALLOC_NET_DATA
1690             r = prealloc_netdata_get(card, &card->to_host_data[slot], len);
1691 #else
1692             r = unifi_net_data_malloc(card->ospriv, &card->to_host_data[slot], len);
1693 #endif
1694             if (r != CSR_RESULT_SUCCESS)
1695             {
1696                 unifi_error(card->ospriv, "Failed to allocate t-h bulk data\n");
1697                 return CSR_RESULT_FAILURE;
1698             }
1699
1700             bdslot = &card->to_host_data[slot];
1701
1702             /* Make sure that the buffer is 4-bytes aligned */
1703             r = unifi_net_dma_align(card->ospriv, bdslot);
1704             if (r != CSR_RESULT_SUCCESS)
1705             {
1706                 unifi_error(card->ospriv, "Failed to align t-h bulk data buffer for DMA\n");
1707                 return CSR_RESULT_FAILURE;
1708             }
1709         }
1710         else
1711         {
1712             /* Request is for from-host bulk data */
1713
1714             if (slot >= card->config_data.num_fromhost_data_slots)
1715             {
1716                 unifi_error(card->ospriv,
1717                             "Invalid from-host data slot in SDIO bulk xfr req: %d\n",
1718                             slot);
1719                 return CSR_RESULT_FAILURE;
1720             }
1721             bdslot = &card->from_host_data[slot].bd;
1722         }
1723         offset = bdcmd.offset;
1724     }
1725     /* Do the transfer */
1726     dir = (cmd == SDIO_CMD_TO_HOST_TRANSFER)?
1727           UNIFI_SDIO_READ : UNIFI_SDIO_WRITE;
1728
1729     unifi_trace(card->ospriv, UDBG4,
1730                 "Bulk %c %s len=%d, handle %d - slot=%d %p+(%d)\n",
1731                 (dir == UNIFI_SDIO_READ)?'R' : 'W',
1732                 lookup_bulkcmd_name(cmd),
1733                 len,
1734                 bdcmd.buffer_handle,
1735                 slot, bdslot->os_data_ptr, offset);
1736 #ifdef CSR_WIFI_HIP_NOISY
1737     unifi_error(card->ospriv, "Bulk %s len=%d, handle %d - slot=%d %p+(%d)\n",
1738                 lookup_bulkcmd_name(cmd),
1739                 len,
1740                 bdcmd.buffer_handle,
1741                 slot, bdslot->os_data_ptr, offset);
1742 #endif /* CSR_WIFI_HIP_NOISY */
1743
1744
1745     if (bdslot->os_data_ptr == NULL)
1746     {
1747         unifi_error(card->ospriv, "Null os_data_ptr - Bulk %s handle %d - slot=%d o=(%d)\n",
1748                     lookup_bulkcmd_name(cmd),
1749                     bdcmd.buffer_handle,
1750                     slot,
1751                     offset);
1752         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
1753     }
1754
1755 #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
1756     /* if os_data_ptr is not 4-byte aligned, then allocate a new buffer and copy data
1757     to new buffer to ensure the address passed to unifi_bulk_rw is 4-byte aligned */
1758
1759     if (len != 0 && (dir == UNIFI_SDIO_WRITE) && (((ptrdiff_t)bdslot->os_data_ptr + offset) & 3))
1760     {
1761         host_bulk_data_slot = kmalloc(len, GFP_KERNEL);
1762
1763         if (!host_bulk_data_slot)
1764         {
1765             unifi_error(card->ospriv, " failed to allocate request_data before unifi_bulk_rw\n");
1766             return -1;
1767         }
1768
1769         memcpy((void *)host_bulk_data_slot,
1770                   (void *)(bdslot->os_data_ptr + offset), len);
1771
1772         r = unifi_bulk_rw(card,
1773                           bdcmd.buffer_handle,
1774                           (void *)host_bulk_data_slot,
1775                           len,
1776                           dir);
1777     }
1778     else
1779 #endif
1780     {
1781         r = unifi_bulk_rw(card,
1782                           bdcmd.buffer_handle,
1783                           (void *)(bdslot->os_data_ptr + offset),
1784                           len,
1785                           dir);
1786     }
1787
1788     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
1789     {
1790         return r;
1791     }
1792     if (r != CSR_RESULT_SUCCESS)
1793     {
1794         unifi_error(card->ospriv,
1795                     "Failed: %s hlen=%d, slen=%d, handle %d - slot=%d %p+0x%X\n",
1796                     lookup_bulkcmd_name(cmd),
1797                     len,                    /* Header length */
1798                     bdslot->data_length,    /* Length stored in slot */
1799                     bdcmd.buffer_handle,
1800                     slot, bdslot->os_data_ptr, offset);
1801         return r;
1802     }
1803
1804     bdslot->data_length = len;
1805
1806     if (cmd == SDIO_CMD_FROM_HOST_AND_CLEAR)
1807     {
1808         if (slot >= card->config_data.num_fromhost_data_slots)
1809         {
1810             unifi_error(card->ospriv,
1811                         "Invalid from-host data slot in SDIO_CMD_FROM_HOST_AND_CLEAR: %d\n",
1812                         slot);
1813             return CSR_RESULT_FAILURE;
1814         }
1815
1816 #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
1817         /* moving this check before we clear host data slot */
1818         if ((len != 0) && (dir == UNIFI_SDIO_WRITE) && (((ptrdiff_t)bdslot->os_data_ptr + offset) & 3))
1819         {
1820             kfree(host_bulk_data_slot);
1821         }
1822 #endif
1823
1824         if (card->fh_slot_host_tag_record)
1825         {
1826             unifi_trace(card->ospriv, UDBG5, "CopyFromHostAndClearSlot Reset entry for slot=%d\n", slot);
1827
1828             /* reset the host tag entry for the corresponding slot */
1829             card->fh_slot_host_tag_record[slot] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
1830         }
1831
1832
1833         /* Set length field in from_host_data array to 0 */
1834         CardClearFromHostDataSlot(card, slot);
1835     }
1836
1837     return CSR_RESULT_SUCCESS;
1838 } /* process_bulk_data_command() */
1839
1840
1841 /*
1842  * ---------------------------------------------------------------------------
1843  *  check_fh_sig_slots
1844  *
1845  *      Check whether there are <n> free signal slots available on UniFi.
1846  *      This takes into account the signals already batched since the
1847  *      from_host_signal counts were last read.
1848  *      If the from_host_signal counts indicate not enough space, we read
1849  *      the latest count from UniFi to see if some more have been freed.
1850  *
1851  *  Arguments:
1852  *      None.
1853  *
1854  *  Returns:
1855  *      CSR_RESULT_SUCCESS, otherwise CSR error code on error.
1856  * ---------------------------------------------------------------------------
1857  */
1858 static CsrResult check_fh_sig_slots(card_t *card, u16 needed, s32 *space_fh)
1859 {
1860     u32 count_fhw;
1861     u32 occupied_fh, slots_fh;
1862     s32 count_fhr;
1863
1864     count_fhw = card->from_host_signals_w;
1865     count_fhr = card->from_host_signals_r;
1866     slots_fh = card->config_data.num_fromhost_sig_frags;
1867
1868     /* Only read the space in from-host queue if necessary */
1869     occupied_fh = (count_fhw - count_fhr) % 128;
1870
1871     if (slots_fh < occupied_fh)
1872     {
1873         *space_fh = 0;
1874     }
1875     else
1876     {
1877         *space_fh = slots_fh - occupied_fh;
1878     }
1879
1880     if ((occupied_fh != 0) && (*space_fh < needed))
1881     {
1882         count_fhr = unifi_read_shared_count(card, card->sdio_ctrl_addr + 2);
1883         if (count_fhr < 0)
1884         {
1885             unifi_error(card->ospriv, "Failed to read from-host sig read count\n");
1886             return CSR_RESULT_FAILURE;
1887         }
1888         card->from_host_signals_r = count_fhr; /* diag */
1889
1890         occupied_fh = (count_fhw - count_fhr) % 128;
1891         *space_fh = slots_fh - occupied_fh;
1892     }
1893
1894     return CSR_RESULT_SUCCESS;
1895 } /* check_fh_sig_slots() */
1896
1897
1898 /*
1899 * If we are padding the From-Host signals to the SDIO block size,
1900 * we need to round up the needed_chunks to the SDIO block size.
1901 */
1902 #define ROUND_UP_NEEDED_CHUNKS(_card, _needed_chunks) \
1903     { \
1904         u16 _chunks_per_block; \
1905         u16 _chunks_in_last_block; \
1906  \
1907         if (_card->sdio_io_block_pad) \
1908         { \
1909             _chunks_per_block = _card->sdio_io_block_size / _card->config_data.sig_frag_size; \
1910             _chunks_in_last_block = _needed_chunks % _chunks_per_block; \
1911             if (_chunks_in_last_block != 0) \
1912             { \
1913                 _needed_chunks = _needed_chunks + (_chunks_per_block - _chunks_in_last_block); \
1914             } \
1915         } \
1916     }
1917
1918
1919 #define ROUND_UP_SPACE_CHUNKS(_card, _space_chunks) \
1920     { \
1921         u16 _chunks_per_block; \
1922  \
1923         if (_card->sdio_io_block_pad) \
1924         { \
1925             _chunks_per_block = _card->sdio_io_block_size / _card->config_data.sig_frag_size; \
1926             _space_chunks = ((_space_chunks / _chunks_per_block) * _chunks_per_block); \
1927         } \
1928     }
1929
1930
1931
1932
1933
1934 /*
1935  * ---------------------------------------------------------------------------
1936  *  process_fh_cmd_queue
1937  *
1938  *      Take one signal off the from-host queue and copy it to the UniFi.
1939  *      Does nothing if the UniFi has no slots free.
1940  *
1941  *  Arguments:
1942  *      card       Pointer to card context struct
1943  *      processed  Location to write:
1944  *                      0 if there is nothing on the queue to process
1945  *                      1 if a signal was successfully processed
1946  *
1947  *  Returns:
1948  *      CSR error code if an error occurred.
1949  *
1950  *  Notes:
1951  *      The from-host queue contains signal requests from the network driver
1952  *      and any UDI clients interspersed. UDI clients' requests have been stored
1953  *      in the from-host queue using the wire-format structures, as they arrive.
1954  *      All other requests are stored in the from-host queue using the host
1955  *      (cpu specific) structures. We use the is_packed member of the card_signal_t
1956  *      structure that describes the queue to make the distiction.
1957  * ---------------------------------------------------------------------------
1958  */
1959 static CsrResult process_fh_cmd_queue(card_t *card, s32 *processed)
1960 {
1961     q_t *sigq = &card->fh_command_queue;
1962
1963     CsrResult r;
1964     u16 pending_sigs;
1965     u16 pending_chunks;
1966     u16 needed_chunks;
1967     s32 space_chunks;
1968     u16 q_index;
1969
1970     *processed = 0;
1971
1972     /* Get the number of pending signals. */
1973     pending_sigs = CSR_WIFI_HIP_Q_SLOTS_USED(sigq);
1974     unifi_trace(card->ospriv, UDBG5, "proc_fh: %d pending\n", pending_sigs);
1975     if (pending_sigs == 0)
1976     {
1977         /* Nothing to do */
1978         return CSR_RESULT_SUCCESS;
1979     }
1980
1981     /* Work out how many chunks we have waiting to send */
1982     for (pending_chunks = 0, q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq);
1983          q_index != CSR_WIFI_HIP_Q_NEXT_W_SLOT(sigq);
1984          q_index = CSR_WIFI_HIP_Q_WRAP(sigq, q_index + 1))
1985     {
1986         card_signal_t *csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, q_index);
1987
1988         /*
1989          * Note that GET_CHUNKS_FOR() needs the size of the packed
1990          * (wire-formatted) structure
1991          */
1992         pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2));
1993     }
1994
1995     /*
1996      * Check whether UniFi has space for all the buffered bulk-data
1997      * commands and signals as well.
1998      */
1999     needed_chunks = pending_chunks + card->fh_buffer.count;
2000
2001     /* Round up to the block size if necessary */
2002     ROUND_UP_NEEDED_CHUNKS(card, needed_chunks);
2003
2004     r = check_fh_sig_slots(card, needed_chunks, &space_chunks);
2005     if (r != CSR_RESULT_SUCCESS)
2006     {
2007         /* Error */
2008         unifi_error(card->ospriv, "Failed to read fh sig count\n");
2009         return r;
2010     }
2011
2012 #ifdef CSR_WIFI_HIP_NOISY
2013     unifi_error(card->ospriv, "proc_fh: %d chunks free, need %d\n",
2014                 space_chunks, needed_chunks);
2015 #endif /* CSR_WIFI_HIP_NOISY */
2016
2017
2018     /*
2019      * Coalesce as many from-host signals as possible
2020      * into a single block and write using a single CMD53
2021      */
2022     if (needed_chunks > (u16)space_chunks)
2023     {
2024         /* Round up to the block size if necessary */
2025         ROUND_UP_SPACE_CHUNKS(card, space_chunks);
2026
2027         /*
2028          * If the f/w has less free chunks than those already pending
2029          * return immediately.
2030          */
2031         if ((u16)space_chunks <= card->fh_buffer.count)
2032         {
2033             /*
2034              * No room in UniFi for any signals after the buffered bulk
2035              * data commands have been sent.
2036              */
2037             unifi_error(card->ospriv, "not enough room to send signals, need %d chunks, %d free\n",
2038                         card->fh_buffer.count, space_chunks);
2039             card->generate_interrupt = 1;
2040             return CSR_RESULT_SUCCESS;
2041         }
2042         pending_chunks = (u16)(space_chunks - card->fh_buffer.count);
2043     }
2044
2045     while (pending_sigs-- && pending_chunks > 0)
2046     {
2047         card_signal_t *csptr;
2048         s16 i;
2049         u16 sig_chunks, total_length, free_chunks_in_fh_buffer;
2050         bulk_data_param_t bulkdata;
2051         u8 *packed_sigptr;
2052         u16 signal_length = 0;
2053
2054         /* Retrieve the entry at the head of the queue */
2055         q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq);
2056
2057         /* Get a pointer to the containing card_signal_t struct */
2058         csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, q_index);
2059
2060         /* Get the new length of the packed signal */
2061         signal_length = csptr->signal_length;
2062
2063         if ((signal_length & 1) || (signal_length > UNIFI_PACKED_SIGBUF_SIZE))
2064         {
2065             unifi_error(card->ospriv, "process_fh_queue: Bad len: %d\n", signal_length);
2066             return CSR_RESULT_FAILURE;
2067         }
2068
2069         /* Need space for 2-byte SDIO protocol header + signal */
2070         sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2));
2071
2072         free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
2073                                                   (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
2074         if (free_chunks_in_fh_buffer < sig_chunks)
2075         {
2076             /* No more room */
2077             unifi_notice(card->ospriv, "proc_fh_cmd_q: no room in fh buffer for 0x%.4X, deferring\n",
2078                          (u16)(GET_SIGNAL_ID(csptr->sigbuf)));
2079             break;
2080         }
2081
2082         packed_sigptr = csptr->sigbuf;
2083
2084         /* Claim and set up a from-host data slot */
2085         if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, UNIFI_TRAFFIC_Q_MLME))
2086         {
2087             unifi_notice(card->ospriv, "proc_fh_cmd_q: no fh data slots for 0x%.4X, deferring\n",
2088                          (u16)(GET_SIGNAL_ID(csptr->sigbuf)));
2089             break;
2090         }
2091
2092         for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
2093         {
2094             if (csptr->bulkdata[i].data_length == 0)
2095             {
2096                 UNIFI_INIT_BULK_DATA(&bulkdata.d[i]);
2097             }
2098             else
2099             {
2100                 bulkdata.d[i].os_data_ptr = csptr->bulkdata[i].os_data_ptr;
2101                 bulkdata.d[i].data_length = csptr->bulkdata[i].data_length;
2102             }
2103
2104             /* Pass the free responsibility to the lower layer. */
2105             UNIFI_INIT_BULK_DATA(&csptr->bulkdata[i]);
2106         }
2107
2108         unifi_trace(card->ospriv, UDBG2, "Sending signal 0x%.4X\n",
2109                     GET_SIGNAL_ID(packed_sigptr));
2110 #ifdef CSR_WIFI_HIP_NOISY
2111         unifi_error(card->ospriv, "Sending signal 0x%.4X\n",
2112                     GET_SIGNAL_ID(packed_sigptr));
2113 #endif  /* CSR_WIFI_HIP_NOISY */
2114
2115
2116         /* Append packed signal to F-H buffer */
2117         total_length = sig_chunks * card->config_data.sig_frag_size;
2118
2119         card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff);
2120         card->fh_buffer.ptr[1] =
2121             (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
2122
2123         memcpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
2124         memset(card->fh_buffer.ptr + 2 + signal_length, 0,
2125                   total_length - (2 + signal_length));
2126
2127 #ifdef CSR_WIFI_HIP_NOISY
2128         unifi_error(card->ospriv, "proc_fh: fh_buffer %d bytes \n",
2129                     signal_length + 2);
2130         dump(card->fh_buffer.ptr, signal_length + 2);
2131         unifi_trace(card->ospriv, UDBG1, " \n");
2132 #endif  /* CSR_WIFI_HIP_NOISY */
2133
2134         card->fh_buffer.ptr += total_length;
2135         card->fh_buffer.count += sig_chunks;
2136
2137 #ifdef CSR_WIFI_HIP_NOISY
2138         unifi_error(card->ospriv, "Added %d to fh buf, len now %d, count %d\n",
2139                     signal_length,
2140                     card->fh_buffer.ptr - card->fh_buffer.buf,
2141                     card->fh_buffer.count);
2142 #endif  /* CSR_WIFI_HIP_NOISY */
2143
2144         (*processed)++;
2145         pending_chunks -= sig_chunks;
2146
2147         /* Log the signal to the UDI. */
2148         /* UDI will get the packed structure */
2149         /* Can not log the unpacked signal, unless we reconstruct it! */
2150         if (card->udi_hook)
2151         {
2152             (*card->udi_hook)(card->ospriv, packed_sigptr, signal_length,
2153                               &bulkdata, UDI_LOG_FROM_HOST);
2154         }
2155
2156         /* Remove entry from q */
2157         csptr->signal_length = 0;
2158         CSR_WIFI_HIP_Q_INC_R(sigq);
2159     }
2160
2161     return CSR_RESULT_SUCCESS;
2162 } /* process_fh_cmd_queue() */
2163
2164
2165 /*
2166  * ---------------------------------------------------------------------------
2167  *  process_fh_traffic_queue
2168  *
2169  *      Take signals off the from-host queue and copy them to the UniFi.
2170  *      Does nothing if the UniFi has no slots free.
2171  *
2172  *  Arguments:
2173  *      card       Pointer to card context struct
2174  *      sigq       Pointer to the traffic queue
2175  *      processed  Pointer to location to write:
2176  *                      0 if there is nothing on the queue to process
2177  *                      1 if a signal was successfully processed
2178  *
2179  *  Returns:
2180  *      CSR error code if an error occurred.
2181  *
2182  *  Notes:
2183  *      The from-host queue contains signal requests from the network driver
2184  *      and any UDI clients interspersed.
2185  * ---------------------------------------------------------------------------
2186  */
2187 static CsrResult process_fh_traffic_queue(card_t *card, s32 *processed)
2188 {
2189     q_t *sigq = card->fh_traffic_queue;
2190
2191     CsrResult r;
2192     s16 n = 0;
2193     s32 q_no;
2194     u16 pending_sigs = 0;
2195     u16 pending_chunks = 0;
2196     u16 needed_chunks;
2197     s32 space_chunks;
2198     u16 q_index;
2199     u32 host_tag = 0;
2200     u16 slot_num = 0;
2201
2202     *processed = 0;
2203
2204     /* calculate how many signals are in queues and how many chunks are needed. */
2205     for (n = UNIFI_NO_OF_TX_QS - 1; n >= 0; n--)
2206     {
2207         /* Get the number of pending signals. */
2208         pending_sigs += CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[n]);
2209         unifi_trace(card->ospriv, UDBG5, "proc_fh%d: %d pending\n", n, pending_sigs);
2210
2211         /* Work out how many chunks we have waiting to send */
2212         for (q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(&sigq[n]);
2213              q_index != CSR_WIFI_HIP_Q_NEXT_W_SLOT(&sigq[n]);
2214              q_index = CSR_WIFI_HIP_Q_WRAP(&sigq[n], q_index + 1))
2215         {
2216             card_signal_t *csptr = CSR_WIFI_HIP_Q_SLOT_DATA(&sigq[n], q_index);
2217
2218             /*
2219              * Note that GET_CHUNKS_FOR() needs the size of the packed
2220              * (wire-formatted) structure
2221              */
2222             pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2));
2223         }
2224     }
2225
2226     /* If there are no pending signals, just return */
2227     if (pending_sigs == 0)
2228     {
2229         /* Nothing to do */
2230         return CSR_RESULT_SUCCESS;
2231     }
2232
2233     /*
2234      * Check whether UniFi has space for all the buffered bulk-data
2235      * commands and signals as well.
2236      */
2237     needed_chunks = pending_chunks + card->fh_buffer.count;
2238
2239     /* Round up to the block size if necessary */
2240     ROUND_UP_NEEDED_CHUNKS(card, needed_chunks);
2241
2242     r = check_fh_sig_slots(card, needed_chunks, &space_chunks);
2243     if (r != CSR_RESULT_SUCCESS)
2244     {
2245         /* Error */
2246         unifi_error(card->ospriv, "Failed to read fh sig count\n");
2247         return r;
2248     }
2249
2250 #ifdef CSR_WIFI_HIP_NOISY
2251     unifi_error(card->ospriv,
2252                 "process_fh_traffic_queue: %d chunks free, need %d\n",
2253                 space_chunks, needed_chunks);
2254     read_fhsr(card);            /* debugging only */
2255 #endif /* CSR_WIFI_HIP_NOISY */
2256
2257     /* Coalesce as many from-host signals as possible
2258        into a single block and write using a single CMD53 */
2259     if (needed_chunks > (u16)space_chunks)
2260     {
2261         /* Round up to the block size if necessary */
2262         ROUND_UP_SPACE_CHUNKS(card, space_chunks);
2263
2264         if ((u16)space_chunks <= card->fh_buffer.count)
2265         {
2266             /*
2267              * No room in UniFi for any signals after the buffered bulk
2268              * data commands have been sent.
2269              */
2270             unifi_error(card->ospriv, "not enough room to send signals, need %d chunks, %d free\n",
2271                         card->fh_buffer.count, space_chunks);
2272             card->generate_interrupt = 1;
2273             return 0;
2274         }
2275
2276         pending_chunks = (u16)space_chunks - card->fh_buffer.count;
2277     }
2278
2279     q_no = UNIFI_NO_OF_TX_QS - 1;
2280
2281     /*
2282      * pending_sigs will be exhausted if there are is no restriction to the pending
2283      * signals per queue. pending_chunks may be exhausted if there is a restriction.
2284      * q_no check will be exhausted if there is a restriction and our round-robin
2285      * algorith fails to fill all chunks.
2286      */
2287     do
2288     {
2289         card_signal_t *csptr;
2290         u16 sig_chunks, total_length, free_chunks_in_fh_buffer;
2291         bulk_data_param_t bulkdata;
2292         u8 *packed_sigptr;
2293         u16 signal_length = 0;
2294
2295         /* if this queue is empty go to next one. */
2296         if (CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[q_no]) == 0)
2297         {
2298             q_no--;
2299             continue;
2300         }
2301
2302         /* Retrieve the entry at the head of the queue */
2303         q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(&sigq[q_no]);
2304
2305         /* Get a pointer to the containing card_signal_t struct */
2306         csptr = CSR_WIFI_HIP_Q_SLOT_DATA(&sigq[q_no], q_index);
2307
2308         /* Get the new length of the packed signal */
2309         signal_length = csptr->signal_length;
2310
2311         if ((signal_length & 1) || (signal_length > UNIFI_PACKED_SIGBUF_SIZE))
2312         {
2313             unifi_error(card->ospriv, "process_fh_traffic_queue: Bad len: %d\n", signal_length);
2314             return CSR_RESULT_FAILURE;
2315         }
2316
2317         /* Need space for 2-byte SDIO protocol header + signal */
2318         sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2));
2319         free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
2320                                                   (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
2321         if (free_chunks_in_fh_buffer < sig_chunks)
2322         {
2323             /* No more room */
2324             unifi_notice(card->ospriv, "process_fh_traffic_queue: no more chunks.\n");
2325             break;
2326         }
2327
2328         packed_sigptr = csptr->sigbuf;
2329         /* Claim and set up a from-host data slot */
2330         if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, (unifi_TrafficQueue)q_no))
2331         {
2332             q_no--;
2333             continue;
2334         }
2335
2336         /* Sanity check: MA-PACKET.req must have a valid bulk data */
2337         if ((csptr->bulkdata[0].data_length == 0) || (csptr->bulkdata[0].os_data_ptr == NULL))
2338         {
2339             unifi_error(card->ospriv, "MA-PACKET.req with empty bulk data (%d bytes in %p)\n",
2340                         csptr->bulkdata[0].data_length, csptr->bulkdata[0].os_data_ptr);
2341             dump(packed_sigptr, signal_length);
2342             return CSR_RESULT_FAILURE;
2343         }
2344
2345         bulkdata.d[0].os_data_ptr = csptr->bulkdata[0].os_data_ptr;
2346         bulkdata.d[0].data_length = csptr->bulkdata[0].data_length;
2347         bulkdata.d[0].os_net_buf_ptr = csptr->bulkdata[0].os_net_buf_ptr;
2348         bulkdata.d[0].net_buf_length = csptr->bulkdata[0].net_buf_length;
2349
2350         /* The driver owns clearing of HIP slots for following scenario
2351          * - driver has requested a MA-PACKET.req signal
2352          * - The f/w after receiving the signal decides it can't send it out due to various reasons
2353          * - So the f/w without downloading the bulk data decides to just send a confirmation with fail
2354          * - and then sends a clear slot signal to HIP
2355          *
2356          * But in some cases the clear slot signal never comes and the slot remains --NOT-- freed for ever
2357          *
2358          * To handle this, HIP will keep the record of host tag for each occupied slot
2359          * and then based on status of that Host tag and slot the driver will decide if the slot is
2360          * cleared by f/w signal or the slot has to be freed by driver
2361          */
2362
2363         if (card->fh_slot_host_tag_record)
2364         {
2365             /* Update the f-h slot record for the corresponding host tag */
2366             host_tag = GET_PACKED_MA_PACKET_REQUEST_HOST_TAG(packed_sigptr);
2367             slot_num = GET_PACKED_DATAREF_SLOT(packed_sigptr, 0) & 0x00FF;
2368
2369             unifi_trace(card->ospriv, UDBG5,
2370                         "process_fh_traffic_queue signal ID =%x fh slot=%x Host tag =%x\n",
2371                         GET_SIGNAL_ID(packed_sigptr), slot_num, host_tag);
2372             card->fh_slot_host_tag_record[slot_num] = host_tag;
2373         }
2374         UNIFI_INIT_BULK_DATA(&bulkdata.d[1]);
2375         UNIFI_INIT_BULK_DATA(&csptr->bulkdata[0]);
2376         UNIFI_INIT_BULK_DATA(&csptr->bulkdata[1]);
2377
2378 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
2379         if (bulkdata.d[0].os_data_ptr)
2380         {
2381             if ((*bulkdata.d[0].os_data_ptr) & 0x08)
2382             {
2383                 card->cmd_prof.tx_count++;
2384             }
2385         }
2386 #endif
2387         unifi_trace(card->ospriv, UDBG3, "Sending signal 0x%.4X\n",
2388                     GET_SIGNAL_ID(packed_sigptr));
2389 #ifdef CSR_WIFI_HIP_NOISY
2390         unifi_error(card->ospriv, "Sending signal 0x%.4X\n",
2391                     GET_SIGNAL_ID(packed_sigptr));
2392 #endif  /* CSR_WIFI_HIP_NOISY */
2393
2394         /* Append packed signal to F-H buffer */
2395         total_length = sig_chunks * card->config_data.sig_frag_size;
2396
2397         card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff);
2398         card->fh_buffer.ptr[1] =
2399             (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
2400
2401         memcpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
2402         memset(card->fh_buffer.ptr + 2 + signal_length, 0,
2403                   total_length - (2 + signal_length));
2404
2405 #ifdef CSR_WIFI_HIP_NOISY
2406         unifi_error(card->ospriv, "proc_fh: fh_buffer %d bytes \n",
2407                     signal_length + 2);
2408         dump(card->fh_buffer.ptr, signal_length + 2);
2409         unifi_trace(card->ospriv, UDBG1, " \n");
2410 #endif  /* CSR_WIFI_HIP_NOISY */
2411
2412         card->fh_buffer.ptr += total_length;
2413         card->fh_buffer.count += sig_chunks;
2414
2415 #ifdef CSR_WIFI_HIP_NOISY
2416         unifi_error(card->ospriv, "Added %d to fh buf, len now %d, count %d\n",
2417                     signal_length,
2418                     card->fh_buffer.ptr - card->fh_buffer.buf,
2419                     card->fh_buffer.count);
2420 #endif  /* CSR_WIFI_HIP_NOISY */
2421
2422         (*processed)++;
2423         pending_sigs--;
2424         pending_chunks -= sig_chunks;
2425
2426         /* Log the signal to the UDI. */
2427         /* UDI will get the packed structure */
2428         /* Can not log the unpacked signal, unless we reconstruct it! */
2429         if (card->udi_hook)
2430         {
2431             (*card->udi_hook)(card->ospriv, packed_sigptr, signal_length,
2432                               &bulkdata, UDI_LOG_FROM_HOST);
2433         }
2434
2435         /* Remove entry from q */
2436         csptr->signal_length = 0;
2437         /* Note that the traffic queue has only one valid bulk data buffer. */
2438         csptr->bulkdata[0].data_length = 0;
2439
2440         CSR_WIFI_HIP_Q_INC_R(&sigq[q_no]);
2441     } while ((pending_sigs > 0) && (pending_chunks > 0) && (q_no >= 0));
2442
2443     return CSR_RESULT_SUCCESS;
2444 } /* process_fh_traffic_queue() */
2445
2446
2447 /*
2448  * ---------------------------------------------------------------------------
2449  *  flush_fh_buffer
2450  *
2451  *      Write out the cache from-hosts signals to the UniFi.
2452  *
2453  *  Arguments:
2454  *      card       Pointer to card context struct
2455  *
2456  *  Returns:
2457  *      CSR error code if an SDIO error occurred.
2458  * ---------------------------------------------------------------------------
2459  */
2460 static CsrResult flush_fh_buffer(card_t *card)
2461 {
2462     CsrResult r;
2463     u16 len;
2464     u16 sig_units;
2465     u16 data_round;
2466     u16 chunks_in_last_block;
2467     u16 padding_chunks;
2468     u16 i;
2469
2470     len = card->fh_buffer.ptr - card->fh_buffer.buf;
2471
2472 #ifdef CSR_WIFI_HIP_NOISY
2473     unifi_error(card->ospriv, "fh_buffer is at %p, ptr= %p\n",
2474                 card->fh_buffer.buf, card->fh_buffer.ptr);
2475 #endif /* CSR_WIFI_HIP_NOISY */
2476
2477     if (len == 0)
2478     {
2479         return CSR_RESULT_SUCCESS;
2480     }
2481
2482 #ifdef CSR_WIFI_HIP_NOISY
2483     if (dump_fh_buf)
2484     {
2485         dump(card->fh_buffer.buf, len);
2486         dump_fh_buf = 0;
2487     }
2488 #endif /* CSR_WIFI_HIP_NOISY */
2489
2490     if (card->sdio_io_block_pad)
2491     {
2492         /* Both of these are powers of 2 */
2493         sig_units = card->config_data.sig_frag_size;
2494         data_round = card->sdio_io_block_size;
2495
2496         if (data_round > sig_units)
2497         {
2498             chunks_in_last_block = (len % data_round) / sig_units;
2499
2500             if (chunks_in_last_block != 0)
2501             {
2502                 padding_chunks = (data_round / sig_units) - chunks_in_last_block;
2503
2504                 memset(card->fh_buffer.ptr, 0, padding_chunks * sig_units);
2505                 for (i = 0; i < padding_chunks; i++)
2506                 {
2507                     card->fh_buffer.ptr[1] = SDIO_CMD_PADDING << 4;
2508                     card->fh_buffer.ptr += sig_units;
2509                 }
2510
2511                 card->fh_buffer.count += padding_chunks;
2512                 len += padding_chunks * sig_units;
2513             }
2514         }
2515     }
2516
2517     r = unifi_bulk_rw(card,
2518                       card->config_data.fromhost_sigbuf_handle,
2519                       card->fh_buffer.buf,
2520                       len, UNIFI_SDIO_WRITE);
2521     if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
2522     {
2523         return r;
2524     }
2525     if (r != CSR_RESULT_SUCCESS)
2526     {
2527         unifi_error(card->ospriv, "Failed to write fh signals: %u bytes, error %d\n", len, r);
2528         return r;
2529     }
2530
2531     /* Update from-host-signals-written signal count */
2532     card->from_host_signals_w =
2533         (card->from_host_signals_w + card->fh_buffer.count) % 128u;
2534     r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 0,
2535                             (u8)card->from_host_signals_w);
2536     if (r != CSR_RESULT_SUCCESS)
2537     {
2538         unifi_error(card->ospriv, "Failed to write fh signal count %u with error %d\n",
2539                     card->from_host_signals_w, r);
2540         return r;
2541     }
2542     card->generate_interrupt = 1;
2543
2544     /* Reset the fh buffer pointer */
2545     card->fh_buffer.ptr = card->fh_buffer.buf;
2546     card->fh_buffer.count = 0;
2547
2548 #ifdef CSR_WIFI_HIP_NOISY
2549     unifi_error(card->ospriv, "END flush: fh len %d, count %d\n",
2550                 card->fh_buffer.ptr - card->fh_buffer.buf,
2551                 card->fh_buffer.count);
2552 #endif /* CSR_WIFI_HIP_NOISY */
2553
2554     return CSR_RESULT_SUCCESS;
2555 } /* flush_fh_buffer() */
2556
2557
2558 /*
2559  * ---------------------------------------------------------------------------
2560  *  restart_packet_flow
2561  *
2562  *      This function is called before the bottom-half thread sleeps.
2563  *      It checks whether both data and signal resources are available and
2564  *      then calls the OS-layer function to re-enable packet transmission.
2565  *
2566  *  Arguments:
2567  *      card       Pointer to card context struct
2568  *
2569  *  Returns:
2570  *      None.
2571  * ---------------------------------------------------------------------------
2572  */
2573 static void restart_packet_flow(card_t *card)
2574 {
2575     u8 q;
2576
2577     /*
2578      * We only look at the fh_traffic_queue, because that is where packets from
2579      * the network stack are placed.
2580      */
2581     for (q = 0; q <= UNIFI_TRAFFIC_Q_VO; q++)
2582     {
2583         if (card_is_tx_q_paused(card, q) &&
2584             CSR_WIFI_HIP_Q_SLOTS_FREE(&card->fh_traffic_queue[q]) >= RESUME_XMIT_THRESHOLD)
2585         {
2586 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
2587             unifi_debug_log_to_buf("U");
2588 #endif
2589             card_tx_q_unpause(card, q);
2590             unifi_restart_xmit(card->ospriv, (unifi_TrafficQueue)q);
2591         }
2592     }
2593 } /* restart_packet_flow() */
2594
2595