static int
msm72k_queue(struct usb_ep *_ep, struct usb_request *req, gfp_t gfp_flags)
{
struct msm_endpoint *ep = to_msm_endpoint(_ep);
struct usb_info *ui = ep->ui;
if (ep == &ui->ep0in) {
struct msm_request *r = to_msm_request(req);
if (!req->length)
goto ep_queue_done;
else {
if (ui->ep0_dir == USB_DIR_OUT) {
ep = &ui->ep0out;
ep->ep.driver_data = ui->ep0in.ep.driver_data;
}
/* ep0_queue_ack_complete queue a receive for ACK before
** calling req->complete
*/
r->gadget_complete = req->complete;
req->complete = ep0_queue_ack_complete;
}
}
ep_queue_done:
return usb_ept_queue_xfer(ep, req);
}
static void ep0_setup_ack(struct usb_info *ui)
{
struct usb_request *req = ui->setup_req;
req->length = 0;
req->complete = ep0_setup_ack_complete;
usb_ept_queue_xfer(&ui->ep0in, req);
}
static ssize_t adb_write(struct file *fp, const char __user *buf,
size_t count, loff_t *pos)
{
struct adb_context *ctxt = &_context;
struct usb_request *req = 0;
int r = count, xfer;
int ret;
DBG("adb_write(%d)\n", count);
if (_lock(&ctxt->write_excl))
return -EBUSY;
while (count > 0) {
if (ctxt->error) {
r = -EIO;
break;
}
/* get an idle tx request to use */
req = 0;
ret = wait_event_interruptible(ctxt->write_wq,
((req = req_get(ctxt, &ctxt->tx_idle)) || ctxt->error));
if (ret < 0) {
r = ret;
break;
}
if (req != 0) {
xfer = count > TXN_MAX ? TXN_MAX : count;
if (copy_from_user(req->buf, buf, xfer)) {
r = -EFAULT;
break;
}
req->length = xfer;
ret = usb_ept_queue_xfer(ctxt->in, req);
if (ret < 0) {
DBG("adb_write: xfer error %d\n", ret);
ctxt->error = 1;
r = -EIO;
break;
}
buf += xfer;
count -= xfer;
/* zero this so we don't try to free it on error exit */
req = 0;
}
}
if (req)
req_put(ctxt, &ctxt->tx_idle, req);
_unlock(&ctxt->write_excl);
return r;
}
static void ep0_queue_ack_complete(struct usb_ep *ep, struct usb_request *req)
{
struct msm_endpoint *ept = to_msm_endpoint(ep);
/* queue up the receive of the ACK response from the host */
if (req->status == 0) {
struct usb_info *ui = ept->ui;
req->length = 0;
req->complete = ep0_complete;
if (ui->ep0_dir == USB_DIR_IN)
usb_ept_queue_xfer(&ui->ep0out, req);
else
usb_ept_queue_xfer(&ui->ep0in, req);
} else
ep0_complete(ep, req);
}
static int
msm72k_queue(struct usb_ep *_ep, struct usb_request *req, gfp_t gfp_flags)
{
struct msm_endpoint *ep = to_msm_endpoint(_ep);
struct usb_info *ui = ep->ui;
int ret;
if (ep == &ui->ep0in) {
struct msm_request *r = to_msm_request(req);
if (!req->length)
goto ep_queue_done;
r->gadget_complete = req->complete;
/* ep0_queue_ack_complete queue a receive for ACK before
** calling req->complete
*/
req->complete = ep0_queue_ack_complete;
if (ui->ep0_dir == USB_DIR_OUT)
ep = &ui->ep0out;
goto ep_queue_done;
}
if (ui->usb_state == USB_STATE_SUSPENDED) {
ret = msm72k_wakeup(&ui->gadget);
if (ret)
return ret;
}
ep_queue_done:
return usb_ept_queue_xfer(ep, req);
}
static void zero_queue_in(struct zero_context *ctxt, struct usb_request *req)
{
req->complete = zero_in_complete;
req->context = ctxt;
req->length = 4096;
usb_ept_queue_xfer(ctxt->in, req);
}
static void null_queue_out(struct null_context *ctxt, struct usb_request *req)
{
req->complete = null_out_complete;
req->context = ctxt;
req->length = 4096;
usb_ept_queue_xfer(ctxt->out, req);
}
static void ep0_setup_send(struct usb_info *ui, unsigned length)
{
struct usb_request *req = ui->setup_req;
struct msm_request *r = to_msm_request(req);
struct msm_endpoint *ept = &ui->ep0in;
req->length = length;
req->complete = ep0_queue_ack_complete;
r->gadget_complete = NULL;
usb_ept_queue_xfer(ept, req);
}
static ssize_t adb_read(struct file *fp, char __user *buf,
size_t count, loff_t *pos)
{
struct adb_context *ctxt = &_context;
struct usb_request *req;
int r = count, xfer;
int ret;
unsigned MaxPacketSize;
DBG("adb_read(%d)\n", count);
if (_lock(&ctxt->read_excl))
return -EBUSY;
/* we will block until we're online */
while (!(ctxt->online || ctxt->error)) {
DBG("adb_read: waiting for online state\n");
ret = wait_event_interruptible(ctxt->read_wq, (ctxt->online || ctxt->error));
if (ret < 0) {
_unlock(&ctxt->read_excl);
return ret;
}
}
MaxPacketSize = usb_ept_get_max_packet(ctxt->out);
if (MaxPacketSize > 512)
MaxPacketSize = 512;
while (count > 0) {
if (ctxt->error) {
r = -EIO;
break;
}
/* if we have idle read requests, get them queued */
while ((req = req_get(ctxt, &ctxt->rx_idle))) {
requeue_req:
req->length = MaxPacketSize;
ret = usb_ept_queue_xfer(ctxt->out, req);
if (ret < 0) {
DBG("adb_read: failed to queue req %p (%d)\n", req, ret);
r = -EIO;
ctxt->error = 1;
req_put(ctxt, &ctxt->rx_idle, req);
goto fail;
} else {
DBG("%s(): rx %p queue\n", __func__, req);
}
}
/* if we have data pending, give it to userspace */
if (ctxt->read_count > 0) {
xfer = (ctxt->read_count < count) ? ctxt->read_count : count;
if (copy_to_user(buf, ctxt->read_buf, xfer)) {
r = -EFAULT;
break;
}
ctxt->read_buf += xfer;
ctxt->read_count -= xfer;
buf += xfer;
count -= xfer;
/* if we've emptied the buffer, release the request */
if (ctxt->read_count == 0) {
req_put(ctxt, &ctxt->rx_idle, ctxt->read_req);
ctxt->read_req = 0;
}
continue;
}
/* wait for a request to complete */
req = 0;
ret = wait_event_interruptible(ctxt->read_wq,
((req = req_get(ctxt, &ctxt->rx_done)) || ctxt->error));
if (req != 0) {
/* if we got a 0-len one we need to put it back into
** service. if we made it the current read req we'd
** be stuck forever
*/
if (req->actual == 0)
goto requeue_req;
ctxt->read_req = req;
ctxt->read_count = req->actual;
ctxt->read_buf = req->buf;
DBG("%s(): rx %p %d\n", __func__, req, req->actual);
}
if (ret < 0) {
r = ret;
break;
}
}
fail:
_unlock(&ctxt->read_excl);
return r;
}
