MIPS: Alchemy: use 36bit addresses for PCMCIA resources.

[safe/jmp/linux-2.6] / drivers / pcmcia / m32r_pcc.c

diff --git a/drivers/pcmcia/m32r_pcc.c b/drivers/pcmcia/m32r_pcc.c
index 0964fd7..72844c5 100644 (file)
--- a/drivers/pcmcia/m32r_pcc.c
+++ b/drivers/pcmcia/m32r_pcc.c
@@ -16,16 +16,15 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
+#include <linux/bitops.h>
 #include <asm/irq.h>
 #include <asm/io.h>
-#include <asm/bitops.h>
 #include <asm/system.h>
 #include <asm/addrspace.h>
 
@@ -46,16 +45,6 @@
 
 #define PCC_DEBUG_DBEX
 
-#ifdef DEBUG
-static int m32r_pcc_debug;
-module_param(m32r_pcc_debug, int, 0644);
-#define debug(lvl, fmt, arg...) do {                           \
-       if (m32r_pcc_debug > (lvl))                             \
-               printk(KERN_DEBUG "m32r_pcc: " fmt , ## arg);   \
-} while (0)
-#else
-#define debug(n, args...) do { } while (0)
-#endif
 
 /* Poll status interval -- 0 means default to interrupt */
 static int poll_interval = 0;
@@ -66,7 +55,7 @@ typedef struct pcc_socket {
        u_short                 type, flags;
        struct pcmcia_socket    socket;
        unsigned int            number;
-       kio_addr_t              ioaddr;
+       unsigned int            ioaddr;
        u_long                  mapaddr;
        u_long                  base;   /* PCC register base */
        u_char                  cs_irq, intr;
@@ -311,7 +300,8 @@ static int __init is_alive(u_short sock)
        return 0;
 }
 
