1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Marvell NFC-over-USB driver: USB interface related functions
4 *
5 * Copyright (C) 2014, Marvell International Ltd.
6 */
7
8 #include <linux/module.h>
9 #include <linux/usb.h>
10 #include <linux/nfc.h>
11 #include <net/nfc/nci.h>
12 #include <net/nfc/nci_core.h>
13 #include "nfcmrvl.h"
14
15 static struct usb_device_id nfcmrvl_table[] = {
16 { USB_DEVICE_AND_INTERFACE_INFO(0x1286, 0x2046,
17 USB_CLASS_VENDOR_SPEC, 4, 1) },
18 { } /* Terminating entry */
19 };
20 MODULE_DEVICE_TABLE(usb, nfcmrvl_table);
21
22 #define NFCMRVL_USB_BULK_RUNNING 1
23 #define NFCMRVL_USB_SUSPENDING 2
24
25 struct nfcmrvl_usb_drv_data {
26 struct usb_device *udev;
27 struct usb_interface *intf;
28 unsigned long flags;
29 struct work_struct waker;
30 struct usb_anchor tx_anchor;
31 struct usb_anchor bulk_anchor;
32 struct usb_anchor deferred;
33 int tx_in_flight;
34 /* protects tx_in_flight */
35 spinlock_t txlock;
36 struct usb_endpoint_descriptor *bulk_tx_ep;
37 struct usb_endpoint_descriptor *bulk_rx_ep;
38 int suspend_count;
39 struct nfcmrvl_private *priv;
40 };
41
nfcmrvl_inc_tx(struct nfcmrvl_usb_drv_data * drv_data)42 static int nfcmrvl_inc_tx(struct nfcmrvl_usb_drv_data *drv_data)
43 {
44 unsigned long flags;
45 int rv;
46
47 spin_lock_irqsave(&drv_data->txlock, flags);
48 rv = test_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
49 if (!rv)
50 drv_data->tx_in_flight++;
51 spin_unlock_irqrestore(&drv_data->txlock, flags);
52
53 return rv;
54 }
55
nfcmrvl_bulk_complete(struct urb * urb)56 static void nfcmrvl_bulk_complete(struct urb *urb)
57 {
58 struct nfcmrvl_usb_drv_data *drv_data = urb->context;
59 int err;
60
61 dev_dbg(&drv_data->udev->dev, "urb %p status %d count %d\n",
62 urb, urb->status, urb->actual_length);
63
64 if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
65 return;
66
67 if (!urb->status) {
68 struct sk_buff *skb;
69
70 skb = nci_skb_alloc(drv_data->priv->ndev, urb->actual_length,
71 GFP_ATOMIC);
72 if (!skb) {
73 nfc_err(&drv_data->udev->dev, "failed to alloc mem\n");
74 } else {
75 skb_put_data(skb, urb->transfer_buffer,
76 urb->actual_length);
77 if (nfcmrvl_nci_recv_frame(drv_data->priv, skb) < 0)
78 nfc_err(&drv_data->udev->dev,
79 "corrupted Rx packet\n");
80 }
81 }
82
83 if (!test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags))
84 return;
85
86 usb_anchor_urb(urb, &drv_data->bulk_anchor);
87 usb_mark_last_busy(drv_data->udev);
88
89 err = usb_submit_urb(urb, GFP_ATOMIC);
90 if (err) {
91 /* -EPERM: urb is being killed;
92 * -ENODEV: device got disconnected
93 */
94 if (err != -EPERM && err != -ENODEV)
95 nfc_err(&drv_data->udev->dev,
96 "urb %p failed to resubmit (%d)\n", urb, -err);
97 usb_unanchor_urb(urb);
98 }
99 }
100
101 static int
nfcmrvl_submit_bulk_urb(struct nfcmrvl_usb_drv_data * drv_data,gfp_t mem_flags)102 nfcmrvl_submit_bulk_urb(struct nfcmrvl_usb_drv_data *drv_data, gfp_t mem_flags)
103 {
104 struct urb *urb;
105 unsigned char *buf;
106 unsigned int pipe;
107 int err, size = NFCMRVL_NCI_MAX_EVENT_SIZE;
108
109 if (!drv_data->bulk_rx_ep)
110 return -ENODEV;
111
112 urb = usb_alloc_urb(0, mem_flags);
113 if (!urb)
114 return -ENOMEM;
115
116 buf = kmalloc(size, mem_flags);
117 if (!buf) {
118 usb_free_urb(urb);
119 return -ENOMEM;
120 }
121
122 pipe = usb_rcvbulkpipe(drv_data->udev,
123 drv_data->bulk_rx_ep->bEndpointAddress);
124
125 usb_fill_bulk_urb(urb, drv_data->udev, pipe, buf, size,
126 nfcmrvl_bulk_complete, drv_data);
127
128 urb->transfer_flags |= URB_FREE_BUFFER;
129
130 usb_mark_last_busy(drv_data->udev);
131 usb_anchor_urb(urb, &drv_data->bulk_anchor);
132
133 err = usb_submit_urb(urb, mem_flags);
134 if (err) {
135 if (err != -EPERM && err != -ENODEV)
136 nfc_err(&drv_data->udev->dev,
137 "urb %p submission failed (%d)\n", urb, -err);
138 usb_unanchor_urb(urb);
139 }
140
141 usb_free_urb(urb);
142
143 return err;
144 }
145
nfcmrvl_tx_complete(struct urb * urb)146 static void nfcmrvl_tx_complete(struct urb *urb)
147 {
148 struct sk_buff *skb = urb->context;
149 struct nci_dev *ndev = (struct nci_dev *)skb->dev;
150 struct nfcmrvl_private *priv = nci_get_drvdata(ndev);
151 struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
152 unsigned long flags;
153
154 nfc_info(priv->dev, "urb %p status %d count %d\n",
155 urb, urb->status, urb->actual_length);
156
157 spin_lock_irqsave(&drv_data->txlock, flags);
158 drv_data->tx_in_flight--;
159 spin_unlock_irqrestore(&drv_data->txlock, flags);
160
161 kfree(urb->setup_packet);
162 kfree_skb(skb);
163 }
164
nfcmrvl_usb_nci_open(struct nfcmrvl_private * priv)165 static int nfcmrvl_usb_nci_open(struct nfcmrvl_private *priv)
166 {
167 struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
168 int err;
169
170 err = usb_autopm_get_interface(drv_data->intf);
171 if (err)
172 return err;
173
174 drv_data->intf->needs_remote_wakeup = 1;
175
176 err = nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
177 if (err)
178 goto failed;
179
180 set_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
181 nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
182
183 usb_autopm_put_interface(drv_data->intf);
184 return 0;
185
186 failed:
187 usb_autopm_put_interface(drv_data->intf);
188 return err;
189 }
190
nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data * drv_data)191 static void nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data *drv_data)
192 {
193 usb_kill_anchored_urbs(&drv_data->bulk_anchor);
194 }
195
nfcmrvl_usb_nci_close(struct nfcmrvl_private * priv)196 static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv)
197 {
198 struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
199 int err;
200
201 cancel_work_sync(&drv_data->waker);
202
203 clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
204
205 nfcmrvl_usb_stop_traffic(drv_data);
206 usb_kill_anchored_urbs(&drv_data->tx_anchor);
207 err = usb_autopm_get_interface(drv_data->intf);
208 if (err)
209 goto failed;
210
211 drv_data->intf->needs_remote_wakeup = 0;
212 usb_autopm_put_interface(drv_data->intf);
213
214 failed:
215 usb_scuttle_anchored_urbs(&drv_data->deferred);
216 return 0;
217 }
218
nfcmrvl_usb_nci_send(struct nfcmrvl_private * priv,struct sk_buff * skb)219 static int nfcmrvl_usb_nci_send(struct nfcmrvl_private *priv,
220 struct sk_buff *skb)
221 {
222 struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
223 struct urb *urb;
224 unsigned int pipe;
225 int err;
226
227 if (!drv_data->bulk_tx_ep)
228 return -ENODEV;
229
230 urb = usb_alloc_urb(0, GFP_ATOMIC);
231 if (!urb)
232 return -ENOMEM;
233
234 pipe = usb_sndbulkpipe(drv_data->udev,
235 drv_data->bulk_tx_ep->bEndpointAddress);
236
237 usb_fill_bulk_urb(urb, drv_data->udev, pipe, skb->data, skb->len,
238 nfcmrvl_tx_complete, skb);
239
240 err = nfcmrvl_inc_tx(drv_data);
241 if (err) {
242 usb_anchor_urb(urb, &drv_data->deferred);
243 schedule_work(&drv_data->waker);
244 err = 0;
245 goto done;
246 }
247
248 usb_anchor_urb(urb, &drv_data->tx_anchor);
249
250 err = usb_submit_urb(urb, GFP_ATOMIC);
251 if (err) {
252 if (err != -EPERM && err != -ENODEV)
253 nfc_err(&drv_data->udev->dev,
254 "urb %p submission failed (%d)\n", urb, -err);
255 kfree(urb->setup_packet);
256 usb_unanchor_urb(urb);
257 } else {
258 usb_mark_last_busy(drv_data->udev);
259 }
260
261 done:
262 usb_free_urb(urb);
263 return err;
264 }
265
266 static const struct nfcmrvl_if_ops usb_ops = {
267 .nci_open = nfcmrvl_usb_nci_open,
268 .nci_close = nfcmrvl_usb_nci_close,
269 .nci_send = nfcmrvl_usb_nci_send,
270 };
271
nfcmrvl_waker(struct work_struct * work)272 static void nfcmrvl_waker(struct work_struct *work)
273 {
274 struct nfcmrvl_usb_drv_data *drv_data =
275 container_of(work, struct nfcmrvl_usb_drv_data, waker);
276 int err;
277
278 err = usb_autopm_get_interface(drv_data->intf);
279 if (err)
280 return;
281
282 usb_autopm_put_interface(drv_data->intf);
283 }
284
nfcmrvl_probe(struct usb_interface * intf,const struct usb_device_id * id)285 static int nfcmrvl_probe(struct usb_interface *intf,
286 const struct usb_device_id *id)
287 {
288 struct nfcmrvl_usb_drv_data *drv_data;
289 struct nfcmrvl_private *priv;
290 struct usb_device *udev = interface_to_usbdev(intf);
291 struct nfcmrvl_platform_data config;
292 int ret;
293
294 /* No configuration for USB */
295 memset(&config, 0, sizeof(config));
296 config.reset_gpio = NULL;
297
298 nfc_info(&udev->dev, "intf %p id %p\n", intf, id);
299
300 drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
301 if (!drv_data)
302 return -ENOMEM;
303
304 ret = usb_find_common_endpoints(intf->cur_altsetting, &drv_data->bulk_rx_ep,
305 &drv_data->bulk_tx_ep, NULL, NULL);
306 if (ret)
307 return -ENODEV;
308
309 drv_data->udev = udev;
310 drv_data->intf = intf;
311
312 INIT_WORK(&drv_data->waker, nfcmrvl_waker);
313 spin_lock_init(&drv_data->txlock);
314
315 init_usb_anchor(&drv_data->tx_anchor);
316 init_usb_anchor(&drv_data->bulk_anchor);
317 init_usb_anchor(&drv_data->deferred);
318
319 priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_USB, drv_data, &usb_ops,
320 &intf->dev, &config);
321 if (IS_ERR(priv))
322 return PTR_ERR(priv);
323
324 drv_data->priv = priv;
325 drv_data->priv->support_fw_dnld = false;
326
327 usb_set_intfdata(intf, drv_data);
328
329 return 0;
330 }
331
nfcmrvl_disconnect(struct usb_interface * intf)332 static void nfcmrvl_disconnect(struct usb_interface *intf)
333 {
334 struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
335
336 if (!drv_data)
337 return;
338
339 nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
340
341 nfcmrvl_nci_unregister_dev(drv_data->priv);
342
343 usb_set_intfdata(drv_data->intf, NULL);
344 }
345
346 #ifdef CONFIG_PM
nfcmrvl_suspend(struct usb_interface * intf,pm_message_t message)347 static int nfcmrvl_suspend(struct usb_interface *intf, pm_message_t message)
348 {
349 struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
350
351 nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
352
353 if (drv_data->suspend_count++)
354 return 0;
355
356 spin_lock_irq(&drv_data->txlock);
357 if (!(PMSG_IS_AUTO(message) && drv_data->tx_in_flight)) {
358 set_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
359 spin_unlock_irq(&drv_data->txlock);
360 } else {
361 spin_unlock_irq(&drv_data->txlock);
362 drv_data->suspend_count--;
363 return -EBUSY;
364 }
365
366 nfcmrvl_usb_stop_traffic(drv_data);
367 usb_kill_anchored_urbs(&drv_data->tx_anchor);
368
369 return 0;
370 }
371
nfcmrvl_play_deferred(struct nfcmrvl_usb_drv_data * drv_data)372 static void nfcmrvl_play_deferred(struct nfcmrvl_usb_drv_data *drv_data)
373 {
374 struct urb *urb;
375 int err;
376
377 while ((urb = usb_get_from_anchor(&drv_data->deferred))) {
378 usb_anchor_urb(urb, &drv_data->tx_anchor);
379
380 err = usb_submit_urb(urb, GFP_ATOMIC);
381 if (err) {
382 kfree(urb->setup_packet);
383 usb_unanchor_urb(urb);
384 usb_free_urb(urb);
385 break;
386 }
387
388 drv_data->tx_in_flight++;
389 usb_free_urb(urb);
390 }
391
392 /* Cleanup the rest deferred urbs. */
393 while ((urb = usb_get_from_anchor(&drv_data->deferred))) {
394 kfree(urb->setup_packet);
395 usb_free_urb(urb);
396 }
397 }
398
nfcmrvl_resume(struct usb_interface * intf)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\n", 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");
458 MODULE_LICENSE("GPL v2");
459