[net-next-2.6.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.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;

	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->resource[0]->start;
		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->resource[0]->start;

	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->resource[0]->start;

	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->resource[0]->start;

	/* 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->bus = 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->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
	link->resource[0]->end = 8;

	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;

	p_dev->io_lines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;

	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->resource[0]->start = cf->io.win[0].base;
		if (!pcmcia_request_io(p_dev))
			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->resource[0]->start = base[j];
			p_dev->io_lines = base[j] ? 16 : 3;
			if (!pcmcia_request_io(p_dev))
				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, &bt3c_interrupt);
	if (i != 0)
		goto failed;

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

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

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