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