static int cdc_mbim_suspend(struct usb_interface *intf, pm_message_t message) { int ret = -ENODEV; struct usbnet *dev = usb_get_intfdata(intf); struct cdc_mbim_state *info = (void *)&dev->data; struct cdc_ncm_ctx *ctx = info->ctx; if (!ctx) goto error; /* * Both usbnet_suspend() and subdriver->suspend() MUST return 0 * in system sleep context, otherwise, the resume callback has * to recover device from previous suspend failure. */ ret = usbnet_suspend(intf, message); if (ret < 0) goto error; if (intf == ctx->control && info->subdriver && info->subdriver->suspend) ret = info->subdriver->suspend(intf, message); if (ret < 0) usbnet_resume(intf); error: return ret; }
static int huawei_cdc_ncm_suspend(struct usb_interface *intf, pm_message_t message) { int ret = 0; struct usbnet *usbnet_dev = usb_get_intfdata(intf); struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data; struct cdc_ncm_ctx *ctx = drvstate->ctx; if (ctx == NULL) { ret = -ENODEV; goto error; } ret = usbnet_suspend(intf, message); if (ret < 0) goto error; if (intf == ctx->control && drvstate->subdriver && drvstate->subdriver->suspend) ret = drvstate->subdriver->suspend(intf, message); if (ret < 0) usbnet_resume(intf); error: return ret; }
static int rmnet_usb_resume(struct usb_interface *iface) { int retval = 0; int oldstate; struct usbnet *unet; struct rmnet_ctrl_dev *dev; unet = usb_get_intfdata(iface); if (!unet) { pr_err("%s:data device not found\n", __func__); retval = -ENODEV; goto fail; } dev = (struct rmnet_ctrl_dev *)unet->data[1]; if (!dev) { dev_err(&iface->dev, "%s: ctrl device not found\n", __func__); retval = -ENODEV; goto fail; } oldstate = iface->dev.power.power_state.event; iface->dev.power.power_state.event = PM_EVENT_ON; retval = usbnet_resume(iface); if (!retval) { if (oldstate & PM_EVENT_SUSPEND) retval = rmnet_usb_ctrl_start_rx(dev); } fail: return retval; }
static int rmnet_usb_resume(struct usb_interface *iface) { struct usbnet *unet = usb_get_intfdata(iface); struct rmnet_ctrl_udev *dev; dev = (struct rmnet_ctrl_udev *)unet->data[1]; usbnet_resume(iface); return rmnet_usb_ctrl_start_rx(dev); }
static int rmnet_usb_resume(struct usb_interface *iface) { int retval = 0; struct usbnet *unet; struct rmnet_ctrl_dev *dev; unet = usb_get_intfdata(iface); dev = (struct rmnet_ctrl_dev *)unet->data[1]; usbnet_resume(iface); retval = rmnet_usb_ctrl_start_rx(dev); return retval; }
static int qmi_wwan_resume(struct usb_interface *intf) { struct usbnet *dev = usb_get_intfdata(intf); struct qmi_wwan_state *info = (void *)&dev->data; int ret = 0; if (info->subdriver && info->subdriver->resume) ret = info->subdriver->resume(intf); if (ret < 0) goto err; ret = usbnet_resume(intf); if (ret < 0 && info->subdriver && info->subdriver->resume && info->subdriver->suspend) info->subdriver->suspend(intf, PMSG_SUSPEND); err: return ret; }
static int qmi_wwan_resume(struct usb_interface *intf) { struct usbnet *dev = usb_get_intfdata(intf); struct usb_driver *subdriver = (void *)dev->data[0]; int ret = 0; if (subdriver && subdriver->resume) ret = subdriver->resume(intf); if (ret < 0) goto err; ret = usbnet_resume(intf); if (ret < 0 && subdriver && subdriver->resume && subdriver->suspend) subdriver->suspend(intf, PMSG_SUSPEND); err: return ret; }
/* suspend/resume wrappers calling both usbnet and the cdc-wdm * subdriver if present. * * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide * wrappers for those without adding usbnet reset support first. */ static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message) { struct usbnet *dev = usb_get_intfdata(intf); struct usb_driver *subdriver = (void *)dev->data[0]; int ret; ret = usbnet_suspend(intf, message); if (ret < 0) goto err; if (subdriver && subdriver->suspend) ret = subdriver->suspend(intf, message); if (ret < 0) usbnet_resume(intf); err: return ret; }
/* suspend/resume wrappers calling both usbnet and the cdc-wdm * subdriver if present. * * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide * wrappers for those without adding usbnet reset support first. */ static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message) { struct usbnet *dev = usb_get_intfdata(intf); struct qmi_wwan_state *info = (void *)&dev->data; int ret; ret = usbnet_suspend(intf, message); if (ret < 0) goto err; if (intf == info->control && info->subdriver && info->subdriver->suspend) ret = info->subdriver->suspend(intf, message); if (ret < 0) usbnet_resume(intf); err: return ret; }
static int cdc_mbim_resume(struct usb_interface *intf) { int ret = 0; struct usbnet *dev = usb_get_intfdata(intf); struct cdc_mbim_state *info = (void *)&dev->data; struct cdc_ncm_ctx *ctx = info->ctx; bool callsub = (intf == ctx->control && info->subdriver && info->subdriver->resume); if (callsub) ret = info->subdriver->resume(intf); if (ret < 0) goto err; ret = usbnet_resume(intf); if (ret < 0 && callsub) info->subdriver->suspend(intf, PMSG_SUSPEND); err: return ret; }
static int rmnet_usb_resume(struct usb_interface *iface) { int retval = 0; struct usbnet *unet; struct rmnet_ctrl_dev *dev; char *resumed[2] = {"QMI_STATE=RESUMED", NULL}; unet = usb_get_intfdata(iface); dev = (struct rmnet_ctrl_dev *)unet->data[1]; usbnet_resume(iface); retval = rmnet_usb_ctrl_start_rx(dev); kobject_uevent_env(&dev->devicep->kobj, KOBJ_CHANGE, resumed); return retval; }
static int rmnet_usb_resume(struct usb_interface *iface) { int retval = 0; struct usbnet *unet; struct rmnet_ctrl_dev *dev; pr_debug("%s", __func__); unet = usb_get_intfdata(iface); dev = (struct rmnet_ctrl_dev *)unet->data[1]; usbnet_resume(iface); if (work_busy(&dev->get_encap_work)) { pr_debug("%s ret", __func__); return 0; } retval = rmnet_usb_ctrl_start_rx(dev); return retval; }
static int cdc_ether_resume(struct usb_interface *intf) { int ret; #ifdef CONFIG_HAS_WAKELOCK struct usbnet *dev = usb_get_intfdata(intf); struct cdc_state *info = (void *) &dev->data; #endif /* CONFIG_HAS_WAKELOCK */ ret = usbnet_resume(intf); #ifdef CONFIG_HAS_WAKELOCK if (!ret && dev->driver_info->flags & FLAG_WAKELOCK) { wake_lock(&info->wake_lock); } #endif /* CONFIG_HAS_WAKELOCK */ /* Force autopm to schedule an auto suspend */ usb_autopm_get_interface_no_resume(intf); usb_autopm_put_interface_async(intf); return ret; }
/* suspend/resume wrappers calling both usbnet and the cdc-wdm * subdriver if present. * * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide * wrappers for those without adding usbnet reset support first. */ static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message) { struct usbnet *dev = usb_get_intfdata(intf); struct qmi_wwan_state *info = (void *)&dev->data; int ret; /* Both usbnet_suspend() and subdriver->suspend() MUST return 0 * in system sleep context, otherwise, the resume callback has * to recover device from previous suspend failure. */ ret = usbnet_suspend(intf, message); if (ret < 0) goto err; if (intf == info->control && info->subdriver && info->subdriver->suspend) ret = info->subdriver->suspend(intf, message); if (ret < 0) usbnet_resume(intf); err: return ret; }
static int rmnet_usb_resume(struct usb_interface *iface) { struct usbnet *unet = usb_get_intfdata(iface); struct rmnet_ctrl_dev *dev; int n, rdev_cnt, unet_id; rdev_cnt = unet->data[4] ? no_rmnet_insts_per_dev : 1; for (n = 0; n < rdev_cnt; n++) { unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev; unet = unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface); dev = (struct rmnet_ctrl_dev *)unet->data[1]; rmnet_usb_ctrl_start_rx(dev); usb_set_intfdata(iface, unet); unet->suspend_count = 1; usbnet_resume(iface); } return 0; }
static int huawei_cdc_ncm_resume(struct usb_interface *intf) { int ret = 0; struct usbnet *usbnet_dev = usb_get_intfdata(intf); struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data; bool callsub; struct cdc_ncm_ctx *ctx = drvstate->ctx; /* should we call subdriver's resume function? */ callsub = (intf == ctx->control && drvstate->subdriver && drvstate->subdriver->resume); if (callsub) ret = drvstate->subdriver->resume(intf); if (ret < 0) goto err; ret = usbnet_resume(intf); if (ret < 0 && callsub) drvstate->subdriver->suspend(intf, PMSG_SUSPEND); err: return ret; }
static int cdc_mbim_suspend(struct usb_interface *intf, pm_message_t message) { int ret = 0; struct usbnet *dev = usb_get_intfdata(intf); struct cdc_mbim_state *info = (void *)&dev->data; struct cdc_ncm_ctx *ctx = info->ctx; if (ctx == NULL) { ret = -1; goto error; } ret = usbnet_suspend(intf, message); if (ret < 0) goto error; if (intf == ctx->control && info->subdriver && info->subdriver->suspend) ret = info->subdriver->suspend(intf, message); if (ret < 0) usbnet_resume(intf); error: return ret; }
/*=========================================================================== METHOD: GobiNetResume (Public Method) DESCRIPTION: Resume QMI traffic or recreate QMI device PARAMETERS pIntf [ I ] - Pointer to interface RETURN VALUE: int - 0 for success negative errno for failure ===========================================================================*/ int GobiNetResume( struct usb_interface * pIntf ) { struct usbnet * pDev; sGobiUSBNet * pGobiDev; int nRet; int oldPowerState; if (pIntf == 0) { return -ENOMEM; } #if (LINUX_VERSION_CODE > KERNEL_VERSION( 2,6,23 )) pDev = usb_get_intfdata( pIntf ); #else pDev = (struct usbnet *)pIntf->dev.platform_data; #endif if (pDev == NULL || pDev->net == NULL) { DBG( "failed to get netdevice\n" ); return -ENXIO; } pGobiDev = (sGobiUSBNet *)pDev->data[0]; if (pGobiDev == NULL) { DBG( "failed to get QMIDevice\n" ); return -ENXIO; } oldPowerState = pIntf->dev.power.power_state.event; pIntf->dev.power.power_state.event = PM_EVENT_ON; DBG( "resuming from power mode %d\n", oldPowerState ); if (oldPowerState & PM_EVENT_SUSPEND) { // It doesn't matter if this is autoresume or system resume GobiClearDownReason( pGobiDev, DRIVER_SUSPENDED ); nRet = usbnet_resume( pIntf ); if (nRet != 0) { DBG( "usbnet_resume error %d\n", nRet ); return nRet; } // Restart QMI read callbacks nRet = StartRead( pGobiDev ); if (nRet != 0) { DBG( "StartRead error %d\n", nRet ); return nRet; } // Kick Auto PM thread to process any queued URBs complete( &pGobiDev->mAutoPM.mThreadDoWork ); } else { DBG( "nothing to resume\n" ); return 0; } return nRet; }