]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/bluetooth/bt3c_cs.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] pcmcia: remove dev_list from drivers
[mirror_ubuntu-bionic-kernel.git] / drivers / bluetooth / bt3c_cs.c
CommitLineData
1da177e4
LT		 1/*
2 *
3 * Driver for the 3Com Bluetooth PCMCIA card
4 *
5 * Copyright (C) 2001-2002 Marcel Holtmann <marcel@holtmann.org>
6 * Jose Orlando Pereira <jop@di.uminho.pt>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation;
12 *
13 * Software distributed under the License is distributed on an "AS
14 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15 * implied. See the License for the specific language governing
16 * rights and limitations under the License.
17 *
18 * The initial developer of the original code is David A. Hinds
19 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
20 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
21 *
22 */
23
24#include <linux/config.h>
25#include <linux/module.h>
26
27#include <linux/kernel.h>
28#include <linux/init.h>
29#include <linux/slab.h>
30#include <linux/types.h>
31#include <linux/sched.h>
32#include <linux/delay.h>
33#include <linux/errno.h>
34#include <linux/ptrace.h>
35#include <linux/ioport.h>
36#include <linux/spinlock.h>
37#include <linux/moduleparam.h>
38
39#include <linux/skbuff.h>
40#include <linux/string.h>
41#include <linux/serial.h>
42#include <linux/serial_reg.h>
43#include <linux/bitops.h>
44#include <asm/system.h>
45#include <asm/io.h>
46
47#include <linux/device.h>
48#include <linux/firmware.h>
49
1da177e4
LT		 50#include <pcmcia/cs_types.h>
51#include <pcmcia/cs.h>
52#include <pcmcia/cistpl.h>
53#include <pcmcia/ciscode.h>
54#include <pcmcia/ds.h>
55#include <pcmcia/cisreg.h>
56
57#include <net/bluetooth/bluetooth.h>
58#include <net/bluetooth/hci_core.h>
59
60
61
62/* ======================== Module parameters ======================== */
63
64
65MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>, Jose Orlando Pereira <jop@di.uminho.pt>");
66MODULE_DESCRIPTION("Bluetooth driver for the 3Com Bluetooth PCMCIA card");
67MODULE_LICENSE("GPL");
68
69
70
71/* ======================== Local structures ======================== */
72
73
74typedef struct bt3c_info_t {
75 dev_link_t link;
76 dev_node_t node;
77
78 struct hci_dev *hdev;
79
80 spinlock_t lock; /* For serializing operations */
81
82 struct sk_buff_head txq;
83 unsigned long tx_state;
84
85 unsigned long rx_state;
86 unsigned long rx_count;
87 struct sk_buff *rx_skb;
88} bt3c_info_t;
89
90
91static void bt3c_config(dev_link_t *link);
92static void bt3c_release(dev_link_t *link);
93static int bt3c_event(event_t event, int priority, event_callback_args_t *args);
94
95static dev_info_t dev_info = "bt3c_cs";
96
97static dev_link_t *bt3c_attach(void);
cc3b4866 98static void bt3c_detach(struct pcmcia_device *p_dev);
1da177e4 99
1da177e4
LT		 100
101/* Transmit states */
102#define XMIT_SENDING 1
103#define XMIT_WAKEUP 2
104#define XMIT_WAITING 8
105
106/* Receiver states */
107#define RECV_WAIT_PACKET_TYPE 0
108#define RECV_WAIT_EVENT_HEADER 1
109#define RECV_WAIT_ACL_HEADER 2
110#define RECV_WAIT_SCO_HEADER 3
111#define RECV_WAIT_DATA 4
112
113
114
115/* ======================== Special I/O functions ======================== */
116
117
118#define DATA_L 0
119#define DATA_H 1
120#define ADDR_L 2
121#define ADDR_H 3
122#define CONTROL 4
123
124
125static inline void bt3c_address(unsigned int iobase, unsigned short addr)
126{
127 outb(addr & 0xff, iobase + ADDR_L);
128 outb((addr >> 8) & 0xff, iobase + ADDR_H);
129}
130
131
132static inline void bt3c_put(unsigned int iobase, unsigned short value)
133{
134 outb(value & 0xff, iobase + DATA_L);
135 outb((value >> 8) & 0xff, iobase + DATA_H);
136}
137
138
139static inline void bt3c_io_write(unsigned int iobase, unsigned short addr, unsigned short value)
140{
141 bt3c_address(iobase, addr);
142 bt3c_put(iobase, value);
143}
144
145
146static inline unsigned short bt3c_get(unsigned int iobase)
147{
148 unsigned short value = inb(iobase + DATA_L);
149
150 value |= inb(iobase + DATA_H) << 8;
151
152 return value;
153}
154
155
156static inline unsigned short bt3c_read(unsigned int iobase, unsigned short addr)
157{
158 bt3c_address(iobase, addr);
159
160 return bt3c_get(iobase);
161}
162
163
164
165/* ======================== Interrupt handling ======================== */
166
167
168static int bt3c_write(unsigned int iobase, int fifo_size, __u8 *buf, int len)
169{
170 int actual = 0;
171
172 bt3c_address(iobase, 0x7080);
173
174 /* Fill FIFO with current frame */
175 while (actual < len) {
176 /* Transmit next byte */
177 bt3c_put(iobase, buf[actual]);
178 actual++;
179 }
180
181 bt3c_io_write(iobase, 0x7005, actual);
182
183 return actual;
184}
185
186
187static void bt3c_write_wakeup(bt3c_info_t *info)
188{
189 if (!info) {
190 BT_ERR("Unknown device");
191 return;
192 }
193
194 if (test_and_set_bit(XMIT_SENDING, &(info->tx_state)))
195 return;
196
197 do {
198 register unsigned int iobase = info->link.io.BasePort1;
199 register struct sk_buff *skb;
200 register int len;
201
202 if (!(info->link.state & DEV_PRESENT))
203 break;
204
205
206 if (!(skb = skb_dequeue(&(info->txq)))) {
207 clear_bit(XMIT_SENDING, &(info->tx_state));
208 break;
209 }
210
211 /* Send frame */
212 len = bt3c_write(iobase, 256, skb->data, skb->len);
213
214 if (len != skb->len) {
215 BT_ERR("Very strange");
216 }
217
218 kfree_skb(skb);
219
220 info->hdev->stat.byte_tx += len;
221
222 } while (0);
223}
224
225
226static void bt3c_receive(bt3c_info_t *info)
227{
228 unsigned int iobase;
229 int size = 0, avail;
230
231 if (!info) {
232 BT_ERR("Unknown device");
233 return;
234 }
235
236 iobase = info->link.io.BasePort1;
237
238 avail = bt3c_read(iobase, 0x7006);
239 //printk("bt3c_cs: receiving %d bytes\n", avail);
240
241 bt3c_address(iobase, 0x7480);
242 while (size < avail) {
243 size++;
244 info->hdev->stat.byte_rx++;
245
246 /* Allocate packet */
247 if (info->rx_skb == NULL) {
248 info->rx_state = RECV_WAIT_PACKET_TYPE;
249 info->rx_count = 0;
250 if (!(info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC))) {
251 BT_ERR("Can't allocate mem for new packet");
252 return;
253 }
254 }
255
256
257 if (info->rx_state == RECV_WAIT_PACKET_TYPE) {
258
259 info->rx_skb->dev = (void *) info->hdev;
0d48d939 260 bt_cb(info->rx_skb)->pkt_type = inb(iobase + DATA_L);
1da177e4 261 inb(iobase + DATA_H);
0d48d939 262 //printk("bt3c: PACKET_TYPE=%02x\n", bt_cb(info->rx_skb)->pkt_type);
1da177e4 263
0d48d939 264 switch (bt_cb(info->rx_skb)->pkt_type) {
1da177e4
LT		 265
266 case HCI_EVENT_PKT:
267 info->rx_state = RECV_WAIT_EVENT_HEADER;
268 info->rx_count = HCI_EVENT_HDR_SIZE;
269 break;
270
271 case HCI_ACLDATA_PKT:
272 info->rx_state = RECV_WAIT_ACL_HEADER;
273 info->rx_count = HCI_ACL_HDR_SIZE;
274 break;
275
276 case HCI_SCODATA_PKT:
277 info->rx_state = RECV_WAIT_SCO_HEADER;
278 info->rx_count = HCI_SCO_HDR_SIZE;
279 break;
280
281 default:
282 /* Unknown packet */
0d48d939 283 BT_ERR("Unknown HCI packet with type 0x%02x received", bt_cb(info->rx_skb)->pkt_type);
1da177e4
LT		 284 info->hdev->stat.err_rx++;
285 clear_bit(HCI_RUNNING, &(info->hdev->flags));
286
287 kfree_skb(info->rx_skb);
288 info->rx_skb = NULL;
289 break;
290
291 }
292
293 } else {
294
295 __u8 x = inb(iobase + DATA_L);
296
297 *skb_put(info->rx_skb, 1) = x;
298 inb(iobase + DATA_H);
299 info->rx_count--;
300
301 if (info->rx_count == 0) {
302
303 int dlen;
304 struct hci_event_hdr *eh;
305 struct hci_acl_hdr *ah;
306 struct hci_sco_hdr *sh;
307
308 switch (info->rx_state) {
309
310 case RECV_WAIT_EVENT_HEADER:
311 eh = (struct hci_event_hdr *)(info->rx_skb->data);
312 info->rx_state = RECV_WAIT_DATA;
313 info->rx_count = eh->plen;
314 break;
315
316 case RECV_WAIT_ACL_HEADER:
317 ah = (struct hci_acl_hdr *)(info->rx_skb->data);
318 dlen = __le16_to_cpu(ah->dlen);
319 info->rx_state = RECV_WAIT_DATA;
320 info->rx_count = dlen;
321 break;
322
323 case RECV_WAIT_SCO_HEADER:
324 sh = (struct hci_sco_hdr *)(info->rx_skb->data);
325 info->rx_state = RECV_WAIT_DATA;
326 info->rx_count = sh->dlen;
327 break;
328
329 case RECV_WAIT_DATA:
330 hci_recv_frame(info->rx_skb);
331 info->rx_skb = NULL;
332 break;
333
334 }
335
336 }
337
338 }
339
340 }
341
342 bt3c_io_write(iobase, 0x7006, 0x0000);
343}
344
345
346static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
347{
348 bt3c_info_t *info = dev_inst;
349 unsigned int iobase;
350 int iir;
351
352 if (!info || !info->hdev) {
353 BT_ERR("Call of irq %d for unknown device", irq);
354 return IRQ_NONE;
355 }
356
357 iobase = info->link.io.BasePort1;
358
359 spin_lock(&(info->lock));
360
361 iir = inb(iobase + CONTROL);
362 if (iir & 0x80) {
363 int stat = bt3c_read(iobase, 0x7001);
364
365 if ((stat & 0xff) == 0x7f) {
366 BT_ERR("Very strange (stat=0x%04x)", stat);
367 } else if ((stat & 0xff) != 0xff) {
368 if (stat & 0x0020) {
369 int stat = bt3c_read(iobase, 0x7002) & 0x10;
370 BT_INFO("%s: Antenna %s", info->hdev->name,
371 stat ? "out" : "in");
372 }
373 if (stat & 0x0001)
374 bt3c_receive(info);
375 if (stat & 0x0002) {
376 //BT_ERR("Ack (stat=0x%04x)", stat);
377 clear_bit(XMIT_SENDING, &(info->tx_state));
378 bt3c_write_wakeup(info);
379 }
380
381 bt3c_io_write(iobase, 0x7001, 0x0000);
382
383 outb(iir, iobase + CONTROL);
384 }
385 }
386
387 spin_unlock(&(info->lock));
388
389 return IRQ_HANDLED;
390}
391
392
393
394/* ======================== HCI interface ======================== */
395
396
397static int bt3c_hci_flush(struct hci_dev *hdev)
398{
399 bt3c_info_t *info = (bt3c_info_t *)(hdev->driver_data);
400
401 /* Drop TX queue */
402 skb_queue_purge(&(info->txq));
403
404 return 0;
405}
406
407
408static int bt3c_hci_open(struct hci_dev *hdev)
409{
410 set_bit(HCI_RUNNING, &(hdev->flags));
411
412 return 0;
413}
414
415
416static int bt3c_hci_close(struct hci_dev *hdev)
417{
418 if (!test_and_clear_bit(HCI_RUNNING, &(hdev->flags)))
419 return 0;
420
421 bt3c_hci_flush(hdev);
422
423 return 0;
424}
425
426
427static int bt3c_hci_send_frame(struct sk_buff *skb)
428{
429 bt3c_info_t *info;
430 struct hci_dev *hdev = (struct hci_dev *)(skb->dev);
431 unsigned long flags;
432
433 if (!hdev) {
434 BT_ERR("Frame for unknown HCI device (hdev=NULL)");
435 return -ENODEV;
436 }
437
438 info = (bt3c_info_t *) (hdev->driver_data);
439
0d48d939 440 switch (bt_cb(skb)->pkt_type) {
1da177e4
LT		 441 case HCI_COMMAND_PKT:
442 hdev->stat.cmd_tx++;
443 break;
444 case HCI_ACLDATA_PKT:
445 hdev->stat.acl_tx++;
446 break;
447 case HCI_SCODATA_PKT:
448 hdev->stat.sco_tx++;
449 break;
450 };
451
452 /* Prepend skb with frame type */
0d48d939 453 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
1da177e4
LT		 454 skb_queue_tail(&(info->txq), skb);
455
456 spin_lock_irqsave(&(info->lock), flags);
457
458 bt3c_write_wakeup(info);
459
460 spin_unlock_irqrestore(&(info->lock), flags);
461
462 return 0;
463}
464
465
466static void bt3c_hci_destruct(struct hci_dev *hdev)
467{
468}
469
470
471static int bt3c_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
472{
473 return -ENOIOCTLCMD;
474}
475
476
477
478/* ======================== Card services HCI interaction ======================== */
479
480
481static struct device *bt3c_device(void)
482{
483 static struct device dev = {
484 .bus_id = "pcmcia",
485 };
486 kobject_set_name(&dev.kobj, "bt3c");
487 kobject_init(&dev.kobj);
488
489 return &dev;
490}
491
492
493static int bt3c_load_firmware(bt3c_info_t *info, unsigned char *firmware, int count)
494{
495 char *ptr = (char *) firmware;
496 char b[9];
497 unsigned int iobase, size, addr, fcs, tmp;
498 int i, err = 0;
499
500 iobase = info->link.io.BasePort1;
501
502 /* Reset */
503 bt3c_io_write(iobase, 0x8040, 0x0404);
504 bt3c_io_write(iobase, 0x8040, 0x0400);
505
506 udelay(1);
507
508 bt3c_io_write(iobase, 0x8040, 0x0404);
509
510 udelay(17);
511
512 /* Load */
513 while (count) {
514 if (ptr[0] != 'S') {
515 BT_ERR("Bad address in firmware");
516 err = -EFAULT;
517 goto error;
518 }
519
520 memset(b, 0, sizeof(b));
521 memcpy(b, ptr + 2, 2);
522 size = simple_strtol(b, NULL, 16);
523
524 memset(b, 0, sizeof(b));
525 memcpy(b, ptr + 4, 8);
526 addr = simple_strtol(b, NULL, 16);
527
528 memset(b, 0, sizeof(b));
529 memcpy(b, ptr + (size * 2) + 2, 2);
530 fcs = simple_strtol(b, NULL, 16);
531
532 memset(b, 0, sizeof(b));
533 for (tmp = 0, i = 0; i < size; i++) {
534 memcpy(b, ptr + (i * 2) + 2, 2);
535 tmp += simple_strtol(b, NULL, 16);
536 }
537
538 if (((tmp + fcs) & 0xff) != 0xff) {
539 BT_ERR("Checksum error in firmware");
540 err = -EILSEQ;
541 goto error;
542 }
543
544 if (ptr[1] == '3') {
545 bt3c_address(iobase, addr);
546
547 memset(b, 0, sizeof(b));
548 for (i = 0; i < (size - 4) / 2; i++) {
549 memcpy(b, ptr + (i * 4) + 12, 4);
550 tmp = simple_strtol(b, NULL, 16);
551 bt3c_put(iobase, tmp);
552 }
553 }
554
555 ptr += (size * 2) + 6;
556 count -= (size * 2) + 6;
557 }
558
559 udelay(17);
560
561 /* Boot */
562 bt3c_address(iobase, 0x3000);
563 outb(inb(iobase + CONTROL) | 0x40, iobase + CONTROL);
564
565error:
566 udelay(17);
567
568 /* Clear */
569 bt3c_io_write(iobase, 0x7006, 0x0000);
570 bt3c_io_write(iobase, 0x7005, 0x0000);
571 bt3c_io_write(iobase, 0x7001, 0x0000);
572
573 return err;
574}
575
576
577static int bt3c_open(bt3c_info_t *info)
578{
579 const struct firmware *firmware;
580 struct hci_dev *hdev;
581 int err;
582
583 spin_lock_init(&(info->lock));
584
585 skb_queue_head_init(&(info->txq));
586
587 info->rx_state = RECV_WAIT_PACKET_TYPE;
588 info->rx_count = 0;
589 info->rx_skb = NULL;
590
591 /* Initialize HCI device */
592 hdev = hci_alloc_dev();
593 if (!hdev) {
594 BT_ERR("Can't allocate HCI device");
595 return -ENOMEM;
596 }
597
598 info->hdev = hdev;
599
600 hdev->type = HCI_PCCARD;
601 hdev->driver_data = info;
602
603 hdev->open = bt3c_hci_open;
604 hdev->close = bt3c_hci_close;
605 hdev->flush = bt3c_hci_flush;
606 hdev->send = bt3c_hci_send_frame;
607 hdev->destruct = bt3c_hci_destruct;
608 hdev->ioctl = bt3c_hci_ioctl;
609
610 hdev->owner = THIS_MODULE;
611
612 /* Load firmware */
613 err = request_firmware(&firmware, "BT3CPCC.bin", bt3c_device());
614 if (err < 0) {
615 BT_ERR("Firmware request failed");
616 goto error;
617 }
618
619 err = bt3c_load_firmware(info, firmware->data, firmware->size);
620
621 release_firmware(firmware);
622
623 if (err < 0) {
624 BT_ERR("Firmware loading failed");
625 goto error;
626 }
627
628 /* Timeout before it is safe to send the first HCI packet */
629 msleep(1000);
630
631 /* Register HCI device */
632 err = hci_register_dev(hdev);
633 if (err < 0) {
634 BT_ERR("Can't register HCI device");
635 goto error;
636 }
637
638 return 0;
639
640error:
641 info->hdev = NULL;
642 hci_free_dev(hdev);
643 return err;
644}
645
646
647static int bt3c_close(bt3c_info_t *info)
648{
649 struct hci_dev *hdev = info->hdev;
650
651 if (!hdev)
652 return -ENODEV;
653
654 bt3c_hci_close(hdev);
655
656 if (hci_unregister_dev(hdev) < 0)
657 BT_ERR("Can't unregister HCI device %s", hdev->name);
658
659 hci_free_dev(hdev);
660
661 return 0;
662}
663
664static dev_link_t *bt3c_attach(void)
665{
666 bt3c_info_t *info;
667 client_reg_t client_reg;
668 dev_link_t *link;
669 int ret;
670
671 /* Create new info device */
089b1dbb 672 info = kzalloc(sizeof(*info), GFP_KERNEL);
1da177e4
LT		 673 if (!info)
674 return NULL;
1da177e4
LT		 675
676 link = &info->link;
677 link->priv = info;
678
679 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
680 link->io.NumPorts1 = 8;
681 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
682 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
683
684 link->irq.Handler = bt3c_interrupt;
685 link->irq.Instance = info;
686
687 link->conf.Attributes = CONF_ENABLE_IRQ;
688 link->conf.Vcc = 50;
689 link->conf.IntType = INT_MEMORY_AND_IO;
690
691 /* Register with Card Services */
b4635811 692 link->next = NULL;
1da177e4 693 client_reg.dev_info = &dev_info;
1da177e4
LT		 694 client_reg.Version = 0x0210;
695 client_reg.event_callback_args.client_data = link;
696
697 ret = pcmcia_register_client(&link->handle, &client_reg);
698 if (ret != CS_SUCCESS) {
699 cs_error(link->handle, RegisterClient, ret);
cc3b4866 700 bt3c_detach(link->handle);
1da177e4
LT		 701 return NULL;
702 }
703
704 return link;
705}
706
707
cc3b4866 708static void bt3c_detach(struct pcmcia_device *p_dev)
1da177e4 709{
cc3b4866 710 dev_link_t *link = dev_to_instance(p_dev);
1da177e4 711 bt3c_info_t *info = link->priv;
1da177e4
LT		 712
713 if (link->state & DEV_CONFIG)
714 bt3c_release(link);
715
1da177e4
LT		 716 kfree(info);
717}
718
719static int get_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
720{
721 int i;
722
723 i = pcmcia_get_tuple_data(handle, tuple);
724 if (i != CS_SUCCESS)
725 return i;
726
727 return pcmcia_parse_tuple(handle, tuple, parse);
728}
729
730static int first_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
731{
732 if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS)
733 return CS_NO_MORE_ITEMS;
734 return get_tuple(handle, tuple, parse);
735}
736
737static int next_tuple(client_handle_t handle, tuple_t *tuple, cisparse_t *parse)
738{
739 if (pcmcia_get_next_tuple(handle, tuple) != CS_SUCCESS)
740 return CS_NO_MORE_ITEMS;
741 return get_tuple(handle, tuple, parse);
742}
743
744static void bt3c_config(dev_link_t *link)
745{
746 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
747 client_handle_t handle = link->handle;
748 bt3c_info_t *info = link->priv;
749 tuple_t tuple;
750 u_short buf[256];
751 cisparse_t parse;
752 cistpl_cftable_entry_t *cf = &parse.cftable_entry;
753 config_info_t config;
754 int i, j, try, last_ret, last_fn;
755
756 tuple.TupleData = (cisdata_t *)buf;
757 tuple.TupleOffset = 0;
758 tuple.TupleDataMax = 255;
759 tuple.Attributes = 0;
760
761 /* Get configuration register information */
762 tuple.DesiredTuple = CISTPL_CONFIG;
763 last_ret = first_tuple(handle, &tuple, &parse);
764 if (last_ret != CS_SUCCESS) {
765 last_fn = ParseTuple;
766 goto cs_failed;
767 }
768 link->conf.ConfigBase = parse.config.base;
769 link->conf.Present = parse.config.rmask[0];
770
771 /* Configure card */
772 link->state |= DEV_CONFIG;
773 i = pcmcia_get_configuration_info(handle, &config);
774 link->conf.Vcc = config.Vcc;
775
776 /* First pass: look for a config entry that looks normal. */
777 tuple.TupleData = (cisdata_t *)buf;
778 tuple.TupleOffset = 0;
779 tuple.TupleDataMax = 255;
780 tuple.Attributes = 0;
781 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
782 /* Two tries: without IO aliases, then with aliases */
783 for (try = 0; try < 2; try++) {
784 i = first_tuple(handle, &tuple, &parse);
785 while (i != CS_NO_MORE_ITEMS) {
786 if (i != CS_SUCCESS)
787 goto next_entry;
788 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
789 link->conf.Vpp1 = link->conf.Vpp2 = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
790 if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) && (cf->io.win[0].base != 0)) {
791 link->conf.ConfigIndex = cf->index;
792 link->io.BasePort1 = cf->io.win[0].base;
793 link->io.IOAddrLines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
794 i = pcmcia_request_io(link->handle, &link->io);
795 if (i == CS_SUCCESS)
796 goto found_port;
797 }
798next_entry:
799 i = next_tuple(handle, &tuple, &parse);
800 }
801 }
802
803 /* Second pass: try to find an entry that isn't picky about
804 its base address, then try to grab any standard serial port
805 address, and finally try to get any free port. */
806 i = first_tuple(handle, &tuple, &parse);
807 while (i != CS_NO_MORE_ITEMS) {
808 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
809 link->conf.ConfigIndex = cf->index;
810 for (j = 0; j < 5; j++) {
811 link->io.BasePort1 = base[j];
812 link->io.IOAddrLines = base[j] ? 16 : 3;
813 i = pcmcia_request_io(link->handle, &link->io);
814 if (i == CS_SUCCESS)
815 goto found_port;
816 }
817 }
818 i = next_tuple(handle, &tuple, &parse);
819 }
820
821found_port:
822 if (i != CS_SUCCESS) {
823 BT_ERR("No usable port range found");
824 cs_error(link->handle, RequestIO, i);
825 goto failed;
826 }
827
828 i = pcmcia_request_irq(link->handle, &link->irq);
829 if (i != CS_SUCCESS) {
830 cs_error(link->handle, RequestIRQ, i);
831 link->irq.AssignedIRQ = 0;
832 }
833
834 i = pcmcia_request_configuration(link->handle, &link->conf);
835 if (i != CS_SUCCESS) {
836 cs_error(link->handle, RequestConfiguration, i);
837 goto failed;
838 }
839
840 if (bt3c_open(info) != 0)
841 goto failed;
842
843 strcpy(info->node.dev_name, info->hdev->name);
844 link->dev = &info->node;
845 link->state &= ~DEV_CONFIG_PENDING;
846
847 return;
848
849cs_failed:
850 cs_error(link->handle, last_fn, last_ret);
851
852failed:
853 bt3c_release(link);
854}
855
856
857static void bt3c_release(dev_link_t *link)
858{
859 bt3c_info_t *info = link->priv;
860
861 if (link->state & DEV_PRESENT)
862 bt3c_close(info);
863
864 link->dev = NULL;
865
866 pcmcia_release_configuration(link->handle);
867 pcmcia_release_io(link->handle, &link->io);
868 pcmcia_release_irq(link->handle, &link->irq);
869
870 link->state &= ~DEV_CONFIG;
871}
872
98e4c28b
DB		 873static int bt3c_suspend(struct pcmcia_device *dev)
874{
875 dev_link_t *link = dev_to_instance(dev);
876
877 link->state |= DEV_SUSPEND;
878 if (link->state & DEV_CONFIG)
879 pcmcia_release_configuration(link->handle);
880
881 return 0;
882}
883
884static int bt3c_resume(struct pcmcia_device *dev)
885{
886 dev_link_t *link = dev_to_instance(dev);
887
888 link->state &= ~DEV_SUSPEND;
889 if (DEV_OK(link))
890 pcmcia_request_configuration(link->handle, &link->conf);
891
892 return 0;
893}
1da177e4
LT		 894
895static int bt3c_event(event_t event, int priority, event_callback_args_t *args)
896{
897 dev_link_t *link = args->client_data;
1da177e4
LT		 898
899 switch (event) {
1da177e4
LT		 900 case CS_EVENT_CARD_INSERTION:
901 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
902 bt3c_config(link);
903 break;
1da177e4
LT		 904 }
905
906 return 0;
907}
908
a01c3ed4
DB		 909static struct pcmcia_device_id bt3c_ids[] = {
910 PCMCIA_DEVICE_PROD_ID13("3COM", "Bluetooth PC Card", 0xefce0a31, 0xd4ce9b02),
911 PCMCIA_DEVICE_NULL
912};
913MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
914
1da177e4
LT		 915static struct pcmcia_driver bt3c_driver = {
916 .owner = THIS_MODULE,
917 .drv = {
918 .name = "bt3c_cs",
919 },
920 .attach = bt3c_attach,
1e212f36 921 .event = bt3c_event,
cc3b4866 922 .remove = bt3c_detach,
a01c3ed4 923 .id_table = bt3c_ids,
98e4c28b
DB		 924 .suspend = bt3c_suspend,
925 .resume = bt3c_resume,
1da177e4
LT		 926};
927
928static int __init init_bt3c_cs(void)
929{
930 return pcmcia_register_driver(&bt3c_driver);
931}
932
933
934static void __exit exit_bt3c_cs(void)
935{
936 pcmcia_unregister_driver(&bt3c_driver);
1da177e4
LT		 937}
938
939module_init(init_bt3c_cs);
940module_exit(exit_bt3c_cs);
ubuntu-bionic-kernel mirror