static int
uvc_video_enable(struct uvc_video *video, int enable)
{
unsigned int i;
int ret;
if (video->ep == NULL) {
printk(KERN_INFO "Video enable failed, device is "
"uninitialized.\n");
return -ENODEV;
}
if (!enable) {
for (i = 0; i < UVC_NUM_REQUESTS; ++i)
usb_ep_dequeue(video->ep, video->req[i]);
uvc_video_free_requests(video);
uvc_queue_enable(&video->queue, 0);
return 0;
}
if ((ret = uvc_queue_enable(&video->queue, 1)) < 0)
return ret;
if ((ret = uvc_video_alloc_requests(video)) < 0)
return ret;
if (video->max_payload_size) {
video->encode = uvc_video_encode_bulk;
video->payload_size = 0;
} else
video->encode = uvc_video_encode_isoc;
return uvc_video_pump(video);
}
static void dtf_function_disable(struct usb_function *f)
{
struct dtf_dev *dev = func_to_dtf(f);
int speed_check;
_dbgmsg( "IN\n" );
if( dev->mCtrl_ep_enbl == 1 )
{
dev->mCtrl_ep_enbl = 0;
_dbgmsg_gadget( "usb_ep_disable(%s)\n", dev->pg.ep_intr->name );
usb_ep_disable( dev->pg.ep_intr );
}
if( dev->mData_ep_enbl == 1 )
{
dev->mData_ep_enbl = 0;
_dbgmsg_gadget( "usb_ep_dequeue\n" );
usb_ep_dequeue( dev->pg.ep_out, dev->pg.mReq_out );
_dbgmsg_gadget( "usb_ep_disable(%s)\n", dev->pg.ep_intr->name );
usb_ep_disable( dev->pg.ep_in );
_dbgmsg_gadget( "usb_ep_disable(%s)\n", dev->pg.ep_out->name );
usb_ep_disable( dev->pg.ep_out );
}
speed_check = (_dtf_dev->cdev->gadget->speed == USB_SPEED_HIGH)?(1):(0);
dtf_if_out_disable(speed_check);
_dbgmsg( "OUT\n" );
}
static void hub_interrupt_transmit (struct psfreedom_device *dev)
{
struct usb_ep *ep = dev->hub_ep;
struct usb_request *req = dev->hub_req;
u8 data = 0;
int i;
if (!ep)
return;
if (!req) {
req = alloc_ep_req(ep, USB_BUFSIZ);
dev->hub_req = req;
}
if (!req) {
ERROR(dev, "hub_interrupt_transmit: alloc_ep_request failed\n");
return;
}
req->complete = hub_interrupt_complete;
for (i = 0; i < 6; i++) {
if (dev->hub_ports[i].change != 0)
data |= 1 << (i+1);
}
if (data != 0) {
int err = 0;
if (hub_interrupt_queued) {
ERROR(dev, "hub_interrupt_transmit: Already queued a request\n");
return;
}
/* Only queue one interrupt, and send it only once... If we don't do that
then it will confuse the ps3, which will try to reset our device a few
times and it will make it take over 15 seconds to get to plugging the JIG
which will not work since it must be plugged in during boot in less
than 5 seconds */
memcpy (req->buf, &data, sizeof(data));
req->length = sizeof(data);
DBG (dev, "transmitting interrupt byte 0x%X\n", data);
hub_interrupt_queued = 1;
err = usb_ep_queue(ep, req, GFP_ATOMIC);
} else {
DBG (dev, "Nothing to report, freeing request, NAK-ing interrupt\n");
if (hub_interrupt_queued)
usb_ep_dequeue(ep, req);
hub_interrupt_queued = 0;
}
}
/**
* ipa_data_stop_endless_xfer() - terminate and dequeue endless TX/RX request
* @port: USB IPA data channel information
* @in: USB endpoint direction i.e. IN - Device TX, OUT - Device RX
*
* It is being used to terminate and dequeue endless TX/RX request with UDC
* driver.
*/
static void ipa_data_stop_endless_xfer(struct ipa_data_ch_info *port, bool in)
{
int status;
if (!port->port_usb) {
pr_err("%s(): port_usb is NULL.\n", __func__);
return;
}
if (in) {
pr_debug("%s: dequeue endless TX_REQ(IN)\n", __func__);
status = usb_ep_dequeue(port->port_usb->in, port->tx_req);
if (status)
pr_err("error dequeueing endless TX_REQ, %d\n", status);
} else {
pr_debug("%s: dequeue endless RX_REQ(OUT)\n", __func__);
status = usb_ep_dequeue(port->port_usb->out, port->rx_req);
if (status)
pr_err("error dequeueing endless RX_REQ, %d\n", status);
}
}
static int rockusb_tx_write(const char *buffer, unsigned int buffer_size)
{
struct usb_request *in_req = rockusb_func->in_req;
int ret;
memcpy(in_req->buf, buffer, buffer_size);
in_req->length = buffer_size;
usb_ep_dequeue(rockusb_func->in_ep, in_req);
ret = usb_ep_queue(rockusb_func->in_ep, in_req, 0);
if (ret)
printf("Error %d on queue\n", ret);
return 0;
}
static void bam_data_stop_endless_tx(struct bam_data_port *port)
{
struct bam_data_ch_info *d = &port->data_ch;
int status;
if (!port->port_usb)
return;
pr_debug("%s: dequeue\n", __func__);
status = usb_ep_dequeue(port->port_usb->in, d->tx_req);
if (status)
pr_err("%s: error dequeuing transfer, %d\n", __func__, status);
}
static void bam_data_stop_endless_rx(struct bam_data_port *port)
{
struct bam_data_ch_info *d = &port->data_ch;
int status;
spin_lock(&port->port_lock_ul);
if (!port->port_usb) {
spin_unlock(&port->port_lock_ul);
return;
}
pr_debug("%s: dequeue\n", __func__);
status = usb_ep_dequeue(port->port_usb->out, d->rx_req);
if (status)
pr_err("%s: error dequeuing transfer, %d\n", __func__, status);
spin_unlock(&port->port_lock_ul);
}
static ssize_t
ep_io (struct ep_data *epdata, void *buf, unsigned len)
{
DECLARE_COMPLETION_ONSTACK (done);
int value;
spin_lock_irq (&epdata->dev->lock);
if (likely (epdata->ep != NULL)) {
struct usb_request *req = epdata->req;
req->context = &done;
req->complete = epio_complete;
req->buf = buf;
req->length = len;
value = usb_ep_queue (epdata->ep, req, GFP_ATOMIC);
} else
value = -ENODEV;
spin_unlock_irq (&epdata->dev->lock);
if (likely (value == 0)) {
value = wait_event_interruptible (done.wait, done.done);
if (value != 0) {
spin_lock_irq (&epdata->dev->lock);
if (likely (epdata->ep != NULL)) {
DBG (epdata->dev, "%s i/o interrupted\n",
epdata->name);
usb_ep_dequeue (epdata->ep, epdata->req);
spin_unlock_irq (&epdata->dev->lock);
wait_event (done.wait, done.done);
if (epdata->status == -ECONNRESET)
epdata->status = -EINTR;
} else {
spin_unlock_irq (&epdata->dev->lock);
DBG (epdata->dev, "endpoint gone\n");
epdata->status = -ENODEV;
}
}
return epdata->status;
}
return value;
}
static ssize_t acc_read(struct file *fp, char __user *buf,
size_t count, loff_t *pos)
{
struct acc_dev *dev = fp->private_data;
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req;
int r = count, xfer;
int ret = 0;
DBG(cdev, "acc_read(%d)\n", count);
if (dev->disconnected)
return -ENODEV;
if (count > BULK_BUFFER_SIZE)
count = BULK_BUFFER_SIZE;
/* we will block until we're online */
DBG(cdev, "acc_read: waiting for online\n");
ret = wait_event_interruptible(dev->read_wq, dev->online);
if (ret < 0) {
r = ret;
goto done;
}
requeue_req:
/* queue a request */
req = dev->rx_req[0];
req->length = count;
dev->rx_done = 0;
ret = usb_ep_queue(dev->ep_out, req, GFP_KERNEL);
if (ret < 0) {
r = -EIO;
goto done;
} else {
DBG(cdev, "rx %p queue\n", req);
}
/* wait for a request to complete */
ret = wait_event_interruptible(dev->read_wq, dev->rx_done);
if (ret < 0) {
r = ret;
usb_ep_dequeue(dev->ep_out, req);
goto done;
}
if (dev->online) {
/* If we got a 0-len packet, throw it back and try again. */
if (req->actual == 0)
goto requeue_req;
DBG(cdev, "rx %p %d\n", req, req->actual);
xfer = (req->actual < count) ? req->actual : count;
r = xfer;
if (copy_to_user(buf, req->buf, xfer))
r = -EFAULT;
} else
r = -EIO;
done:
DBG(cdev, "acc_read returning %d\n", r);
return r;
}
int f_cloner_setup_handle(struct usb_function *f,
const struct usb_ctrlrequest *ctlreq)
{
struct cloner *cloner = f->config->cdev->req->context;
struct usb_request *req = cloner->ep0req;
debug_cond(BURNNER_DEBUG,"vendor bRequestType %x,bRequest %x wLength %d\n",
ctlreq->bRequestType,
ctlreq->bRequest,
ctlreq->wLength);
if ((ctlreq->bRequestType & USB_TYPE_MASK) != USB_TYPE_VENDOR) {
printf("Unkown RequestType 0x%x \n",ctlreq->bRequestType);
cloner->ack = -ENOSYS;
return -ENOSYS;
}
usb_ep_dequeue(cloner->ep0, cloner->ep0req);
usb_ep_dequeue(cloner->ep_in, cloner->read_req);
usb_ep_dequeue(cloner->ep_out, cloner->write_req);
cloner->cmd_type = ctlreq->bRequest;
req->length = ctlreq->wLength;
req->complete = handle_cmd;
switch (ctlreq->bRequest) {
case VR_GET_CPU_INFO:
strcpy(cloner->ep0req->buf,"BOOT47XX");
break;
case VR_GET_ACK:
if (cloner->ack) printf("cloner->ack = %d\n",cloner->ack);
memcpy(cloner->ep0req->buf,&cloner->ack,sizeof(int));
break;
case VR_GET_CRC:
if (cloner->ack) printf("cloner->ack = %d, cloner->crc = %x\n",cloner->ack, cloner->crc);
memcpy(cloner->ep0req->buf,&cloner->ack,sizeof(int));
memcpy(cloner->ep0req->buf + sizeof(int),&cloner->crc,sizeof(int));
break;
case VR_INIT:
break;
case VR_UPDATE_CFG:
case VR_WRITE:
cloner->ack = -EBUSY;
break;
#ifdef CONFIG_CMD_EFUSE
case VR_GET_CHIP_ID:
case VR_GET_USER_ID:
cloner->ep0req->length = ctlreq->wLength;
cloner->ack = efuse_program(cloner);
break;
#endif
case VR_SET_DATA_ADDR:
case VR_SET_DATA_LEN:
cloner->full_size = ctlreq->wIndex | ctlreq->wValue << 16;
cloner->full_size_remainder = cloner->full_size;
printf("cloner->full_size = %x\n", cloner->full_size);
break;
}
return usb_ep_queue(cloner->ep0, cloner->ep0req, 0);
}
static ssize_t acc_read(struct file *fp, char __user *buf,
size_t count, loff_t *pos)
{
struct acc_dev *dev = fp->private_data;
struct usb_request *req;
int r = count, xfer;
int ret = 0;
pr_debug("acc_read(%d)\n", count);
if (dev->disconnected)
return -ENODEV;
if (count > BULK_BUFFER_SIZE)
count = BULK_BUFFER_SIZE;
pr_debug("acc_read: waiting for online\n");
ret = wait_event_interruptible(dev->read_wq, dev->online);
if (ret < 0) {
r = ret;
goto done;
}
requeue_req:
req = dev->rx_req[0];
req->length = count;
dev->rx_done = 0;
ret = usb_ep_queue(dev->ep_out, req, GFP_KERNEL);
if (ret < 0) {
r = -EIO;
goto done;
} else {
pr_debug("rx %p queue\n", req);
}
ret = wait_event_interruptible(dev->read_wq, dev->rx_done);
if (ret < 0) {
r = ret;
usb_ep_dequeue(dev->ep_out, req);
goto done;
}
if (dev->online) {
if (req->actual == 0)
goto requeue_req;
pr_debug("rx %p %d\n", req, req->actual);
xfer = (req->actual < count) ? req->actual : count;
r = xfer;
if (copy_to_user(buf, req->buf, xfer))
r = -EFAULT;
} else
r = -EIO;
done:
pr_debug("acc_read returning %d\n", r);
return r;
}
static ssize_t acc_read(struct file *fp, char __user *buf,
size_t count, loff_t *pos)
{
struct acc_dev *dev = fp->private_data;
struct usb_request *req;
int r = count, xfer;
int ret = 0;
pr_debug("acc_read(%d)\n", count);
if (dev->disconnected) {
pr_debug("acc_read disconnected");
return -ENODEV;
}
if (count > BULK_BUFFER_SIZE)
count = BULK_BUFFER_SIZE;
/* we will block until we're online */
pr_debug("acc_read: waiting for online\n");
ret = wait_event_interruptible(dev->read_wq, dev->online);
if (ret < 0) {
r = ret;
goto done;
}
if (dev->rx_done) {
// last req cancelled. try to get it.
req = dev->rx_req[0];
goto copy_data;
}
requeue_req:
/* queue a request */
req = dev->rx_req[0];
req->length = count;
dev->rx_done = 0;
ret = usb_ep_queue(dev->ep_out, req, GFP_KERNEL);
if (ret < 0) {
r = -EIO;
goto done;
} else {
pr_debug("rx %p queue\n", req);
}
/* wait for a request to complete */
ret = wait_event_interruptible(dev->read_wq, dev->rx_done);
if (ret < 0) {
r = ret;
ret = usb_ep_dequeue(dev->ep_out, req);
if (ret != 0) {
// cancel failed. There can be a data already received.
// it will be retrieved in the next read.
pr_debug("acc_read: cancelling failed %d", ret);
}
goto done;
}
copy_data:
dev->rx_done = 0;
if (dev->online) {
/* If we got a 0-len packet, throw it back and try again. */
if (req->actual == 0)
goto requeue_req;
pr_debug("rx %p %d\n", req, req->actual);
xfer = (req->actual < count) ? req->actual : count;
r = xfer;
if (copy_to_user(buf, req->buf, xfer))
r = -EFAULT;
} else
r = -EIO;
done:
pr_debug("acc_read returning %d\n", r);
return r;
}
