[linux-2.6-block.git] / drivers / bluetooth / bt3c_cs.c

/*
 *
 *  Driver for the 3Com Bluetooth PCMCIA card
 *
 *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
 *                           Jose Orlando Pereira <jop@di.uminho.pt>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation;
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing
 *  rights and limitations under the License.
 *
 *  The initial developer of the original code is David A. Hinds
 *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 *
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/spinlock.h>
#include <linux/moduleparam.h>

#include <linux/skbuff.h>
#include <linux/string.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/bitops.h>
#include <asm/system.h>
#include <asm/io.h>

#include <linux/device.h>
#include <linux/firmware.h>

#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/ciscode.h>
#include <pcmcia/ds.h>
#include <pcmcia/cisreg.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>


/* ======================== Module parameters ======================== */


MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
MODULE_LICENSE("GPL");
MODULE_FIRMWARE("BT3CPCC.bin");


/* ======================== Local structures ======================== */


typedef struct bt3c_info_t {
	struct pcmcia_device *p_dev;
	dev_node_t node;

	struct hci_dev *hdev;

	spinlock_t lock;		/* For serializing operations */

	struct sk_buff_head txq;
	unsigned long tx_state;

	unsigned long rx_state;
	unsigned long rx_count;
	struct sk_buff *rx_skb;
} bt3c_info_t;


static int bt3c_config(struct pcmcia_device *link);
static void bt3c_release(struct pcmcia_device *link);

static void bt3c_detach(struct pcmcia_device *p_dev);


/* Transmit states  */
#define XMIT_SENDING  1
#define XMIT_WAKEUP   2
#define XMIT_WAITING  8

/* Receiver states */
#define RECV_WAIT_PACKET_TYPE   0
#define RECV_WAIT_EVENT_HEADER  1
#define RECV_WAIT_ACL_HEADER    2
#define RECV_WAIT_SCO_HEADER    3
#define RECV_WAIT_DATA          4


/* ======================== Special I/O functions ======================== */


#define DATA_L   0
#define DATA_H   1
#define ADDR_L   2
#define ADDR_H   3
#define CONTROL  4


static inline void bt3c_address(unsigned int iobase, unsigned short addr)
{
	outb(addr & 0xff, iobase + ADDR_L);
	outb((addr >> 8) & 0xff, iobase + ADDR_H);
}


static inline void bt3c_put(unsigned int iobase, unsigned short value)
{
	outb(value & 0xff, iobase + DATA_L);
	outb((value >> 8) & 0xff, iobase + DATA_H);
}


static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
{
	bt3c_address(iobase, addr);
	bt3c_put(iobase, value);
}


static inline unsigned short bt3c_get(unsigned int iobase)
{
	unsigned short value = inb(iobase + DATA_L);

	value |= inb(iobase + DATA_H) << 8;

	return value;
}


static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
{
	bt3c_address(iobase, addr);

	return bt3c_get(iobase);
}


/* ======================== Interrupt handling ======================== */


static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
{
	int actual = 0;

	bt3c_address(iobase, 0x7080);

	/* Fill FIFO with current frame */
	while (actual < len) {
		/* Transmit next byte */
		bt3c_put(iobase, buf[actual]);
		actual++;
	}

	bt3c_io_write(iobase, 0x7005, actual);

	return actual;
}


static void bt3c_write_wakeup(bt3c_info_t *info)
{
	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
		return;

	do {
		register unsigned int iobase = info->p_dev->io.BasePort1;
		register struct sk_buff *skb;
		register int len;

		if (!pcmcia_dev_present(info->p_dev))
			break;


		if (!(skb = skb_dequeue(&(info->txq)))) {
			clear_bit(XMIT_SENDING, &(info->tx_state));
			break;
		}

		/* Send frame */
		len = bt3c_write(iobase, 256, skb->data, skb->len);

		if (len != skb->len) {
			BT_ERR("Very strange");
		}

		kfree_skb(skb);

		info->hdev->stat.byte_tx += len;

	} while (0);
}


