void jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c) { struct super_block *sb=OFNI_BS_2SFFJ(c); CYG_ASSERTC(sb->s_gc_thread_handle); D1(printk("jffs2_stop_garbage_collect_thread\n")); /* Stop the thread and wait for it if necessary */ cyg_flag_setbits(&sb->s_gc_thread_flags,GC_THREAD_FLAG_STOP); D1(printk("jffs2_stop_garbage_collect_thread wait\n")); cyg_flag_wait(&sb->s_gc_thread_flags, GC_THREAD_FLAG_HAS_EXIT, CYG_FLAG_WAITMODE_OR| CYG_FLAG_WAITMODE_CLR); // Kill and free the resources ... this is safe due to the flag // from the thread. cyg_thread_kill(sb->s_gc_thread_handle); cyg_thread_delete(sb->s_gc_thread_handle); cyg_mutex_destroy(&sb->s_lock); cyg_flag_destroy(&sb->s_gc_thread_flags); }
int WakeUpWaitQ(wlan_thread *thread) { cyg_flag_setbits( &thread->waitQ_flag_q, 1 ); return 0; }
void jffs2_garbage_collect_trigger(struct jffs2_sb_info *c) { struct super_block *sb=OFNI_BS_2SFFJ(c); /* Wake up the thread */ D1(printk("jffs2_garbage_collect_trigger\n")); cyg_flag_setbits(&sb->s_gc_thread_flags,GC_THREAD_FLAG_TRIG); }
static void jffs2_garbage_collect_thread(cyg_addrword_t data) { struct jffs2_sb_info *c=(struct jffs2_sb_info *)data; struct super_block *sb=OFNI_BS_2SFFJ(c); cyg_flag_value_t flag; cyg_mtab_entry *mte; D1(printk("jffs2_garbage_collect_thread START\n")); while(1) { flag=cyg_flag_timed_wait(&sb->s_gc_thread_flags, GC_THREAD_FLAG_TRIG|GC_THREAD_FLAG_STOP, CYG_FLAG_WAITMODE_OR| CYG_FLAG_WAITMODE_CLR, cyg_current_time()+ CYGNUM_JFFS2_GS_THREAD_TICKS); if (flag & GC_THREAD_FLAG_STOP) break; D1(printk("jffs2: GC THREAD GC BEGIN\n")); mte=cyg_fs_root_lookup((cyg_dir *) sb->s_root); CYG_ASSERT(mte, "Bad mount point"); cyg_fs_lock(mte, mte->fs->syncmode); if (jffs2_garbage_collect_pass(c) == -ENOSPC) { printf("No space for garbage collection. " "Aborting JFFS2 GC thread\n"); break; } cyg_fs_unlock(mte, mte->fs->syncmode); D1(printk("jffs2: GC THREAD GC END\n")); } D1(printk("jffs2_garbage_collect_thread EXIT\n")); cyg_flag_setbits(&sb->s_gc_thread_flags,GC_THREAD_FLAG_HAS_EXIT); }
/** * @brief This function handles the timeout of packet * transmission * * @param dev A pointer to net_device structure * @return n/a */ static void wlan_tx_timeout(struct net_device *dev) { wlan_private *priv = (wlan_private *) dev->priv; ENTER(); diag_printf("tx watch dog timeout!\n"); priv->wlan_dev.dnld_sent = DNLD_RES_RECEIVED; UpdateTransStart(dev); if (priv->adapter->CurrentTxSkb) { //wake_up_interruptible(&priv->MainThread.waitQ); cyg_flag_setbits( &priv->MainThread.waitQ_flag_q, 1 ); } else { //os_start_queue(priv); } LEAVE(); }
/** * @brief This function handles the interrupt. it will change PS * state if applicable. it will wake up main_thread to handle * the interrupt event as well. * * @param dev A pointer to net_device structure * @return n/a */ void wlan_interrupt(struct eth_drv_sc *sc) { wlan_private *priv = (wlan_private *)sc->driver_private; ENTER(); //diag_printf("wlan_interrupt: IntCounter=%d\n", priv->adapter->IntCounter); priv->adapter->IntCounter++; if (priv->adapter->HS_Activated && !priv->adapter->WakeupTries && //JONO priv->adapter->fwWakeupMethod == WAKEUP_FW_THRU_INTERFACE) { diag_printf("SDIO interrupt received while HS_Activated\n"); wlan_host_sleep_gpio_int_event(priv); } //JONO priv->adapter->WakeupTries = 0; if (priv->adapter->PSState == PS_STATE_SLEEP) { priv->adapter->PSState = PS_STATE_AWAKE; } if (priv->adapter->IsDeepSleep == TRUE) { priv->adapter->IsDeepSleep = FALSE; priv->wlan_dev.dnld_sent = DNLD_RES_RECEIVED; priv->adapter->HisRegCpy |= HIS_TxDnLdRdy; diag_printf("Interrupt received in DEEP SLEEP mode!\n"); //os_carrier_on(priv); //os_start_queue(priv); } //wake_up_interruptible(&priv->MainThread.waitQ); cyg_flag_setbits( &priv->MainThread.waitQ_flag_q, 1 ); LEAVE(); }
void ecos_synch_eth_drv_dsr(void) { cyg_flag_setbits( &alarm_flag, 2 ); }
// ------------------------------------------------------------------------ // ALARM EVENT FUNCTION // This is the DSR for the alarm firing: static void do_alarm(cyg_handle_t alarm, cyg_addrword_t data) { cyg_flag_setbits( &alarm_flag, 1 ); }
/** * @brief This function removes the card. * * @param priv A pointer to card * @return WLAN_STATUS_SUCCESS */ static int wlan_remove_card(void *card) { wlan_private *priv = &w99702_priv_data0; wlan_adapter *Adapter; //struct net_device *dev; struct cyg_netdevtab_entry *dev; struct eth_drv_sc *sc; union iwreq_data wrqu; ENTER(); if (!priv) { LEAVE(); return WLAN_STATUS_SUCCESS; } Adapter = priv->adapter; if (!Adapter) { LEAVE(); return WLAN_STATUS_SUCCESS; } dev = priv->wlan_dev.netdev; sc = (struct eth_drv_sc *)dev->device_instance; // wake_up_interruptible(&Adapter->ds_awake_q); cyg_cond_broadcast(&Adapter->ds_cond_q); if (Adapter->CurCmd) { diag_printf("Wake up current cmdwait_q\n"); // wake_up_interruptible(&Adapter->CurCmd->cmdwait_q); cyg_flag_setbits( &Adapter->CurCmd->cmdwait_flag_q, 3 ); } Adapter->CurCmd = NULL; if (Adapter->PSMode == Wlan802_11PowerModeMAX_PSP) { Adapter->PSMode = Wlan802_11PowerModeCAM; PSWakeup(priv, HostCmd_OPTION_WAITFORRSP); } if (Adapter->IsDeepSleep == TRUE) { Adapter->IsDeepSleep = FALSE; sbi_exit_deep_sleep(priv); } memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); wrqu.ap_addr.sa_family = ARPHRD_ETHER; wireless_send_event(priv->wlan_dev.netdev, SIOCGIWAP, &wrqu, NULL); /* Disable interrupts on the card as we cannot handle them after RESET */ sbi_disable_host_int(priv); PrepareAndSendCommand(priv, HostCmd_CMD_802_11_RESET, 0, 0, 0, NULL); cyg_thread_delay(20); //udelay(200*1000); #ifdef ENABLE_PM pm_unregister(wlan_pm_dev); #endif /* Flush all the packets upto the OS before stopping */ // wlan_send_rxskbQ(priv); eth_drv_dsr(0, 0, (cyg_addrword_t)sc); cleanup_txqueues(priv); // os_stop_queue(priv); // os_carrier_off(priv); Adapter->SurpriseRemoved = TRUE; /* Stop the thread servicing the interrupts */ //wake_up_interruptible(&priv->MainThread.waitQ); cyg_flag_setbits( &priv->MainThread.waitQ_flag_q, 1 ); #ifdef REASSOCIATION //wake_up_interruptible(&priv->ReassocThread.waitQ); cyg_flag_setbits( &priv->ReassocThread.waitQ_flag_q, 1 ); #endif /* REASSOCIATION */ #ifdef PROC_DEBUG wlan_debug_remove(priv); #endif // wlan_proc_remove(priv); diag_printf("unregester dev\n"); sbi_unregister_dev(priv); diag_printf("Free Adapter\n"); wlan_free_adapter(priv); /* Last reference is our one */ // diag_printf("refcnt = %d\n", atomic_read(&dev->refcnt)); // diag_printf("netdev_finish_unregister: %s%s.\n", dev->name, // (dev->features & NETIF_F_DYNALLOC) ? "" : ", old style"); // unregister_netdev(dev); diag_printf("Unregister finish\n"); priv->wlan_dev.netdev = NULL; //free_netdev(dev); //wlanpriv = NULL; LEAVE(); return WLAN_STATUS_SUCCESS; }
//static wlan_private * wlan_add_card(void *card) { //struct net_device *dev = NULL; wlan_private *priv = NULL; //struct eth_drv_sc *dev; ENTER(); /* probe the card */ if (sbi_probe_card(card) < 0) { diag_printf("NO card found!\n"); return NULL; } #if 0 /* Allocate an Ethernet device and register it */ if (!(dev = alloc_etherdev(sizeof(wlan_private)))) { diag_printf("Init ethernet device failed!\n"); return NULL; } #endif priv = (wlan_private *)((cyg_uint32)&w99702_priv_data0 | NON_CACHE_FLAG); /* allocate buffer for wlan_adapter */ MALLOC(priv->adapter, wlan_adapter *, sizeof(wlan_adapter), 0, M_NOWAIT); if(!priv->adapter) { diag_printf("Allocate buffer for wlan_adapter failed!\n"); goto err_kmalloc; } priv->adapter = (wlan_adapter *)((unsigned int)priv->adapter | NON_CACHE_FLAG); /* init wlan_adapter */ memset(priv->adapter, 0, sizeof(wlan_adapter)); priv->wlan_dev.netdev = &w99702_netdev; priv->wlan_dev.card = card; // wlanpriv = priv; // SET_MODULE_OWNER(dev); #if 0 /* Setup the OS Interface to our functions */ dev->open = wlan_open; dev->hard_start_xmit = wlan_hard_start_xmit; dev->stop = wlan_close; dev->do_ioctl = wlan_do_ioctl; dev->set_mac_address = wlan_set_mac_address; #define WLAN_WATCHDOG_TIMEOUT (2 * HZ) dev->tx_timeout = wlan_tx_timeout; dev->get_stats = wlan_get_stats; dev->watchdog_timeo = WLAN_WATCHDOG_TIMEOUT; #ifdef WIRELESS_EXT dev->get_wireless_stats = wlan_get_wireless_stats; dev->wireless_handlers = (struct iw_handler_def *) &wlan_handler_def; #endif #define NETIF_F_DYNALLOC 16 dev->features |= NETIF_F_DYNALLOC; dev->flags |= IFF_BROADCAST | IFF_MULTICAST; dev->set_multicast_list = wlan_set_multicast_list; #endif//clyu #ifdef MFG_CMD_SUPPORT /* Required for the mfg command */ //init_waitqueue_head(&priv->adapter->mfg_cmd_q); cyg_cond_init(&priv->adapter->mfg_cond_q, &priv->adapter->mfg_mutex); #endif //init_waitqueue_head(&priv->adapter->ds_awake_q); cyg_cond_init(&priv->adapter->ds_cond_q, &priv->adapter->ds_mutex); #ifdef ENABLE_PM if (!(wlan_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, wlan_pm_callback))) diag_printf("Failed to register PM callback\n"); #endif INIT_LIST_HEAD(&priv->adapter->CmdFreeQ); INIT_LIST_HEAD(&priv->adapter->CmdPendingQ); diag_printf("Starting kthread...\n"); priv->MainThread.priv = priv; cyg_thread_create(WIRELESS_THREAD_PRIORITY, // Priority wlan_service_main_thread, // entry (cyg_addrword_t)&w99702_sc, // entry parameter "pxa270m card support", // Name &thread_stack[0], // Stack sizeof(thread_stack), // Size &thread_handle, // Handle &thread_data // Thread data structure ); priv->MainThread.task = thread_handle; cyg_thread_resume(thread_handle); // Start it // ConfigureThreadPriority(); #ifdef REASSOCIATION priv->ReassocThread.priv = priv; /* wlan_create_thread(wlan_reassociation_thread, &priv->ReassocThread, "wlan_reassoc_service");*/ cyg_thread_create(WIRELESS_THREAD_PRIORITY, // Priority wlan_reassociation_thread, // entry (cyg_addrword_t)&w99702_sc, // entry parameter "wlan_reassoc_service", // Name &reassoc_stack[0], // Stack sizeof(reassoc_stack), // Size &reassoc_handle, // Handle &reassoc_data // Thread data structure ); priv->ReassocThread.task = reassoc_handle; cyg_thread_resume(reassoc_handle); // Start it #endif /* REASSOCIATION */ /* * Register the device. Fillup the private data structure with * relevant information from the card and request for the required * IRQ. */ if (sbi_register_dev(priv) < 0) { diag_printf("Failed to register wlan device!\n"); goto err_registerdev; } #if 0 diag_printf("%s: Marvell Wlan 802.11 Adapter " "revision 0x%02X at IRQ %i\n", dev->name, priv->adapter->chip_rev, dev->irq); #endif //wlan_proc_entry(priv, dev); #ifdef PROC_DEBUG wlan_debug_entry(priv, dev); #endif #if 0 /* Get the CIS Table */ sbi_get_cis_info(priv); #endif /* init FW and HW */ if (wlan_init_fw(priv)) { diag_printf("Firmware Init Failed\n"); goto err_init_fw; } #if 0 if (register_netdev(dev)) { printk(KERN_ERR "Cannot register network device!\n"); goto err_init_fw; } #endif LEAVE(); return priv; err_init_fw: sbi_unregister_dev(priv); err_registerdev: /* Stop the thread servicing the interrupts */ //wake_up_interruptible(&priv->MainThread.waitQ); cyg_flag_setbits( &priv->MainThread.waitQ_flag_q, 1 ); wlan_terminate_thread(&priv->MainThread); #ifdef REASSOCIATION //wake_up_interruptible(&priv->ReassocThread.waitQ); cyg_flag_setbits( &priv->ReassocThread.waitQ_flag_q, 1 ); wlan_terminate_thread(&priv->ReassocThread); #endif /* REASSOCIATION */ err_kmalloc: // unregister_netdev(dev); FREE(priv->adapter, 0); //wlanpriv = NULL; LEAVE(); return NULL; }