C++ (Cpp) tiwlan_ext_int_init Exemples

Exemple #1

int hPlatform_initInterrupt(void *tnet_drv, void* handle_add ) 
{
	TWlanDrvIfObj *drv = tnet_drv;
    int rc=0;

	//if (drv->irq == 0 || handle_add == NULL)
	if (handle_add == NULL)
	{
	  print_err("hPlatform_initInterrupt() bad param drv->irq=%d handle_add=0x%x !!!\n",drv->irq,(int)handle_add);
	  return -EINVAL;
	}


          drv->irq = tiwlan_ext_int_init();
	  g_drv  = drv;

      // set_irq_type(drv->irq  , IRQ_TYPE_EDGE_FALLING);


/*
               rc = gpio_request(IRQ_GPIO , "wl1271_wlan_irq");
                if (rc < 0) {
                       printk("%s: failed to request GPIO %d,"
                                " error %d\n",__func__ , IRQ_GPIO , rc);
                }

                oc = gpio_direction_input(IRQ_GPIO);

                if (rc < 0) {
                        pr_err("%s: failed to configure input"
                                " direction for GPIO %d, error %d\n",
                                __func__, IRQ_GPIO , rc);
                        gpio_free(IRQ_GPIO);
                }

                drv->irq = gpio_to_irq(IRQ_GPIO);
                if (drv->irq  < 0) {
                        rc = drv->irq;
                        pr_err("%s: Unable to get irq number"
                                " for GPIO %d, error %d\n",
                                __func__,IRQ_GPIO , rc);
                        gpio_free(IRQ_GPIO);
                }
*/

#if 1
        if ((rc = request_irq(drv->irq, handle_add, IRQF_TRIGGER_FALLING, "WL1271_IRQ", drv)))
        {
            	print_err("TIWLAN: Failed to register interrupt handler\n");
                return rc;
        }
#endif



	return rc;

} /* hPlatform_initInterrupt() */

Exemple #2

/** 
 * \fn     wlanDrvIf_Create
 * \brief  Create the driver instance
 * 
 * Allocate driver object.
 * Initialize driver OS resources (IRQ, workqueue, events socket)
 * Setup driver network interface.
 * Create and link all driver modules.
 *
 * \note   
 * \param  void
 * \return 0 - OK, else - failure
 * \sa     wlanDrvIf_Destroy
 */ 
static int wlanDrvIf_Create (void)
{
    TWlanDrvIfObj *drv;
    int rc;

    /* Allocate driver's structure */
    drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL);
    if (!drv)
    {
        return -ENOMEM;
    }
#ifdef TI_DBG
    tb_init(TB_OPTION_NONE);
#endif
    pDrvStaticHandle = drv;  /* save for module destroy */
    #ifdef TI_MEM_ALLOC_TRACE        
      os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj));
    #endif
    memset (drv, 0, sizeof(TWlanDrvIfObj));
/*
#if defined HOST_PLATFORM_OMAP3430 || defined HOST_PLATFORM_ZOOM2 || defined HOST_PLATFORM_ZOOM1

	if(g_external_board)
	{
		WLAN_OS_REPORT(("\nZoom2 use external board"));
		drv->irq = (OMAP_GPIO_IRQ(IRQ_GPIO_EXT));
	}
	else
	{
		drv->irq = (OMAP_GPIO_IRQ(IRQ_GPIO));
	}
#endif   
*/
    drv->irq = tiwlan_ext_int_init(); 

    drv->tCommon.eDriverState = DRV_STATE_IDLE;
#ifdef AP_MODE_ENABLED
    /* for STA role, need to allocate another driver and to set STA role */
    drv->tCommon.eIfRole = IF_ROLE_TYPE_AP;
#endif

    drv->pWorkQueue = create_singlethread_workqueue (TIWLAN_DRV_NAME);
    if (!drv->pWorkQueue)
    {
        return -ENOMEM; 
    }

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
    INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv);
#else
    INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask);
#endif
    spin_lock_init (&drv->lock);

    /* Setup driver network interface. */
    rc = wlanDrvIf_SetupNetif (drv);
    if (rc)
    {
        kfree (drv);
        return rc;
    }
   

    /* Create the events socket interface */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
    drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE );
#else
        drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE );
#endif
    if (drv->wl_sock == NULL)
    {
        ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n");
        return -EINVAL;
    }

    /* Create all driver modules and link their handles */
    drvMain_Create (drv, 
                    &drv->tCommon.hDrvMain, 
                    &drv->tCommon.hCmdHndlr, 
                    &drv->tCommon.hContext, 
                    &drv->tCommon.hTxDataQ,
                    &drv->tCommon.hTxMgmtQ,
                    &drv->tCommon.hTxCtrl,
                    &drv->tCommon.hTWD,
                    &drv->tCommon.hEvHandler,
                    &drv->tCommon.hCmdDispatch,
                    &drv->tCommon.hReport);

    /* 
     *  Initialize interrupts (or polling mode for debug):
     */
#ifdef PRIODIC_INTERRUPT
    /* Debug mode: Polling (the timer is started by HwInit process) */
    drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv);
#else 
    /* Normal mode: Interrupts (the default mode) */
    rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt);
    if (rc)
    {
        ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n");
        return rc;
    }
#ifdef  HOST_PLATFORM_OMAP2430
    set_irq_type (drv->irq, IRQT_FALLING);
#endif
#endif  /* PRIODIC_INTERRUPT */

   return 0;
}