static int rt2870_suspend(
struct usb_interface *intf,
pm_message_t state)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
UCHAR Flag;
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend===> rt2870_suspend()\n"));
/* if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF)) */
RTMP_DRIVER_ADAPTER_IDLE_RADIO_OFF_TEST(pAd, &Flag);
if(!Flag)
{
/*RT28xxUsbAsicRadioOff(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_OFF(pAd);
/*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_CPU_SUSPEND); */
RTMP_DRIVER_ADAPTER_CPU_SUSPEND_SET(pAd);
}
/*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_SET(pAd);
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_suspend()\n"));
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_detach(net_dev);
RTMP_DRIVER_USB_SUSPEND(pAd, netif_running(net_dev));
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_suspend()\n"));
return 0;
}
/*
========================================================================
Routine Description:
Set channel.
Arguments:
pWiphy - Wireless hardware description
pChan - Channel information
ChannelType - Channel type
Return Value:
0 - success
-x - fail
Note:
For iw utility: set channel, set freq
enum nl80211_channel_type {
NL80211_CHAN_NO_HT,
NL80211_CHAN_HT20,
NL80211_CHAN_HT40MINUS,
NL80211_CHAN_HT40PLUS
};
========================================================================
*/
static int CFG80211_OpsChannelSet(
IN struct wiphy *pWiphy,
IN struct net_device *pDev,
IN struct ieee80211_channel *pChan,
IN enum nl80211_channel_type ChannelType)
{
struct rtmp_adapter *pAd;
CFG80211_CB *p80211CB;
CMD_RTPRIV_IOCTL_80211_CHAN ChanInfo;
u32 ChanId;
struct net_device *dev = NULL;
CFG80211DBG(RT_DEBUG_ERROR, ("80211> %s ==>\n", __FUNCTION__));
MAC80211_PAD_GET(pAd, pWiphy);
RTMP_DRIVER_NET_DEV_GET(pAd, &dev);
/* get channel number */
ChanId = ieee80211_frequency_to_channel(pChan->center_freq);
CFG80211DBG(RT_DEBUG_ERROR, ("80211> Channel = %d\n", ChanId));
CFG80211DBG(RT_DEBUG_ERROR, ("80211> ChannelType = %d\n", ChannelType));
/* init */
memset(&ChanInfo, 0, sizeof(ChanInfo));
ChanInfo.ChanId = ChanId;
p80211CB = NULL;
RTMP_DRIVER_80211_CB_GET(pAd, &p80211CB);
if (p80211CB == NULL)
{
CFG80211DBG(RT_DEBUG_ERROR, ("80211> p80211CB == NULL!\n"));
return 0;
}
if (p80211CB->pCfg80211_Wdev->iftype == NL80211_IFTYPE_STATION)
ChanInfo.IfType = RT_CMD_80211_IFTYPE_STATION;
else if (p80211CB->pCfg80211_Wdev->iftype == NL80211_IFTYPE_ADHOC)
ChanInfo.IfType = RT_CMD_80211_IFTYPE_ADHOC;
else if (p80211CB->pCfg80211_Wdev->iftype == NL80211_IFTYPE_MONITOR)
ChanInfo.IfType = RT_CMD_80211_IFTYPE_MONITOR;
if (ChannelType == NL80211_CHAN_NO_HT)
ChanInfo.ChanType = RT_CMD_80211_CHANTYPE_NOHT;
else if (ChannelType == NL80211_CHAN_HT20)
ChanInfo.ChanType = RT_CMD_80211_CHANTYPE_HT20;
else if (ChannelType == NL80211_CHAN_HT40MINUS)
ChanInfo.ChanType = RT_CMD_80211_CHANTYPE_HT40MINUS;
else if (ChannelType == NL80211_CHAN_HT40PLUS)
ChanInfo.ChanType = RT_CMD_80211_CHANTYPE_HT40PLUS;
ChanInfo.MonFilterFlag = p80211CB->MonFilterFlag;
/* set channel */
RTMP_DRIVER_80211_CHAN_SET(pAd, &ChanInfo);
return 0;
} /* End of CFG80211_OpsChannelSet */
static int rt2870_resume(
struct usb_interface *intf)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef CONFIG_HAS_EARLYSUSPEND
UCHAR check_early_suspend_flag;
RTMP_DRIVER_ADAPTER_CHECK_EARLYSUSPEND(pAd, &check_early_suspend_flag);
if (check_early_suspend_flag == TRUE){
DBGPRINT(RT_DEBUG_OFF, ("%s, We has already register earlysuspend, do nothing here\n", __func__));
return 0;
}
#endif
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
INT pm_usage_cnt;
UCHAR Flag;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
pm_usage_cnt = atomic_read(&intf->pm_usage_cnt);
#else
pm_usage_cnt = intf->pm_usage_cnt;
#endif
if(pm_usage_cnt <= 0)
usb_autopm_get_interface(intf);
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend===> rt2870_resume()\n"));
/*RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_CLEAR(pAd);
/*RT28xxUsbAsicRadioOn(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_ON(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend<=== rt2870_resume()\n"));
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_resume()\n"));
/* pAd->PM_FlgSuspend = 0; */
RTMP_DRIVER_USB_RESUME(pAd);
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_attach(net_dev);
netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_resume()\n"));
return 0;
}
static int rt2870_resume(
struct usb_interface *intf)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
int pm_usage_cnt;
UCHAR Flag;
printk("------------%s,%d------------------\n",__func__,__LINE__);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
if ((RT_IS_EARLYSUSPEND_REGISTERED((PRTMP_ADAPTER)pAd)) && (late_resume_flag == TRUE)){
DBGPRINT(RT_DEBUG_OFF, ("%s, We has already register earlysuspend, call VIRTUAL_IF_UP\n", __func__));
return 0;
}
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
pm_usage_cnt = atomic_read(&intf->pm_usage_cnt);
#else
pm_usage_cnt = intf->pm_usage_cnt;
#endif
if(pm_usage_cnt <= 0)
usb_autopm_get_interface(intf);
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend===> rt2870_resume()\n"));
/*RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_CLEAR(pAd);
/*RT28xxUsbAsicRadioOn(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_ON(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend<=== rt2870_resume()\n"));
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_resume()\n"));
/* pAd->PM_FlgSuspend = 0; */
RTMP_DRIVER_USB_RESUME(pAd);
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_attach(net_dev);
netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_resume()\n"));
return 0;
}
static int rt2870_suspend(
struct usb_interface *intf,
pm_message_t state)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
late_resume_flag = TRUE;
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
UCHAR Flag;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
if ((RT_IS_EARLYSUSPEND_REGISTERED((PRTMP_ADAPTER)pAd)) && (late_resume_flag == TRUE)){
VIRTUAL_IF_DOWN((VOID *)pAd);
DBGPRINT(RT_DEBUG_OFF, ("%s, We has already register earlysuspend, make VIRTUAL_IF_DOWN\n", __func__));
return 0;
}
#endif
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
// UCHAR Flag;
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend===> rt2870_suspend()\n"));
/* RtmpOSWrielessEventSend(pAd->net_dev, RT_WLAN_EVENT_CGIWAP, -1, NULL, NULL, 0);*/
RTMP_DRIVER_ADAPTER_END_DISSASSOCIATE(pAd);
/* if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF)) */
RTMP_DRIVER_ADAPTER_IDLE_RADIO_OFF_TEST(pAd, &Flag);
if(!Flag)
{
/*RT28xxUsbAsicRadioOff(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_OFF(pAd);
/*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_CPU_SUSPEND); */
RTMP_DRIVER_ADAPTER_CPU_SUSPEND_SET(pAd);
}
/*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_SET(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend <=== rt2870_suspend()\n"));
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_suspend()\n"));
// RtmpOSWrielessEventSend(pAd->net_dev, RT_WLAN_EVENT_CGIWAP, -1, NULL, NULL, 0);
// RTMP_DRIVER_ADAPTER_END_DISSASSOCIATE(pAd);
// RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_OFF(pAd);
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_detach(net_dev);
RTMP_DRIVER_USB_SUSPEND(pAd, netif_running(net_dev));
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_suspend()\n"));
return 0;
}
static int rtusb_resume(struct usb_interface *intf)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
INT pm_usage_cnt;
UCHAR Flag;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
pm_usage_cnt = atomic_read(&intf->pm_usage_cnt);
#else
pm_usage_cnt = intf->pm_usage_cnt;
#endif
if(pm_usage_cnt <= 0)
usb_autopm_get_interface(intf);
DBGPRINT(RT_DEBUG_ERROR, ("%s():=>autosuspend\n", __FUNCTION__));
/*RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_CLEAR(pAd);
#ifdef WOW_SUPPORT
RTMP_DRIVER_ADAPTER_RT28XX_USB_WOW_STATUS(pAd, &Flag);
if (Flag == TRUE)
RTMP_DRIVER_ADAPTER_RT28XX_USB_WOW_DISABLE(pAd);
else
#endif /* WOW_SUPPORT */
/*RT28xxUsbAsicRadioOn(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_ON(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("%s(): <=autosuspend\n", __FUNCTION__));
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("%s()=>\n", __FUNCTION__));
/* pAd->PM_FlgSuspend = 0; */
RTMP_DRIVER_USB_RESUME(pAd);
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_attach(net_dev);
netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);
DBGPRINT(RT_DEBUG_TRACE, ("<=%s()\n", __FUNCTION__));
return 0;
}
static int rt2870_suspend(
struct usb_interface *intf,
pm_message_t state)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef CONFIG_HAS_EARLYSUSPEND
UCHAR check_early_suspend_flag;
RTMP_DRIVER_ADAPTER_CHECK_EARLYSUSPEND(pAd, &check_early_suspend_flag);
if (check_early_suspend_flag == TRUE){
VIRTUAL_IF_DOWN(pAd);
DBGPRINT(RT_DEBUG_OFF, ("%s, We has already register earlysuspend, make VIRTUAL_IF_DOWN\n", __func__));
return 0;
}
#endif
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
UCHAR Flag;
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend===> rt2870_suspend()\n"));
{
/* if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF)) */
RTMP_DRIVER_ADAPTER_END_DISSASSOCIATE(pAd);
RTMP_DRIVER_ADAPTER_IDLE_RADIO_OFF_TEST(pAd, &Flag);
if(!Flag)
{
/*RT28xxUsbAsicRadioOff(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_OFF(pAd);
}
}
/*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_SET(pAd);
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_suspend()\n"));
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_detach(net_dev);
RTMP_DRIVER_USB_SUSPEND(pAd, netif_running(net_dev));
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_suspend()\n"));
return 0;
}
static int rtusb_suspend(struct usb_interface *intf, pm_message_t state)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
UCHAR Flag;
#endif
#if (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT)
UCHAR WOWEable;
#endif
DBGPRINT(RT_DEBUG_TRACE, ("===> rtusb_suspend()\n"));
if (!RTMP_TEST_FLAG((PRTMP_ADAPTER)pAd, fRTMP_ADAPTER_START_UP))
return 0;
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
DBGPRINT(RT_DEBUG_ERROR, ("%s():=>autosuspend\n", __func__));
RTMP_DRIVER_ADAPTER_RT28XX_CMD_RADIO_OFF(pAd);
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
#ifdef RESUME_WITH_USB_RESET_SUPPORT
last_pm_cnt = os_get_sync_anchor();
#endif /* RESUME_WITH_USB_RESET_SUPPORT */
#if (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT)
RTMP_DRIVER_ADAPTER_RT28XX_WOW_READY(pAd, &WOWEable);
if (WOWEable)
RTMP_DRIVER_ADAPTER_RT28XX_WOW_ENABLE(pAd);
else
#endif /* (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT) */
{
DBGPRINT(RT_DEBUG_ERROR, ("%s :radio_off \n", __func__));
RTMP_DRIVER_ADAPTER_RT28XX_CMD_RADIO_OFF(pAd);
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_detach(net_dev);
}
RTMP_DRIVER_USB_SUSPEND(pAd, netif_running(net_dev));
DBGPRINT(RT_DEBUG_TRACE, ("<=%s()\n", __func__));
return 0;
}
int netdev_sysfs_reinit(VOID **ppAd, struct usb_device *usb_dev)
{
VOID *pAd = *ppAd;
struct net_device *net_dev = NULL;
#ifdef RT_CFG80211_P2P_SUPPORT
struct net_device *dummy_net_dev = NULL;
#endif /* RT_CFG80211_P2P_SUPPORT */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
/* Sansity check for avoiding null pointer */
if (!net_dev || !net_dev->ieee80211_ptr || !usb_dev)
{
DBGPRINT(RT_DEBUG_ERROR, ("%s(): Ignore invalid dev pointer.\n", __func__));
return 0;
}
/* Link usb's dev to wiphy's dev */
set_wiphy_dev(net_dev->ieee80211_ptr->wiphy, &(usb_dev->dev));
/* main net device(wlan0) */
SET_NETDEV_DEV(net_dev, &(usb_dev->dev));
device_del(&(net_dev->dev));
if (device_add(&(net_dev->dev)) != 0)
DBGPRINT(RT_DEBUG_OFF, ("%s(): device_add fail for main net device\n", __func__));
#ifdef RT_CFG80211_P2P_SUPPORT
RTMP_DRIVER_DUMMY_NET_DEV_GET(pAd, &dummy_net_dev);
if (!dummy_net_dev)
{
DBGPRINT(RT_DEBUG_ERROR, ("%s(): Ignore dummy net device\n", __func__));
return 0;
}
/* dummy net device(p2p0) */
SET_NETDEV_DEV(dummy_net_dev, &(usb_dev->dev));
device_del(&(dummy_net_dev->dev));
if (device_add(&(dummy_net_dev->dev)) != 0)
DBGPRINT(RT_DEBUG_OFF, ("%s(): device_add fail for dummy net device\n", __func__));
#endif /* RT_CFG80211_P2P_SUPPORT */
return 0;
}
static int rtusb_suspend(struct usb_interface *intf, pm_message_t state)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
UCHAR Flag;
DBGPRINT(RT_DEBUG_ERROR, ("%s():=>autosuspend\n", __FUNCTION__));
#ifdef WOW_SUPPORT
RTMP_DRIVER_ADAPTER_RT28XX_USB_WOW_STATUS(pAd, &Flag);
if (Flag == TRUE)
RTMP_DRIVER_ADAPTER_RT28XX_USB_WOW_ENABLE(pAd);
else
#endif /* WOW_SUPPORT */
{
/* if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_IDLE_RADIO_OFF)) */
RTMP_DRIVER_ADAPTER_END_DISSASSOCIATE(pAd);
RTMP_DRIVER_ADAPTER_IDLE_RADIO_OFF_TEST(pAd, &Flag);
if(!Flag)
{
/*RT28xxUsbAsicRadioOff(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_OFF(pAd);
}
}
/*RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_SET(pAd);
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("%s()=>\n", __FUNCTION__));
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_detach(net_dev);
RTMP_DRIVER_USB_SUSPEND(pAd, netif_running(net_dev));
DBGPRINT(RT_DEBUG_TRACE, ("<=%s()\n", __FUNCTION__));
return 0;
}
/*
========================================================================
Routine Description:
Release allocated resources.
Arguments:
*dev Point to the PCI or USB device
pAd driver control block pointer
Return Value:
None
Note:
========================================================================
*/
static void rt2870_disconnect(struct usb_device *dev, VOID *pAd)
{
struct net_device *net_dev;
DBGPRINT(RT_DEBUG_ERROR, ("rtusb_disconnect: unregister usbnet usb-%s-%s\n",
dev->bus->bus_name, dev->devpath));
if (!pAd)
{
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) /* kernel 2.4 series */
while(MOD_IN_USE > 0)
{
MOD_DEC_USE_COUNT;
}
#else
usb_put_dev(dev);
#endif /* LINUX_VERSION_CODE */
printk("rtusb_disconnect: pAd == NULL!\n");
return;
}
/* RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST); */
RTMP_DRIVER_NIC_NOT_EXIST_SET(pAd);
/* for debug, wait to show some messages to /proc system */
udelay(1);
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
RtmpPhyNetDevExit(pAd, net_dev);
/* FIXME: Shall we need following delay and flush the schedule?? */
udelay(1);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) /* kernel 2.4 series */
#else
flush_scheduled_work();
#endif /* LINUX_VERSION_CODE */
udelay(1);
#ifdef CONFIG_HAS_EARLYSUSPEND
RTMP_DRIVER_ADAPTER_UNREGISTER_EARLYSUSPEND(pAd);
#endif
#ifdef RT_CFG80211_SUPPORT
RTMP_DRIVER_80211_UNREGISTER(pAd, net_dev);
#endif /* RT_CFG80211_SUPPORT */
/* free the root net_device */
// RtmpOSNetDevFree(net_dev);
RtmpRaDevCtrlExit(pAd);
/* free the root net_device */
RtmpOSNetDevFree(net_dev);
/* release a use of the usb device structure */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) /* kernel 2.4 series */
while(MOD_IN_USE > 0)
{
MOD_DEC_USE_COUNT;
}
#else
usb_put_dev(dev);
#endif /* LINUX_VERSION_CODE */
udelay(1);
DBGPRINT(RT_DEBUG_ERROR, (" RTUSB disconnect successfully\n"));
}
static int rt2870_resume(
struct usb_interface *intf)
{
struct net_device *net_dev;
VOID *pAd = usb_get_intfdata(intf);
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
struct usb_device *pUsb_Dev;
UCHAR Flag;
INT pm_usage_cnt;
RTMP_DRIVER_USB_DEV_GET(pAd, &pUsb_Dev);
RTMP_DRIVER_USB_INTF_GET(pAd, &intf);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
pm_usage_cnt = atomic_read(&intf->pm_usage_cnt);
#else
pm_usage_cnt = intf->pm_usage_cnt;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)
if(pUsb_Dev->autosuspend_disabled == 0)
#else
if(pUsb_Dev->auto_pm == 1)
#endif
{
if(pm_usage_cnt <= 0)
usb_autopm_get_interface(intf);
}
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend===> rt2870_resume()\n"));
/*RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_SUSPEND); */
RTMP_DRIVER_ADAPTER_SUSPEND_CLEAR(pAd);
RTMP_DRIVER_ADAPTER_CPU_SUSPEND_TEST(pAd, &Flag);
if(Flag)
/*if(RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_CPU_SUSPEND)) */
{
/*RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_CPU_SUSPEND); */
RTMP_DRIVER_ADAPTER_CPU_SUSPEND_CLEAR(pAd);
}
/*RT28xxUsbAsicRadioOn(pAd); */
RTMP_DRIVER_ADAPTER_RT28XX_USB_ASICRADIO_ON(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("autosuspend<=== rt2870_resume()\n"));
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_resume()\n"));
/* pAd->PM_FlgSuspend = 0; */
RTMP_DRIVER_USB_RESUME(pAd);
/* net_dev = pAd->net_dev; */
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_attach(net_dev);
netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_resume()\n"));
return 0;
}
/*
========================================================================
Routine Description:
Request to do a scan. If returning zero, the scan request is given
the driver, and will be valid until passed to cfg80211_scan_done().
For scan results, call cfg80211_inform_bss(); you can call this outside
the scan/scan_done bracket too.
Arguments:
pWiphy - Wireless hardware description
pNdev - Network device interface
pRequest - Scan request
Return Value:
0 - success
-x - fail
Note:
For iw utility: scan
struct cfg80211_scan_request {
struct cfg80211_ssid *ssids;
int n_ssids;
struct ieee80211_channel **channels;
u32 n_channels;
const u8 *ie;
size_t ie_len;
* @ssids: SSIDs to scan for (active scan only)
* @n_ssids: number of SSIDs
* @channels: channels to scan on.
* @n_channels: number of channels for each band
* @ie: optional information element(s) to add into Probe Request or %NULL
* @ie_len: length of ie in octets
========================================================================
*/
static int CFG80211_OpsScan(
IN struct wiphy *pWiphy,
IN struct cfg80211_scan_request *pRequest)
{
#ifdef CONFIG_STA_SUPPORT
struct rtmp_adapter *pAd;
CFG80211_CB *pCfg80211_CB;
#ifdef WPA_SUPPLICANT_SUPPORT
struct iw_scan_req IwReq;
union iwreq_data Wreq;
#endif /* WPA_SUPPLICANT_SUPPORT */
struct net_device *pNdev = NULL;
CFG80211DBG(RT_DEBUG_ERROR, ("80211> %s ==>\n", __FUNCTION__));
MAC80211_PAD_GET(pAd, pWiphy);
RTMP_DRIVER_NET_DEV_GET(pAd, &pNdev);
/* sanity check */
if ((pNdev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) &&
(pNdev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC))
{
return -EOPNOTSUPP;
} /* End of if */
if (RTMP_DRIVER_IOCTL_SANITY_CHECK(pAd, NULL) != NDIS_STATUS_SUCCESS)
{
DBGPRINT(RT_DEBUG_TRACE, ("80211> Network is down!\n"));
return -ENETDOWN;
} /* End of if */
if (RTMP_DRIVER_80211_SCAN(pAd) != NDIS_STATUS_SUCCESS)
return -EBUSY; /* scanning */
/* End of if */
RTMP_DRIVER_80211_CB_GET(pAd, &pCfg80211_CB);
pCfg80211_CB->pCfg80211_ScanReq = pRequest; /* used in scan end */
#ifdef WPA_SUPPLICANT_SUPPORT
memset(&Wreq, 0, sizeof(Wreq));
memset(&IwReq, 0, sizeof(IwReq));
if ((pRequest->ssids != NULL) &&
(sizeof(pRequest->ssids->ssid) <= sizeof(IwReq.essid)))
{
/* use 1st SSID in the requested SSID list */
IwReq.essid_len = pRequest->ssids->ssid_len;
memcpy(IwReq.essid, pRequest->ssids->ssid, sizeof(IwReq.essid));
Wreq.data.flags |= IW_SCAN_THIS_ESSID;
Wreq.data.length = sizeof(struct iw_scan_req);
}
rt_ioctl_siwscan(pNdev, NULL, &Wreq, (char *)&IwReq);
#else
rt_ioctl_siwscan(pNdev, NULL, NULL, NULL);
#endif /* WPA_SUPPLICANT_SUPPORT */
return 0;
#else
return -EOPNOTSUPP;
#endif /* CONFIG_STA_SUPPORT */
} /* End of CFG80211_OpsScan */
static int rtusb_resume(struct usb_interface *intf)
{
struct net_device *net_dev;
#if (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT)
UCHAR WOWRun;
#endif /* (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT) */
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
INT pm_usage_cnt;
UCHAR Flag;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
VOID *pAd = usb_get_intfdata(intf);
DBGPRINT(RT_DEBUG_TRACE, ("%s()=>\n", __func__));
if (!RTMP_TEST_FLAG((PRTMP_ADAPTER)pAd, fRTMP_ADAPTER_START_UP))
return 0;
#ifdef RESUME_WITH_USB_RESET_SUPPORT
if (last_pm_cnt != os_get_sync_anchor())
{
DBGPRINT(RT_DEBUG_ERROR, ("real suspend before\n"));
return 0;
}
#endif /* RESUME_WITH_USB_RESET_SUPPORT */
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
pm_usage_cnt = atomic_read(&intf->pm_usage_cnt);
#else
pm_usage_cnt = intf->pm_usage_cnt;
#endif
if(pm_usage_cnt <= 0)
usb_autopm_get_interface(intf);
RTMP_DRIVER_ADAPTER_RT28XX_CMD_RADIO_ON(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("%s():=>autosuspend\n", __func__));
return 0;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
#if (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT)
RTMP_DRIVER_ADAPTER_RT28XX_WOW_RUNSTATUS(pAd, &WOWRun);
if (WOWRun)
RTMP_DRIVER_ADAPTER_RT28XX_WOW_DISABLE(pAd);
else
#endif /* (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT) */
{
DBGPRINT(RT_DEBUG_ERROR, ("%s :radio_on \n", __func__));
RTMP_DRIVER_ADAPTER_RT28XX_CMD_RADIO_ON(pAd);
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_attach(net_dev);
netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);
}
RTMP_DRIVER_USB_RESUME(pAd);
DBGPRINT(RT_DEBUG_TRACE, ("<=%s()\n", __func__));
return 0;
}
int rtusb_fast_probe(VOID *handle, VOID **ppAd, struct usb_interface *intf)
{
VOID *pAd = *ppAd;
VOID *pCookie = NULL;
struct net_device *net_dev;
#if (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT)
UCHAR WOWRun;
#endif /* (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT) */
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
INT pm_usage_cnt;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
struct usb_device *usb_dev = NULL;
pCookie = RTMPCheckOsCookie(handle, &pAd);
if (pCookie == NULL)
return NDIS_STATUS_FAILURE;
usb_dev = ((POS_COOKIE)pCookie)->pUsb_Dev;
if (USBDevConfigInit(usb_dev, intf, pAd) == FALSE)
{
RTMPFreeAdapter(pAd);
return NDIS_STATUS_FAILURE;
}
RTMP_DRIVER_USB_INIT(pAd, usb_dev, 0);
/* netdevice-related structure set-up */
netdev_sysfs_reinit(&pAd, usb_dev);
if (RTMP_DRIVER_IOCTL_SANITY_CHECK(pAd, NULL) != NDIS_STATUS_SUCCESS)
{
DBGPRINT(RT_DEBUG_ERROR, ("Driver is not init, ignore %s\n", __func__));
return NDIS_STATUS_SUCCESS;
}
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
pm_usage_cnt = atomic_read(&intf->pm_usage_cnt);
#else
pm_usage_cnt = intf->pm_usage_cnt;
#endif
if(pm_usage_cnt <= 0)
usb_autopm_get_interface(intf);
RTMP_DRIVER_ADAPTER_RT28XX_CMD_RADIO_ON(pAd);
DBGPRINT(RT_DEBUG_ERROR, ("%s(): <=autosuspend\n", __func__));
return NDIS_STATUS_SUCCESS;
#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
#if (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT)
RTMP_DRIVER_ADAPTER_RT28XX_WOW_RUNSTATUS(pAd, &WOWRun);
if (WOWRun)
RTMP_DRIVER_ADAPTER_RT28XX_WOW_DISABLE(pAd);
else
#endif /* (defined(WOW_SUPPORT) && defined(RTMP_MAC_USB)) || defined(NEW_WOW_SUPPORT) */
{
DBGPRINT(RT_DEBUG_ERROR, ("%s :radio_on \n", __func__));
RTMP_DRIVER_ADAPTER_RT28XX_CMD_RADIO_ON(pAd);
RTMP_DRIVER_NET_DEV_GET(pAd, &net_dev);
netif_device_attach(net_dev);
netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);
}
RTMP_DRIVER_USB_RESUME(pAd);
DBGPRINT(RT_DEBUG_TRACE, ("<=%s()\n", __func__));
return NDIS_STATUS_SUCCESS;
}
