Loading...
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
65typedef struct btuart_info_t {
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} btuart_info_t;
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(btuart_info_t *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(btuart_info_t *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 btuart_info_t *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(btuart_info_t *info, unsigned int speed)
344{
345 unsigned long flags;
346 unsigned int iobase;
347 int fcr; /* FIFO control reg */
348 int lcr; /* Line control reg */
349 int divisor;
350
351 if (!info) {
352 BT_ERR("Unknown device");
353 return;
354 }
355
356 iobase = info->p_dev->resource[0]->start;
357
358 spin_lock_irqsave(&(info->lock), flags);
359
360 /* Turn off interrupts */
361 outb(0, iobase + UART_IER);
362
363 divisor = SPEED_MAX / speed;
364
365 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
366
367 /*
368 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
369 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
370 * about this timeout since it will always be fast enough.
371 */
372
373 if (speed < 38400)
374 fcr |= UART_FCR_TRIGGER_1;
375 else
376 fcr |= UART_FCR_TRIGGER_14;
377
378 /* Bluetooth cards use 8N1 */
379 lcr = UART_LCR_WLEN8;
380
381 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
382 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
383 outb(divisor >> 8, iobase + UART_DLM);
384 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
385 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
386
387 /* Turn on interrupts */
388 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
389
390 spin_unlock_irqrestore(&(info->lock), flags);
391}
392
393
394
395/* ======================== HCI interface ======================== */
396
397
398static int btuart_hci_flush(struct hci_dev *hdev)
399{
400 btuart_info_t *info = hci_get_drvdata(hdev);
401
402 /* Drop TX queue */
403 skb_queue_purge(&(info->txq));
404
405 return 0;
406}
407
408
409static int btuart_hci_open(struct hci_dev *hdev)
410{
411 set_bit(HCI_RUNNING, &(hdev->flags));
412
413 return 0;
414}
415
416
417static int btuart_hci_close(struct hci_dev *hdev)
418{
419 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
420 return 0;
421
422 btuart_hci_flush(hdev);
423
424 return 0;
425}
426
427
428static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
429{
430 btuart_info_t *info = hci_get_drvdata(hdev);
431
432 switch (bt_cb(skb)->pkt_type) {
433 case HCI_COMMAND_PKT:
434 hdev->stat.cmd_tx++;
435 break;
436 case HCI_ACLDATA_PKT:
437 hdev->stat.acl_tx++;
438 break;
439 case HCI_SCODATA_PKT:
440 hdev->stat.sco_tx++;
441 break;
442 }
443
444 /* Prepend skb with frame type */
445 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
446 skb_queue_tail(&(info->txq), skb);
447
448 btuart_write_wakeup(info);
449
450 return 0;
451}
452
453
454
455/* ======================== Card services HCI interaction ======================== */
456
457
458static int btuart_open(btuart_info_t *info)
459{
460 unsigned long flags;
461 unsigned int iobase = info->p_dev->resource[0]->start;
462 struct hci_dev *hdev;
463
464 spin_lock_init(&(info->lock));
465
466 skb_queue_head_init(&(info->txq));
467
468 info->rx_state = RECV_WAIT_PACKET_TYPE;
469 info->rx_count = 0;
470 info->rx_skb = NULL;
471
472 /* Initialize HCI device */
473 hdev = hci_alloc_dev();
474 if (!hdev) {
475 BT_ERR("Can't allocate HCI device");
476 return -ENOMEM;
477 }
478
479 info->hdev = hdev;
480
481 hdev->bus = HCI_PCCARD;
482 hci_set_drvdata(hdev, info);
483 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
484
485 hdev->open = btuart_hci_open;
486 hdev->close = btuart_hci_close;
487 hdev->flush = btuart_hci_flush;
488 hdev->send = btuart_hci_send_frame;
489
490 spin_lock_irqsave(&(info->lock), flags);
491
492 /* Reset UART */
493 outb(0, iobase + UART_MCR);
494
495 /* Turn off interrupts */
496 outb(0, iobase + UART_IER);
497
498 /* Initialize UART */
499 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
500 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
501
502 /* Turn on interrupts */
503 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
504
505 spin_unlock_irqrestore(&(info->lock), flags);
506
507 btuart_change_speed(info, DEFAULT_BAUD_RATE);
508
509 /* Timeout before it is safe to send the first HCI packet */
510 msleep(1000);
511
512 /* Register HCI device */
513 if (hci_register_dev(hdev) < 0) {
514 BT_ERR("Can't register HCI device");
515 info->hdev = NULL;
516 hci_free_dev(hdev);
517 return -ENODEV;
518 }
519
520 return 0;
521}
522
523
524static int btuart_close(btuart_info_t *info)
525{
526 unsigned long flags;
527 unsigned int iobase = info->p_dev->resource[0]->start;
528 struct hci_dev *hdev = info->hdev;
529
530 if (!hdev)
531 return -ENODEV;
532
533 btuart_hci_close(hdev);
534
535 spin_lock_irqsave(&(info->lock), flags);
536
537 /* Reset UART */
538 outb(0, iobase + UART_MCR);
539
540 /* Turn off interrupts */
541 outb(0, iobase + UART_IER);
542
543 spin_unlock_irqrestore(&(info->lock), flags);
544
545 hci_unregister_dev(hdev);
546 hci_free_dev(hdev);
547
548 return 0;
549}
550
551static int btuart_probe(struct pcmcia_device *link)
552{
553 btuart_info_t *info;
554
555 /* Create new info device */
556 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
557 if (!info)
558 return -ENOMEM;
559
560 info->p_dev = link;
561 link->priv = info;
562
563 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
564 CONF_AUTO_SET_IO;
565
566 return btuart_config(link);
567}
568
569
570static void btuart_detach(struct pcmcia_device *link)
571{
572 btuart_release(link);
573}
574
575static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
576{
577 int *try = priv_data;
578
579 if (!try)
580 p_dev->io_lines = 16;
581
582 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
583 return -EINVAL;
584
585 p_dev->resource[0]->end = 8;
586 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
587 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
588
589 return pcmcia_request_io(p_dev);
590}
591
592static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
593 void *priv_data)
594{
595 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
596 int j;
597
598 if (p_dev->io_lines > 3)
599 return -ENODEV;
600
601 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
602 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
603 p_dev->resource[0]->end = 8;
604
605 for (j = 0; j < 5; j++) {
606 p_dev->resource[0]->start = base[j];
607 p_dev->io_lines = base[j] ? 16 : 3;
608 if (!pcmcia_request_io(p_dev))
609 return 0;
610 }
611 return -ENODEV;
612}
613
614static int btuart_config(struct pcmcia_device *link)
615{
616 btuart_info_t *info = link->priv;
617 int i;
618 int try;
619
620 /* First pass: look for a config entry that looks normal.
621 Two tries: without IO aliases, then with aliases */
622 for (try = 0; try < 2; try++)
623 if (!pcmcia_loop_config(link, btuart_check_config, &try))
624 goto found_port;
625
626 /* Second pass: try to find an entry that isn't picky about
627 its base address, then try to grab any standard serial port
628 address, and finally try to get any free port. */
629 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
630 goto found_port;
631
632 BT_ERR("No usable port range found");
633 goto failed;
634
635found_port:
636 i = pcmcia_request_irq(link, btuart_interrupt);
637 if (i != 0)
638 goto failed;
639
640 i = pcmcia_enable_device(link);
641 if (i != 0)
642 goto failed;
643
644 if (btuart_open(info) != 0)
645 goto failed;
646
647 return 0;
648
649failed:
650 btuart_release(link);
651 return -ENODEV;
652}
653
654
655static void btuart_release(struct pcmcia_device *link)
656{
657 btuart_info_t *info = link->priv;
658
659 btuart_close(info);
660
661 pcmcia_disable_device(link);
662}
663
664static const struct pcmcia_device_id btuart_ids[] = {
665 /* don't use this driver. Use serial_cs + hci_uart instead */
666 PCMCIA_DEVICE_NULL
667};
668MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
669
670static struct pcmcia_driver btuart_driver = {
671 .owner = THIS_MODULE,
672 .name = "btuart_cs",
673 .probe = btuart_probe,
674 .remove = btuart_detach,
675 .id_table = btuart_ids,
676};
677module_pcmcia_driver(btuart_driver);
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 <linux/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) {
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 hci_skb_pkt_type(info->rx_skb) = inb(iobase + UART_RX);
204
205 switch (hci_skb_pkt_type(info->rx_skb)) {
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",
225 hci_skb_pkt_type(info->rx_skb));
226 info->hdev->stat.err_rx++;
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 return 0;
413}
414
415
416static int btuart_hci_close(struct hci_dev *hdev)
417{
418 btuart_hci_flush(hdev);
419
420 return 0;
421}
422
423
424static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
425{
426 struct btuart_info *info = hci_get_drvdata(hdev);
427
428 switch (hci_skb_pkt_type(skb)) {
429 case HCI_COMMAND_PKT:
430 hdev->stat.cmd_tx++;
431 break;
432 case HCI_ACLDATA_PKT:
433 hdev->stat.acl_tx++;
434 break;
435 case HCI_SCODATA_PKT:
436 hdev->stat.sco_tx++;
437 break;
438 }
439
440 /* Prepend skb with frame type */
441 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
442 skb_queue_tail(&(info->txq), skb);
443
444 btuart_write_wakeup(info);
445
446 return 0;
447}
448
449
450
451/* ======================== Card services HCI interaction ======================== */
452
453
454static int btuart_open(struct btuart_info *info)
455{
456 unsigned long flags;
457 unsigned int iobase = info->p_dev->resource[0]->start;
458 struct hci_dev *hdev;
459
460 spin_lock_init(&(info->lock));
461
462 skb_queue_head_init(&(info->txq));
463
464 info->rx_state = RECV_WAIT_PACKET_TYPE;
465 info->rx_count = 0;
466 info->rx_skb = NULL;
467
468 /* Initialize HCI device */
469 hdev = hci_alloc_dev();
470 if (!hdev) {
471 BT_ERR("Can't allocate HCI device");
472 return -ENOMEM;
473 }
474
475 info->hdev = hdev;
476
477 hdev->bus = HCI_PCCARD;
478 hci_set_drvdata(hdev, info);
479 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
480
481 hdev->open = btuart_hci_open;
482 hdev->close = btuart_hci_close;
483 hdev->flush = btuart_hci_flush;
484 hdev->send = btuart_hci_send_frame;
485
486 spin_lock_irqsave(&(info->lock), flags);
487
488 /* Reset UART */
489 outb(0, iobase + UART_MCR);
490
491 /* Turn off interrupts */
492 outb(0, iobase + UART_IER);
493
494 /* Initialize UART */
495 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
496 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
497
498 /* Turn on interrupts */
499 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
500
501 spin_unlock_irqrestore(&(info->lock), flags);
502
503 btuart_change_speed(info, DEFAULT_BAUD_RATE);
504
505 /* Timeout before it is safe to send the first HCI packet */
506 msleep(1000);
507
508 /* Register HCI device */
509 if (hci_register_dev(hdev) < 0) {
510 BT_ERR("Can't register HCI device");
511 info->hdev = NULL;
512 hci_free_dev(hdev);
513 return -ENODEV;
514 }
515
516 return 0;
517}
518
519
520static int btuart_close(struct btuart_info *info)
521{
522 unsigned long flags;
523 unsigned int iobase = info->p_dev->resource[0]->start;
524 struct hci_dev *hdev = info->hdev;
525
526 if (!hdev)
527 return -ENODEV;
528
529 btuart_hci_close(hdev);
530
531 spin_lock_irqsave(&(info->lock), flags);
532
533 /* Reset UART */
534 outb(0, iobase + UART_MCR);
535
536 /* Turn off interrupts */
537 outb(0, iobase + UART_IER);
538
539 spin_unlock_irqrestore(&(info->lock), flags);
540
541 hci_unregister_dev(hdev);
542 hci_free_dev(hdev);
543
544 return 0;
545}
546
547static int btuart_probe(struct pcmcia_device *link)
548{
549 struct btuart_info *info;
550
551 /* Create new info device */
552 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
553 if (!info)
554 return -ENOMEM;
555
556 info->p_dev = link;
557 link->priv = info;
558
559 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
560 CONF_AUTO_SET_IO;
561
562 return btuart_config(link);
563}
564
565
566static void btuart_detach(struct pcmcia_device *link)
567{
568 btuart_release(link);
569}
570
571static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
572{
573 int *try = priv_data;
574
575 if (!try)
576 p_dev->io_lines = 16;
577
578 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
579 return -EINVAL;
580
581 p_dev->resource[0]->end = 8;
582 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
583 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
584
585 return pcmcia_request_io(p_dev);
586}
587
588static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
589 void *priv_data)
590{
591 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
592 int j;
593
594 if (p_dev->io_lines > 3)
595 return -ENODEV;
596
597 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
598 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
599 p_dev->resource[0]->end = 8;
600
601 for (j = 0; j < 5; j++) {
602 p_dev->resource[0]->start = base[j];
603 p_dev->io_lines = base[j] ? 16 : 3;
604 if (!pcmcia_request_io(p_dev))
605 return 0;
606 }
607 return -ENODEV;
608}
609
610static int btuart_config(struct pcmcia_device *link)
611{
612 struct btuart_info *info = link->priv;
613 int i;
614 int try;
615
616 /* First pass: look for a config entry that looks normal.
617 Two tries: without IO aliases, then with aliases */
618 for (try = 0; try < 2; try++)
619 if (!pcmcia_loop_config(link, btuart_check_config, &try))
620 goto found_port;
621
622 /* Second pass: try to find an entry that isn't picky about
623 its base address, then try to grab any standard serial port
624 address, and finally try to get any free port. */
625 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
626 goto found_port;
627
628 BT_ERR("No usable port range found");
629 goto failed;
630
631found_port:
632 i = pcmcia_request_irq(link, btuart_interrupt);
633 if (i != 0)
634 goto failed;
635
636 i = pcmcia_enable_device(link);
637 if (i != 0)
638 goto failed;
639
640 if (btuart_open(info) != 0)
641 goto failed;
642
643 return 0;
644
645failed:
646 btuart_release(link);
647 return -ENODEV;
648}
649
650
651static void btuart_release(struct pcmcia_device *link)
652{
653 struct btuart_info *info = link->priv;
654
655 btuart_close(info);
656
657 pcmcia_disable_device(link);
658}
659
660static const struct pcmcia_device_id btuart_ids[] = {
661 /* don't use this driver. Use serial_cs + hci_uart instead */
662 PCMCIA_DEVICE_NULL
663};
664MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
665
666static struct pcmcia_driver btuart_driver = {
667 .owner = THIS_MODULE,
668 .name = "btuart_cs",
669 .probe = btuart_probe,
670 .remove = btuart_detach,
671 .id_table = btuart_ids,
672};
673module_pcmcia_driver(btuart_driver);