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