static void bt3c_receive(bt3c_info_t *info)
{
	unsigned int iobase;
	int size = 0, avail;

	if (!info) {
		BT_ERR("Unknown device");
		return;
	}

	iobase = info->p_dev->io.BasePort1;

	avail = bt3c_read(iobase, 0x7006);
	//printk("bt3c_cs: receiving %d bytes\n", avail);

	bt3c_address(iobase, 0x7480);
	while (size < avail) {
		size++;
		info->hdev->stat.byte_rx++;

		/* Allocate packet */
		if (info->rx_skb == NULL) {
			info->rx_state = RECV_WAIT_PACKET_TYPE;
			info->rx_count = 0;
			if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
				BT_ERR("Can't allocate mem for new packet");
				return;
			}
		}


		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {

			info->rx_skb->dev = (void *) info->hdev;
			bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
			inb(iobase + DATA_H);
			//printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);

			switch (bt_cb(info->rx_skb)->pkt_type) {

			case HCI_EVENT_PKT:
				info->rx_state = RECV_WAIT_EVENT_HEADER;
				info->rx_count = HCI_EVENT_HDR_SIZE;
				break;

			case HCI_ACLDATA_PKT:
				info->rx_state = RECV_WAIT_ACL_HEADER;
				info->rx_count = HCI_ACL_HDR_SIZE;
				break;

			case HCI_SCODATA_PKT:
				info->rx_state = RECV_WAIT_SCO_HEADER;
				info->rx_count = HCI_SCO_HDR_SIZE;
				break;

			default:
				/* Unknown packet */
				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
				info->hdev->stat.err_rx++;
				clear_bit(HCI_RUNNING, &(info->hdev->flags));

				kfree_skb(info->rx_skb);
				info->rx_skb = NULL;
				break;

			}

		} else {

			__u8 x = inb(iobase + DATA_L);

			*skb_put(info->rx_skb, 1) = x;
			inb(iobase + DATA_H);
			info->rx_count--;

			if (info->rx_count == 0) {

				int dlen;
				struct hci_event_hdr *eh;
				struct hci_acl_hdr *ah;
				struct hci_sco_hdr *sh;

				switch (info->rx_state) {

				case RECV_WAIT_EVENT_HEADER:
					eh = hci_event_hdr(info->rx_skb);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = eh->plen;
					break;

				case RECV_WAIT_ACL_HEADER:
					ah = hci_acl_hdr(info->rx_skb);
					dlen = __le16_to_cpu(ah->dlen);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = dlen;
					break;

				case RECV_WAIT_SCO_HEADER:
					sh = hci_sco_hdr(info->rx_skb);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = sh->dlen;
					break;

				case RECV_WAIT_DATA:
					hci_recv_frame(info->rx_skb);
					info->rx_skb = NULL;
					break;

				}

			}

		}

	}

	bt3c_io_write(iobase, 0x7006, 0x0000);
}


static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
{
	bt3c_info_t *info = dev_inst;
	unsigned int iobase;
	int iir;
	irqreturn_t r = IRQ_NONE;

	if (!info || !info->hdev)
		/* our irq handler is shared */
		return IRQ_NONE;

	iobase = info->p_dev->io.BasePort1;

	spin_lock(&(info->lock));

	iir = inb(iobase + CONTROL);
	if (iir & 0x80) {
		int stat = bt3c_read(iobase, 0x7001);

		if ((stat & 0xff) == 0x7f) {
			BT_ERR("Very strange (stat=0x%04x)", stat);
		} else if ((stat & 0xff) != 0xff) {
			if (stat & 0x0020) {
				int status = bt3c_read(iobase, 0x7002) & 0x10;
				BT_INFO("%s: Antenna %s", info->hdev->name,
							status ? "out" : "in");
			}
			if (stat & 0x0001)
				bt3c_receive(info);
			if (stat & 0x0002) {
				//BT_ERR("Ack (stat=0x%04x)", stat);
				clear_bit(XMIT_SENDING, &(info->tx_state));
				bt3c_write_wakeup(info);
			}

			bt3c_io_write(iobase, 0x7001, 0x0000);

			outb(iir, iobase + CONTROL);
		}
		r = IRQ_HANDLED;
	}

	spin_unlock(&(info->lock));

	return r;
}


/* ======================== HCI interface ======================== */


static int bt3c_hci_flush(struct hci_dev *hdev)
{
	bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);

	/* Drop TX queue */
	skb_queue_purge(&(info->txq));

	return 0;
}


static int bt3c_hci_open(struct hci_dev *hdev)
{
	set_bit(HCI_RUNNING, &(hdev->flags));

	return 0;
}


static int bt3c_hci_close(struct hci_dev *hdev)
{
	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
		return 0;

	bt3c_hci_flush(hdev);

	return 0;
}


static int bt3c_hci_send_frame(struct sk_buff *skb)
{
	bt3c_info_t *info;
	struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
	unsigned long flags;

	if (!hdev) {
		BT_ERR("Frame for unknown HCI device (hdev=NULL)");
		return -ENODEV;
	}

	info = (bt3c_info_t *) (hdev->driver_data);

	switch (bt_cb(skb)->pkt_type) {
	case HCI_COMMAND_PKT:
		hdev->stat.cmd_tx++;
		break;
	case HCI_ACLDATA_PKT:
		hdev->stat.acl_tx++;
		break;
	case HCI_SCODATA_PKT:
		hdev->stat.sco_tx++;
		break;
	};

	/* Prepend skb with frame type */
	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
	skb_queue_tail(&(info->txq), skb);

	spin_lock_irqsave(&(info->lock), flags);

	bt3c_write_wakeup(info);

	spin_unlock_irqrestore(&(info->lock), flags);

	return 0;
}


static void bt3c_hci_destruct(struct hci_dev *hdev)
{
}


static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
{
	return -ENOIOCTLCMD;
}


/* ======================== Card services HCI interaction ======================== */


