]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/nfc/hci/shdlc.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
NFC: Modified hci_transceive to become an asynchronous operation
[mirror_ubuntu-bionic-kernel.git] / net / nfc / hci / shdlc.c
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, write to the
16 * Free Software Foundation, Inc.,
17 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
20 #define pr_fmt(fmt) "shdlc: %s: " fmt, __func__
21
22 #include <linux/sched.h>
23 #include <linux/export.h>
24 #include <linux/wait.h>
25 #include <linux/slab.h>
26 #include <linux/skbuff.h>
27
28 #include <net/nfc/hci.h>
29 #include <net/nfc/shdlc.h>
30
31 #define SHDLC_LLC_HEAD_ROOM 2
32
33 #define SHDLC_MAX_WINDOW 4
34 #define SHDLC_SREJ_SUPPORT false
35
36 #define SHDLC_CONTROL_HEAD_MASK 0xe0
37 #define SHDLC_CONTROL_HEAD_I 0x80
38 #define SHDLC_CONTROL_HEAD_I2 0xa0
39 #define SHDLC_CONTROL_HEAD_S 0xc0
40 #define SHDLC_CONTROL_HEAD_U 0xe0
41
42 #define SHDLC_CONTROL_NS_MASK 0x38
43 #define SHDLC_CONTROL_NR_MASK 0x07
44 #define SHDLC_CONTROL_TYPE_MASK 0x18
45
46 #define SHDLC_CONTROL_M_MASK 0x1f
47
48 enum sframe_type {
49 S_FRAME_RR = 0x00,
50 S_FRAME_REJ = 0x01,
51 S_FRAME_RNR = 0x02,
52 S_FRAME_SREJ = 0x03
53 };
54
55 enum uframe_modifier {
56 U_FRAME_UA = 0x06,
57 U_FRAME_RSET = 0x19
58 };
59
60 #define SHDLC_CONNECT_VALUE_MS 5
61 #define SHDLC_T1_VALUE_MS(w) ((5 * w) / 4)
62 #define SHDLC_T2_VALUE_MS 300
63
64 #define SHDLC_DUMP_SKB(info, skb) \
65 do { \
66 pr_debug("%s:\n", info); \
67 print_hex_dump(KERN_DEBUG, "shdlc: ", DUMP_PREFIX_OFFSET, \
68 16, 1, skb->data, skb->len, 0); \
69 } while (0)
70
71 /* checks x < y <= z modulo 8 */
72 static bool nfc_shdlc_x_lt_y_lteq_z(int x, int y, int z)
73 {
74 if (x < z)
75 return ((x < y) && (y <= z)) ? true : false;
76 else
77 return ((y > x) || (y <= z)) ? true : false;
78 }
79
80 /* checks x <= y < z modulo 8 */
81 static bool nfc_shdlc_x_lteq_y_lt_z(int x, int y, int z)
82 {
83 if (x <= z)
84 return ((x <= y) && (y < z)) ? true : false;
85 else /* x > z -> z+8 > x */
86 return ((y >= x) || (y < z)) ? true : false;
87 }
88
89 static struct sk_buff *nfc_shdlc_alloc_skb(struct nfc_shdlc *shdlc,
90 int payload_len)
91 {
92 struct sk_buff *skb;
93
94 skb = alloc_skb(shdlc->client_headroom + SHDLC_LLC_HEAD_ROOM +
95 shdlc->client_tailroom + payload_len, GFP_KERNEL);
96 if (skb)
97 skb_reserve(skb, shdlc->client_headroom + SHDLC_LLC_HEAD_ROOM);
98
99 return skb;
100 }
101
102 /* immediately sends an S frame. */
103 static int nfc_shdlc_send_s_frame(struct nfc_shdlc *shdlc,
104 enum sframe_type sframe_type, int nr)
105 {
106 int r;
107 struct sk_buff *skb;
108
109 pr_debug("sframe_type=%d nr=%d\n", sframe_type, nr);
110
111 skb = nfc_shdlc_alloc_skb(shdlc, 0);
112 if (skb == NULL)
113 return -ENOMEM;
114
115 *skb_push(skb, 1) = SHDLC_CONTROL_HEAD_S | (sframe_type << 3) | nr;
116
117 r = shdlc->ops->xmit(shdlc, skb);
118
119 kfree_skb(skb);
120
121 return r;
122 }
123
124 /* immediately sends an U frame. skb may contain optional payload */
125 static int nfc_shdlc_send_u_frame(struct nfc_shdlc *shdlc,
126 struct sk_buff *skb,
127 enum uframe_modifier uframe_modifier)
128 {
129 int r;
130
131 pr_debug("uframe_modifier=%d\n", uframe_modifier);
132
133 *skb_push(skb, 1) = SHDLC_CONTROL_HEAD_U | uframe_modifier;
134
135 r = shdlc->ops->xmit(shdlc, skb);
136
137 kfree_skb(skb);
138
139 return r;
140 }
141
142 /*
143 * Free ack_pending frames until y_nr - 1, and reset t2 according to
144 * the remaining oldest ack_pending frame sent time
145 */
146 static void nfc_shdlc_reset_t2(struct nfc_shdlc *shdlc, int y_nr)
147 {
148 struct sk_buff *skb;
149 int dnr = shdlc->dnr; /* MUST initially be < y_nr */
150
151 pr_debug("release ack pending up to frame %d excluded\n", y_nr);
152
153 while (dnr != y_nr) {
154 pr_debug("release ack pending frame %d\n", dnr);
155
156 skb = skb_dequeue(&shdlc->ack_pending_q);
157 kfree_skb(skb);
158
159 dnr = (dnr + 1) % 8;
160 }
161
162 if (skb_queue_empty(&shdlc->ack_pending_q)) {
163 if (shdlc->t2_active) {
164 del_timer_sync(&shdlc->t2_timer);
165 shdlc->t2_active = false;
166
167 pr_debug
168 ("All sent frames acked. Stopped T2(retransmit)\n");
169 }
170 } else {
171 skb = skb_peek(&shdlc->ack_pending_q);
172
173 mod_timer(&shdlc->t2_timer, *(unsigned long *)skb->cb +
174 msecs_to_jiffies(SHDLC_T2_VALUE_MS));
175 shdlc->t2_active = true;
176
177 pr_debug
178 ("Start T2(retransmit) for remaining unacked sent frames\n");
179 }
180 }
181
182 /*
183 * Receive validated frames from lower layer. skb contains HCI payload only.
184 * Handle according to algorithm at spec:10.8.2
185 */
186 static void nfc_shdlc_rcv_i_frame(struct nfc_shdlc *shdlc,
187 struct sk_buff *skb, int ns, int nr)
188 {
189 int x_ns = ns;
190 int y_nr = nr;
191
192 pr_debug("recvd I-frame %d, remote waiting frame %d\n", ns, nr);
193
194 if (shdlc->state != SHDLC_CONNECTED)
195 goto exit;
196
197 if (x_ns != shdlc->nr) {
198 nfc_shdlc_send_s_frame(shdlc, S_FRAME_REJ, shdlc->nr);
199 goto exit;
200 }
201
202 if (shdlc->t1_active == false) {
203 shdlc->t1_active = true;
204 mod_timer(&shdlc->t1_timer,
205 msecs_to_jiffies(SHDLC_T1_VALUE_MS(shdlc->w)));
206 pr_debug("(re)Start T1(send ack)\n");
207 }
208
209 if (skb->len) {
210 nfc_hci_recv_frame(shdlc->hdev, skb);
211 skb = NULL;
212 }
213
214 shdlc->nr = (shdlc->nr + 1) % 8;
215
216 if (nfc_shdlc_x_lt_y_lteq_z(shdlc->dnr, y_nr, shdlc->ns)) {
217 nfc_shdlc_reset_t2(shdlc, y_nr);
218
219 shdlc->dnr = y_nr;
220 }
221
222 exit:
223 kfree_skb(skb);
224 }
225
226 static void nfc_shdlc_rcv_ack(struct nfc_shdlc *shdlc, int y_nr)
227 {
228 pr_debug("remote acked up to frame %d excluded\n", y_nr);
229
230 if (nfc_shdlc_x_lt_y_lteq_z(shdlc->dnr, y_nr, shdlc->ns)) {
231 nfc_shdlc_reset_t2(shdlc, y_nr);
232 shdlc->dnr = y_nr;
233 }
234 }
235
236 static void nfc_shdlc_requeue_ack_pending(struct nfc_shdlc *shdlc)
237 {
238 struct sk_buff *skb;
239
240 pr_debug("ns reset to %d\n", shdlc->dnr);
241
242 while ((skb = skb_dequeue_tail(&shdlc->ack_pending_q))) {
243 skb_pull(skb, 1); /* remove control field */
244 skb_queue_head(&shdlc->send_q, skb);
245 }
246 shdlc->ns = shdlc->dnr;
247 }
248
249 static void nfc_shdlc_rcv_rej(struct nfc_shdlc *shdlc, int y_nr)
250 {
251 struct sk_buff *skb;
252
253 pr_debug("remote asks retransmition from frame %d\n", y_nr);
254
255 if (nfc_shdlc_x_lteq_y_lt_z(shdlc->dnr, y_nr, shdlc->ns)) {
256 if (shdlc->t2_active) {
257 del_timer_sync(&shdlc->t2_timer);
258 shdlc->t2_active = false;
259 pr_debug("Stopped T2(retransmit)\n");
260 }
261
262 if (shdlc->dnr != y_nr) {
263 while ((shdlc->dnr = ((shdlc->dnr + 1) % 8)) != y_nr) {
264 skb = skb_dequeue(&shdlc->ack_pending_q);
265 kfree_skb(skb);
266 }
267 }
268
269 nfc_shdlc_requeue_ack_pending(shdlc);
270 }
271 }
272
273 /* See spec RR:10.8.3 REJ:10.8.4 */
274 static void nfc_shdlc_rcv_s_frame(struct nfc_shdlc *shdlc,
275 enum sframe_type s_frame_type, int nr)
276 {
277 struct sk_buff *skb;
278
279 if (shdlc->state != SHDLC_CONNECTED)
280 return;
281
282 switch (s_frame_type) {
283 case S_FRAME_RR:
284 nfc_shdlc_rcv_ack(shdlc, nr);
285 if (shdlc->rnr == true) { /* see SHDLC 10.7.7 */
286 shdlc->rnr = false;
287 if (shdlc->send_q.qlen == 0) {
288 skb = nfc_shdlc_alloc_skb(shdlc, 0);
289 if (skb)
290 skb_queue_tail(&shdlc->send_q, skb);
291 }
292 }
293 break;
294 case S_FRAME_REJ:
295 nfc_shdlc_rcv_rej(shdlc, nr);
296 break;
297 case S_FRAME_RNR:
298 nfc_shdlc_rcv_ack(shdlc, nr);
299 shdlc->rnr = true;
300 break;
301 default:
302 break;
303 }
304 }
305
306 static void nfc_shdlc_connect_complete(struct nfc_shdlc *shdlc, int r)
307 {
308 pr_debug("result=%d\n", r);
309
310 del_timer_sync(&shdlc->connect_timer);
311
312 if (r == 0) {
313 shdlc->ns = 0;
314 shdlc->nr = 0;
315 shdlc->dnr = 0;
316
317 shdlc->state = SHDLC_CONNECTED;
318 } else {
319 shdlc->state = SHDLC_DISCONNECTED;
320 }
321
322 shdlc->connect_result = r;
323
324 wake_up(shdlc->connect_wq);
325 }
326
327 static int nfc_shdlc_connect_initiate(struct nfc_shdlc *shdlc)
328 {
329 struct sk_buff *skb;
330
331 pr_debug("\n");
332
333 skb = nfc_shdlc_alloc_skb(shdlc, 2);
334 if (skb == NULL)
335 return -ENOMEM;
336
337 *skb_put(skb, 1) = SHDLC_MAX_WINDOW;
338 *skb_put(skb, 1) = SHDLC_SREJ_SUPPORT ? 1 : 0;
339
340 return nfc_shdlc_send_u_frame(shdlc, skb, U_FRAME_RSET);
341 }
342
343 static int nfc_shdlc_connect_send_ua(struct nfc_shdlc *shdlc)
344 {
345 struct sk_buff *skb;
346
347 pr_debug("\n");
348
349 skb = nfc_shdlc_alloc_skb(shdlc, 0);
350 if (skb == NULL)
351 return -ENOMEM;
352
353 return nfc_shdlc_send_u_frame(shdlc, skb, U_FRAME_UA);
354 }
355
356 static void nfc_shdlc_rcv_u_frame(struct nfc_shdlc *shdlc,
357 struct sk_buff *skb,
358 enum uframe_modifier u_frame_modifier)
359 {
360 u8 w = SHDLC_MAX_WINDOW;
361 bool srej_support = SHDLC_SREJ_SUPPORT;
362 int r;
363
364 pr_debug("u_frame_modifier=%d\n", u_frame_modifier);
365
366 switch (u_frame_modifier) {
367 case U_FRAME_RSET:
368 if (shdlc->state == SHDLC_NEGOCIATING) {
369 /* we sent RSET, but chip wants to negociate */
370 if (skb->len > 0)
371 w = skb->data[0];
372
373 if (skb->len > 1)
374 srej_support = skb->data[1] & 0x01 ? true :
375 false;
376
377 if ((w <= SHDLC_MAX_WINDOW) &&
378 (SHDLC_SREJ_SUPPORT || (srej_support == false))) {
379 shdlc->w = w;
380 shdlc->srej_support = srej_support;
381 r = nfc_shdlc_connect_send_ua(shdlc);
382 nfc_shdlc_connect_complete(shdlc, r);
383 }
384 } else if (shdlc->state == SHDLC_CONNECTED) {
385 /*
386 * Chip wants to reset link. This is unexpected and
387 * unsupported.
388 */
389 shdlc->hard_fault = -ECONNRESET;
390 }
391 break;
392 case U_FRAME_UA:
393 if ((shdlc->state == SHDLC_CONNECTING &&
394 shdlc->connect_tries > 0) ||
395 (shdlc->state == SHDLC_NEGOCIATING))
396 nfc_shdlc_connect_complete(shdlc, 0);
397 break;
398 default:
399 break;
400 }
401
402 kfree_skb(skb);
403 }
404
405 static void nfc_shdlc_handle_rcv_queue(struct nfc_shdlc *shdlc)
406 {
407 struct sk_buff *skb;
408 u8 control;
409 int nr;
410 int ns;
411 enum sframe_type s_frame_type;
412 enum uframe_modifier u_frame_modifier;
413
414 if (shdlc->rcv_q.qlen)
415 pr_debug("rcvQlen=%d\n", shdlc->rcv_q.qlen);
416
417 while ((skb = skb_dequeue(&shdlc->rcv_q)) != NULL) {
418 control = skb->data[0];
419 skb_pull(skb, 1);
420 switch (control & SHDLC_CONTROL_HEAD_MASK) {
421 case SHDLC_CONTROL_HEAD_I:
422 case SHDLC_CONTROL_HEAD_I2:
423 ns = (control & SHDLC_CONTROL_NS_MASK) >> 3;
424 nr = control & SHDLC_CONTROL_NR_MASK;
425 nfc_shdlc_rcv_i_frame(shdlc, skb, ns, nr);
426 break;
427 case SHDLC_CONTROL_HEAD_S:
428 s_frame_type = (control & SHDLC_CONTROL_TYPE_MASK) >> 3;
429 nr = control & SHDLC_CONTROL_NR_MASK;
430 nfc_shdlc_rcv_s_frame(shdlc, s_frame_type, nr);
431 kfree_skb(skb);
432 break;
433 case SHDLC_CONTROL_HEAD_U:
434 u_frame_modifier = control & SHDLC_CONTROL_M_MASK;
435 nfc_shdlc_rcv_u_frame(shdlc, skb, u_frame_modifier);
436 break;
437 default:
438 pr_err("UNKNOWN Control=%d\n", control);
439 kfree_skb(skb);
440 break;
441 }
442 }
443 }
444
445 static int nfc_shdlc_w_used(int ns, int dnr)
446 {
447 int unack_count;
448
449 if (dnr <= ns)
450 unack_count = ns - dnr;
451 else
452 unack_count = 8 - dnr + ns;
453
454 return unack_count;
455 }
456
457 /* Send frames according to algorithm at spec:10.8.1 */
458 static void nfc_shdlc_handle_send_queue(struct nfc_shdlc *shdlc)
459 {
460 struct sk_buff *skb;
461 int r;
462 unsigned long time_sent;
463
464 if (shdlc->send_q.qlen)
465 pr_debug
466 ("sendQlen=%d ns=%d dnr=%d rnr=%s w_room=%d unackQlen=%d\n",
467 shdlc->send_q.qlen, shdlc->ns, shdlc->dnr,
468 shdlc->rnr == false ? "false" : "true",
469 shdlc->w - nfc_shdlc_w_used(shdlc->ns, shdlc->dnr),
470 shdlc->ack_pending_q.qlen);
471
472 while (shdlc->send_q.qlen && shdlc->ack_pending_q.qlen < shdlc->w &&
473 (shdlc->rnr == false)) {
474
475 if (shdlc->t1_active) {
476 del_timer_sync(&shdlc->t1_timer);
477 shdlc->t1_active = false;
478 pr_debug("Stopped T1(send ack)\n");
479 }
480
481 skb = skb_dequeue(&shdlc->send_q);
482
483 *skb_push(skb, 1) = SHDLC_CONTROL_HEAD_I | (shdlc->ns << 3) |
484 shdlc->nr;
485
486 pr_debug("Sending I-Frame %d, waiting to rcv %d\n", shdlc->ns,
487 shdlc->nr);
488 /* SHDLC_DUMP_SKB("shdlc frame written", skb); */
489
490 r = shdlc->ops->xmit(shdlc, skb);
491 if (r < 0) {
492 shdlc->hard_fault = r;
493 break;
494 }
495
496 shdlc->ns = (shdlc->ns + 1) % 8;
497
498 time_sent = jiffies;
499 *(unsigned long *)skb->cb = time_sent;
500
501 skb_queue_tail(&shdlc->ack_pending_q, skb);
502
503 if (shdlc->t2_active == false) {
504 shdlc->t2_active = true;
505 mod_timer(&shdlc->t2_timer, time_sent +
506 msecs_to_jiffies(SHDLC_T2_VALUE_MS));
507 pr_debug("Started T2 (retransmit)\n");
508 }
509 }
510 }
511
512 static void nfc_shdlc_connect_timeout(unsigned long data)
513 {
514 struct nfc_shdlc *shdlc = (struct nfc_shdlc *)data;
515
516 pr_debug("\n");
517
518 queue_work(system_nrt_wq, &shdlc->sm_work);
519 }
520
521 static void nfc_shdlc_t1_timeout(unsigned long data)
522 {
523 struct nfc_shdlc *shdlc = (struct nfc_shdlc *)data;
524
525 pr_debug("SoftIRQ: need to send ack\n");
526
527 queue_work(system_nrt_wq, &shdlc->sm_work);
528 }
529
530 static void nfc_shdlc_t2_timeout(unsigned long data)
531 {
532 struct nfc_shdlc *shdlc = (struct nfc_shdlc *)data;
533
534 pr_debug("SoftIRQ: need to retransmit\n");
535
536 queue_work(system_nrt_wq, &shdlc->sm_work);
537 }
538
539 static void nfc_shdlc_sm_work(struct work_struct *work)
540 {
541 struct nfc_shdlc *shdlc = container_of(work, struct nfc_shdlc, sm_work);
542 int r;
543
544 pr_debug("\n");
545
546 mutex_lock(&shdlc->state_mutex);
547
548 switch (shdlc->state) {
549 case SHDLC_DISCONNECTED:
550 skb_queue_purge(&shdlc->rcv_q);
551 skb_queue_purge(&shdlc->send_q);
552 skb_queue_purge(&shdlc->ack_pending_q);
553 break;
554 case SHDLC_CONNECTING:
555 if (shdlc->hard_fault) {
556 nfc_shdlc_connect_complete(shdlc, shdlc->hard_fault);
557 break;
558 }
559
560 if (shdlc->connect_tries++ < 5)
561 r = nfc_shdlc_connect_initiate(shdlc);
562 else
563 r = -ETIME;
564 if (r < 0)
565 nfc_shdlc_connect_complete(shdlc, r);
566 else {
567 mod_timer(&shdlc->connect_timer, jiffies +
568 msecs_to_jiffies(SHDLC_CONNECT_VALUE_MS));
569
570 shdlc->state = SHDLC_NEGOCIATING;
571 }
572 break;
573 case SHDLC_NEGOCIATING:
574 if (timer_pending(&shdlc->connect_timer) == 0) {
575 shdlc->state = SHDLC_CONNECTING;
576 queue_work(system_nrt_wq, &shdlc->sm_work);
577 }
578
579 nfc_shdlc_handle_rcv_queue(shdlc);
580
581 if (shdlc->hard_fault) {
582 nfc_shdlc_connect_complete(shdlc, shdlc->hard_fault);
583 break;
584 }
585 break;
586 case SHDLC_CONNECTED:
587 nfc_shdlc_handle_rcv_queue(shdlc);
588 nfc_shdlc_handle_send_queue(shdlc);
589
590 if (shdlc->t1_active && timer_pending(&shdlc->t1_timer) == 0) {
591 pr_debug
592 ("Handle T1(send ack) elapsed (T1 now inactive)\n");
593
594 shdlc->t1_active = false;
595 r = nfc_shdlc_send_s_frame(shdlc, S_FRAME_RR,
596 shdlc->nr);
597 if (r < 0)
598 shdlc->hard_fault = r;
599 }
600
601 if (shdlc->t2_active && timer_pending(&shdlc->t2_timer) == 0) {
602 pr_debug
603 ("Handle T2(retransmit) elapsed (T2 inactive)\n");
604
605 shdlc->t2_active = false;
606
607 nfc_shdlc_requeue_ack_pending(shdlc);
608 nfc_shdlc_handle_send_queue(shdlc);
609 }
610
611 if (shdlc->hard_fault) {
612 nfc_hci_driver_failure(shdlc->hdev, shdlc->hard_fault);
613 }
614 break;
615 default:
616 break;
617 }
618 mutex_unlock(&shdlc->state_mutex);
619 }
620
621 /*
622 * Called from syscall context to establish shdlc link. Sleeps until
623 * link is ready or failure.
624 */
625 static int nfc_shdlc_connect(struct nfc_shdlc *shdlc)
626 {
627 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(connect_wq);
628
629 pr_debug("\n");
630
631 mutex_lock(&shdlc->state_mutex);
632
633 shdlc->state = SHDLC_CONNECTING;
634 shdlc->connect_wq = &connect_wq;
635 shdlc->connect_tries = 0;
636 shdlc->connect_result = 1;
637
638 mutex_unlock(&shdlc->state_mutex);
639
640 queue_work(system_nrt_wq, &shdlc->sm_work);
641
642 wait_event(connect_wq, shdlc->connect_result != 1);
643
644 return shdlc->connect_result;
645 }
646
647 static void nfc_shdlc_disconnect(struct nfc_shdlc *shdlc)
648 {
649 pr_debug("\n");
650
651 mutex_lock(&shdlc->state_mutex);
652
653 shdlc->state = SHDLC_DISCONNECTED;
654
655 mutex_unlock(&shdlc->state_mutex);
656
657 queue_work(system_nrt_wq, &shdlc->sm_work);
658 }
659
660 /*
661 * Receive an incoming shdlc frame. Frame has already been crc-validated.
662 * skb contains only LLC header and payload.
663 * If skb == NULL, it is a notification that the link below is dead.
664 */
665 void nfc_shdlc_recv_frame(struct nfc_shdlc *shdlc, struct sk_buff *skb)
666 {
667 if (skb == NULL) {
668 pr_err("NULL Frame -> link is dead\n");
669 shdlc->hard_fault = -EREMOTEIO;
670 } else {
671 SHDLC_DUMP_SKB("incoming frame", skb);
672 skb_queue_tail(&shdlc->rcv_q, skb);
673 }
674
675 queue_work(system_nrt_wq, &shdlc->sm_work);
676 }
677 EXPORT_SYMBOL(nfc_shdlc_recv_frame);
678
679 static int nfc_shdlc_open(struct nfc_hci_dev *hdev)
680 {
681 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
682 int r;
683
684 pr_debug("\n");
685
686 if (shdlc->ops->open) {
687 r = shdlc->ops->open(shdlc);
688 if (r < 0)
689 return r;
690 }
691
692 r = nfc_shdlc_connect(shdlc);
693 if (r < 0 && shdlc->ops->close)
694 shdlc->ops->close(shdlc);
695
696 return r;
697 }
698
699 static void nfc_shdlc_close(struct nfc_hci_dev *hdev)
700 {
701 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
702
703 pr_debug("\n");
704
705 nfc_shdlc_disconnect(shdlc);
706
707 if (shdlc->ops->close)
708 shdlc->ops->close(shdlc);
709 }
710
711 static int nfc_shdlc_hci_ready(struct nfc_hci_dev *hdev)
712 {
713 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
714 int r = 0;
715
716 pr_debug("\n");
717
718 if (shdlc->ops->hci_ready)
719 r = shdlc->ops->hci_ready(shdlc);
720
721 return r;
722 }
723
724 static int nfc_shdlc_xmit(struct nfc_hci_dev *hdev, struct sk_buff *skb)
725 {
726 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
727
728 SHDLC_DUMP_SKB("queuing HCP packet to shdlc", skb);
729
730 skb_queue_tail(&shdlc->send_q, skb);
731
732 queue_work(system_nrt_wq, &shdlc->sm_work);
733
734 return 0;
735 }
736
737 static int nfc_shdlc_start_poll(struct nfc_hci_dev *hdev,
738 u32 im_protocols, u32 tm_protocols)
739 {
740 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
741
742 pr_debug("\n");
743
744 if (shdlc->ops->start_poll)
745 return shdlc->ops->start_poll(shdlc,
746 im_protocols, tm_protocols);
747
748 return 0;
749 }
750
751 static int nfc_shdlc_target_from_gate(struct nfc_hci_dev *hdev, u8 gate,
752 struct nfc_target *target)
753 {
754 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
755
756 if (shdlc->ops->target_from_gate)
757 return shdlc->ops->target_from_gate(shdlc, gate, target);
758
759 return -EPERM;
760 }
761
762 static int nfc_shdlc_complete_target_discovered(struct nfc_hci_dev *hdev,
763 u8 gate,
764 struct nfc_target *target)
765 {
766 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
767
768 pr_debug("\n");
769
770 if (shdlc->ops->complete_target_discovered)
771 return shdlc->ops->complete_target_discovered(shdlc, gate,
772 target);
773
774 return 0;
775 }
776
777 static int nfc_shdlc_data_exchange(struct nfc_hci_dev *hdev,
778 struct nfc_target *target,
779 struct sk_buff *skb,
780 data_exchange_cb_t cb, void *cb_context)
781 {
782 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
783
784 if (shdlc->ops->data_exchange)
785 return shdlc->ops->data_exchange(shdlc, target, skb, cb,
786 cb_context);
787
788 return -EPERM;
789 }
790
791 static int nfc_shdlc_check_presence(struct nfc_hci_dev *hdev,
792 struct nfc_target *target)
793 {
794 struct nfc_shdlc *shdlc = nfc_hci_get_clientdata(hdev);
795
796 if (shdlc->ops->check_presence)
797 return shdlc->ops->check_presence(shdlc, target);
798
799 return 0;
800 }
801
802 static struct nfc_hci_ops shdlc_ops = {
803 .open = nfc_shdlc_open,
804 .close = nfc_shdlc_close,
805 .hci_ready = nfc_shdlc_hci_ready,
806 .xmit = nfc_shdlc_xmit,
807 .start_poll = nfc_shdlc_start_poll,
808 .target_from_gate = nfc_shdlc_target_from_gate,
809 .complete_target_discovered = nfc_shdlc_complete_target_discovered,
810 .data_exchange = nfc_shdlc_data_exchange,
811 .check_presence = nfc_shdlc_check_presence,
812 };
813
814 struct nfc_shdlc *nfc_shdlc_allocate(struct nfc_shdlc_ops *ops,
815 struct nfc_hci_init_data *init_data,
816 u32 protocols,
817 int tx_headroom, int tx_tailroom,
818 int max_link_payload, const char *devname)
819 {
820 struct nfc_shdlc *shdlc;
821 int r;
822
823 if (ops->xmit == NULL)
824 return NULL;
825
826 shdlc = kzalloc(sizeof(struct nfc_shdlc), GFP_KERNEL);
827 if (shdlc == NULL)
828 return NULL;
829
830 mutex_init(&shdlc->state_mutex);
831 shdlc->ops = ops;
832 shdlc->state = SHDLC_DISCONNECTED;
833
834 init_timer(&shdlc->connect_timer);
835 shdlc->connect_timer.data = (unsigned long)shdlc;
836 shdlc->connect_timer.function = nfc_shdlc_connect_timeout;
837
838 init_timer(&shdlc->t1_timer);
839 shdlc->t1_timer.data = (unsigned long)shdlc;
840 shdlc->t1_timer.function = nfc_shdlc_t1_timeout;
841
842 init_timer(&shdlc->t2_timer);
843 shdlc->t2_timer.data = (unsigned long)shdlc;
844 shdlc->t2_timer.function = nfc_shdlc_t2_timeout;
845
846 shdlc->w = SHDLC_MAX_WINDOW;
847 shdlc->srej_support = SHDLC_SREJ_SUPPORT;
848
849 skb_queue_head_init(&shdlc->rcv_q);
850 skb_queue_head_init(&shdlc->send_q);
851 skb_queue_head_init(&shdlc->ack_pending_q);
852
853 INIT_WORK(&shdlc->sm_work, nfc_shdlc_sm_work);
854
855 shdlc->client_headroom = tx_headroom;
856 shdlc->client_tailroom = tx_tailroom;
857
858 shdlc->hdev = nfc_hci_allocate_device(&shdlc_ops, init_data, protocols,
859 tx_headroom + SHDLC_LLC_HEAD_ROOM,
860 tx_tailroom,
861 max_link_payload);
862 if (shdlc->hdev == NULL)
863 goto err_allocdev;
864
865 nfc_hci_set_clientdata(shdlc->hdev, shdlc);
866
867 r = nfc_hci_register_device(shdlc->hdev);
868 if (r < 0)
869 goto err_regdev;
870
871 return shdlc;
872
873 err_regdev:
874 nfc_hci_free_device(shdlc->hdev);
875
876 err_allocdev:
877 kfree(shdlc);
878
879 return NULL;
880 }
881 EXPORT_SYMBOL(nfc_shdlc_allocate);
882
883 void nfc_shdlc_free(struct nfc_shdlc *shdlc)
884 {
885 pr_debug("\n");
886
887 nfc_hci_unregister_device(shdlc->hdev);
888 nfc_hci_free_device(shdlc->hdev);
889
890 cancel_work_sync(&shdlc->sm_work);
891
892 skb_queue_purge(&shdlc->rcv_q);
893 skb_queue_purge(&shdlc->send_q);
894 skb_queue_purge(&shdlc->ack_pending_q);
895
896 kfree(shdlc);
897 }
898 EXPORT_SYMBOL(nfc_shdlc_free);
899
900 void nfc_shdlc_set_clientdata(struct nfc_shdlc *shdlc, void *clientdata)
901 {
902 pr_debug("\n");
903
904 shdlc->clientdata = clientdata;
905 }
906 EXPORT_SYMBOL(nfc_shdlc_set_clientdata);
907
908 void *nfc_shdlc_get_clientdata(struct nfc_shdlc *shdlc)
909 {
910 return shdlc->clientdata;
911 }
912 EXPORT_SYMBOL(nfc_shdlc_get_clientdata);
913
914 struct nfc_hci_dev *nfc_shdlc_get_hci_dev(struct nfc_shdlc *shdlc)
915 {
916 return shdlc->hdev;
917 }
918 EXPORT_SYMBOL(nfc_shdlc_get_hci_dev);
ubuntu-bionic-kernel mirror