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/sched.h>
  31 #include <linux/delay.h>
  32 #include <linux/errno.h>
  33 #include <linux/ptrace.h>
  34 #include <linux/ioport.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/moduleparam.h>
  37
  38 #include <linux/skbuff.h>
  39 #include <linux/string.h>
  40 #include <linux/serial.h>
  41 #include <linux/serial_reg.h>
  42 #include <linux/bitops.h>
  43 #include <asm/system.h>
  44 #include <asm/io.h>
  45
  46 #include <linux/device.h>
  47 #include <linux/firmware.h>
  48
  49 #include <pcmcia/cs_types.h>
  50 #include <pcmcia/cs.h>
  51 #include <pcmcia/cistpl.h>
  52 #include <pcmcia/ciscode.h>
  53 #include <pcmcia/ds.h>
  54 #include <pcmcia/cisreg.h>
  55
  56 #include <net/bluetooth/bluetooth.h>
  57 #include <net/bluetooth/hci_core.h>
  58
  59
  60
  61 /* ======================== Module parameters ======================== */
  62
  63
  64 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
  65 MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
  66 MODULE_LICENSE("GPL");
  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 = (struct hci_event_hdr *)(info->rx_skb->data);
 307                                         info->rx_state = RECV_WAIT_DATA;
 308                                         info->rx_count = eh->plen;
 309                                         break;
 310
 311                                 case RECV_WAIT_ACL_HEADER:
 312                                         ah = (struct hci_acl_hdr *)(info->rx_skb->data);
 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 = (struct hci_sco_hdr *)(info->rx_skb->data);
 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, struct pt_regs *regs)
 342 {
 343         bt3c_info_t *info = dev_inst;
 344         unsigned int iobase;
 345         int iir;
 346
 347         if (!info || !info->hdev) {
 348                 BT_ERR("Call of irq %d for unknown device", irq);
 349                 return IRQ_NONE;
 350         }
 351
 352         iobase = info->p_dev->io.BasePort1;
 353
 354         spin_lock(&(info->lock));
 355
 356         iir = inb(iobase + CONTROL);
 357         if (iir & 0x80) {
 358                 int stat = bt3c_read(iobase, 0x7001);
 359
 360                 if ((stat & 0xff) == 0x7f) {
 361                         BT_ERR("Very strange (stat=0x%04x)", stat);
 362                 } else if ((stat & 0xff) != 0xff) {
 363                         if (stat & 0x0020) {
 364                                 int stat = bt3c_read(iobase, 0x7002) & 0x10;
 365                                 BT_INFO("%s: Antenna %s", info->hdev->name,
 366                                                         stat ? "out" : "in");
 367                         }
 368                         if (stat & 0x0001)
 369                                 bt3c_receive(info);
 370                         if (stat & 0x0002) {
 371                                 //BT_ERR("Ack (stat=0x%04x)", stat);
 372                                 clear_bit(XMIT_SENDING, &(info->tx_state));
 373                                 bt3c_write_wakeup(info);
 374                         }
 375
 376                         bt3c_io_write(iobase, 0x7001, 0x0000);
 377
 378                         outb(iir, iobase + CONTROL);
 379                 }
 380         }
 381
 382         spin_unlock(&(info->lock));
 383
 384         return IRQ_HANDLED;
 385 }
 386
 387
 388
 389 /* ======================== HCI interface ======================== */
 390
 391
 392 static int bt3c_hci_flush(struct hci_dev *hdev)
 393 {
 394         bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
 395
 396         /* Drop TX queue */
 397         skb_queue_purge(&(info->txq));
 398
 399         return 0;
 400 }
 401
 402
 403 static int bt3c_hci_open(struct hci_dev *hdev)
 404 {
 405         set_bit(HCI_RUNNING, &(hdev->flags));
 406
 407         return 0;
 408 }
 409
 410
 411 static int bt3c_hci_close(struct hci_dev *hdev)
 412 {
 413         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 414                 return 0;
 415
 416         bt3c_hci_flush(hdev);
 417
 418         return 0;
 419 }
 420
 421
 422 static int bt3c_hci_send_frame(struct sk_buff *skb)
 423 {
 424         bt3c_info_t *info;
 425         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 426         unsigned long flags;
 427
 428         if (!hdev) {
 429                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 430                 return -ENODEV;
 431         }
 432
 433         info = (bt3c_info_t *) (hdev->driver_data);
 434
 435         switch (bt_cb(skb)->pkt_type) {
 436         case HCI_COMMAND_PKT:
 437                 hdev->stat.cmd_tx++;
 438                 break;
 439         case HCI_ACLDATA_PKT:
 440                 hdev->stat.acl_tx++;
 441                 break;
 442         case HCI_SCODATA_PKT:
 443                 hdev->stat.sco_tx++;
 444                 break;
 445         };
 446
 447         /* Prepend skb with frame type */
 448         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 449         skb_queue_tail(&(info->txq), skb);
 450
 451         spin_lock_irqsave(&(info->lock), flags);
 452
 453         bt3c_write_wakeup(info);
 454
 455         spin_unlock_irqrestore(&(info->lock), flags);
 456
 457         return 0;
 458 }
 459
 460
 461 static void bt3c_hci_destruct(struct hci_dev *hdev)
 462 {
 463 }
 464
 465
 466 static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 467 {
 468         return -ENOIOCTLCMD;
 469 }
 470
 471
 472
 473 /* ======================== Card services HCI interaction ======================== */
 474
 475
 476 static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, 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->io.BasePort1;
 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_strtol(b, NULL, 16);
 506
 507                 memset(b, 0, sizeof(b));
 508                 memcpy(b, ptr + 4, 8);
 509                 addr = simple_strtol(b, NULL, 16);
 510
 511                 memset(b, 0, sizeof(b));
 512                 memcpy(b, ptr + (size * 2) + 2, 2);
 513                 fcs = simple_strtol(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_strtol(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->type = HCI_PCCARD;
 584         hdev->driver_data = info;
 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
 623 error:
 624         info->hdev = NULL;
 625         hci_free_dev(hdev);
 626         return err;
 627 }
 628
 629
 630 static 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         if (hci_unregister_dev(hdev) < 0)
 640                 BT_ERR("Can't unregister HCI device %s", hdev->name);
 641
 642         hci_free_dev(hdev);
 643
 644         return 0;
 645 }
 646
 647 static int bt3c_probe(struct pcmcia_device *link)
 648 {
 649         bt3c_info_t *info;
 650
 651         /* Create new info device */
 652         info = kzalloc(sizeof(*info), GFP_KERNEL);
 653         if (!info)
 654                 return -ENOMEM;
 655
 656         info->p_dev = link;
 657         link->priv = info;
 658
 659         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 660         link->io.NumPorts1 = 8;
 661         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 662         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 663
 664         link->irq.Handler = bt3c_interrupt;
 665         link->irq.Instance = info;
 666
 667         link->conf.Attributes = CONF_ENABLE_IRQ;
 668         link->conf.IntType = INT_MEMORY_AND_IO;
 669
 670         return bt3c_config(link);
 671 }
 672
 673
 674 static void bt3c_detach(struct pcmcia_device *link)
 675 {
 676         bt3c_info_t *info = link->priv;
 677
 678         bt3c_release(link);
 679         kfree(info);
 680 }
 681
 682 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
 683 {
 684         int i;
 685
 686         i = pcmcia_get_tuple_data(handle, tuple);
 687         if (i != CS_SUCCESS)
 688                 return i;
 689
 690         return pcmcia_parse_tuple(handle, tuple, parse);
 691 }
 692
 693 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
 694 {
 695         if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
 696                 return CS_NO_MORE_ITEMS;
 697         return get_tuple(handle, tuple, parse);
 698 }
 699
 700 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
 701 {
 702         if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
 703                 return CS_NO_MORE_ITEMS;
 704         return get_tuple(handle, tuple, parse);
 705 }
 706
 707 static int bt3c_config(struct pcmcia_device *link)
 708 {
 709         static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 710         bt3c_info_t *info = link->priv;
 711         tuple_t tuple;
 712         u_short buf[256];
 713         cisparse_t parse;
 714         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 715         int i, j, try, last_ret, last_fn;
 716
 717         tuple.TupleData = (cisdata_t *)buf;
 718         tuple.TupleOffset = 0;
 719         tuple.TupleDataMax = 255;
 720         tuple.Attributes = 0;
 721
 722         /* Get configuration register information */
 723         tuple.DesiredTuple = CISTPL_CONFIG;
 724         last_ret = first_tuple(link, &tuple, &parse);
 725         if (last_ret != CS_SUCCESS) {
 726                 last_fn = ParseTuple;
 727                 goto cs_failed;
 728         }
 729         link->conf.ConfigBase = parse.config.base;
 730         link->conf.Present = parse.config.rmask[0];
 731
 732         /* First pass: look for a config entry that looks normal. */
 733         tuple.TupleData = (cisdata_t *)buf;
 734         tuple.TupleOffset = 0;
 735         tuple.TupleDataMax = 255;
 736         tuple.Attributes = 0;
 737         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 738         /* Two tries: without IO aliases, then with aliases */
 739         for (try = 0; try < 2; try++) {
 740                 i = first_tuple(link, &tuple, &parse);
 741                 while (i != CS_NO_MORE_ITEMS) {
 742                         if (i != CS_SUCCESS)
 743                                 goto next_entry;
 744                         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 745                                 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 746                         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
 747                                 link->conf.ConfigIndex = cf->index;
 748                                 link->io.BasePort1 = cf->io.win[0].base;
 749                                 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 750                                 i = pcmcia_request_io(link, &link->io);
 751                                 if (i == CS_SUCCESS)
 752                                         goto found_port;
 753                         }
 754 next_entry:
 755                         i = next_tuple(link, &tuple, &parse);
 756                 }
 757         }
 758
 759         /* Second pass: try to find an entry that isn't picky about
 760            its base address, then try to grab any standard serial port
 761            address, and finally try to get any free port. */
 762         i = first_tuple(link, &tuple, &parse);
 763         while (i != CS_NO_MORE_ITEMS) {
 764                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 765                         link->conf.ConfigIndex = cf->index;
 766                         for (j = 0; j < 5; j++) {
 767                                 link->io.BasePort1 = base[j];
 768                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 769                                 i = pcmcia_request_io(link, &link->io);
 770                                 if (i == CS_SUCCESS)
 771                                         goto found_port;
 772                         }
 773                 }
 774                 i = next_tuple(link, &tuple, &parse);
 775         }
 776
 777 found_port:
 778         if (i != CS_SUCCESS) {
 779                 BT_ERR("No usable port range found");
 780                 cs_error(link, RequestIO, i);
 781                 goto failed;
 782         }
 783
 784         i = pcmcia_request_irq(link, &link->irq);
 785         if (i != CS_SUCCESS) {
 786                 cs_error(link, RequestIRQ, i);
 787                 link->irq.AssignedIRQ = 0;
 788         }
 789
 790         i = pcmcia_request_configuration(link, &link->conf);
 791         if (i != CS_SUCCESS) {
 792                 cs_error(link, RequestConfiguration, i);
 793                 goto failed;
 794         }
 795
 796         if (bt3c_open(info) != 0)
 797                 goto failed;
 798
 799         strcpy(info->node.dev_name, info->hdev->name);
 800         link->dev_node = &info->node;
 801
 802         return 0;
 803
 804 cs_failed:
 805         cs_error(link, last_fn, last_ret);
 806
 807 failed:
 808         bt3c_release(link);
 809         return -ENODEV;
 810 }
 811
 812
 813 static void bt3c_release(struct pcmcia_device *link)
 814 {
 815         bt3c_info_t *info = link->priv;
 816
 817         bt3c_close(info);
 818
 819         pcmcia_disable_device(link);
 820 }
 821
 822
 823 static struct pcmcia_device_id bt3c_ids[] = {
 824         PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
 825         PCMCIA_DEVICE_NULL
 826 };
 827 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
 828
 829 static struct pcmcia_driver bt3c_driver = {
 830         .owner          = THIS_MODULE,
 831         .drv            = {
 832                 .name   = "bt3c_cs",
 833         },
 834         .probe          = bt3c_probe,
 835         .remove         = bt3c_detach,
 836         .id_table       = bt3c_ids,
 837 };
 838
 839 static int __init init_bt3c_cs(void)
 840 {
 841         return pcmcia_register_driver(&bt3c_driver);
 842 }
 843
 844
 845 static void __exit exit_bt3c_cs(void)
 846 {
 847         pcmcia_unregister_driver(&bt3c_driver);
 848 }
 849
 850 module_init(init_bt3c_cs);
 851 module_exit(exit_bt3c_cs);