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/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
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
63
64
65struct btuart_info {
66 struct pcmcia_device *p_dev;
67
68 struct hci_dev *hdev;
69
70 spinlock_t lock;
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
88#define SPEED_MAX 115200
89
90
91#define DEFAULT_BAUD_RATE 115200
92
93
94
95#define XMIT_SENDING 1
96#define XMIT_WAKEUP 2
97#define XMIT_WAITING 8
98
99
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
109
110
111static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
112{
113 int actual = 0;
114
115
116 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
117 return 0;
118
119
120 while ((fifo_size-- > 0) && (actual < len)) {
121
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
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
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
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
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
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(struct btuart_info *info,
344 unsigned int speed)
345{
346 unsigned long flags;
347 unsigned int iobase;
348 int fcr;
349 int lcr;
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
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
370
371
372
373
374 if (speed < 38400)
375 fcr |= UART_FCR_TRIGGER_1;
376 else
377 fcr |= UART_FCR_TRIGGER_14;
378
379
380 lcr = UART_LCR_WLEN8;
381
382 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);
383 outb(divisor & 0xff, iobase + UART_DLL);
384 outb(divisor >> 8, iobase + UART_DLM);
385 outb(lcr, iobase + UART_LCR);
386 outb(fcr, iobase + UART_FCR);
387
388
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
397
398
399static int btuart_hci_flush(struct hci_dev *hdev)
400{
401 struct btuart_info *info = hci_get_drvdata(hdev);
402
403
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
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
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
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
494 outb(0, iobase + UART_MCR);
495
496
497 outb(0, iobase + UART_IER);
498
499
500 outb(UART_LCR_WLEN8, iobase + UART_LCR);
501 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
502
503
504
505
506 spin_unlock_irqrestore(&(info->lock), flags);
507
508 btuart_change_speed(info, DEFAULT_BAUD_RATE);
509
510
511 msleep(1000);
512
513
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
539 outb(0, iobase + UART_MCR);
540
541
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
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
622
623 for (try = 0; try < 2; try++)
624 if (!pcmcia_loop_config(link, btuart_check_config, &try))
625 goto found_port;
626
627
628
629
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
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