[mirror_ubuntu-artful-kernel.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>, Jose Orlando Pereira <jop@di.uminho.pt>");
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;

	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);
		}
	}

	spin_unlock(&(info->lock));

	return IRQ_HANDLED;
}


/* ======================== 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, 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_EXCLUSIVE | 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 get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	int i;

	i = pcmcia_get_tuple_data(handle, tuple);
	if (i != CS_SUCCESS)
		return i;

	return pcmcia_parse_tuple(handle, tuple, parse);
}

static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
		return CS_NO_MORE_ITEMS;
	return get_tuple(handle, tuple, parse);
}

static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
{
	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
		return CS_NO_MORE_ITEMS;
	return get_tuple(handle, tuple, parse);
}

static int bt3c_config(struct pcmcia_device *link)
{
	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
	bt3c_info_t *info = link->priv;
	tuple_t tuple;
	u_short buf[256];
	cisparse_t parse;
	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
	int i, j, try;

	/* First pass: look for a config entry that looks normal. */
	tuple.TupleData = (cisdata_t *)buf;
	tuple.TupleOffset = 0;
	tuple.TupleDataMax = 255;
	tuple.Attributes = 0;
	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	/* Two tries: without IO aliases, then with aliases */
	for (try = 0; try < 2; try++) {
		i = first_tuple(link, &tuple, &parse);
		while (i != CS_NO_MORE_ITEMS) {
			if (i != CS_SUCCESS)
				goto next_entry;
			if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
				link->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)) {
				link->conf.ConfigIndex = cf->index;
				link->io.BasePort1 = cf->io.win[0].base;
				link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
				i = pcmcia_request_io(link, &link->io);
				if (i == CS_SUCCESS)
					goto found_port;
			}
next_entry:
			i = next_tuple(link, &tuple, &parse);
		}
	}

	/* 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. */
	i = first_tuple(link, &tuple, &parse);
	while (i != CS_NO_MORE_ITEMS) {
		if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
			link->conf.ConfigIndex = cf->index;
			for (j = 0; j < 5; j++) {
				link->io.BasePort1 = base[j];
				link->io.IOAddrLines = base[j] ? 16 : 3;
				i = pcmcia_request_io(link, &link->io);
				if (i == CS_SUCCESS)
					goto found_port;
			}
		}
		i = next_tuple(link, &tuple, &parse);
	}

found_port:
	if (i != CS_SUCCESS) {
		BT_ERR("No usable port range found");
		cs_error(link, RequestIO, i);
		goto failed;
	}

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

	i = pcmcia_request_configuration(link, &link->conf);
	if (i != CS_SUCCESS) {
		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
	63	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
	64	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
	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;
	346
ac019360	347	BUG_ON(!info->hdev);
1da177e4	348
fd238232	349	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	350
	351	spin_lock(&(info->lock));
	352
	353	iir = inb(iobase + CONTROL);
	354	if (iir & 0x80) {
	355	int stat = bt3c_read(iobase, 0x7001);
	356
	357	if ((stat & 0xff) == 0x7f) {
	358	BT_ERR("Very strange (stat=0x%04x)", stat);
	359	} else if ((stat & 0xff) != 0xff) {
	360	if (stat & 0x0020) {
	361	int stat = bt3c_read(iobase, 0x7002) & 0x10;
	362	BT_INFO("%s: Antenna %s", info->hdev->name,
	363	stat ? "out" : "in");
	364	}
	365	if (stat & 0x0001)
	366	bt3c_receive(info);
	367	if (stat & 0x0002) {
	368	//BT_ERR("Ack (stat=0x%04x)", stat);
	369	clear_bit(XMIT_SENDING, &(info->tx_state));
	370	bt3c_write_wakeup(info);
	371	}
	372
	373	bt3c_io_write(iobase, 0x7001, 0x0000);
	374
	375	outb(iir, iobase + CONTROL);
	376	}
	377	}
	378
	379	spin_unlock(&(info->lock));
	380
	381	return IRQ_HANDLED;
	382	}
	383
	384
	385
	386	/* ======================== HCI interface ======================== */
	387
	388
	389	static int bt3c_hci_flush(struct hci_dev *hdev)
	390	{
	391	bt3c_info_t info = (bt3c_info_t )(hdev->driver_data);
	392
	393	/* Drop TX queue */
	394	skb_queue_purge(&(info->txq));
	395
	396	return 0;
	397	}
	398
	399
	400	static int bt3c_hci_open(struct hci_dev *hdev)
	401	{
	402	set_bit(HCI_RUNNING, &(hdev->flags));
	403
	404	return 0;
	405	}
	406
	407
	408	static int bt3c_hci_close(struct hci_dev *hdev)
	409	{
	410	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	411	return 0;
	412
	413	bt3c_hci_flush(hdev);
414
415	return 0;
416	}
417
418
419	static int bt3c_hci_send_frame(struct sk_buff *skb)
420	{
421	bt3c_info_t *info;
422	struct hci_dev hdev = (struct hci_dev )(skb->dev);
423	unsigned long flags;
424
425	if (!hdev) {
426	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
427	return -ENODEV;
428	}
429
430	info = (bt3c_info_t *) (hdev->driver_data);
431
0d48d939	432	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	433	case HCI_COMMAND_PKT:
	434	hdev->stat.cmd_tx++;
	435	break;
	436	case HCI_ACLDATA_PKT:
	437	hdev->stat.acl_tx++;
	438	break;
	439	case HCI_SCODATA_PKT:
	440	hdev->stat.sco_tx++;
	441	break;
	442	};
	443
	444	/* Prepend skb with frame type */
