?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.19-rc6
[cris-mirror.git] / net / nfc / hci / core.c
blobef50e7716c4a8742840731db126351fee16bc57b
1 /*
2 * Copyright (C) 2012 Intel Corporation. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #define pr_fmt(fmt) "hci: %s: " fmt, __func__
19
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/nfc.h>
24
25 #include <net/nfc/nfc.h>
26 #include <net/nfc/hci.h>
27 #include <net/nfc/llc.h>
28
29 #include "hci.h"
30
31 /* Largest headroom needed for outgoing HCI commands */
32 #define HCI_CMDS_HEADROOM 1
33
34 int nfc_hci_result_to_errno(u8 result)
35 {
36 switch (result) {
37 case NFC_HCI_ANY_OK:
38 return 0;
39 case NFC_HCI_ANY_E_REG_PAR_UNKNOWN:
40 return -EOPNOTSUPP;
41 case NFC_HCI_ANY_E_TIMEOUT:
42 return -ETIME;
43 default:
44 return -1;
45 }
46 }
47 EXPORT_SYMBOL(nfc_hci_result_to_errno);
48
49 static void nfc_hci_msg_tx_work(struct work_struct *work)
50 {
51 struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
52 msg_tx_work);
53 struct hci_msg *msg;
54 struct sk_buff *skb;
55 int r = 0;
56
57 mutex_lock(&hdev->msg_tx_mutex);
58 if (hdev->shutting_down)
59 goto exit;
60
61 if (hdev->cmd_pending_msg) {
62 if (timer_pending(&hdev->cmd_timer) == 0) {
63 if (hdev->cmd_pending_msg->cb)
64 hdev->cmd_pending_msg->cb(hdev->
65 cmd_pending_msg->
66 cb_context,
67 NULL,
68 -ETIME);
69 kfree(hdev->cmd_pending_msg);
70 hdev->cmd_pending_msg = NULL;
71 } else {
72 goto exit;
73 }
74 }
75
76 next_msg:
77 if (list_empty(&hdev->msg_tx_queue))
78 goto exit;
79
80 msg = list_first_entry(&hdev->msg_tx_queue, struct hci_msg, msg_l);
81 list_del(&msg->msg_l);
82
83 pr_debug("msg_tx_queue has a cmd to send\n");
84 while ((skb = skb_dequeue(&msg->msg_frags)) != NULL) {
85 r = nfc_llc_xmit_from_hci(hdev->llc, skb);
86 if (r < 0) {
87 kfree_skb(skb);
88 skb_queue_purge(&msg->msg_frags);
89 if (msg->cb)
90 msg->cb(msg->cb_context, NULL, r);
91 kfree(msg);
92 break;
93 }
94 }
95
96 if (r)
97 goto next_msg;
98
99 if (msg->wait_response == false) {
100 kfree(msg);
101 goto next_msg;
102 }
103
104 hdev->cmd_pending_msg = msg;
105 mod_timer(&hdev->cmd_timer, jiffies +
106 msecs_to_jiffies(hdev->cmd_pending_msg->completion_delay));
107
108 exit:
109 mutex_unlock(&hdev->msg_tx_mutex);
110 }
111
112 static void nfc_hci_msg_rx_work(struct work_struct *work)
113 {
114 struct nfc_hci_dev *hdev = container_of(work, struct nfc_hci_dev,
115 msg_rx_work);
116 struct sk_buff *skb;
117 struct hcp_message *message;
118 u8 pipe;
119 u8 type;
120 u8 instruction;
121
122 while ((skb = skb_dequeue(&hdev->msg_rx_queue)) != NULL) {
123 pipe = skb->data[0];
124 skb_pull(skb, NFC_HCI_HCP_PACKET_HEADER_LEN);
125 message = (struct hcp_message *)skb->data;
126 type = HCP_MSG_GET_TYPE(message->header);
127 instruction = HCP_MSG_GET_CMD(message->header);
128 skb_pull(skb, NFC_HCI_HCP_MESSAGE_HEADER_LEN);
129
130 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, skb);
131 }
132 }
133
134 static void __nfc_hci_cmd_completion(struct nfc_hci_dev *hdev, int err,
135 struct sk_buff *skb)
136 {
137 del_timer_sync(&hdev->cmd_timer);
138
139 if (hdev->cmd_pending_msg->cb)
140 hdev->cmd_pending_msg->cb(hdev->cmd_pending_msg->cb_context,
141 skb, err);
142 else
143 kfree_skb(skb);
144
145 kfree(hdev->cmd_pending_msg);
146 hdev->cmd_pending_msg = NULL;
147
148 schedule_work(&hdev->msg_tx_work);
149 }
150
151 void nfc_hci_resp_received(struct nfc_hci_dev *hdev, u8 result,
152 struct sk_buff *skb)
153 {
154 mutex_lock(&hdev->msg_tx_mutex);
155
156 if (hdev->cmd_pending_msg == NULL) {
157 kfree_skb(skb);
158 goto exit;
159 }
160
161 __nfc_hci_cmd_completion(hdev, nfc_hci_result_to_errno(result), skb);
162
163 exit:
164 mutex_unlock(&hdev->msg_tx_mutex);
165 }
166
167 void nfc_hci_cmd_received(struct nfc_hci_dev *hdev, u8 pipe, u8 cmd,
168 struct sk_buff *skb)
169 {
170 int r = 0;
171 u8 gate = nfc_hci_pipe2gate(hdev, pipe);
172 u8 local_gate, new_pipe;
173 u8 gate_opened = 0x00;
174
175 pr_debug("from gate %x pipe %x cmd %x\n", gate, pipe, cmd);
176
177 switch (cmd) {
178 case NFC_HCI_ADM_NOTIFY_PIPE_CREATED:
179 if (skb->len != 5) {
180 r = -EPROTO;
181 break;
182 }
183
184 local_gate = skb->data[3];
185 new_pipe = skb->data[4];
186 nfc_hci_send_response(hdev, gate, NFC_HCI_ANY_OK, NULL, 0);
187
188 /* save the new created pipe and bind with local gate,
189 * the description for skb->data[3] is destination gate id
190 * but since we received this cmd from host controller, we
191 * are the destination and it is our local gate
192 */
193 hdev->gate2pipe[local_gate] = new_pipe;
194 break;
195 case NFC_HCI_ANY_OPEN_PIPE:
196 /* if the pipe is already created, we allow remote host to
197 * open it
198 */
199 if (gate != 0xff)
200 nfc_hci_send_response(hdev, gate, NFC_HCI_ANY_OK,
201 &gate_opened, 1);
202 break;
203 case NFC_HCI_ADM_NOTIFY_ALL_PIPE_CLEARED:
204 nfc_hci_send_response(hdev, gate, NFC_HCI_ANY_OK, NULL, 0);
205 break;
206 default:
207 pr_info("Discarded unknown cmd %x to gate %x\n", cmd, gate);
208 r = -EINVAL;
209 break;
210 }
211
212 kfree_skb(skb);
213 }
214
215 u32 nfc_hci_sak_to_protocol(u8 sak)
216 {
217 switch (NFC_HCI_TYPE_A_SEL_PROT(sak)) {
218 case NFC_HCI_TYPE_A_SEL_PROT_MIFARE:
219 return NFC_PROTO_MIFARE_MASK;
220 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443:
221 return NFC_PROTO_ISO14443_MASK;
222 case NFC_HCI_TYPE_A_SEL_PROT_DEP:
223 return NFC_PROTO_NFC_DEP_MASK;
224 case NFC_HCI_TYPE_A_SEL_PROT_ISO14443_DEP:
225 return NFC_PROTO_ISO14443_MASK | NFC_PROTO_NFC_DEP_MASK;
226 default:
227 return 0xffffffff;
228 }
229 }
230 EXPORT_SYMBOL(nfc_hci_sak_to_protocol);
231
232 int nfc_hci_target_discovered(struct nfc_hci_dev *hdev, u8 gate)
233 {
234 struct nfc_target *targets;
235 struct sk_buff *atqa_skb = NULL;
236 struct sk_buff *sak_skb = NULL;
237 struct sk_buff *uid_skb = NULL;
238 int r;
239
240 pr_debug("from gate %d\n", gate);
241
242 targets = kzalloc(sizeof(struct nfc_target), GFP_KERNEL);
243 if (targets == NULL)
244 return -ENOMEM;
245
246 switch (gate) {
247 case NFC_HCI_RF_READER_A_GATE:
248 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
249 NFC_HCI_RF_READER_A_ATQA, &atqa_skb);
250 if (r < 0)
251 goto exit;
252
253 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
254 NFC_HCI_RF_READER_A_SAK, &sak_skb);
255 if (r < 0)
256 goto exit;
257
258 if (atqa_skb->len != 2 || sak_skb->len != 1) {
259 r = -EPROTO;
260 goto exit;
261 }
262
263 targets->supported_protocols =
264 nfc_hci_sak_to_protocol(sak_skb->data[0]);
265 if (targets->supported_protocols == 0xffffffff) {
266 r = -EPROTO;
267 goto exit;
268 }
269
270 targets->sens_res = be16_to_cpu(*(__be16 *)atqa_skb->data);
271 targets->sel_res = sak_skb->data[0];
272
273 r = nfc_hci_get_param(hdev, NFC_HCI_RF_READER_A_GATE,
274 NFC_HCI_RF_READER_A_UID, &uid_skb);
275 if (r < 0)
276 goto exit;
277
278 if (uid_skb->len == 0 || uid_skb->len > NFC_NFCID1_MAXSIZE) {
279 r = -EPROTO;
280 goto exit;
281 }
282
283 memcpy(targets->nfcid1, uid_skb->data, uid_skb->len);
284 targets->nfcid1_len = uid_skb->len;
285
286 if (hdev->ops->complete_target_discovered) {
287 r = hdev->ops->complete_target_discovered(hdev, gate,
288 targets);
289 if (r < 0)
290 goto exit;
291 }
292 break;
293 case NFC_HCI_RF_READER_B_GATE:
294 targets->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
295 break;
296 default:
297 if (hdev->ops->target_from_gate)
298 r = hdev->ops->target_from_gate(hdev, gate, targets);
299 else
300 r = -EPROTO;
301 if (r < 0)
302 goto exit;
303
304 if (hdev->ops->complete_target_discovered) {
305 r = hdev->ops->complete_target_discovered(hdev, gate,
306 targets);
307 if (r < 0)
308 goto exit;
309 }
310 break;
311 }
312
313 /* if driver set the new gate, we will skip the old one */
314 if (targets->hci_reader_gate == 0x00)
315 targets->hci_reader_gate = gate;
316
317 r = nfc_targets_found(hdev->ndev, targets, 1);
318
319 exit:
320 kfree(targets);
321 kfree_skb(atqa_skb);
322 kfree_skb(sak_skb);
323 kfree_skb(uid_skb);
324
325 return r;
326 }
327 EXPORT_SYMBOL(nfc_hci_target_discovered);
328
329 void nfc_hci_event_received(struct nfc_hci_dev *hdev, u8 pipe, u8 event,
330 struct sk_buff *skb)
331 {
332 int r = 0;
333 u8 gate = nfc_hci_pipe2gate(hdev, pipe);
334
335 if (gate == 0xff) {
336 pr_err("Discarded event %x to unopened pipe %x\n", event, pipe);
337 goto exit;
338 }
339
340 if (hdev->ops->event_received) {
341 r = hdev->ops->event_received(hdev, gate, event, skb);
342 if (r <= 0)
343 goto exit_noskb;
344 }
345
346 switch (event) {
347 case NFC_HCI_EVT_TARGET_DISCOVERED:
348 if (skb->len < 1) { /* no status data? */
349 r = -EPROTO;
350 goto exit;
351 }
352
353 if (skb->data[0] == 3) {
354 /* TODO: Multiple targets in field, none activated
355 * poll is supposedly stopped, but there is no
356 * single target to activate, so nothing to report
357 * up.
358 * if we need to restart poll, we must save the
359 * protocols from the initial poll and reuse here.
360 */
361 }
362
363 if (skb->data[0] != 0) {
364 r = -EPROTO;
365 goto exit;
366 }
367
368 r = nfc_hci_target_discovered(hdev, gate);
369 break;
370 default:
371 pr_info("Discarded unknown event %x to gate %x\n", event, gate);
372 r = -EINVAL;
373 break;
374 }
375
376 exit:
377 kfree_skb(skb);
378
379 exit_noskb:
380 if (r)
381 nfc_hci_driver_failure(hdev, r);
382 }
383
384 static void nfc_hci_cmd_timeout(unsigned long data)
385 {
386 struct nfc_hci_dev *hdev = (struct nfc_hci_dev *)data;
387
388 schedule_work(&hdev->msg_tx_work);
389 }
390
391 static int hci_dev_connect_gates(struct nfc_hci_dev *hdev, u8 gate_count,
392 struct nfc_hci_gate *gates)
393 {
394 int r;
395 while (gate_count--) {
396 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID,
397 gates->gate, gates->pipe);
398 if (r < 0)
399 return r;
400 gates++;
401 }
402
403 return 0;
404 }
405
406 static int hci_dev_session_init(struct nfc_hci_dev *hdev)
407 {
408 struct sk_buff *skb = NULL;
409 int r;
410
411 if (hdev->init_data.gates[0].gate != NFC_HCI_ADMIN_GATE)
412 return -EPROTO;
413
414 r = nfc_hci_connect_gate(hdev, NFC_HCI_HOST_CONTROLLER_ID,
415 hdev->init_data.gates[0].gate,
416 hdev->init_data.gates[0].pipe);
417 if (r < 0)
418 goto exit;
419
420 r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE,
421 NFC_HCI_ADMIN_SESSION_IDENTITY, &skb);
422 if (r < 0)
423 goto disconnect_all;
424
425 if (skb->len && skb->len == strlen(hdev->init_data.session_id) &&
426 (memcmp(hdev->init_data.session_id, skb->data,
427 skb->len) == 0) && hdev->ops->load_session) {
428 /* Restore gate<->pipe table from some proprietary location. */
429
430 r = hdev->ops->load_session(hdev);
431
432 if (r < 0)
433 goto disconnect_all;
434 } else {
435
436 r = nfc_hci_disconnect_all_gates(hdev);
437 if (r < 0)
438 goto exit;
439
440 r = hci_dev_connect_gates(hdev, hdev->init_data.gate_count,
441 hdev->init_data.gates);
442 if (r < 0)
443 goto disconnect_all;
444
445 r = nfc_hci_set_param(hdev, NFC_HCI_ADMIN_GATE,
446 NFC_HCI_ADMIN_SESSION_IDENTITY,
447 hdev->init_data.session_id,
448 strlen(hdev->init_data.session_id));
449 }
450 if (r == 0)
451 goto exit;
452
453 disconnect_all:
454 nfc_hci_disconnect_all_gates(hdev);
455
456 exit:
457 kfree_skb(skb);
458
459 return r;
460 }
461
462 static int hci_dev_version(struct nfc_hci_dev *hdev)
463 {
464 int r;
465 struct sk_buff *skb;
466
467 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
468 NFC_HCI_ID_MGMT_VERSION_SW, &skb);
469 if (r == -EOPNOTSUPP) {
470 pr_info("Software/Hardware info not available\n");
471 return 0;
472 }
473 if (r < 0)
474 return r;
475
476 if (skb->len != 3) {
477 kfree_skb(skb);
478 return -EINVAL;
479 }
480
481 hdev->sw_romlib = (skb->data[0] & 0xf0) >> 4;
482 hdev->sw_patch = skb->data[0] & 0x0f;
483 hdev->sw_flashlib_major = skb->data[1];
484 hdev->sw_flashlib_minor = skb->data[2];
485
486 kfree_skb(skb);
487
488 r = nfc_hci_get_param(hdev, NFC_HCI_ID_MGMT_GATE,
489 NFC_HCI_ID_MGMT_VERSION_HW, &skb);
490 if (r < 0)
491 return r;
492
493 if (skb->len != 3) {
494 kfree_skb(skb);
495 return -EINVAL;
496 }
497
498 hdev->hw_derivative = (skb->data[0] & 0xe0) >> 5;
499 hdev->hw_version = skb->data[0] & 0x1f;
500 hdev->hw_mpw = (skb->data[1] & 0xc0) >> 6;
501 hdev->hw_software = skb->data[1] & 0x3f;
502 hdev->hw_bsid = skb->data[2];
503
504 kfree_skb(skb);
505
506 pr_info("SOFTWARE INFO:\n");
507 pr_info("RomLib : %d\n", hdev->sw_romlib);
508 pr_info("Patch : %d\n", hdev->sw_patch);
509 pr_info("FlashLib Major : %d\n", hdev->sw_flashlib_major);
510 pr_info("FlashLib Minor : %d\n", hdev->sw_flashlib_minor);
511 pr_info("HARDWARE INFO:\n");
512 pr_info("Derivative : %d\n", hdev->hw_derivative);
513 pr_info("HW Version : %d\n", hdev->hw_version);
514 pr_info("#MPW : %d\n", hdev->hw_mpw);
515 pr_info("Software : %d\n", hdev->hw_software);
516 pr_info("BSID Version : %d\n", hdev->hw_bsid);
517
518 return 0;
519 }
520
521 static int hci_dev_up(struct nfc_dev *nfc_dev)
522 {
523 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
524 int r = 0;
525
526 if (hdev->ops->open) {
527 r = hdev->ops->open(hdev);
528 if (r < 0)
529 return r;
530 }
531
532 r = nfc_llc_start(hdev->llc);
533 if (r < 0)
534 goto exit_close;
535
536 r = hci_dev_session_init(hdev);
537 if (r < 0)
538 goto exit_llc;
539
540 r = nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
541 NFC_HCI_EVT_END_OPERATION, NULL, 0);
542 if (r < 0)
543 goto exit_llc;
544
545 if (hdev->ops->hci_ready) {
546 r = hdev->ops->hci_ready(hdev);
547 if (r < 0)
548 goto exit_llc;
549 }
550
551 r = hci_dev_version(hdev);
552 if (r < 0)
553 goto exit_llc;
554
555 return 0;
556
557 exit_llc:
558 nfc_llc_stop(hdev->llc);
559
560 exit_close:
561 if (hdev->ops->close)
562 hdev->ops->close(hdev);
563
564 return r;
565 }
566
567 static int hci_dev_down(struct nfc_dev *nfc_dev)
568 {
569 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
570
571 nfc_llc_stop(hdev->llc);
572
573 if (hdev->ops->close)
574 hdev->ops->close(hdev);
575
576 memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
577
578 return 0;
579 }
580
581 static int hci_start_poll(struct nfc_dev *nfc_dev,
582 u32 im_protocols, u32 tm_protocols)
583 {
584 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
585
586 if (hdev->ops->start_poll)
587 return hdev->ops->start_poll(hdev, im_protocols, tm_protocols);
588 else
589 return nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
590 NFC_HCI_EVT_READER_REQUESTED,
591 NULL, 0);
592 }
593
594 static void hci_stop_poll(struct nfc_dev *nfc_dev)
595 {
596 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
597
598 if (hdev->ops->stop_poll)
599 hdev->ops->stop_poll(hdev);
600 else
601 nfc_hci_send_event(hdev, NFC_HCI_RF_READER_A_GATE,
602 NFC_HCI_EVT_END_OPERATION, NULL, 0);
603 }
604
605 static int hci_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
606 __u8 comm_mode, __u8 *gb, size_t gb_len)
607 {
608 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
609
610 if (!hdev->ops->dep_link_up)
611 return 0;
612
613 return hdev->ops->dep_link_up(hdev, target, comm_mode,
614 gb, gb_len);
615 }
616
617 static int hci_dep_link_down(struct nfc_dev *nfc_dev)
618 {
619 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
620
621 if (!hdev->ops->dep_link_down)
622 return 0;
623
624 return hdev->ops->dep_link_down(hdev);
625 }
626
627 static int hci_activate_target(struct nfc_dev *nfc_dev,
628 struct nfc_target *target, u32 protocol)
629 {
630 return 0;
631 }
632
633 static void hci_deactivate_target(struct nfc_dev *nfc_dev,
634 struct nfc_target *target)
635 {
636 }
637
638 #define HCI_CB_TYPE_TRANSCEIVE 1
639
640 static void hci_transceive_cb(void *context, struct sk_buff *skb, int err)
641 {
642 struct nfc_hci_dev *hdev = context;
643
644 switch (hdev->async_cb_type) {
645 case HCI_CB_TYPE_TRANSCEIVE:
646 /*
647 * TODO: Check RF Error indicator to make sure data is valid.
648 * It seems that HCI cmd can complete without error, but data
649 * can be invalid if an RF error occured? Ignore for now.
650 */
651 if (err == 0)
652 skb_trim(skb, skb->len - 1); /* RF Err ind */
653
654 hdev->async_cb(hdev->async_cb_context, skb, err);
655 break;
656 default:
657 if (err == 0)
658 kfree_skb(skb);
659 break;
660 }
661 }
662
663 static int hci_transceive(struct nfc_dev *nfc_dev, struct nfc_target *target,
664 struct sk_buff *skb, data_exchange_cb_t cb,
665 void *cb_context)
666 {
667 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
668 int r;
669
670 pr_debug("target_idx=%d\n", target->idx);
671
672 switch (target->hci_reader_gate) {
673 case NFC_HCI_RF_READER_A_GATE:
674 case NFC_HCI_RF_READER_B_GATE:
675 if (hdev->ops->im_transceive) {
676 r = hdev->ops->im_transceive(hdev, target, skb, cb,
677 cb_context);
678 if (r <= 0) /* handled */
679 break;
680 }
681
682 *skb_push(skb, 1) = 0; /* CTR, see spec:10.2.2.1 */
683
684 hdev->async_cb_type = HCI_CB_TYPE_TRANSCEIVE;
685 hdev->async_cb = cb;
686 hdev->async_cb_context = cb_context;
687
688 r = nfc_hci_send_cmd_async(hdev, target->hci_reader_gate,
689 NFC_HCI_WR_XCHG_DATA, skb->data,
690 skb->len, hci_transceive_cb, hdev);
691 break;
692 default:
693 if (hdev->ops->im_transceive) {
694 r = hdev->ops->im_transceive(hdev, target, skb, cb,
695 cb_context);
696 if (r == 1)
697 r = -ENOTSUPP;
698 } else {
699 r = -ENOTSUPP;
700 }
701 break;
702 }
703
704 kfree_skb(skb);
705
706 return r;
707 }
708
709 static int hci_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
710 {
711 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
712
713 if (!hdev->ops->tm_send) {
714 kfree_skb(skb);
715 return -ENOTSUPP;
716 }
717
718 return hdev->ops->tm_send(hdev, skb);
719 }
720
721 static int hci_check_presence(struct nfc_dev *nfc_dev,
722 struct nfc_target *target)
723 {
724 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
725
726 if (!hdev->ops->check_presence)
727 return 0;
728
729 return hdev->ops->check_presence(hdev, target);
730 }
731
732 static int hci_discover_se(struct nfc_dev *nfc_dev)
733 {
734 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
735
736 if (hdev->ops->discover_se)
737 return hdev->ops->discover_se(hdev);
738
739 return 0;
740 }
741
742 static int hci_enable_se(struct nfc_dev *nfc_dev, u32 se_idx)
743 {
744 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
745
746 if (hdev->ops->enable_se)
747 return hdev->ops->enable_se(hdev, se_idx);
748
749 return 0;
750 }
751
752 static int hci_disable_se(struct nfc_dev *nfc_dev, u32 se_idx)
753 {
754 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
755
756 if (hdev->ops->disable_se)
757 return hdev->ops->disable_se(hdev, se_idx);
758
759 return 0;
760 }
761
762 static int hci_se_io(struct nfc_dev *nfc_dev, u32 se_idx,
763 u8 *apdu, size_t apdu_length,
764 se_io_cb_t cb, void *cb_context)
765 {
766 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
767
768 if (hdev->ops->se_io)
769 return hdev->ops->se_io(hdev, se_idx, apdu,
770 apdu_length, cb, cb_context);
771
772 return 0;
773 }
774
775 static void nfc_hci_failure(struct nfc_hci_dev *hdev, int err)
776 {
777 mutex_lock(&hdev->msg_tx_mutex);
778
779 if (hdev->cmd_pending_msg == NULL) {
780 nfc_driver_failure(hdev->ndev, err);
781 goto exit;
782 }
783
784 __nfc_hci_cmd_completion(hdev, err, NULL);
785
786 exit:
787 mutex_unlock(&hdev->msg_tx_mutex);
788 }
789
790 static void nfc_hci_llc_failure(struct nfc_hci_dev *hdev, int err)
791 {
792 nfc_hci_failure(hdev, err);
793 }
794
795 static void nfc_hci_recv_from_llc(struct nfc_hci_dev *hdev, struct sk_buff *skb)
796 {
797 struct hcp_packet *packet;
798 u8 type;
799 u8 instruction;
800 struct sk_buff *hcp_skb;
801 u8 pipe;
802 struct sk_buff *frag_skb;
803 int msg_len;
804
805 packet = (struct hcp_packet *)skb->data;
806 if ((packet->header & ~NFC_HCI_FRAGMENT) == 0) {
807 skb_queue_tail(&hdev->rx_hcp_frags, skb);
808 return;
809 }
810
811 /* it's the last fragment. Does it need re-aggregation? */
812 if (skb_queue_len(&hdev->rx_hcp_frags)) {
813 pipe = packet->header & NFC_HCI_FRAGMENT;
814 skb_queue_tail(&hdev->rx_hcp_frags, skb);
815
816 msg_len = 0;
817 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
818 msg_len += (frag_skb->len -
819 NFC_HCI_HCP_PACKET_HEADER_LEN);
820 }
821
822 hcp_skb = nfc_alloc_recv_skb(NFC_HCI_HCP_PACKET_HEADER_LEN +
823 msg_len, GFP_KERNEL);
824 if (hcp_skb == NULL) {
825 nfc_hci_failure(hdev, -ENOMEM);
826 return;
827 }
828
829 *skb_put(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN) = pipe;
830
831 skb_queue_walk(&hdev->rx_hcp_frags, frag_skb) {
832 msg_len = frag_skb->len - NFC_HCI_HCP_PACKET_HEADER_LEN;
833 memcpy(skb_put(hcp_skb, msg_len),
834 frag_skb->data + NFC_HCI_HCP_PACKET_HEADER_LEN,
835 msg_len);
836 }
837
838 skb_queue_purge(&hdev->rx_hcp_frags);
839 } else {
840 packet->header &= NFC_HCI_FRAGMENT;
841 hcp_skb = skb;
842 }
843
844 /* if this is a response, dispatch immediately to
845 * unblock waiting cmd context. Otherwise, enqueue to dispatch
846 * in separate context where handler can also execute command.
847 */
848 packet = (struct hcp_packet *)hcp_skb->data;
849 type = HCP_MSG_GET_TYPE(packet->message.header);
850 if (type == NFC_HCI_HCP_RESPONSE) {
851 pipe = packet->header;
852 instruction = HCP_MSG_GET_CMD(packet->message.header);
853 skb_pull(hcp_skb, NFC_HCI_HCP_PACKET_HEADER_LEN +
854 NFC_HCI_HCP_MESSAGE_HEADER_LEN);
855 nfc_hci_hcp_message_rx(hdev, pipe, type, instruction, hcp_skb);
856 } else {
857 skb_queue_tail(&hdev->msg_rx_queue, hcp_skb);
858 schedule_work(&hdev->msg_rx_work);
859 }
860 }
861
862 static int hci_fw_download(struct nfc_dev *nfc_dev, const char *firmware_name)
863 {
864 struct nfc_hci_dev *hdev = nfc_get_drvdata(nfc_dev);
865
866 if (!hdev->ops->fw_download)
867 return -ENOTSUPP;
868
869 return hdev->ops->fw_download(hdev, firmware_name);
870 }
871
872 static struct nfc_ops hci_nfc_ops = {
873 .dev_up = hci_dev_up,
874 .dev_down = hci_dev_down,
875 .start_poll = hci_start_poll,
876 .stop_poll = hci_stop_poll,
877 .dep_link_up = hci_dep_link_up,
878 .dep_link_down = hci_dep_link_down,
879 .activate_target = hci_activate_target,
880 .deactivate_target = hci_deactivate_target,
881 .im_transceive = hci_transceive,
882 .tm_send = hci_tm_send,
883 .check_presence = hci_check_presence,
884 .fw_download = hci_fw_download,
885 .discover_se = hci_discover_se,
886 .enable_se = hci_enable_se,
887 .disable_se = hci_disable_se,
888 .se_io = hci_se_io,
889 };
890
891 struct nfc_hci_dev *nfc_hci_allocate_device(struct nfc_hci_ops *ops,
892 struct nfc_hci_init_data *init_data,
893 unsigned long quirks,
894 u32 protocols,
895 const char *llc_name,
896 int tx_headroom,
897 int tx_tailroom,
898 int max_link_payload)
899 {
900 struct nfc_hci_dev *hdev;
901
902 if (ops->xmit == NULL)
903 return NULL;
904
905 if (protocols == 0)
906 return NULL;
907
908 hdev = kzalloc(sizeof(struct nfc_hci_dev), GFP_KERNEL);
909 if (hdev == NULL)
910 return NULL;
911
912 hdev->llc = nfc_llc_allocate(llc_name, hdev, ops->xmit,
913 nfc_hci_recv_from_llc, tx_headroom,
914 tx_tailroom, nfc_hci_llc_failure);
915 if (hdev->llc == NULL) {
916 kfree(hdev);
917 return NULL;
918 }
919
920 hdev->ndev = nfc_allocate_device(&hci_nfc_ops, protocols,
921 tx_headroom + HCI_CMDS_HEADROOM,
922 tx_tailroom);
923 if (!hdev->ndev) {
924 nfc_llc_free(hdev->llc);
925 kfree(hdev);
926 return NULL;
927 }
928
929 hdev->ops = ops;
930 hdev->max_data_link_payload = max_link_payload;
931 hdev->init_data = *init_data;
932
933 nfc_set_drvdata(hdev->ndev, hdev);
934
935 memset(hdev->gate2pipe, NFC_HCI_INVALID_PIPE, sizeof(hdev->gate2pipe));
936
937 hdev->quirks = quirks;
938
939 return hdev;
940 }
941 EXPORT_SYMBOL(nfc_hci_allocate_device);
942
943 void nfc_hci_free_device(struct nfc_hci_dev *hdev)
944 {
945 nfc_free_device(hdev->ndev);
946 nfc_llc_free(hdev->llc);
947 kfree(hdev);
948 }
949 EXPORT_SYMBOL(nfc_hci_free_device);
950
951 int nfc_hci_register_device(struct nfc_hci_dev *hdev)
952 {
953 mutex_init(&hdev->msg_tx_mutex);
954
955 INIT_LIST_HEAD(&hdev->msg_tx_queue);
956
957 INIT_WORK(&hdev->msg_tx_work, nfc_hci_msg_tx_work);
958
959 init_timer(&hdev->cmd_timer);
960 hdev->cmd_timer.data = (unsigned long)hdev;
961 hdev->cmd_timer.function = nfc_hci_cmd_timeout;
962
963 skb_queue_head_init(&hdev->rx_hcp_frags);
964
965 INIT_WORK(&hdev->msg_rx_work, nfc_hci_msg_rx_work);
966
967 skb_queue_head_init(&hdev->msg_rx_queue);
968
969 return nfc_register_device(hdev->ndev);
970 }
971 EXPORT_SYMBOL(nfc_hci_register_device);
972
973 void nfc_hci_unregister_device(struct nfc_hci_dev *hdev)
974 {
975 struct hci_msg *msg, *n;
976
977 mutex_lock(&hdev->msg_tx_mutex);
978
979 if (hdev->cmd_pending_msg) {
980 if (hdev->cmd_pending_msg->cb)
981 hdev->cmd_pending_msg->cb(
982 hdev->cmd_pending_msg->cb_context,
983 NULL, -ESHUTDOWN);
984 kfree(hdev->cmd_pending_msg);
985 hdev->cmd_pending_msg = NULL;
986 }
987
988 hdev->shutting_down = true;
989
990 mutex_unlock(&hdev->msg_tx_mutex);
991
992 del_timer_sync(&hdev->cmd_timer);
993 cancel_work_sync(&hdev->msg_tx_work);
994
995 cancel_work_sync(&hdev->msg_rx_work);
996
997 nfc_unregister_device(hdev->ndev);
998
999 skb_queue_purge(&hdev->rx_hcp_frags);
1000 skb_queue_purge(&hdev->msg_rx_queue);
1001
1002 list_for_each_entry_safe(msg, n, &hdev->msg_tx_queue, msg_l) {
1003 list_del(&msg->msg_l);
1004 skb_queue_purge(&msg->msg_frags);
1005 kfree(msg);
1006 }
1007 }
1008 EXPORT_SYMBOL(nfc_hci_unregister_device);
1009
1010 void nfc_hci_set_clientdata(struct nfc_hci_dev *hdev, void *clientdata)
1011 {
1012 hdev->clientdata = clientdata;
1013 }
1014 EXPORT_SYMBOL(nfc_hci_set_clientdata);
1015
1016 void *nfc_hci_get_clientdata(struct nfc_hci_dev *hdev)
1017 {
1018 return hdev->clientdata;
1019 }
1020 EXPORT_SYMBOL(nfc_hci_get_clientdata);
1021
1022 void nfc_hci_driver_failure(struct nfc_hci_dev *hdev, int err)
1023 {
1024 nfc_hci_failure(hdev, err);
1025 }
1026 EXPORT_SYMBOL(nfc_hci_driver_failure);
1027
1028 void nfc_hci_recv_frame(struct nfc_hci_dev *hdev, struct sk_buff *skb)
1029 {
1030 nfc_llc_rcv_from_drv(hdev->llc, skb);
1031 }
1032 EXPORT_SYMBOL(nfc_hci_recv_frame);
1033
1034 static int __init nfc_hci_init(void)
1035 {
1036 return nfc_llc_init();
1037 }
1038
1039 static void __exit nfc_hci_exit(void)
1040 {
1041 nfc_llc_exit();
1042 }
1043
1044 subsys_initcall(nfc_hci_init);
1045 module_exit(nfc_hci_exit);
1046
1047 MODULE_LICENSE("GPL");
1048 MODULE_DESCRIPTION("NFC HCI Core");
CRIS linux kernel tree