1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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/system.h>
42#include <asm/io.h>
43
44#include <pcmcia/cistpl.h>
45#include <pcmcia/ciscode.h>
46#include <pcmcia/ds.h>
47#include <pcmcia/cisreg.h>
48
49#include <net/bluetooth/bluetooth.h>
50#include <net/bluetooth/hci_core.h>
51
52
53
54
55
56
57MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
58MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
59MODULE_LICENSE("GPL");
60
61
62
63
64
65
66typedef struct btuart_info_t {
67 struct pcmcia_device *p_dev;
68
69 struct hci_dev *hdev;
70
71 spinlock_t lock;
72
73 struct sk_buff_head txq;
74 unsigned long tx_state;
75
76 unsigned long rx_state;
77 unsigned long rx_count;
78 struct sk_buff *rx_skb;
79} btuart_info_t;
80
81
82static int btuart_config(struct pcmcia_device *link);
83static void btuart_release(struct pcmcia_device *link);
84
85static void btuart_detach(struct pcmcia_device *p_dev);
86
87
88
89#define SPEED_MAX 115200
90
91
92#define DEFAULT_BAUD_RATE 115200
93
94
95
96#define XMIT_SENDING 1
97#define XMIT_WAKEUP 2
98#define XMIT_WAITING 8
99
100
101#define RECV_WAIT_PACKET_TYPE 0
102#define RECV_WAIT_EVENT_HEADER 1
103#define RECV_WAIT_ACL_HEADER 2
104#define RECV_WAIT_SCO_HEADER 3
105#define RECV_WAIT_DATA 4
106
107
108
109
110
111
112static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
113{
114 int actual = 0;
115
116
117 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
118 return 0;
119
120
121 while ((fifo_size-- > 0) && (actual < len)) {
122
123 outb(buf[actual], iobase + UART_TX);
124 actual++;
125 }
126
127 return actual;
128}
129
130
131static void btuart_write_wakeup(btuart_info_t *info)
132{
133 if (!info) {
134 BT_ERR("Unknown device");
135 return;
136 }
137
138 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
139 set_bit(XMIT_WAKEUP, &(info->tx_state));
140 return;
141 }
142
143 do {
144 register unsigned int iobase = info->p_dev->resource[0]->start;
145 register struct sk_buff *skb;
146 register int len;
147
148 clear_bit(XMIT_WAKEUP, &(info->tx_state));
149
150 if (!pcmcia_dev_present(info->p_dev))
151 return;
152
153 if (!(skb = skb_dequeue(&(info->txq))))
154 break;
155
156
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
191 if (info->rx_skb == NULL) {
192 info->rx_state = RECV_WAIT_PACKET_TYPE;
193 info->rx_count = 0;
194 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
195 BT_ERR("Can't allocate mem for new packet");
196 return;
197 }
198 }
199
200 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
201
202 info->rx_skb->dev = (void *) info->hdev;
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
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->rx_skb);
270 info->rx_skb = NULL;
271 break;
272
273 }
274
275 }
276
277 }
278
279
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
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
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
316 btuart_receive(info);
317 break;
318 case UART_IIR_THRI:
319 if (lsr & UART_LSR_THRE) {
320
321 btuart_write_wakeup(info);
322 }
323 break;
324 default:
325 BT_ERR("Unhandled IIR=%#x", iir);
326 break;
327 }
328
329
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;
348 int lcr;
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
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
369
370
371
372
373 if (speed < 38400)
374 fcr |= UART_FCR_TRIGGER_1;
375 else
376 fcr |= UART_FCR_TRIGGER_14;
377
378
379 lcr = UART_LCR_WLEN8;
380
381 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);
382 outb(divisor & 0xff, iobase + UART_DLL);
383 outb(divisor >> 8, iobase + UART_DLM);
384 outb(lcr, iobase + UART_LCR);
385 outb(fcr, iobase + UART_FCR);
386
387
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
396
397
398static int btuart_hci_flush(struct hci_dev *hdev)
399{
400 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
401
402
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 sk_buff *skb)
429{
430 btuart_info_t *info;
431 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
432
433 if (!hdev) {
434 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
435 return -ENODEV;
436 }
437
438 info = (btuart_info_t *)(hdev->driver_data);
439
440 switch (bt_cb(skb)->pkt_type) {
441 case HCI_COMMAND_PKT:
442 hdev->stat.cmd_tx++;
443 break;
444 case HCI_ACLDATA_PKT:
445 hdev->stat.acl_tx++;
446 break;
447 case HCI_SCODATA_PKT:
448 hdev->stat.sco_tx++;
449 break;
450 };
451
452
453 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
454 skb_queue_tail(&(info->txq), skb);
455
456 btuart_write_wakeup(info);
457
458 return 0;
459}
460
461
462static void btuart_hci_destruct(struct hci_dev *hdev)
463{
464}
465
466
467static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
468{
469 return -ENOIOCTLCMD;
470}
471
472
473
474
475
476
477static int btuart_open(btuart_info_t *info)
478{
479 unsigned long flags;
480 unsigned int iobase = info->p_dev->resource[0]->start;
481 struct hci_dev *hdev;
482
483 spin_lock_init(&(info->lock));
484
485 skb_queue_head_init(&(info->txq));
486
487 info->rx_state = RECV_WAIT_PACKET_TYPE;
488 info->rx_count = 0;
489 info->rx_skb = NULL;
490
491
492 hdev = hci_alloc_dev();
493 if (!hdev) {
494 BT_ERR("Can't allocate HCI device");
495 return -ENOMEM;
496 }
497
498 info->hdev = hdev;
499
500 hdev->bus = HCI_PCCARD;
501 hdev->driver_data = info;
502 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
503
504 hdev->open = btuart_hci_open;
505 hdev->close = btuart_hci_close;
506 hdev->flush = btuart_hci_flush;
507 hdev->send = btuart_hci_send_frame;
508 hdev->destruct = btuart_hci_destruct;
509 hdev->ioctl = btuart_hci_ioctl;
510
511 hdev->owner = THIS_MODULE;
512
513 spin_lock_irqsave(&(info->lock), flags);
514
515
516 outb(0, iobase + UART_MCR);
517
518
519 outb(0, iobase + UART_IER);
520
521
522 outb(UART_LCR_WLEN8, iobase + UART_LCR);
523 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
524
525
526
527
528 spin_unlock_irqrestore(&(info->lock), flags);
529
530 btuart_change_speed(info, DEFAULT_BAUD_RATE);
531
532
533 msleep(1000);
534
535
536 if (hci_register_dev(hdev) < 0) {
537 BT_ERR("Can't register HCI device");
538 info->hdev = NULL;
539 hci_free_dev(hdev);
540 return -ENODEV;
541 }
542
543 return 0;
544}
545
546
547static int btuart_close(btuart_info_t *info)
548{
549 unsigned long flags;
550 unsigned int iobase = info->p_dev->resource[0]->start;
551 struct hci_dev *hdev = info->hdev;
552
553 if (!hdev)
554 return -ENODEV;
555
556 btuart_hci_close(hdev);
557
558 spin_lock_irqsave(&(info->lock), flags);
559
560
561 outb(0, iobase + UART_MCR);
562
563
564 outb(0, iobase + UART_IER);
565
566 spin_unlock_irqrestore(&(info->lock), flags);
567
568 if (hci_unregister_dev(hdev) < 0)
569 BT_ERR("Can't unregister HCI device %s", hdev->name);
570
571 hci_free_dev(hdev);
572
573 return 0;
574}
575
576static int btuart_probe(struct pcmcia_device *link)
577{
578 btuart_info_t *info;
579
580
581 info = kzalloc(sizeof(*info), GFP_KERNEL);
582 if (!info)
583 return -ENOMEM;
584
585 info->p_dev = link;
586 link->priv = info;
587
588 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
589 CONF_AUTO_SET_IO;
590
591 return btuart_config(link);
592}
593
594
595static void btuart_detach(struct pcmcia_device *link)
596{
597 btuart_info_t *info = link->priv;
598
599 btuart_release(link);
600 kfree(info);
601}
602
603static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
604{
605 int *try = priv_data;
606
607 if (try == 0)
608 p_dev->io_lines = 16;
609
610 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
611 return -EINVAL;
612
613 p_dev->resource[0]->end = 8;
614 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
615 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
616
617 return pcmcia_request_io(p_dev);
618}
619
620static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
621 void *priv_data)
622{
623 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
624 int j;
625
626 if (p_dev->io_lines > 3)
627 return -ENODEV;
628
629 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
630 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
631 p_dev->resource[0]->end = 8;
632
633 for (j = 0; j < 5; j++) {
634 p_dev->resource[0]->start = base[j];
635 p_dev->io_lines = base[j] ? 16 : 3;
636 if (!pcmcia_request_io(p_dev))
637 return 0;
638 }
639 return -ENODEV;
640}
641
642static int btuart_config(struct pcmcia_device *link)
643{
644 btuart_info_t *info = link->priv;
645 int i;
646 int try;
647
648
649
650 for (try = 0; try < 2; try++)
651 if (!pcmcia_loop_config(link, btuart_check_config, &try))
652 goto found_port;
653
654
655
656
657 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
658 goto found_port;
659
660 BT_ERR("No usable port range found");
661 goto failed;
662
663found_port:
664 i = pcmcia_request_irq(link, btuart_interrupt);
665 if (i != 0)
666 goto failed;
667
668 i = pcmcia_enable_device(link);
669 if (i != 0)
670 goto failed;
671
672 if (btuart_open(info) != 0)
673 goto failed;
674
675 return 0;
676
677failed:
678 btuart_release(link);
679 return -ENODEV;
680}
681
682
683static void btuart_release(struct pcmcia_device *link)
684{
685 btuart_info_t *info = link->priv;
686
687 btuart_close(info);
688
689 pcmcia_disable_device(link);
690}
691
692static struct pcmcia_device_id btuart_ids[] = {
693
694 PCMCIA_DEVICE_NULL
695};
696MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
697
698static struct pcmcia_driver btuart_driver = {
699 .owner = THIS_MODULE,
700 .name = "btuart_cs",
701 .probe = btuart_probe,
702 .remove = btuart_detach,
703 .id_table = btuart_ids,
704};
705
706static int __init init_btuart_cs(void)
707{
708 return pcmcia_register_driver(&btuart_driver);
709}
710
711
712static void __exit exit_btuart_cs(void)
713{
714 pcmcia_unregister_driver(&btuart_driver);
715}
716
717module_init(init_btuart_cs);
718module_exit(exit_btuart_cs);
719
