drivers/bluetooth/bt3c_cs.c

   1 /*
   2  *
   3  *  Driver for the 3Com Bluetooth PCMCIA card
   4  *
   5  *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
   6  *                           Jose Orlando Pereira <jop@di.uminho.pt>
   7  *
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License version 2 as
  11  *  published by the Free Software Foundation;
  12  *
  13  *  Software distributed under the License is distributed on an "AS
  14  *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  15  *  implied. See the License for the specific language governing
  16  *  rights and limitations under the License.
  17  *
  18  *  The initial developer of the original code is David A. Hinds
  19  *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  20  *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  21  *
  22  */
  23
  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/delay.h>
  31 #include <linux/errno.h>
  32 #include <linux/ptrace.h>
  33 #include <linux/ioport.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/moduleparam.h>
  36
  37 #include <linux/skbuff.h>
  38 #include <linux/string.h>
  39 #include <linux/serial.h>
  40 #include <linux/serial_reg.h>
  41 #include <linux/bitops.h>
  42 #include <asm/system.h>
  43 #include <asm/io.h>
  44
  45 #include <linux/device.h>
  46 #include <linux/firmware.h>
  47
  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 the 3Com Bluetooth PCMCIA card");
  63 MODULE_LICENSE("GPL");
  64 MODULE_FIRMWARE("BT3CPCC.bin");
  65
  66
  67
  68 /* ======================== Local structures ======================== */
  69
  70
  71 typedef struct bt3c_info_t {
  72         struct pcmcia_device *p_dev;
  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 } bt3c_info_t;
  85
  86
  87 static int bt3c_config(struct pcmcia_device *link);
  88 static void bt3c_release(struct pcmcia_device *link);
  89
  90 static void bt3c_detach(struct pcmcia_device *p_dev);
  91
  92
  93 /* Transmit states  */
  94 #define XMIT_SENDING  1
  95 #define XMIT_WAKEUP   2
  96 #define XMIT_WAITING  8
  97
  98 /* Receiver states */
  99 #define RECV_WAIT_PACKET_TYPE   0
 100 #define RECV_WAIT_EVENT_HEADER  1
 101 #define RECV_WAIT_ACL_HEADER    2
 102 #define RECV_WAIT_SCO_HEADER    3
 103 #define RECV_WAIT_DATA          4
 104
 105
 106
 107 /* ======================== Special I/O functions ======================== */
 108
 109
 110 #define DATA_L   0
 111 #define DATA_H   1
 112 #define ADDR_L   2
 113 #define ADDR_H   3
 114 #define CONTROL  4
 115
 116
 117 static inline void bt3c_address(unsigned int iobase, unsigned short addr)
 118 {
 119         outb(addr & 0xff, iobase + ADDR_L);
 120         outb((addr >> 8) & 0xff, iobase + ADDR_H);
 121 }
 122
 123
 124 static inline void bt3c_put(unsigned int iobase, unsigned short value)
 125 {
 126         outb(value & 0xff, iobase + DATA_L);
 127         outb((value >> 8) & 0xff, iobase + DATA_H);
 128 }
 129
 130
 131 static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
 132 {
 133         bt3c_address(iobase, addr);
 134         bt3c_put(iobase, value);
 135 }
 136
 137
 138 static inline unsigned short bt3c_get(unsigned int iobase)
 139 {
 140         unsigned short value = inb(iobase + DATA_L);
 141
 142         value |= inb(iobase + DATA_H) << 8;
 143
 144         return value;
 145 }
 146
 147
 148 static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
 149 {
 150         bt3c_address(iobase, addr);
 151
 152         return bt3c_get(iobase);
 153 }
 154
 155
 156
 157 /* ======================== Interrupt handling ======================== */
 158
 159
 160 static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 161 {
 162         int actual = 0;
 163
 164         bt3c_address(iobase, 0x7080);
 165
 166         /* Fill FIFO with current frame */
 167         while (actual < len) {
 168                 /* Transmit next byte */
 169                 bt3c_put(iobase, buf[actual]);
 170                 actual++;
 171         }
 172
 173         bt3c_io_write(iobase, 0x7005, actual);
 174
 175         return actual;
 176 }
 177
 178
 179 static void bt3c_write_wakeup(bt3c_info_t *info)
 180 {
 181         if (!info) {
 182                 BT_ERR("Unknown device");
 183                 return;
 184         }
 185
 186         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
 187                 return;
 188
 189         do {
 190                 register unsigned int iobase = info->p_dev->resource[0]->start;
 191                 register struct sk_buff *skb;
 192                 register int len;
 193
 194                 if (!pcmcia_dev_present(info->p_dev))
 195                         break;
 196
 197
 198                 if (!(skb = skb_dequeue(&(info->txq)))) {
 199                         clear_bit(XMIT_SENDING, &(info->tx_state));
 200                         break;
 201                 }
 202
 203                 /* Send frame */
 204                 len = bt3c_write(iobase, 256, skb->data, skb->len);
 205
 206                 if (len != skb->len) {
 207                         BT_ERR("Very strange");
 208                 }
 209
 210                 kfree_skb(skb);
 211
 212                 info->hdev->stat.byte_tx += len;
 213
 214         } while (0);
 215 }
 216
 217
 218 static void bt3c_receive(bt3c_info_t *info)
 219 {
 220         unsigned int iobase;
 221         int size = 0, avail;
 222
 223         if (!info) {
 224                 BT_ERR("Unknown device");
 225                 return;
 226         }
 227
 228         iobase = info->p_dev->resource[0]->start;
 229
 230         avail = bt3c_read(iobase, 0x7006);
 231         //printk("bt3c_cs: receiving %d bytes\n", avail);
 232
 233         bt3c_address(iobase, 0x7480);
 234         while (size < avail) {
 235                 size++;
 236                 info->hdev->stat.byte_rx++;
 237
 238                 /* Allocate packet */
 239                 if (info->rx_skb == NULL) {
 240                         info->rx_state = RECV_WAIT_PACKET_TYPE;
 241                         info->rx_count = 0;
 242                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 243                                 BT_ERR("Can't allocate mem for new packet");
 244                                 return;
 245                         }
 246                 }
 247
 248
 249                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 250
 251                         info->rx_skb->dev = (void *) info->hdev;
 252                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
 253                         inb(iobase + DATA_H);
 254                         //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
 255
 256                         switch (bt_cb(info->rx_skb)->pkt_type) {
 257
 258                         case HCI_EVENT_PKT:
 259                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 260                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 261                                 break;
 262
 263                         case HCI_ACLDATA_PKT:
 264                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 265                                 info->rx_count = HCI_ACL_HDR_SIZE;
 266                                 break;
 267
 268                         case HCI_SCODATA_PKT:
 269                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 270                                 info->rx_count = HCI_SCO_HDR_SIZE;
 271                                 break;
 272
 273                         default:
 274                                 /* Unknown packet */
 275                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 276                                 info->hdev->stat.err_rx++;
 277                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
 278
 279                                 kfree_skb(info->rx_skb);
 280                                 info->rx_skb = NULL;
 281                                 break;
 282
 283                         }
 284
 285                 } else {
 286
 287                         __u8 x = inb(iobase + DATA_L);
 288
 289                         *skb_put(info->rx_skb, 1) = x;
 290                         inb(iobase + DATA_H);
 291                         info->rx_count--;
 292
 293                         if (info->rx_count == 0) {
 294
 295                                 int dlen;
 296                                 struct hci_event_hdr *eh;
 297                                 struct hci_acl_hdr *ah;
 298                                 struct hci_sco_hdr *sh;
 299
 300                                 switch (info->rx_state) {
 301
 302                                 case RECV_WAIT_EVENT_HEADER:
 303                                         eh = hci_event_hdr(info->rx_skb);
 304                                         info->rx_state = RECV_WAIT_DATA;
 305                                         info->rx_count = eh->plen;
 306                                         break;
 307
 308                                 case RECV_WAIT_ACL_HEADER:
 309                                         ah = hci_acl_hdr(info->rx_skb);
 310                                         dlen = __le16_to_cpu(ah->dlen);
 311                                         info->rx_state = RECV_WAIT_DATA;
 312                                         info->rx_count = dlen;
 313                                         break;
 314
 315                                 case RECV_WAIT_SCO_HEADER:
 316                                         sh = hci_sco_hdr(info->rx_skb);
 317                                         info->rx_state = RECV_WAIT_DATA;
 318                                         info->rx_count = sh->dlen;
 319                                         break;
 320
 321                                 case RECV_WAIT_DATA:
 322                                         hci_recv_frame(info->rx_skb);
 323                                         info->rx_skb = NULL;
 324                                         break;
 325
 326                                 }
 327
 328                         }
 329
 330                 }
 331
 332         }
 333
 334         bt3c_io_write(iobase, 0x7006, 0x0000);
 335 }
 336
 337
 338 static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
 339 {
 340         bt3c_info_t *info = dev_inst;
 341         unsigned int iobase;
 342         int iir;
 343         irqreturn_t r = IRQ_NONE;
 344
 345         if (!info || !info->hdev)
 346                 /* our irq handler is shared */
 347                 return IRQ_NONE;
 348
 349         iobase = info->p_dev->resource[0]->start;
 350
 351         spin_lock(&(info->lock));
 352
 353         iir = inb(iobase + CONTROL);
 354         if (iir & 0x80) {
 355                 int stat = bt3c_read(iobase, 0x7001);
 356
 357                 if ((stat & 0xff) == 0x7f) {
 358                         BT_ERR("Very strange (stat=0x%04x)", stat);
 359                 } else if ((stat & 0xff) != 0xff) {
 360                         if (stat & 0x0020) {
 361                                 int status = bt3c_read(iobase, 0x7002) & 0x10;
 362                                 BT_INFO("%s: Antenna %s", info->hdev->name,
 363                                                         status ? "out" : "in");
 364                         }
 365                         if (stat & 0x0001)
 366                                 bt3c_receive(info);
 367                         if (stat & 0x0002) {
 368                                 //BT_ERR("Ack (stat=0x%04x)", stat);
 369                                 clear_bit(XMIT_SENDING, &(info->tx_state));
 370                                 bt3c_write_wakeup(info);
 371                         }
 372
 373                         bt3c_io_write(iobase, 0x7001, 0x0000);
 374
 375                         outb(iir, iobase + CONTROL);
 376                 }
 377                 r = IRQ_HANDLED;
 378         }
 379
 380         spin_unlock(&(info->lock));
 381
 382         return r;
 383 }
 384
 385
 386
 387 /* ======================== HCI interface ======================== */
 388
 389
 390 static int bt3c_hci_flush(struct hci_dev *hdev)
 391 {
 392         bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
 393
 394         /* Drop TX queue */
 395         skb_queue_purge(&(info->txq));
 396
 397         return 0;
 398 }
 399
 400
 401 static int bt3c_hci_open(struct hci_dev *hdev)
 402 {
 403         set_bit(HCI_RUNNING, &(hdev->flags));
 404
 405         return 0;
 406 }
 407
 408
 409 static int bt3c_hci_close(struct hci_dev *hdev)
 410 {
 411         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 412                 return 0;
 413
 414         bt3c_hci_flush(hdev);
 415
 416         return 0;
 417 }
 418
 419
 420 static int bt3c_hci_send_frame(struct sk_buff *skb)
 421 {
 422         bt3c_info_t *info;
 423         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 424         unsigned long flags;
 425
 426         if (!hdev) {
 427                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 428                 return -ENODEV;
 429         }
 430
 431         info = (bt3c_info_t *) (hdev->driver_data);
 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         /* Prepend skb with frame type */
 446         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 447         skb_queue_tail(&(info->txq), skb);
 448
 449         spin_lock_irqsave(&(info->lock), flags);
 450
 451         bt3c_write_wakeup(info);
 452
 453         spin_unlock_irqrestore(&(info->lock), flags);
 454
 455         return 0;
 456 }
 457
 458
 459 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 460 {
 461         return -ENOIOCTLCMD;
 462 }
 463
 464
 465
 466 /* ======================== Card services HCI interaction ======================== */
 467
 468
 469 static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
 470                               int count)
 471 {
 472         char *ptr = (char *) firmware;
 473         char b[9];
 474         unsigned int iobase, size, addr, fcs, tmp;
 475         int i, err = 0;
 476
 477         iobase = info->p_dev->resource[0]->start;
 478
 479         /* Reset */
 480         bt3c_io_write(iobase, 0x8040, 0x0404);
 481         bt3c_io_write(iobase, 0x8040, 0x0400);
 482
 483         udelay(1);
 484
 485         bt3c_io_write(iobase, 0x8040, 0x0404);
 486
 487         udelay(17);
 488
 489         /* Load */
 490         while (count) {
 491                 if (ptr[0] != 'S') {
 492                         BT_ERR("Bad address in firmware");
 493                         err = -EFAULT;
 494                         goto error;
 495                 }
 496
 497                 memset(b, 0, sizeof(b));
 498                 memcpy(b, ptr + 2, 2);
 499                 size = simple_strtoul(b, NULL, 16);
 500
 501                 memset(b, 0, sizeof(b));
 502                 memcpy(b, ptr + 4, 8);
 503                 addr = simple_strtoul(b, NULL, 16);
 504
 505                 memset(b, 0, sizeof(b));
 506                 memcpy(b, ptr + (size * 2) + 2, 2);
 507                 fcs = simple_strtoul(b, NULL, 16);
 508
 509                 memset(b, 0, sizeof(b));
 510                 for (tmp = 0, i = 0; i < size; i++) {
 511                         memcpy(b, ptr + (i * 2) + 2, 2);
 512                         tmp += simple_strtol(b, NULL, 16);
 513                 }
 514
 515                 if (((tmp + fcs) & 0xff) != 0xff) {
 516                         BT_ERR("Checksum error in firmware");
 517                         err = -EILSEQ;
 518                         goto error;
 519                 }
 520
 521                 if (ptr[1] == '3') {
 522                         bt3c_address(iobase, addr);
 523
 524                         memset(b, 0, sizeof(b));
 525                         for (i = 0; i < (size - 4) / 2; i++) {
 526                                 memcpy(b, ptr + (i * 4) + 12, 4);
 527                                 tmp = simple_strtoul(b, NULL, 16);
 528                                 bt3c_put(iobase, tmp);
 529                         }
 530                 }
 531
 532                 ptr   += (size * 2) + 6;
 533                 count -= (size * 2) + 6;
 534         }
 535
 536         udelay(17);
 537
 538         /* Boot */
 539         bt3c_address(iobase, 0x3000);
 540         outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
 541
 542 error:
 543         udelay(17);
 544
 545         /* Clear */
 546         bt3c_io_write(iobase, 0x7006, 0x0000);
 547         bt3c_io_write(iobase, 0x7005, 0x0000);
 548         bt3c_io_write(iobase, 0x7001, 0x0000);
 549
 550         return err;
 551 }
 552
 553
 554 static int bt3c_open(bt3c_info_t *info)
 555 {
 556         const struct firmware *firmware;
 557         struct hci_dev *hdev;
 558         int err;
 559
 560         spin_lock_init(&(info->lock));
 561
 562         skb_queue_head_init(&(info->txq));
 563
 564         info->rx_state = RECV_WAIT_PACKET_TYPE;
 565         info->rx_count = 0;
 566         info->rx_skb = NULL;
 567
 568         /* Initialize HCI device */
 569         hdev = hci_alloc_dev();
 570         if (!hdev) {
 571                 BT_ERR("Can't allocate HCI device");
 572                 return -ENOMEM;
 573         }
 574
 575         info->hdev = hdev;
 576
 577         hdev->bus = HCI_PCCARD;
 578         hdev->driver_data = info;
 579         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 580
 581         hdev->open     = bt3c_hci_open;
 582         hdev->close    = bt3c_hci_close;
 583         hdev->flush    = bt3c_hci_flush;
 584         hdev->send     = bt3c_hci_send_frame;
 585         hdev->ioctl    = bt3c_hci_ioctl;
 586
 587         hdev->owner = THIS_MODULE;
 588
 589         /* Load firmware */
 590         err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
 591         if (err < 0) {
 592                 BT_ERR("Firmware request failed");
 593                 goto error;
 594         }
 595
 596         err = bt3c_load_firmware(info, firmware->data, firmware->size);
 597
 598         release_firmware(firmware);
 599
 600         if (err < 0) {
 601                 BT_ERR("Firmware loading failed");
 602                 goto error;
 603         }
 604
 605         /* Timeout before it is safe to send the first HCI packet */
 606         msleep(1000);
 607
 608         /* Register HCI device */
 609         err = hci_register_dev(hdev);
 610         if (err < 0) {
 611                 BT_ERR("Can't register HCI device");
 612                 goto error;
 613         }
 614
 615         return 0;
 616
 617 error:
 618         info->hdev = NULL;
 619         hci_free_dev(hdev);
 620         return err;
 621 }
 622
 623
 624 static int bt3c_close(bt3c_info_t *info)
 625 {
 626         struct hci_dev *hdev = info->hdev;
 627
 628         if (!hdev)
 629                 return -ENODEV;
 630
 631         bt3c_hci_close(hdev);
 632
 633         hci_unregister_dev(hdev);
 634         hci_free_dev(hdev);
 635
 636         return 0;
 637 }
 638
 639 static int bt3c_probe(struct pcmcia_device *link)
 640 {
 641         bt3c_info_t *info;
 642
 643         /* Create new info device */
 644         info = kzalloc(sizeof(*info), GFP_KERNEL);
 645         if (!info)
 646                 return -ENOMEM;
 647
 648         info->p_dev = link;
 649         link->priv = info;
 650
 651         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 652                 CONF_AUTO_SET_IO;
 653
 654         return bt3c_config(link);
 655 }
 656
 657
 658 static void bt3c_detach(struct pcmcia_device *link)
 659 {
 660         bt3c_info_t *info = link->priv;
 661
 662         bt3c_release(link);
 663         kfree(info);
 664 }
 665
 666 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
 667 {
 668         int *try = priv_data;
 669
 670         if (try == 0)
 671                 p_dev->io_lines = 16;
 672
 673         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 674                 return -EINVAL;
 675
 676         p_dev->resource[0]->end = 8;
 677         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 678         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 679
 680         return pcmcia_request_io(p_dev);
 681 }
 682
 683 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
 684                                       void *priv_data)
 685 {
 686         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 687         int j;
 688
 689         if (p_dev->io_lines > 3)
 690                 return -ENODEV;
 691
 692         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 693         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 694         p_dev->resource[0]->end = 8;
 695
 696         for (j = 0; j < 5; j++) {
 697                 p_dev->resource[0]->start = base[j];
 698                 p_dev->io_lines = base[j] ? 16 : 3;
 699                 if (!pcmcia_request_io(p_dev))
 700                         return 0;
 701         }
 702         return -ENODEV;
 703 }
 704
 705 static int bt3c_config(struct pcmcia_device *link)
 706 {
 707         bt3c_info_t *info = link->priv;
 708         int i;
 709         unsigned long try;
 710
 711         /* First pass: look for a config entry that looks normal.
 712            Two tries: without IO aliases, then with aliases */
 713         for (try = 0; try < 2; try++)
 714                 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
 715                         goto found_port;
 716
 717         /* Second pass: try to find an entry that isn't picky about
 718            its base address, then try to grab any standard serial port
 719            address, and finally try to get any free port. */
 720         if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
 721                 goto found_port;
 722
 723         BT_ERR("No usable port range found");
 724         goto failed;
 725
 726 found_port:
 727         i = pcmcia_request_irq(link, &bt3c_interrupt);
 728         if (i != 0)
 729                 goto failed;
 730
 731         i = pcmcia_enable_device(link);
 732         if (i != 0)
 733                 goto failed;
 734
 735         if (bt3c_open(info) != 0)
 736                 goto failed;
 737
 738         return 0;
 739
 740 failed:
 741         bt3c_release(link);
 742         return -ENODEV;
 743 }
 744
 745
 746 static void bt3c_release(struct pcmcia_device *link)
 747 {
 748         bt3c_info_t *info = link->priv;
 749
 750         bt3c_close(info);
 751
 752         pcmcia_disable_device(link);
 753 }
 754
 755
 756 static const struct pcmcia_device_id bt3c_ids[] = {
 757         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
 758         PCMCIA_DEVICE_NULL
 759 };
 760 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
 761
 762 static struct pcmcia_driver bt3c_driver = {
 763         .owner          = THIS_MODULE,
 764         .name           = "bt3c_cs",
 765         .probe          = bt3c_probe,
 766         .remove         = bt3c_detach,
 767         .id_table       = bt3c_ids,
 768 };
 769
 770 static int __init init_bt3c_cs(void)
 771 {
 772         return pcmcia_register_driver(&bt3c_driver);
 773 }
 774
 775
 776 static void __exit exit_bt3c_cs(void)
 777 {
 778         pcmcia_unregister_driver(&bt3c_driver);
 779 }
 780
 781 module_init(init_bt3c_cs);
 782 module_exit(exit_bt3c_cs);