[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/sched.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");


/* ======================== 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 = (struct hci_event_hdr *)(info->rx_skb->data);
					info->rx_state = RECV_WAIT_DATA;
					info->rx_count = eh->plen;
					break;

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

				case RECV_WAIT_SCO_HEADER:
					sh = (struct hci_sco_hdr *)(info->rx_skb->data);
					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, struct pt_regs *regs)
{
	bt3c_info_t *info = dev_inst;
	unsigned int iobase;
	int iir;

	if (!info || !info->hdev) {
		BT_ERR("Call of irq %d for unknown device", irq);
		return IRQ_NONE;
	}

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

	spin_lock(&(info->lock));

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

		if ((stat & 0xff) == 0x7f) {
			BT_ERR("Very strange (stat=0x%04x)", stat);
		} else if ((stat & 0xff) != 0xff) {
			if (stat & 0x0020) {
				int 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 kio_addr_t 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, last_ret, last_fn;

	tuple.TupleData = (cisdata_t *)buf;
	tuple.TupleOffset = 0;
	tuple.TupleDataMax = 255;
	tuple.Attributes = 0;

	/* Get configuration register information */
	tuple.DesiredTuple = CISTPL_CONFIG;
	last_ret = first_tuple(link, &tuple, &parse);
	if (last_ret != CS_SUCCESS) {
		last_fn = ParseTuple;
		goto cs_failed;
	}
	link->conf.ConfigBase = parse.config.base;
	link->conf.Present = parse.config.rmask[0];

	/* 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;

cs_failed:
	cs_error(link, last_fn, last_ret);

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>
	30	#include <linux/sched.h>
	31	#include <linux/delay.h>
	32	#include <linux/errno.h>
	33	#include <linux/ptrace.h>
	34	#include <linux/ioport.h>
	35	#include <linux/spinlock.h>
	36	#include <linux/moduleparam.h>
	37
	38	#include <linux/skbuff.h>
	39	#include <linux/string.h>
	40	#include <linux/serial.h>
	41	#include <linux/serial_reg.h>
	42	#include <linux/bitops.h>
	43	#include <asm/system.h>
	44	#include <asm/io.h>
	45
	46	#include <linux/device.h>
	47	#include <linux/firmware.h>
	48
1da177e4 LT	49	#include <pcmcia/cs_types.h>
	50	#include <pcmcia/cs.h>
	51	#include <pcmcia/cistpl.h>
	52	#include <pcmcia/ciscode.h>
	53	#include <pcmcia/ds.h>
	54	#include <pcmcia/cisreg.h>
	55
	56	#include <net/bluetooth/bluetooth.h>
	57	#include <net/bluetooth/hci_core.h>
	58
	59
	60
	61	/* ======================== Module parameters ======================== */
	62
	63
	64	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
	65	MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
	66	MODULE_LICENSE("GPL");
	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:
	306	eh = (struct hci_event_hdr *)(info->rx_skb->data);
	307	info->rx_state = RECV_WAIT_DATA;
	308	info->rx_count = eh->plen;
	309	break;
	310
	311	case RECV_WAIT_ACL_HEADER:
	312	ah = (struct hci_acl_hdr *)(info->rx_skb->data);
	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:
	319	sh = (struct hci_sco_hdr *)(info->rx_skb->data);
	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
	341	static irqreturn_t bt3c_interrupt(int irq, void dev_inst, struct pt_regs regs)
	342	{
343	bt3c_info_t *info = dev_inst;
344	unsigned int iobase;
345	int iir;
346
347	if (!info \|\| !info->hdev) {
348	BT_ERR("Call of irq %d for unknown device", irq);
349	return IRQ_NONE;
350	}
351
fd238232	352	iobase = info->p_dev->io.BasePort1;
1da177e4 LT	353
	354	spin_lock(&(info->lock));
	355
	356	iir = inb(iobase + CONTROL);
	357	if (iir & 0x80) {
	358	int stat = bt3c_read(iobase, 0x7001);
	359
	360	if ((stat & 0xff) == 0x7f) {
	361	BT_ERR("Very strange (stat=0x%04x)", stat);
	362	} else if ((stat & 0xff) != 0xff) {
	363	if (stat & 0x0020) {
	364	int stat = bt3c_read(iobase, 0x7002) & 0x10;
	365	BT_INFO("%s: Antenna %s", info->hdev->name,
	366	stat ? "out" : "in");
	367	}
	368	if (stat & 0x0001)
	369	bt3c_receive(info);
	370	if (stat & 0x0002) {
	371	//BT_ERR("Ack (stat=0x%04x)", stat);
	372	clear_bit(XMIT_SENDING, &(info->tx_state));
	373	bt3c_write_wakeup(info);
	374	}
	375
	376	bt3c_io_write(iobase, 0x7001, 0x0000);
	377
	378	outb(iir, iobase + CONTROL);
	379	}
	380	}
	381
	382	spin_unlock(&(info->lock));
	383
	384	return IRQ_HANDLED;
	385	}
	386
	387
	388
	389	/* ======================== HCI interface ======================== */
	390
	391
	392	static int bt3c_hci_flush(struct hci_dev *hdev)
	393	{
	394	bt3c_info_t info = (bt3c_info_t )(hdev->driver_data);
	395
	396	/* Drop TX queue */
	397	skb_queue_purge(&(info->txq));
	398
	399	return 0;
	400	}
	401
	402
	403	static int bt3c_hci_open(struct hci_dev *hdev)
	404	{
	405	set_bit(HCI_RUNNING, &(hdev->flags));
	406
	407	return 0;
	408	}
	409
	410
	411	static int bt3c_hci_close(struct hci_dev *hdev)
	412	{
	413	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
	414	return 0;
	415
	416	bt3c_hci_flush(hdev);
417
418	return 0;
419	}
420
421
422	static int bt3c_hci_send_frame(struct sk_buff *skb)
423	{
424	bt3c_info_t *info;
425	struct hci_dev hdev = (struct hci_dev )(skb->dev);
426	unsigned long flags;
427
428	if (!hdev) {
429	BT_ERR("Frame for unknown HCI device (hdev=NULL)");
430	return -ENODEV;
431	}
432
433	info = (bt3c_info_t *) (hdev->driver_data);
434
0d48d939	435	switch (bt_cb(skb)->pkt_type) {
1da177e4 LT	436	case HCI_COMMAND_PKT:
	437	hdev->stat.cmd_tx++;
	438	break;
	439	case HCI_ACLDATA_PKT:
	440	hdev->stat.acl_tx++;
	441	break;
	442	case HCI_SCODATA_PKT:
	443	hdev->stat.sco_tx++;
	444	break;
	445	};
	446
	447	/* Prepend skb with frame type */
0d48d939	448	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4 LT	449	skb_queue_tail(&(info->txq), skb);
	450
	451	spin_lock_irqsave(&(info->lock), flags);
	452
	453	bt3c_write_wakeup(info);
	454
	455	spin_unlock_irqrestore(&(info->lock), flags);
	456
	457	return 0;
	458	}
	459
	460
	461	static void bt3c_hci_destruct(struct hci_dev *hdev)
	462	{
	463	}
	464
	465
	466	static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
	467	{
	468	return -ENOIOCTLCMD;
	469	}
	470
	471
	472
	473	/* ======================== Card services HCI interaction ======================== */
	474
	475
1da177e4 LT	476	static int bt3c_load_firmware(bt3c_info_t info, unsigned char firmware, int count)
	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;
	662	link->irq.Attributes = IRQ_TYPE_EXCLUSIVE \| IRQ_HANDLE_PRESENT;
	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
fba395ee	683	static int get_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	684	{
	685	int i;
	686
	687	i = pcmcia_get_tuple_data(handle, tuple);
	688	if (i != CS_SUCCESS)
	689	return i;
	690
	691	return pcmcia_parse_tuple(handle, tuple, parse);
	692	}
	693
fba395ee	694	static int first_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	695	{
	696	if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
	697	return CS_NO_MORE_ITEMS;
	698	return get_tuple(handle, tuple, parse);
	699	}
	700
fba395ee	701	static int next_tuple(struct pcmcia_device handle, tuple_t tuple, cisparse_t *parse)
1da177e4 LT	702	{
	703	if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
	704	return CS_NO_MORE_ITEMS;
	705	return get_tuple(handle, tuple, parse);
	706	}
	707
15b99ac1	708	static int bt3c_config(struct pcmcia_device *link)
1da177e4 LT	709	{
1da177e4 LT	710	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
1da177e4 LT	711	bt3c_info_t *info = link->priv;
	712	tuple_t tuple;
	713	u_short buf[256];
	714	cisparse_t parse;
	715	cistpl_cftable_entry_t *cf = &parse.cftable_entry;
1da177e4 LT	716	int i, j, try, last_ret, last_fn;
	717
	718	tuple.TupleData = (cisdata_t *)buf;
	719	tuple.TupleOffset = 0;
	720	tuple.TupleDataMax = 255;
	721	tuple.Attributes = 0;
	722
	723	/* Get configuration register information */
	724	tuple.DesiredTuple = CISTPL_CONFIG;
fba395ee	725	last_ret = first_tuple(link, &tuple, &parse);
1da177e4 LT	726	if (last_ret != CS_SUCCESS) {
	727	last_fn = ParseTuple;
	728	goto cs_failed;
	729	}
	730	link->conf.ConfigBase = parse.config.base;
	731	link->conf.Present = parse.config.rmask[0];
	732
1da177e4 LT	733	/* First pass: look for a config entry that looks normal. */
	734	tuple.TupleData = (cisdata_t *)buf;
	735	tuple.TupleOffset = 0;
	736	tuple.TupleDataMax = 255;
	737	tuple.Attributes = 0;
	738	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
	739	/* Two tries: without IO aliases, then with aliases */
	740	for (try = 0; try < 2; try++) {
fba395ee	741	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	742	while (i != CS_NO_MORE_ITEMS) {
	743	if (i != CS_SUCCESS)
	744	goto next_entry;
	745	if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
70294b46	746	link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1da177e4 LT	747	if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
	748	link->conf.ConfigIndex = cf->index;
	749	link->io.BasePort1 = cf->io.win[0].base;
	750	link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
fba395ee	751	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	752	if (i == CS_SUCCESS)
	753	goto found_port;
	754	}
	755	next_entry:
fba395ee	756	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	757	}
	758	}
	759
	760	/* Second pass: try to find an entry that isn't picky about
	761	its base address, then try to grab any standard serial port
	762	address, and finally try to get any free port. */
fba395ee	763	i = first_tuple(link, &tuple, &parse);
1da177e4 LT	764	while (i != CS_NO_MORE_ITEMS) {
	765	if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
	766	link->conf.ConfigIndex = cf->index;
	767	for (j = 0; j < 5; j++) {
	768	link->io.BasePort1 = base[j];
	769	link->io.IOAddrLines = base[j] ? 16 : 3;
fba395ee	770	i = pcmcia_request_io(link, &link->io);
1da177e4 LT	771	if (i == CS_SUCCESS)
	772	goto found_port;
	773	}
	774	}
fba395ee	775	i = next_tuple(link, &tuple, &parse);
1da177e4 LT	776	}
	777
	778	found_port:
	779	if (i != CS_SUCCESS) {
	780	BT_ERR("No usable port range found");
fba395ee	781	cs_error(link, RequestIO, i);
1da177e4 LT	782	goto failed;
	783	}
	784
