ia64/linux-2.6.18-xen.hg

view drivers/bluetooth/bluecard_cs.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
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 */
23 #include <linux/module.h>
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>
39 #include <linux/skbuff.h>
40 #include <asm/io.h>
42 #include <pcmcia/cs_types.h>
43 #include <pcmcia/cs.h>
44 #include <pcmcia/cistpl.h>
45 #include <pcmcia/ciscode.h>
46 #include <pcmcia/ds.h>
47 #include <pcmcia/cisreg.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
54 /* ======================== Module parameters ======================== */
57 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
58 MODULE_DESCRIPTION("Bluetooth driver for the Anycom BlueCard (LSE039/LSE041)");
59 MODULE_LICENSE("GPL");
63 /* ======================== Local structures ======================== */
66 typedef struct bluecard_info_t {
67 struct pcmcia_device *p_dev;
68 dev_node_t node;
70 struct hci_dev *hdev;
72 spinlock_t lock; /* For serializing operations */
73 struct timer_list timer; /* For LED control */
75 struct sk_buff_head txq;
76 unsigned long tx_state;
78 unsigned long rx_state;
79 unsigned long rx_count;
80 struct sk_buff *rx_skb;
82 unsigned char ctrl_reg;
83 unsigned long hw_state; /* Status of the hardware and LED control */
84 } bluecard_info_t;
87 static int bluecard_config(struct pcmcia_device *link);
88 static void bluecard_release(struct pcmcia_device *link);
90 static void bluecard_detach(struct pcmcia_device *p_dev);
93 /* Default baud rate: 57600, 115200, 230400 or 460800 */
94 #define DEFAULT_BAUD_RATE 230400
97 /* Hardware states */
98 #define CARD_READY 1
99 #define CARD_HAS_PCCARD_ID 4
100 #define CARD_HAS_POWER_LED 5
101 #define CARD_HAS_ACTIVITY_LED 6
103 /* Transmit states */
104 #define XMIT_SENDING 1
105 #define XMIT_WAKEUP 2
106 #define XMIT_BUFFER_NUMBER 5 /* unset = buffer one, set = buffer two */
107 #define XMIT_BUF_ONE_READY 6
108 #define XMIT_BUF_TWO_READY 7
109 #define XMIT_SENDING_READY 8
111 /* Receiver states */
112 #define RECV_WAIT_PACKET_TYPE 0
113 #define RECV_WAIT_EVENT_HEADER 1
114 #define RECV_WAIT_ACL_HEADER 2
115 #define RECV_WAIT_SCO_HEADER 3
116 #define RECV_WAIT_DATA 4
118 /* Special packet types */
119 #define PKT_BAUD_RATE_57600 0x80
120 #define PKT_BAUD_RATE_115200 0x81
121 #define PKT_BAUD_RATE_230400 0x82
122 #define PKT_BAUD_RATE_460800 0x83
125 /* These are the register offsets */
126 #define REG_COMMAND 0x20
127 #define REG_INTERRUPT 0x21
128 #define REG_CONTROL 0x22
129 #define REG_RX_CONTROL 0x24
130 #define REG_CARD_RESET 0x30
131 #define REG_LED_CTRL 0x30
133 /* REG_COMMAND */
134 #define REG_COMMAND_TX_BUF_ONE 0x01
135 #define REG_COMMAND_TX_BUF_TWO 0x02
136 #define REG_COMMAND_RX_BUF_ONE 0x04
137 #define REG_COMMAND_RX_BUF_TWO 0x08
138 #define REG_COMMAND_RX_WIN_ONE 0x00
139 #define REG_COMMAND_RX_WIN_TWO 0x10
141 /* REG_CONTROL */
142 #define REG_CONTROL_BAUD_RATE_57600 0x00
143 #define REG_CONTROL_BAUD_RATE_115200 0x01
144 #define REG_CONTROL_BAUD_RATE_230400 0x02
145 #define REG_CONTROL_BAUD_RATE_460800 0x03
146 #define REG_CONTROL_RTS 0x04
147 #define REG_CONTROL_BT_ON 0x08
148 #define REG_CONTROL_BT_RESET 0x10
149 #define REG_CONTROL_BT_RES_PU 0x20
150 #define REG_CONTROL_INTERRUPT 0x40
151 #define REG_CONTROL_CARD_RESET 0x80
153 /* REG_RX_CONTROL */
154 #define RTS_LEVEL_SHIFT_BITS 0x02
158 /* ======================== LED handling routines ======================== */
161 static void bluecard_activity_led_timeout(u_long arg)
162 {
163 bluecard_info_t *info = (bluecard_info_t *)arg;
164 unsigned int iobase = info->p_dev->io.BasePort1;
166 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
167 return;
169 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
170 /* Disable activity LED */
171 outb(0x08 | 0x20, iobase + 0x30);
172 } else {
173 /* Disable power LED */
174 outb(0x00, iobase + 0x30);
175 }
176 }
179 static void bluecard_enable_activity_led(bluecard_info_t *info)
180 {
181 unsigned int iobase = info->p_dev->io.BasePort1;
183 if (!test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
184 return;
186 if (test_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state))) {
187 /* Enable activity LED */
188 outb(0x10 | 0x40, iobase + 0x30);
190 /* Stop the LED after HZ/4 */
191 mod_timer(&(info->timer), jiffies + HZ / 4);
192 } else {
193 /* Enable power LED */
194 outb(0x08 | 0x20, iobase + 0x30);
196 /* Stop the LED after HZ/2 */
197 mod_timer(&(info->timer), jiffies + HZ / 2);
198 }
199 }
203 /* ======================== Interrupt handling ======================== */
206 static int bluecard_write(unsigned int iobase, unsigned int offset, __u8 *buf, int len)
207 {
208 int i, actual;
210 actual = (len > 15) ? 15 : len;
212 outb_p(actual, iobase + offset);
214 for (i = 0; i < actual; i++)
215 outb_p(buf[i], iobase + offset + i + 1);
217 return actual;
218 }
221 static void bluecard_write_wakeup(bluecard_info_t *info)
222 {
223 if (!info) {
224 BT_ERR("Unknown device");
225 return;
226 }
228 if (!test_bit(XMIT_SENDING_READY, &(info->tx_state)))
229 return;
231 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
232 set_bit(XMIT_WAKEUP, &(info->tx_state));
233 return;
234 }
236 do {
237 register unsigned int iobase = info->p_dev->io.BasePort1;
238 register unsigned int offset;
239 register unsigned char command;
240 register unsigned long ready_bit;
241 register struct sk_buff *skb;
242 register int len;
244 clear_bit(XMIT_WAKEUP, &(info->tx_state));
246 if (!pcmcia_dev_present(info->p_dev))
247 return;
249 if (test_bit(XMIT_BUFFER_NUMBER, &(info->tx_state))) {
250 if (!test_bit(XMIT_BUF_TWO_READY, &(info->tx_state)))
251 break;
252 offset = 0x10;
253 command = REG_COMMAND_TX_BUF_TWO;
254 ready_bit = XMIT_BUF_TWO_READY;
255 } else {
256 if (!test_bit(XMIT_BUF_ONE_READY, &(info->tx_state)))
257 break;
258 offset = 0x00;
259 command = REG_COMMAND_TX_BUF_ONE;
260 ready_bit = XMIT_BUF_ONE_READY;
261 }
263 if (!(skb = skb_dequeue(&(info->txq))))
264 break;
266 if (bt_cb(skb)->pkt_type & 0x80) {
267 /* Disable RTS */
268 info->ctrl_reg |= REG_CONTROL_RTS;
269 outb(info->ctrl_reg, iobase + REG_CONTROL);
270 }
272 /* Activate LED */
273 bluecard_enable_activity_led(info);
275 /* Send frame */
276 len = bluecard_write(iobase, offset, skb->data, skb->len);
278 /* Tell the FPGA to send the data */
279 outb_p(command, iobase + REG_COMMAND);
281 /* Mark the buffer as dirty */
282 clear_bit(ready_bit, &(info->tx_state));
284 if (bt_cb(skb)->pkt_type & 0x80) {
285 DECLARE_WAIT_QUEUE_HEAD(wq);
286 DEFINE_WAIT(wait);
288 unsigned char baud_reg;
290 switch (bt_cb(skb)->pkt_type) {
291 case PKT_BAUD_RATE_460800:
292 baud_reg = REG_CONTROL_BAUD_RATE_460800;
293 break;
294 case PKT_BAUD_RATE_230400:
295 baud_reg = REG_CONTROL_BAUD_RATE_230400;
296 break;
297 case PKT_BAUD_RATE_115200:
298 baud_reg = REG_CONTROL_BAUD_RATE_115200;
299 break;
300 case PKT_BAUD_RATE_57600:
301 /* Fall through... */
302 default:
303 baud_reg = REG_CONTROL_BAUD_RATE_57600;
304 break;
305 }
307 /* Wait until the command reaches the baseband */
308 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
309 schedule_timeout(HZ/10);
310 finish_wait(&wq, &wait);
312 /* Set baud on baseband */
313 info->ctrl_reg &= ~0x03;
314 info->ctrl_reg |= baud_reg;
315 outb(info->ctrl_reg, iobase + REG_CONTROL);
317 /* Enable RTS */
318 info->ctrl_reg &= ~REG_CONTROL_RTS;
319 outb(info->ctrl_reg, iobase + REG_CONTROL);
321 /* Wait before the next HCI packet can be send */
322 prepare_to_wait(&wq, &wait, TASK_INTERRUPTIBLE);
323 schedule_timeout(HZ);
324 finish_wait(&wq, &wait);
325 }
327 if (len == skb->len) {
328 kfree_skb(skb);
329 } else {
330 skb_pull(skb, len);
331 skb_queue_head(&(info->txq), skb);
332 }
334 info->hdev->stat.byte_tx += len;
336 /* Change buffer */
337 change_bit(XMIT_BUFFER_NUMBER, &(info->tx_state));
339 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
341 clear_bit(XMIT_SENDING, &(info->tx_state));
342 }
345 static int bluecard_read(unsigned int iobase, unsigned int offset, __u8 *buf, int size)
346 {
347 int i, n, len;
349 outb(REG_COMMAND_RX_WIN_ONE, iobase + REG_COMMAND);
351 len = inb(iobase + offset);
352 n = 0;
353 i = 1;
355 while (n < len) {
357 if (i == 16) {
358 outb(REG_COMMAND_RX_WIN_TWO, iobase + REG_COMMAND);
359 i = 0;
360 }
362 buf[n] = inb(iobase + offset + i);
364 n++;
365 i++;
367 }
369 return len;
370 }
373 static void bluecard_receive(bluecard_info_t *info, unsigned int offset)
374 {
375 unsigned int iobase;
376 unsigned char buf[31];
377 int i, len;
379 if (!info) {
380 BT_ERR("Unknown device");
381 return;
382 }
384 iobase = info->p_dev->io.BasePort1;
386 if (test_bit(XMIT_SENDING_READY, &(info->tx_state)))
387 bluecard_enable_activity_led(info);
389 len = bluecard_read(iobase, offset, buf, sizeof(buf));
391 for (i = 0; i < len; i++) {
393 /* Allocate packet */
394 if (info->rx_skb == NULL) {
395 info->rx_state = RECV_WAIT_PACKET_TYPE;
396 info->rx_count = 0;
397 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
398 BT_ERR("Can't allocate mem for new packet");
399 return;
400 }
401 }
403 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
405 info->rx_skb->dev = (void *) info->hdev;
406 bt_cb(info->rx_skb)->pkt_type = buf[i];
408 switch (bt_cb(info->rx_skb)->pkt_type) {
410 case 0x00:
411 /* init packet */
412 if (offset != 0x00) {
413 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
414 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
415 set_bit(XMIT_SENDING_READY, &(info->tx_state));
416 bluecard_write_wakeup(info);
417 }
419 kfree_skb(info->rx_skb);
420 info->rx_skb = NULL;
421 break;
423 case HCI_EVENT_PKT:
424 info->rx_state = RECV_WAIT_EVENT_HEADER;
425 info->rx_count = HCI_EVENT_HDR_SIZE;
426 break;
428 case HCI_ACLDATA_PKT:
429 info->rx_state = RECV_WAIT_ACL_HEADER;
430 info->rx_count = HCI_ACL_HDR_SIZE;
431 break;
433 case HCI_SCODATA_PKT:
434 info->rx_state = RECV_WAIT_SCO_HEADER;
435 info->rx_count = HCI_SCO_HDR_SIZE;
436 break;
438 default:
439 /* unknown packet */
440 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
441 info->hdev->stat.err_rx++;
443 kfree_skb(info->rx_skb);
444 info->rx_skb = NULL;
445 break;
447 }
449 } else {
451 *skb_put(info->rx_skb, 1) = buf[i];
452 info->rx_count--;
454 if (info->rx_count == 0) {
456 int dlen;
457 struct hci_event_hdr *eh;
458 struct hci_acl_hdr *ah;
459 struct hci_sco_hdr *sh;
461 switch (info->rx_state) {
463 case RECV_WAIT_EVENT_HEADER:
464 eh = (struct hci_event_hdr *)(info->rx_skb->data);
465 info->rx_state = RECV_WAIT_DATA;
466 info->rx_count = eh->plen;
467 break;
469 case RECV_WAIT_ACL_HEADER:
470 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
471 dlen = __le16_to_cpu(ah->dlen);
472 info->rx_state = RECV_WAIT_DATA;
473 info->rx_count = dlen;
474 break;
476 case RECV_WAIT_SCO_HEADER:
477 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
478 info->rx_state = RECV_WAIT_DATA;
479 info->rx_count = sh->dlen;
480 break;
482 case RECV_WAIT_DATA:
483 hci_recv_frame(info->rx_skb);
484 info->rx_skb = NULL;
485 break;
487 }
489 }
491 }
494 }
496 info->hdev->stat.byte_rx += len;
497 }
500 static irqreturn_t bluecard_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
501 {
502 bluecard_info_t *info = dev_inst;
503 unsigned int iobase;
504 unsigned char reg;
506 if (!info || !info->hdev) {
507 BT_ERR("Call of irq %d for unknown device", irq);
508 return IRQ_NONE;
509 }
511 if (!test_bit(CARD_READY, &(info->hw_state)))
512 return IRQ_HANDLED;
514 iobase = info->p_dev->io.BasePort1;
516 spin_lock(&(info->lock));
518 /* Disable interrupt */
519 info->ctrl_reg &= ~REG_CONTROL_INTERRUPT;
520 outb(info->ctrl_reg, iobase + REG_CONTROL);
522 reg = inb(iobase + REG_INTERRUPT);
524 if ((reg != 0x00) && (reg != 0xff)) {
526 if (reg & 0x04) {
527 bluecard_receive(info, 0x00);
528 outb(0x04, iobase + REG_INTERRUPT);
529 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
530 }
532 if (reg & 0x08) {
533 bluecard_receive(info, 0x10);
534 outb(0x08, iobase + REG_INTERRUPT);
535 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
536 }
538 if (reg & 0x01) {
539 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
540 outb(0x01, iobase + REG_INTERRUPT);
541 bluecard_write_wakeup(info);
542 }
544 if (reg & 0x02) {
545 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
546 outb(0x02, iobase + REG_INTERRUPT);
547 bluecard_write_wakeup(info);
548 }
550 }
552 /* Enable interrupt */
553 info->ctrl_reg |= REG_CONTROL_INTERRUPT;
554 outb(info->ctrl_reg, iobase + REG_CONTROL);
556 spin_unlock(&(info->lock));
558 return IRQ_HANDLED;
559 }
563 /* ======================== Device specific HCI commands ======================== */
566 static int bluecard_hci_set_baud_rate(struct hci_dev *hdev, int baud)
567 {
568 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
569 struct sk_buff *skb;
571 /* Ericsson baud rate command */
572 unsigned char cmd[] = { HCI_COMMAND_PKT, 0x09, 0xfc, 0x01, 0x03 };
574 if (!(skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
575 BT_ERR("Can't allocate mem for new packet");
576 return -1;
577 }
579 switch (baud) {
580 case 460800:
581 cmd[4] = 0x00;
582 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_460800;
583 break;
584 case 230400:
585 cmd[4] = 0x01;
586 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_230400;
587 break;
588 case 115200:
589 cmd[4] = 0x02;
590 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_115200;
591 break;
592 case 57600:
593 /* Fall through... */
594 default:
595 cmd[4] = 0x03;
596 bt_cb(skb)->pkt_type = PKT_BAUD_RATE_57600;
597 break;
598 }
600 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
602 skb_queue_tail(&(info->txq), skb);
604 bluecard_write_wakeup(info);
606 return 0;
607 }
611 /* ======================== HCI interface ======================== */
614 static int bluecard_hci_flush(struct hci_dev *hdev)
615 {
616 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
618 /* Drop TX queue */
619 skb_queue_purge(&(info->txq));
621 return 0;
622 }
625 static int bluecard_hci_open(struct hci_dev *hdev)
626 {
627 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
628 unsigned int iobase = info->p_dev->io.BasePort1;
630 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state)))
631 bluecard_hci_set_baud_rate(hdev, DEFAULT_BAUD_RATE);
633 if (test_and_set_bit(HCI_RUNNING, &(hdev->flags)))
634 return 0;
636 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
637 /* Enable LED */
638 outb(0x08 | 0x20, iobase + 0x30);
639 }
641 return 0;
642 }
645 static int bluecard_hci_close(struct hci_dev *hdev)
646 {
647 bluecard_info_t *info = (bluecard_info_t *)(hdev->driver_data);
648 unsigned int iobase = info->p_dev->io.BasePort1;
650 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
651 return 0;
653 bluecard_hci_flush(hdev);
655 if (test_bit(CARD_HAS_PCCARD_ID, &(info->hw_state))) {
656 /* Disable LED */
657 outb(0x00, iobase + 0x30);
658 }
660 return 0;
661 }
664 static int bluecard_hci_send_frame(struct sk_buff *skb)
665 {
666 bluecard_info_t *info;
667 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
669 if (!hdev) {
670 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
671 return -ENODEV;
672 }
674 info = (bluecard_info_t *)(hdev->driver_data);
676 switch (bt_cb(skb)->pkt_type) {
677 case HCI_COMMAND_PKT:
678 hdev->stat.cmd_tx++;
679 break;
680 case HCI_ACLDATA_PKT:
681 hdev->stat.acl_tx++;
682 break;
683 case HCI_SCODATA_PKT:
684 hdev->stat.sco_tx++;
685 break;
686 };
688 /* Prepend skb with frame type */
689 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
690 skb_queue_tail(&(info->txq), skb);
692 bluecard_write_wakeup(info);
694 return 0;
695 }
698 static void bluecard_hci_destruct(struct hci_dev *hdev)
699 {
700 }
703 static int bluecard_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
704 {
705 return -ENOIOCTLCMD;
706 }
710 /* ======================== Card services HCI interaction ======================== */
713 static int bluecard_open(bluecard_info_t *info)
714 {
715 unsigned int iobase = info->p_dev->io.BasePort1;
716 struct hci_dev *hdev;
717 unsigned char id;
719 spin_lock_init(&(info->lock));
721 init_timer(&(info->timer));
722 info->timer.function = &bluecard_activity_led_timeout;
723 info->timer.data = (u_long)info;
725 skb_queue_head_init(&(info->txq));
727 info->rx_state = RECV_WAIT_PACKET_TYPE;
728 info->rx_count = 0;
729 info->rx_skb = NULL;
731 /* Initialize HCI device */
732 hdev = hci_alloc_dev();
733 if (!hdev) {
734 BT_ERR("Can't allocate HCI device");
735 return -ENOMEM;
736 }
738 info->hdev = hdev;
740 hdev->type = HCI_PCCARD;
741 hdev->driver_data = info;
742 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
744 hdev->open = bluecard_hci_open;
745 hdev->close = bluecard_hci_close;
746 hdev->flush = bluecard_hci_flush;
747 hdev->send = bluecard_hci_send_frame;
748 hdev->destruct = bluecard_hci_destruct;
749 hdev->ioctl = bluecard_hci_ioctl;
751 hdev->owner = THIS_MODULE;
753 id = inb(iobase + 0x30);
755 if ((id & 0x0f) == 0x02)
756 set_bit(CARD_HAS_PCCARD_ID, &(info->hw_state));
758 if (id & 0x10)
759 set_bit(CARD_HAS_POWER_LED, &(info->hw_state));
761 if (id & 0x20)
762 set_bit(CARD_HAS_ACTIVITY_LED, &(info->hw_state));
764 /* Reset card */
765 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
766 outb(info->ctrl_reg, iobase + REG_CONTROL);
768 /* Turn FPGA off */
769 outb(0x80, iobase + 0x30);
771 /* Wait some time */
772 msleep(10);
774 /* Turn FPGA on */
775 outb(0x00, iobase + 0x30);
777 /* Activate card */
778 info->ctrl_reg = REG_CONTROL_BT_ON | REG_CONTROL_BT_RES_PU;
779 outb(info->ctrl_reg, iobase + REG_CONTROL);
781 /* Enable interrupt */
782 outb(0xff, iobase + REG_INTERRUPT);
783 info->ctrl_reg |= REG_CONTROL_INTERRUPT;
784 outb(info->ctrl_reg, iobase + REG_CONTROL);
786 if ((id & 0x0f) == 0x03) {
787 /* Disable RTS */
788 info->ctrl_reg |= REG_CONTROL_RTS;
789 outb(info->ctrl_reg, iobase + REG_CONTROL);
791 /* Set baud rate */
792 info->ctrl_reg |= 0x03;
793 outb(info->ctrl_reg, iobase + REG_CONTROL);
795 /* Enable RTS */
796 info->ctrl_reg &= ~REG_CONTROL_RTS;
797 outb(info->ctrl_reg, iobase + REG_CONTROL);
799 set_bit(XMIT_BUF_ONE_READY, &(info->tx_state));
800 set_bit(XMIT_BUF_TWO_READY, &(info->tx_state));
801 set_bit(XMIT_SENDING_READY, &(info->tx_state));
802 }
804 /* Start the RX buffers */
805 outb(REG_COMMAND_RX_BUF_ONE, iobase + REG_COMMAND);
806 outb(REG_COMMAND_RX_BUF_TWO, iobase + REG_COMMAND);
808 /* Signal that the hardware is ready */
809 set_bit(CARD_READY, &(info->hw_state));
811 /* Drop TX queue */
812 skb_queue_purge(&(info->txq));
814 /* Control the point at which RTS is enabled */
815 outb((0x0f << RTS_LEVEL_SHIFT_BITS) | 1, iobase + REG_RX_CONTROL);
817 /* Timeout before it is safe to send the first HCI packet */
818 msleep(1250);
820 /* Register HCI device */
821 if (hci_register_dev(hdev) < 0) {
822 BT_ERR("Can't register HCI device");
823 info->hdev = NULL;
824 hci_free_dev(hdev);
825 return -ENODEV;
826 }
828 return 0;
829 }
832 static int bluecard_close(bluecard_info_t *info)
833 {
834 unsigned int iobase = info->p_dev->io.BasePort1;
835 struct hci_dev *hdev = info->hdev;
837 if (!hdev)
838 return -ENODEV;
840 bluecard_hci_close(hdev);
842 clear_bit(CARD_READY, &(info->hw_state));
844 /* Reset card */
845 info->ctrl_reg = REG_CONTROL_BT_RESET | REG_CONTROL_CARD_RESET;
846 outb(info->ctrl_reg, iobase + REG_CONTROL);
848 /* Turn FPGA off */
849 outb(0x80, iobase + 0x30);
851 if (hci_unregister_dev(hdev) < 0)
852 BT_ERR("Can't unregister HCI device %s", hdev->name);
854 hci_free_dev(hdev);
856 return 0;
857 }
859 static int bluecard_probe(struct pcmcia_device *link)
860 {
861 bluecard_info_t *info;
863 /* Create new info device */
864 info = kzalloc(sizeof(*info), GFP_KERNEL);
865 if (!info)
866 return -ENOMEM;
868 info->p_dev = link;
869 link->priv = info;
871 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
872 link->io.NumPorts1 = 8;
873 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
874 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
876 link->irq.Handler = bluecard_interrupt;
877 link->irq.Instance = info;
879 link->conf.Attributes = CONF_ENABLE_IRQ;
880 link->conf.IntType = INT_MEMORY_AND_IO;
882 return bluecard_config(link);
883 }
886 static void bluecard_detach(struct pcmcia_device *link)
887 {
888 bluecard_info_t *info = link->priv;
890 bluecard_release(link);
891 kfree(info);
892 }
895 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
896 {
897 int i;
899 i = pcmcia_get_first_tuple(handle, tuple);
900 if (i != CS_SUCCESS)
901 return CS_NO_MORE_ITEMS;
903 i = pcmcia_get_tuple_data(handle, tuple);
904 if (i != CS_SUCCESS)
905 return i;
907 return pcmcia_parse_tuple(handle, tuple, parse);
908 }
910 static int bluecard_config(struct pcmcia_device *link)
911 {
912 bluecard_info_t *info = link->priv;
913 tuple_t tuple;
914 u_short buf[256];
915 cisparse_t parse;
916 int i, n, last_ret, last_fn;
918 tuple.TupleData = (cisdata_t *)buf;
919 tuple.TupleOffset = 0;
920 tuple.TupleDataMax = 255;
921 tuple.Attributes = 0;
923 /* Get configuration register information */
924 tuple.DesiredTuple = CISTPL_CONFIG;
925 last_ret = first_tuple(link, &tuple, &parse);
926 if (last_ret != CS_SUCCESS) {
927 last_fn = ParseTuple;
928 goto cs_failed;
929 }
930 link->conf.ConfigBase = parse.config.base;
931 link->conf.Present = parse.config.rmask[0];
933 link->conf.ConfigIndex = 0x20;
934 link->io.NumPorts1 = 64;
935 link->io.IOAddrLines = 6;
937 for (n = 0; n < 0x400; n += 0x40) {
938 link->io.BasePort1 = n ^ 0x300;
939 i = pcmcia_request_io(link, &link->io);
940 if (i == CS_SUCCESS)
941 break;
942 }
944 if (i != CS_SUCCESS) {
945 cs_error(link, RequestIO, i);
946 goto failed;
947 }
949 i = pcmcia_request_irq(link, &link->irq);
950 if (i != CS_SUCCESS) {
951 cs_error(link, RequestIRQ, i);
952 link->irq.AssignedIRQ = 0;
953 }
955 i = pcmcia_request_configuration(link, &link->conf);
956 if (i != CS_SUCCESS) {
957 cs_error(link, RequestConfiguration, i);
958 goto failed;
959 }
961 if (bluecard_open(info) != 0)
962 goto failed;
964 strcpy(info->node.dev_name, info->hdev->name);
965 link->dev_node = &info->node;
967 return 0;
969 cs_failed:
970 cs_error(link, last_fn, last_ret);
972 failed:
973 bluecard_release(link);
974 return -ENODEV;
975 }
978 static void bluecard_release(struct pcmcia_device *link)
979 {
980 bluecard_info_t *info = link->priv;
982 bluecard_close(info);
984 del_timer(&(info->timer));
986 pcmcia_disable_device(link);
987 }
989 static struct pcmcia_device_id bluecard_ids[] = {
990 PCMCIA_DEVICE_PROD_ID12("BlueCard", "LSE041", 0xbaf16fbf, 0x657cc15e),
991 PCMCIA_DEVICE_PROD_ID12("BTCFCARD", "LSE139", 0xe3987764, 0x2524b59c),
992 PCMCIA_DEVICE_PROD_ID12("WSS", "LSE039", 0x0a0736ec, 0x24e6dfab),
993 PCMCIA_DEVICE_NULL
994 };
995 MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);
997 static struct pcmcia_driver bluecard_driver = {
998 .owner = THIS_MODULE,
999 .drv = {
1000 .name = "bluecard_cs",
1001 },
1002 .probe = bluecard_probe,
1003 .remove = bluecard_detach,
1004 .id_table = bluecard_ids,
1005 };
1007 static int __init init_bluecard_cs(void)
1009 return pcmcia_register_driver(&bluecard_driver);
1013 static void __exit exit_bluecard_cs(void)
1015 pcmcia_unregister_driver(&bluecard_driver);
1018 module_init(init_bluecard_cs);
1019 module_exit(exit_bluecard_cs);