1/*
  2 *
  3 *  Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)
  4 *
  5 *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
  6 *
  7 *
  8 *  This program is free software; you can redistribute it and/or modify
  9 *  it under the terms of the GNU General Public License version 2 as
 10 *  published by the Free Software Foundation;
 11 *
 12 *  Software distributed under the License is distributed on an "AS
 13 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 14 *  implied. See the License for the specific language governing
 15 *  rights and limitations under the License.
 16 *
 17 *  The initial developer of the original code is David A. Hinds
 18 *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
 19 *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
 20 *
 21 */
 22
 23#include <linux/module.h>
 24
 25#include <linux/kernel.h>
 26#include <linux/init.h>
 27#include <linux/slab.h>
 28#include <linux/types.h>
 29#include <linux/sched.h>
 30#include <linux/delay.h>
 31#include <linux/timer.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#include <linux/wait.h>
 38
 39#include <linux/skbuff.h>
 40#include <linux/io.h>
 41
 42#include <pcmcia/cistpl.h>
 43#include <pcmcia/ciscode.h>
 44#include <pcmcia/ds.h>
 45#include <pcmcia/cisreg.h>
 46
 47#include <net/bluetooth/bluetooth.h>
 48#include <net/bluetooth/hci_core.h>
 49
 50
 51
 52/* ======================== Module parameters ======================== */
 53
 54
 55MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 56MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)");
 57MODULE_LICENSE("GPL");
 58
 59
 60
 61/* ======================== Local structures ======================== */
 62
 63
 64struct bluecard_info {
 65	struct pcmcia_device *p_dev;
 66
 67	struct hci_dev *hdev;
 68
 69	spinlock_t lock;		/* For serializing operations */
 70	struct timer_list timer;	/* For LED control */
 71
 72	struct sk_buff_head txq;
 73	unsigned long tx_state;
 74
 75	unsigned long rx_state;
 76	unsigned long rx_count;
 77	struct sk_buff *rx_skb;
 78
 79	unsigned char ctrl_reg;
 80	unsigned long hw_state;		/* Status of the hardware and LED control */
 81};
 82
 83
 84static int bluecard_config(struct pcmcia_device *link);
 85static void bluecard_release(struct pcmcia_device *link);
 86
 87static void bluecard_detach(struct pcmcia_device *p_dev);
 88
 89
 90/* Default baud rate: 57600, 115200, 230400 or 460800 */
 91#define DEFAULT_BAUD_RATE  230400
 92
 93
 94/* Hardware states */
 95#define CARD_READY             1
 96#define CARD_HAS_PCCARD_ID     4
 97#define CARD_HAS_POWER_LED     5
 98#define CARD_HAS_ACTIVITY_LED  6
 99
