int fm10k_setup_tc(struct net_device *dev, u8 tc)
{
struct fm10k_intfc *interface = netdev_priv(dev);
int err;
/* Currently only the PF supports priority classes */
if (tc && (interface->hw.mac.type != fm10k_mac_pf))
return -EINVAL;
/* Hardware supports up to 8 traffic classes */
if (tc > 8)
return -EINVAL;
/* Hardware has to reinitialize queues to match packet
* buffer alignment. Unfortunately, the hardware is not
* flexible enough to do this dynamically.
*/
if (netif_running(dev))
fm10k_close(dev);
fm10k_mbx_free_irq(interface);
fm10k_clear_queueing_scheme(interface);
/* we expect the prio_tc map to be repopulated later */
netdev_reset_tc(dev);
netdev_set_num_tc(dev, tc);
err = fm10k_init_queueing_scheme(interface);
if (err)
goto err_queueing_scheme;
err = fm10k_mbx_request_irq(interface);
if (err)
goto err_mbx_irq;
err = netif_running(dev) ? fm10k_open(dev) : 0;
if (err)
goto err_open;
/* flag to indicate SWPRI has yet to be updated */
interface->flags |= FM10K_FLAG_SWPRI_CONFIG;
return 0;
err_open:
fm10k_mbx_free_irq(interface);
err_mbx_irq:
fm10k_clear_queueing_scheme(interface);
err_queueing_scheme:
netif_device_detach(dev);
return err;
}
static int wl_adapter_suspend(struct pcmcia_device *link)
{
struct net_device *dev = link->priv;
/* if (link->open) { */
netif_device_detach(dev);
wl_suspend(dev);
/* CHECK! pcmcia_release_configuration(link->handle); */
/* } */
return 0;
} /* wl_adapter_suspend */
static int wl_adapter_suspend(struct pcmcia_device *link)
{
struct net_device *dev = link->priv;
//if (link->open) {
netif_device_detach(dev);
wl_suspend(dev);
//// CHECK! pcmcia_release_configuration(link->handle);
//}
return 0;
} // wl_adapter_suspend
/*----------------------------------------------------------------
* p80211netdev_hwremoved
*
* Hardware removed notification. This function should be called
* immediately after an MSD has detected that the underlying hardware
* has been yanked out from under us. The primary things we need
* to do are:
* - Mark the wlandev
* - Prevent any further traffic from the knetdev i/f
* - Prevent any further requests from mgmt i/f
* - If there are any waitq'd mgmt requests or mgmt-frame exchanges,
* shut them down.
* - Call the MSD hwremoved function.
*
* The remainder of the cleanup will be handled by unregister().
* Our primary goal here is to prevent as much tickling of the MSD
* as possible since the MSD is already in a 'wounded' state.
*
* TODO: As new features are added, this function should be
* updated.
*
* Arguments:
* wlandev WLAN network device structure
* Returns:
* nothing
* Side effects:
*
* Call context:
* Usually interrupt.
----------------------------------------------------------------*/
void p80211netdev_hwremoved(wlandevice_t *wlandev)
{
DBFENTER;
wlandev->hwremoved = 1;
if ( wlandev->state == WLAN_DEVICE_OPEN) {
p80211netdev_stop_queue(wlandev);
}
netif_device_detach(wlandev->netdev);
DBFEXIT;
}
static int netvsc_change_mtu(struct net_device *ndev, int mtu)
{
struct net_device_context *ndevctx = netdev_priv(ndev);
struct netvsc_device *nvdev = ndevctx->nvdev;
struct hv_device *hdev = ndevctx->device_ctx;
int orig_mtu = ndev->mtu;
struct netvsc_device_info device_info;
int limit = ETH_DATA_LEN;
bool was_opened;
int ret = 0;
if (!nvdev || nvdev->destroy)
return -ENODEV;
if (nvdev->nvsp_version >= NVSP_PROTOCOL_VERSION_2)
limit = NETVSC_MTU - ETH_HLEN;
if (mtu < NETVSC_MTU_MIN || mtu > limit)
return -EINVAL;
netif_device_detach(ndev);
was_opened = rndis_filter_opened(nvdev);
if (was_opened)
rndis_filter_close(nvdev);
memset(&device_info, 0, sizeof(device_info));
device_info.ring_size = ring_size;
device_info.num_chn = nvdev->num_chn;
rndis_filter_device_remove(hdev, nvdev);
ndev->mtu = mtu;
nvdev = rndis_filter_device_add(hdev, &device_info);
if (IS_ERR(nvdev)) {
ret = PTR_ERR(nvdev);
/* Attempt rollback to original MTU */
ndev->mtu = orig_mtu;
rndis_filter_device_add(hdev, &device_info);
}
if (was_opened)
rndis_filter_open(nvdev);
netif_device_attach(ndev);
/* We may have missed link change notifications */
schedule_delayed_work(&ndevctx->dwork, 0);
return ret;
}
static int at91ether_suspend(struct platform_device *pdev, pm_message_t mesg)
{
struct net_device *net_dev = platform_get_drvdata(pdev);
struct macb *lp = netdev_priv(net_dev);
if (netif_running(net_dev)) {
netif_stop_queue(net_dev);
netif_device_detach(net_dev);
clk_disable(lp->pclk);
}
return 0;
}
static int pxa_irda_suspend(struct platform_device *_dev, pm_message_t state)
{
struct net_device *dev = platform_get_drvdata(_dev);
struct pxa_irda *si;
if (dev && netif_running(dev)) {
si = netdev_priv(dev);
netif_device_detach(dev);
pxa_irda_shutdown(si);
}
return 0;
}
int lbs_suspend(struct lbs_private *priv)
{
int ret;
if (priv->is_deep_sleep) {
ret = lbs_set_deep_sleep(priv, 0);
if (ret) {
netdev_err(priv->dev,
"deep sleep cancellation failed: %d\n", ret);
return ret;
}
priv->deep_sleep_required = 1;
}
ret = lbs_set_host_sleep(priv, 1);
netif_device_detach(priv->dev);
if (priv->mesh_dev)
netif_device_detach(priv->mesh_dev);
return ret;
}
static int hieth_plat_driver_suspend_port(struct platform_device *pdev, \
pm_message_t state,
int port)
{
struct net_device *ndev = hieth_devs_save[port];
if (ndev) {
hieth_net_close(ndev);
netif_device_detach(ndev);
}
return 0;
}
/* USB suspend, so power off the transmitter/receiver */
static int ksdazzle_suspend(struct usb_interface *intf, pm_message_t message)
{
struct ksdazzle_cb *kingsun = usb_get_intfdata(intf);
netif_device_detach(kingsun->netdev);
if (kingsun->speed_urb != NULL)
usb_kill_urb(kingsun->speed_urb);
if (kingsun->tx_urb != NULL)
usb_kill_urb(kingsun->tx_urb);
if (kingsun->rx_urb != NULL)
usb_kill_urb(kingsun->rx_urb);
return 0;
}
static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
{
struct usb_card_rec *cardp = usb_get_intfdata(intf);
wlan_private *priv = cardp->priv;
lbs_deb_enter(LBS_DEB_USB);
if (priv->adapter->psstate != PS_STATE_FULL_POWER)
return -1;
netif_device_detach(cardp->eth_dev);
netif_device_detach(priv->mesh_dev);
/* Unlink tx & rx urb */
usb_kill_urb(cardp->tx_urb);
usb_kill_urb(cardp->rx_urb);
cardp->rx_urb_recall = 1;
lbs_deb_leave(LBS_DEB_USB);
return 0;
}
static int rt2860_suspend(struct pci_dev *pci_dev, pm_message_t state)
{
struct net_device *net_dev = pci_get_drvdata(pci_dev);
struct rt_rtmp_adapter *pAd = (struct rt_rtmp_adapter *)NULL;
int retval = 0;
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2860_suspend()\n"));
if (net_dev == NULL) {
DBGPRINT(RT_DEBUG_ERROR, ("net_dev == NULL!\n"));
} else {
GET_PAD_FROM_NET_DEV(pAd, net_dev);
/* we can not use IFF_UP because ra0 down but ra1 up */
/* and 1 suspend/resume function for 1 module, not for each interface */
/* so Linux will call suspend/resume function once */
if (VIRTUAL_IF_NUM(pAd) > 0) {
/* avoid users do suspend after interface is down */
/* stop interface */
netif_carrier_off(net_dev);
netif_stop_queue(net_dev);
/* mark device as removed from system and therefore no longer available */
netif_device_detach(net_dev);
/* mark halt flag */
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
/* take down the device */
rt28xx_close((struct net_device *)net_dev);
RT_MOD_DEC_USE_COUNT();
}
}
/* reference to http://vovo2000.com/type-lab/linux/kernel-api/linux-kernel-api.html */
/* enable device to generate PME# when suspended */
/* pci_choose_state(): Choose the power state of a PCI device to be suspended */
retval = pci_enable_wake(pci_dev, pci_choose_state(pci_dev, state), 1);
/* save the PCI configuration space of a device before suspending */
pci_save_state(pci_dev);
/* disable PCI device after use */
pci_disable_device(pci_dev);
retval = pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state));
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2860_suspend()\n"));
return retval;
}
int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
{
struct usbnet *dev = usb_get_intfdata(intf);
if (!dev->suspend_count++) {
/* accelerate emptying of the rx and queues, to avoid
* having everything error out.
*/
netif_device_detach (dev->net);
(void) unlink_urbs (dev, &dev->rxq);
(void) unlink_urbs (dev, &dev->txq);
}
return 0;
}
static int prism2_usb_suspend(struct usb_interface *interface, pm_message_t state)
{
struct net_device *dev = usb_get_intfdata(interface);
// FIXME: kill some URBs???
if (netif_running(dev)) {
netif_stop_queue(dev);
netif_device_detach(dev);
}
prism2_suspend(dev);
return 0;
}
/**
* ks8695_drv_suspend - Suspend a KS8695 ethernet platform device.
* @pdev: The device to suspend
* @state: The suspend state
*
* This routine detaches and shuts down a KS8695 ethernet device.
*/
static int
ks8695_drv_suspend(struct platform_device *pdev, pm_message_t state)
{
struct net_device *ndev = platform_get_drvdata(pdev);
struct ks8695_priv *ksp = netdev_priv(ndev);
ksp->in_suspend = 1;
if (netif_running(ndev)) {
netif_device_detach(ndev);
ks8695_shutdown(ksp);
}
return 0;
}
static int r871x_suspend(struct usb_interface *pusb_intf, pm_message_t state)
{
struct net_device *pnetdev = usb_get_intfdata(pusb_intf);
printk(KERN_INFO "r8712: suspending...\n");
if (!pnetdev || !netif_running(pnetdev)) {
printk(KERN_INFO "r8712: unable to suspend\n");
return 0;
}
if (pnetdev->netdev_ops->ndo_stop)
pnetdev->netdev_ops->ndo_stop(pnetdev);
mdelay(10);
netif_device_detach(pnetdev);
return 0;
}
static int prism2_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
struct net_device *dev = pci_get_drvdata(pdev);
if (netif_running(dev)) {
netif_stop_queue(dev);
netif_device_detach(dev);
}
prism2_suspend(dev);
pci_save_state(pdev);
pci_disable_device(pdev);
pci_set_power_state(pdev, PCI_D3hot);
return 0;
}
static int nmclan_suspend(struct pcmcia_device *p_dev)
{
dev_link_t *link = dev_to_instance(p_dev);
struct net_device *dev = link->priv;
link->state |= DEV_SUSPEND;
if (link->state & DEV_CONFIG) {
if (link->open)
netif_device_detach(dev);
pcmcia_release_configuration(link->handle);
}
return 0;
}
/*
* Suspend the IrDA interface.
*/
static int sa1100_irda_suspend(struct net_device *dev, int state)
{
struct sa1100_irda *si = dev->priv;
if (si && si->open) {
/*
* Stop the transmit queue
*/
netif_device_detach(dev);
disable_irq(dev->irq);
sa1100_irda_shutdown(si);
__sa1100_irda_set_power(si, 0);
}
return 0;
}
int dsa_slave_suspend(struct net_device *slave_dev)
{
struct dsa_slave_priv *p = netdev_priv(slave_dev);
netif_device_detach(slave_dev);
if (p->phy) {
phy_stop(p->phy);
p->old_pause = -1;
p->old_link = -1;
p->old_duplex = -1;
phy_suspend(p->phy);
}
return 0;
}
static int ti_hecc_suspend(struct platform_device *pdev, pm_message_t state)
{
struct net_device *dev = platform_get_drvdata(pdev);
struct ti_hecc_priv *priv = netdev_priv(dev);
if (netif_running(dev)) {
netif_stop_queue(dev);
netif_device_detach(dev);
}
hecc_set_bit(priv, HECC_CANMC, HECC_CANMC_PDR);
priv->can.state = CAN_STATE_SLEEPING;
clk_disable(priv->clk);
return 0;
}
static int rt2870_suspend(struct usb_interface *intf, pm_message_t state)
{
struct net_device *net_dev;
struct rt_rtmp_adapter *pAd = usb_get_intfdata(intf);
DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_suspend()\n"));
net_dev = pAd->net_dev;
netif_device_detach(net_dev);
pAd->PM_FlgSuspend = 1;
if (netif_running(net_dev)) {
RTUSBCancelPendingBulkInIRP(pAd);
RTUSBCancelPendingBulkOutIRP(pAd);
}
DBGPRINT(RT_DEBUG_TRACE, ("<=== rt2870_suspend()\n"));
return 0;
}
int rtl8192E_suspend(struct pci_dev *pdev, pm_message_t state)
{
struct net_device *dev = pci_get_drvdata(pdev);
struct r8192_priv *priv = rtllib_priv(dev);
u32 ulRegRead;
netdev_info(dev, "============> r8192E suspend call.\n");
del_timer_sync(&priv->gpio_polling_timer);
cancel_delayed_work(&priv->gpio_change_rf_wq);
priv->polling_timer_on = 0;
if (!netif_running(dev)) {
netdev_info(dev,
"RTL819XE:UI is open out of suspend function\n");
goto out_pci_suspend;
}
if (dev->netdev_ops->ndo_stop)
dev->netdev_ops->ndo_stop(dev);
netif_device_detach(dev);
if (!priv->rtllib->bSupportRemoteWakeUp) {
MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_INIT, true);
ulRegRead = read_nic_dword(dev, CPU_GEN);
ulRegRead |= CPU_GEN_SYSTEM_RESET;
write_nic_dword(dev, CPU_GEN, ulRegRead);
} else {
write_nic_dword(dev, WFCRC0, 0xffffffff);
write_nic_dword(dev, WFCRC1, 0xffffffff);
write_nic_dword(dev, WFCRC2, 0xffffffff);
write_nic_byte(dev, PMR, 0x5);
write_nic_byte(dev, MacBlkCtrl, 0xa);
}
out_pci_suspend:
netdev_info(dev, "WOL is %s\n", priv->rtllib->bSupportRemoteWakeUp ?
"Supported" : "Not supported");
pci_save_state(pdev);
pci_disable_device(pdev);
pci_enable_wake(pdev, pci_choose_state(pdev, state),
priv->rtllib->bSupportRemoteWakeUp ? 1 : 0);
pci_set_power_state(pdev, pci_choose_state(pdev, state));
mdelay(20);
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;
printk("------------%s,%d------------------\n",__func__,__LINE__);
#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
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 r871x_suspend(struct usb_interface *pusb_intf, pm_message_t state)
{
struct net_device *pnetdev = usb_get_intfdata(pusb_intf);
struct _adapter *padapter = netdev_priv(pnetdev);
netdev_info(pnetdev, "Suspending...\n");
if (!pnetdev || !netif_running(pnetdev)) {
netdev_info(pnetdev, "Unable to suspend\n");
return 0;
}
padapter->bSuspended = true;
rtl871x_intf_stop(padapter);
if (pnetdev->netdev_ops->ndo_stop)
pnetdev->netdev_ops->ndo_stop(pnetdev);
mdelay(10);
netif_device_detach(pnetdev);
return 0;
}
int rtl8180_suspend (struct pci_dev *pdev, pm_message_t state)
{
struct net_device *dev = pci_get_drvdata(pdev);
// struct r8180_priv *priv = ieee80211_priv(dev);
if (!netif_running(dev))
goto out_pci_suspend;
dev->stop(dev);
netif_device_detach(dev);
out_pci_suspend:
pci_save_state(pdev);
pci_disable_device(pdev);
pci_set_power_state(pdev,pci_choose_state(pdev,state));
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
airport_sleep_notify(struct pmu_sleep_notifier *self, int when)
{
dldwd_priv_t *priv;
struct net_device *ndev;
dldwd_card_t* card;
int rc;
if (!airport_dev)
return PBOOK_SLEEP_OK;
priv = airport_dev;
ndev = &priv->ndev;
card = (dldwd_card_t *)priv->card;
switch (when) {
case PBOOK_SLEEP_REQUEST:
break;
case PBOOK_SLEEP_REJECT:
break;
case PBOOK_SLEEP_NOW:
printk(KERN_INFO "%s: Airport entering sleep mode\n", ndev->name);
netif_device_detach(ndev);
if (card->open)
dldwd_shutdown(priv);
disable_irq(ndev->irq);
feature_set_airport_power(card->node, 0);
priv->hw_ready = 0;
break;
case PBOOK_WAKE:
printk(KERN_INFO "%s: Airport waking up\n", ndev->name);
feature_set_airport_power(card->node, 1);
mdelay(200);
hermes_reset(&priv->hw);
priv->hw_ready = 1;
rc = dldwd_reset(priv);
if (rc)
printk(KERN_ERR "airport: Error %d re-initing card !\n", rc);
else if (card->open)
netif_device_attach(ndev);
enable_irq(ndev->irq);
break;
}
return PBOOK_SLEEP_OK;
}
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;
}
static int bfin_sir_suspend(struct platform_device *pdev, pm_message_t state)
{
struct bfin_sir_port *sir_port;
struct net_device *dev;
struct bfin_sir_self *self;
sir_port = platform_get_drvdata(pdev);
if (!sir_port)
return 0;
dev = sir_port->dev;
self = netdev_priv(dev);
if (self->open) {
flush_work(&self->work);
bfin_sir_shutdown(self->sir_port, dev);
netif_device_detach(dev);
}
return 0;
}