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/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 the 3Com Bluetooth PCMCIA card");
63 MODULE_LICENSE("GPL");
64 MODULE_FIRMWARE("BT3CPCC.bin");
68 /* ======================== Local structures ======================== */
71 typedef struct bt3c_info_t {
72 struct pcmcia_device *p_dev;
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;
87 static int bt3c_config(struct pcmcia_device *link);
88 static void bt3c_release(struct pcmcia_device *link);
90 static void bt3c_detach(struct pcmcia_device *p_dev);
94 #define XMIT_SENDING 1
96 #define XMIT_WAITING 8
99 #define RECV_WAIT_PACKET_TYPE 0
100 #define RECV_WAIT_EVENT_HEADER 1
101 #define RECV_WAIT_ACL_HEADER 2
102 #define RECV_WAIT_SCO_HEADER 3
103 #define RECV_WAIT_DATA 4
107 /* ======================== Special I/O functions ======================== */
117 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
119 outb(addr & 0xff, iobase + ADDR_L);
120 outb((addr >> 8) & 0xff, iobase + ADDR_H);
124 static inline void bt3c_put(unsigned int iobase, unsigned short value)
126 outb(value & 0xff, iobase + DATA_L);
127 outb((value >> 8) & 0xff, iobase + DATA_H);
131 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
133 bt3c_address(iobase, addr);
134 bt3c_put(iobase, value);
138 static inline unsigned short bt3c_get(unsigned int iobase)
140 unsigned short value = inb(iobase + DATA_L);
142 value |= inb(iobase + DATA_H) << 8;
148 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
150 bt3c_address(iobase, addr);
152 return bt3c_get(iobase);
157 /* ======================== Interrupt handling ======================== */
160 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
164 bt3c_address(iobase, 0x7080);
166 /* Fill FIFO with current frame */
167 while (actual < len) {
168 /* Transmit next byte */
169 bt3c_put(iobase, buf[actual]);
173 bt3c_io_write(iobase, 0x7005, actual);
179 static void bt3c_write_wakeup(bt3c_info_t *info)
182 BT_ERR("Unknown device");
186 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
190 register unsigned int iobase = info->p_dev->resource[0]->start;
191 register struct sk_buff *skb;
194 if (!pcmcia_dev_present(info->p_dev))
198 if (!(skb = skb_dequeue(&(info->txq)))) {
199 clear_bit(XMIT_SENDING, &(info->tx_state));
204 len = bt3c_write(iobase, 256, skb->data, skb->len);
206 if (len != skb->len) {
207 BT_ERR("Very strange");
212 info->hdev->stat.byte_tx += len;
218 static void bt3c_receive(bt3c_info_t *info)
224 BT_ERR("Unknown device");
228 iobase = info->p_dev->resource[0]->start;
230 avail = bt3c_read(iobase, 0x7006);
231 //printk("bt3c_cs: receiving %d bytes\n", avail);
233 bt3c_address(iobase, 0x7480);
234 while (size < avail) {
236 info->hdev->stat.byte_rx++;
238 /* Allocate packet */
239 if (info->rx_skb == NULL) {
240 info->rx_state = RECV_WAIT_PACKET_TYPE;
242 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
243 BT_ERR("Can't allocate mem for new packet");
249 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
251 info->rx_skb->dev = (void *) info->hdev;
252 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
253 inb(iobase + DATA_H);
254 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
256 switch (bt_cb(info->rx_skb)->pkt_type) {
259 info->rx_state = RECV_WAIT_EVENT_HEADER;
260 info->rx_count = HCI_EVENT_HDR_SIZE;
263 case HCI_ACLDATA_PKT:
264 info->rx_state = RECV_WAIT_ACL_HEADER;
265 info->rx_count = HCI_ACL_HDR_SIZE;
268 case HCI_SCODATA_PKT:
269 info->rx_state = RECV_WAIT_SCO_HEADER;
270 info->rx_count = HCI_SCO_HDR_SIZE;
275 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
276 info->hdev->stat.err_rx++;
277 clear_bit(HCI_RUNNING, &(info->hdev->flags));
279 kfree_skb(info->rx_skb);
287 __u8 x = inb(iobase + DATA_L);
289 *skb_put(info->rx_skb, 1) = x;
290 inb(iobase + DATA_H);
293 if (info->rx_count == 0) {
296 struct hci_event_hdr *eh;
297 struct hci_acl_hdr *ah;
298 struct hci_sco_hdr *sh;
300 switch (info->rx_state) {
302 case RECV_WAIT_EVENT_HEADER:
303 eh = hci_event_hdr(info->rx_skb);
304 info->rx_state = RECV_WAIT_DATA;
305 info->rx_count = eh->plen;
308 case RECV_WAIT_ACL_HEADER:
309 ah = hci_acl_hdr(info->rx_skb);
310 dlen = __le16_to_cpu(ah->dlen);
311 info->rx_state = RECV_WAIT_DATA;
312 info->rx_count = dlen;
315 case RECV_WAIT_SCO_HEADER:
316 sh = hci_sco_hdr(info->rx_skb);
317 info->rx_state = RECV_WAIT_DATA;
318 info->rx_count = sh->dlen;
322 hci_recv_frame(info->rx_skb);
334 bt3c_io_write(iobase, 0x7006, 0x0000);
338 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
340 bt3c_info_t *info = dev_inst;
343 irqreturn_t r = IRQ_NONE;
345 if (!info || !info->hdev)
346 /* our irq handler is shared */
349 iobase = info->p_dev->resource[0]->start;
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 status = bt3c_read(iobase, 0x7002) & 0x10;
362 BT_INFO("%s: Antenna %s", info->hdev->name,
363 status ? "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);
380 spin_unlock(&(info->lock));
387 /* ======================== HCI interface ======================== */
390 static int bt3c_hci_flush(struct hci_dev *hdev)
392 bt3c_info_t *info = hci_get_drvdata(hdev);
395 skb_queue_purge(&(info->txq));
401 static int bt3c_hci_open(struct hci_dev *hdev)
403 set_bit(HCI_RUNNING, &(hdev->flags));
409 static int bt3c_hci_close(struct hci_dev *hdev)
411 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
414 bt3c_hci_flush(hdev);
420 static int bt3c_hci_send_frame(struct sk_buff *skb)
423 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
427 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
431 info = hci_get_drvdata(hdev);
433 switch (bt_cb(skb)->pkt_type) {
434 case HCI_COMMAND_PKT:
437 case HCI_ACLDATA_PKT:
440 case HCI_SCODATA_PKT:
445 /* Prepend skb with frame type */
446 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
447 skb_queue_tail(&(info->txq), skb);
449 spin_lock_irqsave(&(info->lock), flags);
451 bt3c_write_wakeup(info);
453 spin_unlock_irqrestore(&(info->lock), flags);
459 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
466 /* ======================== Card services HCI interaction ======================== */
469 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
472 char *ptr = (char *) firmware;
474 unsigned int iobase, size, addr, fcs, tmp;
477 iobase = info->p_dev->resource[0]->start;
480 bt3c_io_write(iobase, 0x8040, 0x0404);
481 bt3c_io_write(iobase, 0x8040, 0x0400);
485 bt3c_io_write(iobase, 0x8040, 0x0404);
492 BT_ERR("Bad address in firmware");
497 memset(b, 0, sizeof(b));
498 memcpy(b, ptr + 2, 2);
499 size = simple_strtoul(b, NULL, 16);
501 memset(b, 0, sizeof(b));
502 memcpy(b, ptr + 4, 8);
503 addr = simple_strtoul(b, NULL, 16);
505 memset(b, 0, sizeof(b));
506 memcpy(b, ptr + (size * 2) + 2, 2);
507 fcs = simple_strtoul(b, NULL, 16);
509 memset(b, 0, sizeof(b));
510 for (tmp = 0, i = 0; i < size; i++) {
511 memcpy(b, ptr + (i * 2) + 2, 2);
512 tmp += simple_strtol(b, NULL, 16);
515 if (((tmp + fcs) & 0xff) != 0xff) {
516 BT_ERR("Checksum error in firmware");
522 bt3c_address(iobase, addr);
524 memset(b, 0, sizeof(b));
525 for (i = 0; i < (size - 4) / 2; i++) {
526 memcpy(b, ptr + (i * 4) + 12, 4);
527 tmp = simple_strtoul(b, NULL, 16);
528 bt3c_put(iobase, tmp);
532 ptr += (size * 2) + 6;
533 count -= (size * 2) + 6;
539 bt3c_address(iobase, 0x3000);
540 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
546 bt3c_io_write(iobase, 0x7006, 0x0000);
547 bt3c_io_write(iobase, 0x7005, 0x0000);
548 bt3c_io_write(iobase, 0x7001, 0x0000);
554 static int bt3c_open(bt3c_info_t *info)
556 const struct firmware *firmware;
557 struct hci_dev *hdev;
560 spin_lock_init(&(info->lock));
562 skb_queue_head_init(&(info->txq));
564 info->rx_state = RECV_WAIT_PACKET_TYPE;
568 /* Initialize HCI device */
569 hdev = hci_alloc_dev();
571 BT_ERR("Can't allocate HCI device");
577 hdev->bus = HCI_PCCARD;
578 hci_set_drvdata(hdev, info);
579 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
581 hdev->open = bt3c_hci_open;
582 hdev->close = bt3c_hci_close;
583 hdev->flush = bt3c_hci_flush;
584 hdev->send = bt3c_hci_send_frame;
585 hdev->ioctl = bt3c_hci_ioctl;
588 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
590 BT_ERR("Firmware request failed");
594 err = bt3c_load_firmware(info, firmware->data, firmware->size);
596 release_firmware(firmware);
599 BT_ERR("Firmware loading failed");
603 /* Timeout before it is safe to send the first HCI packet */
606 /* Register HCI device */
607 err = hci_register_dev(hdev);
609 BT_ERR("Can't register HCI device");
622 static int bt3c_close(bt3c_info_t *info)
624 struct hci_dev *hdev = info->hdev;
629 bt3c_hci_close(hdev);
631 hci_unregister_dev(hdev);
637 static int bt3c_probe(struct pcmcia_device *link)
641 /* Create new info device */
642 info = kzalloc(sizeof(*info), GFP_KERNEL);
649 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
652 return bt3c_config(link);
656 static void bt3c_detach(struct pcmcia_device *link)
658 bt3c_info_t *info = link->priv;
664 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
666 int *try = priv_data;
669 p_dev->io_lines = 16;
671 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
674 p_dev->resource[0]->end = 8;
675 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
676 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
678 return pcmcia_request_io(p_dev);
681 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
684 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
687 if (p_dev->io_lines > 3)
690 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
691 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
692 p_dev->resource[0]->end = 8;
694 for (j = 0; j < 5; j++) {
695 p_dev->resource[0]->start = base[j];
696 p_dev->io_lines = base[j] ? 16 : 3;
697 if (!pcmcia_request_io(p_dev))
703 static int bt3c_config(struct pcmcia_device *link)
705 bt3c_info_t *info = link->priv;
709 /* First pass: look for a config entry that looks normal.
710 Two tries: without IO aliases, then with aliases */
711 for (try = 0; try < 2; try++)
712 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
715 /* Second pass: try to find an entry that isn't picky about
716 its base address, then try to grab any standard serial port
717 address, and finally try to get any free port. */
718 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
721 BT_ERR("No usable port range found");
725 i = pcmcia_request_irq(link, &bt3c_interrupt);
729 i = pcmcia_enable_device(link);
733 if (bt3c_open(info) != 0)
744 static void bt3c_release(struct pcmcia_device *link)
746 bt3c_info_t *info = link->priv;
750 pcmcia_disable_device(link);
754 static const struct pcmcia_device_id bt3c_ids[] = {
755 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
758 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
760 static struct pcmcia_driver bt3c_driver = {
761 .owner = THIS_MODULE,
764 .remove = bt3c_detach,
765 .id_table = bt3c_ids,
768 static int __init init_bt3c_cs(void)
770 return pcmcia_register_driver(&bt3c_driver);
774 static void __exit exit_bt3c_cs(void)
776 pcmcia_unregister_driver(&bt3c_driver);
779 module_init(init_bt3c_cs);
780 module_exit(exit_bt3c_cs);