/***************************************************************************** (c) Cambridge Silicon Radio Limited 2012 All rights reserved and confidential information of CSR Refer to LICENSE.txt included with this source for details on the license terms. *****************************************************************************/ /* * --------------------------------------------------------------------------- * FILE: csr_wifi_hip_card_sdio_intr.c * * PURPOSE: * Interrupt processing for the UniFi SDIO driver. * * We may need another signal queue of responses to UniFi to hold * bulk data commands generated by read_to_host_signals(). * * --------------------------------------------------------------------------- */ #undef CSR_WIFI_HIP_NOISY #include "csr_wifi_hip_unifi.h" #include "csr_wifi_hip_conversions.h" #include "csr_wifi_hip_card.h" #include "csr_wifi_hip_xbv.h" /* * If the SDIO link is idle for this time (in milliseconds), * signal UniFi to go into Deep Sleep. * Valid return value of unifi_bh(). */ #define UNIFI_DEFAULT_HOST_IDLE_TIMEOUT 5 /* * If the UniFi has not woken up for this time (in milliseconds), * signal the bottom half to take action. * Valid return value of unifi_bh(). */ #define UNIFI_DEFAULT_WAKE_TIMEOUT 1000 static CsrResult process_bh(card_t *card); static CsrResult handle_host_protocol(card_t *card, u8 *processed_something); static CsrResult flush_fh_buffer(card_t *card); static CsrResult check_fh_sig_slots(card_t *card, u16 needed, s32 *space); static CsrResult read_to_host_signals(card_t *card, s32 *processed); static CsrResult process_to_host_signals(card_t *card, s32 *processed); static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr, s16 cmd, u16 len); static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr); static CsrResult process_fh_cmd_queue(card_t *card, s32 *processed); static CsrResult process_fh_traffic_queue(card_t *card, s32 *processed); static void restart_packet_flow(card_t *card); static CsrResult process_clock_request(card_t *card); #ifdef CSR_WIFI_HIP_NOISY s16 dump_fh_buf = 0; #endif /* CSR_WIFI_HIP_NOISY */ #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE /* * The unifi_debug_output buffer can be used to debug the HIP behaviour offline * i.e. without using the tracing functions that change the timing. * * Call unifi_debug_log_to_buf() with printf arguments to store a string into * unifi_debug_output. When unifi_debug_buf_dump() is called, the contents of the * buffer are dumped with dump_str() which has to be implemented in the * OS layer, during the porting exercise. The offset printed, holds the * offset where the last character is (always a zero). * */ #define UNIFI_DEBUG_GBUFFER_SIZE 8192 static char unifi_debug_output[UNIFI_DEBUG_GBUFFER_SIZE]; static char *unifi_dbgbuf_ptr = unifi_debug_output; static char *unifi_dbgbuf_start = unifi_debug_output; static void append_char(char c) { /* write char and advance pointer */ *unifi_dbgbuf_ptr++ = c; /* wrap pointer at end of buffer */ if ((unifi_dbgbuf_ptr - unifi_debug_output) >= UNIFI_DEBUG_GBUFFER_SIZE) { unifi_dbgbuf_ptr = unifi_debug_output; } } /* append_char() */ void unifi_debug_string_to_buf(const char *str) { const char *p = str; while (*p) { append_char(*p); p++; } /* Update start-of-buffer pointer */ unifi_dbgbuf_start = unifi_dbgbuf_ptr + 1; if ((unifi_dbgbuf_start - unifi_debug_output) >= UNIFI_DEBUG_GBUFFER_SIZE) { unifi_dbgbuf_start = unifi_debug_output; } } void unifi_debug_log_to_buf(const char *fmt, ...) { #define DEBUG_BUFFER_SIZE 80 static char s[DEBUG_BUFFER_SIZE]; va_list args; va_start(args, fmt); vsnprintf(s, DEBUG_BUFFER_SIZE, fmt, args); va_end(args); unifi_debug_string_to_buf(s); } /* unifi_debug_log_to_buf() */ /* Convert signed 32 bit (or less) integer to string */ static void CsrUInt16ToHex(u16 number, char *str) { u16 index; u16 currentValue; for (index = 0; index < 4; index++) { currentValue = (u16) (number & 0x000F); number >>= 4; str[3 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0'); } str[4] = '\0'; } /* * --------------------------------------------------------------------------- * unifi_debug_hex_to_buf * * puts the contents of the passed buffer into the debug buffer as a hex string * * Arguments: * buff buffer to print as hex * length number of chars to print * * Returns: * None. * * --------------------------------------------------------------------------- */ void unifi_debug_hex_to_buf(const char *buff, u16 length) { char s[5]; u16 i; for (i = 0; i < length; i = i + 2) { CsrUInt16ToHex(*((u16 *)(buff + i)), s); unifi_debug_string_to_buf(s); } } void unifi_debug_buf_dump(void) { s32 offset = unifi_dbgbuf_ptr - unifi_debug_output; unifi_error(NULL, "HIP debug buffer offset=%d\n", offset); dump_str(unifi_debug_output + offset, UNIFI_DEBUG_GBUFFER_SIZE - offset); dump_str(unifi_debug_output, offset); } /* unifi_debug_buf_dump() */ #endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */ #ifdef CSR_PRE_ALLOC_NET_DATA #define NETDATA_PRE_ALLOC_BUF_SIZE 8000 void prealloc_netdata_free(card_t *card) { unifi_warning(card->ospriv, "prealloc_netdata_free: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r); while (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length != 0) { unifi_warning(card->ospriv, "prealloc_netdata_free: r=%d\n", card->prealloc_netdata_r); unifi_net_data_free(card->ospriv, &card->bulk_data_desc_list[card->prealloc_netdata_r]); card->prealloc_netdata_r++; card->prealloc_netdata_r %= BULK_DATA_PRE_ALLOC_NUM; } card->prealloc_netdata_r = card->prealloc_netdata_w = 0; unifi_warning(card->ospriv, "prealloc_netdata_free: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r); } CsrResult prealloc_netdata_alloc(card_t *card) { CsrResult r; unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_alloc: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r); while (card->bulk_data_desc_list[card->prealloc_netdata_w].data_length == 0) { r = unifi_net_data_malloc(card->ospriv, &card->bulk_data_desc_list[card->prealloc_netdata_w], NETDATA_PRE_ALLOC_BUF_SIZE); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "prealloc_netdata_alloc: Failed to allocate t-h bulk data\n"); return CSR_RESULT_FAILURE; } card->prealloc_netdata_w++; card->prealloc_netdata_w %= BULK_DATA_PRE_ALLOC_NUM; } unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_alloc: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r); return CSR_RESULT_SUCCESS; } static CsrResult prealloc_netdata_get(card_t *card, bulk_data_desc_t *bulk_data_slot, u32 size) { CsrResult r; unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_get: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r); if (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length == 0) { unifi_error(card->ospriv, "prealloc_netdata_get: data_length = 0\n"); } if ((size > NETDATA_PRE_ALLOC_BUF_SIZE) || (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length == 0)) { unifi_warning(card->ospriv, "prealloc_netdata_get: Calling net_data_malloc\n"); r = unifi_net_data_malloc(card->ospriv, bulk_data_slot, size); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "prealloc_netdata_get: Failed to allocate t-h bulk data\n"); return CSR_RESULT_FAILURE; } return CSR_RESULT_SUCCESS; } *bulk_data_slot = card->bulk_data_desc_list[card->prealloc_netdata_r]; card->bulk_data_desc_list[card->prealloc_netdata_r].os_data_ptr = NULL; card->bulk_data_desc_list[card->prealloc_netdata_r].os_net_buf_ptr = NULL; card->bulk_data_desc_list[card->prealloc_netdata_r].net_buf_length = 0; card->bulk_data_desc_list[card->prealloc_netdata_r].data_length = 0; card->prealloc_netdata_r++; card->prealloc_netdata_r %= BULK_DATA_PRE_ALLOC_NUM; unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_get: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r); return CSR_RESULT_SUCCESS; } #endif /* * --------------------------------------------------------------------------- * unifi_sdio_interrupt_handler * * This function should be called by the OS-dependent code to handle * an SDIO interrupt from the UniFi. * * Arguments: * card Pointer to card context structure. * * Returns: * None. * * Notes: This function may be called in DRS context. In this case, * tracing with the unifi_trace(), etc, is not allowed. * --------------------------------------------------------------------------- */ void unifi_sdio_interrupt_handler(card_t *card) { /* * Set the flag to say reason for waking was SDIO interrupt. * Then ask the OS layer to run the unifi_bh to give attention to the UniFi. */ card->bh_reason_unifi = 1; (void)unifi_run_bh(card->ospriv); } /* sdio_interrupt_handler() */ /* * --------------------------------------------------------------------------- * unifi_configure_low_power_mode * * This function should be called by the OS-dependent when * the deep sleep signaling needs to be enabled or disabled. * * Arguments: * card Pointer to card context structure. * low_power_mode Disable/Enable the deep sleep signaling * periodic_wake_mode UniFi wakes host periodically. * * Returns: * CSR_RESULT_SUCCESS on success or a CSR error code. * --------------------------------------------------------------------------- */ CsrResult unifi_configure_low_power_mode(card_t *card, enum unifi_low_power_mode low_power_mode, enum unifi_periodic_wake_mode periodic_wake_mode) { card->low_power_mode = low_power_mode; card->periodic_wake_mode = periodic_wake_mode; unifi_trace(card->ospriv, UDBG1, "unifi_configure_low_power_mode: new mode = %s, wake_host = %s\n", (low_power_mode == UNIFI_LOW_POWER_DISABLED)?"disabled" : "enabled", (periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_DISABLED)?"FALSE" : "TRUE"); (void)unifi_run_bh(card->ospriv); return CSR_RESULT_SUCCESS; } /* unifi_configure_low_power_mode() */ /* * --------------------------------------------------------------------------- * unifi_force_low_power_mode * * This function should be called by the OS-dependent when * UniFi needs to be set to the low power mode (e.g. on suspend) * * Arguments: * card Pointer to card context structure. * * Returns: * CSR_RESULT_SUCCESS on success or a CSR error code. * --------------------------------------------------------------------------- */ CsrResult unifi_force_low_power_mode(card_t *card) { if (card->low_power_mode == UNIFI_LOW_POWER_DISABLED) { unifi_error(card->ospriv, "Attempt to set mode to TORPID when lower power mode is disabled\n"); return CSR_WIFI_HIP_RESULT_INVALID_VALUE; } return unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID); } /* unifi_force_low_power_mode() */ /* * --------------------------------------------------------------------------- * unifi_bh * * This function should be called by the OS-dependent code when * host and/or UniFi has requested an exchange of messages. * * Arguments: * card Pointer to card context structure. * * Returns: * CSR_RESULT_SUCCESS on success or a CSR error code. * --------------------------------------------------------------------------- */ CsrResult unifi_bh(card_t *card, u32 *remaining) { CsrResult r; CsrResult csrResult; u8 pending; s32 iostate, j; const enum unifi_low_power_mode low_power_mode = card->low_power_mode; u16 data_slots_used = 0; /* Process request to raise the maximum SDIO clock */ r = process_clock_request(card); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Error setting maximum SDIO clock\n"); goto exit; } /* * Why was the BH thread woken? * If it was an SDIO interrupt, UniFi is awake and we need to process it. * If it was a host process queueing data, then we need to awaken UniFi. * * Priority of flags is top down. * * ----------------------------------------------------------+ * \state| AWAKE | DROWSY | TORPID | * flag\ | | | | * ---------+--------------+----------------+----------------| * | do the host | go to AWAKE and| go to AWAKE and| * unifi | protocol | do the host | do the host | * | | protocol | protocol | * ---------+--------------+----------------+----------------| * | do the host | | | * host | protocol | do nothing | go to DROWSY | * | | | | * ---------+--------------+----------------+----------------| * | | | should not | * timeout | go to TORPID | error, unifi | occur | * | | didn't wake up | do nothing | * ----------------------------------------------------------+ * * Note that if we end up in the AWAKE state we always do the host protocol. */ do { /* * When the host state is set to DROWSY, then we can not disable the * interrupts as UniFi can generate an interrupt even when the INT_ENABLE * register has the interrupts disabled. This interrupt will be lost. */ if (card->host_state == UNIFI_HOST_STATE_DROWSY || card->host_state == UNIFI_HOST_STATE_TORPID) { u8 reason_unifi; /* * An interrupt may occur while or after we cache the reason. * This interrupt will cause the unifi_bh() to be scheduled again. * Any interrupt that has happened before the register is read * and is considered spurious has to acknowledged. */ reason_unifi = card->bh_reason_unifi; /* * If an interrupt is received, check if it was a real one, * set the host state to AWAKE and run the BH. */ r = CardPendingInt(card, &pending); if (r != CSR_RESULT_SUCCESS) { goto exit; } if (pending) { unifi_trace(card->ospriv, UDBG5, "UNIFI_HOST_STATE_%s: Set state to AWAKE.\n", (card->host_state == UNIFI_HOST_STATE_TORPID)?"TORPID" : "DROWSY"); r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE); if (r == CSR_RESULT_SUCCESS) { (*remaining) = 0; break; } } else if (reason_unifi) { CsrSdioInterruptAcknowledge(card->sdio_if); } /* * If an chip is in TORPID, and the host wants to wake it up, * set the host state to DROWSY and wait for the wake-up interrupt. */ if ((card->host_state == UNIFI_HOST_STATE_TORPID) && card->bh_reason_host) { r = unifi_set_host_state(card, UNIFI_HOST_STATE_DROWSY); if (r == CSR_RESULT_SUCCESS) { /* * set the timeout value to UNIFI_DEFAULT_WAKE_TIMEOUT * to capture a wake error. */ card->bh_reason_host = 0; (*remaining) = UNIFI_DEFAULT_WAKE_TIMEOUT; return CSR_RESULT_SUCCESS; } goto exit; } /* * If the chip is in DROWSY, and the timeout expires, * we need to reset the chip. This should never occur. * (If it does, check that the calling thread set "remaining" * according to the time remaining when unifi_bh() was called). */ if ((card->host_state == UNIFI_HOST_STATE_DROWSY) && ((*remaining) == 0)) { unifi_error(card->ospriv, "UniFi did not wake up on time...\n"); /* * Check if Function1 has gone away or * if we missed an SDIO interrupt. */ r = unifi_check_io_status(card, &iostate); if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE) { goto exit; } /* Need to reset and reboot */ return CSR_RESULT_FAILURE; } } else { if (card->bh_reason_unifi || card->bh_reason_host) { break; } if (((*remaining) == 0) && (low_power_mode == UNIFI_LOW_POWER_ENABLED)) { r = unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID); if (r == CSR_RESULT_SUCCESS) { (*remaining) = 0; return CSR_RESULT_SUCCESS; } goto exit; } } /* No need to run the host protocol */ return CSR_RESULT_SUCCESS; } while (0); /* Disable the SDIO interrupts while doing SDIO ops */ csrResult = CsrSdioInterruptDisable(card->sdio_if); if (csrResult == CSR_SDIO_RESULT_NO_DEVICE) { r = CSR_WIFI_HIP_RESULT_NO_DEVICE; goto exit; } if (csrResult != CSR_RESULT_SUCCESS) { r = ConvertCsrSdioToCsrHipResult(card, csrResult); unifi_error(card->ospriv, "Failed to disable SDIO interrupts. unifi_bh queues error.\n"); goto exit; } /* Now that the interrupts are disabled, ack the interrupt */ CsrSdioInterruptAcknowledge(card->sdio_if); /* Run the HIP */ r = process_bh(card); if (r != CSR_RESULT_SUCCESS) { goto exit; } /* * If host is now idle, schedule a timer for the delay before we * let UniFi go into deep sleep. * If the timer goes off, we will move to TORPID state. * If UniFi raises an interrupt in the meantime, we will cancel * the timer and start a new one when we become idle. */ for (j = 0; j < UNIFI_NO_OF_TX_QS; j++) { data_slots_used += CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_traffic_queue[j]); } if ((low_power_mode == UNIFI_LOW_POWER_ENABLED) && (data_slots_used == 0)) { #ifndef CSR_WIFI_HIP_TA_DISABLE if (card->ta_sampling.traffic_type != CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC) { #endif /* return the UNIFI_DEFAULT_HOST_IDLE_TIMEOUT, so we can go to sleep. */ unifi_trace(card->ospriv, UDBG5, "Traffic is not periodic, set timer for TORPID.\n"); (*remaining) = UNIFI_DEFAULT_HOST_IDLE_TIMEOUT; #ifndef CSR_WIFI_HIP_TA_DISABLE } else { unifi_trace(card->ospriv, UDBG5, "Traffic is periodic, set unifi to TORPID immediately.\n"); if (CardAreAllFromHostDataSlotsEmpty(card) == 1) { r = unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID); if (r != CSR_RESULT_SUCCESS) { goto exit; } } } #endif } csrResult = CsrSdioInterruptEnable(card->sdio_if); if (csrResult == CSR_SDIO_RESULT_NO_DEVICE) { r = CSR_WIFI_HIP_RESULT_NO_DEVICE; } if (csrResult != CSR_RESULT_SUCCESS) { r = ConvertCsrSdioToCsrHipResult(card, csrResult); unifi_error(card->ospriv, "Failed to enable SDIO interrupt\n"); } exit: unifi_trace(card->ospriv, UDBG4, "New state=%d\n", card->host_state); if (r != CSR_RESULT_SUCCESS) { #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE) unifi_debug_buf_dump(); #endif /* If an interrupt has been raised, ack it here */ if (card->bh_reason_unifi) { CsrSdioInterruptAcknowledge(card->sdio_if); } unifi_error(card->ospriv, "unifi_bh: state=%d %c, clock=%dkHz, interrupt=%d host=%d, power_save=%s\n", card->host_state, (card->host_state == UNIFI_HOST_STATE_AWAKE)?'A' : (card->host_state == UNIFI_HOST_STATE_DROWSY)?'D' : 'T', card->sdio_clock_speed / 1000, card->bh_reason_unifi, card->bh_reason_host, (low_power_mode == UNIFI_LOW_POWER_DISABLED)?"disabled" : "enabled"); /* Try to capture firmware panic codes */ (void)unifi_capture_panic(card); /* Ask for a mini-coredump when the driver has reset UniFi */ (void)unifi_coredump_request_at_next_reset(card, 1); } return r; } /* unifi_bh() */ /* * --------------------------------------------------------------------------- * process_clock_request * * Handle request from the OS layer to increase the SDIO clock speed. * The fast clock is limited until the firmware has indicated that it has * completed initialisation to the OS layer. * * Arguments: * card Pointer to card context structure. * * Returns: * CSR_RESULT_SUCCESS on success or CSR error code. * --------------------------------------------------------------------------- */ static CsrResult process_clock_request(card_t *card) { CsrResult r = CSR_RESULT_SUCCESS; CsrResult csrResult; if (!card->request_max_clock) { return CSR_RESULT_SUCCESS; /* No pending request */ } /* * The SDIO clock speed request from the OS layer is only acted upon if * the UniFi is awake. If it was in any other state, the clock speed will * transition through SAFE to MAX while the host wakes it up, and the * final speed reached will be UNIFI_SDIO_CLOCK_MAX_HZ. * This assumes that the SME never requests low power mode while the f/w * initialisation takes place. */ if (card->host_state == UNIFI_HOST_STATE_AWAKE) { unifi_trace(card->ospriv, UDBG1, "Set SDIO max clock\n"); csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_MAX_HZ); if (csrResult != CSR_RESULT_SUCCESS) { r = ConvertCsrSdioToCsrHipResult(card, csrResult); } else { card->sdio_clock_speed = UNIFI_SDIO_CLOCK_MAX_HZ; /* log the new freq */ } } else { unifi_trace(card->ospriv, UDBG1, "Will set SDIO max clock after wakeup\n"); } /* Cancel the request now that it has been acted upon, or is about to be * by the wakeup mechanism */ card->request_max_clock = 0; return r; } /* * --------------------------------------------------------------------------- * process_bh * * Exchange messages with UniFi * * Arguments: * card Pointer to card context structure. * * Returns: * CSR_RESULT_SUCCESS on success or CSR error code. * --------------------------------------------------------------------------- */ static CsrResult process_bh(card_t *card) { CsrResult r; u8 more; more = FALSE; /* Process the reasons (interrupt, signals) */ do { /* * Run in a while loop, to save clearing the interrupts * every time around the outside loop. */ do { /* If configured to run the HIP just once, skip first loop */ if (card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE) { break; } r = handle_host_protocol(card, &more); if (r != CSR_RESULT_SUCCESS) { return r; } #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) unifi_debug_log_to_buf("c52=%d c53=%d tx=%d txc=%d rx=%d s=%d t=%d fc=%d\n", card->cmd_prof.cmd52_count, card->cmd_prof.cmd53_count, card->cmd_prof.tx_count, card->cmd_prof.tx_cfm_count, card->cmd_prof.rx_count, card->cmd_prof.sdio_cmd_signal, card->cmd_prof.sdio_cmd_to_host, card->cmd_prof.sdio_cmd_from_host_and_clear ); card->cmd_prof.cmd52_count = card->cmd_prof.cmd53_count = 0; card->cmd_prof.tx_count = card->cmd_prof.tx_cfm_count = card->cmd_prof.rx_count = 0; card->cmd_prof.cmd52_f0_r_count = 0; card->cmd_prof.cmd52_f0_w_count = 0; card->cmd_prof.cmd52_r8or16_count = 0; card->cmd_prof.cmd52_w8or16_count = 0; card->cmd_prof.cmd52_r16_count = 0; card->cmd_prof.cmd52_w16_count = 0; card->cmd_prof.cmd52_r32_count = 0; card->cmd_prof.sdio_cmd_signal = 0; card->cmd_prof.sdio_cmd_clear_slot = 0; card->cmd_prof.sdio_cmd_to_host = 0; card->cmd_prof.sdio_cmd_from_host = 0; card->cmd_prof.sdio_cmd_from_host_and_clear = 0; #endif } while (more || card->bh_reason_unifi || card->bh_reason_host); /* Acknowledge the h/w interrupt */ r = CardClearInt(card); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to acknowledge interrupt.\n"); return r; } /* * UniFi may have tried to generate an interrupt during the * CardClearInt() was running. So, we need to run the host * protocol again, to check if there are any pending requests. */ r = handle_host_protocol(card, &more); if (r != CSR_RESULT_SUCCESS) { return r; } #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) unifi_debug_log_to_buf("c52=%d c53=%d tx=%d txc=%d rx=%d s=%d t=%d fc=%d\n", card->cmd_prof.cmd52_count, card->cmd_prof.cmd53_count, card->cmd_prof.tx_count, card->cmd_prof.tx_cfm_count, card->cmd_prof.rx_count, card->cmd_prof.sdio_cmd_signal, card->cmd_prof.sdio_cmd_to_host, card->cmd_prof.sdio_cmd_from_host_and_clear ); card->cmd_prof.cmd52_count = card->cmd_prof.cmd53_count = 0; card->cmd_prof.tx_count = card->cmd_prof.tx_cfm_count = card->cmd_prof.rx_count = 0; card->cmd_prof.cmd52_f0_r_count = 0; card->cmd_prof.cmd52_f0_w_count = 0; card->cmd_prof.cmd52_r8or16_count = 0; card->cmd_prof.cmd52_w8or16_count = 0; card->cmd_prof.cmd52_r16_count = 0; card->cmd_prof.cmd52_w16_count = 0; card->cmd_prof.cmd52_r32_count = 0; card->cmd_prof.sdio_cmd_signal = 0; card->cmd_prof.sdio_cmd_clear_slot = 0; card->cmd_prof.sdio_cmd_to_host = 0; card->cmd_prof.sdio_cmd_from_host = 0; card->cmd_prof.sdio_cmd_from_host_and_clear = 0; #endif /* If configured to run the HIP just once, work is now done */ if (card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE) { break; } } while (more || card->bh_reason_unifi || card->bh_reason_host); #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) if ((card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE) == 0) { unifi_debug_log_to_buf("proc=%d\n", card->cmd_prof.process_count); } #endif return CSR_RESULT_SUCCESS; } /* process_bh() */ /* * --------------------------------------------------------------------------- * handle_host_protocol * * This function implements the Host Interface Protocol (HIP) as * described in the Host Interface Protocol Specification. * * Arguments: * card Pointer to card context structure. * processed_something Pointer to location to update processing status: * TRUE when data was transferred * FALSE when no data was transferred (queues empty) * * Returns: * CSR_RESULT_SUCCESS on success or CSR error code. * --------------------------------------------------------------------------- */ static CsrResult handle_host_protocol(card_t *card, u8 *processed_something) { CsrResult r; s32 done; *processed_something = FALSE; #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, " ======================== \n"); #endif /* CSR_WIFI_HIP_NOISY */ #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE card->cmd_prof.process_count++; #endif card->bh_reason_unifi = card->bh_reason_host = 0; card->generate_interrupt = 0; /* * (Re)fill the T-H signal buffer */ r = read_to_host_signals(card, &done); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Error occured reading to-host signals\n"); return r; } if (done > 0) { *processed_something = TRUE; } /* * Process any to-host signals. * Perform any requested CMD53 transfers here, but just queue any * bulk data command responses. */ r = process_to_host_signals(card, &done); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Error occured processing to-host signals\n"); return r; } /* Now send any signals in the F-H queues */ /* Give precedence to the command queue */ r = process_fh_cmd_queue(card, &done); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Error occured processing from-host signals\n"); return r; } if (done > 0) { *processed_something = TRUE; } r = process_fh_traffic_queue(card, &done); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Error occured processing from-host data signals\n"); return r; } if (done > 0) { *processed_something = TRUE; } /* Flush out the batch of signals to the UniFi. */ r = flush_fh_buffer(card); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to copy from-host signals to UniFi\n"); return r; } /* * Send the host interrupt to say the queues have been modified. */ if (card->generate_interrupt) { r = CardGenInt(card); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to notify UniFi that queues have been modified.\n"); return r; } } #ifdef CSR_WIFI_RX_PATH_SPLIT #ifdef CSR_WIFI_RX_PATH_SPLIT_DONT_USE_WQ unifi_rx_queue_flush(card->ospriv); #endif #endif /* See if we can re-enable transmission now */ restart_packet_flow(card); #ifdef CSR_PRE_ALLOC_NET_DATA r = prealloc_netdata_alloc(card); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "prealloc_netdata failed\n"); return r; } #endif /* * Don't put the thread sleep if we just interacted with the chip, * there might be more to do if we look again. */ return r; } /* handle_host_protocol() */ /* * Rounds the given signal length in bytes to a whole number * of sig_frag_size. */ #define GET_CHUNKS_FOR(SIG_FRAG_SIZE, LENGTH) (((LENGTH) + ((SIG_FRAG_SIZE)-1)) / (SIG_FRAG_SIZE)) /* * --------------------------------------------------------------------------- * read_to_host_signals * * Read everything pending in the UniFi TH signal buffer. * Only do it if the local buffer is empty. * * Arguments: * card Pointer to card context struct * processed Number of signals read: * 0 if there were no signals pending, * 1 if we read at least one signal * Returns: * CSR error code if an error occurred. * --------------------------------------------------------------------------- */ static CsrResult read_to_host_signals(card_t *card, s32 *processed) { s32 count_thw, count_thr; s32 unread_chunks, unread_bytes; CsrResult r; *processed = 0; /* Read any pending signals or bulk data commands */ count_thw = unifi_read_shared_count(card, card->sdio_ctrl_addr + 4); if (count_thw < 0) { unifi_error(card->ospriv, "Failed to read to-host sig written count\n"); return CSR_RESULT_FAILURE; } card->to_host_signals_w = count_thw; /* diag */ count_thr = card->to_host_signals_r; if (count_thw == count_thr) { return CSR_RESULT_SUCCESS; } unread_chunks = (((count_thw - count_thr) + 128) % 128) - card->th_buffer.count; if (unread_chunks == 0) { return CSR_RESULT_SUCCESS; } unread_bytes = card->config_data.sig_frag_size * unread_chunks; r = unifi_bulk_rw(card, card->config_data.tohost_sigbuf_handle, card->th_buffer.ptr, unread_bytes, UNIFI_SDIO_READ); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to read ToHost signal\n"); return r; } card->th_buffer.ptr += unread_bytes; card->th_buffer.count += (u16)unread_chunks; *processed = 1; return CSR_RESULT_SUCCESS; } /* read_to_host_signals() */ /* * --------------------------------------------------------------------------- * update_to_host_signals_r * * Advance the shared-memory count of chunks read from the to-host * signal buffer. * Raise a UniFi internal interrupt to tell the firmware that the * count has changed. * * Arguments: * card Pointer to card context struct * pending Number of chunks remaining * * Returns: * CSR_RESULT_SUCCESS on success or CSR error code * --------------------------------------------------------------------------- */ static CsrResult update_to_host_signals_r(card_t *card, s16 pending) { CsrResult r; card->to_host_signals_r = (card->to_host_signals_r + (card->th_buffer.count - pending)) % 128; card->th_buffer.count = pending; /* Update the count of signals read */ r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 6, (u8)card->to_host_signals_r); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to update to-host signals read\n"); return r; } r = CardGenInt(card); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to notify UniFi that we processed to-host signals.\n"); return r; } card->generate_interrupt = 0; return CSR_RESULT_SUCCESS; } /* update_to_host_signals_r() */ /* * --------------------------------------------------------------------------- * read_unpack_cmd * * Converts a wire-formatted command to the host bulk_data_cmd_t structure. * * Arguments: * ptr Pointer to the command * bulk_data_cmd Pointer to the host structure * * Returns: * None. * --------------------------------------------------------------------------- */ static void read_unpack_cmd(const u8 *ptr, bulk_data_cmd_t *bulk_data_cmd) { s16 index = 0; bulk_data_cmd->cmd_and_len = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index); index += SIZEOF_UINT16; bulk_data_cmd->data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index); index += SIZEOF_UINT16; bulk_data_cmd->offset = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index); index += SIZEOF_UINT16; bulk_data_cmd->buffer_handle = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index); index += SIZEOF_UINT16; } /* read_unpack_cmd */ /* * --------------------------------------------------------------------------- * process_to_host_signals * * Read and dispatch signals from the UniFi * * Arguments: * card Pointer to card context struct * processed Pointer to location to write processing result: * 0 if there were no signals pending, * 1 if we read at least one signal * * Returns: * CSR error code if there was an error * * Notes: * Since bulk data transfers can take a long time, if we wait until * all are done before we acknowledge the signals, the UniFi runs out * of buffer space. Therefore we keep a count of the bytes transferred * in bulk data commands, and update the to-host-signals-read count * if we've done a large transfer. * * All data in the f/w is stored in a little endian format, without any * padding bytes. Every read from the memory has to be transformed in * host (cpu specific) format, before we can process it. Therefore we * use read_unpack_cmd() and read_unpack_signal() to convert the raw data * contained in the card->th_buffer.buf to host structures. * Important: UDI clients use wire-formatted structures, so we need to * indicate all data, as we have read it from the device. * --------------------------------------------------------------------------- */ static CsrResult process_to_host_signals(card_t *card, s32 *processed) { s16 pending; s16 remaining; u8 *bufptr; bulk_data_param_t data_ptrs; s16 cmd; u16 sig_len; s16 i; u16 chunks_in_buf; u16 bytes_transferred = 0; CsrResult r = CSR_RESULT_SUCCESS; *processed = 0; pending = card->th_buffer.count; /* Are there new to-host signals? */ unifi_trace(card->ospriv, UDBG4, "handling %d to-host chunks\n", pending); if (!pending) { return CSR_RESULT_SUCCESS; } /* * This is a pointer to the raw data we have read from the f/w. * Can be a signal or a command. Note that we need to convert * it to a host structure before we process it. */ bufptr = card->th_buffer.buf; while (pending > 0) { s16 f_flush_count = 0; /* * Command and length are common to signal and bulk data msgs. * If command == 0 (i.e. a signal), len is number of bytes * *following* the 2-byte header. */ cmd = bufptr[1] >> 4; sig_len = bufptr[0] + ((bufptr[1] & 0x0F) << 8); #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "Received UniFi msg cmd=%d, len=%d\n", cmd, sig_len); #endif /* CSR_WIFI_HIP_NOISY */ if ((sig_len == 0) && ((cmd != SDIO_CMD_CLEAR_SLOT) && (cmd != SDIO_CMD_PADDING))) { unifi_error(card->ospriv, "incomplete signal or command: has size zero\n"); return CSR_RESULT_FAILURE; } /* * Make sure the buffer contains a complete message. * Signals may occupy multiple chunks, bulk-data commands occupy * one chunk. */ if (cmd == SDIO_CMD_SIGNAL) { chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(sig_len + 2)); } else { chunks_in_buf = 1; } if (chunks_in_buf > (u16)pending) { unifi_error(card->ospriv, "incomplete signal (0x%x?): need %d chunks, got %d\n", GET_SIGNAL_ID(bufptr + 2), chunks_in_buf, pending); unifi_error(card->ospriv, " thsw=%d, thsr=%d\n", card->to_host_signals_w, card->to_host_signals_r); return CSR_RESULT_FAILURE; } switch (cmd) { case SDIO_CMD_SIGNAL: /* This is a signal. Read the rest of it and then handle it. */ #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) card->cmd_prof.sdio_cmd_signal++; #endif for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) { /* Retrieve dataRefs[i].DataLength */ u16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i); /* * The bulk data length in the signal can not be greater than * the maximun length allowed by the SDIO config structure. */ if (data_len > card->config_data.data_slot_size) { unifi_error(card->ospriv, "Bulk Data length (%d) exceeds Maximum Bulk Data length (%d)\n", data_len, card->config_data.data_slot_size); return CSR_RESULT_FAILURE; } /* * Len here might not be the same as the length in the * bulk data slot. The slot length will always be even, * but len could be odd. */ if (data_len != 0) { /* Retrieve dataRefs[i].SlotNumber */ s16 slot = GET_PACKED_DATAREF_SLOT(bufptr + 2, i); if (slot >= card->config_data.num_tohost_data_slots) { unifi_error(card->ospriv, "!!!bad slot number in to-host signal: %d, sig 0x%X\n", slot, cmd); return CSR_RESULT_FAILURE; } data_ptrs.d[i].os_data_ptr = card->to_host_data[slot].os_data_ptr; data_ptrs.d[i].os_net_buf_ptr = card->to_host_data[slot].os_net_buf_ptr; data_ptrs.d[i].net_buf_length = card->to_host_data[slot].net_buf_length; data_ptrs.d[i].data_length = data_len; } else { UNIFI_INIT_BULK_DATA(&data_ptrs.d[i]); } } /* * Log the signal to the UDI, before call unifi_receive_event() as * it can modify the bulk data. */ if (card->udi_hook) { (*card->udi_hook)(card->ospriv, bufptr + 2, sig_len, &data_ptrs, UDI_LOG_TO_HOST); } #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID) { card->cmd_prof.tx_cfm_count++; } else if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_INDICATION_ID) { if (data_ptrs.d[0].os_data_ptr) { if ((*data_ptrs.d[0].os_data_ptr) & 0x08) { card->cmd_prof.rx_count++; } } } #endif /* * Check if the signal is MA-PACKET.cfm and if so check the status. * If the status is failure, search through the slot records to find * if any slots are occupied for this host tag. This can happen if * f/w has not downloaded the bulkdata and before that itself it has * signalled the confirm with failure. If it finds a slot with that * host tag then, it clears the corresponding slot */ if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID) { /* Get host tag and transmission status */ u32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2); u16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(bufptr + 2); unifi_trace(card->ospriv, UDBG4, "process_to_host_signals signal ID=%x host Tag=%x status=%x\n", GET_SIGNAL_ID(bufptr + 2), host_tag, status); /* If transmission status is failure then search through the slot records * and if for any slot records the clear slot is not done then do it now */ if (status && (card->fh_slot_host_tag_record)) { u16 num_fh_slots = card->config_data.num_fromhost_data_slots; /* search through the list of slot records and match with host tag * If a slot is not yet cleared then clear the slot from here */ for (i = 0; i < num_fh_slots; i++) { if (card->fh_slot_host_tag_record[i] == host_tag) { #ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL /* Invoke the HAL module function to requeue it back to HAL Queues */ r = unifi_reque_ma_packet_request(card->ospriv, host_tag, status, &card->from_host_data[i].bd); card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG; if (CSR_RESULT_SUCCESS != r) { unifi_trace(card->ospriv, UDBG5, "process_to_host_signals: Failed to requeue Packet(hTag:%x) back to HAL \n", host_tag); CardClearFromHostDataSlot(card, i); } else { CardClearFromHostDataSlotWithoutFreeingBulkData(card, i); } #else unifi_trace(card->ospriv, UDBG4, "process_to_host_signals Clear slot=%x host tag=%x\n", i, host_tag); card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG; /* Set length field in from_host_data array to 0 */ CardClearFromHostDataSlot(card, i); #endif break; } } } } /* Pass event to OS layer */ unifi_receive_event(card->ospriv, bufptr + 2, sig_len, &data_ptrs); /* Initialise the to_host data, so it can be re-used. */ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) { /* The slot is only valid if the length is non-zero. */ if (GET_PACKED_DATAREF_LEN(bufptr + 2, i) != 0) { s16 slot = GET_PACKED_DATAREF_SLOT(bufptr + 2, i); if (slot < card->config_data.num_tohost_data_slots) { UNIFI_INIT_BULK_DATA(&card->to_host_data[slot]); } } } #ifndef CSR_WIFI_DEFER_TH_FLUSH /* * If we have previously transferred a lot of data, ack * the signals read so far, so f/w can reclaim the buffer * memory sooner. */ if (bytes_transferred >= TO_HOST_FLUSH_THRESHOLD) { f_flush_count = 1; } #endif break; case SDIO_CMD_CLEAR_SLOT: #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) card->cmd_prof.sdio_cmd_clear_slot++; #endif /* This is a clear slot command. */ if (sig_len != 0) { unifi_error(card->ospriv, "process_to_host_signals: clear slot, bad data len: 0x%X at offset %d\n", sig_len, bufptr - card->th_buffer.buf); return CSR_RESULT_FAILURE; } r = process_clear_slot_command(card, bufptr); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to process clear slot\n"); return r; } break; case SDIO_CMD_TO_HOST_TRANSFER: case SDIO_CMD_FROM_HOST_TRANSFER: case SDIO_CMD_FROM_HOST_AND_CLEAR: case SDIO_CMD_OVERLAY_TRANSFER: /* This is a bulk data command. */ if (sig_len & 1) { unifi_error(card->ospriv, "process_to_host_signals: bulk data, bad data len: 0x%X at offset %d\n", sig_len, bufptr - card->th_buffer.buf); return CSR_RESULT_FAILURE; } r = process_bulk_data_command(card, bufptr, cmd, sig_len); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to process bulk cmd\n"); return r; } /* Count the bytes transferred */ bytes_transferred += sig_len; if (cmd == SDIO_CMD_FROM_HOST_AND_CLEAR) { #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) card->cmd_prof.sdio_cmd_from_host_and_clear++; #endif #ifndef CSR_WIFI_DEFER_TH_FLUSH f_flush_count = 1; #endif } #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) else if (cmd == SDIO_CMD_FROM_HOST_TRANSFER) { card->cmd_prof.sdio_cmd_from_host++; } else if (cmd == SDIO_CMD_TO_HOST_TRANSFER) { card->cmd_prof.sdio_cmd_to_host++; } #endif break; case SDIO_CMD_PADDING: break; default: unifi_error(card->ospriv, "Unrecognised to-host command: %d\n", cmd); break; } bufptr += chunks_in_buf * card->config_data.sig_frag_size; pending -= chunks_in_buf; /* * Write out the host signal count when a significant * number of bytes of bulk data have been transferred or * when we have performed a CopyFromHostAndClear. */ if (f_flush_count) { r = update_to_host_signals_r(card, pending); if (r != CSR_RESULT_SUCCESS) { return r; } bytes_transferred = 0; } } if (pending) { unifi_warning(card->ospriv, "proc_th_sigs: %d unprocessed\n", pending); } /* If we processed any signals, write the updated count to UniFi */ if (card->th_buffer.count != pending) { r = update_to_host_signals_r(card, pending); if (r != CSR_RESULT_SUCCESS) { return r; } } /* * Reset the buffer pointer, copying down any un-processed signals. * This can happen if we enable the optimisation in read_to_host_signals() * that limits the length to whole blocks. */ remaining = card->th_buffer.ptr - bufptr; if (remaining < 0) { unifi_error(card->ospriv, "Processing TH signals overran the buffer\n"); return CSR_RESULT_FAILURE; } if (remaining > 0) { /* Use a safe copy because source and destination may overlap */ u8 *d = card->th_buffer.buf; u8 *s = bufptr; s32 n = remaining; while (n--) { *d++ = *s++; } } card->th_buffer.ptr = card->th_buffer.buf + remaining; /* If we reach here then we processed something */ *processed = 1; return CSR_RESULT_SUCCESS; } /* process_to_host_signals() */ /* * --------------------------------------------------------------------------- * process_clear_slot_command * * Process a clear slot command fom the UniFi. * * Arguments: * card Pointer to card context struct * bdcmd Pointer to bulk-data command msg from UniFi * * Returns: * 0 on success, CSR error code on error * --------------------------------------------------------------------------- */ static CsrResult process_clear_slot_command(card_t *card, const u8 *cmdptr) { u16 data_slot; s16 slot; data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cmdptr + SIZEOF_UINT16); unifi_trace(card->ospriv, UDBG4, "Processing clear slot cmd, slot=0x%X\n", data_slot); slot = data_slot & 0x7FFF; #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "CMD clear data slot 0x%04x\n", data_slot); #endif /* CSR_WIFI_HIP_NOISY */ if (data_slot & SLOT_DIR_TO_HOST) { if (slot >= card->config_data.num_tohost_data_slots) { unifi_error(card->ospriv, "Invalid to-host data slot in SDIO_CMD_CLEAR_SLOT: %d\n", slot); return CSR_RESULT_FAILURE; } /* clear to-host data slot */ unifi_warning(card->ospriv, "Unexpected clear to-host data slot cmd: 0x%04x\n", data_slot); } else { if (slot >= card->config_data.num_fromhost_data_slots) { unifi_error(card->ospriv, "Invalid from-host data slot in SDIO_CMD_CLEAR_SLOT: %d\n", slot); return CSR_RESULT_FAILURE; } /* * The driver is the owner to clear all slots now * Ref - comment in process_fh_traffic_queue * so it will just ignore the clear slot command from firmware * and return success */ return CSR_RESULT_SUCCESS; /* Set length field in from_host_data array to 0 */ /* CardClearFromHostDataSlot(card, slot); */ } return CSR_RESULT_SUCCESS; } /* process_clear_slot_command() */ /* * --------------------------------------------------------------------------- * process_bulk_data_command * * Process a bulk data request from the UniFi. * * Arguments: * card Pointer to card context struct * bdcmd Pointer to bulk-data command msg from UniFi * cmd, len Decoded values of command and length from the msg header * Cmd will only be one of: * SDIO_CMD_TO_HOST_TRANSFER * SDIO_CMD_FROM_HOST_TRANSFER * SDIO_CMD_FROM_HOST_AND_CLEAR * SDIO_CMD_OVERLAY_TRANSFER * * Returns: * CSR_RESULT_SUCCESS on success, CSR error code on error * --------------------------------------------------------------------------- */ static CsrResult process_bulk_data_command(card_t *card, const u8 *cmdptr, s16 cmd, u16 len) { bulk_data_desc_t *bdslot; #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND u8 *host_bulk_data_slot; #endif bulk_data_cmd_t bdcmd; s16 offset; s16 slot; s16 dir; CsrResult r; read_unpack_cmd(cmdptr, &bdcmd); unifi_trace(card->ospriv, UDBG4, "Processing bulk data cmd %d %s, len=%d, slot=0x%X\n", cmd, lookup_bulkcmd_name(cmd), len, bdcmd.data_slot); /* * Round up the transfer length if required. * This is useful to force all transfers to be a multiple of the SDIO block * size, so the SDIO driver won't try to use a byte-mode CMD53. These are * broken on some hardware platforms. */ if (card->sdio_io_block_pad) { len = (len + card->sdio_io_block_size - 1) & ~(card->sdio_io_block_size - 1); unifi_trace(card->ospriv, UDBG4, "Rounded bulk data length up to %d\n", len); } slot = bdcmd.data_slot & 0x7FFF; if (cmd == SDIO_CMD_OVERLAY_TRANSFER) { return CSR_WIFI_HIP_RESULT_INVALID_VALUE; /* Not used on CSR6xxx */ } else { if (bdcmd.data_slot & SLOT_DIR_TO_HOST) { /* Request is for to-host bulk data */ /* Check sanity of slot number */ if (slot >= card->config_data.num_tohost_data_slots) { unifi_error(card->ospriv, "Invalid to-host data slot in SDIO bulk xfr req: %d\n", slot); return CSR_RESULT_FAILURE; } /* Allocate memory for card->to_host_data[slot] bulk data here. */ #ifdef CSR_PRE_ALLOC_NET_DATA r = prealloc_netdata_get(card, &card->to_host_data[slot], len); #else r = unifi_net_data_malloc(card->ospriv, &card->to_host_data[slot], len); #endif if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to allocate t-h bulk data\n"); return CSR_RESULT_FAILURE; } bdslot = &card->to_host_data[slot]; /* Make sure that the buffer is 4-bytes aligned */ r = unifi_net_dma_align(card->ospriv, bdslot); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to align t-h bulk data buffer for DMA\n"); return CSR_RESULT_FAILURE; } } else { /* Request is for from-host bulk data */ if (slot >= card->config_data.num_fromhost_data_slots) { unifi_error(card->ospriv, "Invalid from-host data slot in SDIO bulk xfr req: %d\n", slot); return CSR_RESULT_FAILURE; } bdslot = &card->from_host_data[slot].bd; } offset = bdcmd.offset; } /* Do the transfer */ dir = (cmd == SDIO_CMD_TO_HOST_TRANSFER)? UNIFI_SDIO_READ : UNIFI_SDIO_WRITE; unifi_trace(card->ospriv, UDBG4, "Bulk %c %s len=%d, handle %d - slot=%d %p+(%d)\n", (dir == UNIFI_SDIO_READ)?'R' : 'W', lookup_bulkcmd_name(cmd), len, bdcmd.buffer_handle, slot, bdslot->os_data_ptr, offset); #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "Bulk %s len=%d, handle %d - slot=%d %p+(%d)\n", lookup_bulkcmd_name(cmd), len, bdcmd.buffer_handle, slot, bdslot->os_data_ptr, offset); #endif /* CSR_WIFI_HIP_NOISY */ if (bdslot->os_data_ptr == NULL) { unifi_error(card->ospriv, "Null os_data_ptr - Bulk %s handle %d - slot=%d o=(%d)\n", lookup_bulkcmd_name(cmd), bdcmd.buffer_handle, slot, offset); return CSR_WIFI_HIP_RESULT_INVALID_VALUE; } #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND /* if os_data_ptr is not 4-byte aligned, then allocate a new buffer and copy data to new buffer to ensure the address passed to unifi_bulk_rw is 4-byte aligned */ if (len != 0 && (dir == UNIFI_SDIO_WRITE) && (((ptrdiff_t)bdslot->os_data_ptr + offset) & 3)) { host_bulk_data_slot = kmalloc(len, GFP_KERNEL); if (!host_bulk_data_slot) { unifi_error(card->ospriv, " failed to allocate request_data before unifi_bulk_rw\n"); return -1; } memcpy((void *)host_bulk_data_slot, (void *)(bdslot->os_data_ptr + offset), len); r = unifi_bulk_rw(card, bdcmd.buffer_handle, (void *)host_bulk_data_slot, len, dir); } else #endif { r = unifi_bulk_rw(card, bdcmd.buffer_handle, (void *)(bdslot->os_data_ptr + offset), len, dir); } if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE) { return r; } if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed: %s hlen=%d, slen=%d, handle %d - slot=%d %p+0x%X\n", lookup_bulkcmd_name(cmd), len, /* Header length */ bdslot->data_length, /* Length stored in slot */ bdcmd.buffer_handle, slot, bdslot->os_data_ptr, offset); return r; } bdslot->data_length = len; if (cmd == SDIO_CMD_FROM_HOST_AND_CLEAR) { if (slot >= card->config_data.num_fromhost_data_slots) { unifi_error(card->ospriv, "Invalid from-host data slot in SDIO_CMD_FROM_HOST_AND_CLEAR: %d\n", slot); return CSR_RESULT_FAILURE; } #ifdef CSR_WIFI_ALIGNMENT_WORKAROUND /* moving this check before we clear host data slot */ if ((len != 0) && (dir == UNIFI_SDIO_WRITE) && (((ptrdiff_t)bdslot->os_data_ptr + offset) & 3)) { kfree(host_bulk_data_slot); } #endif if (card->fh_slot_host_tag_record) { unifi_trace(card->ospriv, UDBG5, "CopyFromHostAndClearSlot Reset entry for slot=%d\n", slot); /* reset the host tag entry for the corresponding slot */ card->fh_slot_host_tag_record[slot] = CSR_WIFI_HIP_RESERVED_HOST_TAG; } /* Set length field in from_host_data array to 0 */ CardClearFromHostDataSlot(card, slot); } return CSR_RESULT_SUCCESS; } /* process_bulk_data_command() */ /* * --------------------------------------------------------------------------- * check_fh_sig_slots * * Check whether there are free signal slots available on UniFi. * This takes into account the signals already batched since the * from_host_signal counts were last read. * If the from_host_signal counts indicate not enough space, we read * the latest count from UniFi to see if some more have been freed. * * Arguments: * None. * * Returns: * CSR_RESULT_SUCCESS, otherwise CSR error code on error. * --------------------------------------------------------------------------- */ static CsrResult check_fh_sig_slots(card_t *card, u16 needed, s32 *space_fh) { u32 count_fhw; u32 occupied_fh, slots_fh; s32 count_fhr; count_fhw = card->from_host_signals_w; count_fhr = card->from_host_signals_r; slots_fh = card->config_data.num_fromhost_sig_frags; /* Only read the space in from-host queue if necessary */ occupied_fh = (count_fhw - count_fhr) % 128; if (slots_fh < occupied_fh) { *space_fh = 0; } else { *space_fh = slots_fh - occupied_fh; } if ((occupied_fh != 0) && (*space_fh < needed)) { count_fhr = unifi_read_shared_count(card, card->sdio_ctrl_addr + 2); if (count_fhr < 0) { unifi_error(card->ospriv, "Failed to read from-host sig read count\n"); return CSR_RESULT_FAILURE; } card->from_host_signals_r = count_fhr; /* diag */ occupied_fh = (count_fhw - count_fhr) % 128; *space_fh = slots_fh - occupied_fh; } return CSR_RESULT_SUCCESS; } /* check_fh_sig_slots() */ /* * If we are padding the From-Host signals to the SDIO block size, * we need to round up the needed_chunks to the SDIO block size. */ #define ROUND_UP_NEEDED_CHUNKS(_card, _needed_chunks) \ { \ u16 _chunks_per_block; \ u16 _chunks_in_last_block; \ \ if (_card->sdio_io_block_pad) \ { \ _chunks_per_block = _card->sdio_io_block_size / _card->config_data.sig_frag_size; \ _chunks_in_last_block = _needed_chunks % _chunks_per_block; \ if (_chunks_in_last_block != 0) \ { \ _needed_chunks = _needed_chunks + (_chunks_per_block - _chunks_in_last_block); \ } \ } \ } #define ROUND_UP_SPACE_CHUNKS(_card, _space_chunks) \ { \ u16 _chunks_per_block; \ \ if (_card->sdio_io_block_pad) \ { \ _chunks_per_block = _card->sdio_io_block_size / _card->config_data.sig_frag_size; \ _space_chunks = ((_space_chunks / _chunks_per_block) * _chunks_per_block); \ } \ } /* * --------------------------------------------------------------------------- * process_fh_cmd_queue * * Take one signal off the from-host queue and copy it to the UniFi. * Does nothing if the UniFi has no slots free. * * Arguments: * card Pointer to card context struct * processed Location to write: * 0 if there is nothing on the queue to process * 1 if a signal was successfully processed * * Returns: * CSR error code if an error occurred. * * Notes: * The from-host queue contains signal requests from the network driver * and any UDI clients interspersed. UDI clients' requests have been stored * in the from-host queue using the wire-format structures, as they arrive. * All other requests are stored in the from-host queue using the host * (cpu specific) structures. We use the is_packed member of the card_signal_t * structure that describes the queue to make the distiction. * --------------------------------------------------------------------------- */ static CsrResult process_fh_cmd_queue(card_t *card, s32 *processed) { q_t *sigq = &card->fh_command_queue; CsrResult r; u16 pending_sigs; u16 pending_chunks; u16 needed_chunks; s32 space_chunks; u16 q_index; *processed = 0; /* Get the number of pending signals. */ pending_sigs = CSR_WIFI_HIP_Q_SLOTS_USED(sigq); unifi_trace(card->ospriv, UDBG5, "proc_fh: %d pending\n", pending_sigs); if (pending_sigs == 0) { /* Nothing to do */ return CSR_RESULT_SUCCESS; } /* Work out how many chunks we have waiting to send */ for (pending_chunks = 0, q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq); q_index != CSR_WIFI_HIP_Q_NEXT_W_SLOT(sigq); q_index = CSR_WIFI_HIP_Q_WRAP(sigq, q_index + 1)) { card_signal_t *csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, q_index); /* * Note that GET_CHUNKS_FOR() needs the size of the packed * (wire-formatted) structure */ pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2)); } /* * Check whether UniFi has space for all the buffered bulk-data * commands and signals as well. */ needed_chunks = pending_chunks + card->fh_buffer.count; /* Round up to the block size if necessary */ ROUND_UP_NEEDED_CHUNKS(card, needed_chunks); r = check_fh_sig_slots(card, needed_chunks, &space_chunks); if (r != CSR_RESULT_SUCCESS) { /* Error */ unifi_error(card->ospriv, "Failed to read fh sig count\n"); return r; } #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "proc_fh: %d chunks free, need %d\n", space_chunks, needed_chunks); #endif /* CSR_WIFI_HIP_NOISY */ /* * Coalesce as many from-host signals as possible * into a single block and write using a single CMD53 */ if (needed_chunks > (u16)space_chunks) { /* Round up to the block size if necessary */ ROUND_UP_SPACE_CHUNKS(card, space_chunks); /* * If the f/w has less free chunks than those already pending * return immediately. */ if ((u16)space_chunks <= card->fh_buffer.count) { /* * No room in UniFi for any signals after the buffered bulk * data commands have been sent. */ unifi_error(card->ospriv, "not enough room to send signals, need %d chunks, %d free\n", card->fh_buffer.count, space_chunks); card->generate_interrupt = 1; return CSR_RESULT_SUCCESS; } pending_chunks = (u16)(space_chunks - card->fh_buffer.count); } while (pending_sigs-- && pending_chunks > 0) { card_signal_t *csptr; s16 i; u16 sig_chunks, total_length, free_chunks_in_fh_buffer; bulk_data_param_t bulkdata; u8 *packed_sigptr; u16 signal_length = 0; /* Retrieve the entry at the head of the queue */ q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq); /* Get a pointer to the containing card_signal_t struct */ csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, q_index); /* Get the new length of the packed signal */ signal_length = csptr->signal_length; if ((signal_length & 1) || (signal_length > UNIFI_PACKED_SIGBUF_SIZE)) { unifi_error(card->ospriv, "process_fh_queue: Bad len: %d\n", signal_length); return CSR_RESULT_FAILURE; } /* Need space for 2-byte SDIO protocol header + signal */ sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2)); free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr)); if (free_chunks_in_fh_buffer < sig_chunks) { /* No more room */ unifi_notice(card->ospriv, "proc_fh_cmd_q: no room in fh buffer for 0x%.4X, deferring\n", (u16)(GET_SIGNAL_ID(csptr->sigbuf))); break; } packed_sigptr = csptr->sigbuf; /* Claim and set up a from-host data slot */ if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, UNIFI_TRAFFIC_Q_MLME)) { unifi_notice(card->ospriv, "proc_fh_cmd_q: no fh data slots for 0x%.4X, deferring\n", (u16)(GET_SIGNAL_ID(csptr->sigbuf))); break; } for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) { if (csptr->bulkdata[i].data_length == 0) { UNIFI_INIT_BULK_DATA(&bulkdata.d[i]); } else { bulkdata.d[i].os_data_ptr = csptr->bulkdata[i].os_data_ptr; bulkdata.d[i].data_length = csptr->bulkdata[i].data_length; } /* Pass the free responsibility to the lower layer. */ UNIFI_INIT_BULK_DATA(&csptr->bulkdata[i]); } unifi_trace(card->ospriv, UDBG2, "Sending signal 0x%.4X\n", GET_SIGNAL_ID(packed_sigptr)); #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "Sending signal 0x%.4X\n", GET_SIGNAL_ID(packed_sigptr)); #endif /* CSR_WIFI_HIP_NOISY */ /* Append packed signal to F-H buffer */ total_length = sig_chunks * card->config_data.sig_frag_size; card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff); card->fh_buffer.ptr[1] = (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4)); memcpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length); memset(card->fh_buffer.ptr + 2 + signal_length, 0, total_length - (2 + signal_length)); #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "proc_fh: fh_buffer %d bytes \n", signal_length + 2); dump(card->fh_buffer.ptr, signal_length + 2); unifi_trace(card->ospriv, UDBG1, " \n"); #endif /* CSR_WIFI_HIP_NOISY */ card->fh_buffer.ptr += total_length; card->fh_buffer.count += sig_chunks; #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "Added %d to fh buf, len now %d, count %d\n", signal_length, card->fh_buffer.ptr - card->fh_buffer.buf, card->fh_buffer.count); #endif /* CSR_WIFI_HIP_NOISY */ (*processed)++; pending_chunks -= sig_chunks; /* Log the signal to the UDI. */ /* UDI will get the packed structure */ /* Can not log the unpacked signal, unless we reconstruct it! */ if (card->udi_hook) { (*card->udi_hook)(card->ospriv, packed_sigptr, signal_length, &bulkdata, UDI_LOG_FROM_HOST); } /* Remove entry from q */ csptr->signal_length = 0; CSR_WIFI_HIP_Q_INC_R(sigq); } return CSR_RESULT_SUCCESS; } /* process_fh_cmd_queue() */ /* * --------------------------------------------------------------------------- * process_fh_traffic_queue * * Take signals off the from-host queue and copy them to the UniFi. * Does nothing if the UniFi has no slots free. * * Arguments: * card Pointer to card context struct * sigq Pointer to the traffic queue * processed Pointer to location to write: * 0 if there is nothing on the queue to process * 1 if a signal was successfully processed * * Returns: * CSR error code if an error occurred. * * Notes: * The from-host queue contains signal requests from the network driver * and any UDI clients interspersed. * --------------------------------------------------------------------------- */ static CsrResult process_fh_traffic_queue(card_t *card, s32 *processed) { q_t *sigq = card->fh_traffic_queue; CsrResult r; s16 n = 0; s32 q_no; u16 pending_sigs = 0; u16 pending_chunks = 0; u16 needed_chunks; s32 space_chunks; u16 q_index; u32 host_tag = 0; u16 slot_num = 0; *processed = 0; /* calculate how many signals are in queues and how many chunks are needed. */ for (n = UNIFI_NO_OF_TX_QS - 1; n >= 0; n--) { /* Get the number of pending signals. */ pending_sigs += CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[n]); unifi_trace(card->ospriv, UDBG5, "proc_fh%d: %d pending\n", n, pending_sigs); /* Work out how many chunks we have waiting to send */ for (q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(&sigq[n]); q_index != CSR_WIFI_HIP_Q_NEXT_W_SLOT(&sigq[n]); q_index = CSR_WIFI_HIP_Q_WRAP(&sigq[n], q_index + 1)) { card_signal_t *csptr = CSR_WIFI_HIP_Q_SLOT_DATA(&sigq[n], q_index); /* * Note that GET_CHUNKS_FOR() needs the size of the packed * (wire-formatted) structure */ pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(csptr->signal_length + 2)); } } /* If there are no pending signals, just return */ if (pending_sigs == 0) { /* Nothing to do */ return CSR_RESULT_SUCCESS; } /* * Check whether UniFi has space for all the buffered bulk-data * commands and signals as well. */ needed_chunks = pending_chunks + card->fh_buffer.count; /* Round up to the block size if necessary */ ROUND_UP_NEEDED_CHUNKS(card, needed_chunks); r = check_fh_sig_slots(card, needed_chunks, &space_chunks); if (r != CSR_RESULT_SUCCESS) { /* Error */ unifi_error(card->ospriv, "Failed to read fh sig count\n"); return r; } #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "process_fh_traffic_queue: %d chunks free, need %d\n", space_chunks, needed_chunks); read_fhsr(card); /* debugging only */ #endif /* CSR_WIFI_HIP_NOISY */ /* Coalesce as many from-host signals as possible into a single block and write using a single CMD53 */ if (needed_chunks > (u16)space_chunks) { /* Round up to the block size if necessary */ ROUND_UP_SPACE_CHUNKS(card, space_chunks); if ((u16)space_chunks <= card->fh_buffer.count) { /* * No room in UniFi for any signals after the buffered bulk * data commands have been sent. */ unifi_error(card->ospriv, "not enough room to send signals, need %d chunks, %d free\n", card->fh_buffer.count, space_chunks); card->generate_interrupt = 1; return 0; } pending_chunks = (u16)space_chunks - card->fh_buffer.count; } q_no = UNIFI_NO_OF_TX_QS - 1; /* * pending_sigs will be exhausted if there are is no restriction to the pending * signals per queue. pending_chunks may be exhausted if there is a restriction. * q_no check will be exhausted if there is a restriction and our round-robin * algorith fails to fill all chunks. */ do { card_signal_t *csptr; u16 sig_chunks, total_length, free_chunks_in_fh_buffer; bulk_data_param_t bulkdata; u8 *packed_sigptr; u16 signal_length = 0; /* if this queue is empty go to next one. */ if (CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[q_no]) == 0) { q_no--; continue; } /* Retrieve the entry at the head of the queue */ q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(&sigq[q_no]); /* Get a pointer to the containing card_signal_t struct */ csptr = CSR_WIFI_HIP_Q_SLOT_DATA(&sigq[q_no], q_index); /* Get the new length of the packed signal */ signal_length = csptr->signal_length; if ((signal_length & 1) || (signal_length > UNIFI_PACKED_SIGBUF_SIZE)) { unifi_error(card->ospriv, "process_fh_traffic_queue: Bad len: %d\n", signal_length); return CSR_RESULT_FAILURE; } /* Need space for 2-byte SDIO protocol header + signal */ sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)(signal_length + 2)); free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (u16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr)); if (free_chunks_in_fh_buffer < sig_chunks) { /* No more room */ unifi_notice(card->ospriv, "process_fh_traffic_queue: no more chunks.\n"); break; } packed_sigptr = csptr->sigbuf; /* Claim and set up a from-host data slot */ if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, (unifi_TrafficQueue)q_no)) { q_no--; continue; } /* Sanity check: MA-PACKET.req must have a valid bulk data */ if ((csptr->bulkdata[0].data_length == 0) || (csptr->bulkdata[0].os_data_ptr == NULL)) { unifi_error(card->ospriv, "MA-PACKET.req with empty bulk data (%d bytes in %p)\n", csptr->bulkdata[0].data_length, csptr->bulkdata[0].os_data_ptr); dump(packed_sigptr, signal_length); return CSR_RESULT_FAILURE; } bulkdata.d[0].os_data_ptr = csptr->bulkdata[0].os_data_ptr; bulkdata.d[0].data_length = csptr->bulkdata[0].data_length; bulkdata.d[0].os_net_buf_ptr = csptr->bulkdata[0].os_net_buf_ptr; bulkdata.d[0].net_buf_length = csptr->bulkdata[0].net_buf_length; /* The driver owns clearing of HIP slots for following scenario * - driver has requested a MA-PACKET.req signal * - The f/w after receiving the signal decides it can't send it out due to various reasons * - So the f/w without downloading the bulk data decides to just send a confirmation with fail * - and then sends a clear slot signal to HIP * * But in some cases the clear slot signal never comes and the slot remains --NOT-- freed for ever * * To handle this, HIP will keep the record of host tag for each occupied slot * and then based on status of that Host tag and slot the driver will decide if the slot is * cleared by f/w signal or the slot has to be freed by driver */ if (card->fh_slot_host_tag_record) { /* Update the f-h slot record for the corresponding host tag */ host_tag = GET_PACKED_MA_PACKET_REQUEST_HOST_TAG(packed_sigptr); slot_num = GET_PACKED_DATAREF_SLOT(packed_sigptr, 0) & 0x00FF; unifi_trace(card->ospriv, UDBG5, "process_fh_traffic_queue signal ID =%x fh slot=%x Host tag =%x\n", GET_SIGNAL_ID(packed_sigptr), slot_num, host_tag); card->fh_slot_host_tag_record[slot_num] = host_tag; } UNIFI_INIT_BULK_DATA(&bulkdata.d[1]); UNIFI_INIT_BULK_DATA(&csptr->bulkdata[0]); UNIFI_INIT_BULK_DATA(&csptr->bulkdata[1]); #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE if (bulkdata.d[0].os_data_ptr) { if ((*bulkdata.d[0].os_data_ptr) & 0x08) { card->cmd_prof.tx_count++; } } #endif unifi_trace(card->ospriv, UDBG3, "Sending signal 0x%.4X\n", GET_SIGNAL_ID(packed_sigptr)); #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "Sending signal 0x%.4X\n", GET_SIGNAL_ID(packed_sigptr)); #endif /* CSR_WIFI_HIP_NOISY */ /* Append packed signal to F-H buffer */ total_length = sig_chunks * card->config_data.sig_frag_size; card->fh_buffer.ptr[0] = (u8)(signal_length & 0xff); card->fh_buffer.ptr[1] = (u8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4)); memcpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length); memset(card->fh_buffer.ptr + 2 + signal_length, 0, total_length - (2 + signal_length)); #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "proc_fh: fh_buffer %d bytes \n", signal_length + 2); dump(card->fh_buffer.ptr, signal_length + 2); unifi_trace(card->ospriv, UDBG1, " \n"); #endif /* CSR_WIFI_HIP_NOISY */ card->fh_buffer.ptr += total_length; card->fh_buffer.count += sig_chunks; #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "Added %d to fh buf, len now %d, count %d\n", signal_length, card->fh_buffer.ptr - card->fh_buffer.buf, card->fh_buffer.count); #endif /* CSR_WIFI_HIP_NOISY */ (*processed)++; pending_sigs--; pending_chunks -= sig_chunks; /* Log the signal to the UDI. */ /* UDI will get the packed structure */ /* Can not log the unpacked signal, unless we reconstruct it! */ if (card->udi_hook) { (*card->udi_hook)(card->ospriv, packed_sigptr, signal_length, &bulkdata, UDI_LOG_FROM_HOST); } /* Remove entry from q */ csptr->signal_length = 0; /* Note that the traffic queue has only one valid bulk data buffer. */ csptr->bulkdata[0].data_length = 0; CSR_WIFI_HIP_Q_INC_R(&sigq[q_no]); } while ((pending_sigs > 0) && (pending_chunks > 0) && (q_no >= 0)); return CSR_RESULT_SUCCESS; } /* process_fh_traffic_queue() */ /* * --------------------------------------------------------------------------- * flush_fh_buffer * * Write out the cache from-hosts signals to the UniFi. * * Arguments: * card Pointer to card context struct * * Returns: * CSR error code if an SDIO error occurred. * --------------------------------------------------------------------------- */ static CsrResult flush_fh_buffer(card_t *card) { CsrResult r; u16 len; u16 sig_units; u16 data_round; u16 chunks_in_last_block; u16 padding_chunks; u16 i; len = card->fh_buffer.ptr - card->fh_buffer.buf; #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "fh_buffer is at %p, ptr= %p\n", card->fh_buffer.buf, card->fh_buffer.ptr); #endif /* CSR_WIFI_HIP_NOISY */ if (len == 0) { return CSR_RESULT_SUCCESS; } #ifdef CSR_WIFI_HIP_NOISY if (dump_fh_buf) { dump(card->fh_buffer.buf, len); dump_fh_buf = 0; } #endif /* CSR_WIFI_HIP_NOISY */ if (card->sdio_io_block_pad) { /* Both of these are powers of 2 */ sig_units = card->config_data.sig_frag_size; data_round = card->sdio_io_block_size; if (data_round > sig_units) { chunks_in_last_block = (len % data_round) / sig_units; if (chunks_in_last_block != 0) { padding_chunks = (data_round / sig_units) - chunks_in_last_block; memset(card->fh_buffer.ptr, 0, padding_chunks * sig_units); for (i = 0; i < padding_chunks; i++) { card->fh_buffer.ptr[1] = SDIO_CMD_PADDING << 4; card->fh_buffer.ptr += sig_units; } card->fh_buffer.count += padding_chunks; len += padding_chunks * sig_units; } } } r = unifi_bulk_rw(card, card->config_data.fromhost_sigbuf_handle, card->fh_buffer.buf, len, UNIFI_SDIO_WRITE); if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE) { return r; } if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to write fh signals: %u bytes, error %d\n", len, r); return r; } /* Update from-host-signals-written signal count */ card->from_host_signals_w = (card->from_host_signals_w + card->fh_buffer.count) % 128u; r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 0, (u8)card->from_host_signals_w); if (r != CSR_RESULT_SUCCESS) { unifi_error(card->ospriv, "Failed to write fh signal count %u with error %d\n", card->from_host_signals_w, r); return r; } card->generate_interrupt = 1; /* Reset the fh buffer pointer */ card->fh_buffer.ptr = card->fh_buffer.buf; card->fh_buffer.count = 0; #ifdef CSR_WIFI_HIP_NOISY unifi_error(card->ospriv, "END flush: fh len %d, count %d\n", card->fh_buffer.ptr - card->fh_buffer.buf, card->fh_buffer.count); #endif /* CSR_WIFI_HIP_NOISY */ return CSR_RESULT_SUCCESS; } /* flush_fh_buffer() */ /* * --------------------------------------------------------------------------- * restart_packet_flow * * This function is called before the bottom-half thread sleeps. * It checks whether both data and signal resources are available and * then calls the OS-layer function to re-enable packet transmission. * * Arguments: * card Pointer to card context struct * * Returns: * None. * --------------------------------------------------------------------------- */ static void restart_packet_flow(card_t *card) { u8 q; /* * We only look at the fh_traffic_queue, because that is where packets from * the network stack are placed. */ for (q = 0; q <= UNIFI_TRAFFIC_Q_VO; q++) { if (card_is_tx_q_paused(card, q) && CSR_WIFI_HIP_Q_SLOTS_FREE(&card->fh_traffic_queue[q]) >= RESUME_XMIT_THRESHOLD) { #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE) unifi_debug_log_to_buf("U"); #endif card_tx_q_unpause(card, q); unifi_restart_xmit(card->ospriv, (unifi_TrafficQueue)q); } } } /* restart_packet_flow() */