?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / bluetooth / btuart_cs.c
blob68d1d258e6a4f5f4e8064a061d374ef1b632dca3
1 /*
2 *
3 * Driver for Bluetooth PCMCIA cards with HCI UART interface
4 *
5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation;
11 *
12 * Software distributed under the License is distributed on an "AS
13 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14 * implied. See the License for the specific language governing
15 * rights and limitations under the License.
16 *
17 * The initial developer of the original code is David A. Hinds
18 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
19 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
20 *
21 */
22
23 #include <linux/module.h>
24
25 #include <linux/kernel.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/types.h>
29 #include <linux/delay.h>
30 #include <linux/errno.h>
31 #include <linux/ptrace.h>
32 #include <linux/ioport.h>
33 #include <linux/spinlock.h>
34 #include <linux/moduleparam.h>
35
36 #include <linux/skbuff.h>
37 #include <linux/string.h>
38 #include <linux/serial.h>
39 #include <linux/serial_reg.h>
40 #include <linux/bitops.h>
41 #include <asm/system.h>
42 #include <asm/io.h>
43
44 #include <pcmcia/cs_types.h>
45 #include <pcmcia/cs.h>
46 #include <pcmcia/cistpl.h>
47 #include <pcmcia/ciscode.h>
48 #include <pcmcia/ds.h>
49 #include <pcmcia/cisreg.h>
50
51 #include <net/bluetooth/bluetooth.h>
52 #include <net/bluetooth/hci_core.h>
53
54
55
56 /* ======================== Module parameters ======================== */
57
58
59 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
60 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
61 MODULE_LICENSE("GPL");
62
63
64
65 /* ======================== Local structures ======================== */
66
67
68 typedef struct btuart_info_t {
69 struct pcmcia_device *p_dev;
70 dev_node_t node;
71
72 struct hci_dev *hdev;
73
74 spinlock_t lock; /* For serializing operations */
75
76 struct sk_buff_head txq;
77 unsigned long tx_state;
78
79 unsigned long rx_state;
80 unsigned long rx_count;
81 struct sk_buff *rx_skb;
82 } btuart_info_t;
83
84
85 static int btuart_config(struct pcmcia_device *link);
86 static void btuart_release(struct pcmcia_device *link);
87
88 static void btuart_detach(struct pcmcia_device *p_dev);
89
90
91 /* Maximum baud rate */
92 #define SPEED_MAX 115200
93
94 /* Default baud rate: 57600, 115200, 230400 or 460800 */
95 #define DEFAULT_BAUD_RATE 115200
96
97
98 /* Transmit states */
99 #define XMIT_SENDING 1
100 #define XMIT_WAKEUP 2
101 #define XMIT_WAITING 8
102
103 /* Receiver states */
104 #define RECV_WAIT_PACKET_TYPE 0
105 #define RECV_WAIT_EVENT_HEADER 1
106 #define RECV_WAIT_ACL_HEADER 2
107 #define RECV_WAIT_SCO_HEADER 3
108 #define RECV_WAIT_DATA 4
109
110
111
112 /* ======================== Interrupt handling ======================== */
113
114
115 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
116 {
117 int actual = 0;
118
119 /* Tx FIFO should be empty */
120 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
121 return 0;
122
123 /* Fill FIFO with current frame */
124 while ((fifo_size-- > 0) && (actual < len)) {
125 /* Transmit next byte */
126 outb(buf[actual], iobase + UART_TX);
127 actual++;
128 }
129
130 return actual;
131 }
132
133
134 static void btuart_write_wakeup(btuart_info_t *info)
135 {
136 if (!info) {
137 BT_ERR("Unknown device");
138 return;
139 }
140
141 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
142 set_bit(XMIT_WAKEUP, &(info->tx_state));
143 return;
144 }
145
146 do {
147 register unsigned int iobase = info->p_dev->io.BasePort1;
148 register struct sk_buff *skb;
149 register int len;
150
151 clear_bit(XMIT_WAKEUP, &(info->tx_state));
152
153 if (!pcmcia_dev_present(info->p_dev))
154 return;
155
156 if (!(skb = skb_dequeue(&(info->txq))))
157 break;
158
159 /* Send frame */
160 len = btuart_write(iobase, 16, skb->data, skb->len);
161 set_bit(XMIT_WAKEUP, &(info->tx_state));
162
163 if (len == skb->len) {
164 kfree_skb(skb);
165 } else {
166 skb_pull(skb, len);
167 skb_queue_head(&(info->txq), skb);
168 }
169
170 info->hdev->stat.byte_tx += len;
171
172 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
173
174 clear_bit(XMIT_SENDING, &(info->tx_state));
175 }
176
177
178 static void btuart_receive(btuart_info_t *info)
179 {
180 unsigned int iobase;
181 int boguscount = 0;
182
183 if (!info) {
184 BT_ERR("Unknown device");
185 return;
186 }
187
188 iobase = info->p_dev->io.BasePort1;
189
190 do {
191 info->hdev->stat.byte_rx++;
192
193 /* Allocate packet */
194 if (info->rx_skb == NULL) {
195 info->rx_state = RECV_WAIT_PACKET_TYPE;
196 info->rx_count = 0;
197 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
198 BT_ERR("Can't allocate mem for new packet");
199 return;
200 }
201 }
202
203 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
204
205 info->rx_skb->dev = (void *) info->hdev;
206 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
207
208 switch (bt_cb(info->rx_skb)->pkt_type) {
209
210 case HCI_EVENT_PKT:
211 info->rx_state = RECV_WAIT_EVENT_HEADER;
212 info->rx_count = HCI_EVENT_HDR_SIZE;
213 break;
214
215 case HCI_ACLDATA_PKT:
216 info->rx_state = RECV_WAIT_ACL_HEADER;
217 info->rx_count = HCI_ACL_HDR_SIZE;
218 break;
219
220 case HCI_SCODATA_PKT:
221 info->rx_state = RECV_WAIT_SCO_HEADER;
222 info->rx_count = HCI_SCO_HDR_SIZE;
223 break;
224
225 default:
226 /* Unknown packet */
227 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
228 info->hdev->stat.err_rx++;
229 clear_bit(HCI_RUNNING, &(info->hdev->flags));
230
231 kfree_skb(info->rx_skb);
232 info->rx_skb = NULL;
233 break;
234
235 }
236
237 } else {
238
239 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
240 info->rx_count--;
241
242 if (info->rx_count == 0) {
243
244 int dlen;
245 struct hci_event_hdr *eh;
246 struct hci_acl_hdr *ah;
247 struct hci_sco_hdr *sh;
248
249
250 switch (info->rx_state) {
251
252 case RECV_WAIT_EVENT_HEADER:
253 eh = hci_event_hdr(info->rx_skb);
254 info->rx_state = RECV_WAIT_DATA;
255 info->rx_count = eh->plen;
256 break;
257
258 case RECV_WAIT_ACL_HEADER:
259 ah = hci_acl_hdr(info->rx_skb);
260 dlen = __le16_to_cpu(ah->dlen);
261 info->rx_state = RECV_WAIT_DATA;
262 info->rx_count = dlen;
263 break;
264
265 case RECV_WAIT_SCO_HEADER:
266 sh = hci_sco_hdr(info->rx_skb);
267 info->rx_state = RECV_WAIT_DATA;
268 info->rx_count = sh->dlen;
269 break;
270
271 case RECV_WAIT_DATA:
272 hci_recv_frame(info->rx_skb);
273 info->rx_skb = NULL;
274 break;
275
276 }
277
278 }
279
280 }
281
282 /* Make sure we don't stay here too long */
283 if (boguscount++ > 16)
284 break;
285
286 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
287 }
288
289
290 static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
291 {
292 btuart_info_t *info = dev_inst;
293 unsigned int iobase;
294 int boguscount = 0;
295 int iir, lsr;
296
297 BUG_ON(!info->hdev);
298
299 iobase = info->p_dev->io.BasePort1;
300
301 spin_lock(&(info->lock));
302
303 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
304 while (iir) {
305
306 /* Clear interrupt */
307 lsr = inb(iobase + UART_LSR);
308
309 switch (iir) {
310 case UART_IIR_RLSI:
311 BT_ERR("RLSI");
312 break;
313 case UART_IIR_RDI:
314 /* Receive interrupt */
315 btuart_receive(info);
316 break;
317 case UART_IIR_THRI:
318 if (lsr & UART_LSR_THRE) {
319 /* Transmitter ready for data */
320 btuart_write_wakeup(info);
321 }
322 break;
323 default:
324 BT_ERR("Unhandled IIR=%#x", iir);
325 break;
326 }
327
328 /* Make sure we don't stay here too long */
329 if (boguscount++ > 100)
330 break;
331
332 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
333
334 }
335
336 spin_unlock(&(info->lock));
337
338 return IRQ_HANDLED;
339 }
340
341
342 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
343 {
344 unsigned long flags;
345 unsigned int iobase;
346 int fcr; /* FIFO control reg */
347 int lcr; /* Line control reg */
348 int divisor;
349
350 if (!info) {
351 BT_ERR("Unknown device");
352 return;
353 }
354
355 iobase = info->p_dev->io.BasePort1;
356
357 spin_lock_irqsave(&(info->lock), flags);
358
359 /* Turn off interrupts */
360 outb(0, iobase + UART_IER);
361
362 divisor = SPEED_MAX / speed;
363
364 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
365
366 /*
367 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
368 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
369 * about this timeout since it will always be fast enough.
370 */
371
372 if (speed < 38400)
373 fcr |= UART_FCR_TRIGGER_1;
374 else
375 fcr |= UART_FCR_TRIGGER_14;
376
377 /* Bluetooth cards use 8N1 */
378 lcr = UART_LCR_WLEN8;
379
380 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
381 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
382 outb(divisor >> 8, iobase + UART_DLM);
383 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
384 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
385
386 /* Turn on interrupts */
387 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
388
389 spin_unlock_irqrestore(&(info->lock), flags);
390 }
391
392
393
394 /* ======================== HCI interface ======================== */
395
396
397 static int btuart_hci_flush(struct hci_dev *hdev)
398 {
399 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
400
401 /* Drop TX queue */
402 skb_queue_purge(&(info->txq));
403
404 return 0;
405 }
406
407
408 static int btuart_hci_open(struct hci_dev *hdev)
409 {
410 set_bit(HCI_RUNNING, &(hdev->flags));
411
412 return 0;
413 }
414
415
416 static int btuart_hci_close(struct hci_dev *hdev)
417 {
418 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
419 return 0;
420
421 btuart_hci_flush(hdev);
422
423 return 0;
424 }
425
426
427 static int btuart_hci_send_frame(struct sk_buff *skb)
428 {
429 btuart_info_t *info;
430 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
431
432 if (!hdev) {
433 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
434 return -ENODEV;
435 }
436
437 info = (btuart_info_t *)(hdev->driver_data);
438
439 switch (bt_cb(skb)->pkt_type) {
440 case HCI_COMMAND_PKT:
441 hdev->stat.cmd_tx++;
442 break;
443 case HCI_ACLDATA_PKT:
444 hdev->stat.acl_tx++;
445 break;
446 case HCI_SCODATA_PKT:
447 hdev->stat.sco_tx++;
448 break;
449 };
450
451 /* Prepend skb with frame type */
452 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
453 skb_queue_tail(&(info->txq), skb);
454
455 btuart_write_wakeup(info);
456
457 return 0;
458 }
459
460
461 static void btuart_hci_destruct(struct hci_dev *hdev)
462 {
463 }
464
465
466 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
467 {
468 return -ENOIOCTLCMD;
469 }
470
471
472
473 /* ======================== Card services HCI interaction ======================== */
474
475
476 static int btuart_open(btuart_info_t *info)
477 {
478 unsigned long flags;
479 unsigned int iobase = info->p_dev->io.BasePort1;
480 struct hci_dev *hdev;
481
482 spin_lock_init(&(info->lock));
483
484 skb_queue_head_init(&(info->txq));
485
486 info->rx_state = RECV_WAIT_PACKET_TYPE;
487 info->rx_count = 0;
488 info->rx_skb = NULL;
489
490 /* Initialize HCI device */
491 hdev = hci_alloc_dev();
492 if (!hdev) {
493 BT_ERR("Can't allocate HCI device");
494 return -ENOMEM;
495 }
496
497 info->hdev = hdev;
498
499 hdev->type = HCI_PCCARD;
500 hdev->driver_data = info;
501 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
502
503 hdev->open = btuart_hci_open;
504 hdev->close = btuart_hci_close;
505 hdev->flush = btuart_hci_flush;
506 hdev->send = btuart_hci_send_frame;
507 hdev->destruct = btuart_hci_destruct;
508 hdev->ioctl = btuart_hci_ioctl;
509
510 hdev->owner = THIS_MODULE;
511
512 spin_lock_irqsave(&(info->lock), flags);
513
514 /* Reset UART */
515 outb(0, iobase + UART_MCR);
516
517 /* Turn off interrupts */
518 outb(0, iobase + UART_IER);
519
520 /* Initialize UART */
521 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
522 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
523
524 /* Turn on interrupts */
525 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
526
527 spin_unlock_irqrestore(&(info->lock), flags);
528
529 btuart_change_speed(info, DEFAULT_BAUD_RATE);
530
531 /* Timeout before it is safe to send the first HCI packet */
532 msleep(1000);
533
534 /* Register HCI device */
535 if (hci_register_dev(hdev) < 0) {
536 BT_ERR("Can't register HCI device");
537 info->hdev = NULL;
538 hci_free_dev(hdev);
539 return -ENODEV;
540 }
541
542 return 0;
543 }
544
545
546 static int btuart_close(btuart_info_t *info)
547 {
548 unsigned long flags;
549 unsigned int iobase = info->p_dev->io.BasePort1;
550 struct hci_dev *hdev = info->hdev;
551
552 if (!hdev)
553 return -ENODEV;
554
555 btuart_hci_close(hdev);
556
557 spin_lock_irqsave(&(info->lock), flags);
558
559 /* Reset UART */
560 outb(0, iobase + UART_MCR);
561
562 /* Turn off interrupts */
563 outb(0, iobase + UART_IER);
564
565 spin_unlock_irqrestore(&(info->lock), flags);
566
567 if (hci_unregister_dev(hdev) < 0)
568 BT_ERR("Can't unregister HCI device %s", hdev->name);
569
570 hci_free_dev(hdev);
571
572 return 0;
573 }
574
575 static int btuart_probe(struct pcmcia_device *link)
576 {
577 btuart_info_t *info;
578
579 /* Create new info device */
580 info = kzalloc(sizeof(*info), GFP_KERNEL);
581 if (!info)
582 return -ENOMEM;
583
584 info->p_dev = link;
585 link->priv = info;
586
587 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
588 link->io.NumPorts1 = 8;
589 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
590 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
591
592 link->irq.Handler = btuart_interrupt;
593 link->irq.Instance = info;
594
595 link->conf.Attributes = CONF_ENABLE_IRQ;
596 link->conf.IntType = INT_MEMORY_AND_IO;
597
598 return btuart_config(link);
599 }
600
601
602 static void btuart_detach(struct pcmcia_device *link)
603 {
604 btuart_info_t *info = link->priv;
605
606 btuart_release(link);
607 kfree(info);
608 }
609
610 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
611 {
612 int i;
613
614 i = pcmcia_get_tuple_data(handle, tuple);
615 if (i != CS_SUCCESS)
616 return i;
617
618 return pcmcia_parse_tuple(handle, tuple, parse);
619 }
620
621 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
622 {
623 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
624 return CS_NO_MORE_ITEMS;
625 return get_tuple(handle, tuple, parse);
626 }
627
628 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
629 {
630 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
631 return CS_NO_MORE_ITEMS;
632 return get_tuple(handle, tuple, parse);
633 }
634
635 static int btuart_config(struct pcmcia_device *link)
636 {
637 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
638 btuart_info_t *info = link->priv;
639 tuple_t tuple;
640 u_short buf[256];
641 cisparse_t parse;
642 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
643 int i, j, try;
644
645 /* First pass: look for a config entry that looks normal. */
646 tuple.TupleData = (cisdata_t *) buf;
647 tuple.TupleOffset = 0;
648 tuple.TupleDataMax = 255;
649 tuple.Attributes = 0;
650 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
651 /* Two tries: without IO aliases, then with aliases */
652 for (try = 0; try < 2; try++) {
653 i = first_tuple(link, &tuple, &parse);
654 while (i != CS_NO_MORE_ITEMS) {
655 if (i != CS_SUCCESS)
656 goto next_entry;
657 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
658 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
659 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
660 link->conf.ConfigIndex = cf->index;
661 link->io.BasePort1 = cf->io.win[0].base;
662 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
663 i = pcmcia_request_io(link, &link->io);
664 if (i == CS_SUCCESS)
665 goto found_port;
666 }
667 next_entry:
668 i = next_tuple(link, &tuple, &parse);
669 }
670 }
671
672 /* Second pass: try to find an entry that isn't picky about
673 its base address, then try to grab any standard serial port
674 address, and finally try to get any free port. */
675 i = first_tuple(link, &tuple, &parse);
676 while (i != CS_NO_MORE_ITEMS) {
677 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
678 && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
679 link->conf.ConfigIndex = cf->index;
680 for (j = 0; j < 5; j++) {
681 link->io.BasePort1 = base[j];
682 link->io.IOAddrLines = base[j] ? 16 : 3;
683 i = pcmcia_request_io(link, &link->io);
684 if (i == CS_SUCCESS)
685 goto found_port;
686 }
687 }
688 i = next_tuple(link, &tuple, &parse);
689 }
690
691 found_port:
692 if (i != CS_SUCCESS) {
693 BT_ERR("No usable port range found");
694 cs_error(link, RequestIO, i);
695 goto failed;
696 }
697
698 i = pcmcia_request_irq(link, &link->irq);
699 if (i != CS_SUCCESS) {
700 cs_error(link, RequestIRQ, i);
701 link->irq.AssignedIRQ = 0;
702 }
703
704 i = pcmcia_request_configuration(link, &link->conf);
705 if (i != CS_SUCCESS) {
706 cs_error(link, RequestConfiguration, i);
707 goto failed;
708 }
709
710 if (btuart_open(info) != 0)
711 goto failed;
712
713 strcpy(info->node.dev_name, info->hdev->name);
714 link->dev_node = &info->node;
715
716 return 0;
717
718 failed:
719 btuart_release(link);
720 return -ENODEV;
721 }
722
723
724 static void btuart_release(struct pcmcia_device *link)
725 {
726 btuart_info_t *info = link->priv;
727
728 btuart_close(info);
729
730 pcmcia_disable_device(link);
731 }
732
733 static struct pcmcia_device_id btuart_ids[] = {
734 /* don't use this driver. Use serial_cs + hci_uart instead */
735 PCMCIA_DEVICE_NULL
736 };
737 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
738
739 static struct pcmcia_driver btuart_driver = {
740 .owner = THIS_MODULE,
741 .drv = {
742 .name = "btuart_cs",
743 },
744 .probe = btuart_probe,
745 .remove = btuart_detach,
746 .id_table = btuart_ids,
747 };
748
749 static int __init init_btuart_cs(void)
750 {
751 return pcmcia_register_driver(&btuart_driver);
752 }
753
754
755 static void __exit exit_btuart_cs(void)
756 {
757 pcmcia_unregister_driver(&btuart_driver);
758 }
759
760 module_init(init_btuart_cs);
761 module_exit(exit_btuart_cs);
mah project overlay