static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
			      int count)
{
	char *ptr = (char *) firmware;
	char b[9];
	unsigned int iobase, size, addr, fcs, tmp;
	int i, err = 0;

	iobase = info->p_dev->io.BasePort1;

	/* Reset */
	bt3c_io_write(iobase, 0x8040, 0x0404);
	bt3c_io_write(iobase, 0x8040, 0x0400);

	udelay(1);

	bt3c_io_write(iobase, 0x8040, 0x0404);

	udelay(17);

	/* Load */
	while (count) {
		if (ptr[0] != 'S') {
			BT_ERR("Bad address in firmware");
			err = -EFAULT;
			goto error;
		}

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + 2, 2);
		size = simple_strtoul(b, NULL, 16);

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + 4, 8);
		addr = simple_strtoul(b, NULL, 16);

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + (size * 2) + 2, 2);
		fcs = simple_strtoul(b, NULL, 16);

		memset(b, 0, sizeof(b));
		for (tmp = 0, i = 0; i < size; i++) {
			memcpy(b, ptr + (i * 2) + 2, 2);
			tmp += simple_strtol(b, NULL, 16);
		}

		if (((tmp + fcs) & 0xff) != 0xff) {
			BT_ERR("Checksum error in firmware");
			err = -EILSEQ;
			goto error;
		}

		if (ptr[1] == '3') {
			bt3c_address(iobase, addr);

			memset(b, 0, sizeof(b));
			for (i = 0; i < (size - 4) / 2; i++) {
				memcpy(b, ptr + (i * 4) + 12, 4);
				tmp = simple_strtoul(b, NULL, 16);
				bt3c_put(iobase, tmp);
			}
		}

		ptr   += (size * 2) + 6;
		count -= (size * 2) + 6;
	}

	udelay(17);

	/* Boot */
	bt3c_address(iobase, 0x3000);
	outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);

error:
	udelay(17);

	/* Clear */
	bt3c_io_write(iobase, 0x7006, 0x0000);
	bt3c_io_write(iobase, 0x7005, 0x0000);
	bt3c_io_write(iobase, 0x7001, 0x0000);

	return err;
}


static int bt3c_open(bt3c_info_t *info)
{
	const struct firmware *firmware;
	struct hci_dev *hdev;
	int err;

	spin_lock_init(&(info->lock));

	skb_queue_head_init(&(info->txq));

	info->rx_state = RECV_WAIT_PACKET_TYPE;
	info->rx_count = 0;
	info->rx_skb = NULL;

	/* Initialize HCI device */
	hdev = hci_alloc_dev();
	if (!hdev) {
		BT_ERR("Can't allocate HCI device");
		return -ENOMEM;
	}

	info->hdev = hdev;

	hdev->type = HCI_PCCARD;
	hdev->driver_data = info;
	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);

	hdev->open     = bt3c_hci_open;
	hdev->close    = bt3c_hci_close;
	hdev->flush    = bt3c_hci_flush;
	hdev->send     = bt3c_hci_send_frame;
	hdev->destruct = bt3c_hci_destruct;
	hdev->ioctl    = bt3c_hci_ioctl;

	hdev->owner = THIS_MODULE;

	/* Load firmware */
	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
	if (err < 0) {
		BT_ERR("Firmware request failed");
		goto error;
	}

	err = bt3c_load_firmware(info, firmware->data, firmware->size);

	release_firmware(firmware);

	if (err < 0) {
		BT_ERR("Firmware loading failed");
		goto error;
	}

	/* Timeout before it is safe to send the first HCI packet */
	msleep(1000);

	/* Register HCI device */
	err = hci_register_dev(hdev);
	if (err < 0) {
		BT_ERR("Can't register HCI device");
		goto error;
	}

	return 0;

error:
	info->hdev = NULL;
	hci_free_dev(hdev);
	return err;
}


static int bt3c_close(bt3c_info_t *info)
{
	struct hci_dev *hdev = info->hdev;

	if (!hdev)
		return -ENODEV;

	bt3c_hci_close(hdev);

	if (hci_unregister_dev(hdev) < 0)
		BT_ERR("Can't unregister HCI device %s", hdev->name);

	hci_free_dev(hdev);

	return 0;
}

static int bt3c_probe(struct pcmcia_device *link)
{
	bt3c_info_t *info;

	/* Create new info device */
	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->p_dev = link;
	link->priv = info;

	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	link->io.NumPorts1 = 8;
	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;

	link->irq.Handler = bt3c_interrupt;

	link->conf.Attributes = CONF_ENABLE_IRQ;
	link->conf.IntType = INT_MEMORY_AND_IO;

	return bt3c_config(link);
}


static void bt3c_detach(struct pcmcia_device *link)
{
	bt3c_info_t *info = link->priv;

	bt3c_release(link);
	kfree(info);
}

static int bt3c_check_config(struct pcmcia_device *p_dev,
			     cistpl_cftable_entry_t *cf,
			     cistpl_cftable_entry_t *dflt,
			     unsigned int vcc,
			     void *priv_data)
{
	unsigned long try = (unsigned long) priv_data;

	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
		p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
	    (cf->io.win[0].base != 0)) {
		p_dev->io.BasePort1 = cf->io.win[0].base;
		p_dev->io.IOAddrLines = (try == 0) ? 16 :
			cf->io.flags & CISTPL_IO_LINES_MASK;
		if (!pcmcia_request_io(p_dev, &p_dev->io))
			return 0;
	}
	return -ENODEV;
}

static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
				      cistpl_cftable_entry_t *cf,
				      cistpl_cftable_entry_t *dflt,
				      unsigned int vcc,
				      void *priv_data)
{
	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	int j;

	if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
		for (j = 0; j < 5; j++) {
			p_dev->io.BasePort1 = base[j];
			p_dev->io.IOAddrLines = base[j] ? 16 : 3;
			if (!pcmcia_request_io(p_dev, &p_dev->io))
				return 0;
		}
	}
	return -ENODEV;
}

