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