?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs/Makefile: Stupid typo breakage of exofs inclusion
[linux-btrfs-devel.git] / net / nfc / nci / core.c
blob4047e29acb3b0f1eeac3d030c8ae7642399d80f1
1 /*
2 * The NFC Controller Interface is the communication protocol between an
3 * NFC Controller (NFCC) and a Device Host (DH).
4 *
5 * Copyright (C) 2011 Texas Instruments, Inc.
6 *
7 * Written by Ilan Elias <ilane@ti.com>
8 *
9 * Acknowledgements:
10 * This file is based on hci_core.c, which was written
11 * by Maxim Krasnyansky.
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2
15 * as published by the Free Software Foundation
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 */
27
28 #include <linux/types.h>
29 #include <linux/workqueue.h>
30 #include <linux/completion.h>
31 #include <linux/sched.h>
32 #include <linux/bitops.h>
33 #include <linux/skbuff.h>
34
35 #include "../nfc.h"
36 #include <net/nfc/nci.h>
37 #include <net/nfc/nci_core.h>
38 #include <linux/nfc.h>
39
40 static void nci_cmd_work(struct work_struct *work);
41 static void nci_rx_work(struct work_struct *work);
42 static void nci_tx_work(struct work_struct *work);
43
44 /* ---- NCI requests ---- */
45
46 void nci_req_complete(struct nci_dev *ndev, int result)
47 {
48 if (ndev->req_status == NCI_REQ_PEND) {
49 ndev->req_result = result;
50 ndev->req_status = NCI_REQ_DONE;
51 complete(&ndev->req_completion);
52 }
53 }
54
55 static void nci_req_cancel(struct nci_dev *ndev, int err)
56 {
57 if (ndev->req_status == NCI_REQ_PEND) {
58 ndev->req_result = err;
59 ndev->req_status = NCI_REQ_CANCELED;
60 complete(&ndev->req_completion);
61 }
62 }
63
64 /* Execute request and wait for completion. */
65 static int __nci_request(struct nci_dev *ndev,
66 void (*req)(struct nci_dev *ndev, unsigned long opt),
67 unsigned long opt,
68 __u32 timeout)
69 {
70 int rc = 0;
71 unsigned long completion_rc;
72
73 ndev->req_status = NCI_REQ_PEND;
74
75 init_completion(&ndev->req_completion);
76 req(ndev, opt);
77 completion_rc = wait_for_completion_interruptible_timeout(
78 &ndev->req_completion,
79 timeout);
80
81 nfc_dbg("wait_for_completion return %ld", completion_rc);
82
83 if (completion_rc > 0) {
84 switch (ndev->req_status) {
85 case NCI_REQ_DONE:
86 rc = nci_to_errno(ndev->req_result);
87 break;
88
89 case NCI_REQ_CANCELED:
90 rc = -ndev->req_result;
91 break;
92
93 default:
94 rc = -ETIMEDOUT;
95 break;
96 }
97 } else {
98 nfc_err("wait_for_completion_interruptible_timeout failed %ld",
99 completion_rc);
100
101 rc = ((completion_rc == 0) ? (-ETIMEDOUT) : (completion_rc));
102 }
103
104 ndev->req_status = ndev->req_result = 0;
105
106 return rc;
107 }
108
109 static inline int nci_request(struct nci_dev *ndev,
110 void (*req)(struct nci_dev *ndev, unsigned long opt),
111 unsigned long opt, __u32 timeout)
112 {
113 int rc;
114
115 if (!test_bit(NCI_UP, &ndev->flags))
116 return -ENETDOWN;
117
118 /* Serialize all requests */
119 mutex_lock(&ndev->req_lock);
120 rc = __nci_request(ndev, req, opt, timeout);
121 mutex_unlock(&ndev->req_lock);
122
123 return rc;
124 }
125
126 static void nci_reset_req(struct nci_dev *ndev, unsigned long opt)
127 {
128 nci_send_cmd(ndev, NCI_OP_CORE_RESET_CMD, 0, NULL);
129 }
130
131 static void nci_init_req(struct nci_dev *ndev, unsigned long opt)
132 {
133 nci_send_cmd(ndev, NCI_OP_CORE_INIT_CMD, 0, NULL);
134 }
135
136 static void nci_init_complete_req(struct nci_dev *ndev, unsigned long opt)
137 {
138 struct nci_core_conn_create_cmd conn_cmd;
139 struct nci_rf_disc_map_cmd cmd;
140 struct disc_map_config *cfg = cmd.mapping_configs;
141 __u8 *num = &cmd.num_mapping_configs;
142 int i;
143
144 /* create static rf connection */
145 conn_cmd.target_handle = 0;
146 conn_cmd.num_target_specific_params = 0;
147 nci_send_cmd(ndev, NCI_OP_CORE_CONN_CREATE_CMD, 2, &conn_cmd);
148
149 /* set rf mapping configurations */
150 *num = 0;
151
152 /* by default mapping is set to NCI_RF_INTERFACE_FRAME */
153 for (i = 0; i < ndev->num_supported_rf_interfaces; i++) {
154 if (ndev->supported_rf_interfaces[i] ==
155 NCI_RF_INTERFACE_ISO_DEP) {
156 cfg[*num].rf_protocol = NCI_RF_PROTOCOL_ISO_DEP;
157 cfg[*num].mode = NCI_DISC_MAP_MODE_BOTH;
158 cfg[*num].rf_interface_type = NCI_RF_INTERFACE_ISO_DEP;
159 (*num)++;
160 } else if (ndev->supported_rf_interfaces[i] ==
161 NCI_RF_INTERFACE_NFC_DEP) {
162 cfg[*num].rf_protocol = NCI_RF_PROTOCOL_NFC_DEP;
163 cfg[*num].mode = NCI_DISC_MAP_MODE_BOTH;
164 cfg[*num].rf_interface_type = NCI_RF_INTERFACE_NFC_DEP;
165 (*num)++;
166 }
167
168 if (*num == NCI_MAX_NUM_MAPPING_CONFIGS)
169 break;
170 }
171
172 nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_MAP_CMD,
173 (1 + ((*num)*sizeof(struct disc_map_config))),
174 &cmd);
175 }
176
177 static void nci_rf_discover_req(struct nci_dev *ndev, unsigned long opt)
178 {
179 struct nci_rf_disc_cmd cmd;
180 __u32 protocols = opt;
181
182 cmd.num_disc_configs = 0;
183
184 if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
185 (protocols & NFC_PROTO_JEWEL_MASK
186 || protocols & NFC_PROTO_MIFARE_MASK
187 || protocols & NFC_PROTO_ISO14443_MASK
188 || protocols & NFC_PROTO_NFC_DEP_MASK)) {
189 cmd.disc_configs[cmd.num_disc_configs].type =
190 NCI_DISCOVERY_TYPE_POLL_A_PASSIVE;
191 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
192 cmd.num_disc_configs++;
193 }
194
195 if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
196 (protocols & NFC_PROTO_ISO14443_MASK)) {
197 cmd.disc_configs[cmd.num_disc_configs].type =
198 NCI_DISCOVERY_TYPE_POLL_B_PASSIVE;
199 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
200 cmd.num_disc_configs++;
201 }
202
203 if ((cmd.num_disc_configs < NCI_MAX_NUM_RF_CONFIGS) &&
204 (protocols & NFC_PROTO_FELICA_MASK
205 || protocols & NFC_PROTO_NFC_DEP_MASK)) {
206 cmd.disc_configs[cmd.num_disc_configs].type =
207 NCI_DISCOVERY_TYPE_POLL_F_PASSIVE;
208 cmd.disc_configs[cmd.num_disc_configs].frequency = 1;
209 cmd.num_disc_configs++;
210 }
211
212 nci_send_cmd(ndev, NCI_OP_RF_DISCOVER_CMD,
213 (1 + (cmd.num_disc_configs*sizeof(struct disc_config))),
214 &cmd);
215 }
216
217 static void nci_rf_deactivate_req(struct nci_dev *ndev, unsigned long opt)
218 {
219 struct nci_rf_deactivate_cmd cmd;
220
221 cmd.type = NCI_DEACTIVATE_TYPE_IDLE_MODE;
222
223 nci_send_cmd(ndev, NCI_OP_RF_DEACTIVATE_CMD,
224 sizeof(struct nci_rf_deactivate_cmd),
225 &cmd);
226 }
227
228 static int nci_open_device(struct nci_dev *ndev)
229 {
230 int rc = 0;
231
232 mutex_lock(&ndev->req_lock);
233
234 if (test_bit(NCI_UP, &ndev->flags)) {
235 rc = -EALREADY;
236 goto done;
237 }
238
239 if (ndev->ops->open(ndev)) {
240 rc = -EIO;
241 goto done;
242 }
243
244 atomic_set(&ndev->cmd_cnt, 1);
245
246 set_bit(NCI_INIT, &ndev->flags);
247
248 rc = __nci_request(ndev, nci_reset_req, 0,
249 msecs_to_jiffies(NCI_RESET_TIMEOUT));
250
251 if (!rc) {
252 rc = __nci_request(ndev, nci_init_req, 0,
253 msecs_to_jiffies(NCI_INIT_TIMEOUT));
254 }
255
256 if (!rc) {
257 rc = __nci_request(ndev, nci_init_complete_req, 0,
258 msecs_to_jiffies(NCI_INIT_TIMEOUT));
259 }
260
261 clear_bit(NCI_INIT, &ndev->flags);
262
263 if (!rc) {
264 set_bit(NCI_UP, &ndev->flags);
265 } else {
266 /* Init failed, cleanup */
267 skb_queue_purge(&ndev->cmd_q);
268 skb_queue_purge(&ndev->rx_q);
269 skb_queue_purge(&ndev->tx_q);
270
271 ndev->ops->close(ndev);
272 ndev->flags = 0;
273 }
274
275 done:
276 mutex_unlock(&ndev->req_lock);
277 return rc;
278 }
279
280 static int nci_close_device(struct nci_dev *ndev)
281 {
282 nci_req_cancel(ndev, ENODEV);
283 mutex_lock(&ndev->req_lock);
284
285 if (!test_and_clear_bit(NCI_UP, &ndev->flags)) {
286 del_timer_sync(&ndev->cmd_timer);
287 mutex_unlock(&ndev->req_lock);
288 return 0;
289 }
290
291 /* Drop RX and TX queues */
292 skb_queue_purge(&ndev->rx_q);
293 skb_queue_purge(&ndev->tx_q);
294
295 /* Flush RX and TX wq */
296 flush_workqueue(ndev->rx_wq);
297 flush_workqueue(ndev->tx_wq);
298
299 /* Reset device */
300 skb_queue_purge(&ndev->cmd_q);
301 atomic_set(&ndev->cmd_cnt, 1);
302
303 set_bit(NCI_INIT, &ndev->flags);
304 __nci_request(ndev, nci_reset_req, 0,
305 msecs_to_jiffies(NCI_RESET_TIMEOUT));
306 clear_bit(NCI_INIT, &ndev->flags);
307
308 /* Flush cmd wq */
309 flush_workqueue(ndev->cmd_wq);
310
311 /* After this point our queues are empty
312 * and no works are scheduled. */
313 ndev->ops->close(ndev);
314
315 /* Clear flags */
316 ndev->flags = 0;
317
318 mutex_unlock(&ndev->req_lock);
319
320 return 0;
321 }
322
323 /* NCI command timer function */
324 static void nci_cmd_timer(unsigned long arg)
325 {
326 struct nci_dev *ndev = (void *) arg;
327
328 nfc_dbg("entry");
329
330 atomic_set(&ndev->cmd_cnt, 1);
331 queue_work(ndev->cmd_wq, &ndev->cmd_work);
332 }
333
334 static int nci_dev_up(struct nfc_dev *nfc_dev)
335 {
336 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
337
338 nfc_dbg("entry");
339
340 return nci_open_device(ndev);
341 }
342
343 static int nci_dev_down(struct nfc_dev *nfc_dev)
344 {
345 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
346
347 nfc_dbg("entry");
348
349 return nci_close_device(ndev);
350 }
351
352 static int nci_start_poll(struct nfc_dev *nfc_dev, __u32 protocols)
353 {
354 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
355 int rc;
356
357 nfc_dbg("entry");
358
359 if (test_bit(NCI_DISCOVERY, &ndev->flags)) {
360 nfc_err("unable to start poll, since poll is already active");
361 return -EBUSY;
362 }
363
364 if (ndev->target_active_prot) {
365 nfc_err("there is an active target");
366 return -EBUSY;
367 }
368
369 if (test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
370 nfc_dbg("target is active, implicitly deactivate...");
371
372 rc = nci_request(ndev, nci_rf_deactivate_req, 0,
373 msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
374 if (rc)
375 return -EBUSY;
376 }
377
378 rc = nci_request(ndev, nci_rf_discover_req, protocols,
379 msecs_to_jiffies(NCI_RF_DISC_TIMEOUT));
380
381 if (!rc)
382 ndev->poll_prots = protocols;
383
384 return rc;
385 }
386
387 static void nci_stop_poll(struct nfc_dev *nfc_dev)
388 {
389 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
390
391 nfc_dbg("entry");
392
393 if (!test_bit(NCI_DISCOVERY, &ndev->flags)) {
394 nfc_err("unable to stop poll, since poll is not active");
395 return;
396 }
397
398 nci_request(ndev, nci_rf_deactivate_req, 0,
399 msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
400 }
401
402 static int nci_activate_target(struct nfc_dev *nfc_dev, __u32 target_idx,
403 __u32 protocol)
404 {
405 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
406
407 nfc_dbg("entry, target_idx %d, protocol 0x%x", target_idx, protocol);
408
409 if (!test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
410 nfc_err("there is no available target to activate");
411 return -EINVAL;
412 }
413
414 if (ndev->target_active_prot) {
415 nfc_err("there is already an active target");
416 return -EBUSY;
417 }
418
419 if (!(ndev->target_available_prots & (1 << protocol))) {
420 nfc_err("target does not support the requested protocol 0x%x",
421 protocol);
422 return -EINVAL;
423 }
424
425 ndev->target_active_prot = protocol;
426 ndev->target_available_prots = 0;
427
428 return 0;
429 }
430
431 static void nci_deactivate_target(struct nfc_dev *nfc_dev, __u32 target_idx)
432 {
433 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
434
435 nfc_dbg("entry, target_idx %d", target_idx);
436
437 if (!ndev->target_active_prot) {
438 nfc_err("unable to deactivate target, no active target");
439 return;
440 }
441
442 ndev->target_active_prot = 0;
443
444 if (test_bit(NCI_POLL_ACTIVE, &ndev->flags)) {
445 nci_request(ndev, nci_rf_deactivate_req, 0,
446 msecs_to_jiffies(NCI_RF_DEACTIVATE_TIMEOUT));
447 }
448 }
449
450 static int nci_data_exchange(struct nfc_dev *nfc_dev, __u32 target_idx,
451 struct sk_buff *skb,
452 data_exchange_cb_t cb,
453 void *cb_context)
454 {
455 struct nci_dev *ndev = nfc_get_drvdata(nfc_dev);
456 int rc;
457
458 nfc_dbg("entry, target_idx %d, len %d", target_idx, skb->len);
459
460 if (!ndev->target_active_prot) {
461 nfc_err("unable to exchange data, no active target");
462 return -EINVAL;
463 }
464
465 if (test_and_set_bit(NCI_DATA_EXCHANGE, &ndev->flags))
466 return -EBUSY;
467
468 /* store cb and context to be used on receiving data */
469 ndev->data_exchange_cb = cb;
470 ndev->data_exchange_cb_context = cb_context;
471
472 rc = nci_send_data(ndev, ndev->conn_id, skb);
473 if (rc)
474 clear_bit(NCI_DATA_EXCHANGE, &ndev->flags);
475
476 return rc;
477 }
478
479 static struct nfc_ops nci_nfc_ops = {
480 .dev_up = nci_dev_up,
481 .dev_down = nci_dev_down,
482 .start_poll = nci_start_poll,
483 .stop_poll = nci_stop_poll,
484 .activate_target = nci_activate_target,
485 .deactivate_target = nci_deactivate_target,
486 .data_exchange = nci_data_exchange,
487 };
488
489 /* ---- Interface to NCI drivers ---- */
490
491 /**
492 * nci_allocate_device - allocate a new nci device
493 *
494 * @ops: device operations
495 * @supported_protocols: NFC protocols supported by the device
496 */
497 struct nci_dev *nci_allocate_device(struct nci_ops *ops,
498 __u32 supported_protocols,
499 int tx_headroom,
500 int tx_tailroom)
501 {
502 struct nci_dev *ndev;
503
504 nfc_dbg("entry, supported_protocols 0x%x", supported_protocols);
505
506 if (!ops->open || !ops->close || !ops->send)
507 return NULL;
508
509 if (!supported_protocols)
510 return NULL;
511
512 ndev = kzalloc(sizeof(struct nci_dev), GFP_KERNEL);
513 if (!ndev)
514 return NULL;
515
516 ndev->ops = ops;
517 ndev->tx_headroom = tx_headroom;
518 ndev->tx_tailroom = tx_tailroom;
519
520 ndev->nfc_dev = nfc_allocate_device(&nci_nfc_ops,
521 supported_protocols,
522 tx_headroom + NCI_DATA_HDR_SIZE,
523 tx_tailroom);
524 if (!ndev->nfc_dev)
525 goto free_exit;
526
527 nfc_set_drvdata(ndev->nfc_dev, ndev);
528
529 return ndev;
530
531 free_exit:
532 kfree(ndev);
533 return NULL;
534 }
535 EXPORT_SYMBOL(nci_allocate_device);
536
537 /**
538 * nci_free_device - deallocate nci device
539 *
540 * @ndev: The nci device to deallocate
541 */
542 void nci_free_device(struct nci_dev *ndev)
543 {
544 nfc_dbg("entry");
545
546 nfc_free_device(ndev->nfc_dev);
547 kfree(ndev);
548 }
549 EXPORT_SYMBOL(nci_free_device);
550
551 /**
552 * nci_register_device - register a nci device in the nfc subsystem
553 *
554 * @dev: The nci device to register
555 */
556 int nci_register_device(struct nci_dev *ndev)
557 {
558 int rc;
559 struct device *dev = &ndev->nfc_dev->dev;
560 char name[32];
561
562 nfc_dbg("entry");
563
564 rc = nfc_register_device(ndev->nfc_dev);
565 if (rc)
566 goto exit;
567
568 ndev->flags = 0;
569
570 INIT_WORK(&ndev->cmd_work, nci_cmd_work);
571 snprintf(name, sizeof(name), "%s_nci_cmd_wq", dev_name(dev));
572 ndev->cmd_wq = create_singlethread_workqueue(name);
573 if (!ndev->cmd_wq) {
574 rc = -ENOMEM;
575 goto unreg_exit;
576 }
577
578 INIT_WORK(&ndev->rx_work, nci_rx_work);
579 snprintf(name, sizeof(name), "%s_nci_rx_wq", dev_name(dev));
580 ndev->rx_wq = create_singlethread_workqueue(name);
581 if (!ndev->rx_wq) {
582 rc = -ENOMEM;
583 goto destroy_cmd_wq_exit;
584 }
585
586 INIT_WORK(&ndev->tx_work, nci_tx_work);
587 snprintf(name, sizeof(name), "%s_nci_tx_wq", dev_name(dev));
588 ndev->tx_wq = create_singlethread_workqueue(name);
589 if (!ndev->tx_wq) {
590 rc = -ENOMEM;
591 goto destroy_rx_wq_exit;
592 }
593
594 skb_queue_head_init(&ndev->cmd_q);
595 skb_queue_head_init(&ndev->rx_q);
596 skb_queue_head_init(&ndev->tx_q);
597
598 setup_timer(&ndev->cmd_timer, nci_cmd_timer,
599 (unsigned long) ndev);
600
601 mutex_init(&ndev->req_lock);
602
603 goto exit;
604
605 destroy_rx_wq_exit:
606 destroy_workqueue(ndev->rx_wq);
607
608 destroy_cmd_wq_exit:
609 destroy_workqueue(ndev->cmd_wq);
610
611 unreg_exit:
612 nfc_unregister_device(ndev->nfc_dev);
613
614 exit:
615 return rc;
616 }
617 EXPORT_SYMBOL(nci_register_device);
618
619 /**
620 * nci_unregister_device - unregister a nci device in the nfc subsystem
621 *
622 * @dev: The nci device to unregister
623 */
624 void nci_unregister_device(struct nci_dev *ndev)
625 {
626 nfc_dbg("entry");
627
628 nci_close_device(ndev);
629
630 destroy_workqueue(ndev->cmd_wq);
631 destroy_workqueue(ndev->rx_wq);
632 destroy_workqueue(ndev->tx_wq);
633
634 nfc_unregister_device(ndev->nfc_dev);
635 }
636 EXPORT_SYMBOL(nci_unregister_device);
637
638 /**
639 * nci_recv_frame - receive frame from NCI drivers
640 *
641 * @skb: The sk_buff to receive
642 */
643 int nci_recv_frame(struct sk_buff *skb)
644 {
645 struct nci_dev *ndev = (struct nci_dev *) skb->dev;
646
647 nfc_dbg("entry, len %d", skb->len);
648
649 if (!ndev || (!test_bit(NCI_UP, &ndev->flags)
650 && !test_bit(NCI_INIT, &ndev->flags))) {
651 kfree_skb(skb);
652 return -ENXIO;
653 }
654
655 /* Queue frame for rx worker thread */
656 skb_queue_tail(&ndev->rx_q, skb);
657 queue_work(ndev->rx_wq, &ndev->rx_work);
658
659 return 0;
660 }
661 EXPORT_SYMBOL(nci_recv_frame);
662
663 static int nci_send_frame(struct sk_buff *skb)
664 {
665 struct nci_dev *ndev = (struct nci_dev *) skb->dev;
666
667 nfc_dbg("entry, len %d", skb->len);
668
669 if (!ndev) {
670 kfree_skb(skb);
671 return -ENODEV;
672 }
673
674 /* Get rid of skb owner, prior to sending to the driver. */
675 skb_orphan(skb);
676
677 return ndev->ops->send(skb);
678 }
679
680 /* Send NCI command */
681 int nci_send_cmd(struct nci_dev *ndev, __u16 opcode, __u8 plen, void *payload)
682 {
683 struct nci_ctrl_hdr *hdr;
684 struct sk_buff *skb;
685
686 nfc_dbg("entry, opcode 0x%x, plen %d", opcode, plen);
687
688 skb = nci_skb_alloc(ndev, (NCI_CTRL_HDR_SIZE + plen), GFP_KERNEL);
689 if (!skb) {
690 nfc_err("no memory for command");
691 return -ENOMEM;
692 }
693
694 hdr = (struct nci_ctrl_hdr *) skb_put(skb, NCI_CTRL_HDR_SIZE);
695 hdr->gid = nci_opcode_gid(opcode);
696 hdr->oid = nci_opcode_oid(opcode);
697 hdr->plen = plen;
698
699 nci_mt_set((__u8 *)hdr, NCI_MT_CMD_PKT);
700 nci_pbf_set((__u8 *)hdr, NCI_PBF_LAST);
701
702 if (plen)
703 memcpy(skb_put(skb, plen), payload, plen);
704
705 skb->dev = (void *) ndev;
706
707 skb_queue_tail(&ndev->cmd_q, skb);
708 queue_work(ndev->cmd_wq, &ndev->cmd_work);
709
710 return 0;
711 }
712
713 /* ---- NCI TX Data worker thread ---- */
714
715 static void nci_tx_work(struct work_struct *work)
716 {
717 struct nci_dev *ndev = container_of(work, struct nci_dev, tx_work);
718 struct sk_buff *skb;
719
720 nfc_dbg("entry, credits_cnt %d", atomic_read(&ndev->credits_cnt));
721
722 /* Send queued tx data */
723 while (atomic_read(&ndev->credits_cnt)) {
724 skb = skb_dequeue(&ndev->tx_q);
725 if (!skb)
726 return;
727
728 atomic_dec(&ndev->credits_cnt);
729
730 nfc_dbg("NCI TX: MT=data, PBF=%d, conn_id=%d, plen=%d",
731 nci_pbf(skb->data),
732 nci_conn_id(skb->data),
733 nci_plen(skb->data));
734
735 nci_send_frame(skb);
736 }
737 }
738
739 /* ----- NCI RX worker thread (data & control) ----- */
740
741 static void nci_rx_work(struct work_struct *work)
742 {
743 struct nci_dev *ndev = container_of(work, struct nci_dev, rx_work);
744 struct sk_buff *skb;
745
746 while ((skb = skb_dequeue(&ndev->rx_q))) {
747 /* Process frame */
748 switch (nci_mt(skb->data)) {
749 case NCI_MT_RSP_PKT:
750 nci_rsp_packet(ndev, skb);
751 break;
752
753 case NCI_MT_NTF_PKT:
754 nci_ntf_packet(ndev, skb);
755 break;
756
757 case NCI_MT_DATA_PKT:
758 nci_rx_data_packet(ndev, skb);
759 break;
760
761 default:
762 nfc_err("unknown MT 0x%x", nci_mt(skb->data));
763 kfree_skb(skb);
764 break;
765 }
766 }
767 }
768
769 /* ----- NCI TX CMD worker thread ----- */
770
771 static void nci_cmd_work(struct work_struct *work)
772 {
773 struct nci_dev *ndev = container_of(work, struct nci_dev, cmd_work);
774 struct sk_buff *skb;
775
776 nfc_dbg("entry, cmd_cnt %d", atomic_read(&ndev->cmd_cnt));
777
778 /* Send queued command */
779 if (atomic_read(&ndev->cmd_cnt)) {
780 skb = skb_dequeue(&ndev->cmd_q);
781 if (!skb)
782 return;
783
784 atomic_dec(&ndev->cmd_cnt);
785
786 nfc_dbg("NCI TX: MT=cmd, PBF=%d, GID=0x%x, OID=0x%x, plen=%d",
787 nci_pbf(skb->data),
788 nci_opcode_gid(nci_opcode(skb->data)),
789 nci_opcode_oid(nci_opcode(skb->data)),
790 nci_plen(skb->data));
791
792 nci_send_frame(skb);
793
794 mod_timer(&ndev->cmd_timer,
795 jiffies + msecs_to_jiffies(NCI_CMD_TIMEOUT));
796 }
797 }
Linux Btrfs Development