[deliverable/linux.git] / drivers / nfc / nfcmrvl / usb.c

/**
 * Marvell NFC-over-USB driver: USB interface related functions
 *
 * Copyright (C) 2014, Marvell International Ltd.
 *
 * This software file (the "File") is distributed by Marvell International
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available on the worldwide web at
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 **/

#include <linux/module.h>
#include <linux/usb.h>
#include <linux/nfc.h>
#include <net/nfc/nci.h>
#include <net/nfc/nci_core.h>
#include "nfcmrvl.h"

#define VERSION "1.0"

static struct usb_device_id nfcmrvl_table[] = {
	{ USB_DEVICE_INTERFACE_CLASS(0x1286, 0x2046, 0xff) },
	{ }	/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, nfcmrvl_table);

#define NFCMRVL_USB_BULK_RUNNING	1
#define NFCMRVL_USB_SUSPENDING		2

struct nfcmrvl_usb_drv_data {
	struct usb_device *udev;
	struct usb_interface *intf;
	unsigned long flags;
	struct work_struct waker;
	struct usb_anchor tx_anchor;
	struct usb_anchor bulk_anchor;
	struct usb_anchor deferred;
	int tx_in_flight;
	/* protects tx_in_flight */
	spinlock_t txlock;
	struct usb_endpoint_descriptor *bulk_tx_ep;
	struct usb_endpoint_descriptor *bulk_rx_ep;
	int suspend_count;
	struct nfcmrvl_private *priv;
};

static int nfcmrvl_inc_tx(struct nfcmrvl_usb_drv_data *drv_data)
{
	unsigned long flags;
	int rv;

	spin_lock_irqsave(&drv_data->txlock, flags);
	rv = test_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
	if (!rv)
		drv_data->tx_in_flight++;
	spin_unlock_irqrestore(&drv_data->txlock, flags);

	return rv;
}

static void nfcmrvl_bulk_complete(struct urb *urb)
{
	struct nfcmrvl_usb_drv_data *drv_data = urb->context;
	int err;

	dev_dbg(&drv_data->udev->dev, "urb %p status %d count %d",
		urb, urb->status, urb->actual_length);

	if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
		return;

	if (!urb->status) {
		if (nfcmrvl_nci_recv_frame(drv_data->priv, urb->transfer_buffer,
					   urb->actual_length) < 0)
			nfc_err(&drv_data->udev->dev, "corrupted Rx packet");
	}

	if (!test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags))
		return;

	usb_anchor_urb(urb, &drv_data->bulk_anchor);
	usb_mark_last_busy(drv_data->udev);

	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err) {
		/* -EPERM: urb is being killed;
		 * -ENODEV: device got disconnected
		 */
		if (err != -EPERM && err != -ENODEV)
			nfc_err(&drv_data->udev->dev,
				"urb %p failed to resubmit (%d)", urb, -err);
		usb_unanchor_urb(urb);
	}
}

static int
nfcmrvl_submit_bulk_urb(struct nfcmrvl_usb_drv_data *drv_data, gfp_t mem_flags)
{
	struct urb *urb;
	unsigned char *buf;
	unsigned int pipe;
	int err, size = NFCMRVL_NCI_MAX_EVENT_SIZE;

	if (!drv_data->bulk_rx_ep)
		return -ENODEV;

	urb = usb_alloc_urb(0, mem_flags);
	if (!urb)
		return -ENOMEM;

	buf = kmalloc(size, mem_flags);
	if (!buf) {
		usb_free_urb(urb);
		return -ENOMEM;
	}

	pipe = usb_rcvbulkpipe(drv_data->udev,
			       drv_data->bulk_rx_ep->bEndpointAddress);

	usb_fill_bulk_urb(urb, drv_data->udev, pipe, buf, size,
			  nfcmrvl_bulk_complete, drv_data);

	urb->transfer_flags |= URB_FREE_BUFFER;

	usb_mark_last_busy(drv_data->udev);
	usb_anchor_urb(urb, &drv_data->bulk_anchor);

	err = usb_submit_urb(urb, mem_flags);
	if (err) {
		if (err != -EPERM && err != -ENODEV)
			nfc_err(&drv_data->udev->dev,
				"urb %p submission failed (%d)", urb, -err);
		usb_unanchor_urb(urb);
	}

	usb_free_urb(urb);

	return err;
}

