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