Pull pnpacpi into acpica branch

24 files changed, 315 insertions, 402 deletions

diff --git a/drivers/char/.gitignore b/drivers/char/.gitignore
index 2b6b1d772ed7..73dfdcebfbba 100644
--- a/drivers/char/.gitignore
+++ b/drivers/char/.gitignore
@@ -1,3 +1,3 @@
 consolemap_deftbl.c
 defkeymap.c
-
+qtronixmap.c
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 970f70d498f4..5ebd06b1b4ca 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -687,7 +687,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC32 && !PARISC && !IA64 && !M68K
+        depends on !PPC32 && !PARISC && !IA64 && !M68K && (!SPARC || PCI)
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
@@ -735,7 +735,7 @@ config SGI_IP27_RTC
 
 config GEN_RTC
         tristate "Generic /dev/rtc emulation"
-        depends on RTC!=y && !IA64 && !ARM && !M32R && !SPARC32 && !SPARC64
+        depends on RTC!=y && !IA64 && !ARM && !M32R && !SPARC
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
@@ -943,6 +943,15 @@ config RAW_DRIVER
           Applications should simply open the device (eg /dev/hda1)
           with the O_DIRECT flag.
 
+config MAX_RAW_DEVS
+        int "Maximum number of RAW devices to support (1-8192)"
+        depends on RAW_DRIVER
+        default "256"
+        help
+          The maximum number of RAW devices that are supported.
+          Default is 256. Increase this number in case you need lots of
+          raw devices.
+
 config HPET
         bool "HPET - High Precision Event Timer" if (X86 || IA64)
         default n
@@ -974,18 +983,9 @@ config HPET_MMAP
           exposed to the user.  If this applies to your hardware,
           say N here.
 
-config MAX_RAW_DEVS
-        int "Maximum number of RAW devices to support (1-8192)"
-        depends on RAW_DRIVER
-        default "256"
-        help
-          The maximum number of RAW devices that are supported.
-          Default is 256. Increase this number in case you need lots of
-          raw devices.
-
 config HANGCHECK_TIMER
         tristate "Hangcheck timer"
-        depends on X86 || IA64 || PPC64 || ARCH_S390
+        depends on X86 || IA64 || PPC64 || S390
         help
           The hangcheck-timer module detects when the system has gone
           out to lunch past a certain margin.  It can reboot the system
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 03839ea31092..342302d46743 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -1311,7 +1311,7 @@ static void radeon_set_pcigart(drm_radeon_private_t * dev_priv, int on)
 
 static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
 {
-        drm_radeon_private_t *dev_priv = dev->dev_private;;
+        drm_radeon_private_t *dev_priv = dev->dev_private;
         DRM_DEBUG("\n");
 
         dev_priv->is_pci = init->is_pci;
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index 7bda7e33d2bd..d92ccee3e54c 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -379,6 +379,7 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #       define RADEON_PLL_WR_EN                 (1 << 7)
 #define RADEON_CLOCK_CNTL_INDEX         0x0008
 #define RADEON_CONFIG_APER_SIZE         0x0108
+#define RADEON_CONFIG_MEMSIZE           0x00f8
 #define RADEON_CRTC_OFFSET              0x0224
 #define RADEON_CRTC_OFFSET_CNTL         0x0228
 #       define RADEON_CRTC_TILE_EN              (1 << 15)
diff --git a/drivers/char/hangcheck-timer.c b/drivers/char/hangcheck-timer.c
index 66e53dd450ff..40a67c86420c 100644
--- a/drivers/char/hangcheck-timer.c
+++ b/drivers/char/hangcheck-timer.c
@@ -120,7 +120,7 @@ __setup("hcheck_dump_tasks", hangcheck_parse_dump_tasks);
 #if defined(CONFIG_X86)
 # define HAVE_MONOTONIC
 # define TIMER_FREQ 1000000000ULL
-#elif defined(CONFIG_ARCH_S390)
+#elif defined(CONFIG_S390)
 /* FA240000 is 1 Second in the IBM time universe (Page 4-38 Principles of Op for zSeries */
 # define TIMER_FREQ 0xFA240000ULL
 #elif defined(CONFIG_IA64)
diff --git a/drivers/char/hw_random.c b/drivers/char/hw_random.c
index 6f673d2de0b1..49769f59ea1b 100644
--- a/drivers/char/hw_random.c
+++ b/drivers/char/hw_random.c
@@ -1,4 +1,9 @@
 /*
+        Added support for the AMD Geode LX RNG
+        (c) Copyright 2004-2005 Advanced Micro Devices, Inc.
+
+        derived from
+
         Hardware driver for the Intel/AMD/VIA Random Number Generators (RNG)
         (c) Copyright 2003 Red Hat Inc <jgarzik@redhat.com>
  
@@ -95,6 +100,11 @@ static unsigned int via_data_present (void);
 static u32 via_data_read (void);
 #endif
 
+static int __init geode_init(struct pci_dev *dev);
+static void geode_cleanup(void);
+static unsigned int geode_data_present (void);
+static u32 geode_data_read (void);
+
 struct rng_operations {
         int (*init) (struct pci_dev *dev);
         void (*cleanup) (void);
@@ -122,6 +132,7 @@ enum {
         rng_hw_intel,
         rng_hw_amd,
         rng_hw_via,
+        rng_hw_geode,
 };
 
 static struct rng_operations rng_vendor_ops[] = {
@@ -139,6 +150,9 @@ static struct rng_operations rng_vendor_ops[] = {
         /* rng_hw_via */
         { via_init, via_cleanup, via_data_present, via_data_read, 1 },
 #endif
+
+        /* rng_hw_geode */
+        { geode_init, geode_cleanup, geode_data_present, geode_data_read, 4 }
 };
 
 /*
@@ -159,6 +173,9 @@ static struct pci_device_id rng_pci_tbl[] = {
         { 0x8086, 0x244e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, rng_hw_intel },
         { 0x8086, 0x245e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, rng_hw_intel },
 
+        { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LX_AES,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, rng_hw_geode },
+
         { 0, }, /* terminate list */
 };
 MODULE_DEVICE_TABLE (pci, rng_pci_tbl);
@@ -460,6 +477,57 @@ static void via_cleanup(void)
 }
 #endif
 
