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