?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: pci_root: simplify list traversals
[linux-2.6/linux-acpi-2.6.git] / drivers / serial / serial_cs.c
blob7546aa887fa7565417fe3a9f14956f5e9e314e40
1 /*======================================================================
2
3 A driver for PCMCIA serial devices
4
5 serial_cs.c 1.134 2002/05/04 05:48:53
6
7 The contents of this file are subject to the Mozilla Public
8 License Version 1.1 (the "License"); you may not use this file
9 except in compliance with the License. You may obtain a copy of
10 the License at http://www.mozilla.org/MPL/
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 Alternatively, the contents of this file may be used under the
22 terms of the GNU General Public License version 2 (the "GPL"), in which
23 case the provisions of the GPL are applicable instead of the
24 above. If you wish to allow the use of your version of this file
25 only under the terms of the GPL and not to allow others to use
26 your version of this file under the MPL, indicate your decision
27 by deleting the provisions above and replace them with the notice
28 and other provisions required by the GPL. If you do not delete
29 the provisions above, a recipient may use your version of this
30 file under either the MPL or the GPL.
31
32 ======================================================================*/
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/kernel.h>
37 #include <linux/init.h>
38 #include <linux/ptrace.h>
39 #include <linux/slab.h>
40 #include <linux/string.h>
41 #include <linux/timer.h>
42 #include <linux/serial_core.h>
43 #include <linux/delay.h>
44 #include <linux/major.h>
45 #include <asm/io.h>
46 #include <asm/system.h>
47
48 #include <pcmcia/cs_types.h>
49 #include <pcmcia/cs.h>
50 #include <pcmcia/cistpl.h>
51 #include <pcmcia/ciscode.h>
52 #include <pcmcia/ds.h>
53 #include <pcmcia/cisreg.h>
54
55 #include "8250.h"
56
57 #ifdef PCMCIA_DEBUG
58 static int pc_debug = PCMCIA_DEBUG;
59 module_param(pc_debug, int, 0644);
60 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
61 static char *version = "serial_cs.c 1.134 2002/05/04 05:48:53 (David Hinds)";
62 #else
63 #define DEBUG(n, args...)
64 #endif
65
66 /*====================================================================*/
67
68 /* Parameters that can be set with 'insmod' */
69
70 /* Enable the speaker? */
71 static int do_sound = 1;
72 /* Skip strict UART tests? */
73 static int buggy_uart;
74
75 module_param(do_sound, int, 0444);
76 module_param(buggy_uart, int, 0444);
77
78 /*====================================================================*/
79
80 /* Table of multi-port card ID's */
81
82 struct serial_quirk {
83 unsigned int manfid;
84 unsigned int prodid;
85 int multi; /* 1 = multifunction, > 1 = # ports */
86 void (*config)(struct pcmcia_device *);
87 void (*setup)(struct pcmcia_device *, struct uart_port *);
88 void (*wakeup)(struct pcmcia_device *);
89 int (*post)(struct pcmcia_device *);
90 };
91
92 struct serial_info {
93 struct pcmcia_device *p_dev;
94 int ndev;
95 int multi;
96 int slave;
97 int manfid;
98 int prodid;
99 int c950ctrl;
100 dev_node_t node[4];
101 int line[4];
102 const struct serial_quirk *quirk;
103 };
104
105 struct serial_cfg_mem {
106 tuple_t tuple;
107 cisparse_t parse;
108 u_char buf[256];
109 };
110
111 /*
112 * vers_1 5.0, "Brain Boxes", "2-Port RS232 card", "r6"
113 * manfid 0x0160, 0x0104
114 * This card appears to have a 14.7456MHz clock.
115 */
116 static void quirk_setup_brainboxes_0104(struct pcmcia_device *link, struct uart_port *port)
117 {
118 port->uartclk = 14745600;
119 }
120
121 static int quirk_post_ibm(struct pcmcia_device *link)
122 {
123 conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
124 int last_ret, last_fn;
125
126 last_ret = pcmcia_access_configuration_register(link, &reg);
127 if (last_ret) {
128 last_fn = AccessConfigurationRegister;
129 goto cs_failed;
130 }
131 reg.Action = CS_WRITE;
132 reg.Value = reg.Value | 1;
133 last_ret = pcmcia_access_configuration_register(link, &reg);
134 if (last_ret) {
135 last_fn = AccessConfigurationRegister;
136 goto cs_failed;
137 }
138 return 0;
139
140 cs_failed:
141 cs_error(link, last_fn, last_ret);
142 return -ENODEV;
143 }
144
145 /*
146 * Nokia cards are not really multiport cards. Shouldn't this
147 * be handled by setting the quirk entry .multi = 0 | 1 ?
148 */
149 static void quirk_config_nokia(struct pcmcia_device *link)
150 {
151 struct serial_info *info = link->priv;
152
153 if (info->multi > 1)
154 info->multi = 1;
155 }
156
157 static void quirk_wakeup_oxsemi(struct pcmcia_device *link)
158 {
159 struct serial_info *info = link->priv;
160
161 outb(12, info->c950ctrl + 1);
162 }
163
164 /* request_region? oxsemi branch does no request_region too... */
165 /*
166 * This sequence is needed to properly initialize MC45 attached to OXCF950.
167 * I tried decreasing these msleep()s, but it worked properly (survived
168 * 1000 stop/start operations) with these timeouts (or bigger).
169 */
170 static void quirk_wakeup_possio_gcc(struct pcmcia_device *link)
171 {
172 struct serial_info *info = link->priv;
173 unsigned int ctrl = info->c950ctrl;
174
175 outb(0xA, ctrl + 1);
176 msleep(100);
177 outb(0xE, ctrl + 1);
178 msleep(300);
179 outb(0xC, ctrl + 1);
180 msleep(100);
181 outb(0xE, ctrl + 1);
182 msleep(200);
183 outb(0xF, ctrl + 1);
184 msleep(100);
185 outb(0xE, ctrl + 1);
186 msleep(100);
187 outb(0xC, ctrl + 1);
188 }
189
190 /*
191 * Socket Dual IO: this enables irq's for second port
192 */
193 static void quirk_config_socket(struct pcmcia_device *link)
194 {
195 struct serial_info *info = link->priv;
196
197 if (info->multi) {
198 link->conf.Present |= PRESENT_EXT_STATUS;
199 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
200 }
201 }
202
203 static const struct serial_quirk quirks[] = {
204 {
205 .manfid = 0x0160,
206 .prodid = 0x0104,
207 .multi = -1,
208 .setup = quirk_setup_brainboxes_0104,
209 }, {
210 .manfid = MANFID_IBM,
211 .prodid = ~0,
212 .multi = -1,
213 .post = quirk_post_ibm,
214 }, {
215 .manfid = MANFID_INTEL,
216 .prodid = PRODID_INTEL_DUAL_RS232,
217 .multi = 2,
218 }, {
219 .manfid = MANFID_NATINST,
220 .prodid = PRODID_NATINST_QUAD_RS232,
221 .multi = 4,
222 }, {
223 .manfid = MANFID_NOKIA,
224 .prodid = ~0,
225 .multi = -1,
226 .config = quirk_config_nokia,
227 }, {
228 .manfid = MANFID_OMEGA,
229 .prodid = PRODID_OMEGA_QSP_100,
230 .multi = 4,
231 }, {
232 .manfid = MANFID_OXSEMI,
233 .prodid = ~0,
234 .multi = -1,
235 .wakeup = quirk_wakeup_oxsemi,
236 }, {
237 .manfid = MANFID_POSSIO,
238 .prodid = PRODID_POSSIO_GCC,
239 .multi = -1,
240 .wakeup = quirk_wakeup_possio_gcc,
241 }, {
242 .manfid = MANFID_QUATECH,
243 .prodid = PRODID_QUATECH_DUAL_RS232,
244 .multi = 2,
245 }, {
246 .manfid = MANFID_QUATECH,
247 .prodid = PRODID_QUATECH_DUAL_RS232_D1,
248 .multi = 2,
249 }, {
250 .manfid = MANFID_QUATECH,
251 .prodid = PRODID_QUATECH_DUAL_RS232_G,
252 .multi = 2,
253 }, {
254 .manfid = MANFID_QUATECH,
255 .prodid = PRODID_QUATECH_QUAD_RS232,
256 .multi = 4,
257 }, {
258 .manfid = MANFID_SOCKET,
259 .prodid = PRODID_SOCKET_DUAL_RS232,
260 .multi = 2,
261 .config = quirk_config_socket,
262 }, {
263 .manfid = MANFID_SOCKET,
264 .prodid = ~0,
265 .multi = -1,
266 .config = quirk_config_socket,
267 }
268 };
269
270
271 static int serial_config(struct pcmcia_device * link);
272
273
274 /*======================================================================
275
276 After a card is removed, serial_remove() will unregister
277 the serial device(s), and release the PCMCIA configuration.
278
279 ======================================================================*/
280
281 static void serial_remove(struct pcmcia_device *link)
282 {
283 struct serial_info *info = link->priv;
284 int i;
285
286 DEBUG(0, "serial_release(0x%p)\n", link);
287
288 /*
289 * Recheck to see if the device is still configured.
290 */
291 for (i = 0; i < info->ndev; i++)
292 serial8250_unregister_port(info->line[i]);
293
294 info->p_dev->dev_node = NULL;
295
296 if (!info->slave)
297 pcmcia_disable_device(link);
298 }
299
300 static int serial_suspend(struct pcmcia_device *link)
301 {
302 struct serial_info *info = link->priv;
303 int i;
304
305 for (i = 0; i < info->ndev; i++)
306 serial8250_suspend_port(info->line[i]);
307
308 return 0;
309 }
310
311 static int serial_resume(struct pcmcia_device *link)
312 {
313 struct serial_info *info = link->priv;
314 int i;
315
316 for (i = 0; i < info->ndev; i++)
317 serial8250_resume_port(info->line[i]);
318
319 if (info->quirk && info->quirk->wakeup)
320 info->quirk->wakeup(link);
321
322 return 0;
323 }
324
325 /*======================================================================
326
327 serial_attach() creates an "instance" of the driver, allocating
328 local data structures for one device. The device is registered
329 with Card Services.
330
331 ======================================================================*/
332
333 static int serial_probe(struct pcmcia_device *link)
334 {
335 struct serial_info *info;
336
337 DEBUG(0, "serial_attach()\n");
338
339 /* Create new serial device */
340 info = kzalloc(sizeof (*info), GFP_KERNEL);
341 if (!info)
342 return -ENOMEM;
343 info->p_dev = link;
344 link->priv = info;
345
346 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
347 link->io.NumPorts1 = 8;
348 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
349 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
350 link->conf.Attributes = CONF_ENABLE_IRQ;
351 if (do_sound) {
352 link->conf.Attributes |= CONF_ENABLE_SPKR;
353 link->conf.Status = CCSR_AUDIO_ENA;
354 }
355 link->conf.IntType = INT_MEMORY_AND_IO;
356
357 return serial_config(link);
358 }
359
360 /*======================================================================
361
362 This deletes a driver "instance". The device is de-registered
363 with Card Services. If it has been released, all local data
364 structures are freed. Otherwise, the structures will be freed
365 when the device is released.
366
367 ======================================================================*/
368
369 static void serial_detach(struct pcmcia_device *link)
370 {
371 struct serial_info *info = link->priv;
372
373 DEBUG(0, "serial_detach(0x%p)\n", link);
374
375 /*
376 * Ensure any outstanding scheduled tasks are completed.
377 */
378 flush_scheduled_work();
379
380 /*
381 * Ensure that the ports have been released.
382 */
383 serial_remove(link);
384
385 /* free bits */
386 kfree(info);
387 }
388
389 /*====================================================================*/
390
391 static int setup_serial(struct pcmcia_device *handle, struct serial_info * info,
392 unsigned int iobase, int irq)
393 {
394 struct uart_port port;
395 int line;
396
397 memset(&port, 0, sizeof (struct uart_port));
398 port.iobase = iobase;
399 port.irq = irq;
400 port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
401 port.uartclk = 1843200;
402 port.dev = &handle_to_dev(handle);
403 if (buggy_uart)
404 port.flags |= UPF_BUGGY_UART;
405
406 if (info->quirk && info->quirk->setup)
407 info->quirk->setup(handle, &port);
408
409 line = serial8250_register_port(&port);
410 if (line < 0) {
411 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
412 "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
413 return -EINVAL;
414 }
415
416 info->line[info->ndev] = line;
417 sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
418 info->node[info->ndev].major = TTY_MAJOR;
419 info->node[info->ndev].minor = 0x40 + line;
420 if (info->ndev > 0)
421 info->node[info->ndev - 1].next = &info->node[info->ndev];
422 info->ndev++;
423
424 return 0;
425 }
426
427 /*====================================================================*/
428
429 static int
430 first_tuple(struct pcmcia_device *handle, tuple_t * tuple, cisparse_t * parse)
431 {
432 int i;
433 i = pcmcia_get_first_tuple(handle, tuple);
434 if (i != 0)
435 return i;
436 i = pcmcia_get_tuple_data(handle, tuple);
437 if (i != 0)
438 return i;
439 return pcmcia_parse_tuple(tuple, parse);
440 }
441
442 /*====================================================================*/
443
444 static int simple_config_check(struct pcmcia_device *p_dev,
445 cistpl_cftable_entry_t *cf,
446 cistpl_cftable_entry_t *dflt,
447 unsigned int vcc,
448 void *priv_data)
449 {
450 static const int size_table[2] = { 8, 16 };
451 int *try = priv_data;
452
453 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
454 p_dev->conf.Vpp =
455 cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
456
457 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[(*try >> 1)])
458 && (cf->io.win[0].base != 0)) {
459 p_dev->io.BasePort1 = cf->io.win[0].base;
460 p_dev->io.IOAddrLines = ((*try & 0x1) == 0) ?
461 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
462 if (!pcmcia_request_io(p_dev, &p_dev->io))
463 return 0;
464 }
465 return -EINVAL;
466 }
467
468 static int simple_config_check_notpicky(struct pcmcia_device *p_dev,
469 cistpl_cftable_entry_t *cf,
470 cistpl_cftable_entry_t *dflt,
471 unsigned int vcc,
472 void *priv_data)
473 {
474 static const unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
475 int j;
476
477 if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
478 for (j = 0; j < 5; j++) {
479 p_dev->io.BasePort1 = base[j];
480 p_dev->io.IOAddrLines = base[j] ? 16 : 3;
481 if (!pcmcia_request_io(p_dev, &p_dev->io))
482 return 0;
483 }
484 }
485 return -ENODEV;
486 }
487
488 static int simple_config(struct pcmcia_device *link)
489 {
490 struct serial_info *info = link->priv;
491 int i = -ENODEV, try;
492
493 /* If the card is already configured, look up the port and irq */
494 if (link->function_config) {
495 unsigned int port = 0;
496 if ((link->io.BasePort2 != 0) &&
497 (link->io.NumPorts2 == 8)) {
498 port = link->io.BasePort2;
499 info->slave = 1;
500 } else if ((info->manfid == MANFID_OSITECH) &&
501 (link->io.NumPorts1 == 0x40)) {
502 port = link->io.BasePort1 + 0x28;
503 info->slave = 1;
504 }
505 if (info->slave) {
506 return setup_serial(link, info, port,
507 link->irq.AssignedIRQ);
508 }
509 }
510
511 /* First pass: look for a config entry that looks normal.
512 * Two tries: without IO aliases, then with aliases */
513 for (try = 0; try < 4; try++)
514 if (!pcmcia_loop_config(link, simple_config_check, &try))
515 goto found_port;
516
517 /* Second pass: try to find an entry that isn't picky about
518 its base address, then try to grab any standard serial port
519 address, and finally try to get any free port. */
520 if (!pcmcia_loop_config(link, simple_config_check_notpicky, NULL))
521 goto found_port;
522
523 printk(KERN_NOTICE
524 "serial_cs: no usable port range found, giving up\n");
525 cs_error(link, RequestIO, i);
526 return -1;
527
528 found_port:
529 i = pcmcia_request_irq(link, &link->irq);
530 if (i != 0) {
531 cs_error(link, RequestIRQ, i);
532 link->irq.AssignedIRQ = 0;
533 }
534 if (info->multi && (info->manfid == MANFID_3COM))
535 link->conf.ConfigIndex &= ~(0x08);
536
537 /*
538 * Apply any configuration quirks.
539 */
540 if (info->quirk && info->quirk->config)
541 info->quirk->config(link);
542
543 i = pcmcia_request_configuration(link, &link->conf);
544 if (i != 0) {
545 cs_error(link, RequestConfiguration, i);
546 return -1;
547 }
548 return setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
549 }
550
551 static int multi_config_check(struct pcmcia_device *p_dev,
552 cistpl_cftable_entry_t *cf,
553 cistpl_cftable_entry_t *dflt,
554 unsigned int vcc,
555 void *priv_data)
556 {
557 int *base2 = priv_data;
558
559 /* The quad port cards have bad CIS's, so just look for a
560 window larger than 8 ports and assume it will be right */
561 if ((cf->io.nwin == 1) && (cf->io.win[0].len > 8)) {
562 p_dev->io.BasePort1 = cf->io.win[0].base;
563 p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
564 if (!pcmcia_request_io(p_dev, &p_dev->io)) {
565 *base2 = p_dev->io.BasePort1 + 8;
566 return 0;
567 }
568 }
569 return -ENODEV;
570 }
571
572 static int multi_config_check_notpicky(struct pcmcia_device *p_dev,
573 cistpl_cftable_entry_t *cf,
574 cistpl_cftable_entry_t *dflt,
575 unsigned int vcc,
576 void *priv_data)
577 {
578 int *base2 = priv_data;
579
580 if (cf->io.nwin == 2) {
581 p_dev->io.BasePort1 = cf->io.win[0].base;
582 p_dev->io.BasePort2 = cf->io.win[1].base;
583 p_dev->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
584 if (!pcmcia_request_io(p_dev, &p_dev->io)) {
585 *base2 = p_dev->io.BasePort2;
586 return 0;
587 }
588 }
589 return -ENODEV;
590 }
591
592 static int multi_config(struct pcmcia_device *link)
593 {
594 struct serial_info *info = link->priv;
595 int i, base2 = 0;
596
597 /* First, look for a generic full-sized window */
598 link->io.NumPorts1 = info->multi * 8;
599 if (pcmcia_loop_config(link, multi_config_check, &base2)) {
600 /* If that didn't work, look for two windows */
601 link->io.NumPorts1 = link->io.NumPorts2 = 8;
602 info->multi = 2;
603 if (pcmcia_loop_config(link, multi_config_check_notpicky,
604 &base2)) {
605 printk(KERN_NOTICE "serial_cs: no usable port range"
606 "found, giving up\n");
607 return -ENODEV;
608 }
609 }
610
611 i = pcmcia_request_irq(link, &link->irq);
612 if (i != 0) {
613 /* FIXME: comment does not fit, error handling does not fit */
614 printk(KERN_NOTICE
615 "serial_cs: no usable port range found, giving up\n");
616 cs_error(link, RequestIRQ, i);
617 link->irq.AssignedIRQ = 0;
618 }
619
620 /*
621 * Apply any configuration quirks.
622 */
623 if (info->quirk && info->quirk->config)
624 info->quirk->config(link);
625
626 i = pcmcia_request_configuration(link, &link->conf);
627 if (i != 0) {
628 cs_error(link, RequestConfiguration, i);
629 return -ENODEV;
630 }
631
632 /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
633 * 8 registers are for the UART, the others are extra registers.
634 * Siemen's MC45 PCMCIA (Possio's GCC) is OXCF950 based too.
635 */
636 if (info->manfid == MANFID_OXSEMI || (info->manfid == MANFID_POSSIO &&
637 info->prodid == PRODID_POSSIO_GCC)) {
638 int err;
639
640 if (link->conf.ConfigIndex == 1 ||
641 link->conf.ConfigIndex == 3) {
642 err = setup_serial(link, info, base2,
643 link->irq.AssignedIRQ);
644 base2 = link->io.BasePort1;
645 } else {
646 err = setup_serial(link, info, link->io.BasePort1,
647 link->irq.AssignedIRQ);
648 }
649 info->c950ctrl = base2;
650
651 /*
652 * FIXME: We really should wake up the port prior to
653 * handing it over to the serial layer.
654 */
655 if (info->quirk && info->quirk->wakeup)
656 info->quirk->wakeup(link);
657
658 return 0;
659 }
660
661 setup_serial(link, info, link->io.BasePort1, link->irq.AssignedIRQ);
662 for (i = 0; i < info->multi - 1; i++)
663 setup_serial(link, info, base2 + (8 * i),
664 link->irq.AssignedIRQ);
665 return 0;
666 }
667
668 /*======================================================================
669
670 serial_config() is scheduled to run after a CARD_INSERTION event
671 is received, to configure the PCMCIA socket, and to make the
672 serial device available to the system.
673
674 ======================================================================*/
675
676 static int serial_config(struct pcmcia_device * link)
677 {
678 struct serial_info *info = link->priv;
679 struct serial_cfg_mem *cfg_mem;
680 tuple_t *tuple;
681 u_char *buf;
682 cisparse_t *parse;
683 cistpl_cftable_entry_t *cf;
684 int i;
685
686 DEBUG(0, "serial_config(0x%p)\n", link);
687
688 cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
689 if (!cfg_mem)
690 goto failed;
691
692 tuple = &cfg_mem->tuple;
693 parse = &cfg_mem->parse;
694 cf = &parse->cftable_entry;
695 buf = cfg_mem->buf;
696
697 tuple->TupleData = (cisdata_t *) buf;
698 tuple->TupleOffset = 0;
699 tuple->TupleDataMax = 255;
700 tuple->Attributes = 0;
701
702 /* Is this a compliant multifunction card? */
703 tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
704 tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
705 info->multi = (first_tuple(link, tuple, parse) == 0);
706
707 /* Is this a multiport card? */
708 tuple->DesiredTuple = CISTPL_MANFID;
709 info->manfid = link->manf_id;
710 info->prodid = link->card_id;
711
712 for (i = 0; i < ARRAY_SIZE(quirks); i++)
713 if ((quirks[i].manfid == ~0 ||
714 quirks[i].manfid == info->manfid) &&
715 (quirks[i].prodid == ~0 ||
716 quirks[i].prodid == info->prodid)) {
717 info->quirk = &quirks[i];
718 break;
719 }
720
721 /* Another check for dual-serial cards: look for either serial or
722 multifunction cards that ask for appropriate IO port ranges */
723 tuple->DesiredTuple = CISTPL_FUNCID;
724 if ((info->multi == 0) &&
725 (link->has_func_id) &&
726 ((link->func_id == CISTPL_FUNCID_MULTI) ||
727 (link->func_id == CISTPL_FUNCID_SERIAL))) {
728 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
729 if (first_tuple(link, tuple, parse) == 0) {
730 if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
731 info->multi = cf->io.win[0].len >> 3;
732 if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
733 (cf->io.win[1].len == 8))
734 info->multi = 2;
735 }
736 }
737
738 /*
739 * Apply any multi-port quirk.
740 */
741 if (info->quirk && info->quirk->multi != -1)
742 info->multi = info->quirk->multi;
743
744 if (info->multi > 1)
745 multi_config(link);
746 else
747 simple_config(link);
748
749 if (info->ndev == 0)
750 goto failed;
751
752 /*
753 * Apply any post-init quirk. FIXME: This should really happen
754 * before we register the port, since it might already be in use.
755 */
756 if (info->quirk && info->quirk->post)
757 if (info->quirk->post(link))
758 goto failed;
759
760 link->dev_node = &info->node[0];
761 kfree(cfg_mem);
762 return 0;
763
764 failed:
765 serial_remove(link);
766 kfree(cfg_mem);
767 return -ENODEV;
768 }
769
770 static struct pcmcia_device_id serial_ids[] = {
771 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
772 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
773 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
774 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
775 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
776 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
777 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
778 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
779 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
780 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
781 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
782 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
783 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
784 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
785 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
786 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
787 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
788 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
789 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
790 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
791 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
792 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
793 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
794 PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
795 PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
796 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
797 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
798 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
799 PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
800 PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
801 PCMCIA_PFC_DEVICE_PROD_ID12(1, "MICRO RESEARCH", "COMBO-L/M-336", 0xb2ced065, 0x3ced0555),
802 PCMCIA_PFC_DEVICE_PROD_ID12(1, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
803 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
804 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
805 PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
806 PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
807 PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
808 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
809 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x0a05),
810 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0032, 0x1101),
811 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
812 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
813 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
814 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
815 PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
816 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card ", 0xb569a6e5, 0x5bd4ff2c),
817 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
818 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
819 PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
820 PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
821 PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
822 PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x0276),
823 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
824 PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
825 PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
826 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
827 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
828 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
829 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
830 PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
831 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
832 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
833 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
834 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
835 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
836 PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
837 PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
838 PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
839 PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
840 PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
841 PCMCIA_DEVICE_PROD_ID123("Novatel Wireless", "Merlin UMTS Modem", "U630", 0x32607776, 0xd9e73b13, 0xe87332e),
842 PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
843 PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
844 PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
845 PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
846 PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
847 PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
848 PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
849 PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
850 PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
851 PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
852 PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
853 PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
854 PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
855 PCMCIA_DEVICE_PROD_ID12("OEM ", "C288MX ", 0xb572d360, 0xd2385b7a),
856 PCMCIA_DEVICE_PROD_ID12("PCMCIA ", "C336MX ", 0x99bcafe9, 0xaa25bcab),
857 PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
858 PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "Dual RS-232 Serial Port PC Card", 0xc4420b35, 0x031a380d),
859 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
860 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
861 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
862 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
863 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
864 PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
865 PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
866 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
867 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
868 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
869 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
870 PCMCIA_DEVICE_CIS_PROD_ID12("Sierra Wireless", "AC850", 0xd85f6206, 0x42a2c018, "SW_8xx_SER.cis"), /* Sierra Wireless AC850 3G Network Adapter R1 */
871 PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0x0710, "SW_7xx_SER.cis"), /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
872 PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
873 PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
874 PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
875 PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
876 PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
877 PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
878 PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "GLOBETROTTER.cis"),
879 PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100 1.00.",0x19ca78af,0xf964f42b),
880 PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL100",0x19ca78af,0x71d98e83),
881 PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232 1.00.",0x19ca78af,0x69fb7490),
882 PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c1997.","SERIAL CARD: SL232",0x19ca78af,0xb6bc0235),
883 PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c2000.","SERIAL CARD: CF232",0x63f2e0bd,0xb9e175d3),
884 PCMCIA_DEVICE_PROD_ID12("ELAN DIGITAL SYSTEMS LTD, c2000.","SERIAL CARD: CF232-5",0x63f2e0bd,0xfce33442),
885 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF232",0x3beb8cf2,0x171e7190),
886 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF232-5",0x3beb8cf2,0x20da4262),
887 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF428",0x3beb8cf2,0xea5dd57d),
888 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: CF500",0x3beb8cf2,0xd77255fa),
889 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: IC232",0x3beb8cf2,0x6a709903),
890 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: SL232",0x3beb8cf2,0x18430676),
891 PCMCIA_DEVICE_PROD_ID12("Elan","Serial Port: XL232",0x3beb8cf2,0x6f933767),
892 PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: CF332",0x3beb8cf2,0x16dc1ba7),
893 PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL332",0x3beb8cf2,0x19816c41),
894 PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL385",0x3beb8cf2,0x64112029),
895 PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
896 PCMCIA_MFC_DEVICE_PROD_ID12(0,"Elan","Serial+Parallel Port: SP230",0x3beb8cf2,0xdb9e58bc),
897 PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: CF332",0x3beb8cf2,0x16dc1ba7),
898 PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL332",0x3beb8cf2,0x19816c41),
899 PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL385",0x3beb8cf2,0x64112029),
900 PCMCIA_MFC_DEVICE_PROD_ID12(1,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
901 PCMCIA_MFC_DEVICE_PROD_ID12(2,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
902 PCMCIA_MFC_DEVICE_PROD_ID12(3,"Elan","Serial Port: SL432",0x3beb8cf2,0x1cce7ac4),
903 PCMCIA_DEVICE_MANF_CARD(0x0279, 0x950b),
904 /* too generic */
905 /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
906 /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
907 PCMCIA_DEVICE_FUNC_ID(2),
908 PCMCIA_DEVICE_NULL,
909 };
910 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
911
912 static struct pcmcia_driver serial_cs_driver = {
913 .owner = THIS_MODULE,
914 .drv = {
915 .name = "serial_cs",
916 },
917 .probe = serial_probe,
918 .remove = serial_detach,
919 .id_table = serial_ids,
920 .suspend = serial_suspend,
921 .resume = serial_resume,
922 };
923
924 static int __init init_serial_cs(void)
925 {
926 return pcmcia_register_driver(&serial_cs_driver);
927 }
928
929 static void __exit exit_serial_cs(void)
930 {
931 pcmcia_unregister_driver(&serial_cs_driver);
932 }
933
934 module_init(init_serial_cs);
935 module_exit(exit_serial_cs);
936
937 MODULE_LICENSE("GPL");
Linux ACPI git tree (mirror)