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 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
227 kfree_skb(info->rx_skb);
228 info->rx_skb = NULL;
229 break;
230
231 }
232
233 } else {
234
235 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
236 info->rx_count--;
237
238 if (info->rx_count == 0) {
239
240 int dlen;
241 struct hci_event_hdr *eh;
242 struct hci_acl_hdr *ah;
243 struct hci_sco_hdr *sh;
244
245
246 switch (info->rx_state) {
247
248 case RECV_WAIT_EVENT_HEADER:
249 eh = hci_event_hdr(info->rx_skb);
250 info->rx_state = RECV_WAIT_DATA;
251 info->rx_count = eh->plen;
252 break;
253
254 case RECV_WAIT_ACL_HEADER:
255 ah = hci_acl_hdr(info->rx_skb);
256 dlen = __le16_to_cpu(ah->dlen);
257 info->rx_state = RECV_WAIT_DATA;
258 info->rx_count = dlen;
259 break;
260
261 case RECV_WAIT_SCO_HEADER:
262 sh = hci_sco_hdr(info->rx_skb);
263 info->rx_state = RECV_WAIT_DATA;
264 info->rx_count = sh->dlen;
265 break;
266
267 case RECV_WAIT_DATA:
268 hci_recv_frame(info->hdev, info->rx_skb);
269 info->rx_skb = NULL;
270 break;
271
272 }
273
274 }
275
276 }
277
278 /* Make sure we don't stay here too long */
279 if (boguscount++ > 16)
280 break;
281
282 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
283 }
284
285
btuart_interrupt(int irq,void * dev_inst)286 static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
287 {
288 struct btuart_info *info = dev_inst;
289 unsigned int iobase;
290 int boguscount = 0;
291 int iir, lsr;
292 irqreturn_t r = IRQ_NONE;
293
294 if (!info || !info->hdev)
295 /* our irq handler is shared */
296 return IRQ_NONE;
297
298 iobase = info->p_dev->resource[0]->start;
299
300 spin_lock(&(info->lock));
301
302 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
303 while (iir) {
304 r = IRQ_HANDLED;
305
306 /* Clear interrupt */
307 lsr = inb(iobase + UART_LSR);
308
309 switch (iir) {
310 case UART_IIR_RLSI:
311 BT_ERR("RLSI");
312 break;
313 case UART_IIR_RDI:
314 /* Receive interrupt */
315 btuart_receive(info);
316 break;
317 case UART_IIR_THRI:
318 if (lsr & UART_LSR_THRE) {
319 /* Transmitter ready for data */
320 btuart_write_wakeup(info);
321 }
322 break;
323 default:
324 BT_ERR("Unhandled IIR=%#x", iir);
325 break;
326 }
327
328 /* Make sure we don't stay here too long */
329 if (boguscount++ > 100)
330 break;
331
332 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
333
334 }
335
336 spin_unlock(&(info->lock));
337
338 return r;
339 }
340
341
btuart_change_speed(struct btuart_info * info,unsigned int speed)342 static void btuart_change_speed(struct btuart_info *info,
343 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
btuart_hci_flush(struct hci_dev * hdev)398 static int btuart_hci_flush(struct hci_dev *hdev)
399 {
400 struct btuart_info *info = hci_get_drvdata(hdev);
401
402 /* Drop TX queue */
403 skb_queue_purge(&(info->txq));
404
405 return 0;
406 }
407
408
btuart_hci_open(struct hci_dev * hdev)409 static int btuart_hci_open(struct hci_dev *hdev)
410 {
411 return 0;
412 }
413
414
btuart_hci_close(struct hci_dev * hdev)415 static int btuart_hci_close(struct hci_dev *hdev)
416 {
417 btuart_hci_flush(hdev);
418
419 return 0;
420 }
421
422
btuart_hci_send_frame(struct hci_dev * hdev,struct sk_buff * skb)423 static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
424 {
425 struct btuart_info *info = hci_get_drvdata(hdev);
426
427 switch (bt_cb(skb)->pkt_type) {
428 case HCI_COMMAND_PKT:
429 hdev->stat.cmd_tx++;
430 break;
431 case HCI_ACLDATA_PKT:
432 hdev->stat.acl_tx++;
433 break;
434 case HCI_SCODATA_PKT:
435 hdev->stat.sco_tx++;
436 break;
437 }
438
439 /* Prepend skb with frame type */
440 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
441 skb_queue_tail(&(info->txq), skb);
442
443 btuart_write_wakeup(info);
444
445 return 0;
446 }
447
448
449
450 /* ======================== Card services HCI interaction ======================== */
451
452
btuart_open(struct btuart_info * info)453 static int btuart_open(struct btuart_info *info)
454 {
455 unsigned long flags;
456 unsigned int iobase = info->p_dev->resource[0]->start;
457 struct hci_dev *hdev;
458
459 spin_lock_init(&(info->lock));
460
461 skb_queue_head_init(&(info->txq));
462
463 info->rx_state = RECV_WAIT_PACKET_TYPE;
464 info->rx_count = 0;
465 info->rx_skb = NULL;
466
467 /* Initialize HCI device */
468 hdev = hci_alloc_dev();
469 if (!hdev) {
470 BT_ERR("Can't allocate HCI device");
471 return -ENOMEM;
472 }
473
474 info->hdev = hdev;
475
476 hdev->bus = HCI_PCCARD;
477 hci_set_drvdata(hdev, info);
478 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
479
480 hdev->open = btuart_hci_open;
481 hdev->close = btuart_hci_close;
482 hdev->flush = btuart_hci_flush;
483 hdev->send = btuart_hci_send_frame;
484
485 spin_lock_irqsave(&(info->lock), flags);
486
487 /* Reset UART */
488 outb(0, iobase + UART_MCR);
489
490 /* Turn off interrupts */
491 outb(0, iobase + UART_IER);
492
493 /* Initialize UART */
494 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
495 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
496
497 /* Turn on interrupts */
498 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
499
500 spin_unlock_irqrestore(&(info->lock), flags);
501
502 btuart_change_speed(info, DEFAULT_BAUD_RATE);
503
504 /* Timeout before it is safe to send the first HCI packet */
505 msleep(1000);
506
507 /* Register HCI device */
508 if (hci_register_dev(hdev) < 0) {
509 BT_ERR("Can't register HCI device");
510 info->hdev = NULL;
511 hci_free_dev(hdev);
512 return -ENODEV;
513 }
514
515 return 0;
516 }
517
518
btuart_close(struct btuart_info * info)519 static int btuart_close(struct btuart_info *info)
520 {
521 unsigned long flags;
522 unsigned int iobase = info->p_dev->resource[0]->start;
523 struct hci_dev *hdev = info->hdev;
524
525 if (!hdev)
526 return -ENODEV;
527
528 btuart_hci_close(hdev);
529
530 spin_lock_irqsave(&(info->lock), flags);
531
532 /* Reset UART */
533 outb(0, iobase + UART_MCR);
534
535 /* Turn off interrupts */
536 outb(0, iobase + UART_IER);
537
538 spin_unlock_irqrestore(&(info->lock), flags);
539
540 hci_unregister_dev(hdev);
541 hci_free_dev(hdev);
542
543 return 0;
544 }
545
btuart_probe(struct pcmcia_device * link)546 static int btuart_probe(struct pcmcia_device *link)
547 {
548 struct btuart_info *info;
549
550 /* Create new info device */
551 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
552 if (!info)
553 return -ENOMEM;
554
555 info->p_dev = link;
556 link->priv = info;
557
558 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
559 CONF_AUTO_SET_IO;
560
561 return btuart_config(link);
562 }
563
564
btuart_detach(struct pcmcia_device * link)565 static void btuart_detach(struct pcmcia_device *link)
566 {
567 btuart_release(link);
568 }
569
btuart_check_config(struct pcmcia_device * p_dev,void * priv_data)570 static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
571 {
572 int *try = priv_data;
573
574 if (!try)
575 p_dev->io_lines = 16;
576
577 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
578 return -EINVAL;
579
580 p_dev->resource[0]->end = 8;
581 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
582 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
583
584 return pcmcia_request_io(p_dev);
585 }
586
btuart_check_config_notpicky(struct pcmcia_device * p_dev,void * priv_data)587 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
588 void *priv_data)
589 {
590 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
591 int j;
592
593 if (p_dev->io_lines > 3)
594 return -ENODEV;
595
596 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
597 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
598 p_dev->resource[0]->end = 8;
599
600 for (j = 0; j < 5; j++) {
601 p_dev->resource[0]->start = base[j];
602 p_dev->io_lines = base[j] ? 16 : 3;
603 if (!pcmcia_request_io(p_dev))
604 return 0;
605 }
606 return -ENODEV;
607 }
608
btuart_config(struct pcmcia_device * link)609 static int btuart_config(struct pcmcia_device *link)
610 {
611 struct btuart_info *info = link->priv;
612 int i;
613 int try;
614
615 /* First pass: look for a config entry that looks normal.
616 Two tries: without IO aliases, then with aliases */
617 for (try = 0; try < 2; try++)
618 if (!pcmcia_loop_config(link, btuart_check_config, &try))
619 goto found_port;
620
621 /* Second pass: try to find an entry that isn't picky about
622 its base address, then try to grab any standard serial port
623 address, and finally try to get any free port. */
624 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
625 goto found_port;
626
627 BT_ERR("No usable port range found");
628 goto failed;
629
630 found_port:
631 i = pcmcia_request_irq(link, btuart_interrupt);
632 if (i != 0)
633 goto failed;
634
635 i = pcmcia_enable_device(link);
636 if (i != 0)
637 goto failed;
638
639 if (btuart_open(info) != 0)
640 goto failed;
641
642 return 0;
643
644 failed:
645 btuart_release(link);
646 return -ENODEV;
647 }
648
649
btuart_release(struct pcmcia_device * link)650 static void btuart_release(struct pcmcia_device *link)
651 {
652 struct btuart_info *info = link->priv;
653
654 btuart_close(info);
655
656 pcmcia_disable_device(link);
657 }
658
659 static const struct pcmcia_device_id btuart_ids[] = {
660 /* don't use this driver. Use serial_cs + hci_uart instead */
661 PCMCIA_DEVICE_NULL
662 };
663 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
664
665 static struct pcmcia_driver btuart_driver = {
666 .owner = THIS_MODULE,
667 .name = "btuart_cs",
668 .probe = btuart_probe,
669 .remove = btuart_detach,
670 .id_table = btuart_ids,
671 };
672 module_pcmcia_driver(btuart_driver);
673