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