static void hifDeviceRemoved(struct sdio_func *func)
{
A_STATUS status = A_OK;
HIF_DEVICE *device;
AR_DEBUG_ASSERT(func != NULL);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: +hifDeviceRemoved\n"));
device = getHifDevice(func);
if (device->claimedContext != NULL) {
status = osdrvCallbacks.deviceRemovedHandler(device->claimedContext, device);
}
if (device->is_suspend) {
device->is_suspend = FALSE;
} else {
if (hifDisableFunc(device, func)!=0) {
status = A_ERROR;
}
}
CleanupHIFScatterResources(device);
delHifDevice(device);
AR_DEBUG_ASSERT(status == A_OK);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: -hifDeviceRemoved\n"));
}
static void hifDeviceRemoved(struct sdio_func *func)
{
A_STATUS status = A_OK;
HIF_DEVICE *device;
int ret;
AR_DEBUG_ASSERT(func != NULL);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: +hifDeviceRemoved\n"));
device = getHifDevice(func);
if (device->claimedContext != NULL) {
status = osdrvCallbacks.deviceRemovedHandler(device->claimedContext, device);
}
do {
if (device->is_suspend) {
device->is_suspend = FALSE;
break;
}
if (!IS_ERR(device->async_task)) {
init_completion(&device->async_completion);
device->async_shutdown = 1;
up(&device->sem_async);
wait_for_completion(&device->async_completion);
device->async_task = NULL;
}
/* Disable the card */
sdio_claim_host(device->func);
ret = sdio_disable_func(device->func);
sdio_release_host(device->func);
} while (0);
delHifDevice(device);
AR_DEBUG_ASSERT(status == A_OK);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: -hifDeviceRemoved\n"));
}
/* handle HTC startup via thread*/
static int resume_task(void *param)
{
HIF_DEVICE *device;
device = (HIF_DEVICE *)param;
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: call HTC from resume_task\n"));
/* start up inform DRV layer */
if (device && device->claimedContext && osdrvCallbacks.deviceResumeHandler &&
osdrvCallbacks.deviceResumeHandler(device->claimedContext) != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: Device rejected\n"));
}
return 0;
}
/* handle HTC startup via thread*/
static int startup_task(void *param)
{
HIF_DEVICE *device;
device = (HIF_DEVICE *)param;
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: call HTC from startup_task\n"));
/* start up inform DRV layer */
if ((osdrvCallbacks.deviceInsertedHandler(osdrvCallbacks.context,device)) != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: Device rejected\n"));
}
return 0;
}
static int hifDeviceSuspend(struct device *dev)
{
struct sdio_func *func = dev_to_sdio_func(dev);
A_STATUS status = A_OK;
HIF_DEVICE *device;
device = getHifDevice(func);
if (device && device->claimedContext && osdrvCallbacks.deviceSuspendHandler) {
status = osdrvCallbacks.deviceSuspendHandler(device->claimedContext);
}
if (status == A_OK) {
int oldresetvalue = reset_sdio_on_unload;
reset_sdio_on_unload = 1;
hifDisableFunc(device, func);
reset_sdio_on_unload = oldresetvalue;
device->is_suspend = TRUE;
} else if (status == A_EBUSY) {
A_INT32 cnt = 10;
A_UINT8 host_int_status;
do {
while (atomic_read(&device->irqHandling)) {
/* wait until irq handler finished all the jobs */
schedule_timeout(HZ/10);
}
/* check if there is any pending irq due to force done */
host_int_status = 0;
status = HIFReadWrite(device, HOST_INT_STATUS_ADDRESS,
(A_UINT8 *)&host_int_status, sizeof(host_int_status),
HIF_RD_SYNC_BYTE_INC, NULL);
host_int_status = A_SUCCESS(status) ? (host_int_status & (1 << 0)) : 0;
if (host_int_status) {
schedule(); /* schedule for next dsrHandler */
}
} while (host_int_status && --cnt > 0);
if (host_int_status && cnt == 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
("AR6000: %s(), Unable clear up pending IRQ before the system suspended\n",
__FUNCTION__));
}
#if 1
status = A_OK; /* assume that sdio host controller will take care the power of wifi chip */
#else
return -EBUSY; /* Return -EBUSY if customer use all android patch of mmc stack provided by us */
#endif
}
return A_SUCCESS(status) ? 0 : status;
}
static int hifDeviceSuspend(struct device *dev)
{
struct sdio_func *func = dev_to_sdio_func(dev);
A_STATUS status = A_OK;
HIF_DEVICE *device;
device = getHifDevice(func);
if (device && device->claimedContext && osdrvCallbacks.deviceSuspendHandler) {
status = osdrvCallbacks.deviceSuspendHandler(device->claimedContext);
}
if (status == A_OK) {
hifDisableFunc(device, func);
device->is_suspend = TRUE;
} else if (status == A_EBUSY) {
status = A_OK; /* assume that sdio host controller will take care the power of wifi chip */
}
return A_SUCCESS(status) ? 0 : status;
}
void
hifDeviceRemoved(SDFUNCTION *function, SDDEVICE *handle)
{
A_STATUS status = A_OK;
HIF_DEVICE *device;
AR_DEBUG_ASSERT(function != NULL);
AR_DEBUG_ASSERT(handle != NULL);
/* our device is the IRQ context we stored */
device = (HIF_DEVICE *)handle->IrqContext;
if (device->claimedContext != NULL) {
status = osdrvCallbacks.deviceRemovedHandler(device->claimedContext, device);
}
/* cleanup the instance */
hifCleanupDevice(device);
AR_DEBUG_ASSERT(status == A_OK);
}
void
hifDeviceRemoved(SD_DEVICE_HANDLE *handle)
{
A_STATUS status;
HIF_DEVICE *device;
NDIS_DEBUG_PRINTF(1, "%s() : + Enter \r\n", __FUNCTION__);
device = getHifDevice(handle);
if (device->claimedContext != NULL) {
status = osdrvCallbacks.deviceRemovedHandler(device->claimedContext, device);
}
delHifDevice(handle);
AR_DEBUG_ASSERT(status == A_OK);
return;
}
int HIFDoDeviceSuspend(HIF_DEVICE *device)
{
A_STATUS status = A_OK;
if (device && device->claimedContext && osdrvCallbacks.deviceSuspendHandler) {
status = osdrvCallbacks.deviceSuspendHandler(device->claimedContext);
}
if (status == A_OK) {
/* Waiting for all pending request */
if (!IS_ERR(device->async_task)) {
init_completion(&device->async_completion);
device->async_shutdown = 1;
up(&device->sem_async);
wait_for_completion(&device->async_completion);
device->async_task = NULL;
}
device->is_suspend = TRUE;
} else if (status == A_EBUSY) {
return -EBUSY; /* Return -1 if customer use all android patch of mmc stack provided by us */
}
return A_SUCCESS(status) ? 0 : status;
}
/* handle HTC startup via thread*/
static int startup_task(void *param)
{
HIF_DEVICE *device;
device = (HIF_DEVICE *)param;
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: call HTC from startup_task\n"));
/* ATHENV */
#ifdef ANDROID_ENV
wake_lock(&ar6k_init_wake_lock);
#endif
/* ATHENV */
/* start up inform DRV layer */
if ((osdrvCallbacks.deviceInsertedHandler(osdrvCallbacks.context,device)) != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: Device rejected\n"));
}
/* ATHENV */
#ifdef ANDROID_ENV
wake_unlock(&ar6k_init_wake_lock);
#endif
/* ATHENV */
return 0;
}
/* handle HTC startup via thread*/
static int resume_task(void *param)
{
HIF_DEVICE *device;
device = (HIF_DEVICE *)param;
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: call HTC from resume_task\n"));
/* ATHENV */
#ifdef ANDROID_ENV
wake_lock(&ar6k_init_wake_lock);
#endif
/* ATHENV */
/* start up inform DRV layer */
if (device && device->claimedContext && osdrvCallbacks.deviceResumeHandler &&
osdrvCallbacks.deviceResumeHandler(device->claimedContext) != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: Device rejected\n"));
}
/* ATHENV */
#ifdef ANDROID_ENV
wake_unlock(&ar6k_init_wake_lock);
#endif
/* ATHENV */
return 0;
}
BOOL
hifDeviceInserted(SD_DEVICE_HANDLE *handle)
{
HIF_DEVICE *device;
#if 0
SD_API_STATUS sdStatus;
SDIO_CARD_INFO sdioInfo;
SD_HOST_BLOCK_CAPABILITY blockCap;
SD_CARD_RCA cardRCA;
A_UCHAR rgucTuple[SD_CISTPLE_MAX_BODY_SIZE];
PSD_CISTPL_FUNCE_FUNCTION pFunce = (PSD_CISTPL_FUNCE_FUNCTION) rgucTuple;
A_UINT32 ulLength = 0;
A_UCHAR ucRegVal;
A_BOOL blockMode;
SD_CARD_INTERFACE ci;
SD_IO_FUNCTION_ENABLE_INFO fData;
DWORD bData;
//SDCONFIG_FUNC_SLOT_CURRENT_DATA slotCurrent;
//HANDLE hIrqThread;
#endif
HANDLE hThread;
device = addHifDevice(handle);
NDIS_DEBUG_PRINTF(1, "hifDeviceInserted: Enter\r\n");
#if 0
/* Enable SDIO [dragon] function */
fData.Interval = DEFAULT_SDIO_FUNCTION_RETRY_TIMEOUT;
fData.ReadyRetryCount = DEFAULT_SDIO_FUNCTION_RETRIES;
sdStatus = SDSetCardFeature (handle, SD_IO_FUNCTION_ENABLE, &fData, sizeof(fData));
if (!SD_API_SUCCESS(sdStatus))
{
return FALSE;
}
/*
* 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.
*/
sdStatus = SDCardInfoQuery(handle, SD_INFO_SDIO, &sdioInfo, sizeof(sdioInfo));
if (!SD_API_SUCCESS(sdStatus))
{
return FALSE;
}
funcNo = sdioInfo.FunctionNumber;
sdStatus = SDCardInfoQuery(handle, SD_INFO_REGISTER_RCA, &cardRCA, sizeof(cardRCA));
NDIS_DEBUG_PRINTF(1, " Card RCA is 0x%x \r\n", cardRCA);
/* Configure the SDIO Bus Width */
memset(&ci, 0, sizeof(ci));
if (sdio1bitmode) {
ci.InterfaceMode = SD_INTERFACE_SD_MMC_1BIT;
} else {
ci.InterfaceMode = SD_INTERFACE_SD_4BIT;
}
if (sdiobusspeedlow) {
ci.ClockRate = SDIO_CLOCK_FREQUENCY_REDUCED;
} else {
ci.ClockRate = SDIO_CLOCK_FREQUENCY_DEFAULT;
}
sdStatus = SDSetCardFeature(handle, SD_SET_CARD_INTERFACE, &ci, sizeof(ci));
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
/* Check if the target supports block mode */
sdStatus = SDReadWriteRegistersDirect(handle, SD_IO_READ, 0, 0x08, FALSE, &ucRegVal, 1);
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
blockMode = (ucRegVal & 0x2) >> 1; // SMB is bit 1
if (!blockMode)
{
NDIS_DEBUG_PRINTF(DBG_ERR, "[HIF] Function does not support block mode \r\n");
return FALSE;
}
else
{
NDIS_DEBUG_PRINTF(DBG_LEVEL_HIF, "[HIF] Function supports block mode \r\n");
blockCap.ReadBlocks = blockCap.WriteBlocks = 8;
blockCap.ReadBlockSize = blockCap.WriteBlockSize = HIF_MBOX_BLOCK_SIZE;
sdStatus = SDCardInfoQuery(handle, SD_INFO_HOST_BLOCK_CAPABILITY,
&blockCap, sizeof(blockCap));
if (blockCap.ReadBlockSize < blockCap.WriteBlockSize) {
maxBlockSize = blockCap.ReadBlockSize;
} else {
maxBlockSize = blockCap.WriteBlockSize;
}
if (blockCap.ReadBlocks < blockCap.WriteBlocks) {
maxBlocks = blockCap.ReadBlocks;
} else {
maxBlocks = blockCap.WriteBlocks;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, NULL, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) || (ulLength > sizeof(rgucTuple)) ) {
return FALSE;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, rgucTuple, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) || (pFunce->bType != SD_CISTPL_FUNCE_FUNCTION_TYPE) ) {
return FALSE;
}
if (maxBlockSize > pFunce->wMaxBlkSize) {
maxBlockSize = pFunce->wMaxBlkSize;
}
bData = (DWORD)maxBlockSize;
sdStatus = SDSetCardFeature(handle, SD_IO_FUNCTION_SET_BLOCK_SIZE, &bData, sizeof(bData));
}
NDIS_DEBUG_PRINTF(DBG_LEVEL_HIF,
"Bytes Per Block: %d bytes, Block Count:%d \r\n",
maxBlockSize, maxBlocks);
/* Allocate the slot current */
/* Kowsalya : commenting as there is no equivalent for this in WINCE */
/*
status = SDLIB_GetDefaultOpCurrent(handle, &slotCurrent.SlotCurrent);
if (SDIO_SUCCESS(status)) {
HIF_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)) {
HIF_DEBUG_PRINTF(ATH_DEBUG_ERROR,
("Failed to allocate slot current %d\n", status));
return FALSE;
}
}
*/
/* Initialize the bus requests to be used later */
A_MEMZERO(device->busRequest, sizeof(device->busRequest));
for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
NdisInitializeEvent(&device->busRequest[count].sem_req);
hifFreeBusRequest(device, &device->busRequest[count]);
}
#else
SetupSlotPowerControl(device);
if (!SetupSDIOInterface(device)) {
return FALSE;
}
#endif
InitializeCriticalSection(&gCriticalSection); //ÃʱâÈ
device->async_shutdown = 0;
hThread = CreateThread(NULL, 0, async_task, (void *)device, 0, NULL);
CeSetThreadPriority(hThread, 200);
CloseHandle(hThread);
NdisInitializeEvent(&device->sem_async);
#if USE_IRQ_THREAD
hThread = CreateThread(NULL, 0, hifIRQThread, (void *)device, 0, NULL);
CeSetThreadPriority(hThread, 200);
CloseHandle(hThread);
NdisInitializeEvent(&hifIRQEvent);
#endif
/* start up inform DRV layer */
if ((osdrvCallbacks.deviceInsertedHandler(osdrvCallbacks.context,device)) != A_OK) {
NDIS_DEBUG_PRINTF(DBG_ERR, "[HIF] AR6000: Device rejected \r\n");
}
NDIS_DEBUG_PRINTF(DBG_LEVEL_HIF, " %s() -Exit \r\n",__FUNCTION__);
return TRUE;
}
BOOL
hifDeviceInserted(SDFUNCTION *function, SDDEVICE *handle)
{
A_UINT32 count;
HIF_DEVICE *device;
BOOL accepted = FALSE;
AR_DEBUG_ASSERT(function != NULL);
AR_DEBUG_ASSERT(handle != NULL);
do {
device = (HIF_DEVICE *)KernelAlloc(sizeof(HIF_DEVICE));
if (NULL == device) {
break;
}
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Device: %p\n", device));
ZERO_POBJECT(device);
CriticalSectionInit(&device->lock);
device->busrequestfreelist = NULL;
device->handle = handle;
device->enabledSpiInts = ATH_SPI_INTR_PKT_AVAIL | ATH_SPI_INTR_CPU_INTR;
/* set the IRQ Handler which associates the instance with the SDDEVICE */
SDDEVICE_SET_IRQ_HANDLER(device->handle, hifIRQHandler, device);
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("Device: %p\n", device));
if (handle->pId[0].CardFlags & CARD_RAW) {
if (strstr(SDDEVICE_GET_HCDNAME(handle), SDIO_RAW_BD_BASE) == NULL) {
/* Not supported */
break;
}
}
/* Card identification */
AR_DEBUG_PRINTF(ATH_DEBUG_TRC,
("SPI card: %s\n", SDDEVICE_GET_HCDNAME(handle)));
/* Version information */
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("Stack version: %d.%d\n",
SDDEVICE_GET_VERSION_MAJOR(handle),
SDDEVICE_GET_VERSION_MINOR(handle)));
/* Get the maximum block size supported */
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("Maximum block length: %d bytes\n",
SDDEVICE_GET_MAX_BLOCK_LEN(handle)));
device->curBlockSize = SDDEVICE_GET_OPER_BLOCK_LEN(handle);
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("Current block length: %d bytes\n",
device->curBlockSize));
/* Allocate the bus requests to be used later */
for (count = 0; count < BUS_REQUEST_MAX_NUM_TOTAL; count ++) {
if ((device->busrequestblob[count].request = SDDeviceAllocRequest(handle)) == NULL){
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Unable to allocate bus request\n"));
break;
}
/* free to the list */
hifFreeBusRequest(device, &device->busrequestblob[count]);
}
if (count != BUS_REQUEST_MAX_NUM_TOTAL) {
break;
}
/* Configure the SPI interface */
if ((hifConfigureSPI(device)) != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Failed to configure the device\n"));
break;
}
/* Inform HTC */
if ((osdrvCallbacks.deviceInsertedHandler(osdrvCallbacks.context, (void *)device)) != A_OK) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("Device rejected\n"));
return FALSE;
}
accepted = TRUE;
} while (FALSE);
if (!accepted & (device != NULL)) {
/* cleanup device */
hifCleanupDevice(device);
}
return accepted;
}