-static void add_pcc_socket(ulong base, int irq, ulong mapaddr, kio_addr_t ioaddr)
+static void add_pcc_socket(ulong base, int irq, ulong mapaddr,
+                          unsigned int ioaddr)
 {
        pcc_socket_t *t = &socket[pcc_sockets];
 
@@ -358,7 +348,7 @@ static irqreturn_t pcc_interrupt(int irq, void *dev)
        u_int events, active;
        int handled = 0;
 
-       debug(4, "m32r: pcc_interrupt(%d)\n", irq);
+       pr_debug("m32r_pcc: pcc_interrupt(%d)\n", irq);
 
        for (j = 0; j < 20; j++) {
                active = 0;
@@ -369,13 +359,14 @@ static irqreturn_t pcc_interrupt(int irq, void *dev)
                        handled = 1;
                        irc = pcc_get(i, PCIRC);
                        irc >>=16;
-                       debug(2, "m32r-pcc:interrput: socket %d pcirc 0x%02x ", i, irc);
+                       pr_debug("m32r_pcc: interrupt: socket %d pcirc 0x%02x ",
+                               i, irc);
                        if (!irc)
                                continue;
 
                        events = (irc) ? SS_DETECT : 0;
                        events |= (pcc_get(i,PCCR) & PCCR_PCEN) ? SS_READY : 0;
-                       debug(2, " event 0x%02x\n", events);
+                       pr_debug("m32r_pcc: event 0x%02x\n", events);
 
                        if (events)
                                pcmcia_parse_events(&socket[i].socket, events);
@@ -388,14 +379,14 @@ static irqreturn_t pcc_interrupt(int irq, void *dev)
        if (j == 20)
                printk(KERN_NOTICE "m32r-pcc: infinite loop in interrupt handler\n");
 
-       debug(4, "m32r-pcc: interrupt done\n");
+       pr_debug("m32r_pcc: interrupt done\n");
 
        return IRQ_RETVAL(handled);
 } /* pcc_interrupt */
 
 static void pcc_interrupt_wrapper(u_long data)
 {
-       pcc_interrupt(0, NULL, NULL);
+       pcc_interrupt(0, NULL);
        init_timer(&poll_timer);
        poll_timer.expires = jiffies + poll_interval;
        add_timer(&poll_timer);
@@ -422,7 +413,7 @@ static int _pcc_get_status(u_short sock, u_int *value)
        status = pcc_get(sock,PCCSIGCR);
        *value |= (status & PCCSIGCR_VEN) ? SS_POWERON : 0;
 
-       debug(3, "m32r-pcc: GetStatus(%d) = %#4.4x\n", sock, *value);
+       pr_debug("m32r_pcc: GetStatus(%d) = %#4.4x\n", sock, *value);
        return 0;
 } /* _get_status */
 
@@ -432,7 +423,7 @@ static int _pcc_set_socket(u_short sock, socket_state_t *state)
 {
        u_long reg = 0;
 
-       debug(3, "m32r-pcc: SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
+       pr_debug("m32r_pcc: SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
                  "io_irq %d, csc_mask %#2.2x)", sock, state->flags,
                  state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
 
@@ -448,11 +439,11 @@ static int _pcc_set_socket(u_short sock, socket_state_t *state)
        }
 
        if (state->flags & SS_RESET) {
-               debug(3, ":RESET\n");
+               pr_debug("m32r_pcc: :RESET\n");
                reg |= PCCSIGCR_CRST;
        }
        if (state->flags & SS_OUTPUT_ENA){
-               debug(3, ":OUTPUT_ENA\n");
+               pr_debug("m32r_pcc: :OUTPUT_ENA\n");
                /* bit clear */
        } else {
                reg |= PCCSIGCR_SEN;
@@ -460,28 +451,26 @@ static int _pcc_set_socket(u_short sock, socket_state_t *state)
 
        pcc_set(sock,PCCSIGCR,reg);
 
-#ifdef DEBUG
        if(state->flags & SS_IOCARD){
-               debug(3, ":IOCARD");
+               pr_debug("m32r_pcc: :IOCARD");
        }
        if (state->flags & SS_PWR_AUTO) {
-               debug(3, ":PWR_AUTO");
+               pr_debug("m32r_pcc: :PWR_AUTO");
        }
        if (state->csc_mask & SS_DETECT)
-               debug(3, ":csc-SS_DETECT");
+               pr_debug("m32r_pcc: :csc-SS_DETECT");
        if (state->flags & SS_IOCARD) {
                if (state->csc_mask & SS_STSCHG)
-                       debug(3, ":STSCHG");
+                       pr_debug("m32r_pcc: :STSCHG");
        } else {
                if (state->csc_mask & SS_BATDEAD)
-                       debug(3, ":BATDEAD");
+                       pr_debug("m32r_pcc: :BATDEAD");
                if (state->csc_mask & SS_BATWARN)
-                       debug(3, ":BATWARN");
+                       pr_debug("m32r_pcc: :BATWARN");
                if (state->csc_mask & SS_READY)
-                       debug(3, ":READY");
+                       pr_debug("m32r_pcc: :READY");
        }
-       debug(3, "\n");
-#endif
+       pr_debug("m32r_pcc: \n");
        return 0;
 } /* _set_socket */
 
@@ -491,9 +480,10 @@ static int _pcc_set_io_map(u_short sock, struct pccard_io_map *io)
 {
        u_char map;
 
-       debug(3, "m32r-pcc: SetIOMap(%d, %d, %#2.2x, %d ns, "
-                 "%#lx-%#lx)\n", sock, io->map, io->flags,
-                 io->speed, io->start, io->stop);
+       pr_debug("m32r_pcc: SetIOMap(%d, %d, %#2.2x, %d ns, "
+                 "%#llx-%#llx)\n", sock, io->map, io->flags,
+                 io->speed, (unsigned long long)io->start,
+                 (unsigned long long)io->stop);
        map = io->map;
 
        return 0;
@@ -514,9 +504,10 @@ static int _pcc_set_mem_map(u_short sock, struct pccard_mem_map *mem)
 #endif
 #endif
 
-       debug(3, "m32r-pcc: SetMemMap(%d, %d, %#2.2x, %d ns, "
-                "%#lx,  %#x)\n", sock, map, mem->flags,
-                mem->speed, mem->static_start, mem->card_start);
+       pr_debug("m32r_pcc: SetMemMap(%d, %d, %#2.2x, %d ns, "
+                "%#llx,  %#x)\n", sock, map, mem->flags,
+                mem->speed, (unsigned long long)mem->static_start,
+                mem->card_start);
 
        /*
         * sanity check
@@ -660,7 +651,7 @@ static int pcc_set_mem_map(struct pcmcia_socket *s, struct pccard_mem_map *mem)
 
 static int pcc_init(struct pcmcia_socket *s)
 {
-       debug(4, "m32r-pcc: init call\n");
+       pr_debug("m32r_pcc: init call\n");
        return 0;
 }
 
@@ -672,13 +663,25 @@ static struct pccard_operations pcc_operations = {
        .set_mem_map            = pcc_set_mem_map,
 };
 
+static int pcc_drv_pcmcia_suspend(struct platform_device *dev,
+                                    pm_message_t state)
+{
+       return pcmcia_socket_dev_suspend(&dev->dev);
+}
+
+static int pcc_drv_pcmcia_resume(struct platform_device *dev)
+{
+       return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
 
-static struct device_driver pcc_driver = {
-       .name = "pcc",
-       .bus = &platform_bus_type,
-       .suspend = pcmcia_socket_dev_suspend,
-       .resume = pcmcia_socket_dev_resume,
+static struct platform_driver pcc_driver = {
+       .driver = {
+               .name           = "pcc",
+               .owner          = THIS_MODULE,
+       },
+       .suspend        = pcc_drv_pcmcia_suspend,
+       .resume         = pcc_drv_pcmcia_resume,
 };
 
 static struct platform_device pcc_device = {
@@ -692,13 +695,13 @@ static int __init init_m32r_pcc(void)
 {
        int i, ret;
 
-       ret = driver_register(&pcc_driver);
+       ret = platform_driver_register(&pcc_driver);
        if (ret)
                return ret;
 
        ret = platform_device_register(&pcc_device);
        if (ret){
-               driver_unregister(&pcc_driver);
+               platform_driver_unregister(&pcc_driver);
                return ret;
        }
 
@@ -715,14 +718,14 @@ static int __init init_m32r_pcc(void)
        if (pcc_sockets == 0) {
                printk("socket is not found.\n");
                platform_device_unregister(&pcc_device);
-               driver_unregister(&pcc_driver);
+               platform_driver_unregister(&pcc_driver);
                return -ENODEV;
        }
 
        /* Set up interrupt handler(s) */
 
        for (i = 0 ; i < pcc_sockets ; i++) {
-               socket[i].socket.dev.dev = &pcc_device.dev;
+               socket[i].socket.dev.parent = &pcc_device.dev;
                socket[i].socket.ops = &pcc_operations;
                socket[i].socket.resource_ops = &pccard_static_ops;
                socket[i].socket.owner = THIS_MODULE;
@@ -763,7 +766,7 @@ static void __exit exit_m32r_pcc(void)
        if (poll_interval != 0)
                del_timer_sync(&poll_timer);
 
-       driver_unregister(&pcc_driver);
+       platform_driver_unregister(&pcc_driver);
 } /* exit_m32r_pcc */
 
 module_init(init_m32r_pcc);