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