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