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