Patched in Tegra support.

10 files changed, 478 insertions, 87 deletions

diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index 0e60438ebe3..d92185a5523 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -36,7 +36,7 @@ if PARPORT
 config PARPORT_PC
         tristate "PC-style hardware"
         depends on (!SPARC64 || PCI) && !SPARC32 && !M32R && !FRV && \
-                (!M68K || ISA) && !MN10300 && !AVR32 && !BLACKFIN && !XTENSA
+                (!M68K || ISA) && !MN10300 && !AVR32 && !BLACKFIN
         ---help---
           You should say Y here if you have a PC-style parallel port. All
           IBM PC compatible computers and some Alphas have PC-style
@@ -57,8 +57,8 @@ config PARPORT_SERIAL
           will be called parport_serial.
 
 config PARPORT_PC_FIFO
-        bool "Use FIFO/DMA if available"
-        depends on PARPORT_PC
+        bool "Use FIFO/DMA if available (EXPERIMENTAL)"
+        depends on PARPORT_PC && EXPERIMENTAL
         help
           Many parallel port chipsets provide hardware that can speed up
           printing. Say Y here if you want to take advantage of that.
@@ -70,8 +70,8 @@ config PARPORT_PC_FIFO
           specify which IRQ/DMA to use.
 
 config PARPORT_PC_SUPERIO
-        bool "SuperIO chipset support"
-        depends on PARPORT_PC
+        bool "SuperIO chipset support (EXPERIMENTAL)"
+        depends on PARPORT_PC && EXPERIMENTAL
         help
           Saying Y here enables some probes for Super-IO chipsets in order to
           find out things like base addresses, IRQ lines and DMA channels.  It
@@ -85,8 +85,8 @@ config PARPORT_PC_PCMCIA
           ports. If unsure, say N.
 
 config PARPORT_IP32
-        tristate "SGI IP32 builtin port"
-        depends on SGI_IP32
+        tristate "SGI IP32 builtin port (EXPERIMENTAL)"
+        depends on SGI_IP32 && EXPERIMENTAL
         select PARPORT_NOT_PC
         help
           Say Y here if you need support for the parallel port on
@@ -126,8 +126,8 @@ config PARPORT_GSC
         select PARPORT_NOT_PC
 
 config PARPORT_SUNBPP
-        tristate "Sparc hardware"
-        depends on SBUS
+        tristate "Sparc hardware (EXPERIMENTAL)"
+        depends on SBUS && EXPERIMENTAL
         select PARPORT_NOT_PC
         help
           This driver provides support for the bidirectional parallel port
diff --git a/drivers/parport/parport_amiga.c b/drivers/parport/parport_amiga.c
index ee78e0ee6e0..8bef6d60f88 100644
--- a/drivers/parport/parport_amiga.c
+++ b/drivers/parport/parport_amiga.c
@@ -48,6 +48,23 @@ static unsigned char amiga_read_data(struct parport *p)
         return ciaa.prb;
 }
 
