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/module.h> 24 25#include <linux/kernel.h> 26#include <linux/init.h> 27#include <linux/slab.h> 28#include <linux/types.h> 29#include <linux/delay.h> 30#include <linux/errno.h> 31#include <linux/ptrace.h> 32#include <linux/ioport.h> 33#include <linux/spinlock.h> 34#include <linux/moduleparam.h> 35 36#include <linux/skbuff.h> 37#include <linux/string.h> 38#include <linux/serial.h> 39#include <linux/serial_reg.h> 40#include <linux/bitops.h> 41#include <asm/system.h> 42#include <asm/io.h> 43 44#include <pcmcia/cs.h> 45#include <pcmcia/cistpl.h> 46#include <pcmcia/ciscode.h> 47#include <pcmcia/ds.h> 48#include <pcmcia/cisreg.h> 49 50#include <net/bluetooth/bluetooth.h> 51#include <net/bluetooth/hci_core.h> 52 53 54 55/* ======================== Module parameters ======================== */ 56 57 58MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 59MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface"); 60MODULE_LICENSE("GPL"); 61 62 63 64/* ======================== Local structures ======================== */ 65 66 67typedef struct btuart_info_t { 68 struct pcmcia_device *p_dev; 69 70 struct hci_dev *hdev; 71 72 spinlock_t lock; /* For serializing operations */ 73 74 struct sk_buff_head txq; 75 unsigned long tx_state; 76 77 unsigned long rx_state; 78 unsigned long rx_count; 79 struct sk_buff *rx_skb; 80} btuart_info_t; 81 82 83static int btuart_config(struct pcmcia_device *link); 84static void btuart_release(struct pcmcia_device *link); 85 86static void btuart_detach(struct pcmcia_device *p_dev); 87 88 89/* Maximum baud rate */ 90#define SPEED_MAX 115200 91 92/* Default baud rate: 57600, 115200, 230400 or 460800 */ 93#define DEFAULT_BAUD_RATE 115200 94 95 96/* Transmit states */ 97#define XMIT_SENDING 1 98#define XMIT_WAKEUP 2 99#define XMIT_WAITING 8 100 101/* Receiver states */ 102#define RECV_WAIT_PACKET_TYPE 0 103#define RECV_WAIT_EVENT_HEADER 1 104#define RECV_WAIT_ACL_HEADER 2 105#define RECV_WAIT_SCO_HEADER 3 106#define RECV_WAIT_DATA 4 107 108 109 110/* ======================== Interrupt handling ======================== */ 111 112 113static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len) 114{ 115 int actual = 0; 116 117 /* Tx FIFO should be empty */ 118 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE)) 119 return 0; 120 121 /* Fill FIFO with current frame */ 122 while ((fifo_size-- > 0) && (actual < len)) { 123 /* Transmit next byte */ 124 outb(buf[actual], iobase + UART_TX); 125 actual++; 126 } 127 128 return actual; 129} 130 131 132static void btuart_write_wakeup(btuart_info_t *info) 133{ 134 if (!info) { 135 BT_ERR("Unknown device"); 136 return; 137 } 138 139 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) { 140 set_bit(XMIT_WAKEUP, &(info->tx_state)); 141 return; 142 } 143 144 do { 145 register unsigned int iobase = info->p_dev->resource[0]->start; 146 register struct sk_buff *skb; 147 register int len; 148 149 clear_bit(XMIT_WAKEUP, &(info->tx_state)); 150 151 if (!pcmcia_dev_present(info->p_dev)) 152 return; 153 154 if (!(skb = skb_dequeue(&(info->txq)))) 155 break; 156 157 /* Send frame */ 158 len = btuart_write(iobase, 16, skb->data, skb->len); 159 set_bit(XMIT_WAKEUP, &(info->tx_state)); 160 161 if (len == skb->len) { 162 kfree_skb(skb); 163 } else { 164 skb_pull(skb, len); 165 skb_queue_head(&(info->txq), skb); 166 } 167 168 info->hdev->stat.byte_tx += len; 169 170 } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); 171 172 clear_bit(XMIT_SENDING, &(info->tx_state)); 173} 174 175 176static void btuart_receive(btuart_info_t *info) 177{ 178 unsigned int iobase; 179 int boguscount = 0; 180 181 if (!info) { 182 BT_ERR("Unknown device"); 183 return; 184 } 185 186 iobase = info->p_dev->resource[0]->start; 187 188 do { 189 info->hdev->stat.byte_rx++; 190 191 /* Allocate packet */ 192 if (info->rx_skb == NULL) { 193 info->rx_state = RECV_WAIT_PACKET_TYPE; 194 info->rx_count = 0; 195 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) { 196 BT_ERR("Can't allocate mem for new packet"); 197 return; 198 } 199 } 200 201 if (info->rx_state == RECV_WAIT_PACKET_TYPE) { 202 203 info->rx_skb->dev = (void *) info->hdev; 204 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX); 205 206 switch (bt_cb(info->rx_skb)->pkt_type) { 207 208 case HCI_EVENT_PKT: 209 info->rx_state = RECV_WAIT_EVENT_HEADER; 210 info->rx_count = HCI_EVENT_HDR_SIZE; 211 break; 212 213 case HCI_ACLDATA_PKT: 214 info->rx_state = RECV_WAIT_ACL_HEADER; 215 info->rx_count = HCI_ACL_HDR_SIZE; 216 break; 217 218 case HCI_SCODATA_PKT: 219 info->rx_state = RECV_WAIT_SCO_HEADER; 220 info->rx_count = HCI_SCO_HDR_SIZE; 221 break; 222 223 default: 224 /* Unknown packet */ 225 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type); 226 info->hdev->stat.err_rx++; 227 clear_bit(HCI_RUNNING, &(info->hdev->flags)); 228 229 kfree_skb(info->rx_skb); 230 info->rx_skb = NULL; 231 break; 232 233 } 234 235 } else { 236 237 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX); 238 info->rx_count--; 239 240 if (info->rx_count == 0) { 241 242 int dlen; 243 struct hci_event_hdr *eh; 244 struct hci_acl_hdr *ah; 245 struct hci_sco_hdr *sh; 246 247 248 switch (info->rx_state) { 249 250 case RECV_WAIT_EVENT_HEADER: 251 eh = hci_event_hdr(info->rx_skb); 252 info->rx_state = RECV_WAIT_DATA; 253 info->rx_count = eh->plen; 254 break; 255 256 case RECV_WAIT_ACL_HEADER: 257 ah = hci_acl_hdr(info->rx_skb); 258 dlen = __le16_to_cpu(ah->dlen); 259 info->rx_state = RECV_WAIT_DATA; 260 info->rx_count = dlen; 261 break; 262 263 case RECV_WAIT_SCO_HEADER: 264 sh = hci_sco_hdr(info->rx_skb); 265 info->rx_state = RECV_WAIT_DATA; 266 info->rx_count = sh->dlen; 267 break; 268 269 case RECV_WAIT_DATA: 270 hci_recv_frame(info->rx_skb); 271 info->rx_skb = NULL; 272 break; 273 274 } 275 276 } 277 278 } 279 280 /* Make sure we don't stay here too long */ 281 if (boguscount++ > 16) 282 break; 283 284 } while (inb(iobase + UART_LSR) & UART_LSR_DR); 285} 286 287 288static irqreturn_t btuart_interrupt(int irq, void *dev_inst) 289{ 290 btuart_info_t *info = dev_inst; 291 unsigned int iobase; 292 int boguscount = 0; 293 int iir, lsr; 294 irqreturn_t r = IRQ_NONE; 295 296 if (!info || !info->hdev) 297 /* our irq handler is shared */ 298 return IRQ_NONE; 299 300 iobase = info->p_dev->resource[0]->start; 301 302 spin_lock(&(info->lock)); 303 304 iir = inb(iobase + UART_IIR) & UART_IIR_ID; 305 while (iir) { 306 r = IRQ_HANDLED; 307 308 /* Clear interrupt */ 309 lsr = inb(iobase + UART_LSR); 310 311 switch (iir) { 312 case UART_IIR_RLSI: 313 BT_ERR("RLSI"); 314 break; 315 case UART_IIR_RDI: 316 /* Receive interrupt */ 317 btuart_receive(info); 318 break; 319 case UART_IIR_THRI: 320 if (lsr & UART_LSR_THRE) { 321 /* Transmitter ready for data */ 322 btuart_write_wakeup(info); 323 } 324 break; 325 default: 326 BT_ERR("Unhandled IIR=%#x", iir); 327 break; 328 } 329 330 /* Make sure we don't stay here too long */ 331 if (boguscount++ > 100) 332 break; 333 334 iir = inb(iobase + UART_IIR) & UART_IIR_ID; 335 336 } 337 338 spin_unlock(&(info->lock)); 339 340 return r; 341} 342 343 344static void btuart_change_speed(btuart_info_t *info, unsigned int speed) 345{ 346 unsigned long flags; 347 unsigned int iobase; 348 int fcr; /* FIFO control reg */ 349 int lcr; /* Line control reg */ 350 int divisor; 351 352 if (!info) { 353 BT_ERR("Unknown device"); 354 return; 355 } 356 357 iobase = info->p_dev->resource[0]->start; 358 359 spin_lock_irqsave(&(info->lock), flags); 360 361 /* Turn off interrupts */ 362 outb(0, iobase + UART_IER); 363 364 divisor = SPEED_MAX / speed; 365 366 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT; 367 368 /* 369 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and 370 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget 371 * about this timeout since it will always be fast enough. 372 */ 373 374 if (speed < 38400) 375 fcr |= UART_FCR_TRIGGER_1; 376 else 377 fcr |= UART_FCR_TRIGGER_14; 378 379 /* Bluetooth cards use 8N1 */ 380 lcr = UART_LCR_WLEN8; 381 382 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */ 383 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */ 384 outb(divisor >> 8, iobase + UART_DLM); 385 outb(lcr, iobase + UART_LCR); /* Set 8N1 */ 386 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */ 387 388 /* Turn on interrupts */ 389 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER); 390 391 spin_unlock_irqrestore(&(info->lock), flags); 392} 393 394 395 396/* ======================== HCI interface ======================== */ 397 398 399static int btuart_hci_flush(struct hci_dev *hdev) 400{ 401 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data); 402 403 /* Drop TX queue */ 404 skb_queue_purge(&(info->txq)); 405 406 return 0; 407} 408 409 410static int btuart_hci_open(struct hci_dev *hdev) 411{ 412 set_bit(HCI_RUNNING, &(hdev->flags)); 413 414 return 0; 415} 416 417 418static int btuart_hci_close(struct hci_dev *hdev) 419{ 420 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags))) 421 return 0; 422 423 btuart_hci_flush(hdev); 424 425 return 0; 426} 427 428 429static int btuart_hci_send_frame(struct sk_buff *skb) 430{ 431 btuart_info_t *info; 432 struct hci_dev *hdev = (struct hci_dev *)(skb->dev); 433 434 if (!hdev) { 435 BT_ERR("Frame for unknown HCI device (hdev=NULL)"); 436 return -ENODEV; 437 } 438 439 info = (btuart_info_t *)(hdev->driver_data); 440 441 switch (bt_cb(skb)->pkt_type) { 442 case HCI_COMMAND_PKT: 443 hdev->stat.cmd_tx++; 444 break; 445 case HCI_ACLDATA_PKT: 446 hdev->stat.acl_tx++; 447 break; 448 case HCI_SCODATA_PKT: 449 hdev->stat.sco_tx++; 450 break; 451 }; 452 453 /* Prepend skb with frame type */ 454 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 455 skb_queue_tail(&(info->txq), skb); 456 457 btuart_write_wakeup(info); 458 459 return 0; 460} 461 462 463static void btuart_hci_destruct(struct hci_dev *hdev) 464{ 465} 466 467 468static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg) 469{ 470 return -ENOIOCTLCMD; 471} 472 473 474 475/* ======================== Card services HCI interaction ======================== */ 476 477 478static int btuart_open(btuart_info_t *info) 479{ 480 unsigned long flags; 481 unsigned int iobase = info->p_dev->resource[0]->start; 482 struct hci_dev *hdev; 483 484 spin_lock_init(&(info->lock)); 485 486 skb_queue_head_init(&(info->txq)); 487 488 info->rx_state = RECV_WAIT_PACKET_TYPE; 489 info->rx_count = 0; 490 info->rx_skb = NULL; 491 492 /* Initialize HCI device */ 493 hdev = hci_alloc_dev(); 494 if (!hdev) { 495 BT_ERR("Can't allocate HCI device"); 496 return -ENOMEM; 497 } 498 499 info->hdev = hdev; 500 501 hdev->bus = HCI_PCCARD; 502 hdev->driver_data = info; 503 SET_HCIDEV_DEV(hdev, &info->p_dev->dev); 504 505 hdev->open = btuart_hci_open; 506 hdev->close = btuart_hci_close; 507 hdev->flush = btuart_hci_flush; 508 hdev->send = btuart_hci_send_frame; 509 hdev->destruct = btuart_hci_destruct; 510 hdev->ioctl = btuart_hci_ioctl; 511 512 hdev->owner = THIS_MODULE; 513 514 spin_lock_irqsave(&(info->lock), flags); 515 516 /* Reset UART */ 517 outb(0, iobase + UART_MCR); 518 519 /* Turn off interrupts */ 520 outb(0, iobase + UART_IER); 521 522 /* Initialize UART */ 523 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */ 524 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR); 525 526 /* Turn on interrupts */ 527 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER); 528 529 spin_unlock_irqrestore(&(info->lock), flags); 530 531 btuart_change_speed(info, DEFAULT_BAUD_RATE); 532 533 /* Timeout before it is safe to send the first HCI packet */ 534 msleep(1000); 535 536 /* Register HCI device */ 537 if (hci_register_dev(hdev) < 0) { 538 BT_ERR("Can't register HCI device"); 539 info->hdev = NULL; 540 hci_free_dev(hdev); 541 return -ENODEV; 542 } 543 544 return 0; 545} 546 547 548static int btuart_close(btuart_info_t *info) 549{ 550 unsigned long flags; 551 unsigned int iobase = info->p_dev->resource[0]->start; 552 struct hci_dev *hdev = info->hdev; 553 554 if (!hdev) 555 return -ENODEV; 556 557 btuart_hci_close(hdev); 558 559 spin_lock_irqsave(&(info->lock), flags); 560 561 /* Reset UART */ 562 outb(0, iobase + UART_MCR); 563 564 /* Turn off interrupts */ 565 outb(0, iobase + UART_IER); 566 567 spin_unlock_irqrestore(&(info->lock), flags); 568 569 if (hci_unregister_dev(hdev) < 0) 570 BT_ERR("Can't unregister HCI device %s", hdev->name); 571 572 hci_free_dev(hdev); 573 574 return 0; 575} 576 577static int btuart_probe(struct pcmcia_device *link) 578{ 579 btuart_info_t *info; 580 581 /* Create new info device */ 582 info = kzalloc(sizeof(*info), GFP_KERNEL); 583 if (!info) 584 return -ENOMEM; 585 586 info->p_dev = link; 587 link->priv = info; 588 589 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; 590 link->resource[0]->end = 8; 591 592 link->conf.Attributes = CONF_ENABLE_IRQ; 593 link->conf.IntType = INT_MEMORY_AND_IO; 594 595 return btuart_config(link); 596} 597 598 599static void btuart_detach(struct pcmcia_device *link) 600{ 601 btuart_info_t *info = link->priv; 602 603 btuart_release(link); 604 kfree(info); 605} 606 607static int btuart_check_config(struct pcmcia_device *p_dev, 608 cistpl_cftable_entry_t *cf, 609 cistpl_cftable_entry_t *dflt, 610 unsigned int vcc, 611 void *priv_data) 612{ 613 int *try = priv_data; 614 615 p_dev->io_lines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK; 616 617 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM)) 618 p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000; 619 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && 620 (cf->io.win[0].base != 0)) { 621 p_dev->resource[0]->start = cf->io.win[0].base; 622 if (!pcmcia_request_io(p_dev)) 623 return 0; 624 } 625 return -ENODEV; 626} 627 628static int btuart_check_config_notpicky(struct pcmcia_device *p_dev, 629 cistpl_cftable_entry_t *cf, 630 cistpl_cftable_entry_t *dflt, 631 unsigned int vcc, 632 void *priv_data) 633{ 634 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 }; 635 int j; 636 637 if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) { 638 for (j = 0; j < 5; j++) { 639 p_dev->resource[0]->start = base[j]; 640 p_dev->io_lines = base[j] ? 16 : 3; 641 if (!pcmcia_request_io(p_dev)) 642 return 0; 643 } 644 } 645 return -ENODEV; 646} 647 648static int btuart_config(struct pcmcia_device *link) 649{ 650 btuart_info_t *info = link->priv; 651 int i; 652 int try; 653 654 /* First pass: look for a config entry that looks normal. 655 Two tries: without IO aliases, then with aliases */ 656 for (try = 0; try < 2; try++) 657 if (!pcmcia_loop_config(link, btuart_check_config, &try)) 658 goto found_port; 659 660 /* Second pass: try to find an entry that isn't picky about 661 its base address, then try to grab any standard serial port 662 address, and finally try to get any free port. */ 663 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL)) 664 goto found_port; 665 666 BT_ERR("No usable port range found"); 667 goto failed; 668 669found_port: 670 i = pcmcia_request_irq(link, btuart_interrupt); 671 if (i != 0) 672 goto failed; 673 674 i = pcmcia_request_configuration(link, &link->conf); 675 if (i != 0) 676 goto failed; 677 678 if (btuart_open(info) != 0) 679 goto failed; 680 681 return 0; 682 683failed: 684 btuart_release(link); 685 return -ENODEV; 686} 687 688 689static void btuart_release(struct pcmcia_device *link) 690{ 691 btuart_info_t *info = link->priv; 692 693 btuart_close(info); 694 695 pcmcia_disable_device(link); 696} 697 698static struct pcmcia_device_id btuart_ids[] = { 699 /* don't use this driver. Use serial_cs + hci_uart instead */ 700 PCMCIA_DEVICE_NULL 701}; 702MODULE_DEVICE_TABLE(pcmcia, btuart_ids); 703 704static struct pcmcia_driver btuart_driver = { 705 .owner = THIS_MODULE, 706 .drv = { 707 .name = "btuart_cs", 708 }, 709 .probe = btuart_probe, 710 .remove = btuart_detach, 711 .id_table = btuart_ids, 712}; 713 714static int __init init_btuart_cs(void) 715{ 716 return pcmcia_register_driver(&btuart_driver); 717} 718 719 720static void __exit exit_btuart_cs(void) 721{ 722 pcmcia_unregister_driver(&btuart_driver); 723} 724 725module_init(init_btuart_cs); 726module_exit(exit_btuart_cs); 727