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 int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count) 478 { 479 char *ptr = (char *) firmware; 480 char b[9]; 481 unsigned int iobase, size, addr, fcs, tmp; 482 int i, err = 0; 483 484 iobase = info->link.io.BasePort1; 485 486 /* Reset */ 487 bt3c_io_write(iobase, 0x8040, 0x0404); 488 bt3c_io_write(iobase, 0x8040, 0x0400); 489 490 udelay(1); 491 492 bt3c_io_write(iobase, 0x8040, 0x0404); 493 494 udelay(17); 495 496 /* Load */ 497 while (count) { 498 if (ptr[0] != 'S') { 499 BT_ERR("Bad address in firmware"); 500 err = -EFAULT; 501 goto error; 502 } 503 504 memset(b, 0, sizeof(b)); 505 memcpy(b, ptr + 2, 2); 506 size = simple_strtol(b, NULL, 16); 507 508 memset(b, 0, sizeof(b)); 509 memcpy(b, ptr + 4, 8); 510 addr = simple_strtol(b, NULL, 16); 511 512 memset(b, 0, sizeof(b)); 513 memcpy(b, ptr + (size * 2) + 2, 2); 514 fcs = simple_strtol(b, NULL, 16); 515 516 memset(b, 0, sizeof(b)); 517 for (tmp = 0, i = 0; i < size; i++) { 518 memcpy(b, ptr + (i * 2) + 2, 2); 519 tmp += simple_strtol(b, NULL, 16); 520 } 521 522 if (((tmp + fcs) & 0xff) != 0xff) { 523 BT_ERR("Checksum error in firmware"); 524 err = -EILSEQ; 525 goto error; 526 } 527 528 if (ptr[1] == '3') { 529 bt3c_address(iobase, addr); 530 531 memset(b, 0, sizeof(b)); 532 for (i = 0; i < (size - 4) / 2; i++) { 533 memcpy(b, ptr + (i * 4) + 12, 4); 534 tmp = simple_strtol(b, NULL, 16); 535 bt3c_put(iobase, tmp); 536 } 537 } 538 539 ptr += (size * 2) + 6; 540 count -= (size * 2) + 6; 541 } 542 543 udelay(17); 544 545 /* Boot */ 546 bt3c_address(iobase, 0x3000); 547 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL); 548 549 error: 550 udelay(17); 551 552 /* Clear */ 553 bt3c_io_write(iobase, 0x7006, 0x0000); 554 bt3c_io_write(iobase, 0x7005, 0x0000); 555 bt3c_io_write(iobase, 0x7001, 0x0000); 556 557 return err; 558 } 559 560 561 static int bt3c_open(bt3c_info_t *info) 562 { 563 const struct firmware *firmware; 564 struct hci_dev *hdev; 565 client_handle_t handle; 566 int err; 567 568 spin_lock_init(&(info->lock)); 569 570 skb_queue_head_init(&(info->txq)); 571 572 info->rx_state = RECV_WAIT_PACKET_TYPE; 573 info->rx_count = 0; 574 info->rx_skb = NULL; 575 576 /* Initialize HCI device */ 577 hdev = hci_alloc_dev(); 578 if (!hdev) { 579 BT_ERR("Can't allocate HCI device"); 580 return -ENOMEM; 581 } 582 583 info->hdev = hdev; 584 585 hdev->type = HCI_PCCARD; 586 hdev->driver_data = info; 587 588 hdev->open = bt3c_hci_open; 589 hdev->close = bt3c_hci_close; 590 hdev->flush = bt3c_hci_flush; 591 hdev->send = bt3c_hci_send_frame; 592 hdev->destruct = bt3c_hci_destruct; 593 hdev->ioctl = bt3c_hci_ioctl; 594 595 hdev->owner = THIS_MODULE; 596 597 handle = info->link.handle; 598 599 /* Load firmware */ 600 err = request_firmware(&firmware, "BT3CPCC.bin", &handle_to_dev(handle)); 601 if (err < 0) { 602 BT_ERR("Firmware request failed"); 603 goto error; 604 } 605 606 err = bt3c_load_firmware(info, firmware->data, firmware->size); 607 608 release_firmware(firmware); 609 610 if (err < 0) { 611 BT_ERR("Firmware loading failed"); 612 goto error; 613 } 614 615 /* Timeout before it is safe to send the first HCI packet */ 616 msleep(1000); 617 618 /* Register HCI device */ 619 err = hci_register_dev(hdev); 620 if (err < 0) { 621 BT_ERR("Can't register HCI device"); 622 goto error; 623 } 624 625 return 0; 626 627 error: 628 info->hdev = NULL; 629 hci_free_dev(hdev); 630 return err; 631 } 632 633 634 static int bt3c_close(bt3c_info_t *info) 635 { 636 struct hci_dev *hdev = info->hdev; 637 638 if (!hdev) 639 return -ENODEV; 640 641 bt3c_hci_close(hdev); 642 643 if (hci_unregister_dev(hdev) < 0) 644 BT_ERR("Can't unregister HCI device %s", hdev->name); 645 646 hci_free_dev(hdev); 647 648 return 0; 649 } 650 651 static int bt3c_attach(struct pcmcia_device *p_dev) 652 { 653 bt3c_info_t *info; 654 dev_link_t *link; 655 656 /* Create new info device */ 657 info = kzalloc(sizeof(*info), GFP_KERNEL); 658 if (!info) 659 return -ENOMEM; 660 661 link = &info->link; 662 link->priv = info; 663 664 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 665 link->io.NumPorts1 = 8; 666 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; 667 link->irq.IRQInfo1 = IRQ_LEVEL_ID; 668 669 link->irq.Handler = bt3c_interrupt; 670 link->irq.Instance = info; 671 672 link->conf.Attributes = CONF_ENABLE_IRQ; 673 link->conf.Vcc = 50; 674 link->conf.IntType = INT_MEMORY_AND_IO; 675 676 link->handle = p_dev; 677 p_dev->instance = link; 678 679 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; 680 bt3c_config(link); 681 682 return 0; 683 } 684 685 686 static void bt3c_detach(struct pcmcia_device *p_dev) 687 { 688 dev_link_t *link = dev_to_instance(p_dev); 689 bt3c_info_t *info = link->priv; 690 691 if (link->state & DEV_CONFIG) 692 bt3c_release(link); 693 694 kfree(info); 695 } 696 697 static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse) 698 { 699 int i; 700 701 i = pcmcia_get_tuple_data(handle, tuple); 702 if (i != CS_SUCCESS) 703 return i; 704 705 return pcmcia_parse_tuple(handle, tuple, parse); 706 } 707 708 static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse) 709 { 710 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS) 711 return CS_NO_MORE_ITEMS; 712 return get_tuple(handle, tuple, parse); 713 } 714 715 static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse) 716 { 717 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS) 718 return CS_NO_MORE_ITEMS; 719 return get_tuple(handle, tuple, parse); 720 } 721 722 static void bt3c_config(dev_link_t *link) 723 { 724 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 }; 725 client_handle_t handle = link->handle; 726 bt3c_info_t *info = link->priv; 727 tuple_t tuple; 728 u_short buf[256]; 729 cisparse_t parse; 730 cistpl_cftable_entry_t *cf = &parse.cftable_entry; 731 config_info_t config; 732 int i, j, try, last_ret, last_fn; 733 734 tuple.TupleData = (cisdata_t *)buf; 735 tuple.TupleOffset = 0; 736 tuple.TupleDataMax = 255; 737 tuple.Attributes = 0; 738 739 /* Get configuration register information */ 740 tuple.DesiredTuple = CISTPL_CONFIG; 741 last_ret = first_tuple(handle, &tuple, &parse); 742 if (last_ret != CS_SUCCESS) { 743 last_fn = ParseTuple; 744 goto cs_failed; 745 } 746 link->conf.ConfigBase = parse.config.base; 747 link->conf.Present = parse.config.rmask[0]; 748 749 /* Configure card */ 750 link->state |= DEV_CONFIG; 751 i = pcmcia_get_configuration_info(handle, &config); 752 link->conf.Vcc = config.Vcc; 753 754 /* First pass: look for a config entry that looks normal. */ 755 tuple.TupleData = (cisdata_t *)buf; 756 tuple.TupleOffset = 0; 757 tuple.TupleDataMax = 255; 758 tuple.Attributes = 0; 759 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 760 /* Two tries: without IO aliases, then with aliases */ 761 for (try = 0; try < 2; try++) { 762 i = first_tuple(handle, &tuple, &parse); 763 while (i != CS_NO_MORE_ITEMS) { 764 if (i != CS_SUCCESS) 765 goto next_entry; 766 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM)) 767 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000; 768 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) { 769 link->conf.ConfigIndex = cf->index; 770 link->io.BasePort1 = cf->io.win[0].base; 771 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK; 772 i = pcmcia_request_io(link->handle, &link->io); 773 if (i == CS_SUCCESS) 774 goto found_port; 775 } 776 next_entry: 777 i = next_tuple(handle, &tuple, &parse); 778 } 779 } 780 781 /* Second pass: try to find an entry that isn't picky about 782 its base address, then try to grab any standard serial port 783 address, and finally try to get any free port. */ 784 i = first_tuple(handle, &tuple, &parse); 785 while (i != CS_NO_MORE_ITEMS) { 786 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) { 787 link->conf.ConfigIndex = cf->index; 788 for (j = 0; j < 5; j++) { 789 link->io.BasePort1 = base[j]; 790 link->io.IOAddrLines = base[j] ? 16 : 3; 791 i = pcmcia_request_io(link->handle, &link->io); 792 if (i == CS_SUCCESS) 793 goto found_port; 794 } 795 } 796 i = next_tuple(handle, &tuple, &parse); 797 } 798 799 found_port: 800 if (i != CS_SUCCESS) { 801 BT_ERR("No usable port range found"); 802 cs_error(link->handle, RequestIO, i); 803 goto failed; 804 } 805 806 i = pcmcia_request_irq(link->handle, &link->irq); 807 if (i != CS_SUCCESS) { 808 cs_error(link->handle, RequestIRQ, i); 809 link->irq.AssignedIRQ = 0; 810 } 811 812 i = pcmcia_request_configuration(link->handle, &link->conf); 813 if (i != CS_SUCCESS) { 814 cs_error(link->handle, RequestConfiguration, i); 815 goto failed; 816 } 817 818 if (bt3c_open(info) != 0) 819 goto failed; 820 821 strcpy(info->node.dev_name, info->hdev->name); 822 link->dev = &info->node; 823 link->state &= ~DEV_CONFIG_PENDING; 824 825 return; 826 827 cs_failed: 828 cs_error(link->handle, last_fn, last_ret); 829 830 failed: 831 bt3c_release(link); 832 } 833 834 835 static void bt3c_release(dev_link_t *link) 836 { 837 bt3c_info_t *info = link->priv; 838 839 if (link->state & DEV_PRESENT) 840 bt3c_close(info); 841 842 link->dev = NULL; 843 844 pcmcia_release_configuration(link->handle); 845 pcmcia_release_io(link->handle, &link->io); 846 pcmcia_release_irq(link->handle, &link->irq); 847 848 link->state &= ~DEV_CONFIG; 849 } 850 851 static int bt3c_suspend(struct pcmcia_device *dev) 852 { 853 dev_link_t *link = dev_to_instance(dev); 854 855 link->state |= DEV_SUSPEND; 856 if (link->state & DEV_CONFIG) 857 pcmcia_release_configuration(link->handle); 858 859 return 0; 860 } 861 862 static int bt3c_resume(struct pcmcia_device *dev) 863 { 864 dev_link_t *link = dev_to_instance(dev); 865 866 link->state &= ~DEV_SUSPEND; 867 if (DEV_OK(link)) 868 pcmcia_request_configuration(link->handle, &link->conf); 869 870 return 0; 871 } 872 873 874 static struct pcmcia_device_id bt3c_ids[] = { 875 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02), 876 PCMCIA_DEVICE_NULL 877 }; 878 MODULE_DEVICE_TABLE(pcmcia, bt3c_ids); 879 880 static struct pcmcia_driver bt3c_driver = { 881 .owner = THIS_MODULE, 882 .drv = { 883 .name = "bt3c_cs", 884 }, 885 .probe = bt3c_attach, 886 .remove = bt3c_detach, 887 .id_table = bt3c_ids, 888 .suspend = bt3c_suspend, 889 .resume = bt3c_resume, 890 }; 891 892 static int __init init_bt3c_cs(void) 893 { 894 return pcmcia_register_driver(&bt3c_driver); 895 } 896 897 898 static void __exit exit_bt3c_cs(void) 899 { 900 pcmcia_unregister_driver(&bt3c_driver); 901 } 902 903 module_init(init_bt3c_cs); 904 module_exit(exit_bt3c_cs); 905