xref: /linux/drivers/nfc/nfcmrvl/usb.c (revision ca853314e78b0a65c20b6a889a23c31f918d4aa2) 
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 static struct usb_device_id nfcmrvl_table[] = {
27 	{ USB_DEVICE_AND_INTERFACE_INFO(0x1286, 0x2046,
28 					USB_CLASS_VENDOR_SPEC, 4, 1) },
29 	{ }	/* Terminating entry */
30 };
31 
32 MODULE_DEVICE_TABLE(usb, nfcmrvl_table);
33 
34 #define NFCMRVL_USB_BULK_RUNNING	1
35 #define NFCMRVL_USB_SUSPENDING		2
36 
37 struct nfcmrvl_usb_drv_data {
38 	struct usb_device *udev;
39 	struct usb_interface *intf;
40 	unsigned long flags;
41 	struct work_struct waker;
42 	struct usb_anchor tx_anchor;
43 	struct usb_anchor bulk_anchor;
44 	struct usb_anchor deferred;
45 	int tx_in_flight;
46 	/* protects tx_in_flight */
47 	spinlock_t txlock;
48 	struct usb_endpoint_descriptor *bulk_tx_ep;
49 	struct usb_endpoint_descriptor *bulk_rx_ep;
50 	int suspend_count;
51 	struct nfcmrvl_private *priv;
52 };
53 
54 static int nfcmrvl_inc_tx(struct nfcmrvl_usb_drv_data *drv_data)
55 {
56 	unsigned long flags;
57 	int rv;
58 
59 	spin_lock_irqsave(&drv_data->txlock, flags);
60 	rv = test_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
61 	if (!rv)
62 		drv_data->tx_in_flight++;
63 	spin_unlock_irqrestore(&drv_data->txlock, flags);
64 
65 	return rv;
66 }
67 
68 static void nfcmrvl_bulk_complete(struct urb *urb)
69 {
70 	struct nfcmrvl_usb_drv_data *drv_data = urb->context;
71 	struct sk_buff *skb;
72 	int err;
73 
74 	dev_dbg(&drv_data->udev->dev, "urb %p status %d count %d\n",
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 		skb = nci_skb_alloc(drv_data->priv->ndev, urb->actual_length,
82 				    GFP_ATOMIC);
83 		if (!skb) {
84 			nfc_err(&drv_data->udev->dev, "failed to alloc mem\n");
85 		} else {
86 			skb_put_data(skb, urb->transfer_buffer,
87 				     urb->actual_length);
88 			if (nfcmrvl_nci_recv_frame(drv_data->priv, skb) < 0)
89 				nfc_err(&drv_data->udev->dev,
90 					"corrupted Rx packet\n");
91 		}
92 	}
93 
94 	if (!test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags))
95 		return;
96 
97 	usb_anchor_urb(urb, &drv_data->bulk_anchor);
98 	usb_mark_last_busy(drv_data->udev);
99 
100 	err = usb_submit_urb(urb, GFP_ATOMIC);
101 	if (err) {
102 		/* -EPERM: urb is being killed;
103 		 * -ENODEV: device got disconnected
104 		 */
105 		if (err != -EPERM && err != -ENODEV)
106 			nfc_err(&drv_data->udev->dev,
107 				"urb %p failed to resubmit (%d)\n", urb, -err);
108 		usb_unanchor_urb(urb);
109 	}
110 }
111 
112 static int
113 nfcmrvl_submit_bulk_urb(struct nfcmrvl_usb_drv_data *drv_data, gfp_t mem_flags)
114 {
115 	struct urb *urb;
116 	unsigned char *buf;
117 	unsigned int pipe;
118 	int err, size = NFCMRVL_NCI_MAX_EVENT_SIZE;
119 
120 	if (!drv_data->bulk_rx_ep)
121 		return -ENODEV;
122 
123 	urb = usb_alloc_urb(0, mem_flags);
124 	if (!urb)
125 		return -ENOMEM;
126 
127 	buf = kmalloc(size, mem_flags);
128 	if (!buf) {
129 		usb_free_urb(urb);
130 		return -ENOMEM;
131 	}
132 
133 	pipe = usb_rcvbulkpipe(drv_data->udev,
134 			       drv_data->bulk_rx_ep->bEndpointAddress);
135 
136 	usb_fill_bulk_urb(urb, drv_data->udev, pipe, buf, size,
137 			  nfcmrvl_bulk_complete, drv_data);
138 
139 	urb->transfer_flags |= URB_FREE_BUFFER;
140 
141 	usb_mark_last_busy(drv_data->udev);
142 	usb_anchor_urb(urb, &drv_data->bulk_anchor);
143 
144 	err = usb_submit_urb(urb, mem_flags);
145 	if (err) {
146 		if (err != -EPERM && err != -ENODEV)
147 			nfc_err(&drv_data->udev->dev,
148 				"urb %p submission failed (%d)\n", urb, -err);
149 		usb_unanchor_urb(urb);
150 	}
151 
152 	usb_free_urb(urb);
153 
154 	return err;
155 }
156 
157 static void nfcmrvl_tx_complete(struct urb *urb)
158 {
159 	struct sk_buff *skb = urb->context;
160 	struct nci_dev *ndev = (struct nci_dev *)skb->dev;
161 	struct nfcmrvl_private *priv = nci_get_drvdata(ndev);
162 	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
163 	unsigned long flags;
164 
165 	nfc_info(priv->dev, "urb %p status %d count %d\n",
166 		 urb, urb->status, urb->actual_length);
167 
168 	spin_lock_irqsave(&drv_data->txlock, flags);
169 	drv_data->tx_in_flight--;
170 	spin_unlock_irqrestore(&drv_data->txlock, flags);
171 
172 	kfree(urb->setup_packet);
173 	kfree_skb(skb);
174 }
175 
176 static int nfcmrvl_usb_nci_open(struct nfcmrvl_private *priv)
177 {
178 	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
179 	int err;
180 
181 	err = usb_autopm_get_interface(drv_data->intf);
182 	if (err)
183 		return err;
184 
185 	drv_data->intf->needs_remote_wakeup = 1;
186 
187 	err = nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
188 	if (err)
189 		goto failed;
190 
191 	set_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
192 	nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
193 
194 	usb_autopm_put_interface(drv_data->intf);
195 	return 0;
196 
197 failed:
198 	usb_autopm_put_interface(drv_data->intf);
199 	return err;
200 }
201 
202 static void nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data *drv_data)
203 {
204 	usb_kill_anchored_urbs(&drv_data->bulk_anchor);
205 }
206 
207 static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv)
208 {
209 	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
210 	int err;
211 
212 	cancel_work_sync(&drv_data->waker);
213 
214 	clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
215 
216 	nfcmrvl_usb_stop_traffic(drv_data);
217 	usb_kill_anchored_urbs(&drv_data->tx_anchor);
218 	err = usb_autopm_get_interface(drv_data->intf);
219 	if (err)
220 		goto failed;
221 
222 	drv_data->intf->needs_remote_wakeup = 0;
223 	usb_autopm_put_interface(drv_data->intf);
224 
225 failed:
226 	usb_scuttle_anchored_urbs(&drv_data->deferred);
227 	return 0;
228 }
229 
230 static int nfcmrvl_usb_nci_send(struct nfcmrvl_private *priv,
231 				struct sk_buff *skb)
232 {
233 	struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
234 	struct urb *urb;
235 	unsigned int pipe;
236 	int err;
237 
238 	if (!drv_data->bulk_tx_ep)
239 		return -ENODEV;
240 
241 	urb = usb_alloc_urb(0, GFP_ATOMIC);
242 	if (!urb)
243 		return -ENOMEM;
244 
245 	pipe = usb_sndbulkpipe(drv_data->udev,
246 				drv_data->bulk_tx_ep->bEndpointAddress);
247 
248 	usb_fill_bulk_urb(urb, drv_data->udev, pipe, skb->data, skb->len,
249 			  nfcmrvl_tx_complete, skb);
250 
251 	err = nfcmrvl_inc_tx(drv_data);
252 	if (err) {
253 		usb_anchor_urb(urb, &drv_data->deferred);
254 		schedule_work(&drv_data->waker);
255 		err = 0;
256 		goto done;
257 	}
258 
259 	usb_anchor_urb(urb, &drv_data->tx_anchor);
260 
261 	err = usb_submit_urb(urb, GFP_ATOMIC);
262 	if (err) {
263 		if (err != -EPERM && err != -ENODEV)
264 			nfc_err(&drv_data->udev->dev,
265 				"urb %p submission failed (%d)\n", urb, -err);
266 		kfree(urb->setup_packet);
267 		usb_unanchor_urb(urb);
268 	} else {
269 		usb_mark_last_busy(drv_data->udev);
270 	}
271 
272 done:
273 	usb_free_urb(urb);
274 	return err;
275 }
276 
277 static struct nfcmrvl_if_ops usb_ops = {
278 	.nci_open = nfcmrvl_usb_nci_open,
279 	.nci_close = nfcmrvl_usb_nci_close,
280 	.nci_send = nfcmrvl_usb_nci_send,
281 };
282 
283 static void nfcmrvl_waker(struct work_struct *work)
284 {
285 	struct nfcmrvl_usb_drv_data *drv_data =
286 			container_of(work, struct nfcmrvl_usb_drv_data, waker);
287 	int err;
288 
289 	err = usb_autopm_get_interface(drv_data->intf);
290 	if (err)
291 		return;
292 
293 	usb_autopm_put_interface(drv_data->intf);
294 }
295 
296 static int nfcmrvl_probe(struct usb_interface *intf,
297 			 const struct usb_device_id *id)
298 {
299 	struct usb_endpoint_descriptor *ep_desc;
300 	struct nfcmrvl_usb_drv_data *drv_data;
301 	struct nfcmrvl_private *priv;
302 	int i;
303 	struct usb_device *udev = interface_to_usbdev(intf);
304 	struct nfcmrvl_platform_data config;
305 
306 	/* No configuration for USB */
307 	memset(&config, 0, sizeof(config));
308 	config.reset_n_io = -EINVAL;
309 
310 	nfc_info(&udev->dev, "intf %p id %p\n", intf, id);
311 
312 	drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
313 	if (!drv_data)
314 		return -ENOMEM;
315 
316 	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
317 		ep_desc = &intf->cur_altsetting->endpoint[i].desc;
318 
319 		if (!drv_data->bulk_tx_ep &&
320 		    usb_endpoint_is_bulk_out(ep_desc)) {
321 			drv_data->bulk_tx_ep = ep_desc;
322 			continue;
323 		}
324 
325 		if (!drv_data->bulk_rx_ep &&
326 		    usb_endpoint_is_bulk_in(ep_desc)) {
327 			drv_data->bulk_rx_ep = ep_desc;
328 			continue;
329 		}
330 	}
331 
332 	if (!drv_data->bulk_tx_ep || !drv_data->bulk_rx_ep)
333 		return -ENODEV;
334 
335 	drv_data->udev = udev;
336 	drv_data->intf = intf;
337 
338 	INIT_WORK(&drv_data->waker, nfcmrvl_waker);
339 	spin_lock_init(&drv_data->txlock);
340 
341 	init_usb_anchor(&drv_data->tx_anchor);
342 	init_usb_anchor(&drv_data->bulk_anchor);
343 	init_usb_anchor(&drv_data->deferred);
344 
345 	priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_USB, drv_data, &usb_ops,
346 					&intf->dev, &config);
347 	if (IS_ERR(priv))
348 		return PTR_ERR(priv);
349 
350 	drv_data->priv = priv;
351 	drv_data->priv->support_fw_dnld = false;
352 
353 	usb_set_intfdata(intf, drv_data);
354 
355 	return 0;
356 }
357 
358 static void nfcmrvl_disconnect(struct usb_interface *intf)
359 {
360 	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
361 
362 	if (!drv_data)
363 		return;
364 
365 	nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
366 
367 	nfcmrvl_nci_unregister_dev(drv_data->priv);
368 
369 	usb_set_intfdata(drv_data->intf, NULL);
370 }
371 
372 #ifdef CONFIG_PM
373 static int nfcmrvl_suspend(struct usb_interface *intf, pm_message_t message)
374 {
375 	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
376 
377 	nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
378 
379 	if (drv_data->suspend_count++)
380 		return 0;
381 
382 	spin_lock_irq(&drv_data->txlock);
383 	if (!(PMSG_IS_AUTO(message) && drv_data->tx_in_flight)) {
384 		set_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
385 		spin_unlock_irq(&drv_data->txlock);
386 	} else {
387 		spin_unlock_irq(&drv_data->txlock);
388 		drv_data->suspend_count--;
389 		return -EBUSY;
390 	}
391 
392 	nfcmrvl_usb_stop_traffic(drv_data);
393 	usb_kill_anchored_urbs(&drv_data->tx_anchor);
394 
395 	return 0;
396 }
397 
398 static void nfcmrvl_play_deferred(struct nfcmrvl_usb_drv_data *drv_data)
399 {
400 	struct urb *urb;
401 	int err;
402 
403 	while ((urb = usb_get_from_anchor(&drv_data->deferred))) {
404 		err = usb_submit_urb(urb, GFP_ATOMIC);
405 		if (err)
406 			break;
407 
408 		drv_data->tx_in_flight++;
409 	}
410 	usb_scuttle_anchored_urbs(&drv_data->deferred);
411 }
412 
413 static int nfcmrvl_resume(struct usb_interface *intf)
414 {
415 	struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
416 	int err = 0;
417 
418 	nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
419 
420 	if (--drv_data->suspend_count)
421 		return 0;
422 
423 	if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
424 		goto done;
425 
426 	if (test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags)) {
427 		err = nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
428 		if (err) {
429 			clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
430 			goto failed;
431 		}
432 
433 		nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
434 	}
435 
436 	spin_lock_irq(&drv_data->txlock);
437 	nfcmrvl_play_deferred(drv_data);
438 	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
439 	spin_unlock_irq(&drv_data->txlock);
440 
441 	return 0;
442 
443 failed:
444 	usb_scuttle_anchored_urbs(&drv_data->deferred);
445 done:
446 	spin_lock_irq(&drv_data->txlock);
447 	clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
448 	spin_unlock_irq(&drv_data->txlock);
449 
450 	return err;
451 }
452 #endif
453 
454 static struct usb_driver nfcmrvl_usb_driver = {
455 	.name		= "nfcmrvl",
456 	.probe		= nfcmrvl_probe,
457 	.disconnect	= nfcmrvl_disconnect,
458 #ifdef CONFIG_PM
459 	.suspend	= nfcmrvl_suspend,
460 	.resume		= nfcmrvl_resume,
461 	.reset_resume	= nfcmrvl_resume,
462 #endif
463 	.id_table	= nfcmrvl_table,
464 	.supports_autosuspend = 1,
465 	.disable_hub_initiated_lpm = 1,
466 	.soft_unbind = 1,
467 };
468 module_usb_driver(nfcmrvl_usb_driver);
469 
470 MODULE_AUTHOR("Marvell International Ltd.");
471 MODULE_DESCRIPTION("Marvell NFC-over-USB driver");
472 MODULE_LICENSE("GPL v2");
473