static void nfcmrvl_tx_complete(struct urb *urb)
{
	struct sk_buff *skb = urb->context;
	struct nci_dev *ndev = (struct nci_dev *)skb->dev;
	struct nfcmrvl_private *priv = nci_get_drvdata(ndev);
	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;

	nfc_info(priv->dev, "urb %p status %d count %d",
		 urb, urb->status, urb->actual_length);

	spin_lock(&drv_data->txlock);
	drv_data->tx_in_flight--;
	spin_unlock(&drv_data->txlock);

	kfree(urb->setup_packet);
	kfree_skb(skb);
}

static int nfcmrvl_usb_nci_open(struct nfcmrvl_private *priv)
{
	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
	int err;

	err = usb_autopm_get_interface(drv_data->intf);
	if (err)
		return err;

	drv_data->intf->needs_remote_wakeup = 1;

	err = nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
	if (err)
		goto failed;

	set_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
	nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);

	usb_autopm_put_interface(drv_data->intf);
	return 0;

failed:
	usb_autopm_put_interface(drv_data->intf);
	return err;
}

static void nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data *drv_data)
{
	usb_kill_anchored_urbs(&drv_data->bulk_anchor);
}

static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv)
{
	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
	int err;

	cancel_work_sync(&drv_data->waker);

	clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);

	nfcmrvl_usb_stop_traffic(drv_data);
	usb_kill_anchored_urbs(&drv_data->tx_anchor);
	err = usb_autopm_get_interface(drv_data->intf);
	if (err)
		goto failed;

	drv_data->intf->needs_remote_wakeup = 0;
	usb_autopm_put_interface(drv_data->intf);

failed:
	usb_scuttle_anchored_urbs(&drv_data->deferred);
	return 0;
}

static int nfcmrvl_usb_nci_send(struct nfcmrvl_private *priv,
				struct sk_buff *skb)
{
	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
	struct urb *urb;
	unsigned int pipe;
	int err;

	if (!drv_data->bulk_tx_ep)
		return -ENODEV;

	urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!urb)
		return -ENOMEM;

	pipe = usb_sndbulkpipe(drv_data->udev,
				drv_data->bulk_tx_ep->bEndpointAddress);

	usb_fill_bulk_urb(urb, drv_data->udev, pipe, skb->data, skb->len,
			  nfcmrvl_tx_complete, skb);

	err = nfcmrvl_inc_tx(drv_data);
	if (err) {
		usb_anchor_urb(urb, &drv_data->deferred);
		schedule_work(&drv_data->waker);
		err = 0;
		goto done;
	}

	usb_anchor_urb(urb, &drv_data->tx_anchor);

	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err) {
		if (err != -EPERM && err != -ENODEV)
			nfc_err(&drv_data->udev->dev,
				"urb %p submission failed (%d)", urb, -err);
		kfree(urb->setup_packet);
		usb_unanchor_urb(urb);
	} else {
		usb_mark_last_busy(drv_data->udev);
	}

done:
	usb_free_urb(urb);
	return err;
}

static struct nfcmrvl_if_ops usb_ops = {
	.nci_open = nfcmrvl_usb_nci_open,
	.nci_close = nfcmrvl_usb_nci_close,
	.nci_send = nfcmrvl_usb_nci_send,
};

static void nfcmrvl_waker(struct work_struct *work)
{
	struct nfcmrvl_usb_drv_data *drv_data =
			container_of(work, struct nfcmrvl_usb_drv_data, waker);
	int err;

	err = usb_autopm_get_interface(drv_data->intf);
	if (err)
		return;

	usb_autopm_put_interface(drv_data->intf);
}

