Пример #1
0
//*****************************************************************************
//
//! Returns the USB controller to and inactive state when in OTG mode
//! operation.
//!
//! \param ui32Index specifies the USB controller to end OTG mode operations.
//!
//! Applications using OTG mode may call this function to disable interrupts
//! in preparation for shutdown or a change of operating mode.
//!
//! \return None.
//
//*****************************************************************************
void
USBOTGModeTerm(uint32_t ui32Index)
{
    //
    // We only support a single USB controller.
    //
    ASSERT(ui32Index == 0);

    //
    // Disable the USB interrupt.
    //
    OS_INT_DISABLE(g_psDCDInst[0].ui32IntNum);

    //
    // Disable all control interrupts.
    //
    MAP_USBIntDisableControl(USB0_BASE, USB_INTCTRL_ALL);

    //
    // Disable all endpoint interrupts.
    //
    MAP_USBIntDisableEndpoint(USB0_BASE, USB_INTEP_ALL);

    //
    // Set the mode to none if it is not already.
    //
    USBOTGSetMode(eUSBModeNone);
}
Пример #2
0
//*****************************************************************************
//
// USBLibDMAChannelEnable() for USB controllers that use uDMA.
//
//*****************************************************************************
static void
uDMAUSBChannelEnable(tUSBDMAInstance *psUSBDMAInst, uint32_t ui32Channel)
{
    uint32_t ui32IntEnabled;

    //
    // Save if the interrupt was enabled or not.
    //
    ui32IntEnabled = IntIsEnabled(psUSBDMAInst->ui32IntNum);

    //
    // Disable the USB interrupt if it was enabled.
    //
    if(ui32IntEnabled)
    {
        OS_INT_DISABLE(psUSBDMAInst->ui32IntNum);
    }

    //
    // Mark this channel as pending and not complete.
    //
    psUSBDMAInst->ui32Pending |= (1 << (ui32Channel - 1));
    psUSBDMAInst->ui32Complete &= ~(1 << (ui32Channel - 1));

    //
    // Enable DMA for the endpoint.
    //
    if(UDMAConfigIsRx(psUSBDMAInst->pui32Config[ui32Channel - 1]))
    {
        MAP_USBEndpointDMAEnable(psUSBDMAInst->ui32Base,
                                 psUSBDMAInst->pui8Endpoint[ui32Channel - 1],
                                 USB_EP_DEV_OUT | USB_EP_HOST_IN);
    }
    else
    {
        MAP_USBEndpointDMAEnable(psUSBDMAInst->ui32Base,
                                 psUSBDMAInst->pui8Endpoint[ui32Channel - 1],
                                 USB_EP_DEV_IN | USB_EP_HOST_OUT);
    }

    //
    // Enable the DMA in the uDMA controller.
    //
    MAP_uDMAChannelEnable(ui32Channel - 1);

    //
    // Enable the USB interrupt if it was enabled before.
    //
    if(ui32IntEnabled)
    {
        OS_INT_ENABLE(psUSBDMAInst->ui32IntNum);
    }
}
Пример #3
0
//*****************************************************************************
//
//! Returns the USB controller to the default mode when in dual mode operation.
//!
//! \param ui32Index specifies the USB controller whose dual mode operation is
//! to be ended.  This parameter must be set to 0.
//!
//! Applications using both host and device modes may call this function to
//! disable interrupts in preparation for shutdown or a change of operating
//! mode.
//!
//! \return None.
//
//*****************************************************************************
void
USBDualModeTerm(uint32_t ui32Index)
{
    //
    // We only support a single USB controller.
    //
    ASSERT(ui32Index == 0);

    //
    // Disable the USB interrupt.
    //
    OS_INT_DISABLE(g_psDCDInst[0].ui32IntNum);

    MAP_USBIntDisableControl(USB0_BASE, USB_INTCTRL_ALL);

    MAP_USBIntDisableEndpoint(USB0_BASE, USB_INTEP_ALL);
}
Пример #4
0
//*****************************************************************************
//
// USBLibDMAChannelEnable() for USB controllers with an integrated DMA
// controller.
//
//*****************************************************************************
static void
iDMAUSBChannelEnable(tUSBDMAInstance *psUSBDMAInst, uint32_t ui32Channel)
{
    uint32_t ui32IntEnabled;

    //
    // Save if the interrupt was enabled or not.
    //
    ui32IntEnabled = IntIsEnabled(psUSBDMAInst->ui32IntNum);

    //
    // Disable the USB interrupt if it was enabled.
    //
    if(ui32IntEnabled)
    {
        OS_INT_DISABLE(psUSBDMAInst->ui32IntNum);
    }

    //
    // Mark this channel as pending and not complete.
    //
    psUSBDMAInst->ui32Pending |= (1 << (ui32Channel - 1));
    psUSBDMAInst->ui32Complete &= ~(1 << (ui32Channel - 1));

    //
    // Enable the interrupt for this DMA channel.
    //
    USBDMAChannelIntEnable(psUSBDMAInst->ui32Base, ui32Channel - 1);

    //
    // Enable the DMA channel.
    //
    USBDMAChannelEnable(psUSBDMAInst->ui32Base, ui32Channel - 1);

    //
    // Enable the USB interrupt if it was enabled before.
    //
    if(ui32IntEnabled)
    {
        OS_INT_ENABLE(psUSBDMAInst->ui32IntNum);
    }
}
Пример #5
0
/** 
 *  @brief handle TX Queue
 *  @param priv       pointer to wlan_private
 *  @return 	      N/A
*/
void
wlan_process_txqueue(wlan_private * priv)
{
    wlan_adapter *Adapter = priv->adapter;
    ulong flags;
    struct sk_buff *Q;
    OS_INTERRUPT_SAVE_AREA;
    ENTER();
    //spin_lock_irqsave(&Adapter->CurrentTxLock, flags);
    OS_INT_DISABLE(flags);
    if (Adapter->TxSkbNum > 0) {
        Q = &priv->adapter->TxSkbQ;
        Adapter->CurrentTxSkb = Q->next;
        list_del((struct list_head *) Adapter->CurrentTxSkb);
        Adapter->TxSkbNum--;
    }
    //spin_unlock_irqrestore(&Adapter->CurrentTxLock, flags);
    OS_INT_RESTORE(flags);
    if (Adapter->CurrentTxSkb) {
        wlan_process_tx(priv);
    }

    LEAVE();
}
/** 
 *  @brief This function handles the major job in WLAN driver.
 *  it handles the event generated by firmware, rx data received
 *  from firmware and tx data sent from kernel.
 *  
 *  @param data    A pointer to wlan_thread structure
 *  @return        WLAN_STATUS_SUCCESS
 */
