drivers/bluetooth/hci_bcsp.c

   1 /*
   2  *
   3  *  Bluetooth HCI UART driver
   4  *
   5  *  Copyright (C) 2002-2003  Fabrizio Gennari <fabrizio.gennari@philips.com>
   6  *  Copyright (C) 2004-2005  Marcel Holtmann <marcel@holtmann.org>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 #include <linux/module.h>
  26
  27 #include <linux/kernel.h>
  28 #include <linux/init.h>
  29 #include <linux/types.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/ptrace.h>
  33 #include <linux/poll.h>
  34
  35 #include <linux/slab.h>
  36 #include <linux/tty.h>
  37 #include <linux/errno.h>
  38 #include <linux/string.h>
  39 #include <linux/signal.h>
  40 #include <linux/ioctl.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/bitrev.h>
  43 #include <asm/unaligned.h>
  44
  45 #include <net/bluetooth/bluetooth.h>
  46 #include <net/bluetooth/hci_core.h>
  47
  48 #include "hci_uart.h"
  49
  50 static bool txcrc = true;
  51 static bool hciextn = true;
  52
  53 #define BCSP_TXWINSIZE  4
  54
  55 #define BCSP_ACK_PKT    0x05
  56 #define BCSP_LE_PKT     0x06
  57
  58 struct bcsp_struct {
  59         struct sk_buff_head unack;      /* Unack'ed packets queue */
  60         struct sk_buff_head rel;        /* Reliable packets queue */
  61         struct sk_buff_head unrel;      /* Unreliable packets queue */
  62
  63         unsigned long rx_count;
  64         struct  sk_buff *rx_skb;
  65         u8      rxseq_txack;            /* rxseq == txack. */
  66         u8      rxack;                  /* Last packet sent by us that the peer ack'ed */
  67         struct  timer_list tbcsp;
  68
  69         enum {
  70                 BCSP_W4_PKT_DELIMITER,
  71                 BCSP_W4_PKT_START,
  72                 BCSP_W4_BCSP_HDR,
  73                 BCSP_W4_DATA,
  74                 BCSP_W4_CRC
  75         } rx_state;
  76
  77         enum {
  78                 BCSP_ESCSTATE_NOESC,
  79                 BCSP_ESCSTATE_ESC
  80         } rx_esc_state;
  81
  82         u8      use_crc;
  83         u16     message_crc;
  84         u8      txack_req;              /* Do we need to send ack's to the peer? */
  85
  86         /* Reliable packet sequence number - used to assign seq to each rel pkt. */
  87         u8      msgq_txseq;
  88 };
  89
  90 /* ---- BCSP CRC calculation ---- */
  91
  92 /* Table for calculating CRC for polynomial 0x1021, LSB processed first,
  93 initial value 0xffff, bits shifted in reverse order. */
  94
  95 static const u16 crc_table[] = {
  96         0x0000, 0x1081, 0x2102, 0x3183,
  97         0x4204, 0x5285, 0x6306, 0x7387,
  98         0x8408, 0x9489, 0xa50a, 0xb58b,
  99         0xc60c, 0xd68d, 0xe70e, 0xf78f
 100 };
 101
 102 /* Initialise the crc calculator */
 103 #define BCSP_CRC_INIT(x) x = 0xffff
 104
 105 /*
 106    Update crc with next data byte
 107
 108    Implementation note
 109         The data byte is treated as two nibbles.  The crc is generated
 110         in reverse, i.e., bits are fed into the register from the top.
 111 */
 112 static void bcsp_crc_update(u16 *crc, u8 d)
 113 {
 114         u16 reg = *crc;
 115
 116         reg = (reg >> 4) ^ crc_table[(reg ^ d) & 0x000f];
 117         reg = (reg >> 4) ^ crc_table[(reg ^ (d >> 4)) & 0x000f];
 118
 119         *crc = reg;
 120 }
 121
 122 /* ---- BCSP core ---- */
 123
 124 static void bcsp_slip_msgdelim(struct sk_buff *skb)
 125 {
 126         const char pkt_delim = 0xc0;
 127
 128         memcpy(skb_put(skb, 1), &pkt_delim, 1);
 129 }
 130
 131 static void bcsp_slip_one_byte(struct sk_buff *skb, u8 c)
 132 {
 133         const char esc_c0[2] = { 0xdb, 0xdc };
 134         const char esc_db[2] = { 0xdb, 0xdd };
 135
 136         switch (c) {
 137         case 0xc0:
 138                 memcpy(skb_put(skb, 2), &esc_c0, 2);
 139                 break;
 140         case 0xdb:
 141                 memcpy(skb_put(skb, 2), &esc_db, 2);
 142                 break;
 143         default:
 144                 memcpy(skb_put(skb, 1), &c, 1);
 145         }
 146 }
 147
 148 static int bcsp_enqueue(struct hci_uart *hu, struct sk_buff *skb)
 149 {
 150         struct bcsp_struct *bcsp = hu->priv;
 151
 152         if (skb->len > 0xFFF) {
 153                 BT_ERR("Packet too long");
 154                 kfree_skb(skb);
 155                 return 0;
 156         }
 157
 158         switch (bt_cb(skb)->pkt_type) {
 159         case HCI_ACLDATA_PKT:
 160         case HCI_COMMAND_PKT:
 161                 skb_queue_tail(&bcsp->rel, skb);
 162                 break;
 163
 164         case HCI_SCODATA_PKT:
 165                 skb_queue_tail(&bcsp->unrel, skb);
 166                 break;
 167
 168         default:
 169                 BT_ERR("Unknown packet type");
 170                 kfree_skb(skb);
 171                 break;
 172         }
 173
 174         return 0;
 175 }
 176
 177 static struct sk_buff *bcsp_prepare_pkt(struct bcsp_struct *bcsp, u8 *data,
 178                 int len, int pkt_type)
 179 {
 180         struct sk_buff *nskb;
 181         u8 hdr[4], chan;
 182         u16 BCSP_CRC_INIT(bcsp_txmsg_crc);
 183         int rel, i;
 184
 185         switch (pkt_type) {
 186         case HCI_ACLDATA_PKT:
 187                 chan = 6;       /* BCSP ACL channel */
 188                 rel = 1;        /* reliable channel */
 189                 break;
 190         case HCI_COMMAND_PKT:
 191                 chan = 5;       /* BCSP cmd/evt channel */
 192                 rel = 1;        /* reliable channel */
 193                 break;
 194         case HCI_SCODATA_PKT:
 195                 chan = 7;       /* BCSP SCO channel */
 196                 rel = 0;        /* unreliable channel */
 197                 break;
 198         case BCSP_LE_PKT:
 199                 chan = 1;       /* BCSP LE channel */
 200                 rel = 0;        /* unreliable channel */
 201                 break;
 202         case BCSP_ACK_PKT:
 203                 chan = 0;       /* BCSP internal channel */
 204                 rel = 0;        /* unreliable channel */
 205                 break;
 206         default:
 207                 BT_ERR("Unknown packet type");
 208                 return NULL;
 209         }
 210
 211         if (hciextn && chan == 5) {
 212                 __le16 opcode = ((struct hci_command_hdr *)data)->opcode;
 213
 214                 /* Vendor specific commands */
 215                 if (hci_opcode_ogf(__le16_to_cpu(opcode)) == 0x3f) {
 216                         u8 desc = *(data + HCI_COMMAND_HDR_SIZE);
 217                         if ((desc & 0xf0) == 0xc0) {
 218                                 data += HCI_COMMAND_HDR_SIZE + 1;
 219                                 len  -= HCI_COMMAND_HDR_SIZE + 1;
 220                                 chan = desc & 0x0f;
 221                         }
 222                 }
 223         }
 224
 225         /* Max len of packet: (original len +4(bcsp hdr) +2(crc))*2
 226            (because bytes 0xc0 and 0xdb are escaped, worst case is
 227            when the packet is all made of 0xc0 and 0xdb :) )
 228            + 2 (0xc0 delimiters at start and end). */
 229
 230         nskb = alloc_skb((len + 6) * 2 + 2, GFP_ATOMIC);
 231         if (!nskb)
 232                 return NULL;
 233
 234         bt_cb(nskb)->pkt_type = pkt_type;
 235
 236         bcsp_slip_msgdelim(nskb);
 237
 238         hdr[0] = bcsp->rxseq_txack << 3;
 239         bcsp->txack_req = 0;
 240         BT_DBG("We request packet no %u to card", bcsp->rxseq_txack);
 241
 242         if (rel) {
 243                 hdr[0] |= 0x80 + bcsp->msgq_txseq;
 244                 BT_DBG("Sending packet with seqno %u", bcsp->msgq_txseq);
 245                 bcsp->msgq_txseq = (bcsp->msgq_txseq + 1) & 0x07;
 246         }
 247
 248         if (bcsp->use_crc)
 249                 hdr[0] |= 0x40;
 250
 251         hdr[1] = ((len << 4) & 0xff) | chan;
 252         hdr[2] = len >> 4;
 253         hdr[3] = ~(hdr[0] + hdr[1] + hdr[2]);
 254
 255         /* Put BCSP header */
 256         for (i = 0; i < 4; i++) {
 257                 bcsp_slip_one_byte(nskb, hdr[i]);
 258
 259                 if (bcsp->use_crc)
 260                         bcsp_crc_update(&bcsp_txmsg_crc, hdr[i]);
 261         }
 262
 263         /* Put payload */
 264         for (i = 0; i < len; i++) {
 265                 bcsp_slip_one_byte(nskb, data[i]);
 266
 267                 if (bcsp->use_crc)
 268                         bcsp_crc_update(&bcsp_txmsg_crc, data[i]);
 269         }
 270
 271         /* Put CRC */
 272         if (bcsp->use_crc) {
 273                 bcsp_txmsg_crc = bitrev16(bcsp_txmsg_crc);
 274                 bcsp_slip_one_byte(nskb, (u8) ((bcsp_txmsg_crc >> 8) & 0x00ff));
 275                 bcsp_slip_one_byte(nskb, (u8) (bcsp_txmsg_crc & 0x00ff));
 276         }
 277
 278         bcsp_slip_msgdelim(nskb);
 279         return nskb;
 280 }
 281
 282 /* This is a rewrite of pkt_avail in ABCSP */
 283 static struct sk_buff *bcsp_dequeue(struct hci_uart *hu)
 284 {
 285         struct bcsp_struct *bcsp = hu->priv;
 286         unsigned long flags;
 287         struct sk_buff *skb;
 288
 289         /* First of all, check for unreliable messages in the queue,
 290            since they have priority */
 291
 292         skb = skb_dequeue(&bcsp->unrel);
 293         if (skb != NULL) {
 294                 struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, bt_cb(skb)->pkt_type);
 295                 if (nskb) {
 296                         kfree_skb(skb);
 297                         return nskb;
 298                 } else {
 299                         skb_queue_head(&bcsp->unrel, skb);
 300                         BT_ERR("Could not dequeue pkt because alloc_skb failed");
 301                 }
 302         }
 303
 304         /* Now, try to send a reliable pkt. We can only send a
 305            reliable packet if the number of packets sent but not yet ack'ed
 306            is < than the winsize */
 307
 308         spin_lock_irqsave_nested(&bcsp->unack.lock, flags, SINGLE_DEPTH_NESTING);
 309
 310         if (bcsp->unack.qlen < BCSP_TXWINSIZE) {
 311                 skb = skb_dequeue(&bcsp->rel);
 312                 if (skb != NULL) {
 313                         struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len,
 314                                                                 bt_cb(skb)->pkt_type);
 315                         if (nskb) {
 316                                 __skb_queue_tail(&bcsp->unack, skb);
 317                                 mod_timer(&bcsp->tbcsp, jiffies + HZ / 4);
 318                                 spin_unlock_irqrestore(&bcsp->unack.lock, flags);
 319                                 return nskb;
 320                         } else {
 321                                 skb_queue_head(&bcsp->rel, skb);
 322                                 BT_ERR("Could not dequeue pkt because alloc_skb failed");
 323                         }
 324                 }
 325         }
 326
 327         spin_unlock_irqrestore(&bcsp->unack.lock, flags);
 328
 329         /* We could not send a reliable packet, either because there are
 330            none or because there are too many unack'ed pkts. Did we receive
 331            any packets we have not acknowledged yet ? */
 332
 333         if (bcsp->txack_req) {
 334                 /* if so, craft an empty ACK pkt and send it on BCSP unreliable
 335                    channel 0 */
 336                 struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, NULL, 0, BCSP_ACK_PKT);
 337                 return nskb;
 338         }
 339
 340         /* We have nothing to send */
 341         return NULL;
 342 }
 343
 344 static int bcsp_flush(struct hci_uart *hu)
 345 {
 346         BT_DBG("hu %p", hu);
 347         return 0;
 348 }
 349
 350 /* Remove ack'ed packets */
 351 static void bcsp_pkt_cull(struct bcsp_struct *bcsp)
 352 {
 353         struct sk_buff *skb, *tmp;
 354         unsigned long flags;
 355         int i, pkts_to_be_removed;
 356         u8 seqno;
 357
 358         spin_lock_irqsave(&bcsp->unack.lock, flags);
 359
 360         pkts_to_be_removed = skb_queue_len(&bcsp->unack);
 361         seqno = bcsp->msgq_txseq;
 362
 363         while (pkts_to_be_removed) {
 364                 if (bcsp->rxack == seqno)
 365                         break;
 366                 pkts_to_be_removed--;
 367                 seqno = (seqno - 1) & 0x07;
 368         }
 369
 370         if (bcsp->rxack != seqno)
 371                 BT_ERR("Peer acked invalid packet");
 372
 373         BT_DBG("Removing %u pkts out of %u, up to seqno %u",
 374                pkts_to_be_removed, skb_queue_len(&bcsp->unack),
 375                (seqno - 1) & 0x07);
 376
 377         i = 0;
 378         skb_queue_walk_safe(&bcsp->unack, skb, tmp) {
 379                 if (i >= pkts_to_be_removed)
 380                         break;
 381                 i++;
 382
 383                 __skb_unlink(skb, &bcsp->unack);
 384                 kfree_skb(skb);
 385         }
 386
 387         if (skb_queue_empty(&bcsp->unack))
 388                 del_timer(&bcsp->tbcsp);
 389
 390         spin_unlock_irqrestore(&bcsp->unack.lock, flags);
 391
 392         if (i != pkts_to_be_removed)
 393                 BT_ERR("Removed only %u out of %u pkts", i, pkts_to_be_removed);
 394 }
 395
 396 /* Handle BCSP link-establishment packets. When we
 397    detect a "sync" packet, symptom that the BT module has reset,
 398    we do nothing :) (yet) */
 399 static void bcsp_handle_le_pkt(struct hci_uart *hu)
 400 {
 401         struct bcsp_struct *bcsp = hu->priv;
 402         u8 conf_pkt[4]     = { 0xad, 0xef, 0xac, 0xed };
 403         u8 conf_rsp_pkt[4] = { 0xde, 0xad, 0xd0, 0xd0 };
 404         u8 sync_pkt[4]     = { 0xda, 0xdc, 0xed, 0xed };
 405
 406         /* spot "conf" pkts and reply with a "conf rsp" pkt */
 407         if (bcsp->rx_skb->data[1] >> 4 == 4 && bcsp->rx_skb->data[2] == 0 &&
 408                         !memcmp(&bcsp->rx_skb->data[4], conf_pkt, 4)) {
 409                 struct sk_buff *nskb = alloc_skb(4, GFP_ATOMIC);
 410
 411                 BT_DBG("Found a LE conf pkt");
 412                 if (!nskb)
 413                         return;
 414                 memcpy(skb_put(nskb, 4), conf_rsp_pkt, 4);
 415                 bt_cb(nskb)->pkt_type = BCSP_LE_PKT;
 416
 417                 skb_queue_head(&bcsp->unrel, nskb);
 418                 hci_uart_tx_wakeup(hu);
 419         }
 420         /* Spot "sync" pkts. If we find one...disaster! */
 421         else if (bcsp->rx_skb->data[1] >> 4 == 4 && bcsp->rx_skb->data[2] == 0 &&
 422                         !memcmp(&bcsp->rx_skb->data[4], sync_pkt, 4)) {
 423                 BT_ERR("Found a LE sync pkt, card has reset");
 424         }
 425 }
 426
 427 static inline void bcsp_unslip_one_byte(struct bcsp_struct *bcsp, unsigned char byte)
 428 {
 429         const u8 c0 = 0xc0, db = 0xdb;
 430
 431         switch (bcsp->rx_esc_state) {
 432         case BCSP_ESCSTATE_NOESC:
 433                 switch (byte) {
 434                 case 0xdb:
 435                         bcsp->rx_esc_state = BCSP_ESCSTATE_ESC;
 436                         break;
 437                 default:
 438                         memcpy(skb_put(bcsp->rx_skb, 1), &byte, 1);
 439                         if ((bcsp->rx_skb->data[0] & 0x40) != 0 &&
 440                                         bcsp->rx_state != BCSP_W4_CRC)
 441                                 bcsp_crc_update(&bcsp->message_crc, byte);
 442                         bcsp->rx_count--;
 443                 }
 444                 break;
 445
 446         case BCSP_ESCSTATE_ESC:
 447                 switch (byte) {
 448                 case 0xdc:
 449                         memcpy(skb_put(bcsp->rx_skb, 1), &c0, 1);
 450                         if ((bcsp->rx_skb->data[0] & 0x40) != 0 &&
 451                                         bcsp->rx_state != BCSP_W4_CRC)
 452                                 bcsp_crc_update(&bcsp->message_crc, 0xc0);
 453                         bcsp->rx_esc_state = BCSP_ESCSTATE_NOESC;
 454                         bcsp->rx_count--;
 455                         break;
 456
 457                 case 0xdd:
 458                         memcpy(skb_put(bcsp->rx_skb, 1), &db, 1);
 459                         if ((bcsp->rx_skb->data[0] & 0x40) != 0 &&
 460                                         bcsp->rx_state != BCSP_W4_CRC)
 461                                 bcsp_crc_update(&bcsp->message_crc, 0xdb);
 462                         bcsp->rx_esc_state = BCSP_ESCSTATE_NOESC;
 463                         bcsp->rx_count--;
 464                         break;
 465
 466                 default:
 467                         BT_ERR("Invalid byte %02x after esc byte", byte);
 468                         kfree_skb(bcsp->rx_skb);
 469                         bcsp->rx_skb = NULL;
 470                         bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 471                         bcsp->rx_count = 0;
 472                 }
 473         }
 474 }
 475
 476 static void bcsp_complete_rx_pkt(struct hci_uart *hu)
 477 {
 478         struct bcsp_struct *bcsp = hu->priv;
 479         int pass_up;
 480
 481         if (bcsp->rx_skb->data[0] & 0x80) {     /* reliable pkt */
 482                 BT_DBG("Received seqno %u from card", bcsp->rxseq_txack);
 483                 bcsp->rxseq_txack++;
 484                 bcsp->rxseq_txack %= 0x8;
 485                 bcsp->txack_req    = 1;
 486
 487                 /* If needed, transmit an ack pkt */
 488                 hci_uart_tx_wakeup(hu);
 489         }
 490
 491         bcsp->rxack = (bcsp->rx_skb->data[0] >> 3) & 0x07;
 492         BT_DBG("Request for pkt %u from card", bcsp->rxack);
 493
 494         bcsp_pkt_cull(bcsp);
 495         if ((bcsp->rx_skb->data[1] & 0x0f) == 6 &&
 496                         bcsp->rx_skb->data[0] & 0x80) {
 497                 bt_cb(bcsp->rx_skb)->pkt_type = HCI_ACLDATA_PKT;
 498                 pass_up = 1;
 499         } else if ((bcsp->rx_skb->data[1] & 0x0f) == 5 &&
 500                         bcsp->rx_skb->data[0] & 0x80) {
 501                 bt_cb(bcsp->rx_skb)->pkt_type = HCI_EVENT_PKT;
 502                 pass_up = 1;
 503         } else if ((bcsp->rx_skb->data[1] & 0x0f) == 7) {
 504                 bt_cb(bcsp->rx_skb)->pkt_type = HCI_SCODATA_PKT;
 505                 pass_up = 1;
 506         } else if ((bcsp->rx_skb->data[1] & 0x0f) == 1 &&
 507                         !(bcsp->rx_skb->data[0] & 0x80)) {
 508                 bcsp_handle_le_pkt(hu);
 509                 pass_up = 0;
 510         } else
 511                 pass_up = 0;
 512
 513         if (!pass_up) {
 514                 struct hci_event_hdr hdr;
 515                 u8 desc = (bcsp->rx_skb->data[1] & 0x0f);
 516
 517                 if (desc != 0 && desc != 1) {
 518                         if (hciextn) {
 519                                 desc |= 0xc0;
 520                                 skb_pull(bcsp->rx_skb, 4);
 521                                 memcpy(skb_push(bcsp->rx_skb, 1), &desc, 1);
 522
 523                                 hdr.evt = 0xff;
 524                                 hdr.plen = bcsp->rx_skb->len;
 525                                 memcpy(skb_push(bcsp->rx_skb, HCI_EVENT_HDR_SIZE), &hdr, HCI_EVENT_HDR_SIZE);
 526                                 bt_cb(bcsp->rx_skb)->pkt_type = HCI_EVENT_PKT;
 527
 528                                 hci_recv_frame(hu->hdev, bcsp->rx_skb);
 529                         } else {
 530                                 BT_ERR("Packet for unknown channel (%u %s)",
 531                                         bcsp->rx_skb->data[1] & 0x0f,
 532                                         bcsp->rx_skb->data[0] & 0x80 ?
 533                                         "reliable" : "unreliable");
 534                                 kfree_skb(bcsp->rx_skb);
 535                         }
 536                 } else
 537                         kfree_skb(bcsp->rx_skb);
 538         } else {
 539                 /* Pull out BCSP hdr */
 540                 skb_pull(bcsp->rx_skb, 4);
 541
 542                 hci_recv_frame(hu->hdev, bcsp->rx_skb);
 543         }
 544
 545         bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 546         bcsp->rx_skb = NULL;
 547 }
 548
 549 static u16 bscp_get_crc(struct bcsp_struct *bcsp)
 550 {
 551         return get_unaligned_be16(&bcsp->rx_skb->data[bcsp->rx_skb->len - 2]);
 552 }
 553
 554 /* Recv data */
 555 static int bcsp_recv(struct hci_uart *hu, const void *data, int count)
 556 {
 557         struct bcsp_struct *bcsp = hu->priv;
 558         const unsigned char *ptr;
 559
 560         BT_DBG("hu %p count %d rx_state %d rx_count %ld",
 561                 hu, count, bcsp->rx_state, bcsp->rx_count);
 562
 563         ptr = data;
 564         while (count) {
 565                 if (bcsp->rx_count) {
 566                         if (*ptr == 0xc0) {
 567                                 BT_ERR("Short BCSP packet");
 568                                 kfree_skb(bcsp->rx_skb);
 569                                 bcsp->rx_state = BCSP_W4_PKT_START;
 570                                 bcsp->rx_count = 0;
 571                         } else
 572                                 bcsp_unslip_one_byte(bcsp, *ptr);
 573
 574                         ptr++; count--;
 575                         continue;
 576                 }
 577
 578                 switch (bcsp->rx_state) {
 579                 case BCSP_W4_BCSP_HDR:
 580                         if ((0xff & (u8) ~ (bcsp->rx_skb->data[0] + bcsp->rx_skb->data[1] +
 581                                         bcsp->rx_skb->data[2])) != bcsp->rx_skb->data[3]) {
 582                                 BT_ERR("Error in BCSP hdr checksum");
 583                                 kfree_skb(bcsp->rx_skb);
 584                                 bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 585                                 bcsp->rx_count = 0;
 586                                 continue;
 587                         }
 588                         if (bcsp->rx_skb->data[0] & 0x80        /* reliable pkt */
 589                                         && (bcsp->rx_skb->data[0] & 0x07) != bcsp->rxseq_txack) {
 590                                 BT_ERR("Out-of-order packet arrived, got %u expected %u",
 591                                         bcsp->rx_skb->data[0] & 0x07, bcsp->rxseq_txack);
 592
 593                                 kfree_skb(bcsp->rx_skb);
 594                                 bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 595                                 bcsp->rx_count = 0;
 596                                 continue;
 597                         }
 598                         bcsp->rx_state = BCSP_W4_DATA;
 599                         bcsp->rx_count = (bcsp->rx_skb->data[1] >> 4) +
 600                                         (bcsp->rx_skb->data[2] << 4);   /* May be 0 */
 601                         continue;
 602
 603                 case BCSP_W4_DATA:
 604                         if (bcsp->rx_skb->data[0] & 0x40) {     /* pkt with crc */
 605                                 bcsp->rx_state = BCSP_W4_CRC;
 606                                 bcsp->rx_count = 2;
 607                         } else
 608                                 bcsp_complete_rx_pkt(hu);
 609                         continue;
 610
 611                 case BCSP_W4_CRC:
 612                         if (bitrev16(bcsp->message_crc) != bscp_get_crc(bcsp)) {
 613                                 BT_ERR ("Checksum failed: computed %04x received %04x",
 614                                         bitrev16(bcsp->message_crc),
 615                                         bscp_get_crc(bcsp));
 616
 617                                 kfree_skb(bcsp->rx_skb);
 618                                 bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 619                                 bcsp->rx_count = 0;
 620                                 continue;
 621                         }
 622                         skb_trim(bcsp->rx_skb, bcsp->rx_skb->len - 2);
 623                         bcsp_complete_rx_pkt(hu);
 624                         continue;
 625
 626                 case BCSP_W4_PKT_DELIMITER:
 627                         switch (*ptr) {
 628                         case 0xc0:
 629                                 bcsp->rx_state = BCSP_W4_PKT_START;
 630                                 break;
 631                         default:
 632                                 /*BT_ERR("Ignoring byte %02x", *ptr);*/
 633                                 break;
 634                         }
 635                         ptr++; count--;
 636                         break;
 637
 638                 case BCSP_W4_PKT_START:
 639                         switch (*ptr) {
 640                         case 0xc0:
 641                                 ptr++; count--;
 642                                 break;
 643
 644                         default:
 645                                 bcsp->rx_state = BCSP_W4_BCSP_HDR;
 646                                 bcsp->rx_count = 4;
 647                                 bcsp->rx_esc_state = BCSP_ESCSTATE_NOESC;
 648                                 BCSP_CRC_INIT(bcsp->message_crc);
 649
 650                                 /* Do not increment ptr or decrement count
 651                                  * Allocate packet. Max len of a BCSP pkt=
 652                                  * 0xFFF (payload) +4 (header) +2 (crc) */
 653
 654                                 bcsp->rx_skb = bt_skb_alloc(0x1005, GFP_ATOMIC);
 655                                 if (!bcsp->rx_skb) {
 656                                         BT_ERR("Can't allocate mem for new packet");
 657                                         bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 658                                         bcsp->rx_count = 0;
 659                                         return 0;
 660                                 }
 661                                 break;
 662                         }
 663                         break;
 664                 }
 665         }
 666         return count;
 667 }
 668
 669         /* Arrange to retransmit all messages in the relq. */
 670 static void bcsp_timed_event(unsigned long arg)
 671 {
 672         struct hci_uart *hu = (struct hci_uart *) arg;
 673         struct bcsp_struct *bcsp = hu->priv;
 674         struct sk_buff *skb;
 675         unsigned long flags;
 676
 677         BT_DBG("hu %p retransmitting %u pkts", hu, bcsp->unack.qlen);
 678
 679         spin_lock_irqsave_nested(&bcsp->unack.lock, flags, SINGLE_DEPTH_NESTING);
 680
 681         while ((skb = __skb_dequeue_tail(&bcsp->unack)) != NULL) {
 682                 bcsp->msgq_txseq = (bcsp->msgq_txseq - 1) & 0x07;
 683                 skb_queue_head(&bcsp->rel, skb);
 684         }
 685
 686         spin_unlock_irqrestore(&bcsp->unack.lock, flags);
 687
 688         hci_uart_tx_wakeup(hu);
 689 }
 690
 691 static int bcsp_open(struct hci_uart *hu)
 692 {
 693         struct bcsp_struct *bcsp;
 694
 695         BT_DBG("hu %p", hu);
 696
 697         bcsp = kzalloc(sizeof(*bcsp), GFP_KERNEL);
 698         if (!bcsp)
 699                 return -ENOMEM;
 700
 701         hu->priv = bcsp;
 702         skb_queue_head_init(&bcsp->unack);
 703         skb_queue_head_init(&bcsp->rel);
 704         skb_queue_head_init(&bcsp->unrel);
 705
 706         init_timer(&bcsp->tbcsp);
 707         bcsp->tbcsp.function = bcsp_timed_event;
 708         bcsp->tbcsp.data     = (u_long) hu;
 709
 710         bcsp->rx_state = BCSP_W4_PKT_DELIMITER;
 711
 712         if (txcrc)
 713                 bcsp->use_crc = 1;
 714
 715         return 0;
 716 }
 717
 718 static int bcsp_close(struct hci_uart *hu)
 719 {
 720         struct bcsp_struct *bcsp = hu->priv;
 721
 722         del_timer_sync(&bcsp->tbcsp);
 723
 724         hu->priv = NULL;
 725
 726         BT_DBG("hu %p", hu);
 727
 728         skb_queue_purge(&bcsp->unack);
 729         skb_queue_purge(&bcsp->rel);
 730         skb_queue_purge(&bcsp->unrel);
 731
 732         kfree(bcsp);
 733         return 0;
 734 }
 735
 736 static const struct hci_uart_proto bcsp = {
 737         .id             = HCI_UART_BCSP,
 738         .name           = "BCSP",
 739         .open           = bcsp_open,
 740         .close          = bcsp_close,
 741         .enqueue        = bcsp_enqueue,
 742         .dequeue        = bcsp_dequeue,
 743         .recv           = bcsp_recv,
 744         .flush          = bcsp_flush
 745 };
 746
 747 int __init bcsp_init(void)
 748 {
 749         return hci_uart_register_proto(&bcsp);
 750 }
 751
 752 int __exit bcsp_deinit(void)
 753 {
 754         return hci_uart_unregister_proto(&bcsp);
 755 }
 756
 757 module_param(txcrc, bool, 0644);
 758 MODULE_PARM_DESC(txcrc, "Transmit CRC with every BCSP packet");
 759
 760 module_param(hciextn, bool, 0644);
 761 MODULE_PARM_DESC(hciextn, "Convert HCI Extensions into BCSP packets");