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