static int bt3c_config(struct pcmcia_device *link)
{
	bt3c_info_t *info = link->priv;
	int i;
	unsigned long try;

	/* First pass: look for a config entry that looks normal.
	   Two tries: without IO aliases, then with aliases */
	for (try = 0; try < 2; try++)
		if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
			goto found_port;

	/* Second pass: try to find an entry that isn't picky about
	   its base address, then try to grab any standard serial port
	   address, and finally try to get any free port. */
	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
		goto found_port;

	BT_ERR("No usable port range found");
	goto failed;

found_port:
	i = pcmcia_request_irq(link, &link->irq);
	if (i != 0)
		link->irq.AssignedIRQ = 0;

	i = pcmcia_request_configuration(link, &link->conf);
	if (i != 0)
		goto failed;

	if (bt3c_open(info) != 0)
		goto failed;

	strcpy(info->node.dev_name, info->hdev->name);
	link->dev_node = &info->node;

	return 0;

failed:
	bt3c_release(link);
	return -ENODEV;
}


static void bt3c_release(struct pcmcia_device *link)
{
	bt3c_info_t *info = link->priv;

	bt3c_close(info);

	pcmcia_disable_device(link);
}


static struct pcmcia_device_id bt3c_ids[] = {
	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	PCMCIA_DEVICE_NULL
};
MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);

static struct pcmcia_driver bt3c_driver = {
	.owner		= THIS_MODULE,
	.drv		= {
		.name	= "bt3c_cs",
	},
	.probe		= bt3c_probe,
	.remove		= bt3c_detach,
	.id_table	= bt3c_ids,
};

static int __init init_bt3c_cs(void)
{
	return pcmcia_register_driver(&bt3c_driver);
}


static void __exit exit_bt3c_cs(void)
{
	pcmcia_unregister_driver(&bt3c_driver);
}

module_init(init_bt3c_cs);
module_exit(exit_bt3c_cs);
Commit	Line	Data
1da177e4 LT	1	/*
	2	*
	3	* Driver for the 3Com Bluetooth PCMCIA card
	4	*
	5	* Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
	6	* Jose Orlando Pereira <jop@di.uminho.pt>
	7	*
	8	*
	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;
	12	*
	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.
	17	*
	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.
	21	*
	22	*/
	23
1da177e4 LT	24	#include <linux/module.h>
	25
	26	#include <linux/kernel.h>
	27	#include <linux/init.h>
	28	#include <linux/slab.h>
	29	#include <linux/types.h>
1da177e4 LT	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>
	36
	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>
	43	#include <asm/io.h>
	44
	45	#include <linux/device.h>
	46	#include <linux/firmware.h>
	47
1da177e4 LT	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>
	54
	55	#include <net/bluetooth/bluetooth.h>
	56	#include <net/bluetooth/hci_core.h>
	57
	58
	59
	60	/* ======================== Module parameters ======================== */
	61
	62
63fbd24e	63	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	64	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
1da177e4 LT	65	MODULE_LICENSE("GPL");
2312119a	66	MODULE_FIRMWARE("BT3CPCC.bin");
1da177e4 LT	67
	68
	69
	70	/* ======================== Local structures ======================== */
	71
	72
	73	typedef struct bt3c_info_t {
fd238232	74	struct pcmcia_device *p_dev;
1da177e4 LT	75	dev_node_t node;
	76
	77	struct hci_dev *hdev;
	78
	79	spinlock_t lock; /* For serializing operations */
	80
	81	struct sk_buff_head txq;
	82	unsigned long tx_state;
	83
	84	unsigned long rx_state;
	85	unsigned long rx_count;
	86	struct sk_buff *rx_skb;
	87	} bt3c_info_t;
	88
	89
15b99ac1	90	static int bt3c_config(struct pcmcia_device *link);
fba395ee	91	static void bt3c_release(struct pcmcia_device *link);
1da177e4	92
cc3b4866	93	static void bt3c_detach(struct pcmcia_device *p_dev);
1da177e4	94
1da177e4 LT	95
	96	/* Transmit states */
	97	#define XMIT_SENDING 1
	98	#define XMIT_WAKEUP 2
	99	#define XMIT_WAITING 8
	100
	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
	107
	108
	109
	110	/* ======================== Special I/O functions ======================== */
	111
	112
	113	#define DATA_L 0
	114	#define DATA_H 1
	115	#define ADDR_L 2
	116	#define ADDR_H 3
	117	#define CONTROL 4
	118
	119
	120	static inline void bt3c_address(unsigned int iobase, unsigned short addr)
	121	{
	122	outb(addr & 0xff, iobase + ADDR_L);
	123	outb((addr >> 8) & 0xff, iobase + ADDR_H);
	124	}
	125
	126
	127	static inline void bt3c_put(unsigned int iobase, unsigned short value)
	128	{
	129	outb(value & 0xff, iobase + DATA_L);
	130	outb((value >> 8) & 0xff, iobase + DATA_H);
	131	}
	132
	133
	134	static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
	135	{
	136	bt3c_address(iobase, addr);
	137	bt3c_put(iobase, value);
	138	}
	139
	140
	141	static inline unsigned short bt3c_get(unsigned int iobase)
	142	{
	143	unsigned short value = inb(iobase + DATA_L);
	144
	145	value \|= inb(iobase + DATA_H) << 8;
	146
	147	return value;
	148	}
	149
	150
	151	static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
	152	{
	153	bt3c_address(iobase, addr);
	154
	155	return bt3c_get(iobase);
	156	}
	157
	158
