git.oblomov.eu Git - linux-2.6/blob - drivers/bluetooth/btuart_cs.c

   1 /*
   2  *
   3  *  Driver for Bluetooth PCMCIA cards with HCI UART interface
   4  *
   5  *  Copyright (C) 2001-2002  Marcel Holtmann <marcel@holtmann.org>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation;
  11  *
  12  *  Software distributed under the License is distributed on an "AS
  13  *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14  *  implied. See the License for the specific language governing
  15  *  rights and limitations under the License.
  16  *
  17  *  The initial developer of the original code is David A. Hinds
  18  *  <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  19  *  are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  20  *
  21  */
  22
  23 #include <linux/config.h>
  24 #include <linux/module.h>
  25
  26 #include <linux/kernel.h>
  27 #include <linux/init.h>
  28 #include <linux/slab.h>
  29 #include <linux/types.h>
  30 #include <linux/sched.h>
  31 #include <linux/delay.h>
  32 #include <linux/errno.h>
  33 #include <linux/ptrace.h>
  34 #include <linux/ioport.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/moduleparam.h>
  37
  38 #include <linux/skbuff.h>
  39 #include <linux/string.h>
  40 #include <linux/serial.h>
  41 #include <linux/serial_reg.h>
  42 #include <linux/bitops.h>
  43 #include <asm/system.h>
  44 #include <asm/io.h>
  45
  46 #include <pcmcia/cs_types.h>
  47 #include <pcmcia/cs.h>
  48 #include <pcmcia/cistpl.h>
  49 #include <pcmcia/ciscode.h>
  50 #include <pcmcia/ds.h>
  51 #include <pcmcia/cisreg.h>
  52
  53 #include <net/bluetooth/bluetooth.h>
  54 #include <net/bluetooth/hci_core.h>
  55
  56
  57
  58 /* ======================== Module parameters ======================== */
  59
  60
  61 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  62 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
  63 MODULE_LICENSE("GPL");
  64
  65
  66
  67 /* ======================== Local structures ======================== */
  68
  69
  70 typedef struct btuart_info_t {
  71         dev_link_t link;
  72         dev_node_t node;
  73
  74         struct hci_dev *hdev;
  75
  76         spinlock_t lock;        /* For serializing operations */
  77
  78         struct sk_buff_head txq;
  79         unsigned long tx_state;
  80
  81         unsigned long rx_state;
  82         unsigned long rx_count;
  83         struct sk_buff *rx_skb;
  84 } btuart_info_t;
  85
  86
  87 static void btuart_config(dev_link_t *link);
  88 static void btuart_release(dev_link_t *link);
  89
  90 static void btuart_detach(struct pcmcia_device *p_dev);
  91
  92
  93 /* Maximum baud rate */
  94 #define SPEED_MAX  115200
  95
  96 /* Default baud rate: 57600, 115200, 230400 or 460800 */
  97 #define DEFAULT_BAUD_RATE  115200
  98
  99
 100 /* Transmit states  */
 101 #define XMIT_SENDING    1
 102 #define XMIT_WAKEUP     2
 103 #define XMIT_WAITING    8
 104
 105 /* Receiver states */
 106 #define RECV_WAIT_PACKET_TYPE   0
 107 #define RECV_WAIT_EVENT_HEADER  1
 108 #define RECV_WAIT_ACL_HEADER    2
 109 #define RECV_WAIT_SCO_HEADER    3
 110 #define RECV_WAIT_DATA          4
 111
 112
 113
 114 /* ======================== Interrupt handling ======================== */
 115
 116
 117 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 118 {
 119         int actual = 0;
 120
 121         /* Tx FIFO should be empty */
 122         if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
 123                 return 0;
 124
 125         /* Fill FIFO with current frame */
 126         while ((fifo_size-- > 0) && (actual < len)) {
 127                 /* Transmit next byte */
 128                 outb(buf[actual], iobase + UART_TX);
 129                 actual++;
 130         }
 131
 132         return actual;
 133 }
 134
 135
 136 static void btuart_write_wakeup(btuart_info_t *info)
 137 {
 138         if (!info) {
 139                 BT_ERR("Unknown device");
 140                 return;
 141         }
 142
 143         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 144                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 145                 return;
 146         }
 147
 148         do {
 149                 register unsigned int iobase = info->link.io.BasePort1;
 150                 register struct sk_buff *skb;
 151                 register int len;
 152
 153                 clear_bit(XMIT_WAKEUP, &(info->tx_state));
 154
 155                 if (!(info->link.state & DEV_PRESENT))
 156                         return;
 157
 158                 if (!(skb = skb_dequeue(&(info->txq))))
 159                         break;
 160
 161                 /* Send frame */
 162                 len = btuart_write(iobase, 16, skb->data, skb->len);
 163                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 164
 165                 if (len == skb->len) {
 166                         kfree_skb(skb);
 167                 } else {
 168                         skb_pull(skb, len);
 169                         skb_queue_head(&(info->txq), skb);
 170                 }
 171
 172                 info->hdev->stat.byte_tx += len;
 173
 174         } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 175
 176         clear_bit(XMIT_SENDING, &(info->tx_state));
 177 }
 178
 179
 180 static void btuart_receive(btuart_info_t *info)
 181 {
 182         unsigned int iobase;
 183         int boguscount = 0;
 184
 185         if (!info) {
 186                 BT_ERR("Unknown device");
 187                 return;
 188         }
 189
 190         iobase = info->link.io.BasePort1;
 191
 192         do {
 193                 info->hdev->stat.byte_rx++;
 194
 195                 /* Allocate packet */
 196                 if (info->rx_skb == NULL) {
 197                         info->rx_state = RECV_WAIT_PACKET_TYPE;
 198                         info->rx_count = 0;
 199                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 200                                 BT_ERR("Can't allocate mem for new packet");
 201                                 return;
 202                         }
 203                 }
 204
 205                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 206
 207                         info->rx_skb->dev = (void *) info->hdev;
 208                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
 209
 210                         switch (bt_cb(info->rx_skb)->pkt_type) {
 211
 212                         case HCI_EVENT_PKT:
 213                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 214                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 215                                 break;
 216
 217                         case HCI_ACLDATA_PKT:
 218                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 219                                 info->rx_count = HCI_ACL_HDR_SIZE;
 220                                 break;
 221
 222                         case HCI_SCODATA_PKT:
 223                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 224                                 info->rx_count = HCI_SCO_HDR_SIZE;
 225                                 break;
 226
 227                         default:
 228                                 /* Unknown packet */
 229                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 230                                 info->hdev->stat.err_rx++;
 231                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
 232
 233                                 kfree_skb(info->rx_skb);
 234                                 info->rx_skb = NULL;
 235                                 break;
 236
 237                         }
 238
 239                 } else {
 240
 241                         *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
 242                         info->rx_count--;
 243
 244                         if (info->rx_count == 0) {
 245
 246                                 int dlen;
 247                                 struct hci_event_hdr *eh;
 248                                 struct hci_acl_hdr *ah;
 249                                 struct hci_sco_hdr *sh;
 250
 251
 252                                 switch (info->rx_state) {
 253
 254                                 case RECV_WAIT_EVENT_HEADER:
 255                                         eh = (struct hci_event_hdr *)(info->rx_skb->data);
 256                                         info->rx_state = RECV_WAIT_DATA;
 257                                         info->rx_count = eh->plen;
 258                                         break;
 259
 260                                 case RECV_WAIT_ACL_HEADER:
 261                                         ah = (struct hci_acl_hdr *)(info->rx_skb->data);
 262                                         dlen = __le16_to_cpu(ah->dlen);
 263                                         info->rx_state = RECV_WAIT_DATA;
 264                                         info->rx_count = dlen;
 265                                         break;
 266
 267                                 case RECV_WAIT_SCO_HEADER:
 268                                         sh = (struct hci_sco_hdr *)(info->rx_skb->data);
 269                                         info->rx_state = RECV_WAIT_DATA;
 270                                         info->rx_count = sh->dlen;
 271                                         break;
 272
 273                                 case RECV_WAIT_DATA:
 274                                         hci_recv_frame(info->rx_skb);
 275                                         info->rx_skb = NULL;
 276                                         break;
 277
 278                                 }
 279
 280                         }
 281
 282                 }
 283
 284                 /* Make sure we don't stay here too long */
 285                 if (boguscount++ > 16)
 286                         break;
 287
 288         } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 289 }
 290
 291
 292 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
 293 {
 294         btuart_info_t *info = dev_inst;
 295         unsigned int iobase;
 296         int boguscount = 0;
 297         int iir, lsr;
 298
 299         if (!info || !info->hdev) {
 300                 BT_ERR("Call of irq %d for unknown device", irq);
 301                 return IRQ_NONE;
 302         }
 303
 304         iobase = info->link.io.BasePort1;
 305
 306         spin_lock(&(info->lock));
 307
 308         iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 309         while (iir) {
 310
 311                 /* Clear interrupt */
 312                 lsr = inb(iobase + UART_LSR);
 313
 314                 switch (iir) {
 315                 case UART_IIR_RLSI:
 316                         BT_ERR("RLSI");
 317                         break;
 318                 case UART_IIR_RDI:
 319                         /* Receive interrupt */
 320                         btuart_receive(info);
 321                         break;
 322                 case UART_IIR_THRI:
 323                         if (lsr & UART_LSR_THRE) {
 324                                 /* Transmitter ready for data */
 325                                 btuart_write_wakeup(info);
 326                         }
 327                         break;
 328                 default:
 329                         BT_ERR("Unhandled IIR=%#x", iir);
 330                         break;
 331                 }
 332
 333                 /* Make sure we don't stay here too long */
 334                 if (boguscount++ > 100)
 335                         break;
 336
 337                 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 338
 339         }
 340
 341         spin_unlock(&(info->lock));
 342
 343         return IRQ_HANDLED;
 344 }
 345
 346
 347 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
 348 {
 349         unsigned long flags;
 350         unsigned int iobase;
 351         int fcr;                /* FIFO control reg */
 352         int lcr;                /* Line control reg */
 353         int divisor;
 354
 355         if (!info) {
 356                 BT_ERR("Unknown device");
 357                 return;
 358         }
 359
 360         iobase = info->link.io.BasePort1;
 361
 362         spin_lock_irqsave(&(info->lock), flags);
 363
 364         /* Turn off interrupts */
 365         outb(0, iobase + UART_IER);
 366
 367         divisor = SPEED_MAX / speed;
 368
 369         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 370
 371         /*
 372          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 373          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 374          * about this timeout since it will always be fast enough.
 375          */
 376
 377         if (speed < 38400)
 378                 fcr |= UART_FCR_TRIGGER_1;
 379         else
 380                 fcr |= UART_FCR_TRIGGER_14;
 381
 382         /* Bluetooth cards use 8N1 */
 383         lcr = UART_LCR_WLEN8;
 384
 385         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 386         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 387         outb(divisor >> 8, iobase + UART_DLM);
 388         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 389         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 390
 391         /* Turn on interrups */
 392         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 393
 394         spin_unlock_irqrestore(&(info->lock), flags);
 395 }
 396
 397
 398
 399 /* ======================== HCI interface ======================== */
 400
 401
 402 static int btuart_hci_flush(struct hci_dev *hdev)
 403 {
 404         btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
 405
 406         /* Drop TX queue */
 407         skb_queue_purge(&(info->txq));
 408
 409         return 0;
 410 }
 411
 412
 413 static int btuart_hci_open(struct hci_dev *hdev)
 414 {
 415         set_bit(HCI_RUNNING, &(hdev->flags));
 416
 417         return 0;
 418 }
 419
 420
 421 static int btuart_hci_close(struct hci_dev *hdev)
 422 {
 423         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 424                 return 0;
 425
 426         btuart_hci_flush(hdev);
 427
 428         return 0;
 429 }
 430
 431
 432 static int btuart_hci_send_frame(struct sk_buff *skb)
 433 {
 434         btuart_info_t *info;
 435         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 436
 437         if (!hdev) {
 438                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 439                 return -ENODEV;
 440         }
 441
 442         info = (btuart_info_t *)(hdev->driver_data);
 443
 444         switch (bt_cb(skb)->pkt_type) {
 445         case HCI_COMMAND_PKT:
 446                 hdev->stat.cmd_tx++;
 447                 break;
 448         case HCI_ACLDATA_PKT:
 449                 hdev->stat.acl_tx++;
 450                 break;
 451         case HCI_SCODATA_PKT:
 452                 hdev->stat.sco_tx++;
 453                 break;
 454         };
 455
 456         /* Prepend skb with frame type */
 457         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 458         skb_queue_tail(&(info->txq), skb);
 459
 460         btuart_write_wakeup(info);
 461
 462         return 0;
 463 }
 464
 465
 466 static void btuart_hci_destruct(struct hci_dev *hdev)
 467 {
 468 }
 469
 470
 471 static int btuart_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 int btuart_open(btuart_info_t *info)
 482 {
 483         unsigned long flags;
 484         unsigned int iobase = info->link.io.BasePort1;
 485         struct hci_dev *hdev;
 486
 487         spin_lock_init(&(info->lock));
 488
 489         skb_queue_head_init(&(info->txq));
 490
 491         info->rx_state = RECV_WAIT_PACKET_TYPE;
 492         info->rx_count = 0;
 493         info->rx_skb = NULL;
 494
 495         /* Initialize HCI device */
 496         hdev = hci_alloc_dev();
 497         if (!hdev) {
 498                 BT_ERR("Can't allocate HCI device");
 499                 return -ENOMEM;
 500         }
 501
 502         info->hdev = hdev;
 503
 504         hdev->type = HCI_PCCARD;
 505         hdev->driver_data = info;
 506
 507         hdev->open     = btuart_hci_open;
 508         hdev->close    = btuart_hci_close;
 509         hdev->flush    = btuart_hci_flush;
 510         hdev->send     = btuart_hci_send_frame;
 511         hdev->destruct = btuart_hci_destruct;
 512         hdev->ioctl    = btuart_hci_ioctl;
 513
 514         hdev->owner = THIS_MODULE;
 515
 516         spin_lock_irqsave(&(info->lock), flags);
 517
 518         /* Reset UART */
 519         outb(0, iobase + UART_MCR);
 520
 521         /* Turn off interrupts */
 522         outb(0, iobase + UART_IER);
 523
 524         /* Initialize UART */
 525         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 526         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 527
 528         /* Turn on interrupts */
 529         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 530
 531         spin_unlock_irqrestore(&(info->lock), flags);
 532
 533         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 534
 535         /* Timeout before it is safe to send the first HCI packet */
 536         msleep(1000);
 537
 538         /* Register HCI device */
 539         if (hci_register_dev(hdev) < 0) {
 540                 BT_ERR("Can't register HCI device");
 541                 info->hdev = NULL;
 542                 hci_free_dev(hdev);
 543                 return -ENODEV;
 544         }
 545
 546         return 0;
 547 }
 548
 549
 550 static int btuart_close(btuart_info_t *info)
 551 {
 552         unsigned long flags;
 553         unsigned int iobase = info->link.io.BasePort1;
 554         struct hci_dev *hdev = info->hdev;
 555
 556         if (!hdev)
 557                 return -ENODEV;
 558
 559         btuart_hci_close(hdev);
 560
 561         spin_lock_irqsave(&(info->lock), flags);
 562
 563         /* Reset UART */
 564         outb(0, iobase + UART_MCR);
 565
 566         /* Turn off interrupts */
 567         outb(0, iobase + UART_IER);
 568
 569         spin_unlock_irqrestore(&(info->lock), flags);
 570
 571         if (hci_unregister_dev(hdev) < 0)
 572                 BT_ERR("Can't unregister HCI device %s", hdev->name);
 573
 574         hci_free_dev(hdev);
 575
 576         return 0;
 577 }
 578
 579 static int btuart_attach(struct pcmcia_device *p_dev)
 580 {
 581         btuart_info_t *info;
 582         dev_link_t *link;
 583
 584         /* Create new info device */
 585         info = kzalloc(sizeof(*info), GFP_KERNEL);
 586         if (!info)
 587                 return -ENOMEM;
 588
 589         link = &info->link;
 590         link->priv = info;
 591
 592         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 593         link->io.NumPorts1 = 8;
 594         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 595         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 596
 597         link->irq.Handler = btuart_interrupt;
 598         link->irq.Instance = info;
 599
 600         link->conf.Attributes = CONF_ENABLE_IRQ;
 601         link->conf.Vcc = 50;
 602         link->conf.IntType = INT_MEMORY_AND_IO;
 603
 604         link->handle = p_dev;
 605         p_dev->instance = link;
 606
 607         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 608         btuart_config(link);
 609
 610         return 0;
 611 }
 612
 613
 614 static void btuart_detach(struct pcmcia_device *p_dev)
 615 {
 616         dev_link_t *link = dev_to_instance(p_dev);
 617         btuart_info_t *info = link->priv;
 618
 619         if (link->state & DEV_CONFIG)
 620                 btuart_release(link);
 621
 622         kfree(info);
 623 }
 624
 625 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
 626 {
 627         int i;
 628
 629         i = pcmcia_get_tuple_data(handle, tuple);
 630         if (i != CS_SUCCESS)
 631                 return i;
 632
 633         return pcmcia_parse_tuple(handle, tuple, parse);
 634 }
 635
 636 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
 637 {
 638         if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
 639                 return CS_NO_MORE_ITEMS;
 640         return get_tuple(handle, tuple, parse);
 641 }
 642
 643 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
 644 {
 645         if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
 646                 return CS_NO_MORE_ITEMS;
 647         return get_tuple(handle, tuple, parse);
 648 }
 649
 650 static void btuart_config(dev_link_t *link)
 651 {
 652         static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 653         client_handle_t handle = link->handle;
 654         btuart_info_t *info = link->priv;
 655         tuple_t tuple;
 656         u_short buf[256];
 657         cisparse_t parse;
 658         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 659         config_info_t config;
 660         int i, j, try, last_ret, last_fn;
 661
 662         tuple.TupleData = (cisdata_t *)buf;
 663         tuple.TupleOffset = 0;
 664         tuple.TupleDataMax = 255;
 665         tuple.Attributes = 0;
 666
 667         /* Get configuration register information */
 668         tuple.DesiredTuple = CISTPL_CONFIG;
 669         last_ret = first_tuple(handle, &tuple, &parse);
 670         if (last_ret != CS_SUCCESS) {
 671                 last_fn = ParseTuple;
 672                 goto cs_failed;
 673         }
 674         link->conf.ConfigBase = parse.config.base;
 675         link->conf.Present = parse.config.rmask[0];
 676
 677         /* Configure card */
 678         link->state |= DEV_CONFIG;
 679         i = pcmcia_get_configuration_info(handle, &config);
 680         link->conf.Vcc = config.Vcc;
 681
 682         /* First pass: look for a config entry that looks normal. */
 683         tuple.TupleData = (cisdata_t *) buf;
 684         tuple.TupleOffset = 0;
 685         tuple.TupleDataMax = 255;
 686         tuple.Attributes = 0;
 687         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 688         /* Two tries: without IO aliases, then with aliases */
 689         for (try = 0; try < 2; try++) {
 690                 i = first_tuple(handle, &tuple, &parse);
 691                 while (i != CS_NO_MORE_ITEMS) {
 692                         if (i != CS_SUCCESS)
 693                                 goto next_entry;
 694                         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 695                                 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 696                         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
 697                                 link->conf.ConfigIndex = cf->index;
 698                                 link->io.BasePort1 = cf->io.win[0].base;
 699                                 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 700                                 i = pcmcia_request_io(link->handle, &link->io);
 701                                 if (i == CS_SUCCESS)
 702                                         goto found_port;
 703                         }
 704 next_entry:
 705                         i = next_tuple(handle, &tuple, &parse);
 706                 }
 707         }
 708
 709         /* Second pass: try to find an entry that isn't picky about
 710            its base address, then try to grab any standard serial port
 711            address, and finally try to get any free port. */
 712         i = first_tuple(handle, &tuple, &parse);
 713         while (i != CS_NO_MORE_ITEMS) {
 714                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
 715                     && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 716                         link->conf.ConfigIndex = cf->index;
 717                         for (j = 0; j < 5; j++) {
 718                                 link->io.BasePort1 = base[j];
 719                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 720                                 i = pcmcia_request_io(link->handle, &link->io);
 721                                 if (i == CS_SUCCESS)
 722                                         goto found_port;
 723                         }
 724                 }
 725                 i = next_tuple(handle, &tuple, &parse);
 726         }
 727
 728 found_port:
 729         if (i != CS_SUCCESS) {
 730                 BT_ERR("No usable port range found");
 731                 cs_error(link->handle, RequestIO, i);
 732                 goto failed;
 733         }
 734
 735         i = pcmcia_request_irq(link->handle, &link->irq);
 736         if (i != CS_SUCCESS) {
 737                 cs_error(link->handle, RequestIRQ, i);
 738                 link->irq.AssignedIRQ = 0;
 739         }
 740
 741         i = pcmcia_request_configuration(link->handle, &link->conf);
 742         if (i != CS_SUCCESS) {
 743                 cs_error(link->handle, RequestConfiguration, i);
 744                 goto failed;
 745         }
 746
 747         if (btuart_open(info) != 0)
 748                 goto failed;
 749
 750         strcpy(info->node.dev_name, info->hdev->name);
 751         link->dev = &info->node;
 752         link->state &= ~DEV_CONFIG_PENDING;
 753
 754         return;
 755
 756 cs_failed:
 757         cs_error(link->handle, last_fn, last_ret);
 758
 759 failed:
 760         btuart_release(link);
 761 }
 762
 763
 764 static void btuart_release(dev_link_t *link)
 765 {
 766         btuart_info_t *info = link->priv;
 767
 768         if (link->state & DEV_PRESENT)
 769                 btuart_close(info);
 770
 771         link->dev = NULL;
 772
 773         pcmcia_release_configuration(link->handle);
 774         pcmcia_release_io(link->handle, &link->io);
 775         pcmcia_release_irq(link->handle, &link->irq);
 776
 777         link->state &= ~DEV_CONFIG;
 778 }
 779
 780 static int btuart_suspend(struct pcmcia_device *dev)
 781 {
 782         dev_link_t *link = dev_to_instance(dev);
 783
 784         link->state |= DEV_SUSPEND;
 785         if (link->state & DEV_CONFIG)
 786                 pcmcia_release_configuration(link->handle);
 787
 788         return 0;
 789 }
 790
 791 static int btuart_resume(struct pcmcia_device *dev)
 792 {
 793         dev_link_t *link = dev_to_instance(dev);
 794
 795         link->state &= ~DEV_SUSPEND;
 796         if (DEV_OK(link))
 797                 pcmcia_request_configuration(link->handle, &link->conf);
 798
 799         return 0;
 800 }
 801
 802
 803 static struct pcmcia_device_id btuart_ids[] = {
 804         /* don't use this driver. Use serial_cs + hci_uart instead */
 805         PCMCIA_DEVICE_NULL
 806 };
 807 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 808
 809 static struct pcmcia_driver btuart_driver = {
 810         .owner          = THIS_MODULE,
 811         .drv            = {
 812                 .name   = "btuart_cs",
 813         },
 814         .probe          = btuart_attach,
 815         .remove         = btuart_detach,
 816         .id_table       = btuart_ids,
 817         .suspend        = btuart_suspend,
 818         .resume         = btuart_resume,
 819 };
 820
 821 static int __init init_btuart_cs(void)
 822 {
 823         return pcmcia_register_driver(&btuart_driver);
 824 }
 825
 826
 827 static void __exit exit_btuart_cs(void)
 828 {
 829         pcmcia_unregister_driver(&btuart_driver);
 830 }
 831
 832 module_init(init_btuart_cs);
 833 module_exit(exit_btuart_cs);