3 * Driver for the 3Com Bluetooth PCMCIA card
5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
6 * Jose Orlando Pereira <jop@di.uminho.pt>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation;
13 * Software distributed under the License is distributed on an "AS
14 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15 * implied. See the License for the specific language governing
16 * rights and limitations under the License.
18 * The initial developer of the original code is David A. Hinds
19 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
20 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
24 #include <linux/config.h>
25 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/types.h>
31 #include <linux/sched.h>
32 #include <linux/delay.h>
33 #include <linux/errno.h>
34 #include <linux/ptrace.h>
35 #include <linux/ioport.h>
36 #include <linux/spinlock.h>
37 #include <linux/moduleparam.h>
39 #include <linux/skbuff.h>
40 #include <linux/string.h>
41 #include <linux/serial.h>
42 #include <linux/serial_reg.h>
43 #include <linux/bitops.h>
44 #include <asm/system.h>
47 #include <linux/device.h>
48 #include <linux/firmware.h>
50 #include <pcmcia/cs_types.h>
51 #include <pcmcia/cs.h>
52 #include <pcmcia/cistpl.h>
53 #include <pcmcia/ciscode.h>
54 #include <pcmcia/ds.h>
55 #include <pcmcia/cisreg.h>
57 #include <net/bluetooth/bluetooth.h>
58 #include <net/bluetooth/hci_core.h>
62 /* ======================== Module parameters ======================== */
65 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
66 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
67 MODULE_LICENSE("GPL");
71 /* ======================== Local structures ======================== */
74 typedef struct bt3c_info_t {
75 struct pcmcia_device *p_dev;
80 spinlock_t lock; /* For serializing operations */
82 struct sk_buff_head txq;
83 unsigned long tx_state;
85 unsigned long rx_state;
86 unsigned long rx_count;
87 struct sk_buff *rx_skb;
91 static void bt3c_config(dev_link_t *link);
92 static void bt3c_release(dev_link_t *link);
94 static void bt3c_detach(struct pcmcia_device *p_dev);
98 #define XMIT_SENDING 1
100 #define XMIT_WAITING 8
102 /* Receiver states */
103 #define RECV_WAIT_PACKET_TYPE 0
104 #define RECV_WAIT_EVENT_HEADER 1
105 #define RECV_WAIT_ACL_HEADER 2
106 #define RECV_WAIT_SCO_HEADER 3
107 #define RECV_WAIT_DATA 4
111 /* ======================== Special I/O functions ======================== */
121 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
123 outb(addr & 0xff, iobase + ADDR_L);
124 outb((addr >> 8) & 0xff, iobase + ADDR_H);
128 static inline void bt3c_put(unsigned int iobase, unsigned short value)
130 outb(value & 0xff, iobase + DATA_L);
131 outb((value >> 8) & 0xff, iobase + DATA_H);
135 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
137 bt3c_address(iobase, addr);
138 bt3c_put(iobase, value);
142 static inline unsigned short bt3c_get(unsigned int iobase)
144 unsigned short value = inb(iobase + DATA_L);
146 value |= inb(iobase + DATA_H) << 8;
152 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
154 bt3c_address(iobase, addr);
156 return bt3c_get(iobase);
161 /* ======================== Interrupt handling ======================== */
164 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
168 bt3c_address(iobase, 0x7080);
170 /* Fill FIFO with current frame */
171 while (actual < len) {
172 /* Transmit next byte */
173 bt3c_put(iobase, buf[actual]);
177 bt3c_io_write(iobase, 0x7005, actual);
183 static void bt3c_write_wakeup(bt3c_info_t *info)
186 BT_ERR("Unknown device");
190 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
194 register unsigned int iobase = info->p_dev->io.BasePort1;
195 register struct sk_buff *skb;
198 if (!(info->p_dev->state & DEV_PRESENT))
202 if (!(skb = skb_dequeue(&(info->txq)))) {
203 clear_bit(XMIT_SENDING, &(info->tx_state));
208 len = bt3c_write(iobase, 256, skb->data, skb->len);
210 if (len != skb->len) {
211 BT_ERR("Very strange");
216 info->hdev->stat.byte_tx += len;
222 static void bt3c_receive(bt3c_info_t *info)
228 BT_ERR("Unknown device");
232 iobase = info->p_dev->io.BasePort1;
234 avail = bt3c_read(iobase, 0x7006);
235 //printk("bt3c_cs: receiving %d bytes\n", avail);
237 bt3c_address(iobase, 0x7480);
238 while (size < avail) {
240 info->hdev->stat.byte_rx++;
242 /* Allocate packet */
243 if (info->rx_skb == NULL) {
244 info->rx_state = RECV_WAIT_PACKET_TYPE;
246 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
247 BT_ERR("Can't allocate mem for new packet");
253 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
255 info->rx_skb->dev = (void *) info->hdev;
256 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
257 inb(iobase + DATA_H);
258 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
260 switch (bt_cb(info->rx_skb)->pkt_type) {
263 info->rx_state = RECV_WAIT_EVENT_HEADER;
264 info->rx_count = HCI_EVENT_HDR_SIZE;
267 case HCI_ACLDATA_PKT:
268 info->rx_state = RECV_WAIT_ACL_HEADER;
269 info->rx_count = HCI_ACL_HDR_SIZE;
272 case HCI_SCODATA_PKT:
273 info->rx_state = RECV_WAIT_SCO_HEADER;
274 info->rx_count = HCI_SCO_HDR_SIZE;
279 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
280 info->hdev->stat.err_rx++;
281 clear_bit(HCI_RUNNING, &(info->hdev->flags));
283 kfree_skb(info->rx_skb);
291 __u8 x = inb(iobase + DATA_L);
293 *skb_put(info->rx_skb, 1) = x;
294 inb(iobase + DATA_H);
297 if (info->rx_count == 0) {
300 struct hci_event_hdr *eh;
301 struct hci_acl_hdr *ah;
302 struct hci_sco_hdr *sh;
304 switch (info->rx_state) {
306 case RECV_WAIT_EVENT_HEADER:
307 eh = (struct hci_event_hdr *)(info->rx_skb->data);
308 info->rx_state = RECV_WAIT_DATA;
309 info->rx_count = eh->plen;
312 case RECV_WAIT_ACL_HEADER:
313 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
314 dlen = __le16_to_cpu(ah->dlen);
315 info->rx_state = RECV_WAIT_DATA;
316 info->rx_count = dlen;
319 case RECV_WAIT_SCO_HEADER:
320 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
321 info->rx_state = RECV_WAIT_DATA;
322 info->rx_count = sh->dlen;
326 hci_recv_frame(info->rx_skb);
338 bt3c_io_write(iobase, 0x7006, 0x0000);
342 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
344 bt3c_info_t *info = dev_inst;
348 if (!info || !info->hdev) {
349 BT_ERR("Call of irq %d for unknown device", irq);
353 iobase = info->p_dev->io.BasePort1;
355 spin_lock(&(info->lock));
357 iir = inb(iobase + CONTROL);
359 int stat = bt3c_read(iobase, 0x7001);
361 if ((stat & 0xff) == 0x7f) {
362 BT_ERR("Very strange (stat=0x%04x)", stat);
363 } else if ((stat & 0xff) != 0xff) {
365 int stat = bt3c_read(iobase, 0x7002) & 0x10;
366 BT_INFO("%s: Antenna %s", info->hdev->name,
367 stat ? "out" : "in");
372 //BT_ERR("Ack (stat=0x%04x)", stat);
373 clear_bit(XMIT_SENDING, &(info->tx_state));
374 bt3c_write_wakeup(info);
377 bt3c_io_write(iobase, 0x7001, 0x0000);
379 outb(iir, iobase + CONTROL);
383 spin_unlock(&(info->lock));
390 /* ======================== HCI interface ======================== */
393 static int bt3c_hci_flush(struct hci_dev *hdev)
395 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
398 skb_queue_purge(&(info->txq));
404 static int bt3c_hci_open(struct hci_dev *hdev)
406 set_bit(HCI_RUNNING, &(hdev->flags));
412 static int bt3c_hci_close(struct hci_dev *hdev)
414 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
417 bt3c_hci_flush(hdev);
423 static int bt3c_hci_send_frame(struct sk_buff *skb)
426 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
430 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
434 info = (bt3c_info_t *) (hdev->driver_data);
436 switch (bt_cb(skb)->pkt_type) {
437 case HCI_COMMAND_PKT:
440 case HCI_ACLDATA_PKT:
443 case HCI_SCODATA_PKT:
448 /* Prepend skb with frame type */
449 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
450 skb_queue_tail(&(info->txq), skb);
452 spin_lock_irqsave(&(info->lock), flags);
454 bt3c_write_wakeup(info);
456 spin_unlock_irqrestore(&(info->lock), flags);
462 static void bt3c_hci_destruct(struct hci_dev *hdev)
467 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
474 /* ======================== Card services HCI interaction ======================== */
477 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
479 char *ptr = (char *) firmware;
481 unsigned int iobase, size, addr, fcs, tmp;
484 iobase = info->p_dev->io.BasePort1;
487 bt3c_io_write(iobase, 0x8040, 0x0404);
488 bt3c_io_write(iobase, 0x8040, 0x0400);
492 bt3c_io_write(iobase, 0x8040, 0x0404);
499 BT_ERR("Bad address in firmware");
504 memset(b, 0, sizeof(b));
505 memcpy(b, ptr + 2, 2);
506 size = simple_strtol(b, NULL, 16);
508 memset(b, 0, sizeof(b));
509 memcpy(b, ptr + 4, 8);
510 addr = simple_strtol(b, NULL, 16);
512 memset(b, 0, sizeof(b));
513 memcpy(b, ptr + (size * 2) + 2, 2);
514 fcs = simple_strtol(b, NULL, 16);
516 memset(b, 0, sizeof(b));
517 for (tmp = 0, i = 0; i < size; i++) {
518 memcpy(b, ptr + (i * 2) + 2, 2);
519 tmp += simple_strtol(b, NULL, 16);
522 if (((tmp + fcs) & 0xff) != 0xff) {
523 BT_ERR("Checksum error in firmware");
529 bt3c_address(iobase, addr);
531 memset(b, 0, sizeof(b));
532 for (i = 0; i < (size - 4) / 2; i++) {
533 memcpy(b, ptr + (i * 4) + 12, 4);
534 tmp = simple_strtol(b, NULL, 16);
535 bt3c_put(iobase, tmp);
539 ptr += (size * 2) + 6;
540 count -= (size * 2) + 6;
546 bt3c_address(iobase, 0x3000);
547 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
553 bt3c_io_write(iobase, 0x7006, 0x0000);
554 bt3c_io_write(iobase, 0x7005, 0x0000);
555 bt3c_io_write(iobase, 0x7001, 0x0000);
561 static int bt3c_open(bt3c_info_t *info)
563 const struct firmware *firmware;
564 struct hci_dev *hdev;
567 spin_lock_init(&(info->lock));
569 skb_queue_head_init(&(info->txq));
571 info->rx_state = RECV_WAIT_PACKET_TYPE;
575 /* Initialize HCI device */
576 hdev = hci_alloc_dev();
578 BT_ERR("Can't allocate HCI device");
584 hdev->type = HCI_PCCARD;
585 hdev->driver_data = info;
587 hdev->open = bt3c_hci_open;
588 hdev->close = bt3c_hci_close;
589 hdev->flush = bt3c_hci_flush;
590 hdev->send = bt3c_hci_send_frame;
591 hdev->destruct = bt3c_hci_destruct;
592 hdev->ioctl = bt3c_hci_ioctl;
594 hdev->owner = THIS_MODULE;
597 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
599 BT_ERR("Firmware request failed");
603 err = bt3c_load_firmware(info, firmware->data, firmware->size);
605 release_firmware(firmware);
608 BT_ERR("Firmware loading failed");
612 /* Timeout before it is safe to send the first HCI packet */
615 /* Register HCI device */
616 err = hci_register_dev(hdev);
618 BT_ERR("Can't register HCI device");
631 static int bt3c_close(bt3c_info_t *info)
633 struct hci_dev *hdev = info->hdev;
638 bt3c_hci_close(hdev);
640 if (hci_unregister_dev(hdev) < 0)
641 BT_ERR("Can't unregister HCI device %s", hdev->name);
648 static int bt3c_attach(struct pcmcia_device *p_dev)
651 dev_link_t *link = dev_to_instance(p_dev);
653 /* Create new info device */
654 info = kzalloc(sizeof(*info), GFP_KERNEL);
661 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
662 link->io.NumPorts1 = 8;
663 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
664 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
666 link->irq.Handler = bt3c_interrupt;
667 link->irq.Instance = info;
669 link->conf.Attributes = CONF_ENABLE_IRQ;
670 link->conf.IntType = INT_MEMORY_AND_IO;
672 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
679 static void bt3c_detach(struct pcmcia_device *p_dev)
681 dev_link_t *link = dev_to_instance(p_dev);
682 bt3c_info_t *info = link->priv;
684 if (link->state & DEV_CONFIG)
690 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
694 i = pcmcia_get_tuple_data(handle, tuple);
698 return pcmcia_parse_tuple(handle, tuple, parse);
701 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
703 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
704 return CS_NO_MORE_ITEMS;
705 return get_tuple(handle, tuple, parse);
708 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
710 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
711 return CS_NO_MORE_ITEMS;
712 return get_tuple(handle, tuple, parse);
715 static void bt3c_config(dev_link_t *link)
717 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
718 client_handle_t handle = link->handle;
719 bt3c_info_t *info = link->priv;
723 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
724 int i, j, try, last_ret, last_fn;
726 tuple.TupleData = (cisdata_t *)buf;
727 tuple.TupleOffset = 0;
728 tuple.TupleDataMax = 255;
729 tuple.Attributes = 0;
731 /* Get configuration register information */
732 tuple.DesiredTuple = CISTPL_CONFIG;
733 last_ret = first_tuple(handle, &tuple, &parse);
734 if (last_ret != CS_SUCCESS) {
735 last_fn = ParseTuple;
738 link->conf.ConfigBase = parse.config.base;
739 link->conf.Present = parse.config.rmask[0];
742 link->state |= DEV_CONFIG;
744 /* First pass: look for a config entry that looks normal. */
745 tuple.TupleData = (cisdata_t *)buf;
746 tuple.TupleOffset = 0;
747 tuple.TupleDataMax = 255;
748 tuple.Attributes = 0;
749 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
750 /* Two tries: without IO aliases, then with aliases */
751 for (try = 0; try < 2; try++) {
752 i = first_tuple(handle, &tuple, &parse);
753 while (i != CS_NO_MORE_ITEMS) {
756 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
757 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
758 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
759 link->conf.ConfigIndex = cf->index;
760 link->io.BasePort1 = cf->io.win[0].base;
761 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
762 i = pcmcia_request_io(link->handle, &link->io);
767 i = next_tuple(handle, &tuple, &parse);
771 /* Second pass: try to find an entry that isn't picky about
772 its base address, then try to grab any standard serial port
773 address, and finally try to get any free port. */
774 i = first_tuple(handle, &tuple, &parse);
775 while (i != CS_NO_MORE_ITEMS) {
776 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
777 link->conf.ConfigIndex = cf->index;
778 for (j = 0; j < 5; j++) {
779 link->io.BasePort1 = base[j];
780 link->io.IOAddrLines = base[j] ? 16 : 3;
781 i = pcmcia_request_io(link->handle, &link->io);
786 i = next_tuple(handle, &tuple, &parse);
790 if (i != CS_SUCCESS) {
791 BT_ERR("No usable port range found");
792 cs_error(link->handle, RequestIO, i);
796 i = pcmcia_request_irq(link->handle, &link->irq);
797 if (i != CS_SUCCESS) {
798 cs_error(link->handle, RequestIRQ, i);
799 link->irq.AssignedIRQ = 0;
802 i = pcmcia_request_configuration(link->handle, &link->conf);
803 if (i != CS_SUCCESS) {
804 cs_error(link->handle, RequestConfiguration, i);
808 if (bt3c_open(info) != 0)
811 strcpy(info->node.dev_name, info->hdev->name);
812 link->dev_node = &info->node;
813 link->state &= ~DEV_CONFIG_PENDING;
818 cs_error(link->handle, last_fn, last_ret);
825 static void bt3c_release(dev_link_t *link)
827 bt3c_info_t *info = link->priv;
829 if (link->state & DEV_PRESENT)
832 pcmcia_disable_device(link->handle);
836 static struct pcmcia_device_id bt3c_ids[] = {
837 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
840 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
842 static struct pcmcia_driver bt3c_driver = {
843 .owner = THIS_MODULE,
847 .probe = bt3c_attach,
848 .remove = bt3c_detach,
849 .id_table = bt3c_ids,
852 static int __init init_bt3c_cs(void)
854 return pcmcia_register_driver(&bt3c_driver);
858 static void __exit exit_bt3c_cs(void)
860 pcmcia_unregister_driver(&bt3c_driver);
863 module_init(init_bt3c_cs);
864 module_exit(exit_bt3c_cs);