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