static BOOL
hifDeviceInserted(CF_DEVICE_HANDLE cfHandle)
{
HIF_DEVICE *device;
device = addHifDevice(cfHandle);
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "hifDeviceInserted: Enter\n");
HIF_DEBUG_PRINTF(ATH_LOG_INF, "hifDeviceInsetred: Device = %p\n",device);
/* Inform HTC */
if ((htcCallbacks.deviceInsertedHandler(device)) != A_OK) {
HIF_DEBUG_PRINTF(ATH_LOG_ERR, "hifDeviceInserted: HTC failed device inserted\n");
return FALSE;
}
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "hifDeviceInserted: Exit\n");
return TRUE;
}
BOOL
hifDeviceInserted(SD_DEVICE_HANDLE *handle)
{
HIF_DEVICE *device;
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;
#ifdef CEPC
HANDLE hThread;
#endif //CEPC
device = addHifDevice(handle);
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "hifDeviceInserted: Enter\n");
/* 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));
HIF_DEBUG_PRINTF(ATH_LOG_INF, "Card RCA is 0x%x\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) {
HIF_DEBUG_PRINTF(ATH_LOG_ERR, "Function does not support block mode\n");
return FALSE;
} else {
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "Function supports block mode\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));
}
HIF_DEBUG_PRINTF(ATH_LOG_TRC,
"Bytes Per Block: %d bytes, Block Count:%d \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;
}
}
*/
/* Inform HTC */
if ((htcCallbacks.deviceInsertedHandler(device)) != A_OK) {
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "Device rejected\n");
return FALSE;
}
#ifdef CEPC
NdisInitializeEvent(&hifIRQEvent);
hThread = CreateThread(NULL, 0,
hifIRQThread, (LPVOID)handle, 0, NULL);
CeSetThreadPriority(hThread, 200);
CloseHandle(hThread);
#endif //CEPC
return TRUE;
}
static int hifDeviceInserted(struct sdio_func *func, const struct sdio_device_id *id)
{
int ret;
HIF_DEVICE * device;
int count;
struct task_struct* startup_task_struct;
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
("AR6000: hifDeviceInserted, Function: 0x%X, Vendor ID: 0x%X, Device ID: 0x%X, block size: 0x%X/0x%X\n",
func->num, func->vendor, func->device, func->max_blksize, func->cur_blksize));
addHifDevice(func);
device = getHifDevice(func);
spin_lock_init(&device->lock);
spin_lock_init(&device->asynclock);
DL_LIST_INIT(&device->ScatterReqHead);
if (!nohifscattersupport) {
/* try to allow scatter operation on all instances,
* unless globally overridden */
device->scatter_enabled = TRUE;
}
/* enable the SDIO function */
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: claim\n"));
sdio_claim_host(func);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: enable\n"));
if ((id->device & MANUFACTURER_ID_AR6K_BASE_MASK) >= MANUFACTURER_ID_AR6003_BASE) {
/* enable 4-bit ASYNC interrupt on AR6003 or later devices */
ret = Func0_CMD52WriteByte(func->card, CCCR_SDIO_IRQ_MODE_REG, SDIO_IRQ_MODE_ASYNC_4BIT_IRQ);
if (ret) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("AR6000: failed to enable 4-bit ASYNC IRQ mode %d \n",ret));
sdio_release_host(func);
return ret;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: 4-bit ASYNC IRQ mode enabled\n"));
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
/* give us some time to enable, in ms */
func->enable_timeout = 100;
#endif
ret = sdio_enable_func(func);
if (ret) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), Unable to enable AR6K: 0x%X\n",
__FUNCTION__, ret));
sdio_release_host(func);
return ret;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: set block size 0x%X\n", HIF_MBOX_BLOCK_SIZE));
ret = sdio_set_block_size(func, HIF_MBOX_BLOCK_SIZE);
sdio_release_host(func);
if (ret) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), Unable to set block size 0x%x AR6K: 0x%X\n",
__FUNCTION__, HIF_MBOX_BLOCK_SIZE, ret));
return ret;
}
/* Initialize the bus requests to be used later */
A_MEMZERO(device->busRequest, sizeof(device->busRequest));
for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
sema_init(&device->busRequest[count].sem_req, 0);
hifFreeBusRequest(device, &device->busRequest[count]);
}
/* create async I/O thread */
device->async_shutdown = 0;
device->async_task = kthread_create(async_task,
(void *)device,
"AR6K Async");
if (IS_ERR(device->async_task)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), to create async task\n", __FUNCTION__));
return A_ERROR;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: start async task\n"));
sema_init(&device->sem_async, 0);
wake_up_process(device->async_task );
/* create startup thread */
startup_task_struct = kthread_create(startup_task,
(void *)device,
"AR6K startup");
if (IS_ERR(startup_task_struct)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), to create startup task\n", __FUNCTION__));
return A_ERROR;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: start startup task\n"));
wake_up_process(startup_task_struct);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: return %d\n", ret));
return ret;
}
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;
}
static int hifDeviceInserted(struct sdio_func *func, const struct sdio_device_id *id)
{
int ret;
HIF_DEVICE * device;
int count;
struct task_struct* startup_task_struct;
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
("AR6000: hifDeviceInserted, Function: 0x%X, Vendor ID: 0x%X, Device ID: 0x%X, block size: 0x%X/0x%X\n",
func->num, func->vendor, func->device, func->max_blksize, func->cur_blksize));
addHifDevice(func);
device = getHifDevice(func);
spin_lock_init(&device->lock);
spin_lock_init(&device->asynclock);
/* enable the SDIO function */
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: claim\n"));
sdio_claim_host(func);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: enable\n"));
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
/* give us some time to enable, in ms */
func->enable_timeout = 100;
#endif
ret = sdio_enable_func(func);
if (ret) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), Unable to enable AR6K: 0x%X, timeout: %d\n",
__FUNCTION__, ret, func->enable_timeout));
#else
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), Unable to enable AR6K: 0x%X\n",
__FUNCTION__, ret));
#endif
sdio_release_host(func);
return ret;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: set block size 0x%X\n", HIF_MBOX_BLOCK_SIZE));
ret = sdio_set_block_size(func, HIF_MBOX_BLOCK_SIZE);
sdio_release_host(func);
if (ret) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), Unable to set block size 0x%x AR6K: 0x%X\n",
__FUNCTION__, HIF_MBOX_BLOCK_SIZE, ret));
return ret;
}
/* Initialize the bus requests to be used later */
A_MEMZERO(device->busRequest, sizeof(device->busRequest));
for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
sema_init(&device->busRequest[count].sem_req, 0);
hifFreeBusRequest(device, &device->busRequest[count]);
}
/* create async I/O thread */
device->async_shutdown = 0;
device->async_task = kthread_create(async_task,
(void *)device,
"AR6K Async");
if (IS_ERR(device->async_task)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), to create async task\n", __FUNCTION__));
return A_ERROR;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: start async task\n"));
sema_init(&device->sem_async, 0);
wake_up_process(device->async_task );
/* create startup thread */
startup_task_struct = kthread_create(startup_task,
(void *)device,
"AR6K startup");
if (IS_ERR(startup_task_struct)) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("AR6000: %s(), to create startup task\n", __FUNCTION__));
return A_ERROR;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: start startup task\n"));
wake_up_process(startup_task_struct);
AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: return %d\n", ret));
return ret;
}
