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/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/delay.h>
31 #include <linux/errno.h>
32 #include <linux/ptrace.h>
33 #include <linux/ioport.h>
34 #include <linux/spinlock.h>
35 #include <linux/moduleparam.h>
37 #include <linux/skbuff.h>
38 #include <linux/string.h>
39 #include <linux/serial.h>
40 #include <linux/serial_reg.h>
41 #include <linux/bitops.h>
42 #include <asm/system.h>
45 #include <linux/device.h>
46 #include <linux/firmware.h>
48 #include <pcmcia/cs_types.h>
49 #include <pcmcia/cs.h>
50 #include <pcmcia/cistpl.h>
51 #include <pcmcia/ciscode.h>
52 #include <pcmcia/ds.h>
53 #include <pcmcia/cisreg.h>
55 #include <net/bluetooth/bluetooth.h>
56 #include <net/bluetooth/hci_core.h>
60 /* ======================== Module parameters ======================== */
63 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
64 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
65 MODULE_LICENSE("GPL");
66 MODULE_FIRMWARE("BT3CPCC.bin");
70 /* ======================== Local structures ======================== */
73 typedef struct bt3c_info_t {
74 struct pcmcia_device *p_dev;
79 spinlock_t lock; /* For serializing operations */
81 struct sk_buff_head txq;
82 unsigned long tx_state;
84 unsigned long rx_state;
85 unsigned long rx_count;
86 struct sk_buff *rx_skb;
90 static int bt3c_config(struct pcmcia_device *link);
91 static void bt3c_release(struct pcmcia_device *link);
93 static void bt3c_detach(struct pcmcia_device *p_dev);
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 /* ======================== Special I/O functions ======================== */
120 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
122 outb(addr & 0xff, iobase + ADDR_L);
123 outb((addr >> 8) & 0xff, iobase + ADDR_H);
127 static inline void bt3c_put(unsigned int iobase, unsigned short value)
129 outb(value & 0xff, iobase + DATA_L);
130 outb((value >> 8) & 0xff, iobase + DATA_H);
134 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
136 bt3c_address(iobase, addr);
137 bt3c_put(iobase, value);
141 static inline unsigned short bt3c_get(unsigned int iobase)
143 unsigned short value = inb(iobase + DATA_L);
145 value |= inb(iobase + DATA_H) << 8;
151 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
153 bt3c_address(iobase, addr);
155 return bt3c_get(iobase);
160 /* ======================== Interrupt handling ======================== */
163 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
167 bt3c_address(iobase, 0x7080);
169 /* Fill FIFO with current frame */
170 while (actual < len) {
171 /* Transmit next byte */
172 bt3c_put(iobase, buf[actual]);
176 bt3c_io_write(iobase, 0x7005, actual);
182 static void bt3c_write_wakeup(bt3c_info_t *info)
185 BT_ERR("Unknown device");
189 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
193 register unsigned int iobase = info->p_dev->io.BasePort1;
194 register struct sk_buff *skb;
197 if (!pcmcia_dev_present(info->p_dev))
201 if (!(skb = skb_dequeue(&(info->txq)))) {
202 clear_bit(XMIT_SENDING, &(info->tx_state));
207 len = bt3c_write(iobase, 256, skb->data, skb->len);
209 if (len != skb->len) {
210 BT_ERR("Very strange");
215 info->hdev->stat.byte_tx += len;
221 static void bt3c_receive(bt3c_info_t *info)
227 BT_ERR("Unknown device");
231 iobase = info->p_dev->io.BasePort1;
233 avail = bt3c_read(iobase, 0x7006);
234 //printk("bt3c_cs: receiving %d bytes\n", avail);
236 bt3c_address(iobase, 0x7480);
237 while (size < avail) {
239 info->hdev->stat.byte_rx++;
241 /* Allocate packet */
242 if (info->rx_skb == NULL) {
243 info->rx_state = RECV_WAIT_PACKET_TYPE;
245 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
246 BT_ERR("Can't allocate mem for new packet");
252 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
254 info->rx_skb->dev = (void *) info->hdev;
255 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
256 inb(iobase + DATA_H);
257 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
259 switch (bt_cb(info->rx_skb)->pkt_type) {
262 info->rx_state = RECV_WAIT_EVENT_HEADER;
263 info->rx_count = HCI_EVENT_HDR_SIZE;
266 case HCI_ACLDATA_PKT:
267 info->rx_state = RECV_WAIT_ACL_HEADER;
268 info->rx_count = HCI_ACL_HDR_SIZE;
271 case HCI_SCODATA_PKT:
272 info->rx_state = RECV_WAIT_SCO_HEADER;
273 info->rx_count = HCI_SCO_HDR_SIZE;
278 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
279 info->hdev->stat.err_rx++;
280 clear_bit(HCI_RUNNING, &(info->hdev->flags));
282 kfree_skb(info->rx_skb);
290 __u8 x = inb(iobase + DATA_L);
292 *skb_put(info->rx_skb, 1) = x;
293 inb(iobase + DATA_H);
296 if (info->rx_count == 0) {
299 struct hci_event_hdr *eh;
300 struct hci_acl_hdr *ah;
301 struct hci_sco_hdr *sh;
303 switch (info->rx_state) {
305 case RECV_WAIT_EVENT_HEADER:
306 eh = hci_event_hdr(info->rx_skb);
307 info->rx_state = RECV_WAIT_DATA;
308 info->rx_count = eh->plen;
311 case RECV_WAIT_ACL_HEADER:
312 ah = hci_acl_hdr(info->rx_skb);
313 dlen = __le16_to_cpu(ah->dlen);
314 info->rx_state = RECV_WAIT_DATA;
315 info->rx_count = dlen;
318 case RECV_WAIT_SCO_HEADER:
319 sh = hci_sco_hdr(info->rx_skb);
320 info->rx_state = RECV_WAIT_DATA;
321 info->rx_count = sh->dlen;
325 hci_recv_frame(info->rx_skb);
337 bt3c_io_write(iobase, 0x7006, 0x0000);
341 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
343 bt3c_info_t *info = dev_inst;
349 iobase = info->p_dev->io.BasePort1;
351 spin_lock(&(info->lock));
353 iir = inb(iobase + CONTROL);
355 int stat = bt3c_read(iobase, 0x7001);
357 if ((stat & 0xff) == 0x7f) {
358 BT_ERR("Very strange (stat=0x%04x)", stat);
359 } else if ((stat & 0xff) != 0xff) {
361 int stat = bt3c_read(iobase, 0x7002) & 0x10;
362 BT_INFO("%s: Antenna %s", info->hdev->name,
363 stat ? "out" : "in");
368 //BT_ERR("Ack (stat=0x%04x)", stat);
369 clear_bit(XMIT_SENDING, &(info->tx_state));
370 bt3c_write_wakeup(info);
373 bt3c_io_write(iobase, 0x7001, 0x0000);
375 outb(iir, iobase + CONTROL);
379 spin_unlock(&(info->lock));
386 /* ======================== HCI interface ======================== */
389 static int bt3c_hci_flush(struct hci_dev *hdev)
391 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
394 skb_queue_purge(&(info->txq));
400 static int bt3c_hci_open(struct hci_dev *hdev)
402 set_bit(HCI_RUNNING, &(hdev->flags));
408 static int bt3c_hci_close(struct hci_dev *hdev)
410 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
413 bt3c_hci_flush(hdev);
419 static int bt3c_hci_send_frame(struct sk_buff *skb)
422 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
426 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
430 info = (bt3c_info_t *) (hdev->driver_data);
432 switch (bt_cb(skb)->pkt_type) {
433 case HCI_COMMAND_PKT:
436 case HCI_ACLDATA_PKT:
439 case HCI_SCODATA_PKT:
444 /* Prepend skb with frame type */
445 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
446 skb_queue_tail(&(info->txq), skb);
448 spin_lock_irqsave(&(info->lock), flags);
450 bt3c_write_wakeup(info);
452 spin_unlock_irqrestore(&(info->lock), flags);
458 static void bt3c_hci_destruct(struct hci_dev *hdev)
463 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
470 /* ======================== Card services HCI interaction ======================== */
473 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
475 char *ptr = (char *) firmware;
477 unsigned int iobase, size, addr, fcs, tmp;
480 iobase = info->p_dev->io.BasePort1;
483 bt3c_io_write(iobase, 0x8040, 0x0404);
484 bt3c_io_write(iobase, 0x8040, 0x0400);
488 bt3c_io_write(iobase, 0x8040, 0x0404);
495 BT_ERR("Bad address in firmware");
500 memset(b, 0, sizeof(b));
501 memcpy(b, ptr + 2, 2);
502 size = simple_strtol(b, NULL, 16);
504 memset(b, 0, sizeof(b));
505 memcpy(b, ptr + 4, 8);
506 addr = simple_strtol(b, NULL, 16);
508 memset(b, 0, sizeof(b));
509 memcpy(b, ptr + (size * 2) + 2, 2);
510 fcs = simple_strtol(b, NULL, 16);
512 memset(b, 0, sizeof(b));
513 for (tmp = 0, i = 0; i < size; i++) {
514 memcpy(b, ptr + (i * 2) + 2, 2);
515 tmp += simple_strtol(b, NULL, 16);
518 if (((tmp + fcs) & 0xff) != 0xff) {
519 BT_ERR("Checksum error in firmware");
525 bt3c_address(iobase, addr);
527 memset(b, 0, sizeof(b));
528 for (i = 0; i < (size - 4) / 2; i++) {
529 memcpy(b, ptr + (i * 4) + 12, 4);
530 tmp = simple_strtol(b, NULL, 16);
531 bt3c_put(iobase, tmp);
535 ptr += (size * 2) + 6;
536 count -= (size * 2) + 6;
542 bt3c_address(iobase, 0x3000);
543 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
549 bt3c_io_write(iobase, 0x7006, 0x0000);
550 bt3c_io_write(iobase, 0x7005, 0x0000);
551 bt3c_io_write(iobase, 0x7001, 0x0000);
557 static int bt3c_open(bt3c_info_t *info)
559 const struct firmware *firmware;
560 struct hci_dev *hdev;
563 spin_lock_init(&(info->lock));
565 skb_queue_head_init(&(info->txq));
567 info->rx_state = RECV_WAIT_PACKET_TYPE;
571 /* Initialize HCI device */
572 hdev = hci_alloc_dev();
574 BT_ERR("Can't allocate HCI device");
580 hdev->type = HCI_PCCARD;
581 hdev->driver_data = info;
582 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
584 hdev->open = bt3c_hci_open;
585 hdev->close = bt3c_hci_close;
586 hdev->flush = bt3c_hci_flush;
587 hdev->send = bt3c_hci_send_frame;
588 hdev->destruct = bt3c_hci_destruct;
589 hdev->ioctl = bt3c_hci_ioctl;
591 hdev->owner = THIS_MODULE;
594 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
596 BT_ERR("Firmware request failed");
600 err = bt3c_load_firmware(info, firmware->data, firmware->size);
602 release_firmware(firmware);
605 BT_ERR("Firmware loading failed");
609 /* Timeout before it is safe to send the first HCI packet */
612 /* Register HCI device */
613 err = hci_register_dev(hdev);
615 BT_ERR("Can't register HCI device");
628 static int bt3c_close(bt3c_info_t *info)
630 struct hci_dev *hdev = info->hdev;
635 bt3c_hci_close(hdev);
637 if (hci_unregister_dev(hdev) < 0)
638 BT_ERR("Can't unregister HCI device %s", hdev->name);
645 static int bt3c_probe(struct pcmcia_device *link)
649 /* Create new info device */
650 info = kzalloc(sizeof(*info), GFP_KERNEL);
657 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
658 link->io.NumPorts1 = 8;
659 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
660 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
662 link->irq.Handler = bt3c_interrupt;
663 link->irq.Instance = info;
665 link->conf.Attributes = CONF_ENABLE_IRQ;
666 link->conf.IntType = INT_MEMORY_AND_IO;
668 return bt3c_config(link);
672 static void bt3c_detach(struct pcmcia_device *link)
674 bt3c_info_t *info = link->priv;
680 static int get_tuple(struct pcmcia_device *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(struct pcmcia_device *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(struct pcmcia_device *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 int bt3c_config(struct pcmcia_device *link)
707 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
708 bt3c_info_t *info = link->priv;
712 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
715 /* First pass: look for a config entry that looks normal. */
716 tuple.TupleData = (cisdata_t *)buf;
717 tuple.TupleOffset = 0;
718 tuple.TupleDataMax = 255;
719 tuple.Attributes = 0;
720 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
721 /* Two tries: without IO aliases, then with aliases */
722 for (try = 0; try < 2; try++) {
723 i = first_tuple(link, &tuple, &parse);
724 while (i != CS_NO_MORE_ITEMS) {
727 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
728 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
729 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
730 link->conf.ConfigIndex = cf->index;
731 link->io.BasePort1 = cf->io.win[0].base;
732 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
733 i = pcmcia_request_io(link, &link->io);
738 i = next_tuple(link, &tuple, &parse);
742 /* Second pass: try to find an entry that isn't picky about
743 its base address, then try to grab any standard serial port
744 address, and finally try to get any free port. */
745 i = first_tuple(link, &tuple, &parse);
746 while (i != CS_NO_MORE_ITEMS) {
747 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
748 link->conf.ConfigIndex = cf->index;
749 for (j = 0; j < 5; j++) {
750 link->io.BasePort1 = base[j];
751 link->io.IOAddrLines = base[j] ? 16 : 3;
752 i = pcmcia_request_io(link, &link->io);
757 i = next_tuple(link, &tuple, &parse);
761 if (i != CS_SUCCESS) {
762 BT_ERR("No usable port range found");
763 cs_error(link, RequestIO, i);
767 i = pcmcia_request_irq(link, &link->irq);
768 if (i != CS_SUCCESS) {
769 cs_error(link, RequestIRQ, i);
770 link->irq.AssignedIRQ = 0;
773 i = pcmcia_request_configuration(link, &link->conf);
774 if (i != CS_SUCCESS) {
775 cs_error(link, RequestConfiguration, i);
779 if (bt3c_open(info) != 0)
782 strcpy(info->node.dev_name, info->hdev->name);
783 link->dev_node = &info->node;
793 static void bt3c_release(struct pcmcia_device *link)
795 bt3c_info_t *info = link->priv;
799 pcmcia_disable_device(link);
803 static struct pcmcia_device_id bt3c_ids[] = {
804 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
807 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
809 static struct pcmcia_driver bt3c_driver = {
810 .owner = THIS_MODULE,
815 .remove = bt3c_detach,
816 .id_table = bt3c_ids,
819 static int __init init_bt3c_cs(void)
821 return pcmcia_register_driver(&bt3c_driver);
825 static void __exit exit_bt3c_cs(void)
827 pcmcia_unregister_driver(&bt3c_driver);
830 module_init(init_bt3c_cs);
831 module_exit(exit_bt3c_cs);