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