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