+#if 0
+static unsigned char control_pc_to_amiga(unsigned char control)
+{
+        unsigned char ret = 0;
+
+        if (control & PARPORT_CONTROL_SELECT) /* XXX: What is SELECP? */
+                ;
+        if (control & PARPORT_CONTROL_INIT) /* INITP */
+                /* reset connected to cpu reset pin */;
+        if (control & PARPORT_CONTROL_AUTOFD) /* AUTOLF */
+                /* Not connected */;
+        if (control & PARPORT_CONTROL_STROBE) /* Strobe */
+                /* Handled only directly by hardware */;
+        return ret;
+}
+#endif
+
 static unsigned char control_amiga_to_pc(unsigned char control)
 {
         return PARPORT_CONTROL_SELECT |
@@ -78,6 +95,25 @@ static unsigned char amiga_frob_control( struct parport *p, unsigned char mask,
         return old;
 }
 
+#if 0 /* currently unused */
+static unsigned char status_pc_to_amiga(unsigned char status)
+{
+        unsigned char ret = 1;
+
+        if (status & PARPORT_STATUS_BUSY) /* Busy */
+                ret &= ~1;
+        if (status & PARPORT_STATUS_ACK) /* Ack */
+                /* handled in hardware */;
+        if (status & PARPORT_STATUS_PAPEROUT) /* PaperOut */
+                ret |= 2;
+        if (status & PARPORT_STATUS_SELECT) /* select */
+                ret |= 4;
+        if (status & PARPORT_STATUS_ERROR) /* error */
+                /* not connected */;
+        return ret;
+}
+#endif
+
 static unsigned char status_amiga_to_pc(unsigned char status)
 {
         unsigned char ret = PARPORT_STATUS_BUSY | PARPORT_STATUS_ACK | PARPORT_STATUS_ERROR;
diff --git a/drivers/parport/parport_atari.c b/drivers/parport/parport_atari.c
index 7ad59ac68cf..0b28fccec03 100644
--- a/drivers/parport/parport_atari.c
+++ b/drivers/parport/parport_atari.c
@@ -130,6 +130,15 @@ parport_atari_data_forward(struct parport *p)
 static void
 parport_atari_data_reverse(struct parport *p)
 {
+#if 0 /* too dangerous, can kill sound chip */
+        unsigned long flags;
+
+        local_irq_save(flags);
+        /* Soundchip port B as input. */
+        sound_ym.rd_data_reg_sel = 7;
+        sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~0x40;
+        local_irq_restore(flags);
+#endif
 }
 
 static struct parport_operations parport_atari_ops = {
diff --git a/drivers/parport/parport_ax88796.c b/drivers/parport/parport_ax88796.c
index 7c5d86696ee..844f6137970 100644
--- a/drivers/parport/parport_ax88796.c
+++ b/drivers/parport/parport_ax88796.c
@@ -420,7 +420,18 @@ static struct platform_driver axdrv = {
         .resume         = parport_ax88796_resume,
 };
 
-module_platform_driver(axdrv);
+static int __init parport_ax88796_init(void)
+{
+        return platform_driver_register(&axdrv);
+}
+
+static void __exit parport_ax88796_exit(void)
+{
+        platform_driver_unregister(&axdrv);
+}
+
+module_init(parport_ax88796_init)
+module_exit(parport_ax88796_exit)
 
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 MODULE_DESCRIPTION("AX88796 Parport parallel port driver");
diff --git a/drivers/parport/parport_gsc.c b/drivers/parport/parport_gsc.c
index 050773c3682..5d6de380e42 100644
--- a/drivers/parport/parport_gsc.c
+++ b/drivers/parport/parport_gsc.c
@@ -137,7 +137,7 @@ struct parport_operations parport_gsc_ops =
 /*
  * Checks for port existence, all ports support SPP MODE
  */
-static int parport_SPP_supported(struct parport *pb)
+static int __devinit parport_SPP_supported(struct parport *pb)
 {
         unsigned char r, w;
 
@@ -201,7 +201,7 @@ static int parport_SPP_supported(struct parport *pb)
  * be misdetected here is rather academic. 
  */
 
-static int parport_PS2_supported(struct parport *pb)
+static int __devinit parport_PS2_supported(struct parport *pb)
 {
         int ok = 0;
   
@@ -232,9 +232,10 @@ static int parport_PS2_supported(struct parport *pb)
 
 /* --- Initialisation code -------------------------------- */
 
-struct parport *parport_gsc_probe_port(unsigned long base,
-                                       unsigned long base_hi, int irq,
-                                       int dma, struct pci_dev *dev)
+struct parport *__devinit parport_gsc_probe_port (unsigned long base,
+                                                 unsigned long base_hi,
+                                                 int irq, int dma,
+                                                 struct pci_dev *dev)
 {
         struct parport_gsc_private *priv;
         struct parport_operations *ops;
@@ -270,7 +271,6 @@ struct parport *parport_gsc_probe_port(unsigned long base,
         if (!parport_SPP_supported (p)) {
                 /* No port. */
                 kfree (priv);
-                kfree(ops);
                 return NULL;
         }
         parport_PS2_supported (p);
@@ -344,9 +344,9 @@ struct parport *parport_gsc_probe_port(unsigned long base,
 
 #define PARPORT_GSC_OFFSET 0x800
 
-static int parport_count;
+static int __devinitdata parport_count;
 
-static int parport_init_chip(struct parisc_device *dev)
+static int __devinit parport_init_chip(struct parisc_device *dev)
 {
         struct parport *p;
         unsigned long port;
@@ -381,7 +381,7 @@ static int parport_init_chip(struct parisc_device *dev)
         return 0;
 }
 
-static int parport_remove_chip(struct parisc_device *dev)
+static int __devexit parport_remove_chip(struct parisc_device *dev)
 {
         struct parport *p = dev_get_drvdata(&dev->dev);
         if (p) {
@@ -414,15 +414,15 @@ static struct parisc_driver parport_driver = {
         .name           = "Parallel",
         .id_table       = parport_tbl,
         .probe          = parport_init_chip,
-        .remove         = parport_remove_chip,
+        .remove         = __devexit_p(parport_remove_chip),
 };
 
-int parport_gsc_init(void)
+int __devinit parport_gsc_init(void)
 {
         return register_parisc_driver(&parport_driver);
 }
 
-static void parport_gsc_exit(void)
+static void __devexit parport_gsc_exit(void)
 {
         unregister_parisc_driver(&parport_driver);
 }
diff --git a/drivers/parport/parport_ip32.c b/drivers/parport/parport_ip32.c
index d4716273651..0dc34f12f92 100644
--- a/drivers/parport/parport_ip32.c
+++ b/drivers/parport/parport_ip32.c
@@ -135,7 +135,7 @@
 #define PARPORT_IP32_ENABLE_EPP (1U << 3)
 #define PARPORT_IP32_ENABLE_ECP (1U << 4)
 static unsigned int features =  ~0U;
-static bool verbose_probing =   DEFAULT_VERBOSE_PROBING;
+static int verbose_probing =    DEFAULT_VERBOSE_PROBING;
 
 /* We do not support more than one port. */
 static struct parport *this_port = NULL;
diff --git a/drivers/parport/parport_mfc3.c b/drivers/parport/parport_mfc3.c
index 7578d79b368..362db31d8ca 100644
--- a/drivers/parport/parport_mfc3.c
+++ b/drivers/parport/parport_mfc3.c
@@ -147,6 +147,25 @@ DPRINTK(KERN_DEBUG "frob_control mask %02x, value %02x\n",mask,val);
         return old;
 }
 
+#if 0 /* currently unused */
+static unsigned char status_pc_to_mfc3(unsigned char status)
+{
+        unsigned char ret = 1;
+
+        if (status & PARPORT_STATUS_BUSY) /* Busy */
+                ret &= ~1;
+        if (status & PARPORT_STATUS_ACK) /* Ack */
+                ret |= 8;
+        if (status & PARPORT_STATUS_PAPEROUT) /* PaperOut */
+                ret |= 2;
+        if (status & PARPORT_STATUS_SELECT) /* select */
+                ret |= 4;
+        if (status & PARPORT_STATUS_ERROR) /* error */
+                ret |= 16;
+        return ret;
+}
+#endif
+
 static unsigned char status_mfc3_to_pc(unsigned char status)
 {
         unsigned char ret = PARPORT_STATUS_BUSY;
@@ -165,6 +184,14 @@ static unsigned char status_mfc3_to_pc(unsigned char status)
         return ret;
 }
 
+#if 0 /* currently unused */
+static void mfc3_write_status( struct parport *p, unsigned char status)
+{
+DPRINTK(KERN_DEBUG "write_status %02x\n",status);
+        pia(p)->ppra = (pia(p)->ppra & 0xe0) | status_pc_to_mfc3(status);
+}
+#endif
+
 static unsigned char mfc3_read_status(struct parport *p)
 {
         unsigned char status;
@@ -174,6 +201,14 @@ DPRINTK(KERN_DEBUG "read_status %02x\n", status);
         return status;
 }
 
+#if 0 /* currently unused */
+static void mfc3_change_mode( struct parport *p, int m)
+{
+        /* XXX: This port only has one mode, and I am
+        not sure about the corresponding PC-style mode*/
+}
+#endif
+
 static int use_cnt = 0;
 
 static irqreturn_t mfc3_interrupt(int irq, void *dev_id)
@@ -362,7 +397,7 @@ static void __exit parport_mfc3_exit(void)
 
 
 MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");
-MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Parallel Port");
+MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Paralllel Port");
 MODULE_SUPPORTED_DEVICE("Multiface 3 Parallel Port");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 903e1285fda..d1cdb9449f8 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -197,6 +197,54 @@ static int change_mode(struct parport *p, int m)
         ECR_WRITE(p, oecr);
         return 0;
 }
+
+#ifdef CONFIG_PARPORT_1284
+/* Find FIFO lossage; FIFO is reset */
+#if 0
+static int get_fifo_residue(struct parport *p)
+{
+        int residue;
+        int cnfga;
+        const struct parport_pc_private *priv = p->physport->private_data;
+
+        /* Adjust for the contents of the FIFO. */
+        for (residue = priv->fifo_depth; ; residue--) {
+                if (inb(ECONTROL(p)) & 0x2)
+                                /* Full up. */
+                        break;
+
+                outb(0, FIFO(p));
+        }
+
+        printk(KERN_DEBUG "%s: %d PWords were left in FIFO\n", p->name,
+                residue);
+
+        /* Reset the FIFO. */
+        frob_set_mode(p, ECR_PS2);
+
+        /* Now change to config mode and clean up. FIXME */
+        frob_set_mode(p, ECR_CNF);
+        cnfga = inb(CONFIGA(p));
+        printk(KERN_DEBUG "%s: cnfgA contains 0x%02x\n", p->name, cnfga);
+
+        if (!(cnfga & (1<<2))) {
+                printk(KERN_DEBUG "%s: Accounting for extra byte\n", p->name);
+                residue++;
+        }
+
+        /* Don't care about partial PWords until support is added for
+         * PWord != 1 byte. */
+
+        /* Back to PS2 mode. */
+        frob_set_mode(p, ECR_PS2);
+
+        DPRINTK(KERN_DEBUG
+             "*** get_fifo_residue: done residue collecting (ecr = 0x%2.2x)\n",
+                                                        inb(ECONTROL(p)));
+        return residue;
+}
+#endif  /*  0 */
+#endif /* IEEE 1284 support */
 #endif /* FIFO support */
 
 /*
@@ -892,6 +940,234 @@ static size_t parport_pc_ecp_write_block_pio(struct parport *port,
 
         return written;
 }
+
+#if 0
+static size_t parport_pc_ecp_read_block_pio(struct parport *port,
+                                             void *buf, size_t length,
+                                             int flags)
+{
+        size_t left = length;
+        size_t fifofull;
+        int r;
+        const int fifo = FIFO(port);
+        const struct parport_pc_private *priv = port->physport->private_data;
+        const int fifo_depth = priv->fifo_depth;
+        char *bufp = buf;
+
+        port = port->physport;
+        DPRINTK(KERN_DEBUG "parport_pc: parport_pc_ecp_read_block_pio\n");
+        dump_parport_state("enter fcn", port);
+
+        /* Special case: a timeout of zero means we cannot call schedule().
+         * Also if O_NONBLOCK is set then use the default implementation. */
+        if (port->cad->timeout <= PARPORT_INACTIVITY_O_NONBLOCK)
+                return parport_ieee1284_ecp_read_data(port, buf,
+                                                       length, flags);
+
+        if (port->ieee1284.mode == IEEE1284_MODE_ECPRLE) {
+                /* If the peripheral is allowed to send RLE compressed
+                 * data, it is possible for a byte to expand to 128
+                 * bytes in the FIFO. */
+                fifofull = 128;
+        } else {
+                fifofull = fifo_depth;
+        }
+
+        /* If the caller wants less than a full FIFO's worth of data,
+         * go through software emulation.  Otherwise we may have to throw
+         * away data. */
+        if (length < fifofull)
+                return parport_ieee1284_ecp_read_data(port, buf,
+                                                       length, flags);
+
+        if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE) {
+                /* change to reverse-idle phase (must be in forward-idle) */
+
+                /* Event 38: Set nAutoFd low (also make sure nStrobe is high) */
+                parport_frob_control(port,
+                                      PARPORT_CONTROL_AUTOFD
+                                      | PARPORT_CONTROL_STROBE,
+                                      PARPORT_CONTROL_AUTOFD);
+                parport_pc_data_reverse(port); /* Must be in PS2 mode */
+                udelay(5);
+                /* Event 39: Set nInit low to initiate bus reversal */
+                parport_frob_control(port,
+                                      PARPORT_CONTROL_INIT,
+                                      0);
+                /* Event 40: Wait for  nAckReverse (PError) to go low */
+                r = parport_wait_peripheral(port, PARPORT_STATUS_PAPEROUT, 0);
+                if (r) {
+                        printk(KERN_DEBUG "%s: PE timeout Event 40 (%d) "
+                                "in ecp_read_block_pio\n", port->name, r);
+                        return 0;
+                }
+        }
+
+        /* Set up ECP FIFO mode.*/
+/*      parport_pc_frob_control(port,
+                                 PARPORT_CONTROL_STROBE |
+                                 PARPORT_CONTROL_AUTOFD,
+                                 PARPORT_CONTROL_AUTOFD); */
+        r = change_mode(port, ECR_ECP); /* ECP FIFO */
+        if (r)
+                printk(KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n",
+                                                                port->name);
+
+        port->ieee1284.phase = IEEE1284_PH_REV_DATA;
+
+        /* the first byte must be collected manually */
+        dump_parport_state("pre 43", port);
+        /* Event 43: Wait for nAck to go low */
+        r = parport_wait_peripheral(port, PARPORT_STATUS_ACK, 0);
+        if (r) {
+                /* timed out while reading -- no data */
+                printk(KERN_DEBUG "PIO read timed out (initial byte)\n");
+                goto out_no_data;
+        }
+        /* read byte */
+        *bufp++ = inb(DATA(port));
+        left--;
+        dump_parport_state("43-44", port);
+        /* Event 44: nAutoFd (HostAck) goes high to acknowledge */
+        parport_pc_frob_control(port,
+                                 PARPORT_CONTROL_AUTOFD,
+                                 0);
+        dump_parport_state("pre 45", port);
+        /* Event 45: Wait for nAck to go high */
+        /* r = parport_wait_peripheral(port, PARPORT_STATUS_ACK,
+                                                PARPORT_STATUS_ACK); */
+        dump_parport_state("post 45", port);
+        r = 0;
+        if (r) {
+                /* timed out while waiting for peripheral to respond to ack */
+                printk(KERN_DEBUG "ECP PIO read timed out (waiting for nAck)\n");
+
+                /* keep hold of the byte we've got already */
+                goto out_no_data;
+        }
+        /* Event 46: nAutoFd (HostAck) goes low to accept more data */
+        parport_pc_frob_control(port,
+                                 PARPORT_CONTROL_AUTOFD,
+                                 PARPORT_CONTROL_AUTOFD);
+
+
+        dump_parport_state("rev idle", port);
+        /* Do the transfer. */
+        while (left > fifofull) {
+                int ret;
+                unsigned long expire = jiffies + port->cad->timeout;
+                unsigned char ecrval = inb(ECONTROL(port));
+
+                if (need_resched() && time_before(jiffies, expire))
+                        /* Can't yield the port. */
+                        schedule();
+
+                /* At this point, the FIFO may already be full. In
+                 * that case ECP is already holding back the
+                 * peripheral (assuming proper design) with a delayed
+                 * handshake.  Work fast to avoid a peripheral
+                 * timeout.  */
+
+                if (ecrval & 0x01) {
+                        /* FIFO is empty. Wait for interrupt. */
+                        dump_parport_state("FIFO empty", port);
+
+                        /* Anyone else waiting for the port? */
+                        if (port->waithead) {
+                                printk(KERN_DEBUG "Somebody wants the port\n");
+                                break;
+                        }
+
+                        /* Clear serviceIntr */
+                        ECR_WRITE(port, ecrval & ~(1<<2));
+false_alarm:
+                        dump_parport_state("waiting", port);
+                        ret = parport_wait_event(port, HZ);
+                        DPRINTK(KERN_DEBUG "parport_wait_event returned %d\n",
+                                                                        ret);
+                        if (ret < 0)
+                                break;
+                        ret = 0;
+                        if (!time_before(jiffies, expire)) {
+                                /* Timed out. */
+                                dump_parport_state("timeout", port);
+                                printk(KERN_DEBUG "PIO read timed out\n");
+                                break;
+                        }
+                        ecrval = inb(ECONTROL(port));
+                        if (!(ecrval & (1<<2))) {
+                                if (need_resched() &&
+                                    time_before(jiffies, expire)) {
+                                        schedule();
+                                }
+                                goto false_alarm;
+                        }
+
+                        /* Depending on how the FIFO threshold was
+                         * set, how long interrupt service took, and
+                         * how fast the peripheral is, we might be
+                         * lucky and have a just filled FIFO. */
+                        continue;
+                }
+
+                if (ecrval & 0x02) {
+                        /* FIFO is full. */
+                        dump_parport_state("FIFO full", port);
+                        insb(fifo, bufp, fifo_depth);
+                        bufp += fifo_depth;
+                        left -= fifo_depth;
+                        continue;
+                }
+
+                DPRINTK(KERN_DEBUG
+                  "*** ecp_read_block_pio: reading one byte from the FIFO\n");
+
+                /* FIFO not filled.  We will cycle this loop for a while
+                 * and either the peripheral will fill it faster,
+                 * tripping a fast empty with insb, or we empty it. */
+                *bufp++ = inb(fifo);
+                left--;
+        }
+
+        /* scoop up anything left in the FIFO */
+        while (left && !(inb(ECONTROL(port) & 0x01))) {
+                *bufp++ = inb(fifo);
+                left--;
+        }
+
+        port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
+        dump_parport_state("rev idle2", port);
+
+out_no_data:
+
+        /* Go to forward idle mode to shut the peripheral up (event 47). */
+        parport_frob_control(port, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
+
+        /* event 49: PError goes high */
+        r = parport_wait_peripheral(port,
+                                     PARPORT_STATUS_PAPEROUT,
+                                     PARPORT_STATUS_PAPEROUT);
+        if (r) {
+                printk(KERN_DEBUG
+                        "%s: PE timeout FWDIDLE (%d) in ecp_read_block_pio\n",
+                        port->name, r);
+        }
+
+        port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
+
+        /* Finish up. */
+        {
+                int lost = get_fifo_residue(port);
+                if (lost)
+                        /* Shouldn't happen with compliant peripherals. */
+                        printk(KERN_DEBUG "%s: DATA LOSS (%d bytes)!\n",
+                                port->name, lost);
+        }
+
+        dump_parport_state("fwd idle", port);
+        return length - left;
+}
+#endif  /*  0  */
 #endif /* IEEE 1284 support */
 #endif /* Allowed to use FIFO/DMA */
 
@@ -953,7 +1229,7 @@ static struct superio_struct *find_free_superio(void)
 
 
 /* Super-IO chipset detection, Winbond, SMSC */
-static void show_parconfig_smsc37c669(int io, int key)
+static void __devinit show_parconfig_smsc37c669(int io, int key)
 {
         int cr1, cr4, cra, cr23, cr26, cr27;
         struct superio_struct *s;
@@ -1038,7 +1314,7 @@ static void show_parconfig_smsc37c669(int io, int key)
 }
 
 
-static void show_parconfig_winbond(int io, int key)
+static void __devinit show_parconfig_winbond(int io, int key)
 {
         int cr30, cr60, cr61, cr70, cr74, crf0;
         struct superio_struct *s;
@@ -1106,7 +1382,8 @@ static void show_parconfig_winbond(int io, int key)
         }
 }
 
-static void decode_winbond(int efer, int key, int devid, int devrev, int oldid)
+static void __devinit decode_winbond(int efer, int key, int devid,
+                                                        int devrev, int oldid)
 {
         const char *type = "unknown";
         int id, progif = 2;
@@ -1158,7 +1435,7 @@ static void decode_winbond(int efer, int key, int devid, int devrev, int oldid)
                 show_parconfig_winbond(efer, key);
 }
 
-static void decode_smsc(int efer, int key, int devid, int devrev)
+static void __devinit decode_smsc(int efer, int key, int devid, int devrev)
 {
         const char *type = "unknown";
         void (*func)(int io, int key);
@@ -1192,7 +1469,7 @@ static void decode_smsc(int efer, int key, int devid, int devrev)
 }
 
 
-static void winbond_check(int io, int key)
+static void __devinit winbond_check(int io, int key)
 {
         int origval, devid, devrev, oldid, x_devid, x_devrev, x_oldid;
 
@@ -1230,7 +1507,7 @@ out:
         release_region(io, 3);
 }
 
-static void winbond_check2(int io, int key)
+static void __devinit winbond_check2(int io, int key)
 {
         int origval[3], devid, devrev, oldid, x_devid, x_devrev, x_oldid;
 
@@ -1271,7 +1548,7 @@ out:
         release_region(io, 3);
 }
 
-static void smsc_check(int io, int key)
+static void __devinit smsc_check(int io, int key)
 {
         int origval, id, rev, oldid, oldrev, x_id, x_rev, x_oldid, x_oldrev;
 
@@ -1315,7 +1592,7 @@ out:
 }
 
 
-static void detect_and_report_winbond(void)
+static void __devinit detect_and_report_winbond(void)
 {
         if (verbose_probing)
                 printk(KERN_DEBUG "Winbond Super-IO detection, now testing ports 3F0,370,250,4E,2E ...\n");
@@ -1328,7 +1605,7 @@ static void detect_and_report_winbond(void)
         winbond_check2(0x250, 0x89);
 }
 
-static void detect_and_report_smsc(void)
+static void __devinit detect_and_report_smsc(void)
 {
         if (verbose_probing)
                 printk(KERN_DEBUG "SMSC Super-IO detection, now testing Ports 2F0, 370 ...\n");
@@ -1338,7 +1615,7 @@ static void detect_and_report_smsc(void)
         smsc_check(0x370, 0x44);
 }
 
-static void detect_and_report_it87(void)
+static void __devinit detect_and_report_it87(void)
 {
         u16 dev;
         u8 origval, r;
@@ -1795,24 +2072,24 @@ static int parport_ECPEPP_supported(struct parport *pb)
 #else /* No IEEE 1284 support */
 
 /* Don't bother probing for modes we know we won't use. */
-static int parport_PS2_supported(struct parport *pb) { return 0; }
+static int __devinit parport_PS2_supported(struct parport *pb) { return 0; }
 #ifdef CONFIG_PARPORT_PC_FIFO
 static int parport_ECP_supported(struct parport *pb)
 {
         return 0;
 }
 #endif
-static int parport_EPP_supported(struct parport *pb)
+static int __devinit parport_EPP_supported(struct parport *pb)
 {
         return 0;
 }
 
-static int parport_ECPEPP_supported(struct parport *pb)
+static int __devinit parport_ECPEPP_supported(struct parport *pb)
 {
         return 0;
 }
 
-static int parport_ECPPS2_supported(struct parport *pb)
+static int __devinit parport_ECPPS2_supported(struct parport *pb)
 {
         return 0;
 }
@@ -2074,7 +2351,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
 
         printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base);
         if (p->base_hi && priv->ecr)
-                printk(KERN_CONT " (0x%lx)", p->base_hi);
+                printk(" (0x%lx)", p->base_hi);
         if (p->irq == PARPORT_IRQ_AUTO) {
                 p->irq = PARPORT_IRQ_NONE;
                 parport_irq_probe(p);
@@ -2085,7 +2362,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                 p->irq = PARPORT_IRQ_NONE;
         }
         if (p->irq != PARPORT_IRQ_NONE) {
-                printk(KERN_CONT ", irq %d", p->irq);
+                printk(", irq %d", p->irq);
                 priv->ctr_writable |= 0x10;
 
                 if (p->dma == PARPORT_DMA_AUTO) {
@@ -2109,21 +2386,21 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                 /* p->ops->ecp_read_data = parport_pc_ecp_read_block_pio; */
 #endif /* IEEE 1284 support */
                 if (p->dma != PARPORT_DMA_NONE) {
-                        printk(KERN_CONT ", dma %d", p->dma);
+                        printk(", dma %d", p->dma);
                         p->modes |= PARPORT_MODE_DMA;
                 } else
-                        printk(KERN_CONT ", using FIFO");
+                        printk(", using FIFO");
         } else
                 /* We can't use the DMA channel after all. */
                 p->dma = PARPORT_DMA_NONE;
 #endif /* Allowed to use FIFO/DMA */
 
-        printk(KERN_CONT " [");
+        printk(" [");
 
 #define printmode(x) \
         {\
                 if (p->modes & PARPORT_MODE_##x) {\
-                        printk(KERN_CONT "%s%s", f ? "," : "", #x);\
+                        printk("%s%s", f ? "," : "", #x);\
                         f++;\
                 } \
         }
@@ -2139,9 +2416,9 @@ struct parport *parport_pc_probe_port(unsigned long int base,
         }
 #undef printmode
 #ifndef CONFIG_PARPORT_1284
-        printk(KERN_CONT "(,...)");
+        printk("(,...)");
 #endif /* CONFIG_PARPORT_1284 */
-        printk(KERN_CONT "]\n");
+        printk("]\n");
         if (probedirq != PARPORT_IRQ_NONE)
                 printk(KERN_INFO "%s: irq %d detected\n", p->name, probedirq);
 
@@ -2268,8 +2545,9 @@ EXPORT_SYMBOL(parport_pc_unregister_port);
 #ifdef CONFIG_PCI
 
 /* ITE support maintained by Rich Liu <richliu@poorman.org> */
-static int sio_ite_8872_probe(struct pci_dev *pdev, int autoirq, int autodma,
-                              const struct parport_pc_via_data *via)
+static int __devinit sio_ite_8872_probe(struct pci_dev *pdev, int autoirq,
+                                         int autodma,
+                                         const struct parport_pc_via_data *via)
 {
         short inta_addr[6] = { 0x2A0, 0x2C0, 0x220, 0x240, 0x1E0 };
         u32 ite8872set;
@@ -2317,17 +2595,14 @@ static int sio_ite_8872_probe(struct pci_dev *pdev, int autoirq, int autodma,
                 break;
         case 0x6:
                 printk(KERN_INFO "parport_pc: ITE8873 found (1S)\n");
-                release_region(inta_addr[i], 32);
                 return 0;
         case 0x8:
                 printk(KERN_INFO "parport_pc: ITE8874 found (2S)\n");
-                release_region(inta_addr[i], 32);
                 return 0;
         default:
                 printk(KERN_INFO "parport_pc: unknown ITE887x\n");
                 printk(KERN_INFO "parport_pc: please mail 'lspci -nvv' "
                         "output to Rich.Liu@ite.com.tw\n");
-                release_region(inta_addr[i], 32);
                 return 0;
         }
 
@@ -2375,10 +2650,10 @@ static int sio_ite_8872_probe(struct pci_dev *pdev, int autoirq, int autodma,
 
 /* VIA 8231 support by Pavel Fedin <sonic_amiga@rambler.ru>
    based on VIA 686a support code by Jeff Garzik <jgarzik@pobox.com> */
-static int parport_init_mode;
+static int __devinitdata parport_init_mode;
 
 /* Data for two known VIA chips */
-static struct parport_pc_via_data via_686a_data = {
+static struct parport_pc_via_data via_686a_data __devinitdata = {
         0x51,
         0x50,
         0x85,
@@ -2387,7 +2662,7 @@ static struct parport_pc_via_data via_686a_data = {
         0xF0,
         0xE6
 };
-static struct parport_pc_via_data via_8231_data = {
+static struct parport_pc_via_data via_8231_data __devinitdata = {
         0x45,
         0x44,
         0x50,
@@ -2397,8 +2672,9 @@ static struct parport_pc_via_data via_8231_data = {
         0xF6
 };
 
-static int sio_via_probe(struct pci_dev *pdev, int autoirq, int autodma,
-                         const struct parport_pc_via_data *via)
+static int __devinit sio_via_probe(struct pci_dev *pdev, int autoirq,
+                                    int autodma,
+                                    const struct parport_pc_via_data *via)
 {
         u8 tmp, tmp2, siofunc;
         u8 ppcontrol = 0;
@@ -2572,7 +2848,7 @@ static struct parport_pc_superio {
         int (*probe) (struct pci_dev *pdev, int autoirq, int autodma,
                       const struct parport_pc_via_data *via);
         const struct parport_pc_via_data *via;
-} parport_pc_superio_info[] = {
+} parport_pc_superio_info[] __devinitdata = {
         { sio_via_probe, &via_686a_data, },
         { sio_via_probe, &via_8231_data, },
         { sio_ite_8872_probe, NULL, },
@@ -2857,7 +3133,7 @@ static int parport_pc_pci_probe(struct pci_dev *dev,
         return -ENODEV;
 }
 
-static void parport_pc_pci_remove(struct pci_dev *dev)
+static void __devexit parport_pc_pci_remove(struct pci_dev *dev)
 {
         struct pci_parport_data *data = pci_get_drvdata(dev);
         int i;
@@ -2876,7 +3152,7 @@ static struct pci_driver parport_pc_pci_driver = {
         .name           = "parport_pc",
         .id_table       = parport_pc_pci_tbl,
         .probe          = parport_pc_pci_probe,
-        .remove         = parport_pc_pci_remove,
+        .remove         = __devexit_p(parport_pc_pci_remove),
 };
 
 static int __init parport_pc_init_superio(int autoirq, int autodma)
@@ -2980,7 +3256,7 @@ static struct pnp_driver parport_pc_pnp_driver = {
 static struct pnp_driver parport_pc_pnp_driver;
 #endif /* CONFIG_PNP */
 
-static int parport_pc_platform_probe(struct platform_device *pdev)
+static int __devinit parport_pc_platform_probe(struct platform_device *pdev)
 {
         /* Always succeed, the actual probing is done in
          * parport_pc_probe_port(). */
@@ -2996,7 +3272,7 @@ static struct platform_driver parport_pc_platform_driver = {
 };
 
 /* This is called by parport_pc_find_nonpci_ports (in asm/parport.h) */
-static int __attribute__((unused))
+static int __devinit __attribute__((unused))
 parport_pc_find_isa_ports(int autoirq, int autodma)
 {
         int count = 0;
@@ -3125,8 +3401,8 @@ static int __init parport_init_mode_setup(char *str)
 #endif
 
 #ifdef MODULE
-static char *irq[PARPORT_PC_MAX_PORTS];
-static char *dma[PARPORT_PC_MAX_PORTS];
+static const char *irq[PARPORT_PC_MAX_PORTS];
+static const char *dma[PARPORT_PC_MAX_PORTS];
 
 MODULE_PARM_DESC(io, "Base I/O address (SPP regs)");
 module_param_array(io, int, NULL, 0);
diff --git a/drivers/parport/parport_serial.c b/drivers/parport/parport_serial.c
index ef6169adb84..e9c32274df3 100644
--- a/drivers/parport/parport_serial.c
+++ b/drivers/parport/parport_serial.c
@@ -62,7 +62,6 @@ enum parport_pc_pci_cards {
         timedia_9079a,
         timedia_9079b,
         timedia_9079c,
-        wch_ch353_2s1p,
 };
 
 /* each element directly indexed from enum list, above */
@@ -87,8 +86,7 @@ struct parport_pc_pci {
                                 struct parport_pc_pci *card, int failed);
 };
 
-static int netmos_parallel_init(struct pci_dev *dev, struct parport_pc_pci *par,
-                                int autoirq, int autodma)
+static int __devinit netmos_parallel_init(struct pci_dev *dev, struct parport_pc_pci *par, int autoirq, int autodma)
 {
         /* the rule described below doesn't hold for this device */
         if (dev->device == PCI_DEVICE_ID_NETMOS_9835 &&
@@ -112,7 +110,7 @@ static int netmos_parallel_init(struct pci_dev *dev, struct parport_pc_pci *par,
         return 0;
 }
 
-static struct parport_pc_pci cards[] = {
+static struct parport_pc_pci cards[] __devinitdata = {
         /* titan_110l */                { 1, { { 3, -1 }, } },
         /* titan_210l */                { 1, { { 3, -1 }, } },
         /* netmos_9xx5_combo */         { 1, { { 2, -1 }, }, netmos_parallel_init },
@@ -147,7 +145,6 @@ static struct parport_pc_pci cards[] = {
         /* timedia_9079a */             { 1, { { 2, 3 }, } },
         /* timedia_9079b */             { 1, { { 2, 3 }, } },
         /* timedia_9079c */             { 1, { { 2, 3 }, } },
-        /* wch_ch353_2s1p*/             { 1, { { 2, -1}, } },
 };
 
 static struct pci_device_id parport_serial_pci_tbl[] = {
@@ -246,8 +243,7 @@ static struct pci_device_id parport_serial_pci_tbl[] = {
         { 0x1409, 0x7168, 0x1409, 0xb079, 0, 0, timedia_9079a },
         { 0x1409, 0x7168, 0x1409, 0xc079, 0, 0, timedia_9079b },
         { 0x1409, 0x7168, 0x1409, 0xd079, 0, 0, timedia_9079c },
-        /* WCH CARDS */
-        { 0x4348, 0x7053, 0x4348, 0x3253, 0, 0, wch_ch353_2s1p},
+
         { 0, } /* terminate list */
 };
 MODULE_DEVICE_TABLE(pci,parport_serial_pci_tbl);
@@ -259,7 +255,7 @@ MODULE_DEVICE_TABLE(pci,parport_serial_pci_tbl);
  * Cards not tested are marked n/t
  * If you have one of these cards and it works for you, please tell me..
  */
-static struct pciserial_board pci_parport_serial_boards[] = {
+static struct pciserial_board pci_parport_serial_boards[] __devinitdata = {
         [titan_110l] = {
                 .flags          = FL_BASE1 | FL_BASE_BARS,
                 .num_ports      = 1,
@@ -464,12 +460,6 @@ static struct pciserial_board pci_parport_serial_boards[] = {
                 .base_baud      = 921600,
                 .uart_offset    = 8,
         },
-        [wch_ch353_2s1p] = {
-                .flags          = FL_BASE0|FL_BASE_BARS,
-                .num_ports      = 2,
-                .base_baud      = 115200,
-                .uart_offset    = 8,
-        },
 };
 
 struct parport_serial_private {
@@ -480,7 +470,8 @@ struct parport_serial_private {
 };
 
 /* Register the serial port(s) of a PCI card. */
-static int serial_register(struct pci_dev *dev, const struct pci_device_id *id)
+static int __devinit serial_register (struct pci_dev *dev,
+                                      const struct pci_device_id *id)
 {
         struct parport_serial_private *priv = pci_get_drvdata (dev);
         struct pciserial_board *board;
@@ -501,7 +492,8 @@ static int serial_register(struct pci_dev *dev, const struct pci_device_id *id)
 }
 
 /* Register the parallel port(s) of a PCI card. */
-static int parport_register(struct pci_dev *dev, const struct pci_device_id *id)
+static int __devinit parport_register (struct pci_dev *dev,
+                                       const struct pci_device_id *id)
 {
         struct parport_pc_pci *card;
         struct parport_serial_private *priv = pci_get_drvdata (dev);
@@ -562,8 +554,8 @@ static int parport_register(struct pci_dev *dev, const struct pci_device_id *id)
         return 0;
 }
 
-static int parport_serial_pci_probe(struct pci_dev *dev,
-                                    const struct pci_device_id *id)
+static int __devinit parport_serial_pci_probe (struct pci_dev *dev,
+                                               const struct pci_device_id *id)
 {
         struct parport_serial_private *priv;
         int err;
@@ -598,7 +590,7 @@ static int parport_serial_pci_probe(struct pci_dev *dev,
         return 0;
 }
 
-static void parport_serial_pci_remove(struct pci_dev *dev)
+static void __devexit parport_serial_pci_remove (struct pci_dev *dev)
 {
         struct parport_serial_private *priv = pci_get_drvdata (dev);
         int i;
@@ -663,7 +655,7 @@ static struct pci_driver parport_serial_pci_driver = {
         .name           = "parport_serial",
         .id_table       = parport_serial_pci_tbl,
         .probe          = parport_serial_pci_probe,
-        .remove         = parport_serial_pci_remove,
+        .remove         = __devexit_p(parport_serial_pci_remove),
 #ifdef CONFIG_PM
         .suspend        = parport_serial_pci_suspend,
         .resume         = parport_serial_pci_resume,
diff --git a/drivers/parport/parport_sunbpp.c b/drivers/parport/parport_sunbpp.c
index 5c4b6a1db6c..910c5a26e34 100644
--- a/drivers/parport/parport_sunbpp.c
+++ b/drivers/parport/parport_sunbpp.c
@@ -82,6 +82,27 @@ static unsigned char parport_sunbpp_read_data(struct parport *p)
         return sbus_readb(&regs->p_dr);
 }
 
+#if 0
+static void control_pc_to_sunbpp(struct parport *p, unsigned char status)
+{
+        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
+        unsigned char value_tcr = sbus_readb(&regs->p_tcr);
+        unsigned char value_or = sbus_readb(&regs->p_or);
+
+        if (status & PARPORT_CONTROL_STROBE) 
+                value_tcr |= P_TCR_DS;
+        if (status & PARPORT_CONTROL_AUTOFD) 
+                value_or |= P_OR_AFXN;
+        if (status & PARPORT_CONTROL_INIT) 
+                value_or |= P_OR_INIT;
+        if (status & PARPORT_CONTROL_SELECT) 
+                value_or |= P_OR_SLCT_IN;
+
+        sbus_writeb(value_or, &regs->p_or);
+        sbus_writeb(value_tcr, &regs->p_tcr);
+}
+#endif
+
 static unsigned char status_sunbpp_to_pc(struct parport *p)
 {
         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
@@ -265,7 +286,7 @@ static struct parport_operations parport_sunbpp_ops =
         .owner          = THIS_MODULE,
 };
 
-static int bpp_probe(struct platform_device *op)
+static int __devinit bpp_probe(struct platform_device *op)
 {
         struct parport_operations *ops;
         struct bpp_regs __iomem *regs;
@@ -330,7 +351,7 @@ out_unmap:
         return err;
 }
 
-static int bpp_remove(struct platform_device *op)
+static int __devexit bpp_remove(struct platform_device *op)
 {
         struct parport *p = dev_get_drvdata(&op->dev);
         struct parport_operations *ops = p->ops;
@@ -367,13 +388,24 @@ static struct platform_driver bpp_sbus_driver = {
                 .of_match_table = bpp_match,
         },
         .probe          = bpp_probe,
-        .remove         = bpp_remove,
+        .remove         = __devexit_p(bpp_remove),
 };
 
-module_platform_driver(bpp_sbus_driver);
+static int __init parport_sunbpp_init(void)
+{
+        return platform_driver_register(&bpp_sbus_driver);
+}
+
+static void __exit parport_sunbpp_exit(void)
+{
+        platform_driver_unregister(&bpp_sbus_driver);
+}
 
 MODULE_AUTHOR("Derrick J Brashear");
 MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
 MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
 MODULE_VERSION("2.0");
 MODULE_LICENSE("GPL");
+
+module_init(parport_sunbpp_init)
+module_exit(parport_sunbpp_exit)