blob: 35a553a90616d85f07bf5c03d5d24e5373494ac6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <asm/io.h>
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#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
56MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
57MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
58MODULE_LICENSE("GPL");
59
60
61
62/* ======================== Local structures ======================== */
63
64
65typedef struct btuart_info_t {
Dominik Brodowskifd238232006-03-05 10:45:09 +010066 struct pcmcia_device *p_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
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
Dominik Brodowski15b99ac2006-03-31 17:26:06 +020081static int btuart_config(struct pcmcia_device *link);
Dominik Brodowskifba395e2006-03-31 17:21:06 +020082static void btuart_release(struct pcmcia_device *link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Dominik Brodowskicc3b4862005-11-14 21:23:14 +010084static void btuart_detach(struct pcmcia_device *p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
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
111static 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
130static 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 {
Gustavo Padovanfc5fef62012-05-23 04:04:19 -0300143 unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 register struct sk_buff *skb;
Gustavo Padovanfc5fef62012-05-23 04:04:19 -0300145 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147 clear_bit(XMIT_WAKEUP, &(info->tx_state));
148
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100149 if (!pcmcia_dev_present(info->p_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 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
174static 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
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200184 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
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;
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700202 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700204 switch (bt_cb(info->rx_skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
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 */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700223 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 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:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300249 eh = hci_event_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 info->rx_state = RECV_WAIT_DATA;
251 info->rx_count = eh->plen;
252 break;
253
254 case RECV_WAIT_ACL_HEADER:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300255 ah = hci_acl_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 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:
Arnaldo Carvalho de Melo2a123b82007-03-27 18:38:07 -0300262 sh = hci_sco_hdr(info->rx_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 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
David Howells7d12e782006-10-05 14:55:46 +0100286static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 btuart_info_t *info = dev_inst;
289 unsigned int iobase;
290 int boguscount = 0;
291 int iir, lsr;
Alan Coxaafcf992008-10-05 17:35:41 +0100292 irqreturn_t r = IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Mike Frysinger74278472009-09-14 13:43:49 -0400294 if (!info || !info->hdev)
295 /* our irq handler is shared */
296 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200298 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 spin_lock(&(info->lock));
301
302 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
303 while (iir) {
Alan Coxaafcf992008-10-05 17:35:41 +0100304 r = IRQ_HANDLED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
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
Alan Coxaafcf992008-10-05 17:35:41 +0100338 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339}
340
341
342static 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
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200355 iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
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
Joe Perchesb92b1c52008-02-03 17:10:31 +0200386 /* Turn on interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 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
397static int btuart_hci_flush(struct hci_dev *hdev)
398{
David Herrmann155961e2012-02-09 21:58:32 +0100399 btuart_info_t *info = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
401 /* Drop TX queue */
402 skb_queue_purge(&(info->txq));
403
404 return 0;
405}
406
407
408static int btuart_hci_open(struct hci_dev *hdev)
409{
410 set_bit(HCI_RUNNING, &(hdev->flags));
411
412 return 0;
413}
414
415
416static 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
427static 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
David Herrmann155961e2012-02-09 21:58:32 +0100437 info = hci_get_drvdata(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700439 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 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;
Peter Senna Tschudin5ad77792012-09-07 17:24:48 +0200449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451 /* Prepend skb with frame type */
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700452 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 skb_queue_tail(&(info->txq), skb);
454
455 btuart_write_wakeup(info);
456
457 return 0;
458}
459
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
462{
463 return -ENOIOCTLCMD;
464}
465
466
467
468/* ======================== Card services HCI interaction ======================== */
469
470
471static int btuart_open(btuart_info_t *info)
472{
473 unsigned long flags;
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200474 unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 struct hci_dev *hdev;
476
477 spin_lock_init(&(info->lock));
478
479 skb_queue_head_init(&(info->txq));
480
481 info->rx_state = RECV_WAIT_PACKET_TYPE;
482 info->rx_count = 0;
483 info->rx_skb = NULL;
484
485 /* Initialize HCI device */
486 hdev = hci_alloc_dev();
487 if (!hdev) {
488 BT_ERR("Can't allocate HCI device");
489 return -ENOMEM;
490 }
491
492 info->hdev = hdev;
493
Marcel Holtmannc13854c2010-02-08 15:27:07 +0100494 hdev->bus = HCI_PCCARD;
David Herrmann155961e2012-02-09 21:58:32 +0100495 hci_set_drvdata(hdev, info);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200496 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498 hdev->open = btuart_hci_open;
499 hdev->close = btuart_hci_close;
500 hdev->flush = btuart_hci_flush;
501 hdev->send = btuart_hci_send_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 hdev->ioctl = btuart_hci_ioctl;
503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 spin_lock_irqsave(&(info->lock), flags);
505
506 /* Reset UART */
507 outb(0, iobase + UART_MCR);
508
509 /* Turn off interrupts */
510 outb(0, iobase + UART_IER);
511
512 /* Initialize UART */
513 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
514 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
515
516 /* Turn on interrupts */
517 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
518
519 spin_unlock_irqrestore(&(info->lock), flags);
520
521 btuart_change_speed(info, DEFAULT_BAUD_RATE);
522
523 /* Timeout before it is safe to send the first HCI packet */
524 msleep(1000);
525
526 /* Register HCI device */
527 if (hci_register_dev(hdev) < 0) {
528 BT_ERR("Can't register HCI device");
529 info->hdev = NULL;
530 hci_free_dev(hdev);
531 return -ENODEV;
532 }
533
534 return 0;
535}
536
537
538static int btuart_close(btuart_info_t *info)
539{
540 unsigned long flags;
Dominik Brodowski9a017a92010-07-24 15:58:54 +0200541 unsigned int iobase = info->p_dev->resource[0]->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 struct hci_dev *hdev = info->hdev;
543
544 if (!hdev)
545 return -ENODEV;
546
547 btuart_hci_close(hdev);
548
549 spin_lock_irqsave(&(info->lock), flags);
550
551 /* Reset UART */
552 outb(0, iobase + UART_MCR);
553
554 /* Turn off interrupts */
555 outb(0, iobase + UART_IER);
556
557 spin_unlock_irqrestore(&(info->lock), flags);
558
David Herrmann13ea4012011-10-26 10:43:18 +0200559 hci_unregister_dev(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 hci_free_dev(hdev);
561
562 return 0;
563}
564
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200565static int btuart_probe(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{
567 btuart_info_t *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 /* Create new info device */
Sachin Kamatfdefa112012-07-27 12:38:38 +0530570 info = devm_kzalloc(&link->dev, sizeof(*info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if (!info)
Dominik Brodowskif8cfa612005-11-14 21:25:51 +0100572 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200574 info->p_dev = link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 link->priv = info;
576
Dominik Brodowski00990e72010-07-30 13:13:46 +0200577 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
578 CONF_AUTO_SET_IO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200580 return btuart_config(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581}
582
583
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200584static void btuart_detach(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100586 btuart_release(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
Dominik Brodowski00990e72010-07-30 13:13:46 +0200589static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590{
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200591 int *try = priv_data;
Dominik Brodowski90abdc32010-07-24 17:23:51 +0200592
Andrei Emeltchenko510df252012-06-20 14:40:12 +0300593 if (!try)
Dominik Brodowski00990e72010-07-30 13:13:46 +0200594 p_dev->io_lines = 16;
595
596 if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
597 return -EINVAL;
598
599 p_dev->resource[0]->end = 8;
600 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
601 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
602
603 return pcmcia_request_io(p_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
Dominik Brodowskied588722008-07-29 08:38:55 +0200606static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
Dominik Brodowskied588722008-07-29 08:38:55 +0200607 void *priv_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Dominik Brodowskied588722008-07-29 08:38:55 +0200609 static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
610 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
Dominik Brodowski00990e72010-07-30 13:13:46 +0200612 if (p_dev->io_lines > 3)
613 return -ENODEV;
614
615 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
616 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
617 p_dev->resource[0]->end = 8;
618
619 for (j = 0; j < 5; j++) {
620 p_dev->resource[0]->start = base[j];
621 p_dev->io_lines = base[j] ? 16 : 3;
622 if (!pcmcia_request_io(p_dev))
623 return 0;
Dominik Brodowskied588722008-07-29 08:38:55 +0200624 }
625 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
627
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200628static int btuart_config(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 btuart_info_t *info = link->priv;
Dominik Brodowskied588722008-07-29 08:38:55 +0200631 int i;
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200632 int try;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Dominik Brodowskied588722008-07-29 08:38:55 +0200634 /* First pass: look for a config entry that looks normal.
635 Two tries: without IO aliases, then with aliases */
636 for (try = 0; try < 2; try++)
Dominik Brodowskiad913c12008-08-02 16:12:00 +0200637 if (!pcmcia_loop_config(link, btuart_check_config, &try))
Dominik Brodowskied588722008-07-29 08:38:55 +0200638 goto found_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
640 /* Second pass: try to find an entry that isn't picky about
641 its base address, then try to grab any standard serial port
642 address, and finally try to get any free port. */
Dominik Brodowskied588722008-07-29 08:38:55 +0200643 if (!pcmcia_loop_config(link, btuart_check_config_notpicky, NULL))
644 goto found_port;
645
646 BT_ERR("No usable port range found");
Dominik Brodowskied588722008-07-29 08:38:55 +0200647 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649found_port:
Dominik Brodowskieb141202010-03-07 12:21:16 +0100650 i = pcmcia_request_irq(link, btuart_interrupt);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200651 if (i != 0)
Dominik Brodowskieb141202010-03-07 12:21:16 +0100652 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Dominik Brodowski1ac71e52010-07-29 19:27:09 +0200654 i = pcmcia_enable_device(link);
Dominik Brodowski9ac3e582009-10-24 15:45:06 +0200655 if (i != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 goto failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 if (btuart_open(info) != 0)
659 goto failed;
660
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200661 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663failed:
664 btuart_release(link);
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200665 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
667
668
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200669static void btuart_release(struct pcmcia_device *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 btuart_info_t *info = link->priv;
672
Dominik Brodowskie2d40962006-03-02 00:09:29 +0100673 btuart_close(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
Dominik Brodowskifba395e2006-03-31 17:21:06 +0200675 pcmcia_disable_device(link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676}
677
Joe Perches25f8f542011-05-03 19:29:01 -0700678static const struct pcmcia_device_id btuart_ids[] = {
Dominik Brodowski279c9362005-06-27 16:28:38 -0700679 /* don't use this driver. Use serial_cs + hci_uart instead */
680 PCMCIA_DEVICE_NULL
681};
682MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
683
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684static struct pcmcia_driver btuart_driver = {
685 .owner = THIS_MODULE,
Dominik Brodowski2e9b9812010-08-08 11:36:26 +0200686 .name = "btuart_cs",
Dominik Brodowski15b99ac2006-03-31 17:26:06 +0200687 .probe = btuart_probe,
Dominik Brodowskicc3b4862005-11-14 21:23:14 +0100688 .remove = btuart_detach,
Dominik Brodowski279c9362005-06-27 16:28:38 -0700689 .id_table = btuart_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690};
691
692static int __init init_btuart_cs(void)
693{
694 return pcmcia_register_driver(&btuart_driver);
695}
696
697
698static void __exit exit_btuart_cs(void)
699{
700 pcmcia_unregister_driver(&btuart_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701}
702
703module_init(init_btuart_cs);
704module_exit(exit_btuart_cs);