Merge with Linus' kernel.

15 files changed, 274 insertions, 362 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 84e68cdd451b..5ebd06b1b4ca 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -985,7 +985,7 @@ config HPET_MMAP
 
 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/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 1f56b4cf0f58..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;
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/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 61681c9f3f72..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
@@ -1864,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)
@@ -1935,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++)
@@ -1948,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;
 }
 
@@ -2042,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,
 };
 
@@ -2064,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/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/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/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,