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