+/***********************************************************************
+ *
+ * AMD Geode RNG operations
+ *
+ */
+
+static void __iomem *geode_rng_base = NULL;
+
+#define GEODE_RNG_DATA_REG   0x50
+#define GEODE_RNG_STATUS_REG 0x54
+
+static u32 geode_data_read(void)
+{
+        u32 val;
+
+        assert(geode_rng_base != NULL);
+        val = readl(geode_rng_base + GEODE_RNG_DATA_REG);
+        return val;
+}
+
+static unsigned int geode_data_present(void)
+{
+        u32 val;
+
+        assert(geode_rng_base != NULL);
+        val = readl(geode_rng_base + GEODE_RNG_STATUS_REG);
+        return val;
+}
+
+static void geode_cleanup(void)
+{
+        iounmap(geode_rng_base);
+        geode_rng_base = NULL;
+}
+
+static int geode_init(struct pci_dev *dev)
+{
+        unsigned long rng_base = pci_resource_start(dev, 0);
+
+        if (rng_base == 0)
+                return 1;
+
+        geode_rng_base = ioremap(rng_base, 0x58);
+
+        if (geode_rng_base == NULL) {
+                printk(KERN_ERR PFX "Cannot ioremap RNG memory\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
 
 /***********************************************************************
  *
@@ -574,7 +642,7 @@ static int __init rng_init (void)
 
         DPRINTK ("ENTER\n");
 
-        /* Probe for Intel, AMD RNGs */
+        /* Probe for Intel, AMD, Geode RNGs */
         for_each_pci_dev(pdev) {
                 ent = pci_match_id(rng_pci_tbl, pdev);
                 if (ent) {
diff --git a/drivers/char/ip2/i2pack.h b/drivers/char/ip2/i2pack.h
index e9b87a78622c..00342a677c90 100644
--- a/drivers/char/ip2/i2pack.h
+++ b/drivers/char/ip2/i2pack.h
@@ -358,7 +358,7 @@ typedef struct _failStat
 #define MB_OUT_STRIPPED    0x40  // Board has read all output from fifo 
 #define MB_FATAL_ERROR     0x20  // Board has encountered a fatal error
 
-#pragma pack(4)                  // Reset padding to command-line default
+#pragma pack()                  // Reset padding to command-line default
 
 #endif      // I2PACK_H
 
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 6b302a930e5f..561430ed94af 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -787,7 +787,6 @@ int ipmi_destroy_user(ipmi_user_t user)
         int              i;
         unsigned long    flags;
         struct cmd_rcvr  *rcvr;
-        struct list_head *entry1, *entry2;
         struct cmd_rcvr  *rcvrs = NULL;
 
         user->valid = 1;
@@ -812,8 +811,7 @@ int ipmi_destroy_user(ipmi_user_t user)
          * synchronize_rcu()) then free everything in that list.
          */
         down(&intf->cmd_rcvrs_lock);
-        list_for_each_safe_rcu(entry1, entry2, &intf->cmd_rcvrs) {
-                rcvr = list_entry(entry1, struct cmd_rcvr, link);
+        list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
                 if (rcvr->user == user) {
                         list_del_rcu(&rcvr->link);
                         rcvr->next = rcvrs;
@@ -2986,7 +2984,7 @@ static void send_panic_events(char *str)
         msg.cmd = 2; /* Platform event command. */
         msg.data = data;
         msg.data_len = 8;
-        data[0] = 0x21; /* Kernel generator ID, IPMI table 5-4 */
+        data[0] = 0x41; /* Kernel generator ID, IPMI table 5-4 */
         data[1] = 0x03; /* This is for IPMI 1.0. */
         data[2] = 0x20; /* OS Critical Stop, IPMI table 36-3 */
         data[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 01a1f6badb53..beea450ee4b2 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -2399,7 +2399,8 @@ static int init_one_smi(int intf_num, struct smi_info **smi)
                         new_smi->handlers->cleanup(new_smi->si_sm);
                 kfree(new_smi->si_sm);
         }
-        new_smi->io_cleanup(new_smi);
+        if (new_smi->io_cleanup)
+                new_smi->io_cleanup(new_smi);
 
         return rv;
 }
@@ -2518,7 +2519,8 @@ static void __exit cleanup_one_si(struct smi_info *to_clean)
 
         kfree(to_clean->si_sm);
 
-        to_clean->io_cleanup(to_clean);
+        if (to_clean->io_cleanup)
+                to_clean->io_cleanup(to_clean);
 }
 
 static __exit void cleanup_ipmi_si(void)
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 449d029ad4f4..8b603b2d1c42 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -930,8 +930,8 @@ static void kbd_refresh_leds(struct input_handle *handle)
 }
 
 #if defined(CONFIG_X86) || defined(CONFIG_IA64) || defined(CONFIG_ALPHA) ||\
-    defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC32) ||\
-    defined(CONFIG_SPARC64) || defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
+    defined(CONFIG_MIPS) || defined(CONFIG_PPC) || defined(CONFIG_SPARC) ||\
+    defined(CONFIG_PARISC) || defined(CONFIG_SUPERH) ||\
     (defined(CONFIG_ARM) && defined(CONFIG_KEYBOARD_ATKBD) && !defined(CONFIG_ARCH_RPC))
 
 #define HW_RAW(dev) (test_bit(EV_MSC, dev->evbit) && test_bit(MSC_RAW, dev->mscbit) &&\
@@ -958,7 +958,7 @@ static unsigned short x86_keycodes[256] =
 extern int mac_hid_mouse_emulate_buttons(int, int, int);
 #endif /* CONFIG_MAC_EMUMOUSEBTN */
 
-#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
+#ifdef CONFIG_SPARC
 static int sparc_l1_a_state = 0;
 extern void sun_do_break(void);
 #endif
@@ -1045,7 +1045,7 @@ static void kbd_keycode(unsigned int keycode, int down,
 
         if (keycode == KEY_LEFTALT || keycode == KEY_RIGHTALT)
                 sysrq_alt = down;
-#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
+#ifdef CONFIG_SPARC
         if (keycode == KEY_STOP)
                 sparc_l1_a_state = down;
 #endif
@@ -1072,7 +1072,7 @@ static void kbd_keycode(unsigned int keycode, int down,
                 return;
         }
 #endif
-#if defined(CONFIG_SPARC32) || defined(CONFIG_SPARC64)
+#ifdef CONFIG_SPARC
         if (keycode == KEY_A && sparc_l1_a_state) {
                 sparc_l1_a_state = 0;
                 sun_do_break();
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 78c89a3e7825..c92378121b4c 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -1,11 +1,11 @@
 /*
- * Intel Multimedia Timer device implementation for SGI SN platforms.
+ * Timer device implementation for SGI SN platforms.
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2001-2004 Silicon Graphics, Inc.  All rights reserved.
+ * Copyright (c) 2001-2006 Silicon Graphics, Inc.  All rights reserved.
  *
  * This driver exports an API that should be supportable by any HPET or IA-PC
  * multimedia timer.  The code below is currently specific to the SGI Altix
@@ -45,7 +45,7 @@ MODULE_LICENSE("GPL");
 /* name of the device, usually in /dev */
 #define MMTIMER_NAME "mmtimer"
 #define MMTIMER_DESC "SGI Altix RTC Timer"
-#define MMTIMER_VERSION "2.0"
+#define MMTIMER_VERSION "2.1"
 
 #define RTC_BITS 55 /* 55 bits for this implementation */
 
@@ -227,10 +227,7 @@ typedef struct mmtimer {
         struct tasklet_struct tasklet;
 } mmtimer_t;
 
-/*
- * Total number of comparators is comparators/node * MAX nodes/running kernel
- */
-static mmtimer_t timers[NUM_COMPARATORS*MAX_COMPACT_NODES];
+static mmtimer_t ** timers;
 
 /**
  * mmtimer_ioctl - ioctl interface for /dev/mmtimer
@@ -441,29 +438,29 @@ static irqreturn_t
 mmtimer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         int i;
-        mmtimer_t *base = timers + cpu_to_node(smp_processor_id()) *
-                                                NUM_COMPARATORS;
         unsigned long expires = 0;
         int result = IRQ_NONE;
+        unsigned indx = cpu_to_node(smp_processor_id());
 
         /*
          * Do this once for each comparison register
          */
         for (i = 0; i < NUM_COMPARATORS; i++) {
+                mmtimer_t *base = timers[indx] + i;
                 /* Make sure this doesn't get reused before tasklet_sched */
-                spin_lock(&base[i].lock);
-                if (base[i].cpu == smp_processor_id()) {
-                        if (base[i].timer)
-                                expires = base[i].timer->it.mmtimer.expires;
+                spin_lock(&base->lock);
+                if (base->cpu == smp_processor_id()) {
+                        if (base->timer)
+                                expires = base->timer->it.mmtimer.expires;
                         /* expires test won't work with shared irqs */
                         if ((mmtimer_int_pending(i) > 0) ||
                                 (expires && (expires < rtc_time()))) {
                                 mmtimer_clr_int_pending(i);
-                                tasklet_schedule(&base[i].tasklet);
+                                tasklet_schedule(&base->tasklet);
                                 result = IRQ_HANDLED;
                         }
                 }
-                spin_unlock(&base[i].lock);
+                spin_unlock(&base->lock);
                 expires = 0;
         }
         return result;
@@ -523,7 +520,7 @@ static int sgi_timer_del(struct k_itimer *timr)
 {
         int i = timr->it.mmtimer.clock;
         cnodeid_t nodeid = timr->it.mmtimer.node;
-        mmtimer_t *t = timers + nodeid * NUM_COMPARATORS +i;
+        mmtimer_t *t = timers[nodeid] + i;
         unsigned long irqflags;
 
         if (i != TIMER_OFF) {
@@ -609,11 +606,11 @@ static int sgi_timer_set(struct k_itimer *timr, int flags,
         preempt_disable();
 
         nodeid =  cpu_to_node(smp_processor_id());
-        base = timers + nodeid * NUM_COMPARATORS;
 retry:
         /* Don't use an allocated timer, or a deleted one that's pending */
         for(i = 0; i< NUM_COMPARATORS; i++) {
-                if (!base[i].timer && !base[i].tasklet.state) {
+                base = timers[nodeid] + i;
+                if (!base->timer && !base->tasklet.state) {
                         break;
                 }
         }
@@ -623,14 +620,14 @@ retry:
                 return -EBUSY;
         }
 
-        spin_lock_irqsave(&base[i].lock, irqflags);
+        spin_lock_irqsave(&base->lock, irqflags);
 
-        if (base[i].timer || base[i].tasklet.state != 0) {
-                spin_unlock_irqrestore(&base[i].lock, irqflags);
+        if (base->timer || base->tasklet.state != 0) {
+                spin_unlock_irqrestore(&base->lock, irqflags);
                 goto retry;
         }
-        base[i].timer = timr;
-        base[i].cpu = smp_processor_id();
+        base->timer = timr;
+        base->cpu = smp_processor_id();
 
         timr->it.mmtimer.clock = i;
         timr->it.mmtimer.node = nodeid;
@@ -645,11 +642,11 @@ retry:
                 }
         } else {
                 timr->it.mmtimer.expires -= period;
-                if (reschedule_periodic_timer(base+i))
+                if (reschedule_periodic_timer(base))
                         err = -EINVAL;
         }
 
-        spin_unlock_irqrestore(&base[i].lock, irqflags);
+        spin_unlock_irqrestore(&base->lock, irqflags);
 
         preempt_enable();
 
@@ -675,6 +672,7 @@ static struct k_clock sgi_clock = {
 static int __init mmtimer_init(void)
 {
         unsigned i;
+        cnodeid_t node, maxn = -1;
 
         if (!ia64_platform_is("sn2"))
                 return -1;
@@ -691,14 +689,6 @@ static int __init mmtimer_init(void)
         mmtimer_femtoperiod = ((unsigned long)1E15 + sn_rtc_cycles_per_second /
                                2) / sn_rtc_cycles_per_second;
 
-        for (i=0; i< NUM_COMPARATORS*MAX_COMPACT_NODES; i++) {
-                spin_lock_init(&timers[i].lock);
-                timers[i].timer = NULL;
-                timers[i].cpu = 0;
-                timers[i].i = i % NUM_COMPARATORS;
-                tasklet_init(&timers[i].tasklet, mmtimer_tasklet, (unsigned long) (timers+i));
-        }
-
         if (request_irq(SGI_MMTIMER_VECTOR, mmtimer_interrupt, SA_PERCPU_IRQ, MMTIMER_NAME, NULL)) {
                 printk(KERN_WARNING "%s: unable to allocate interrupt.",
                         MMTIMER_NAME);
@@ -712,6 +702,40 @@ static int __init mmtimer_init(void)
                 return -1;
         }
 
+        /* Get max numbered node, calculate slots needed */
+        for_each_online_node(node) {
+                maxn = node;
+        }
+        maxn++;
+
+        /* Allocate list of node ptrs to mmtimer_t's */
+        timers = kmalloc(sizeof(mmtimer_t *)*maxn, GFP_KERNEL);
+        if (timers == NULL) {
+                printk(KERN_ERR "%s: failed to allocate memory for device\n",
+                                MMTIMER_NAME);
+                return -1;
+        }
+
+        /* Allocate mmtimer_t's for each online node */
+        for_each_online_node(node) {
+                timers[node] = kmalloc_node(sizeof(mmtimer_t)*NUM_COMPARATORS, GFP_KERNEL, node);
+                if (timers[node] == NULL) {
+                        printk(KERN_ERR "%s: failed to allocate memory for device\n",
+                                MMTIMER_NAME);
+                        return -1;
+                }
+                for (i=0; i< NUM_COMPARATORS; i++) {
+                        mmtimer_t * base = timers[node] + i;
+
+                        spin_lock_init(&base->lock);
+                        base->timer = NULL;
+                        base->cpu = 0;
+                        base->i = i;
+                        tasklet_init(&base->tasklet, mmtimer_tasklet,
+                                (unsigned long) (base));
+                }
+        }
+
         sgi_clock_period = sgi_clock.res = NSEC_PER_SEC / sn_rtc_cycles_per_second;
         register_posix_clock(CLOCK_SGI_CYCLE, &sgi_clock);
 
diff --git a/drivers/char/mwave/mwavepub.h b/drivers/char/mwave/mwavepub.h
index f1f9da7a65c1..60c961ae23b4 100644
--- a/drivers/char/mwave/mwavepub.h
+++ b/drivers/char/mwave/mwavepub.h
@@ -69,7 +69,7 @@ typedef struct _MW_ABILITIES {
 typedef struct _MW_READWRITE {
         unsigned short usDspAddress;    /* The dsp address */
         unsigned long ulDataLength;     /* The size in bytes of the data or user buffer */
-        void *pBuf;             /* Input:variable sized buffer */
+        void __user *pBuf;              /* Input:variable sized buffer */
 } MW_READWRITE, *pMW_READWRITE;
 
 #define IOCTL_MW_RESET           _IO(MWAVE_MINOR,1)
diff --git a/drivers/char/n_hdlc.c b/drivers/char/n_hdlc.c
index c3660d8781a4..a133a62f3d55 100644
--- a/drivers/char/n_hdlc.c
+++ b/drivers/char/n_hdlc.c
@@ -562,7 +562,7 @@ static void n_hdlc_tty_receive(struct tty_struct *tty, const __u8 *data,
 }       /* end of n_hdlc_tty_receive() */
 
 /**
- * n_hdlc_tty_read - Called to retreive one frame of data (if available)
+ * n_hdlc_tty_read - Called to retrieve one frame of data (if available)
  * @tty - pointer to tty instance data
  * @file - pointer to open file object
  * @buf - pointer to returned data buffer
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index ef011ef5dc46..649677b5dc36 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -66,7 +66,6 @@ static char *version = "cm4000_cs.c v2.4.0gm5 - All bugs added by Harald Welte";
 #define T_100MSEC       msecs_to_jiffies(100)
 #define T_500MSEC       msecs_to_jiffies(500)
 
-static void cm4000_detach(dev_link_t *link);
 static void cm4000_release(dev_link_t *link);
 
 static int major;               /* major number we get from the kernel */
@@ -156,7 +155,6 @@ struct cm4000_dev {
                 /*sbuf*/ 512*sizeof(char) -                     \
                 /*queue*/ 4*sizeof(wait_queue_head_t))
 
-static dev_info_t dev_info = MODULE_NAME;
 static dev_link_t *dev_table[CM4000_MAX_DEV];
 
 /* This table doesn't use spaces after the comma between fields and thus
@@ -1444,6 +1442,7 @@ static int cmm_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
         dev_link_t *link;
         int size;
         int rc;
+        void __user *argp = (void __user *)arg;
 #ifdef PCMCIA_DEBUG
         char *ioctl_names[CM_IOC_MAXNR + 1] = {
                 [_IOC_NR(CM_IOCGSTATUS)] "CM_IOCGSTATUS",
@@ -1481,11 +1480,11 @@ static int cmm_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
               _IOC_DIR(cmd), _IOC_READ, _IOC_WRITE, size, cmd);
 
         if (_IOC_DIR(cmd) & _IOC_READ) {
-                if (!access_ok(VERIFY_WRITE, (void *)arg, size))
+                if (!access_ok(VERIFY_WRITE, argp, size))
                         return -EFAULT;
         }
         if (_IOC_DIR(cmd) & _IOC_WRITE) {
-                if (!access_ok(VERIFY_READ, (void *)arg, size))
+                if (!access_ok(VERIFY_READ, argp, size))
                         return -EFAULT;
         }
 
@@ -1506,14 +1505,14 @@ static int cmm_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                                 status |= CM_NO_READER;
                         if (test_bit(IS_BAD_CARD, &dev->flags))
                                 status |= CM_BAD_CARD;
-                        if (copy_to_user((int *)arg, &status, sizeof(int)))
+                        if (copy_to_user(argp, &status, sizeof(int)))
                                 return -EFAULT;
                 }
                 return 0;
         case CM_IOCGATR:
                 DEBUGP(4, dev, "... in CM_IOCGATR\n");
                 {
-                        struct atreq *atreq = (struct atreq *) arg;
+                        struct atreq __user *atreq = argp;
                         int tmp;
                         /* allow nonblocking io and being interrupted */
                         if (wait_event_interruptible
@@ -1597,7 +1596,7 @@ static int cmm_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                 {
                         struct ptsreq krnptsreq;
 
-                        if (copy_from_user(&krnptsreq, (struct ptsreq *) arg,
+                        if (copy_from_user(&krnptsreq, argp,
                                            sizeof(struct ptsreq)))
                                 return -EFAULT;
 
@@ -1641,7 +1640,7 @@ static int cmm_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
                         int old_pc_debug = 0;
 
                         old_pc_debug = pc_debug;
-                        if (copy_from_user(&pc_debug, (int *)arg, sizeof(int)))
+                        if (copy_from_user(&pc_debug, argp, sizeof(int)))
                                 return -EFAULT;
 
                         if (old_pc_debug != pc_debug)
@@ -1863,68 +1862,36 @@ cs_release:
         link->state &= ~DEV_CONFIG_PENDING;
 }
 
-static int cm4000_event(event_t event, int priority,
-                        event_callback_args_t *args)
+static int cm4000_suspend(struct pcmcia_device *p_dev)
 {
-        dev_link_t *link;
+        dev_link_t *link = dev_to_instance(p_dev);
         struct cm4000_dev *dev;
-        int devno;
 
-        link = args->client_data;
         dev = link->priv;
 
-        DEBUGP(3, dev, "-> cm4000_event\n");
-        for (devno = 0; devno < CM4000_MAX_DEV; devno++)
-                if (dev_table[devno] == link)
-                        break;
+        link->state |= DEV_SUSPEND;
+        if (link->state & DEV_CONFIG)
+                pcmcia_release_configuration(link->handle);
+        stop_monitor(dev);
 
-        if (devno == CM4000_MAX_DEV)
-                return CS_BAD_ADAPTER;
+        return 0;
+}
 
-        switch (event) {
-        case CS_EVENT_CARD_INSERTION:
-                DEBUGP(5, dev, "CS_EVENT_CARD_INSERTION\n");
-                link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
-                cm4000_config(link, devno);
-                break;
-        case CS_EVENT_CARD_REMOVAL:
-                DEBUGP(5, dev, "CS_EVENT_CARD_REMOVAL\n");
-                link->state &= ~DEV_PRESENT;
-                stop_monitor(dev);
-                break;
-        case CS_EVENT_PM_SUSPEND:
-                DEBUGP(5, dev, "CS_EVENT_PM_SUSPEND "
-                      "(fall-through to CS_EVENT_RESET_PHYSICAL)\n");
-                link->state |= DEV_SUSPEND;
-                /* fall-through */
-        case CS_EVENT_RESET_PHYSICAL:
-                DEBUGP(5, dev, "CS_EVENT_RESET_PHYSICAL\n");
-                if (link->state & DEV_CONFIG) {
-                        DEBUGP(5, dev, "ReleaseConfiguration\n");
-                        pcmcia_release_configuration(link->handle);
-                }
-                stop_monitor(dev);
-                break;
-        case CS_EVENT_PM_RESUME:
-                DEBUGP(5, dev, "CS_EVENT_PM_RESUME "
-                      "(fall-through to CS_EVENT_CARD_RESET)\n");
-                link->state &= ~DEV_SUSPEND;
-                /* fall-through */
-        case CS_EVENT_CARD_RESET:
-                DEBUGP(5, dev, "CS_EVENT_CARD_RESET\n");
-                if ((link->state & DEV_CONFIG)) {
-                        DEBUGP(5, dev, "RequestConfiguration\n");
-                        pcmcia_request_configuration(link->handle, &link->conf);
-                }
-                if (link->open)
-                        start_monitor(dev);
-                break;
-        default:
-                DEBUGP(5, dev, "unknown event %.2x\n", event);
-                break;
-        }
-        DEBUGP(3, dev, "<- cm4000_event\n");
-        return CS_SUCCESS;
+static int cm4000_resume(struct pcmcia_device *p_dev)
+{
+        dev_link_t *link = dev_to_instance(p_dev);
+        struct cm4000_dev *dev;
+
+        dev = link->priv;
+
+        link->state &= ~DEV_SUSPEND;
+        if (link->state & DEV_CONFIG)
+                pcmcia_request_configuration(link->handle, &link->conf);
+
+        if (link->open)
+                start_monitor(dev);
+
+        return 0;
 }
 
 static void cm4000_release(dev_link_t *link)
@@ -1934,11 +1901,10 @@ static void cm4000_release(dev_link_t *link)
         pcmcia_release_io(link->handle, &link->io);
 }
 
-static dev_link_t *cm4000_attach(void)
+static int cm4000_attach(struct pcmcia_device *p_dev)
 {
         struct cm4000_dev *dev;
         dev_link_t *link;
-        client_reg_t client_reg;
         int i;
 
         for (i = 0; i < CM4000_MAX_DEV; i++)
@@ -1947,76 +1913,55 @@ static dev_link_t *cm4000_attach(void)
 
         if (i == CM4000_MAX_DEV) {
                 printk(KERN_NOTICE MODULE_NAME ": all devices in use\n");
-                return NULL;
+                return -ENODEV;
         }
 
         /* create a new cm4000_cs device */
         dev = kzalloc(sizeof(struct cm4000_dev), GFP_KERNEL);
         if (dev == NULL)
-                return NULL;
+                return -ENOMEM;
 
         link = &dev->link;
         link->priv = dev;
         link->conf.IntType = INT_MEMORY_AND_IO;
         dev_table[i] = link;
 
-        /* register with card services */
-        client_reg.dev_info = &dev_info;
-        client_reg.EventMask =
-            CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
-            CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
-            CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
-        client_reg.Version = 0x0210;
-        client_reg.event_callback_args.client_data = link;
-
-        i = pcmcia_register_client(&link->handle, &client_reg);
-        if (i) {
-                cs_error(link->handle, RegisterClient, i);
-                cm4000_detach(link);
-                return NULL;
-        }
-
         init_waitqueue_head(&dev->devq);
         init_waitqueue_head(&dev->ioq);
         init_waitqueue_head(&dev->atrq);
         init_waitqueue_head(&dev->readq);
 
-        return link;
-}
-
-static void cm4000_detach_by_devno(int devno, dev_link_t * link)
-{
-        struct cm4000_dev *dev = link->priv;
-
-        DEBUGP(3, dev, "-> detach_by_devno(devno=%d)\n", devno);
-
-        if (link->state & DEV_CONFIG) {
-                DEBUGP(5, dev, "device still configured (try to release it)\n");
-                cm4000_release(link);
-        }
+        link->handle = p_dev;
+        p_dev->instance = link;
 
-        if (link->handle) {
-                pcmcia_deregister_client(link->handle);
-        }
+        link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
+        cm4000_config(link, i);
 
-        dev_table[devno] = NULL;
-        kfree(dev);
-        return;
+        return 0;
 }
 
-static void cm4000_detach(dev_link_t * link)
+static void cm4000_detach(struct pcmcia_device *p_dev)
 {
-        int i;
+        dev_link_t *link = dev_to_instance(p_dev);
+        struct cm4000_dev *dev = link->priv;
+        int devno;
 
         /* find device */
-        for (i = 0; i < CM4000_MAX_DEV; i++)
-                if (dev_table[i] == link)
+        for (devno = 0; devno < CM4000_MAX_DEV; devno++)
+                if (dev_table[devno] == link)
                         break;
-
-        if (i == CM4000_MAX_DEV)
+        if (devno == CM4000_MAX_DEV)
                 return;
 
-        cm4000_detach_by_devno(i, link);
+        link->state &= ~DEV_PRESENT;
+        stop_monitor(dev);
+
+        if (link->state & DEV_CONFIG)
+                cm4000_release(link);
+
+        dev_table[devno] = NULL;
+        kfree(dev);
+
         return;
 }
 
@@ -2041,9 +1986,10 @@ static struct pcmcia_driver cm4000_driver = {
         .drv      = {
                 .name = "cm4000_cs",
                 },
-        .attach   = cm4000_attach,
-        .detach   = cm4000_detach,
-        .event    = cm4000_event,
+        .probe    = cm4000_attach,
+        .remove   = cm4000_detach,
+        .suspend  = cm4000_suspend,
+        .resume   = cm4000_resume,
         .id_table = cm4000_ids,
 };
 
@@ -2063,13 +2009,8 @@ static int __init cmm_init(void)
 
 static void __exit cmm_exit(void)
 {
-        int i;
-
         printk(KERN_INFO MODULE_NAME ": unloading\n");
         pcmcia_unregister_driver(&cm4000_driver);
-        for (i = 0; i < CM4000_MAX_DEV; i++)
-                if (dev_table[i])
-                        cm4000_detach_by_devno(i, dev_table[i]);
         unregister_chrdev(major, DEVICE_NAME);
 };
 
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index 4c698d908ffa..46eb371bf17e 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -65,7 +65,6 @@ static char *version =
 #define POLL_PERIOD                             msecs_to_jiffies(10)
 
 static void reader_release(dev_link_t *link);
-static void reader_detach(dev_link_t *link);
 
 static int major;
 
@@ -86,7 +85,6 @@ struct reader_dev {
         struct timer_list       poll_timer;
 };
 
-static dev_info_t dev_info = MODULE_NAME;
 static dev_link_t *dev_table[CM_MAX_DEV];
 
 #ifndef PCMCIA_DEBUG
@@ -629,65 +627,26 @@ cs_release:
         link->state &= ~DEV_CONFIG_PENDING;
 }
 
-static int reader_event(event_t event, int priority,
-                        event_callback_args_t *args)
+static int reader_suspend(struct pcmcia_device *p_dev)
 {
-        dev_link_t *link;
-        struct reader_dev *dev;
-        int devno;
+        dev_link_t *link = dev_to_instance(p_dev);
 
-        link = args->client_data;
-        dev = link->priv;
-        DEBUGP(3, dev, "-> reader_event\n");
-        for (devno = 0; devno < CM_MAX_DEV; devno++) {
-                if (dev_table[devno] == link)
-                        break;
-        }
-        if (devno == CM_MAX_DEV)
-                return CS_BAD_ADAPTER;
+        link->state |= DEV_SUSPEND;
+        if (link->state & DEV_CONFIG)
+                pcmcia_release_configuration(link->handle);
 
-        switch (event) {
-                case CS_EVENT_CARD_INSERTION:
-                        DEBUGP(5, dev, "CS_EVENT_CARD_INSERTION\n");
-                        link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
-                        reader_config(link, devno);
-                        break;
-                case CS_EVENT_CARD_REMOVAL:
-                        DEBUGP(5, dev, "CS_EVENT_CARD_REMOVAL\n");
-                        link->state &= ~DEV_PRESENT;
-                        break;
-                case CS_EVENT_PM_SUSPEND:
-                        DEBUGP(5, dev, "CS_EVENT_PM_SUSPEND "
-                              "(fall-through to CS_EVENT_RESET_PHYSICAL)\n");
-                        link->state |= DEV_SUSPEND;
-
-                case CS_EVENT_RESET_PHYSICAL:
-                        DEBUGP(5, dev, "CS_EVENT_RESET_PHYSICAL\n");
-                        if (link->state & DEV_CONFIG) {
-                                DEBUGP(5, dev, "ReleaseConfiguration\n");
-                                pcmcia_release_configuration(link->handle);
-                        }
-                        break;
-                case CS_EVENT_PM_RESUME:
-                        DEBUGP(5, dev, "CS_EVENT_PM_RESUME "
-                              "(fall-through to CS_EVENT_CARD_RESET)\n");
-                        link->state &= ~DEV_SUSPEND;
-
-                case CS_EVENT_CARD_RESET:
-                        DEBUGP(5, dev, "CS_EVENT_CARD_RESET\n");
-                        if ((link->state & DEV_CONFIG)) {
-                                DEBUGP(5, dev, "RequestConfiguration\n");
-                                pcmcia_request_configuration(link->handle,
-                                                             &link->conf);
-                        }
-                        break;
-                default:
-                        DEBUGP(5, dev, "reader_event: unknown event %.2x\n",
-                               event);
-                        break;
-        }
-        DEBUGP(3, dev, "<- reader_event\n");
-        return CS_SUCCESS;
+        return 0;
+}
+
+static int reader_resume(struct pcmcia_device *p_dev)
+{
+        dev_link_t *link = dev_to_instance(p_dev);
+
+        link->state &= ~DEV_SUSPEND;
+        if (link->state & DEV_CONFIG)
+                pcmcia_request_configuration(link->handle, &link->conf);
+
+        return 0;
 }
 
 static void reader_release(dev_link_t *link)
@@ -697,11 +656,10 @@ static void reader_release(dev_link_t *link)
         pcmcia_release_io(link->handle, &link->io);
 }
 
-static dev_link_t *reader_attach(void)
+static int reader_attach(struct pcmcia_device *p_dev)
 {
         struct reader_dev *dev;
         dev_link_t *link;
-        client_reg_t client_reg;
         int i;
 
         for (i = 0; i < CM_MAX_DEV; i++) {
@@ -710,11 +668,11 @@ static dev_link_t *reader_attach(void)
         }
 
         if (i == CM_MAX_DEV)
-                return NULL;
+                return -ENODEV;
 
         dev = kzalloc(sizeof(struct reader_dev), GFP_KERNEL);
         if (dev == NULL)
-                return NULL;
+                return -ENOMEM;
 
         dev->timeout = CCID_DRIVER_MINIMUM_TIMEOUT;
         dev->buffer_status = 0;
@@ -725,20 +683,6 @@ static dev_link_t *reader_attach(void)
         link->conf.IntType = INT_MEMORY_AND_IO;
         dev_table[i] = link;
 
-        client_reg.dev_info = &dev_info;
-        client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
-        client_reg.EventMask=
-                CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
-                CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
-                CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
-        client_reg.Version = 0x0210;
-        client_reg.event_callback_args.client_data = link;
-        i = pcmcia_register_client(&link->handle, &client_reg);
-        if (i) {
-                cs_error(link->handle, RegisterClient, i);
-                reader_detach(link);
-                return NULL;
-        }
         init_waitqueue_head(&dev->devq);
         init_waitqueue_head(&dev->poll_wait);
         init_waitqueue_head(&dev->read_wait);
@@ -746,39 +690,37 @@ static dev_link_t *reader_attach(void)
         init_timer(&dev->poll_timer);
         dev->poll_timer.function = &cm4040_do_poll;
 
-        return link;
-}
-
-static void reader_detach_by_devno(int devno, dev_link_t *link)
-{
-        struct reader_dev *dev = link->priv;
+        link->handle = p_dev;
+        p_dev->instance = link;
 
-        if (link->state & DEV_CONFIG) {
-                DEBUGP(5, dev, "device still configured (try to release it)\n");
-                reader_release(link);
-        }
+        link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
+        reader_config(link, i);
 
-        pcmcia_deregister_client(link->handle);
-        dev_table[devno] = NULL;
-        DEBUGP(5, dev, "freeing dev=%p\n", dev);
-        cm4040_stop_poll(dev);
-        kfree(dev);
-        return;
+        return 0;
 }
 
-static void reader_detach(dev_link_t *link)
+static void reader_detach(struct pcmcia_device *p_dev)
 {
-        int i;
+        dev_link_t *link = dev_to_instance(p_dev);
+        struct reader_dev *dev = link->priv;
+        int devno;
 
         /* find device */
-        for (i = 0; i < CM_MAX_DEV; i++) {
-                if (dev_table[i] == link)
+        for (devno = 0; devno < CM_MAX_DEV; devno++) {
+                if (dev_table[devno] == link)
                         break;
         }
-        if (i == CM_MAX_DEV)
+        if (devno == CM_MAX_DEV)
                 return;
 
-        reader_detach_by_devno(i, link);
+        link->state &= ~DEV_PRESENT;
+
+        if (link->state & DEV_CONFIG)
+                reader_release(link);
+
+        dev_table[devno] = NULL;
+        kfree(dev);
+
         return;
 }
 
@@ -804,9 +746,10 @@ static struct pcmcia_driver reader_driver = {
         .drv            = {
                 .name   = "cm4040_cs",
         },
-        .attach         = reader_attach,
-        .detach         = reader_detach,
-        .event          = reader_event,
+        .probe          = reader_attach,
+        .remove         = reader_detach,
+        .suspend        = reader_suspend,
+        .resume         = reader_resume,
         .id_table       = cm4040_ids,
 };
 
@@ -825,14 +768,8 @@ static int __init cm4040_init(void)
 
 static void __exit cm4040_exit(void)
 {
-        int i;
-
         printk(KERN_INFO MODULE_NAME ": unloading\n");
         pcmcia_unregister_driver(&reader_driver);
-        for (i = 0; i < CM_MAX_DEV; i++) {
-                if (dev_table[i])
-                        reader_detach_by_devno(i, dev_table[i]);
-        }
         unregister_chrdev(major, DEVICE_NAME);
 }
 
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 2c326ea53421..cf45b100eff1 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -486,13 +486,7 @@ static void mgslpc_wait_until_sent(struct tty_struct *tty, int timeout);
 
 static void mgslpc_config(dev_link_t *link);
 static void mgslpc_release(u_long arg);
-static int  mgslpc_event(event_t event, int priority,
-                         event_callback_args_t *args);
-static dev_link_t *mgslpc_attach(void);
-static void mgslpc_detach(dev_link_t *);
-
-static dev_info_t dev_info = "synclink_cs";
-static dev_link_t *dev_list = NULL;
+static void mgslpc_detach(struct pcmcia_device *p_dev);
 
 /*
  * 1st function defined in .text section. Calling this function in
@@ -539,12 +533,10 @@ static void ldisc_receive_buf(struct tty_struct *tty,
         }
 }
 
-static dev_link_t *mgslpc_attach(void)
+static int mgslpc_attach(struct pcmcia_device *p_dev)
 {
     MGSLPC_INFO *info;
     dev_link_t *link;
-    client_reg_t client_reg;
-    int ret;
     
     if (debug_level >= DEBUG_LEVEL_INFO)
             printk("mgslpc_attach\n");
@@ -552,7 +544,7 @@ static dev_link_t *mgslpc_attach(void)
     info = (MGSLPC_INFO *)kmalloc(sizeof(MGSLPC_INFO), GFP_KERNEL);
     if (!info) {
             printk("Error can't allocate device instance data\n");
-            return NULL;
+            return -ENOMEM;
     }
 
     memset(info, 0, sizeof(MGSLPC_INFO));
@@ -587,24 +579,15 @@ static dev_link_t *mgslpc_attach(void)
     link->conf.Vcc = 50;
     link->conf.IntType = INT_MEMORY_AND_IO;
 
-    /* Register with Card Services */
-    link->next = dev_list;
-    dev_list = link;
-
-    client_reg.dev_info = &dev_info;
-    client_reg.Version = 0x0210;
-    client_reg.event_callback_args.client_data = link;
+    link->handle = p_dev;
+    p_dev->instance = link;
 
-    ret = pcmcia_register_client(&link->handle, &client_reg);
-    if (ret != CS_SUCCESS) {
-            cs_error(link->handle, RegisterClient, ret);
-            mgslpc_detach(link);
-            return NULL;
-    }
+    link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
+    mgslpc_config(link);
 
     mgslpc_add_device(info);
 
-    return link;
+    return 0;
 }
 
 /* Card has been inserted.
@@ -736,85 +719,50 @@ static void mgslpc_release(u_long arg)
             pcmcia_release_io(link->handle, &link->io);
     if (link->irq.AssignedIRQ)
             pcmcia_release_irq(link->handle, &link->irq);
-    if (link->state & DEV_STALE_LINK)
-            mgslpc_detach(link);
 }
 
-static void mgslpc_detach(dev_link_t *link)
+static void mgslpc_detach(struct pcmcia_device *p_dev)
 {
-    dev_link_t **linkp;
+    dev_link_t *link = dev_to_instance(p_dev);
 
     if (debug_level >= DEBUG_LEVEL_INFO)
             printk("mgslpc_detach(0x%p)\n", link);
-    
-    /* find device */
-    for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
-            if (*linkp == link) break;
-    if (*linkp == NULL)
-            return;
 
     if (link->state & DEV_CONFIG) {
-            /* device is configured/active, mark it so when
-             * release() is called a proper detach() occurs.
-             */
-            if (debug_level >= DEBUG_LEVEL_INFO)
-                    printk(KERN_DEBUG "synclinkpc: detach postponed, '%s' "
-                           "still locked\n", link->dev->dev_name);
-            link->state |= DEV_STALE_LINK;
-            return;
+            ((MGSLPC_INFO *)link->priv)->stop = 1;
+            mgslpc_release((u_long)link);
     }
 
-    /* Break the link with Card Services */
-    if (link->handle)
-            pcmcia_deregister_client(link->handle);
-    
-    /* Unlink device structure, and free it */
-    *linkp = link->next;
     mgslpc_remove_device((MGSLPC_INFO *)link->priv);
 }
 
-static int mgslpc_event(event_t event, int priority,
-                        event_callback_args_t *args)
+static int mgslpc_suspend(struct pcmcia_device *dev)
 {
-    dev_link_t *link = args->client_data;
-    MGSLPC_INFO *info = link->priv;
-    
-    if (debug_level >= DEBUG_LEVEL_INFO)
-            printk("mgslpc_event(0x%06x)\n", event);
-    
-    switch (event) {
-    case CS_EVENT_CARD_REMOVAL:
-            link->state &= ~DEV_PRESENT;
-            if (link->state & DEV_CONFIG) {
-                    ((MGSLPC_INFO *)link->priv)->stop = 1;
-                    mgslpc_release((u_long)link);
-            }
-            break;
-    case CS_EVENT_CARD_INSERTION:
-            link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
-            mgslpc_config(link);
-            break;
-    case CS_EVENT_PM_SUSPEND:
-            link->state |= DEV_SUSPEND;
-            /* Fall through... */
-    case CS_EVENT_RESET_PHYSICAL:
-            /* Mark the device as stopped, to block IO until later */
-            info->stop = 1;
-            if (link->state & DEV_CONFIG)
-                    pcmcia_release_configuration(link->handle);
-            break;
-    case CS_EVENT_PM_RESUME:
-            link->state &= ~DEV_SUSPEND;
-            /* Fall through... */
-    case CS_EVENT_CARD_RESET:
-            if (link->state & DEV_CONFIG)
-                    pcmcia_request_configuration(link->handle, &link->conf);
-            info->stop = 0;
-            break;
-    }
-    return 0;
+        dev_link_t *link = dev_to_instance(dev);
+        MGSLPC_INFO *info = link->priv;
+
+        link->state |= DEV_SUSPEND;
+        info->stop = 1;
+        if (link->state & DEV_CONFIG)
+                pcmcia_release_configuration(link->handle);
+
+        return 0;
 }
 
+static int mgslpc_resume(struct pcmcia_device *dev)
+{
+        dev_link_t *link = dev_to_instance(dev);
+        MGSLPC_INFO *info = link->priv;
+
+        link->state &= ~DEV_SUSPEND;
+        if (link->state & DEV_CONFIG)
+                pcmcia_request_configuration(link->handle, &link->conf);
+        info->stop = 0;
+
+        return 0;
+}
+
+
 static inline int mgslpc_paranoia_check(MGSLPC_INFO *info,
                                         char *name, const char *routine)
 {
@@ -3091,10 +3039,11 @@ static struct pcmcia_driver mgslpc_driver = {
         .drv            = {
                 .name   = "synclink_cs",
         },
-        .attach         = mgslpc_attach,
-        .event          = mgslpc_event,
-        .detach         = mgslpc_detach,
+        .probe          = mgslpc_attach,
+        .remove         = mgslpc_detach,
         .id_table       = mgslpc_ids,
+        .suspend        = mgslpc_suspend,
+        .resume         = mgslpc_resume,
 };
 
 static struct tty_operations mgslpc_ops = {
@@ -3138,7 +3087,6 @@ static void synclink_cs_cleanup(void)
         }
 
         pcmcia_unregister_driver(&mgslpc_driver);
-        BUG_ON(dev_list != NULL);
 }
 
 static int __init synclink_cs_init(void)
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 7999da25fe40..bdfdfd28594d 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1554,10 +1554,8 @@ __u32 secure_tcp_sequence_number(__u32 saddr, __u32 daddr,
 
 EXPORT_SYMBOL(secure_tcp_sequence_number);
 
-
-
-/* Generate secure starting point for ephemeral TCP port search */
-u32 secure_tcp_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport)
+/* Generate secure starting point for ephemeral IPV4 transport port search */
+u32 secure_ipv4_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport)
 {
         struct keydata *keyptr = get_keyptr();
         u32 hash[4];
@@ -1575,7 +1573,7 @@ u32 secure_tcp_port_ephemeral(__u32 saddr, __u32 daddr, __u16 dport)
 }
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-u32 secure_tcpv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dport)
+u32 secure_ipv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dport)
 {
         struct keydata *keyptr = get_keyptr();
         u32 hash[12];
@@ -1586,7 +1584,7 @@ u32 secure_tcpv6_port_ephemeral(const __u32 *saddr, const __u32 *daddr, __u16 dp
 
         return twothirdsMD4Transform(daddr, hash);
 }
-EXPORT_SYMBOL(secure_tcpv6_port_ephemeral);
+EXPORT_SYMBOL(secure_ipv6_port_ephemeral);
 #endif
 
 #if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE)
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index f66c7ad6fd38..3c1dafaa3441 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -419,7 +419,7 @@ vcs_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
                         while (this_round > 1) {
                                 unsigned short w;
 
-                                w = get_unaligned(((const unsigned short *)con_buf0));
+                                w = get_unaligned(((unsigned short *)con_buf0));
                                 vcs_scr_writew(vc, w, org++);
                                 con_buf0 += 2;
                                 this_round -= 2;
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig
index 344001b45af9..a6544790af60 100644
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -438,7 +438,7 @@ config INDYDOG
 
 config ZVM_WATCHDOG
         tristate "z/VM Watchdog Timer"
-        depends on WATCHDOG && ARCH_S390
+        depends on WATCHDOG && S390
         help
           IBM s/390 and zSeries machines running under z/VM 5.1 or later
           provide a virtual watchdog timer to their guest that cause a
diff --git a/drivers/char/watchdog/booke_wdt.c b/drivers/char/watchdog/booke_wdt.c
index 65830ec71042..b6640606b44d 100644
--- a/drivers/char/watchdog/booke_wdt.c
+++ b/drivers/char/watchdog/booke_wdt.c
@@ -72,7 +72,7 @@ static __inline__ void booke_wdt_ping(void)
 /*
  * booke_wdt_write:
  */
-static ssize_t booke_wdt_write (struct file *file, const char *buf,
+static ssize_t booke_wdt_write (struct file *file, const char __user *buf,
                                 size_t count, loff_t *ppos)
 {
         booke_wdt_ping();
@@ -92,14 +92,15 @@ static int booke_wdt_ioctl (struct inode *inode, struct file *file,
                             unsigned int cmd, unsigned long arg)
 {
         u32 tmp = 0;
+        u32 __user *p = (u32 __user *)arg;
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user ((struct watchdog_info *) arg, &ident,
+                if (copy_to_user ((struct watchdog_info __user *) arg, &ident,
                                 sizeof(struct watchdog_info)))
                         return -EFAULT;
         case WDIOC_GETSTATUS:
-                return put_user(ident.options, (u32 *) arg);
+                return put_user(ident.options, p);
         case WDIOC_GETBOOTSTATUS:
                 /* XXX: something is clearing TSR */
                 tmp = mfspr(SPRN_TSR) & TSR_WRS(3);
@@ -109,14 +110,14 @@ static int booke_wdt_ioctl (struct inode *inode, struct file *file,
                 booke_wdt_ping();
                 return 0;
         case WDIOC_SETTIMEOUT:
-                if (get_user(booke_wdt_period, (u32 *) arg))
+                if (get_user(booke_wdt_period, p))
                         return -EFAULT;
                 mtspr(SPRN_TCR, (mfspr(SPRN_TCR)&~WDTP(0))|WDTP(booke_wdt_period));
                 return 0;
         case WDIOC_GETTIMEOUT:
-                return put_user(booke_wdt_period, (u32 *) arg);
+                return put_user(booke_wdt_period, p);
         case WDIOC_SETOPTIONS:
-                if (get_user(tmp, (u32 *) arg))
+                if (get_user(tmp, p))
                         return -EINVAL;
                 if (tmp == WDIOS_ENABLECARD) {
                         booke_wdt_ping();
@@ -172,7 +173,7 @@ static int __init booke_wdt_init(void)
         int ret = 0;
 
         printk (KERN_INFO "PowerPC Book-E Watchdog Timer Loaded\n");
-        ident.firmware_version = cpu_specs[0].pvr_value;
+        ident.firmware_version = cur_cpu_spec->pvr_value;
 
         ret = misc_register(&booke_wdt_miscdev);
         if (ret) {
diff --git a/drivers/char/watchdog/ixp4xx_wdt.c b/drivers/char/watchdog/ixp4xx_wdt.c
index b5be8b11104a..3800835ca8f3 100644
--- a/drivers/char/watchdog/ixp4xx_wdt.c
+++ b/drivers/char/watchdog/ixp4xx_wdt.c
@@ -186,8 +186,8 @@ static int __init ixp4xx_wdt_init(void)
         unsigned long processor_id;
 
         asm("mrc p15, 0, %0, cr0, cr0, 0;" : "=r"(processor_id) :);
-        if (!(processor_id & 0xf)) {
-                printk("IXP4XXX Watchdog: Rev. A0 CPU detected - "
+        if (!(processor_id & 0xf) && !cpu_is_ixp46x()) {
+                printk("IXP4XXX Watchdog: Rev. A0 IXP42x CPU detected - "
                         "watchdog disabled\n");
 
                 return -ENODEV;
diff --git a/drivers/char/watchdog/mpcore_wdt.c b/drivers/char/watchdog/mpcore_wdt.c
index 9defcf861b67..b4d843489881 100644
--- a/drivers/char/watchdog/mpcore_wdt.c
+++ b/drivers/char/watchdog/mpcore_wdt.c
@@ -180,10 +180,6 @@ static ssize_t mpcore_wdt_write(struct file *file, const char *data, size_t len,
 {
         struct mpcore_wdt *wdt = file->private_data;
 
-        /*  Can't seek (pwrite) on this device  */
-        if (ppos != &file->f_pos)
-                return -ESPIPE;
-
         /*
          *      Refresh the timer.
          */
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index 092e9b133750..1533f56baa42 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -151,7 +151,6 @@ static void usb_pcwd_disconnect	(struct usb_interface *interface);
 
 /* usb specific object needed to register this driver with the usb subsystem */
 static struct usb_driver usb_pcwd_driver = {
-        .owner =        THIS_MODULE,
         .name =         DRIVER_NAME,
         .probe =        usb_pcwd_probe,
         .disconnect =   usb_pcwd_disconnect,
diff --git a/drivers/char/watchdog/wdrtas.c b/drivers/char/watchdog/wdrtas.c
index 619e2ffca33f..dacfe31caccf 100644
--- a/drivers/char/watchdog/wdrtas.c
+++ b/drivers/char/watchdog/wdrtas.c
@@ -320,7 +320,7 @@ static int
 wdrtas_ioctl(struct inode *inode, struct file *file,
              unsigned int cmd, unsigned long arg)
 {
-        int __user *argp = (void *)arg;
+        int __user *argp = (void __user *)arg;
         int i;
         static struct watchdog_info wdinfo = {
                 .options = WDRTAS_SUPPORTED_MASK,