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;
}
int rmnet_usb_ctrl_start(struct rmnet_ctrl_dev *dev)
{
int status = 0;
mutex_lock(&dev->dev_lock);
if (dev->is_opened)
status = rmnet_usb_ctrl_start_rx(dev);
mutex_unlock(&dev->dev_lock);
return status;
}
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 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 rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
struct usbnet *unet = usb_get_intfdata(iface);
struct rmnet_ctrl_udev *dev;
dev = (struct rmnet_ctrl_udev *)unet->data[1];
if (work_busy(&dev->get_encap_work))
return -EBUSY;
usb_kill_anchored_urbs(&dev->rx_submitted);
if (work_busy(&dev->get_encap_work))
return -EBUSY;
if (usbnet_suspend(iface, message)) {
rmnet_usb_ctrl_start_rx(dev);
return -EBUSY;
}
return 0;
}
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 rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
struct usbnet *unet = usb_get_intfdata(iface);
struct rmnet_ctrl_dev *dev;
int i, n, rdev_cnt, unet_id;
int retval = 0;
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];
spin_lock_irq(&unet->txq.lock);
if (work_busy(&dev->get_encap_work) || unet->txq.qlen) {
spin_unlock_irq(&unet->txq.lock);
retval = -EBUSY;
goto abort_suspend;
}
set_bit(EVENT_DEV_ASLEEP, &unet->flags);
spin_unlock_irq(&unet->txq.lock);
usb_kill_anchored_urbs(&dev->rx_submitted);
if (work_busy(&dev->get_encap_work)) {
spin_lock_irq(&unet->txq.lock);
clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
spin_unlock_irq(&unet->txq.lock);
retval = -EBUSY;
goto abort_suspend;
}
}
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];
netif_device_detach(unet->net);
usbnet_terminate_urbs(unet);
netif_device_attach(unet->net);
}
#if defined(CONFIG_MONITOR_STREAMING_PORT_SOCKET) && defined(CONFIG_MSM_NONSMD_PACKET_FILTER)
if (use_extend_suspend_timer) {
if (original_autosuspend_timer != 0) {
struct usb_device *udev= unet->udev;
if (udev) {
use_extend_suspend_timer= false;
pm_runtime_set_autosuspend_delay(&udev->dev, original_autosuspend_timer);
dev_err(&udev->dev, "is_streaming_sock_connectted:%d pm_runtime_set_autosuspend_delay %d\n", is_streaming_sock_connectted, original_autosuspend_timer);
}
}
}
#endif
return 0;
abort_suspend:
for (i = 0; i < n; i++) {
unet_id = i + 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);
spin_lock_irq(&unet->txq.lock);
clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
spin_unlock_irq(&unet->txq.lock);
}
return retval;
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
struct usbnet *unet = usb_get_intfdata(iface);
struct rmnet_ctrl_dev *dev;
int i, n, rdev_cnt, unet_id;
int retval = 0;
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];
spin_lock_irq(&unet->txq.lock);
if (work_busy(&dev->get_encap_work) || unet->txq.qlen) {
spin_unlock_irq(&unet->txq.lock);
retval = -EBUSY;
goto abort_suspend;
}
set_bit(EVENT_DEV_ASLEEP, &unet->flags);
spin_unlock_irq(&unet->txq.lock);
usb_kill_anchored_urbs(&dev->rx_submitted);
if (work_busy(&dev->get_encap_work)) {
spin_lock_irq(&unet->txq.lock);
clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
spin_unlock_irq(&unet->txq.lock);
retval = -EBUSY;
goto abort_suspend;
}
}
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];
netif_device_detach(unet->net);
usbnet_terminate_urbs(unet);
netif_device_attach(unet->net);
}
return 0;
abort_suspend:
for (i = 0; i < n; i++) {
unet_id = i + 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);
spin_lock_irq(&unet->txq.lock);
clear_bit(EVENT_DEV_ASLEEP, &unet->flags);
spin_unlock_irq(&unet->txq.lock);
}
return retval;
}
int rmnet_usb_ctrl_probe(struct usb_interface *intf,
struct usb_host_endpoint *int_in, struct rmnet_ctrl_dev *dev)
{
u16 wMaxPacketSize;
struct usb_endpoint_descriptor *ep;
struct usb_device *udev;
int interval;
int ret = 0;
udev = interface_to_usbdev(intf);
if (!dev) {
pr_err("%s: Ctrl device not found\n", __func__);
return -ENODEV;
}
dev->int_pipe = usb_rcvintpipe(udev,
int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
mutex_lock(&dev->dev_lock);
dev->intf = intf;
/*TBD: for now just update CD status*/
dev->cbits_tolocal = ACM_CTRL_CD;
/*send DTR high to modem*/
dev->cbits_tomdm = ACM_CTRL_DTR;
mutex_unlock(&dev->dev_lock);
dev->resp_available = false;
dev->snd_encap_cmd_cnt = 0;
dev->get_encap_resp_cnt = 0;
dev->resp_avail_cnt = 0;
dev->tx_ctrl_err_cnt = 0;
dev->set_ctrl_line_state_cnt = 0;
ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
USB_CDC_REQ_SET_CONTROL_LINE_STATE,
(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE),
dev->cbits_tomdm,
dev->intf->cur_altsetting->desc.bInterfaceNumber,
NULL, 0, USB_CTRL_SET_TIMEOUT);
if (ret < 0)
return ret;
dev->set_ctrl_line_state_cnt++;
dev->inturb = usb_alloc_urb(0, GFP_KERNEL);
if (!dev->inturb) {
dev_err(dev->devicep, "Error allocating int urb\n");
return -ENOMEM;
}
/*use max pkt size from ep desc*/
ep = &dev->intf->cur_altsetting->endpoint[0].desc;
wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);
if (!dev->intbuf) {
usb_free_urb(dev->inturb);
dev_err(dev->devicep, "Error allocating int buffer\n");
return -ENOMEM;
}
dev->in_ctlreq->bRequestType =
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
dev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
dev->in_ctlreq->wValue = 0;
dev->in_ctlreq->wIndex =
dev->intf->cur_altsetting->desc.bInterfaceNumber;
dev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH);
interval = max((int)int_in->desc.bInterval,
(udev->speed == USB_SPEED_HIGH) ? HS_INTERVAL
: FS_LS_INTERVAL);
usb_fill_int_urb(dev->inturb, udev,
dev->int_pipe,
dev->intbuf, wMaxPacketSize,
notification_available_cb, dev, interval);
usb_mark_last_busy(udev);
ret = rmnet_usb_ctrl_start_rx(dev);
if (!ret)
dev->is_connected = true;
ctl_msg_dbg_mask = 0;
return ret;
}
int rmnet_usb_ctrl_probe(struct usb_interface *intf,
struct usb_host_endpoint *int_in,
unsigned long rmnet_devnum,
unsigned long *data)
{
struct rmnet_ctrl_dev *dev = NULL;
u16 wMaxPacketSize;
struct usb_endpoint_descriptor *ep;
struct usb_device *udev = interface_to_usbdev(intf);
int interval;
int ret = 0, n;
/* Find next available ctrl_dev */
for (n = 0; n < insts_per_dev; n++) {
dev = &ctrl_devs[rmnet_devnum][n];
if (!dev->claimed)
break;
}
if (!dev || n == insts_per_dev) {
pr_err("%s: No available ctrl devices for %lu\n", __func__,
rmnet_devnum);
return -ENODEV;
}
dev->int_pipe = usb_rcvintpipe(udev,
int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
dev->intf = intf;
dev->id = rmnet_devnum;
dev->snd_encap_cmd_cnt = 0;
dev->get_encap_resp_cnt = 0;
dev->resp_avail_cnt = 0;
dev->tx_ctrl_err_cnt = 0;
dev->set_ctrl_line_state_cnt = 0;
dev->inturb = usb_alloc_urb(0, GFP_KERNEL);
if (!dev->inturb) {
dev_err(dev->devicep, "Error allocating int urb\n");
return -ENOMEM;
}
/*use max pkt size from ep desc*/
ep = &dev->intf->cur_altsetting->endpoint[0].desc;
wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);
if (!dev->intbuf) {
usb_free_urb(dev->inturb);
dev_err(dev->devicep, "Error allocating int buffer\n");
return -ENOMEM;
}
dev->in_ctlreq->bRequestType =
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
dev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
dev->in_ctlreq->wValue = 0;
dev->in_ctlreq->wIndex =
dev->intf->cur_altsetting->desc.bInterfaceNumber;
dev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH);
interval = max((int)int_in->desc.bInterval,
(udev->speed == USB_SPEED_HIGH) ? HS_INTERVAL
: FS_LS_INTERVAL);
usb_fill_int_urb(dev->inturb, udev,
dev->int_pipe,
dev->intbuf, wMaxPacketSize,
notification_available_cb, dev, interval);
usb_mark_last_busy(udev);
ret = rmnet_usb_ctrl_start_rx(dev);
if (ret) {
usb_free_urb(dev->inturb);
kfree(dev->intbuf);
return ret;
}
ctl_msg_dbg_mask = MSM_USB_CTL_DUMP_BUFFER;
dev->claimed = true;
/*mux info is passed to data parameter*/
if (*data)
set_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status);
*data = (unsigned long)dev;
/* If MUX is enabled, wakeup the open process here */
if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status)) {
set_bit(RMNET_CTRL_DEV_READY, &dev->status);
wake_up(&dev->open_wait_queue);
}
return 0;
}
int rmnet_usb_ctrl_probe(struct usb_interface *intf,
struct usb_host_endpoint *int_in,
unsigned long rmnet_devnum,
unsigned long *data)
{
struct rmnet_ctrl_udev *cudev;
struct rmnet_ctrl_dev *dev = NULL;
u16 wMaxPacketSize;
struct usb_endpoint_descriptor *ep;
struct usb_device *udev = interface_to_usbdev(intf);
int interval;
int ret = 0, n;
/* Find next available ctrl_dev */
for (n = 0; n < insts_per_dev; n++) {
dev = &ctrl_devs[rmnet_devnum][n];
if (!dev->claimed)
break;
}
if (!dev || n == insts_per_dev) {
pr_err("%s: No available ctrl devices for %lu\n", __func__,
rmnet_devnum);
return -ENODEV;
}
cudev = dev->cudev;
cudev->int_pipe = usb_rcvintpipe(udev,
int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
cudev->intf = intf;
cudev->inturb = usb_alloc_urb(0, GFP_KERNEL);
if (!cudev->inturb) {
dev_err(&intf->dev, "Error allocating int urb\n");
kfree(cudev);
return -ENOMEM;
}
/*use max pkt size from ep desc*/
ep = &cudev->intf->cur_altsetting->endpoint[0].desc;
wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
cudev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);
if (!cudev->intbuf) {
usb_free_urb(cudev->inturb);
kfree(cudev);
dev_err(&intf->dev, "Error allocating int buffer\n");
return -ENOMEM;
}
cudev->in_ctlreq->bRequestType =
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
cudev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
cudev->in_ctlreq->wValue = 0;
cudev->in_ctlreq->wIndex =
cudev->intf->cur_altsetting->desc.bInterfaceNumber;
cudev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH);
interval = int_in->desc.bInterval;
usb_fill_int_urb(cudev->inturb, udev,
cudev->int_pipe,
cudev->intbuf, wMaxPacketSize,
notification_available_cb, cudev, interval);
usb_mark_last_busy(udev);
mutex_init(&cudev->udev_lock);
ret = rmnet_usb_ctrl_start_rx(cudev);
if (ret) {
usb_free_urb(cudev->inturb);
kfree(cudev->intbuf);
kfree(cudev);
return ret;
}
*data = (unsigned long)cudev;
/* If MUX is enabled, wakeup the open process here */
if (test_bit(RMNET_CTRL_DEV_MUX_EN, &cudev->status)) {
set_bit(RMNET_CTRL_DEV_READY, &cudev->status);
for (n = 0; n < insts_per_dev; n++) {
dev = &ctrl_devs[rmnet_devnum][n];
wake_up(&dev->open_wait_queue);
}
} else {
cudev->ctrldev_id = n;
dev->claimed = true;
}
return 0;
}
