linux/drivers/bluetooth/bt3c_cs.c
<<
>>
Prefs
   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
  61MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  62MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
  63MODULE_LICENSE("GPL");
  64MODULE_FIRMWARE("BT3CPCC.bin");
  65
  66
  67
  68/* ======================== Local structures ======================== */
  69
  70
  71typedef 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
  87static int bt3c_config(struct pcmcia_device *link);
  88static void bt3c_release(struct pcmcia_device *link);
  89
  90static 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
 117static 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
 124static 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
 131static 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
 138static 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
 148static 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
 160static 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
 179static 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
 218static 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
 338static 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
 390static 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
 401static int bt3c_hci_open(struct hci_dev *hdev)
 402{
 403        set_bit(HCI_RUNNING, &(hdev->flags));
 404
 405        return 0;
 406}
 407
 408
 409static 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
 420static 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
 459static void bt3c_hci_destruct(struct hci_dev *hdev)
 460{
 461}
 462
 463
 464static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 465{
 466        return -ENOIOCTLCMD;
 467}
 468
 469
 470
 471/* ======================== Card services HCI interaction ======================== */
 472
 473
 474static int bt3c_load_firmware(bt3c_info_t *info, const unsigned char *firmware,
 475                              int count)
 476{
 477        char *ptr = (char *) firmware;
 478        char b[9];
 479        unsigned int iobase, size, addr, fcs, tmp;
 480        int i, err = 0;
 481
 482        iobase = info->p_dev->resource[0]->start;
 483
 484        /* Reset */
 485        bt3c_io_write(iobase, 0x8040, 0x0404);
 486        bt3c_io_write(iobase, 0x8040, 0x0400);
 487
 488        udelay(1);
 489
 490        bt3c_io_write(iobase, 0x8040, 0x0404);
 491
 492        udelay(17);
 493
 494        /* Load */
 495        while (count) {
 496                if (ptr[0] != 'S') {
 497                        BT_ERR("Bad address in firmware");
 498                        err = -EFAULT;
 499                        goto error;
 500                }
 501
 502                memset(b, 0, sizeof(b));
 503                memcpy(b, ptr + 2, 2);
 504                size = simple_strtoul(b, NULL, 16);
 505
 506                memset(b, 0, sizeof(b));
 507                memcpy(b, ptr + 4, 8);
 508                addr = simple_strtoul(b, NULL, 16);
 509
 510                memset(b, 0, sizeof(b));
 511                memcpy(b, ptr + (size * 2) + 2, 2);
 512                fcs = simple_strtoul(b, NULL, 16);
 513
 514                memset(b, 0, sizeof(b));
 515                for (tmp = 0, i = 0; i < size; i++) {
 516                        memcpy(b, ptr + (i * 2) + 2, 2);
 517                        tmp += simple_strtol(b, NULL, 16);
 518                }
 519
 520                if (((tmp + fcs) & 0xff) != 0xff) {
 521                        BT_ERR("Checksum error in firmware");
 522                        err = -EILSEQ;
 523                        goto error;
 524                }
 525
 526                if (ptr[1] == '3') {
 527                        bt3c_address(iobase, addr);
 528
 529                        memset(b, 0, sizeof(b));
 530                        for (i = 0; i < (size - 4) / 2; i++) {
 531                                memcpy(b, ptr + (i * 4) + 12, 4);
 532                                tmp = simple_strtoul(b, NULL, 16);
 533                                bt3c_put(iobase, tmp);
 534                        }
 535                }
 536
 537                ptr   += (size * 2) + 6;
 538                count -= (size * 2) + 6;
 539        }
 540
 541        udelay(17);
 542
 543        /* Boot */
 544        bt3c_address(iobase, 0x3000);
 545        outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
 546
 547error:
 548        udelay(17);
 549
 550        /* Clear */
 551        bt3c_io_write(iobase, 0x7006, 0x0000);
 552        bt3c_io_write(iobase, 0x7005, 0x0000);
 553        bt3c_io_write(iobase, 0x7001, 0x0000);
 554
 555        return err;
 556}
 557
 558
 559static int bt3c_open(bt3c_info_t *info)
 560{
 561        const struct firmware *firmware;
 562        struct hci_dev *hdev;
 563        int err;
 564
 565        spin_lock_init(&(info->lock));
 566
 567        skb_queue_head_init(&(info->txq));
 568
 569        info->rx_state = RECV_WAIT_PACKET_TYPE;
 570        info->rx_count = 0;
 571        info->rx_skb = NULL;
 572
 573        /* Initialize HCI device */
 574        hdev = hci_alloc_dev();
 575        if (!hdev) {
 576                BT_ERR("Can't allocate HCI device");
 577                return -ENOMEM;
 578        }
 579
 580        info->hdev = hdev;
 581
 582        hdev->bus = HCI_PCCARD;
 583        hdev->driver_data = info;
 584        SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 585
 586        hdev->open     = bt3c_hci_open;
 587        hdev->close    = bt3c_hci_close;
 588        hdev->flush    = bt3c_hci_flush;
 589        hdev->send     = bt3c_hci_send_frame;
 590        hdev->destruct = bt3c_hci_destruct;
 591        hdev->ioctl    = bt3c_hci_ioctl;
 592
 593        hdev->owner = THIS_MODULE;
 594
 595        /* Load firmware */
 596        err = request_firmware(&firmware, "BT3CPCC.bin", &info->p_dev->dev);
 597        if (err < 0) {
 598                BT_ERR("Firmware request failed");
 599                goto error;
 600        }
 601
 602        err = bt3c_load_firmware(info, firmware->data, firmware->size);
 603
 604        release_firmware(firmware);
 605
 606        if (err < 0) {
 607                BT_ERR("Firmware loading failed");
 608                goto error;
 609        }
 610
 611        /* Timeout before it is safe to send the first HCI packet */
 612        msleep(1000);
 613
 614        /* Register HCI device */
 615        err = hci_register_dev(hdev);
 616        if (err < 0) {
 617                BT_ERR("Can't register HCI device");
 618                goto error;
 619        }
 620
 621        return 0;
 622
 623error:
 624        info->hdev = NULL;
 625        hci_free_dev(hdev);
 626        return err;
 627}
 628
 629
 630static int bt3c_close(bt3c_info_t *info)
 631{
 632        struct hci_dev *hdev = info->hdev;
 633
 634        if (!hdev)
 635                return -ENODEV;
 636
 637        bt3c_hci_close(hdev);
 638
 639        hci_unregister_dev(hdev);
 640        hci_free_dev(hdev);
 641
 642        return 0;
 643}
 644
 645static int bt3c_probe(struct pcmcia_device *link)
 646{
 647        bt3c_info_t *info;
 648
 649        /* Create new info device */
 650        info = kzalloc(sizeof(*info), GFP_KERNEL);
 651        if (!info)
 652                return -ENOMEM;
 653
 654        info->p_dev = link;
 655        link->priv = info;
 656
 657        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 658                CONF_AUTO_SET_IO;
 659
 660        return bt3c_config(link);
 661}
 662
 663
 664static void bt3c_detach(struct pcmcia_device *link)
 665{
 666        bt3c_info_t *info = link->priv;
 667
 668        bt3c_release(link);
 669        kfree(info);
 670}
 671
 672static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
 673{
 674        int *try = priv_data;
 675
 676        if (try == 0)
 677                p_dev->io_lines = 16;
 678
 679        if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 680                return -EINVAL;
 681
 682        p_dev->resource[0]->end = 8;
 683        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 684        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 685
 686        return pcmcia_request_io(p_dev);
 687}
 688
 689static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
 690                                      void *priv_data)
 691{
 692        static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 693        int j;
 694
 695        if (p_dev->io_lines > 3)
 696                return -ENODEV;
 697
 698        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 699        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 700        p_dev->resource[0]->end = 8;
 701
 702        for (j = 0; j < 5; j++) {
 703                p_dev->resource[0]->start = base[j];
 704                p_dev->io_lines = base[j] ? 16 : 3;
 705                if (!pcmcia_request_io(p_dev))
 706                        return 0;
 707        }
 708        return -ENODEV;
 709}
 710
 711static int bt3c_config(struct pcmcia_device *link)
 712{
 713        bt3c_info_t *info = link->priv;
 714        int i;
 715        unsigned long try;
 716
 717        /* First pass: look for a config entry that looks normal.
 718           Two tries: without IO aliases, then with aliases */
 719        for (try = 0; try < 2; try++)
 720                if (!pcmcia_loop_config(link, bt3c_check_config, (void *) try))
 721                        goto found_port;
 722
 723        /* Second pass: try to find an entry that isn't picky about
 724           its base address, then try to grab any standard serial port
 725           address, and finally try to get any free port. */
 726        if (!pcmcia_loop_config(link, bt3c_check_config_notpicky, NULL))
 727                goto found_port;
 728
 729        BT_ERR("No usable port range found");
 730        goto failed;
 731
 732found_port:
 733        i = pcmcia_request_irq(link, &bt3c_interrupt);
 734        if (i != 0)
 735                goto failed;
 736
 737        i = pcmcia_enable_device(link);
 738        if (i != 0)
 739                goto failed;
 740
 741        if (bt3c_open(info) != 0)
 742                goto failed;
 743
 744        return 0;
 745
 746failed:
 747        bt3c_release(link);
 748        return -ENODEV;
 749}
 750
 751
 752static void bt3c_release(struct pcmcia_device *link)
 753{
 754        bt3c_info_t *info = link->priv;
 755
 756        bt3c_close(info);
 757
 758        pcmcia_disable_device(link);
 759}
 760
 761
 762static const struct pcmcia_device_id bt3c_ids[] = {
 763        PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
 764        PCMCIA_DEVICE_NULL
 765};
 766MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
 767
 768static struct pcmcia_driver bt3c_driver = {
 769        .owner          = THIS_MODULE,
 770        .name           = "bt3c_cs",
 771        .probe          = bt3c_probe,
 772        .remove         = bt3c_detach,
 773        .id_table       = bt3c_ids,
 774};
 775
 776static int __init init_bt3c_cs(void)
 777{
 778        return pcmcia_register_driver(&bt3c_driver);
 779}
 780
 781
 782static void __exit exit_bt3c_cs(void)
 783{
 784        pcmcia_unregister_driver(&bt3c_driver);
 785}
 786
 787module_init(init_bt3c_cs);
 788module_exit(exit_bt3c_cs);
 789