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