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