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/config.h>
24 #include <linux/module.h>
25
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/delay.h>
32 #include <linux/errno.h>
33 #include <linux/ptrace.h>
34 #include <linux/ioport.h>
35 #include <linux/spinlock.h>
36 #include <linux/moduleparam.h>
37
38 #include <linux/skbuff.h>
39 #include <linux/string.h>
40 #include <linux/serial.h>
41 #include <linux/serial_reg.h>
42 #include <linux/bitops.h>
43 #include <asm/system.h>
44 #include <asm/io.h>
45
46 #include <pcmcia/cs_types.h>
47 #include <pcmcia/cs.h>
48 #include <pcmcia/cistpl.h>
49 #include <pcmcia/ciscode.h>
50 #include <pcmcia/ds.h>
51 #include <pcmcia/cisreg.h>
52
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/hci_core.h>
55
56
57
58 /* ======================== Module parameters ======================== */
59
60
61 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
62 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
63 MODULE_LICENSE("GPL");
64
65
66
67 /* ======================== Local structures ======================== */
68
69
70 typedef struct btuart_info_t {
71 struct pcmcia_device *p_dev;
72 dev_node_t node;
73
74 struct hci_dev *hdev;
75
76 spinlock_t lock; /* For serializing operations */
77
78 struct sk_buff_head txq;
79 unsigned long tx_state;
80
81 unsigned long rx_state;
82 unsigned long rx_count;
83 struct sk_buff *rx_skb;
84 } btuart_info_t;
85
86
87 static int btuart_config(struct pcmcia_device *link);
88 static void btuart_release(struct pcmcia_device *link);
89
90 static void btuart_detach(struct pcmcia_device *p_dev);
91
92
93 /* Maximum baud rate */
94 #define SPEED_MAX 115200
95
96 /* Default baud rate: 57600, 115200, 230400 or 460800 */
97 #define DEFAULT_BAUD_RATE 115200
98
99
100 /* Transmit states */
101 #define XMIT_SENDING 1
102 #define XMIT_WAKEUP 2
103 #define XMIT_WAITING 8
104
105 /* Receiver states */
106 #define RECV_WAIT_PACKET_TYPE 0
107 #define RECV_WAIT_EVENT_HEADER 1
108 #define RECV_WAIT_ACL_HEADER 2
109 #define RECV_WAIT_SCO_HEADER 3
110 #define RECV_WAIT_DATA 4
111
112
113
114 /* ======================== Interrupt handling ======================== */
115
116
117 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
118 {
119 int actual = 0;
120
121 /* Tx FIFO should be empty */
122 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
123 return 0;
124
125 /* Fill FIFO with current frame */
126 while ((fifo_size-- > 0) && (actual < len)) {
127 /* Transmit next byte */
128 outb(buf[actual], iobase + UART_TX);
129 actual++;
130 }
131
132 return actual;
133 }
134
135
136 static void btuart_write_wakeup(btuart_info_t *info)
137 {
138 if (!info) {
139 BT_ERR("Unknown device");
140 return;
141 }
142
143 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
144 set_bit(XMIT_WAKEUP, &(info->tx_state));
145 return;
146 }
147
148 do {
149 register unsigned int iobase = info->p_dev->io.BasePort1;
150 register struct sk_buff *skb;
151 register int len;
152
153 clear_bit(XMIT_WAKEUP, &(info->tx_state));
154
155 if (!pcmcia_dev_present(info->p_dev))
156 return;
157
158 if (!(skb = skb_dequeue(&(info->txq))))
159 break;
160
161 /* Send frame */
162 len = btuart_write(iobase, 16, skb->data, skb->len);
163 set_bit(XMIT_WAKEUP, &(info->tx_state));
164
165 if (len == skb->len) {
166 kfree_skb(skb);
167 } else {
168 skb_pull(skb, len);
169 skb_queue_head(&(info->txq), skb);
170 }
171
172 info->hdev->stat.byte_tx += len;
173
174 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
175
176 clear_bit(XMIT_SENDING, &(info->tx_state));
177 }
178
179
180 static void btuart_receive(btuart_info_t *info)
181 {
182 unsigned int iobase;
183 int boguscount = 0;
184
185 if (!info) {
186 BT_ERR("Unknown device");
187 return;
188 }
189
190 iobase = info->p_dev->io.BasePort1;
191
192 do {
193 info->hdev->stat.byte_rx++;
194
195 /* Allocate packet */
196 if (info->rx_skb == NULL) {
197 info->rx_state = RECV_WAIT_PACKET_TYPE;
198 info->rx_count = 0;
199 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
200 BT_ERR("Can't allocate mem for new packet");
201 return;
202 }
203 }
204
205 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
206
207 info->rx_skb->dev = (void *) info->hdev;
208 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
209
210 switch (bt_cb(info->rx_skb)->pkt_type) {
211
212 case HCI_EVENT_PKT:
213 info->rx_state = RECV_WAIT_EVENT_HEADER;
214 info->rx_count = HCI_EVENT_HDR_SIZE;
215 break;
216
217 case HCI_ACLDATA_PKT:
218 info->rx_state = RECV_WAIT_ACL_HEADER;
219 info->rx_count = HCI_ACL_HDR_SIZE;
220 break;
221
222 case HCI_SCODATA_PKT:
223 info->rx_state = RECV_WAIT_SCO_HEADER;
224 info->rx_count = HCI_SCO_HDR_SIZE;
225 break;
226
227 default:
228 /* Unknown packet */
229 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
230 info->hdev->stat.err_rx++;
231 clear_bit(HCI_RUNNING, &(info->hdev->flags));
232
233 kfree_skb(info->rx_skb);
234 info->rx_skb = NULL;
235 break;
236
237 }
238
239 } else {
240
241 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
242 info->rx_count--;
243
244 if (info->rx_count == 0) {
245
246 int dlen;
247 struct hci_event_hdr *eh;
248 struct hci_acl_hdr *ah;
249 struct hci_sco_hdr *sh;
250
251
252 switch (info->rx_state) {
253
254 case RECV_WAIT_EVENT_HEADER:
255 eh = (struct hci_event_hdr *)(info->rx_skb->data);
256 info->rx_state = RECV_WAIT_DATA;
257 info->rx_count = eh->plen;
258 break;
259
260 case RECV_WAIT_ACL_HEADER:
261 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
262 dlen = __le16_to_cpu(ah->dlen);
263 info->rx_state = RECV_WAIT_DATA;
264 info->rx_count = dlen;
265 break;
266
267 case RECV_WAIT_SCO_HEADER:
268 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
269 info->rx_state = RECV_WAIT_DATA;
270 info->rx_count = sh->dlen;
271 break;
272
273 case RECV_WAIT_DATA:
274 hci_recv_frame(info->rx_skb);
275 info->rx_skb = NULL;
276 break;
277
278 }
279
280 }
281
282 }
283
284 /* Make sure we don't stay here too long */
285 if (boguscount++ > 16)
286 break;
287
288 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
289 }
290
291
292 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
293 {
294 btuart_info_t *info = dev_inst;
295 unsigned int iobase;
296 int boguscount = 0;
297 int iir, lsr;
298
299 if (!info || !info->hdev) {
300 BT_ERR("Call of irq %d for unknown device", irq);
301 return IRQ_NONE;
302 }
303
304 iobase = info->p_dev->io.BasePort1;
305
306 spin_lock(&(info->lock));
307
308 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
309 while (iir) {
310
311 /* Clear interrupt */
312 lsr = inb(iobase + UART_LSR);
313
314 switch (iir) {
315 case UART_IIR_RLSI:
316 BT_ERR("RLSI");
317 break;
318 case UART_IIR_RDI:
319 /* Receive interrupt */
320 btuart_receive(info);
321 break;
322 case UART_IIR_THRI:
323 if (lsr & UART_LSR_THRE) {
324 /* Transmitter ready for data */
325 btuart_write_wakeup(info);
326 }
327 break;
328 default:
329 BT_ERR("Unhandled IIR=%#x", iir);
330 break;
331 }
332
333 /* Make sure we don't stay here too long */
334 if (boguscount++ > 100)
335 break;
336
337 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
338
339 }
340
341 spin_unlock(&(info->lock));
342
343 return IRQ_HANDLED;
344 }
345
346
347 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
348 {
349 unsigned long flags;
350 unsigned int iobase;
351 int fcr; /* FIFO control reg */
352 int lcr; /* Line control reg */
353 int divisor;
354
355 if (!info) {
356 BT_ERR("Unknown device");
357 return;
358 }
359
360 iobase = info->p_dev->io.BasePort1;
361
362 spin_lock_irqsave(&(info->lock), flags);
363
364 /* Turn off interrupts */
365 outb(0, iobase + UART_IER);
366
367 divisor = SPEED_MAX / speed;
368
369 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
370
371 /*
372 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
373 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
374 * about this timeout since it will always be fast enough.
375 */
376
377 if (speed < 38400)
378 fcr |= UART_FCR_TRIGGER_1;
379 else
380 fcr |= UART_FCR_TRIGGER_14;
381
382 /* Bluetooth cards use 8N1 */
383 lcr = UART_LCR_WLEN8;
384
385 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
386 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
387 outb(divisor >> 8, iobase + UART_DLM);
388 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
389 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
390
391 /* Turn on interrups */
392 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
393
394 spin_unlock_irqrestore(&(info->lock), flags);
395 }
396
397
398
399 /* ======================== HCI interface ======================== */
400
401
402 static int btuart_hci_flush(struct hci_dev *hdev)
403 {
404 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
405
406 /* Drop TX queue */
407 skb_queue_purge(&(info->txq));
408
409 return 0;
410 }
411
412
413 static int btuart_hci_open(struct hci_dev *hdev)
414 {
415 set_bit(HCI_RUNNING, &(hdev->flags));
416
417 return 0;
418 }
419
420
421 static int btuart_hci_close(struct hci_dev *hdev)
422 {
423 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
424 return 0;
425
426 btuart_hci_flush(hdev);
427
428 return 0;
429 }
430
431
432 static int btuart_hci_send_frame(struct sk_buff *skb)
433 {
434 btuart_info_t *info;
435 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
436
437 if (!hdev) {
438 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
439 return -ENODEV;
440 }
441
442 info = (btuart_info_t *)(hdev->driver_data);
443
444 switch (bt_cb(skb)->pkt_type) {
445 case HCI_COMMAND_PKT:
446 hdev->stat.cmd_tx++;
447 break;
448 case HCI_ACLDATA_PKT:
449 hdev->stat.acl_tx++;
450 break;
451 case HCI_SCODATA_PKT:
452 hdev->stat.sco_tx++;
453 break;
454 };
455
456 /* Prepend skb with frame type */
457 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
458 skb_queue_tail(&(info->txq), skb);
459
460 btuart_write_wakeup(info);
461
462 return 0;
463 }
464
465
466 static void btuart_hci_destruct(struct hci_dev *hdev)
467 {
468 }
469
470
471 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
472 {
473 return -ENOIOCTLCMD;
474 }
475
476
477
478 /* ======================== Card services HCI interaction ======================== */
479
480
481 static int btuart_open(btuart_info_t *info)
482 {
483 unsigned long flags;
484 unsigned int iobase = info->p_dev->io.BasePort1;
485 struct hci_dev *hdev;
486
487 spin_lock_init(&(info->lock));
488
489 skb_queue_head_init(&(info->txq));
490
491 info->rx_state = RECV_WAIT_PACKET_TYPE;
492 info->rx_count = 0;
493 info->rx_skb = NULL;
494
495 /* Initialize HCI device */
496 hdev = hci_alloc_dev();
497 if (!hdev) {
498 BT_ERR("Can't allocate HCI device");
499 return -ENOMEM;
500 }
501
502 info->hdev = hdev;
503
504 hdev->type = HCI_PCCARD;
505 hdev->driver_data = info;
506
507 hdev->open = btuart_hci_open;
508 hdev->close = btuart_hci_close;
509 hdev->flush = btuart_hci_flush;
510 hdev->send = btuart_hci_send_frame;
511 hdev->destruct = btuart_hci_destruct;
512 hdev->ioctl = btuart_hci_ioctl;
513
514 hdev->owner = THIS_MODULE;
515
516 spin_lock_irqsave(&(info->lock), flags);
517
518 /* Reset UART */
519 outb(0, iobase + UART_MCR);
520
521 /* Turn off interrupts */
522 outb(0, iobase + UART_IER);
523
524 /* Initialize UART */
525 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
526 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
527
528 /* Turn on interrupts */
529 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
530
531 spin_unlock_irqrestore(&(info->lock), flags);
532
533 btuart_change_speed(info, DEFAULT_BAUD_RATE);
534
535 /* Timeout before it is safe to send the first HCI packet */
536 msleep(1000);
537
538 /* Register HCI device */
539 if (hci_register_dev(hdev) < 0) {
540 BT_ERR("Can't register HCI device");
541 info->hdev = NULL;
542 hci_free_dev(hdev);
543 return -ENODEV;
544 }
545
546 return 0;
547 }
548
549
550 static int btuart_close(btuart_info_t *info)
551 {
552 unsigned long flags;
553 unsigned int iobase = info->p_dev->io.BasePort1;
554 struct hci_dev *hdev = info->hdev;
555
556 if (!hdev)
557 return -ENODEV;
558
559 btuart_hci_close(hdev);
560
561 spin_lock_irqsave(&(info->lock), flags);
562
563 /* Reset UART */
564 outb(0, iobase + UART_MCR);
565
566 /* Turn off interrupts */
567 outb(0, iobase + UART_IER);
568
569 spin_unlock_irqrestore(&(info->lock), flags);
570
571 if (hci_unregister_dev(hdev) < 0)
572 BT_ERR("Can't unregister HCI device %s", hdev->name);
573
574 hci_free_dev(hdev);
575
576 return 0;
577 }
578
579 static int btuart_probe(struct pcmcia_device *link)
580 {
581 btuart_info_t *info;
582
583 /* Create new info device */
584 info = kzalloc(sizeof(*info), GFP_KERNEL);
585 if (!info)
586 return -ENOMEM;
587
588 info->p_dev = link;
589 link->priv = info;
590
591 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
592 link->io.NumPorts1 = 8;
593 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
594 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
595
596 link->irq.Handler = btuart_interrupt;
597 link->irq.Instance = info;
598
599 link->conf.Attributes = CONF_ENABLE_IRQ;
600 link->conf.IntType = INT_MEMORY_AND_IO;
601
602 return btuart_config(link);
603 }
604
605
606 static void btuart_detach(struct pcmcia_device *link)
607 {
608 btuart_info_t *info = link->priv;
609
610 btuart_release(link);
611 kfree(info);
612 }
613
614 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
615 {
616 int i;
617
618 i = pcmcia_get_tuple_data(handle, tuple);
619 if (i != CS_SUCCESS)
620 return i;
621
622 return pcmcia_parse_tuple(handle, tuple, parse);
623 }
624
625 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
626 {
627 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
628 return CS_NO_MORE_ITEMS;
629 return get_tuple(handle, tuple, parse);
630 }
631
632 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
633 {
634 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
635 return CS_NO_MORE_ITEMS;
636 return get_tuple(handle, tuple, parse);
637 }
638
639 static int btuart_config(struct pcmcia_device *link)
640 {
641 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
642 btuart_info_t *info = link->priv;
643 tuple_t tuple;
644 u_short buf[256];
645 cisparse_t parse;
646 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
647 int i, j, try, last_ret, last_fn;
648
649 tuple.TupleData = (cisdata_t *)buf;
650 tuple.TupleOffset = 0;
651 tuple.TupleDataMax = 255;
652 tuple.Attributes = 0;
653
654 /* Get configuration register information */
655 tuple.DesiredTuple = CISTPL_CONFIG;
656 last_ret = first_tuple(link, &tuple, &parse);
657 if (last_ret != CS_SUCCESS) {
658 last_fn = ParseTuple;
659 goto cs_failed;
660 }
661 link->conf.ConfigBase = parse.config.base;
662 link->conf.Present = parse.config.rmask[0];
663
664 /* First pass: look for a config entry that looks normal. */
665 tuple.TupleData = (cisdata_t *) buf;
666 tuple.TupleOffset = 0;
667 tuple.TupleDataMax = 255;
668 tuple.Attributes = 0;
669 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
670 /* Two tries: without IO aliases, then with aliases */
671 for (try = 0; try < 2; try++) {
672 i = first_tuple(link, &tuple, &parse);
673 while (i != CS_NO_MORE_ITEMS) {
674 if (i != CS_SUCCESS)
675 goto next_entry;
676 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
677 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
678 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
679 link->conf.ConfigIndex = cf->index;
680 link->io.BasePort1 = cf->io.win[0].base;
681 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
682 i = pcmcia_request_io(link, &link->io);
683 if (i == CS_SUCCESS)
684 goto found_port;
685 }
686 next_entry:
687 i = next_tuple(link, &tuple, &parse);
688 }
689 }
690
691 /* Second pass: try to find an entry that isn't picky about
692 its base address, then try to grab any standard serial port
693 address, and finally try to get any free port. */
694 i = first_tuple(link, &tuple, &parse);
695 while (i != CS_NO_MORE_ITEMS) {
696 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
697 && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
698 link->conf.ConfigIndex = cf->index;
699 for (j = 0; j < 5; j++) {
700 link->io.BasePort1 = base[j];
701 link->io.IOAddrLines = base[j] ? 16 : 3;
702 i = pcmcia_request_io(link, &link->io);
703 if (i == CS_SUCCESS)
704 goto found_port;
705 }
706 }
707 i = next_tuple(link, &tuple, &parse);
708 }
709
710 found_port:
711 if (i != CS_SUCCESS) {
712 BT_ERR("No usable port range found");
713 cs_error(link, RequestIO, i);
714 goto failed;
715 }
716
717 i = pcmcia_request_irq(link, &link->irq);
718 if (i != CS_SUCCESS) {
719 cs_error(link, RequestIRQ, i);
720 link->irq.AssignedIRQ = 0;
721 }
722
723 i = pcmcia_request_configuration(link, &link->conf);
724 if (i != CS_SUCCESS) {
725 cs_error(link, RequestConfiguration, i);
726 goto failed;
727 }
728
729 if (btuart_open(info) != 0)
730 goto failed;
731
732 strcpy(info->node.dev_name, info->hdev->name);
733 link->dev_node = &info->node;
734
735 return 0;
736
737 cs_failed:
738 cs_error(link, last_fn, last_ret);
739
740 failed:
741 btuart_release(link);
742 return -ENODEV;
743 }
744
745
746 static void btuart_release(struct pcmcia_device *link)
747 {
748 btuart_info_t *info = link->priv;
749
750 btuart_close(info);
751
752 pcmcia_disable_device(link);
753 }
754
755 static struct pcmcia_device_id btuart_ids[] = {
756 /* don't use this driver. Use serial_cs + hci_uart instead */
757 PCMCIA_DEVICE_NULL
758 };
759 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
760
761 static struct pcmcia_driver btuart_driver = {
762 .owner = THIS_MODULE,
763 .drv = {
764 .name = "btuart_cs",
765 },
766 .probe = btuart_probe,
767 .remove = btuart_detach,
768 .id_table = btuart_ids,
769 };
770
771 static int __init init_btuart_cs(void)
772 {
773 return pcmcia_register_driver(&btuart_driver);
774 }
775
776
777 static void __exit exit_btuart_cs(void)
778 {
779 pcmcia_unregister_driver(&btuart_driver);
780 }
781
782 module_init(init_btuart_cs);
783 module_exit(exit_btuart_cs);
784
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.