?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[DCCP]: Update documentation references.
[linux-2.6.22.y-op.git] / drivers / serial / serial_cs.c
blob00f9ffd6948969c000b1382b860eb916df25f61d
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, last_ret, last_fn;
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 /* Get configuration register information */
744 tuple->DesiredTuple = CISTPL_CONFIG;
745 last_ret = first_tuple(link, tuple, parse);
746 if (last_ret != CS_SUCCESS) {
747 last_fn = ParseTuple;
748 goto cs_failed;
749 }
750 link->conf.ConfigBase = parse->config.base;
751 link->conf.Present = parse->config.rmask[0];
752
753 /* Is this a compliant multifunction card? */
754 tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
755 tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
756 info->multi = (first_tuple(link, tuple, parse) == CS_SUCCESS);
757
758 /* Is this a multiport card? */
759 tuple->DesiredTuple = CISTPL_MANFID;
760 if (first_tuple(link, tuple, parse) == CS_SUCCESS) {
761 info->manfid = parse->manfid.manf;
762 info->prodid = parse->manfid.card;
763
764 for (i = 0; i < ARRAY_SIZE(quirks); i++)
765 if ((quirks[i].manfid == ~0 ||
766 quirks[i].manfid == info->manfid) &&
767 (quirks[i].prodid == ~0 ||
768 quirks[i].prodid == info->prodid)) {
769 info->quirk = &quirks[i];
770 break;
771 }
772 }
773
774 /* Another check for dual-serial cards: look for either serial or
775 multifunction cards that ask for appropriate IO port ranges */
776 tuple->DesiredTuple = CISTPL_FUNCID;
777 if ((info->multi == 0) &&
778 ((first_tuple(link, tuple, parse) != CS_SUCCESS) ||
779 (parse->funcid.func == CISTPL_FUNCID_MULTI) ||
780 (parse->funcid.func == CISTPL_FUNCID_SERIAL))) {
781 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
782 if (first_tuple(link, tuple, parse) == CS_SUCCESS) {
783 if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
784 info->multi = cf->io.win[0].len >> 3;
785 if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
786 (cf->io.win[1].len == 8))
787 info->multi = 2;
788 }
789 }
790
791 /*
792 * Apply any multi-port quirk.
793 */
794 if (info->quirk && info->quirk->multi != -1)
795 info->multi = info->quirk->multi;
796
797 if (info->multi > 1)
798 multi_config(link);
799 else
800 simple_config(link);
801
802 if (info->ndev == 0)
803 goto failed;
804
805 /*
806 * Apply any post-init quirk. FIXME: This should really happen
807 * before we register the port, since it might already be in use.
808 */
809 if (info->quirk && info->quirk->post)
810 if (info->quirk->post(link))
811 goto failed;
812
813 link->dev_node = &info->node[0];
814 kfree(cfg_mem);
815 return 0;
816
817 cs_failed:
818 cs_error(link, last_fn, last_ret);
819 failed:
820 serial_remove(link);
821 kfree(cfg_mem);
822 return -ENODEV;
823 }
824
825 static struct pcmcia_device_id serial_ids[] = {
826 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
827 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
828 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
829 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
830 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
831 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
832 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
833 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
834 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
835 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
836 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
837 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
838 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
839 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
840 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
841 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
842 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
843 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
844 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
845 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
846 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
847 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
848 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
849 PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet + 56K COMBO", 0x578ba6e7, 0xb0ac62c4),
850 PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
851 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
852 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
853 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
854 PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
855 PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
856 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
857 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
858 PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
859 PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
860 PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
861 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet+Modem II", 0x2e3ee845, 0xeca401bf),
862 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
863 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
864 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
865 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
866 PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
867 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card ", 0xb569a6e5, 0x5bd4ff2c),
868 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
869 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
870 PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
871 PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
872 PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
873 PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x0276),
874 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0039),
875 PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0006),
876 PCMCIA_DEVICE_MANF_CARD(0x0105, 0x410a),
877 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d50),
878 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d51),
879 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d52),
880 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0d53),
881 PCMCIA_DEVICE_MANF_CARD(0x010b, 0xd180),
882 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x000e),
883 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x001b),
884 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0025),
885 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0045),
886 PCMCIA_DEVICE_MANF_CARD(0x0137, 0x0052),
887 PCMCIA_DEVICE_PROD_ID134("ADV", "TECH", "COMpad-32/85", 0x67459937, 0x916d02ba, 0x8fbe92ae),
888 PCMCIA_DEVICE_PROD_ID124("GATEWAY2000", "CC3144", "PCMCIA MODEM", 0x506bccae, 0xcb3685f1, 0xbd6c43ef),
889 PCMCIA_DEVICE_PROD_ID14("MEGAHERTZ", "PCMCIA MODEM", 0xf510db04, 0xbd6c43ef),
890 PCMCIA_DEVICE_PROD_ID124("TOSHIBA", "T144PF", "PCMCIA MODEM", 0xb4585a1a, 0x7271409c, 0xbd6c43ef),
891 PCMCIA_DEVICE_PROD_ID123("FUJITSU", "FC14F ", "MBH10213", 0x6ee5a3d8, 0x30ead12b, 0xb00f05a0),
892 PCMCIA_DEVICE_PROD_ID123("Novatel Wireless", "Merlin UMTS Modem", "U630", 0x32607776, 0xd9e73b13, 0xe87332e),
893 PCMCIA_DEVICE_PROD_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
894 PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
895 PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
896 PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
897 PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
898 PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
899 PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
900 PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
901 PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400+", 0x816cc815, 0x412729fb),
902 PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
903 PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
904 PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
905 PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
906 PCMCIA_DEVICE_PROD_ID12("OEM ", "C288MX ", 0xb572d360, 0xd2385b7a),
907 PCMCIA_DEVICE_PROD_ID12("PCMCIA ", "C336MX ", 0x99bcafe9, 0xaa25bcab),
908 PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
909 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
910 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
911 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
912 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
913 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
914 PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
915 PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
916 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
917 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
918 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
919 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
920 PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0x0710, "SW_7xx_SER.cis"), /* Sierra Wireless AC710/AC750 GPRS Network Adapter R1 */
921 PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
922 PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
923 PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
924 PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
925 PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
926 PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
927 PCMCIA_DEVICE_CIS_MANF_CARD(0x0013, 0x0000, "GLOBETROTTER.cis"),
928 /* too generic */
929 /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
930 /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
931 PCMCIA_DEVICE_FUNC_ID(2),
932 PCMCIA_DEVICE_NULL,
933 };
934 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
935
936 static struct pcmcia_driver serial_cs_driver = {
937 .owner = THIS_MODULE,
938 .drv = {
939 .name = "serial_cs",
940 },
941 .probe = serial_probe,
942 .remove = serial_detach,
943 .id_table = serial_ids,
944 .suspend = serial_suspend,
945 .resume = serial_resume,
946 };
947
948 static int __init init_serial_cs(void)
949 {
950 return pcmcia_register_driver(&serial_cs_driver);
951 }
952
953 static void __exit exit_serial_cs(void)
954 {
955 pcmcia_unregister_driver(&serial_cs_driver);
956 }
957
958 module_init(init_serial_cs);
959 module_exit(exit_serial_cs);
960
961 MODULE_LICENSE("GPL");
linux v2.6.22.y-op