+++ /dev/null
-/*
- * @file: hif.c
- *
- * @abstract: HIF layer reference implementation for Atheros SDIO stack
- *
- * @notice: Copyright (c) 2004-2006 Atheros Communications Inc.
- *
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation;
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- *
- *
- */
-
-#include "hif_internal.h"
-
-/* ------ Static Variables ------ */
-
-/* ------ Global Variable Declarations ------- */
-SD_PNP_INFO Ids[] = {
- {
- .SDIO_ManufacturerID = MANUFACTURER_ID_AR6001_BASE | 0xB,
- .SDIO_ManufacturerCode = MANUFACTURER_CODE,
- .SDIO_FunctionClass = FUNCTION_CLASS,
- .SDIO_FunctionNo = 1
- },
- {
- .SDIO_ManufacturerID = MANUFACTURER_ID_AR6001_BASE | 0xA,
- .SDIO_ManufacturerCode = MANUFACTURER_CODE,
- .SDIO_FunctionClass = FUNCTION_CLASS,
- .SDIO_FunctionNo = 1
- },
- {
- .SDIO_ManufacturerID = MANUFACTURER_ID_AR6001_BASE | 0x9,
- .SDIO_ManufacturerCode = MANUFACTURER_CODE,
- .SDIO_FunctionClass = FUNCTION_CLASS,
- .SDIO_FunctionNo = 1
- },
- {
- .SDIO_ManufacturerID = MANUFACTURER_ID_AR6001_BASE | 0x8,
- .SDIO_ManufacturerCode = MANUFACTURER_CODE,
- .SDIO_FunctionClass = FUNCTION_CLASS,
- .SDIO_FunctionNo = 1
- },
- {
- .SDIO_ManufacturerID = MANUFACTURER_ID_AR6002_BASE | 0x0,
- .SDIO_ManufacturerCode = MANUFACTURER_CODE,
- .SDIO_FunctionClass = FUNCTION_CLASS,
- .SDIO_FunctionNo = 1
- },
- {
- .SDIO_ManufacturerID = MANUFACTURER_ID_AR6002_BASE | 0x1,
- .SDIO_ManufacturerCode = MANUFACTURER_CODE,
- .SDIO_FunctionClass = FUNCTION_CLASS,
- .SDIO_FunctionNo = 1
- },
- {
- } //list is null termintaed
-};
-
-TARGET_FUNCTION_CONTEXT FunctionContext = {
- .function.Version = CT_SDIO_STACK_VERSION_CODE,
- .function.pName = "sdio_wlan",
- .function.MaxDevices = 1,
- .function.NumDevices = 0,
- .function.pIds = Ids,
- .function.pProbe = hifDeviceInserted,
- .function.pRemove = hifDeviceRemoved,
- .function.pSuspend = NULL,
- .function.pResume = NULL,
- .function.pWake = NULL,
- .function.pContext = &FunctionContext,
-};
-
-HIF_DEVICE hifDevice[HIF_MAX_DEVICES];
-HTC_CALLBACKS htcCallbacks;
-BUS_REQUEST busRequest[BUS_REQUEST_MAX_NUM];
-static BUS_REQUEST *s_busRequestFreeQueue = NULL;
-OS_CRITICALSECTION lock;
-extern A_UINT32 onebitmode;
-extern A_UINT32 busspeedlow;
-
-#ifdef DEBUG
-extern A_UINT32 debughif;
-#define ATH_DEBUG_ERROR 1
-#define ATH_DEBUG_WARN 2
-#define ATH_DEBUG_TRACE 3
-#define _AR_DEBUG_PRINTX_ARG(arg...) arg
-#define AR_DEBUG_PRINTF(lvl, args)\
- {if (lvl <= debughif)\
- A_PRINTF(KERN_ALERT _AR_DEBUG_PRINTX_ARG args);\
- }
-#else
-#define AR_DEBUG_PRINTF(lvl, args)
-#endif
-
-static BUS_REQUEST *hifAllocateBusRequest(void);
-static void hifFreeBusRequest(BUS_REQUEST *busrequest);
-static THREAD_RETURN insert_helper_func(POSKERNEL_HELPER pHelper);
-static void ResetAllCards(void);
-
-/* ------ Functions ------ */
-int HIFInit(HTC_CALLBACKS *callbacks)
-{
- SDIO_STATUS status;
- DBG_ASSERT(callbacks != NULL);
-
- /* Store the callback and event handlers */
- htcCallbacks.deviceInsertedHandler = callbacks->deviceInsertedHandler;
- htcCallbacks.deviceRemovedHandler = callbacks->deviceRemovedHandler;
- htcCallbacks.deviceSuspendHandler = callbacks->deviceSuspendHandler;
- htcCallbacks.deviceResumeHandler = callbacks->deviceResumeHandler;
- htcCallbacks.deviceWakeupHandler = callbacks->deviceWakeupHandler;
- htcCallbacks.rwCompletionHandler = callbacks->rwCompletionHandler;
- htcCallbacks.dsrHandler = callbacks->dsrHandler;
-
- CriticalSectionInit(&lock);
-
- /* Register with bus driver core */
- status = SDIO_RegisterFunction(&FunctionContext.function);
- DBG_ASSERT(SDIO_SUCCESS(status));
-
- return(0);
-}
-
-A_STATUS
-HIFReadWrite(HIF_DEVICE *device,
- A_UINT32 address,
- A_UCHAR *buffer,
- A_UINT32 length,
- A_UINT32 request,
- void *context)
-{
- A_UINT8 rw;
- A_UINT8 mode;
- A_UINT8 funcNo;
- A_UINT8 opcode;
- A_UINT16 count;
- SDREQUEST *sdrequest;
- SDIO_STATUS sdiostatus;
- BUS_REQUEST *busrequest;
- A_STATUS status = A_OK;
-
- DBG_ASSERT(device != NULL);
- DBG_ASSERT(device->handle != NULL);
-
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Device: %p\n", device));
-
- do {
- busrequest = hifAllocateBusRequest();
- if (busrequest == NULL) {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("HIF Unable to allocate bus request\n"));
- status = A_NO_RESOURCE;
- break;
- }
-
- sdrequest = busrequest->request;
- busrequest->context = context;
-
- sdrequest->pDataBuffer = buffer;
- if (request & HIF_SYNCHRONOUS) {
- sdrequest->Flags = SDREQ_FLAGS_RESP_SDIO_R5 | SDREQ_FLAGS_DATA_TRANS;
- sdrequest->pCompleteContext = NULL;
- sdrequest->pCompletion = NULL;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Execution mode: Synchronous\n"));
- } else if (request & HIF_ASYNCHRONOUS) {
- sdrequest->Flags = SDREQ_FLAGS_RESP_SDIO_R5 | SDREQ_FLAGS_DATA_TRANS |
- SDREQ_FLAGS_TRANS_ASYNC;
- sdrequest->pCompleteContext = busrequest;
- sdrequest->pCompletion = hifRWCompletionHandler;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Execution mode: Asynchronous\n"));
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Invalid execution mode: 0x%08x\n", request));
- status = A_EINVAL;
- break;
- }
-
- if (request & HIF_EXTENDED_IO) {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Command type: CMD53\n"));
- sdrequest->Command = CMD53;
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Invalid command type: 0x%08x\n", request));
- status = A_EINVAL;
- break;
- }
-
- if (request & HIF_BLOCK_BASIS) {
- mode = CMD53_BLOCK_BASIS;
- sdrequest->BlockLen = HIF_MBOX_BLOCK_SIZE;
- sdrequest->BlockCount = length / HIF_MBOX_BLOCK_SIZE;
- count = sdrequest->BlockCount;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Block mode (BlockLen: %d, BlockCount: %d)\n",
- sdrequest->BlockLen, sdrequest->BlockCount));
- } else if (request & HIF_BYTE_BASIS) {
- mode = CMD53_BYTE_BASIS;
- sdrequest->BlockLen = length;
- sdrequest->BlockCount = 1;
- count = sdrequest->BlockLen;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Byte mode (BlockLen: %d, BlockCount: %d)\n",
- sdrequest->BlockLen, sdrequest->BlockCount));
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Invalid data mode: 0x%08x\n", request));
- status = A_EINVAL;
- break;
- }
-
-#if 0
- /* useful for checking register accesses */
- if (length & 0x3) {
- A_PRINTF(KERN_ALERT"HIF (%s) is not a multiple of 4 bytes, addr:0x%X, len:%d\n",
- request & HIF_WRITE ? "write":"read", address, length);
- }
-#endif
-
- if ((address >= HIF_MBOX_START_ADDR(0)) &&
- (address <= HIF_MBOX_END_ADDR(3)))
- {
-
- DBG_ASSERT(length <= HIF_MBOX_WIDTH);
-
- /*
- * Mailbox write. Adjust the address so that the last byte
- * falls on the EOM address.
- */
- address += (HIF_MBOX_WIDTH - length);
- }
-
-
-
- if (request & HIF_WRITE) {
- rw = CMD53_WRITE;
- sdrequest->Flags |= SDREQ_FLAGS_DATA_WRITE;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Direction: Write\n"));
- } else if (request & HIF_READ) {
- rw = CMD53_READ;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Direction: Read\n"));
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Invalid direction: 0x%08x\n", request));
- status = A_EINVAL;
- break;
- }
-
- if (request & HIF_FIXED_ADDRESS) {
- opcode = CMD53_FIXED_ADDRESS;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Address mode: Fixed\n"));
- } else if (request & HIF_INCREMENTAL_ADDRESS) {
- opcode = CMD53_INCR_ADDRESS;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Address mode: Incremental\n"));
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Invalid address mode: 0x%08x\n", request));
- status = A_EINVAL;
- break;
- }
-
- funcNo = SDDEVICE_GET_SDIO_FUNCNO(device->handle);
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Function number: %d\n", funcNo));
- SDIO_SET_CMD53_ARG(sdrequest->Argument, rw, funcNo,
- mode, opcode, address, count);
-
- /* Send the command out */
- sdiostatus = SDDEVICE_CALL_REQUEST_FUNC(device->handle, sdrequest);
-
- if (!SDIO_SUCCESS(sdiostatus)) {
- status = A_ERROR;
- }
-
- } while (FALSE);
-
- if (A_FAILED(status) || (request & HIF_SYNCHRONOUS)) {
- if (busrequest != NULL) {
- hifFreeBusRequest(busrequest);
- }
- }
-
- if (A_FAILED(status) && (request & HIF_ASYNCHRONOUS)) {
- /* call back async handler on failure */
- htcCallbacks.rwCompletionHandler(context, status);
- }
-
- return status;
-}
-
-A_STATUS
-HIFConfigureDevice(HIF_DEVICE *device, HIF_DEVICE_CONFIG_OPCODE opcode,
- void *config, A_UINT32 configLen)
-{
- A_UINT32 count;
-
- switch(opcode) {
- case HIF_DEVICE_GET_MBOX_BLOCK_SIZE:
- ((A_UINT32 *)config)[0] = HIF_MBOX0_BLOCK_SIZE;
- ((A_UINT32 *)config)[1] = HIF_MBOX1_BLOCK_SIZE;
- ((A_UINT32 *)config)[2] = HIF_MBOX2_BLOCK_SIZE;
- ((A_UINT32 *)config)[3] = HIF_MBOX3_BLOCK_SIZE;
- break;
-
- case HIF_DEVICE_GET_MBOX_ADDR:
- for (count = 0; count < 4; count ++) {
- ((A_UINT32 *)config)[count] = HIF_MBOX_START_ADDR(count);
- }
- break;
- case HIF_DEVICE_GET_IRQ_PROC_MODE:
- /* the SDIO stack allows the interrupts to be processed either way, ASYNC or SYNC */
- *((HIF_DEVICE_IRQ_PROCESSING_MODE *)config) = HIF_DEVICE_IRQ_ASYNC_SYNC;
- break;
- default:
- AR_DEBUG_PRINTF(ATH_DEBUG_WARN,
- ("Unsupported configuration opcode: %d\n", opcode));
- return A_ERROR;
- }
-
- return A_OK;
-}
-
-void
-HIFShutDownDevice(HIF_DEVICE *device)
-{
- A_UINT8 data;
- A_UINT32 count;
- SDIO_STATUS status;
- SDCONFIG_BUS_MODE_DATA busSettings;
- SDCONFIG_FUNC_ENABLE_DISABLE_DATA fData;
-
- if (device != NULL) {
- DBG_ASSERT(device->handle != NULL);
-
- /* Remove the allocated current if any */
- status = SDLIB_IssueConfig(device->handle,
- SDCONFIG_FUNC_FREE_SLOT_CURRENT, NULL, 0);
- DBG_ASSERT(SDIO_SUCCESS(status));
-
- /* Disable the card */
- fData.EnableFlags = SDCONFIG_DISABLE_FUNC;
- fData.TimeOut = 1;
- status = SDLIB_IssueConfig(device->handle, SDCONFIG_FUNC_ENABLE_DISABLE,
- &fData, sizeof(fData));
- DBG_ASSERT(SDIO_SUCCESS(status));
-
- /* Perform a soft I/O reset */
- data = SDIO_IO_RESET;
- status = SDLIB_IssueCMD52(device->handle, 0, SDIO_IO_ABORT_REG,
- &data, 1, 1);
- DBG_ASSERT(SDIO_SUCCESS(status));
-
- /*
- * WAR - Codetelligence driver does not seem to shutdown correctly in 1
- * bit mode. By default it configures the HC in the 4 bit. Its later in
- * our driver that we switch to 1 bit mode. If we try to shutdown, the
- * driver hangs so we revert to 4 bit mode, to be transparent to the
- * underlying bus driver.
- */
- if (onebitmode) {
- ZERO_OBJECT(busSettings);
- busSettings.BusModeFlags = SDDEVICE_GET_BUSMODE_FLAGS(device->handle);
- SDCONFIG_SET_BUS_WIDTH(busSettings.BusModeFlags,
- SDCONFIG_BUS_WIDTH_4_BIT);
-
- /* Issue config request to change the bus width to 4 bit */
- status = SDLIB_IssueConfig(device->handle, SDCONFIG_BUS_MODE_CTRL,
- &busSettings,
- sizeof(SDCONFIG_BUS_MODE_DATA));
- DBG_ASSERT(SDIO_SUCCESS(status));
- }
-
- /* Free the bus requests */
- for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
- SDDeviceFreeRequest(device->handle, busRequest[count].request);
- }
- /* Clean up the queue */
- s_busRequestFreeQueue = NULL;
- } else {
- /* since we are unloading the driver anyways, reset all cards in case the SDIO card
- * is externally powered and we are unloading the SDIO stack. This avoids the problem when
- * the SDIO stack is reloaded and attempts are made to re-enumerate a card that is already
- * enumerated */
- ResetAllCards();
- /* Unregister with bus driver core */
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Unregistering with the bus driver\n"));
- status = SDIO_UnregisterFunction(&FunctionContext.function);
- DBG_ASSERT(SDIO_SUCCESS(status));
- }
-}
-
-void
-hifRWCompletionHandler(SDREQUEST *request)
-{
- A_STATUS status;
- void *context;
- BUS_REQUEST *busrequest;
-
- if (SDIO_SUCCESS(request->Status)) {
- status = A_OK;
- } else {
- status = A_ERROR;
- }
-
- DBG_ASSERT(status == A_OK);
- busrequest = (BUS_REQUEST *) request->pCompleteContext;
- context = (void *) busrequest->context;
- /* free the request before calling the callback, in case the
- * callback submits another request, this guarantees that
- * there is at least 1 free request available everytime the callback
- * is invoked */
- hifFreeBusRequest(busrequest);
- htcCallbacks.rwCompletionHandler(context, status);
-}
-
-void
-hifIRQHandler(void *context)
-{
- A_STATUS status;
- HIF_DEVICE *device;
-
- device = (HIF_DEVICE *)context;
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Device: %p\n", device));
- status = htcCallbacks.dsrHandler(device->htc_handle);
- DBG_ASSERT(status == A_OK);
-}
-
-BOOL
-hifDeviceInserted(SDFUNCTION *function, SDDEVICE *handle)
-{
- BOOL enabled;
- A_UINT8 data;
- A_UINT32 count;
- HIF_DEVICE *device;
- SDIO_STATUS status;
- A_UINT16 maxBlocks;
- A_UINT16 maxBlockSize;
- SDCONFIG_BUS_MODE_DATA busSettings;
- SDCONFIG_FUNC_ENABLE_DISABLE_DATA fData;
- TARGET_FUNCTION_CONTEXT *functionContext;
- SDCONFIG_FUNC_SLOT_CURRENT_DATA slotCurrent;
- SD_BUSCLOCK_RATE currentBusClock;
-
- DBG_ASSERT(function != NULL);
- DBG_ASSERT(handle != NULL);
-
- device = addHifDevice(handle);
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Device: %p\n", device));
- functionContext = (TARGET_FUNCTION_CONTEXT *)function->pContext;
-
- /*
- * Issue commands to get the manufacturer ID and stuff and compare it
- * against the rev Id derived from the ID registered during the
- * initialization process. Report the device only in the case there
- * is a match. In the case od SDIO, the bus driver has already queried
- * these details so we just need to use their data structures to get the
- * relevant values. Infact, the driver has already matched it against
- * the Ids that we registered with it so we dont need to the step here.
- */
-
- /* Configure the SDIO Bus Width */
- if (onebitmode) {
- data = SDIO_BUS_WIDTH_1_BIT;
- status = SDLIB_IssueCMD52(handle, 0, SDIO_BUS_IF_REG, &data, 1, 1);
- if (!SDIO_SUCCESS(status)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Unable to set the bus width to 1 bit\n"));
- return FALSE;
- }
- }
-
- /* Get current bus flags */
- ZERO_OBJECT(busSettings);
-
- busSettings.BusModeFlags = SDDEVICE_GET_BUSMODE_FLAGS(handle);
- if (onebitmode) {
- SDCONFIG_SET_BUS_WIDTH(busSettings.BusModeFlags,
- SDCONFIG_BUS_WIDTH_1_BIT);
- }
-
- /* get the current operating clock, the bus driver sets us up based
- * on what our CIS reports and what the host controller can handle
- * we can use this to determine whether we want to drop our clock rate
- * down */
- currentBusClock = SDDEVICE_GET_OPER_CLOCK(handle);
- busSettings.ClockRate = currentBusClock;
-
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("HIF currently running at: %d \n",currentBusClock));
-
- /* see if HIF wants to run at a lower clock speed, we may already be
- * at that lower clock speed */
- if (currentBusClock > (SDIO_CLOCK_FREQUENCY_DEFAULT >> busspeedlow)) {
- busSettings.ClockRate = SDIO_CLOCK_FREQUENCY_DEFAULT >> busspeedlow;
- AR_DEBUG_PRINTF(ATH_DEBUG_WARN,
- ("HIF overriding clock to %d \n",busSettings.ClockRate));
- }
-
- /* Issue config request to override clock rate */
- status = SDLIB_IssueConfig(handle, SDCONFIG_FUNC_CHANGE_BUS_MODE, &busSettings,
- sizeof(SDCONFIG_BUS_MODE_DATA));
- if (!SDIO_SUCCESS(status)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Unable to configure the host clock\n"));
- return FALSE;
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Configured clock: %d, Maximum clock: %d\n",
- busSettings.ActualClockRate,
- SDDEVICE_GET_MAX_CLOCK(handle)));
- }
-
- /*
- * Check if the target supports block mode. This result of this check
- * can be used to implement the HIFReadWrite API.
- */
- if (SDDEVICE_GET_SDIO_FUNC_MAXBLKSIZE(handle)) {
- /* Limit block size to operational block limit or card function
- capability */
- maxBlockSize = min(SDDEVICE_GET_OPER_BLOCK_LEN(handle),
- SDDEVICE_GET_SDIO_FUNC_MAXBLKSIZE(handle));
-
- /* check if the card support multi-block transfers */
- if (!(SDDEVICE_GET_SDIOCARD_CAPS(handle) & SDIO_CAPS_MULTI_BLOCK)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Byte basis only\n"));
-
- /* Limit block size to max byte basis */
- maxBlockSize = min(maxBlockSize,
- (A_UINT16)SDIO_MAX_LENGTH_BYTE_BASIS);
- maxBlocks = 1;
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Multi-block capable\n"));
- maxBlocks = SDDEVICE_GET_OPER_BLOCKS(handle);
- status = SDLIB_SetFunctionBlockSize(handle, HIF_MBOX_BLOCK_SIZE);
- if (!SDIO_SUCCESS(status)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Failed to set block size. Err:%d\n", status));
- return FALSE;
- }
- }
-
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Bytes Per Block: %d bytes, Block Count:%d \n",
- maxBlockSize, maxBlocks));
- } else {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Function does not support Block Mode!\n"));
- return FALSE;
- }
-
- /* Allocate the slot current */
- status = SDLIB_GetDefaultOpCurrent(handle, &slotCurrent.SlotCurrent);
- if (SDIO_SUCCESS(status)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Allocating Slot current: %d mA\n",
- slotCurrent.SlotCurrent));
- status = SDLIB_IssueConfig(handle, SDCONFIG_FUNC_ALLOC_SLOT_CURRENT,
- &slotCurrent, sizeof(slotCurrent));
- if (!SDIO_SUCCESS(status)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Failed to allocate slot current %d\n", status));
- return FALSE;
- }
- }
-
- /* Enable the dragon function */
- count = 0;
- enabled = FALSE;
- fData.TimeOut = 1;
- fData.EnableFlags = SDCONFIG_ENABLE_FUNC;
- while ((count++ < SDWLAN_ENABLE_DISABLE_TIMEOUT) && !enabled)
- {
- /* Enable dragon */
- status = SDLIB_IssueConfig(handle, SDCONFIG_FUNC_ENABLE_DISABLE,
- &fData, sizeof(fData));
- if (!SDIO_SUCCESS(status)) {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Attempting to enable the card again\n"));
- continue;
- }
-
- /* Mark the status as enabled */
- enabled = TRUE;
- }
-
- /* Check if we were succesful in enabling the target */
- if (!enabled) {
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
- ("Failed to communicate with the target\n"));
- return FALSE;
- }
-
- /* Allocate the bus requests to be used later */
- A_MEMZERO(busRequest, sizeof(busRequest));
- for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
- if ((busRequest[count].request = SDDeviceAllocRequest(handle)) == NULL){
- AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Unable to allocate memory\n"));
- /* TODO: Free the memory that has already been allocated */
- return FALSE;
- }
- hifFreeBusRequest(&busRequest[count]);
-
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("0x%08x = busRequest[%d].request = 0x%08x\n",
- (unsigned int) &busRequest[count], count,
- (unsigned int) busRequest[count].request));
- }
-
- /* Schedule a worker to handle device inserted, this is a temporary workaround
- * to fix a deadlock if the device fails to intialize in the insertion handler
- * The failure causes the instance to shutdown the HIF layer and unregister the
- * function driver within the busdriver probe context which can deadlock
- *
- * NOTE: we cannot use the default work queue because that would block
- * SD bus request processing for all synchronous I/O. We must use a kernel
- * thread that is creating using the helper library.
- * */
-
- if (SDIO_SUCCESS(SDLIB_OSCreateHelper(&device->insert_helper,
- insert_helper_func,
- device))) {
- device->helper_started = TRUE;
- }
-
- return TRUE;
-}
-
-static THREAD_RETURN insert_helper_func(POSKERNEL_HELPER pHelper)
-{
-
- /*
- * Adding a wait of around a second before we issue the very first
- * command to dragon. During the process of loading/unloading the
- * driver repeatedly it was observed that we get a data timeout
- * while accessing function 1 registers in the chip. The theory at
- * this point is that some initialization delay in dragon is
- * causing the SDIO state in dragon core to be not ready even after
- * the ready bit indicates that function 1 is ready. Accomodating
- * for this behavior by adding some delay in the driver before it
- * issues the first command after switching on dragon. Need to
- * investigate this a bit more - TODO
- */
-
- A_MDELAY(1000);
- /* Inform HTC */
- if ((htcCallbacks.deviceInsertedHandler(SD_GET_OS_HELPER_CONTEXT(pHelper))) != A_OK) {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Device rejected\n"));
- }
-
- return 0;
-}
-
-void
-HIFAckInterrupt(HIF_DEVICE *device)
-{
- SDIO_STATUS status;
- DBG_ASSERT(device != NULL);
- DBG_ASSERT(device->handle != NULL);
-
- /* Acknowledge our function IRQ */
- status = SDLIB_IssueConfig(device->handle, SDCONFIG_FUNC_ACK_IRQ,
- NULL, 0);
- DBG_ASSERT(SDIO_SUCCESS(status));
-}
-
-void
-HIFUnMaskInterrupt(HIF_DEVICE *device)
-{
- SDIO_STATUS status;
-
- DBG_ASSERT(device != NULL);
- DBG_ASSERT(device->handle != NULL);
-
- /* Register the IRQ Handler */
- SDDEVICE_SET_IRQ_HANDLER(device->handle, hifIRQHandler, device);
-
- /* Unmask our function IRQ */
- status = SDLIB_IssueConfig(device->handle, SDCONFIG_FUNC_UNMASK_IRQ,
- NULL, 0);
- DBG_ASSERT(SDIO_SUCCESS(status));
-}
-
-void HIFMaskInterrupt(HIF_DEVICE *device)
-{
- SDIO_STATUS status;
- DBG_ASSERT(device != NULL);
- DBG_ASSERT(device->handle != NULL);
-
- /* Mask our function IRQ */
- status = SDLIB_IssueConfig(device->handle, SDCONFIG_FUNC_MASK_IRQ,
- NULL, 0);
- DBG_ASSERT(SDIO_SUCCESS(status));
-
- /* Unregister the IRQ Handler */
- SDDEVICE_SET_IRQ_HANDLER(device->handle, NULL, NULL);
-}
-
-static BUS_REQUEST *hifAllocateBusRequest(void)
-{
- BUS_REQUEST *busrequest;
-
- /* Acquire lock */
- CriticalSectionAcquire(&lock);
-
- /* Remove first in list */
- if((busrequest = s_busRequestFreeQueue) != NULL)
- {
- s_busRequestFreeQueue = busrequest->next;
- }
-
- /* Release lock */
- CriticalSectionRelease(&lock);
-
- return busrequest;
-}
-
-static void
-hifFreeBusRequest(BUS_REQUEST *busrequest)
-{
- DBG_ASSERT(busrequest != NULL);
-
- /* Acquire lock */
- CriticalSectionAcquire(&lock);
-
- /* Insert first in list */
- busrequest->next = s_busRequestFreeQueue;
- s_busRequestFreeQueue = busrequest;
-
- /* Release lock */
- CriticalSectionRelease(&lock);
-}
-
-void
-hifDeviceRemoved(SDFUNCTION *function, SDDEVICE *handle)
-{
- A_STATUS status;
- HIF_DEVICE *device;
- DBG_ASSERT(function != NULL);
- DBG_ASSERT(handle != NULL);
-
- device = getHifDevice(handle);
- status = htcCallbacks.deviceRemovedHandler(device->htc_handle, A_OK);
-
- /* cleanup the helper thread */
- if (device->helper_started) {
- SDLIB_OSDeleteHelper(&device->insert_helper);
- device->helper_started = FALSE;
- }
-
- delHifDevice(handle);
- DBG_ASSERT(status == A_OK);
-}
-
-HIF_DEVICE *
-addHifDevice(SDDEVICE *handle)
-{
- DBG_ASSERT(handle != NULL);
- hifDevice[0].handle = handle;
- return &hifDevice[0];
-}
-
-HIF_DEVICE *
-getHifDevice(SDDEVICE *handle)
-{
- DBG_ASSERT(handle != NULL);
- return &hifDevice[0];
-}
-
-void
-delHifDevice(SDDEVICE *handle)
-{
- DBG_ASSERT(handle != NULL);
- hifDevice[0].handle = NULL;
-}
-
-struct device*
-HIFGetOSDevice(HIF_DEVICE *device)
-{
- return &device->handle->Device->dev;
-}
-
-static void ResetAllCards(void)
-{
- UINT8 data;
- SDIO_STATUS status;
- int i;
-
- data = SDIO_IO_RESET;
-
- /* set the I/O CARD reset bit:
- * NOTE: we are exploiting a "feature" of the SDIO core that resets the core when you
- * set the RES bit in the SDIO_IO_ABORT register. This bit however "normally" resets the
- * I/O functions leaving the SDIO core in the same state (as per SDIO spec).
- * In this design, this reset can be used to reset the SDIO core itself */
- for (i = 0; i < HIF_MAX_DEVICES; i++) {
- if (hifDevice[i].handle != NULL) {
- AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
- ("Issuing I/O Card reset for instance: %d \n",i));
- /* set the I/O Card reset bit */
- status = SDLIB_IssueCMD52(hifDevice[i].handle,
- 0, /* function 0 space */
- SDIO_IO_ABORT_REG,
- &data,
- 1, /* 1 byte */
- TRUE); /* write */
- }
- }
-
-}
-
-void HIFSetHandle(void *hif_handle, void *handle)
-{
- HIF_DEVICE *device = (HIF_DEVICE *) hif_handle;
-
- device->htc_handle = handle;
-
- return;
-}
projects / openwrt / svn-archive / archive.git / blobdiff