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