static int nmclan_resume(struct pcmcia_device *link) { struct net_device *dev = link->priv; if (link->open) { nmclan_reset(dev); netif_device_attach(dev); } return 0; }
static int emac_resume(struct platform_device *dev) { struct net_device *ndev = platform_get_drvdata(dev); struct emac_board_info *db = netdev_priv(ndev); emac_reset(db); emac_init_device(ndev); netif_device_attach(ndev); return 0; }
int rtw_resume_process(_adapter *padapter) { struct net_device *pnetdev; struct pwrctrl_priv *pwrpriv; u8 is_pwrlock_hold_by_caller; u8 is_directly_called_by_auto_resume; int ret = 0; u32 start_time = rtw_get_current_time(); _func_enter_; DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid); if(padapter) { pnetdev= padapter->pnetdev; pwrpriv = &padapter->pwrctrlpriv; } else { ret =-1; goto exit; } rtw_reset_drv_sw(padapter); pwrpriv->bkeepfwalive = _FALSE; DBG_871X("bkeepfwalive(%x)\n",pwrpriv->bkeepfwalive); if(pm_netdev_open(pnetdev,_TRUE) != 0) { ret = -1; goto exit; } netif_device_attach(pnetdev); netif_carrier_on(pnetdev); if( padapter->pid[1]!=0) { DBG_871X("pid[1]:%d\n",padapter->pid[1]); rtw_signal_process(padapter->pid[1], SIGUSR2); } #ifdef CONFIG_LAYER2_ROAMING_RESUME rtw_roaming(padapter, NULL); #endif #ifdef CONFIG_RESUME_IN_WORKQUEUE rtw_unlock_suspend(); #endif //CONFIG_RESUME_IN_WORKQUEUE exit: DBG_871X("<=== %s return %d.............. in %dms\n", __FUNCTION__ , ret, rtw_get_passing_time_ms(start_time)); _func_exit_; return ret; }
static int airo_resume(struct pcmcia_device *link) { local_info_t *local = link->priv; if (link->open) { reset_airo_card(local->eth_dev); netif_device_attach(local->eth_dev); } 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 pcnet_resume(struct pcmcia_device *link) { struct net_device *dev = link->priv; if (link->open) { pcnet_reset_8390(dev); NS8390_init(dev, 1); netif_device_attach(dev); } return 0; }
/* Coming out of suspend, so reset hardware */ static int ksdazzle_resume(struct usb_interface *intf) { struct ksdazzle_cb *kingsun = usb_get_intfdata(intf); if (kingsun->rx_urb != NULL) { /* Setup request already filled in ksdazzle_probe */ usb_submit_urb(kingsun->rx_urb, GFP_KERNEL); } netif_device_attach(kingsun->netdev); return 0; }
static int prism2_usb_resume(struct usb_interface *interface) { struct net_device *dev = usb_get_intfdata(interface); prism2_hw_config(dev, 0); if (netif_running(dev)) { netif_device_attach(dev); netif_start_queue(dev); } return 0; }
static int spectrum_cs_resume(struct pcmcia_device *link) { struct net_device *dev = link->priv; struct orinoco_private *priv = netdev_priv(dev); netif_device_attach(dev); priv->hw_unavailable--; schedule_work(&priv->reset_work); return 0; }
static int rtl8169_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); if (!netif_running(dev)) return 0; netif_device_attach(dev); rtl8169_hw_start(dev); return 0; }
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; }
int dsa_slave_resume(struct net_device *slave_dev) { struct dsa_slave_priv *p = netdev_priv(slave_dev); netif_device_attach(slave_dev); if (p->phy) { phy_resume(p->phy); phy_start(p->phy); } return 0; }
static int at91ether_resume(struct platform_device *pdev) { struct net_device *net_dev = platform_get_drvdata(pdev); struct macb *lp = netdev_priv(net_dev); if (netif_running(net_dev)) { clk_enable(lp->pclk); netif_device_attach(net_dev); netif_start_queue(net_dev); } return 0; }
static int pxa_irda_resume(struct platform_device *_dev) { struct net_device *dev = platform_get_drvdata(_dev); struct pxa_irda *si; if (dev && netif_running(dev)) { si = netdev_priv(dev); pxa_irda_startup(si); netif_device_attach(dev); netif_wake_queue(dev); } return 0; }
static int r871x_resume(struct usb_interface *pusb_intf) { struct net_device *pnetdev = usb_get_intfdata(pusb_intf); printk(KERN_INFO "r8712: resuming...\n"); if (!pnetdev || !netif_running(pnetdev)) { printk(KERN_INFO "r8712: unable to resume\n"); return 0; } netif_device_attach(pnetdev); if (pnetdev->netdev_ops->ndo_open) pnetdev->netdev_ops->ndo_open(pnetdev); return 0; }
int lbs_resume(struct lbs_private *priv) { int ret; ret = lbs_set_host_sleep(priv, 0); netif_device_attach(priv->dev); if (priv->mesh_dev) netif_device_attach(priv->mesh_dev); if (priv->deep_sleep_required) { priv->deep_sleep_required = 0; ret = lbs_set_deep_sleep(priv, 1); if (ret) netdev_err(priv->dev, "deep sleep activation failed: %d\n", ret); } if (priv->setup_fw_on_resume) ret = lbs_setup_firmware(priv); return ret; }
static int r871x_resume(struct usb_interface *pusb_intf) { struct net_device *pnetdev = usb_get_intfdata(pusb_intf); netdev_info(pnetdev, "Resuming...\n"); if (!pnetdev || !netif_running(pnetdev)) { netdev_info(pnetdev, "Unable to resume\n"); return 0; } netif_device_attach(pnetdev); if (pnetdev->netdev_ops->ndo_open) pnetdev->netdev_ops->ndo_open(pnetdev); return 0; }
static int orinoco_plx_open(struct net_device *dev) { struct orinoco_private *priv = (struct orinoco_private *) dev->priv; int err; netif_device_attach(dev); err = orinoco_reset(priv); if (err) printk(KERN_ERR "%s: orinoco_reset failed in orinoco_plx_open()", dev->name); else netif_start_queue(dev); return err; }
static int nmclan_resume(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) { pcmcia_request_configuration(link->handle, &link->conf); if (link->open) { nmclan_reset(dev); netif_device_attach(dev); } } return 0; }
static int rtw_resume(struct usb_interface *pusb_intf) { struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf); struct rtw_adapter *padapter = dvobj->if1; struct net_device *pnetdev; struct pwrctrl_priv *pwrpriv = NULL; int ret = -1; unsigned long start_time = jiffies; DBG_8723A("==> %s (%s:%d)\n", __func__, current->comm, current->pid); if (!padapter) goto exit; pnetdev = padapter->pnetdev; pwrpriv = &padapter->pwrctrlpriv; down(&pwrpriv->lock); rtw_reset_drv_sw23a(padapter); pwrpriv->bkeepfwalive = false; DBG_8723A("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive); if (pm_netdev_open23a(pnetdev, true) != 0) { up(&pwrpriv->lock); goto exit; } netif_device_attach(pnetdev); netif_carrier_on(pnetdev); up(&pwrpriv->lock); if (padapter->pid[1] != 0) { DBG_8723A("pid[1]:%d\n", padapter->pid[1]); kill_pid(find_vpid(padapter->pid[1]), SIGUSR2, 1); } rtw23a_roaming(padapter, NULL); ret = 0; exit: if (pwrpriv) pwrpriv->bInSuspend = false; DBG_8723A("<=== %s return %d.............. in %dms\n", __func__, ret, jiffies_to_msecs(jiffies - start_time)); return ret; }
static int awc_event(event_t event, int priority, event_callback_args_t *args) { dev_link_t *link = args->client_data; struct net_device *dev = link->priv; PC_DEBUG(1, "awc_event(0x%06x)\n", event); switch (event) { case CS_EVENT_CARD_REMOVAL: link->state &= ~DEV_PRESENT; if (link->state & DEV_CONFIG) { netif_device_detach(dev); link->release.expires = RUN_AT( HZ/20 ); add_timer(&link->release); } break; case CS_EVENT_CARD_INSERTION: link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; awc_pcmcia_config(link); break; case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; /* Fall through... */ case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { if (link->open) netif_device_detach(dev); CardServices(ReleaseConfiguration, link->handle); } break; case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; /* Fall through... */ case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { CardServices(RequestConfiguration, link->handle, &link->conf); if (link->open) { // awc_reset(dev); netif_device_attach(dev); } } break; } return 0; } /* awc_event */
static int tc589_event(event_t event, int priority, event_callback_args_t *args) { dev_link_t *link = args->client_data; struct el3_private *lp = link->priv; struct net_device *dev = &lp->dev; DEBUG(1, "3c589_event(0x%06x)\n", event); switch (event) { case CS_EVENT_CARD_REMOVAL: link->state &= ~DEV_PRESENT; if (link->state & DEV_CONFIG) { netif_device_detach(dev); mod_timer(&link->release, jiffies + HZ/20); } break; case CS_EVENT_CARD_INSERTION: link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; tc589_config(link); break; case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; /* Fall through... */ case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { if (link->open) netif_device_detach(dev); CardServices(ReleaseConfiguration, link->handle); } break; case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; /* Fall through... */ case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { CardServices(RequestConfiguration, link->handle, &link->conf); if (link->open) { tc589_reset(dev); netif_device_attach(dev); } } break; } return 0; } /* tc589_event */
static int r871x_resume(struct usb_interface *pusb_intf) { struct net_device *pnetdev = usb_get_intfdata(pusb_intf); struct _adapter *padapter = netdev_priv(pnetdev); netdev_info(pnetdev, "Resuming...\n"); if (!pnetdev || !netif_running(pnetdev)) { netdev_info(pnetdev, "Unable to resume\n"); return 0; } netif_device_attach(pnetdev); if (pnetdev->netdev_ops->ndo_open) pnetdev->netdev_ops->ndo_open(pnetdev); padapter->bSuspended = false; rtl871x_intf_resume(padapter); return 0; }
static int rt2870_resume(struct usb_interface *intf) { struct net_device *net_dev; struct rt_rtmp_adapter *pAd = usb_get_intfdata(intf); DBGPRINT(RT_DEBUG_TRACE, ("===> rt2870_resume()\n")); pAd->PM_FlgSuspend = 0; net_dev = 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 ti_hecc_resume(struct platform_device *pdev) { struct net_device *dev = platform_get_drvdata(pdev); struct ti_hecc_priv *priv = netdev_priv(dev); clk_enable(priv->clk); hecc_clear_bit(priv, HECC_CANMC, HECC_CANMC_PDR); priv->can.state = CAN_STATE_ERROR_ACTIVE; if (netif_running(dev)) { netif_device_attach(dev); netif_start_queue(dev); } return 0; }
/** * ks8695_drv_resume - Resume a KS8695 ethernet platform device. * @pdev: The device to resume * * This routine re-initialises and re-attaches a KS8695 ethernet * device. */ static int ks8695_drv_resume(struct platform_device *pdev) { struct net_device *ndev = platform_get_drvdata(pdev); struct ks8695_priv *ksp = netdev_priv(ndev); if (netif_running(ndev)) { ks8695_reset(ksp); ks8695_init_net(ksp); ks8695_set_multicast(ndev); netif_device_attach(ndev); } ksp->in_suspend = 0; return 0; }
static int rtw_resume_process(struct adapter *padapter) { struct net_device *pnetdev; struct pwrctrl_priv *pwrpriv = NULL; int ret = -1; u32 start_time = jiffies; DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid); if (padapter) { pnetdev = padapter->pnetdev; pwrpriv = &padapter->pwrctrlpriv; } else { goto exit; } _enter_pwrlock(&pwrpriv->lock); rtw_reset_drv_sw(padapter); pwrpriv->bkeepfwalive = false; DBG_88E("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive); if (pm_netdev_open(pnetdev, true) != 0) goto exit; netif_device_attach(pnetdev); netif_carrier_on(pnetdev); _exit_pwrlock(&pwrpriv->lock); if (padapter->pid[1] != 0) { DBG_88E("pid[1]:%d\n", padapter->pid[1]); rtw_signal_process(padapter->pid[1], SIGUSR2); } rtw_roaming(padapter, NULL); ret = 0; exit: if (pwrpriv) pwrpriv->bInSuspend = false; DBG_88E("<=== %s return %d.............. in %dms\n", __func__, ret, rtw_get_passing_time_ms(start_time)); return ret; }
static int prism2_pci_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct hostap_interface *iface = dev->priv; local_info_t *local = iface->local; pci_enable_device(pdev); #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,6)) pci_restore_state(pdev, local->pci_save_state); #endif prism2_hw_config(dev, 0); if (netif_running(dev)) { netif_device_attach(dev); netif_start_queue(dev); } 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; }
int rtl8192E_resume(struct pci_dev *pdev) { struct net_device *dev = pci_get_drvdata(pdev); struct r8192_priv *priv = rtllib_priv(dev); int err; u32 val; netdev_info(dev, "================>r8192E resume call.\n"); pci_set_power_state(pdev, PCI_D0); err = pci_enable_device(pdev); if (err) { netdev_err(dev, "pci_enable_device failed on resume\n"); return err; } pci_restore_state(pdev); pci_read_config_dword(pdev, 0x40, &val); if ((val & 0x0000ff00) != 0) pci_write_config_dword(pdev, 0x40, val & 0xffff00ff); pci_enable_wake(pdev, PCI_D0, 0); if (priv->polling_timer_on == 0) check_rfctrl_gpio_timer((unsigned long)dev); if (!netif_running(dev)) { netdev_info(dev, "RTL819XE:UI is open out of resume function\n"); goto out; } netif_device_attach(dev); if (dev->netdev_ops->ndo_open) dev->netdev_ops->ndo_open(dev); if (!priv->rtllib->bSupportRemoteWakeUp) MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_INIT, true); out: RT_TRACE(COMP_POWER, "<================r8192E resume call.\n"); return 0; }