/*
* Can not be called in atomic context.
*/
static void message_cancel(struct gb_message *message)
{
struct gb_host_device *hd = message->operation->connection->hd;
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct urb *urb;
int i;
might_sleep();
spin_lock_irq(&es2->cport_out_urb_lock);
urb = message->hcpriv;
/* Prevent dynamically allocated urb from being deallocated. */
usb_get_urb(urb);
/* Prevent pre-allocated urb from being reused. */
for (i = 0; i < NUM_CPORT_OUT_URB; ++i) {
if (urb == es2->cport_out_urb[i]) {
es2->cport_out_urb_cancelled[i] = true;
break;
}
}
spin_unlock_irq(&es2->cport_out_urb_lock);
usb_kill_urb(urb);
if (i < NUM_CPORT_OUT_URB) {
spin_lock_irq(&es2->cport_out_urb_lock);
es2->cport_out_urb_cancelled[i] = false;
spin_unlock_irq(&es2->cport_out_urb_lock);
}
usb_free_urb(urb);
}
/*
* Returns zero if the message was successfully queued, or a negative errno
* otherwise.
*/
static int message_send(struct gb_host_device *hd, u16 cport_id,
struct gb_message *message, gfp_t gfp_mask)
{
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct usb_device *udev = es2->usb_dev;
size_t buffer_size;
int retval;
struct urb *urb;
int ep_pair;
unsigned long flags;
/*
* The data actually transferred will include an indication
* of where the data should be sent. Do one last check of
* the target CPort id before filling it in.
*/
if (!cport_id_valid(hd, cport_id)) {
dev_err(&udev->dev, "invalid destination cport 0x%02x\n",
cport_id);
return -EINVAL;
}
/* Find a free urb */
urb = next_free_urb(es2, gfp_mask);
if (!urb)
return -ENOMEM;
spin_lock_irqsave(&es2->cport_out_urb_lock, flags);
message->hcpriv = urb;
spin_unlock_irqrestore(&es2->cport_out_urb_lock, flags);
/* Pack the cport id into the message header */
gb_message_cport_pack(message->header, cport_id);
buffer_size = sizeof(*message->header) + message->payload_size;
ep_pair = cport_to_ep_pair(es2, cport_id);
usb_fill_bulk_urb(urb, udev,
usb_sndbulkpipe(udev,
es2->cport_out[ep_pair].endpoint),
message->buffer, buffer_size,
cport_out_callback, message);
urb->transfer_flags |= URB_ZERO_PACKET;
trace_gb_host_device_send(hd, cport_id, buffer_size);
retval = usb_submit_urb(urb, gfp_mask);
if (retval) {
dev_err(&udev->dev, "failed to submit out-urb: %d\n", retval);
spin_lock_irqsave(&es2->cport_out_urb_lock, flags);
message->hcpriv = NULL;
spin_unlock_irqrestore(&es2->cport_out_urb_lock, flags);
free_urb(es2, urb);
gb_message_cport_clear(message->header);
return retval;
}
return 0;
}
static int output(struct gb_host_device *hd, void *req, u16 size, u8 cmd,
bool async)
{
struct es2_ap_dev *es2 = hd_to_es2(hd);
if (async)
return output_async(es2, req, size, cmd);
return output_sync(es2, req, size, cmd);
}
static int cport_features_enable(struct gb_host_device *hd, u16 cport_id)
{
int retval;
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct usb_device *udev = es2->usb_dev;
retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
GB_APB_REQUEST_CPORT_FEAT_EN,
USB_DIR_OUT | USB_TYPE_VENDOR |
USB_RECIP_INTERFACE, cport_id, 0, NULL,
0, ES2_TIMEOUT);
if (retval < 0)
dev_err(&udev->dev, "Cannot enable CPort features for cport %u: %d\n",
cport_id, retval);
return retval;
}
static int cport_reset(struct gb_host_device *hd, u16 cport_id)
{
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct usb_device *udev = es2->usb_dev;
int retval;
retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
GB_APB_REQUEST_RESET_CPORT,
USB_DIR_OUT | USB_TYPE_VENDOR |
USB_RECIP_INTERFACE, cport_id, 0,
NULL, 0, ES2_TIMEOUT);
if (retval < 0) {
dev_err(&udev->dev, "failed to reset cport %u: %d\n", cport_id,
retval);
return retval;
}
return 0;
}
static void cport_out_callback(struct urb *urb)
{
struct gb_message *message = urb->context;
struct gb_host_device *hd = message->operation->connection->hd;
struct es2_ap_dev *es2 = hd_to_es2(hd);
int status = check_urb_status(urb);
unsigned long flags;
gb_message_cport_clear(message->header);
spin_lock_irqsave(&es2->cport_out_urb_lock, flags);
message->hcpriv = NULL;
spin_unlock_irqrestore(&es2->cport_out_urb_lock, flags);
/*
* Tell the submitter that the message send (attempt) is
* complete, and report the status.
*/
greybus_message_sent(hd, message, status);
free_urb(es2, urb);
}
static int latency_tag_disable(struct gb_host_device *hd, u16 cport_id)
{
int retval;
struct es2_ap_dev *es2 = hd_to_es2(hd);
struct usb_device *udev = es2->usb_dev;
if (!cport_id_valid(hd, cport_id)) {
dev_err(&udev->dev, "invalid cport %u\n", cport_id);
return -EINVAL;
}
retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
GB_APB_REQUEST_LATENCY_TAG_DIS,
USB_DIR_OUT | USB_TYPE_VENDOR |
USB_RECIP_INTERFACE, cport_id, 0, NULL,
0, ES2_TIMEOUT);
if (retval < 0)
dev_err(&udev->dev, "Cannot disable latency tag for cport %d\n",
cport_id);
return retval;
}
/*
* The ES2 USB Bridge device has 15 endpoints
* 1 Control - usual USB stuff + AP -> APBridgeA messages
* 7 Bulk IN - CPort data in
* 7 Bulk OUT - CPort data out
*/
static int ap_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct es2_ap_dev *es2;
struct gb_host_device *hd;
struct usb_device *udev;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
int bulk_in = 0;
int bulk_out = 0;
int retval = -ENOMEM;
int i;
int num_cports;
int cport_id;
udev = usb_get_dev(interface_to_usbdev(interface));
num_cports = apb_get_cport_count(udev);
if (num_cports < 0) {
usb_put_dev(udev);
dev_err(&udev->dev, "Cannot retrieve CPort count: %d\n",
num_cports);
return num_cports;
}
hd = gb_hd_create(&es2_driver, &udev->dev, ES2_GBUF_MSG_SIZE_MAX,
num_cports);
if (IS_ERR(hd)) {
usb_put_dev(udev);
return PTR_ERR(hd);
}
/*
* CPorts 16 and 17 are reserved for CDSI0 and CDSI1, make sure they
* won't be allocated dynamically.
*/
do {
cport_id = ida_simple_get(&hd->cport_id_map, 16, 18, GFP_KERNEL);
} while (cport_id > 0);
es2 = hd_to_es2(hd);
es2->hd = hd;
es2->usb_intf = interface;
es2->usb_dev = udev;
spin_lock_init(&es2->cport_out_urb_lock);
INIT_KFIFO(es2->apb_log_fifo);
usb_set_intfdata(interface, es2);
es2->cport_to_ep = kcalloc(hd->num_cports, sizeof(*es2->cport_to_ep),
GFP_KERNEL);
if (!es2->cport_to_ep) {
retval = -ENOMEM;
goto error;
}
/* find all bulk endpoints */
iface_desc = interface->cur_altsetting;
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
endpoint = &iface_desc->endpoint[i].desc;
if (usb_endpoint_is_bulk_in(endpoint)) {
es2->cport_in[bulk_in++].endpoint =
endpoint->bEndpointAddress;
} else if (usb_endpoint_is_bulk_out(endpoint)) {
es2->cport_out[bulk_out++].endpoint =
endpoint->bEndpointAddress;
} else {
dev_err(&udev->dev,
"Unknown endpoint type found, address 0x%02x\n",
endpoint->bEndpointAddress);
}
}
if (bulk_in != NUM_BULKS || bulk_out != NUM_BULKS) {
dev_err(&udev->dev, "Not enough endpoints found in device, aborting!\n");
goto error;
}
/* Allocate buffers for our cport in messages */
for (bulk_in = 0; bulk_in < NUM_BULKS; bulk_in++) {
struct es2_cport_in *cport_in = &es2->cport_in[bulk_in];
for (i = 0; i < NUM_CPORT_IN_URB; ++i) {
struct urb *urb;
u8 *buffer;
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb)
goto error;
buffer = kmalloc(ES2_GBUF_MSG_SIZE_MAX, GFP_KERNEL);
if (!buffer)
goto error;
usb_fill_bulk_urb(urb, udev,
usb_rcvbulkpipe(udev,
cport_in->endpoint),
buffer, ES2_GBUF_MSG_SIZE_MAX,
cport_in_callback, hd);
cport_in->urb[i] = urb;
cport_in->buffer[i] = buffer;
}
}
/* Allocate urbs for our CPort OUT messages */
for (i = 0; i < NUM_CPORT_OUT_URB; ++i) {
struct urb *urb;
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb)
goto error;
es2->cport_out_urb[i] = urb;
es2->cport_out_urb_busy[i] = false; /* just to be anal */
}
/* XXX We will need to rename this per APB */
es2->apb_log_enable_dentry = debugfs_create_file("apb_log_enable",
(S_IWUSR | S_IRUGO),
gb_debugfs_get(), es2,
&apb_log_enable_fops);
retval = gb_hd_add(hd);
if (retval)
goto error;
for (i = 0; i < NUM_BULKS; ++i) {
retval = es2_cport_in_enable(es2, &es2->cport_in[i]);
if (retval)
goto err_disable_cport_in;
}
return 0;
err_disable_cport_in:
for (--i; i >= 0; --i)
es2_cport_in_disable(es2, &es2->cport_in[i]);
gb_hd_del(hd);
error:
es2_destroy(es2);
return retval;
}