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 {
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);
93 static int bt3c_event(event_t event, int priority, event_callback_args_t *args);
95 static dev_info_t dev_info = "bt3c_cs";
97 static dev_link_t *bt3c_attach(void);
98 static void bt3c_detach(struct pcmcia_device *p_dev);
101 /* Transmit states */
102 #define XMIT_SENDING 1
103 #define XMIT_WAKEUP 2
104 #define XMIT_WAITING 8
106 /* Receiver states */
107 #define RECV_WAIT_PACKET_TYPE 0
108 #define RECV_WAIT_EVENT_HEADER 1
109 #define RECV_WAIT_ACL_HEADER 2
110 #define RECV_WAIT_SCO_HEADER 3
111 #define RECV_WAIT_DATA 4
115 /* ======================== Special I/O functions ======================== */
125 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
127 outb(addr & 0xff, iobase + ADDR_L);
128 outb((addr >> 8) & 0xff, iobase + ADDR_H);
132 static inline void bt3c_put(unsigned int iobase, unsigned short value)
134 outb(value & 0xff, iobase + DATA_L);
135 outb((value >> 8) & 0xff, iobase + DATA_H);
139 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
141 bt3c_address(iobase, addr);
142 bt3c_put(iobase, value);
146 static inline unsigned short bt3c_get(unsigned int iobase)
148 unsigned short value = inb(iobase + DATA_L);
150 value |= inb(iobase + DATA_H) << 8;
156 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
158 bt3c_address(iobase, addr);
160 return bt3c_get(iobase);
165 /* ======================== Interrupt handling ======================== */
168 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
172 bt3c_address(iobase, 0x7080);
174 /* Fill FIFO with current frame */
175 while (actual < len) {
176 /* Transmit next byte */
177 bt3c_put(iobase, buf[actual]);
181 bt3c_io_write(iobase, 0x7005, actual);
187 static void bt3c_write_wakeup(bt3c_info_t *info)
190 BT_ERR("Unknown device");
194 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
198 register unsigned int iobase = info->link.io.BasePort1;
199 register struct sk_buff *skb;
202 if (!(info->link.state & DEV_PRESENT))
206 if (!(skb = skb_dequeue(&(info->txq)))) {
207 clear_bit(XMIT_SENDING, &(info->tx_state));
212 len = bt3c_write(iobase, 256, skb->data, skb->len);
214 if (len != skb->len) {
215 BT_ERR("Very strange");
220 info->hdev->stat.byte_tx += len;
226 static void bt3c_receive(bt3c_info_t *info)
232 BT_ERR("Unknown device");
236 iobase = info->link.io.BasePort1;
238 avail = bt3c_read(iobase, 0x7006);
239 //printk("bt3c_cs: receiving %d bytes\n", avail);
241 bt3c_address(iobase, 0x7480);
242 while (size < avail) {
244 info->hdev->stat.byte_rx++;
246 /* Allocate packet */
247 if (info->rx_skb == NULL) {
248 info->rx_state = RECV_WAIT_PACKET_TYPE;
250 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
251 BT_ERR("Can't allocate mem for new packet");
257 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
259 info->rx_skb->dev = (void *) info->hdev;
260 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
261 inb(iobase + DATA_H);
262 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
264 switch (bt_cb(info->rx_skb)->pkt_type) {
267 info->rx_state = RECV_WAIT_EVENT_HEADER;
268 info->rx_count = HCI_EVENT_HDR_SIZE;
271 case HCI_ACLDATA_PKT:
272 info->rx_state = RECV_WAIT_ACL_HEADER;
273 info->rx_count = HCI_ACL_HDR_SIZE;
276 case HCI_SCODATA_PKT:
277 info->rx_state = RECV_WAIT_SCO_HEADER;
278 info->rx_count = HCI_SCO_HDR_SIZE;
283 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
284 info->hdev->stat.err_rx++;
285 clear_bit(HCI_RUNNING, &(info->hdev->flags));
287 kfree_skb(info->rx_skb);
295 __u8 x = inb(iobase + DATA_L);
297 *skb_put(info->rx_skb, 1) = x;
298 inb(iobase + DATA_H);
301 if (info->rx_count == 0) {
304 struct hci_event_hdr *eh;
305 struct hci_acl_hdr *ah;
306 struct hci_sco_hdr *sh;
308 switch (info->rx_state) {
310 case RECV_WAIT_EVENT_HEADER:
311 eh = (struct hci_event_hdr *)(info->rx_skb->data);
312 info->rx_state = RECV_WAIT_DATA;
313 info->rx_count = eh->plen;
316 case RECV_WAIT_ACL_HEADER:
317 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
318 dlen = __le16_to_cpu(ah->dlen);
319 info->rx_state = RECV_WAIT_DATA;
320 info->rx_count = dlen;
323 case RECV_WAIT_SCO_HEADER:
324 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
325 info->rx_state = RECV_WAIT_DATA;
326 info->rx_count = sh->dlen;
330 hci_recv_frame(info->rx_skb);
342 bt3c_io_write(iobase, 0x7006, 0x0000);
346 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
348 bt3c_info_t *info = dev_inst;
352 if (!info || !info->hdev) {
353 BT_ERR("Call of irq %d for unknown device", irq);
357 iobase = info->link.io.BasePort1;
359 spin_lock(&(info->lock));
361 iir = inb(iobase + CONTROL);
363 int stat = bt3c_read(iobase, 0x7001);
365 if ((stat & 0xff) == 0x7f) {
366 BT_ERR("Very strange (stat=0x%04x)", stat);
367 } else if ((stat & 0xff) != 0xff) {
369 int stat = bt3c_read(iobase, 0x7002) & 0x10;
370 BT_INFO("%s: Antenna %s", info->hdev->name,
371 stat ? "out" : "in");
376 //BT_ERR("Ack (stat=0x%04x)", stat);
377 clear_bit(XMIT_SENDING, &(info->tx_state));
378 bt3c_write_wakeup(info);
381 bt3c_io_write(iobase, 0x7001, 0x0000);
383 outb(iir, iobase + CONTROL);
387 spin_unlock(&(info->lock));
394 /* ======================== HCI interface ======================== */
397 static int bt3c_hci_flush(struct hci_dev *hdev)
399 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
402 skb_queue_purge(&(info->txq));
408 static int bt3c_hci_open(struct hci_dev *hdev)
410 set_bit(HCI_RUNNING, &(hdev->flags));
416 static int bt3c_hci_close(struct hci_dev *hdev)
418 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
421 bt3c_hci_flush(hdev);
427 static int bt3c_hci_send_frame(struct sk_buff *skb)
430 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
434 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
438 info = (bt3c_info_t *) (hdev->driver_data);
440 switch (bt_cb(skb)->pkt_type) {
441 case HCI_COMMAND_PKT:
444 case HCI_ACLDATA_PKT:
447 case HCI_SCODATA_PKT:
452 /* Prepend skb with frame type */
453 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
454 skb_queue_tail(&(info->txq), skb);
456 spin_lock_irqsave(&(info->lock), flags);
458 bt3c_write_wakeup(info);
460 spin_unlock_irqrestore(&(info->lock), flags);
466 static void bt3c_hci_destruct(struct hci_dev *hdev)
471 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
478 /* ======================== Card services HCI interaction ======================== */
481 static struct device *bt3c_device(void)
483 static struct device dev = {
486 kobject_set_name(&dev.kobj, "bt3c");
487 kobject_init(&dev.kobj);
493 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
495 char *ptr = (char *) firmware;
497 unsigned int iobase, size, addr, fcs, tmp;
500 iobase = info->link.io.BasePort1;
503 bt3c_io_write(iobase, 0x8040, 0x0404);
504 bt3c_io_write(iobase, 0x8040, 0x0400);
508 bt3c_io_write(iobase, 0x8040, 0x0404);
515 BT_ERR("Bad address in firmware");
520 memset(b, 0, sizeof(b));
521 memcpy(b, ptr + 2, 2);
522 size = simple_strtol(b, NULL, 16);
524 memset(b, 0, sizeof(b));
525 memcpy(b, ptr + 4, 8);
526 addr = simple_strtol(b, NULL, 16);
528 memset(b, 0, sizeof(b));
529 memcpy(b, ptr + (size * 2) + 2, 2);
530 fcs = simple_strtol(b, NULL, 16);
532 memset(b, 0, sizeof(b));
533 for (tmp = 0, i = 0; i < size; i++) {
534 memcpy(b, ptr + (i * 2) + 2, 2);
535 tmp += simple_strtol(b, NULL, 16);
538 if (((tmp + fcs) & 0xff) != 0xff) {
539 BT_ERR("Checksum error in firmware");
545 bt3c_address(iobase, addr);
547 memset(b, 0, sizeof(b));
548 for (i = 0; i < (size - 4) / 2; i++) {
549 memcpy(b, ptr + (i * 4) + 12, 4);
550 tmp = simple_strtol(b, NULL, 16);
551 bt3c_put(iobase, tmp);
555 ptr += (size * 2) + 6;
556 count -= (size * 2) + 6;
562 bt3c_address(iobase, 0x3000);
563 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
569 bt3c_io_write(iobase, 0x7006, 0x0000);
570 bt3c_io_write(iobase, 0x7005, 0x0000);
571 bt3c_io_write(iobase, 0x7001, 0x0000);
577 static int bt3c_open(bt3c_info_t *info)
579 const struct firmware *firmware;
580 struct hci_dev *hdev;
583 spin_lock_init(&(info->lock));
585 skb_queue_head_init(&(info->txq));
587 info->rx_state = RECV_WAIT_PACKET_TYPE;
591 /* Initialize HCI device */
592 hdev = hci_alloc_dev();
594 BT_ERR("Can't allocate HCI device");
600 hdev->type = HCI_PCCARD;
601 hdev->driver_data = info;
603 hdev->open = bt3c_hci_open;
604 hdev->close = bt3c_hci_close;
605 hdev->flush = bt3c_hci_flush;
606 hdev->send = bt3c_hci_send_frame;
607 hdev->destruct = bt3c_hci_destruct;
608 hdev->ioctl = bt3c_hci_ioctl;
610 hdev->owner = THIS_MODULE;
613 err = request_firmware(&firmware, "BT3CPCC.bin", bt3c_device());
615 BT_ERR("Firmware request failed");
619 err = bt3c_load_firmware(info, firmware->data, firmware->size);
621 release_firmware(firmware);
624 BT_ERR("Firmware loading failed");
628 /* Timeout before it is safe to send the first HCI packet */
631 /* Register HCI device */
632 err = hci_register_dev(hdev);
634 BT_ERR("Can't register HCI device");
647 static int bt3c_close(bt3c_info_t *info)
649 struct hci_dev *hdev = info->hdev;
654 bt3c_hci_close(hdev);
656 if (hci_unregister_dev(hdev) < 0)
657 BT_ERR("Can't unregister HCI device %s", hdev->name);
664 static dev_link_t *bt3c_attach(void)
667 client_reg_t client_reg;
671 /* Create new info device */
672 info = kzalloc(sizeof(*info), GFP_KERNEL);
679 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
680 link->io.NumPorts1 = 8;
681 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
682 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
684 link->irq.Handler = bt3c_interrupt;
685 link->irq.Instance = info;
687 link->conf.Attributes = CONF_ENABLE_IRQ;
689 link->conf.IntType = INT_MEMORY_AND_IO;
691 /* Register with Card Services */
693 client_reg.dev_info = &dev_info;
694 client_reg.Version = 0x0210;
695 client_reg.event_callback_args.client_data = link;
697 ret = pcmcia_register_client(&link->handle, &client_reg);
698 if (ret != CS_SUCCESS) {
699 cs_error(link->handle, RegisterClient, ret);
700 bt3c_detach(link->handle);
708 static void bt3c_detach(struct pcmcia_device *p_dev)
710 dev_link_t *link = dev_to_instance(p_dev);
711 bt3c_info_t *info = link->priv;
713 if (link->state & DEV_CONFIG)
719 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
723 i = pcmcia_get_tuple_data(handle, tuple);
727 return pcmcia_parse_tuple(handle, tuple, parse);
730 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
732 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
733 return CS_NO_MORE_ITEMS;
734 return get_tuple(handle, tuple, parse);
737 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
739 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
740 return CS_NO_MORE_ITEMS;
741 return get_tuple(handle, tuple, parse);
744 static void bt3c_config(dev_link_t *link)
746 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
747 client_handle_t handle = link->handle;
748 bt3c_info_t *info = link->priv;
752 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
753 config_info_t config;
754 int i, j, try, last_ret, last_fn;
756 tuple.TupleData = (cisdata_t *)buf;
757 tuple.TupleOffset = 0;
758 tuple.TupleDataMax = 255;
759 tuple.Attributes = 0;
761 /* Get configuration register information */
762 tuple.DesiredTuple = CISTPL_CONFIG;
763 last_ret = first_tuple(handle, &tuple, &parse);
764 if (last_ret != CS_SUCCESS) {
765 last_fn = ParseTuple;
768 link->conf.ConfigBase = parse.config.base;
769 link->conf.Present = parse.config.rmask[0];
772 link->state |= DEV_CONFIG;
773 i = pcmcia_get_configuration_info(handle, &config);
774 link->conf.Vcc = config.Vcc;
776 /* First pass: look for a config entry that looks normal. */
777 tuple.TupleData = (cisdata_t *)buf;
778 tuple.TupleOffset = 0;
779 tuple.TupleDataMax = 255;
780 tuple.Attributes = 0;
781 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
782 /* Two tries: without IO aliases, then with aliases */
783 for (try = 0; try < 2; try++) {
784 i = first_tuple(handle, &tuple, &parse);
785 while (i != CS_NO_MORE_ITEMS) {
788 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
789 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
790 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
791 link->conf.ConfigIndex = cf->index;
792 link->io.BasePort1 = cf->io.win[0].base;
793 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
794 i = pcmcia_request_io(link->handle, &link->io);
799 i = next_tuple(handle, &tuple, &parse);
803 /* Second pass: try to find an entry that isn't picky about
804 its base address, then try to grab any standard serial port
805 address, and finally try to get any free port. */
806 i = first_tuple(handle, &tuple, &parse);
807 while (i != CS_NO_MORE_ITEMS) {
808 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
809 link->conf.ConfigIndex = cf->index;
810 for (j = 0; j < 5; j++) {
811 link->io.BasePort1 = base[j];
812 link->io.IOAddrLines = base[j] ? 16 : 3;
813 i = pcmcia_request_io(link->handle, &link->io);
818 i = next_tuple(handle, &tuple, &parse);
822 if (i != CS_SUCCESS) {
823 BT_ERR("No usable port range found");
824 cs_error(link->handle, RequestIO, i);
828 i = pcmcia_request_irq(link->handle, &link->irq);
829 if (i != CS_SUCCESS) {
830 cs_error(link->handle, RequestIRQ, i);
831 link->irq.AssignedIRQ = 0;
834 i = pcmcia_request_configuration(link->handle, &link->conf);
835 if (i != CS_SUCCESS) {
836 cs_error(link->handle, RequestConfiguration, i);
840 if (bt3c_open(info) != 0)
843 strcpy(info->node.dev_name, info->hdev->name);
844 link->dev = &info->node;
845 link->state &= ~DEV_CONFIG_PENDING;
850 cs_error(link->handle, last_fn, last_ret);
857 static void bt3c_release(dev_link_t *link)
859 bt3c_info_t *info = link->priv;
861 if (link->state & DEV_PRESENT)
866 pcmcia_release_configuration(link->handle);
867 pcmcia_release_io(link->handle, &link->io);
868 pcmcia_release_irq(link->handle, &link->irq);
870 link->state &= ~DEV_CONFIG;
873 static int bt3c_suspend(struct pcmcia_device *dev)
875 dev_link_t *link = dev_to_instance(dev);
877 link->state |= DEV_SUSPEND;
878 if (link->state & DEV_CONFIG)
879 pcmcia_release_configuration(link->handle);
884 static int bt3c_resume(struct pcmcia_device *dev)
886 dev_link_t *link = dev_to_instance(dev);
888 link->state &= ~DEV_SUSPEND;
890 pcmcia_request_configuration(link->handle, &link->conf);
895 static int bt3c_event(event_t event, int priority, event_callback_args_t *args)
897 dev_link_t *link = args->client_data;
900 case CS_EVENT_CARD_INSERTION:
901 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
909 static struct pcmcia_device_id bt3c_ids[] = {
910 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
913 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
915 static struct pcmcia_driver bt3c_driver = {
916 .owner = THIS_MODULE,
920 .attach = bt3c_attach,
922 .remove = bt3c_detach,
923 .id_table = bt3c_ids,
924 .suspend = bt3c_suspend,
925 .resume = bt3c_resume,
928 static int __init init_bt3c_cs(void)
930 return pcmcia_register_driver(&bt3c_driver);
934 static void __exit exit_bt3c_cs(void)
936 pcmcia_unregister_driver(&bt3c_driver);
939 module_init(init_bt3c_cs);
940 module_exit(exit_bt3c_cs);