0d48d939	445	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	446	skb_queue_tail(&(info->txq), skb);
	447
	448	spin_lock_irqsave(&(info->lock), flags);
	449
	450	bt3c_write_wakeup(info);
	451
	452	spin_unlock_irqrestore(&(info->lock), flags);
	453
	454	return 0;
	455	}
	456
	457
	458	static void bt3c_hci_destruct(struct hci_dev *hdev)
	459	{
	460	}
	461
	462
	463	static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	464	{
	465	return -ENOIOCTLCMD;
	466	}
	467
	468
	469
	470	/* ======================== Card services HCI interaction ======================== */
	471
	472
1da177e4 LT	473	static int bt3c_load_firmware(bt3c_info_t info, unsigned char firmware, int count)
	474	{
	475	char ptr = (char ) firmware;
	476	char b[9];
	477	unsigned int iobase, size, addr, fcs, tmp;
	478	int i, err = 0;
	479
fd238232	480	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	481
	482	/* Reset */
	483	bt3c_io_write(iobase, 0x8040, 0x0404);
	484	bt3c_io_write(iobase, 0x8040, 0x0400);
	485
	486	udelay(1);
	487
	488	bt3c_io_write(iobase, 0x8040, 0x0404);
	489
	490	udelay(17);
	491
	492	/* Load */
	493	while (count) {
	494	if (ptr[0] != 'S') {
	495	BT_ERR("Bad address in firmware");
	496	err = -EFAULT;
	497	goto error;
	498	}
	499
	500	memset(b, 0, sizeof(b));
	501	memcpy(b, ptr + 2, 2);
	502	size = simple_strtol(b, NULL, 16);
	503
	504	memset(b, 0, sizeof(b));
	505	memcpy(b, ptr + 4, 8);
	506	addr = simple_strtol(b, NULL, 16);
	507
	508	memset(b, 0, sizeof(b));
	509	memcpy(b, ptr + (size * 2) + 2, 2);
	510	fcs = simple_strtol(b, NULL, 16);
	511
	512	memset(b, 0, sizeof(b));
	513	for (tmp = 0, i = 0; i < size; i++) {
	514	memcpy(b, ptr + (i * 2) + 2, 2);
	515	tmp += simple_strtol(b, NULL, 16);
	516	}
	517
	518	if (((tmp + fcs) & 0xff) != 0xff) {
	519	BT_ERR("Checksum error in firmware");
	520	err = -EILSEQ;
	521	goto error;
	522	}
	523
	524	if (ptr[1] == '3') {
	525	bt3c_address(iobase, addr);
	526
	527	memset(b, 0, sizeof(b));
	528	for (i = 0; i < (size - 4) / 2; i++) {
	529	memcpy(b, ptr + (i * 4) + 12, 4);
	530	tmp = simple_strtol(b, NULL, 16);
	531	bt3c_put(iobase, tmp);
	532	}
	533	}
	534
	535	ptr += (size * 2) + 6;
	536	count -= (size * 2) + 6;
	537	}
	538
	539	udelay(17);
	540
	541	/* Boot */
	542	bt3c_address(iobase, 0x3000);
	543	outb(inb(iobase + CONTROL) \| 0x40, iobase + CONTROL);
	544
545	error:
546	udelay(17);
547
548	/* Clear */
549	bt3c_io_write(iobase, 0x7006, 0x0000);
550	bt3c_io_write(iobase, 0x7005, 0x0000);
551	bt3c_io_write(iobase, 0x7001, 0x0000);
552
553	return err;
554	}
555
556
557	static int bt3c_open(bt3c_info_t *info)
558	{
559	const struct firmware *firmware;
560	struct hci_dev *hdev;
561	int err;
562
563	spin_lock_init(&(info->lock));
564
565	skb_queue_head_init(&(info->txq));
566
567	info->rx_state = RECV_WAIT_PACKET_TYPE;
568	info->rx_count = 0;
569	info->rx_skb = NULL;
570
571	/* Initialize HCI device */
572	hdev = hci_alloc_dev();
573	if (!hdev) {
574	BT_ERR("Can't allocate HCI device");
575	return -ENOMEM;
576	}
577
578	info->hdev = hdev;
579
580	hdev->type = HCI_PCCARD;
581	hdev->driver_data = info;
27d35284	582	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
1da177e4 LT	583
	584	hdev->open = bt3c_hci_open;
	585	hdev->close = bt3c_hci_close;
	586	hdev->flush = bt3c_hci_flush;
	587	hdev->send = bt3c_hci_send_frame;
	588	hdev->destruct = bt3c_hci_destruct;
	589	hdev->ioctl = bt3c_hci_ioctl;
	590
	591	hdev->owner = THIS_MODULE;
	592
	593	/* Load firmware */
fd238232	594	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
1da177e4 LT	595	if (err < 0) {
	596	BT_ERR("Firmware request failed");
	597	goto error;
	598	}
	599
	600	err = bt3c_load_firmware(info, firmware->data, firmware->size);
	601
	602	release_firmware(firmware);
	603
	604	if (err < 0) {
	605	BT_ERR("Firmware loading failed");
	606	goto error;
	607	}
	608
	609	/* Timeout before it is safe to send the first HCI packet */
	610	msleep(1000);
	611
	612	/* Register HCI device */
	613	err = hci_register_dev(hdev);
	614	if (err < 0) {
	615	BT_ERR("Can't register HCI device");
	616	goto error;
	617	}
	618
	619	return 0;
	620
	621	error:
	622	info->hdev = NULL;
	623	hci_free_dev(hdev);
	624	return err;
	625	}
	626
	627
	628	static int bt3c_close(bt3c_info_t *info)
	629	{
	630	struct hci_dev *hdev = info->hdev;
	631
	632	if (!hdev)
	633	return -ENODEV;
	634
	635	bt3c_hci_close(hdev);
	636
	637	if (hci_unregister_dev(hdev) < 0)
	638	BT_ERR("Can't unregister HCI device %s", hdev->name);
	639
	640	hci_free_dev(hdev);
	641
	642	return 0;
	643	}
	644
