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 static int btuart_event(event_t event, int priority, event_callback_args_t *args);
  90
  91 static dev_info_t dev_info = "btuart_cs";
  92
  93 static dev_link_t *btuart_attach(void);
  94 static void btuart_detach(dev_link_t *);
  95
  96 static dev_link_t *dev_list = NULL;
  97
  98
  99 /* Maximum baud rate */
 100 #define SPEED_MAX  115200
 101
 102 /* Default baud rate: 57600, 115200, 230400 or 460800 */
 103 #define DEFAULT_BAUD_RATE  115200
 104
 105
 106 /* Transmit states  */
 107 #define XMIT_SENDING    1
 108 #define XMIT_WAKEUP     2
 109 #define XMIT_WAITING    8
 110
 111 /* Receiver states */
 112 #define RECV_WAIT_PACKET_TYPE   0
 113 #define RECV_WAIT_EVENT_HEADER  1
 114 #define RECV_WAIT_ACL_HEADER    2
 115 #define RECV_WAIT_SCO_HEADER    3
 116 #define RECV_WAIT_DATA          4
 117
 118
 119
 120 /* ======================== Interrupt handling ======================== */
 121
 122
 123 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
 124 {
 125         int actual = 0;
 126
 127         /* Tx FIFO should be empty */
 128         if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
 129                 return 0;
 130
 131         /* Fill FIFO with current frame */
 132         while ((fifo_size-- > 0) && (actual < len)) {
 133                 /* Transmit next byte */
 134                 outb(buf[actual], iobase + UART_TX);
 135                 actual++;
 136         }
 137
 138         return actual;
 139 }
 140
 141
 142 static void btuart_write_wakeup(btuart_info_t *info)
 143 {
 144         if (!info) {
 145                 BT_ERR("Unknown device");
 146                 return;
 147         }
 148
 149         if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
 150                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 151                 return;
 152         }
 153
 154         do {
 155                 register unsigned int iobase = info->link.io.BasePort1;
 156                 register struct sk_buff *skb;
 157                 register int len;
 158
 159                 clear_bit(XMIT_WAKEUP, &(info->tx_state));
 160
 161                 if (!(info->link.state & DEV_PRESENT))
 162                         return;
 163
 164                 if (!(skb = skb_dequeue(&(info->txq))))
 165                         break;
 166
 167                 /* Send frame */
 168                 len = btuart_write(iobase, 16, skb->data, skb->len);
 169                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 170
 171                 if (len == skb->len) {
 172                         kfree_skb(skb);
 173                 } else {
 174                         skb_pull(skb, len);
 175                         skb_queue_head(&(info->txq), skb);
 176                 }
 177
 178                 info->hdev->stat.byte_tx += len;
 179
 180         } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 181
 182         clear_bit(XMIT_SENDING, &(info->tx_state));
 183 }
 184
 185
 186 static void btuart_receive(btuart_info_t *info)
 187 {
 188         unsigned int iobase;
 189         int boguscount = 0;
 190
 191         if (!info) {
 192                 BT_ERR("Unknown device");
 193                 return;
 194         }
 195
 196         iobase = info->link.io.BasePort1;
 197
 198         do {
 199                 info->hdev->stat.byte_rx++;
 200
 201                 /* Allocate packet */
 202                 if (info->rx_skb == NULL) {
 203                         info->rx_state = RECV_WAIT_PACKET_TYPE;
 204                         info->rx_count = 0;
 205                         if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
 206                                 BT_ERR("Can't allocate mem for new packet");
 207                                 return;
 208                         }
 209                 }
 210
 211                 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
 212
 213                         info->rx_skb->dev = (void *) info->hdev;
 214                         info->rx_skb->pkt_type = inb(iobase + UART_RX);
 215
 216                         switch (info->rx_skb->pkt_type) {
 217
 218                         case HCI_EVENT_PKT:
 219                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 220                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 221                                 break;
 222
 223                         case HCI_ACLDATA_PKT:
 224                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 225                                 info->rx_count = HCI_ACL_HDR_SIZE;
 226                                 break;
 227
 228                         case HCI_SCODATA_PKT:
 229                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 230                                 info->rx_count = HCI_SCO_HDR_SIZE;
 231                                 break;
 232
 233                         default:
 234                                 /* Unknown packet */
 235                                 BT_ERR("Unknown HCI packet with type 0x%02x received", info->rx_skb->pkt_type);
 236                                 info->hdev->stat.err_rx++;
 237                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
 238
 239                                 kfree_skb(info->rx_skb);
 240                                 info->rx_skb = NULL;
 241                                 break;
 242
 243                         }
 244
 245                 } else {
 246
 247                         *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
 248                         info->rx_count--;
 249
 250                         if (info->rx_count == 0) {
 251
 252                                 int dlen;
 253                                 struct hci_event_hdr *eh;
 254                                 struct hci_acl_hdr *ah;
 255                                 struct hci_sco_hdr *sh;
 256
 257
 258                                 switch (info->rx_state) {
 259
 260                                 case RECV_WAIT_EVENT_HEADER:
 261                                         eh = (struct hci_event_hdr *)(info->rx_skb->data);
 262                                         info->rx_state = RECV_WAIT_DATA;
 263                                         info->rx_count = eh->plen;
 264                                         break;
 265
 266                                 case RECV_WAIT_ACL_HEADER:
 267                                         ah = (struct hci_acl_hdr *)(info->rx_skb->data);
 268                                         dlen = __le16_to_cpu(ah->dlen);
 269                                         info->rx_state = RECV_WAIT_DATA;
 270                                         info->rx_count = dlen;
 271                                         break;
 272
 273                                 case RECV_WAIT_SCO_HEADER:
 274                                         sh = (struct hci_sco_hdr *)(info->rx_skb->data);
 275                                         info->rx_state = RECV_WAIT_DATA;
 276                                         info->rx_count = sh->dlen;
 277                                         break;
 278
 279                                 case RECV_WAIT_DATA:
 280                                         hci_recv_frame(info->rx_skb);
 281                                         info->rx_skb = NULL;
 282                                         break;
 283
 284                                 }
 285
 286                         }
 287
 288                 }
 289
 290                 /* Make sure we don't stay here too long */
 291                 if (boguscount++ > 16)
 292                         break;
 293
 294         } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 295 }
 296
 297
 298 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
 299 {
 300         btuart_info_t *info = dev_inst;
 301         unsigned int iobase;
 302         int boguscount = 0;
 303         int iir, lsr;
 304
 305         if (!info || !info->hdev) {
 306                 BT_ERR("Call of irq %d for unknown device", irq);
 307                 return IRQ_NONE;
 308         }
 309
 310         iobase = info->link.io.BasePort1;
 311
 312         spin_lock(&(info->lock));
 313
 314         iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 315         while (iir) {
 316
 317                 /* Clear interrupt */
 318                 lsr = inb(iobase + UART_LSR);
 319
 320                 switch (iir) {
 321                 case UART_IIR_RLSI:
 322                         BT_ERR("RLSI");
 323                         break;
 324                 case UART_IIR_RDI:
 325                         /* Receive interrupt */
 326                         btuart_receive(info);
 327                         break;
 328                 case UART_IIR_THRI:
 329                         if (lsr & UART_LSR_THRE) {
 330                                 /* Transmitter ready for data */
 331                                 btuart_write_wakeup(info);
 332                         }
 333                         break;
 334                 default:
 335                         BT_ERR("Unhandled IIR=%#x", iir);
 336                         break;
 337                 }
 338
 339                 /* Make sure we don't stay here too long */
 340                 if (boguscount++ > 100)
 341                         break;
 342
 343                 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 344
 345         }
 346
 347         spin_unlock(&(info->lock));
 348
 349         return IRQ_HANDLED;
 350 }
 351
 352
 353 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
 354 {
 355         unsigned long flags;
 356         unsigned int iobase;
 357         int fcr;                /* FIFO control reg */
 358         int lcr;                /* Line control reg */
 359         int divisor;
 360
 361         if (!info) {
 362                 BT_ERR("Unknown device");
 363                 return;
 364         }
 365
 366         iobase = info->link.io.BasePort1;
 367
 368         spin_lock_irqsave(&(info->lock), flags);
 369
 370         /* Turn off interrupts */
 371         outb(0, iobase + UART_IER);
 372
 373         divisor = SPEED_MAX / speed;
 374
 375         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 376
 377         /*
 378          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 379          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 380          * about this timeout since it will always be fast enough.
 381          */
 382
 383         if (speed < 38400)
 384                 fcr |= UART_FCR_TRIGGER_1;
 385         else
 386                 fcr |= UART_FCR_TRIGGER_14;
 387
 388         /* Bluetooth cards use 8N1 */
 389         lcr = UART_LCR_WLEN8;
 390
 391         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 392         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 393         outb(divisor >> 8, iobase + UART_DLM);
 394         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 395         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 396
 397         /* Turn on interrups */
 398         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 399
 400         spin_unlock_irqrestore(&(info->lock), flags);
 401 }
 402
 403
 404
 405 /* ======================== HCI interface ======================== */
 406
 407
 408 static int btuart_hci_flush(struct hci_dev *hdev)
 409 {
 410         btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
 411
 412         /* Drop TX queue */
 413         skb_queue_purge(&(info->txq));
 414
 415         return 0;
 416 }
 417
 418
 419 static int btuart_hci_open(struct hci_dev *hdev)
 420 {
 421         set_bit(HCI_RUNNING, &(hdev->flags));
 422
 423         return 0;
 424 }
 425
 426
 427 static int btuart_hci_close(struct hci_dev *hdev)
 428 {
 429         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 430                 return 0;
 431
 432         btuart_hci_flush(hdev);
 433
 434         return 0;
 435 }
 436
 437
 438 static int btuart_hci_send_frame(struct sk_buff *skb)
 439 {
 440         btuart_info_t *info;
 441         struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
 442
 443         if (!hdev) {
 444                 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
 445                 return -ENODEV;
 446         }
 447
 448         info = (btuart_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         btuart_write_wakeup(info);
 467
 468         return 0;
 469 }
 470
 471
 472 static void btuart_hci_destruct(struct hci_dev *hdev)
 473 {
 474 }
 475
 476
 477 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
 478 {
 479         return -ENOIOCTLCMD;
 480 }
 481
 482
 483
 484 /* ======================== Card services HCI interaction ======================== */
 485
 486
 487 static int btuart_open(btuart_info_t *info)
 488 {
 489         unsigned long flags;
 490         unsigned int iobase = info->link.io.BasePort1;
 491         struct hci_dev *hdev;
 492
 493         spin_lock_init(&(info->lock));
 494
 495         skb_queue_head_init(&(info->txq));
 496
 497         info->rx_state = RECV_WAIT_PACKET_TYPE;
 498         info->rx_count = 0;
 499         info->rx_skb = NULL;
 500
 501         /* Initialize HCI device */
 502         hdev = hci_alloc_dev();
 503         if (!hdev) {
 504                 BT_ERR("Can't allocate HCI device");
 505                 return -ENOMEM;
 506         }
 507
 508         info->hdev = hdev;
 509
 510         hdev->type = HCI_PCCARD;
 511         hdev->driver_data = info;
 512
 513         hdev->open     = btuart_hci_open;
 514         hdev->close    = btuart_hci_close;
 515         hdev->flush    = btuart_hci_flush;
 516         hdev->send     = btuart_hci_send_frame;
 517         hdev->destruct = btuart_hci_destruct;
 518         hdev->ioctl    = btuart_hci_ioctl;
 519
 520         hdev->owner = THIS_MODULE;
 521
 522         spin_lock_irqsave(&(info->lock), flags);
 523
 524         /* Reset UART */
 525         outb(0, iobase + UART_MCR);
 526
 527         /* Turn off interrupts */
 528         outb(0, iobase + UART_IER);
 529
 530         /* Initialize UART */
 531         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 532         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 533
 534         /* Turn on interrupts */
 535         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 536
 537         spin_unlock_irqrestore(&(info->lock), flags);
 538
 539         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 540
 541         /* Timeout before it is safe to send the first HCI packet */
 542         msleep(1000);
 543
 544         /* Register HCI device */
 545         if (hci_register_dev(hdev) < 0) {
 546                 BT_ERR("Can't register HCI device");
 547                 info->hdev = NULL;
 548                 hci_free_dev(hdev);
 549                 return -ENODEV;
 550         }
 551
 552         return 0;
 553 }
 554
 555
 556 static int btuart_close(btuart_info_t *info)
 557 {
 558         unsigned long flags;
 559         unsigned int iobase = info->link.io.BasePort1;
 560         struct hci_dev *hdev = info->hdev;
 561
 562         if (!hdev)
 563                 return -ENODEV;
 564
 565         btuart_hci_close(hdev);
 566
 567         spin_lock_irqsave(&(info->lock), flags);
 568
 569         /* Reset UART */
 570         outb(0, iobase + UART_MCR);
 571
 572         /* Turn off interrupts */
 573         outb(0, iobase + UART_IER);
 574
 575         spin_unlock_irqrestore(&(info->lock), flags);
 576
 577         if (hci_unregister_dev(hdev) < 0)
 578                 BT_ERR("Can't unregister HCI device %s", hdev->name);
 579
 580         hci_free_dev(hdev);
 581
 582         return 0;
 583 }
 584
 585 static dev_link_t *btuart_attach(void)
 586 {
 587         btuart_info_t *info;
 588         client_reg_t client_reg;
 589         dev_link_t *link;
 590         int ret;
 591
 592         /* Create new info device */
 593         info = kmalloc(sizeof(*info), GFP_KERNEL);
 594         if (!info)
 595                 return NULL;
 596         memset(info, 0, sizeof(*info));
 597
 598         link = &info->link;
 599         link->priv = info;
 600
 601         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 602         link->io.NumPorts1 = 8;
 603         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 604         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 605
 606         link->irq.Handler = btuart_interrupt;
 607         link->irq.Instance = info;
 608
 609         link->conf.Attributes = CONF_ENABLE_IRQ;
 610         link->conf.Vcc = 50;
 611         link->conf.IntType = INT_MEMORY_AND_IO;
 612
 613         /* Register with Card Services */
 614         link->next = dev_list;
 615         dev_list = link;
 616         client_reg.dev_info = &dev_info;
 617         client_reg.Version = 0x0210;
 618         client_reg.event_callback_args.client_data = link;
 619
 620         ret = pcmcia_register_client(&link->handle, &client_reg);
 621         if (ret != CS_SUCCESS) {
 622                 cs_error(link->handle, RegisterClient, ret);
 623                 btuart_detach(link);
 624                 return NULL;
 625         }
 626
 627         return link;
 628 }
 629
 630
 631 static void btuart_detach(dev_link_t *link)
 632 {
 633         btuart_info_t *info = link->priv;
 634         dev_link_t **linkp;
 635         int ret;
 636
 637         /* Locate device structure */
 638         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 639                 if (*linkp == link)
 640                         break;
 641
 642         if (*linkp == NULL)
 643                 return;
 644
 645         if (link->state & DEV_CONFIG)
 646                 btuart_release(link);
 647
 648         if (link->handle) {
 649                 ret = pcmcia_deregister_client(link->handle);
 650                 if (ret != CS_SUCCESS)
 651                         cs_error(link->handle, DeregisterClient, ret);
 652         }
 653
 654         /* Unlink device structure, free bits */
 655         *linkp = link->next;
 656
 657         kfree(info);
 658 }
 659
 660 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
 661 {
 662         int i;
 663
 664         i = pcmcia_get_tuple_data(handle, tuple);
 665         if (i != CS_SUCCESS)
 666                 return i;
 667
 668         return pcmcia_parse_tuple(handle, tuple, parse);
 669 }
 670
 671 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
 672 {
 673         if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
 674                 return CS_NO_MORE_ITEMS;
 675         return get_tuple(handle, tuple, parse);
 676 }
 677
 678 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
 679 {
 680         if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
 681                 return CS_NO_MORE_ITEMS;
 682         return get_tuple(handle, tuple, parse);
 683 }
 684
 685 static void btuart_config(dev_link_t *link)
 686 {
 687         static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 688         client_handle_t handle = link->handle;
 689         btuart_info_t *info = link->priv;
 690         tuple_t tuple;
 691         u_short buf[256];
 692         cisparse_t parse;
 693         cistpl_cftable_entry_t *cf = &parse.cftable_entry;
 694         config_info_t config;
 695         int i, j, try, last_ret, last_fn;
 696
 697         tuple.TupleData = (cisdata_t *)buf;
 698         tuple.TupleOffset = 0;
 699         tuple.TupleDataMax = 255;
 700         tuple.Attributes = 0;
 701
 702         /* Get configuration register information */
 703         tuple.DesiredTuple = CISTPL_CONFIG;
 704         last_ret = first_tuple(handle, &tuple, &parse);
 705         if (last_ret != CS_SUCCESS) {
 706                 last_fn = ParseTuple;
 707                 goto cs_failed;
 708         }
 709         link->conf.ConfigBase = parse.config.base;
 710         link->conf.Present = parse.config.rmask[0];
 711
 712         /* Configure card */
 713         link->state |= DEV_CONFIG;
 714         i = pcmcia_get_configuration_info(handle, &config);
 715         link->conf.Vcc = config.Vcc;
 716
 717         /* First pass: look for a config entry that looks normal. */
 718         tuple.TupleData = (cisdata_t *) buf;
 719         tuple.TupleOffset = 0;
 720         tuple.TupleDataMax = 255;
 721         tuple.Attributes = 0;
 722         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 723         /* Two tries: without IO aliases, then with aliases */
 724         for (try = 0; try < 2; try++) {
 725                 i = first_tuple(handle, &tuple, &parse);
 726                 while (i != CS_NO_MORE_ITEMS) {
 727                         if (i != CS_SUCCESS)
 728                                 goto next_entry;
 729                         if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
 730                                 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 731                         if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
 732                                 link->conf.ConfigIndex = cf->index;
 733                                 link->io.BasePort1 = cf->io.win[0].base;
 734                                 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
 735                                 i = pcmcia_request_io(link->handle, &link->io);
 736                                 if (i == CS_SUCCESS)
 737                                         goto found_port;
 738                         }
 739 next_entry:
 740                         i = next_tuple(handle, &tuple, &parse);
 741                 }
 742         }
 743
 744         /* Second pass: try to find an entry that isn't picky about
 745            its base address, then try to grab any standard serial port
 746            address, and finally try to get any free port. */
 747         i = first_tuple(handle, &tuple, &parse);
 748         while (i != CS_NO_MORE_ITEMS) {
 749                 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
 750                     && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
 751                         link->conf.ConfigIndex = cf->index;
 752                         for (j = 0; j < 5; j++) {
 753                                 link->io.BasePort1 = base[j];
 754                                 link->io.IOAddrLines = base[j] ? 16 : 3;
 755                                 i = pcmcia_request_io(link->handle, &link->io);
 756                                 if (i == CS_SUCCESS)
 757                                         goto found_port;
 758                         }
 759                 }
 760                 i = next_tuple(handle, &tuple, &parse);
 761         }
 762
 763 found_port:
 764         if (i != CS_SUCCESS) {
 765                 BT_ERR("No usable port range found");
 766                 cs_error(link->handle, RequestIO, i);
 767                 goto failed;
 768         }
 769
 770         i = pcmcia_request_irq(link->handle, &link->irq);
 771         if (i != CS_SUCCESS) {
 772                 cs_error(link->handle, RequestIRQ, i);
 773                 link->irq.AssignedIRQ = 0;
 774         }
 775
 776         i = pcmcia_request_configuration(link->handle, &link->conf);
 777         if (i != CS_SUCCESS) {
 778                 cs_error(link->handle, RequestConfiguration, i);
 779                 goto failed;
 780         }
 781
 782         if (btuart_open(info) != 0)
 783                 goto failed;
 784
 785         strcpy(info->node.dev_name, info->hdev->name);
 786         link->dev = &info->node;
 787         link->state &= ~DEV_CONFIG_PENDING;
 788
 789         return;
 790
 791 cs_failed:
 792         cs_error(link->handle, last_fn, last_ret);
 793
 794 failed:
 795         btuart_release(link);
 796 }
 797
 798
 799 static void btuart_release(dev_link_t *link)
 800 {
 801         btuart_info_t *info = link->priv;
 802
 803         if (link->state & DEV_PRESENT)
 804                 btuart_close(info);
 805
 806         link->dev = NULL;
 807
 808         pcmcia_release_configuration(link->handle);
 809         pcmcia_release_io(link->handle, &link->io);
 810         pcmcia_release_irq(link->handle, &link->irq);
 811
 812         link->state &= ~DEV_CONFIG;
 813 }
 814
 815
 816 static int btuart_event(event_t event, int priority, event_callback_args_t *args)
 817 {
 818         dev_link_t *link = args->client_data;
 819         btuart_info_t *info = link->priv;
 820
 821         switch (event) {
 822         case CS_EVENT_CARD_REMOVAL:
 823                 link->state &= ~DEV_PRESENT;
 824                 if (link->state & DEV_CONFIG) {
 825                         btuart_close(info);
 826                         btuart_release(link);
 827                 }
 828                 break;
 829         case CS_EVENT_CARD_INSERTION:
 830                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 831                 btuart_config(link);
 832                 break;
 833         case CS_EVENT_PM_SUSPEND:
 834                 link->state |= DEV_SUSPEND;
 835                 /* Fall through... */
 836         case CS_EVENT_RESET_PHYSICAL:
 837                 if (link->state & DEV_CONFIG)
 838                         pcmcia_release_configuration(link->handle);
 839                 break;
 840         case CS_EVENT_PM_RESUME:
 841                 link->state &= ~DEV_SUSPEND;
 842                 /* Fall through... */
 843         case CS_EVENT_CARD_RESET:
 844                 if (DEV_OK(link))
 845                         pcmcia_request_configuration(link->handle, &link->conf);
 846                 break;
 847         }
 848
 849         return 0;
 850 }
 851
 852 static struct pcmcia_device_id btuart_ids[] = {
 853         /* don't use this driver. Use serial_cs + hci_uart instead */
 854         PCMCIA_DEVICE_NULL
 855 };
 856 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 857
 858 static struct pcmcia_driver btuart_driver = {
 859         .owner          = THIS_MODULE,
 860         .drv            = {
 861                 .name   = "btuart_cs",
 862         },
 863         .attach         = btuart_attach,
 864         .event          = btuart_event,
 865         .detach         = btuart_detach,
 866         .id_table       = btuart_ids,
 867 };
 868
 869 static int __init init_btuart_cs(void)
 870 {
 871         return pcmcia_register_driver(&btuart_driver);
 872 }
 873
 874
 875 static void __exit exit_btuart_cs(void)
 876 {
 877         pcmcia_unregister_driver(&btuart_driver);
 878         BUG_ON(dev_list != NULL);
 879 }
 880
 881 module_init(init_btuart_cs);
 882 module_exit(exit_btuart_cs);