static int ar9170_usb_flush(struct ar9170 *ar)
{
struct ar9170_usb *aru = (void *) ar;
struct urb *urb;
int ret, err = 0;
if (IS_STARTED(ar))
aru->common.state = AR9170_IDLE;
usb_wait_anchor_empty_timeout(&aru->tx_pending,
msecs_to_jiffies(800));
while ((urb = usb_get_from_anchor(&aru->tx_pending))) {
ar9170_tx_callback(&aru->common, (void *) urb->context);
usb_free_urb(urb);
}
/* lets wait a while until the tx - queues are dried out */
ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
msecs_to_jiffies(100));
if (ret == 0)
err = -ETIMEDOUT;
usb_kill_anchored_urbs(&aru->tx_submitted);
if (IS_ACCEPTING_CMD(ar))
aru->common.state = AR9170_STARTED;
return err;
}
static int carl9170_usb_flush(struct ar9170 *ar)
{
struct urb *urb;
int ret, err = 0;
while ((urb = usb_get_from_anchor(&ar->tx_wait))) {
struct sk_buff *skb = (void *)urb->context;
carl9170_tx_drop(ar, skb);
carl9170_tx_callback(ar, skb);
usb_free_urb(urb);
}
ret = usb_wait_anchor_empty_timeout(&ar->tx_cmd, 1000);
if (ret == 0)
err = -ETIMEDOUT;
/* lets wait a while until the tx - queues are dried out */
ret = usb_wait_anchor_empty_timeout(&ar->tx_anch, 1000);
if (ret == 0)
err = -ETIMEDOUT;
usb_kill_anchored_urbs(&ar->tx_anch);
carl9170_usb_handle_tx_err(ar);
return err;
}
static void bcd2000_init_device(struct bcd2000 *bcd2k)
{
int ret;
init_usb_anchor(&bcd2k->anchor);
usb_anchor_urb(bcd2k->midi_out_urb, &bcd2k->anchor);
usb_anchor_urb(bcd2k->midi_in_urb, &bcd2k->anchor);
/* copy init sequence into buffer */
memcpy(bcd2k->midi_out_buf, bcd2000_init_sequence, 52);
bcd2k->midi_out_urb->transfer_buffer_length = 52;
/* submit sequence */
ret = usb_submit_urb(bcd2k->midi_out_urb, GFP_KERNEL);
if (ret < 0)
dev_err(&bcd2k->dev->dev, PREFIX
"%s: usb_submit_urb() out failed, ret=%d: ",
__func__, ret);
else
bcd2k->midi_out_active = 1;
/* pass URB to device to enable button and controller events */
ret = usb_submit_urb(bcd2k->midi_in_urb, GFP_KERNEL);
if (ret < 0)
dev_err(&bcd2k->dev->dev, PREFIX
"%s: usb_submit_urb() in failed, ret=%d: ",
__func__, ret);
/* ensure initialization is finished */
usb_wait_anchor_empty_timeout(&bcd2k->anchor, 1000);
}
void ctrl_bridge_close(unsigned int id)
{
struct ctrl_bridge *dev;
if (id >= MAX_BRIDGE_DEVICES)
return;
dev = __dev[id];
if (!dev || !dev->brdg)
return;
dev_dbg(&dev->intf->dev, "%s:\n", __func__);
ctrl_bridge_set_cbits(dev->brdg->ch_id, 0);
dev_err(&dev->intf->dev, "%s: usb_wait_anchor_empty_timeout tx_submitted\n", __func__);
usb_wait_anchor_empty_timeout(&dev->tx_submitted, 500);
dev_err(&dev->intf->dev, "%s: tx_submitted usb_anchor_empty:%d\n", __func__, usb_anchor_empty(&dev->tx_submitted));
usb_unlink_anchored_urbs(&dev->tx_submitted);
dev->brdg = NULL;
}
static void retina_draw_down(struct usb_retina *dev)
{
int time;
time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
if (!time)
usb_kill_anchored_urbs(&dev->submitted);
}
static void skel_draw_down(struct usb_skel *dev)
{
int time;
time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
if (!time)
usb_kill_anchored_urbs(&dev->submitted);
usb_kill_urb(dev->bulk_in_urb);
}
static void synccom_draw_down(struct synccom_port *port)
{
int time;
time = usb_wait_anchor_empty_timeout(&port->submitted, 1000);
if (!time)
usb_kill_anchored_urbs(&port->submitted);
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
struct usbnet *unet;
struct rmnet_ctrl_dev *dev;
int time = 0;
int retval = 0;
//htc_dbg
if (get_radio_flag() & 0x0001)
pr_info("%s intf %p\n", __func__, iface);
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;
}
retval = usbnet_suspend(iface, message);
if (!retval) {
if (message.event & PM_EVENT_SUSPEND) {
time = usb_wait_anchor_empty_timeout(&dev->tx_submitted,
1000);
if (!time)
{
pr_info("%s :+usb_kill_anchored_urbs\n", __func__);
usb_kill_anchored_urbs(&dev->tx_submitted);
pr_info("%s :-usb_kill_anchored_urbs\n", __func__);
}
retval = rmnet_usb_ctrl_stop_rx(dev);
iface->dev.power.power_state.event = message.event;
}
/* TBD : do we need to set/clear usbnet->udev->reset_resume*/
} else
dev_err(&iface->dev,
"%s: device is busy can not suspend\n", __func__);
fail:
return retval;
}
static int vstusb_suspend(struct usb_interface *intf, pm_message_t message)
{
struct vstusb_device *vstdev = usb_get_intfdata(intf);
int time;
if (!vstdev)
return 0;
mutex_lock(&vstdev->lock);
time = usb_wait_anchor_empty_timeout(&vstdev->submitted, 1000);
if (!time)
usb_kill_anchored_urbs(&vstdev->submitted);
mutex_unlock(&vstdev->lock);
return 0;
}
static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message)
{
struct usbnet *unet;
struct rmnet_ctrl_dev *dev;
int time = 0;
int retval = 0;
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;
}
retval = usbnet_suspend(iface, message);
if (!retval) {
if (message.event & PM_EVENT_SUSPEND) {
time = usb_wait_anchor_empty_timeout(&dev->tx_submitted,
1000);
if (!time)
usb_kill_anchored_urbs(&dev->tx_submitted);
retval = rmnet_usb_ctrl_stop_rx(dev);
iface->dev.power.power_state.event = message.event;
}
} else
dev_info(&iface->dev,
"%s: device is busy can not suspend\n", __func__);
fail:
return retval;
}
void ctrl_bridge_close(unsigned int id)
{
struct ctrl_bridge *dev;
if (id >= MAX_BRIDGE_DEVICES)
return;
dev = __dev[id];
if (!dev || !dev->brdg)
return;
dev_dbg(&dev->intf->dev, "%s:\n", __func__);
ctrl_bridge_set_cbits(dev->brdg->ch_id, 0);
//(+)12/11/08 p10919 : mdm remotefs hello fail fix by case 01013984
usb_wait_anchor_empty_timeout(&dev->tx_submitted,500);
//(+)12/11/08 p10919
usb_unlink_anchored_urbs(&dev->tx_submitted);
dev->brdg = NULL;
}
static void r92su_usb_disconnect(struct usb_interface *intf)
{
struct r92su *r92su = usb_get_intfdata(intf);
struct urb *urb;
r92su_unregister(r92su);
/* give the disconnect command some time to finish... */
usb_wait_anchor_empty_timeout(&r92su->tx_submitted,
USB_CTRL_SET_TIMEOUT);
/* ... before everything is forcefully terminated */
usb_poison_anchored_urbs(&r92su->tx_submitted);
usb_poison_anchored_urbs(&r92su->rx_submitted);
while ((urb = usb_get_from_anchor(&r92su->tx_wait))) {
kfree_skb(urb->context);
usb_free_urb(urb);
}
r92su_free(r92su);
}
static int rmnet_ctl_release(struct inode *inode, struct file *file)
{
struct ctrl_pkt_list_elem *list_elem = NULL;
struct rmnet_ctrl_dev *dev;
unsigned long flag;
int time;
dev = file->private_data;
if (!dev)
return -ENODEV;
DBG("%s Called on %s device\n", __func__, dev->name);
spin_lock_irqsave(&dev->rx_lock, flag);
while (!list_empty(&dev->rx_list)) {
list_elem = list_first_entry(
&dev->rx_list,
struct ctrl_pkt_list_elem,
list);
list_del(&list_elem->list);
kfree(list_elem->cpkt.data);
kfree(list_elem);
}
spin_unlock_irqrestore(&dev->rx_lock, flag);
mutex_lock(&dev->dev_lock);
dev->is_opened = 0;
mutex_unlock(&dev->dev_lock);
time = usb_wait_anchor_empty_timeout(&dev->tx_submitted,
UNLINK_TIMEOUT_MS);
if (!time)
usb_kill_anchored_urbs(&dev->tx_submitted);
file->private_data = NULL;
return 0;
}
static int rmnet_usb_ctrl_write(struct rmnet_ctrl_dev *dev,
struct ctrl_pkt *cpkt, size_t size)
{
int result;
struct urb *sndurb;
struct usb_ctrlrequest *out_ctlreq;
struct usb_device *udev;
if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status))
return -ENETRESET;
udev = interface_to_usbdev(dev->intf);
sndurb = usb_alloc_urb(0, GFP_KERNEL);
if (!sndurb) {
dev_err(dev->devicep, "Error allocating read urb\n");
return -ENOMEM;
}
out_ctlreq = kmalloc(sizeof(*out_ctlreq), GFP_KERNEL);
if (!out_ctlreq) {
usb_free_urb(sndurb);
dev_err(dev->devicep, "Error allocating setup packet buffer\n");
return -ENOMEM;
}
/* CDC Send Encapsulated Request packet */
out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |
USB_RECIP_INTERFACE);
out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
out_ctlreq->wValue = 0;
out_ctlreq->wIndex = dev->intf->cur_altsetting->desc.bInterfaceNumber;
out_ctlreq->wLength = cpu_to_le16(cpkt->data_size);
usb_fill_control_urb(sndurb, udev,
usb_sndctrlpipe(udev, 0),
(unsigned char *)out_ctlreq, (void *)cpkt->data,
cpkt->data_size, ctrl_write_callback, cpkt);
result = usb_autopm_get_interface(dev->intf);
if (result < 0) {
dev_dbg(dev->devicep, "%s: Unable to resume interface: %d\n",
__func__, result);
/*
* Revisit: if (result == -EPERM)
* rmnet_usb_suspend(dev->intf, PMSG_SUSPEND);
*/
usb_free_urb(sndurb);
kfree(out_ctlreq);
return result;
}
usb_anchor_urb(sndurb, &dev->tx_submitted);
dev->snd_encap_cmd_cnt++;
result = usb_submit_urb(sndurb, GFP_KERNEL);
if (result < 0) {
if (result != -ENODEV)
dev_err(dev->devicep,
"%s: Submit URB error %d\n",
__func__, result);
dev->snd_encap_cmd_cnt--;
usb_autopm_put_interface(dev->intf);
usb_unanchor_urb(sndurb);
usb_free_urb(sndurb);
kfree(out_ctlreq);
return result;
}
if (usb_wait_anchor_empty_timeout(&dev->tx_submitted, 1000) > 0)
return size;
else {
usb_kill_anchored_urbs(&dev->tx_submitted);
return -EAGAIN;
}
}