15b99ac1	645	static int bt3c_probe(struct pcmcia_device *link)
1da177e4 LT	646	{
1da177e4 LT	647	bt3c_info_t *info;
1da177e4 LT	648
1da177e4 LT	649	/* Create new info device */
089b1dbb	650	info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4	651	if (!info)
f8cfa618	652	return -ENOMEM;
1da177e4	653
fba395ee	654	info->p_dev = link;
1da177e4 LT	655	link->priv = info;
	656
	657	link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
	658	link->io.NumPorts1 = 8;
	659	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE \| IRQ_HANDLE_PRESENT;
	660	link->irq.IRQInfo1 = IRQ_LEVEL_ID;
	661
	662	link->irq.Handler = bt3c_interrupt;
	663	link->irq.Instance = info;
	664
	665	link->conf.Attributes = CONF_ENABLE_IRQ;
1da177e4 LT	666	link->conf.IntType = INT_MEMORY_AND_IO;
1da177e4 LT	667
15b99ac1	668	return bt3c_config(link);
1da177e4 LT	669	}
	670
	671
fba395ee	672	static void bt3c_detach(struct pcmcia_device *link)
1da177e4 LT	673	{
1da177e4 LT	674	bt3c_info_t *info = link->priv;
1da177e4	675
e2d40963	676	bt3c_release(link);
1da177e4 LT	677	kfree(info);
	678	}
	679
fba395ee	680	static int get_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	681	{
	682	int i;
	683
	684	i = pcmcia_get_tuple_data(handle, tuple);
	685	if (i != CS_SUCCESS)
	686	return i;
	687
	688	return pcmcia_parse_tuple(handle, tuple, parse);
	689	}
	690
fba395ee	691	static int first_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	692	{
	693	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
	694	return CS_NO_MORE_ITEMS;
	695	return get_tuple(handle, tuple, parse);
	696	}
	697
