3 * Driver for Bluetooth PCMCIA cards with HCI UART interface
5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
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;
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.
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.
23 #include <linux/config.h>
24 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/delay.h>
32 #include <linux/errno.h>
33 #include <linux/ptrace.h>
34 #include <linux/ioport.h>
35 #include <linux/spinlock.h>
36 #include <linux/moduleparam.h>
38 #include <linux/skbuff.h>
39 #include <linux/string.h>
40 #include <linux/serial.h>
41 #include <linux/serial_reg.h>
42 #include <linux/bitops.h>
43 #include <asm/system.h>
46 #include <pcmcia/cs_types.h>
47 #include <pcmcia/cs.h>
48 #include <pcmcia/cistpl.h>
49 #include <pcmcia/ciscode.h>
50 #include <pcmcia/ds.h>
51 #include <pcmcia/cisreg.h>
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/hci_core.h>
58 /* ======================== Module parameters ======================== */
61 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
62 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
63 MODULE_LICENSE("GPL");
67 /* ======================== Local structures ======================== */
70 typedef struct btuart_info_t {
76 spinlock_t lock; /* For serializing operations */
78 struct sk_buff_head txq;
79 unsigned long tx_state;
81 unsigned long rx_state;
82 unsigned long rx_count;
83 struct sk_buff *rx_skb;
87 static void btuart_config(dev_link_t *link);
88 static void btuart_release(dev_link_t *link);
89 static int btuart_event(event_t event, int priority, event_callback_args_t *args);
91 static dev_info_t dev_info = "btuart_cs";
93 static dev_link_t *btuart_attach(void);
94 static void btuart_detach(struct pcmcia_device *p_dev);
96 static dev_link_t *dev_list = NULL;
99 /* Maximum baud rate */
100 #define SPEED_MAX 115200
102 /* Default baud rate: 57600, 115200, 230400 or 460800 */
103 #define DEFAULT_BAUD_RATE 115200
106 /* Transmit states */
107 #define XMIT_SENDING 1
108 #define XMIT_WAKEUP 2
109 #define XMIT_WAITING 8
111 /* Receiver states */
112 #define RECV_WAIT_PACKET_TYPE 0
113 #define RECV_WAIT_EVENT_HEADER 1
114 #define RECV_WAIT_ACL_HEADER 2
115 #define RECV_WAIT_SCO_HEADER 3
116 #define RECV_WAIT_DATA 4
120 /* ======================== Interrupt handling ======================== */
123 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
127 /* Tx FIFO should be empty */
128 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
131 /* Fill FIFO with current frame */
132 while ((fifo_size-- > 0) && (actual < len)) {
133 /* Transmit next byte */
134 outb(buf[actual], iobase + UART_TX);
142 static void btuart_write_wakeup(btuart_info_t *info)
145 BT_ERR("Unknown device");
149 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
150 set_bit(XMIT_WAKEUP, &(info->tx_state));
155 register unsigned int iobase = info->link.io.BasePort1;
156 register struct sk_buff *skb;
159 clear_bit(XMIT_WAKEUP, &(info->tx_state));
161 if (!(info->link.state & DEV_PRESENT))
164 if (!(skb = skb_dequeue(&(info->txq))))
168 len = btuart_write(iobase, 16, skb->data, skb->len);
169 set_bit(XMIT_WAKEUP, &(info->tx_state));
171 if (len == skb->len) {
175 skb_queue_head(&(info->txq), skb);
178 info->hdev->stat.byte_tx += len;
180 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
182 clear_bit(XMIT_SENDING, &(info->tx_state));
186 static void btuart_receive(btuart_info_t *info)
192 BT_ERR("Unknown device");
196 iobase = info->link.io.BasePort1;
199 info->hdev->stat.byte_rx++;
201 /* Allocate packet */
202 if (info->rx_skb == NULL) {
203 info->rx_state = RECV_WAIT_PACKET_TYPE;
205 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
206 BT_ERR("Can't allocate mem for new packet");
211 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
213 info->rx_skb->dev = (void *) info->hdev;
214 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
216 switch (bt_cb(info->rx_skb)->pkt_type) {
219 info->rx_state = RECV_WAIT_EVENT_HEADER;
220 info->rx_count = HCI_EVENT_HDR_SIZE;
223 case HCI_ACLDATA_PKT:
224 info->rx_state = RECV_WAIT_ACL_HEADER;
225 info->rx_count = HCI_ACL_HDR_SIZE;
228 case HCI_SCODATA_PKT:
229 info->rx_state = RECV_WAIT_SCO_HEADER;
230 info->rx_count = HCI_SCO_HDR_SIZE;
235 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
236 info->hdev->stat.err_rx++;
237 clear_bit(HCI_RUNNING, &(info->hdev->flags));
239 kfree_skb(info->rx_skb);
247 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
250 if (info->rx_count == 0) {
253 struct hci_event_hdr *eh;
254 struct hci_acl_hdr *ah;
255 struct hci_sco_hdr *sh;
258 switch (info->rx_state) {
260 case RECV_WAIT_EVENT_HEADER:
261 eh = (struct hci_event_hdr *)(info->rx_skb->data);
262 info->rx_state = RECV_WAIT_DATA;
263 info->rx_count = eh->plen;
266 case RECV_WAIT_ACL_HEADER:
267 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
268 dlen = __le16_to_cpu(ah->dlen);
269 info->rx_state = RECV_WAIT_DATA;
270 info->rx_count = dlen;
273 case RECV_WAIT_SCO_HEADER:
274 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
275 info->rx_state = RECV_WAIT_DATA;
276 info->rx_count = sh->dlen;
280 hci_recv_frame(info->rx_skb);
290 /* Make sure we don't stay here too long */
291 if (boguscount++ > 16)
294 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
298 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
300 btuart_info_t *info = dev_inst;
305 if (!info || !info->hdev) {
306 BT_ERR("Call of irq %d for unknown device", irq);
310 iobase = info->link.io.BasePort1;
312 spin_lock(&(info->lock));
314 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
317 /* Clear interrupt */
318 lsr = inb(iobase + UART_LSR);
325 /* Receive interrupt */
326 btuart_receive(info);
329 if (lsr & UART_LSR_THRE) {
330 /* Transmitter ready for data */
331 btuart_write_wakeup(info);
335 BT_ERR("Unhandled IIR=%#x", iir);
339 /* Make sure we don't stay here too long */
340 if (boguscount++ > 100)
343 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
347 spin_unlock(&(info->lock));
353 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
357 int fcr; /* FIFO control reg */
358 int lcr; /* Line control reg */
362 BT_ERR("Unknown device");
366 iobase = info->link.io.BasePort1;
368 spin_lock_irqsave(&(info->lock), flags);
370 /* Turn off interrupts */
371 outb(0, iobase + UART_IER);
373 divisor = SPEED_MAX / speed;
375 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
378 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
379 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
380 * about this timeout since it will always be fast enough.
384 fcr |= UART_FCR_TRIGGER_1;
386 fcr |= UART_FCR_TRIGGER_14;
388 /* Bluetooth cards use 8N1 */
389 lcr = UART_LCR_WLEN8;
391 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
392 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
393 outb(divisor >> 8, iobase + UART_DLM);
394 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
395 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
397 /* Turn on interrups */
398 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
400 spin_unlock_irqrestore(&(info->lock), flags);
405 /* ======================== HCI interface ======================== */
408 static int btuart_hci_flush(struct hci_dev *hdev)
410 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
413 skb_queue_purge(&(info->txq));
419 static int btuart_hci_open(struct hci_dev *hdev)
421 set_bit(HCI_RUNNING, &(hdev->flags));
427 static int btuart_hci_close(struct hci_dev *hdev)
429 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
432 btuart_hci_flush(hdev);
438 static int btuart_hci_send_frame(struct sk_buff *skb)
441 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
444 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
448 info = (btuart_info_t *)(hdev->driver_data);
450 switch (bt_cb(skb)->pkt_type) {
451 case HCI_COMMAND_PKT:
454 case HCI_ACLDATA_PKT:
457 case HCI_SCODATA_PKT:
462 /* Prepend skb with frame type */
463 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
464 skb_queue_tail(&(info->txq), skb);
466 btuart_write_wakeup(info);
472 static void btuart_hci_destruct(struct hci_dev *hdev)
477 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
484 /* ======================== Card services HCI interaction ======================== */
487 static int btuart_open(btuart_info_t *info)
490 unsigned int iobase = info->link.io.BasePort1;
491 struct hci_dev *hdev;
493 spin_lock_init(&(info->lock));
495 skb_queue_head_init(&(info->txq));
497 info->rx_state = RECV_WAIT_PACKET_TYPE;
501 /* Initialize HCI device */
502 hdev = hci_alloc_dev();
504 BT_ERR("Can't allocate HCI device");
510 hdev->type = HCI_PCCARD;
511 hdev->driver_data = info;
513 hdev->open = btuart_hci_open;
514 hdev->close = btuart_hci_close;
515 hdev->flush = btuart_hci_flush;
516 hdev->send = btuart_hci_send_frame;
517 hdev->destruct = btuart_hci_destruct;
518 hdev->ioctl = btuart_hci_ioctl;
520 hdev->owner = THIS_MODULE;
522 spin_lock_irqsave(&(info->lock), flags);
525 outb(0, iobase + UART_MCR);
527 /* Turn off interrupts */
528 outb(0, iobase + UART_IER);
530 /* Initialize UART */
531 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
532 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
534 /* Turn on interrupts */
535 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
537 spin_unlock_irqrestore(&(info->lock), flags);
539 btuart_change_speed(info, DEFAULT_BAUD_RATE);
541 /* Timeout before it is safe to send the first HCI packet */
544 /* Register HCI device */
545 if (hci_register_dev(hdev) < 0) {
546 BT_ERR("Can't register HCI device");
556 static int btuart_close(btuart_info_t *info)
559 unsigned int iobase = info->link.io.BasePort1;
560 struct hci_dev *hdev = info->hdev;
565 btuart_hci_close(hdev);
567 spin_lock_irqsave(&(info->lock), flags);
570 outb(0, iobase + UART_MCR);
572 /* Turn off interrupts */
573 outb(0, iobase + UART_IER);
575 spin_unlock_irqrestore(&(info->lock), flags);
577 if (hci_unregister_dev(hdev) < 0)
578 BT_ERR("Can't unregister HCI device %s", hdev->name);
585 static dev_link_t *btuart_attach(void)
588 client_reg_t client_reg;
592 /* Create new info device */
593 info = kzalloc(sizeof(*info), GFP_KERNEL);
600 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
601 link->io.NumPorts1 = 8;
602 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
603 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
605 link->irq.Handler = btuart_interrupt;
606 link->irq.Instance = info;
608 link->conf.Attributes = CONF_ENABLE_IRQ;
610 link->conf.IntType = INT_MEMORY_AND_IO;
612 /* Register with Card Services */
613 link->next = dev_list;
615 client_reg.dev_info = &dev_info;
616 client_reg.Version = 0x0210;
617 client_reg.event_callback_args.client_data = link;
619 ret = pcmcia_register_client(&link->handle, &client_reg);
620 if (ret != CS_SUCCESS) {
621 cs_error(link->handle, RegisterClient, ret);
622 btuart_detach(link->handle);
630 static void btuart_detach(struct pcmcia_device *p_dev)
632 dev_link_t *link = dev_to_instance(p_dev);
633 btuart_info_t *info = link->priv;
636 /* Locate device structure */
637 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
644 if (link->state & DEV_CONFIG)
645 btuart_release(link);
647 /* Unlink device structure, free bits */
653 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
657 i = pcmcia_get_tuple_data(handle, tuple);
661 return pcmcia_parse_tuple(handle, tuple, parse);
664 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
666 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
667 return CS_NO_MORE_ITEMS;
668 return get_tuple(handle, tuple, parse);
671 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
673 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
674 return CS_NO_MORE_ITEMS;
675 return get_tuple(handle, tuple, parse);
678 static void btuart_config(dev_link_t *link)
680 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
681 client_handle_t handle = link->handle;
682 btuart_info_t *info = link->priv;
686 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
687 config_info_t config;
688 int i, j, try, last_ret, last_fn;
690 tuple.TupleData = (cisdata_t *)buf;
691 tuple.TupleOffset = 0;
692 tuple.TupleDataMax = 255;
693 tuple.Attributes = 0;
695 /* Get configuration register information */
696 tuple.DesiredTuple = CISTPL_CONFIG;
697 last_ret = first_tuple(handle, &tuple, &parse);
698 if (last_ret != CS_SUCCESS) {
699 last_fn = ParseTuple;
702 link->conf.ConfigBase = parse.config.base;
703 link->conf.Present = parse.config.rmask[0];
706 link->state |= DEV_CONFIG;
707 i = pcmcia_get_configuration_info(handle, &config);
708 link->conf.Vcc = config.Vcc;
710 /* First pass: look for a config entry that looks normal. */
711 tuple.TupleData = (cisdata_t *) buf;
712 tuple.TupleOffset = 0;
713 tuple.TupleDataMax = 255;
714 tuple.Attributes = 0;
715 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
716 /* Two tries: without IO aliases, then with aliases */
717 for (try = 0; try < 2; try++) {
718 i = first_tuple(handle, &tuple, &parse);
719 while (i != CS_NO_MORE_ITEMS) {
722 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
723 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
724 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
725 link->conf.ConfigIndex = cf->index;
726 link->io.BasePort1 = cf->io.win[0].base;
727 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
728 i = pcmcia_request_io(link->handle, &link->io);
733 i = next_tuple(handle, &tuple, &parse);
737 /* Second pass: try to find an entry that isn't picky about
738 its base address, then try to grab any standard serial port
739 address, and finally try to get any free port. */
740 i = first_tuple(handle, &tuple, &parse);
741 while (i != CS_NO_MORE_ITEMS) {
742 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
743 && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
744 link->conf.ConfigIndex = cf->index;
745 for (j = 0; j < 5; j++) {
746 link->io.BasePort1 = base[j];
747 link->io.IOAddrLines = base[j] ? 16 : 3;
748 i = pcmcia_request_io(link->handle, &link->io);
753 i = next_tuple(handle, &tuple, &parse);
757 if (i != CS_SUCCESS) {
758 BT_ERR("No usable port range found");
759 cs_error(link->handle, RequestIO, i);
763 i = pcmcia_request_irq(link->handle, &link->irq);
764 if (i != CS_SUCCESS) {
765 cs_error(link->handle, RequestIRQ, i);
766 link->irq.AssignedIRQ = 0;
769 i = pcmcia_request_configuration(link->handle, &link->conf);
770 if (i != CS_SUCCESS) {
771 cs_error(link->handle, RequestConfiguration, i);
775 if (btuart_open(info) != 0)
778 strcpy(info->node.dev_name, info->hdev->name);
779 link->dev = &info->node;
780 link->state &= ~DEV_CONFIG_PENDING;
785 cs_error(link->handle, last_fn, last_ret);
788 btuart_release(link);
792 static void btuart_release(dev_link_t *link)
794 btuart_info_t *info = link->priv;
796 if (link->state & DEV_PRESENT)
801 pcmcia_release_configuration(link->handle);
802 pcmcia_release_io(link->handle, &link->io);
803 pcmcia_release_irq(link->handle, &link->irq);
805 link->state &= ~DEV_CONFIG;
808 static int btuart_suspend(struct pcmcia_device *dev)
810 dev_link_t *link = dev_to_instance(dev);
812 link->state |= DEV_SUSPEND;
813 if (link->state & DEV_CONFIG)
814 pcmcia_release_configuration(link->handle);
819 static int btuart_resume(struct pcmcia_device *dev)
821 dev_link_t *link = dev_to_instance(dev);
823 link->state &= ~DEV_SUSPEND;
825 pcmcia_request_configuration(link->handle, &link->conf);
831 static int btuart_event(event_t event, int priority, event_callback_args_t *args)
833 dev_link_t *link = args->client_data;
836 case CS_EVENT_CARD_INSERTION:
837 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
845 static struct pcmcia_device_id btuart_ids[] = {
846 /* don't use this driver. Use serial_cs + hci_uart instead */
849 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
851 static struct pcmcia_driver btuart_driver = {
852 .owner = THIS_MODULE,
856 .attach = btuart_attach,
857 .event = btuart_event,
858 .remove = btuart_detach,
859 .id_table = btuart_ids,
860 .suspend = btuart_suspend,
861 .resume = btuart_resume,
864 static int __init init_btuart_cs(void)
866 return pcmcia_register_driver(&btuart_driver);
870 static void __exit exit_btuart_cs(void)
872 pcmcia_unregister_driver(&btuart_driver);
873 BUG_ON(dev_list != NULL);
876 module_init(init_btuart_cs);
877 module_exit(exit_btuart_cs);