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