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 <linux/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 struct btuart_info {
  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 };
  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(struct btuart_info *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                 skb = skb_dequeue(&(info->txq));
 153                 if (!skb)
 154                         break;
 155
 156                 /* Send frame */
 157                 len = btuart_write(iobase, 16, skb->data, skb->len);
 158                 set_bit(XMIT_WAKEUP, &(info->tx_state));
 159
 160                 if (len == skb->len) {
 161                         kfree_skb(skb);
 162                 } else {
 163                         skb_pull(skb, len);
 164                         skb_queue_head(&(info->txq), skb);
 165                 }
 166
 167                 info->hdev->stat.byte_tx += len;
 168
 169         } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
 170
 171         clear_bit(XMIT_SENDING, &(info->tx_state));
 172 }
 173
 174
 175 static void btuart_receive(struct btuart_info *info)
 176 {
 177         unsigned int iobase;
 178         int boguscount = 0;
 179
 180         if (!info) {
 181                 BT_ERR("Unknown device");
 182                 return;
 183         }
 184
 185         iobase = info->p_dev->resource[0]->start;
 186
 187         do {
 188                 info->hdev->stat.byte_rx++;
 189
 190                 /* Allocate packet */
 191                 if (!info->rx_skb) {
 192                         info->rx_state = RECV_WAIT_PACKET_TYPE;
 193                         info->rx_count = 0;
 194                         info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
 195                         if (!info->rx_skb) {
 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                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
 204
 205                         switch (bt_cb(info->rx_skb)->pkt_type) {
 206
 207                         case HCI_EVENT_PKT:
 208                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 209                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 210                                 break;
 211
 212                         case HCI_ACLDATA_PKT:
 213                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 214                                 info->rx_count = HCI_ACL_HDR_SIZE;
 215                                 break;
 216
 217                         case HCI_SCODATA_PKT:
 218                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 219                                 info->rx_count = HCI_SCO_HDR_SIZE;
 220                                 break;
 221
 222                         default:
 223                                 /* Unknown packet */
 224                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 225                                 info->hdev->stat.err_rx++;
 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->hdev, 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         struct btuart_info *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(struct btuart_info *info,
 343                                 unsigned int speed)
 344 {
 345         unsigned long flags;
 346         unsigned int iobase;
 347         int fcr;                /* FIFO control reg */
 348         int lcr;                /* Line control reg */
 349         int divisor;
 350
 351         if (!info) {
 352                 BT_ERR("Unknown device");
 353                 return;
 354         }
 355
 356         iobase = info->p_dev->resource[0]->start;
 357
 358         spin_lock_irqsave(&(info->lock), flags);
 359
 360         /* Turn off interrupts */
 361         outb(0, iobase + UART_IER);
 362
 363         divisor = SPEED_MAX / speed;
 364
 365         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 366
 367         /*
 368          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 369          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 370          * about this timeout since it will always be fast enough.
 371          */
 372
 373         if (speed < 38400)
 374                 fcr |= UART_FCR_TRIGGER_1;
 375         else
 376                 fcr |= UART_FCR_TRIGGER_14;
 377
 378         /* Bluetooth cards use 8N1 */
 379         lcr = UART_LCR_WLEN8;
 380
 381         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 382         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 383         outb(divisor >> 8, iobase + UART_DLM);
 384         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 385         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 386
 387         /* Turn on interrupts */
 388         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 389
 390         spin_unlock_irqrestore(&(info->lock), flags);
 391 }
 392
 393
 394
 395 /* ======================== HCI interface ======================== */
 396
 397
 398 static int btuart_hci_flush(struct hci_dev *hdev)
 399 {
 400         struct btuart_info *info = hci_get_drvdata(hdev);
 401
 402         /* Drop TX queue */
 403         skb_queue_purge(&(info->txq));
 404
 405         return 0;
 406 }
 407
 408
 409 static int btuart_hci_open(struct hci_dev *hdev)
 410 {
 411         return 0;
 412 }
 413
 414
 415 static int btuart_hci_close(struct hci_dev *hdev)
 416 {
 417         btuart_hci_flush(hdev);
 418
 419         return 0;
 420 }
 421
 422
 423 static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 424 {
 425         struct btuart_info *info = hci_get_drvdata(hdev);
 426
 427         switch (bt_cb(skb)->pkt_type) {
 428         case HCI_COMMAND_PKT:
 429                 hdev->stat.cmd_tx++;
 430                 break;
 431         case HCI_ACLDATA_PKT:
 432                 hdev->stat.acl_tx++;
 433                 break;
 434         case HCI_SCODATA_PKT:
 435                 hdev->stat.sco_tx++;
 436                 break;
 437         }
 438
 439         /* Prepend skb with frame type */
 440         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 441         skb_queue_tail(&(info->txq), skb);
 442
 443         btuart_write_wakeup(info);
 444
 445         return 0;
 446 }
 447
 448
 449
 450 /* ======================== Card services HCI interaction ======================== */
 451
 452
 453 static int btuart_open(struct btuart_info *info)
 454 {
 455         unsigned long flags;
 456         unsigned int iobase = info->p_dev->resource[0]->start;
 457         struct hci_dev *hdev;
 458
 459         spin_lock_init(&(info->lock));
 460
 461         skb_queue_head_init(&(info->txq));
 462
 463         info->rx_state = RECV_WAIT_PACKET_TYPE;
 464         info->rx_count = 0;
 465         info->rx_skb = NULL;
 466
 467         /* Initialize HCI device */
 468         hdev = hci_alloc_dev();
 469         if (!hdev) {
 470                 BT_ERR("Can't allocate HCI device");
 471                 return -ENOMEM;
 472         }
 473
 474         info->hdev = hdev;
 475
 476         hdev->bus = HCI_PCCARD;
 477         hci_set_drvdata(hdev, info);
 478         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 479
 480         hdev->open  = btuart_hci_open;
 481         hdev->close = btuart_hci_close;
 482         hdev->flush = btuart_hci_flush;
 483         hdev->send  = btuart_hci_send_frame;
 484
 485         spin_lock_irqsave(&(info->lock), flags);
 486
 487         /* Reset UART */
 488         outb(0, iobase + UART_MCR);
 489
 490         /* Turn off interrupts */
 491         outb(0, iobase + UART_IER);
 492
 493         /* Initialize UART */
 494         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 495         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 496
 497         /* Turn on interrupts */
 498         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 499
 500         spin_unlock_irqrestore(&(info->lock), flags);
 501
 502         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 503
 504         /* Timeout before it is safe to send the first HCI packet */
 505         msleep(1000);
 506
 507         /* Register HCI device */
 508         if (hci_register_dev(hdev) < 0) {
 509                 BT_ERR("Can't register HCI device");
 510                 info->hdev = NULL;
 511                 hci_free_dev(hdev);
 512                 return -ENODEV;
 513         }
 514
 515         return 0;
 516 }
 517
 518
 519 static int btuart_close(struct btuart_info *info)
 520 {
 521         unsigned long flags;
 522         unsigned int iobase = info->p_dev->resource[0]->start;
 523         struct hci_dev *hdev = info->hdev;
 524
 525         if (!hdev)
 526                 return -ENODEV;
 527
 528         btuart_hci_close(hdev);
 529
 530         spin_lock_irqsave(&(info->lock), flags);
 531
 532         /* Reset UART */
 533         outb(0, iobase + UART_MCR);
 534
 535         /* Turn off interrupts */
 536         outb(0, iobase + UART_IER);
 537
 538         spin_unlock_irqrestore(&(info->lock), flags);
 539
 540         hci_unregister_dev(hdev);
 541         hci_free_dev(hdev);
 542
 543         return 0;
 544 }
 545
 546 static int btuart_probe(struct pcmcia_device *link)
 547 {
 548         struct btuart_info *info;
 549
 550         /* Create new info device */
 551         info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
 552         if (!info)
 553                 return -ENOMEM;
 554
 555         info->p_dev = link;
 556         link->priv = info;
 557
 558         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 559                 CONF_AUTO_SET_IO;
 560
 561         return btuart_config(link);
 562 }
 563
 564
 565 static void btuart_detach(struct pcmcia_device *link)
 566 {
 567         btuart_release(link);
 568 }
 569
 570 static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 571 {
 572         int *try = priv_data;
 573
 574         if (!try)
 575                 p_dev->io_lines = 16;
 576
 577         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 578                 return -EINVAL;
 579
 580         p_dev->resource[0]->end = 8;
 581         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 582         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 583
 584         return pcmcia_request_io(p_dev);
 585 }
 586
 587 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 588                                         void *priv_data)
 589 {
 590         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 591         int j;
 592
 593         if (p_dev->io_lines > 3)
 594                 return -ENODEV;
 595
 596         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 597         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 598         p_dev->resource[0]->end = 8;
 599
 600         for (j = 0; j < 5; j++) {
 601                 p_dev->resource[0]->start = base[j];
 602                 p_dev->io_lines = base[j] ? 16 : 3;
 603                 if (!pcmcia_request_io(p_dev))
 604                         return 0;
 605         }
 606         return -ENODEV;
 607 }
 608
 609 static int btuart_config(struct pcmcia_device *link)
 610 {
 611         struct btuart_info *info = link->priv;
 612         int i;
 613         int try;
 614
 615         /* First pass: look for a config entry that looks normal.
 616            Two tries: without IO aliases, then with aliases */
 617         for (try = 0; try < 2; try++)
 618                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
 619                         goto found_port;
 620
 621         /* Second pass: try to find an entry that isn't picky about
 622            its base address, then try to grab any standard serial port
 623            address, and finally try to get any free port. */
 624         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 625                 goto found_port;
 626
 627         BT_ERR("No usable port range found");
 628         goto failed;
 629
 630 found_port:
 631         i = pcmcia_request_irq(link, btuart_interrupt);
 632         if (i != 0)
 633                 goto failed;
 634
 635         i = pcmcia_enable_device(link);
 636         if (i != 0)
 637                 goto failed;
 638
 639         if (btuart_open(info) != 0)
 640                 goto failed;
 641
 642         return 0;
 643
 644 failed:
 645         btuart_release(link);
 646         return -ENODEV;
 647 }
 648
 649
 650 static void btuart_release(struct pcmcia_device *link)
 651 {
 652         struct btuart_info *info = link->priv;
 653
 654         btuart_close(info);
 655
 656         pcmcia_disable_device(link);
 657 }
 658
 659 static const struct pcmcia_device_id btuart_ids[] = {
 660         /* don't use this driver. Use serial_cs + hci_uart instead */
 661         PCMCIA_DEVICE_NULL
 662 };
 663 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 664
 665 static struct pcmcia_driver btuart_driver = {
 666         .owner          = THIS_MODULE,
 667         .name           = "btuart_cs",
 668         .probe          = btuart_probe,
 669         .remove         = btuart_detach,
 670         .id_table       = btuart_ids,
 671 };
 672 module_pcmcia_driver(btuart_driver);