static int nfcmrvl_probe(struct usb_interface *intf,
			 const struct usb_device_id *id)
{
	struct usb_endpoint_descriptor *ep_desc;
	struct nfcmrvl_usb_drv_data *drv_data;
	struct nfcmrvl_private *priv;
	int i;
	struct usb_device *udev = interface_to_usbdev(intf);

	nfc_info(&udev->dev, "intf %p id %p", intf, id);

	drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
	if (!drv_data)
		return -ENOMEM;

	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
		ep_desc = &intf->cur_altsetting->endpoint[i].desc;

		if (!drv_data->bulk_tx_ep &&
		    usb_endpoint_is_bulk_out(ep_desc)) {
			drv_data->bulk_tx_ep = ep_desc;
			continue;
		}

		if (!drv_data->bulk_rx_ep &&
		    usb_endpoint_is_bulk_in(ep_desc)) {
			drv_data->bulk_rx_ep = ep_desc;
			continue;
		}
	}

	if (!drv_data->bulk_tx_ep || !drv_data->bulk_rx_ep)
		return -ENODEV;

	drv_data->udev = udev;
	drv_data->intf = intf;

	INIT_WORK(&drv_data->waker, nfcmrvl_waker);
	spin_lock_init(&drv_data->txlock);

	init_usb_anchor(&drv_data->tx_anchor);
	init_usb_anchor(&drv_data->bulk_anchor);
	init_usb_anchor(&drv_data->deferred);

	priv = nfcmrvl_nci_register_dev(drv_data, &usb_ops,
					&drv_data->udev->dev);
	if (IS_ERR(priv))
		return PTR_ERR(priv);

	drv_data->priv = priv;
	priv->dev = &drv_data->udev->dev;

	usb_set_intfdata(intf, drv_data);

	return 0;
}

static void nfcmrvl_disconnect(struct usb_interface *intf)
{
	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);

	if (!drv_data)
		return;

	nfc_info(&drv_data->udev->dev, "intf %p", intf);

	nfcmrvl_nci_unregister_dev(drv_data->priv);

	usb_set_intfdata(drv_data->intf, NULL);
}

#ifdef CONFIG_PM
static int nfcmrvl_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);

	nfc_info(&drv_data->udev->dev, "intf %p", intf);

	if (drv_data->suspend_count++)
		return 0;

	spin_lock_irq(&drv_data->txlock);
	if (!(PMSG_IS_AUTO(message) && drv_data->tx_in_flight)) {
		set_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
		spin_unlock_irq(&drv_data->txlock);
	} else {
		spin_unlock_irq(&drv_data->txlock);
		drv_data->suspend_count--;
		return -EBUSY;
	}

	nfcmrvl_usb_stop_traffic(drv_data);
	usb_kill_anchored_urbs(&drv_data->tx_anchor);

	return 0;
}

static void nfcmrvl_play_deferred(struct nfcmrvl_usb_drv_data *drv_data)
{
	struct urb *urb;
	int err;

	while ((urb = usb_get_from_anchor(&drv_data->deferred))) {
		err = usb_submit_urb(urb, GFP_ATOMIC);
		if (err)
			break;

		drv_data->tx_in_flight++;
	}
	usb_scuttle_anchored_urbs(&drv_data->deferred);
}

static int nfcmrvl_resume(struct usb_interface *intf)
{
	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
	int err = 0;

	nfc_info(&drv_data->udev->dev, "intf %p", intf);

	if (--drv_data->suspend_count)
		return 0;

	if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
		goto done;

	if (test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags)) {
		err = nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
		if (err) {
			clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
			goto failed;
		}

		nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
	}

	spin_lock_irq(&drv_data->txlock);
	nfcmrvl_play_deferred(drv_data);
	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
	spin_unlock_irq(&drv_data->txlock);

	return 0;

failed:
	usb_scuttle_anchored_urbs(&drv_data->deferred);
done:
	spin_lock_irq(&drv_data->txlock);
	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
	spin_unlock_irq(&drv_data->txlock);

	return err;
}
#endif

