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