159
160	/* ======================== Interrupt handling ======================== */
161
162
163	static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
164	{
165	int actual = 0;
166
167	bt3c_address(iobase, 0x7080);
168
169	/* Fill FIFO with current frame */
170	while (actual < len) {
171	/* Transmit next byte */
172	bt3c_put(iobase, buf[actual]);
173	actual++;
174	}
175
176	bt3c_io_write(iobase, 0x7005, actual);
177
178	return actual;
179	}
180
181
182	static void bt3c_write_wakeup(bt3c_info_t *info)
183	{
184	if (!info) {
185	BT_ERR("Unknown device");
186	return;
187	}
188
189	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
190	return;
191
192	do {
fd238232	193	register unsigned int iobase = info->p_dev->io.BasePort1;
1da177e4 LT	194	register struct sk_buff *skb;
	195	register int len;
	196
e2d40963	197	if (!pcmcia_dev_present(info->p_dev))
1da177e4 LT	198	break;
	199
	200
	201	if (!(skb = skb_dequeue(&(info->txq)))) {
	202	clear_bit(XMIT_SENDING, &(info->tx_state));
	203	break;
	204	}
	205
	206	/* Send frame */
	207	len = bt3c_write(iobase, 256, skb->data, skb->len);
	208
	209	if (len != skb->len) {
	210	BT_ERR("Very strange");
	211	}
	212
	213	kfree_skb(skb);
	214
	215	info->hdev->stat.byte_tx += len;
	216
	217	} while (0);
	218	}
	219
	220
	221	static void bt3c_receive(bt3c_info_t *info)
	222	{
	223	unsigned int iobase;
	224	int size = 0, avail;
	225
	226	if (!info) {
	227	BT_ERR("Unknown device");
	228	return;
	229	}
	230
fd238232	231	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	232
	233	avail = bt3c_read(iobase, 0x7006);
	234	//printk("bt3c_cs: receiving %d bytes\n", avail);
	235
	236	bt3c_address(iobase, 0x7480);
	237	while (size < avail) {
	238	size++;
	239	info->hdev->stat.byte_rx++;
	240
	241	/* Allocate packet */
	242	if (info->rx_skb == NULL) {
	243	info->rx_state = RECV_WAIT_PACKET_TYPE;
	244	info->rx_count = 0;
	245	if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
	246	BT_ERR("Can't allocate mem for new packet");
	247	return;
	248	}
	249	}
	250
	251
	252	if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
	253
	254	info->rx_skb->dev = (void *) info->hdev;
0d48d939	255	bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
1da177e4	256	inb(iobase + DATA_H);
0d48d939	257	//printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
1da177e4	258
0d48d939	259	switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4 LT	260
	261	case HCI_EVENT_PKT:
	262	info->rx_state = RECV_WAIT_EVENT_HEADER;
	263	info->rx_count = HCI_EVENT_HDR_SIZE;
	264	break;
	265
	266	case HCI_ACLDATA_PKT:
	267	info->rx_state = RECV_WAIT_ACL_HEADER;
	268	info->rx_count = HCI_ACL_HDR_SIZE;
	269	break;
	270
	271	case HCI_SCODATA_PKT:
	272	info->rx_state = RECV_WAIT_SCO_HEADER;
	273	info->rx_count = HCI_SCO_HDR_SIZE;
	274	break;
	275
	276	default:
	277	/* Unknown packet */
0d48d939	278	BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4 LT	279	info->hdev->stat.err_rx++;
	280	clear_bit(HCI_RUNNING, &(info->hdev->flags));
	281
	282	kfree_skb(info->rx_skb);
	283	info->rx_skb = NULL;
	284	break;
	285
	286	}
	287
	288	} else {
	289
	290	__u8 x = inb(iobase + DATA_L);
	291
	292	*skb_put(info->rx_skb, 1) = x;
	293	inb(iobase + DATA_H);
	294	info->rx_count--;
	295
	296	if (info->rx_count == 0) {
	297
	298	int dlen;
	299	struct hci_event_hdr *eh;
	300	struct hci_acl_hdr *ah;
	301	struct hci_sco_hdr *sh;
	302
	303	switch (info->rx_state) {
	304
	305	case RECV_WAIT_EVENT_HEADER:
2a123b86	306	eh = hci_event_hdr(info->rx_skb);
1da177e4 LT	307	info->rx_state = RECV_WAIT_DATA;
	308	info->rx_count = eh->plen;
	309	break;
	310
	311	case RECV_WAIT_ACL_HEADER:
2a123b86	312	ah = hci_acl_hdr(info->rx_skb);
1da177e4 LT	313	dlen = __le16_to_cpu(ah->dlen);
	314	info->rx_state = RECV_WAIT_DATA;
	315	info->rx_count = dlen;
	316	break;
	317
	318	case RECV_WAIT_SCO_HEADER:
2a123b86	319	sh = hci_sco_hdr(info->rx_skb);
1da177e4 LT	320	info->rx_state = RECV_WAIT_DATA;
	321	info->rx_count = sh->dlen;
	322	break;
	323
	324	case RECV_WAIT_DATA:
	325	hci_recv_frame(info->rx_skb);
	326	info->rx_skb = NULL;
	327	break;
	328
	329	}
	330
	331	}
	332
	333	}
	334
	335	}
	336
	337	bt3c_io_write(iobase, 0x7006, 0x0000);
	338	}
	339
	340
