int wlanDrvWext_Handler (struct net_device *dev,
struct iw_request_info *info,
void *iw_req,
void *extra)
{
int rc;
TWlanDrvIfObj *drv = (TWlanDrvIfObj *)NETDEV_GET_PRIVATE(dev);
ti_private_cmd_t my_command;
struct iw_mlme mlme;
struct iw_scan_req scanreq;
void *copy_to_buf=NULL, *param3=NULL;
os_memoryZero(drv, &my_command, sizeof(ti_private_cmd_t));
os_memoryZero(drv, &mlme, sizeof(struct iw_mlme));
os_memoryZero(drv, &scanreq, sizeof(struct iw_scan_req));
switch (info->cmd)
{
case SIOCIWFIRSTPRIV:
{
void *copy_from_buf;
if (os_memoryCopyFromUser(drv, &my_command, ((union iwreq_data *)iw_req)->data.pointer, sizeof(ti_private_cmd_t)))
{
os_printf ("wlanDrvWext_Handler() os_memoryCopyFromUser FAILED !!!\n");
return TI_NOK;
}
if (IS_PARAM_FOR_MODULE(my_command.cmd, DRIVER_MODULE_PARAM))
{
/* If it's a driver level command, handle it here and exit */
switch (my_command.cmd)
{
case DRIVER_INIT_PARAM:
return wlanDrvIf_LoadFiles (drv, my_command.in_buffer);
case DRIVER_START_PARAM:
return wlanDrvIf_Open (dev);
case DRIVER_STOP_PARAM:
return wlanDrvIf_Stop (dev);
case DRIVER_STATUS_PARAM:
*(TI_UINT32 *)my_command.out_buffer =
(drv->tCommon.eDriverState == DRV_STATE_RUNNING) ? TI_TRUE : TI_FALSE;
return TI_OK;
}
}
/* if we are still here handle a normal private command*/
if ((my_command.in_buffer) && (my_command.in_buffer_len))
{
copy_from_buf = my_command.in_buffer;
my_command.in_buffer = os_memoryAlloc(drv, my_command.in_buffer_len);
if (os_memoryCopyFromUser(drv, my_command.in_buffer, copy_from_buf, my_command.in_buffer_len))
{
os_printf ("wlanDrvWext_Handler() os_memoryCopyFromUser 1 FAILED !!!\n");
return TI_NOK;
}
}
if ((my_command.out_buffer) && (my_command.out_buffer_len))
{
copy_to_buf = my_command.out_buffer;
my_command.out_buffer = os_memoryAlloc(drv, my_command.out_buffer_len);
}
param3 = &my_command;
}
break;
case SIOCSIWMLME:
{
os_memoryCopyFromUser(drv, &mlme, ((union iwreq_data *)iw_req)->data.pointer, sizeof(struct iw_mlme));
param3 = &mlme;
}
break;
case SIOCSIWSCAN:
{
if (((union iwreq_data *)iw_req)->data.pointer)
{
os_memoryCopyFromUser(drv, &scanreq, ((union iwreq_data *)iw_req)->data.pointer, sizeof(struct iw_scan_req));
param3 = &scanreq;
}
}
break;
case SIOCSIWGENIE:
{
TI_UINT16 ie_length = ((union iwreq_data *)iw_req)->data.length;
TI_UINT8 *ie_content = ((union iwreq_data *)iw_req)->data.pointer;
if ((ie_length == 0) && (ie_content == NULL)) {
/* Do nothing, deleting the IE */
} else if ((ie_content != NULL) && (ie_length <= RSN_MAX_GENERIC_IE_LENGTH) && (ie_length > 0)) {
/* One IE cannot be larger than RSN_MAX_GENERIC_IE_LENGTH bytes */
my_command.in_buffer = os_memoryAlloc(drv, ie_length);
os_memoryCopyFromUser(drv, my_command.in_buffer, ie_content, ie_length );
param3 = my_command.in_buffer;
} else {
return TI_NOK;
}
}
break;
}
/* If the friver is not running, return NOK */
if (drv->tCommon.eDriverState != DRV_STATE_RUNNING)
{
return TI_NOK;
}
/* Call the Cmd module with the given user paramters */
rc = (cmdHndlr_InsertCommand (drv->tCommon.hCmdHndlr,
info->cmd,
info->flags,
iw_req,
0,
extra,
0,
param3,
NULL));
/* Here we are after the command was completed */
if (my_command.in_buffer)
{
os_memoryFree (drv, my_command.in_buffer, my_command.in_buffer_len);
}
if (my_command.out_buffer)
{
if (os_memoryCopyToUser(drv, copy_to_buf, my_command.out_buffer, my_command.out_buffer_len))
{
os_printf ("wlanDrvWext_Handler() os_memoryCopyToUser FAILED !!!\n");
rc = TI_NOK;
}
os_memoryFree (drv, my_command.out_buffer, my_command.out_buffer_len);
}
return rc;
}
/**
* \fn wlanDrvIf_Destroy
* \brief Destroy the driver instance
*
* Destroy all driver modules.
* Release driver OS resources (IRQ, workqueue, events socket)
* Release driver network interface.
* Free init files memory.
* Free driver object.
*
* \note
* \param drv - The driver object handle
* \return void
* \sa wlanDrvIf_Create
*/
static void wlanDrvIf_Destroy (TWlanDrvIfObj *drv)
{
/* Release the driver network interface */
if (drv->netdev)
{
netif_stop_queue (drv->netdev);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
wlanDrvIf_Stop (drv->netdev);
#endif
unregister_netdev (drv->netdev);
free_netdev(drv->netdev);
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21))
cancel_work_sync (&drv->tWork);
#else
cancel_delayed_work (&drv->tWork);
#endif
flush_workqueue (drv->pWorkQueue);
destroy_workqueue (drv->pWorkQueue);
/* Destroy all driver modules */
if (drv->tCommon.hDrvMain)
{
drvMain_Destroy (drv->tCommon.hDrvMain);
}
/* close the ipc_kernel socket*/
if (drv && drv->wl_sock)
{
sock_release (drv->wl_sock->sk_socket);
}
/* Release the driver interrupt (or polling timer) */
#ifdef PRIODIC_INTERRUPT
os_timerDestroy (drv, drv->hPollTimer);
#else
if (drv->irq)
{
free_irq (drv->irq, drv);
drv->irq=NULL;
hPlatform_freeInterrupt ();
}
#endif
/*
* Free init files memory
*/
if (drv->tCommon.tFwImage.pImage)
{
os_memoryFree (drv, drv->tCommon.tFwImage.pImage, drv->tCommon.tFwImage.uSize);
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kfree(0x%p) : %d\n",
__FUNCTION__, __LINE__, drv->tCommon.tFwImage.uSize, -drv->tCommon.tFwImage.uSize);
#endif
}
if (drv->tCommon.tNvsImage.pImage)
{
kfree (drv->tCommon.tNvsImage.pImage);
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kfree(0x%p) : %d\n",
__FUNCTION__, __LINE__, drv->tCommon.tNvsImage.uSize, -drv->tCommon.tNvsImage.uSize);
#endif
}
if (drv->tCommon.tIniFile.pImage)
{
kfree (drv->tCommon.tIniFile.pImage);
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kfree(0x%p) : %d\n",
__FUNCTION__, __LINE__, drv->tCommon.tIniFile.uSize, -drv->tCommon.tIniFile.uSize);
#endif
}
/* Free the driver object */
#ifdef TI_DBG
tb_destroy();
#endif
kfree (drv);
}
static int wlanDrvIf_pm_suspend(void)
{
wlanDrvIf_Release(pDrvStaticHandle->netdev);
return(wlanDrvIf_Stop(pDrvStaticHandle->netdev));
}
/**
* \fn wlanDrvIf_Destroy
* \brief Destroy the driver instance
*
* Destroy all driver modules.
* Release driver OS resources (IRQ, workqueue, events socket)
* Release driver network interface.
* Free init files memory.
* Free driver object.
*
* \note
* \param drv - The driver object handle
* \return void
* \sa wlanDrvIf_Create
*/
static void wlanDrvIf_Destroy (TWlanDrvIfObj *drv)
{
if (!drv)
return;
if (drv->tiwlan_wq) {
cancel_work_sync(&drv->tWork);
flush_workqueue(drv->tiwlan_wq);
}
/* Release the driver network interface */
if (drv->netdev) {
netif_stop_queue (drv->netdev);
wlanDrvIf_Stop (drv->netdev);
unregister_netdev (drv->netdev);
free_netdev (drv->netdev);
}
/* Destroy all driver modules */
if (drv->tCommon.hDrvMain) {
drvMain_Destroy (drv->tCommon.hDrvMain);
}
/* close the ipc_kernel socket*/
if (drv && drv->wl_sock)
{
sock_release (drv->wl_sock->sk_socket);
}
/* Release the driver interrupt (or polling timer) */
#ifdef PRIODIC_INTERRUPT
os_timerDestroy (drv, drv->hPollTimer);
#else
if (drv->irq)
{
hPlatform_freeInterrupt(drv);
}
#endif
if (drv->tiwlan_wq)
destroy_workqueue(drv->tiwlan_wq);
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_destroy(&drv->wl_wifi);
wake_lock_destroy(&drv->wl_rxwake);
#endif
/*
* Free init files memory
*/
if (drv->tCommon.tFwImage.pImage)
{
os_memoryFree (drv, drv->tCommon.tFwImage.pImage, drv->tCommon.tFwImage.uSize);
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kfree(0x%p) : %d\n",
__FUNCTION__, __LINE__, drv->tCommon.tFwImage.uSize, -drv->tCommon.tFwImage.uSize);
#endif
}
if (drv->tCommon.tNvsImage.pImage)
{
kfree (drv->tCommon.tNvsImage.pImage);
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kfree(0x%p) : %d\n",
__FUNCTION__, __LINE__, drv->tCommon.tNvsImage.uSize, -drv->tCommon.tNvsImage.uSize);
#endif
}
if (drv->tCommon.tIniFile.pImage)
{
kfree (drv->tCommon.tIniFile.pImage);
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kfree(0x%p) : %d\n",
__FUNCTION__, __LINE__, drv->tCommon.tIniFile.uSize, -drv->tCommon.tIniFile.uSize);
#endif
}
/* Free the driver object */
#ifdef TI_DBG
tb_destroy();
#endif
kfree (drv);
}
