drm: add 32/64 support for MGA/R128/i915
[linux-2.6/verdex.git] / drivers / serial / serial_cs.c
blob73a34b18866f405ee8a5d147a42ce9e46108a83d
1 /*======================================================================
3 A driver for PCMCIA serial devices
5 serial_cs.c 1.134 2002/05/04 05:48:53
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/
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.
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.
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.
32 ======================================================================*/
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/major.h>
45 #include <asm/io.h>
46 #include <asm/system.h>
48 #include <pcmcia/version.h>
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>
56 #include "8250.h"
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
67 /*====================================================================*/
69 /* Parameters that can be set with 'insmod' */
71 /* Enable the speaker? */
72 static int do_sound = 1;
73 /* Skip strict UART tests? */
74 static int buggy_uart;
76 module_param(do_sound, int, 0444);
77 module_param(buggy_uart, int, 0444);
79 /*====================================================================*/
81 /* Table of multi-port card ID's */
83 struct multi_id {
84 u_short manfid;
85 u_short prodid;
86 int multi; /* 1 = multifunction, > 1 = # ports */
89 static struct multi_id multi_id[] = {
90 { MANFID_OMEGA, PRODID_OMEGA_QSP_100, 4 },
91 { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232, 2 },
92 { MANFID_QUATECH, PRODID_QUATECH_DUAL_RS232_D1, 2 },
93 { MANFID_QUATECH, PRODID_QUATECH_QUAD_RS232, 4 },
94 { MANFID_SOCKET, PRODID_SOCKET_DUAL_RS232, 2 },
95 { MANFID_INTEL, PRODID_INTEL_DUAL_RS232, 2 },
96 { MANFID_NATINST, PRODID_NATINST_QUAD_RS232, 4 }
98 #define MULTI_COUNT (sizeof(multi_id)/sizeof(struct multi_id))
100 struct serial_info {
101 dev_link_t link;
102 int ndev;
103 int multi;
104 int slave;
105 int manfid;
106 dev_node_t node[4];
107 int line[4];
110 struct serial_cfg_mem {
111 tuple_t tuple;
112 cisparse_t parse;
113 u_char buf[256];
117 static void serial_config(dev_link_t * link);
118 static int serial_event(event_t event, int priority,
119 event_callback_args_t * args);
121 static dev_info_t dev_info = "serial_cs";
123 static dev_link_t *serial_attach(void);
124 static void serial_detach(dev_link_t *);
126 static dev_link_t *dev_list = NULL;
128 /*======================================================================
130 After a card is removed, serial_remove() will unregister
131 the serial device(s), and release the PCMCIA configuration.
133 ======================================================================*/
135 static void serial_remove(dev_link_t *link)
137 struct serial_info *info = link->priv;
138 int i;
140 link->state &= ~DEV_PRESENT;
142 DEBUG(0, "serial_release(0x%p)\n", link);
145 * Recheck to see if the device is still configured.
147 if (info->link.state & DEV_CONFIG) {
148 for (i = 0; i < info->ndev; i++)
149 serial8250_unregister_port(info->line[i]);
151 info->link.dev = NULL;
153 if (!info->slave) {
154 pcmcia_release_configuration(info->link.handle);
155 pcmcia_release_io(info->link.handle, &info->link.io);
156 pcmcia_release_irq(info->link.handle, &info->link.irq);
159 info->link.state &= ~DEV_CONFIG;
163 static void serial_suspend(dev_link_t *link)
165 link->state |= DEV_SUSPEND;
167 if (link->state & DEV_CONFIG) {
168 struct serial_info *info = link->priv;
169 int i;
171 for (i = 0; i < info->ndev; i++)
172 serial8250_suspend_port(info->line[i]);
174 if (!info->slave)
175 pcmcia_release_configuration(link->handle);
179 static void serial_resume(dev_link_t *link)
181 link->state &= ~DEV_SUSPEND;
183 if (DEV_OK(link)) {
184 struct serial_info *info = link->priv;
185 int i;
187 if (!info->slave)
188 pcmcia_request_configuration(link->handle, &link->conf);
190 for (i = 0; i < info->ndev; i++)
191 serial8250_resume_port(info->line[i]);
195 /*======================================================================
197 serial_attach() creates an "instance" of the driver, allocating
198 local data structures for one device. The device is registered
199 with Card Services.
201 ======================================================================*/
203 static dev_link_t *serial_attach(void)
205 struct serial_info *info;
206 client_reg_t client_reg;
207 dev_link_t *link;
208 int ret;
210 DEBUG(0, "serial_attach()\n");
212 /* Create new serial device */
213 info = kmalloc(sizeof (*info), GFP_KERNEL);
214 if (!info)
215 return NULL;
216 memset(info, 0, sizeof (*info));
217 link = &info->link;
218 link->priv = info;
220 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
221 link->io.NumPorts1 = 8;
222 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
223 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
224 link->conf.Attributes = CONF_ENABLE_IRQ;
225 if (do_sound) {
226 link->conf.Attributes |= CONF_ENABLE_SPKR;
227 link->conf.Status = CCSR_AUDIO_ENA;
229 link->conf.IntType = INT_MEMORY_AND_IO;
231 /* Register with Card Services */
232 link->next = dev_list;
233 dev_list = link;
234 client_reg.dev_info = &dev_info;
235 client_reg.EventMask =
236 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
237 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
238 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
239 client_reg.event_handler = &serial_event;
240 client_reg.Version = 0x0210;
241 client_reg.event_callback_args.client_data = link;
242 ret = pcmcia_register_client(&link->handle, &client_reg);
243 if (ret != CS_SUCCESS) {
244 cs_error(link->handle, RegisterClient, ret);
245 serial_detach(link);
246 return NULL;
249 return link;
252 /*======================================================================
254 This deletes a driver "instance". The device is de-registered
255 with Card Services. If it has been released, all local data
256 structures are freed. Otherwise, the structures will be freed
257 when the device is released.
259 ======================================================================*/
261 static void serial_detach(dev_link_t * link)
263 struct serial_info *info = link->priv;
264 dev_link_t **linkp;
265 int ret;
267 DEBUG(0, "serial_detach(0x%p)\n", link);
269 /* Locate device structure */
270 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
271 if (*linkp == link)
272 break;
273 if (*linkp == NULL)
274 return;
277 * Ensure any outstanding scheduled tasks are completed.
279 flush_scheduled_work();
282 * Ensure that the ports have been released.
284 serial_remove(link);
286 if (link->handle) {
287 ret = pcmcia_deregister_client(link->handle);
288 if (ret != CS_SUCCESS)
289 cs_error(link->handle, DeregisterClient, ret);
292 /* Unlink device structure, free bits */
293 *linkp = link->next;
294 kfree(info);
297 /*====================================================================*/
299 static int setup_serial(client_handle_t handle, struct serial_info * info,
300 kio_addr_t iobase, int irq)
302 struct uart_port port;
303 int line;
305 memset(&port, 0, sizeof (struct uart_port));
306 port.iobase = iobase;
307 port.irq = irq;
308 port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
309 port.uartclk = 1843200;
310 port.dev = &handle_to_dev(handle);
311 if (buggy_uart)
312 port.flags |= UPF_BUGGY_UART;
313 line = serial8250_register_port(&port);
314 if (line < 0) {
315 printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
316 "0x%04lx, irq %d failed\n", (u_long)iobase, irq);
317 return -EINVAL;
320 info->line[info->ndev] = line;
321 sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
322 info->node[info->ndev].major = TTY_MAJOR;
323 info->node[info->ndev].minor = 0x40 + line;
324 if (info->ndev > 0)
325 info->node[info->ndev - 1].next = &info->node[info->ndev];
326 info->ndev++;
328 return 0;
331 /*====================================================================*/
333 static int
334 first_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
336 int i;
337 i = pcmcia_get_first_tuple(handle, tuple);
338 if (i != CS_SUCCESS)
339 return CS_NO_MORE_ITEMS;
340 i = pcmcia_get_tuple_data(handle, tuple);
341 if (i != CS_SUCCESS)
342 return i;
343 return pcmcia_parse_tuple(handle, tuple, parse);
346 static int
347 next_tuple(client_handle_t handle, tuple_t * tuple, cisparse_t * parse)
349 int i;
350 i = pcmcia_get_next_tuple(handle, tuple);
351 if (i != CS_SUCCESS)
352 return CS_NO_MORE_ITEMS;
353 i = pcmcia_get_tuple_data(handle, tuple);
354 if (i != CS_SUCCESS)
355 return i;
356 return pcmcia_parse_tuple(handle, tuple, parse);
359 /*====================================================================*/
361 static int simple_config(dev_link_t *link)
363 static kio_addr_t base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
364 static int size_table[2] = { 8, 16 };
365 client_handle_t handle = link->handle;
366 struct serial_info *info = link->priv;
367 struct serial_cfg_mem *cfg_mem;
368 tuple_t *tuple;
369 u_char *buf;
370 cisparse_t *parse;
371 cistpl_cftable_entry_t *cf;
372 config_info_t config;
373 int i, j, try;
374 int s;
376 cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
377 if (!cfg_mem)
378 return -1;
380 tuple = &cfg_mem->tuple;
381 parse = &cfg_mem->parse;
382 cf = &parse->cftable_entry;
383 buf = cfg_mem->buf;
385 /* If the card is already configured, look up the port and irq */
386 i = pcmcia_get_configuration_info(handle, &config);
387 if ((i == CS_SUCCESS) && (config.Attributes & CONF_VALID_CLIENT)) {
388 kio_addr_t port = 0;
389 if ((config.BasePort2 != 0) && (config.NumPorts2 == 8)) {
390 port = config.BasePort2;
391 info->slave = 1;
392 } else if ((info->manfid == MANFID_OSITECH) &&
393 (config.NumPorts1 == 0x40)) {
394 port = config.BasePort1 + 0x28;
395 info->slave = 1;
397 if (info->slave) {
398 kfree(cfg_mem);
399 return setup_serial(handle, info, port, config.AssignedIRQ);
402 link->conf.Vcc = config.Vcc;
404 /* First pass: look for a config entry that looks normal. */
405 tuple->TupleData = (cisdata_t *) buf;
406 tuple->TupleOffset = 0;
407 tuple->TupleDataMax = 255;
408 tuple->Attributes = 0;
409 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
410 /* Two tries: without IO aliases, then with aliases */
411 for (s = 0; s < 2; s++) {
412 for (try = 0; try < 2; try++) {
413 i = first_tuple(handle, tuple, parse);
414 while (i != CS_NO_MORE_ITEMS) {
415 if (i != CS_SUCCESS)
416 goto next_entry;
417 if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
418 link->conf.Vpp1 = link->conf.Vpp2 =
419 cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
420 if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[s]) &&
421 (cf->io.win[0].base != 0)) {
422 link->conf.ConfigIndex = cf->index;
423 link->io.BasePort1 = cf->io.win[0].base;
424 link->io.IOAddrLines = (try == 0) ?
425 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
426 i = pcmcia_request_io(link->handle, &link->io);
427 if (i == CS_SUCCESS)
428 goto found_port;
430 next_entry:
431 i = next_tuple(handle, tuple, parse);
435 /* Second pass: try to find an entry that isn't picky about
436 its base address, then try to grab any standard serial port
437 address, and finally try to get any free port. */
438 i = first_tuple(handle, tuple, parse);
439 while (i != CS_NO_MORE_ITEMS) {
440 if ((i == CS_SUCCESS) && (cf->io.nwin > 0) &&
441 ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
442 link->conf.ConfigIndex = cf->index;
443 for (j = 0; j < 5; j++) {
444 link->io.BasePort1 = base[j];
445 link->io.IOAddrLines = base[j] ? 16 : 3;
446 i = pcmcia_request_io(link->handle, &link->io);
447 if (i == CS_SUCCESS)
448 goto found_port;
451 i = next_tuple(handle, tuple, parse);
454 found_port:
455 if (i != CS_SUCCESS) {
456 printk(KERN_NOTICE
457 "serial_cs: no usable port range found, giving up\n");
458 cs_error(link->handle, RequestIO, i);
459 kfree(cfg_mem);
460 return -1;
463 i = pcmcia_request_irq(link->handle, &link->irq);
464 if (i != CS_SUCCESS) {
465 cs_error(link->handle, RequestIRQ, i);
466 link->irq.AssignedIRQ = 0;
468 if (info->multi && (info->manfid == MANFID_3COM))
469 link->conf.ConfigIndex &= ~(0x08);
470 i = pcmcia_request_configuration(link->handle, &link->conf);
471 if (i != CS_SUCCESS) {
472 cs_error(link->handle, RequestConfiguration, i);
473 kfree(cfg_mem);
474 return -1;
476 kfree(cfg_mem);
477 return setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
480 static int multi_config(dev_link_t * link)
482 client_handle_t handle = link->handle;
483 struct serial_info *info = link->priv;
484 struct serial_cfg_mem *cfg_mem;
485 tuple_t *tuple;
486 u_char *buf;
487 cisparse_t *parse;
488 cistpl_cftable_entry_t *cf;
489 config_info_t config;
490 int i, rc, base2 = 0;
492 cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
493 if (!cfg_mem)
494 return -1;
495 tuple = &cfg_mem->tuple;
496 parse = &cfg_mem->parse;
497 cf = &parse->cftable_entry;
498 buf = cfg_mem->buf;
500 i = pcmcia_get_configuration_info(handle, &config);
501 if (i != CS_SUCCESS) {
502 cs_error(handle, GetConfigurationInfo, i);
503 rc = -1;
504 goto free_cfg_mem;
506 link->conf.Vcc = config.Vcc;
508 tuple->TupleData = (cisdata_t *) buf;
509 tuple->TupleOffset = 0;
510 tuple->TupleDataMax = 255;
511 tuple->Attributes = 0;
512 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
514 /* First, look for a generic full-sized window */
515 link->io.NumPorts1 = info->multi * 8;
516 i = first_tuple(handle, tuple, parse);
517 while (i != CS_NO_MORE_ITEMS) {
518 /* The quad port cards have bad CIS's, so just look for a
519 window larger than 8 ports and assume it will be right */
520 if ((i == CS_SUCCESS) && (cf->io.nwin == 1) &&
521 (cf->io.win[0].len > 8)) {
522 link->conf.ConfigIndex = cf->index;
523 link->io.BasePort1 = cf->io.win[0].base;
524 link->io.IOAddrLines =
525 cf->io.flags & CISTPL_IO_LINES_MASK;
526 i = pcmcia_request_io(link->handle, &link->io);
527 base2 = link->io.BasePort1 + 8;
528 if (i == CS_SUCCESS)
529 break;
531 i = next_tuple(handle, tuple, parse);
534 /* If that didn't work, look for two windows */
535 if (i != CS_SUCCESS) {
536 link->io.NumPorts1 = link->io.NumPorts2 = 8;
537 info->multi = 2;
538 i = first_tuple(handle, tuple, parse);
539 while (i != CS_NO_MORE_ITEMS) {
540 if ((i == CS_SUCCESS) && (cf->io.nwin == 2)) {
541 link->conf.ConfigIndex = cf->index;
542 link->io.BasePort1 = cf->io.win[0].base;
543 link->io.BasePort2 = cf->io.win[1].base;
544 link->io.IOAddrLines =
545 cf->io.flags & CISTPL_IO_LINES_MASK;
546 i = pcmcia_request_io(link->handle, &link->io);
547 base2 = link->io.BasePort2;
548 if (i == CS_SUCCESS)
549 break;
551 i = next_tuple(handle, tuple, parse);
555 if (i != CS_SUCCESS) {
556 cs_error(link->handle, RequestIO, i);
557 rc = -1;
558 goto free_cfg_mem;
561 i = pcmcia_request_irq(link->handle, &link->irq);
562 if (i != CS_SUCCESS) {
563 printk(KERN_NOTICE
564 "serial_cs: no usable port range found, giving up\n");
565 cs_error(link->handle, RequestIRQ, i);
566 link->irq.AssignedIRQ = 0;
568 /* Socket Dual IO: this enables irq's for second port */
569 if (info->multi && (info->manfid == MANFID_SOCKET)) {
570 link->conf.Present |= PRESENT_EXT_STATUS;
571 link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
573 i = pcmcia_request_configuration(link->handle, &link->conf);
574 if (i != CS_SUCCESS) {
575 cs_error(link->handle, RequestConfiguration, i);
576 rc = -1;
577 goto free_cfg_mem;
580 /* The Oxford Semiconductor OXCF950 cards are in fact single-port:
581 8 registers are for the UART, the others are extra registers */
582 if (info->manfid == MANFID_OXSEMI) {
583 if (cf->index == 1 || cf->index == 3) {
584 setup_serial(handle, info, base2, link->irq.AssignedIRQ);
585 outb(12, link->io.BasePort1 + 1);
586 } else {
587 setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
588 outb(12, base2 + 1);
590 rc = 0;
591 goto free_cfg_mem;
594 setup_serial(handle, info, link->io.BasePort1, link->irq.AssignedIRQ);
595 /* The Nokia cards are not really multiport cards */
596 if (info->manfid == MANFID_NOKIA) {
597 rc = 0;
598 goto free_cfg_mem;
600 for (i = 0; i < info->multi - 1; i++)
601 setup_serial(handle, info, base2 + (8 * i),
602 link->irq.AssignedIRQ);
603 rc = 0;
604 free_cfg_mem:
605 kfree(cfg_mem);
606 return rc;
609 /*======================================================================
611 serial_config() is scheduled to run after a CARD_INSERTION event
612 is received, to configure the PCMCIA socket, and to make the
613 serial device available to the system.
615 ======================================================================*/
617 void serial_config(dev_link_t * link)
619 client_handle_t handle = link->handle;
620 struct serial_info *info = link->priv;
621 struct serial_cfg_mem *cfg_mem;
622 tuple_t *tuple;
623 u_char *buf;
624 cisparse_t *parse;
625 cistpl_cftable_entry_t *cf;
626 int i, last_ret, last_fn;
628 DEBUG(0, "serial_config(0x%p)\n", link);
630 cfg_mem = kmalloc(sizeof(struct serial_cfg_mem), GFP_KERNEL);
631 if (!cfg_mem)
632 goto failed;
634 tuple = &cfg_mem->tuple;
635 parse = &cfg_mem->parse;
636 cf = &parse->cftable_entry;
637 buf = cfg_mem->buf;
639 tuple->TupleData = (cisdata_t *) buf;
640 tuple->TupleOffset = 0;
641 tuple->TupleDataMax = 255;
642 tuple->Attributes = 0;
643 /* Get configuration register information */
644 tuple->DesiredTuple = CISTPL_CONFIG;
645 last_ret = first_tuple(handle, tuple, parse);
646 if (last_ret != CS_SUCCESS) {
647 last_fn = ParseTuple;
648 goto cs_failed;
650 link->conf.ConfigBase = parse->config.base;
651 link->conf.Present = parse->config.rmask[0];
653 /* Configure card */
654 link->state |= DEV_CONFIG;
656 /* Is this a compliant multifunction card? */
657 tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
658 tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
659 info->multi = (first_tuple(handle, tuple, parse) == CS_SUCCESS);
661 /* Is this a multiport card? */
662 tuple->DesiredTuple = CISTPL_MANFID;
663 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
664 info->manfid = parse->manfid.manf;
665 for (i = 0; i < MULTI_COUNT; i++)
666 if ((info->manfid == multi_id[i].manfid) &&
667 (parse->manfid.card == multi_id[i].prodid))
668 break;
669 if (i < MULTI_COUNT)
670 info->multi = multi_id[i].multi;
673 /* Another check for dual-serial cards: look for either serial or
674 multifunction cards that ask for appropriate IO port ranges */
675 tuple->DesiredTuple = CISTPL_FUNCID;
676 if ((info->multi == 0) &&
677 ((first_tuple(handle, tuple, parse) != CS_SUCCESS) ||
678 (parse->funcid.func == CISTPL_FUNCID_MULTI) ||
679 (parse->funcid.func == CISTPL_FUNCID_SERIAL))) {
680 tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
681 if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
682 if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
683 info->multi = cf->io.win[0].len >> 3;
684 if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
685 (cf->io.win[1].len == 8))
686 info->multi = 2;
690 if (info->multi > 1)
691 multi_config(link);
692 else
693 simple_config(link);
695 if (info->ndev == 0)
696 goto failed;
698 if (info->manfid == MANFID_IBM) {
699 conf_reg_t reg = { 0, CS_READ, 0x800, 0 };
700 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
701 if (last_ret) {
702 last_fn = AccessConfigurationRegister;
703 goto cs_failed;
705 reg.Action = CS_WRITE;
706 reg.Value = reg.Value | 1;
707 last_ret = pcmcia_access_configuration_register(link->handle, &reg);
708 if (last_ret) {
709 last_fn = AccessConfigurationRegister;
710 goto cs_failed;
714 link->dev = &info->node[0];
715 link->state &= ~DEV_CONFIG_PENDING;
716 kfree(cfg_mem);
717 return;
719 cs_failed:
720 cs_error(link->handle, last_fn, last_ret);
721 failed:
722 serial_remove(link);
723 link->state &= ~DEV_CONFIG_PENDING;
724 kfree(cfg_mem);
727 /*======================================================================
729 The card status event handler. Mostly, this schedules other
730 stuff to run after an event is received. A CARD_REMOVAL event
731 also sets some flags to discourage the serial drivers from
732 talking to the ports.
734 ======================================================================*/
736 static int
737 serial_event(event_t event, int priority, event_callback_args_t * args)
739 dev_link_t *link = args->client_data;
740 struct serial_info *info = link->priv;
742 DEBUG(1, "serial_event(0x%06x)\n", event);
744 switch (event) {
745 case CS_EVENT_CARD_REMOVAL:
746 serial_remove(link);
747 break;
749 case CS_EVENT_CARD_INSERTION:
750 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
751 serial_config(link);
752 break;
754 case CS_EVENT_PM_SUSPEND:
755 serial_suspend(link);
756 break;
758 case CS_EVENT_RESET_PHYSICAL:
759 if ((link->state & DEV_CONFIG) && !info->slave)
760 pcmcia_release_configuration(link->handle);
761 break;
763 case CS_EVENT_PM_RESUME:
764 serial_resume(link);
765 break;
767 case CS_EVENT_CARD_RESET:
768 if (DEV_OK(link) && !info->slave)
769 pcmcia_request_configuration(link->handle, &link->conf);
770 break;
772 return 0;
775 static struct pcmcia_device_id serial_ids[] = {
776 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0057, 0x0021),
777 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0089, 0x110a),
778 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0104, 0x000a),
779 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0xea15),
780 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0109, 0x0501),
781 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0138, 0x110a),
782 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0140, 0x000a),
783 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0x3341),
784 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0143, 0xc0ab),
785 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x016c, 0x0081),
786 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x021b, 0x0101),
787 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x08a1, 0xc0ab),
788 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0d0a),
789 PCMCIA_PFC_DEVICE_MANF_CARD(1, 0x0105, 0x0e0a),
790 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
791 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
792 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
793 PCMCIA_PFC_DEVICE_PROD_ID123(1, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
794 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM28", 0x2e3ee845, 0x0ea978ea),
795 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM33", 0x2e3ee845, 0x80609023),
796 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "CEM56", 0x2e3ee845, 0xa650c32a),
797 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "REM10", 0x2e3ee845, 0x76df1d29),
798 PCMCIA_PFC_DEVICE_PROD_ID13(1, "Xircom", "XEM5600", 0x2e3ee845, 0xf1403719),
799 PCMCIA_PFC_DEVICE_PROD_ID12(1, "AnyCom", "Fast Ethernet ", 0x578ba6e7, 0x02d92d1e),
800 PCMCIA_PFC_DEVICE_PROD_ID12(1, "D-Link", "DME336T", 0x1a424a1c, 0xb23897ff),
801 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
802 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Grey Cell", "GCS3000", 0x2a151fac, 0x48b932ae),
803 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Linksys", "EtherFast 10&100 + 56K PC Card (PCMLM56)", 0x0733cc81, 0xb3765033),
804 PCMCIA_PFC_DEVICE_PROD_ID12(1, "LINKSYS", "PCMLM336", 0xf7cb0b07, 0x7a821b58),
805 PCMCIA_PFC_DEVICE_PROD_ID12(1, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
806 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard", 0x0c2f80cd, 0x0573c29f),
807 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Ositech", "Trumpcard", 0x0c2f80cd, 0x0573c29f),
808 PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "ComboCard", 0xdcfe12d3, 0xcd8906cc),
809 PCMCIA_PFC_DEVICE_PROD_ID12(1, "PCMCIAs", "LanModem", 0xdcfe12d3, 0xc67c648f),
810 PCMCIA_PFC_DEVICE_PROD_ID12(1, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
811 PCMCIA_PFC_DEVICE_PROD_ID12(1, "Xircom", "CreditCard Ethernet", 0x2e3ee845, 0xc0e778c2),
812 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0104, 0x0070),
813 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0101, 0x0562),
814 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0104, 0x0070),
815 PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x016c, 0x0020),
816 PCMCIA_MFC_DEVICE_PROD_ID123(1, "APEX DATA", "MULTICARD", "ETHERNET-MODEM", 0x11c2da09, 0x7289dc5d, 0xaad95e1f),
817 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away 28.8 PC Card ", 0xb569a6e5, 0x5bd4ff2c),
818 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "Home and Away Credit Card Adapter", 0xb569a6e5, 0x4bdf15c3),
819 PCMCIA_MFC_DEVICE_PROD_ID12(1, "IBM", "w95 Home and Away Credit Card ", 0xb569a6e5, 0xae911c15),
820 PCMCIA_MFC_DEVICE_PROD_ID1(1, "Motorola MARQUIS", 0xf03e4e77),
821 PCMCIA_MFC_DEVICE_PROD_ID2(1, "FAX/Modem/Ethernet Combo Card ", 0x1ed59302),
822 PCMCIA_DEVICE_MANF_CARD(0x0089, 0x0301),
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_ID13("MEGAHERTZ", "V.34 PCMCIA MODEM", 0xf510db04, 0xbb2cce4a),
842 PCMCIA_DEVICE_PROD_ID12("Brain Boxes", "Bluetooth PC Card", 0xee138382, 0xd4ce9b02),
843 PCMCIA_DEVICE_PROD_ID12("CIRRUS LOGIC", "FAX MODEM", 0xe625f451, 0xcecd6dfa),
844 PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 28800 FAX/DATA MODEM", 0xa3a3062c, 0x8cbd7c76),
845 PCMCIA_DEVICE_PROD_ID12("COMPAQ", "PCMCIA 33600 FAX/DATA MODEM", 0xa3a3062c, 0x5a00ce95),
846 PCMCIA_DEVICE_PROD_ID12("Computerboards, Inc.", "PCM-COM422", 0xd0b78f51, 0x7e2d49ed),
847 PCMCIA_DEVICE_PROD_ID12("Dr. Neuhaus", "FURY CARD 14K4", 0x76942813, 0x8b96ce65),
848 PCMCIA_DEVICE_PROD_ID12("Intelligent", "ANGIA FAX/MODEM", 0xb496e65e, 0xf31602a6),
849 PCMCIA_DEVICE_PROD_ID12("Intel", "MODEM 2400", 0x816cc815, 0x23539b80),
850 PCMCIA_DEVICE_PROD_ID12("IOTech Inc ", "PCMCIA Dual RS-232 Serial Port Card", 0x3bd2d898, 0x92abc92f),
851 PCMCIA_DEVICE_PROD_ID12("MACRONIX", "FAX/MODEM", 0x668388b3, 0x3f9bdf2f),
852 PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT1432LT", 0x5f73be51, 0x0b3e2383),
853 PCMCIA_DEVICE_PROD_ID12("Multi-Tech", "MT2834LT", 0x5f73be51, 0x4cd7c09e),
854 PCMCIA_DEVICE_PROD_ID12("OEM ", "C288MX ", 0xb572d360, 0xd2385b7a),
855 PCMCIA_DEVICE_PROD_ID12("PCMCIA ", "C336MX ", 0x99bcafe9, 0xaa25bcab),
856 PCMCIA_DEVICE_PROD_ID12("Quatech Inc", "PCMCIA Dual RS-232 Serial Port Card", 0xc4420b35, 0x92abc92f),
857 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "EN2218-LAN/MODEM", 0x281f1c5d, 0x570f348e, "PCMLM28.cis"),
858 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "PCMCIA", "UE2218-LAN/MODEM", 0x281f1c5d, 0x6fdcacee, "PCMLM28.cis"),
859 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet", 0xf5f025c2, 0x338e8155, "PCMLM28.cis"),
860 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "Psion Dacom", "Gold Card V34 Ethernet GSM", 0xf5f025c2, 0x4ae85d35, "PCMLM28.cis"),
861 PCMCIA_PFC_DEVICE_CIS_PROD_ID12(1, "LINKSYS", "PCMLM28", 0xf7cb0b07, 0x66881874, "PCMLM28.cis"),
862 PCMCIA_MFC_DEVICE_CIS_PROD_ID12(1, "DAYNA COMMUNICATIONS", "LAN AND MODEM MULTIFUNCTION", 0x8fdf8f89, 0xdd5ed9e8, "DP83903.cis"),
863 PCMCIA_MFC_DEVICE_CIS_PROD_ID4(1, "NSC MF LAN/Modem", 0x58fc6056, "DP83903.cis"),
864 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0556, "3CCFEM556.cis"),
865 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0175, 0x0000, "DP83903.cis"),
866 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x0035, "3CXEM556.cis"),
867 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(1, 0x0101, 0x003d, "3CXEM556.cis"),
868 PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "MT5634ZLX.cis"),
869 PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
870 PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
871 PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "RS-COM-2P.cis"),
872 /* too generic */
873 /* PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0160, 0x0002), */
874 /* PCMCIA_MFC_DEVICE_MANF_CARD(1, 0x0160, 0x0002), */
875 PCMCIA_DEVICE_FUNC_ID(2),
876 PCMCIA_DEVICE_NULL,
878 MODULE_DEVICE_TABLE(pcmcia, serial_ids);
880 static struct pcmcia_driver serial_cs_driver = {
881 .owner = THIS_MODULE,
882 .drv = {
883 .name = "serial_cs",
885 .attach = serial_attach,
886 .detach = serial_detach,
887 .id_table = serial_ids,
890 static int __init init_serial_cs(void)
892 return pcmcia_register_driver(&serial_cs_driver);
895 static void __exit exit_serial_cs(void)
897 pcmcia_unregister_driver(&serial_cs_driver);
898 BUG_ON(dev_list != NULL);
901 module_init(init_serial_cs);
902 module_exit(exit_serial_cs);
904 MODULE_LICENSE("GPL");