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