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/version.h>
47 #include <pcmcia/cs_types.h>
48 #include <pcmcia/cs.h>
49 #include <pcmcia/cistpl.h>
50 #include <pcmcia/ciscode.h>
51 #include <pcmcia/ds.h>
52 #include <pcmcia/cisreg.h>
54 #include <net/bluetooth/bluetooth.h>
55 #include <net/bluetooth/hci_core.h>
59 /* ======================== Module parameters ======================== */
62 /* Bit map of interrupts to choose from */
63 static unsigned int irq_mask = 0xffff;
64 static int irq_list[4] = { -1 };
66 module_param(irq_mask, uint, 0);
67 module_param_array(irq_list, int, NULL, 0);
69 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
70 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
71 MODULE_LICENSE("GPL");
75 /* ======================== Local structures ======================== */
78 typedef struct btuart_info_t {
84 spinlock_t lock; /* For serializing operations */
86 struct sk_buff_head txq;
87 unsigned long tx_state;
89 unsigned long rx_state;
90 unsigned long rx_count;
91 struct sk_buff *rx_skb;
95 static void btuart_config(dev_link_t *link);
96 static void btuart_release(dev_link_t *link);
97 static int btuart_event(event_t event, int priority, event_callback_args_t *args);
99 static dev_info_t dev_info = "btuart_cs";
101 static dev_link_t *btuart_attach(void);
102 static void btuart_detach(dev_link_t *);
104 static dev_link_t *dev_list = NULL;
107 /* Maximum baud rate */
108 #define SPEED_MAX 115200
110 /* Default baud rate: 57600, 115200, 230400 or 460800 */
111 #define DEFAULT_BAUD_RATE 115200
114 /* Transmit states */
115 #define XMIT_SENDING 1
116 #define XMIT_WAKEUP 2
117 #define XMIT_WAITING 8
119 /* Receiver states */
120 #define RECV_WAIT_PACKET_TYPE 0
121 #define RECV_WAIT_EVENT_HEADER 1
122 #define RECV_WAIT_ACL_HEADER 2
123 #define RECV_WAIT_SCO_HEADER 3
124 #define RECV_WAIT_DATA 4
128 /* ======================== Interrupt handling ======================== */
131 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
135 /* Tx FIFO should be empty */
136 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
139 /* Fill FIFO with current frame */
140 while ((fifo_size-- > 0) && (actual < len)) {
141 /* Transmit next byte */
142 outb(buf[actual], iobase + UART_TX);
150 static void btuart_write_wakeup(btuart_info_t *info)
153 BT_ERR("Unknown device");
157 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
158 set_bit(XMIT_WAKEUP, &(info->tx_state));
163 register unsigned int iobase = info->link.io.BasePort1;
164 register struct sk_buff *skb;
167 clear_bit(XMIT_WAKEUP, &(info->tx_state));
169 if (!(info->link.state & DEV_PRESENT))
172 if (!(skb = skb_dequeue(&(info->txq))))
176 len = btuart_write(iobase, 16, skb->data, skb->len);
177 set_bit(XMIT_WAKEUP, &(info->tx_state));
179 if (len == skb->len) {
183 skb_queue_head(&(info->txq), skb);
186 info->hdev->stat.byte_tx += len;
188 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
190 clear_bit(XMIT_SENDING, &(info->tx_state));
194 static void btuart_receive(btuart_info_t *info)
200 BT_ERR("Unknown device");
204 iobase = info->link.io.BasePort1;
207 info->hdev->stat.byte_rx++;
209 /* Allocate packet */
210 if (info->rx_skb == NULL) {
211 info->rx_state = RECV_WAIT_PACKET_TYPE;
213 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
214 BT_ERR("Can't allocate mem for new packet");
219 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
221 info->rx_skb->dev = (void *) info->hdev;
222 info->rx_skb->pkt_type = inb(iobase + UART_RX);
224 switch (info->rx_skb->pkt_type) {
227 info->rx_state = RECV_WAIT_EVENT_HEADER;
228 info->rx_count = HCI_EVENT_HDR_SIZE;
231 case HCI_ACLDATA_PKT:
232 info->rx_state = RECV_WAIT_ACL_HEADER;
233 info->rx_count = HCI_ACL_HDR_SIZE;
236 case HCI_SCODATA_PKT:
237 info->rx_state = RECV_WAIT_SCO_HEADER;
238 info->rx_count = HCI_SCO_HDR_SIZE;
243 BT_ERR("Unknown HCI packet with type 0x%02x received", info->rx_skb->pkt_type);
244 info->hdev->stat.err_rx++;
245 clear_bit(HCI_RUNNING, &(info->hdev->flags));
247 kfree_skb(info->rx_skb);
255 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
258 if (info->rx_count == 0) {
261 struct hci_event_hdr *eh;
262 struct hci_acl_hdr *ah;
263 struct hci_sco_hdr *sh;
266 switch (info->rx_state) {
268 case RECV_WAIT_EVENT_HEADER:
269 eh = (struct hci_event_hdr *)(info->rx_skb->data);
270 info->rx_state = RECV_WAIT_DATA;
271 info->rx_count = eh->plen;
274 case RECV_WAIT_ACL_HEADER:
275 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
276 dlen = __le16_to_cpu(ah->dlen);
277 info->rx_state = RECV_WAIT_DATA;
278 info->rx_count = dlen;
281 case RECV_WAIT_SCO_HEADER:
282 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
283 info->rx_state = RECV_WAIT_DATA;
284 info->rx_count = sh->dlen;
288 hci_recv_frame(info->rx_skb);
298 /* Make sure we don't stay here too long */
299 if (boguscount++ > 16)
302 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
306 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
308 btuart_info_t *info = dev_inst;
313 if (!info || !info->hdev) {
314 BT_ERR("Call of irq %d for unknown device", irq);
318 iobase = info->link.io.BasePort1;
320 spin_lock(&(info->lock));
322 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
325 /* Clear interrupt */
326 lsr = inb(iobase + UART_LSR);
333 /* Receive interrupt */
334 btuart_receive(info);
337 if (lsr & UART_LSR_THRE) {
338 /* Transmitter ready for data */
339 btuart_write_wakeup(info);
343 BT_ERR("Unhandled IIR=%#x", iir);
347 /* Make sure we don't stay here too long */
348 if (boguscount++ > 100)
351 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
355 spin_unlock(&(info->lock));
361 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
365 int fcr; /* FIFO control reg */
366 int lcr; /* Line control reg */
370 BT_ERR("Unknown device");
374 iobase = info->link.io.BasePort1;
376 spin_lock_irqsave(&(info->lock), flags);
378 /* Turn off interrupts */
379 outb(0, iobase + UART_IER);
381 divisor = SPEED_MAX / speed;
383 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
386 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
387 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
388 * about this timeout since it will always be fast enough.
392 fcr |= UART_FCR_TRIGGER_1;
394 fcr |= UART_FCR_TRIGGER_14;
396 /* Bluetooth cards use 8N1 */
397 lcr = UART_LCR_WLEN8;
399 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
400 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
401 outb(divisor >> 8, iobase + UART_DLM);
402 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
403 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
405 /* Turn on interrups */
406 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
408 spin_unlock_irqrestore(&(info->lock), flags);
413 /* ======================== HCI interface ======================== */
416 static int btuart_hci_flush(struct hci_dev *hdev)
418 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
421 skb_queue_purge(&(info->txq));
427 static int btuart_hci_open(struct hci_dev *hdev)
429 set_bit(HCI_RUNNING, &(hdev->flags));
435 static int btuart_hci_close(struct hci_dev *hdev)
437 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
440 btuart_hci_flush(hdev);
446 static int btuart_hci_send_frame(struct sk_buff *skb)
449 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
452 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
456 info = (btuart_info_t *)(hdev->driver_data);
458 switch (skb->pkt_type) {
459 case HCI_COMMAND_PKT:
462 case HCI_ACLDATA_PKT:
465 case HCI_SCODATA_PKT:
470 /* Prepend skb with frame type */
471 memcpy(skb_push(skb, 1), &(skb->pkt_type), 1);
472 skb_queue_tail(&(info->txq), skb);
474 btuart_write_wakeup(info);
480 static void btuart_hci_destruct(struct hci_dev *hdev)
485 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
492 /* ======================== Card services HCI interaction ======================== */
495 static int btuart_open(btuart_info_t *info)
498 unsigned int iobase = info->link.io.BasePort1;
499 struct hci_dev *hdev;
501 spin_lock_init(&(info->lock));
503 skb_queue_head_init(&(info->txq));
505 info->rx_state = RECV_WAIT_PACKET_TYPE;
509 /* Initialize HCI device */
510 hdev = hci_alloc_dev();
512 BT_ERR("Can't allocate HCI device");
518 hdev->type = HCI_PCCARD;
519 hdev->driver_data = info;
521 hdev->open = btuart_hci_open;
522 hdev->close = btuart_hci_close;
523 hdev->flush = btuart_hci_flush;
524 hdev->send = btuart_hci_send_frame;
525 hdev->destruct = btuart_hci_destruct;
526 hdev->ioctl = btuart_hci_ioctl;
528 hdev->owner = THIS_MODULE;
530 spin_lock_irqsave(&(info->lock), flags);
533 outb(0, iobase + UART_MCR);
535 /* Turn off interrupts */
536 outb(0, iobase + UART_IER);
538 /* Initialize UART */
539 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
540 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
542 /* Turn on interrupts */
543 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
545 spin_unlock_irqrestore(&(info->lock), flags);
547 btuart_change_speed(info, DEFAULT_BAUD_RATE);
549 /* Timeout before it is safe to send the first HCI packet */
552 /* Register HCI device */
553 if (hci_register_dev(hdev) < 0) {
554 BT_ERR("Can't register HCI device");
564 static int btuart_close(btuart_info_t *info)
567 unsigned int iobase = info->link.io.BasePort1;
568 struct hci_dev *hdev = info->hdev;
573 btuart_hci_close(hdev);
575 spin_lock_irqsave(&(info->lock), flags);
578 outb(0, iobase + UART_MCR);
580 /* Turn off interrupts */
581 outb(0, iobase + UART_IER);
583 spin_unlock_irqrestore(&(info->lock), flags);
585 if (hci_unregister_dev(hdev) < 0)
586 BT_ERR("Can't unregister HCI device %s", hdev->name);
593 static dev_link_t *btuart_attach(void)
596 client_reg_t client_reg;
600 /* Create new info device */
601 info = kmalloc(sizeof(*info), GFP_KERNEL);
604 memset(info, 0, sizeof(*info));
609 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
610 link->io.NumPorts1 = 8;
611 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
612 link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_LEVEL_ID;
614 if (irq_list[0] == -1)
615 link->irq.IRQInfo2 = irq_mask;
617 for (i = 0; i < 4; i++)
618 link->irq.IRQInfo2 |= 1 << irq_list[i];
620 link->irq.Handler = btuart_interrupt;
621 link->irq.Instance = info;
623 link->conf.Attributes = CONF_ENABLE_IRQ;
625 link->conf.IntType = INT_MEMORY_AND_IO;
627 /* Register with Card Services */
628 link->next = dev_list;
630 client_reg.dev_info = &dev_info;
631 client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
632 client_reg.EventMask =
633 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
634 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
635 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
636 client_reg.event_handler = &btuart_event;
637 client_reg.Version = 0x0210;
638 client_reg.event_callback_args.client_data = link;
640 ret = pcmcia_register_client(&link->handle, &client_reg);
641 if (ret != CS_SUCCESS) {
642 cs_error(link->handle, RegisterClient, ret);
651 static void btuart_detach(dev_link_t *link)
653 btuart_info_t *info = link->priv;
657 /* Locate device structure */
658 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
665 if (link->state & DEV_CONFIG)
666 btuart_release(link);
669 ret = pcmcia_deregister_client(link->handle);
670 if (ret != CS_SUCCESS)
671 cs_error(link->handle, DeregisterClient, ret);
674 /* Unlink device structure, free bits */
680 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
684 i = pcmcia_get_tuple_data(handle, tuple);
688 return pcmcia_parse_tuple(handle, tuple, parse);
691 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
693 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
694 return CS_NO_MORE_ITEMS;
695 return get_tuple(handle, tuple, parse);
698 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
700 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
701 return CS_NO_MORE_ITEMS;
702 return get_tuple(handle, tuple, parse);
705 static void btuart_config(dev_link_t *link)
707 static ioaddr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
708 client_handle_t handle = link->handle;
709 btuart_info_t *info = link->priv;
713 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
714 config_info_t config;
715 int i, j, try, last_ret, last_fn;
717 tuple.TupleData = (cisdata_t *)buf;
718 tuple.TupleOffset = 0;
719 tuple.TupleDataMax = 255;
720 tuple.Attributes = 0;
722 /* Get configuration register information */
723 tuple.DesiredTuple = CISTPL_CONFIG;
724 last_ret = first_tuple(handle, &tuple, &parse);
725 if (last_ret != CS_SUCCESS) {
726 last_fn = ParseTuple;
729 link->conf.ConfigBase = parse.config.base;
730 link->conf.Present = parse.config.rmask[0];
733 link->state |= DEV_CONFIG;
734 i = pcmcia_get_configuration_info(handle, &config);
735 link->conf.Vcc = config.Vcc;
737 /* First pass: look for a config entry that looks normal. */
738 tuple.TupleData = (cisdata_t *) buf;
739 tuple.TupleOffset = 0;
740 tuple.TupleDataMax = 255;
741 tuple.Attributes = 0;
742 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
743 /* Two tries: without IO aliases, then with aliases */
744 for (try = 0; try < 2; try++) {
745 i = first_tuple(handle, &tuple, &parse);
746 while (i != CS_NO_MORE_ITEMS) {
749 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
750 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
751 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
752 link->conf.ConfigIndex = cf->index;
753 link->io.BasePort1 = cf->io.win[0].base;
754 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
755 i = pcmcia_request_io(link->handle, &link->io);
760 i = next_tuple(handle, &tuple, &parse);
764 /* Second pass: try to find an entry that isn't picky about
765 its base address, then try to grab any standard serial port
766 address, and finally try to get any free port. */
767 i = first_tuple(handle, &tuple, &parse);
768 while (i != CS_NO_MORE_ITEMS) {
769 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
770 && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
771 link->conf.ConfigIndex = cf->index;
772 for (j = 0; j < 5; j++) {
773 link->io.BasePort1 = base[j];
774 link->io.IOAddrLines = base[j] ? 16 : 3;
775 i = pcmcia_request_io(link->handle, &link->io);
780 i = next_tuple(handle, &tuple, &parse);
784 if (i != CS_SUCCESS) {
785 BT_ERR("No usable port range found");
786 cs_error(link->handle, RequestIO, i);
790 i = pcmcia_request_irq(link->handle, &link->irq);
791 if (i != CS_SUCCESS) {
792 cs_error(link->handle, RequestIRQ, i);
793 link->irq.AssignedIRQ = 0;
796 i = pcmcia_request_configuration(link->handle, &link->conf);
797 if (i != CS_SUCCESS) {
798 cs_error(link->handle, RequestConfiguration, i);
802 if (btuart_open(info) != 0)
805 strcpy(info->node.dev_name, info->hdev->name);
806 link->dev = &info->node;
807 link->state &= ~DEV_CONFIG_PENDING;
812 cs_error(link->handle, last_fn, last_ret);
815 btuart_release(link);
819 static void btuart_release(dev_link_t *link)
821 btuart_info_t *info = link->priv;
823 if (link->state & DEV_PRESENT)
828 pcmcia_release_configuration(link->handle);
829 pcmcia_release_io(link->handle, &link->io);
830 pcmcia_release_irq(link->handle, &link->irq);
832 link->state &= ~DEV_CONFIG;
836 static int btuart_event(event_t event, int priority, event_callback_args_t *args)
838 dev_link_t *link = args->client_data;
839 btuart_info_t *info = link->priv;
842 case CS_EVENT_CARD_REMOVAL:
843 link->state &= ~DEV_PRESENT;
844 if (link->state & DEV_CONFIG) {
846 btuart_release(link);
849 case CS_EVENT_CARD_INSERTION:
850 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
853 case CS_EVENT_PM_SUSPEND:
854 link->state |= DEV_SUSPEND;
855 /* Fall through... */
856 case CS_EVENT_RESET_PHYSICAL:
857 if (link->state & DEV_CONFIG)
858 pcmcia_release_configuration(link->handle);
860 case CS_EVENT_PM_RESUME:
861 link->state &= ~DEV_SUSPEND;
862 /* Fall through... */
863 case CS_EVENT_CARD_RESET:
865 pcmcia_request_configuration(link->handle, &link->conf);
872 static struct pcmcia_driver btuart_driver = {
873 .owner = THIS_MODULE,
877 .attach = btuart_attach,
878 .detach = btuart_detach,
881 static int __init init_btuart_cs(void)
883 return pcmcia_register_driver(&btuart_driver);
887 static void __exit exit_btuart_cs(void)
889 pcmcia_unregister_driver(&btuart_driver);
891 /* XXX: this really needs to move into generic code.. */
892 while (dev_list != NULL)
893 btuart_detach(dev_list);
896 module_init(init_btuart_cs);
897 module_exit(exit_btuart_cs);