[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;

	BUG_ON(!info->hdev);

	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 stat = bt3c_read(iobase, 0x7002) & 0x10;
				BT_INFO("%s: Antenna %s", info->hdev->name,
							stat ? "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_strtol(b, NULL, 16);

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

		memset(b, 0, sizeof(b));
		memcpy(b, ptr + (size * 2) + 2, 2);
		fcs = simple_strtol(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_strtol(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 | IRQ_HANDLE_PRESENT;
	link->irq.IRQInfo1 = IRQ_LEVEL_ID;

	link->irq.Handler = bt3c_interrupt;
	link->irq.Instance = info;

	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");
	cs_error(link, RequestIO, -ENODEV);
	goto failed;

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

	i = pcmcia_request_configuration(link, &link->conf);
	if (i != 0) {
		cs_error(link, RequestConfiguration, i);
		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
ac019360	348	BUG_ON(!info->hdev);
1da177e4	349
fd238232	350	iobase = info->p_dev->io.BasePort1;
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) {
	362	int stat = bt3c_read(iobase, 0x7002) & 0x10;
	363	BT_INFO("%s: Antenna %s", info->hdev->name,
	364	stat ? "out" : "in");
	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
fd238232	483	iobase = info->p_dev->io.BasePort1;
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);
	505	size = simple_strtol(b, NULL, 16);
	506
	507	memset(b, 0, sizeof(b));
	508	memcpy(b, ptr + 4, 8);
	509	addr = simple_strtol(b, NULL, 16);
	510
	511	memset(b, 0, sizeof(b));
	512	memcpy(b, ptr + (size * 2) + 2, 2);
	513	fcs = simple_strtol(b, NULL, 16);
	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);
	533	tmp = simple_strtol(b, NULL, 16);
	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
583	hdev->type = HCI_PCCARD;
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;
	659
	660	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	661	link->io.NumPorts1 = 8;
aafcf998	662	link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING \| IRQ_HANDLE_PRESENT;
1da177e4 LT	663	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	664
	665	link->irq.Handler = bt3c_interrupt;
	666	link->irq.Instance = info;
	667
	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 DB	742	BT_ERR("No usable port range found");
	743	cs_error(link, RequestIO, -ENODEV);
	744	goto failed;
1da177e4	745
ed58872a	746	found_port:
fba395ee	747	i = pcmcia_request_irq(link, &link->irq);
4c89e88b	748	if (i != 0) {
fba395ee	749	cs_error(link, RequestIRQ, i);
1da177e4 LT	750	link->irq.AssignedIRQ = 0;
	751	}
	752
fba395ee	753	i = pcmcia_request_configuration(link, &link->conf);
4c89e88b	754	if (i != 0) {
fba395ee	755	cs_error(link, RequestConfiguration, i);
1da177e4 LT	756	goto failed;
	757	}
	758
	759	if (bt3c_open(info) != 0)
	760	goto failed;
	761
	762	strcpy(info->node.dev_name, info->hdev->name);
fd238232	763	link->dev_node = &info->node;
1da177e4	764
15b99ac1	765	return 0;
1da177e4	766
1da177e4 LT	767	failed:
1da177e4 LT	768	bt3c_release(link);
15b99ac1	769	return -ENODEV;
1da177e4 LT	770	}
	771
	772
fba395ee	773	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	774	{
	775	bt3c_info_t *info = link->priv;
	776
e2d40963	777	bt3c_close(info);
1da177e4	778
fba395ee	779	pcmcia_disable_device(link);
1da177e4 LT	780	}
1da177e4 LT	781
1da177e4	782
a01c3ed4 DB	783	static struct pcmcia_device_id bt3c_ids[] = {
	784	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	785	PCMCIA_DEVICE_NULL
	786	};
	787	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	788
1da177e4 LT	789	static struct pcmcia_driver bt3c_driver = {
	790	.owner = THIS_MODULE,
	791	.drv = {
	792	.name = "bt3c_cs",
	793	},
15b99ac1	794	.probe = bt3c_probe,
cc3b4866	795	.remove = bt3c_detach,
a01c3ed4	796	.id_table = bt3c_ids,
1da177e4 LT	797	};
	798
	799	static int __init init_bt3c_cs(void)
	800	{
	801	return pcmcia_register_driver(&bt3c_driver);
	802	}
	803
	804
	805	static void __exit exit_bt3c_cs(void)
	806	{
	807	pcmcia_unregister_driver(&bt3c_driver);
1da177e4 LT	808	}
	809
	810	module_init(init_bt3c_cs);
	811	module_exit(exit_bt3c_cs);