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