Merge master.kernel.org:/pub/scm/linux/kernel/git/holtmann/bluetooth-2.6
[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 #endif
62
63 static int hciextn = 1;
64
65 /* ---- BCSP CRC calculation ---- */
66
67 /* Table for calculating CRC for polynomial 0x1021, LSB processed first,
68 initial value 0xffff, bits shifted in reverse order. */
69
70 static 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 */
87 static 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 */
105 static 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
119 static 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
125 static 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
142 static 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
152         switch (skb->pkt_type) {
153         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
171 static 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
230         nskb->pkt_type = pkt_type;
231
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 */
279 static 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) {
289                 struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, skb->pkt_type);
290                 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) {
306                 struct sk_buff *nskb = bcsp_prepare_pkt(bcsp, skb->data, skb->len, skb->pkt_type);
307                 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
336 static int bcsp_flush(struct hci_uart *hu)
337 {
338         BT_DBG("hu %p", hu);
339         return 0;
340 }
341
342 /* Remove ack'ed packets */
343 static 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) */
388 static 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);
404                 nskb->pkt_type = BCSP_LE_PKT;
405
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
416 static 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
465 static 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) {
486                 bcsp->rx_skb->pkt_type = HCI_ACLDATA_PKT;
487                 pass_up = 1;
488         } else if ((bcsp->rx_skb->data[1] & 0x0f) == 5 &&
489                         bcsp->rx_skb->data[0] & 0x80) {
490                 bcsp->rx_skb->pkt_type = HCI_EVENT_PKT;
491                 pass_up = 1;
492         } else if ((bcsp->rx_skb->data[1] & 0x0f) == 7) {
493                 bcsp->rx_skb->pkt_type = HCI_SCODATA_PKT;
494                 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);
515                                 bcsp->rx_skb->pkt_type = HCI_EVENT_PKT;
516
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 */
538 static 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. */
658 static 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
679 static 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
704 static 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
720 static 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
730 int 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
741 int bcsp_deinit(void)
742 {
743         return hci_uart_unregister_proto(&bcsp);
744 }
745
746 module_param(hciextn, bool, 0644);
747 MODULE_PARM_DESC(hciextn, "Convert HCI Extensions into BCSP packets");