100/* Transmit states  */
101#define XMIT_SENDING         1
102#define XMIT_WAKEUP          2
103#define XMIT_BUFFER_NUMBER   5	/* unset = buffer one, set = buffer two */
104#define XMIT_BUF_ONE_READY   6
105#define XMIT_BUF_TWO_READY   7
106#define XMIT_SENDING_READY   8
107
108/* Receiver states */
109#define RECV_WAIT_PACKET_TYPE   0
110#define RECV_WAIT_EVENT_HEADER  1
111#define RECV_WAIT_ACL_HEADER    2
112#define RECV_WAIT_SCO_HEADER    3
113#define RECV_WAIT_DATA          4
114
115/* Special packet types */
116#define PKT_BAUD_RATE_57600   0x80
117#define PKT_BAUD_RATE_115200  0x81
118#define PKT_BAUD_RATE_230400  0x82
119#define PKT_BAUD_RATE_460800  0x83
120
121
122/* These are the register offsets */
123#define REG_COMMAND     0x20
124#define REG_INTERRUPT   0x21
125#define REG_CONTROL     0x22
126#define REG_RX_CONTROL  0x24
127#define REG_CARD_RESET  0x30
128#define REG_LED_CTRL    0x30
129
130/* REG_COMMAND */
131#define REG_COMMAND_TX_BUF_ONE  0x01
132#define REG_COMMAND_TX_BUF_TWO  0x02
133#define REG_COMMAND_RX_BUF_ONE  0x04
134#define REG_COMMAND_RX_BUF_TWO  0x08
135#define REG_COMMAND_RX_WIN_ONE  0x00
136#define REG_COMMAND_RX_WIN_TWO  0x10
137
138/* REG_CONTROL */
139#define REG_CONTROL_BAUD_RATE_57600   0x00
140#define REG_CONTROL_BAUD_RATE_115200  0x01
141#define REG_CONTROL_BAUD_RATE_230400  0x02
142#define REG_CONTROL_BAUD_RATE_460800  0x03
143#define REG_CONTROL_RTS               0x04
144#define REG_CONTROL_BT_ON             0x08
145#define REG_CONTROL_BT_RESET          0x10
146#define REG_CONTROL_BT_RES_PU         0x20
147#define REG_CONTROL_INTERRUPT         0x40
148#define REG_CONTROL_CARD_RESET        0x80
149
150/* REG_RX_CONTROL */
151#define RTS_LEVEL_SHIFT_BITS  0x02
152
153
154
155/* ======================== LED handling routines ======================== */
156
157
158static void bluecard_activity_led_timeout(u_long arg)
159{
160	struct bluecard_info *info = (struct bluecard_info *)arg;
161	unsigned int iobase = info->p_dev->resource[0]->start;
162
163	if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
164		return;
165
166	if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
167		/* Disable activity LED */
168		outb(0x08 | 0x20, iobase + 0x30);
169	} else {
170		/* Disable power LED */
171		outb(0x00, iobase + 0x30);
172	}
173}
174
175
176static void bluecard_enable_activity_led(struct bluecard_info *info)
177{
178	unsigned int iobase = info->p_dev->resource[0]->start;
179
180	if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
181		return;
182
183	if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
184		/* Enable activity LED */
185		outb(0x10 | 0x40, iobase + 0x30);
186
187		/* Stop the LED after HZ/4 */
188		mod_timer(&(info->timer), jiffies + HZ / 4);
189	} else {
190		/* Enable power LED */
191		outb(0x08 | 0x20, iobase + 0x30);
192
193		/* Stop the LED after HZ/2 */
194		mod_timer(&(info->timer), jiffies + HZ / 2);
195	}
196}
197
198
199
200/* ======================== Interrupt handling ======================== */
201
202
203static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len)
204{
205	int i, actual;
206
207	actual = (len > 15) ? 15 : len;
208
209	outb_p(actual, iobase + offset);
210
211	for (i = 0; i < actual; i++)
212		outb_p(buf[i], iobase + offset + i + 1);
213
214	return actual;
215}
216
217
218static void bluecard_write_wakeup(struct bluecard_info *info)
219{
220	if (!info) {
221		BT_ERR("Unknown device");
222		return;
223	}
224
225	if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))
226		return;
227
228	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
229		set_bit(XMIT_WAKEUP, &(info->tx_state));
230		return;
231	}
232
233	do {
234		unsigned int iobase = info->p_dev->resource[0]->start;
235		unsigned int offset;
236		unsigned char command;
237		unsigned long ready_bit;
238		register struct sk_buff *skb;
239		int len;
240
241		clear_bit(XMIT_WAKEUP, &(info->tx_state));
242
243		if (!pcmcia_dev_present(info->p_dev))
244			return;
245
246		if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {
247			if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))
248				break;
249			offset = 0x10;
250			command = REG_COMMAND_TX_BUF_TWO;
251			ready_bit = XMIT_BUF_TWO_READY;
252		} else {
253			if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))
254				break;
255			offset = 0x00;
256			command = REG_COMMAND_TX_BUF_ONE;
257			ready_bit = XMIT_BUF_ONE_READY;
258		}
259
260		skb = skb_dequeue(&(info->txq));
261		if (!skb)
262			break;
263
264		if (hci_skb_pkt_type(skb) & 0x80) {
265			/* Disable RTS */
266			info->ctrl_reg |= REG_CONTROL_RTS;
267			outb(info->ctrl_reg, iobase + REG_CONTROL);
268		}
269
270		/* Activate LED */
271		bluecard_enable_activity_led(info);
272
273		/* Send frame */
274		len = bluecard_write(iobase, offset, skb->data, skb->len);
275
276		/* Tell the FPGA to send the data */
277		outb_p(command, iobase + REG_COMMAND);
278
279		/* Mark the buffer as dirty */
280		clear_bit(ready_bit, &(info->tx_state));
281
282		if (hci_skb_pkt_type(skb) & 0x80) {
283			DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
284			DEFINE_WAIT(wait);
285
286			unsigned char baud_reg;
287
288			switch (hci_skb_pkt_type(skb)) {
289			case PKT_BAUD_RATE_460800:
290				baud_reg = REG_CONTROL_BAUD_RATE_460800;
291				break;
292			case PKT_BAUD_RATE_230400:
293				baud_reg = REG_CONTROL_BAUD_RATE_230400;
294				break;
295			case PKT_BAUD_RATE_115200:
296				baud_reg = REG_CONTROL_BAUD_RATE_115200;
297				break;
298			case PKT_BAUD_RATE_57600:
299				/* Fall through... */
300			default:
301				baud_reg = REG_CONTROL_BAUD_RATE_57600;
302				break;
303			}
304
305			/* Wait until the command reaches the baseband */
306			prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
307			schedule_timeout(HZ/10);
308			finish_wait(&wq, &wait);
309
310			/* Set baud on baseband */
311			info->ctrl_reg &= ~0x03;
312			info->ctrl_reg |= baud_reg;
313			outb(info->ctrl_reg, iobase + REG_CONTROL);
314
315			/* Enable RTS */
316			info->ctrl_reg &= ~REG_CONTROL_RTS;
317			outb(info->ctrl_reg, iobase + REG_CONTROL);
318
319			/* Wait before the next HCI packet can be send */
320			prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
321			schedule_timeout(HZ);
322			finish_wait(&wq, &wait);
323		}
324
325		if (len == skb->len) {
326			kfree_skb(skb);
327		} else {
328			skb_pull(skb, len);
329			skb_queue_head(&(info->txq), skb);
330		}
331
332		info->hdev->stat.byte_tx += len;
333
334		/* Change buffer */
335		change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state));
336
337	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
338
339	clear_bit(XMIT_SENDING, &(info->tx_state));
340}
341
342
343static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size)
344{
345	int i, n, len;
346
347	outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND);
348
349	len = inb(iobase + offset);
350	n = 0;
351	i = 1;
352
353	while (n < len) {
354
355		if (i == 16) {
356			outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND);
357			i = 0;
358		}
359
360		buf[n] = inb(iobase + offset + i);
361
362		n++;
363		i++;
364
365	}
366
367	return len;
368}
369
370
371static void bluecard_receive(struct bluecard_info *info,
372			     unsigned int offset)
373{
374	unsigned int iobase;
375	unsigned char buf[31];
376	int i, len;
377
378	if (!info) {
379		BT_ERR("Unknown device");
380		return;
381	}
382
383	iobase = info->p_dev->resource[0]->start;
384
385	if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))
386		bluecard_enable_activity_led(info);
387
388	len = bluecard_read(iobase, offset, buf, sizeof(buf));
389
390	for (i = 0; i < len; i++) {
391
392		/* Allocate packet */
393		if (!info->rx_skb) {
394			info->rx_state = RECV_WAIT_PACKET_TYPE;
395			info->rx_count = 0;
396			info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
397			if (!info->rx_skb) {
398				BT_ERR("Can't allocate mem for new packet");
399				return;
400			}
401		}
402
403		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
404
405			hci_skb_pkt_type(info->rx_skb) = buf[i];
406
407			switch (hci_skb_pkt_type(info->rx_skb)) {
408
409			case 0x00:
410				/* init packet */
411				if (offset != 0x00) {
412					set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
413					set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
414					set_bit(XMIT_SENDING_READY, &(info->tx_state));
415					bluecard_write_wakeup(info);
416				}
417
418				kfree_skb(info->rx_skb);
419				info->rx_skb = NULL;
420				break;
421
422			case HCI_EVENT_PKT:
423				info->rx_state = RECV_WAIT_EVENT_HEADER;
424				info->rx_count = HCI_EVENT_HDR_SIZE;
425				break;
426
427			case HCI_ACLDATA_PKT:
428				info->rx_state = RECV_WAIT_ACL_HEADER;
429				info->rx_count = HCI_ACL_HDR_SIZE;
430				break;
431
432			case HCI_SCODATA_PKT:
433				info->rx_state = RECV_WAIT_SCO_HEADER;
434				info->rx_count = HCI_SCO_HDR_SIZE;
435				break;
436
437			default:
438				/* unknown packet */
439				BT_ERR("Unknown HCI packet with type 0x%02x received",
440				       hci_skb_pkt_type(info->rx_skb));
441				info->hdev->stat.err_rx++;
442
443				kfree_skb(info->rx_skb);
444				info->rx_skb = NULL;
445				break;
446
447			}
448
449		} else {
450
451			*skb_put(info->rx_skb, 1) = buf[i];
452			info->rx_count--;
453
454			if (info->rx_count == 0) {
455
456				int dlen;
457				struct hci_event_hdr *eh;
458				struct hci_acl_hdr *ah;
459				struct hci_sco_hdr *sh;
460
461				switch (info->rx_state) {
462
463				case RECV_WAIT_EVENT_HEADER:
464					eh = hci_event_hdr(info->rx_skb);
465					info->rx_state = RECV_WAIT_DATA;
466					info->rx_count = eh->plen;
467					break;
468
469				case RECV_WAIT_ACL_HEADER:
470					ah = hci_acl_hdr(info->rx_skb);
471					dlen = __le16_to_cpu(ah->dlen);
472					info->rx_state = RECV_WAIT_DATA;
473					info->rx_count = dlen;
474					break;
475
476				case RECV_WAIT_SCO_HEADER:
477					sh = hci_sco_hdr(info->rx_skb);
478					info->rx_state = RECV_WAIT_DATA;
479					info->rx_count = sh->dlen;
480					break;
481
482				case RECV_WAIT_DATA:
483					hci_recv_frame(info->hdev, info->rx_skb);
484					info->rx_skb = NULL;
485					break;
486
487				}
488
489			}
490
491		}
492
493
494	}
495
496	info->hdev->stat.byte_rx += len;
497}
498
499
500static irqreturn_t bluecard_interrupt(int irq, void *dev_inst)
501{
502	struct bluecard_info *info = dev_inst;
503	unsigned int iobase;
504	unsigned char reg;
505
506	if (!info || !info->hdev)
507		/* our irq handler is shared */
508		return IRQ_NONE;
509
510	if (!test_bit(CARD_READY, &(info->hw_state)))
511		return IRQ_HANDLED;
512
513	iobase = info->p_dev->resource[0]->start;
514
515	spin_lock(&(info->lock));
516
517	/* Disable interrupt */
518	info->ctrl_reg &= ~REG_CONTROL_INTERRUPT;
519	outb(info->ctrl_reg, iobase + REG_CONTROL);
520
521	reg = inb(iobase + REG_INTERRUPT);
522
523	if ((reg != 0x00) && (reg != 0xff)) {
524
525		if (reg & 0x04) {
526			bluecard_receive(info, 0x00);
527			outb(0x04, iobase + REG_INTERRUPT);
528			outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
529		}
530
531		if (reg & 0x08) {
532			bluecard_receive(info, 0x10);
533			outb(0x08, iobase + REG_INTERRUPT);
534			outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
535		}
536
537		if (reg & 0x01) {
538			set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
539			outb(0x01, iobase + REG_INTERRUPT);
540			bluecard_write_wakeup(info);
541		}
542
543		if (reg & 0x02) {
544			set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
545			outb(0x02, iobase + REG_INTERRUPT);
546			bluecard_write_wakeup(info);
547		}
548
549	}
550
551	/* Enable interrupt */
552	info->ctrl_reg |= REG_CONTROL_INTERRUPT;
553	outb(info->ctrl_reg, iobase + REG_CONTROL);
554
555	spin_unlock(&(info->lock));
556
557	return IRQ_HANDLED;
558}
559
560
561
562/* ======================== Device specific HCI commands ======================== */
563
564
565static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud)
566{
567	struct bluecard_info *info = hci_get_drvdata(hdev);
568	struct sk_buff *skb;
569
570	/* Ericsson baud rate command */
571	unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 };
572
573	skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
574	if (!skb) {
575		BT_ERR("Can't allocate mem for new packet");
576		return -1;
577	}
578
579	switch (baud) {
580	case 460800:
581		cmd[4] = 0x00;
582		hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800;
583		break;
584	case 230400:
585		cmd[4] = 0x01;
586		hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400;
587		break;
588	case 115200:
589		cmd[4] = 0x02;
590		hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200;
591		break;
592	case 57600:
593		/* Fall through... */
594	default:
595		cmd[4] = 0x03;
596		hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600;
597		break;
598	}
599
600	memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
601
602	skb_queue_tail(&(info->txq), skb);
603
604	bluecard_write_wakeup(info);
605
606	return 0;
607}
608
609
610
611/* ======================== HCI interface ======================== */
612
613
614static int bluecard_hci_flush(struct hci_dev *hdev)
615{
616	struct bluecard_info *info = hci_get_drvdata(hdev);
617
618	/* Drop TX queue */
619	skb_queue_purge(&(info->txq));
620
621	return 0;
622}
623
624
625static int bluecard_hci_open(struct hci_dev *hdev)
626{
627	struct bluecard_info *info = hci_get_drvdata(hdev);
628
629	if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
630		bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE);
631
632	if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
633		unsigned int iobase = info->p_dev->resource[0]->start;
634
635		/* Enable LED */
636		outb(0x08 | 0x20, iobase + 0x30);
637	}
638
639	return 0;
640}
641
642
643static int bluecard_hci_close(struct hci_dev *hdev)
644{
645	struct bluecard_info *info = hci_get_drvdata(hdev);
646
647	bluecard_hci_flush(hdev);
648
649	if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
650		unsigned int iobase = info->p_dev->resource[0]->start;
651
652		/* Disable LED */
653		outb(0x00, iobase + 0x30);
654	}
655
656	return 0;
657}
658
659
660static int bluecard_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
661{
662	struct bluecard_info *info = hci_get_drvdata(hdev);
663
664	switch (hci_skb_pkt_type(skb)) {
665	case HCI_COMMAND_PKT:
666		hdev->stat.cmd_tx++;
667		break;
668	case HCI_ACLDATA_PKT:
669		hdev->stat.acl_tx++;
670		break;
671	case HCI_SCODATA_PKT:
672		hdev->stat.sco_tx++;
673		break;
674	}
675
676	/* Prepend skb with frame type */
677	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
678	skb_queue_tail(&(info->txq), skb);
679
680	bluecard_write_wakeup(info);
681
682	return 0;
683}
684
685
686
687/* ======================== Card services HCI interaction ======================== */
688
689
690static int bluecard_open(struct bluecard_info *info)
691{
692	unsigned int iobase = info->p_dev->resource[0]->start;
693	struct hci_dev *hdev;
694	unsigned char id;
695
696	spin_lock_init(&(info->lock));
697
698	init_timer(&(info->timer));
699	info->timer.function = &bluecard_activity_led_timeout;
700	info->timer.data = (u_long)info;
701
702	skb_queue_head_init(&(info->txq));
703
704	info->rx_state = RECV_WAIT_PACKET_TYPE;
705	info->rx_count = 0;
706	info->rx_skb = NULL;
707
708	/* Initialize HCI device */
709	hdev = hci_alloc_dev();
710	if (!hdev) {
711		BT_ERR("Can't allocate HCI device");
712		return -ENOMEM;
713	}
714
715	info->hdev = hdev;
716
717	hdev->bus = HCI_PCCARD;
718	hci_set_drvdata(hdev, info);
719	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
720
721	hdev->open  = bluecard_hci_open;
722	hdev->close = bluecard_hci_close;
723	hdev->flush = bluecard_hci_flush;
724	hdev->send  = bluecard_hci_send_frame;
725
726	id = inb(iobase + 0x30);
727
728	if ((id & 0x0f) == 0x02)
729		set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));
730
731	if (id & 0x10)
732		set_bit(CARD_HAS_POWER_LED, &(info->hw_state));
733
734	if (id & 0x20)
735		set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));
736
737	/* Reset card */
738	info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
739	outb(info->ctrl_reg, iobase + REG_CONTROL);
740
741	/* Turn FPGA off */
742	outb(0x80, iobase + 0x30);
743
744	/* Wait some time */
745	msleep(10);
746
747	/* Turn FPGA on */
748	outb(0x00, iobase + 0x30);
749
750	/* Activate card */
751	info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;
752	outb(info->ctrl_reg, iobase + REG_CONTROL);
753
754	/* Enable interrupt */
755	outb(0xff, iobase + REG_INTERRUPT);
756	info->ctrl_reg |= REG_CONTROL_INTERRUPT;
757	outb(info->ctrl_reg, iobase + REG_CONTROL);
758
759	if ((id & 0x0f) == 0x03) {
760		/* Disable RTS */
761		info->ctrl_reg |= REG_CONTROL_RTS;
762		outb(info->ctrl_reg, iobase + REG_CONTROL);
763
764		/* Set baud rate */
765		info->ctrl_reg |= 0x03;
766		outb(info->ctrl_reg, iobase + REG_CONTROL);
767
768		/* Enable RTS */
769		info->ctrl_reg &= ~REG_CONTROL_RTS;
770		outb(info->ctrl_reg, iobase + REG_CONTROL);
771
772		set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
773		set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
774		set_bit(XMIT_SENDING_READY, &(info->tx_state));
775	}
776
777	/* Start the RX buffers */
778	outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
779	outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
780
781	/* Signal that the hardware is ready */
782	set_bit(CARD_READY, &(info->hw_state));
783
784	/* Drop TX queue */
785	skb_queue_purge(&(info->txq));
786
787	/* Control the point at which RTS is enabled */
788	outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL);
789
790	/* Timeout before it is safe to send the first HCI packet */
791	msleep(1250);
792
793	/* Register HCI device */
794	if (hci_register_dev(hdev) < 0) {
795		BT_ERR("Can't register HCI device");
796		info->hdev = NULL;
797		hci_free_dev(hdev);
798		return -ENODEV;
799	}
800
801	return 0;
802}
803
804
805static int bluecard_close(struct bluecard_info *info)
806{
807	unsigned int iobase = info->p_dev->resource[0]->start;
808	struct hci_dev *hdev = info->hdev;
809
810	if (!hdev)
811		return -ENODEV;
812
813	bluecard_hci_close(hdev);
814
815	clear_bit(CARD_READY, &(info->hw_state));
816
817	/* Reset card */
818	info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
819	outb(info->ctrl_reg, iobase + REG_CONTROL);
820
821	/* Turn FPGA off */
822	outb(0x80, iobase + 0x30);
823
824	hci_unregister_dev(hdev);
825	hci_free_dev(hdev);
826
827	return 0;
828}
829
830static int bluecard_probe(struct pcmcia_device *link)
831{
832	struct bluecard_info *info;
833
834	/* Create new info device */
835	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
836	if (!info)
837		return -ENOMEM;
838
839	info->p_dev = link;
840	link->priv = info;
841
842	link->config_flags |= CONF_ENABLE_IRQ;
843
844	return bluecard_config(link);
845}
846
847
848static void bluecard_detach(struct pcmcia_device *link)
849{
850	bluecard_release(link);
851}
852
853
854static int bluecard_config(struct pcmcia_device *link)
855{
856	struct bluecard_info *info = link->priv;
857	int i, n;
858
859	link->config_index = 0x20;
860
861	link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
862	link->resource[0]->end = 64;
863	link->io_lines = 6;
864
865	for (n = 0; n < 0x400; n += 0x40) {
866		link->resource[0]->start = n ^ 0x300;
867		i = pcmcia_request_io(link);
868		if (i == 0)
869			break;
870	}
871
872	if (i != 0)
873		goto failed;
874
875	i = pcmcia_request_irq(link, bluecard_interrupt);
876	if (i != 0)
877		goto failed;
878
879	i = pcmcia_enable_device(link);
880	if (i != 0)
881		goto failed;
882
883	if (bluecard_open(info) != 0)
884		goto failed;
885
886	return 0;
887
888failed:
889	bluecard_release(link);
890	return -ENODEV;
891}
892
893
894static void bluecard_release(struct pcmcia_device *link)
895{
896	struct bluecard_info *info = link->priv;
897
898	bluecard_close(info);
899
900	del_timer_sync(&(info->timer));
901
902	pcmcia_disable_device(link);
903}
904
905static const struct pcmcia_device_id bluecard_ids[] = {
906	PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e),
907	PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c),
908	PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab),
909	PCMCIA_DEVICE_NULL
910};
911MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);
912
913static struct pcmcia_driver bluecard_driver = {
914	.owner		= THIS_MODULE,
915	.name		= "bluecard_cs",
916	.probe		= bluecard_probe,
917	.remove		= bluecard_detach,
918	.id_table	= bluecard_ids,
919};
920module_pcmcia_driver(bluecard_driver);