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
56 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
57 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
58 MODULE_LICENSE("GPL");
59
60
61
62 /* ======================== Local structures ======================== */
63
64
65 struct 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
81 static int btuart_config(struct pcmcia_device *link);
82 static void btuart_release(struct pcmcia_device *link);
83
84 static 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
btuart_write(unsigned int iobase,int fifo_size,__u8 * buf,int len)111 static 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
btuart_write_wakeup(struct btuart_info * info)130 static 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
btuart_receive(struct btuart_info * info)175 static 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_u8(info->rx_skb, 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
btuart_interrupt(int irq,void * dev_inst)287 static 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
btuart_change_speed(struct btuart_info * info,unsigned int speed)343 static 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
btuart_hci_flush(struct hci_dev * hdev)399 static 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
btuart_hci_open(struct hci_dev * hdev)410 static int btuart_hci_open(struct hci_dev *hdev)
411 {
412 return 0;
413 }
414
415
btuart_hci_close(struct hci_dev * hdev)416 static int btuart_hci_close(struct hci_dev *hdev)
417 {
418 btuart_hci_flush(hdev);
419
420 return 0;
421 }
422
423
btuart_hci_send_frame(struct hci_dev * hdev,struct sk_buff * skb)424 static 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
btuart_open(struct btuart_info * info)454 static 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
btuart_close(struct btuart_info * info)520 static 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
btuart_probe(struct pcmcia_device * link)547 static 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
btuart_detach(struct pcmcia_device * link)566 static void btuart_detach(struct pcmcia_device *link)
567 {
568 btuart_release(link);
569 }
570
btuart_check_config(struct pcmcia_device * p_dev,void * priv_data)571 static 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
btuart_check_config_notpicky(struct pcmcia_device * p_dev,void * priv_data)588 static 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
btuart_config(struct pcmcia_device * link)610 static 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 */
619 for (try = 0; try < 2; try++)
620 if (!pcmcia_loop_config(link, btuart_check_config, &try))
621 goto found_port;
622
623 /* Second pass: try to find an entry that isn't picky about
624 * its base address, then try to grab any standard serial port
625 * address, and finally try to get any free port.
626 */
627 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
628 goto found_port;
629
630 BT_ERR("No usable port range found");
631 goto failed;
632
633 found_port:
634 i = pcmcia_request_irq(link, btuart_interrupt);
635 if (i != 0)
636 goto failed;
637
638 i = pcmcia_enable_device(link);
639 if (i != 0)
640 goto failed;
641
642 if (btuart_open(info) != 0)
643 goto failed;
644
645 return 0;
646
647 failed:
648 btuart_release(link);
649 return -ENODEV;
650 }
651
652
btuart_release(struct pcmcia_device * link)653 static void btuart_release(struct pcmcia_device *link)
654 {
655 struct btuart_info *info = link->priv;
656
657 btuart_close(info);
658
659 pcmcia_disable_device(link);
660 }
661
662 static const struct pcmcia_device_id btuart_ids[] = {
663 /* don't use this driver. Use serial_cs + hci_uart instead */
664 PCMCIA_DEVICE_NULL
665 };
666 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
667
668 static struct pcmcia_driver btuart_driver = {
669 .owner = THIS_MODULE,
670 .name = "btuart_cs",
671 .probe = btuart_probe,
672 .remove = btuart_detach,
673 .id_table = btuart_ids,
674 };
675 module_pcmcia_driver(btuart_driver);
676