2 * The NFC Controller Interface is the communication protocol between an
3 * NFC Controller (NFCC) and a Device Host (DH).
5 * Copyright (C) 2011 Texas Instruments, Inc.
7 * Written by Ilan Elias <ilane@ti.com>
10 * This file is based on hci_event.c, which was written
11 * by Maxim Krasnyansky.
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
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.
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
28 #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
30 #include <linux/types.h>
31 #include <linux/interrupt.h>
32 #include <linux/bitops.h>
33 #include <linux/skbuff.h>
36 #include <net/nfc/nci.h>
37 #include <net/nfc/nci_core.h>
38 #include <linux/nfc.h>
40 /* Handle NCI Notification packets */
42 static void nci_core_conn_credits_ntf_packet(struct nci_dev
*ndev
,
45 struct nci_core_conn_credit_ntf
*ntf
= (void *) skb
->data
;
48 pr_debug("num_entries %d\n", ntf
->num_entries
);
50 if (ntf
->num_entries
> NCI_MAX_NUM_CONN
)
51 ntf
->num_entries
= NCI_MAX_NUM_CONN
;
53 /* update the credits */
54 for (i
= 0; i
< ntf
->num_entries
; i
++) {
55 ntf
->conn_entries
[i
].conn_id
=
56 nci_conn_id(&ntf
->conn_entries
[i
].conn_id
);
58 pr_debug("entry[%d]: conn_id %d, credits %d\n",
59 i
, ntf
->conn_entries
[i
].conn_id
,
60 ntf
->conn_entries
[i
].credits
);
62 if (ntf
->conn_entries
[i
].conn_id
== NCI_STATIC_RF_CONN_ID
) {
63 /* found static rf connection */
64 atomic_add(ntf
->conn_entries
[i
].credits
,
69 /* trigger the next tx */
70 if (!skb_queue_empty(&ndev
->tx_q
))
71 queue_work(ndev
->tx_wq
, &ndev
->tx_work
);
74 static void nci_core_generic_error_ntf_packet(struct nci_dev
*ndev
,
77 __u8 status
= skb
->data
[0];
79 pr_debug("status 0x%x\n", status
);
81 if (atomic_read(&ndev
->state
) == NCI_W4_HOST_SELECT
) {
82 /* Activation failed, so complete the request
83 (the state remains the same) */
84 nci_req_complete(ndev
, status
);
88 static void nci_core_conn_intf_error_ntf_packet(struct nci_dev
*ndev
,
91 struct nci_core_intf_error_ntf
*ntf
= (void *) skb
->data
;
93 ntf
->conn_id
= nci_conn_id(&ntf
->conn_id
);
95 pr_debug("status 0x%x, conn_id %d\n", ntf
->status
, ntf
->conn_id
);
97 /* complete the data exchange transaction, if exists */
98 if (test_bit(NCI_DATA_EXCHANGE
, &ndev
->flags
))
99 nci_data_exchange_complete(ndev
, NULL
, -EIO
);
102 static __u8
*nci_extract_rf_params_nfca_passive_poll(struct nci_dev
*ndev
,
103 struct rf_tech_specific_params_nfca_poll
*nfca_poll
,
106 nfca_poll
->sens_res
= __le16_to_cpu(*((__u16
*)data
));
109 nfca_poll
->nfcid1_len
= min_t(__u8
, *data
++, NFC_NFCID1_MAXSIZE
);
111 pr_debug("sens_res 0x%x, nfcid1_len %d\n",
112 nfca_poll
->sens_res
, nfca_poll
->nfcid1_len
);
114 memcpy(nfca_poll
->nfcid1
, data
, nfca_poll
->nfcid1_len
);
115 data
+= nfca_poll
->nfcid1_len
;
117 nfca_poll
->sel_res_len
= *data
++;
119 if (nfca_poll
->sel_res_len
!= 0)
120 nfca_poll
->sel_res
= *data
++;
122 pr_debug("sel_res_len %d, sel_res 0x%x\n",
123 nfca_poll
->sel_res_len
,
129 static __u8
*nci_extract_rf_params_nfcb_passive_poll(struct nci_dev
*ndev
,
130 struct rf_tech_specific_params_nfcb_poll
*nfcb_poll
,
133 nfcb_poll
->sensb_res_len
= min_t(__u8
, *data
++, NFC_SENSB_RES_MAXSIZE
);
135 pr_debug("sensb_res_len %d\n", nfcb_poll
->sensb_res_len
);
137 memcpy(nfcb_poll
->sensb_res
, data
, nfcb_poll
->sensb_res_len
);
138 data
+= nfcb_poll
->sensb_res_len
;
143 static __u8
*nci_extract_rf_params_nfcf_passive_poll(struct nci_dev
*ndev
,
144 struct rf_tech_specific_params_nfcf_poll
*nfcf_poll
,
147 nfcf_poll
->bit_rate
= *data
++;
148 nfcf_poll
->sensf_res_len
= min_t(__u8
, *data
++, NFC_SENSF_RES_MAXSIZE
);
150 pr_debug("bit_rate %d, sensf_res_len %d\n",
151 nfcf_poll
->bit_rate
, nfcf_poll
->sensf_res_len
);
153 memcpy(nfcf_poll
->sensf_res
, data
, nfcf_poll
->sensf_res_len
);
154 data
+= nfcf_poll
->sensf_res_len
;
159 static int nci_add_new_protocol(struct nci_dev
*ndev
,
160 struct nfc_target
*target
,
162 __u8 rf_tech_and_mode
,
165 struct rf_tech_specific_params_nfca_poll
*nfca_poll
;
166 struct rf_tech_specific_params_nfcb_poll
*nfcb_poll
;
167 struct rf_tech_specific_params_nfcf_poll
*nfcf_poll
;
170 if (rf_protocol
== NCI_RF_PROTOCOL_T2T
)
171 protocol
= NFC_PROTO_MIFARE_MASK
;
172 else if (rf_protocol
== NCI_RF_PROTOCOL_ISO_DEP
)
173 protocol
= NFC_PROTO_ISO14443_MASK
;
174 else if (rf_protocol
== NCI_RF_PROTOCOL_T3T
)
175 protocol
= NFC_PROTO_FELICA_MASK
;
179 if (!(protocol
& ndev
->poll_prots
)) {
180 pr_err("the target found does not have the desired protocol\n");
184 if (rf_tech_and_mode
== NCI_NFC_A_PASSIVE_POLL_MODE
) {
185 nfca_poll
= (struct rf_tech_specific_params_nfca_poll
*)params
;
187 target
->sens_res
= nfca_poll
->sens_res
;
188 target
->sel_res
= nfca_poll
->sel_res
;
189 target
->nfcid1_len
= nfca_poll
->nfcid1_len
;
190 if (target
->nfcid1_len
> 0) {
191 memcpy(target
->nfcid1
, nfca_poll
->nfcid1
,
194 } else if (rf_tech_and_mode
== NCI_NFC_B_PASSIVE_POLL_MODE
) {
195 nfcb_poll
= (struct rf_tech_specific_params_nfcb_poll
*)params
;
197 target
->sensb_res_len
= nfcb_poll
->sensb_res_len
;
198 if (target
->sensb_res_len
> 0) {
199 memcpy(target
->sensb_res
, nfcb_poll
->sensb_res
,
200 target
->sensb_res_len
);
202 } else if (rf_tech_and_mode
== NCI_NFC_F_PASSIVE_POLL_MODE
) {
203 nfcf_poll
= (struct rf_tech_specific_params_nfcf_poll
*)params
;
205 target
->sensf_res_len
= nfcf_poll
->sensf_res_len
;
206 if (target
->sensf_res_len
> 0) {
207 memcpy(target
->sensf_res
, nfcf_poll
->sensf_res
,
208 target
->sensf_res_len
);
211 pr_err("unsupported rf_tech_and_mode 0x%x\n", rf_tech_and_mode
);
215 target
->supported_protocols
|= protocol
;
217 pr_debug("protocol 0x%x\n", protocol
);
222 static void nci_add_new_target(struct nci_dev
*ndev
,
223 struct nci_rf_discover_ntf
*ntf
)
225 struct nfc_target
*target
;
228 for (i
= 0; i
< ndev
->n_targets
; i
++) {
229 target
= &ndev
->targets
[i
];
230 if (target
->logical_idx
== ntf
->rf_discovery_id
) {
231 /* This target already exists, add the new protocol */
232 nci_add_new_protocol(ndev
, target
, ntf
->rf_protocol
,
233 ntf
->rf_tech_and_mode
,
234 &ntf
->rf_tech_specific_params
);
239 /* This is a new target, check if we've enough room */
240 if (ndev
->n_targets
== NCI_MAX_DISCOVERED_TARGETS
) {
241 pr_debug("not enough room, ignoring new target...\n");
245 target
= &ndev
->targets
[ndev
->n_targets
];
247 rc
= nci_add_new_protocol(ndev
, target
, ntf
->rf_protocol
,
248 ntf
->rf_tech_and_mode
,
249 &ntf
->rf_tech_specific_params
);
251 target
->logical_idx
= ntf
->rf_discovery_id
;
254 pr_debug("logical idx %d, n_targets %d\n", target
->logical_idx
,
259 void nci_clear_target_list(struct nci_dev
*ndev
)
261 memset(ndev
->targets
, 0,
262 (sizeof(struct nfc_target
)*NCI_MAX_DISCOVERED_TARGETS
));
267 static void nci_rf_discover_ntf_packet(struct nci_dev
*ndev
,
270 struct nci_rf_discover_ntf ntf
;
271 __u8
*data
= skb
->data
;
272 bool add_target
= true;
274 ntf
.rf_discovery_id
= *data
++;
275 ntf
.rf_protocol
= *data
++;
276 ntf
.rf_tech_and_mode
= *data
++;
277 ntf
.rf_tech_specific_params_len
= *data
++;
279 pr_debug("rf_discovery_id %d\n", ntf
.rf_discovery_id
);
280 pr_debug("rf_protocol 0x%x\n", ntf
.rf_protocol
);
281 pr_debug("rf_tech_and_mode 0x%x\n", ntf
.rf_tech_and_mode
);
282 pr_debug("rf_tech_specific_params_len %d\n",
283 ntf
.rf_tech_specific_params_len
);
285 if (ntf
.rf_tech_specific_params_len
> 0) {
286 switch (ntf
.rf_tech_and_mode
) {
287 case NCI_NFC_A_PASSIVE_POLL_MODE
:
288 data
= nci_extract_rf_params_nfca_passive_poll(ndev
,
289 &(ntf
.rf_tech_specific_params
.nfca_poll
), data
);
292 case NCI_NFC_B_PASSIVE_POLL_MODE
:
293 data
= nci_extract_rf_params_nfcb_passive_poll(ndev
,
294 &(ntf
.rf_tech_specific_params
.nfcb_poll
), data
);
297 case NCI_NFC_F_PASSIVE_POLL_MODE
:
298 data
= nci_extract_rf_params_nfcf_passive_poll(ndev
,
299 &(ntf
.rf_tech_specific_params
.nfcf_poll
), data
);
303 pr_err("unsupported rf_tech_and_mode 0x%x\n",
304 ntf
.rf_tech_and_mode
);
305 data
+= ntf
.rf_tech_specific_params_len
;
310 ntf
.ntf_type
= *data
++;
311 pr_debug("ntf_type %d\n", ntf
.ntf_type
);
313 if (add_target
== true)
314 nci_add_new_target(ndev
, &ntf
);
316 if (ntf
.ntf_type
== NCI_DISCOVER_NTF_TYPE_MORE
) {
317 atomic_set(&ndev
->state
, NCI_W4_ALL_DISCOVERIES
);
319 atomic_set(&ndev
->state
, NCI_W4_HOST_SELECT
);
320 nfc_targets_found(ndev
->nfc_dev
, ndev
->targets
,
325 static int nci_extract_activation_params_iso_dep(struct nci_dev
*ndev
,
326 struct nci_rf_intf_activated_ntf
*ntf
, __u8
*data
)
328 struct activation_params_nfca_poll_iso_dep
*nfca_poll
;
329 struct activation_params_nfcb_poll_iso_dep
*nfcb_poll
;
331 switch (ntf
->activation_rf_tech_and_mode
) {
332 case NCI_NFC_A_PASSIVE_POLL_MODE
:
333 nfca_poll
= &ntf
->activation_params
.nfca_poll_iso_dep
;
334 nfca_poll
->rats_res_len
= min_t(__u8
, *data
++, 20);
335 pr_debug("rats_res_len %d\n", nfca_poll
->rats_res_len
);
336 if (nfca_poll
->rats_res_len
> 0) {
337 memcpy(nfca_poll
->rats_res
,
338 data
, nfca_poll
->rats_res_len
);
342 case NCI_NFC_B_PASSIVE_POLL_MODE
:
343 nfcb_poll
= &ntf
->activation_params
.nfcb_poll_iso_dep
;
344 nfcb_poll
->attrib_res_len
= min_t(__u8
, *data
++, 50);
345 pr_debug("attrib_res_len %d\n", nfcb_poll
->attrib_res_len
);
346 if (nfcb_poll
->attrib_res_len
> 0) {
347 memcpy(nfcb_poll
->attrib_res
,
348 data
, nfcb_poll
->attrib_res_len
);
353 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
354 ntf
->activation_rf_tech_and_mode
);
355 return NCI_STATUS_RF_PROTOCOL_ERROR
;
358 return NCI_STATUS_OK
;
361 static void nci_target_auto_activated(struct nci_dev
*ndev
,
362 struct nci_rf_intf_activated_ntf
*ntf
)
364 struct nfc_target
*target
;
367 target
= &ndev
->targets
[ndev
->n_targets
];
369 rc
= nci_add_new_protocol(ndev
, target
, ntf
->rf_protocol
,
370 ntf
->activation_rf_tech_and_mode
,
371 &ntf
->rf_tech_specific_params
);
375 target
->logical_idx
= ntf
->rf_discovery_id
;
378 pr_debug("logical idx %d, n_targets %d\n",
379 target
->logical_idx
, ndev
->n_targets
);
381 nfc_targets_found(ndev
->nfc_dev
, ndev
->targets
, ndev
->n_targets
);
384 static void nci_rf_intf_activated_ntf_packet(struct nci_dev
*ndev
,
387 struct nci_rf_intf_activated_ntf ntf
;
388 __u8
*data
= skb
->data
;
389 int err
= NCI_STATUS_OK
;
391 ntf
.rf_discovery_id
= *data
++;
392 ntf
.rf_interface
= *data
++;
393 ntf
.rf_protocol
= *data
++;
394 ntf
.activation_rf_tech_and_mode
= *data
++;
395 ntf
.max_data_pkt_payload_size
= *data
++;
396 ntf
.initial_num_credits
= *data
++;
397 ntf
.rf_tech_specific_params_len
= *data
++;
399 pr_debug("rf_discovery_id %d\n", ntf
.rf_discovery_id
);
400 pr_debug("rf_interface 0x%x\n", ntf
.rf_interface
);
401 pr_debug("rf_protocol 0x%x\n", ntf
.rf_protocol
);
402 pr_debug("activation_rf_tech_and_mode 0x%x\n",
403 ntf
.activation_rf_tech_and_mode
);
404 pr_debug("max_data_pkt_payload_size 0x%x\n",
405 ntf
.max_data_pkt_payload_size
);
406 pr_debug("initial_num_credits 0x%x\n",
407 ntf
.initial_num_credits
);
408 pr_debug("rf_tech_specific_params_len %d\n",
409 ntf
.rf_tech_specific_params_len
);
411 if (ntf
.rf_tech_specific_params_len
> 0) {
412 switch (ntf
.activation_rf_tech_and_mode
) {
413 case NCI_NFC_A_PASSIVE_POLL_MODE
:
414 data
= nci_extract_rf_params_nfca_passive_poll(ndev
,
415 &(ntf
.rf_tech_specific_params
.nfca_poll
), data
);
418 case NCI_NFC_B_PASSIVE_POLL_MODE
:
419 data
= nci_extract_rf_params_nfcb_passive_poll(ndev
,
420 &(ntf
.rf_tech_specific_params
.nfcb_poll
), data
);
423 case NCI_NFC_F_PASSIVE_POLL_MODE
:
424 data
= nci_extract_rf_params_nfcf_passive_poll(ndev
,
425 &(ntf
.rf_tech_specific_params
.nfcf_poll
), data
);
429 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
430 ntf
.activation_rf_tech_and_mode
);
431 err
= NCI_STATUS_RF_PROTOCOL_ERROR
;
436 ntf
.data_exch_rf_tech_and_mode
= *data
++;
437 ntf
.data_exch_tx_bit_rate
= *data
++;
438 ntf
.data_exch_rx_bit_rate
= *data
++;
439 ntf
.activation_params_len
= *data
++;
441 pr_debug("data_exch_rf_tech_and_mode 0x%x\n",
442 ntf
.data_exch_rf_tech_and_mode
);
443 pr_debug("data_exch_tx_bit_rate 0x%x\n", ntf
.data_exch_tx_bit_rate
);
444 pr_debug("data_exch_rx_bit_rate 0x%x\n", ntf
.data_exch_rx_bit_rate
);
445 pr_debug("activation_params_len %d\n", ntf
.activation_params_len
);
447 if (ntf
.activation_params_len
> 0) {
448 switch (ntf
.rf_interface
) {
449 case NCI_RF_INTERFACE_ISO_DEP
:
450 err
= nci_extract_activation_params_iso_dep(ndev
,
454 case NCI_RF_INTERFACE_FRAME
:
455 /* no activation params */
459 pr_err("unsupported rf_interface 0x%x\n",
461 err
= NCI_STATUS_RF_PROTOCOL_ERROR
;
467 if (err
== NCI_STATUS_OK
) {
468 ndev
->max_data_pkt_payload_size
= ntf
.max_data_pkt_payload_size
;
469 ndev
->initial_num_credits
= ntf
.initial_num_credits
;
471 /* set the available credits to initial value */
472 atomic_set(&ndev
->credits_cnt
, ndev
->initial_num_credits
);
475 if (atomic_read(&ndev
->state
) == NCI_DISCOVERY
) {
476 /* A single target was found and activated automatically */
477 atomic_set(&ndev
->state
, NCI_POLL_ACTIVE
);
478 if (err
== NCI_STATUS_OK
)
479 nci_target_auto_activated(ndev
, &ntf
);
480 } else { /* ndev->state == NCI_W4_HOST_SELECT */
481 /* A selected target was activated, so complete the request */
482 atomic_set(&ndev
->state
, NCI_POLL_ACTIVE
);
483 nci_req_complete(ndev
, err
);
487 static void nci_rf_deactivate_ntf_packet(struct nci_dev
*ndev
,
490 struct nci_rf_deactivate_ntf
*ntf
= (void *) skb
->data
;
492 pr_debug("entry, type 0x%x, reason 0x%x\n", ntf
->type
, ntf
->reason
);
494 /* drop tx data queue */
495 skb_queue_purge(&ndev
->tx_q
);
497 /* drop partial rx data packet */
498 if (ndev
->rx_data_reassembly
) {
499 kfree_skb(ndev
->rx_data_reassembly
);
500 ndev
->rx_data_reassembly
= NULL
;
503 /* complete the data exchange transaction, if exists */
504 if (test_bit(NCI_DATA_EXCHANGE
, &ndev
->flags
))
505 nci_data_exchange_complete(ndev
, NULL
, -EIO
);
507 nci_clear_target_list(ndev
);
508 atomic_set(&ndev
->state
, NCI_IDLE
);
509 nci_req_complete(ndev
, NCI_STATUS_OK
);
512 void nci_ntf_packet(struct nci_dev
*ndev
, struct sk_buff
*skb
)
514 __u16 ntf_opcode
= nci_opcode(skb
->data
);
516 pr_debug("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
518 nci_opcode_gid(ntf_opcode
),
519 nci_opcode_oid(ntf_opcode
),
520 nci_plen(skb
->data
));
522 /* strip the nci control header */
523 skb_pull(skb
, NCI_CTRL_HDR_SIZE
);
525 switch (ntf_opcode
) {
526 case NCI_OP_CORE_CONN_CREDITS_NTF
:
527 nci_core_conn_credits_ntf_packet(ndev
, skb
);
530 case NCI_OP_CORE_GENERIC_ERROR_NTF
:
531 nci_core_generic_error_ntf_packet(ndev
, skb
);
534 case NCI_OP_CORE_INTF_ERROR_NTF
:
535 nci_core_conn_intf_error_ntf_packet(ndev
, skb
);
538 case NCI_OP_RF_DISCOVER_NTF
:
539 nci_rf_discover_ntf_packet(ndev
, skb
);
542 case NCI_OP_RF_INTF_ACTIVATED_NTF
:
543 nci_rf_intf_activated_ntf_packet(ndev
, skb
);
546 case NCI_OP_RF_DEACTIVATE_NTF
:
547 nci_rf_deactivate_ntf_packet(ndev
, skb
);
551 pr_err("unknown ntf opcode 0x%x\n", ntf_opcode
);