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