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