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 = hci_get_drvdata(hdev);
 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 = 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         /* 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         hci_set_drvdata(hdev, 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         /* Load firmware */
 588         err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
 589         if (err < 0) {
 590                 BT_ERR("Firmware request failed");
 591                 goto error;
 592         }
 593
 594         err = bt3c_load_firmware(info, firmware->data, firmware->size);
 595
 596         release_firmware(firmware);
 597
 598         if (err < 0) {
 599                 BT_ERR("Firmware loading failed");
 600                 goto error;
 601         }
 602
 603         /* Timeout before it is safe to send the first HCI packet */
 604         msleep(1000);
 605
 606         /* Register HCI device */
 607         err = hci_register_dev(hdev);
 608         if (err < 0) {
 609                 BT_ERR("Can't register HCI device");
 610                 goto error;
 611         }
 612
 613         return 0;
 614
 615 error:
 616         info->hdev = NULL;
 617         hci_free_dev(hdev);
 618         return err;
 619 }
 620
 621
 622 static int bt3c_close(bt3c_info_t *info)
 623 {
 624         struct hci_dev *hdev = info->hdev;
 625
 626         if (!hdev)
 627                 return -ENODEV;
 628
 629         bt3c_hci_close(hdev);
 630
 631         hci_unregister_dev(hdev);
 632         hci_free_dev(hdev);
 633
 634         return 0;
 635 }
 636
 637 static int bt3c_probe(struct pcmcia_device *link)
 638 {
 639         bt3c_info_t *info;
 640
 641         /* Create new info device */
 642         info = kzalloc(sizeof(*info), GFP_KERNEL);
 643         if (!info)
 644                 return -ENOMEM;
 645
 646         info->p_dev = link;
 647         link->priv = info;
 648
 649         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 650                 CONF_AUTO_SET_IO;
 651
 652         return bt3c_config(link);
 653 }
 654
 655
 656 static void bt3c_detach(struct pcmcia_device *link)
 657 {
 658         bt3c_info_t *info = link->priv;
 659
 660         bt3c_release(link);
 661         kfree(info);
 662 }
 663
 664 static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
 665 {
 666         int *try = priv_data;
 667
 668         if (try == 0)
 669                 p_dev->io_lines = 16;
 670
 671         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 672                 return -EINVAL;
 673
 674         p_dev->resource[0]->end = 8;
 675         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 676         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 677
 678         return pcmcia_request_io(p_dev);
 679 }
 680
 681 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
 682                                       void *priv_data)
 683 {
 684         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 685         int j;
 686
 687         if (p_dev->io_lines > 3)
 688                 return -ENODEV;
 689
 690         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 691         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 692         p_dev->resource[0]->end = 8;
 693
 694         for (j = 0; j < 5; j++) {
 695                 p_dev->resource[0]->start = base[j];
 696                 p_dev->io_lines = base[j] ? 16 : 3;
 697                 if (!pcmcia_request_io(p_dev))
 698                         return 0;
 699         }
 700         return -ENODEV;
 701 }
 702
 703 static int bt3c_config(struct pcmcia_device *link)
 704 {
 705         bt3c_info_t *info = link->priv;
 706         int i;
 707         unsigned long try;
 708
 709         /* First pass: look for a config entry that looks normal.
 710            Two tries: without IO aliases, then with aliases */
 711         for (try = 0; try < 2; try++)
 712                 if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
 713                         goto found_port;
 714
 715         /* Second pass: try to find an entry that isn't picky about
 716            its base address, then try to grab any standard serial port
 717            address, and finally try to get any free port. */
 718         if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
 719                 goto found_port;
 720
 721         BT_ERR("No usable port range found");
 722         goto failed;
 723
 724 found_port:
 725         i = pcmcia_request_irq(link, &bt3c_interrupt);
 726         if (i != 0)
 727                 goto failed;
 728
 729         i = pcmcia_enable_device(link);
 730         if (i != 0)
 731                 goto failed;
 732
 733         if (bt3c_open(info) != 0)
 734                 goto failed;
 735
 736         return 0;
 737
 738 failed:
 739         bt3c_release(link);
 740         return -ENODEV;
 741 }
 742
 743
 744 static void bt3c_release(struct pcmcia_device *link)
 745 {
 746         bt3c_info_t *info = link->priv;
 747
 748         bt3c_close(info);
 749
 750         pcmcia_disable_device(link);
 751 }
 752
 753
 754 static const struct pcmcia_device_id bt3c_ids[] = {
 755         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
 756         PCMCIA_DEVICE_NULL
 757 };
 758 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
 759
 760 static struct pcmcia_driver bt3c_driver = {
 761         .owner          = THIS_MODULE,
 762         .name           = "bt3c_cs",
 763         .probe          = bt3c_probe,
 764         .remove         = bt3c_detach,
 765         .id_table       = bt3c_ids,
 766 };
 767
 768 static int __init init_bt3c_cs(void)
 769 {
 770         return pcmcia_register_driver(&bt3c_driver);
 771 }
 772
 773
 774 static void __exit exit_bt3c_cs(void)
 775 {
 776         pcmcia_unregister_driver(&bt3c_driver);
 777 }
 778
 779 module_init(init_bt3c_cs);
 780 module_exit(exit_bt3c_cs);