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 ======================== */
70 typedef struct bt3c_info_t {
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(bt3c_info_t *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);
205 if (len != skb->len) {
206 BT_ERR("Very strange");
211 info->hdev->stat.byte_tx += len;
217 static void bt3c_receive(bt3c_info_t *info)
223 BT_ERR("Unknown device");
227 iobase = info->p_dev->resource[0]->start;
229 avail = bt3c_read(iobase, 0x7006);
230 //printk("bt3c_cs: receiving %d bytes\n", avail);
232 bt3c_address(iobase, 0x7480);
233 while (size < avail) {
235 info->hdev->stat.byte_rx++;
237 /* Allocate packet */
238 if (info->rx_skb == NULL) {
239 info->rx_state = RECV_WAIT_PACKET_TYPE;
241 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 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
252 inb(iobase + DATA_H);
253 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
255 switch (bt_cb(info->rx_skb)->pkt_type) {
258 info->rx_state = RECV_WAIT_EVENT_HEADER;
259 info->rx_count = HCI_EVENT_HDR_SIZE;
262 case HCI_ACLDATA_PKT:
263 info->rx_state = RECV_WAIT_ACL_HEADER;
264 info->rx_count = HCI_ACL_HDR_SIZE;
267 case HCI_SCODATA_PKT:
268 info->rx_state = RECV_WAIT_SCO_HEADER;
269 info->rx_count = HCI_SCO_HDR_SIZE;
274 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
275 info->hdev->stat.err_rx++;
276 clear_bit(HCI_RUNNING, &(info->hdev->flags));
278 kfree_skb(info->rx_skb);
286 __u8 x = inb(iobase + DATA_L);
288 *skb_put(info->rx_skb, 1) = x;
289 inb(iobase + DATA_H);
292 if (info->rx_count == 0) {
295 struct hci_event_hdr *eh;
296 struct hci_acl_hdr *ah;
297 struct hci_sco_hdr *sh;
299 switch (info->rx_state) {
301 case RECV_WAIT_EVENT_HEADER:
302 eh = hci_event_hdr(info->rx_skb);
303 info->rx_state = RECV_WAIT_DATA;
304 info->rx_count = eh->plen;
307 case RECV_WAIT_ACL_HEADER:
308 ah = hci_acl_hdr(info->rx_skb);
309 dlen = __le16_to_cpu(ah->dlen);
310 info->rx_state = RECV_WAIT_DATA;
311 info->rx_count = dlen;
314 case RECV_WAIT_SCO_HEADER:
315 sh = hci_sco_hdr(info->rx_skb);
316 info->rx_state = RECV_WAIT_DATA;
317 info->rx_count = sh->dlen;
321 hci_recv_frame(info->hdev, info->rx_skb);
333 bt3c_io_write(iobase, 0x7006, 0x0000);
337 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
339 bt3c_info_t *info = dev_inst;
342 irqreturn_t r = IRQ_NONE;
344 if (!info || !info->hdev)
345 /* our irq handler is shared */
348 iobase = info->p_dev->resource[0]->start;
350 spin_lock(&(info->lock));
352 iir = inb(iobase + CONTROL);
354 int stat = bt3c_read(iobase, 0x7001);
356 if ((stat & 0xff) == 0x7f) {
357 BT_ERR("Very strange (stat=0x%04x)", stat);
358 } else if ((stat & 0xff) != 0xff) {
360 int status = bt3c_read(iobase, 0x7002) & 0x10;
361 BT_INFO("%s: Antenna %s", info->hdev->name,
362 status ? "out" : "in");
367 //BT_ERR("Ack (stat=0x%04x)", stat);
368 clear_bit(XMIT_SENDING, &(info->tx_state));
369 bt3c_write_wakeup(info);
372 bt3c_io_write(iobase, 0x7001, 0x0000);
374 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 = hci_get_drvdata(hdev);
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 hci_dev *hdev, struct sk_buff *skb)
421 bt3c_info_t *info = hci_get_drvdata(hdev);
424 switch (bt_cb(skb)->pkt_type) {
425 case HCI_COMMAND_PKT:
428 case HCI_ACLDATA_PKT:
431 case HCI_SCODATA_PKT:
436 /* Prepend skb with frame type */
437 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
438 skb_queue_tail(&(info->txq), skb);
440 spin_lock_irqsave(&(info->lock), flags);
442 bt3c_write_wakeup(info);
444 spin_unlock_irqrestore(&(info->lock), flags);
451 /* ======================== Card services HCI interaction ======================== */
454 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
457 char *ptr = (char *) firmware;
459 unsigned int iobase, size, addr, fcs, tmp;
462 iobase = info->p_dev->resource[0]->start;
465 bt3c_io_write(iobase, 0x8040, 0x0404);
466 bt3c_io_write(iobase, 0x8040, 0x0400);
470 bt3c_io_write(iobase, 0x8040, 0x0404);
477 BT_ERR("Bad address in firmware");
482 memset(b, 0, sizeof(b));
483 memcpy(b, ptr + 2, 2);
484 size = simple_strtoul(b, NULL, 16);
486 memset(b, 0, sizeof(b));
487 memcpy(b, ptr + 4, 8);
488 addr = simple_strtoul(b, NULL, 16);
490 memset(b, 0, sizeof(b));
491 memcpy(b, ptr + (size * 2) + 2, 2);
492 fcs = simple_strtoul(b, NULL, 16);
494 memset(b, 0, sizeof(b));
495 for (tmp = 0, i = 0; i < size; i++) {
496 memcpy(b, ptr + (i * 2) + 2, 2);
497 tmp += simple_strtol(b, NULL, 16);
500 if (((tmp + fcs) & 0xff) != 0xff) {
501 BT_ERR("Checksum error in firmware");
507 bt3c_address(iobase, addr);
509 memset(b, 0, sizeof(b));
510 for (i = 0; i < (size - 4) / 2; i++) {
511 memcpy(b, ptr + (i * 4) + 12, 4);
512 tmp = simple_strtoul(b, NULL, 16);
513 bt3c_put(iobase, tmp);
517 ptr += (size * 2) + 6;
518 count -= (size * 2) + 6;
524 bt3c_address(iobase, 0x3000);
525 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
531 bt3c_io_write(iobase, 0x7006, 0x0000);
532 bt3c_io_write(iobase, 0x7005, 0x0000);
533 bt3c_io_write(iobase, 0x7001, 0x0000);
539 static int bt3c_open(bt3c_info_t *info)
541 const struct firmware *firmware;
542 struct hci_dev *hdev;
545 spin_lock_init(&(info->lock));
547 skb_queue_head_init(&(info->txq));
549 info->rx_state = RECV_WAIT_PACKET_TYPE;
553 /* Initialize HCI device */
554 hdev = hci_alloc_dev();
556 BT_ERR("Can't allocate HCI device");
562 hdev->bus = HCI_PCCARD;
563 hci_set_drvdata(hdev, info);
564 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
566 hdev->open = bt3c_hci_open;
567 hdev->close = bt3c_hci_close;
568 hdev->flush = bt3c_hci_flush;
569 hdev->send = bt3c_hci_send_frame;
572 err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
574 BT_ERR("Firmware request failed");
578 err = bt3c_load_firmware(info, firmware->data, firmware->size);
580 release_firmware(firmware);
583 BT_ERR("Firmware loading failed");
587 /* Timeout before it is safe to send the first HCI packet */
590 /* Register HCI device */
591 err = hci_register_dev(hdev);
593 BT_ERR("Can't register HCI device");
606 static int bt3c_close(bt3c_info_t *info)
608 struct hci_dev *hdev = info->hdev;
613 bt3c_hci_close(hdev);
615 hci_unregister_dev(hdev);
621 static int bt3c_probe(struct pcmcia_device *link)
625 /* Create new info device */
626 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
633 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
636 return bt3c_config(link);
640 static void bt3c_detach(struct pcmcia_device *link)
645 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
647 int *try = priv_data;
650 p_dev->io_lines = 16;
652 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
655 p_dev->resource[0]->end = 8;
656 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
657 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
659 return pcmcia_request_io(p_dev);
662 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
665 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
668 if (p_dev->io_lines > 3)
671 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
672 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
673 p_dev->resource[0]->end = 8;
675 for (j = 0; j < 5; j++) {
676 p_dev->resource[0]->start = base[j];
677 p_dev->io_lines = base[j] ? 16 : 3;
678 if (!pcmcia_request_io(p_dev))
684 static int bt3c_config(struct pcmcia_device *link)
686 bt3c_info_t *info = link->priv;
690 /* First pass: look for a config entry that looks normal.
691 Two tries: without IO aliases, then with aliases */
692 for (try = 0; try < 2; try++)
693 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
696 /* Second pass: try to find an entry that isn't picky about
697 its base address, then try to grab any standard serial port
698 address, and finally try to get any free port. */
699 if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
702 BT_ERR("No usable port range found");
706 i = pcmcia_request_irq(link, &bt3c_interrupt);
710 i = pcmcia_enable_device(link);
714 if (bt3c_open(info) != 0)
725 static void bt3c_release(struct pcmcia_device *link)
727 bt3c_info_t *info = link->priv;
731 pcmcia_disable_device(link);
735 static const struct pcmcia_device_id bt3c_ids[] = {
736 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
739 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
741 static struct pcmcia_driver bt3c_driver = {
742 .owner = THIS_MODULE,
745 .remove = bt3c_detach,
746 .id_table = bt3c_ids,
748 module_pcmcia_driver(bt3c_driver);