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