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                         bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
 202
 203                         switch (bt_cb(info->rx_skb)->pkt_type) {
 204
 205                         case HCI_EVENT_PKT:
 206                                 info->rx_state = RECV_WAIT_EVENT_HEADER;
 207                                 info->rx_count = HCI_EVENT_HDR_SIZE;
 208                                 break;
 209
 210                         case HCI_ACLDATA_PKT:
 211                                 info->rx_state = RECV_WAIT_ACL_HEADER;
 212                                 info->rx_count = HCI_ACL_HDR_SIZE;
 213                                 break;
 214
 215                         case HCI_SCODATA_PKT:
 216                                 info->rx_state = RECV_WAIT_SCO_HEADER;
 217                                 info->rx_count = HCI_SCO_HDR_SIZE;
 218                                 break;
 219
 220                         default:
 221                                 /* Unknown packet */
 222                                 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
 223                                 info->hdev->stat.err_rx++;
 224                                 clear_bit(HCI_RUNNING, &(info->hdev->flags));
 225
 226                                 kfree_skb(info->rx_skb);
 227                                 info->rx_skb = NULL;
 228                                 break;
 229
 230                         }
 231
 232                 } else {
 233
 234                         *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
 235                         info->rx_count--;
 236
 237                         if (info->rx_count == 0) {
 238
 239                                 int dlen;
 240                                 struct hci_event_hdr *eh;
 241                                 struct hci_acl_hdr *ah;
 242                                 struct hci_sco_hdr *sh;
 243
 244
 245                                 switch (info->rx_state) {
 246
 247                                 case RECV_WAIT_EVENT_HEADER:
 248                                         eh = hci_event_hdr(info->rx_skb);
 249                                         info->rx_state = RECV_WAIT_DATA;
 250                                         info->rx_count = eh->plen;
 251                                         break;
 252
 253                                 case RECV_WAIT_ACL_HEADER:
 254                                         ah = hci_acl_hdr(info->rx_skb);
 255                                         dlen = __le16_to_cpu(ah->dlen);
 256                                         info->rx_state = RECV_WAIT_DATA;
 257                                         info->rx_count = dlen;
 258                                         break;
 259
 260                                 case RECV_WAIT_SCO_HEADER:
 261                                         sh = hci_sco_hdr(info->rx_skb);
 262                                         info->rx_state = RECV_WAIT_DATA;
 263                                         info->rx_count = sh->dlen;
 264                                         break;
 265
 266                                 case RECV_WAIT_DATA:
 267                                         hci_recv_frame(info->hdev, info->rx_skb);
 268                                         info->rx_skb = NULL;
 269                                         break;
 270
 271                                 }
 272
 273                         }
 274
 275                 }
 276
 277                 /* Make sure we don't stay here too long */
 278                 if (boguscount++ > 16)
 279                         break;
 280
 281         } while (inb(iobase + UART_LSR) & UART_LSR_DR);
 282 }
 283
 284
 285 static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
 286 {
 287         btuart_info_t *info = dev_inst;
 288         unsigned int iobase;
 289         int boguscount = 0;
 290         int iir, lsr;
 291         irqreturn_t r = IRQ_NONE;
 292
 293         if (!info || !info->hdev)
 294                 /* our irq handler is shared */
 295                 return IRQ_NONE;
 296
 297         iobase = info->p_dev->resource[0]->start;
 298
 299         spin_lock(&(info->lock));
 300
 301         iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 302         while (iir) {
 303                 r = IRQ_HANDLED;
 304
 305                 /* Clear interrupt */
 306                 lsr = inb(iobase + UART_LSR);
 307
 308                 switch (iir) {
 309                 case UART_IIR_RLSI:
 310                         BT_ERR("RLSI");
 311                         break;
 312                 case UART_IIR_RDI:
 313                         /* Receive interrupt */
 314                         btuart_receive(info);
 315                         break;
 316                 case UART_IIR_THRI:
 317                         if (lsr & UART_LSR_THRE) {
 318                                 /* Transmitter ready for data */
 319                                 btuart_write_wakeup(info);
 320                         }
 321                         break;
 322                 default:
 323                         BT_ERR("Unhandled IIR=%#x", iir);
 324                         break;
 325                 }
 326
 327                 /* Make sure we don't stay here too long */
 328                 if (boguscount++ > 100)
 329                         break;
 330
 331                 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
 332
 333         }
 334
 335         spin_unlock(&(info->lock));
 336
 337         return r;
 338 }
 339
 340
 341 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
 342 {
 343         unsigned long flags;
 344         unsigned int iobase;
 345         int fcr;                /* FIFO control reg */
 346         int lcr;                /* Line control reg */
 347         int divisor;
 348
 349         if (!info) {
 350                 BT_ERR("Unknown device");
 351                 return;
 352         }
 353
 354         iobase = info->p_dev->resource[0]->start;
 355
 356         spin_lock_irqsave(&(info->lock), flags);
 357
 358         /* Turn off interrupts */
 359         outb(0, iobase + UART_IER);
 360
 361         divisor = SPEED_MAX / speed;
 362
 363         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
 364
 365         /*
 366          * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
 367          * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
 368          * about this timeout since it will always be fast enough.
 369          */
 370
 371         if (speed < 38400)
 372                 fcr |= UART_FCR_TRIGGER_1;
 373         else
 374                 fcr |= UART_FCR_TRIGGER_14;
 375
 376         /* Bluetooth cards use 8N1 */
 377         lcr = UART_LCR_WLEN8;
 378
 379         outb(UART_LCR_DLAB | lcr, iobase + UART_LCR);   /* Set DLAB */
 380         outb(divisor & 0xff, iobase + UART_DLL);        /* Set speed */
 381         outb(divisor >> 8, iobase + UART_DLM);
 382         outb(lcr, iobase + UART_LCR);   /* Set 8N1  */
 383         outb(fcr, iobase + UART_FCR);   /* Enable FIFO's */
 384
 385         /* Turn on interrupts */
 386         outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 387
 388         spin_unlock_irqrestore(&(info->lock), flags);
 389 }
 390
 391
 392
 393 /* ======================== HCI interface ======================== */
 394
 395
 396 static int btuart_hci_flush(struct hci_dev *hdev)
 397 {
 398         btuart_info_t *info = hci_get_drvdata(hdev);
 399
 400         /* Drop TX queue */
 401         skb_queue_purge(&(info->txq));
 402
 403         return 0;
 404 }
 405
 406
 407 static int btuart_hci_open(struct hci_dev *hdev)
 408 {
 409         set_bit(HCI_RUNNING, &(hdev->flags));
 410
 411         return 0;
 412 }
 413
 414
 415 static int btuart_hci_close(struct hci_dev *hdev)
 416 {
 417         if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
 418                 return 0;
 419
 420         btuart_hci_flush(hdev);
 421
 422         return 0;
 423 }
 424
 425
 426 static int btuart_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 427 {
 428         btuart_info_t *info = hci_get_drvdata(hdev);
 429
 430         switch (bt_cb(skb)->pkt_type) {
 431         case HCI_COMMAND_PKT:
 432                 hdev->stat.cmd_tx++;
 433                 break;
 434         case HCI_ACLDATA_PKT:
 435                 hdev->stat.acl_tx++;
 436                 break;
 437         case HCI_SCODATA_PKT:
 438                 hdev->stat.sco_tx++;
 439                 break;
 440         }
 441
 442         /* Prepend skb with frame type */
 443         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 444         skb_queue_tail(&(info->txq), skb);
 445
 446         btuart_write_wakeup(info);
 447
 448         return 0;
 449 }
 450
 451
 452
 453 /* ======================== Card services HCI interaction ======================== */
 454
 455
 456 static int btuart_open(btuart_info_t *info)
 457 {
 458         unsigned long flags;
 459         unsigned int iobase = info->p_dev->resource[0]->start;
 460         struct hci_dev *hdev;
 461
 462         spin_lock_init(&(info->lock));
 463
 464         skb_queue_head_init(&(info->txq));
 465
 466         info->rx_state = RECV_WAIT_PACKET_TYPE;
 467         info->rx_count = 0;
 468         info->rx_skb = NULL;
 469
 470         /* Initialize HCI device */
 471         hdev = hci_alloc_dev();
 472         if (!hdev) {
 473                 BT_ERR("Can't allocate HCI device");
 474                 return -ENOMEM;
 475         }
 476
 477         info->hdev = hdev;
 478
 479         hdev->bus = HCI_PCCARD;
 480         hci_set_drvdata(hdev, info);
 481         SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
 482
 483         hdev->open  = btuart_hci_open;
 484         hdev->close = btuart_hci_close;
 485         hdev->flush = btuart_hci_flush;
 486         hdev->send  = btuart_hci_send_frame;
 487
 488         spin_lock_irqsave(&(info->lock), flags);
 489
 490         /* Reset UART */
 491         outb(0, iobase + UART_MCR);
 492
 493         /* Turn off interrupts */
 494         outb(0, iobase + UART_IER);
 495
 496         /* Initialize UART */
 497         outb(UART_LCR_WLEN8, iobase + UART_LCR);        /* Reset DLAB */
 498         outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
 499
 500         /* Turn on interrupts */
 501         // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
 502
 503         spin_unlock_irqrestore(&(info->lock), flags);
 504
 505         btuart_change_speed(info, DEFAULT_BAUD_RATE);
 506
 507         /* Timeout before it is safe to send the first HCI packet */
 508         msleep(1000);
 509
 510         /* Register HCI device */
 511         if (hci_register_dev(hdev) < 0) {
 512                 BT_ERR("Can't register HCI device");
 513                 info->hdev = NULL;
 514                 hci_free_dev(hdev);
 515                 return -ENODEV;
 516         }
 517
 518         return 0;
 519 }
 520
 521
 522 static int btuart_close(btuart_info_t *info)
 523 {
 524         unsigned long flags;
 525         unsigned int iobase = info->p_dev->resource[0]->start;
 526         struct hci_dev *hdev = info->hdev;
 527
 528         if (!hdev)
 529                 return -ENODEV;
 530
 531         btuart_hci_close(hdev);
 532
 533         spin_lock_irqsave(&(info->lock), flags);
 534
 535         /* Reset UART */
 536         outb(0, iobase + UART_MCR);
 537
 538         /* Turn off interrupts */
 539         outb(0, iobase + UART_IER);
 540
 541         spin_unlock_irqrestore(&(info->lock), flags);
 542
 543         hci_unregister_dev(hdev);
 544         hci_free_dev(hdev);
 545
 546         return 0;
 547 }
 548
 549 static int btuart_probe(struct pcmcia_device *link)
 550 {
 551         btuart_info_t *info;
 552
 553         /* Create new info device */
 554         info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
 555         if (!info)
 556                 return -ENOMEM;
 557
 558         info->p_dev = link;
 559         link->priv = info;
 560
 561         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
 562                 CONF_AUTO_SET_IO;
 563
 564         return btuart_config(link);
 565 }
 566
 567
 568 static void btuart_detach(struct pcmcia_device *link)
 569 {
 570         btuart_release(link);
 571 }
 572
 573 static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 574 {
 575         int *try = priv_data;
 576
 577         if (!try)
 578                 p_dev->io_lines = 16;
 579
 580         if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
 581                 return -EINVAL;
 582
 583         p_dev->resource[0]->end = 8;
 584         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 585         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 586
 587         return pcmcia_request_io(p_dev);
 588 }
 589
 590 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
 591                                         void *priv_data)
 592 {
 593         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 594         int j;
 595
 596         if (p_dev->io_lines > 3)
 597                 return -ENODEV;
 598
 599         p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 600         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 601         p_dev->resource[0]->end = 8;
 602
 603         for (j = 0; j < 5; j++) {
 604                 p_dev->resource[0]->start = base[j];
 605                 p_dev->io_lines = base[j] ? 16 : 3;
 606                 if (!pcmcia_request_io(p_dev))
 607                         return 0;
 608         }
 609         return -ENODEV;
 610 }
 611
 612 static int btuart_config(struct pcmcia_device *link)
 613 {
 614         btuart_info_t *info = link->priv;
 615         int i;
 616         int try;
 617
 618         /* First pass: look for a config entry that looks normal.
 619            Two tries: without IO aliases, then with aliases */
 620         for (try = 0; try < 2; try++)
 621                 if (!pcmcia_loop_config(link, btuart_check_config, &try))
 622                         goto found_port;
 623
 624         /* Second pass: try to find an entry that isn't picky about
 625            its base address, then try to grab any standard serial port
 626            address, and finally try to get any free port. */
 627         if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
 628                 goto found_port;
 629
 630         BT_ERR("No usable port range found");
 631         goto failed;
 632
 633 found_port:
 634         i = pcmcia_request_irq(link, btuart_interrupt);
 635         if (i != 0)
 636                 goto failed;
 637
 638         i = pcmcia_enable_device(link);
 639         if (i != 0)
 640                 goto failed;
 641
 642         if (btuart_open(info) != 0)
 643                 goto failed;
 644
 645         return 0;
 646
 647 failed:
 648         btuart_release(link);
 649         return -ENODEV;
 650 }
 651
 652
 653 static void btuart_release(struct pcmcia_device *link)
 654 {
 655         btuart_info_t *info = link->priv;
 656
 657         btuart_close(info);
 658
 659         pcmcia_disable_device(link);
 660 }
 661
 662 static const struct pcmcia_device_id btuart_ids[] = {
 663         /* don't use this driver. Use serial_cs + hci_uart instead */
 664         PCMCIA_DEVICE_NULL
 665 };
 666 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 667
 668 static struct pcmcia_driver btuart_driver = {
 669         .owner          = THIS_MODULE,
 670         .name           = "btuart_cs",
 671         .probe          = btuart_probe,
 672         .remove         = btuart_detach,
 673         .id_table       = btuart_ids,
 674 };
 675 module_pcmcia_driver(btuart_driver);