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;
}
