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