[PATCH] Represent laptop_mode as jiffies internally
[linux-2.6/verdex.git] / drivers / bluetooth / btuart_cs.c
blob7b4bff4cfa2dfac57daa86f1c96ae9c3b0c947de
1 /*
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>
44 #include <asm/io.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 {
71 dev_link_t link;
72 dev_node_t node;
74 struct hci_dev *hdev;
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;
84 } btuart_info_t;
87 static void btuart_config(dev_link_t *link);
88 static void btuart_release(dev_link_t *link);
90 static void btuart_detach(struct pcmcia_device *p_dev);
93 /* Maximum baud rate */
94 #define SPEED_MAX 115200
96 /* Default baud rate: 57600, 115200, 230400 or 460800 */
97 #define DEFAULT_BAUD_RATE 115200
100 /* Transmit states */
101 #define XMIT_SENDING 1
102 #define XMIT_WAKEUP 2
103 #define XMIT_WAITING 8
105 /* Receiver states */
106 #define RECV_WAIT_PACKET_TYPE 0
107 #define RECV_WAIT_EVENT_HEADER 1
108 #define RECV_WAIT_ACL_HEADER 2
109 #define RECV_WAIT_SCO_HEADER 3
110 #define RECV_WAIT_DATA 4
114 /* ======================== Interrupt handling ======================== */
117 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
119 int actual = 0;
121 /* Tx FIFO should be empty */
122 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
123 return 0;
125 /* Fill FIFO with current frame */
126 while ((fifo_size-- > 0) && (actual < len)) {
127 /* Transmit next byte */
128 outb(buf[actual], iobase + UART_TX);
129 actual++;
132 return actual;
136 static void btuart_write_wakeup(btuart_info_t *info)
138 if (!info) {
139 BT_ERR("Unknown device");
140 return;
143 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
144 set_bit(XMIT_WAKEUP, &(info->tx_state));
145 return;
148 do {
149 register unsigned int iobase = info->link.io.BasePort1;
150 register struct sk_buff *skb;
151 register int len;
153 clear_bit(XMIT_WAKEUP, &(info->tx_state));
155 if (!(info->link.state & DEV_PRESENT))
156 return;
158 if (!(skb = skb_dequeue(&(info->txq))))
159 break;
161 /* Send frame */
162 len = btuart_write(iobase, 16, skb->data, skb->len);
163 set_bit(XMIT_WAKEUP, &(info->tx_state));
165 if (len == skb->len) {
166 kfree_skb(skb);
167 } else {
168 skb_pull(skb, len);
169 skb_queue_head(&(info->txq), skb);
172 info->hdev->stat.byte_tx += len;
174 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
176 clear_bit(XMIT_SENDING, &(info->tx_state));
180 static void btuart_receive(btuart_info_t *info)
182 unsigned int iobase;
183 int boguscount = 0;
185 if (!info) {
186 BT_ERR("Unknown device");
187 return;
190 iobase = info->link.io.BasePort1;
192 do {
193 info->hdev->stat.byte_rx++;
195 /* Allocate packet */
196 if (info->rx_skb == NULL) {
197 info->rx_state = RECV_WAIT_PACKET_TYPE;
198 info->rx_count = 0;
199 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
200 BT_ERR("Can't allocate mem for new packet");
201 return;
205 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
207 info->rx_skb->dev = (void *) info->hdev;
208 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
210 switch (bt_cb(info->rx_skb)->pkt_type) {
212 case HCI_EVENT_PKT:
213 info->rx_state = RECV_WAIT_EVENT_HEADER;
214 info->rx_count = HCI_EVENT_HDR_SIZE;
215 break;
217 case HCI_ACLDATA_PKT:
218 info->rx_state = RECV_WAIT_ACL_HEADER;
219 info->rx_count = HCI_ACL_HDR_SIZE;
220 break;
222 case HCI_SCODATA_PKT:
223 info->rx_state = RECV_WAIT_SCO_HEADER;
224 info->rx_count = HCI_SCO_HDR_SIZE;
225 break;
227 default:
228 /* Unknown packet */
229 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
230 info->hdev->stat.err_rx++;
231 clear_bit(HCI_RUNNING, &(info->hdev->flags));
233 kfree_skb(info->rx_skb);
234 info->rx_skb = NULL;
235 break;
239 } else {
241 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
242 info->rx_count--;
244 if (info->rx_count == 0) {
246 int dlen;
247 struct hci_event_hdr *eh;
248 struct hci_acl_hdr *ah;
249 struct hci_sco_hdr *sh;
252 switch (info->rx_state) {
254 case RECV_WAIT_EVENT_HEADER:
255 eh = (struct hci_event_hdr *)(info->rx_skb->data);
256 info->rx_state = RECV_WAIT_DATA;
257 info->rx_count = eh->plen;
258 break;
260 case RECV_WAIT_ACL_HEADER:
261 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
262 dlen = __le16_to_cpu(ah->dlen);
263 info->rx_state = RECV_WAIT_DATA;
264 info->rx_count = dlen;
265 break;
267 case RECV_WAIT_SCO_HEADER:
268 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
269 info->rx_state = RECV_WAIT_DATA;
270 info->rx_count = sh->dlen;
271 break;
273 case RECV_WAIT_DATA:
274 hci_recv_frame(info->rx_skb);
275 info->rx_skb = NULL;
276 break;
284 /* Make sure we don't stay here too long */
285 if (boguscount++ > 16)
286 break;
288 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
292 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
294 btuart_info_t *info = dev_inst;
295 unsigned int iobase;
296 int boguscount = 0;
297 int iir, lsr;
299 if (!info || !info->hdev) {
300 BT_ERR("Call of irq %d for unknown device", irq);
301 return IRQ_NONE;
304 iobase = info->link.io.BasePort1;
306 spin_lock(&(info->lock));
308 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
309 while (iir) {
311 /* Clear interrupt */
312 lsr = inb(iobase + UART_LSR);
314 switch (iir) {
315 case UART_IIR_RLSI:
316 BT_ERR("RLSI");
317 break;
318 case UART_IIR_RDI:
319 /* Receive interrupt */
320 btuart_receive(info);
321 break;
322 case UART_IIR_THRI:
323 if (lsr & UART_LSR_THRE) {
324 /* Transmitter ready for data */
325 btuart_write_wakeup(info);
327 break;
328 default:
329 BT_ERR("Unhandled IIR=%#x", iir);
330 break;
333 /* Make sure we don't stay here too long */
334 if (boguscount++ > 100)
335 break;
337 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
341 spin_unlock(&(info->lock));
343 return IRQ_HANDLED;
347 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
349 unsigned long flags;
350 unsigned int iobase;
351 int fcr; /* FIFO control reg */
352 int lcr; /* Line control reg */
353 int divisor;
355 if (!info) {
356 BT_ERR("Unknown device");
357 return;
360 iobase = info->link.io.BasePort1;
362 spin_lock_irqsave(&(info->lock), flags);
364 /* Turn off interrupts */
365 outb(0, iobase + UART_IER);
367 divisor = SPEED_MAX / speed;
369 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
372 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
373 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
374 * about this timeout since it will always be fast enough.
377 if (speed < 38400)
378 fcr |= UART_FCR_TRIGGER_1;
379 else
380 fcr |= UART_FCR_TRIGGER_14;
382 /* Bluetooth cards use 8N1 */
383 lcr = UART_LCR_WLEN8;
385 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
386 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
387 outb(divisor >> 8, iobase + UART_DLM);
388 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
389 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
391 /* Turn on interrups */
392 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
394 spin_unlock_irqrestore(&(info->lock), flags);
399 /* ======================== HCI interface ======================== */
402 static int btuart_hci_flush(struct hci_dev *hdev)
404 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
406 /* Drop TX queue */
407 skb_queue_purge(&(info->txq));
409 return 0;
413 static int btuart_hci_open(struct hci_dev *hdev)
415 set_bit(HCI_RUNNING, &(hdev->flags));
417 return 0;
421 static int btuart_hci_close(struct hci_dev *hdev)
423 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
424 return 0;
426 btuart_hci_flush(hdev);
428 return 0;
432 static int btuart_hci_send_frame(struct sk_buff *skb)
434 btuart_info_t *info;
435 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
437 if (!hdev) {
438 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
439 return -ENODEV;
442 info = (btuart_info_t *)(hdev->driver_data);
444 switch (bt_cb(skb)->pkt_type) {
445 case HCI_COMMAND_PKT:
446 hdev->stat.cmd_tx++;
447 break;
448 case HCI_ACLDATA_PKT:
449 hdev->stat.acl_tx++;
450 break;
451 case HCI_SCODATA_PKT:
452 hdev->stat.sco_tx++;
453 break;
456 /* Prepend skb with frame type */
457 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
458 skb_queue_tail(&(info->txq), skb);
460 btuart_write_wakeup(info);
462 return 0;
466 static void btuart_hci_destruct(struct hci_dev *hdev)
471 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
473 return -ENOIOCTLCMD;
478 /* ======================== Card services HCI interaction ======================== */
481 static int btuart_open(btuart_info_t *info)
483 unsigned long flags;
484 unsigned int iobase = info->link.io.BasePort1;
485 struct hci_dev *hdev;
487 spin_lock_init(&(info->lock));
489 skb_queue_head_init(&(info->txq));
491 info->rx_state = RECV_WAIT_PACKET_TYPE;
492 info->rx_count = 0;
493 info->rx_skb = NULL;
495 /* Initialize HCI device */
496 hdev = hci_alloc_dev();
497 if (!hdev) {
498 BT_ERR("Can't allocate HCI device");
499 return -ENOMEM;
502 info->hdev = hdev;
504 hdev->type = HCI_PCCARD;
505 hdev->driver_data = info;
507 hdev->open = btuart_hci_open;
508 hdev->close = btuart_hci_close;
509 hdev->flush = btuart_hci_flush;
510 hdev->send = btuart_hci_send_frame;
511 hdev->destruct = btuart_hci_destruct;
512 hdev->ioctl = btuart_hci_ioctl;
514 hdev->owner = THIS_MODULE;
516 spin_lock_irqsave(&(info->lock), flags);
518 /* Reset UART */
519 outb(0, iobase + UART_MCR);
521 /* Turn off interrupts */
522 outb(0, iobase + UART_IER);
524 /* Initialize UART */
525 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
526 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
528 /* Turn on interrupts */
529 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
531 spin_unlock_irqrestore(&(info->lock), flags);
533 btuart_change_speed(info, DEFAULT_BAUD_RATE);
535 /* Timeout before it is safe to send the first HCI packet */
536 msleep(1000);
538 /* Register HCI device */
539 if (hci_register_dev(hdev) < 0) {
540 BT_ERR("Can't register HCI device");
541 info->hdev = NULL;
542 hci_free_dev(hdev);
543 return -ENODEV;
546 return 0;
550 static int btuart_close(btuart_info_t *info)
552 unsigned long flags;
553 unsigned int iobase = info->link.io.BasePort1;
554 struct hci_dev *hdev = info->hdev;
556 if (!hdev)
557 return -ENODEV;
559 btuart_hci_close(hdev);
561 spin_lock_irqsave(&(info->lock), flags);
563 /* Reset UART */
564 outb(0, iobase + UART_MCR);
566 /* Turn off interrupts */
567 outb(0, iobase + UART_IER);
569 spin_unlock_irqrestore(&(info->lock), flags);
571 if (hci_unregister_dev(hdev) < 0)
572 BT_ERR("Can't unregister HCI device %s", hdev->name);
574 hci_free_dev(hdev);
576 return 0;
579 static int btuart_attach(struct pcmcia_device *p_dev)
581 btuart_info_t *info;
582 dev_link_t *link;
584 /* Create new info device */
585 info = kzalloc(sizeof(*info), GFP_KERNEL);
586 if (!info)
587 return -ENOMEM;
589 link = &info->link;
590 link->priv = info;
592 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
593 link->io.NumPorts1 = 8;
594 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
595 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
597 link->irq.Handler = btuart_interrupt;
598 link->irq.Instance = info;
600 link->conf.Attributes = CONF_ENABLE_IRQ;
601 link->conf.Vcc = 50;
602 link->conf.IntType = INT_MEMORY_AND_IO;
604 link->handle = p_dev;
605 p_dev->instance = link;
607 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
608 btuart_config(link);
610 return 0;
614 static void btuart_detach(struct pcmcia_device *p_dev)
616 dev_link_t *link = dev_to_instance(p_dev);
617 btuart_info_t *info = link->priv;
619 if (link->state & DEV_CONFIG)
620 btuart_release(link);
622 kfree(info);
625 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
627 int i;
629 i = pcmcia_get_tuple_data(handle, tuple);
630 if (i != CS_SUCCESS)
631 return i;
633 return pcmcia_parse_tuple(handle, tuple, parse);
636 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
638 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
639 return CS_NO_MORE_ITEMS;
640 return get_tuple(handle, tuple, parse);
643 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
645 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
646 return CS_NO_MORE_ITEMS;
647 return get_tuple(handle, tuple, parse);
650 static void btuart_config(dev_link_t *link)
652 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
653 client_handle_t handle = link->handle;
654 btuart_info_t *info = link->priv;
655 tuple_t tuple;
656 u_short buf[256];
657 cisparse_t parse;
658 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
659 config_info_t config;
660 int i, j, try, last_ret, last_fn;
662 tuple.TupleData = (cisdata_t *)buf;
663 tuple.TupleOffset = 0;
664 tuple.TupleDataMax = 255;
665 tuple.Attributes = 0;
667 /* Get configuration register information */
668 tuple.DesiredTuple = CISTPL_CONFIG;
669 last_ret = first_tuple(handle, &tuple, &parse);
670 if (last_ret != CS_SUCCESS) {
671 last_fn = ParseTuple;
672 goto cs_failed;
674 link->conf.ConfigBase = parse.config.base;
675 link->conf.Present = parse.config.rmask[0];
677 /* Configure card */
678 link->state |= DEV_CONFIG;
679 i = pcmcia_get_configuration_info(handle, &config);
680 link->conf.Vcc = config.Vcc;
682 /* First pass: look for a config entry that looks normal. */
683 tuple.TupleData = (cisdata_t *) buf;
684 tuple.TupleOffset = 0;
685 tuple.TupleDataMax = 255;
686 tuple.Attributes = 0;
687 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
688 /* Two tries: without IO aliases, then with aliases */
689 for (try = 0; try < 2; try++) {
690 i = first_tuple(handle, &tuple, &parse);
691 while (i != CS_NO_MORE_ITEMS) {
692 if (i != CS_SUCCESS)
693 goto next_entry;
694 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
695 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
696 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
697 link->conf.ConfigIndex = cf->index;
698 link->io.BasePort1 = cf->io.win[0].base;
699 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
700 i = pcmcia_request_io(link->handle, &link->io);
701 if (i == CS_SUCCESS)
702 goto found_port;
704 next_entry:
705 i = next_tuple(handle, &tuple, &parse);
709 /* Second pass: try to find an entry that isn't picky about
710 its base address, then try to grab any standard serial port
711 address, and finally try to get any free port. */
712 i = first_tuple(handle, &tuple, &parse);
713 while (i != CS_NO_MORE_ITEMS) {
714 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
715 && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
716 link->conf.ConfigIndex = cf->index;
717 for (j = 0; j < 5; j++) {
718 link->io.BasePort1 = base[j];
719 link->io.IOAddrLines = base[j] ? 16 : 3;
720 i = pcmcia_request_io(link->handle, &link->io);
721 if (i == CS_SUCCESS)
722 goto found_port;
725 i = next_tuple(handle, &tuple, &parse);
728 found_port:
729 if (i != CS_SUCCESS) {
730 BT_ERR("No usable port range found");
731 cs_error(link->handle, RequestIO, i);
732 goto failed;
735 i = pcmcia_request_irq(link->handle, &link->irq);
736 if (i != CS_SUCCESS) {
737 cs_error(link->handle, RequestIRQ, i);
738 link->irq.AssignedIRQ = 0;
741 i = pcmcia_request_configuration(link->handle, &link->conf);
742 if (i != CS_SUCCESS) {
743 cs_error(link->handle, RequestConfiguration, i);
744 goto failed;
747 if (btuart_open(info) != 0)
748 goto failed;
750 strcpy(info->node.dev_name, info->hdev->name);
751 link->dev = &info->node;
752 link->state &= ~DEV_CONFIG_PENDING;
754 return;
756 cs_failed:
757 cs_error(link->handle, last_fn, last_ret);
759 failed:
760 btuart_release(link);
764 static void btuart_release(dev_link_t *link)
766 btuart_info_t *info = link->priv;
768 if (link->state & DEV_PRESENT)
769 btuart_close(info);
771 link->dev = NULL;
773 pcmcia_release_configuration(link->handle);
774 pcmcia_release_io(link->handle, &link->io);
775 pcmcia_release_irq(link->handle, &link->irq);
777 link->state &= ~DEV_CONFIG;
780 static int btuart_suspend(struct pcmcia_device *dev)
782 dev_link_t *link = dev_to_instance(dev);
784 link->state |= DEV_SUSPEND;
785 if (link->state & DEV_CONFIG)
786 pcmcia_release_configuration(link->handle);
788 return 0;
791 static int btuart_resume(struct pcmcia_device *dev)
793 dev_link_t *link = dev_to_instance(dev);
795 link->state &= ~DEV_SUSPEND;
796 if (DEV_OK(link))
797 pcmcia_request_configuration(link->handle, &link->conf);
799 return 0;
803 static struct pcmcia_device_id btuart_ids[] = {
804 /* don't use this driver. Use serial_cs + hci_uart instead */
805 PCMCIA_DEVICE_NULL
807 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
809 static struct pcmcia_driver btuart_driver = {
810 .owner = THIS_MODULE,
811 .drv = {
812 .name = "btuart_cs",
814 .probe = btuart_attach,
815 .remove = btuart_detach,
816 .id_table = btuart_ids,
817 .suspend = btuart_suspend,
818 .resume = btuart_resume,
821 static int __init init_btuart_cs(void)
823 return pcmcia_register_driver(&btuart_driver);
827 static void __exit exit_btuart_cs(void)
829 pcmcia_unregister_driver(&btuart_driver);
832 module_init(init_btuart_cs);
833 module_exit(exit_btuart_cs);