ia64/linux-2.6.18-xen.hg

view drivers/bluetooth/btuart_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 * 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 */
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/errno.h>
32 #include <linux/ptrace.h>
33 #include <linux/ioport.h>
34 #include <linux/spinlock.h>
35 #include <linux/moduleparam.h>
37 #include <linux/skbuff.h>
38 #include <linux/string.h>
39 #include <linux/serial.h>
40 #include <linux/serial_reg.h>
41 #include <linux/bitops.h>
42 #include <asm/system.h>
43 #include <asm/io.h>
45 #include <pcmcia/cs_types.h>
46 #include <pcmcia/cs.h>
47 #include <pcmcia/cistpl.h>
48 #include <pcmcia/ciscode.h>
49 #include <pcmcia/ds.h>
50 #include <pcmcia/cisreg.h>
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
57 /* ======================== Module parameters ======================== */
60 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
61 MODULE_DESCRIPTION("Bluetooth driver for Bluetooth PCMCIA cards with HCI UART interface");
62 MODULE_LICENSE("GPL");
66 /* ======================== Local structures ======================== */
69 typedef struct btuart_info_t {
70 struct pcmcia_device *p_dev;
71 dev_node_t node;
73 struct hci_dev *hdev;
75 spinlock_t lock; /* For serializing operations */
77 struct sk_buff_head txq;
78 unsigned long tx_state;
80 unsigned long rx_state;
81 unsigned long rx_count;
82 struct sk_buff *rx_skb;
83 } btuart_info_t;
86 static int btuart_config(struct pcmcia_device *link);
87 static void btuart_release(struct pcmcia_device *link);
89 static void btuart_detach(struct pcmcia_device *p_dev);
92 /* Maximum baud rate */
93 #define SPEED_MAX 115200
95 /* Default baud rate: 57600, 115200, 230400 or 460800 */
96 #define DEFAULT_BAUD_RATE 115200
99 /* Transmit states */
100 #define XMIT_SENDING 1
101 #define XMIT_WAKEUP 2
102 #define XMIT_WAITING 8
104 /* Receiver states */
105 #define RECV_WAIT_PACKET_TYPE 0
106 #define RECV_WAIT_EVENT_HEADER 1
107 #define RECV_WAIT_ACL_HEADER 2
108 #define RECV_WAIT_SCO_HEADER 3
109 #define RECV_WAIT_DATA 4
113 /* ======================== Interrupt handling ======================== */
116 static int btuart_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
117 {
118 int actual = 0;
120 /* Tx FIFO should be empty */
121 if (!(inb(iobase + UART_LSR) & UART_LSR_THRE))
122 return 0;
124 /* Fill FIFO with current frame */
125 while ((fifo_size-- > 0) && (actual < len)) {
126 /* Transmit next byte */
127 outb(buf[actual], iobase + UART_TX);
128 actual++;
129 }
131 return actual;
132 }
135 static void btuart_write_wakeup(btuart_info_t *info)
136 {
137 if (!info) {
138 BT_ERR("Unknown device");
139 return;
140 }
142 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state))) {
143 set_bit(XMIT_WAKEUP, &(info->tx_state));
144 return;
145 }
147 do {
148 register unsigned int iobase = info->p_dev->io.BasePort1;
149 register struct sk_buff *skb;
150 register int len;
152 clear_bit(XMIT_WAKEUP, &(info->tx_state));
154 if (!pcmcia_dev_present(info->p_dev))
155 return;
157 if (!(skb = skb_dequeue(&(info->txq))))
158 break;
160 /* Send frame */
161 len = btuart_write(iobase, 16, skb->data, skb->len);
162 set_bit(XMIT_WAKEUP, &(info->tx_state));
164 if (len == skb->len) {
165 kfree_skb(skb);
166 } else {
167 skb_pull(skb, len);
168 skb_queue_head(&(info->txq), skb);
169 }
171 info->hdev->stat.byte_tx += len;
173 } while (test_bit(XMIT_WAKEUP, &(info->tx_state)));
175 clear_bit(XMIT_SENDING, &(info->tx_state));
176 }
179 static void btuart_receive(btuart_info_t *info)
180 {
181 unsigned int iobase;
182 int boguscount = 0;
184 if (!info) {
185 BT_ERR("Unknown device");
186 return;
187 }
189 iobase = info->p_dev->io.BasePort1;
191 do {
192 info->hdev->stat.byte_rx++;
194 /* Allocate packet */
195 if (info->rx_skb == NULL) {
196 info->rx_state = RECV_WAIT_PACKET_TYPE;
197 info->rx_count = 0;
198 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
199 BT_ERR("Can't allocate mem for new packet");
200 return;
201 }
202 }
204 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
206 info->rx_skb->dev = (void *) info->hdev;
207 bt_cb(info->rx_skb)->pkt_type = inb(iobase + UART_RX);
209 switch (bt_cb(info->rx_skb)->pkt_type) {
211 case HCI_EVENT_PKT:
212 info->rx_state = RECV_WAIT_EVENT_HEADER;
213 info->rx_count = HCI_EVENT_HDR_SIZE;
214 break;
216 case HCI_ACLDATA_PKT:
217 info->rx_state = RECV_WAIT_ACL_HEADER;
218 info->rx_count = HCI_ACL_HDR_SIZE;
219 break;
221 case HCI_SCODATA_PKT:
222 info->rx_state = RECV_WAIT_SCO_HEADER;
223 info->rx_count = HCI_SCO_HDR_SIZE;
224 break;
226 default:
227 /* Unknown packet */
228 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
229 info->hdev->stat.err_rx++;
230 clear_bit(HCI_RUNNING, &(info->hdev->flags));
232 kfree_skb(info->rx_skb);
233 info->rx_skb = NULL;
234 break;
236 }
238 } else {
240 *skb_put(info->rx_skb, 1) = inb(iobase + UART_RX);
241 info->rx_count--;
243 if (info->rx_count == 0) {
245 int dlen;
246 struct hci_event_hdr *eh;
247 struct hci_acl_hdr *ah;
248 struct hci_sco_hdr *sh;
251 switch (info->rx_state) {
253 case RECV_WAIT_EVENT_HEADER:
254 eh = (struct hci_event_hdr *)(info->rx_skb->data);
255 info->rx_state = RECV_WAIT_DATA;
256 info->rx_count = eh->plen;
257 break;
259 case RECV_WAIT_ACL_HEADER:
260 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
261 dlen = __le16_to_cpu(ah->dlen);
262 info->rx_state = RECV_WAIT_DATA;
263 info->rx_count = dlen;
264 break;
266 case RECV_WAIT_SCO_HEADER:
267 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
268 info->rx_state = RECV_WAIT_DATA;
269 info->rx_count = sh->dlen;
270 break;
272 case RECV_WAIT_DATA:
273 hci_recv_frame(info->rx_skb);
274 info->rx_skb = NULL;
275 break;
277 }
279 }
281 }
283 /* Make sure we don't stay here too long */
284 if (boguscount++ > 16)
285 break;
287 } while (inb(iobase + UART_LSR) & UART_LSR_DR);
288 }
291 static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
292 {
293 btuart_info_t *info = dev_inst;
294 unsigned int iobase;
295 int boguscount = 0;
296 int iir, lsr;
298 if (!info || !info->hdev) {
299 BT_ERR("Call of irq %d for unknown device", irq);
300 return IRQ_NONE;
301 }
303 iobase = info->p_dev->io.BasePort1;
305 spin_lock(&(info->lock));
307 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
308 while (iir) {
310 /* Clear interrupt */
311 lsr = inb(iobase + UART_LSR);
313 switch (iir) {
314 case UART_IIR_RLSI:
315 BT_ERR("RLSI");
316 break;
317 case UART_IIR_RDI:
318 /* Receive interrupt */
319 btuart_receive(info);
320 break;
321 case UART_IIR_THRI:
322 if (lsr & UART_LSR_THRE) {
323 /* Transmitter ready for data */
324 btuart_write_wakeup(info);
325 }
326 break;
327 default:
328 BT_ERR("Unhandled IIR=%#x", iir);
329 break;
330 }
332 /* Make sure we don't stay here too long */
333 if (boguscount++ > 100)
334 break;
336 iir = inb(iobase + UART_IIR) & UART_IIR_ID;
338 }
340 spin_unlock(&(info->lock));
342 return IRQ_HANDLED;
343 }
346 static void btuart_change_speed(btuart_info_t *info, unsigned int speed)
347 {
348 unsigned long flags;
349 unsigned int iobase;
350 int fcr; /* FIFO control reg */
351 int lcr; /* Line control reg */
352 int divisor;
354 if (!info) {
355 BT_ERR("Unknown device");
356 return;
357 }
359 iobase = info->p_dev->io.BasePort1;
361 spin_lock_irqsave(&(info->lock), flags);
363 /* Turn off interrupts */
364 outb(0, iobase + UART_IER);
366 divisor = SPEED_MAX / speed;
368 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT;
370 /*
371 * Use trigger level 1 to avoid 3 ms. timeout delay at 9600 bps, and
372 * almost 1,7 ms at 19200 bps. At speeds above that we can just forget
373 * about this timeout since it will always be fast enough.
374 */
376 if (speed < 38400)
377 fcr |= UART_FCR_TRIGGER_1;
378 else
379 fcr |= UART_FCR_TRIGGER_14;
381 /* Bluetooth cards use 8N1 */
382 lcr = UART_LCR_WLEN8;
384 outb(UART_LCR_DLAB | lcr, iobase + UART_LCR); /* Set DLAB */
385 outb(divisor & 0xff, iobase + UART_DLL); /* Set speed */
386 outb(divisor >> 8, iobase + UART_DLM);
387 outb(lcr, iobase + UART_LCR); /* Set 8N1 */
388 outb(fcr, iobase + UART_FCR); /* Enable FIFO's */
390 /* Turn on interrups */
391 outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
393 spin_unlock_irqrestore(&(info->lock), flags);
394 }
398 /* ======================== HCI interface ======================== */
401 static int btuart_hci_flush(struct hci_dev *hdev)
402 {
403 btuart_info_t *info = (btuart_info_t *)(hdev->driver_data);
405 /* Drop TX queue */
406 skb_queue_purge(&(info->txq));
408 return 0;
409 }
412 static int btuart_hci_open(struct hci_dev *hdev)
413 {
414 set_bit(HCI_RUNNING, &(hdev->flags));
416 return 0;
417 }
420 static int btuart_hci_close(struct hci_dev *hdev)
421 {
422 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
423 return 0;
425 btuart_hci_flush(hdev);
427 return 0;
428 }
431 static int btuart_hci_send_frame(struct sk_buff *skb)
432 {
433 btuart_info_t *info;
434 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
436 if (!hdev) {
437 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
438 return -ENODEV;
439 }
441 info = (btuart_info_t *)(hdev->driver_data);
443 switch (bt_cb(skb)->pkt_type) {
444 case HCI_COMMAND_PKT:
445 hdev->stat.cmd_tx++;
446 break;
447 case HCI_ACLDATA_PKT:
448 hdev->stat.acl_tx++;
449 break;
450 case HCI_SCODATA_PKT:
451 hdev->stat.sco_tx++;
452 break;
453 };
455 /* Prepend skb with frame type */
456 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
457 skb_queue_tail(&(info->txq), skb);
459 btuart_write_wakeup(info);
461 return 0;
462 }
465 static void btuart_hci_destruct(struct hci_dev *hdev)
466 {
467 }
470 static int btuart_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
471 {
472 return -ENOIOCTLCMD;
473 }
477 /* ======================== Card services HCI interaction ======================== */
480 static int btuart_open(btuart_info_t *info)
481 {
482 unsigned long flags;
483 unsigned int iobase = info->p_dev->io.BasePort1;
484 struct hci_dev *hdev;
486 spin_lock_init(&(info->lock));
488 skb_queue_head_init(&(info->txq));
490 info->rx_state = RECV_WAIT_PACKET_TYPE;
491 info->rx_count = 0;
492 info->rx_skb = NULL;
494 /* Initialize HCI device */
495 hdev = hci_alloc_dev();
496 if (!hdev) {
497 BT_ERR("Can't allocate HCI device");
498 return -ENOMEM;
499 }
501 info->hdev = hdev;
503 hdev->type = HCI_PCCARD;
504 hdev->driver_data = info;
505 SET_HCIDEV_DEV(hdev, &info->p_dev->dev);
507 hdev->open = btuart_hci_open;
508 hdev->close = btuart_hci_close;
509 hdev->flush = btuart_hci_flush;
510 hdev->send = btuart_hci_send_frame;
511 hdev->destruct = btuart_hci_destruct;
512 hdev->ioctl = btuart_hci_ioctl;
514 hdev->owner = THIS_MODULE;
516 spin_lock_irqsave(&(info->lock), flags);
518 /* Reset UART */
519 outb(0, iobase + UART_MCR);
521 /* Turn off interrupts */
522 outb(0, iobase + UART_IER);
524 /* Initialize UART */
525 outb(UART_LCR_WLEN8, iobase + UART_LCR); /* Reset DLAB */
526 outb((UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2), iobase + UART_MCR);
528 /* Turn on interrupts */
529 // outb(UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI, iobase + UART_IER);
531 spin_unlock_irqrestore(&(info->lock), flags);
533 btuart_change_speed(info, DEFAULT_BAUD_RATE);
535 /* Timeout before it is safe to send the first HCI packet */
536 msleep(1000);
538 /* Register HCI device */
539 if (hci_register_dev(hdev) < 0) {
540 BT_ERR("Can't register HCI device");
541 info->hdev = NULL;
542 hci_free_dev(hdev);
543 return -ENODEV;
544 }
546 return 0;
547 }
550 static int btuart_close(btuart_info_t *info)
551 {
552 unsigned long flags;
553 unsigned int iobase = info->p_dev->io.BasePort1;
554 struct hci_dev *hdev = info->hdev;
556 if (!hdev)
557 return -ENODEV;
559 btuart_hci_close(hdev);
561 spin_lock_irqsave(&(info->lock), flags);
563 /* Reset UART */
564 outb(0, iobase + UART_MCR);
566 /* Turn off interrupts */
567 outb(0, iobase + UART_IER);
569 spin_unlock_irqrestore(&(info->lock), flags);
571 if (hci_unregister_dev(hdev) < 0)
572 BT_ERR("Can't unregister HCI device %s", hdev->name);
574 hci_free_dev(hdev);
576 return 0;
577 }
579 static int btuart_probe(struct pcmcia_device *link)
580 {
581 btuart_info_t *info;
583 /* Create new info device */
584 info = kzalloc(sizeof(*info), GFP_KERNEL);
585 if (!info)
586 return -ENOMEM;
588 info->p_dev = link;
589 link->priv = info;
591 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
592 link->io.NumPorts1 = 8;
593 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
594 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
596 link->irq.Handler = btuart_interrupt;
597 link->irq.Instance = info;
599 link->conf.Attributes = CONF_ENABLE_IRQ;
600 link->conf.IntType = INT_MEMORY_AND_IO;
602 return btuart_config(link);
603 }
606 static void btuart_detach(struct pcmcia_device *link)
607 {
608 btuart_info_t *info = link->priv;
610 btuart_release(link);
611 kfree(info);
612 }
614 static int get_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
615 {
616 int i;
618 i = pcmcia_get_tuple_data(handle, tuple);
619 if (i != CS_SUCCESS)
620 return i;
622 return pcmcia_parse_tuple(handle, tuple, parse);
623 }
625 static int first_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
626 {
627 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
628 return CS_NO_MORE_ITEMS;
629 return get_tuple(handle, tuple, parse);
630 }
632 static int next_tuple(struct pcmcia_device *handle, tuple_t *tuple, cisparse_t *parse)
633 {
634 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
635 return CS_NO_MORE_ITEMS;
636 return get_tuple(handle, tuple, parse);
637 }
639 static int btuart_config(struct pcmcia_device *link)
640 {
641 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
642 btuart_info_t *info = link->priv;
643 tuple_t tuple;
644 u_short buf[256];
645 cisparse_t parse;
646 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
647 int i, j, try, last_ret, last_fn;
649 tuple.TupleData = (cisdata_t *)buf;
650 tuple.TupleOffset = 0;
651 tuple.TupleDataMax = 255;
652 tuple.Attributes = 0;
654 /* Get configuration register information */
655 tuple.DesiredTuple = CISTPL_CONFIG;
656 last_ret = first_tuple(link, &tuple, &parse);
657 if (last_ret != CS_SUCCESS) {
658 last_fn = ParseTuple;
659 goto cs_failed;
660 }
661 link->conf.ConfigBase = parse.config.base;
662 link->conf.Present = parse.config.rmask[0];
664 /* First pass: look for a config entry that looks normal. */
665 tuple.TupleData = (cisdata_t *) buf;
666 tuple.TupleOffset = 0;
667 tuple.TupleDataMax = 255;
668 tuple.Attributes = 0;
669 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
670 /* Two tries: without IO aliases, then with aliases */
671 for (try = 0; try < 2; try++) {
672 i = first_tuple(link, &tuple, &parse);
673 while (i != CS_NO_MORE_ITEMS) {
674 if (i != CS_SUCCESS)
675 goto next_entry;
676 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
677 link->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
678 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
679 link->conf.ConfigIndex = cf->index;
680 link->io.BasePort1 = cf->io.win[0].base;
681 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
682 i = pcmcia_request_io(link, &link->io);
683 if (i == CS_SUCCESS)
684 goto found_port;
685 }
686 next_entry:
687 i = next_tuple(link, &tuple, &parse);
688 }
689 }
691 /* Second pass: try to find an entry that isn't picky about
692 its base address, then try to grab any standard serial port
693 address, and finally try to get any free port. */
694 i = first_tuple(link, &tuple, &parse);
695 while (i != CS_NO_MORE_ITEMS) {
696 if ((i == CS_SUCCESS) && (cf->io.nwin > 0)
697 && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
698 link->conf.ConfigIndex = cf->index;
699 for (j = 0; j < 5; j++) {
700 link->io.BasePort1 = base[j];
701 link->io.IOAddrLines = base[j] ? 16 : 3;
702 i = pcmcia_request_io(link, &link->io);
703 if (i == CS_SUCCESS)
704 goto found_port;
705 }
706 }
707 i = next_tuple(link, &tuple, &parse);
708 }
710 found_port:
711 if (i != CS_SUCCESS) {
712 BT_ERR("No usable port range found");
713 cs_error(link, RequestIO, i);
714 goto failed;
715 }
717 i = pcmcia_request_irq(link, &link->irq);
718 if (i != CS_SUCCESS) {
719 cs_error(link, RequestIRQ, i);
720 link->irq.AssignedIRQ = 0;
721 }
723 i = pcmcia_request_configuration(link, &link->conf);
724 if (i != CS_SUCCESS) {
725 cs_error(link, RequestConfiguration, i);
726 goto failed;
727 }
729 if (btuart_open(info) != 0)
730 goto failed;
732 strcpy(info->node.dev_name, info->hdev->name);
733 link->dev_node = &info->node;
735 return 0;
737 cs_failed:
738 cs_error(link, last_fn, last_ret);
740 failed:
741 btuart_release(link);
742 return -ENODEV;
743 }
746 static void btuart_release(struct pcmcia_device *link)
747 {
748 btuart_info_t *info = link->priv;
750 btuart_close(info);
752 pcmcia_disable_device(link);
753 }
755 static struct pcmcia_device_id btuart_ids[] = {
756 /* don't use this driver. Use serial_cs + hci_uart instead */
757 PCMCIA_DEVICE_NULL
758 };
759 MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
761 static struct pcmcia_driver btuart_driver = {
762 .owner = THIS_MODULE,
763 .drv = {
764 .name = "btuart_cs",
765 },
766 .probe = btuart_probe,
767 .remove = btuart_detach,
768 .id_table = btuart_ids,
769 };
771 static int __init init_btuart_cs(void)
772 {
773 return pcmcia_register_driver(&btuart_driver);
774 }
777 static void __exit exit_btuart_cs(void)
778 {
779 pcmcia_unregister_driver(&btuart_driver);
780 }
782 module_init(init_btuart_cs);
783 module_exit(exit_btuart_cs);