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
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/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
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
63MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
64MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
65MODULE_LICENSE("GPL");
66MODULE_FIRMWARE("BT3CPCC.bin");
67
68
69
70/* ======================== Local structures ======================== */
71
72
73typedef struct bt3c_info_t {
74	struct pcmcia_device *p_dev;
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
90static int bt3c_config(struct pcmcia_device *link);
91static void bt3c_release(struct pcmcia_device *link);
92
93static void bt3c_detach(struct pcmcia_device *p_dev);
94
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
120static 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
127static 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
134static 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
141static 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
151static 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
163static 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
182static 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 {
193		register unsigned int iobase = info->p_dev->io.BasePort1;
194		register struct sk_buff *skb;
195		register int len;
196
197		if (!pcmcia_dev_present(info->p_dev))
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
221static 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
231	iobase = info->p_dev->io.BasePort1;
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;
255			bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
256			inb(iobase + DATA_H);
257			//printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
258
259			switch (bt_cb(info->rx_skb)->pkt_type) {
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 */
278				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
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 = hci_event_hdr(info->rx_skb);
307					info->rx_state = RECV_WAIT_DATA;
308					info->rx_count = eh->plen;
309					break;
310
311				case RECV_WAIT_ACL_HEADER:
312					ah = hci_acl_hdr(info->rx_skb);
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 = hci_sco_hdr(info->rx_skb);
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
341static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
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
352	iobase = info->p_dev->io.BasePort1;
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
392static 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
403static int bt3c_hci_open(struct hci_dev *hdev)
404{
405	set_bit(HCI_RUNNING, &(hdev->flags));
406
407	return 0;
408}
409
410
411static 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
422static 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
435	switch (bt_cb(skb)->pkt_type) {
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 */
448	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
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
461static void bt3c_hci_destruct(struct hci_dev *hdev)
462{
463}
464
465
466static 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
476static 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
483	iobase = info->p_dev->io.BasePort1;
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
548error:
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
560static 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;
585	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
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 */
597	err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
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
624error:
625	info->hdev = NULL;
626	hci_free_dev(hdev);
627	return err;
628}
629
630
631static 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
648static int bt3c_probe(struct pcmcia_device *link)
649{
650	bt3c_info_t *info;
651
652	/* Create new info device */
653	info = kzalloc(sizeof(*info), GFP_KERNEL);
654	if (!info)
655		return -ENOMEM;
656
657	info->p_dev = link;
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;
669	link->conf.IntType = INT_MEMORY_AND_IO;
670
671	return bt3c_config(link);
672}
673
674
675static void bt3c_detach(struct pcmcia_device *link)
676{
677	bt3c_info_t *info = link->priv;
678
679	bt3c_release(link);
680	kfree(info);
681}
682
683static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
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
694static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
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
701static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
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
708static int bt3c_config(struct pcmcia_device *link)
709{
710	static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
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;
716	int i, j, try;
717
718	/* First pass: look for a config entry that looks normal. */
719	tuple.TupleData = (cisdata_t *)buf;
720	tuple.TupleOffset = 0;
721	tuple.TupleDataMax = 255;
722	tuple.Attributes = 0;
723	tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
724	/* Two tries: without IO aliases, then with aliases */
725	for (try = 0; try < 2; try++) {
726		i = first_tuple(link, &tuple, &parse);
727		while (i != CS_NO_MORE_ITEMS) {
728			if (i != CS_SUCCESS)
729				goto next_entry;
730			if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
731				link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
732			if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
733				link->conf.ConfigIndex = cf->index;
734				link->io.BasePort1 = cf->io.win[0].base;
735				link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
736				i = pcmcia_request_io(link, &link->io);
737				if (i == CS_SUCCESS)
738					goto found_port;
739			}
740next_entry:
741			i = next_tuple(link, &tuple, &parse);
742		}
743	}
744
745	/* Second pass: try to find an entry that isn't picky about
746	   its base address, then try to grab any standard serial port
747	   address, and finally try to get any free port. */
748	i = first_tuple(link, &tuple, &parse);
749	while (i != CS_NO_MORE_ITEMS) {
750		if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
751			link->conf.ConfigIndex = cf->index;
752			for (j = 0; j < 5; j++) {
753				link->io.BasePort1 = base[j];
754				link->io.IOAddrLines = base[j] ? 16 : 3;
755				i = pcmcia_request_io(link, &link->io);
756				if (i == CS_SUCCESS)
757					goto found_port;
758			}
759		}
760		i = next_tuple(link, &tuple, &parse);
761	}
762
763found_port:
764	if (i != CS_SUCCESS) {
765		BT_ERR("No usable port range found");
766		cs_error(link, RequestIO, i);
767		goto failed;
768	}
769
770	i = pcmcia_request_irq(link, &link->irq);
771	if (i != CS_SUCCESS) {
772		cs_error(link, RequestIRQ, i);
773		link->irq.AssignedIRQ = 0;
774	}
775
776	i = pcmcia_request_configuration(link, &link->conf);
777	if (i != CS_SUCCESS) {
778		cs_error(link, RequestConfiguration, i);
779		goto failed;
780	}
781
782	if (bt3c_open(info) != 0)
783		goto failed;
784
785	strcpy(info->node.dev_name, info->hdev->name);
786	link->dev_node = &info->node;
787
788	return 0;
789
790failed:
791	bt3c_release(link);
792	return -ENODEV;
793}
794
795
796static void bt3c_release(struct pcmcia_device *link)
797{
798	bt3c_info_t *info = link->priv;
799
800	bt3c_close(info);
801
802	pcmcia_disable_device(link);
803}
804
805
806static struct pcmcia_device_id bt3c_ids[] = {
807	PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
808	PCMCIA_DEVICE_NULL
809};
810MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
811
812static struct pcmcia_driver bt3c_driver = {
813	.owner		= THIS_MODULE,
814	.drv		= {
815		.name	= "bt3c_cs",
816	},
817	.probe		= bt3c_probe,
818	.remove		= bt3c_detach,
819	.id_table	= bt3c_ids,
820};
821
822static int __init init_bt3c_cs(void)
823{
824	return pcmcia_register_driver(&bt3c_driver);
825}
826
827
828static void __exit exit_bt3c_cs(void)
829{
830	pcmcia_unregister_driver(&bt3c_driver);
831}
832
833module_init(init_bt3c_cs);
834module_exit(exit_bt3c_cs);
835