--- /dev/null
+/*
+ * context.c
+ *
+ * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name Texas Instruments nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+/** \file context.c
+ * \brief The Context-Engine is an OS independent module, which provides the
+ * infrustracture for switching from external contexts to the driver's context.
+ * This includes also the driver task itself (workqueue in Linux), which invokes the
+ * driver specific handlers in the driver's context.
+ * The OS specific implementation under this module (e.g. task-switching or
+ * protection-locking) is provided by the OS abstraction layer (osapi.c).
+ *
+ * \see context.h, osapi.c
+ */
+
+
+#define __FILE_ID__ FILE_ID_125
+#include "osApi.h"
+#include "report.h"
+#include "context.h"
+#include "bmtrace_api.h"
+
+
+
+#define MAX_CLIENTS 8 /* Maximum number of clients using context services */
+#define MAX_NAME_SIZE 16 /* Maximum client's name string size */
+
+#ifdef TI_DBG
+typedef struct
+{
+ TI_UINT32 uSize; /* Clients' name string size */
+ char sName [MAX_NAME_SIZE]; /* Clients' name string */
+} TClientName;
+#endif /* TI_DBG */
+
+/* context module structure */
+typedef struct
+{
+ TI_HANDLE hOs;
+ TI_HANDLE hReport;
+
+ TI_BOOL bContextSwitchRequired; /* Indicate if the driver should switch to its */
+ /* own context or not before handling events */
+ TI_HANDLE hProtectionLock; /* Handle of protection lock used by context clients */
+ TI_UINT32 uNumClients; /* Number of registered clients */
+ TContextCbFunc aClientCbFunc [MAX_CLIENTS]; /* Clients' callback functions */
+ TI_HANDLE aClientCbHndl [MAX_CLIENTS]; /* Clients' callback handles */
+ TI_BOOL aClientEnabled[MAX_CLIENTS]; /* Clients' enable/disable flags */
+ TI_BOOL aClientPending[MAX_CLIENTS]; /* Clients' pending flags */
+
+#ifdef TI_DBG
+ TClientName aClientName [MAX_CLIENTS]; /* Clients' name string */
+ TI_UINT32 aRequestCount [MAX_CLIENTS]; /* Clients' schedule requests counter*/
+ TI_UINT32 aInvokeCount [MAX_CLIENTS]; /* Clients' invocations counter */
+#endif
+
+} TContext;
+
+
+/**
+ * \fn context_Create
+ * \brief Create the module
+ *
+ * Allocate and clear the module object.
+ *
+ * \note
+ * \param hOs - Handle to Os Abstraction Layer
+ * \return Handle of the allocated object
+ * \sa context_Destroy
+ */
+TI_HANDLE context_Create (TI_HANDLE hOs)
+{
+ TI_HANDLE hContext;
+
+ /* allocate module object */
+ hContext = os_memoryAlloc (hOs, sizeof(TContext));
+
+ if (!hContext)
+ {
+ WLAN_OS_REPORT (("context_Create(): Allocation failed!!\n"));
+ return NULL;
+ }
+
+ os_memoryZero (hOs, hContext, (sizeof(TContext)));
+
+ return (hContext);
+}
+
+
+/**
+ * \fn context_Destroy
+ * \brief Destroy the module.
+ *
+ * Free the module memory.
+ *
+ * \note
+ * \param hContext - The module object
+ * \return TI_OK on success or TI_NOK on failure
+ * \sa context_Create
+ */
+TI_STATUS context_Destroy (TI_HANDLE hContext)
+{
+ TContext *pContext = (TContext *)hContext;
+
+ /* Destroy the protection handle */
+ os_protectDestroy (pContext->hOs, pContext->hProtectionLock);
+
+ /* free module object */
+ os_memoryFree (pContext->hOs, pContext, sizeof(TContext));
+
+ return TI_OK;
+}
+
+
+/**
+ * \fn context_Init
+ * \brief Init required handles
+ *
+ * Init required handles.
+ *
+ * \note
+ * \param hContext - The queue object
+ * \param hOs - Handle to Os Abstraction Layer
+ * \param hReport - Handle to report module
+ * \return void
+ * \sa
+ */
+void context_Init (TI_HANDLE hContext, TI_HANDLE hOs, TI_HANDLE hReport)
+{
+ TContext *pContext = (TContext *)hContext;
+
+ pContext->hOs = hOs;
+ pContext->hReport = hReport;
+
+ /* Create the module's protection lock and save its handle */
+ pContext->hProtectionLock = os_protectCreate (pContext->hOs);
+}
+
+
+/**
+ * \fn context_SetDefaults
+ * \brief Configure module with default settings
+ *
+ * Set default setting which indicates if the driver should switch to
+ * its own context or not before handling events
+ *
+ * \note
+ * \param hContext - The module's object
+ * \param pContextInitParams - The module's init parameters
+ * \return TI_OK on success or TI_NOK on failure
+ * \sa
+ */
+TI_STATUS context_SetDefaults (TI_HANDLE hContext, TContextInitParams *pContextInitParams)
+{
+ TContext *pContext = (TContext *)hContext;
+
+ /* Set parameters */
+ pContext->bContextSwitchRequired = pContextInitParams->bContextSwitchRequired;
+
+ return TI_OK;
+}
+
+
+/**
+ * \fn context_RegisterClient
+ * \brief Save client's parameters
+ *
+ * This function is used by the Context clients in their init process, for registering
+ * their information,
+ * This includes their callback function that should be invoked from the driver context
+ * when they are pending.
+ *
+ * \note
+ * \param hContext - The module handle
+ * \param fCbFunc - The client's callback function.
+ * \param hCbHndl - The client's callback function handle.
+ * \param bEnable - TRUE = Enabled.
+ * \return TI_UINT32 - The index allocated for the client
+ * \sa
+ */
+TI_UINT32 context_RegisterClient (TI_HANDLE hContext,
+ TContextCbFunc fCbFunc,
+ TI_HANDLE hCbHndl,
+ TI_BOOL bEnable,
+ char *sName,
+ TI_UINT32 uNameSize)
+{
+ TContext *pContext = (TContext *)hContext;
+ TI_UINT32 uClientId = pContext->uNumClients;
+
+ /* If max number of clients is exceeded, report error and exit. */
+ if (uClientId == MAX_CLIENTS)
+ {
+ TRACE0(pContext->hReport, REPORT_SEVERITY_ERROR , "context_RegisterClient() MAX_CLIENTS limit exceeded!!\n");
+ return 0;
+ }
+
+ /* Save the new client's parameters. */
+ pContext->aClientCbFunc[uClientId] = fCbFunc;
+ pContext->aClientCbHndl[uClientId] = hCbHndl;
+ pContext->aClientEnabled[uClientId] = bEnable;
+ pContext->aClientPending[uClientId] = TI_FALSE;
+
+#ifdef TI_DBG
+ if (uNameSize <= MAX_NAME_SIZE)
+ {
+ os_memoryCopy(pContext->hOs,
+ (void *)(pContext->aClientName[uClientId].sName),
+ (void *)sName,
+ uNameSize);
+ pContext->aClientName[uClientId].uSize = uNameSize;
+ }
+ else
+ {
+ TRACE0(pContext->hReport, REPORT_SEVERITY_ERROR , "context_RegisterClient() MAX_NAME_SIZE limit exceeded!\n");
+ }
+#endif /* TI_DBG */
+
+ /* Increment clients number and return new client ID. */
+ pContext->uNumClients++;
+
+ TRACE2(pContext->hReport, REPORT_SEVERITY_INIT , "context_RegisterClient(): Client=, ID=%d, enabled=%d\n", uClientId, bEnable);
+
+ return uClientId;
+}
+
+
+/**
+ * \fn context_RequestSchedule
+ * \brief Handle client's switch to driver's context.
+ *
+ * This function is called by a client from external context event.
+ * It sets the client's Pending flag and requests the driver's task scheduling.
+ * Thus, the client's callback will be called afterwards from the driver context.
+ *
+ * \note
+ * \param hContext - The module handle
+ * \param uClientId - The client's index
+ * \return void
+ * \sa context_DriverTask
+ */
+void context_RequestSchedule (TI_HANDLE hContext, TI_UINT32 uClientId)
+{
+ TContext *pContext = (TContext *)hContext;
+
+#ifdef TI_DBG
+ pContext->aRequestCount[uClientId]++;
+ TRACE3(pContext->hReport, REPORT_SEVERITY_INFORMATION , "context_RequestSchedule(): Client=, ID=%d, enabled=%d, pending=%d\n", uClientId, pContext->aClientEnabled[uClientId], pContext->aClientPending[uClientId]);
+#endif /* TI_DBG */
+
+ /* Set client's Pending flag */
+ pContext->aClientPending[uClientId] = TI_TRUE;
+
+ /* Prevent system from going to sleep */
+ os_wake_lock(pContext->hOs);
+
+ /*
+ * If configured to switch context, request driver task scheduling.
+ * Else (context switch not required) call the driver task directly.
+ */
+ if (pContext->bContextSwitchRequired)
+ {
+ if (os_RequestSchedule(pContext->hOs) != TI_OK)
+ os_wake_unlock(pContext->hOs);
+ }
+ else
+ {
+ context_DriverTask(hContext);
+ os_wake_unlock(pContext->hOs);
+ }
+}
+
+
+/**
+ * \fn context_DriverTask
+ * \brief The driver task
+ *
+ * This function is the driver's main task that always runs in the driver's
+ * single context, scheduled through the OS (the driver's workqueue in Linux).
+ * Only one instantiation of this task may run at a time!
+ *
+ * \note
+ * \param hContext - The module handle
+ * \return void
+ * \sa context_RequestSchedule
+ */
+void context_DriverTask (TI_HANDLE hContext)
+{
+ TContext *pContext = (TContext *)hContext;
+ TContextCbFunc fCbFunc;
+ TI_HANDLE hCbHndl;
+ TI_UINT32 i;
+ CL_TRACE_START_L1();
+
+ TRACE0(pContext->hReport, REPORT_SEVERITY_INFORMATION , "context_DriverTask():\n");
+
+ /* For all registered clients do: */
+ for (i = 0; i < pContext->uNumClients; i++)
+ {
+ /* If client is pending and enabled */
+ if (pContext->aClientPending[i] && pContext->aClientEnabled[i])
+ {
+#ifdef TI_DBG
+ pContext->aInvokeCount[i]++;
+ TRACE1(pContext->hReport, REPORT_SEVERITY_INFORMATION , "Invoking - Client=, ID=%d\n", i);
+#endif /* TI_DBG */
+
+ /* Clear client's pending flag */
+ pContext->aClientPending[i] = TI_FALSE;
+
+ /* Call client's callback function */
+ fCbFunc = pContext->aClientCbFunc[i];
+ hCbHndl = pContext->aClientCbHndl[i];
+ fCbFunc(hCbHndl);
+ }
+ }
+
+ CL_TRACE_END_L1("tiwlan_drv.ko", "CONTEXT", "TASK", "");
+}
+
+
+/**
+ * \fn context_EnableClient / context_DisableClient
+ * \brief Enable a specific client activation
+ *
+ * Called by the driver main when needed to enble/disable a specific event handling.
+ * The Enable function also schedules the driver-task if the specified client is pending.
+ *
+ * \note
+ * \param hContext - The module handle
+ * \param uClientId - The client's index
+ * \return void
+ * \sa context_DriverTask
+ */
+void context_EnableClient (TI_HANDLE hContext, TI_UINT32 uClientId)
+{
+ TContext *pContext = (TContext *)hContext;
+
+#ifdef TI_DBG
+ if (pContext->aClientEnabled[uClientId])
+ {
+ TRACE0(pContext->hReport, REPORT_SEVERITY_ERROR , "context_EnableClient() Client already enabled!!\n");
+ return;
+ }
+ TRACE3(pContext->hReport, REPORT_SEVERITY_INFORMATION , "context_EnableClient(): Client=, ID=%d, enabled=%d, pending=%d\n", uClientId, pContext->aClientEnabled[uClientId], pContext->aClientPending[uClientId]);
+#endif /* TI_DBG */
+
+ /* Enable client */
+ pContext->aClientEnabled[uClientId] = TI_TRUE;
+
+ /* If client is pending, schedule driver task */
+ if (pContext->aClientPending[uClientId])
+ {
+ /* Prevent system from going to sleep */
+ os_wake_lock(pContext->hOs);
+
+ /*
+ * If configured to switch context, request driver task scheduling.
+ * Else (context switch not required) call the driver task directly.
+ */
+ if (pContext->bContextSwitchRequired)
+ {
+ if (os_RequestSchedule(pContext->hOs) != TI_OK)
+ os_wake_unlock(pContext->hOs);
+ }
+ else
+ {
+ context_DriverTask(hContext);
+ os_wake_unlock(pContext->hOs);
+ }
+ }
+}
+
+void context_DisableClient (TI_HANDLE hContext, TI_UINT32 uClientId)
+{
+ TContext *pContext = (TContext *)hContext;
+
+#ifdef TI_DBG
+ if (!pContext->aClientEnabled[uClientId])
+ {
+ TRACE0(pContext->hReport, REPORT_SEVERITY_ERROR , "context_DisableClient() Client already disabled!!\n");
+ return;
+ }
+ TRACE3(pContext->hReport, REPORT_SEVERITY_INFORMATION , "context_DisableClient(): Client=, ID=%d, enabled=%d, pending=%d\n", uClientId, pContext->aClientEnabled[uClientId], pContext->aClientPending[uClientId]);
+#endif /* TI_DBG */
+
+ /* Disable client */
+ pContext->aClientEnabled[uClientId] = TI_FALSE;
+}
+
+
+/**
+ * \fn context_EnterCriticalSection / context_LeaveCriticalSection
+ * \brief Lock / Unlock context related critical sections
+ *
+ * The context clients should use these functions for protecting their critical sections
+ * when handling context transition to driver context.
+ *
+ * \note
+ * \param hContext - The module handle
+ * \return void
+ * \sa
+ */
+void context_EnterCriticalSection (TI_HANDLE hContext)
+{
+ TContext *pContext = (TContext *)hContext;
+
+ TRACE0(pContext->hReport, REPORT_SEVERITY_INFORMATION , "context_EnterCriticalSection():\n");
+
+ /* Start critical section protection */
+ os_protectLock (pContext->hOs, pContext->hProtectionLock);
+}
+
+void context_LeaveCriticalSection (TI_HANDLE hContext)
+{
+ TContext *pContext = (TContext *)hContext;
+
+ TRACE0(pContext->hReport, REPORT_SEVERITY_INFORMATION , "context_LeaveCriticalSection():\n");
+
+ /* Stop critical section protection */
+ os_protectUnlock (pContext->hOs, pContext->hProtectionLock);
+}
+
+
+/**
+ * \fn context_Print
+ * \brief Print module information
+ *
+ * Print the module's clients parameters.
+ *
+ * \note
+ * \param hContext - The queue object
+ * \return void
+ * \sa
+ */
+
+#ifdef TI_DBG
+
+void context_Print(TI_HANDLE hContext)
+{
+#ifdef REPORT_LOG
+ TContext *pContext = (TContext *)hContext;
+ TI_UINT32 i;
+
+ WLAN_OS_REPORT(("context_Print(): %d Clients Registered:\n", pContext->uNumClients));
+ WLAN_OS_REPORT(("=======================================\n"));
+ WLAN_OS_REPORT(("bContextSwitchRequired = %d\n", pContext->bContextSwitchRequired));
+
+ for (i = 0; i < pContext->uNumClients; i++)
+ {
+ WLAN_OS_REPORT(("Client %d - %s: CbFunc=0x%x, CbHndl=0x%x, Enabled=%d, Pending=%d, Requests=%d, Invoked=%d\n",
+ i,
+ pContext->aClientName[i].sName,
+ pContext->aClientCbFunc[i],
+ pContext->aClientCbHndl[i],
+ pContext->aClientEnabled[i],
+ pContext->aClientPending[i],
+ pContext->aRequestCount[i],
+ pContext->aInvokeCount[i] ));
+ }
+#endif
+}
+
+#endif /* TI_DBG */
OSDN Git Service
