1 | /* |
2 | * |
3 | * Bluetooth driver for the Anycom BlueCard (LSE039/LSE041) |
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/sched.h> |
30 | #include <linux/delay.h> |
31 | #include <linux/timer.h> |
32 | #include <linux/errno.h> |
33 | #include <linux/ptrace.h> |
34 | #include <linux/ioport.h> |
35 | #include <linux/spinlock.h> |
36 | #include <linux/moduleparam.h> |
37 | #include <linux/wait.h> |
38 | |
39 | #include <linux/skbuff.h> |
40 | #include <linux/io.h> |
41 | |
42 | #include <pcmcia/cistpl.h> |
43 | #include <pcmcia/ciscode.h> |
44 | #include <pcmcia/ds.h> |
45 | #include <pcmcia/cisreg.h> |
46 | |
47 | #include <net/bluetooth/bluetooth.h> |
48 | #include <net/bluetooth/hci_core.h> |
49 | |
50 | |
51 | |
52 | /* ======================== Module parameters ======================== */ |
53 | |
54 | |
55 | MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>" ); |
56 | MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)" ); |
57 | MODULE_LICENSE("GPL" ); |
58 | |
59 | |
60 | |
61 | /* ======================== Local structures ======================== */ |
62 | |
63 | |
64 | struct bluecard_info { |
65 | struct pcmcia_device *p_dev; |
66 | |
67 | struct hci_dev *hdev; |
68 | |
69 | spinlock_t lock; /* For serializing operations */ |
70 | struct timer_list timer; /* For LED control */ |
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 | unsigned char ctrl_reg; |
80 | unsigned long hw_state; /* Status of the hardware and LED control */ |
81 | }; |
82 | |
83 | |
84 | static int bluecard_config(struct pcmcia_device *link); |
85 | static void bluecard_release(struct pcmcia_device *link); |
86 | |
87 | static void bluecard_detach(struct pcmcia_device *p_dev); |
88 | |
89 | |
90 | /* Default baud rate: 57600, 115200, 230400 or 460800 */ |
91 | #define DEFAULT_BAUD_RATE 230400 |
92 | |
93 | |
94 | /* Hardware states */ |
95 | #define CARD_READY 1 |
96 | #define CARD_ACTIVITY 2 |
97 | #define CARD_HAS_PCCARD_ID 4 |
98 | #define CARD_HAS_POWER_LED 5 |
99 | #define CARD_HAS_ACTIVITY_LED 6 |
100 | |
101 | /* Transmit states */ |
102 | #define XMIT_SENDING 1 |
103 | #define XMIT_WAKEUP 2 |
104 | #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */ |
105 | #define XMIT_BUF_ONE_READY 6 |
106 | #define XMIT_BUF_TWO_READY 7 |
107 | #define XMIT_SENDING_READY 8 |
108 | |
109 | /* Receiver states */ |
110 | #define RECV_WAIT_PACKET_TYPE 0 |
111 | #define 1 |
112 | #define 2 |
113 | #define 3 |
114 | #define RECV_WAIT_DATA 4 |
115 | |
116 | /* Special packet types */ |
117 | #define PKT_BAUD_RATE_57600 0x80 |
118 | #define PKT_BAUD_RATE_115200 0x81 |
119 | #define PKT_BAUD_RATE_230400 0x82 |
120 | #define PKT_BAUD_RATE_460800 0x83 |
121 | |
122 | |
123 | /* These are the register offsets */ |
124 | #define REG_COMMAND 0x20 |
125 | #define REG_INTERRUPT 0x21 |
126 | #define REG_CONTROL 0x22 |
127 | #define REG_RX_CONTROL 0x24 |
128 | #define REG_CARD_RESET 0x30 |
129 | #define REG_LED_CTRL 0x30 |
130 | |
131 | /* REG_COMMAND */ |
132 | #define REG_COMMAND_TX_BUF_ONE 0x01 |
133 | #define REG_COMMAND_TX_BUF_TWO 0x02 |
134 | #define REG_COMMAND_RX_BUF_ONE 0x04 |
135 | #define REG_COMMAND_RX_BUF_TWO 0x08 |
136 | #define REG_COMMAND_RX_WIN_ONE 0x00 |
137 | #define REG_COMMAND_RX_WIN_TWO 0x10 |
138 | |
139 | /* REG_CONTROL */ |
140 | #define REG_CONTROL_BAUD_RATE_57600 0x00 |
141 | #define REG_CONTROL_BAUD_RATE_115200 0x01 |
142 | #define REG_CONTROL_BAUD_RATE_230400 0x02 |
143 | #define REG_CONTROL_BAUD_RATE_460800 0x03 |
144 | #define REG_CONTROL_RTS 0x04 |
145 | #define REG_CONTROL_BT_ON 0x08 |
146 | #define REG_CONTROL_BT_RESET 0x10 |
147 | #define REG_CONTROL_BT_RES_PU 0x20 |
148 | #define REG_CONTROL_INTERRUPT 0x40 |
149 | #define REG_CONTROL_CARD_RESET 0x80 |
150 | |
151 | /* REG_RX_CONTROL */ |
152 | #define RTS_LEVEL_SHIFT_BITS 0x02 |
153 | |
154 | |
155 | |
156 | /* ======================== LED handling routines ======================== */ |
157 | |
158 | |
159 | static void bluecard_activity_led_timeout(struct timer_list *t) |
160 | { |
161 | struct bluecard_info *info = from_timer(info, t, timer); |
162 | unsigned int iobase = info->p_dev->resource[0]->start; |
163 | |
164 | if (test_bit(CARD_ACTIVITY, &(info->hw_state))) { |
165 | /* leave LED in inactive state for HZ/10 for blink effect */ |
166 | clear_bit(CARD_ACTIVITY, addr: &(info->hw_state)); |
167 | mod_timer(timer: &(info->timer), expires: jiffies + HZ / 10); |
168 | } |
169 | |
170 | /* Disable activity LED, enable power LED */ |
171 | outb(value: 0x08 | 0x20, port: iobase + 0x30); |
172 | } |
173 | |
174 | |
175 | static void bluecard_enable_activity_led(struct bluecard_info *info) |
176 | { |
177 | unsigned int iobase = info->p_dev->resource[0]->start; |
178 | |
179 | /* don't disturb running blink timer */ |
180 | if (timer_pending(timer: &(info->timer))) |
181 | return; |
182 | |
183 | set_bit(CARD_ACTIVITY, addr: &(info->hw_state)); |
184 | |
185 | if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) { |
186 | /* Enable activity LED, keep power LED enabled */ |
187 | outb(value: 0x18 | 0x60, port: iobase + 0x30); |
188 | } else { |
189 | /* Disable power LED */ |
190 | outb(value: 0x00, port: iobase + 0x30); |
191 | } |
192 | |
193 | /* Stop the LED after HZ/10 */ |
194 | mod_timer(timer: &(info->timer), expires: jiffies + HZ / 10); |
195 | } |
196 | |
197 | |
198 | |
199 | /* ======================== Interrupt handling ======================== */ |
200 | |
201 | |
202 | static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len) |
203 | { |
204 | int i, actual; |
205 | |
206 | actual = (len > 15) ? 15 : len; |
207 | |
208 | outb_p(value: actual, port: iobase + offset); |
209 | |
210 | for (i = 0; i < actual; i++) |
211 | outb_p(value: buf[i], port: iobase + offset + i + 1); |
212 | |
213 | return actual; |
214 | } |
215 | |
216 | |
217 | static void bluecard_write_wakeup(struct bluecard_info *info) |
218 | { |
219 | if (!info) { |
220 | BT_ERR("Unknown device" ); |
221 | return; |
222 | } |
223 | |
224 | if (!test_bit(XMIT_SENDING_READY, &(info->tx_state))) |
225 | return; |
226 | |
227 | if (test_and_set_bit(XMIT_SENDING, addr: &(info->tx_state))) { |
228 | set_bit(XMIT_WAKEUP, addr: &(info->tx_state)); |
229 | return; |
230 | } |
231 | |
232 | do { |
233 | unsigned int iobase = info->p_dev->resource[0]->start; |
234 | unsigned int offset; |
235 | unsigned char command; |
236 | unsigned long ready_bit; |
237 | register struct sk_buff *skb; |
238 | int len; |
239 | |
240 | clear_bit(XMIT_WAKEUP, addr: &(info->tx_state)); |
241 | |
242 | if (!pcmcia_dev_present(p_dev: info->p_dev)) |
243 | return; |
244 | |
245 | if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) { |
246 | if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state))) |
247 | break; |
248 | offset = 0x10; |
249 | command = REG_COMMAND_TX_BUF_TWO; |
250 | ready_bit = XMIT_BUF_TWO_READY; |
251 | } else { |
252 | if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state))) |
253 | break; |
254 | offset = 0x00; |
255 | command = REG_COMMAND_TX_BUF_ONE; |
256 | ready_bit = XMIT_BUF_ONE_READY; |
257 | } |
258 | |
259 | skb = skb_dequeue(list: &(info->txq)); |
260 | if (!skb) |
261 | break; |
262 | |
263 | if (hci_skb_pkt_type(skb) & 0x80) { |
264 | /* Disable RTS */ |
265 | info->ctrl_reg |= REG_CONTROL_RTS; |
266 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
267 | } |
268 | |
269 | /* Activate LED */ |
270 | bluecard_enable_activity_led(info); |
271 | |
272 | /* Send frame */ |
273 | len = bluecard_write(iobase, offset, buf: skb->data, len: skb->len); |
274 | |
275 | /* Tell the FPGA to send the data */ |
276 | outb_p(value: command, port: iobase + REG_COMMAND); |
277 | |
278 | /* Mark the buffer as dirty */ |
279 | clear_bit(nr: ready_bit, addr: &(info->tx_state)); |
280 | |
281 | if (hci_skb_pkt_type(skb) & 0x80) { |
282 | DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq); |
283 | DEFINE_WAIT(wait); |
284 | |
285 | unsigned char baud_reg; |
286 | |
287 | switch (hci_skb_pkt_type(skb)) { |
288 | case PKT_BAUD_RATE_460800: |
289 | baud_reg = REG_CONTROL_BAUD_RATE_460800; |
290 | break; |
291 | case PKT_BAUD_RATE_230400: |
292 | baud_reg = REG_CONTROL_BAUD_RATE_230400; |
293 | break; |
294 | case PKT_BAUD_RATE_115200: |
295 | baud_reg = REG_CONTROL_BAUD_RATE_115200; |
296 | break; |
297 | case PKT_BAUD_RATE_57600: |
298 | default: |
299 | baud_reg = REG_CONTROL_BAUD_RATE_57600; |
300 | break; |
301 | } |
302 | |
303 | /* Wait until the command reaches the baseband */ |
304 | mdelay(100); |
305 | |
306 | /* Set baud on baseband */ |
307 | info->ctrl_reg &= ~0x03; |
308 | info->ctrl_reg |= baud_reg; |
309 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
310 | |
311 | /* Enable RTS */ |
312 | info->ctrl_reg &= ~REG_CONTROL_RTS; |
313 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
314 | |
315 | /* Wait before the next HCI packet can be send */ |
316 | mdelay(1000); |
317 | } |
318 | |
319 | if (len == skb->len) { |
320 | kfree_skb(skb); |
321 | } else { |
322 | skb_pull(skb, len); |
323 | skb_queue_head(list: &(info->txq), newsk: skb); |
324 | } |
325 | |
326 | info->hdev->stat.byte_tx += len; |
327 | |
328 | /* Change buffer */ |
329 | change_bit(XMIT_BUFFER_NUMBER, addr: &(info->tx_state)); |
330 | |
331 | } while (test_bit(XMIT_WAKEUP, &(info->tx_state))); |
332 | |
333 | clear_bit(XMIT_SENDING, addr: &(info->tx_state)); |
334 | } |
335 | |
336 | |
337 | static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size) |
338 | { |
339 | int i, n, len; |
340 | |
341 | outb(REG_COMMAND_RX_WIN_ONE, port: iobase + REG_COMMAND); |
342 | |
343 | len = inb(port: iobase + offset); |
344 | n = 0; |
345 | i = 1; |
346 | |
347 | while (n < len) { |
348 | |
349 | if (i == 16) { |
350 | outb(REG_COMMAND_RX_WIN_TWO, port: iobase + REG_COMMAND); |
351 | i = 0; |
352 | } |
353 | |
354 | buf[n] = inb(port: iobase + offset + i); |
355 | |
356 | n++; |
357 | i++; |
358 | |
359 | } |
360 | |
361 | return len; |
362 | } |
363 | |
364 | |
365 | static void bluecard_receive(struct bluecard_info *info, |
366 | unsigned int offset) |
367 | { |
368 | unsigned int iobase; |
369 | unsigned char buf[31]; |
370 | int i, len; |
371 | |
372 | if (!info) { |
373 | BT_ERR("Unknown device" ); |
374 | return; |
375 | } |
376 | |
377 | iobase = info->p_dev->resource[0]->start; |
378 | |
379 | if (test_bit(XMIT_SENDING_READY, &(info->tx_state))) |
380 | bluecard_enable_activity_led(info); |
381 | |
382 | len = bluecard_read(iobase, offset, buf, size: sizeof(buf)); |
383 | |
384 | for (i = 0; i < len; i++) { |
385 | |
386 | /* Allocate packet */ |
387 | if (!info->rx_skb) { |
388 | info->rx_state = RECV_WAIT_PACKET_TYPE; |
389 | info->rx_count = 0; |
390 | info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC); |
391 | if (!info->rx_skb) { |
392 | BT_ERR("Can't allocate mem for new packet" ); |
393 | return; |
394 | } |
395 | } |
396 | |
397 | if (info->rx_state == RECV_WAIT_PACKET_TYPE) { |
398 | |
399 | hci_skb_pkt_type(info->rx_skb) = buf[i]; |
400 | |
401 | switch (hci_skb_pkt_type(info->rx_skb)) { |
402 | |
403 | case 0x00: |
404 | /* init packet */ |
405 | if (offset != 0x00) { |
406 | set_bit(XMIT_BUF_ONE_READY, addr: &(info->tx_state)); |
407 | set_bit(XMIT_BUF_TWO_READY, addr: &(info->tx_state)); |
408 | set_bit(XMIT_SENDING_READY, addr: &(info->tx_state)); |
409 | bluecard_write_wakeup(info); |
410 | } |
411 | |
412 | kfree_skb(skb: info->rx_skb); |
413 | info->rx_skb = NULL; |
414 | break; |
415 | |
416 | case HCI_EVENT_PKT: |
417 | info->rx_state = RECV_WAIT_EVENT_HEADER; |
418 | info->rx_count = HCI_EVENT_HDR_SIZE; |
419 | break; |
420 | |
421 | case HCI_ACLDATA_PKT: |
422 | info->rx_state = RECV_WAIT_ACL_HEADER; |
423 | info->rx_count = HCI_ACL_HDR_SIZE; |
424 | break; |
425 | |
426 | case HCI_SCODATA_PKT: |
427 | info->rx_state = RECV_WAIT_SCO_HEADER; |
428 | info->rx_count = HCI_SCO_HDR_SIZE; |
429 | break; |
430 | |
431 | default: |
432 | /* unknown packet */ |
433 | BT_ERR("Unknown HCI packet with type 0x%02x received" , |
434 | hci_skb_pkt_type(info->rx_skb)); |
435 | info->hdev->stat.err_rx++; |
436 | |
437 | kfree_skb(skb: info->rx_skb); |
438 | info->rx_skb = NULL; |
439 | break; |
440 | |
441 | } |
442 | |
443 | } else { |
444 | |
445 | skb_put_u8(skb: info->rx_skb, val: buf[i]); |
446 | info->rx_count--; |
447 | |
448 | if (info->rx_count == 0) { |
449 | |
450 | int dlen; |
451 | struct hci_event_hdr *eh; |
452 | struct hci_acl_hdr *ah; |
453 | struct hci_sco_hdr *sh; |
454 | |
455 | switch (info->rx_state) { |
456 | |
457 | case RECV_WAIT_EVENT_HEADER: |
458 | eh = hci_event_hdr(skb: info->rx_skb); |
459 | info->rx_state = RECV_WAIT_DATA; |
460 | info->rx_count = eh->plen; |
461 | break; |
462 | |
463 | case RECV_WAIT_ACL_HEADER: |
464 | ah = hci_acl_hdr(skb: info->rx_skb); |
465 | dlen = __le16_to_cpu(ah->dlen); |
466 | info->rx_state = RECV_WAIT_DATA; |
467 | info->rx_count = dlen; |
468 | break; |
469 | |
470 | case RECV_WAIT_SCO_HEADER: |
471 | sh = hci_sco_hdr(skb: info->rx_skb); |
472 | info->rx_state = RECV_WAIT_DATA; |
473 | info->rx_count = sh->dlen; |
474 | break; |
475 | |
476 | case RECV_WAIT_DATA: |
477 | hci_recv_frame(hdev: info->hdev, skb: info->rx_skb); |
478 | info->rx_skb = NULL; |
479 | break; |
480 | |
481 | } |
482 | |
483 | } |
484 | |
485 | } |
486 | |
487 | |
488 | } |
489 | |
490 | info->hdev->stat.byte_rx += len; |
491 | } |
492 | |
493 | |
494 | static irqreturn_t bluecard_interrupt(int irq, void *dev_inst) |
495 | { |
496 | struct bluecard_info *info = dev_inst; |
497 | unsigned int iobase; |
498 | unsigned char reg; |
499 | |
500 | if (!info || !info->hdev) |
501 | /* our irq handler is shared */ |
502 | return IRQ_NONE; |
503 | |
504 | if (!test_bit(CARD_READY, &(info->hw_state))) |
505 | return IRQ_HANDLED; |
506 | |
507 | iobase = info->p_dev->resource[0]->start; |
508 | |
509 | spin_lock(lock: &(info->lock)); |
510 | |
511 | /* Disable interrupt */ |
512 | info->ctrl_reg &= ~REG_CONTROL_INTERRUPT; |
513 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
514 | |
515 | reg = inb(port: iobase + REG_INTERRUPT); |
516 | |
517 | if ((reg != 0x00) && (reg != 0xff)) { |
518 | |
519 | if (reg & 0x04) { |
520 | bluecard_receive(info, offset: 0x00); |
521 | outb(value: 0x04, port: iobase + REG_INTERRUPT); |
522 | outb(REG_COMMAND_RX_BUF_ONE, port: iobase + REG_COMMAND); |
523 | } |
524 | |
525 | if (reg & 0x08) { |
526 | bluecard_receive(info, offset: 0x10); |
527 | outb(value: 0x08, port: iobase + REG_INTERRUPT); |
528 | outb(REG_COMMAND_RX_BUF_TWO, port: iobase + REG_COMMAND); |
529 | } |
530 | |
531 | if (reg & 0x01) { |
532 | set_bit(XMIT_BUF_ONE_READY, addr: &(info->tx_state)); |
533 | outb(value: 0x01, port: iobase + REG_INTERRUPT); |
534 | bluecard_write_wakeup(info); |
535 | } |
536 | |
537 | if (reg & 0x02) { |
538 | set_bit(XMIT_BUF_TWO_READY, addr: &(info->tx_state)); |
539 | outb(value: 0x02, port: iobase + REG_INTERRUPT); |
540 | bluecard_write_wakeup(info); |
541 | } |
542 | |
543 | } |
544 | |
545 | /* Enable interrupt */ |
546 | info->ctrl_reg |= REG_CONTROL_INTERRUPT; |
547 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
548 | |
549 | spin_unlock(lock: &(info->lock)); |
550 | |
551 | return IRQ_HANDLED; |
552 | } |
553 | |
554 | |
555 | |
556 | /* ======================== Device specific HCI commands ======================== */ |
557 | |
558 | |
559 | static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud) |
560 | { |
561 | struct bluecard_info *info = hci_get_drvdata(hdev); |
562 | struct sk_buff *skb; |
563 | |
564 | /* Ericsson baud rate command */ |
565 | unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 }; |
566 | |
567 | skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_KERNEL); |
568 | if (!skb) { |
569 | BT_ERR("Can't allocate mem for new packet" ); |
570 | return -1; |
571 | } |
572 | |
573 | switch (baud) { |
574 | case 460800: |
575 | cmd[4] = 0x00; |
576 | hci_skb_pkt_type(skb) = PKT_BAUD_RATE_460800; |
577 | break; |
578 | case 230400: |
579 | cmd[4] = 0x01; |
580 | hci_skb_pkt_type(skb) = PKT_BAUD_RATE_230400; |
581 | break; |
582 | case 115200: |
583 | cmd[4] = 0x02; |
584 | hci_skb_pkt_type(skb) = PKT_BAUD_RATE_115200; |
585 | break; |
586 | case 57600: |
587 | default: |
588 | cmd[4] = 0x03; |
589 | hci_skb_pkt_type(skb) = PKT_BAUD_RATE_57600; |
590 | break; |
591 | } |
592 | |
593 | skb_put_data(skb, data: cmd, len: sizeof(cmd)); |
594 | |
595 | skb_queue_tail(list: &(info->txq), newsk: skb); |
596 | |
597 | bluecard_write_wakeup(info); |
598 | |
599 | return 0; |
600 | } |
601 | |
602 | |
603 | |
604 | /* ======================== HCI interface ======================== */ |
605 | |
606 | |
607 | static int bluecard_hci_flush(struct hci_dev *hdev) |
608 | { |
609 | struct bluecard_info *info = hci_get_drvdata(hdev); |
610 | |
611 | /* Drop TX queue */ |
612 | skb_queue_purge(list: &(info->txq)); |
613 | |
614 | return 0; |
615 | } |
616 | |
617 | |
618 | static int bluecard_hci_open(struct hci_dev *hdev) |
619 | { |
620 | struct bluecard_info *info = hci_get_drvdata(hdev); |
621 | unsigned int iobase = info->p_dev->resource[0]->start; |
622 | |
623 | if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) |
624 | bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE); |
625 | |
626 | /* Enable power LED */ |
627 | outb(value: 0x08 | 0x20, port: iobase + 0x30); |
628 | |
629 | return 0; |
630 | } |
631 | |
632 | |
633 | static int bluecard_hci_close(struct hci_dev *hdev) |
634 | { |
635 | struct bluecard_info *info = hci_get_drvdata(hdev); |
636 | unsigned int iobase = info->p_dev->resource[0]->start; |
637 | |
638 | bluecard_hci_flush(hdev); |
639 | |
640 | /* Stop LED timer */ |
641 | del_timer_sync(timer: &(info->timer)); |
642 | |
643 | /* Disable power LED */ |
644 | outb(value: 0x00, port: iobase + 0x30); |
645 | |
646 | return 0; |
647 | } |
648 | |
649 | |
650 | static int bluecard_hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) |
651 | { |
652 | struct bluecard_info *info = hci_get_drvdata(hdev); |
653 | |
654 | switch (hci_skb_pkt_type(skb)) { |
655 | case HCI_COMMAND_PKT: |
656 | hdev->stat.cmd_tx++; |
657 | break; |
658 | case HCI_ACLDATA_PKT: |
659 | hdev->stat.acl_tx++; |
660 | break; |
661 | case HCI_SCODATA_PKT: |
662 | hdev->stat.sco_tx++; |
663 | break; |
664 | } |
665 | |
666 | /* Prepend skb with frame type */ |
667 | memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); |
668 | skb_queue_tail(list: &(info->txq), newsk: skb); |
669 | |
670 | bluecard_write_wakeup(info); |
671 | |
672 | return 0; |
673 | } |
674 | |
675 | |
676 | |
677 | /* ======================== Card services HCI interaction ======================== */ |
678 | |
679 | |
680 | static int bluecard_open(struct bluecard_info *info) |
681 | { |
682 | unsigned int iobase = info->p_dev->resource[0]->start; |
683 | struct hci_dev *hdev; |
684 | unsigned char id; |
685 | |
686 | spin_lock_init(&(info->lock)); |
687 | |
688 | timer_setup(&info->timer, bluecard_activity_led_timeout, 0); |
689 | |
690 | skb_queue_head_init(list: &(info->txq)); |
691 | |
692 | info->rx_state = RECV_WAIT_PACKET_TYPE; |
693 | info->rx_count = 0; |
694 | info->rx_skb = NULL; |
695 | |
696 | /* Initialize HCI device */ |
697 | hdev = hci_alloc_dev(); |
698 | if (!hdev) { |
699 | BT_ERR("Can't allocate HCI device" ); |
700 | return -ENOMEM; |
701 | } |
702 | |
703 | info->hdev = hdev; |
704 | |
705 | hdev->bus = HCI_PCCARD; |
706 | hci_set_drvdata(hdev, data: info); |
707 | SET_HCIDEV_DEV(hdev, &info->p_dev->dev); |
708 | |
709 | hdev->open = bluecard_hci_open; |
710 | hdev->close = bluecard_hci_close; |
711 | hdev->flush = bluecard_hci_flush; |
712 | hdev->send = bluecard_hci_send_frame; |
713 | |
714 | id = inb(port: iobase + 0x30); |
715 | |
716 | if ((id & 0x0f) == 0x02) |
717 | set_bit(CARD_HAS_PCCARD_ID, addr: &(info->hw_state)); |
718 | |
719 | if (id & 0x10) |
720 | set_bit(CARD_HAS_POWER_LED, addr: &(info->hw_state)); |
721 | |
722 | if (id & 0x20) |
723 | set_bit(CARD_HAS_ACTIVITY_LED, addr: &(info->hw_state)); |
724 | |
725 | /* Reset card */ |
726 | info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; |
727 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
728 | |
729 | /* Turn FPGA off */ |
730 | outb(value: 0x80, port: iobase + 0x30); |
731 | |
732 | /* Wait some time */ |
733 | msleep(msecs: 10); |
734 | |
735 | /* Turn FPGA on */ |
736 | outb(value: 0x00, port: iobase + 0x30); |
737 | |
738 | /* Activate card */ |
739 | info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU; |
740 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
741 | |
742 | /* Enable interrupt */ |
743 | outb(value: 0xff, port: iobase + REG_INTERRUPT); |
744 | info->ctrl_reg |= REG_CONTROL_INTERRUPT; |
745 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
746 | |
747 | if ((id & 0x0f) == 0x03) { |
748 | /* Disable RTS */ |
749 | info->ctrl_reg |= REG_CONTROL_RTS; |
750 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
751 | |
752 | /* Set baud rate */ |
753 | info->ctrl_reg |= 0x03; |
754 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
755 | |
756 | /* Enable RTS */ |
757 | info->ctrl_reg &= ~REG_CONTROL_RTS; |
758 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
759 | |
760 | set_bit(XMIT_BUF_ONE_READY, addr: &(info->tx_state)); |
761 | set_bit(XMIT_BUF_TWO_READY, addr: &(info->tx_state)); |
762 | set_bit(XMIT_SENDING_READY, addr: &(info->tx_state)); |
763 | } |
764 | |
765 | /* Start the RX buffers */ |
766 | outb(REG_COMMAND_RX_BUF_ONE, port: iobase + REG_COMMAND); |
767 | outb(REG_COMMAND_RX_BUF_TWO, port: iobase + REG_COMMAND); |
768 | |
769 | /* Signal that the hardware is ready */ |
770 | set_bit(CARD_READY, addr: &(info->hw_state)); |
771 | |
772 | /* Drop TX queue */ |
773 | skb_queue_purge(list: &(info->txq)); |
774 | |
775 | /* Control the point at which RTS is enabled */ |
776 | outb(value: (0x0f << RTS_LEVEL_SHIFT_BITS) | 1, port: iobase + REG_RX_CONTROL); |
777 | |
778 | /* Timeout before it is safe to send the first HCI packet */ |
779 | msleep(msecs: 1250); |
780 | |
781 | /* Register HCI device */ |
782 | if (hci_register_dev(hdev) < 0) { |
783 | BT_ERR("Can't register HCI device" ); |
784 | info->hdev = NULL; |
785 | hci_free_dev(hdev); |
786 | return -ENODEV; |
787 | } |
788 | |
789 | return 0; |
790 | } |
791 | |
792 | |
793 | static int bluecard_close(struct bluecard_info *info) |
794 | { |
795 | unsigned int iobase = info->p_dev->resource[0]->start; |
796 | struct hci_dev *hdev = info->hdev; |
797 | |
798 | if (!hdev) |
799 | return -ENODEV; |
800 | |
801 | bluecard_hci_close(hdev); |
802 | |
803 | clear_bit(CARD_READY, addr: &(info->hw_state)); |
804 | |
805 | /* Reset card */ |
806 | info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET; |
807 | outb(value: info->ctrl_reg, port: iobase + REG_CONTROL); |
808 | |
809 | /* Turn FPGA off */ |
810 | outb(value: 0x80, port: iobase + 0x30); |
811 | |
812 | hci_unregister_dev(hdev); |
813 | hci_free_dev(hdev); |
814 | |
815 | return 0; |
816 | } |
817 | |
818 | static int bluecard_probe(struct pcmcia_device *link) |
819 | { |
820 | struct bluecard_info *info; |
821 | |
822 | /* Create new info device */ |
823 | info = devm_kzalloc(dev: &link->dev, size: sizeof(*info), GFP_KERNEL); |
824 | if (!info) |
825 | return -ENOMEM; |
826 | |
827 | info->p_dev = link; |
828 | link->priv = info; |
829 | |
830 | link->config_flags |= CONF_ENABLE_IRQ; |
831 | |
832 | return bluecard_config(link); |
833 | } |
834 | |
835 | |
836 | static void bluecard_detach(struct pcmcia_device *link) |
837 | { |
838 | bluecard_release(link); |
839 | } |
840 | |
841 | |
842 | static int bluecard_config(struct pcmcia_device *link) |
843 | { |
844 | struct bluecard_info *info = link->priv; |
845 | int i, n; |
846 | |
847 | link->config_index = 0x20; |
848 | |
849 | link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8; |
850 | link->resource[0]->end = 64; |
851 | link->io_lines = 6; |
852 | |
853 | for (n = 0; n < 0x400; n += 0x40) { |
854 | link->resource[0]->start = n ^ 0x300; |
855 | i = pcmcia_request_io(p_dev: link); |
856 | if (i == 0) |
857 | break; |
858 | } |
859 | |
860 | if (i != 0) |
861 | goto failed; |
862 | |
863 | i = pcmcia_request_irq(p_dev: link, handler: bluecard_interrupt); |
864 | if (i != 0) |
865 | goto failed; |
866 | |
867 | i = pcmcia_enable_device(p_dev: link); |
868 | if (i != 0) |
869 | goto failed; |
870 | |
871 | if (bluecard_open(info) != 0) |
872 | goto failed; |
873 | |
874 | return 0; |
875 | |
876 | failed: |
877 | bluecard_release(link); |
878 | return -ENODEV; |
879 | } |
880 | |
881 | |
882 | static void bluecard_release(struct pcmcia_device *link) |
883 | { |
884 | struct bluecard_info *info = link->priv; |
885 | |
886 | bluecard_close(info); |
887 | |
888 | del_timer_sync(timer: &(info->timer)); |
889 | |
890 | pcmcia_disable_device(p_dev: link); |
891 | } |
892 | |
893 | static const struct pcmcia_device_id bluecard_ids[] = { |
894 | PCMCIA_DEVICE_PROD_ID12("BlueCard" , "LSE041" , 0xbaf16fbf, 0x657cc15e), |
895 | PCMCIA_DEVICE_PROD_ID12("BTCFCARD" , "LSE139" , 0xe3987764, 0x2524b59c), |
896 | PCMCIA_DEVICE_PROD_ID12("WSS" , "LSE039" , 0x0a0736ec, 0x24e6dfab), |
897 | PCMCIA_DEVICE_NULL |
898 | }; |
899 | MODULE_DEVICE_TABLE(pcmcia, bluecard_ids); |
900 | |
901 | static struct pcmcia_driver bluecard_driver = { |
902 | .owner = THIS_MODULE, |
903 | .name = "bluecard_cs" , |
904 | .probe = bluecard_probe, |
905 | .remove = bluecard_detach, |
906 | .id_table = bluecard_ids, |
907 | }; |
908 | module_pcmcia_driver(bluecard_driver); |
909 | |