1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
28
29#include <linux/types.h>
30#include <linux/interrupt.h>
31#include <linux/bitops.h>
32#include <linux/skbuff.h>
33
34#include "../nfc.h"
35#include <net/nfc/nci.h>
36#include <net/nfc/nci_core.h>
37#include <linux/nfc.h>
38
39
40
41static void nci_core_conn_credits_ntf_packet(struct nci_dev *ndev,
42 struct sk_buff *skb)
43{
44 struct nci_core_conn_credit_ntf *ntf = (void *) skb->data;
45 int i;
46
47 pr_debug("num_entries %d\n", ntf->num_entries);
48
49 if (ntf->num_entries > NCI_MAX_NUM_CONN)
50 ntf->num_entries = NCI_MAX_NUM_CONN;
51
52
53 for (i = 0; i < ntf->num_entries; i++) {
54 ntf->conn_entries[i].conn_id =
55 nci_conn_id(&ntf->conn_entries[i].conn_id);
56
57 pr_debug("entry[%d]: conn_id %d, credits %d\n",
58 i, ntf->conn_entries[i].conn_id,
59 ntf->conn_entries[i].credits);
60
61 if (ntf->conn_entries[i].conn_id == NCI_STATIC_RF_CONN_ID) {
62
63 atomic_add(ntf->conn_entries[i].credits,
64 &ndev->credits_cnt);
65 }
66 }
67
68
69 if (!skb_queue_empty(&ndev->tx_q))
70 queue_work(ndev->tx_wq, &ndev->tx_work);
71}
72
73static void nci_core_generic_error_ntf_packet(struct nci_dev *ndev,
74 struct sk_buff *skb)
75{
76 __u8 status = skb->data[0];
77
78 pr_debug("status 0x%x\n", status);
79
80 if (atomic_read(&ndev->state) == NCI_W4_HOST_SELECT) {
81
82
83 nci_req_complete(ndev, status);
84 }
85}
86
87static void nci_core_conn_intf_error_ntf_packet(struct nci_dev *ndev,
88 struct sk_buff *skb)
89{
90 struct nci_core_intf_error_ntf *ntf = (void *) skb->data;
91
92 ntf->conn_id = nci_conn_id(&ntf->conn_id);
93
94 pr_debug("status 0x%x, conn_id %d\n", ntf->status, ntf->conn_id);
95
96
97 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
98 nci_data_exchange_complete(ndev, NULL, -EIO);
99}
100
101static __u8 *nci_extract_rf_params_nfca_passive_poll(struct nci_dev *ndev,
102 struct rf_tech_specific_params_nfca_poll *nfca_poll,
103 __u8 *data)
104{
105 nfca_poll->sens_res = __le16_to_cpu(*((__u16 *)data));
106 data += 2;
107
108 nfca_poll->nfcid1_len = min_t(__u8, *data++, NFC_NFCID1_MAXSIZE);
109
110 pr_debug("sens_res 0x%x, nfcid1_len %d\n",
111 nfca_poll->sens_res, nfca_poll->nfcid1_len);
112
113 memcpy(nfca_poll->nfcid1, data, nfca_poll->nfcid1_len);
114 data += nfca_poll->nfcid1_len;
115
116 nfca_poll->sel_res_len = *data++;
117
118 if (nfca_poll->sel_res_len != 0)
119 nfca_poll->sel_res = *data++;
120
121 pr_debug("sel_res_len %d, sel_res 0x%x\n",
122 nfca_poll->sel_res_len,
123 nfca_poll->sel_res);
124
125 return data;
126}
127
128static __u8 *nci_extract_rf_params_nfcb_passive_poll(struct nci_dev *ndev,
129 struct rf_tech_specific_params_nfcb_poll *nfcb_poll,
130 __u8 *data)
131{
132 nfcb_poll->sensb_res_len = min_t(__u8, *data++, NFC_SENSB_RES_MAXSIZE);
133
134 pr_debug("sensb_res_len %d\n", nfcb_poll->sensb_res_len);
135
136 memcpy(nfcb_poll->sensb_res, data, nfcb_poll->sensb_res_len);
137 data += nfcb_poll->sensb_res_len;
138
139 return data;
140}
141
142static __u8 *nci_extract_rf_params_nfcf_passive_poll(struct nci_dev *ndev,
143 struct rf_tech_specific_params_nfcf_poll *nfcf_poll,
144 __u8 *data)
145{
146 nfcf_poll->bit_rate = *data++;
147 nfcf_poll->sensf_res_len = min_t(__u8, *data++, NFC_SENSF_RES_MAXSIZE);
148
149 pr_debug("bit_rate %d, sensf_res_len %d\n",
150 nfcf_poll->bit_rate, nfcf_poll->sensf_res_len);
151
152 memcpy(nfcf_poll->sensf_res, data, nfcf_poll->sensf_res_len);
153 data += nfcf_poll->sensf_res_len;
154
155 return data;
156}
157
158static int nci_add_new_protocol(struct nci_dev *ndev,
159 struct nfc_target *target,
160 __u8 rf_protocol,
161 __u8 rf_tech_and_mode,
162 void *params)
163{
164 struct rf_tech_specific_params_nfca_poll *nfca_poll;
165 struct rf_tech_specific_params_nfcb_poll *nfcb_poll;
166 struct rf_tech_specific_params_nfcf_poll *nfcf_poll;
167 __u32 protocol;
168
169 if (rf_protocol == NCI_RF_PROTOCOL_T1T)
170 protocol = NFC_PROTO_JEWEL_MASK;
171 else if (rf_protocol == NCI_RF_PROTOCOL_T2T)
172 protocol = NFC_PROTO_MIFARE_MASK;
173 else if (rf_protocol == NCI_RF_PROTOCOL_ISO_DEP)
174 if (rf_tech_and_mode == NCI_NFC_A_PASSIVE_POLL_MODE)
175 protocol = NFC_PROTO_ISO14443_MASK;
176 else
177 protocol = NFC_PROTO_ISO14443_B_MASK;
178 else if (rf_protocol == NCI_RF_PROTOCOL_T3T)
179 protocol = NFC_PROTO_FELICA_MASK;
180 else if (rf_protocol == NCI_RF_PROTOCOL_NFC_DEP)
181 protocol = NFC_PROTO_NFC_DEP_MASK;
182 else
183 protocol = 0;
184
185 if (!(protocol & ndev->poll_prots)) {
186 pr_err("the target found does not have the desired protocol\n");
187 return -EPROTO;
188 }
189
190 if (rf_tech_and_mode == NCI_NFC_A_PASSIVE_POLL_MODE) {
191 nfca_poll = (struct rf_tech_specific_params_nfca_poll *)params;
192
193 target->sens_res = nfca_poll->sens_res;
194 target->sel_res = nfca_poll->sel_res;
195 target->nfcid1_len = nfca_poll->nfcid1_len;
196 if (target->nfcid1_len > 0) {
197 memcpy(target->nfcid1, nfca_poll->nfcid1,
198 target->nfcid1_len);
199 }
200 } else if (rf_tech_and_mode == NCI_NFC_B_PASSIVE_POLL_MODE) {
201 nfcb_poll = (struct rf_tech_specific_params_nfcb_poll *)params;
202
203 target->sensb_res_len = nfcb_poll->sensb_res_len;
204 if (target->sensb_res_len > 0) {
205 memcpy(target->sensb_res, nfcb_poll->sensb_res,
206 target->sensb_res_len);
207 }
208 } else if (rf_tech_and_mode == NCI_NFC_F_PASSIVE_POLL_MODE) {
209 nfcf_poll = (struct rf_tech_specific_params_nfcf_poll *)params;
210
211 target->sensf_res_len = nfcf_poll->sensf_res_len;
212 if (target->sensf_res_len > 0) {
213 memcpy(target->sensf_res, nfcf_poll->sensf_res,
214 target->sensf_res_len);
215 }
216 } else {
217 pr_err("unsupported rf_tech_and_mode 0x%x\n", rf_tech_and_mode);
218 return -EPROTO;
219 }
220
221 target->supported_protocols |= protocol;
222
223 pr_debug("protocol 0x%x\n", protocol);
224
225 return 0;
226}
227
228static void nci_add_new_target(struct nci_dev *ndev,
229 struct nci_rf_discover_ntf *ntf)
230{
231 struct nfc_target *target;
232 int i, rc;
233
234 for (i = 0; i < ndev->n_targets; i++) {
235 target = &ndev->targets[i];
236 if (target->logical_idx == ntf->rf_discovery_id) {
237
238 nci_add_new_protocol(ndev, target, ntf->rf_protocol,
239 ntf->rf_tech_and_mode,
240 &ntf->rf_tech_specific_params);
241 return;
242 }
243 }
244
245
246 if (ndev->n_targets == NCI_MAX_DISCOVERED_TARGETS) {
247 pr_debug("not enough room, ignoring new target...\n");
248 return;
249 }
250
251 target = &ndev->targets[ndev->n_targets];
252
253 rc = nci_add_new_protocol(ndev, target, ntf->rf_protocol,
254 ntf->rf_tech_and_mode,
255 &ntf->rf_tech_specific_params);
256 if (!rc) {
257 target->logical_idx = ntf->rf_discovery_id;
258 ndev->n_targets++;
259
260 pr_debug("logical idx %d, n_targets %d\n", target->logical_idx,
261 ndev->n_targets);
262 }
263}
264
265void nci_clear_target_list(struct nci_dev *ndev)
266{
267 memset(ndev->targets, 0,
268 (sizeof(struct nfc_target)*NCI_MAX_DISCOVERED_TARGETS));
269
270 ndev->n_targets = 0;
271}
272
273static void nci_rf_discover_ntf_packet(struct nci_dev *ndev,
274 struct sk_buff *skb)
275{
276 struct nci_rf_discover_ntf ntf;
277 __u8 *data = skb->data;
278 bool add_target = true;
279
280 ntf.rf_discovery_id = *data++;
281 ntf.rf_protocol = *data++;
282 ntf.rf_tech_and_mode = *data++;
283 ntf.rf_tech_specific_params_len = *data++;
284
285 pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id);
286 pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol);
287 pr_debug("rf_tech_and_mode 0x%x\n", ntf.rf_tech_and_mode);
288 pr_debug("rf_tech_specific_params_len %d\n",
289 ntf.rf_tech_specific_params_len);
290
291 if (ntf.rf_tech_specific_params_len > 0) {
292 switch (ntf.rf_tech_and_mode) {
293 case NCI_NFC_A_PASSIVE_POLL_MODE:
294 data = nci_extract_rf_params_nfca_passive_poll(ndev,
295 &(ntf.rf_tech_specific_params.nfca_poll), data);
296 break;
297
298 case NCI_NFC_B_PASSIVE_POLL_MODE:
299 data = nci_extract_rf_params_nfcb_passive_poll(ndev,
300 &(ntf.rf_tech_specific_params.nfcb_poll), data);
301 break;
302
303 case NCI_NFC_F_PASSIVE_POLL_MODE:
304 data = nci_extract_rf_params_nfcf_passive_poll(ndev,
305 &(ntf.rf_tech_specific_params.nfcf_poll), data);
306 break;
307
308 default:
309 pr_err("unsupported rf_tech_and_mode 0x%x\n",
310 ntf.rf_tech_and_mode);
311 data += ntf.rf_tech_specific_params_len;
312 add_target = false;
313 }
314 }
315
316 ntf.ntf_type = *data++;
317 pr_debug("ntf_type %d\n", ntf.ntf_type);
318
319 if (add_target == true)
320 nci_add_new_target(ndev, &ntf);
321
322 if (ntf.ntf_type == NCI_DISCOVER_NTF_TYPE_MORE) {
323 atomic_set(&ndev->state, NCI_W4_ALL_DISCOVERIES);
324 } else {
325 atomic_set(&ndev->state, NCI_W4_HOST_SELECT);
326 nfc_targets_found(ndev->nfc_dev, ndev->targets,
327 ndev->n_targets);
328 }
329}
330
331static int nci_extract_activation_params_iso_dep(struct nci_dev *ndev,
332 struct nci_rf_intf_activated_ntf *ntf, __u8 *data)
333{
334 struct activation_params_nfca_poll_iso_dep *nfca_poll;
335 struct activation_params_nfcb_poll_iso_dep *nfcb_poll;
336
337 switch (ntf->activation_rf_tech_and_mode) {
338 case NCI_NFC_A_PASSIVE_POLL_MODE:
339 nfca_poll = &ntf->activation_params.nfca_poll_iso_dep;
340 nfca_poll->rats_res_len = min_t(__u8, *data++, 20);
341 pr_debug("rats_res_len %d\n", nfca_poll->rats_res_len);
342 if (nfca_poll->rats_res_len > 0) {
343 memcpy(nfca_poll->rats_res,
344 data, nfca_poll->rats_res_len);
345 }
346 break;
347
348 case NCI_NFC_B_PASSIVE_POLL_MODE:
349 nfcb_poll = &ntf->activation_params.nfcb_poll_iso_dep;
350 nfcb_poll->attrib_res_len = min_t(__u8, *data++, 50);
351 pr_debug("attrib_res_len %d\n", nfcb_poll->attrib_res_len);
352 if (nfcb_poll->attrib_res_len > 0) {
353 memcpy(nfcb_poll->attrib_res,
354 data, nfcb_poll->attrib_res_len);
355 }
356 break;
357
358 default:
359 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
360 ntf->activation_rf_tech_and_mode);
361 return NCI_STATUS_RF_PROTOCOL_ERROR;
362 }
363
364 return NCI_STATUS_OK;
365}
366
367static int nci_extract_activation_params_nfc_dep(struct nci_dev *ndev,
368 struct nci_rf_intf_activated_ntf *ntf, __u8 *data)
369{
370 struct activation_params_poll_nfc_dep *poll;
371
372 switch (ntf->activation_rf_tech_and_mode) {
373 case NCI_NFC_A_PASSIVE_POLL_MODE:
374 case NCI_NFC_F_PASSIVE_POLL_MODE:
375 poll = &ntf->activation_params.poll_nfc_dep;
376 poll->atr_res_len = min_t(__u8, *data++, 63);
377 pr_debug("atr_res_len %d\n", poll->atr_res_len);
378 if (poll->atr_res_len > 0)
379 memcpy(poll->atr_res, data, poll->atr_res_len);
380 break;
381
382 default:
383 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
384 ntf->activation_rf_tech_and_mode);
385 return NCI_STATUS_RF_PROTOCOL_ERROR;
386 }
387
388 return NCI_STATUS_OK;
389}
390
391static void nci_target_auto_activated(struct nci_dev *ndev,
392 struct nci_rf_intf_activated_ntf *ntf)
393{
394 struct nfc_target *target;
395 int rc;
396
397 target = &ndev->targets[ndev->n_targets];
398
399 rc = nci_add_new_protocol(ndev, target, ntf->rf_protocol,
400 ntf->activation_rf_tech_and_mode,
401 &ntf->rf_tech_specific_params);
402 if (rc)
403 return;
404
405 target->logical_idx = ntf->rf_discovery_id;
406 ndev->n_targets++;
407
408 pr_debug("logical idx %d, n_targets %d\n",
409 target->logical_idx, ndev->n_targets);
410
411 nfc_targets_found(ndev->nfc_dev, ndev->targets, ndev->n_targets);
412}
413
414static void nci_rf_intf_activated_ntf_packet(struct nci_dev *ndev,
415 struct sk_buff *skb)
416{
417 struct nci_rf_intf_activated_ntf ntf;
418 __u8 *data = skb->data;
419 int err = NCI_STATUS_OK;
420
421 ntf.rf_discovery_id = *data++;
422 ntf.rf_interface = *data++;
423 ntf.rf_protocol = *data++;
424 ntf.activation_rf_tech_and_mode = *data++;
425 ntf.max_data_pkt_payload_size = *data++;
426 ntf.initial_num_credits = *data++;
427 ntf.rf_tech_specific_params_len = *data++;
428
429 pr_debug("rf_discovery_id %d\n", ntf.rf_discovery_id);
430 pr_debug("rf_interface 0x%x\n", ntf.rf_interface);
431 pr_debug("rf_protocol 0x%x\n", ntf.rf_protocol);
432 pr_debug("activation_rf_tech_and_mode 0x%x\n",
433 ntf.activation_rf_tech_and_mode);
434 pr_debug("max_data_pkt_payload_size 0x%x\n",
435 ntf.max_data_pkt_payload_size);
436 pr_debug("initial_num_credits 0x%x\n",
437 ntf.initial_num_credits);
438 pr_debug("rf_tech_specific_params_len %d\n",
439 ntf.rf_tech_specific_params_len);
440
441 if (ntf.rf_tech_specific_params_len > 0) {
442 switch (ntf.activation_rf_tech_and_mode) {
443 case NCI_NFC_A_PASSIVE_POLL_MODE:
444 data = nci_extract_rf_params_nfca_passive_poll(ndev,
445 &(ntf.rf_tech_specific_params.nfca_poll), data);
446 break;
447
448 case NCI_NFC_B_PASSIVE_POLL_MODE:
449 data = nci_extract_rf_params_nfcb_passive_poll(ndev,
450 &(ntf.rf_tech_specific_params.nfcb_poll), data);
451 break;
452
453 case NCI_NFC_F_PASSIVE_POLL_MODE:
454 data = nci_extract_rf_params_nfcf_passive_poll(ndev,
455 &(ntf.rf_tech_specific_params.nfcf_poll), data);
456 break;
457
458 default:
459 pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
460 ntf.activation_rf_tech_and_mode);
461 err = NCI_STATUS_RF_PROTOCOL_ERROR;
462 goto exit;
463 }
464 }
465
466 ntf.data_exch_rf_tech_and_mode = *data++;
467 ntf.data_exch_tx_bit_rate = *data++;
468 ntf.data_exch_rx_bit_rate = *data++;
469 ntf.activation_params_len = *data++;
470
471 pr_debug("data_exch_rf_tech_and_mode 0x%x\n",
472 ntf.data_exch_rf_tech_and_mode);
473 pr_debug("data_exch_tx_bit_rate 0x%x\n", ntf.data_exch_tx_bit_rate);
474 pr_debug("data_exch_rx_bit_rate 0x%x\n", ntf.data_exch_rx_bit_rate);
475 pr_debug("activation_params_len %d\n", ntf.activation_params_len);
476
477 if (ntf.activation_params_len > 0) {
478 switch (ntf.rf_interface) {
479 case NCI_RF_INTERFACE_ISO_DEP:
480 err = nci_extract_activation_params_iso_dep(ndev,
481 &ntf, data);
482 break;
483
484 case NCI_RF_INTERFACE_NFC_DEP:
485 err = nci_extract_activation_params_nfc_dep(ndev,
486 &ntf, data);
487 break;
488
489 case NCI_RF_INTERFACE_FRAME:
490
491 break;
492
493 default:
494 pr_err("unsupported rf_interface 0x%x\n",
495 ntf.rf_interface);
496 err = NCI_STATUS_RF_PROTOCOL_ERROR;
497 break;
498 }
499 }
500
501exit:
502 if (err == NCI_STATUS_OK) {
503 ndev->max_data_pkt_payload_size = ntf.max_data_pkt_payload_size;
504 ndev->initial_num_credits = ntf.initial_num_credits;
505
506
507 atomic_set(&ndev->credits_cnt, ndev->initial_num_credits);
508
509
510 if (ntf.rf_interface == NCI_RF_INTERFACE_NFC_DEP) {
511 ndev->remote_gb_len = 0;
512
513 if (ntf.activation_params_len > 0) {
514
515 ndev->remote_gb_len = min_t(__u8,
516 (ntf.activation_params
517 .poll_nfc_dep.atr_res_len
518 - NFC_ATR_RES_GT_OFFSET),
519 NFC_MAX_GT_LEN);
520 memcpy(ndev->remote_gb,
521 (ntf.activation_params.poll_nfc_dep
522 .atr_res + NFC_ATR_RES_GT_OFFSET),
523 ndev->remote_gb_len);
524 }
525 }
526 }
527
528 if (atomic_read(&ndev->state) == NCI_DISCOVERY) {
529
530 atomic_set(&ndev->state, NCI_POLL_ACTIVE);
531 if (err == NCI_STATUS_OK)
532 nci_target_auto_activated(ndev, &ntf);
533 } else {
534
535 atomic_set(&ndev->state, NCI_POLL_ACTIVE);
536 nci_req_complete(ndev, err);
537 }
538}
539
540static void nci_rf_deactivate_ntf_packet(struct nci_dev *ndev,
541 struct sk_buff *skb)
542{
543 struct nci_rf_deactivate_ntf *ntf = (void *) skb->data;
544
545 pr_debug("entry, type 0x%x, reason 0x%x\n", ntf->type, ntf->reason);
546
547
548 skb_queue_purge(&ndev->tx_q);
549
550
551 if (ndev->rx_data_reassembly) {
552 kfree_skb(ndev->rx_data_reassembly);
553 ndev->rx_data_reassembly = NULL;
554 }
555
556
557 if (test_bit(NCI_DATA_EXCHANGE, &ndev->flags))
558 nci_data_exchange_complete(ndev, NULL, -EIO);
559
560 nci_clear_target_list(ndev);
561 atomic_set(&ndev->state, NCI_IDLE);
562 nci_req_complete(ndev, NCI_STATUS_OK);
563}
564
565void nci_ntf_packet(struct nci_dev *ndev, struct sk_buff *skb)
566{
567 __u16 ntf_opcode = nci_opcode(skb->data);
568
569 pr_debug("NCI RX: MT=ntf, PBF=%d, GID=0x%x, OID=0x%x, plen=%d\n",
570 nci_pbf(skb->data),
571 nci_opcode_gid(ntf_opcode),
572 nci_opcode_oid(ntf_opcode),
573 nci_plen(skb->data));
574
575
576 skb_pull(skb, NCI_CTRL_HDR_SIZE);
577
578 switch (ntf_opcode) {
579 case NCI_OP_CORE_CONN_CREDITS_NTF:
580 nci_core_conn_credits_ntf_packet(ndev, skb);
581 break;
582
583 case NCI_OP_CORE_GENERIC_ERROR_NTF:
584 nci_core_generic_error_ntf_packet(ndev, skb);
585 break;
586
587 case NCI_OP_CORE_INTF_ERROR_NTF:
588 nci_core_conn_intf_error_ntf_packet(ndev, skb);
589 break;
590
591 case NCI_OP_RF_DISCOVER_NTF:
592 nci_rf_discover_ntf_packet(ndev, skb);
593 break;
594
595 case NCI_OP_RF_INTF_ACTIVATED_NTF:
596 nci_rf_intf_activated_ntf_packet(ndev, skb);
597 break;
598
599 case NCI_OP_RF_DEACTIVATE_NTF:
600 nci_rf_deactivate_ntf_packet(ndev, skb);
601 break;
602
603 default:
604 pr_err("unknown ntf opcode 0x%x\n", ntf_opcode);
605 break;
606 }
607
608 kfree_skb(skb);
609}
610