static int
wlan_service_main_thread(void *data)
{
    wlan_thread *thread = data;
    wlan_private *priv = thread->priv;
    wlan_adapter *Adapter = priv->adapter;
    wait_queue_t wait;
    u8 ireg = 0;
    unsigned long driver_flags;

    OS_INTERRUPT_SAVE_AREA;

    ENTER();

    wlan_activate_thread(thread);

    init_waitqueue_entry(&wait, current);

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
    current->flags |= PF_NOFREEZE;
#endif

    wlan_meas_init(priv);

    PRINTM(INFO, "11H: init 11H\n");
    wlan_11h_init(priv);

    wmm_init(priv);

    for (;;) {
#define MAX_MAIN_THREAD_LOOPS (10000)
        if (++Adapter->main_thread_loops > MAX_MAIN_THREAD_LOOPS) {
            panic("main-thread dead loop detected: %u\n"
                  "IntCnt=%d\n"
                  "Adapter->HisRegCpy=%#x\n"
                  "CurCmd=%p CmdPending=%s\n"
                  "Connect=%s\n"
                  "cmd_sent=%s\n"
                  "data_sent=%s\n"
                  "IsDeepSleep=%d\n"
                  "PSMode=%d PSState=%d\n"
                  "WakeupDevReq=%d\n"
                  "HS_Activated=%d\n"
                  "WakeupTries=%d\n", Adapter->main_thread_loops,
                  Adapter->IntCounter,
                  Adapter->HisRegCpy,
                  Adapter->CurCmd,
                  list_empty(&Adapter->CmdPendingQ) ? "N" : "Y",
                  (Adapter->MediaConnectStatus ==
                   WlanMediaStateConnected) ? "Y" : "N",
                  (priv->wlan_dev.cmd_sent) ? "TRUE" : "FALSE",
                  (priv->wlan_dev.data_sent) ? "TRUE" : "FALSE",
                  Adapter->IsDeepSleep, Adapter->PSMode, Adapter->PSState,
                  Adapter->bWakeupDevRequired, Adapter->HS_Activated,
                  Adapter->WakeupTries);
        }

        add_wait_queue(&thread->waitQ, &wait);
        OS_SET_THREAD_STATE(TASK_INTERRUPTIBLE);

        TX_DISABLE;

        if ((Adapter->WakeupTries) ||
            (Adapter->PSState == PS_STATE_SLEEP
             && !Adapter->bWakeupDevRequired) ||
            (!Adapter->IntCounter &&
             Adapter->PSState == PS_STATE_PRE_SLEEP) ||
            (!Adapter->IntCounter
             && (priv->wlan_dev.data_sent || Adapter->TxLockFlag
                 || wmm_lists_empty(priv) || wmm_is_queue_stopped(priv))
             && (priv->wlan_dev.cmd_sent || Adapter->CurCmd ||
                 list_empty(&Adapter->CmdPendingQ))
            )
            ) {
            PRINTM(INFO, "main-thread sleeping... "
                   "HS_Act=%s WakeupReq=%s Conn=%s PS_Mode=%d PS_State=%d\n",
                   (Adapter->HS_Activated) ? "Y" : "N",
                   (Adapter->bWakeupDevRequired) ? "Y" : "N",
                   (Adapter->MediaConnectStatus) ? "Y" : "N",
                   Adapter->PSMode, Adapter->PSState);

            TX_RESTORE;
            Adapter->main_thread_loops = 0;
            schedule();
            PRINTM(INFO, "main-thread waking up: IntCnt=%d "
                   "CurCmd=%s CmdPending=%s\n"
                   "                       Connect=%s "
                   "cmd_sent=%s data_sent=%s\n",
                   Adapter->IntCounter,
                   (Adapter->CurCmd) ? "Y" : "N",
                   list_empty(&Adapter->CmdPendingQ) ? "N" : "Y",
                   (Adapter->MediaConnectStatus) ? "Y" : "N",
                   (priv->wlan_dev.cmd_sent) ? "TRUE" : "FALSE",
                   (priv->wlan_dev.data_sent) ? "TRUE" : "FALSE");
        } else {
            TX_RESTORE;
        }

        OS_SET_THREAD_STATE(TASK_RUNNING);
        remove_wait_queue(&thread->waitQ, &wait);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
        if ((thread->state == WLAN_THREAD_STOPPED) || Adapter->SurpriseRemoved)
#else
        if (kthread_should_stop() || Adapter->SurpriseRemoved)
#endif
        {
            PRINTM(INFO, "main-thread: break from main thread: "
                   "SurpriseRemoved=0x%x\n", Adapter->SurpriseRemoved);
            break;
        }

        if (Adapter->IntCounter) {
            OS_INT_DISABLE(priv, driver_flags);
            Adapter->IntCounter = 0;
            OS_INT_RESTORE(priv, driver_flags);

            if (sbi_get_int_status(priv, &ireg)) {
                PRINTM(ERROR,
                       "main-thread: reading HOST_INT_STATUS_REG failed\n");
                continue;
            }

            /* If we have a valid interrupt then we have something to do, so
               we are not running in a dead loop */
            if (ireg)
                Adapter->main_thread_loops = 0;

            OS_INT_DISABLE(priv, driver_flags);
            Adapter->HisRegCpy |= ireg;
            OS_INT_RESTORE(priv, driver_flags);
            PRINTM(INTR, "INT: status = 0x%x\n", Adapter->HisRegCpy);
        } else if (Adapter->bWakeupDevRequired) {
            Adapter->WakeupTries++;
            PRINTM(CMND,
                   "Wakeup device... WakeupReq=%s Conn=%s PS_Mode=%d PS_State=%d @ %lu\n",
                   (Adapter->bWakeupDevRequired) ? "Y" : "N",
                   (priv->adapter->MediaConnectStatus) ? "Y" : "N",
                   priv->adapter->PSMode, priv->adapter->PSState,
                   os_time_get());

            /* Wake up device */
            if (sbi_exit_deep_sleep(priv))
                PRINTM(MSG, "main-thread: wakeup device failed\n");
            continue;
        }

        /* Command response? */
        if (Adapter->HisRegCpy & HIS_CmdUpLdRdy) {
            OS_INT_DISABLE(priv, driver_flags);
            Adapter->HisRegCpy &= ~HIS_CmdUpLdRdy;
            OS_INT_RESTORE(priv, driver_flags);

            wlan_process_cmdresp(priv);
        }

        /* Any Card Event */
        if (Adapter->HisRegCpy & HIS_CardEvent) {
            OS_INT_DISABLE(priv, driver_flags);
            Adapter->HisRegCpy &= ~HIS_CardEvent;
            OS_INT_RESTORE(priv, driver_flags);

            wlan_process_event(priv);
        }

        /* Check if we need to confirm Sleep Request received previously */
        if (Adapter->PSState == PS_STATE_PRE_SLEEP) {
            if (!priv->wlan_dev.cmd_sent && !Adapter->CurCmd) {
                ASSERT(Adapter->MediaConnectStatus == WlanMediaStateConnected);
                wlan_ps_cond_check(priv, (u16) Adapter->PSMode);
            }
        }

        /* The PS state is changed during processing of Sleep Request event
           above */
        if ((Adapter->PSState == PS_STATE_SLEEP)
            || (Adapter->PSState == PS_STATE_PRE_SLEEP))
            continue;

        if (Adapter->IsDeepSleep)
            continue;

        /* The HS_Activated flag is changed during processing of HS_Activate
           command resp */
        /* We cannot send command or data if HS_Activated and
           WakeupDevRequired are TRUE */
        if (Adapter->HS_Activated && Adapter->bWakeupDevRequired) {
            PRINTM(INFO, "main-thread: cannot send command or data, "
                   "HS_Activated=%d\n", Adapter->HS_Activated);
            continue;
        }

        /* Execute the next command */
        if (!priv->wlan_dev.cmd_sent && !Adapter->CurCmd)
            wlan_exec_next_cmd(priv);

        if (!priv->wlan_dev.data_sent
            && !wmm_lists_empty(priv) && !wmm_is_queue_stopped(priv)) {
            if ((Adapter->PSState == PS_STATE_FULL_POWER)
                || (Adapter->sleep_period.period == 0)
                || (Adapter->TxLockFlag == FALSE))
                wmm_process_tx(priv);

        }

    }

    wlan_deactivate_thread(thread);

    LEAVE();
    return WLAN_STATUS_SUCCESS;
}
Пример #7
0
//*****************************************************************************
//
// This function is called periodically by USBHCDMain().  We use it to handle
// the hub port state machine.
//
//*****************************************************************************
void
USBHHubMain(void)
{
    uint16_t ui16Status, ui16Changed;
    uint_fast8_t ui8Port;
    bool bRetcode;

    //
    // If the hub is not present, just return.
    //
    if((g_sRootHub.ui32Flags & USBLIB_HUB_ACTIVE) == 0)
    {
        return;
    }

    //
    // Initialize the status variables.
    //
    ui16Status = 0;
    ui16Changed = 0;

    //
    // The hub is active and something changed. Check to see which port changed
    // state and handle as necessary.
    //
    for(ui8Port = 0; ui8Port <= g_sRootHub.ui8NumPortsInUse; ui8Port++)
    {
        //
        // Decrement any wait counter if there is one present.
        //
        if(g_sRootHub.psPorts[ui8Port].ui32Count != 0)
        {
            g_sRootHub.psPorts[ui8Port].ui32Count--;
        }

        //
        // Is this port waiting to be enumerated and is the last device
        // enumeration finished?
        //
        if((g_sRootHub.psPorts[ui8Port].iState == ePortConnected) &&
           (!g_sRootHub.bEnumerationBusy) &&
           (g_sRootHub.psPorts[ui8Port].ui32Count == 0))
        {
            //
            // Yes - start the enumeration processing for this device.
            //
            HubDriverDeviceReset(ui8Port);
        }

        //
        // If the state is ePortResetWait then the hub is waiting before
        // accessing device as the USB 2.0 specification requires.
        //
        if((g_sRootHub.psPorts[ui8Port].iState == ePortResetWait) &&
           (g_sRootHub.psPorts[ui8Port].ui32Count == 0))
        {
            //
            // Start the enumeration process if the timeout has passed and
            // the hub is waiting to start enumerating the device.
            //
            g_sRootHub.psPorts[ui8Port].iState = ePortActive;

            //
            // Call the main host controller layer to have it enumerate the
            // newly connected device.
            //
            g_sRootHub.psPorts[ui8Port].ui32DevHandle =
                USBHCDHubDeviceConnected(0, 1, ui8Port,
                                        g_sRootHub.psPorts[ui8Port].ui32Speed);
        }

        //
        // If an enumeration is in progress and the loop is not on the port
        // being enumerated then skip the port.
        //
        if(g_sRootHub.bEnumerationBusy &&
           (g_sRootHub.ui8EnumIdx != ui8Port))
        {
            continue;
        }

        //
        // Did something change for this particular port?
        //
        if(g_ui32ChangeFlags & (1 << ui8Port))
        {
            //
            // Yes - query the port status.
            //
            bRetcode = HubGetPortStatus(&g_sRootHub, ui8Port, &ui16Status,
                                        &ui16Changed);

            //
            // Clear this change with the USB interrupt temporarily disabled to
            // ensure that we do not clear a flag that the interrupt routine
            // has just set.
            //
            OS_INT_DISABLE(g_sRootHub.ui32IntNum);
            g_ui32ChangeFlags &= ~(1 << ui8Port);
            OS_INT_ENABLE(g_sRootHub.ui32IntNum);

            //
            // If there was an error, go on and look at the next bit.
            //
            if(!bRetcode)
            {
                continue;
            }

            //
            // Now consider what changed and handle it as necessary.
            //

            //
            // Was a device connected to or disconnected from the port?
            //
            if(ui16Changed & HUB_PORT_CHANGE_DEVICE_PRESENT)
            {
                DEBUG_OUTPUT("Connection change on port %d\n", ui8Port);

                //
                // Clear the condition.
                //
                HubClearPortFeature(&g_sRootHub, ui8Port,
                                    HUB_FEATURE_C_PORT_CONNECTION);

                //
                // Was a device connected or disconnected?
                //
                if(ui16Status & HUB_PORT_STATUS_DEVICE_PRESENT)
                {
                    DEBUG_OUTPUT("Connected\n");

                    //
                    // A device was connected.
                    //
                    HubDriverDeviceConnect(ui8Port);
                }
                else
                {
                    DEBUG_OUTPUT("Disconnected\n");

                    //
                    // A device was disconnected.
                    //
                    HubDriverDeviceDisconnect(ui8Port);
                }
            }

            //
            // Did a reset on the port complete?
            //
            if(ui16Changed & HUB_PORT_CHANGE_RESET)
            {
                //
                // Clear the condition.
                //
                HubClearPortFeature(&g_sRootHub, ui8Port,
                                    HUB_FEATURE_C_PORT_RESET);

                //
                // Yes - query the port status.
                //
                bRetcode = HubGetPortStatus(&g_sRootHub, ui8Port,
                                            &ui16Status, &ui16Changed);

                DEBUG_OUTPUT("Reset %s for port %d\n",
                        ((ui16Status & HUB_PORT_STATUS_RESET) ? "asserted" :
                        "deasserted"), ui8Port);

                //
                // Handle the reset case.
                //
                HubDriverReset(ui8Port, (ui16Status & HUB_PORT_STATUS_RESET) ?
                               true : false);

                //
                // A device was connected.
                //
                if(ui16Status & HUB_PORT_STATUS_LOW_SPEED)
                {
                    USBHubPortSpeedSet(ui8Port, USB_EP_SPEED_LOW);
                }
                else if(ui16Status & HUB_PORT_STATUS_HIGH_SPEED)
                {
                    USBHubPortSpeedSet(ui8Port, USB_EP_SPEED_HIGH);
                }
                else
                {
                    USBHubPortSpeedSet(ui8Port, USB_EP_SPEED_FULL);
                }
            }

            //
            // Did an over-current reset on the port complete?
            //
            if(ui16Changed & HUB_PORT_CHANGE_OVER_CURRENT)
            {
                DEBUG_OUTPUT("Port %d over current.\n", ui8Port);

                //
                // Currently we ignore this and just clear the condition.
                //
                HubClearPortFeature(&g_sRootHub, ui8Port,
                                    HUB_FEATURE_C_PORT_OVER_CURRENT);
            }

            //
            // Has the port been enabled or disabled?
            //
            if(ui16Changed & HUB_PORT_CHANGE_ENABLED)
            {
                DEBUG_OUTPUT("Enable change for port %d.\n", ui8Port);

                //
                // Currently we ignore this and just clear the condition.
                //
                HubClearPortFeature(&g_sRootHub, ui8Port,
                                    HUB_FEATURE_C_PORT_ENABLE);
            }

            //
            // Has the port been suspended or resumed?
            //
            if(ui16Changed & HUB_PORT_CHANGE_SUSPENDED)
            {
                DEBUG_OUTPUT("Suspend change for port %d.\n", ui8Port);

                //
                // Currently we ignore this and just clear the condition.
                //
                HubClearPortFeature(&g_sRootHub, ui8Port,
                                    HUB_FEATURE_C_PORT_SUSPEND);
            }
        }
    }
}
Пример #8
0
/** 
 *  @brief This function hanldes the major job in WLAN driver.
 *  it handles the event generated by firmware, rx data received
 *  from firmware and tx data sent from kernel.
 *  
 *  @param data    A pointer to wlan_thread structure
 *  @return 	   WLAN_STATUS_SUCCESS
 */
