static int rmnet_ctrl_tiocmset(struct rmnet_ctrl_dev *dev, unsigned int set,
unsigned int clear)
{
int retval;
mutex_lock(&dev->dev_lock);
if (set & TIOCM_DTR)
dev->cbits_tomdm |= ACM_CTRL_DTR;
if (clear & TIOCM_DTR)
dev->cbits_tomdm &= ~ACM_CTRL_DTR;
mutex_unlock(&dev->dev_lock);
retval = usb_autopm_get_interface(dev->intf);
if (retval < 0) {
dev_err(dev->devicep, "%s: Unable to resume interface: %d\n",
__func__, retval);
return retval;
}
retval = rmnet_usb_ctrl_write_cmd(dev);
usb_autopm_put_interface(dev->intf);
return retval;
}
static int rmnet_ctrl_tiocmset(struct rmnet_ctrl_dev *dev, unsigned int set,
unsigned int clear)
{
int retval;
mutex_lock(&dev->dev_lock);
if (set & TIOCM_DTR)
dev->cbits_tomdm |= ACM_CTRL_DTR;
/*
* TBD if (set & TIOCM_RTS)
* dev->cbits_tomdm |= ACM_CTRL_RTS;
*/
if (clear & TIOCM_DTR)
dev->cbits_tomdm &= ~ACM_CTRL_DTR;
/*
* (clear & TIOCM_RTS)
* dev->cbits_tomdm &= ~ACM_CTRL_RTS;
*/
mutex_unlock(&dev->dev_lock);
#ifdef CONFIG_QCT_9K_MODEM
retval = usb_autopm_get_interface(dev->cudev->intf);
if (retval < 0) {
dev_dbg(dev->devicep, "%s: Unable to resume interface: %d\n", __func__, retval);
return retval;
}
retval = rmnet_usb_ctrl_write_cmd(dev);
usb_autopm_put_interface(dev->cudev->intf);
#else
retval = rmnet_usb_ctrl_write_cmd(dev->cudev,
USB_CDC_REQ_SET_CONTROL_LINE_STATE, 0, NULL, 0);
if (!retval)
dev->cudev->set_ctrl_line_state_cnt++;
#endif
return retval;
}
static int rmnet_ctrl_tiocmset(struct rmnet_ctrl_dev *dev, unsigned int set,
unsigned int clear)
{
mutex_lock(&dev->dev_lock);
if (set & TIOCM_DTR)
dev->cbits_tomdm |= ACM_CTRL_DTR;
/*
* TBD if (set & TIOCM_RTS)
* dev->cbits_tomdm |= ACM_CTRL_RTS;
*/
if (clear & TIOCM_DTR)
dev->cbits_tomdm &= ~ACM_CTRL_DTR;
/*
* (clear & TIOCM_RTS)
* dev->cbits_tomdm &= ~ACM_CTRL_RTS;
*/
mutex_unlock(&dev->dev_lock);
return rmnet_usb_ctrl_write_cmd(dev);
}
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;
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);
ret = rmnet_usb_ctrl_write_cmd(dev);
if (ret < 0)
return ret;
return rmnet_usb_ctrl_start_rx(dev);
}
static ssize_t rmnet_ctl_write(struct file *file, const char __user * buf,
size_t size, loff_t *pos)
{
int status;
size_t total_len;
void *wbuf;
void *actual_data;
struct ctrl_pkt *cpkt;
struct rmnet_ctrl_dev *dev = file->private_data;
if (!dev)
return -ENODEV;
if (size <= 0)
return -EINVAL;
if (!test_bit(RMNET_CTRL_DEV_READY, &dev->cudev->status))
return -ENETRESET;
DBG("%s: Writing %i bytes on %s\n", __func__, size, dev->name);
#ifdef CONFIG_QCT_9K_MODEM
if (get_radio_flag() & RADIO_FLAG_MORE_LOG)
pr_info("[RMNET] W: %i\n", size);
#endif
total_len = size;
if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status))
total_len += sizeof(struct mux_hdr) + MAX_PAD_BYTES(4);
wbuf = kmalloc(total_len , GFP_KERNEL);
if (!wbuf)
return -ENOMEM;
cpkt = kmalloc(sizeof(struct ctrl_pkt), GFP_KERNEL);
if (!cpkt) {
kfree(wbuf);
return -ENOMEM;
}
actual_data = cpkt->data = wbuf;
cpkt->data_size = total_len;
cpkt->ctxt = dev;
if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status)) {
actual_data = wbuf + sizeof(struct mux_hdr);
rmnet_usb_ctrl_mux(dev->ch_id, cpkt);
}
status = copy_from_user(actual_data, buf, size);
if (status) {
dev_err(dev->devicep,
"%s: Unable to copy data from userspace %d\n",
__func__, status);
kfree(wbuf);
kfree(cpkt);
return status;
}
DUMP_BUFFER("Write: ", size, buf);
#ifdef CONFIG_QCT_9K_MODEM
status = rmnet_usb_ctrl_write(dev, cpkt, size);
if (status == size)
return size;
else
pr_err("[%s] status %d\n", __func__, status);
#else
status = rmnet_usb_ctrl_write_cmd(dev->cudev,
USB_CDC_SEND_ENCAPSULATED_COMMAND, 0, cpkt->data,
cpkt->data_size);
if (status > 0)
dev->cudev->snd_encap_cmd_cnt++;
kfree(cpkt->data);
kfree(cpkt);
#endif
return status;
}
