1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * NFC Digital Protocol stack |
4 | * Copyright (c) 2013, Intel Corporation. |
5 | */ |
6 | |
7 | #define pr_fmt(fmt) "digital: %s: " fmt, __func__ |
8 | |
9 | #include "digital.h" |
10 | |
11 | #define DIGITAL_NFC_DEP_N_RETRY_NACK 2 |
12 | #define DIGITAL_NFC_DEP_N_RETRY_ATN 2 |
13 | |
14 | #define DIGITAL_NFC_DEP_FRAME_DIR_OUT 0xD4 |
15 | #define DIGITAL_NFC_DEP_FRAME_DIR_IN 0xD5 |
16 | |
17 | #define DIGITAL_NFC_DEP_NFCA_SOD_SB 0xF0 |
18 | |
19 | #define DIGITAL_CMD_ATR_REQ 0x00 |
20 | #define DIGITAL_CMD_ATR_RES 0x01 |
21 | #define DIGITAL_CMD_PSL_REQ 0x04 |
22 | #define DIGITAL_CMD_PSL_RES 0x05 |
23 | #define DIGITAL_CMD_DEP_REQ 0x06 |
24 | #define DIGITAL_CMD_DEP_RES 0x07 |
25 | |
26 | #define DIGITAL_ATR_REQ_MIN_SIZE 16 |
27 | #define DIGITAL_ATR_REQ_MAX_SIZE 64 |
28 | |
29 | #define DIGITAL_ATR_RES_TO_WT(s) ((s) & 0xF) |
30 | |
31 | #define DIGITAL_DID_MAX 14 |
32 | |
33 | #define DIGITAL_PAYLOAD_SIZE_MAX 254 |
34 | #define DIGITAL_PAYLOAD_BITS_TO_PP(s) (((s) & 0x3) << 4) |
35 | #define DIGITAL_PAYLOAD_PP_TO_BITS(s) (((s) >> 4) & 0x3) |
36 | #define DIGITAL_PAYLOAD_BITS_TO_FSL(s) ((s) & 0x3) |
37 | #define DIGITAL_PAYLOAD_FSL_TO_BITS(s) ((s) & 0x3) |
38 | |
39 | #define DIGITAL_GB_BIT 0x02 |
40 | |
41 | #define DIGITAL_NFC_DEP_PFB_TYPE(pfb) ((pfb) & 0xE0) |
42 | |
43 | #define DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT 0x10 |
44 | #define DIGITAL_NFC_DEP_PFB_MI_BIT 0x10 |
45 | #define DIGITAL_NFC_DEP_PFB_NACK_BIT 0x10 |
46 | #define DIGITAL_NFC_DEP_PFB_DID_BIT 0x04 |
47 | |
48 | #define DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb) \ |
49 | ((pfb) & DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT) |
50 | #define DIGITAL_NFC_DEP_MI_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_MI_BIT) |
51 | #define DIGITAL_NFC_DEP_NACK_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_NACK_BIT) |
52 | #define DIGITAL_NFC_DEP_NAD_BIT_SET(pfb) ((pfb) & 0x08) |
53 | #define DIGITAL_NFC_DEP_DID_BIT_SET(pfb) ((pfb) & DIGITAL_NFC_DEP_PFB_DID_BIT) |
54 | #define DIGITAL_NFC_DEP_PFB_PNI(pfb) ((pfb) & 0x03) |
55 | |
56 | #define DIGITAL_NFC_DEP_RTOX_VALUE(data) ((data) & 0x3F) |
57 | #define DIGITAL_NFC_DEP_RTOX_MAX 59 |
58 | |
59 | #define DIGITAL_NFC_DEP_PFB_I_PDU 0x00 |
60 | #define DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU 0x40 |
61 | #define DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU 0x80 |
62 | |
63 | struct digital_atr_req { |
64 | u8 dir; |
65 | u8 cmd; |
66 | u8 nfcid3[10]; |
67 | u8 did; |
68 | u8 bs; |
69 | u8 br; |
70 | u8 pp; |
71 | u8 gb[]; |
72 | } __packed; |
73 | |
74 | struct digital_atr_res { |
75 | u8 dir; |
76 | u8 cmd; |
77 | u8 nfcid3[10]; |
78 | u8 did; |
79 | u8 bs; |
80 | u8 br; |
81 | u8 to; |
82 | u8 pp; |
83 | u8 gb[]; |
84 | } __packed; |
85 | |
86 | struct digital_psl_req { |
87 | u8 dir; |
88 | u8 cmd; |
89 | u8 did; |
90 | u8 brs; |
91 | u8 fsl; |
92 | } __packed; |
93 | |
94 | struct digital_psl_res { |
95 | u8 dir; |
96 | u8 cmd; |
97 | u8 did; |
98 | } __packed; |
99 | |
100 | struct digital_dep_req_res { |
101 | u8 dir; |
102 | u8 cmd; |
103 | u8 pfb; |
104 | } __packed; |
105 | |
106 | static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg, |
107 | struct sk_buff *resp); |
108 | static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg, |
109 | struct sk_buff *resp); |
110 | |
111 | static const u8 digital_payload_bits_map[4] = { |
112 | [0] = 64, |
113 | [1] = 128, |
114 | [2] = 192, |
115 | [3] = 254 |
116 | }; |
117 | |
118 | /* Response Waiting Time for ATR_RES PDU in ms |
119 | * |
120 | * RWT(ATR_RES) = RWT(nfcdep,activation) + dRWT(nfcdep) + dT(nfcdep,initiator) |
121 | * |
122 | * with: |
123 | * RWT(nfcdep,activation) = 4096 * 2^12 / f(c) s |
124 | * dRWT(nfcdep) = 16 / f(c) s |
125 | * dT(nfcdep,initiator) = 100 ms |
126 | * f(c) = 13560000 Hz |
127 | */ |
128 | #define DIGITAL_ATR_RES_RWT 1337 |
129 | |
130 | /* Response Waiting Time for other DEP PDUs in ms |
131 | * |
132 | * max_rwt = rwt + dRWT(nfcdep) + dT(nfcdep,initiator) |
133 | * |
134 | * with: |
135 | * rwt = (256 * 16 / f(c)) * 2^wt s |
136 | * dRWT(nfcdep) = 16 / f(c) s |
137 | * dT(nfcdep,initiator) = 100 ms |
138 | * f(c) = 13560000 Hz |
139 | * 0 <= wt <= 14 (given by the target by the TO field of ATR_RES response) |
140 | */ |
141 | #define DIGITAL_NFC_DEP_IN_MAX_WT 14 |
142 | #define DIGITAL_NFC_DEP_TG_MAX_WT 14 |
143 | static const u16 digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT + 1] = { |
144 | 100, 101, 101, 102, 105, |
145 | 110, 119, 139, 177, 255, |
146 | 409, 719, 1337, 2575, 5049, |
147 | }; |
148 | |
149 | static u8 digital_payload_bits_to_size(u8 payload_bits) |
150 | { |
151 | if (payload_bits >= ARRAY_SIZE(digital_payload_bits_map)) |
152 | return 0; |
153 | |
154 | return digital_payload_bits_map[payload_bits]; |
155 | } |
156 | |
157 | static u8 digital_payload_size_to_bits(u8 payload_size) |
158 | { |
159 | int i; |
160 | |
161 | for (i = 0; i < ARRAY_SIZE(digital_payload_bits_map); i++) |
162 | if (digital_payload_bits_map[i] == payload_size) |
163 | return i; |
164 | |
165 | return 0xff; |
166 | } |
167 | |
168 | static void digital_skb_push_dep_sod(struct nfc_digital_dev *ddev, |
169 | struct sk_buff *skb) |
170 | { |
171 | skb_push(skb, len: sizeof(u8)); |
172 | |
173 | skb->data[0] = skb->len; |
174 | |
175 | if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A) |
176 | *(u8 *)skb_push(skb, len: sizeof(u8)) = DIGITAL_NFC_DEP_NFCA_SOD_SB; |
177 | } |
178 | |
179 | static int digital_skb_pull_dep_sod(struct nfc_digital_dev *ddev, |
180 | struct sk_buff *skb) |
181 | { |
182 | u8 size; |
183 | |
184 | if (skb->len < 2) |
185 | return -EIO; |
186 | |
187 | if (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A) |
188 | skb_pull(skb, len: sizeof(u8)); |
189 | |
190 | size = skb->data[0]; |
191 | if (size != skb->len) |
192 | return -EIO; |
193 | |
194 | skb_pull(skb, len: sizeof(u8)); |
195 | |
196 | return 0; |
197 | } |
198 | |
199 | static struct sk_buff * |
200 | digital_send_dep_data_prep(struct nfc_digital_dev *ddev, struct sk_buff *skb, |
201 | struct digital_dep_req_res *dep_req_res, |
202 | struct digital_data_exch *data_exch) |
203 | { |
204 | struct sk_buff *new_skb; |
205 | |
206 | if (skb->len > ddev->remote_payload_max) { |
207 | dep_req_res->pfb |= DIGITAL_NFC_DEP_PFB_MI_BIT; |
208 | |
209 | new_skb = digital_skb_alloc(ddev, len: ddev->remote_payload_max); |
210 | if (!new_skb) { |
211 | kfree_skb(skb: ddev->chaining_skb); |
212 | ddev->chaining_skb = NULL; |
213 | |
214 | return ERR_PTR(error: -ENOMEM); |
215 | } |
216 | |
217 | skb_put_data(skb: new_skb, data: skb->data, len: ddev->remote_payload_max); |
218 | skb_pull(skb, len: ddev->remote_payload_max); |
219 | |
220 | ddev->chaining_skb = skb; |
221 | ddev->data_exch = data_exch; |
222 | } else { |
223 | ddev->chaining_skb = NULL; |
224 | new_skb = skb; |
225 | } |
226 | |
227 | return new_skb; |
228 | } |
229 | |
230 | static struct sk_buff * |
231 | digital_recv_dep_data_gather(struct nfc_digital_dev *ddev, u8 pfb, |
232 | struct sk_buff *resp, |
233 | int (*send_ack)(struct nfc_digital_dev *ddev, |
234 | struct digital_data_exch |
235 | *data_exch), |
236 | struct digital_data_exch *data_exch) |
237 | { |
238 | struct sk_buff *new_skb; |
239 | int rc; |
240 | |
241 | if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb) && (!ddev->chaining_skb)) { |
242 | ddev->chaining_skb = |
243 | nfc_alloc_recv_skb(size: 8 * ddev->local_payload_max, |
244 | GFP_KERNEL); |
245 | if (!ddev->chaining_skb) { |
246 | rc = -ENOMEM; |
247 | goto error; |
248 | } |
249 | } |
250 | |
251 | if (ddev->chaining_skb) { |
252 | if (resp->len > skb_tailroom(skb: ddev->chaining_skb)) { |
253 | new_skb = skb_copy_expand(skb: ddev->chaining_skb, |
254 | newheadroom: skb_headroom( |
255 | skb: ddev->chaining_skb), |
256 | newtailroom: 8 * ddev->local_payload_max, |
257 | GFP_KERNEL); |
258 | if (!new_skb) { |
259 | rc = -ENOMEM; |
260 | goto error; |
261 | } |
262 | |
263 | kfree_skb(skb: ddev->chaining_skb); |
264 | ddev->chaining_skb = new_skb; |
265 | } |
266 | |
267 | skb_put_data(skb: ddev->chaining_skb, data: resp->data, len: resp->len); |
268 | |
269 | kfree_skb(skb: resp); |
270 | resp = NULL; |
271 | |
272 | if (DIGITAL_NFC_DEP_MI_BIT_SET(pfb)) { |
273 | rc = send_ack(ddev, data_exch); |
274 | if (rc) |
275 | goto error; |
276 | |
277 | return NULL; |
278 | } |
279 | |
280 | resp = ddev->chaining_skb; |
281 | ddev->chaining_skb = NULL; |
282 | } |
283 | |
284 | return resp; |
285 | |
286 | error: |
287 | kfree_skb(skb: resp); |
288 | |
289 | kfree_skb(skb: ddev->chaining_skb); |
290 | ddev->chaining_skb = NULL; |
291 | |
292 | return ERR_PTR(error: rc); |
293 | } |
294 | |
295 | static void digital_in_recv_psl_res(struct nfc_digital_dev *ddev, void *arg, |
296 | struct sk_buff *resp) |
297 | { |
298 | struct nfc_target *target = arg; |
299 | struct digital_psl_res *psl_res; |
300 | int rc; |
301 | |
302 | if (IS_ERR(ptr: resp)) { |
303 | rc = PTR_ERR(ptr: resp); |
304 | resp = NULL; |
305 | goto exit; |
306 | } |
307 | |
308 | rc = ddev->skb_check_crc(resp); |
309 | if (rc) { |
310 | PROTOCOL_ERR("14.4.1.6" ); |
311 | goto exit; |
312 | } |
313 | |
314 | rc = digital_skb_pull_dep_sod(ddev, skb: resp); |
315 | if (rc) { |
316 | PROTOCOL_ERR("14.4.1.2" ); |
317 | goto exit; |
318 | } |
319 | |
320 | psl_res = (struct digital_psl_res *)resp->data; |
321 | |
322 | if ((resp->len != sizeof(*psl_res)) || |
323 | (psl_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN) || |
324 | (psl_res->cmd != DIGITAL_CMD_PSL_RES)) { |
325 | rc = -EIO; |
326 | goto exit; |
327 | } |
328 | |
329 | rc = digital_in_configure_hw(ddev, type: NFC_DIGITAL_CONFIG_RF_TECH, |
330 | param: NFC_DIGITAL_RF_TECH_424F); |
331 | if (rc) |
332 | goto exit; |
333 | |
334 | rc = digital_in_configure_hw(ddev, type: NFC_DIGITAL_CONFIG_FRAMING, |
335 | param: NFC_DIGITAL_FRAMING_NFCF_NFC_DEP); |
336 | if (rc) |
337 | goto exit; |
338 | |
339 | if (!DIGITAL_DRV_CAPS_IN_CRC(ddev) && |
340 | (ddev->curr_rf_tech == NFC_DIGITAL_RF_TECH_106A)) { |
341 | ddev->skb_add_crc = digital_skb_add_crc_f; |
342 | ddev->skb_check_crc = digital_skb_check_crc_f; |
343 | } |
344 | |
345 | ddev->curr_rf_tech = NFC_DIGITAL_RF_TECH_424F; |
346 | |
347 | nfc_dep_link_is_up(dev: ddev->nfc_dev, target_idx: target->idx, NFC_COMM_ACTIVE, |
348 | NFC_RF_INITIATOR); |
349 | |
350 | ddev->curr_nfc_dep_pni = 0; |
351 | |
352 | exit: |
353 | dev_kfree_skb(resp); |
354 | |
355 | if (rc) |
356 | ddev->curr_protocol = 0; |
357 | } |
358 | |
359 | static int digital_in_send_psl_req(struct nfc_digital_dev *ddev, |
360 | struct nfc_target *target) |
361 | { |
362 | struct sk_buff *skb; |
363 | struct digital_psl_req *psl_req; |
364 | int rc; |
365 | u8 payload_size, payload_bits; |
366 | |
367 | skb = digital_skb_alloc(ddev, len: sizeof(*psl_req)); |
368 | if (!skb) |
369 | return -ENOMEM; |
370 | |
371 | skb_put(skb, len: sizeof(*psl_req)); |
372 | |
373 | psl_req = (struct digital_psl_req *)skb->data; |
374 | |
375 | psl_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
376 | psl_req->cmd = DIGITAL_CMD_PSL_REQ; |
377 | psl_req->did = 0; |
378 | psl_req->brs = (0x2 << 3) | 0x2; /* 424F both directions */ |
379 | |
380 | payload_size = min(ddev->local_payload_max, ddev->remote_payload_max); |
381 | payload_bits = digital_payload_size_to_bits(payload_size); |
382 | psl_req->fsl = DIGITAL_PAYLOAD_BITS_TO_FSL(payload_bits); |
383 | |
384 | ddev->local_payload_max = payload_size; |
385 | ddev->remote_payload_max = payload_size; |
386 | |
387 | digital_skb_push_dep_sod(ddev, skb); |
388 | |
389 | ddev->skb_add_crc(skb); |
390 | |
391 | rc = digital_in_send_cmd(ddev, skb, timeout: ddev->dep_rwt, |
392 | cmd_cb: digital_in_recv_psl_res, cb_context: target); |
393 | if (rc) |
394 | kfree_skb(skb); |
395 | |
396 | return rc; |
397 | } |
398 | |
399 | static void digital_in_recv_atr_res(struct nfc_digital_dev *ddev, void *arg, |
400 | struct sk_buff *resp) |
401 | { |
402 | struct nfc_target *target = arg; |
403 | struct digital_atr_res *atr_res; |
404 | u8 gb_len, payload_bits; |
405 | u8 wt; |
406 | int rc; |
407 | |
408 | if (IS_ERR(ptr: resp)) { |
409 | rc = PTR_ERR(ptr: resp); |
410 | resp = NULL; |
411 | goto exit; |
412 | } |
413 | |
414 | rc = ddev->skb_check_crc(resp); |
415 | if (rc) { |
416 | PROTOCOL_ERR("14.4.1.6" ); |
417 | goto exit; |
418 | } |
419 | |
420 | rc = digital_skb_pull_dep_sod(ddev, skb: resp); |
421 | if (rc) { |
422 | PROTOCOL_ERR("14.4.1.2" ); |
423 | goto exit; |
424 | } |
425 | |
426 | if (resp->len < sizeof(struct digital_atr_res)) { |
427 | rc = -EIO; |
428 | goto exit; |
429 | } |
430 | |
431 | gb_len = resp->len - sizeof(struct digital_atr_res); |
432 | |
433 | atr_res = (struct digital_atr_res *)resp->data; |
434 | |
435 | wt = DIGITAL_ATR_RES_TO_WT(atr_res->to); |
436 | if (wt > DIGITAL_NFC_DEP_IN_MAX_WT) |
437 | wt = DIGITAL_NFC_DEP_IN_MAX_WT; |
438 | ddev->dep_rwt = digital_rwt_map[wt]; |
439 | |
440 | payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_res->pp); |
441 | ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits); |
442 | |
443 | if (!ddev->remote_payload_max) { |
444 | rc = -EINVAL; |
445 | goto exit; |
446 | } |
447 | |
448 | rc = nfc_set_remote_general_bytes(dev: ddev->nfc_dev, gt: atr_res->gb, gt_len: gb_len); |
449 | if (rc) |
450 | goto exit; |
451 | |
452 | if ((ddev->protocols & NFC_PROTO_FELICA_MASK) && |
453 | (ddev->curr_rf_tech != NFC_DIGITAL_RF_TECH_424F)) { |
454 | rc = digital_in_send_psl_req(ddev, target); |
455 | if (!rc) |
456 | goto exit; |
457 | } |
458 | |
459 | rc = nfc_dep_link_is_up(dev: ddev->nfc_dev, target_idx: target->idx, NFC_COMM_ACTIVE, |
460 | NFC_RF_INITIATOR); |
461 | |
462 | ddev->curr_nfc_dep_pni = 0; |
463 | |
464 | exit: |
465 | dev_kfree_skb(resp); |
466 | |
467 | if (rc) |
468 | ddev->curr_protocol = 0; |
469 | } |
470 | |
471 | int digital_in_send_atr_req(struct nfc_digital_dev *ddev, |
472 | struct nfc_target *target, __u8 comm_mode, __u8 *gb, |
473 | size_t gb_len) |
474 | { |
475 | struct sk_buff *skb; |
476 | struct digital_atr_req *atr_req; |
477 | uint size; |
478 | int rc; |
479 | u8 payload_bits; |
480 | |
481 | size = DIGITAL_ATR_REQ_MIN_SIZE + gb_len; |
482 | |
483 | if (size > DIGITAL_ATR_REQ_MAX_SIZE) { |
484 | PROTOCOL_ERR("14.6.1.1" ); |
485 | return -EINVAL; |
486 | } |
487 | |
488 | skb = digital_skb_alloc(ddev, len: size); |
489 | if (!skb) |
490 | return -ENOMEM; |
491 | |
492 | skb_put(skb, len: sizeof(struct digital_atr_req)); |
493 | |
494 | atr_req = (struct digital_atr_req *)skb->data; |
495 | memset(atr_req, 0, sizeof(struct digital_atr_req)); |
496 | |
497 | atr_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
498 | atr_req->cmd = DIGITAL_CMD_ATR_REQ; |
499 | if (target->nfcid2_len) |
500 | memcpy(atr_req->nfcid3, target->nfcid2, NFC_NFCID2_MAXSIZE); |
501 | else |
502 | get_random_bytes(buf: atr_req->nfcid3, NFC_NFCID3_MAXSIZE); |
503 | |
504 | atr_req->did = 0; |
505 | atr_req->bs = 0; |
506 | atr_req->br = 0; |
507 | |
508 | ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX; |
509 | payload_bits = digital_payload_size_to_bits(payload_size: ddev->local_payload_max); |
510 | atr_req->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits); |
511 | |
512 | if (gb_len) { |
513 | atr_req->pp |= DIGITAL_GB_BIT; |
514 | skb_put_data(skb, data: gb, len: gb_len); |
515 | } |
516 | |
517 | digital_skb_push_dep_sod(ddev, skb); |
518 | |
519 | ddev->skb_add_crc(skb); |
520 | |
521 | rc = digital_in_send_cmd(ddev, skb, DIGITAL_ATR_RES_RWT, |
522 | cmd_cb: digital_in_recv_atr_res, cb_context: target); |
523 | if (rc) |
524 | kfree_skb(skb); |
525 | |
526 | return rc; |
527 | } |
528 | |
529 | static int digital_in_send_ack(struct nfc_digital_dev *ddev, |
530 | struct digital_data_exch *data_exch) |
531 | { |
532 | struct digital_dep_req_res *dep_req; |
533 | struct sk_buff *skb; |
534 | int rc; |
535 | |
536 | skb = digital_skb_alloc(ddev, len: 1); |
537 | if (!skb) |
538 | return -ENOMEM; |
539 | |
540 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
541 | |
542 | dep_req = (struct digital_dep_req_res *)skb->data; |
543 | |
544 | dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
545 | dep_req->cmd = DIGITAL_CMD_DEP_REQ; |
546 | dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU | |
547 | ddev->curr_nfc_dep_pni; |
548 | |
549 | digital_skb_push_dep_sod(ddev, skb); |
550 | |
551 | ddev->skb_add_crc(skb); |
552 | |
553 | ddev->saved_skb = pskb_copy(skb, GFP_KERNEL); |
554 | |
555 | rc = digital_in_send_cmd(ddev, skb, timeout: ddev->dep_rwt, |
556 | cmd_cb: digital_in_recv_dep_res, cb_context: data_exch); |
557 | if (rc) { |
558 | kfree_skb(skb); |
559 | kfree_skb(skb: ddev->saved_skb); |
560 | ddev->saved_skb = NULL; |
561 | } |
562 | |
563 | return rc; |
564 | } |
565 | |
566 | static int digital_in_send_nack(struct nfc_digital_dev *ddev, |
567 | struct digital_data_exch *data_exch) |
568 | { |
569 | struct digital_dep_req_res *dep_req; |
570 | struct sk_buff *skb; |
571 | int rc; |
572 | |
573 | skb = digital_skb_alloc(ddev, len: 1); |
574 | if (!skb) |
575 | return -ENOMEM; |
576 | |
577 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
578 | |
579 | dep_req = (struct digital_dep_req_res *)skb->data; |
580 | |
581 | dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
582 | dep_req->cmd = DIGITAL_CMD_DEP_REQ; |
583 | dep_req->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU | |
584 | DIGITAL_NFC_DEP_PFB_NACK_BIT | ddev->curr_nfc_dep_pni; |
585 | |
586 | digital_skb_push_dep_sod(ddev, skb); |
587 | |
588 | ddev->skb_add_crc(skb); |
589 | |
590 | rc = digital_in_send_cmd(ddev, skb, timeout: ddev->dep_rwt, |
591 | cmd_cb: digital_in_recv_dep_res, cb_context: data_exch); |
592 | if (rc) |
593 | kfree_skb(skb); |
594 | |
595 | return rc; |
596 | } |
597 | |
598 | static int digital_in_send_atn(struct nfc_digital_dev *ddev, |
599 | struct digital_data_exch *data_exch) |
600 | { |
601 | struct digital_dep_req_res *dep_req; |
602 | struct sk_buff *skb; |
603 | int rc; |
604 | |
605 | skb = digital_skb_alloc(ddev, len: 1); |
606 | if (!skb) |
607 | return -ENOMEM; |
608 | |
609 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
610 | |
611 | dep_req = (struct digital_dep_req_res *)skb->data; |
612 | |
613 | dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
614 | dep_req->cmd = DIGITAL_CMD_DEP_REQ; |
615 | dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU; |
616 | |
617 | digital_skb_push_dep_sod(ddev, skb); |
618 | |
619 | ddev->skb_add_crc(skb); |
620 | |
621 | rc = digital_in_send_cmd(ddev, skb, timeout: ddev->dep_rwt, |
622 | cmd_cb: digital_in_recv_dep_res, cb_context: data_exch); |
623 | if (rc) |
624 | kfree_skb(skb); |
625 | |
626 | return rc; |
627 | } |
628 | |
629 | static int digital_in_send_rtox(struct nfc_digital_dev *ddev, |
630 | struct digital_data_exch *data_exch, u8 rtox) |
631 | { |
632 | struct digital_dep_req_res *dep_req; |
633 | struct sk_buff *skb; |
634 | int rc; |
635 | u16 rwt_int; |
636 | |
637 | rwt_int = ddev->dep_rwt * rtox; |
638 | if (rwt_int > digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT]) |
639 | rwt_int = digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT]; |
640 | |
641 | skb = digital_skb_alloc(ddev, len: 1); |
642 | if (!skb) |
643 | return -ENOMEM; |
644 | |
645 | skb_put_u8(skb, val: rtox); |
646 | |
647 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
648 | |
649 | dep_req = (struct digital_dep_req_res *)skb->data; |
650 | |
651 | dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
652 | dep_req->cmd = DIGITAL_CMD_DEP_REQ; |
653 | dep_req->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU | |
654 | DIGITAL_NFC_DEP_PFB_TIMEOUT_BIT; |
655 | |
656 | digital_skb_push_dep_sod(ddev, skb); |
657 | |
658 | ddev->skb_add_crc(skb); |
659 | |
660 | rc = digital_in_send_cmd(ddev, skb, timeout: rwt_int, |
661 | cmd_cb: digital_in_recv_dep_res, cb_context: data_exch); |
662 | if (rc) |
663 | kfree_skb(skb); |
664 | |
665 | return rc; |
666 | } |
667 | |
668 | static int digital_in_send_saved_skb(struct nfc_digital_dev *ddev, |
669 | struct digital_data_exch *data_exch) |
670 | { |
671 | int rc; |
672 | |
673 | if (!ddev->saved_skb) |
674 | return -EINVAL; |
675 | |
676 | skb_get(skb: ddev->saved_skb); |
677 | |
678 | rc = digital_in_send_cmd(ddev, skb: ddev->saved_skb, timeout: ddev->dep_rwt, |
679 | cmd_cb: digital_in_recv_dep_res, cb_context: data_exch); |
680 | if (rc) |
681 | kfree_skb(skb: ddev->saved_skb); |
682 | |
683 | return rc; |
684 | } |
685 | |
686 | static void digital_in_recv_dep_res(struct nfc_digital_dev *ddev, void *arg, |
687 | struct sk_buff *resp) |
688 | { |
689 | struct digital_data_exch *data_exch = arg; |
690 | struct digital_dep_req_res *dep_res; |
691 | u8 pfb; |
692 | uint size; |
693 | int rc; |
694 | u8 rtox; |
695 | |
696 | if (IS_ERR(ptr: resp)) { |
697 | rc = PTR_ERR(ptr: resp); |
698 | resp = NULL; |
699 | |
700 | if ((rc == -EIO || (rc == -ETIMEDOUT && ddev->nack_count)) && |
701 | (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) { |
702 | ddev->atn_count = 0; |
703 | |
704 | rc = digital_in_send_nack(ddev, data_exch); |
705 | if (rc) |
706 | goto error; |
707 | |
708 | return; |
709 | } else if ((rc == -ETIMEDOUT) && |
710 | (ddev->atn_count++ < DIGITAL_NFC_DEP_N_RETRY_ATN)) { |
711 | ddev->nack_count = 0; |
712 | |
713 | rc = digital_in_send_atn(ddev, data_exch); |
714 | if (rc) |
715 | goto error; |
716 | |
717 | return; |
718 | } |
719 | |
720 | goto exit; |
721 | } |
722 | |
723 | rc = digital_skb_pull_dep_sod(ddev, skb: resp); |
724 | if (rc) { |
725 | PROTOCOL_ERR("14.4.1.2" ); |
726 | goto exit; |
727 | } |
728 | |
729 | rc = ddev->skb_check_crc(resp); |
730 | if (rc) { |
731 | if ((resp->len >= 4) && |
732 | (ddev->nack_count++ < DIGITAL_NFC_DEP_N_RETRY_NACK)) { |
733 | ddev->atn_count = 0; |
734 | |
735 | rc = digital_in_send_nack(ddev, data_exch); |
736 | if (rc) |
737 | goto error; |
738 | |
739 | kfree_skb(skb: resp); |
740 | |
741 | return; |
742 | } |
743 | |
744 | PROTOCOL_ERR("14.4.1.6" ); |
745 | goto error; |
746 | } |
747 | |
748 | ddev->atn_count = 0; |
749 | ddev->nack_count = 0; |
750 | |
751 | if (resp->len > ddev->local_payload_max) { |
752 | rc = -EMSGSIZE; |
753 | goto exit; |
754 | } |
755 | |
756 | size = sizeof(struct digital_dep_req_res); |
757 | dep_res = (struct digital_dep_req_res *)resp->data; |
758 | |
759 | if (resp->len < size || dep_res->dir != DIGITAL_NFC_DEP_FRAME_DIR_IN || |
760 | dep_res->cmd != DIGITAL_CMD_DEP_RES) { |
761 | rc = -EIO; |
762 | goto error; |
763 | } |
764 | |
765 | pfb = dep_res->pfb; |
766 | |
767 | if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) { |
768 | PROTOCOL_ERR("14.8.2.1" ); |
769 | rc = -EIO; |
770 | goto error; |
771 | } |
772 | |
773 | if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) { |
774 | rc = -EIO; |
775 | goto exit; |
776 | } |
777 | |
778 | if (size > resp->len) { |
779 | rc = -EIO; |
780 | goto error; |
781 | } |
782 | |
783 | skb_pull(skb: resp, len: size); |
784 | |
785 | switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) { |
786 | case DIGITAL_NFC_DEP_PFB_I_PDU: |
787 | if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { |
788 | PROTOCOL_ERR("14.12.3.3" ); |
789 | rc = -EIO; |
790 | goto error; |
791 | } |
792 | |
793 | ddev->curr_nfc_dep_pni = |
794 | DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); |
795 | |
796 | kfree_skb(skb: ddev->saved_skb); |
797 | ddev->saved_skb = NULL; |
798 | |
799 | resp = digital_recv_dep_data_gather(ddev, pfb, resp, |
800 | send_ack: digital_in_send_ack, |
801 | data_exch); |
802 | if (IS_ERR(ptr: resp)) { |
803 | rc = PTR_ERR(ptr: resp); |
804 | resp = NULL; |
805 | goto error; |
806 | } |
807 | |
808 | /* If resp is NULL then we're still chaining so return and |
809 | * wait for the next part of the PDU. Else, the PDU is |
810 | * complete so pass it up. |
811 | */ |
812 | if (!resp) |
813 | return; |
814 | |
815 | rc = 0; |
816 | break; |
817 | |
818 | case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU: |
819 | if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { |
820 | PROTOCOL_ERR("14.12.4.5" ); |
821 | rc = -EIO; |
822 | goto exit; |
823 | } |
824 | |
825 | if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { |
826 | PROTOCOL_ERR("14.12.3.3" ); |
827 | rc = -EIO; |
828 | goto exit; |
829 | } |
830 | |
831 | ddev->curr_nfc_dep_pni = |
832 | DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); |
833 | |
834 | if (!ddev->chaining_skb) { |
835 | PROTOCOL_ERR("14.12.4.3" ); |
836 | rc = -EIO; |
837 | goto exit; |
838 | } |
839 | |
840 | /* The initiator has received a valid ACK. Free the last sent |
841 | * PDU and keep on sending chained skb. |
842 | */ |
843 | kfree_skb(skb: ddev->saved_skb); |
844 | ddev->saved_skb = NULL; |
845 | |
846 | rc = digital_in_send_dep_req(ddev, NULL, |
847 | skb: ddev->chaining_skb, |
848 | data_exch: ddev->data_exch); |
849 | if (rc) |
850 | goto error; |
851 | |
852 | goto free_resp; |
853 | |
854 | case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU: |
855 | if (!DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { /* ATN */ |
856 | rc = digital_in_send_saved_skb(ddev, data_exch); |
857 | if (rc) |
858 | goto error; |
859 | |
860 | goto free_resp; |
861 | } |
862 | |
863 | if (ddev->atn_count || ddev->nack_count) { |
864 | PROTOCOL_ERR("14.12.4.4" ); |
865 | rc = -EIO; |
866 | goto error; |
867 | } |
868 | |
869 | rtox = DIGITAL_NFC_DEP_RTOX_VALUE(resp->data[0]); |
870 | if (!rtox || rtox > DIGITAL_NFC_DEP_RTOX_MAX) { |
871 | PROTOCOL_ERR("14.8.4.1" ); |
872 | rc = -EIO; |
873 | goto error; |
874 | } |
875 | |
876 | rc = digital_in_send_rtox(ddev, data_exch, rtox); |
877 | if (rc) |
878 | goto error; |
879 | |
880 | goto free_resp; |
881 | } |
882 | |
883 | exit: |
884 | data_exch->cb(data_exch->cb_context, resp, rc); |
885 | |
886 | error: |
887 | kfree(objp: data_exch); |
888 | |
889 | kfree_skb(skb: ddev->chaining_skb); |
890 | ddev->chaining_skb = NULL; |
891 | |
892 | kfree_skb(skb: ddev->saved_skb); |
893 | ddev->saved_skb = NULL; |
894 | |
895 | if (rc) |
896 | kfree_skb(skb: resp); |
897 | |
898 | return; |
899 | |
900 | free_resp: |
901 | dev_kfree_skb(resp); |
902 | } |
903 | |
904 | int digital_in_send_dep_req(struct nfc_digital_dev *ddev, |
905 | struct nfc_target *target, struct sk_buff *skb, |
906 | struct digital_data_exch *data_exch) |
907 | { |
908 | struct digital_dep_req_res *dep_req; |
909 | struct sk_buff *chaining_skb, *tmp_skb; |
910 | int rc; |
911 | |
912 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
913 | |
914 | dep_req = (struct digital_dep_req_res *)skb->data; |
915 | |
916 | dep_req->dir = DIGITAL_NFC_DEP_FRAME_DIR_OUT; |
917 | dep_req->cmd = DIGITAL_CMD_DEP_REQ; |
918 | dep_req->pfb = ddev->curr_nfc_dep_pni; |
919 | |
920 | ddev->atn_count = 0; |
921 | ddev->nack_count = 0; |
922 | |
923 | chaining_skb = ddev->chaining_skb; |
924 | |
925 | tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req_res: dep_req, data_exch); |
926 | if (IS_ERR(ptr: tmp_skb)) |
927 | return PTR_ERR(ptr: tmp_skb); |
928 | |
929 | digital_skb_push_dep_sod(ddev, skb: tmp_skb); |
930 | |
931 | ddev->skb_add_crc(tmp_skb); |
932 | |
933 | ddev->saved_skb = pskb_copy(skb: tmp_skb, GFP_KERNEL); |
934 | |
935 | rc = digital_in_send_cmd(ddev, skb: tmp_skb, timeout: ddev->dep_rwt, |
936 | cmd_cb: digital_in_recv_dep_res, cb_context: data_exch); |
937 | if (rc) { |
938 | if (tmp_skb != skb) |
939 | kfree_skb(skb: tmp_skb); |
940 | |
941 | kfree_skb(skb: chaining_skb); |
942 | ddev->chaining_skb = NULL; |
943 | |
944 | kfree_skb(skb: ddev->saved_skb); |
945 | ddev->saved_skb = NULL; |
946 | } |
947 | |
948 | return rc; |
949 | } |
950 | |
951 | static void digital_tg_set_rf_tech(struct nfc_digital_dev *ddev, u8 rf_tech) |
952 | { |
953 | ddev->curr_rf_tech = rf_tech; |
954 | |
955 | ddev->skb_add_crc = digital_skb_add_crc_none; |
956 | ddev->skb_check_crc = digital_skb_check_crc_none; |
957 | |
958 | if (DIGITAL_DRV_CAPS_TG_CRC(ddev)) |
959 | return; |
960 | |
961 | switch (ddev->curr_rf_tech) { |
962 | case NFC_DIGITAL_RF_TECH_106A: |
963 | ddev->skb_add_crc = digital_skb_add_crc_a; |
964 | ddev->skb_check_crc = digital_skb_check_crc_a; |
965 | break; |
966 | |
967 | case NFC_DIGITAL_RF_TECH_212F: |
968 | case NFC_DIGITAL_RF_TECH_424F: |
969 | ddev->skb_add_crc = digital_skb_add_crc_f; |
970 | ddev->skb_check_crc = digital_skb_check_crc_f; |
971 | break; |
972 | |
973 | default: |
974 | break; |
975 | } |
976 | } |
977 | |
978 | static int digital_tg_send_ack(struct nfc_digital_dev *ddev, |
979 | struct digital_data_exch *data_exch) |
980 | { |
981 | struct digital_dep_req_res *dep_res; |
982 | struct sk_buff *skb; |
983 | int rc; |
984 | |
985 | skb = digital_skb_alloc(ddev, len: 1); |
986 | if (!skb) |
987 | return -ENOMEM; |
988 | |
989 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
990 | |
991 | dep_res = (struct digital_dep_req_res *)skb->data; |
992 | |
993 | dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; |
994 | dep_res->cmd = DIGITAL_CMD_DEP_RES; |
995 | dep_res->pfb = DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU | |
996 | ddev->curr_nfc_dep_pni; |
997 | |
998 | if (ddev->did) { |
999 | dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT; |
1000 | |
1001 | skb_put_data(skb, data: &ddev->did, len: sizeof(ddev->did)); |
1002 | } |
1003 | |
1004 | ddev->curr_nfc_dep_pni = |
1005 | DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); |
1006 | |
1007 | digital_skb_push_dep_sod(ddev, skb); |
1008 | |
1009 | ddev->skb_add_crc(skb); |
1010 | |
1011 | ddev->saved_skb = pskb_copy(skb, GFP_KERNEL); |
1012 | |
1013 | rc = digital_tg_send_cmd(ddev, skb, timeout: 1500, cmd_cb: digital_tg_recv_dep_req, |
1014 | cb_context: data_exch); |
1015 | if (rc) { |
1016 | kfree_skb(skb); |
1017 | kfree_skb(skb: ddev->saved_skb); |
1018 | ddev->saved_skb = NULL; |
1019 | } |
1020 | |
1021 | return rc; |
1022 | } |
1023 | |
1024 | static int digital_tg_send_atn(struct nfc_digital_dev *ddev) |
1025 | { |
1026 | struct digital_dep_req_res *dep_res; |
1027 | struct sk_buff *skb; |
1028 | int rc; |
1029 | |
1030 | skb = digital_skb_alloc(ddev, len: 1); |
1031 | if (!skb) |
1032 | return -ENOMEM; |
1033 | |
1034 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
1035 | |
1036 | dep_res = (struct digital_dep_req_res *)skb->data; |
1037 | |
1038 | dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; |
1039 | dep_res->cmd = DIGITAL_CMD_DEP_RES; |
1040 | dep_res->pfb = DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU; |
1041 | |
1042 | if (ddev->did) { |
1043 | dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT; |
1044 | |
1045 | skb_put_data(skb, data: &ddev->did, len: sizeof(ddev->did)); |
1046 | } |
1047 | |
1048 | digital_skb_push_dep_sod(ddev, skb); |
1049 | |
1050 | ddev->skb_add_crc(skb); |
1051 | |
1052 | rc = digital_tg_send_cmd(ddev, skb, timeout: 1500, cmd_cb: digital_tg_recv_dep_req, |
1053 | NULL); |
1054 | if (rc) |
1055 | kfree_skb(skb); |
1056 | |
1057 | return rc; |
1058 | } |
1059 | |
1060 | static int digital_tg_send_saved_skb(struct nfc_digital_dev *ddev) |
1061 | { |
1062 | int rc; |
1063 | |
1064 | if (!ddev->saved_skb) |
1065 | return -EINVAL; |
1066 | |
1067 | skb_get(skb: ddev->saved_skb); |
1068 | |
1069 | rc = digital_tg_send_cmd(ddev, skb: ddev->saved_skb, timeout: 1500, |
1070 | cmd_cb: digital_tg_recv_dep_req, NULL); |
1071 | if (rc) |
1072 | kfree_skb(skb: ddev->saved_skb); |
1073 | |
1074 | return rc; |
1075 | } |
1076 | |
1077 | static void digital_tg_recv_dep_req(struct nfc_digital_dev *ddev, void *arg, |
1078 | struct sk_buff *resp) |
1079 | { |
1080 | int rc; |
1081 | struct digital_dep_req_res *dep_req; |
1082 | u8 pfb; |
1083 | size_t size; |
1084 | |
1085 | if (IS_ERR(ptr: resp)) { |
1086 | rc = PTR_ERR(ptr: resp); |
1087 | resp = NULL; |
1088 | goto exit; |
1089 | } |
1090 | |
1091 | rc = ddev->skb_check_crc(resp); |
1092 | if (rc) { |
1093 | PROTOCOL_ERR("14.4.1.6" ); |
1094 | goto exit; |
1095 | } |
1096 | |
1097 | rc = digital_skb_pull_dep_sod(ddev, skb: resp); |
1098 | if (rc) { |
1099 | PROTOCOL_ERR("14.4.1.2" ); |
1100 | goto exit; |
1101 | } |
1102 | |
1103 | if (resp->len > ddev->local_payload_max) { |
1104 | rc = -EMSGSIZE; |
1105 | goto exit; |
1106 | } |
1107 | |
1108 | size = sizeof(struct digital_dep_req_res); |
1109 | dep_req = (struct digital_dep_req_res *)resp->data; |
1110 | |
1111 | if (resp->len < size || dep_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || |
1112 | dep_req->cmd != DIGITAL_CMD_DEP_REQ) { |
1113 | rc = -EIO; |
1114 | goto exit; |
1115 | } |
1116 | |
1117 | pfb = dep_req->pfb; |
1118 | |
1119 | if (DIGITAL_NFC_DEP_DID_BIT_SET(pfb)) { |
1120 | if (ddev->did && (ddev->did == resp->data[3])) { |
1121 | size++; |
1122 | } else { |
1123 | rc = -EIO; |
1124 | goto exit; |
1125 | } |
1126 | } else if (ddev->did) { |
1127 | rc = -EIO; |
1128 | goto exit; |
1129 | } |
1130 | |
1131 | if (DIGITAL_NFC_DEP_NAD_BIT_SET(pfb)) { |
1132 | rc = -EIO; |
1133 | goto exit; |
1134 | } |
1135 | |
1136 | if (size > resp->len) { |
1137 | rc = -EIO; |
1138 | goto exit; |
1139 | } |
1140 | |
1141 | skb_pull(skb: resp, len: size); |
1142 | |
1143 | switch (DIGITAL_NFC_DEP_PFB_TYPE(pfb)) { |
1144 | case DIGITAL_NFC_DEP_PFB_I_PDU: |
1145 | pr_debug("DIGITAL_NFC_DEP_PFB_I_PDU\n" ); |
1146 | |
1147 | if (ddev->atn_count) { |
1148 | /* The target has received (and replied to) at least one |
1149 | * ATN DEP_REQ. |
1150 | */ |
1151 | ddev->atn_count = 0; |
1152 | |
1153 | /* pni of resp PDU equal to the target current pni - 1 |
1154 | * means resp is the previous DEP_REQ PDU received from |
1155 | * the initiator so the target replies with saved_skb |
1156 | * which is the previous DEP_RES saved in |
1157 | * digital_tg_send_dep_res(). |
1158 | */ |
1159 | if (DIGITAL_NFC_DEP_PFB_PNI(pfb) == |
1160 | DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni - 1)) { |
1161 | rc = digital_tg_send_saved_skb(ddev); |
1162 | if (rc) |
1163 | goto exit; |
1164 | |
1165 | goto free_resp; |
1166 | } |
1167 | |
1168 | /* atn_count > 0 and PDU pni != curr_nfc_dep_pni - 1 |
1169 | * means the target probably did not received the last |
1170 | * DEP_REQ PDU sent by the initiator. The target |
1171 | * fallbacks to normal processing then. |
1172 | */ |
1173 | } |
1174 | |
1175 | if (DIGITAL_NFC_DEP_PFB_PNI(pfb) != ddev->curr_nfc_dep_pni) { |
1176 | PROTOCOL_ERR("14.12.3.4" ); |
1177 | rc = -EIO; |
1178 | goto exit; |
1179 | } |
1180 | |
1181 | kfree_skb(skb: ddev->saved_skb); |
1182 | ddev->saved_skb = NULL; |
1183 | |
1184 | resp = digital_recv_dep_data_gather(ddev, pfb, resp, |
1185 | send_ack: digital_tg_send_ack, NULL); |
1186 | if (IS_ERR(ptr: resp)) { |
1187 | rc = PTR_ERR(ptr: resp); |
1188 | resp = NULL; |
1189 | goto exit; |
1190 | } |
1191 | |
1192 | /* If resp is NULL then we're still chaining so return and |
1193 | * wait for the next part of the PDU. Else, the PDU is |
1194 | * complete so pass it up. |
1195 | */ |
1196 | if (!resp) |
1197 | return; |
1198 | |
1199 | rc = 0; |
1200 | break; |
1201 | case DIGITAL_NFC_DEP_PFB_ACK_NACK_PDU: |
1202 | if (DIGITAL_NFC_DEP_NACK_BIT_SET(pfb)) { /* NACK */ |
1203 | if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) != |
1204 | ddev->curr_nfc_dep_pni) { |
1205 | rc = -EIO; |
1206 | goto exit; |
1207 | } |
1208 | |
1209 | ddev->atn_count = 0; |
1210 | |
1211 | rc = digital_tg_send_saved_skb(ddev); |
1212 | if (rc) |
1213 | goto exit; |
1214 | |
1215 | goto free_resp; |
1216 | } |
1217 | |
1218 | /* ACK */ |
1219 | if (ddev->atn_count) { |
1220 | /* The target has previously received one or more ATN |
1221 | * PDUs. |
1222 | */ |
1223 | ddev->atn_count = 0; |
1224 | |
1225 | /* If the ACK PNI is equal to the target PNI - 1 means |
1226 | * that the initiator did not receive the previous PDU |
1227 | * sent by the target so re-send it. |
1228 | */ |
1229 | if (DIGITAL_NFC_DEP_PFB_PNI(pfb + 1) == |
1230 | ddev->curr_nfc_dep_pni) { |
1231 | rc = digital_tg_send_saved_skb(ddev); |
1232 | if (rc) |
1233 | goto exit; |
1234 | |
1235 | goto free_resp; |
1236 | } |
1237 | |
1238 | /* Otherwise, the target did not receive the previous |
1239 | * ACK PDU from the initiator. Fallback to normal |
1240 | * processing of chained PDU then. |
1241 | */ |
1242 | } |
1243 | |
1244 | /* Keep on sending chained PDU */ |
1245 | if (!ddev->chaining_skb || |
1246 | DIGITAL_NFC_DEP_PFB_PNI(pfb) != |
1247 | ddev->curr_nfc_dep_pni) { |
1248 | rc = -EIO; |
1249 | goto exit; |
1250 | } |
1251 | |
1252 | kfree_skb(skb: ddev->saved_skb); |
1253 | ddev->saved_skb = NULL; |
1254 | |
1255 | rc = digital_tg_send_dep_res(ddev, skb: ddev->chaining_skb); |
1256 | if (rc) |
1257 | goto exit; |
1258 | |
1259 | goto free_resp; |
1260 | case DIGITAL_NFC_DEP_PFB_SUPERVISOR_PDU: |
1261 | if (DIGITAL_NFC_DEP_PFB_IS_TIMEOUT(pfb)) { |
1262 | rc = -EINVAL; |
1263 | goto exit; |
1264 | } |
1265 | |
1266 | rc = digital_tg_send_atn(ddev); |
1267 | if (rc) |
1268 | goto exit; |
1269 | |
1270 | ddev->atn_count++; |
1271 | |
1272 | goto free_resp; |
1273 | } |
1274 | |
1275 | rc = nfc_tm_data_received(dev: ddev->nfc_dev, skb: resp); |
1276 | if (rc) |
1277 | resp = NULL; |
1278 | |
1279 | exit: |
1280 | kfree_skb(skb: ddev->chaining_skb); |
1281 | ddev->chaining_skb = NULL; |
1282 | |
1283 | ddev->atn_count = 0; |
1284 | |
1285 | kfree_skb(skb: ddev->saved_skb); |
1286 | ddev->saved_skb = NULL; |
1287 | |
1288 | if (rc) |
1289 | kfree_skb(skb: resp); |
1290 | |
1291 | return; |
1292 | |
1293 | free_resp: |
1294 | dev_kfree_skb(resp); |
1295 | } |
1296 | |
1297 | int digital_tg_send_dep_res(struct nfc_digital_dev *ddev, struct sk_buff *skb) |
1298 | { |
1299 | struct digital_dep_req_res *dep_res; |
1300 | struct sk_buff *chaining_skb, *tmp_skb; |
1301 | int rc; |
1302 | |
1303 | skb_push(skb, len: sizeof(struct digital_dep_req_res)); |
1304 | |
1305 | dep_res = (struct digital_dep_req_res *)skb->data; |
1306 | |
1307 | dep_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; |
1308 | dep_res->cmd = DIGITAL_CMD_DEP_RES; |
1309 | dep_res->pfb = ddev->curr_nfc_dep_pni; |
1310 | |
1311 | if (ddev->did) { |
1312 | dep_res->pfb |= DIGITAL_NFC_DEP_PFB_DID_BIT; |
1313 | |
1314 | skb_put_data(skb, data: &ddev->did, len: sizeof(ddev->did)); |
1315 | } |
1316 | |
1317 | ddev->curr_nfc_dep_pni = |
1318 | DIGITAL_NFC_DEP_PFB_PNI(ddev->curr_nfc_dep_pni + 1); |
1319 | |
1320 | chaining_skb = ddev->chaining_skb; |
1321 | |
1322 | tmp_skb = digital_send_dep_data_prep(ddev, skb, dep_req_res: dep_res, NULL); |
1323 | if (IS_ERR(ptr: tmp_skb)) |
1324 | return PTR_ERR(ptr: tmp_skb); |
1325 | |
1326 | digital_skb_push_dep_sod(ddev, skb: tmp_skb); |
1327 | |
1328 | ddev->skb_add_crc(tmp_skb); |
1329 | |
1330 | ddev->saved_skb = pskb_copy(skb: tmp_skb, GFP_KERNEL); |
1331 | |
1332 | rc = digital_tg_send_cmd(ddev, skb: tmp_skb, timeout: 1500, cmd_cb: digital_tg_recv_dep_req, |
1333 | NULL); |
1334 | if (rc) { |
1335 | if (tmp_skb != skb) |
1336 | kfree_skb(skb: tmp_skb); |
1337 | |
1338 | kfree_skb(skb: chaining_skb); |
1339 | ddev->chaining_skb = NULL; |
1340 | |
1341 | kfree_skb(skb: ddev->saved_skb); |
1342 | ddev->saved_skb = NULL; |
1343 | } |
1344 | |
1345 | return rc; |
1346 | } |
1347 | |
1348 | static void digital_tg_send_psl_res_complete(struct nfc_digital_dev *ddev, |
1349 | void *arg, struct sk_buff *resp) |
1350 | { |
1351 | u8 rf_tech = (unsigned long)arg; |
1352 | |
1353 | if (IS_ERR(ptr: resp)) |
1354 | return; |
1355 | |
1356 | digital_tg_set_rf_tech(ddev, rf_tech); |
1357 | |
1358 | digital_tg_configure_hw(ddev, type: NFC_DIGITAL_CONFIG_RF_TECH, param: rf_tech); |
1359 | |
1360 | digital_tg_listen(ddev, timeout: 1500, cb: digital_tg_recv_dep_req, NULL); |
1361 | |
1362 | dev_kfree_skb(resp); |
1363 | } |
1364 | |
1365 | static int digital_tg_send_psl_res(struct nfc_digital_dev *ddev, u8 did, |
1366 | u8 rf_tech) |
1367 | { |
1368 | struct digital_psl_res *psl_res; |
1369 | struct sk_buff *skb; |
1370 | int rc; |
1371 | |
1372 | skb = digital_skb_alloc(ddev, len: sizeof(struct digital_psl_res)); |
1373 | if (!skb) |
1374 | return -ENOMEM; |
1375 | |
1376 | skb_put(skb, len: sizeof(struct digital_psl_res)); |
1377 | |
1378 | psl_res = (struct digital_psl_res *)skb->data; |
1379 | |
1380 | psl_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; |
1381 | psl_res->cmd = DIGITAL_CMD_PSL_RES; |
1382 | psl_res->did = did; |
1383 | |
1384 | digital_skb_push_dep_sod(ddev, skb); |
1385 | |
1386 | ddev->skb_add_crc(skb); |
1387 | |
1388 | ddev->curr_nfc_dep_pni = 0; |
1389 | |
1390 | rc = digital_tg_send_cmd(ddev, skb, timeout: 0, cmd_cb: digital_tg_send_psl_res_complete, |
1391 | cb_context: (void *)(unsigned long)rf_tech); |
1392 | if (rc) |
1393 | kfree_skb(skb); |
1394 | |
1395 | return rc; |
1396 | } |
1397 | |
1398 | static void digital_tg_recv_psl_req(struct nfc_digital_dev *ddev, void *arg, |
1399 | struct sk_buff *resp) |
1400 | { |
1401 | int rc; |
1402 | struct digital_psl_req *psl_req; |
1403 | u8 rf_tech; |
1404 | u8 dsi, payload_size, payload_bits; |
1405 | |
1406 | if (IS_ERR(ptr: resp)) { |
1407 | rc = PTR_ERR(ptr: resp); |
1408 | resp = NULL; |
1409 | goto exit; |
1410 | } |
1411 | |
1412 | rc = ddev->skb_check_crc(resp); |
1413 | if (rc) { |
1414 | PROTOCOL_ERR("14.4.1.6" ); |
1415 | goto exit; |
1416 | } |
1417 | |
1418 | rc = digital_skb_pull_dep_sod(ddev, skb: resp); |
1419 | if (rc) { |
1420 | PROTOCOL_ERR("14.4.1.2" ); |
1421 | goto exit; |
1422 | } |
1423 | |
1424 | psl_req = (struct digital_psl_req *)resp->data; |
1425 | |
1426 | if (resp->len != sizeof(struct digital_psl_req) || |
1427 | psl_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || |
1428 | psl_req->cmd != DIGITAL_CMD_PSL_REQ) { |
1429 | rc = -EIO; |
1430 | goto exit; |
1431 | } |
1432 | |
1433 | dsi = (psl_req->brs >> 3) & 0x07; |
1434 | switch (dsi) { |
1435 | case 0: |
1436 | rf_tech = NFC_DIGITAL_RF_TECH_106A; |
1437 | break; |
1438 | case 1: |
1439 | rf_tech = NFC_DIGITAL_RF_TECH_212F; |
1440 | break; |
1441 | case 2: |
1442 | rf_tech = NFC_DIGITAL_RF_TECH_424F; |
1443 | break; |
1444 | default: |
1445 | pr_err("Unsupported dsi value %d\n" , dsi); |
1446 | goto exit; |
1447 | } |
1448 | |
1449 | payload_bits = DIGITAL_PAYLOAD_FSL_TO_BITS(psl_req->fsl); |
1450 | payload_size = digital_payload_bits_to_size(payload_bits); |
1451 | |
1452 | if (!payload_size || (payload_size > min(ddev->local_payload_max, |
1453 | ddev->remote_payload_max))) { |
1454 | rc = -EINVAL; |
1455 | goto exit; |
1456 | } |
1457 | |
1458 | ddev->local_payload_max = payload_size; |
1459 | ddev->remote_payload_max = payload_size; |
1460 | |
1461 | rc = digital_tg_send_psl_res(ddev, did: psl_req->did, rf_tech); |
1462 | |
1463 | exit: |
1464 | kfree_skb(skb: resp); |
1465 | } |
1466 | |
1467 | static void digital_tg_send_atr_res_complete(struct nfc_digital_dev *ddev, |
1468 | void *arg, struct sk_buff *resp) |
1469 | { |
1470 | int offset; |
1471 | |
1472 | if (IS_ERR(ptr: resp)) { |
1473 | digital_poll_next_tech(ddev); |
1474 | return; |
1475 | } |
1476 | |
1477 | offset = 2; |
1478 | if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) |
1479 | offset++; |
1480 | |
1481 | ddev->atn_count = 0; |
1482 | |
1483 | if (resp->data[offset] == DIGITAL_CMD_PSL_REQ) |
1484 | digital_tg_recv_psl_req(ddev, arg, resp); |
1485 | else |
1486 | digital_tg_recv_dep_req(ddev, arg, resp); |
1487 | } |
1488 | |
1489 | static int digital_tg_send_atr_res(struct nfc_digital_dev *ddev, |
1490 | struct digital_atr_req *atr_req) |
1491 | { |
1492 | struct digital_atr_res *atr_res; |
1493 | struct sk_buff *skb; |
1494 | u8 *gb, payload_bits; |
1495 | size_t gb_len; |
1496 | int rc; |
1497 | |
1498 | gb = nfc_get_local_general_bytes(dev: ddev->nfc_dev, gb_len: &gb_len); |
1499 | if (!gb) |
1500 | gb_len = 0; |
1501 | |
1502 | skb = digital_skb_alloc(ddev, len: sizeof(struct digital_atr_res) + gb_len); |
1503 | if (!skb) |
1504 | return -ENOMEM; |
1505 | |
1506 | skb_put(skb, len: sizeof(struct digital_atr_res)); |
1507 | atr_res = (struct digital_atr_res *)skb->data; |
1508 | |
1509 | memset(atr_res, 0, sizeof(struct digital_atr_res)); |
1510 | |
1511 | atr_res->dir = DIGITAL_NFC_DEP_FRAME_DIR_IN; |
1512 | atr_res->cmd = DIGITAL_CMD_ATR_RES; |
1513 | memcpy(atr_res->nfcid3, atr_req->nfcid3, sizeof(atr_req->nfcid3)); |
1514 | atr_res->to = DIGITAL_NFC_DEP_TG_MAX_WT; |
1515 | |
1516 | ddev->local_payload_max = DIGITAL_PAYLOAD_SIZE_MAX; |
1517 | payload_bits = digital_payload_size_to_bits(payload_size: ddev->local_payload_max); |
1518 | atr_res->pp = DIGITAL_PAYLOAD_BITS_TO_PP(payload_bits); |
1519 | |
1520 | if (gb_len) { |
1521 | skb_put(skb, len: gb_len); |
1522 | |
1523 | atr_res->pp |= DIGITAL_GB_BIT; |
1524 | memcpy(atr_res->gb, gb, gb_len); |
1525 | } |
1526 | |
1527 | digital_skb_push_dep_sod(ddev, skb); |
1528 | |
1529 | ddev->skb_add_crc(skb); |
1530 | |
1531 | ddev->curr_nfc_dep_pni = 0; |
1532 | |
1533 | rc = digital_tg_send_cmd(ddev, skb, timeout: 999, |
1534 | cmd_cb: digital_tg_send_atr_res_complete, NULL); |
1535 | if (rc) |
1536 | kfree_skb(skb); |
1537 | |
1538 | return rc; |
1539 | } |
1540 | |
1541 | void digital_tg_recv_atr_req(struct nfc_digital_dev *ddev, void *arg, |
1542 | struct sk_buff *resp) |
1543 | { |
1544 | int rc; |
1545 | struct digital_atr_req *atr_req; |
1546 | size_t gb_len, min_size; |
1547 | u8 poll_tech_count, payload_bits; |
1548 | |
1549 | if (IS_ERR(ptr: resp)) { |
1550 | rc = PTR_ERR(ptr: resp); |
1551 | resp = NULL; |
1552 | goto exit; |
1553 | } |
1554 | |
1555 | if (!resp->len) { |
1556 | rc = -EIO; |
1557 | goto exit; |
1558 | } |
1559 | |
1560 | if (resp->data[0] == DIGITAL_NFC_DEP_NFCA_SOD_SB) { |
1561 | min_size = DIGITAL_ATR_REQ_MIN_SIZE + 2; |
1562 | digital_tg_set_rf_tech(ddev, rf_tech: NFC_DIGITAL_RF_TECH_106A); |
1563 | } else { |
1564 | min_size = DIGITAL_ATR_REQ_MIN_SIZE + 1; |
1565 | digital_tg_set_rf_tech(ddev, rf_tech: NFC_DIGITAL_RF_TECH_212F); |
1566 | } |
1567 | |
1568 | if (resp->len < min_size) { |
1569 | rc = -EIO; |
1570 | goto exit; |
1571 | } |
1572 | |
1573 | ddev->curr_protocol = NFC_PROTO_NFC_DEP_MASK; |
1574 | |
1575 | rc = ddev->skb_check_crc(resp); |
1576 | if (rc) { |
1577 | PROTOCOL_ERR("14.4.1.6" ); |
1578 | goto exit; |
1579 | } |
1580 | |
1581 | rc = digital_skb_pull_dep_sod(ddev, skb: resp); |
1582 | if (rc) { |
1583 | PROTOCOL_ERR("14.4.1.2" ); |
1584 | goto exit; |
1585 | } |
1586 | |
1587 | atr_req = (struct digital_atr_req *)resp->data; |
1588 | |
1589 | if (atr_req->dir != DIGITAL_NFC_DEP_FRAME_DIR_OUT || |
1590 | atr_req->cmd != DIGITAL_CMD_ATR_REQ || |
1591 | atr_req->did > DIGITAL_DID_MAX) { |
1592 | rc = -EINVAL; |
1593 | goto exit; |
1594 | } |
1595 | |
1596 | payload_bits = DIGITAL_PAYLOAD_PP_TO_BITS(atr_req->pp); |
1597 | ddev->remote_payload_max = digital_payload_bits_to_size(payload_bits); |
1598 | |
1599 | if (!ddev->remote_payload_max) { |
1600 | rc = -EINVAL; |
1601 | goto exit; |
1602 | } |
1603 | |
1604 | ddev->did = atr_req->did; |
1605 | |
1606 | rc = digital_tg_configure_hw(ddev, type: NFC_DIGITAL_CONFIG_FRAMING, |
1607 | param: NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED); |
1608 | if (rc) |
1609 | goto exit; |
1610 | |
1611 | rc = digital_tg_send_atr_res(ddev, atr_req); |
1612 | if (rc) |
1613 | goto exit; |
1614 | |
1615 | gb_len = resp->len - sizeof(struct digital_atr_req); |
1616 | |
1617 | poll_tech_count = ddev->poll_tech_count; |
1618 | ddev->poll_tech_count = 0; |
1619 | |
1620 | rc = nfc_tm_activated(dev: ddev->nfc_dev, NFC_PROTO_NFC_DEP_MASK, |
1621 | NFC_COMM_PASSIVE, gb: atr_req->gb, gb_len); |
1622 | if (rc) { |
1623 | ddev->poll_tech_count = poll_tech_count; |
1624 | goto exit; |
1625 | } |
1626 | |
1627 | rc = 0; |
1628 | exit: |
1629 | if (rc) |
1630 | digital_poll_next_tech(ddev); |
1631 | |
1632 | dev_kfree_skb(resp); |
1633 | } |
1634 | |