7d12e780	341	static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
1da177e4 LT	342	{
	343	bt3c_info_t *info = dev_inst;
	344	unsigned int iobase;
	345	int iir;
aafcf998	346	irqreturn_t r = IRQ_NONE;
1da177e4	347
7427847d MF	348	if (!info \|\| !info->hdev)
	349	/* our irq handler is shared */
	350	return IRQ_NONE;
1da177e4	351
fd238232	352	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	353
	354	spin_lock(&(info->lock));
	355
	356	iir = inb(iobase + CONTROL);
	357	if (iir & 0x80) {
	358	int stat = bt3c_read(iobase, 0x7001);
	359
	360	if ((stat & 0xff) == 0x7f) {
	361	BT_ERR("Very strange (stat=0x%04x)", stat);
	362	} else if ((stat & 0xff) != 0xff) {
	363	if (stat & 0x0020) {
34a55eda	364	int status = bt3c_read(iobase, 0x7002) & 0x10;
1da177e4	365	BT_INFO("%s: Antenna %s", info->hdev->name,
34a55eda	366	status ? "out" : "in");
1da177e4 LT	367	}
	368	if (stat & 0x0001)
	369	bt3c_receive(info);
	370	if (stat & 0x0002) {
	371	//BT_ERR("Ack (stat=0x%04x)", stat);
	372	clear_bit(XMIT_SENDING, &(info->tx_state));
	373	bt3c_write_wakeup(info);
	374	}
	375
	376	bt3c_io_write(iobase, 0x7001, 0x0000);
	377
	378	outb(iir, iobase + CONTROL);
	379	}
aafcf998	380	r = IRQ_HANDLED;
1da177e4 LT	381	}
	382
	383	spin_unlock(&(info->lock));
	384
aafcf998	385	return r;
1da177e4 LT	386	}
	387
	388
	389
	390	/* ======================== HCI interface ======================== */
	391
	392
	393	static int bt3c_hci_flush(struct hci_dev *hdev)
	394	{
	395	bt3c_info_t info = (bt3c_info_t )(hdev->driver_data);
	396
	397	/* Drop TX queue */
	398	skb_queue_purge(&(info->txq));
	399
	400	return 0;
	401	}
	402
	403
	404	static int bt3c_hci_open(struct hci_dev *hdev)
	405	{
	406	set_bit(HCI_RUNNING, &(hdev->flags));
	407
	408	return 0;
	409	}
	410
	411
	412	static int bt3c_hci_close(struct hci_dev *hdev)
	413	{
	414	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	415	return 0;
	416
	417	bt3c_hci_flush(hdev);
	418
	419	return 0;
	420	}
	421
	422
	423	static int bt3c_hci_send_frame(struct sk_buff *skb)
	424	{
	425	bt3c_info_t *info;
	426	struct hci_dev hdev = (struct hci_dev )(skb->dev);
	427	unsigned long flags;
	428
	429	if (!hdev) {
	430	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
	431	return -ENODEV;
	432	}
	433
	434	info = (bt3c_info_t *) (hdev->driver_data);
	435
0d48d939	436	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	437	case HCI_COMMAND_PKT:
	438	hdev->stat.cmd_tx++;
	439	break;
	440	case HCI_ACLDATA_PKT:
	441	hdev->stat.acl_tx++;
	442	break;
	443	case HCI_SCODATA_PKT:
	444	hdev->stat.sco_tx++;
	445	break;
	446	};
	447
	448	/* Prepend skb with frame type */
0d48d939	449	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	450	skb_queue_tail(&(info->txq), skb);
	451
	452	spin_lock_irqsave(&(info->lock), flags);
	453
	454	bt3c_write_wakeup(info);
	455
	456	spin_unlock_irqrestore(&(info->lock), flags);
	457
	458	return 0;
	459	}
	460
	461
	462	static void bt3c_hci_destruct(struct hci_dev *hdev)
	463	{
	464	}
	465
	466
	467	static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	468	{
	469	return -ENOIOCTLCMD;
	470	}
	471
	472
	473
	474	/* ======================== Card services HCI interaction ======================== */
	475
	476
