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