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