/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@function: Create a message queue
@function name: SDLIB_CreateMessageQueue
@prototype: PSDMESSAGE_QUEUE SDLIB_CreateMessageQueue(INT MaxMessages, INT MaxMessageLength)
@category: Support_Reference
@input: MaxMessages - Maximum number of messages this queue supports
@input: MaxMessageLength - Maximum size of each message
@return: Message queue object, NULL on failure
@notes: This function creates a simple first-in-first-out message queue. The caller must determine
the maximum number of messages the queue supports and the size of each message. This
function will pre-allocate memory for each message. A producer of data posts a message
using SDLIB_PostMessage with a user defined data structure. A consumer of this data
can retrieve the message (in FIFO order) using SDLIB_GetMessage. A message queue does not
provide a signaling mechanism for notifying a consumer of data. Notifying a consumer is
user defined.
@see also: SDLIB_DeleteMessageQueue, SDLIB_GetMessage, SDLIB_PostMessage.
@example: Creating a message queue:
typedef struct _MyMessage {
UINT8 Code;
PVOID pDataBuffer;
} MyMessage;
// create message queue, 16 messages max.
pMsgQueue = SDLIB_CreateMessageQueue(16,sizeof(MyMessage));
if (NULL == pMsgQueue) {
.. failed
}
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
PSDMESSAGE_QUEUE _CreateMessageQueue(INT MaxMessages, INT MaxMessageLength)
{
PSDMESSAGE_QUEUE pQueue = NULL;
SDIO_STATUS status = SDIO_STATUS_SUCCESS;
INT ii;
PSDMESSAGE_BLOCK pMsg;
do {
pQueue = (PSDMESSAGE_QUEUE)KernelAlloc(sizeof(SDMESSAGE_QUEUE));
if (NULL == pQueue) {
status = SDIO_STATUS_NO_RESOURCES;
break;
}
SDLIST_INIT(&pQueue->MessageList);
SDLIST_INIT(&pQueue->FreeMessageList);
pQueue->MaxMessageLength = MaxMessageLength;
status = CriticalSectionInit(&pQueue->MessageCritSection);
if (!SDIO_SUCCESS(status)) {
break;
}
/* allocate message blocks */
for (ii = 0; ii < MaxMessages; ii++) {
pMsg = (PSDMESSAGE_BLOCK)KernelAlloc(sizeof(SDMESSAGE_BLOCK) + MaxMessageLength -1);
if (NULL == pMsg) {
break;
}
FreeMessageBlock(pQueue, pMsg);
}
if (0 == ii) {
status = SDIO_STATUS_NO_RESOURCES;
break;
}
} while (FALSE);
if (!SDIO_SUCCESS(status)) {
if (pQueue != NULL) {
_DeleteMessageQueue(pQueue);
pQueue = NULL;
}
}
return pQueue;
}
Impl()
{
CriticalSectionInit(m_pLock);
}
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;
}