static void wlan_service_main_thread(cyg_addrword_t data)
{
	struct eth_drv_sc *sc = (struct eth_drv_sc *)data;
	wlan_private *priv = (wlan_private *)sc->driver_private;
	w99702_priv_t * priv702 = priv->priv;
    wlan_thread *thread = &priv->MainThread;
    wlan_adapter *Adapter = priv->adapter;
    //wait_queue_t wait;
    cyg_uint8 ireg = 0;
    int volatile save_irq;
    int x;
    int ret;

    //OS_INTERRUPT_SAVE_AREA;

    ENTER();

    wlan_activate_thread(thread);
    thread_stop_ptr[0] = NULL;

    //init_waitqueue_entry(&wait, current);

    for (;;) {
    
    
        #if 0
        diag_printf("main-thread 111: IntCounter=%d "
               "CurCmd=%p CmdPending=%s Connect=%d "
               "dnld_sent=%d\n",
               Adapter->IntCounter,
               Adapter->CurCmd,
               list_empty(&Adapter->CmdPendingQ) ? "N" : "Y",
               Adapter->MediaConnectStatus,
               /*Adapter->CurrentTxSkb,*/ priv->wlan_dev.dnld_sent);
		#endif
        //add_wait_queue(&thread->waitQ, &wait);
        //OS_SET_THREAD_STATE(TASK_INTERRUPTIBLE);

        TX_DISABLE;
				
        if ((Adapter->WakeupTries) ||
            (Adapter->PSState == PS_STATE_SLEEP
             && !Adapter->bWakeupDevRequired) ||
            (!Adapter->IntCounter
             && (priv->wlan_dev.dnld_sent || !Adapter->wmm.enabled ||
                 Adapter->TxLockFlag /*|| !os_queue_is_active(priv)*/ ||
                 wmm_lists_empty(priv))
             && (priv->wlan_dev.dnld_sent || Adapter->TxLockFlag ||
                 !Adapter->TxSkbNum)
             && (priv->wlan_dev.dnld_sent || Adapter->CurCmd ||
                 list_empty(&Adapter->CmdPendingQ))
            )
            ) {
            #if 0
            diag_printf(
                   "main-thread sleeping... Conn=%d IntC=%d PS_Mode=%d PS_State=%d\n",
                   Adapter->MediaConnectStatus, Adapter->IntCounter,
                   Adapter->PSMode, Adapter->PSState);
			#endif


#ifdef _MAINSTONE
            MST_LEDDAT1 = get_utimeofday();
#endif
            TX_RESTORE;
            //schedule();
            /* Lock control thread to avoid re-entry when waiting event. ??? */
			//cyg_mutex_lock(&thread->waitQ_mutex);
			
			//diag_printf("main_thread wait\n");
			/* Waitint until any event input */
			x = cyg_flag_wait(
            &thread->waitQ_flag_q,
            -1,
            CYG_FLAG_WAITMODE_OR | CYG_FLAG_WAITMODE_CLR );
            
            //diag_printf("main_thread wakeup %d\n", Adapter->IntCounter);
/* ----------if keypad pressed then print message-----------------  */    
    	//if ( 2 & x )

		
        } else {
            TX_RESTORE;
        }
		
		#if 0
        diag_printf(
               "main-thread 222 (waking up): IntCounter=%d  "
               "dnld_sent=%d\n", Adapter->IntCounter, /*Adapter->CurrentTxSkb,*/
               priv->wlan_dev.dnld_sent);
		
        //OS_SET_THREAD_STATE(TASK_RUNNING);
        //remove_wait_queue(&thread->waitQ, &wait);
		
        diag_printf("main-thread 333: IntCounter=%d "//CurrentTxSkb=%p
               "dnld_sent=%d g_NeedWakeupMainThread = %d\n",
               Adapter->IntCounter,
               /*Adapter->CurrentTxSkb,*/ priv->wlan_dev.dnld_sent, g_WakeupMainThreadStatus);
		#endif
		
        if (thread_should_stop()
            || Adapter->SurpriseRemoved) {
            diag_printf(
                   "main-thread: break from main thread: SurpriseRemoved=0x%x\n",
                   Adapter->SurpriseRemoved);
            break;
        }
		
		//OS_INT_DISABLE(save_irq);
        if(Adapter->IntCounter)
        {
            Adapter->IntCounter = 0;
            
            if ((ret = sbi_get_int_status(sc, &ireg)) < 0) {
                diag_printf("main-thread: reading HOST_INT_STATUS_REG failed\n");
                
                //OS_INT_RESTORE(save_irq);
                continue;
            }
            
            OS_INT_DISABLE(save_irq);
            Adapter->HisRegCpy |= ireg;
            OS_INT_RESTORE(save_irq);
        }
        //else if (Adapter->bWakeupDevRequired && ((Adapter->PSState == PS_STATE_SLEEP)))
		else if (Adapter->bWakeupDevRequired && Adapter->HS_Activated)  //JONO
        {
        	//OS_INT_RESTORE(save_irq);
            Adapter->WakeupTries++;
            /* we borrow deep_sleep wakeup code for time being */
            if (sbi_exit_deep_sleep(priv))
                diag_printf("main-thread: wakeup dev failed\n");
            continue;
        }
        //else OS_INT_RESTORE(save_irq);
		
		#if 0
        diag_printf("main-thread 444: IntCounter=%d "// CurrentTxSkb=%p
               "dnld_sent=%d TxSkbNum=%d\n",
               Adapter->IntCounter,
               /*Adapter->CurrentTxSkb,*/ priv->wlan_dev.dnld_sent, Adapter->TxSkbNum);
		 diag_printf("Adapter->HisRegCpy = %x, %d, %d, %d\n",	
		 	Adapter->HisRegCpy, priv->wlan_dev.dnld_sent, Adapter->TxLockFlag, priv->open);
		#endif
        /* Command response? */

        if (Adapter->HisRegCpy & HIS_CmdUpLdRdy) {
            //diag_printf("main-thread: Cmd response ready.\n");

            OS_INT_DISABLE(save_irq);
            Adapter->HisRegCpy &= ~HIS_CmdUpLdRdy;
            OS_INT_RESTORE(save_irq);

            wlan_process_rx_command(priv);
        }
       

        /* Any received data? */
#if 1
        if (Adapter->HisRegCpy & HIS_RxUpLdRdy) {
            //diag_printf("main-thread: Rx Packet ready.\n");

            OS_INT_DISABLE(save_irq);
            Adapter->HisRegCpy &= ~HIS_RxUpLdRdy;
            OS_INT_RESTORE(save_irq);

            //wlan_send_rxskbQ(priv);
            if((priv702->rx_head != priv702->rx_tail) || !priv702->rx_head->mode)
            	eth_drv_dsr(0, 0, (cyg_addrword_t)sc);
        }
        else
        	OS_INT_RESTORE(save_irq);
#endif
        /* Any Card Event */
        if (Adapter->HisRegCpy & HIS_CardEvent) {
            //diag_printf("main-thread: Card Event Activity.\n");

            OS_INT_DISABLE(save_irq);
            Adapter->HisRegCpy &= ~HIS_CardEvent;
            OS_INT_RESTORE(save_irq);

            if (sbi_read_event_cause(priv)) {
                diag_printf("main-thread: sbi_read_event_cause failed.\n");
                continue;
            }
            wlan_process_event(priv);
        }

        /* Check if we need to confirm Sleep Request received previously */
        if (Adapter->PSState == PS_STATE_PRE_SLEEP) {
            if (!priv->wlan_dev.dnld_sent && !Adapter->CurCmd) {
                if (Adapter->MediaConnectStatus == WlanMediaStateConnected) {
                    diag_printf(
                           "main_thread: PRE_SLEEP--IntCounter=%d "// CurrentTxSkb=%p
                           "dnld_sent=%d CurCmd=%p, confirm now\n",
                           Adapter->IntCounter, /*Adapter->CurrentTxSkb,*/
                           priv->wlan_dev.dnld_sent, Adapter->CurCmd);

                    PSConfirmSleep(priv, (cyg_uint16) Adapter->PSMode);
                } else {
                    /* workaround for firmware sending deauth/linkloss event
                       immediately after sleep request, remove this after
                       firmware fixes it */
                    Adapter->PSState = PS_STATE_AWAKE;
                    diag_printf(
                           "main-thread: ignore PS_SleepConfirm in non-connected state\n");
                }
            }
        }

        /* The PS state is changed during processing of Sleep Request event above */
        if ((priv->adapter->PSState == PS_STATE_SLEEP)
            || (priv->adapter->PSState == PS_STATE_PRE_SLEEP)
            ) {
                    diag_printf("999 The PS state is changed during processing ... %d\n", priv->adapter->PSState);
             continue; //JONO
        }
        if (Adapter->HS_Activated && Adapter->bWakeupDevRequired) { //JONO
            diag_printf(
                   "main-thread: cannot send command or date, HS_Activated=%d\n",
                   Adapter->HS_Activated); //JONO
            continue;
        }

        /* Execute the next command */
        if (!priv->wlan_dev.dnld_sent && !Adapter->CurCmd) {
            ExecuteNextCommand(priv);
        }

        if (Adapter->wmm.enabled) {
            if (!wmm_lists_empty(priv) && (priv->open == TRUE)/* && os_queue_is_active(priv)*/) {
                if ((Adapter->PSState == PS_STATE_FULL_POWER) ||
                    (Adapter->sleep_period.period == 0)
                    || (Adapter->TxLockFlag == FALSE))
                    //wmm_process_tx(priv);
                    handle_send(sc);
            }
        } else {
            if (!priv->wlan_dev.dnld_sent && (Adapter->TxLockFlag == false)
            &&(priv->open == TRUE)
                /*&& !list_empty((struct list_head *) &priv->adapter->TxSkbQ)*/) {
                //wlan_process_txqueue(priv);
                //diag_printf("send01\n");
                handle_send(sc);
                //diag_printf("send02\n");
            }
        }
    }

    wlan_deactivate_thread(thread);

    LEAVE();
    return ;//WLAN_STATUS_SUCCESS;
}