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