1/*
2 *
3 *  Driver for Bluetooth PCMCIA cards with HCI UART interface
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/delay.h>
30#include <linux/errno.h>
31#include <linux/ptrace.h>
32#include <linux/ioport.h>
33#include <linux/spinlock.h>
34#include <linux/moduleparam.h>
35
36#include <linux/skbuff.h>
37#include <linux/string.h>
38#include <linux/serial.h>
39#include <linux/serial_reg.h>
40#include <linux/bitops.h>
41#include <asm/io.h>
42
43#include <pcmcia/cistpl.h>
44#include <pcmcia/ciscode.h>
45#include <pcmcia/ds.h>
46#include <pcmcia/cisreg.h>
47
48#include <net/bluetooth/bluetooth.h>
49#include <net/bluetooth/hci_core.h>
50
51
52
53/* ======================== Module parameters ======================== */
54
55
56MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
57MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
58MODULE_LICENSE("GPL");
59
60
61
62/* ======================== Local structures ======================== */
63
64
65struct btuart_info {
66	struct pcmcia_device *p_dev;
67
68	struct hci_dev *hdev;
69
70	spinlock_t lock;	/* For serializing operations */
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
80
81static int btuart_config(struct pcmcia_device *link);
82static void btuart_release(struct pcmcia_device *link);
83
84static void btuart_detach(struct pcmcia_device *p_dev);
85
86
87/* Maximum baud rate */
88#define SPEED_MAX  115200
89
90/* Default baud rate: 57600, 115200, 230400 or 460800 */
91#define DEFAULT_BAUD_RATE  115200
92
93
94/* Transmit states  */
95#define XMIT_SENDING	1
96#define XMIT_WAKEUP	2
97#define XMIT_WAITING	8
98
99/* Receiver states */
100#define RECV_WAIT_PACKET_TYPE	0
101#define RECV_WAIT_EVENT_HEADER	1
102#define RECV_WAIT_ACL_HEADER	2
103#define RECV_WAIT_SCO_HEADER	3
104#define RECV_WAIT_DATA		4
105
106
107
108/* ======================== Interrupt handling ======================== */
109
110
111static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
112{
113	int actual = 0;
114
115	/* Tx FIFO should be empty */
116	if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
117		return 0;
118
119	/* Fill FIFO with current frame */
120	while ((fifo_size-- > 0) && (actual < len)) {
121		/* Transmit next byte */
122		outb(buf[actual], iobase + UART_TX);
123		actual++;
124	}
125
126	return actual;
127}
128
129
130static void btuart_write_wakeup(struct btuart_info *info)
131{
132	if (!info) {
133		BT_ERR("Unknown device");
134		return;
135	}
136
137	if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
138		set_bit(XMIT_WAKEUP, &(info->tx_state));
139		return;
140	}
141
142	do {
143		unsigned int iobase = info->p_dev->resource[0]->start;
144		register struct sk_buff *skb;
145		int len;
146
147		clear_bit(XMIT_WAKEUP, &(info->tx_state));
148
149		if (!pcmcia_dev_present(info->p_dev))
150			return;
151
152		skb = skb_dequeue(&(info->txq));
153		if (!skb)
154			break;
155
156		/* Send frame */
157		len = btuart_write(iobase, 16, skb->data, skb->len);
158		set_bit(XMIT_WAKEUP, &(info->tx_state));
159
160		if (len == skb->len) {
161			kfree_skb(skb);
162		} else {
163			skb_pull(skb, len);
164			skb_queue_head(&(info->txq), skb);
165		}
166
167		info->hdev->stat.byte_tx += len;
168
169	} while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
170
171	clear_bit(XMIT_SENDING, &(info->tx_state));
172}
173
174
175static void btuart_receive(struct btuart_info *info)
176{
177	unsigned int iobase;
178	int boguscount = 0;
179
180	if (!info) {
181		BT_ERR("Unknown device");
182		return;
183	}
184
185	iobase = info->p_dev->resource[0]->start;
186
187	do {
188		info->hdev->stat.byte_rx++;
189
190		/* Allocate packet */
191		if (info->rx_skb == NULL) {
192			info->rx_state = RECV_WAIT_PACKET_TYPE;
193			info->rx_count = 0;
194			info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
195			if (!info->rx_skb) {
196				BT_ERR("Can't allocate mem for new packet");
197				return;
198			}
199		}
200
201		if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
202
203			bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
204
205			switch (bt_cb(info->rx_skb)->pkt_type) {
206
207			case HCI_EVENT_PKT:
208				info->rx_state = RECV_WAIT_EVENT_HEADER;
209				info->rx_count = HCI_EVENT_HDR_SIZE;
210				break;
211
212			case HCI_ACLDATA_PKT:
213				info->rx_state = RECV_WAIT_ACL_HEADER;
214				info->rx_count = HCI_ACL_HDR_SIZE;
215				break;
216
217			case HCI_SCODATA_PKT:
218				info->rx_state = RECV_WAIT_SCO_HEADER;
219				info->rx_count = HCI_SCO_HDR_SIZE;
220				break;
221
222			default:
223				/* Unknown packet */
224				BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
225				info->hdev->stat.err_rx++;
226				clear_bit(HCI_RUNNING, &(info->hdev->flags));
227
228				kfree_skb(info->rx_skb);
229				info->rx_skb = NULL;
230				break;
231
232			}
233
234		} else {
235
236			*skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
237			info->rx_count--;
238
239			if (info->rx_count == 0) {
240
241				int dlen;
242				struct hci_event_hdr *eh;
243				struct hci_acl_hdr *ah;
244				struct hci_sco_hdr *sh;
245
246
247				switch (info->rx_state) {
248
249				case RECV_WAIT_EVENT_HEADER:
250					eh = hci_event_hdr(info->rx_skb);
251					info->rx_state = RECV_WAIT_DATA;
252					info->rx_count = eh->plen;
253					break;
254
255				case RECV_WAIT_ACL_HEADER:
256					ah = hci_acl_hdr(info->rx_skb);
257					dlen = __le16_to_cpu(ah->dlen);
258					info->rx_state = RECV_WAIT_DATA;
259					info->rx_count = dlen;
260					break;
261
262				case RECV_WAIT_SCO_HEADER:
263					sh = hci_sco_hdr(info->rx_skb);
264					info->rx_state = RECV_WAIT_DATA;
265					info->rx_count = sh->dlen;
266					break;
267
268				case RECV_WAIT_DATA:
269					hci_recv_frame(info->hdev, info->rx_skb);
270					info->rx_skb = NULL;
271					break;
272
273				}
274
275			}
276
277		}
278
279		/* Make sure we don't stay here too long */
280		if (boguscount++ > 16)
281			break;
282
283	} while (inb(iobase + UART_LSR) & UART_LSR_DR);
284}
285
286
287static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
288{
289	struct btuart_info *info = dev_inst;
290	unsigned int iobase;
291	int boguscount = 0;
292	int iir, lsr;
293	irqreturn_t r = IRQ_NONE;
294
295	if (!info || !info->hdev)
296		/* our irq handler is shared */
297		return IRQ_NONE;
298
299	iobase = info->p_dev->resource[0]->start;
300
301	spin_lock(&(info->lock));
302
303	iir = inb(iobase + UART_IIR) & UART_IIR_ID;
304	while (iir) {
305		r = IRQ_HANDLED;
306
307		/* Clear interrupt */
308		lsr = inb(iobase + UART_LSR);
309
310		switch (iir) {
311		case UART_IIR_RLSI:
312			BT_ERR("RLSI");
313			break;
314		case UART_IIR_RDI:
315			/* Receive interrupt */
316			btuart_receive(info);
317			break;
318		case UART_IIR_THRI:
319			if (lsr & UART_LSR_THRE) {
320				/* Transmitter ready for data */
321				btuart_write_wakeup(info);
322			}
323			break;
324		default:
325			BT_ERR("Unhandled IIR=%#x", iir);
326			break;
327		}
328
329		/* Make sure we don't stay here too long */
330		if (boguscount++ > 100)
331			break;
332
333		iir = inb(iobase + UART_IIR) & UART_IIR_ID;
334
335	}
336
337	spin_unlock(&(info->lock));
338
339	return r;
340}
341
342
343static void btuart_change_speed(struct btuart_info *info,
344				unsigned int speed)
345{
346	unsigned long flags;
347	unsigned int iobase;
348	int fcr;		/* FIFO control reg */
349	int lcr;		/* Line control reg */
350	int divisor;
351
352	if (!info) {
353		BT_ERR("Unknown device");
354		return;
355	}
356
357	iobase = info->p_dev->resource[0]->start;
358
359	spin_lock_irqsave(&(info->lock), flags);
360
361	/* Turn off interrupts */
362	outb(0, iobase + UART_IER);
363
364	divisor = SPEED_MAX / speed;
365
366	fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
367
368	/*
369	 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
370	 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
371	 * about this timeout since it will always be fast enough.
372	 */
373
374	if (speed < 38400)
375		fcr |= UART_FCR_TRIGGER_1;
376	else
377		fcr |= UART_FCR_TRIGGER_14;
378
379	/* Bluetooth cards use 8N1 */
380	lcr = UART_LCR_WLEN8;
381
382	outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);	/* Set DLAB */
383	outb(divisor & 0xff, iobase + UART_DLL);	/* Set speed */
384	outb(divisor >> 8, iobase + UART_DLM);
385	outb(lcr, iobase + UART_LCR);	/* Set 8N1  */
386	outb(fcr, iobase + UART_FCR);	/* Enable FIFO's */
387
388	/* Turn on interrupts */
389	outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
390
391	spin_unlock_irqrestore(&(info->lock), flags);
392}
393
394
395
396/* ======================== HCI interface ======================== */
397
398
399static int btuart_hci_flush(struct hci_dev *hdev)
400{
401	struct btuart_info *info = hci_get_drvdata(hdev);
402
403	/* Drop TX queue */
404	skb_queue_purge(&(info->txq));
405
406	return 0;
407}
408
409
410static int btuart_hci_open(struct hci_dev *hdev)
411{
412	set_bit(HCI_RUNNING, &(hdev->flags));
413
414	return 0;
415}
416
417
418static int btuart_hci_close(struct hci_dev *hdev)
419{
420	if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
421		return 0;
422
423	btuart_hci_flush(hdev);
424
425	return 0;
426}
427
428
429static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
430{
431	struct btuart_info *info = hci_get_drvdata(hdev);
432
433	switch (bt_cb(skb)->pkt_type) {
434	case HCI_COMMAND_PKT:
435		hdev->stat.cmd_tx++;
436		break;
437	case HCI_ACLDATA_PKT:
438		hdev->stat.acl_tx++;
439		break;
440	case HCI_SCODATA_PKT:
441		hdev->stat.sco_tx++;
442		break;
443	}
444
445	/* Prepend skb with frame type */
446	memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
447	skb_queue_tail(&(info->txq), skb);
448
449	btuart_write_wakeup(info);
450
451	return 0;
452}
453
454
455
456/* ======================== Card services HCI interaction ======================== */
457
458
459static int btuart_open(struct btuart_info *info)
460{
461	unsigned long flags;
462	unsigned int iobase = info->p_dev->resource[0]->start;
463	struct hci_dev *hdev;
464
465	spin_lock_init(&(info->lock));
466
467	skb_queue_head_init(&(info->txq));
468
469	info->rx_state = RECV_WAIT_PACKET_TYPE;
470	info->rx_count = 0;
471	info->rx_skb = NULL;
472
473	/* Initialize HCI device */
474	hdev = hci_alloc_dev();
475	if (!hdev) {
476		BT_ERR("Can't allocate HCI device");
477		return -ENOMEM;
478	}
479
480	info->hdev = hdev;
481
482	hdev->bus = HCI_PCCARD;
483	hci_set_drvdata(hdev, info);
484	SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
485
486	hdev->open  = btuart_hci_open;
487	hdev->close = btuart_hci_close;
488	hdev->flush = btuart_hci_flush;
489	hdev->send  = btuart_hci_send_frame;
490
491	spin_lock_irqsave(&(info->lock), flags);
492
493	/* Reset UART */
494	outb(0, iobase + UART_MCR);
495
496	/* Turn off interrupts */
497	outb(0, iobase + UART_IER);
498
499	/* Initialize UART */
500	outb(UART_LCR_WLEN8, iobase + UART_LCR);	/* Reset DLAB */
501	outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
502
503	/* Turn on interrupts */
504	// outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
505
506	spin_unlock_irqrestore(&(info->lock), flags);
507
508	btuart_change_speed(info, DEFAULT_BAUD_RATE);
509
510	/* Timeout before it is safe to send the first HCI packet */
511	msleep(1000);
512
513	/* Register HCI device */
514	if (hci_register_dev(hdev) < 0) {
515		BT_ERR("Can't register HCI device");
516		info->hdev = NULL;
517		hci_free_dev(hdev);
518		return -ENODEV;
519	}
520
521	return 0;
522}
523
524
525static int btuart_close(struct btuart_info *info)
526{
527	unsigned long flags;
528	unsigned int iobase = info->p_dev->resource[0]->start;
529	struct hci_dev *hdev = info->hdev;
530
531	if (!hdev)
532		return -ENODEV;
533
534	btuart_hci_close(hdev);
535
536	spin_lock_irqsave(&(info->lock), flags);
537
538	/* Reset UART */
539	outb(0, iobase + UART_MCR);
540
541	/* Turn off interrupts */
542	outb(0, iobase + UART_IER);
543
544	spin_unlock_irqrestore(&(info->lock), flags);
545
546	hci_unregister_dev(hdev);
547	hci_free_dev(hdev);
548
549	return 0;
550}
551
552static int btuart_probe(struct pcmcia_device *link)
553{
554	struct btuart_info *info;
555
556	/* Create new info device */
557	info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
558	if (!info)
559		return -ENOMEM;
560
561	info->p_dev = link;
562	link->priv = info;
563
564	link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
565		CONF_AUTO_SET_IO;
566
567	return btuart_config(link);
568}
569
570
571static void btuart_detach(struct pcmcia_device *link)
572{
573	btuart_release(link);
574}
575
576static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
577{
578	int *try = priv_data;
579
580	if (!try)
581		p_dev->io_lines = 16;
582
583	if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
584		return -EINVAL;
585
586	p_dev->resource[0]->end = 8;
587	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
588	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
589
590	return pcmcia_request_io(p_dev);
591}
592
593static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
594					void *priv_data)
595{
596	static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
597	int j;
598
599	if (p_dev->io_lines > 3)
600		return -ENODEV;
601
602	p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
603	p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
604	p_dev->resource[0]->end = 8;
605
606	for (j = 0; j < 5; j++) {
607		p_dev->resource[0]->start = base[j];
608		p_dev->io_lines = base[j] ? 16 : 3;
609		if (!pcmcia_request_io(p_dev))
610			return 0;
611	}
612	return -ENODEV;
613}
614
615static int btuart_config(struct pcmcia_device *link)
616{
617	struct btuart_info *info = link->priv;
618	int i;
619	int try;
620
621	/* First pass: look for a config entry that looks normal.
622	   Two tries: without IO aliases, then with aliases */
623	for (try = 0; try < 2; try++)
624		if (!pcmcia_loop_config(link, btuart_check_config, &try))
625			goto found_port;
626
627	/* Second pass: try to find an entry that isn't picky about
628	   its base address, then try to grab any standard serial port
629	   address, and finally try to get any free port. */
630	if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
631		goto found_port;
632
633	BT_ERR("No usable port range found");
634	goto failed;
635
636found_port:
637	i = pcmcia_request_irq(link, btuart_interrupt);
638	if (i != 0)
639		goto failed;
640
641	i = pcmcia_enable_device(link);
642	if (i != 0)
643		goto failed;
644
645	if (btuart_open(info) != 0)
646		goto failed;
647
648	return 0;
649
650failed:
651	btuart_release(link);
652	return -ENODEV;
653}
654
655
656static void btuart_release(struct pcmcia_device *link)
657{
658	struct btuart_info *info = link->priv;
659
660	btuart_close(info);
661
662	pcmcia_disable_device(link);
663}
664
665static const struct pcmcia_device_id btuart_ids[] = {
666	/* don't use this driver. Use serial_cs + hci_uart instead */
667	PCMCIA_DEVICE_NULL
668};
669MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
670
671static struct pcmcia_driver btuart_driver = {
672	.owner		= THIS_MODULE,
673	.name		= "btuart_cs",
674	.probe		= btuart_probe,
675	.remove		= btuart_detach,
676	.id_table	= btuart_ids,
677};
678module_pcmcia_driver(btuart_driver);
679