fba395ee	698	static int next_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	699	{
	700	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
	701	return CS_NO_MORE_ITEMS;
	702	return get_tuple(handle, tuple, parse);
	703	}
	704
15b99ac1	705	static int bt3c_config(struct pcmcia_device *link)
1da177e4	706	{
906da809	707	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
1da177e4 LT	708	bt3c_info_t *info = link->priv;
	709	tuple_t tuple;
	710	u_short buf[256];
	711	cisparse_t parse;
	712	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
af2b3b50	713	int i, j, try;
1da177e4	714
1da177e4 LT	715	/* First pass: look for a config entry that looks normal. */
	716	tuple.TupleData = (cisdata_t *)buf;
	717	tuple.TupleOffset = 0;
	718	tuple.TupleDataMax = 255;
	719	tuple.Attributes = 0;
	720	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	721	/* Two tries: without IO aliases, then with aliases */
	722	for (try = 0; try < 2; try++) {
fba395ee	723	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	724	while (i != CS_NO_MORE_ITEMS) {
	725	if (i != CS_SUCCESS)
	726	goto next_entry;
	727	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	728	link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	729	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
	730	link->conf.ConfigIndex = cf->index;
	731	link->io.BasePort1 = cf->io.win[0].base;
	732	link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
fba395ee	733	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	734	if (i == CS_SUCCESS)
	735	goto found_port;
	736	}
	737	next_entry:
fba395ee	738	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	739	}
	740	}
	741
	742	/* Second pass: try to find an entry that isn't picky about
	743	its base address, then try to grab any standard serial port
	744	address, and finally try to get any free port. */
fba395ee	745	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	746	while (i != CS_NO_MORE_ITEMS) {
	747	if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
	748	link->conf.ConfigIndex = cf->index;
	749	for (j = 0; j < 5; j++) {
	750	link->io.BasePort1 = base[j];
	751	link->io.IOAddrLines = base[j] ? 16 : 3;
fba395ee	752	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	753	if (i == CS_SUCCESS)
	754	goto found_port;
	755	}
	756	}
fba395ee	757	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	758	}
	759
	760	found_port:
	761	if (i != CS_SUCCESS) {
	762	BT_ERR("No usable port range found");
fba395ee	763	cs_error(link, RequestIO, i);
1da177e4 LT	764	goto failed;
	765	}
	766
fba395ee	767	i = pcmcia_request_irq(link, &link->irq);
1da177e4	768	if (i != CS_SUCCESS) {
fba395ee	769	cs_error(link, RequestIRQ, i);
1da177e4 LT	770	link->irq.AssignedIRQ = 0;
	771	}
	772
fba395ee	773	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	774	if (i != CS_SUCCESS) {
fba395ee	775	cs_error(link, RequestConfiguration, i);
1da177e4 LT	776	goto failed;
	777	}
	778
	779	if (bt3c_open(info) != 0)
	780	goto failed;
	781
	782	strcpy(info->node.dev_name, info->hdev->name);
fd238232	783	link->dev_node = &info->node;
1da177e4	784
15b99ac1	785	return 0;
1da177e4	786
1da177e4 LT	787	failed:
1da177e4 LT	788	bt3c_release(link);
15b99ac1	789	return -ENODEV;
1da177e4 LT	790	}
	791
	792
fba395ee	793	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	794	{
	795	bt3c_info_t *info = link->priv;
	796
e2d40963	797	bt3c_close(info);
1da177e4	798
fba395ee	799	pcmcia_disable_device(link);
1da177e4 LT	800	}
1da177e4 LT	801
1da177e4	802
a01c3ed4 DB	803	static struct pcmcia_device_id bt3c_ids[] = {
	804	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	805	PCMCIA_DEVICE_NULL
	806	};
	807	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	808
1da177e4 LT	809	static struct pcmcia_driver bt3c_driver = {
	810	.owner = THIS_MODULE,
	811	.drv = {
	812	.name = "bt3c_cs",
	813	},
15b99ac1	814	.probe = bt3c_probe,
cc3b4866	815	.remove = bt3c_detach,
a01c3ed4	816	.id_table = bt3c_ids,
1da177e4 LT	817	};
	818
	819	static int __init init_bt3c_cs(void)
	820	{
	821	return pcmcia_register_driver(&bt3c_driver);
	822	}
	823
	824
	825	static void __exit exit_bt3c_cs(void)
	826	{
	827	pcmcia_unregister_driver(&bt3c_driver);
1da177e4 LT	828	}
	829
	830	module_init(init_bt3c_cs);
	831	module_exit(exit_bt3c_cs);