This source file includes following definitions.
- nfcmrvl_inc_tx
- nfcmrvl_bulk_complete
- nfcmrvl_submit_bulk_urb
- nfcmrvl_tx_complete
- nfcmrvl_usb_nci_open
- nfcmrvl_usb_stop_traffic
- nfcmrvl_usb_nci_close
- nfcmrvl_usb_nci_send
- nfcmrvl_waker
- nfcmrvl_probe
- nfcmrvl_disconnect
- nfcmrvl_suspend
- nfcmrvl_play_deferred
- nfcmrvl_resume
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 { }
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
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
103
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
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");