static struct usb_driver nfcmrvl_usb_driver = {
	.name		= "nfcmrvl",
	.probe		= nfcmrvl_probe,
	.disconnect	= nfcmrvl_disconnect,
#ifdef CONFIG_PM
	.suspend	= nfcmrvl_suspend,
	.resume		= nfcmrvl_resume,
	.reset_resume	= nfcmrvl_resume,
#endif
	.id_table	= nfcmrvl_table,
	.supports_autosuspend = 1,
	.disable_hub_initiated_lpm = 1,
	.soft_unbind = 1,
};
module_usb_driver(nfcmrvl_usb_driver);

MODULE_AUTHOR("Marvell International Ltd.");
MODULE_DESCRIPTION("Marvell NFC-over-USB driver ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL v2");
Commit	Line	Data
f26e30cc AK	1	/**
	2	* Marvell NFC-over-USB driver: USB interface related functions
	3	*
	4	* Copyright (C) 2014, Marvell International Ltd.
	5	*
	6	* This software file (the "File") is distributed by Marvell International
	7	* Ltd. under the terms of the GNU General Public License Version 2, June 1991
	8	* (the "License"). You may use, redistribute and/or modify this File in
	9	* accordance with the terms and conditions of the License, a copy of which
	10	* is available on the worldwide web at
	11	* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
	12	*
	13	* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
	14	* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
	15	* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
	16	* this warranty disclaimer.
	17	**/
	18
	19	#include <linux/module.h>
	20	#include <linux/usb.h>
	21	#include <linux/nfc.h>
	22	#include <net/nfc/nci.h>
	23	#include <net/nfc/nci_core.h>
	24	#include "nfcmrvl.h"
	25
	26	#define VERSION "1.0"
	27
	28	static struct usb_device_id nfcmrvl_table[] = {
	29	{ USB_DEVICE_INTERFACE_CLASS(0x1286, 0x2046, 0xff) },
	30	{ } /* Terminating entry */
	31	};
	32
	33	MODULE_DEVICE_TABLE(usb, nfcmrvl_table);
	34
	35	#define NFCMRVL_USB_BULK_RUNNING 1
	36	#define NFCMRVL_USB_SUSPENDING 2
	37
	38	struct nfcmrvl_usb_drv_data {
	39	struct usb_device *udev;
	40	struct usb_interface *intf;
	41	unsigned long flags;
	42	struct work_struct waker;
	43	struct usb_anchor tx_anchor;
	44	struct usb_anchor bulk_anchor;
	45	struct usb_anchor deferred;
	46	int tx_in_flight;
	47	/* protects tx_in_flight */
	48	spinlock_t txlock;
	49	struct usb_endpoint_descriptor *bulk_tx_ep;
	50	struct usb_endpoint_descriptor *bulk_rx_ep;
	51	int suspend_count;
	52	struct nfcmrvl_private *priv;
	53	};
	54
	55	static int nfcmrvl_inc_tx(struct nfcmrvl_usb_drv_data *drv_data)
	56	{
	57	unsigned long flags;
	58	int rv;
	59
	60	spin_lock_irqsave(&drv_data->txlock, flags);
	61	rv = test_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
	62	if (!rv)
	63	drv_data->tx_in_flight++;
	64	spin_unlock_irqrestore(&drv_data->txlock, flags);
65
66	return rv;
67	}
68
69	static void nfcmrvl_bulk_complete(struct urb *urb)
70	{
71	struct nfcmrvl_usb_drv_data *drv_data = urb->context;
72	int err;
73
74	dev_dbg(&drv_data->udev->dev, "urb %p status %d count %d",
75	urb, urb->status, urb->actual_length);
76
77	if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
78	return;
79
80	if (!urb->status) {
81	if (nfcmrvl_nci_recv_frame(drv_data->priv, urb->transfer_buffer,
82	urb->actual_length) < 0)
83	nfc_err(&drv_data->udev->dev, "corrupted Rx packet");
84	}
85
86	if (!test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags))
87	return;
88
89	usb_anchor_urb(urb, &drv_data->bulk_anchor);
90	usb_mark_last_busy(drv_data->udev);
91
92	err = usb_submit_urb(urb, GFP_ATOMIC);
93	if (err) {
94	/* -EPERM: urb is being killed;
95	* -ENODEV: device got disconnected
96	*/
97	if (err != -EPERM && err != -ENODEV)
98	nfc_err(&drv_data->udev->dev,
99	"urb %p failed to resubmit (%d)", urb, -err);
100	usb_unanchor_urb(urb);
101	}
102	}
103
104	static int
105	nfcmrvl_submit_bulk_urb(struct nfcmrvl_usb_drv_data *drv_data, gfp_t mem_flags)
106	{
107	struct urb *urb;
108	unsigned char *buf;
109	unsigned int pipe;
110	int err, size = NFCMRVL_NCI_MAX_EVENT_SIZE;
111
112	if (!drv_data->bulk_rx_ep)
113	return -ENODEV;
114
115	urb = usb_alloc_urb(0, mem_flags);
116	if (!urb)
117	return -ENOMEM;
118
119	buf = kmalloc(size, mem_flags);
120	if (!buf) {
121	usb_free_urb(urb);
122	return -ENOMEM;
123	}
124
125	pipe = usb_rcvbulkpipe(drv_data->udev,
126	drv_data->bulk_rx_ep->bEndpointAddress);
127
128	usb_fill_bulk_urb(urb, drv_data->udev, pipe, buf, size,
129	nfcmrvl_bulk_complete, drv_data);
130
131	urb->transfer_flags \|= URB_FREE_BUFFER;
132
133	usb_mark_last_busy(drv_data->udev);
134	usb_anchor_urb(urb, &drv_data->bulk_anchor);
135
136	err = usb_submit_urb(urb, mem_flags);
137	if (err) {
138	if (err != -EPERM && err != -ENODEV)
139	nfc_err(&drv_data->udev->dev,
140	"urb %p submission failed (%d)", urb, -err);
141	usb_unanchor_urb(urb);
142	}
143
144	usb_free_urb(urb);
145
146	return err;
147	}
148
149	static void nfcmrvl_tx_complete(struct urb *urb)
150	{
151	struct sk_buff *skb = urb->context;
152	struct nci_dev ndev = (struct nci_dev )skb->dev;
153	struct nfcmrvl_private *priv = nci_get_drvdata(ndev);
154	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
155
156	nfc_info(priv->dev, "urb %p status %d count %d",
157	urb, urb->status, urb->actual_length);
158
159	spin_lock(&drv_data->txlock);
160	drv_data->tx_in_flight--;
161	spin_unlock(&drv_data->txlock);
162
163	kfree(urb->setup_packet);
164	kfree_skb(skb);
165	}
166
167	static int nfcmrvl_usb_nci_open(struct nfcmrvl_private *priv)
168	{
169	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
170	int err;
171
172	err = usb_autopm_get_interface(drv_data->intf);
173	if (err)
174	return err;
175
176	drv_data->intf->needs_remote_wakeup = 1;
177
178	err = nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
179	if (err)
180	goto failed;
181
182	set_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
183	nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
184
185	usb_autopm_put_interface(drv_data->intf);
186	return 0;
187
188	failed:
189	usb_autopm_put_interface(drv_data->intf);
190	return err;
191	}
192
193	static void nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data *drv_data)
194	{
195	usb_kill_anchored_urbs(&drv_data->bulk_anchor);
196	}
197
198	static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv)
199	{
200	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
201	int err;
202
203	cancel_work_sync(&drv_data->waker);
204
205	clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
206
207	nfcmrvl_usb_stop_traffic(drv_data);
208	usb_kill_anchored_urbs(&drv_data->tx_anchor);
209	err = usb_autopm_get_interface(drv_data->intf);
210	if (err)
211	goto failed;
212
213	drv_data->intf->needs_remote_wakeup = 0;
214	usb_autopm_put_interface(drv_data->intf);
215
216	failed:
217	usb_scuttle_anchored_urbs(&drv_data->deferred);
218	return 0;
219	}
220
221	static int nfcmrvl_usb_nci_send(struct nfcmrvl_private *priv,
222	struct sk_buff *skb)
223	{
224	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
225	struct urb *urb;
226	unsigned int pipe;
227	int err;
228
229	if (!drv_data->bulk_tx_ep)
230	return -ENODEV;
231
232	urb = usb_alloc_urb(0, GFP_ATOMIC);
233	if (!urb)
234	return -ENOMEM;
235
236	pipe = usb_sndbulkpipe(drv_data->udev,
237	drv_data->bulk_tx_ep->bEndpointAddress);
238
239	usb_fill_bulk_urb(urb, drv_data->udev, pipe, skb->data, skb->len,
240	nfcmrvl_tx_complete, skb);
241
242	err = nfcmrvl_inc_tx(drv_data);
243	if (err) {
244	usb_anchor_urb(urb, &drv_data->deferred);
245	schedule_work(&drv_data->waker);
246	err = 0;
247	goto done;
248	}
249
250	usb_anchor_urb(urb, &drv_data->tx_anchor);
251
252	err = usb_submit_urb(urb, GFP_ATOMIC);
253	if (err) {
254	if (err != -EPERM && err != -ENODEV)
255	nfc_err(&drv_data->udev->dev,
256	"urb %p submission failed (%d)", urb, -err);
257	kfree(urb->setup_packet);
258	usb_unanchor_urb(urb);
259	} else {
260	usb_mark_last_busy(drv_data->udev);
261	}
262
263	done:
264	usb_free_urb(urb);
265	return err;
266	}
267
268	static struct nfcmrvl_if_ops usb_ops = {
269	.nci_open = nfcmrvl_usb_nci_open,
270	.nci_close = nfcmrvl_usb_nci_close,
271	.nci_send = nfcmrvl_usb_nci_send,
272	};
273
274	static void nfcmrvl_waker(struct work_struct *work)
275	{
276	struct nfcmrvl_usb_drv_data *drv_data =
277	container_of(work, struct nfcmrvl_usb_drv_data, waker);
278	int err;
279
280	err = usb_autopm_get_interface(drv_data->intf);
281	if (err)
282	return;
283
284	usb_autopm_put_interface(drv_data->intf);
285	}
286
287	static int nfcmrvl_probe(struct usb_interface *intf,
288	const struct usb_device_id *id)
289	{
290	struct usb_endpoint_descriptor *ep_desc;
291	struct nfcmrvl_usb_drv_data *drv_data;
292	struct nfcmrvl_private *priv;
293	int i;
294	struct usb_device *udev = interface_to_usbdev(intf);
295
296	nfc_info(&udev->dev, "intf %p id %p", intf, id);
297
298	drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
299	if (!drv_data)
300	return -ENOMEM;
301
302	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
303	ep_desc = &intf->cur_altsetting->endpoint[i].desc;
304
305	if (!drv_data->bulk_tx_ep &&
306	usb_endpoint_is_bulk_out(ep_desc)) {
307	drv_data->bulk_tx_ep = ep_desc;
308	continue;
309	}
310
311	if (!drv_data->bulk_rx_ep &&
312	usb_endpoint_is_bulk_in(ep_desc)) {
313	drv_data->bulk_rx_ep = ep_desc;
314	continue;
315	}
316	}
317
318	if (!drv_data->bulk_tx_ep \|\| !drv_data->bulk_rx_ep)
319	return -ENODEV;
320
321	drv_data->udev = udev;
322	drv_data->intf = intf;
323
324	INIT_WORK(&drv_data->waker, nfcmrvl_waker);
325	spin_lock_init(&drv_data->txlock);
326
327	init_usb_anchor(&drv_data->tx_anchor);
328	init_usb_anchor(&drv_data->bulk_anchor);
329	init_usb_anchor(&drv_data->deferred);
330
331	priv = nfcmrvl_nci_register_dev(drv_data, &usb_ops,
332	&drv_data->udev->dev);
333	if (IS_ERR(priv))
334	return PTR_ERR(priv);
335
336	drv_data->priv = priv;
337	priv->dev = &drv_data->udev->dev;
338
339	usb_set_intfdata(intf, drv_data);
340
341	return 0;
342	}
343
344	static void nfcmrvl_disconnect(struct usb_interface *intf)
345	{
346	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
347
348	if (!drv_data)
349	return;
350
351	nfc_info(&drv_data->udev->dev, "intf %p", intf);
352
353	nfcmrvl_nci_unregister_dev(drv_data->priv);
354
355	usb_set_intfdata(drv_data->intf, NULL);
356	}
357
358	#ifdef CONFIG_PM
359	static int nfcmrvl_suspend(struct usb_interface *intf, pm_message_t message)
360	{
361	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
362
363	nfc_info(&drv_data->udev->dev, "intf %p", intf);
364
365	if (drv_data->suspend_count++)
366	return 0;
367
368	spin_lock_irq(&drv_data->txlock);
369	if (!(PMSG_IS_AUTO(message) && drv_data->tx_in_flight)) {
370	set_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
371	spin_unlock_irq(&drv_data->txlock);
372	} else {
373	spin_unlock_irq(&drv_data->txlock);
374	drv_data->suspend_count--;
375	return -EBUSY;
376	}
377
378	nfcmrvl_usb_stop_traffic(drv_data);
379	usb_kill_anchored_urbs(&drv_data->tx_anchor);
380
381	return 0;
382	}
383
384	static void nfcmrvl_play_deferred(struct nfcmrvl_usb_drv_data *drv_data)
385	{
386	struct urb *urb;
387	int err;
388
389	while ((urb = usb_get_from_anchor(&drv_data->deferred))) {
390	err = usb_submit_urb(urb, GFP_ATOMIC);
391	if (err)
392	break;
393
394	drv_data->tx_in_flight++;
395	}
396	usb_scuttle_anchored_urbs(&drv_data->deferred);
397	}
398
399	static int nfcmrvl_resume(struct usb_interface *intf)
400	{
401	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
402	int err = 0;
403
404	nfc_info(&drv_data->udev->dev, "intf %p", intf);
405
406	if (--drv_data->suspend_count)
407	return 0;
408
409	if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
410	goto done;
411
412	if (test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags)) {
413	err = nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
414	if (err) {
415	clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
416	goto failed;
417	}
418
419	nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
420	}
421
422	spin_lock_irq(&drv_data->txlock);
423	nfcmrvl_play_deferred(drv_data);
424	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
425	spin_unlock_irq(&drv_data->txlock);
426
427	return 0;
428
429	failed:
430	usb_scuttle_anchored_urbs(&drv_data->deferred);
431	done:
432	spin_lock_irq(&drv_data->txlock);
433	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
434	spin_unlock_irq(&drv_data->txlock);
435
436	return err;
437	}
438	#endif
439
440	static struct usb_driver nfcmrvl_usb_driver = {
441	.name = "nfcmrvl",
442	.probe = nfcmrvl_probe,
443	.disconnect = nfcmrvl_disconnect,
444	#ifdef CONFIG_PM
445	.suspend = nfcmrvl_suspend,
446	.resume = nfcmrvl_resume,
447	.reset_resume = nfcmrvl_resume,
448	#endif
449	.id_table = nfcmrvl_table,
450	.supports_autosuspend = 1,
451	.disable_hub_initiated_lpm = 1,
452	.soft_unbind = 1,
453	};
454	module_usb_driver(nfcmrvl_usb_driver);
455
456	MODULE_AUTHOR("Marvell International Ltd.");
457	MODULE_DESCRIPTION("Marvell NFC-over-USB driver ver " VERSION);
458	MODULE_VERSION(VERSION);
459	MODULE_LICENSE("GPL v2");