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