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/module.h>
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>
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>
44 #include <pcmcia/cs.h>
45 #include <pcmcia/cistpl.h>
46 #include <pcmcia/ciscode.h>
47 #include <pcmcia/ds.h>
48 #include <pcmcia/cisreg.h>
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
55 /* ======================== Module parameters ======================== */
58 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
59 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
60 MODULE_LICENSE("GPL");
64 /* ======================== Local structures ======================== */
67 typedef struct btuart_info_t
{
68 struct pcmcia_device
*p_dev
;
72 spinlock_t lock
; /* For serializing operations */
74 struct sk_buff_head txq
;
75 unsigned long tx_state
;
77 unsigned long rx_state
;
78 unsigned long rx_count
;
79 struct sk_buff
*rx_skb
;
83 static int btuart_config(struct pcmcia_device
*link
);
84 static void btuart_release(struct pcmcia_device
*link
);
86 static void btuart_detach(struct pcmcia_device
*p_dev
);
89 /* Maximum baud rate */
90 #define SPEED_MAX 115200
92 /* Default baud rate: 57600, 115200, 230400 or 460800 */
93 #define DEFAULT_BAUD_RATE 115200
97 #define XMIT_SENDING 1
99 #define XMIT_WAITING 8
101 /* Receiver states */
102 #define RECV_WAIT_PACKET_TYPE 0
103 #define RECV_WAIT_EVENT_HEADER 1
104 #define RECV_WAIT_ACL_HEADER 2
105 #define RECV_WAIT_SCO_HEADER 3
106 #define RECV_WAIT_DATA 4
110 /* ======================== Interrupt handling ======================== */
113 static int btuart_write(unsigned int iobase
, int fifo_size
, __u8
*buf
, int len
)
117 /* Tx FIFO should be empty */
118 if (!(inb(iobase
+ UART_LSR
) & UART_LSR_THRE
))
121 /* Fill FIFO with current frame */
122 while ((fifo_size
-- > 0) && (actual
< len
)) {
123 /* Transmit next byte */
124 outb(buf
[actual
], iobase
+ UART_TX
);
132 static void btuart_write_wakeup(btuart_info_t
*info
)
135 BT_ERR("Unknown device");
139 if (test_and_set_bit(XMIT_SENDING
, &(info
->tx_state
))) {
140 set_bit(XMIT_WAKEUP
, &(info
->tx_state
));
145 register unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
146 register struct sk_buff
*skb
;
149 clear_bit(XMIT_WAKEUP
, &(info
->tx_state
));
151 if (!pcmcia_dev_present(info
->p_dev
))
154 if (!(skb
= skb_dequeue(&(info
->txq
))))
158 len
= btuart_write(iobase
, 16, skb
->data
, skb
->len
);
159 set_bit(XMIT_WAKEUP
, &(info
->tx_state
));
161 if (len
== skb
->len
) {
165 skb_queue_head(&(info
->txq
), skb
);
168 info
->hdev
->stat
.byte_tx
+= len
;
170 } while (test_bit(XMIT_WAKEUP
, &(info
->tx_state
)));
172 clear_bit(XMIT_SENDING
, &(info
->tx_state
));
176 static void btuart_receive(btuart_info_t
*info
)
182 BT_ERR("Unknown device");
186 iobase
= info
->p_dev
->resource
[0]->start
;
189 info
->hdev
->stat
.byte_rx
++;
191 /* Allocate packet */
192 if (info
->rx_skb
== NULL
) {
193 info
->rx_state
= RECV_WAIT_PACKET_TYPE
;
195 if (!(info
->rx_skb
= bt_skb_alloc(HCI_MAX_FRAME_SIZE
, GFP_ATOMIC
))) {
196 BT_ERR("Can't allocate mem for new packet");
201 if (info
->rx_state
== RECV_WAIT_PACKET_TYPE
) {
203 info
->rx_skb
->dev
= (void *) info
->hdev
;
204 bt_cb(info
->rx_skb
)->pkt_type
= inb(iobase
+ UART_RX
);
206 switch (bt_cb(info
->rx_skb
)->pkt_type
) {
209 info
->rx_state
= RECV_WAIT_EVENT_HEADER
;
210 info
->rx_count
= HCI_EVENT_HDR_SIZE
;
213 case HCI_ACLDATA_PKT
:
214 info
->rx_state
= RECV_WAIT_ACL_HEADER
;
215 info
->rx_count
= HCI_ACL_HDR_SIZE
;
218 case HCI_SCODATA_PKT
:
219 info
->rx_state
= RECV_WAIT_SCO_HEADER
;
220 info
->rx_count
= HCI_SCO_HDR_SIZE
;
225 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info
->rx_skb
)->pkt_type
);
226 info
->hdev
->stat
.err_rx
++;
227 clear_bit(HCI_RUNNING
, &(info
->hdev
->flags
));
229 kfree_skb(info
->rx_skb
);
237 *skb_put(info
->rx_skb
, 1) = inb(iobase
+ UART_RX
);
240 if (info
->rx_count
== 0) {
243 struct hci_event_hdr
*eh
;
244 struct hci_acl_hdr
*ah
;
245 struct hci_sco_hdr
*sh
;
248 switch (info
->rx_state
) {
250 case RECV_WAIT_EVENT_HEADER
:
251 eh
= hci_event_hdr(info
->rx_skb
);
252 info
->rx_state
= RECV_WAIT_DATA
;
253 info
->rx_count
= eh
->plen
;
256 case RECV_WAIT_ACL_HEADER
:
257 ah
= hci_acl_hdr(info
->rx_skb
);
258 dlen
= __le16_to_cpu(ah
->dlen
);
259 info
->rx_state
= RECV_WAIT_DATA
;
260 info
->rx_count
= dlen
;
263 case RECV_WAIT_SCO_HEADER
:
264 sh
= hci_sco_hdr(info
->rx_skb
);
265 info
->rx_state
= RECV_WAIT_DATA
;
266 info
->rx_count
= sh
->dlen
;
270 hci_recv_frame(info
->rx_skb
);
280 /* Make sure we don't stay here too long */
281 if (boguscount
++ > 16)
284 } while (inb(iobase
+ UART_LSR
) & UART_LSR_DR
);
288 static irqreturn_t
btuart_interrupt(int irq
, void *dev_inst
)
290 btuart_info_t
*info
= dev_inst
;
294 irqreturn_t r
= IRQ_NONE
;
296 if (!info
|| !info
->hdev
)
297 /* our irq handler is shared */
300 iobase
= info
->p_dev
->resource
[0]->start
;
302 spin_lock(&(info
->lock
));
304 iir
= inb(iobase
+ UART_IIR
) & UART_IIR_ID
;
308 /* Clear interrupt */
309 lsr
= inb(iobase
+ UART_LSR
);
316 /* Receive interrupt */
317 btuart_receive(info
);
320 if (lsr
& UART_LSR_THRE
) {
321 /* Transmitter ready for data */
322 btuart_write_wakeup(info
);
326 BT_ERR("Unhandled IIR=%#x", iir
);
330 /* Make sure we don't stay here too long */
331 if (boguscount
++ > 100)
334 iir
= inb(iobase
+ UART_IIR
) & UART_IIR_ID
;
338 spin_unlock(&(info
->lock
));
344 static void btuart_change_speed(btuart_info_t
*info
, unsigned int speed
)
348 int fcr
; /* FIFO control reg */
349 int lcr
; /* Line control reg */
353 BT_ERR("Unknown device");
357 iobase
= info
->p_dev
->resource
[0]->start
;
359 spin_lock_irqsave(&(info
->lock
), flags
);
361 /* Turn off interrupts */
362 outb(0, iobase
+ UART_IER
);
364 divisor
= SPEED_MAX
/ speed
;
366 fcr
= UART_FCR_ENABLE_FIFO
| UART_FCR_CLEAR_RCVR
| UART_FCR_CLEAR_XMIT
;
369 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
370 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
371 * about this timeout since it will always be fast enough.
375 fcr
|= UART_FCR_TRIGGER_1
;
377 fcr
|= UART_FCR_TRIGGER_14
;
379 /* Bluetooth cards use 8N1 */
380 lcr
= UART_LCR_WLEN8
;
382 outb(UART_LCR_DLAB
| lcr
, iobase
+ UART_LCR
); /* Set DLAB */
383 outb(divisor
& 0xff, iobase
+ UART_DLL
); /* Set speed */
384 outb(divisor
>> 8, iobase
+ UART_DLM
);
385 outb(lcr
, iobase
+ UART_LCR
); /* Set 8N1 */
386 outb(fcr
, iobase
+ UART_FCR
); /* Enable FIFO's */
388 /* Turn on interrupts */
389 outb(UART_IER_RLSI
| UART_IER_RDI
| UART_IER_THRI
, iobase
+ UART_IER
);
391 spin_unlock_irqrestore(&(info
->lock
), flags
);
396 /* ======================== HCI interface ======================== */
399 static int btuart_hci_flush(struct hci_dev
*hdev
)
401 btuart_info_t
*info
= (btuart_info_t
*)(hdev
->driver_data
);
404 skb_queue_purge(&(info
->txq
));
410 static int btuart_hci_open(struct hci_dev
*hdev
)
412 set_bit(HCI_RUNNING
, &(hdev
->flags
));
418 static int btuart_hci_close(struct hci_dev
*hdev
)
420 if (!test_and_clear_bit(HCI_RUNNING
, &(hdev
->flags
)))
423 btuart_hci_flush(hdev
);
429 static int btuart_hci_send_frame(struct sk_buff
*skb
)
432 struct hci_dev
*hdev
= (struct hci_dev
*)(skb
->dev
);
435 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
439 info
= (btuart_info_t
*)(hdev
->driver_data
);
441 switch (bt_cb(skb
)->pkt_type
) {
442 case HCI_COMMAND_PKT
:
445 case HCI_ACLDATA_PKT
:
448 case HCI_SCODATA_PKT
:
453 /* Prepend skb with frame type */
454 memcpy(skb_push(skb
, 1), &bt_cb(skb
)->pkt_type
, 1);
455 skb_queue_tail(&(info
->txq
), skb
);
457 btuart_write_wakeup(info
);
463 static void btuart_hci_destruct(struct hci_dev
*hdev
)
468 static int btuart_hci_ioctl(struct hci_dev
*hdev
, unsigned int cmd
, unsigned long arg
)
475 /* ======================== Card services HCI interaction ======================== */
478 static int btuart_open(btuart_info_t
*info
)
481 unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
482 struct hci_dev
*hdev
;
484 spin_lock_init(&(info
->lock
));
486 skb_queue_head_init(&(info
->txq
));
488 info
->rx_state
= RECV_WAIT_PACKET_TYPE
;
492 /* Initialize HCI device */
493 hdev
= hci_alloc_dev();
495 BT_ERR("Can't allocate HCI device");
501 hdev
->bus
= HCI_PCCARD
;
502 hdev
->driver_data
= info
;
503 SET_HCIDEV_DEV(hdev
, &info
->p_dev
->dev
);
505 hdev
->open
= btuart_hci_open
;
506 hdev
->close
= btuart_hci_close
;
507 hdev
->flush
= btuart_hci_flush
;
508 hdev
->send
= btuart_hci_send_frame
;
509 hdev
->destruct
= btuart_hci_destruct
;
510 hdev
->ioctl
= btuart_hci_ioctl
;
512 hdev
->owner
= THIS_MODULE
;
514 spin_lock_irqsave(&(info
->lock
), flags
);
517 outb(0, iobase
+ UART_MCR
);
519 /* Turn off interrupts */
520 outb(0, iobase
+ UART_IER
);
522 /* Initialize UART */
523 outb(UART_LCR_WLEN8
, iobase
+ UART_LCR
); /* Reset DLAB */
524 outb((UART_MCR_DTR
| UART_MCR_RTS
| UART_MCR_OUT2
), iobase
+ UART_MCR
);
526 /* Turn on interrupts */
527 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
529 spin_unlock_irqrestore(&(info
->lock
), flags
);
531 btuart_change_speed(info
, DEFAULT_BAUD_RATE
);
533 /* Timeout before it is safe to send the first HCI packet */
536 /* Register HCI device */
537 if (hci_register_dev(hdev
) < 0) {
538 BT_ERR("Can't register HCI device");
548 static int btuart_close(btuart_info_t
*info
)
551 unsigned int iobase
= info
->p_dev
->resource
[0]->start
;
552 struct hci_dev
*hdev
= info
->hdev
;
557 btuart_hci_close(hdev
);
559 spin_lock_irqsave(&(info
->lock
), flags
);
562 outb(0, iobase
+ UART_MCR
);
564 /* Turn off interrupts */
565 outb(0, iobase
+ UART_IER
);
567 spin_unlock_irqrestore(&(info
->lock
), flags
);
569 if (hci_unregister_dev(hdev
) < 0)
570 BT_ERR("Can't unregister HCI device %s", hdev
->name
);
577 static int btuart_probe(struct pcmcia_device
*link
)
581 /* Create new info device */
582 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
589 link
->resource
[0]->flags
|= IO_DATA_PATH_WIDTH_8
;
590 link
->resource
[0]->end
= 8;
592 link
->conf
.Attributes
= CONF_ENABLE_IRQ
;
593 link
->conf
.IntType
= INT_MEMORY_AND_IO
;
595 return btuart_config(link
);
599 static void btuart_detach(struct pcmcia_device
*link
)
601 btuart_info_t
*info
= link
->priv
;
603 btuart_release(link
);
607 static int btuart_check_config(struct pcmcia_device
*p_dev
,
608 cistpl_cftable_entry_t
*cf
,
609 cistpl_cftable_entry_t
*dflt
,
613 int *try = priv_data
;
615 p_dev
->io_lines
= (try == 0) ? 16 : cf
->io
.flags
& CISTPL_IO_LINES_MASK
;
617 if (cf
->vpp1
.present
& (1 << CISTPL_POWER_VNOM
))
618 p_dev
->vpp
= cf
->vpp1
.param
[CISTPL_POWER_VNOM
] / 10000;
619 if ((cf
->io
.nwin
> 0) && (cf
->io
.win
[0].len
== 8) &&
620 (cf
->io
.win
[0].base
!= 0)) {
621 p_dev
->resource
[0]->start
= cf
->io
.win
[0].base
;
622 if (!pcmcia_request_io(p_dev
))
628 static int btuart_check_config_notpicky(struct pcmcia_device
*p_dev
,
629 cistpl_cftable_entry_t
*cf
,
630 cistpl_cftable_entry_t
*dflt
,
634 static unsigned int base
[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
637 if ((cf
->io
.nwin
> 0) && ((cf
->io
.flags
& CISTPL_IO_LINES_MASK
) <= 3)) {
638 for (j
= 0; j
< 5; j
++) {
639 p_dev
->resource
[0]->start
= base
[j
];
640 p_dev
->io_lines
= base
[j
] ? 16 : 3;
641 if (!pcmcia_request_io(p_dev
))
648 static int btuart_config(struct pcmcia_device
*link
)
650 btuart_info_t
*info
= link
->priv
;
654 /* First pass: look for a config entry that looks normal.
655 Two tries: without IO aliases, then with aliases */
656 for (try = 0; try < 2; try++)
657 if (!pcmcia_loop_config(link
, btuart_check_config
, &try))
660 /* Second pass: try to find an entry that isn't picky about
661 its base address, then try to grab any standard serial port
662 address, and finally try to get any free port. */
663 if (!pcmcia_loop_config(link
, btuart_check_config_notpicky
, NULL
))
666 BT_ERR("No usable port range found");
670 i
= pcmcia_request_irq(link
, btuart_interrupt
);
674 i
= pcmcia_request_configuration(link
, &link
->conf
);
678 if (btuart_open(info
) != 0)
684 btuart_release(link
);
689 static void btuart_release(struct pcmcia_device
*link
)
691 btuart_info_t
*info
= link
->priv
;
695 pcmcia_disable_device(link
);
698 static struct pcmcia_device_id btuart_ids
[] = {
699 /* don't use this driver. Use serial_cs + hci_uart instead */
702 MODULE_DEVICE_TABLE(pcmcia
, btuart_ids
);
704 static struct pcmcia_driver btuart_driver
= {
705 .owner
= THIS_MODULE
,
709 .probe
= btuart_probe
,
710 .remove
= btuart_detach
,
711 .id_table
= btuart_ids
,
714 static int __init
init_btuart_cs(void)
716 return pcmcia_register_driver(&btuart_driver
);
720 static void __exit
exit_btuart_cs(void)
722 pcmcia_unregister_driver(&btuart_driver
);
725 module_init(init_btuart_cs
);
726 module_exit(exit_btuart_cs
);