8187b4fb DW	477	static int bt3c_load_firmware(bt3c_info_t info, const unsigned char firmware,
8187b4fb DW	478	int count)
1da177e4 LT	479	{
	480	char ptr = (char ) firmware;
	481	char b[9];
	482	unsigned int iobase, size, addr, fcs, tmp;
	483	int i, err = 0;
	484
fd238232	485	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	486
	487	/* Reset */
	488	bt3c_io_write(iobase, 0x8040, 0x0404);
	489	bt3c_io_write(iobase, 0x8040, 0x0400);
	490
	491	udelay(1);
	492
	493	bt3c_io_write(iobase, 0x8040, 0x0404);
	494
	495	udelay(17);
	496
	497	/* Load */
	498	while (count) {
	499	if (ptr[0] != 'S') {
	500	BT_ERR("Bad address in firmware");
	501	err = -EFAULT;
	502	goto error;
	503	}
	504
	505	memset(b, 0, sizeof(b));
	506	memcpy(b, ptr + 2, 2);
51a6fbc8	507	size = simple_strtoul(b, NULL, 16);
1da177e4 LT	508
	509	memset(b, 0, sizeof(b));
	510	memcpy(b, ptr + 4, 8);
51a6fbc8	511	addr = simple_strtoul(b, NULL, 16);
1da177e4 LT	512
	513	memset(b, 0, sizeof(b));
	514	memcpy(b, ptr + (size * 2) + 2, 2);
51a6fbc8	515	fcs = simple_strtoul(b, NULL, 16);
1da177e4 LT	516
	517	memset(b, 0, sizeof(b));
	518	for (tmp = 0, i = 0; i < size; i++) {
	519	memcpy(b, ptr + (i * 2) + 2, 2);
	520	tmp += simple_strtol(b, NULL, 16);
	521	}
	522
	523	if (((tmp + fcs) & 0xff) != 0xff) {
	524	BT_ERR("Checksum error in firmware");
	525	err = -EILSEQ;
	526	goto error;
	527	}
	528
	529	if (ptr[1] == '3') {
	530	bt3c_address(iobase, addr);
	531
	532	memset(b, 0, sizeof(b));
	533	for (i = 0; i < (size - 4) / 2; i++) {
	534	memcpy(b, ptr + (i * 4) + 12, 4);
51a6fbc8	535	tmp = simple_strtoul(b, NULL, 16);
1da177e4 LT	536	bt3c_put(iobase, tmp);
	537	}
	538	}
	539
	540	ptr += (size * 2) + 6;
	541	count -= (size * 2) + 6;
	542	}
	543
	544	udelay(17);
	545
	546	/* Boot */
	547	bt3c_address(iobase, 0x3000);
	548	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	549
	550	error:
	551	udelay(17);
	552
	553	/* Clear */
	554	bt3c_io_write(iobase, 0x7006, 0x0000);
	555	bt3c_io_write(iobase, 0x7005, 0x0000);
	556	bt3c_io_write(iobase, 0x7001, 0x0000);
	557
	558	return err;
	559	}
	560
	561
	562	static int bt3c_open(bt3c_info_t *info)
	563	{
	564	const struct firmware *firmware;
	565	struct hci_dev *hdev;
	566	int err;
	567
	568	spin_lock_init(&(info->lock));
	569
	570	skb_queue_head_init(&(info->txq));
	571
	572	info->rx_state = RECV_WAIT_PACKET_TYPE;
	573	info->rx_count = 0;
	574	info->rx_skb = NULL;
	575
	576	/* Initialize HCI device */
	577	hdev = hci_alloc_dev();
	578	if (!hdev) {
	579	BT_ERR("Can't allocate HCI device");
	580	return -ENOMEM;
	581	}
	582
	583	info->hdev = hdev;
	584
	585	hdev->type = HCI_PCCARD;
	586	hdev->driver_data = info;
27d35284	587	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	588
	589	hdev->open = bt3c_hci_open;
	590	hdev->close = bt3c_hci_close;
	591	hdev->flush = bt3c_hci_flush;
	592	hdev->send = bt3c_hci_send_frame;
	593	hdev->destruct = bt3c_hci_destruct;
	594	hdev->ioctl = bt3c_hci_ioctl;
	595
	596	hdev->owner = THIS_MODULE;
	597
	598	/* Load firmware */
fd238232	599	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	600	if (err < 0) {
	601	BT_ERR("Firmware request failed");
	602	goto error;
	603	}
	604
	605	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	606
	607	release_firmware(firmware);
	608
	609	if (err < 0) {
	610	BT_ERR("Firmware loading failed");
	611	goto error;
	612	}
	613
	614	/* Timeout before it is safe to send the first HCI packet */
	615	msleep(1000);
	616
	617	/* Register HCI device */
	618	err = hci_register_dev(hdev);
	619	if (err < 0) {
	620	BT_ERR("Can't register HCI device");
	621	goto error;
	622	}
	623
	624	return 0;
	625
	626	error:
	627	info->hdev = NULL;
	628	hci_free_dev(hdev);
	629	return err;
	630	}
	631
	632
	633	static int bt3c_close(bt3c_info_t *info)
	634	{
	635	struct hci_dev *hdev = info->hdev;
	636
	637	if (!hdev)
	638	return -ENODEV;
	639
	640	bt3c_hci_close(hdev);
	641
	642	if (hci_unregister_dev(hdev) < 0)
	643	BT_ERR("Can't unregister HCI device %s", hdev->name);
	644
	645	hci_free_dev(hdev);
	646
	647	return 0;
	648	}
	649
15b99ac1	650	static int bt3c_probe(struct pcmcia_device *link)
1da177e4 LT	651	{
1da177e4 LT	652	bt3c_info_t *info;
1da177e4 LT	653
1da177e4 LT	654	/* Create new info device */
089b1dbb	655	info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4	656	if (!info)
f8cfa618	657	return -ENOMEM;
1da177e4	658
fba395ee	659	info->p_dev = link;
1da177e4 LT	660	link->priv = info;
	661
	662	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	663	link->io.NumPorts1 = 8;
5fa9167a	664	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
1da177e4 LT	665
1da177e4 LT	666	link->irq.Handler = bt3c_interrupt;
1da177e4 LT	667
1da177e4 LT	668	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	669	link->conf.IntType = INT_MEMORY_AND_IO;
1da177e4 LT	670
15b99ac1	671	return bt3c_config(link);
1da177e4 LT	672	}
	673
	674
