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>
44 #include <linux/device.h>
45 #include <linux/firmware.h>
47 #include <pcmcia/cistpl.h>
48 #include <pcmcia/ciscode.h>
49 #include <pcmcia/ds.h>
50 #include <pcmcia/cisreg.h>
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
57 /* ======================== Module parameters ======================== */
60 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
61 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
62 MODULE_LICENSE("GPL");
63 MODULE_FIRMWARE("BT3CPCC.bin");
67 /* ======================== Local structures ======================== */
71 struct pcmcia_device *p_dev;
75 spinlock_t lock; /* For serializing operations */
77 struct sk_buff_head txq;
78 unsigned long tx_state;
80 unsigned long rx_state;
81 unsigned long rx_count;
82 struct sk_buff *rx_skb;
86 static int bt3c_config(struct pcmcia_device *link);
87 static void bt3c_release(struct pcmcia_device *link);
89 static void bt3c_detach(struct pcmcia_device *p_dev);
93 #define XMIT_SENDING 1
95 #define XMIT_WAITING 8
98 #define RECV_WAIT_PACKET_TYPE 0
99 #define RECV_WAIT_EVENT_HEADER 1
100 #define RECV_WAIT_ACL_HEADER 2
101 #define RECV_WAIT_SCO_HEADER 3
102 #define RECV_WAIT_DATA 4
106 /* ======================== Special I/O functions ======================== */
116 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
118 outb(addr & 0xff, iobase + ADDR_L);
119 outb((addr >> 8) & 0xff, iobase + ADDR_H);
123 static inline void bt3c_put(unsigned int iobase, unsigned short value)
125 outb(value & 0xff, iobase + DATA_L);
126 outb((value >> 8) & 0xff, iobase + DATA_H);
130 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
132 bt3c_address(iobase, addr);
133 bt3c_put(iobase, value);
137 static inline unsigned short bt3c_get(unsigned int iobase)
139 unsigned short value = inb(iobase + DATA_L);
141 value |= inb(iobase + DATA_H) << 8;
147 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
149 bt3c_address(iobase, addr);
151 return bt3c_get(iobase);
156 /* ======================== Interrupt handling ======================== */
159 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
163 bt3c_address(iobase, 0x7080);
165 /* Fill FIFO with current frame */
166 while (actual < len) {
167 /* Transmit next byte */
168 bt3c_put(iobase, buf[actual]);
172 bt3c_io_write(iobase, 0x7005, actual);
178 static void bt3c_write_wakeup(struct bt3c_info *info)
181 BT_ERR("Unknown device");
185 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
189 unsigned int iobase = info->p_dev->resource[0]->start;
190 register struct sk_buff *skb;
193 if (!pcmcia_dev_present(info->p_dev))
196 skb = skb_dequeue(&(info->txq));
198 clear_bit(XMIT_SENDING, &(info->tx_state));
203 len = bt3c_write(iobase, 256, skb->data, skb->len);
206 BT_ERR("Very strange");
210 info->hdev->stat.byte_tx += len;
216 static void bt3c_receive(struct bt3c_info *info)
222 BT_ERR("Unknown device");
226 iobase = info->p_dev->resource[0]->start;
228 avail = bt3c_read(iobase, 0x7006);
230 bt3c_address(iobase, 0x7480);
231 while (size < avail) {
233 info->hdev->stat.byte_rx++;
235 /* Allocate packet */
236 if (info->rx_skb == NULL) {
237 info->rx_state = RECV_WAIT_PACKET_TYPE;
239 info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
241 BT_ERR("Can't allocate mem for new packet");
247 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
249 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
250 inb(iobase + DATA_H);
252 switch (bt_cb(info->rx_skb)->pkt_type) {
255 info->rx_state = RECV_WAIT_EVENT_HEADER;
256 info->rx_count = HCI_EVENT_HDR_SIZE;
259 case HCI_ACLDATA_PKT:
260 info->rx_state = RECV_WAIT_ACL_HEADER;
261 info->rx_count = HCI_ACL_HDR_SIZE;
264 case HCI_SCODATA_PKT:
265 info->rx_state = RECV_WAIT_SCO_HEADER;
266 info->rx_count = HCI_SCO_HDR_SIZE;
271 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
272 info->hdev->stat.err_rx++;
273 clear_bit(HCI_RUNNING, &(info->hdev->flags));
275 kfree_skb(info->rx_skb);
283 __u8 x = inb(iobase + DATA_L);
285 *skb_put(info->rx_skb, 1) = x;
286 inb(iobase + DATA_H);
289 if (info->rx_count == 0) {
292 struct hci_event_hdr *eh;
293 struct hci_acl_hdr *ah;
294 struct hci_sco_hdr *sh;
296 switch (info->rx_state) {
298 case RECV_WAIT_EVENT_HEADER:
299 eh = hci_event_hdr(info->rx_skb);
300 info->rx_state = RECV_WAIT_DATA;
301 info->rx_count = eh->plen;
304 case RECV_WAIT_ACL_HEADER:
305 ah = hci_acl_hdr(info->rx_skb);
306 dlen = __le16_to_cpu(ah->dlen);
307 info->rx_state = RECV_WAIT_DATA;
308 info->rx_count = dlen;
311 case RECV_WAIT_SCO_HEADER:
312 sh = hci_sco_hdr(info->rx_skb);
313 info->rx_state = RECV_WAIT_DATA;
314 info->rx_count = sh->dlen;
318 hci_recv_frame(info->hdev, info->rx_skb);
330 bt3c_io_write(iobase, 0x7006, 0x0000);
334 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
336 struct bt3c_info *info = dev_inst;
339 irqreturn_t r = IRQ_NONE;
341 if (!info || !info->hdev)
342 /* our irq handler is shared */
345 iobase = info->p_dev->resource[0]->start;
347 spin_lock(&(info->lock));
349 iir = inb(iobase + CONTROL);
351 int stat = bt3c_read(iobase, 0x7001);
353 if ((stat & 0xff) == 0x7f) {
354 BT_ERR("Very strange (stat=0x%04x)", stat);
355 } else if ((stat & 0xff) != 0xff) {
357 int status = bt3c_read(iobase, 0x7002) & 0x10;
358 BT_INFO("%s: Antenna %s", info->hdev->name,
359 status ? "out" : "in");
364 clear_bit(XMIT_SENDING, &(info->tx_state));
365 bt3c_write_wakeup(info);
368 bt3c_io_write(iobase, 0x7001, 0x0000);
370 outb(iir, iobase + CONTROL);
375 spin_unlock(&(info->lock));
382 /* ======================== HCI interface ======================== */
385 static int bt3c_hci_flush(struct hci_dev *hdev)
387 struct bt3c_info *info = hci_get_drvdata(hdev);
390 skb_queue_purge(&(info->txq));
396 static int bt3c_hci_open(struct hci_dev *hdev)
398 set_bit(HCI_RUNNING, &(hdev->flags));
404 static int bt3c_hci_close(struct hci_dev *hdev)
406 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
409 bt3c_hci_flush(hdev);
415 static int bt3c_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
417 struct bt3c_info *info = hci_get_drvdata(hdev);
420 switch (bt_cb(skb)->pkt_type) {
421 case HCI_COMMAND_PKT:
424 case HCI_ACLDATA_PKT:
427 case HCI_SCODATA_PKT:
432 /* Prepend skb with frame type */
433 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
434 skb_queue_tail(&(info->txq), skb);
436 spin_lock_irqsave(&(info->lock), flags);
438 bt3c_write_wakeup(info);
440 spin_unlock_irqrestore(&(info->lock), flags);
447 /* ======================== Card services HCI interaction ======================== */
450 static int bt3c_load_firmware(struct bt3c_info *info,
451 const unsigned char *firmware,
454 char *ptr = (char *) firmware;
456 unsigned int iobase, tmp;
457 unsigned long size, addr, fcs;
460 iobase = info->p_dev->resource[0]->start;
463 bt3c_io_write(iobase, 0x8040, 0x0404);
464 bt3c_io_write(iobase, 0x8040, 0x0400);
468 bt3c_io_write(iobase, 0x8040, 0x0404);
475 BT_ERR("Bad address in firmware");
480 memset(b, 0, sizeof(b));
481 memcpy(b, ptr + 2, 2);
482 if (kstrtoul(b, 16, &size) < 0)
485 memset(b, 0, sizeof(b));
486 memcpy(b, ptr + 4, 8);
487 if (kstrtoul(b, 16, &addr) < 0)
490 memset(b, 0, sizeof(b));
491 memcpy(b, ptr + (size * 2) + 2, 2);
492 if (kstrtoul(b, 16, &fcs) < 0)
495 memset(b, 0, sizeof(b));
496 for (tmp = 0, i = 0; i < size; i++) {
497 memcpy(b, ptr + (i * 2) + 2, 2);
498 tmp += simple_strtol(b, NULL, 16);
501 if (((tmp + fcs) & 0xff) != 0xff) {
502 BT_ERR("Checksum error in firmware");
508 bt3c_address(iobase, addr);
510 memset(b, 0, sizeof(b));
511 for (i = 0; i < (size - 4) / 2; i++) {
512 memcpy(b, ptr + (i * 4) + 12, 4);
513 tmp = simple_strtoul(b, NULL, 16);
514 bt3c_put(iobase, tmp);
518 ptr += (size * 2) + 6;
519 count -= (size * 2) + 6;
525 bt3c_address(iobase, 0x3000);
526 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
532 bt3c_io_write(iobase, 0x7006, 0x0000);
533 bt3c_io_write(iobase, 0x7005, 0x0000);
534 bt3c_io_write(iobase, 0x7001, 0x0000);
540 static int bt3c_open(struct bt3c_info *info)
542 const struct firmware *firmware;
543 struct hci_dev *hdev;
546 spin_lock_init(&(info->lock));
548 skb_queue_head_init(&(info->txq));
550 info->rx_state = RECV_WAIT_PACKET_TYPE;
554 /* Initialize HCI device */
555 hdev = hci_alloc_dev();
557 BT_ERR("Can't allocate HCI device");
563 hdev->bus = HCI_PCCARD;
564 hci_set_drvdata(hdev, info);
565 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
567 hdev->open = bt3c_hci_open;
568 hdev->close = bt3c_hci_close;
569 hdev->flush = bt3c_hci_flush;
570 hdev->send = bt3c_hci_send_frame;
573 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
575 BT_ERR("Firmware request failed");
579 err = bt3c_load_firmware(info, firmware->data, firmware->size);
581 release_firmware(firmware);
584 BT_ERR("Firmware loading failed");
588 /* Timeout before it is safe to send the first HCI packet */
591 /* Register HCI device */
592 err = hci_register_dev(hdev);
594 BT_ERR("Can't register HCI device");
607 static int bt3c_close(struct bt3c_info *info)
609 struct hci_dev *hdev = info->hdev;
614 bt3c_hci_close(hdev);
616 hci_unregister_dev(hdev);
622 static int bt3c_probe(struct pcmcia_device *link)
624 struct bt3c_info *info;
626 /* Create new info device */
627 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
634 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
637 return bt3c_config(link);
641 static void bt3c_detach(struct pcmcia_device *link)
646 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
648 int *try = priv_data;
651 p_dev->io_lines = 16;
653 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
656 p_dev->resource[0]->end = 8;
657 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
658 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
660 return pcmcia_request_io(p_dev);
663 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
666 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
669 if (p_dev->io_lines > 3)
672 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
673 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
674 p_dev->resource[0]->end = 8;
676 for (j = 0; j < 5; j++) {
677 p_dev->resource[0]->start = base[j];
678 p_dev->io_lines = base[j] ? 16 : 3;
679 if (!pcmcia_request_io(p_dev))
685 static int bt3c_config(struct pcmcia_device *link)
687 struct bt3c_info *info = link->priv;
691 /* First pass: look for a config entry that looks normal.
692 Two tries: without IO aliases, then with aliases */
693 for (try = 0; try < 2; try++)
694 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
697 /* Second pass: try to find an entry that isn't picky about
698 its base address, then try to grab any standard serial port
699 address, and finally try to get any free port. */
700 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
703 BT_ERR("No usable port range found");
707 i = pcmcia_request_irq(link, &bt3c_interrupt);
711 i = pcmcia_enable_device(link);
715 if (bt3c_open(info) != 0)
726 static void bt3c_release(struct pcmcia_device *link)
728 struct bt3c_info *info = link->priv;
732 pcmcia_disable_device(link);
736 static const struct pcmcia_device_id bt3c_ids[] = {
737 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
740 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
742 static struct pcmcia_driver bt3c_driver = {
743 .owner = THIS_MODULE,
746 .remove = bt3c_detach,
747 .id_table = bt3c_ids,
749 module_pcmcia_driver(bt3c_driver);