fba395ee	785	i = pcmcia_request_irq(link, &link->irq);
1da177e4	786	if (i != CS_SUCCESS) {
fba395ee	787	cs_error(link, RequestIRQ, i);
1da177e4 LT	788	link->irq.AssignedIRQ = 0;
	789	}
	790
fba395ee	791	i = pcmcia_request_configuration(link, &link->conf);
1da177e4	792	if (i != CS_SUCCESS) {
fba395ee	793	cs_error(link, RequestConfiguration, i);
1da177e4 LT	794	goto failed;
	795	}
	796
	797	if (bt3c_open(info) != 0)
	798	goto failed;
	799
	800	strcpy(info->node.dev_name, info->hdev->name);
fd238232	801	link->dev_node = &info->node;
1da177e4	802
15b99ac1	803	return 0;
1da177e4 LT	804
1da177e4 LT	805	cs_failed:
fba395ee	806	cs_error(link, last_fn, last_ret);
1da177e4 LT	807
	808	failed:
	809	bt3c_release(link);
15b99ac1	810	return -ENODEV;
1da177e4 LT	811	}
	812
	813
fba395ee	814	static void bt3c_release(struct pcmcia_device *link)
1da177e4 LT	815	{
	816	bt3c_info_t *info = link->priv;
	817
e2d40963	818	bt3c_close(info);
1da177e4	819
fba395ee	820	pcmcia_disable_device(link);
1da177e4 LT	821	}
1da177e4 LT	822
1da177e4	823
a01c3ed4 DB	824	static struct pcmcia_device_id bt3c_ids[] = {
	825	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
	826	PCMCIA_DEVICE_NULL
	827	};
	828	MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
	829
1da177e4 LT	830	static struct pcmcia_driver bt3c_driver = {
	831	.owner = THIS_MODULE,
	832	.drv = {
	833	.name = "bt3c_cs",
	834	},
15b99ac1	835	.probe = bt3c_probe,
cc3b4866	836	.remove = bt3c_detach,
a01c3ed4	837	.id_table = bt3c_ids,
1da177e4 LT	838	};
	839
	840	static int __init init_bt3c_cs(void)
	841	{
	842	return pcmcia_register_driver(&bt3c_driver);
	843	}
	844
	845
	846	static void __exit exit_bt3c_cs(void)
	847	{
	848	pcmcia_unregister_driver(&bt3c_driver);
1da177e4 LT	849	}
	850
	851	module_init(init_bt3c_cs);
	852	module_exit(exit_bt3c_cs);