v2.4.2.1 -> v2.4.2.2
[opensuse:kernel.git] / drivers / parport / parport_pc.c
1 /* Low-level parallel-port routines for 8255-based PC-style hardware.
2  * 
3  * Authors: Phil Blundell <Philip.Blundell@pobox.com>
4  *          Tim Waugh <tim@cyberelk.demon.co.uk>
5  *          Jose Renau <renau@acm.org>
6  *          David Campbell <campbell@torque.net>
7  *          Andrea Arcangeli
8  *
9  * based on work by Grant Guenther <grant@torque.net> and Phil Blundell.
10  *
11  * Cleaned up include files - Russell King <linux@arm.uk.linux.org>
12  * DMA support - Bert De Jonghe <bert@sophis.be>
13  * Many ECP bugs fixed.  Fred Barnes & Jamie Lokier, 1999
14  */
15
16 /* This driver should work with any hardware that is broadly compatible
17  * with that in the IBM PC.  This applies to the majority of integrated
18  * I/O chipsets that are commonly available.  The expected register
19  * layout is:
20  *
21  *      base+0          data
22  *      base+1          status
23  *      base+2          control
24  *
25  * In addition, there are some optional registers:
26  *
27  *      base+3          EPP address
28  *      base+4          EPP data
29  *      base+0x400      ECP config A
30  *      base+0x401      ECP config B
31  *      base+0x402      ECP control
32  *
33  * All registers are 8 bits wide and read/write.  If your hardware differs
34  * only in register addresses (eg because your registers are on 32-bit
35  * word boundaries) then you can alter the constants in parport_pc.h to
36  * accomodate this.
37  *
38  * Note that the ECP registers may not start at offset 0x400 for PCI cards,
39  * but rather will start at port->base_hi.
40  */
41
42 #include <linux/config.h>
43 #include <linux/module.h>
44 #include <linux/init.h>
45 #include <linux/sched.h>
46 #include <linux/delay.h>
47 #include <linux/errno.h>
48 #include <linux/interrupt.h>
49 #include <linux/ioport.h>
50 #include <linux/kernel.h>
51 #include <linux/slab.h>
52 #include <linux/pci.h>
53 #include <linux/sysctl.h>
54
55 #include <asm/io.h>
56 #include <asm/dma.h>
57 #include <asm/uaccess.h>
58
59 #include <linux/parport.h>
60 #include <linux/parport_pc.h>
61 #include <asm/parport.h>
62
63 #define PARPORT_PC_MAX_PORTS PARPORT_MAX
64
65 /* ECR modes */
66 #define ECR_SPP 00
67 #define ECR_PS2 01
68 #define ECR_PPF 02
69 #define ECR_ECP 03
70 #define ECR_EPP 04
71 #define ECR_VND 05
72 #define ECR_TST 06
73 #define ECR_CNF 07
74
75 #undef DEBUG
76
77 #ifdef DEBUG
78 #define DPRINTK  printk
79 #else
80 #define DPRINTK(stuff...)
81 #endif
82
83
84 #define NR_SUPERIOS 3
85 static struct superio_struct {  /* For Super-IO chips autodetection */
86         int io;
87         int irq;
88         int dma;
89 } superios[NR_SUPERIOS] __devinitdata = { {0,},};
90
91 static int user_specified __devinitdata = 0;
92 static int registered_parport;
93
94 /* frob_control, but for ECR */
95 static void frob_econtrol (struct parport *pb, unsigned char m,
96                            unsigned char v)
97 {
98         unsigned char ectr = inb (ECONTROL (pb));
99         DPRINTK (KERN_DEBUG "frob_econtrol(%02x,%02x): %02x -> %02x\n",
100                 m, v, ectr, (ectr & ~m) ^ v);
101
102         outb ((ectr & ~m) ^ v, ECONTROL (pb));
103 }
104
105 #ifdef CONFIG_PARPORT_PC_FIFO
106 /* Safely change the mode bits in the ECR 
107    Returns:
108             0    : Success
109            -EBUSY: Could not drain FIFO in some finite amount of time,
110                    mode not changed!
111  */
112 static int change_mode(struct parport *p, int m)
113 {
114         const struct parport_pc_private *priv = p->physport->private_data;
115         int ecr = ECONTROL(p);
116         unsigned char oecr;
117         int mode;
118
119         DPRINTK("parport change_mode ECP-ISA to mode 0x%02x\n",m);
120
121         if (!priv->ecr) {
122                 printk (KERN_DEBUG "change_mode: but there's no ECR!\n");
123                 return 0;
124         }
125
126         /* Bits <7:5> contain the mode. */
127         oecr = inb (ecr);
128         mode = (oecr >> 5) & 0x7;
129         if (mode == m) return 0;
130
131         if (mode >= 2 && !(priv->ctr & 0x20)) {
132                 /* This mode resets the FIFO, so we may
133                  * have to wait for it to drain first. */
134                 long expire = jiffies + p->physport->cad->timeout;
135                 int counter;
136                 switch (mode) {
137                 case ECR_PPF: /* Parallel Port FIFO mode */
138                 case ECR_ECP: /* ECP Parallel Port mode */
139                         /* Busy wait for 200us */
140                         for (counter = 0; counter < 40; counter++) {
141                                 if (inb (ECONTROL (p)) & 0x01)
142                                         break;
143                                 if (signal_pending (current)) break;
144                                 udelay (5);
145                         }
146
147                         /* Poll slowly. */
148                         while (!(inb (ECONTROL (p)) & 0x01)) {
149                                 if (time_after_eq (jiffies, expire))
150                                         /* The FIFO is stuck. */
151                                         return -EBUSY;
152                                 __set_current_state (TASK_INTERRUPTIBLE);
153                                 schedule_timeout ((HZ + 99) / 100);
154                                 if (signal_pending (current))
155                                         break;
156                         }
157                 }
158         }
159
160         if (mode >= 2 && m >= 2) {
161                 /* We have to go through mode 001 */
162                 oecr &= ~(7 << 5);
163                 oecr |= ECR_PS2 << 5;
164                 outb (oecr, ecr);
165         }
166
167         /* Set the mode. */
168         oecr &= ~(7 << 5);
169         oecr |= m << 5;
170         outb (oecr, ecr);
171         return 0;
172 }
173
174 #ifdef CONFIG_PARPORT_1284
175 /* Find FIFO lossage; FIFO is reset */
176 static int get_fifo_residue (struct parport *p)
177 {
178         int residue;
179         int cnfga;
180         const struct parport_pc_private *priv = p->physport->private_data;
181
182         /* Adjust for the contents of the FIFO. */
183         for (residue = priv->fifo_depth; ; residue--) {
184                 if (inb (ECONTROL (p)) & 0x2)
185                                 /* Full up. */
186                         break;
187
188                 outb (0, FIFO (p));
189         }
190
191         printk (KERN_DEBUG "%s: %d PWords were left in FIFO\n", p->name,
192                 residue);
193
194         /* Reset the FIFO. */
195         frob_econtrol (p, 0xe0, ECR_PS2 << 5);
196
197         /* Now change to config mode and clean up. FIXME */
198         frob_econtrol (p, 0xe0, ECR_CNF << 5);
199         cnfga = inb (CONFIGA (p));
200         printk (KERN_DEBUG "%s: cnfgA contains 0x%02x\n", p->name, cnfga);
201
202         if (!(cnfga & (1<<2))) {
203                 printk (KERN_DEBUG "%s: Accounting for extra byte\n", p->name);
204                 residue++;
205         }
206
207         /* Don't care about partial PWords until support is added for
208          * PWord != 1 byte. */
209
210         /* Back to PS2 mode. */
211         frob_econtrol (p, 0xe0, ECR_PS2 << 5);
212
213         return residue;
214 }
215 #endif /* IEEE 1284 support */
216 #endif /* FIFO support */
217
218 /*
219  * Clear TIMEOUT BIT in EPP MODE
220  *
221  * This is also used in SPP detection.
222  */
223 static int clear_epp_timeout(struct parport *pb)
224 {
225         unsigned char r;
226
227         if (!(parport_pc_read_status(pb) & 0x01))
228                 return 1;
229
230         /* To clear timeout some chips require double read */
231         parport_pc_read_status(pb);
232         r = parport_pc_read_status(pb);
233         outb (r | 0x01, STATUS (pb)); /* Some reset by writing 1 */
234         outb (r & 0xfe, STATUS (pb)); /* Others by writing 0 */
235         r = parport_pc_read_status(pb);
236
237         return !(r & 0x01);
238 }
239
240 /*
241  * Access functions.
242  *
243  * Most of these aren't static because they may be used by the
244  * parport_xxx_yyy macros.  extern __inline__ versions of several
245  * of these are in parport_pc.h.
246  */
247
248 static void parport_pc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
249 {
250         parport_generic_irq(irq, (struct parport *) dev_id, regs);
251 }
252
253 void parport_pc_write_data(struct parport *p, unsigned char d)
254 {
255         outb (d, DATA (p));
256 }
257
258 unsigned char parport_pc_read_data(struct parport *p)
259 {
260         return inb (DATA (p));
261 }
262
263 void parport_pc_write_control(struct parport *p, unsigned char d)
264 {
265         const unsigned char wm = (PARPORT_CONTROL_STROBE |
266                                   PARPORT_CONTROL_AUTOFD |
267                                   PARPORT_CONTROL_INIT |
268                                   PARPORT_CONTROL_SELECT);
269
270         /* Take this out when drivers have adapted to the newer interface. */
271         if (d & 0x20) {
272                 printk (KERN_DEBUG "%s (%s): use data_reverse for this!\n",
273                         p->name, p->cad->name);
274                 parport_pc_data_reverse (p);
275         }
276
277         __parport_pc_frob_control (p, wm, d & wm);
278 }
279
280 unsigned char parport_pc_read_control(struct parport *p)
281 {
282         const unsigned char wm = (PARPORT_CONTROL_STROBE |
283                                   PARPORT_CONTROL_AUTOFD |
284                                   PARPORT_CONTROL_INIT |
285                                   PARPORT_CONTROL_SELECT);
286         const struct parport_pc_private *priv = p->physport->private_data;
287         return priv->ctr & wm; /* Use soft copy */
288 }
289
290 unsigned char parport_pc_frob_control (struct parport *p, unsigned char mask,
291                                        unsigned char val)
292 {
293         const unsigned char wm = (PARPORT_CONTROL_STROBE |
294                                   PARPORT_CONTROL_AUTOFD |
295                                   PARPORT_CONTROL_INIT |
296                                   PARPORT_CONTROL_SELECT);
297
298         /* Take this out when drivers have adapted to the newer interface. */
299         if (mask & 0x20) {
300                 printk (KERN_DEBUG "%s (%s): use data_%s for this!\n",
301                         p->name, p->cad->name,
302                         (val & 0x20) ? "reverse" : "forward");
303                 if (val & 0x20)
304                         parport_pc_data_reverse (p);
305                 else
306                         parport_pc_data_forward (p);
307         }
308
309         /* Restrict mask and val to control lines. */
310         mask &= wm;
311         val &= wm;
312
313         return __parport_pc_frob_control (p, mask, val);
314 }
315
316 unsigned char parport_pc_read_status(struct parport *p)
317 {
318         return inb (STATUS (p));
319 }
320
321 void parport_pc_disable_irq(struct parport *p)
322 {
323         __parport_pc_frob_control (p, 0x10, 0);
324 }
325
326 void parport_pc_enable_irq(struct parport *p)
327 {
328         __parport_pc_frob_control (p, 0x10, 0x10);
329 }
330
331 void parport_pc_data_forward (struct parport *p)
332 {
333         __parport_pc_frob_control (p, 0x20, 0);
334 }
335
336 void parport_pc_data_reverse (struct parport *p)
337 {
338         __parport_pc_frob_control (p, 0x20, 0x20);
339 }
340
341 void parport_pc_init_state(struct pardevice *dev, struct parport_state *s)
342 {
343         s->u.pc.ctr = 0xc | (dev->irq_func ? 0x10 : 0x0);
344         s->u.pc.ecr = 0x24;
345 }
346
347 void parport_pc_save_state(struct parport *p, struct parport_state *s)
348 {
349         const struct parport_pc_private *priv = p->physport->private_data;
350         s->u.pc.ctr = inb (CONTROL (p));
351         if (priv->ecr)
352                 s->u.pc.ecr = inb (ECONTROL (p));
353 }
354
355 void parport_pc_restore_state(struct parport *p, struct parport_state *s)
356 {
357         const struct parport_pc_private *priv = p->physport->private_data;
358         outb (s->u.pc.ctr, CONTROL (p));
359         if (priv->ecr)
360                 outb (s->u.pc.ecr, ECONTROL (p));
361 }
362
363 #ifdef CONFIG_PARPORT_1284
364 static size_t parport_pc_epp_read_data (struct parport *port, void *buf,
365                                         size_t length, int flags)
366 {
367         size_t got = 0;
368         for (; got < length; got++) {
369                 *((char*)buf)++ = inb (EPPDATA(port));
370                 if (inb (STATUS(port)) & 0x01) {
371                         clear_epp_timeout (port);
372                         break;
373                 }
374         }
375
376         return got;
377 }
378
379 static size_t parport_pc_epp_write_data (struct parport *port, const void *buf,
380                                          size_t length, int flags)
381 {
382         size_t written = 0;
383         for (; written < length; written++) {
384                 outb (*((char*)buf)++, EPPDATA(port));
385                 if (inb (STATUS(port)) & 0x01) {
386                         clear_epp_timeout (port);
387                         break;
388                 }
389         }
390
391         return written;
392 }
393
394 static size_t parport_pc_epp_read_addr (struct parport *port, void *buf,
395                                         size_t length, int flags)
396 {
397         size_t got = 0;
398         for (; got < length; got++) {
399                 *((char*)buf)++ = inb (EPPADDR (port));
400                 if (inb (STATUS (port)) & 0x01) {
401                         clear_epp_timeout (port);
402                         break;
403                 }
404         }
405
406         return got;
407 }
408
409 static size_t parport_pc_epp_write_addr (struct parport *port,
410                                          const void *buf, size_t length,
411                                          int flags)
412 {
413         size_t written = 0;
414         for (; written < length; written++) {
415                 outb (*((char*)buf)++, EPPADDR (port));
416                 if (inb (STATUS (port)) & 0x01) {
417                         clear_epp_timeout (port);
418                         break;
419                 }
420         }
421
422         return written;
423 }
424
425 static size_t parport_pc_ecpepp_read_data (struct parport *port, void *buf,
426                                            size_t length, int flags)
427 {
428         size_t got;
429
430         frob_econtrol (port, 0xe0, ECR_EPP << 5);
431         parport_pc_data_reverse (port);
432         parport_pc_write_control (port, 0x4);
433         got = parport_pc_epp_read_data (port, buf, length, flags);
434         frob_econtrol (port, 0xe0, ECR_PS2 << 5);
435
436         return got;
437 }
438
439 static size_t parport_pc_ecpepp_write_data (struct parport *port,
440                                             const void *buf, size_t length,
441                                             int flags)
442 {
443         size_t written;
444
445         frob_econtrol (port, 0xe0, ECR_EPP << 5);
446         parport_pc_write_control (port, 0x4);
447         parport_pc_data_forward (port);
448         written = parport_pc_epp_write_data (port, buf, length, flags);
449         frob_econtrol (port, 0xe0, ECR_PS2 << 5);
450
451         return written;
452 }
453
454 static size_t parport_pc_ecpepp_read_addr (struct parport *port, void *buf,
455                                            size_t length, int flags)
456 {
457         size_t got;
458
459         frob_econtrol (port, 0xe0, ECR_EPP << 5);
460         parport_pc_data_reverse (port);
461         parport_pc_write_control (port, 0x4);
462         got = parport_pc_epp_read_addr (port, buf, length, flags);
463         frob_econtrol (port, 0xe0, ECR_PS2 << 5);
464
465         return got;
466 }
467
468 static size_t parport_pc_ecpepp_write_addr (struct parport *port,
469                                             const void *buf, size_t length,
470                                             int flags)
471 {
472         size_t written;
473
474         frob_econtrol (port, 0xe0, ECR_EPP << 5);
475         parport_pc_write_control (port, 0x4);
476         parport_pc_data_forward (port);
477         written = parport_pc_epp_write_addr (port, buf, length, flags);
478         frob_econtrol (port, 0xe0, ECR_PS2 << 5);
479
480         return written;
481 }
482 #endif /* IEEE 1284 support */
483
484 #ifdef CONFIG_PARPORT_PC_FIFO
485 static size_t parport_pc_fifo_write_block_pio (struct parport *port,
486                                                const void *buf, size_t length)
487 {
488         int ret = 0;
489         const unsigned char *bufp = buf;
490         size_t left = length;
491         long expire = jiffies + port->physport->cad->timeout;
492         const int fifo = FIFO (port);
493         int poll_for = 8; /* 80 usecs */
494         const struct parport_pc_private *priv = port->physport->private_data;
495         const int fifo_depth = priv->fifo_depth;
496
497         port = port->physport;
498
499         /* We don't want to be interrupted every character. */
500         parport_pc_disable_irq (port);
501         frob_econtrol (port, (1<<4), (1<<4)); /* nErrIntrEn */
502
503         /* Forward mode. */
504         parport_pc_data_forward (port); /* Must be in PS2 mode */
505
506         while (left) {
507                 unsigned char byte;
508                 unsigned char ecrval = inb (ECONTROL (port));
509                 int i = 0;
510
511                 if (current->need_resched && time_before (jiffies, expire))
512                         /* Can't yield the port. */
513                         schedule ();
514
515                 /* Anyone else waiting for the port? */
516                 if (port->waithead) {
517                         printk (KERN_DEBUG "Somebody wants the port\n");
518                         break;
519                 }
520
521                 if (ecrval & 0x02) {
522                         /* FIFO is full. Wait for interrupt. */
523
524                         /* Clear serviceIntr */
525                         outb (ecrval & ~(1<<2), ECONTROL (port));
526                 false_alarm:
527                         ret = parport_wait_event (port, HZ);
528                         if (ret < 0) break;
529                         ret = 0;
530                         if (!time_before (jiffies, expire)) {
531                                 /* Timed out. */
532                                 printk (KERN_DEBUG "FIFO write timed out\n");
533                                 break;
534                         }
535                         ecrval = inb (ECONTROL (port));
536                         if (!(ecrval & (1<<2))) {
537                                 if (current->need_resched &&
538                                     time_before (jiffies, expire))
539                                         schedule ();
540
541                                 goto false_alarm;
542                         }
543
544                         continue;
545                 }
546
547                 /* Can't fail now. */
548                 expire = jiffies + port->cad->timeout;
549
550         poll:
551                 if (signal_pending (current))
552                         break;
553
554                 if (ecrval & 0x01) {
555                         /* FIFO is empty. Blast it full. */
556                         const int n = left < fifo_depth ? left : fifo_depth;
557                         outsb (fifo, bufp, n);
558                         bufp += n;
559                         left -= n;
560
561                         /* Adjust the poll time. */
562                         if (i < (poll_for - 2)) poll_for--;
563                         continue;
564                 } else if (i++ < poll_for) {
565                         udelay (10);
566                         ecrval = inb (ECONTROL (port));
567                         goto poll;
568                 }
569
570                 /* Half-full (call me an optimist) */
571                 byte = *bufp++;
572                 outb (byte, fifo);
573                 left--;
574         }
575
576         return length - left;
577 }
578
579 static size_t parport_pc_fifo_write_block_dma (struct parport *port,
580                                                const void *buf, size_t length)
581 {
582         int ret = 0;
583         unsigned long dmaflag;
584         size_t left = length;
585         const struct parport_pc_private *priv = port->physport->private_data;
586         dma_addr_t dma_addr, dma_handle;
587         size_t maxlen = 0x10000; /* max 64k per DMA transfer */
588         unsigned long start = (unsigned long) buf;
589         unsigned long end = (unsigned long) buf + length - 1;
590
591         if (end < MAX_DMA_ADDRESS) {
592                 /* If it would cross a 64k boundary, cap it at the end. */
593                 if ((start ^ end) & ~0xffffUL)
594                         maxlen = 0x10000 - (start & 0xffff);
595
596                 dma_addr = dma_handle = pci_map_single(priv->dev, (void *)buf, length,
597                                                        PCI_DMA_TODEVICE);
598         } else {
599                 /* above 16 MB we use a bounce buffer as ISA-DMA is not possible */
600                 maxlen   = PAGE_SIZE;          /* sizeof(priv->dma_buf) */
601                 dma_addr = priv->dma_handle;
602                 dma_handle = 0;
603         }
604
605         port = port->physport;
606
607         /* We don't want to be interrupted every character. */
608         parport_pc_disable_irq (port);
609         frob_econtrol (port, (1<<4), (1<<4)); /* nErrIntrEn */
610
611         /* Forward mode. */
612         parport_pc_data_forward (port); /* Must be in PS2 mode */
613
614         while (left) {
615                 long expire = jiffies + port->physport->cad->timeout;
616
617                 size_t count = left;
618
619                 if (count > maxlen)
620                         count = maxlen;
621
622                 if (!dma_handle)   /* bounce buffer ! */
623                         memcpy(priv->dma_buf, buf, count);
624
625                 dmaflag = claim_dma_lock();
626                 disable_dma(port->dma);
627                 clear_dma_ff(port->dma);
628                 set_dma_mode(port->dma, DMA_MODE_WRITE);
629                 set_dma_addr(port->dma, dma_addr);
630                 set_dma_count(port->dma, count);
631
632                 /* Set DMA mode */
633                 frob_econtrol (port, 1<<3, 1<<3);
634
635                 /* Clear serviceIntr */
636                 frob_econtrol (port, 1<<2, 0);
637
638                 enable_dma(port->dma);
639                 release_dma_lock(dmaflag);
640
641                 /* assume DMA will be successful */
642                 left -= count;
643                 buf  += count;
644                 if (dma_handle) dma_addr += count;
645
646                 /* Wait for interrupt. */
647         false_alarm:
648                 ret = parport_wait_event (port, HZ);
649                 if (ret < 0) break;
650                 ret = 0;
651                 if (!time_before (jiffies, expire)) {
652                         /* Timed out. */
653                         printk (KERN_DEBUG "DMA write timed out\n");
654                         break;
655                 }
656                 /* Is serviceIntr set? */
657                 if (!(inb (ECONTROL (port)) & (1<<2))) {
658                         if (current->need_resched)
659                                 schedule ();
660
661                         goto false_alarm;
662                 }
663
664                 dmaflag = claim_dma_lock();
665                 disable_dma(port->dma);
666                 clear_dma_ff(port->dma);
667                 count = get_dma_residue(port->dma);
668                 release_dma_lock(dmaflag);
669
670                 if (current->need_resched)
671                         /* Can't yield the port. */
672                         schedule ();
673
674                 /* Anyone else waiting for the port? */
675                 if (port->waithead) {
676                         printk (KERN_DEBUG "Somebody wants the port\n");
677                         break;
678                 }
679
680                 /* update for possible DMA residue ! */
681                 buf  -= count;
682                 left += count;
683                 if (dma_handle) dma_addr -= count;
684         }
685
686         /* Maybe got here through break, so adjust for DMA residue! */
687         dmaflag = claim_dma_lock();
688         disable_dma(port->dma);
689         clear_dma_ff(port->dma);
690         left += get_dma_residue(port->dma);
691         release_dma_lock(dmaflag);
692
693         /* Turn off DMA mode */
694         frob_econtrol (port, 1<<3, 0);
695         
696         if (dma_handle)
697                 pci_unmap_single(priv->dev, dma_handle, length, PCI_DMA_TODEVICE);
698
699         return length - left;
700 }
701
702 /* Parallel Port FIFO mode (ECP chipsets) */
703 size_t parport_pc_compat_write_block_pio (struct parport *port,
704                                           const void *buf, size_t length,
705                                           int flags)
706 {
707         size_t written;
708         int r;
709
710         /* Special case: a timeout of zero means we cannot call schedule(). */
711         if (!port->physport->cad->timeout)
712                 return parport_ieee1284_write_compat (port, buf,
713                                                       length, flags);
714
715         /* Set up parallel port FIFO mode.*/
716         parport_pc_data_forward (port); /* Must be in PS2 mode */
717         parport_pc_frob_control (port, PARPORT_CONTROL_STROBE, 0);
718         r = change_mode (port, ECR_PPF); /* Parallel port FIFO */
719         if (r)  printk (KERN_DEBUG "%s: Warning change_mode ECR_PPF failed\n", port->name);
720
721         port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
722
723         /* Write the data to the FIFO. */
724         if (port->dma != PARPORT_DMA_NONE)
725                 written = parport_pc_fifo_write_block_dma (port, buf, length);
726         else
727                 written = parport_pc_fifo_write_block_pio (port, buf, length);
728
729         /* Finish up. */
730         if (change_mode (port, ECR_PS2) == -EBUSY) {
731                 const struct parport_pc_private *priv = 
732                         port->physport->private_data;
733
734                 printk (KERN_DEBUG "%s: FIFO is stuck\n", port->name);
735
736                 /* Prevent further data transfer. */
737                 frob_econtrol (port, 0xe0, ECR_TST << 5);
738
739                 /* Adjust for the contents of the FIFO. */
740                 for (written -= priv->fifo_depth; ; written++) {
741                         if (inb (ECONTROL (port)) & 0x2)
742                                 /* Full up. */
743                                 break;
744
745                         outb (0, FIFO (port));
746                 }
747
748                 /* Reset the FIFO and return to PS2 mode. */
749                 frob_econtrol (port, 0xe0, ECR_PS2 << 5);
750         }
751
752         r = parport_wait_peripheral (port,
753                                      PARPORT_STATUS_BUSY,
754                                      PARPORT_STATUS_BUSY);
755         if (r)
756                 printk (KERN_DEBUG
757                         "%s: BUSY timeout (%d) in compat_write_block_pio\n", 
758                         port->name, r);
759
760         port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
761
762         return written;
763 }
764
765 /* ECP */
766 #ifdef CONFIG_PARPORT_1284
767 size_t parport_pc_ecp_write_block_pio (struct parport *port,
768                                        const void *buf, size_t length,
769                                        int flags)
770 {
771         size_t written;
772         int r;
773
774         /* Special case: a timeout of zero means we cannot call schedule(). */
775         if (!port->physport->cad->timeout)
776                 return parport_ieee1284_ecp_write_data (port, buf,
777                                                         length, flags);
778
779         /* Switch to forward mode if necessary. */
780         if (port->physport->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
781                 /* Event 47: Set nInit high. */
782                 parport_frob_control (port,
783                                       PARPORT_CONTROL_INIT
784                                       | PARPORT_CONTROL_AUTOFD,
785                                       PARPORT_CONTROL_INIT
786                                       | PARPORT_CONTROL_AUTOFD);
787
788                 /* Event 49: PError goes high. */
789                 r = parport_wait_peripheral (port,
790                                              PARPORT_STATUS_PAPEROUT,
791                                              PARPORT_STATUS_PAPEROUT);
792                 if (r)
793                         printk (KERN_DEBUG "%s: PError timeout (%d) "
794                                 "in ecp_write_block_pio\n", port->name, r);
795         }
796
797         /* Set up ECP parallel port mode.*/
798         parport_pc_data_forward (port); /* Must be in PS2 mode */
799         parport_pc_frob_control (port,
800                                  PARPORT_CONTROL_STROBE |
801                                  PARPORT_CONTROL_AUTOFD,
802                                  0);
803         r = change_mode (port, ECR_ECP); /* ECP FIFO */
804         if (r) printk (KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n", port->name);
805         port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
806
807         /* Write the data to the FIFO. */
808         if (port->dma != PARPORT_DMA_NONE)
809                 written = parport_pc_fifo_write_block_dma (port, buf, length);
810         else
811                 written = parport_pc_fifo_write_block_pio (port, buf, length);
812
813         /* Finish up. */
814         if (change_mode (port, ECR_PS2) == -EBUSY) {
815                 const struct parport_pc_private *priv =
816                         port->physport->private_data;
817
818                 printk (KERN_DEBUG "%s: FIFO is stuck\n", port->name);
819
820                 /* Prevent further data transfer. */
821                 frob_econtrol (port, 0xe0, ECR_TST << 5);
822
823                 /* Adjust for the contents of the FIFO. */
824                 for (written -= priv->fifo_depth; ; written++) {
825                         if (inb (ECONTROL (port)) & 0x2)
826                                 /* Full up. */
827                                 break;
828
829                         outb (0, FIFO (port));
830                 }
831
832                 /* Reset the FIFO and return to PS2 mode. */
833                 frob_econtrol (port, 0xe0, ECR_PS2 << 5);
834
835                 /* Host transfer recovery. */
836                 parport_pc_data_reverse (port); /* Must be in PS2 mode */
837                 udelay (5);
838                 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
839                 r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, 0);
840                 if (r)
841                         printk (KERN_DEBUG "%s: PE,1 timeout (%d) "
842                                 "in ecp_write_block_pio\n", port->name, r);
843
844                 parport_frob_control (port,
845                                       PARPORT_CONTROL_INIT,
846                                       PARPORT_CONTROL_INIT);
847                 r = parport_wait_peripheral (port,
848                                              PARPORT_STATUS_PAPEROUT,
849                                              PARPORT_STATUS_PAPEROUT);
850                 if (r)
851                         printk (KERN_DEBUG "%s: PE,2 timeout (%d) "
852                                 "in ecp_write_block_pio\n", port->name, r);
853         }
854
855         r = parport_wait_peripheral (port,
856                                      PARPORT_STATUS_BUSY, 
857                                      PARPORT_STATUS_BUSY);
858         if(r)
859                 printk (KERN_DEBUG
860                         "%s: BUSY timeout (%d) in ecp_write_block_pio\n",
861                         port->name, r);
862
863         port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
864
865         return written;
866 }
867
868 size_t parport_pc_ecp_read_block_pio (struct parport *port,
869                                       void *buf, size_t length, int flags)
870 {
871         size_t left = length;
872         size_t fifofull;
873         int r;
874         const int fifo = FIFO(port);
875         const struct parport_pc_private *priv = port->physport->private_data;
876         const int fifo_depth = priv->fifo_depth;
877         char *bufp = buf;
878
879         port = port->physport;
880
881         /* Special case: a timeout of zero means we cannot call schedule(). */
882         if (!port->cad->timeout)
883                 return parport_ieee1284_ecp_read_data (port, buf,
884                                                        length, flags);
885
886         fifofull = fifo_depth;
887         if (port->ieee1284.mode == IEEE1284_MODE_ECPRLE)
888                 /* If the peripheral is allowed to send RLE compressed
889                  * data, it is possible for a byte to expand to 128
890                  * bytes in the FIFO. */
891                 fifofull = 128;
892
893         /* If the caller wants less than a full FIFO's worth of data,
894          * go through software emulation.  Otherwise we may have to through
895          * away data. */
896         if (length < fifofull)
897                 return parport_ieee1284_ecp_read_data (port, buf,
898                                                        length, flags);
899
900         /* Switch to reverse mode if necessary. */
901         if ((port->ieee1284.phase != IEEE1284_PH_REV_IDLE) &&
902             (port->ieee1284.phase != IEEE1284_PH_REV_DATA)) {
903                 /* Event 38: Set nAutoFd low */
904                 parport_frob_control (port,
905                                       PARPORT_CONTROL_AUTOFD,
906                                       PARPORT_CONTROL_AUTOFD);
907                 parport_pc_data_reverse (port); /* Must be in PS2 mode */
908                 udelay (5);
909
910                 /* Event 39: Set nInit low to initiate bus reversal */
911                 parport_frob_control (port,
912                                       PARPORT_CONTROL_INIT,
913                                       0);
914
915                 /* Event 40: PError goes low */
916                 r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, 0);
917                 if (r)
918                         printk (KERN_DEBUG "%s: PE timeout Event 40 (%d) "
919                                 "in ecp_read_block_pio\n", port->name, r);
920         }
921
922         /* Set up ECP FIFO mode.*/
923         parport_pc_data_reverse (port); /* Must be in PS2 mode */
924         parport_pc_frob_control (port,
925                                  PARPORT_CONTROL_STROBE |
926                                  PARPORT_CONTROL_AUTOFD,
927                                  0);
928         r = change_mode (port, ECR_ECP); /* ECP FIFO */
929         if (r) printk (KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n", port->name);
930         port->ieee1284.phase = IEEE1284_PH_REV_DATA;
931
932         /* Do the transfer. */
933         while (left > fifofull) {
934                 int ret;
935                 long int expire = jiffies + port->cad->timeout;
936                 unsigned char ecrval = inb (ECONTROL (port));
937
938                 if (current->need_resched && time_before (jiffies, expire))
939                         /* Can't yield the port. */
940                         schedule ();
941
942                 /* At this point, the FIFO may already be full.
943                  * Ideally, we'd be able to tell the port to hold on
944                  * for a second while we empty the FIFO, and we'd be
945                  * able to ensure that no data is lost.  I'm not sure
946                  * that's the case. :-(  It might be that you can play
947                  * games with STB, as in the forward case; someone should
948                  * look at a datasheet. */
949
950                 if (ecrval & 0x01) {
951                         /* FIFO is empty. Wait for interrupt. */
952
953                         /* Anyone else waiting for the port? */
954                         if (port->waithead) {
955                                 printk (KERN_DEBUG
956                                         "Somebody wants the port\n");
957                                 break;
958                         }
959
960                         /* Clear serviceIntr */
961                         outb (ecrval & ~(1<<2), ECONTROL (port));
962                 false_alarm:
963                         ret = parport_wait_event (port, HZ);
964                         if (ret < 0) break;
965                         ret = 0;
966                         if (!time_before (jiffies, expire)) {
967                                 /* Timed out. */
968                                 printk (KERN_DEBUG "PIO read timed out\n");
969                                 break;
970                         }
971                         ecrval = inb (ECONTROL (port));
972                         if (!(ecrval & (1<<2))) {
973                                 if (current->need_resched &&
974                                     time_before (jiffies, expire))
975                                         schedule ();
976
977                                 goto false_alarm;
978                         }
979
980                         continue;
981                 }
982
983                 if (ecrval & 0x02) {
984                         /* FIFO is full. */
985                         insb (fifo, bufp, fifo_depth);
986                         bufp += fifo_depth;
987                         left -= fifo_depth;
988                         continue;
989                 }
990
991                 *bufp++ = inb (fifo);
992                 left--;
993         }
994
995         port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
996
997         /* Go to forward idle mode to shut the peripheral up. */
998         parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
999         r = parport_wait_peripheral (port,
1000                                      PARPORT_STATUS_PAPEROUT,
1001                                      PARPORT_STATUS_PAPEROUT);
1002         if (r)
1003                 printk (KERN_DEBUG
1004                         "%s: PE timeout FWDIDLE (%d) in ecp_read_block_pio\n",
1005                         port->name, r);
1006
1007         port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
1008
1009         /* Finish up. */
1010         {
1011                 int lost = get_fifo_residue (port);
1012                 if (lost)
1013                         /* Shouldn't happen with compliant peripherals. */
1014                         printk (KERN_DEBUG "%s: DATA LOSS (%d bytes)!\n",
1015                                 port->name, lost);
1016         }
1017
1018         return length - left;
1019 }
1020
1021 #endif /* IEEE 1284 support */
1022
1023 #endif /* Allowed to use FIFO/DMA */
1024
1025 void parport_pc_inc_use_count(void)
1026 {
1027 #ifdef MODULE
1028         MOD_INC_USE_COUNT;
1029 #endif
1030 }
1031
1032 void parport_pc_dec_use_count(void)
1033 {
1034 #ifdef MODULE
1035         MOD_DEC_USE_COUNT;
1036 #endif
1037 }
1038
1039 struct parport_operations parport_pc_ops = 
1040 {
1041         parport_pc_write_data,
1042         parport_pc_read_data,
1043
1044         parport_pc_write_control,
1045         parport_pc_read_control,
1046         parport_pc_frob_control,
1047
1048         parport_pc_read_status,
1049
1050         parport_pc_enable_irq,
1051         parport_pc_disable_irq,
1052
1053         parport_pc_data_forward,
1054         parport_pc_data_reverse,
1055
1056         parport_pc_init_state,
1057         parport_pc_save_state,
1058         parport_pc_restore_state,
1059
1060         parport_pc_inc_use_count,
1061         parport_pc_dec_use_count,
1062
1063         parport_ieee1284_epp_write_data,
1064         parport_ieee1284_epp_read_data,
1065         parport_ieee1284_epp_write_addr,
1066         parport_ieee1284_epp_read_addr,
1067
1068         parport_ieee1284_ecp_write_data,
1069         parport_ieee1284_ecp_read_data,
1070         parport_ieee1284_ecp_write_addr,
1071
1072         parport_ieee1284_write_compat,
1073         parport_ieee1284_read_nibble,
1074         parport_ieee1284_read_byte,
1075 };
1076
1077 #ifdef CONFIG_PARPORT_PC_SUPERIO
1078 /* Super-IO chipset detection, Winbond, SMSC */
1079 static void __devinit show_parconfig_smsc37c669(int io, int key)
1080 {
1081         int cr1,cr4,cra,cr23,cr26,cr27,i=0;
1082         char *modes[]={ "SPP and Bidirectional (PS/2)", 
1083                         "EPP and SPP",
1084                         "ECP",
1085                         "ECP and EPP"};
1086
1087         outb(key,io);
1088         outb(key,io);
1089         outb(1,io);
1090         cr1=inb(io+1);
1091         outb(4,io);
1092         cr4=inb(io+1);
1093         outb(0x0a,io);
1094         cra=inb(io+1);
1095         outb(0x23,io);
1096         cr23=inb(io+1);
1097         outb(0x26,io);
1098         cr26=inb(io+1);
1099         outb(0x27,io);
1100         cr27=inb(io+1);
1101         outb(0xaa,io);
1102
1103         printk ("SMSC 37c669 LPT Config: cr_1=0x%02x, 4=0x%02x, "
1104                 "A=0x%2x, 23=0x%02x, 26=0x%02x, 27=0x%02x\n",
1105                 cr1,cr4,cra,cr23,cr26,cr27);
1106
1107         /* The documentation calls DMA and IRQ-Lines by letters, so
1108            the board maker can/will wire them
1109            appropriately/randomly...  G=reserved H=IDE-irq, */
1110         printk ("SMSC LPT Config: io=0x%04x, irq=%c, dma=%c, "
1111                 "fifo threshold=%d\n", cr23*4,
1112                 (cr27 &0x0f) ? 'A'-1+(cr27 &0x0f): '-',
1113                 (cr26 &0x0f) ? 'A'-1+(cr26 &0x0f): '-', cra & 0x0f);
1114         printk("SMSC LPT Config: enabled=%s power=%s\n",
1115                (cr23*4 >=0x100) ?"yes":"no", (cr1 & 4) ? "yes" : "no");
1116         printk("SMSC LPT Config: Port mode=%s, EPP version =%s\n",
1117                (cr1 & 0x08 ) ? "Standard mode only (SPP)" : modes[cr4 & 0x03], 
1118                (cr4 & 0x40) ? "1.7" : "1.9");
1119
1120         /* Heuristics !  BIOS setup for this mainboard device limits
1121            the choices to standard settings, i.e. io-address and IRQ
1122            are related, however DMA can be 1 or 3, assume DMA_A=DMA1,
1123            DMA_C=DMA3 (this is true e.g. for TYAN 1564D Tomcat IV) */
1124         if(cr23*4 >=0x100) { /* if active */
1125                 while((superios[i].io!= 0) && (i<NR_SUPERIOS))
1126                         i++;
1127                 if(i==NR_SUPERIOS)
1128                         printk("Super-IO: too many chips!\n");
1129                 else {
1130                         int d;
1131                         switch (cr23*4) {
1132                                 case 0x3bc:
1133                                         superios[i].io = 0x3bc;
1134                                         superios[i].irq = 7;
1135                                         break;
1136                                 case 0x378:
1137                                         superios[i].io = 0x378;
1138                                         superios[i].irq = 7;
1139                                         break;
1140                                 case 0x278:
1141                                         superios[i].io = 0x278;
1142                                         superios[i].irq = 5;
1143                         }
1144                         d=(cr26 &0x0f);
1145                         if((d==1) || (d==3)) 
1146                                 superios[i].dma= d;
1147                         else
1148                                 superios[i].dma= PARPORT_DMA_NONE;
1149                 }
1150         }
1151 }
1152
1153
1154 static void __devinit show_parconfig_winbond(int io, int key)
1155 {
1156         int cr30,cr60,cr61,cr70,cr74,crf0,i=0;
1157         char *modes[]={ "Standard (SPP) and Bidirectional(PS/2)", /* 0 */
1158                         "EPP-1.9 and SPP",
1159                         "ECP",
1160                         "ECP and EPP-1.9",
1161                         "Standard (SPP)",
1162                         "EPP-1.7 and SPP",              /* 5 */
1163                         "undefined!",
1164                         "ECP and EPP-1.7"};
1165         char *irqtypes[]={"pulsed low, high-Z", "follows nACK"};
1166                 
1167         /* The registers are called compatible-PnP because the
1168            register layout is modelled after ISA-PnP, the access
1169            method is just another ... */
1170         outb(key,io);
1171         outb(key,io);
1172         outb(0x07,io);   /* Register 7: Select Logical Device */
1173         outb(0x01,io+1); /* LD1 is Parallel Port */
1174         outb(0x30,io);
1175         cr30=inb(io+1);
1176         outb(0x60,io);
1177         cr60=inb(io+1);
1178         outb(0x61,io);
1179         cr61=inb(io+1);
1180         outb(0x70,io);
1181         cr70=inb(io+1);
1182         outb(0x74,io);
1183         cr74=inb(io+1);
1184         outb(0xf0,io);
1185         crf0=inb(io+1);
1186         outb(0xaa,io);
1187
1188         printk("Winbond LPT Config: cr_30=%02x 60,61=%02x%02x "
1189                "70=%02x 74=%02x, f0=%02x\n", cr30,cr60,cr61,cr70,cr74,crf0);
1190         printk("Winbond LPT Config: active=%s, io=0x%02x%02x irq=%d, ", 
1191                (cr30 & 0x01) ? "yes":"no", cr60,cr61,cr70&0x0f );
1192         if ((cr74 & 0x07) > 3)
1193                 printk("dma=none\n");
1194         else
1195                 printk("dma=%d\n",cr74 & 0x07);
1196         printk("Winbond LPT Config: irqtype=%s, ECP fifo threshold=%d\n",
1197                irqtypes[crf0>>7], (crf0>>3)&0x0f);
1198         printk("Winbond LPT Config: Port mode=%s\n", modes[crf0 & 0x07]);
1199
1200         if(cr30 & 0x01) { /* the settings can be interrogated later ... */
1201                 while((superios[i].io!= 0) && (i<NR_SUPERIOS))
1202                         i++;
1203                 if(i==NR_SUPERIOS) 
1204                         printk("Super-IO: too many chips!\n");
1205                 else {
1206                         superios[i].io = (cr60<<8)|cr61;
1207                         superios[i].irq = cr70&0x0f;
1208                         superios[i].dma = (((cr74 & 0x07) > 3) ?
1209                                            PARPORT_DMA_NONE : (cr74 & 0x07));
1210                 }
1211         }
1212 }
1213
1214 static void __devinit decode_winbond(int efer, int key, int devid, int devrev, int oldid)
1215 {
1216         char *type=NULL;
1217         int id,progif=2;
1218
1219         if (devid == devrev)
1220                 /* simple heuristics, we happened to read some
1221                    non-winbond register */
1222                 return;
1223
1224         printk("Winbond chip at EFER=0x%x key=0x%02x devid=%02x devrev=%02x "
1225                "oldid=%02x\n", efer,key,devid,devrev,oldid);
1226         id=(devid<<8) | devrev;
1227
1228         /* Values are from public data sheets pdf files, I can just
1229            confirm 83977TF is correct :-) */
1230         if      (id == 0x9771) type="83977F/AF";
1231         else if (id == 0x9773) type="83977TF / SMSC 97w33x/97w34x";
1232         else if (id == 0x9774) type="83977ATF";
1233         else if ((id & ~0x0f) == 0x5270) type="83977CTF / SMSC 97w36x";
1234         else if ((id & ~0x0f) == 0x52f0) type="83977EF / SMSC 97w35x";
1235         else if ((id & ~0x0f) == 0x5210) type="83627";
1236         else if ((id & ~0x0f) == 0x6010) type="83697HF";
1237         else if ((oldid &0x0f ) == 0x0a) { type="83877F"; progif=1;}
1238         else if ((oldid &0x0f ) == 0x0b) { type="83877AF"; progif=1;}
1239         else if ((oldid &0x0f ) == 0x0c) { type="83877TF"; progif=1;}
1240         else if ((oldid &0x0f ) == 0x0d) { type="83877ATF"; progif=1;}
1241         else progif=0;
1242
1243         if(type==NULL) 
1244                 printk("Winbond unknown chip type\n");
1245         else    
1246                 printk("Winbond chip type %s\n",type);
1247
1248         if(progif==2)
1249                 show_parconfig_winbond(efer,key);
1250         return;
1251 }
1252
1253 static void __devinit decode_smsc(int efer, int key, int devid, int devrev)
1254 {
1255         char *type=NULL;
1256         void (*func)(int io, int key);
1257         int id;
1258
1259         if (devid == devrev)
1260                 /* simple heuristics, we happened to read some
1261                    non-smsc register */
1262                 return;
1263
1264         func=NULL;
1265         printk("SMSC chip at EFER=0x%x key=0x%02x devid=%02x devrev=%02x\n",
1266                efer,key,devid,devrev);
1267         id=(devid<<8) | devrev;
1268
1269         if      (id==0x0302) {type="37c669"; func=show_parconfig_smsc37c669;}
1270         else if (id==0x6582) type="37c665IR";
1271         else if (devid==0x65) type="37c665GT";
1272         else if (devid==0x66) type="37c666GT";
1273
1274         if(type==NULL)
1275                 printk("SMSC unknown chip type\n");
1276         else
1277                 printk("SMSC chip type %s\n",type);
1278
1279         if(func) (func)(efer,key);
1280         return;
1281 }
1282
1283
1284 static void __devinit winbond_check(int io, int key)
1285 {
1286         int devid,devrev,oldid,x_devid,x_devrev,x_oldid;
1287
1288         /* First probe without key */
1289         outb(0x20,io);
1290         x_devid=inb(io+1);
1291         outb(0x21,io);
1292         x_devrev=inb(io+1);
1293         outb(0x09,io);
1294         x_oldid=inb(io+1);
1295
1296         outb(key,io);
1297         outb(key,io);     /* Write Magic Sequence to EFER, extended
1298                              funtion enable register */
1299         outb(0x20,io);    /* Write EFIR, extended function index register */
1300         devid=inb(io+1);  /* Read EFDR, extended function data register */
1301         outb(0x21,io);
1302         devrev=inb(io+1);
1303         outb(0x09,io);
1304         oldid=inb(io+1);
1305         outb(0xaa,io);    /* Magic Seal */
1306
1307         if ((x_devid == devid) && (x_devrev == devrev) && (x_oldid == oldid))
1308                 return; /* protection against false positives */
1309
1310         decode_winbond(io,key,devid,devrev,oldid);
1311 }
1312
1313 static void __devinit winbond_check2(int io,int key)
1314 {
1315         int devid,devrev,oldid,x_devid,x_devrev,x_oldid;
1316
1317         /* First probe without the key */
1318         outb(0x20,io+2);
1319         x_devid=inb(io+2);
1320         outb(0x21,io+1);
1321         x_devrev=inb(io+2);
1322         outb(0x09,io+1);
1323         x_oldid=inb(io+2);
1324
1325         outb(key,io);     /* Write Magic Byte to EFER, extended
1326                              funtion enable register */
1327         outb(0x20,io+2);  /* Write EFIR, extended function index register */
1328         devid=inb(io+2);  /* Read EFDR, extended function data register */
1329         outb(0x21,io+1);
1330         devrev=inb(io+2);
1331         outb(0x09,io+1);
1332         oldid=inb(io+2);
1333         outb(0xaa,io);    /* Magic Seal */
1334
1335         if ((x_devid == devid) && (x_devrev == devrev) && (x_oldid == oldid))
1336                 return; /* protection against false positives */
1337
1338         decode_winbond(io,key,devid,devrev,oldid);
1339 }
1340
1341 static void __devinit smsc_check(int io, int key)
1342 {
1343         int id,rev,oldid,oldrev,x_id,x_rev,x_oldid,x_oldrev;
1344
1345         /* First probe without the key */
1346         outb(0x0d,io);
1347         x_oldid=inb(io+1);
1348         outb(0x0e,io);
1349         x_oldrev=inb(io+1);
1350         outb(0x20,io);
1351         x_id=inb(io+1);
1352         outb(0x21,io);
1353         x_rev=inb(io+1);
1354
1355         outb(key,io);
1356         outb(key,io);     /* Write Magic Sequence to EFER, extended
1357                              funtion enable register */
1358         outb(0x0d,io);    /* Write EFIR, extended function index register */
1359         oldid=inb(io+1);  /* Read EFDR, extended function data register */
1360         outb(0x0e,io);
1361         oldrev=inb(io+1);
1362         outb(0x20,io);
1363         id=inb(io+1);
1364         outb(0x21,io);
1365         rev=inb(io+1);
1366         outb(0xaa,io);    /* Magic Seal */
1367
1368         if ((x_id == id) && (x_oldrev == oldrev) &&
1369             (x_oldid == oldid) && (x_rev == rev))
1370                 return; /* protection against false positives */
1371
1372         decode_smsc(io,key,oldid,oldrev);
1373 }
1374
1375
1376 static void __devinit detect_and_report_winbond (void)
1377
1378         printk("Winbond Super-IO detection, now testing ports 3F0,370,250,4E,2E ...\n");
1379
1380         winbond_check(0x3f0,0x87);
1381         winbond_check(0x370,0x87);
1382         winbond_check(0x2e ,0x87);
1383         winbond_check(0x4e ,0x87);
1384         winbond_check(0x3f0,0x86);
1385         winbond_check2(0x250,0x88); 
1386         winbond_check2(0x250,0x89);
1387 }
1388
1389 static void __devinit detect_and_report_smsc (void)
1390 {
1391         printk("SMSC Super-IO detection, now testing Ports 2F0, 370 ...\n");
1392         smsc_check(0x3f0,0x55);
1393         smsc_check(0x370,0x55);
1394         smsc_check(0x3f0,0x44);
1395         smsc_check(0x370,0x44);
1396 }
1397 #endif /* CONFIG_PARPORT_PC_SUPERIO */
1398
1399 static int __devinit get_superio_dma (struct parport *p)
1400 {
1401         int i=0;
1402         while( (superios[i].io != p->base) && (i<NR_SUPERIOS))
1403                 i++;
1404         if (i!=NR_SUPERIOS)
1405                 return superios[i].dma;
1406         return PARPORT_DMA_NONE;
1407 }
1408
1409 static int __devinit get_superio_irq (struct parport *p)
1410 {
1411         int i=0;
1412         while( (superios[i].io != p->base) && (i<NR_SUPERIOS))
1413                 i++;
1414         if (i!=NR_SUPERIOS)
1415                 return superios[i].irq;
1416         return PARPORT_IRQ_NONE;
1417 }
1418         
1419
1420 /* --- Mode detection ------------------------------------- */
1421
1422 /*
1423  * Checks for port existence, all ports support SPP MODE
1424  * Returns: 
1425  *         0           :  No parallel port at this adress
1426  *  PARPORT_MODE_PCSPP :  SPP port detected 
1427  *                        (if the user specified an ioport himself,
1428  *                         this shall always be the case!)
1429  *
1430  */
1431 static int __devinit parport_SPP_supported(struct parport *pb)
1432 {
1433         unsigned char r, w;
1434
1435         /*
1436          * first clear an eventually pending EPP timeout 
1437          * I (sailer@ife.ee.ethz.ch) have an SMSC chipset
1438          * that does not even respond to SPP cycles if an EPP
1439          * timeout is pending
1440          */
1441         clear_epp_timeout(pb);
1442
1443         /* Do a simple read-write test to make sure the port exists. */
1444         w = 0xc;
1445         outb (w, CONTROL (pb));
1446
1447         /* Is there a control register that we can read from?  Some
1448          * ports don't allow reads, so read_control just returns a
1449          * software copy. Some ports _do_ allow reads, so bypass the
1450          * software copy here.  In addition, some bits aren't
1451          * writable. */
1452         r = inb (CONTROL (pb));
1453         if ((r & 0xf) == w) {
1454                 w = 0xe;
1455                 outb (w, CONTROL (pb));
1456                 r = inb (CONTROL (pb));
1457                 outb (0xc, CONTROL (pb));
1458                 if ((r & 0xf) == w)
1459                         return PARPORT_MODE_PCSPP;
1460         }
1461
1462         if (user_specified)
1463                 /* That didn't work, but the user thinks there's a
1464                  * port here. */
1465                 printk (KERN_DEBUG "parport 0x%lx (WARNING): CTR: "
1466                         "wrote 0x%02x, read 0x%02x\n", pb->base, w, r);
1467
1468         /* Try the data register.  The data lines aren't tri-stated at
1469          * this stage, so we expect back what we wrote. */
1470         w = 0xaa;
1471         parport_pc_write_data (pb, w);
1472         r = parport_pc_read_data (pb);
1473         if (r == w) {
1474                 w = 0x55;
1475                 parport_pc_write_data (pb, w);
1476                 r = parport_pc_read_data (pb);
1477                 if (r == w)
1478                         return PARPORT_MODE_PCSPP;
1479         }
1480
1481         if (user_specified) {
1482                 /* Didn't work, but the user is convinced this is the
1483                  * place. */
1484                 printk (KERN_DEBUG "parport 0x%lx (WARNING): DATA: "
1485                         "wrote 0x%02x, read 0x%02x\n", pb->base, w, r);
1486                 printk (KERN_DEBUG "parport 0x%lx: You gave this address, "
1487                         "but there is probably no parallel port there!\n",
1488                         pb->base);
1489         }
1490
1491         /* It's possible that we can't read the control register or
1492          * the data register.  In that case just believe the user. */
1493         if (user_specified)
1494                 return PARPORT_MODE_PCSPP;
1495
1496         return 0;
1497 }
1498
1499 /* Check for ECR
1500  *
1501  * Old style XT ports alias io ports every 0x400, hence accessing ECR
1502  * on these cards actually accesses the CTR.
1503  *
1504  * Modern cards don't do this but reading from ECR will return 0xff
1505  * regardless of what is written here if the card does NOT support
1506  * ECP.
1507  *
1508  * We first check to see if ECR is the same as CTR.  If not, the low
1509  * two bits of ECR aren't writable, so we check by writing ECR and
1510  * reading it back to see if it's what we expect.
1511  */
1512 static int __devinit parport_ECR_present(struct parport *pb)
1513 {
1514         struct parport_pc_private *priv = pb->private_data;
1515         unsigned char r = 0xc;
1516
1517         outb (r, CONTROL (pb));
1518         if ((inb (ECONTROL (pb)) & 0x3) == (r & 0x3)) {
1519                 outb (r ^ 0x2, CONTROL (pb)); /* Toggle bit 1 */
1520
1521                 r = inb (CONTROL (pb));
1522                 if ((inb (ECONTROL (pb)) & 0x2) == (r & 0x2))
1523                         goto no_reg; /* Sure that no ECR register exists */
1524         }
1525         
1526         if ((inb (ECONTROL (pb)) & 0x3 ) != 0x1)
1527                 goto no_reg;
1528
1529         outb (0x34, ECONTROL (pb));
1530         if (inb (ECONTROL (pb)) != 0x35)
1531                 goto no_reg;
1532
1533         priv->ecr = 1;
1534         outb (0xc, CONTROL (pb));
1535         
1536         /* Go to mode 000 */
1537         frob_econtrol (pb, 0xe0, ECR_SPP << 5);
1538
1539         return 1;
1540
1541  no_reg:
1542         outb (0xc, CONTROL (pb));
1543         return 0; 
1544 }
1545
1546 #ifdef CONFIG_PARPORT_1284
1547 /* Detect PS/2 support.
1548  *
1549  * Bit 5 (0x20) sets the PS/2 data direction; setting this high
1550  * allows us to read data from the data lines.  In theory we would get back
1551  * 0xff but any peripheral attached to the port may drag some or all of the
1552  * lines down to zero.  So if we get back anything that isn't the contents
1553  * of the data register we deem PS/2 support to be present. 
1554  *
1555  * Some SPP ports have "half PS/2" ability - you can't turn off the line
1556  * drivers, but an external peripheral with sufficiently beefy drivers of
1557  * its own can overpower them and assert its own levels onto the bus, from
1558  * where they can then be read back as normal.  Ports with this property
1559  * and the right type of device attached are likely to fail the SPP test,
1560  * (as they will appear to have stuck bits) and so the fact that they might
1561  * be misdetected here is rather academic. 
1562  */
1563
1564 static int __devinit parport_PS2_supported(struct parport *pb)
1565 {
1566         int ok = 0;
1567   
1568         clear_epp_timeout(pb);
1569
1570         /* try to tri-state the buffer */
1571         parport_pc_data_reverse (pb);
1572         
1573         parport_pc_write_data(pb, 0x55);
1574         if (parport_pc_read_data(pb) != 0x55) ok++;
1575
1576         parport_pc_write_data(pb, 0xaa);
1577         if (parport_pc_read_data(pb) != 0xaa) ok++;
1578
1579         /* cancel input mode */
1580         parport_pc_data_forward (pb);
1581
1582         if (ok) {
1583                 pb->modes |= PARPORT_MODE_TRISTATE;
1584         } else {
1585                 struct parport_pc_private *priv = pb->private_data;
1586                 priv->ctr_writable &= ~0x20;
1587         }
1588
1589         return ok;
1590 }
1591
1592 static int __devinit parport_ECP_supported(struct parport *pb)
1593 {
1594         int i;
1595         int config, configb;
1596         int pword;
1597         struct parport_pc_private *priv = pb->private_data;
1598         int intrline[]={0,7,9,10,11,14,15,5}; /* Translate ECP
1599                                                  intrLine to ISA irq
1600                                                  value */
1601
1602         /* If there is no ECR, we have no hope of supporting ECP. */
1603         if (!priv->ecr)
1604                 return 0;
1605
1606         /* Find out FIFO depth */
1607         outb (ECR_SPP << 5, ECONTROL (pb)); /* Reset FIFO */
1608         outb (ECR_TST << 5, ECONTROL (pb)); /* TEST FIFO */
1609         for (i=0; i < 1024 && !(inb (ECONTROL (pb)) & 0x02); i++)
1610                 outb (0xaa, FIFO (pb));
1611
1612         /*
1613          * Using LGS chipset it uses ECR register, but
1614          * it doesn't support ECP or FIFO MODE
1615          */
1616         if (i == 1024) {
1617                 outb (ECR_SPP << 5, ECONTROL (pb));
1618                 return 0;
1619         }
1620
1621         priv->fifo_depth = i;
1622         printk (KERN_INFO "0x%lx: FIFO is %d bytes\n", pb->base, i);
1623
1624         /* Find out writeIntrThreshold */
1625         frob_econtrol (pb, 1<<2, 1<<2);
1626         frob_econtrol (pb, 1<<2, 0);
1627         for (i = 1; i <= priv->fifo_depth; i++) {
1628                 inb (FIFO (pb));
1629                 udelay (50);
1630                 if (inb (ECONTROL (pb)) & (1<<2))
1631                         break;
1632         }
1633
1634         if (i <= priv->fifo_depth)
1635                 printk (KERN_INFO "0x%lx: writeIntrThreshold is %d\n",
1636                         pb->base, i);
1637         else
1638                 /* Number of bytes we know we can write if we get an
1639                    interrupt. */
1640                 i = 0;
1641
1642         priv->writeIntrThreshold = i;
1643
1644         /* Find out readIntrThreshold */
1645         frob_econtrol (pb, 0xe0, ECR_PS2 << 5); /* Reset FIFO and enable PS2 */
1646         parport_pc_data_reverse (pb); /* Must be in PS2 mode */
1647         frob_econtrol (pb, 0xe0, ECR_TST << 5); /* Test FIFO */
1648         frob_econtrol (pb, 1<<2, 1<<2);
1649         frob_econtrol (pb, 1<<2, 0);
1650         for (i = 1; i <= priv->fifo_depth; i++) {
1651                 outb (0xaa, FIFO (pb));
1652                 if (inb (ECONTROL (pb)) & (1<<2))
1653                         break;
1654         }
1655
1656         if (i <= priv->fifo_depth)
1657                 printk (KERN_INFO "0x%lx: readIntrThreshold is %d\n",
1658                         pb->base, i);
1659         else
1660                 /* Number of bytes we can read if we get an interrupt. */
1661                 i = 0;
1662
1663         priv->readIntrThreshold = i;
1664
1665         outb (ECR_SPP << 5, ECONTROL (pb)); /* Reset FIFO */
1666         outb (0xf4, ECONTROL (pb)); /* Configuration mode */
1667         config = inb (CONFIGA (pb));
1668         pword = (config >> 4) & 0x7;
1669         switch (pword) {
1670         case 0:
1671                 pword = 2;
1672                 printk (KERN_WARNING "0x%lx: Unsupported pword size!\n",
1673                         pb->base);
1674                 break;
1675         case 2:
1676                 pword = 4;
1677                 printk (KERN_WARNING "0x%lx: Unsupported pword size!\n",
1678                         pb->base);
1679                 break;
1680         default:
1681                 printk (KERN_WARNING "0x%lx: Unknown implementation ID\n",
1682                         pb->base);
1683                 /* Assume 1 */
1684         case 1:
1685                 pword = 1;
1686         }
1687         priv->pword = pword;
1688         printk (KERN_DEBUG "0x%lx: PWord is %d bits\n", pb->base, 8 * pword);
1689
1690         printk (KERN_DEBUG "0x%lx: Interrupts are ISA-%s\n", pb->base,
1691                 config & 0x80 ? "Level" : "Pulses");
1692
1693         configb = inb (CONFIGB (pb));
1694         if (!(configb & 0x40)) {
1695                 printk (KERN_WARNING "0x%lx: possible IRQ conflict!\n",
1696                         pb->base);
1697                 pb->irq = PARPORT_IRQ_NONE;
1698         }
1699         printk (KERN_DEBUG "0x%lx: ECP port cfgA=0x%02x cfgB=0x%02x\n",
1700                 pb->base, config, configb);
1701         printk (KERN_DEBUG "0x%lx: ECP settings irq=", pb->base);
1702         if ((configb >>3) & 0x07)
1703                 printk("%d",intrline[(configb >>3) & 0x07]);
1704         else
1705                 printk("<none or set by other means>");
1706         printk ( " dma=");
1707         if( (configb & 0x03 ) == 0x00)
1708                 printk("<none or set by other means>\n");
1709         else
1710                 printk("%d\n",configb & 0x07);
1711
1712         /* Go back to mode 000 */
1713         frob_econtrol (pb, 0xe0, ECR_SPP << 5);
1714         pb->modes |= PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
1715
1716         return 1;
1717 }
1718
1719 static int __devinit parport_ECPPS2_supported(struct parport *pb)
1720 {
1721         const struct parport_pc_private *priv = pb->private_data;
1722         int result;
1723         unsigned char oecr;
1724
1725         if (!priv->ecr)
1726                 return 0;
1727
1728         oecr = inb (ECONTROL (pb));
1729         outb (ECR_PS2 << 5, ECONTROL (pb));
1730         
1731         result = parport_PS2_supported(pb);
1732
1733         outb (oecr, ECONTROL (pb));
1734         return result;
1735 }
1736
1737 /* EPP mode detection  */
1738
1739 static int __devinit parport_EPP_supported(struct parport *pb)
1740 {
1741         const struct parport_pc_private *priv = pb->private_data;
1742
1743         /*
1744          * Theory:
1745          *      Bit 0 of STR is the EPP timeout bit, this bit is 0
1746          *      when EPP is possible and is set high when an EPP timeout
1747          *      occurs (EPP uses the HALT line to stop the CPU while it does
1748          *      the byte transfer, an EPP timeout occurs if the attached
1749          *      device fails to respond after 10 micro seconds).
1750          *
1751          *      This bit is cleared by either reading it (National Semi)
1752          *      or writing a 1 to the bit (SMC, UMC, WinBond), others ???
1753          *      This bit is always high in non EPP modes.
1754          */
1755
1756         /* If EPP timeout bit clear then EPP available */
1757         if (!clear_epp_timeout(pb))
1758                 return 0;  /* No way to clear timeout */
1759
1760         /* Check for Intel bug. */
1761         if (priv->ecr) {
1762                 unsigned char i;
1763                 for (i = 0x00; i < 0x80; i += 0x20) {
1764                         outb (i, ECONTROL (pb));
1765                         if (clear_epp_timeout (pb))
1766                                 /* Phony EPP in ECP. */
1767                                 return 0;
1768                 }
1769         }
1770
1771         pb->modes |= PARPORT_MODE_EPP;
1772
1773         /* Set up access functions to use EPP hardware. */
1774         pb->ops->epp_read_data = parport_pc_epp_read_data;
1775         pb->ops->epp_write_data = parport_pc_epp_write_data;
1776         pb->ops->epp_read_addr = parport_pc_epp_read_addr;
1777         pb->ops->epp_write_addr = parport_pc_epp_write_addr;
1778
1779         return 1;
1780 }
1781
1782 static int __devinit parport_ECPEPP_supported(struct parport *pb)
1783 {
1784         struct parport_pc_private *priv = pb->private_data;
1785         int result;
1786         unsigned char oecr;
1787
1788         if (!priv->ecr)
1789                 return 0;
1790
1791         oecr = inb (ECONTROL (pb));
1792         /* Search for SMC style EPP+ECP mode */
1793         outb (0x80, ECONTROL (pb));
1794         outb (0x04, CONTROL (pb));
1795         result = parport_EPP_supported(pb);
1796
1797         outb (oecr, ECONTROL (pb));
1798
1799         if (result) {
1800                 /* Set up access functions to use ECP+EPP hardware. */
1801                 pb->ops->epp_read_data = parport_pc_ecpepp_read_data;
1802                 pb->ops->epp_write_data = parport_pc_ecpepp_write_data;
1803                 pb->ops->epp_read_addr = parport_pc_ecpepp_read_addr;
1804                 pb->ops->epp_write_addr = parport_pc_ecpepp_write_addr;
1805         }
1806
1807         return result;
1808 }
1809
1810 #else /* No IEEE 1284 support */
1811
1812 /* Don't bother probing for modes we know we won't use. */
1813 static int __devinit parport_PS2_supported(struct parport *pb) { return 0; }
1814 static int __devinit parport_ECP_supported(struct parport *pb) { return 0; }
1815 static int __devinit parport_EPP_supported(struct parport *pb) { return 0; }
1816 static int __devinit parport_ECPEPP_supported(struct parport *pb){return 0;}
1817 static int __devinit parport_ECPPS2_supported(struct parport *pb){return 0;}
1818
1819 #endif /* No IEEE 1284 support */
1820
1821 /* --- IRQ detection -------------------------------------- */
1822
1823 /* Only if supports ECP mode */
1824 static int __devinit programmable_irq_support(struct parport *pb)
1825 {
1826         int irq, intrLine;
1827         unsigned char oecr = inb (ECONTROL (pb));
1828         static const int lookup[8] = {
1829                 PARPORT_IRQ_NONE, 7, 9, 10, 11, 14, 15, 5
1830         };
1831
1832         outb (ECR_CNF << 5, ECONTROL (pb)); /* Configuration MODE */
1833
1834         intrLine = (inb (CONFIGB (pb)) >> 3) & 0x07;
1835         irq = lookup[intrLine];
1836
1837         outb (oecr, ECONTROL (pb));
1838         return irq;
1839 }
1840
1841 static int __devinit irq_probe_ECP(struct parport *pb)
1842 {
1843         int i;
1844         unsigned long irqs;
1845
1846         sti();
1847         irqs = probe_irq_on();
1848                 
1849         outb (ECR_SPP << 5, ECONTROL (pb)); /* Reset FIFO */
1850         outb ((ECR_TST << 5) | 0x04, ECONTROL (pb));
1851         outb (ECR_TST << 5, ECONTROL (pb));
1852
1853         /* If Full FIFO sure that writeIntrThreshold is generated */
1854         for (i=0; i < 1024 && !(inb (ECONTROL (pb)) & 0x02) ; i++) 
1855                 outb (0xaa, FIFO (pb));
1856                 
1857         pb->irq = probe_irq_off(irqs);
1858         outb (ECR_SPP << 5, ECONTROL (pb));
1859
1860         if (pb->irq <= 0)
1861                 pb->irq = PARPORT_IRQ_NONE;
1862
1863         return pb->irq;
1864 }
1865
1866 /*
1867  * This detection seems that only works in National Semiconductors
1868  * This doesn't work in SMC, LGS, and Winbond 
1869  */
1870 static int __devinit irq_probe_EPP(struct parport *pb)
1871 {
1872 #ifndef ADVANCED_DETECT
1873         return PARPORT_IRQ_NONE;
1874 #else
1875         int irqs;
1876         unsigned char oecr;
1877
1878         if (pb->modes & PARPORT_MODE_PCECR)
1879                 oecr = inb (ECONTROL (pb));
1880
1881         sti();
1882         irqs = probe_irq_on();
1883
1884         if (pb->modes & PARPORT_MODE_PCECR)
1885                 frob_econtrol (pb, 0x10, 0x10);
1886         
1887         clear_epp_timeout(pb);
1888         parport_pc_frob_control (pb, 0x20, 0x20);
1889         parport_pc_frob_control (pb, 0x10, 0x10);
1890         clear_epp_timeout(pb);
1891
1892         /* Device isn't expecting an EPP read
1893          * and generates an IRQ.
1894          */
1895         parport_pc_read_epp(pb);
1896         udelay(20);
1897
1898         pb->irq = probe_irq_off (irqs);
1899         if (pb->modes & PARPORT_MODE_PCECR)
1900                 outb (oecr, ECONTROL (pb));
1901         parport_pc_write_control(pb, 0xc);
1902
1903         if (pb->irq <= 0)
1904                 pb->irq = PARPORT_IRQ_NONE;
1905
1906         return pb->irq;
1907 #endif /* Advanced detection */
1908 }
1909
1910 static int __devinit irq_probe_SPP(struct parport *pb)
1911 {
1912         /* Don't even try to do this. */
1913         return PARPORT_IRQ_NONE;
1914 }
1915
1916 /* We will attempt to share interrupt requests since other devices
1917  * such as sound cards and network cards seem to like using the
1918  * printer IRQs.
1919  *
1920  * When ECP is available we can autoprobe for IRQs.
1921  * NOTE: If we can autoprobe it, we can register the IRQ.
1922  */
1923 static int __devinit parport_irq_probe(struct parport *pb)
1924 {
1925         const struct parport_pc_private *priv = pb->private_data;
1926
1927         if (priv->ecr) {
1928                 pb->irq = programmable_irq_support(pb);
1929         }
1930
1931         if (pb->modes & PARPORT_MODE_ECP)
1932                 pb->irq = irq_probe_ECP(pb);
1933
1934         if (pb->irq == PARPORT_IRQ_NONE && priv->ecr &&
1935             (pb->modes & PARPORT_MODE_EPP))
1936                 pb->irq = irq_probe_EPP(pb);
1937
1938         clear_epp_timeout(pb);
1939
1940         if (pb->irq == PARPORT_IRQ_NONE && (pb->modes & PARPORT_MODE_EPP))
1941                 pb->irq = irq_probe_EPP(pb);
1942
1943         clear_epp_timeout(pb);
1944
1945         if (pb->irq == PARPORT_IRQ_NONE)
1946                 pb->irq = irq_probe_SPP(pb);
1947
1948         if (pb->irq == PARPORT_IRQ_NONE)
1949                 pb->irq = get_superio_irq(pb);
1950
1951         return pb->irq;
1952 }
1953
1954 /* --- DMA detection -------------------------------------- */
1955
1956 /* Only if chipset conforms to ECP ISA Interface Standard */
1957 static int __devinit programmable_dma_support (struct parport *p)
1958 {
1959         unsigned char oecr = inb (ECONTROL (p));
1960         int dma;
1961
1962         frob_econtrol (p, 0xe0, ECR_CNF << 5);
1963         
1964         dma = inb (CONFIGB(p)) & 0x07;
1965         /* 000: Indicates jumpered 8-bit DMA if read-only.
1966            100: Indicates jumpered 16-bit DMA if read-only. */
1967         if ((dma & 0x03) == 0)
1968                 dma = PARPORT_DMA_NONE;
1969
1970         outb (oecr, ECONTROL (p));
1971         return dma;
1972 }
1973
1974 static int __devinit parport_dma_probe (struct parport *p)
1975 {
1976         const struct parport_pc_private *priv = p->private_data;
1977         if (priv->ecr)
1978                 p->dma = programmable_dma_support(p); /* ask ECP chipset first */
1979         if (p->dma == PARPORT_DMA_NONE)
1980                 /* ask known Super-IO chips proper, although these
1981                    claim ECP compatible, some don't report their DMA
1982                    conforming to ECP standards */
1983                 p->dma = get_superio_dma(p);
1984
1985         return p->dma;
1986 }
1987
1988 /* --- Initialisation code -------------------------------- */
1989
1990 struct parport *__devinit parport_pc_probe_port (unsigned long int base,
1991                                                  unsigned long int base_hi,
1992                                                  int irq, int dma,
1993                                                  struct pci_dev *dev)
1994 {
1995         struct parport_pc_private *priv;
1996         struct parport_operations *ops;
1997         struct parport tmp;
1998         struct parport *p = &tmp;
1999         int probedirq = PARPORT_IRQ_NONE;
2000         if (check_region(base, 3)) return NULL;
2001         priv = kmalloc (sizeof (struct parport_pc_private), GFP_KERNEL);
2002         if (!priv) {
2003                 printk (KERN_DEBUG "parport (0x%lx): no memory!\n", base);
2004                 return NULL;
2005         }
2006         ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
2007         if (!ops) {
2008                 printk (KERN_DEBUG "parport (0x%lx): no memory for ops!\n",
2009                         base);
2010                 kfree (priv);
2011                 return NULL;
2012         }
2013         memcpy (ops, &parport_pc_ops, sizeof (struct parport_operations));
2014         priv->ctr = 0xc;
2015         priv->ctr_writable = 0xff;
2016         priv->ecr = 0;
2017         priv->fifo_depth = 0;
2018         priv->dma_buf = 0;
2019         priv->dma_handle = 0;
2020         priv->dev = dev;
2021         p->base = base;
2022         p->base_hi = base_hi;
2023         p->irq = irq;
2024         p->dma = dma;
2025         p->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT;
2026         p->ops = ops;
2027         p->private_data = priv;
2028         p->physport = p;
2029         if (base_hi && !check_region(base_hi,3)) {
2030                 parport_ECR_present(p);
2031                 parport_ECP_supported(p);
2032         }
2033         if (base != 0x3bc) {
2034                 if (!check_region(base+0x3, 5)) {
2035                         if (!parport_EPP_supported(p))
2036                                 parport_ECPEPP_supported(p);
2037                 }
2038         }
2039         if (!parport_SPP_supported (p)) {
2040                 /* No port. */
2041                 kfree (priv);
2042                 return NULL;
2043         }
2044         if (priv->ecr)
2045                 parport_ECPPS2_supported(p);
2046         else
2047                 parport_PS2_supported (p);
2048
2049         if (!(p = parport_register_port(base, PARPORT_IRQ_NONE,
2050                                         PARPORT_DMA_NONE, ops))) {
2051                 kfree (priv);
2052                 kfree (ops);
2053                 return NULL;
2054         }
2055
2056         p->base_hi = base_hi;
2057         p->modes = tmp.modes;
2058         p->size = (p->modes & PARPORT_MODE_EPP)?8:3;
2059         p->private_data = priv;
2060
2061         printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base);
2062         if (p->base_hi && (p->modes & PARPORT_MODE_ECP))
2063                 printk(" (0x%lx)", p->base_hi);
2064         p->irq = irq;
2065         p->dma = dma;
2066         if (p->irq == PARPORT_IRQ_AUTO) {
2067                 p->irq = PARPORT_IRQ_NONE;
2068                 parport_irq_probe(p);
2069         } else if (p->irq == PARPORT_IRQ_PROBEONLY) {
2070                 p->irq = PARPORT_IRQ_NONE;
2071                 parport_irq_probe(p);
2072                 probedirq = p->irq;
2073                 p->irq = PARPORT_IRQ_NONE;
2074         }
2075         if (p->irq != PARPORT_IRQ_NONE) {
2076                 printk(", irq %d", p->irq);
2077
2078                 if (p->dma == PARPORT_DMA_AUTO) {
2079                         p->dma = PARPORT_DMA_NONE;
2080                         parport_dma_probe(p);
2081                 }
2082         }
2083         if (p->dma == PARPORT_DMA_AUTO) /* To use DMA, giving the irq
2084                                            is mandatory (see above) */
2085                 p->dma = PARPORT_DMA_NONE;
2086
2087 #ifdef CONFIG_PARPORT_PC_FIFO
2088         if (p->dma != PARPORT_DMA_NOFIFO &&
2089             priv->fifo_depth > 0 && p->irq != PARPORT_IRQ_NONE) {
2090                 p->ops->compat_write_data = parport_pc_compat_write_block_pio;
2091 #ifdef CONFIG_PARPORT_1284
2092                 p->ops->ecp_write_data = parport_pc_ecp_write_block_pio;
2093 #endif /* IEEE 1284 support */
2094                 if (p->dma != PARPORT_DMA_NONE) {
2095                         printk(", dma %d", p->dma);
2096                         p->modes |= PARPORT_MODE_DMA;
2097                 }
2098                 else printk(", using FIFO");
2099         }
2100         else
2101                 /* We can't use the DMA channel after all. */
2102                 p->dma = PARPORT_DMA_NONE;
2103 #endif /* Allowed to use FIFO/DMA */
2104
2105         printk(" [");
2106 #define printmode(x) {if(p->modes&PARPORT_MODE_##x){printk("%s%s",f?",":"",#x);f++;}}
2107         {
2108                 int f = 0;
2109                 printmode(PCSPP);
2110                 printmode(TRISTATE);
2111                 printmode(COMPAT)
2112                 printmode(EPP);
2113                 printmode(ECP);
2114                 printmode(DMA);
2115         }
2116 #undef printmode
2117 #ifndef CONFIG_PARPORT_1284
2118         printk ("(,...)");
2119 #endif /* CONFIG_PARPORT_1284 */
2120         printk("]\n");
2121         if (probedirq != PARPORT_IRQ_NONE) 
2122                 printk(KERN_INFO "%s: irq %d detected\n", p->name, probedirq);
2123         parport_proc_register(p);
2124
2125         request_region (p->base, 3, p->name);
2126         if (p->size > 3)
2127                 request_region (p->base + 3, p->size - 3, p->name);
2128         if (p->modes & PARPORT_MODE_ECP)
2129                 request_region (p->base_hi, 3, p->name);
2130
2131         if (p->irq != PARPORT_IRQ_NONE) {
2132                 if (request_irq (p->irq, parport_pc_interrupt,
2133                                  0, p->name, p)) {
2134                         printk (KERN_WARNING "%s: irq %d in use, "
2135                                 "resorting to polled operation\n",
2136                                 p->name, p->irq);
2137                         p->irq = PARPORT_IRQ_NONE;
2138                         p->dma = PARPORT_DMA_NONE;
2139                 }
2140
2141 #ifdef CONFIG_PARPORT_PC_FIFO
2142                 if (p->dma != PARPORT_DMA_NONE) {
2143                         if (request_dma (p->dma, p->name)) {
2144                                 printk (KERN_WARNING "%s: dma %d in use, "
2145                                         "resorting to PIO operation\n",
2146                                         p->name, p->dma);
2147                                 p->dma = PARPORT_DMA_NONE;
2148                         } else {
2149                                 priv->dma_buf =
2150                                   pci_alloc_consistent(priv->dev,
2151                                                        PAGE_SIZE,
2152                                                        &priv->dma_handle);
2153                                 if (! priv->dma_buf) {
2154                                         printk (KERN_WARNING "%s: "
2155                                                 "cannot get buffer for DMA, "
2156                                                 "resorting to PIO operation\n",
2157                                                 p->name);
2158                                         free_dma(p->dma);
2159                                         p->dma = PARPORT_DMA_NONE;
2160                                 }
2161                         }
2162                 }
2163 #endif /* CONFIG_PARPORT_PC_FIFO */
2164         }
2165
2166         /* Done probing.  Now put the port into a sensible start-up state. */
2167         if (priv->ecr)
2168                 /*
2169                  * Put the ECP detected port in PS2 mode.
2170                  * Do this also for ports that have ECR but don't do ECP.
2171                  */
2172                 outb (0x34, ECONTROL (p));
2173
2174         parport_pc_write_data(p, 0);
2175         parport_pc_data_forward (p);
2176
2177         /* Now that we've told the sharing engine about the port, and
2178            found out its characteristics, let the high-level drivers
2179            know about it. */
2180         parport_announce_port (p);
2181
2182         return p;
2183 }
2184
2185
2186 /* Via support maintained by Jeff Garzik <jgarzik@mandrakesoft.com> */
2187 static int __devinit sio_via_686a_probe (struct pci_dev *pdev)
2188 {
2189         u8 tmp;
2190         int dma, irq;
2191         unsigned port1, port2, have_eppecp;
2192
2193         /*
2194          * unlock super i/o configuration, set 0x85_1
2195          */
2196         pci_read_config_byte (pdev, 0x85, &tmp);
2197         tmp |= (1 << 1);
2198         pci_write_config_byte (pdev, 0x85, tmp);
2199         
2200         /* 
2201          * Super I/O configuration, index port == 3f0h, data port == 3f1h
2202          */
2203         
2204         /* 0xE2_1-0: Parallel Port Mode / Enable */
2205         outb (0xE2, 0x3F0);
2206         tmp = inb (0x3F1);
2207         
2208         if ((tmp & 0x03) == 0x03) {
2209                 printk (KERN_INFO "parport_pc: Via 686A parallel port disabled in BIOS\n");
2210                 return 0;
2211         }
2212         
2213         /* 0xE6: Parallel Port I/O Base Address, bits 9-2 */
2214         outb (0xE6, 0x3F0);
2215         port1 = inb (0x3F1) << 2;
2216         
2217         switch (port1) {
2218         case 0x3bc: port2 = 0x7bc; break;
2219         case 0x378: port2 = 0x778; break;
2220         case 0x278: port2 = 0x678; break;
2221         default:
2222                 printk (KERN_INFO "parport_pc: Via 686A weird parport base 0x%X, ignoring\n",
2223                         port1);
2224                 return 0;
2225         }
2226
2227         /* 0xF0_5: EPP+ECP enable */
2228         outb (0xF0, 0x3F0);
2229         have_eppecp = (inb (0x3F1) & (1 << 5));
2230         
2231         /*
2232          * lock super i/o configuration, clear 0x85_1
2233          */
2234         pci_read_config_byte (pdev, 0x85, &tmp);
2235         tmp &= ~(1 << 1);
2236         pci_write_config_byte (pdev, 0x85, tmp);
2237
2238         /*
2239          * Get DMA and IRQ from PCI->ISA bridge PCI config registers
2240          */
2241
2242         /* 0x50_3-2: PnP Routing for Parallel Port DRQ */
2243         pci_read_config_byte (pdev, 0x50, &tmp);
2244         dma = ((tmp >> 2) & 0x03);
2245         
2246         /* 0x51_7-4: PnP Routing for Parallel Port IRQ */
2247         pci_read_config_byte (pdev, 0x51, &tmp);
2248         irq = ((tmp >> 4) & 0x0F);
2249
2250         /* filter bogus IRQs */
2251         switch (irq) {
2252         case 0:
2253         case 2:
2254         case 8:
2255         case 13:
2256                 irq = PARPORT_IRQ_NONE;
2257                 break;
2258
2259         default: /* do nothing */
2260                 break;
2261         }
2262
2263         /* if ECP not enabled, DMA is not enabled, assumed bogus 'dma' value */
2264         if (!have_eppecp)
2265                 dma = PARPORT_DMA_NONE;
2266
2267         /* finally, do the probe with values obtained */
2268         if (parport_pc_probe_port (port1, port2, irq, dma, NULL)) {
2269                 printk (KERN_INFO
2270                         "parport_pc: Via 686A parallel port: io=0x%X", port1);
2271                 if (irq != PARPORT_IRQ_NONE)
2272                         printk (", irq=%d", irq);
2273                 if (dma != PARPORT_DMA_NONE)
2274                         printk (", dma=%d", dma);
2275                 printk ("\n");
2276                 return 1;
2277         }
2278         
2279         printk (KERN_WARNING "parport_pc: Strange, can't probe Via 686A parallel port: io=0x%X, irq=%d, dma=%d\n",
2280                 port1, irq, dma);
2281         return 0;
2282 }
2283
2284
2285 enum parport_pc_sio_types {
2286         sio_via_686a = 0,       /* Via VT82C686A motherboard Super I/O */
2287         last_sio
2288 };
2289
2290 /* each element directly indexed from enum list, above */
2291 static struct parport_pc_superio {
2292         int (*probe) (struct pci_dev *pdev);
2293 } parport_pc_superio_info[] __devinitdata = {
2294         { sio_via_686a_probe, },
2295 };
2296
2297
2298 enum parport_pc_pci_cards {
2299         siig_1s1p_10x_550 = last_sio,
2300         siig_1s1p_10x_650,
2301         siig_1s1p_10x_850,
2302         siig_1p_10x,
2303         siig_2p_10x,
2304         siig_2s1p_10x_550,
2305         siig_2s1p_10x_650,
2306         siig_2s1p_10x_850,
2307         siig_1p_20x,
2308         siig_2p_20x,
2309         siig_2p1s_20x_550,
2310         siig_2p1s_20x_650,
2311         siig_2p1s_20x_850,
2312         siig_1s1p_20x_550,
2313         siig_1s1p_20x_650,
2314         siig_1s1p_20x_850,
2315         siig_2s1p_20x_550,
2316         siig_2s1p_20x_650,
2317         siig_2s1p_20x_850,
2318         lava_parallel,
2319         lava_parallel_dual_a,
2320         lava_parallel_dual_b,
2321         boca_ioppar,
2322         plx_9050,
2323         afavlab_tk9902,
2324         timedia_4078a,
2325         timedia_4079h,
2326         timedia_4085h,
2327         timedia_4088a,
2328         timedia_4089a,
2329         timedia_4095a,
2330         timedia_4096a,
2331         timedia_4078u,
2332         timedia_4079a,
2333         timedia_4085u,
2334         timedia_4079r,
2335         timedia_4079s,
2336         timedia_4079d,
2337         timedia_4079e,
2338         timedia_4079f,
2339         timedia_9079a,
2340         timedia_9079b,
2341         timedia_9079c,
2342         timedia_4006a,
2343         timedia_4014,
2344         timedia_4008a,
2345         timedia_4018,
2346         timedia_9018a,
2347         syba_2p_epp,
2348         syba_1p_ecp,
2349 };
2350
2351
2352 /* each element directly indexed from enum list, above 
2353  * (but offset by last_sio) */
2354 static struct parport_pc_pci {
2355         int numports;
2356         struct { /* BAR (base address registers) numbers in the config
2357                     space header */
2358                 int lo;
2359                 int hi; /* -1 if not there, >6 for offset-method (max
2360                            BAR is 6) */
2361         } addr[4];
2362 } cards[] __devinitdata = {
2363         /* siig_1s1p_10x_550 */         { 1, { { 3, 4 }, } },
2364         /* siig_1s1p_10x_650 */         { 1, { { 3, 4 }, } },
2365         /* siig_1s1p_10x_850 */         { 1, { { 3, 4 }, } },
2366         /* siig_1p_10x */               { 1, { { 2, 3 }, } },
2367         /* siig_2p_10x */               { 2, { { 2, 3 }, { 4, 5 }, } },
2368         /* siig_2s1p_10x_550 */         { 1, { { 4, 5 }, } },
2369         /* siig_2s1p_10x_650 */         { 1, { { 4, 5 }, } },
2370         /* siig_2s1p_10x_850 */         { 1, { { 4, 5 }, } },
2371         /* siig_1p_20x */               { 1, { { 0, 1 }, } },
2372         /* siig_2p_20x */               { 2, { { 0, 1 }, { 2, 3 }, } },
2373         /* siig_2p1s_20x_550 */         { 2, { { 1, 2 }, { 3, 4 }, } },
2374         /* siig_2p1s_20x_650 */         { 2, { { 1, 2 }, { 3, 4 }, } },
2375         /* siig_2p1s_20x_850 */         { 2, { { 1, 2 }, { 3, 4 }, } },
2376         /* siig_1s1p_20x_550 */         { 1, { { 1, 2 }, } },
2377         /* siig_1s1p_20x_650 */         { 1, { { 1, 2 }, } },
2378         /* siig_1s1p_20x_850 */         { 1, { { 1, 2 }, } },
2379         /* siig_2s1p_20x_550 */         { 1, { { 2, 3 }, } },
2380         /* siig_2s1p_20x_650 */         { 1, { { 2, 3 }, } },
2381         /* siig_2s1p_20x_850 */         { 1, { { 2, 3 }, } },
2382         /* lava_parallel */             { 1, { { 0, -1 }, } },
2383         /* lava_parallel_dual_a */      { 1, { { 0, -1 }, } },
2384         /* lava_parallel_dual_b */      { 1, { { 0, -1 }, } },
2385         /* boca_ioppar */               { 1, { { 0, -1 }, } },
2386         /* plx_9050 */                  { 2, { { 4, -1 }, { 5, -1 }, } },
2387         /* afavlab_tk9902 */            { 1, { { 0, 1 }, } },
2388         /* timedia_4078a */             { 1, { { 2, -1 }, } },
2389         /* timedia_4079h */             { 1, { { 2, 3 }, } },
2390         /* timedia_4085h */             { 2, { { 2, -1 }, { 4, -1 }, } },
2391         /* timedia_4088a */             { 2, { { 2, 3 }, { 4, 5 }, } },
2392         /* timedia_4089a */             { 2, { { 2, 3 }, { 4, 5 }, } },
2393         /* timedia_4095a */             { 2, { { 2, 3 }, { 4, 5 }, } },
2394         /* timedia_4096a */             { 2, { { 2, 3 }, { 4, 5 }, } },
2395         /* timedia_4078u */             { 1, { { 2, -1 }, } },
2396         /* timedia_4079a */             { 1, { { 2, 3 }, } },
2397         /* timedia_4085u */             { 2, { { 2, -1 }, { 4, -1 }, } },
2398         /* timedia_4079r */             { 1, { { 2, 3 }, } },
2399         /* timedia_4079s */             { 1, { { 2, 3 }, } },
2400         /* timedia_4079d */             { 1, { { 2, 3 }, } },
2401         /* timedia_4079e */             { 1, { { 2, 3 }, } },
2402         /* timedia_4079f */             { 1, { { 2, 3 }, } },
2403         /* timedia_9079a */             { 1, { { 2, 3 }, } },
2404         /* timedia_9079b */             { 1, { { 2, 3 }, } },
2405         /* timedia_9079c */             { 1, { { 2, 3 }, } },
2406         /* timedia_4006a */             { 1, { { 0, -1 }, } },
2407         /* timedia_4014  */             { 2, { { 0, -1 }, { 2, -1 }, } },
2408         /* timedia_4008a */             { 1, { { 0, 1 }, } },
2409         /* timedia_4018  */             { 2, { { 0, 1 }, { 2, 3 }, } },
2410         /* timedia_9018a */             { 2, { { 0, 1 }, { 2, 3 }, } },
2411                                         /* SYBA uses fixed offsets in
2412                                            a 1K io window */
2413         /* syba_2p_epp AP138B */        { 2, { { 0, 0x078 }, { 0, 0x178 }, } },
2414         /* syba_1p_ecp W83787 */        { 1, { { 0, 0x078 }, } },
2415 };
2416
2417 static struct pci_device_id parport_pc_pci_tbl[] __devinitdata = {
2418         /* Super-IO onboard chips */
2419         { 0x1106, 0x0686, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sio_via_686a },
2420
2421         /* PCI cards */
2422         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_10x_550,
2423           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_10x_550 },
2424         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_10x_650,
2425           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_10x_650 },
2426         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_10x_850,
2427           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_10x_850 },
2428         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1P_10x,
2429           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1p_10x },
2430         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P_10x,
2431           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p_10x },
2432         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_10x_550,
2433           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_10x_550 },
2434         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_10x_650,
2435           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_10x_650 },
2436         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_10x_850,
2437           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_10x_850 },
2438         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1P_20x,
2439           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1p_20x },
2440         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P_20x,
2441           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p_20x },
2442         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P1S_20x_550,
2443           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p1s_20x_550 },
2444         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P1S_20x_650,
2445           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p1s_20x_650 },
2446         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P1S_20x_850,
2447           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p1s_20x_850 },
2448         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_20x_550,
2449           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_550 },
2450         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_20x_650,
2451           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_20x_650 },
2452         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_20x_850,
2453           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_20x_850 },
2454         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_20x_550,
2455           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_550 },
2456         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_20x_650,
2457           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_650 },
2458         { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_20x_850,
2459           PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_850 },
2460         { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_PARALLEL,
2461           PCI_ANY_ID, PCI_ANY_ID, 0, 0, lava_parallel },
2462         { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_DUAL_PAR_A,
2463           PCI_ANY_ID, PCI_ANY_ID, 0, 0, lava_parallel_dual_a },
2464         { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_DUAL_PAR_B,
2465           PCI_ANY_ID, PCI_ANY_ID, 0, 0, lava_parallel_dual_b },
2466         { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_BOCA_IOPPAR,
2467           PCI_ANY_ID, PCI_ANY_ID, 0, 0, boca_ioppar },
2468         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
2469           PCI_SUBVENDOR_ID_EXSYS, PCI_SUBDEVICE_ID_EXSYS_4014, 0,0, plx_9050 },
2470         { PCI_VENDOR_ID_AFAVLAB, PCI_DEVICE_ID_AFAVLAB_TK9902,
2471           PCI_ANY_ID, PCI_ANY_ID, 0, 0, afavlab_tk9902 },
2472         /* PCI_VENDOR_ID_TIMEDIA/SUNIX has many differing cards ...*/
2473         { 0x1409, 0x7168, 0x1409, 0x4078, 0, 0, timedia_4078a },
2474         { 0x1409, 0x7168, 0x1409, 0x4079, 0, 0, timedia_4079h },
2475         { 0x1409, 0x7168, 0x1409, 0x4085, 0, 0, timedia_4085h },
2476         { 0x1409, 0x7168, 0x1409, 0x4088, 0, 0, timedia_4088a },
2477         { 0x1409, 0x7168, 0x1409, 0x4089, 0, 0, timedia_4089a },
2478         { 0x1409, 0x7168, 0x1409, 0x4095, 0, 0, timedia_4095a },
2479         { 0x1409, 0x7168, 0x1409, 0x4096, 0, 0, timedia_4096a },
2480         { 0x1409, 0x7168, 0x1409, 0x5078, 0, 0, timedia_4078u },
2481         { 0x1409, 0x7168, 0x1409, 0x5079, 0, 0, timedia_4079a },
2482         { 0x1409, 0x7168, 0x1409, 0x5085, 0, 0, timedia_4085u },
2483         { 0x1409, 0x7168, 0x1409, 0x6079, 0, 0, timedia_4079r },
2484         { 0x1409, 0x7168, 0x1409, 0x7079, 0, 0, timedia_4079s },
2485         { 0x1409, 0x7168, 0x1409, 0x8079, 0, 0, timedia_4079d },
2486         { 0x1409, 0x7168, 0x1409, 0x9079, 0, 0, timedia_4079e },
2487         { 0x1409, 0x7168, 0x1409, 0xa079, 0, 0, timedia_4079f },
2488         { 0x1409, 0x7168, 0x1409, 0xb079, 0, 0, timedia_9079a },
2489         { 0x1409, 0x7168, 0x1409, 0xc079, 0, 0, timedia_9079b },
2490         { 0x1409, 0x7168, 0x1409, 0xd079, 0, 0, timedia_9079c },
2491         { 0x1409, 0x7268, 0x1409, 0x0101, 0, 0, timedia_4006a },
2492         { 0x1409, 0x7268, 0x1409, 0x0102, 0, 0, timedia_4014 },
2493         { 0x1409, 0x7268, 0x1409, 0x0103, 0, 0, timedia_4008a },
2494         { 0x1409, 0x7268, 0x1409, 0x0104, 0, 0, timedia_4018 },
2495         { 0x1409, 0x7268, 0x1409, 0x9018, 0, 0, timedia_9018a },
2496         { PCI_VENDOR_ID_SYBA, PCI_DEVICE_ID_SYBA_2P_EPP,
2497           PCI_ANY_ID, PCI_ANY_ID, 0, 0, syba_2p_epp },
2498         { PCI_VENDOR_ID_SYBA, PCI_DEVICE_ID_SYBA_1P_ECP,
2499           PCI_ANY_ID, PCI_ANY_ID, 0, 0, syba_1p_ecp },
2500         { 0, } /* terminate list */
2501 };
2502 MODULE_DEVICE_TABLE(pci,parport_pc_pci_tbl);
2503
2504 static int __devinit parport_pc_pci_probe (struct pci_dev *dev,
2505                                            const struct pci_device_id *id)
2506 {
2507         int err, count, n, i = id->driver_data;
2508         if (i < last_sio)
2509                 /* This is an onboard Super-IO and has already been probed */
2510                 return 0;
2511
2512         /* This is a PCI card */
2513         i -= last_sio;
2514         count = 0;
2515         if ((err = pci_enable_device (dev)) != 0)
2516                 return err;
2517
2518         for (n = 0; n < cards[i].numports; n++) {
2519                 int lo = cards[i].addr[n].lo;
2520                 int hi = cards[i].addr[n].hi;
2521                 unsigned long io_lo, io_hi;
2522                 io_lo = pci_resource_start (dev, lo);
2523                 io_hi = 0;
2524                 if ((hi >= 0) && (hi <= 6))
2525                         io_hi = pci_resource_start (dev, hi);
2526                 else if (hi > 6)
2527                         io_lo += hi; /* Reinterpret the meaning of
2528                                         "hi" as an offset (see SYBA
2529                                         def.) */
2530                 /* TODO: test if sharing interrupts works */
2531                 printk (KERN_DEBUG "PCI parallel port detected: %04x:%04x, "
2532                         "I/O at %#lx(%#lx)\n",
2533                         parport_pc_pci_tbl[i + last_sio].vendor,
2534                         parport_pc_pci_tbl[i + last_sio].device, io_lo, io_hi);
2535                 if (parport_pc_probe_port (io_lo, io_hi, PARPORT_IRQ_NONE,
2536                                            PARPORT_DMA_NONE, dev))
2537                         count++;
2538         }
2539
2540         return count == 0 ? -ENODEV : 0;
2541 }
2542
2543 static struct pci_driver parport_pc_pci_driver = {
2544         name:           "parport_pc",
2545         id_table:       parport_pc_pci_tbl,
2546         probe:          parport_pc_pci_probe,
2547 };
2548
2549 static int __init parport_pc_init_superio (void)
2550 {
2551 #ifdef CONFIG_PCI
2552         const struct pci_device_id *id;
2553         struct pci_dev *pdev;
2554
2555         pci_for_each_dev(pdev) {
2556                 id = pci_match_device (parport_pc_pci_tbl, pdev);
2557                 if (id == NULL || id->driver_data >= last_sio)
2558                         continue;
2559
2560                 return parport_pc_superio_info[id->driver_data].probe (pdev);
2561         }
2562 #endif /* CONFIG_PCI */
2563
2564         return 0; /* zero devices found */
2565 }
2566
2567 /* This is called by parport_pc_find_nonpci_ports (in asm/parport.h) */
2568 static int __init __attribute__((unused))
2569 parport_pc_find_isa_ports (int autoirq, int autodma)
2570 {
2571         int count = 0;
2572
2573         if (parport_pc_probe_port(0x3bc, 0x7bc, autoirq, autodma, NULL))
2574                 count++;
2575         if (parport_pc_probe_port(0x378, 0x778, autoirq, autodma, NULL))
2576                 count++;
2577         if (parport_pc_probe_port(0x278, 0x678, autoirq, autodma, NULL))
2578                 count++;
2579
2580         return count;
2581 }
2582
2583 /* This function is called by parport_pc_init if the user didn't
2584  * specify any ports to probe.  Its job is to find some ports.  Order
2585  * is important here -- we want ISA ports to be registered first,
2586  * followed by PCI cards (for least surprise), but before that we want
2587  * to do chipset-specific tests for some onboard ports that we know
2588  * about.
2589  *
2590  * autoirq is PARPORT_IRQ_NONE, PARPORT_IRQ_AUTO, or PARPORT_IRQ_PROBEONLY
2591  * autodma is PARPORT_DMA_NONE or PARPORT_DMA_AUTO
2592  */
2593 static int __init parport_pc_find_ports (int autoirq, int autodma)
2594 {
2595         int count = 0, r;
2596
2597 #ifdef CONFIG_PARPORT_PC_SUPERIO
2598         detect_and_report_winbond ();
2599         detect_and_report_smsc ();
2600 #endif
2601
2602         /* Onboard SuperIO chipsets that show themselves on the PCI bus. */
2603         count += parport_pc_init_superio ();
2604
2605         /* ISA ports and whatever (see asm/parport.h). */
2606         count += parport_pc_find_nonpci_ports (autoirq, autodma);
2607
2608         r = pci_register_driver (&parport_pc_pci_driver);
2609         if (r >= 0) {
2610                 registered_parport = 1;
2611                 count += r;
2612         }
2613
2614         return count;
2615 }
2616
2617 int __init parport_pc_init (int *io, int *io_hi, int *irq, int *dma)
2618 {
2619         int count = 0, i = 0;
2620
2621         if (io && *io) {
2622                 /* Only probe the ports we were given. */
2623                 user_specified = 1;
2624                 do {
2625                         if (!*io_hi) *io_hi = 0x400 + *io;
2626                         if (parport_pc_probe_port(*(io++), *(io_hi++),
2627                                                   *(irq++), *(dma++), NULL))
2628                                 count++;
2629                 } while (*io && (++i < PARPORT_PC_MAX_PORTS));
2630         } else {
2631                 count += parport_pc_find_ports (irq[0], dma[0]);
2632         }
2633
2634         return count;
2635 }
2636
2637 /* Exported symbols. */
2638 #ifdef CONFIG_PARPORT_PC_PCMCIA
2639
2640 /* parport_cs needs this in order to dyncamically get us to find ports. */
2641 EXPORT_SYMBOL (parport_pc_probe_port);
2642
2643 #else
2644
2645 EXPORT_NO_SYMBOLS;
2646
2647 #endif
2648
2649 #ifdef MODULE
2650 static int io[PARPORT_PC_MAX_PORTS+1] = { [0 ... PARPORT_PC_MAX_PORTS] = 0 };
2651 static int io_hi[PARPORT_PC_MAX_PORTS+1] = { [0 ... PARPORT_PC_MAX_PORTS] = 0 };
2652 static int dmaval[PARPORT_PC_MAX_PORTS] = { [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_DMA_AUTO };
2653 static int irqval[PARPORT_PC_MAX_PORTS] = { [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_IRQ_PROBEONLY };
2654 static const char *irq[PARPORT_PC_MAX_PORTS] = { NULL, };
2655 static const char *dma[PARPORT_PC_MAX_PORTS] = { NULL, };
2656
2657 MODULE_AUTHOR("Phil Blundell, Tim Waugh, others");
2658 MODULE_DESCRIPTION("PC-style parallel port driver");
2659 MODULE_PARM_DESC(io, "Base I/O address (SPP regs)");
2660 MODULE_PARM(io, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "i");
2661 MODULE_PARM_DESC(io_hi, "Base I/O address (ECR)");
2662 MODULE_PARM(io_hi, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "i");
2663 MODULE_PARM_DESC(irq, "IRQ line");
2664 MODULE_PARM(irq, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "s");
2665 MODULE_PARM_DESC(dma, "DMA channel");
2666 MODULE_PARM(dma, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "s");
2667
2668 int init_module(void)
2669 {       
2670         /* Work out how many ports we have, then get parport_share to parse
2671            the irq values. */
2672         unsigned int i;
2673         int ret;
2674         for (i = 0; i < PARPORT_PC_MAX_PORTS && io[i]; i++);
2675         if (i) {
2676                 if (parport_parse_irqs(i, irq, irqval)) return 1;
2677                 if (parport_parse_dmas(i, dma, dmaval)) return 1;
2678         }
2679         else {
2680                 /* The user can make us use any IRQs or DMAs we find. */
2681                 int val;
2682
2683                 if (irq[0] && !parport_parse_irqs (1, irq, &val))
2684                         switch (val) {
2685                         case PARPORT_IRQ_NONE:
2686                         case PARPORT_IRQ_AUTO:
2687                                 irqval[0] = val;
2688                         }
2689
2690                 if (dma[0] && !parport_parse_dmas (1, dma, &val))
2691                         switch (val) {
2692                         case PARPORT_DMA_NONE:
2693                         case PARPORT_DMA_AUTO:
2694                                 dmaval[0] = val;
2695                         }
2696         }
2697
2698         ret = !parport_pc_init (io, io_hi, irqval, dmaval);
2699         if (ret && registered_parport)
2700                 pci_unregister_driver (&parport_pc_pci_driver);
2701
2702         return ret;
2703 }
2704
2705 void cleanup_module(void)
2706 {
2707         /* We ought to keep track of which ports are actually ours. */
2708         struct parport *p = parport_enumerate(), *tmp;
2709
2710         if (!user_specified)
2711                 pci_unregister_driver (&parport_pc_pci_driver);
2712
2713         while (p) {
2714                 tmp = p->next;
2715                 if (p->modes & PARPORT_MODE_PCSPP) { 
2716                         struct parport_pc_private *priv = p->private_data;
2717                         struct parport_operations *ops = p->ops;
2718                         if (p->dma != PARPORT_DMA_NONE)
2719                                 free_dma(p->dma);
2720                         if (p->irq != PARPORT_IRQ_NONE)
2721                                 free_irq(p->irq, p);
2722                         release_region(p->base, 3);
2723                         if (p->size > 3)
2724                                 release_region(p->base + 3, p->size - 3);
2725                         if (p->modes & PARPORT_MODE_ECP)
2726                                 release_region(p->base_hi, 3);
2727                         parport_proc_unregister(p);
2728                         if (priv->dma_buf)
2729                                 pci_free_consistent(priv->dev, PAGE_SIZE,
2730                                                     priv->dma_buf,
2731                                                     priv->dma_handle);
2732                         kfree (p->private_data);
2733                         parport_unregister_port(p);
2734                         kfree (ops); /* hope no-one cached it */
2735                 }
2736                 p = tmp;
2737         }
2738 }
2739 #endif