fba395ee	675	static void bt3c_detach(struct pcmcia_device *link)
1da177e4 LT	676	{
1da177e4 LT	677	bt3c_info_t *info = link->priv;
1da177e4	678
e2d40963	679	bt3c_release(link);
1da177e4 LT	680	kfree(info);
	681	}
	682
ed58872a DB	683	static int bt3c_check_config(struct pcmcia_device *p_dev,
ed58872a DB	684	cistpl_cftable_entry_t *cf,
8e2fc39d	685	cistpl_cftable_entry_t *dflt,
ad913c11	686	unsigned int vcc,
ed58872a	687	void *priv_data)
1da177e4	688	{
ed58872a DB	689	unsigned long try = (unsigned long) priv_data;
	690
	691	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
	692	p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
	693	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
	694	(cf->io.win[0].base != 0)) {
ed58872a DB	695	p_dev->io.BasePort1 = cf->io.win[0].base;
	696	p_dev->io.IOAddrLines = (try == 0) ? 16 :
	697	cf->io.flags & CISTPL_IO_LINES_MASK;
	698	if (!pcmcia_request_io(p_dev, &p_dev->io))
	699	return 0;
	700	}
	701	return -ENODEV;
1da177e4 LT	702	}
1da177e4 LT	703
ed58872a DB	704	static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
ed58872a DB	705	cistpl_cftable_entry_t *cf,
8e2fc39d	706	cistpl_cftable_entry_t *dflt,
ad913c11	707	unsigned int vcc,
ed58872a	708	void *priv_data)
1da177e4	709	{
ed58872a DB	710	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	711	int j;
	712
	713	if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
ed58872a DB	714	for (j = 0; j < 5; j++) {
	715	p_dev->io.BasePort1 = base[j];
	716	p_dev->io.IOAddrLines = base[j] ? 16 : 3;
	717	if (!pcmcia_request_io(p_dev, &p_dev->io))
	718	return 0;
	719	}
	720	}
	721	return -ENODEV;
1da177e4 LT	722	}
1da177e4 LT	723
15b99ac1	724	static int bt3c_config(struct pcmcia_device *link)
1da177e4	725	{
1da177e4	726	bt3c_info_t *info = link->priv;
ed58872a DB	727	int i;
	728	unsigned long try;
	729
	730	/* First pass: look for a config entry that looks normal.
	731	Two tries: without IO aliases, then with aliases */
	732	for (try = 0; try < 2; try++)
	733	if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
	734	goto found_port;
1da177e4 LT	735
	736	/* Second pass: try to find an entry that isn't picky about
	737	its base address, then try to grab any standard serial port
	738	address, and finally try to get any free port. */
ed58872a DB	739	if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
ed58872a DB	740	goto found_port;
1da177e4	741
ed58872a	742	BT_ERR("No usable port range found");
ed58872a	743	goto failed;
1da177e4	744
ed58872a	745	found_port:
fba395ee	746	i = pcmcia_request_irq(link, &link->irq);
9ac3e58c	747	if (i != 0)
1da177e4	748	link->irq.AssignedIRQ = 0;
1da177e4	749
fba395ee	750	i = pcmcia_request_configuration(link, &link->conf);
9ac3e58c	751	if (i != 0)
1da177e4	752	goto failed;
1da177e4 LT	753
	754	if (bt3c_open(info) != 0)
	755	goto failed;
	756
	757	strcpy(info->node.dev_name, info->hdev->name);
fd238232	758	link->dev_node = &info->node;
1da177e4	759
15b99ac1	760	return 0;
1da177e4	761
1da177e4 LT	762	failed:
1da177e4 LT	763	bt3c_release(link);
15b99ac1	764	return -ENODEV;
1da177e4 LT	765	}
	766
	767
fba395ee	768	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	769	{
	770	bt3c_info_t *info = link->priv;
	771
e2d40963	772	bt3c_close(info);
1da177e4	773
fba395ee	774	pcmcia_disable_device(link);
1da177e4 LT	775	}
1da177e4 LT	776
1da177e4	777
a01c3ed4 DB	778	static struct pcmcia_device_id bt3c_ids[] = {
	779	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	780	PCMCIA_DEVICE_NULL
	781	};
	782	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	783
1da177e4 LT	784	static struct pcmcia_driver bt3c_driver = {
	785	.owner = THIS_MODULE,
	786	.drv = {
	787	.name = "bt3c_cs",
	788	},
15b99ac1	789	.probe = bt3c_probe,
cc3b4866	790	.remove = bt3c_detach,
a01c3ed4	791	.id_table = bt3c_ids,
1da177e4 LT	792	};
	793
	794	static int __init init_bt3c_cs(void)
	795	{
	796	return pcmcia_register_driver(&bt3c_driver);
	797	}
	798
	799
	800	static void __exit exit_bt3c_cs(void)
	801	{
	802	pcmcia_unregister_driver(&bt3c_driver);
1da177e4 LT	803	}
	804
	805	module_init(init_bt3c_cs);
	806	module_exit(exit_bt3c_cs);