drivers/bluetooth/btuart_cs.c

   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 <asm/system.h>
  42 #include <asm/io.h>
  43
  44 #include <pcmcia/cs_types.h>
  45 #include <pcmcia/cs.h>
  46 #include <pcmcia/cistpl.h>
  47 #include <pcmcia/ciscode.h>
  48 #include <pcmcia/ds.h>
  49 #include <pcmcia/cisreg.h>
  50
  51 #include <net/bluetooth/bluetooth.h>
  52 #include <net/bluetooth/hci_core.h>
  53
  54
  55
  56 /* ======================== Module parameters ======================== */
  57
  58
  59 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  60 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
  61 MODULE_LICENSE("GPL");
  62
  63
  64
  65 /* ======================== Local structures ======================== */
  66
  67
  68 typedef struct btuart_info_t {
  69         struct pcmcia_device *p_dev;
  70         dev_node_t node;
  71
  72         struct hci_dev *hdev;
  73
  74         spinlock_t lock;        /* For serializing operations */
  75
  76         struct sk_buff_head txq;
  77         unsigned long tx_state;
  78
  79         unsigned long rx_state;
  80         unsigned long rx_count;
  81         struct sk_buff *rx_skb;
  82 } btuart_info_t;
  83
  84
  85 static int btuart_config(struct pcmcia_device *link);
  86 static void btuart_release(struct pcmcia_device *link);
  87
  88 static void btuart_detach(struct pcmcia_device *p_dev);
  89
  90
  91 /* Maximum baud rate */
  92 #define SPEED_MAX  115200
  93
  94 /* Default baud rate: 57600, 115200, 230400 or 460800 */
  95 #define DEFAULT_BAUD_RATE  115200
  96
  97
  98 /* Transmit states  */
  99 #define XMIT_SENDING    1
 100 #define XMIT_WAKEUP     2
 101 #define XMIT_WAITING    8
 102
 103 /* Receiver states */
 104 #define RECV_WAIT_PACKET_TYPE   0
 105 #define RECV_WAIT_EVENT_HEADER  1
 106 #define RECV_WAIT_ACL_HEADER    2
 107 #define RECV_WAIT_SCO_HEADER    3
 108 #define RECV_WAIT_DATA          4
 109
 110
 111
 112 /* ======================== Interrupt handling ======================== */
 113
 114
 115 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 116 {
 117         int actual = 0;
 118
 119         /* Tx FIFO should be empty */
 120         if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
 121                 return 0;
 122
 123         /* Fill FIFO with current frame */
 124         while ((fifo_size-- > 0) && (actual < len)) {
 125                 /* Transmit next byte */
 126                 outb(buf[actual], iobase + UART_TX);
 127                 actual++;
 128         }
 129
 130         return actual;
 131 }
 132
 133
 134 static void btuart_write_wakeup(btuart_info_t *info)
 135 {
 136         if (!info) {
 137                 BT_ERR("Unknown device");
 138                 return;
 139         }
 140
 141         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 142                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 143                 return;
 144         }
 145
 146         do {
 147                 register unsigned int iobase = info->p_dev->io.BasePort1;
 148                 register struct sk_buff *skb;
 149                 register int len;
 150
 151                 clear_bit(XMIT_WAKEUP, &(info->tx_state));
 152
 153                 if (!pcmcia_dev_present(info->p_dev))
 154                         return;
 155
 156                 if (!(skb = skb_dequeue(&(info->txq))))
 157                         break;
 158
 159                 /* Send frame */
 160                 len = btuart_write(iobase, 16, skb->data, skb->len);
 161                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 162
 163                 if (len == skb->len) {
 164                         kfree_skb(skb);
 165                 } else {
 166                         skb_pull(skb, len);
 167                         skb_queue_head(&(info->txq), skb);
 168                 }
 169
 170                 info->hdev->stat.byte_tx += len;
 171
 172         } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 173
 174         clear_bit(XMIT_SENDING, &(info->tx_state));
 175 }
 176
 177
 178 static void btuart_receive(btuart_info_t *info)
 179 {
 180         unsigned int iobase;
 181         int boguscount = 0;
 182
 183         if (!info) {
 184                 BT_ERR("Unknown device");
 185                 return;
 186         }
 187
 188         iobase = info->p_dev->io.BasePort1;
 189
 190         do {
 191                 info->hdev->stat.byte_rx++;
 192
 193                 /* Allocate packet */
 194                 if (info->rx_skb == NULL) {
 195                         info->rx_state = RECV_WAIT_PACKET_TYPE;
 196                         info->rx_count = 0;
 197                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 198                                 BT_ERR("Can't allocate mem for new packet");
 199                                 return;
 200                         }
 201                 }
 202
 203                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 204
 205                         info->rx_skb->dev = (void *) info->hdev;
 206                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
 207
 208                         switch (bt_cb(info->rx_skb)->pkt_type) {
 209
 210                         case HCI_EVENT_PKT:
 211                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 212                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 213                                 break;
 214
 215                         case HCI_ACLDATA_PKT:
 216                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 217                                 info->rx_count = HCI_ACL_HDR_SIZE;
 218                                 break;
 219
 220                         case HCI_SCODATA_PKT:
 221                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 222                                 info->rx_count = HCI_SCO_HDR_SIZE;
 223                                 break;
 224
 225                         default:
 226                                 /* Unknown packet */
 227                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 228                                 info->hdev->stat.err_rx++;
 229                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
 230
 231                                 kfree_skb(info->rx_skb);
 232                                 info->rx_skb = NULL;
 233                                 break;
 234
 235                         }
 236
 237                 } else {
 238
 239                         *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
 240                         info->rx_count--;
 241
 242                         if (info->rx_count == 0) {
 243
 244                                 int dlen;
 245                                 struct hci_event_hdr *eh;
 246                                 struct hci_acl_hdr *ah;
 247                                 struct hci_sco_hdr *sh;
 248
 249
 250                                 switch (info->rx_state) {
 251
 252                                 case RECV_WAIT_EVENT_HEADER:
 253                                         eh = hci_event_hdr(info->rx_skb);
 254                                         info->rx_state = RECV_WAIT_DATA;
 255                                         info->rx_count = eh->plen;
 256                                         break;
 257
 258                                 case RECV_WAIT_ACL_HEADER:
 259                                         ah = hci_acl_hdr(info->rx_skb);
 260                                         dlen = __le16_to_cpu(ah->dlen);
 261                                         info->rx_state = RECV_WAIT_DATA;
 262                                         info->rx_count = dlen;
 263                                         break;
 264
 265                                 case RECV_WAIT_SCO_HEADER:
 266                                         sh = hci_sco_hdr(info->rx_skb);
 267                                         info->rx_state = RECV_WAIT_DATA;
 268                                         info->rx_count = sh->dlen;
 269                                         break;
 270
 271                                 case RECV_WAIT_DATA:
 272                                         hci_recv_frame(info->rx_skb);
 273                                         info->rx_skb = NULL;
 274                                         break;
 275
 276                                 }
 277
 278                         }
 279
 280                 }
 281
 282                 /* Make sure we don't stay here too long */
 283                 if (boguscount++ > 16)
 284                         break;
 285
 286         } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 287 }
 288
 289
 290 static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
 291 {
 292         btuart_info_t *info = dev_inst;
 293         unsigned int iobase;
 294         int boguscount = 0;
 295         int iir, lsr;
 296         irqreturn_t r = IRQ_NONE;
 297
 298         if (!info || !info->hdev)
 299                 /* our irq handler is shared */
 300                 return IRQ_NONE;
 301
 302         iobase = info->p_dev->io.BasePort1;
 303
 304         spin_lock(&(info->lock));
 305
 306         iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 307         while (iir) {
 308                 r = IRQ_HANDLED;
 309
 310                 /* Clear interrupt */
 311                 lsr = inb(iobase + UART_LSR);
 312
 313                 switch (iir) {
 314                 case UART_IIR_RLSI:
 315                         BT_ERR("RLSI");
 316                         break;
 317                 case UART_IIR_RDI:
 318                         /* Receive interrupt */
 319                         btuart_receive(info);
 320                         break;
 321                 case UART_IIR_THRI:
 322                         if (lsr & UART_LSR_THRE) {
 323                                 /* Transmitter ready for data */
 324                                 btuart_write_wakeup(info);
 325                         }
 326                         break;
 327                 default:
 328                         BT_ERR("Unhandled IIR=%#x", iir);
 329                         break;
 330                 }
 331
 332                 /* Make sure we don't stay here too long */
 333                 if (boguscount++ > 100)
 334                         break;
 335
 336                 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 337
 338         }
 339
 340         spin_unlock(&(info->lock));
 341
 342         return r;
 343 }
 344
 345
 346 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
 347 {
 348         unsigned long flags;
 349         unsigned int iobase;
 350         int fcr;                /* FIFO control reg */
 351         int lcr;                /* Line control reg */
 352         int divisor;
 353
 354         if (!info) {
 355                 BT_ERR("Unknown device");
 356                 return;
 357         }
 358
 359         iobase = info->p_dev->io.BasePort1;
 360
 361         spin_lock_irqsave(&(info->lock), flags);
 362
 363         /* Turn off interrupts */
 364         outb(0, iobase + UART_IER);
 365
 366         divisor = SPEED_MAX / speed;
 367
 368         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 369
 370         /*
 371          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 372          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 373          * about this timeout since it will always be fast enough.
 374          */
 375
 376         if (speed < 38400)
 377                 fcr |= UART_FCR_TRIGGER_1;
 378         else
 379                 fcr |= UART_FCR_TRIGGER_14;
 380
 381         /* Bluetooth cards use 8N1 */
 382         lcr = UART_LCR_WLEN8;
 383
 384         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 385         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 386         outb(divisor >> 8, iobase + UART_DLM);
 387         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 388         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 389
 390         /* Turn on interrupts */
 391         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 392
 393         spin_unlock_irqrestore(&(info->lock), flags);
 394 }
 395
 396
 397
 398 /* ======================== HCI interface ======================== */
 399
 400
 401 static int btuart_hci_flush(struct hci_dev *hdev)
 402 {
 403         btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
 404
 405         /* Drop TX queue */
 406         skb_queue_purge(&(info->txq));
 407
 408         return 0;
 409 }
 410
 411
 412 static int btuart_hci_open(struct hci_dev *hdev)
 413 {
 414         set_bit(HCI_RUNNING, &(hdev->flags));
 415
 416         return 0;
 417 }
 418
 419
 420 static int btuart_hci_close(struct hci_dev *hdev)
 421 {
 422         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 423                 return 0;
 424
 425         btuart_hci_flush(hdev);
 426
 427         return 0;
 428 }
 429
 430
 431 static int btuart_hci_send_frame(struct sk_buff *skb)
 432 {
 433         btuart_info_t *info;
 434         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 435
 436         if (!hdev) {
 437                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 438                 return -ENODEV;
 439         }
 440
 441         info = (btuart_info_t *)(hdev->driver_data);
 442
 443         switch (bt_cb(skb)->pkt_type) {
 444         case HCI_COMMAND_PKT:
 445                 hdev->stat.cmd_tx++;
 446                 break;
 447         case HCI_ACLDATA_PKT:
 448                 hdev->stat.acl_tx++;
 449                 break;
 450         case HCI_SCODATA_PKT:
 451                 hdev->stat.sco_tx++;
 452                 break;
 453         };
 454
 455         /* Prepend skb with frame type */
 456         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 457         skb_queue_tail(&(info->txq), skb);
 458
 459         btuart_write_wakeup(info);
 460
 461         return 0;
 462 }
 463
 464
 465 static void btuart_hci_destruct(struct hci_dev *hdev)
 466 {
 467 }
 468
 469
 470 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 471 {
 472         return -ENOIOCTLCMD;
 473 }
 474
 475
 476
 477 /* ======================== Card services HCI interaction ======================== */
 478
 479
 480 static int btuart_open(btuart_info_t *info)
 481 {
 482         unsigned long flags;
 483         unsigned int iobase = info->p_dev->io.BasePort1;
 484         struct hci_dev *hdev;
 485
 486         spin_lock_init(&(info->lock));
 487
 488         skb_queue_head_init(&(info->txq));
 489
 490         info->rx_state = RECV_WAIT_PACKET_TYPE;
 491         info->rx_count = 0;
 492         info->rx_skb = NULL;
 493
 494         /* Initialize HCI device */
 495         hdev = hci_alloc_dev();
 496         if (!hdev) {
 497                 BT_ERR("Can't allocate HCI device");
 498                 return -ENOMEM;
 499         }
 500
 501         info->hdev = hdev;
 502
 503         hdev->bus = HCI_PCCARD;
 504         hdev->driver_data = info;
 505         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 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_DYNAMIC_SHARING;
 594
 595         link->irq.Handler = btuart_interrupt;
 596
 597         link->conf.Attributes = CONF_ENABLE_IRQ;
 598         link->conf.IntType = INT_MEMORY_AND_IO;
 599
 600         return btuart_config(link);
 601 }
 602
 603
 604 static void btuart_detach(struct pcmcia_device *link)
 605 {
 606         btuart_info_t *info = link->priv;
 607
 608         btuart_release(link);
 609         kfree(info);
 610 }
 611
 612 static int btuart_check_config(struct pcmcia_device *p_dev,
 613                                cistpl_cftable_entry_t *cf,
 614                                cistpl_cftable_entry_t *dflt,
 615                                unsigned int vcc,
 616                                void *priv_data)
 617 {
 618         int *try = priv_data;
 619
 620         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 621                 p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 622         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
 623             (cf->io.win[0].base != 0)) {
 624                 p_dev->io.BasePort1 = cf->io.win[0].base;
 625                 p_dev->io.IOAddrLines = (*try == 0) ? 16 :
 626                         cf->io.flags & CISTPL_IO_LINES_MASK;
 627                 if (!pcmcia_request_io(p_dev, &p_dev->io))
 628                         return 0;
 629         }
 630         return -ENODEV;
 631 }
 632
 633 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 634                                         cistpl_cftable_entry_t *cf,
 635                                         cistpl_cftable_entry_t *dflt,
 636                                         unsigned int vcc,
 637                                         void *priv_data)
 638 {
 639         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 640         int j;
 641
 642         if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 643                 for (j = 0; j < 5; j++) {
 644                         p_dev->io.BasePort1 = base[j];
 645                         p_dev->io.IOAddrLines = base[j] ? 16 : 3;
 646                         if (!pcmcia_request_io(p_dev, &p_dev->io))
 647                                 return 0;
 648                 }
 649         }
 650         return -ENODEV;
 651 }
 652
 653 static int btuart_config(struct pcmcia_device *link)
 654 {
 655         btuart_info_t *info = link->priv;
 656         int i;
 657         int try;
 658
 659         /* First pass: look for a config entry that looks normal.
 660            Two tries: without IO aliases, then with aliases */
 661         for (try = 0; try < 2; try++)
 662                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
 663                         goto found_port;
 664
 665         /* Second pass: try to find an entry that isn't picky about
 666            its base address, then try to grab any standard serial port
 667            address, and finally try to get any free port. */
 668         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 669                 goto found_port;
 670
 671         BT_ERR("No usable port range found");
 672         goto failed;
 673
 674 found_port:
 675         i = pcmcia_request_irq(link, &link->irq);
 676         if (i != 0)
 677                 link->irq.AssignedIRQ = 0;
 678
 679         i = pcmcia_request_configuration(link, &link->conf);
 680         if (i != 0)
 681                 goto failed;
 682
 683         if (btuart_open(info) != 0)
 684                 goto failed;
 685
 686         strcpy(info->node.dev_name, info->hdev->name);
 687         link->dev_node = &info->node;
 688
 689         return 0;
 690
 691 failed:
 692         btuart_release(link);
 693         return -ENODEV;
 694 }
 695
 696
 697 static void btuart_release(struct pcmcia_device *link)
 698 {
 699         btuart_info_t *info = link->priv;
 700
 701         btuart_close(info);
 702
 703         pcmcia_disable_device(link);
 704 }
 705
 706 static struct pcmcia_device_id btuart_ids[] = {
 707         /* don't use this driver. Use serial_cs + hci_uart instead */
 708         PCMCIA_DEVICE_NULL
 709 };
 710 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 711
 712 static struct pcmcia_driver btuart_driver = {
 713         .owner          = THIS_MODULE,
 714         .drv            = {
 715                 .name   = "btuart_cs",
 716         },
 717         .probe          = btuart_probe,
 718         .remove         = btuart_detach,
 719         .id_table       = btuart_ids,
 720 };
 721
 722 static int __init init_btuart_cs(void)
 723 {
 724         return pcmcia_register_driver(&btuart_driver);
 725 }
 726
 727
 728 static void __exit exit_btuart_cs(void)
 729 {
 730         pcmcia_unregister_driver(&btuart_driver);
 731 }
 732
 733 module_init(init_btuart_cs);
 734 module_exit(exit_btuart_cs);