30 files changed, 216 insertions, 152 deletions

diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 05ba410682a3..b524f5ba78a9 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -695,7 +695,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC32 && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
+        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
         ---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
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 503dd901d406..090d154098bb 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -31,7 +31,7 @@ obj-$(CONFIG_MOXA_INTELLIO)	+= moxa.o
 obj-$(CONFIG_A2232)             += ser_a2232.o generic_serial.o
 obj-$(CONFIG_ATARI_DSP56K)      += dsp56k.o
 obj-$(CONFIG_MOXA_SMARTIO)      += mxser.o
-obj-$(CONFIG_COMPUTONE)         += ip2.o ip2main.o
+obj-$(CONFIG_COMPUTONE)         += ip2/
 obj-$(CONFIG_RISCOM8)           += riscom8.o
 obj-$(CONFIG_ISI)               += isicom.o
 obj-$(CONFIG_SYNCLINK)          += synclink.o
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 7ac365b5d9ec..6602b3156df5 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -46,8 +46,6 @@
 
 /* Sanity checks */
 
-#define SERIAL_INLINE
-  
 #if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
 #define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
  tty->name, (info->flags), serial_driver->refcount,info->count,tty->count,s)
@@ -95,10 +93,6 @@ static char *serial_version = "4.30";
 #include <asm/amigahw.h>
 #include <asm/amigaints.h>
 
-#ifdef SERIAL_INLINE
-#define _INLINE_ inline
-#endif
-
 #define custom amiga_custom
 static char *serial_name = "Amiga-builtin serial driver";
 
@@ -253,14 +247,14 @@ static void rs_start(struct tty_struct *tty)
  * This routine is used by the interrupt handler to schedule
  * processing in the software interrupt portion of the driver.
  */
-static _INLINE_ void rs_sched_event(struct async_struct *info,
-                                  int event)
+static void rs_sched_event(struct async_struct *info,
+                           int event)
 {
         info->event |= 1 << event;
         tasklet_schedule(&info->tlet);
 }
 
-static _INLINE_ void receive_chars(struct async_struct *info)
+static void receive_chars(struct async_struct *info)
 {
         int status;
         int serdatr;
@@ -349,7 +343,7 @@ out:
         return;
 }
 
-static _INLINE_ void transmit_chars(struct async_struct *info)
+static void transmit_chars(struct async_struct *info)
 {
         custom.intreq = IF_TBE;
         mb();
@@ -389,7 +383,7 @@ static _INLINE_ void transmit_chars(struct async_struct *info)
         }
 }
 
-static _INLINE_ void check_modem_status(struct async_struct *info)
+static void check_modem_status(struct async_struct *info)
 {
         unsigned char status = ciab.pra & (SER_DCD | SER_CTS | SER_DSR);
         unsigned char dstatus;
@@ -1959,7 +1953,7 @@ done:
  * number, and identifies which options were configured into this
  * driver.
  */
-static _INLINE_ void show_serial_version(void)
+static void show_serial_version(void)
 {
         printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
 }
diff --git a/drivers/char/drm/Kconfig b/drivers/char/drm/Kconfig
index 56ace9d5e2ae..5278c388d3e7 100644
--- a/drivers/char/drm/Kconfig
+++ b/drivers/char/drm/Kconfig
@@ -37,8 +37,8 @@ config DRM_RADEON
         help
           Choose this option if you have an ATI Radeon graphics card.  There
           are both PCI and AGP versions.  You don't need to choose this to
-          run the Radeon in plain VGA mode.  There is a product page at
-          <http://www.ati.com/na/pages/products/pc/radeon32/index.html>.
+          run the Radeon in plain VGA mode.
+          
           If M is selected, the module will be called radeon.
 
 config DRM_I810
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index 0291cd62c69f..ffd0800ed601 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -619,6 +619,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 #endif
                 offset = dev->driver->get_reg_ofs(dev);
 #ifdef __sparc__
+                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
                 if (io_remap_pfn_range(DRM_RPR_ARG(vma) vma->vm_start,
                                        (map->offset + offset) >> PAGE_SHIFT,
                                        vma->vm_end - vma->vm_start,
diff --git a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c
index e38a5f0e07bb..5e59c0b42731 100644
--- a/drivers/char/generic_serial.c
+++ b/drivers/char/generic_serial.c
@@ -48,8 +48,8 @@ static int gs_debug;
 #define NEW_WRITE_LOCKING 1
 #if NEW_WRITE_LOCKING
 #define DECL      /* Nothing */
-#define LOCKIT    down (& port->port_write_sem);
-#define RELEASEIT up (&port->port_write_sem);
+#define LOCKIT    mutex_lock(& port->port_write_mutex);
+#define RELEASEIT mutex_unlock(&port->port_write_mutex);
 #else
 #define DECL      unsigned long flags;
 #define LOCKIT    save_flags (flags);cli ()
@@ -124,14 +124,14 @@ int gs_write(struct tty_struct * tty,
         /* get exclusive "write" access to this port (problem 3) */
         /* This is not a spinlock because we can have a disk access (page 
                  fault) in copy_from_user */
-        down (& port->port_write_sem);
+        mutex_lock(& port->port_write_mutex);
 
         while (1) {
 
                 c = count;
  
                 /* This is safe because we "OWN" the "head". Noone else can 
-                   change the "head": we own the port_write_sem. */
+                   change the "head": we own the port_write_mutex. */
                 /* Don't overrun the end of the buffer */
                 t = SERIAL_XMIT_SIZE - port->xmit_head;
                 if (t < c) c = t;
@@ -153,7 +153,7 @@ int gs_write(struct tty_struct * tty,
                 count -= c;
                 total += c;
         }
-        up (& port->port_write_sem);
+        mutex_unlock(& port->port_write_mutex);
 
         gs_dprintk (GS_DEBUG_WRITE, "write: interrupts are %s\n", 
                     (port->flags & GS_TX_INTEN)?"enabled": "disabled"); 
@@ -214,7 +214,7 @@ int gs_write(struct tty_struct * tty,
                 c = count;
 
                 /* This is safe because we "OWN" the "head". Noone else can 
-                   change the "head": we own the port_write_sem. */
+                   change the "head": we own the port_write_mutex. */
                 /* Don't overrun the end of the buffer */
                 t = SERIAL_XMIT_SIZE - port->xmit_head;
                 if (t < c) c = t;
@@ -888,7 +888,7 @@ int gs_init_port(struct gs_port *port)
         spin_lock_irqsave (&port->driver_lock, flags);
         if (port->tty) 
                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
-        init_MUTEX(&port->port_write_sem);
+        mutex_init(&port->port_write_mutex);
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
         spin_unlock_irqrestore(&port->driver_lock, flags);
         gs_set_termios(port->tty, NULL);
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index 831eb4e8d9d3..f7ac31856572 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -118,7 +118,7 @@
  * the hvcs_final_close() function in order to get it out of the spinlock.
  * Rearranged hvcs_close().  Cleaned up some printks and did some housekeeping
  * on the changelog.  Removed local CLC_LENGTH and used HVCS_CLC_LENGTH from
- * arch/ppc64/hvcserver.h.
+ * include/asm-powerpc/hvcserver.h 
  *
  * 1.3.2 -> 1.3.3 Replaced yield() in hvcs_close() with tty_wait_until_sent() to
  * prevent possible lockup with realtime scheduling as similarily pointed out by
@@ -168,9 +168,10 @@ MODULE_VERSION(HVCS_DRIVER_VERSION);
 
 /*
  * The hcall interface involves putting 8 chars into each of two registers.
- * We load up those 2 registers (in arch/ppc64/hvconsole.c) by casting char[16]
- * to long[2].  It would work without __ALIGNED__, but a little (tiny) bit
- * slower because an unaligned load is slower than aligned load.
+ * We load up those 2 registers (in arch/powerpc/platforms/pseries/hvconsole.c)
+ * by casting char[16] to long[2].  It would work without __ALIGNED__, but a 
+ * little (tiny) bit slower because an unaligned load is slower than aligned 
+ * load.
  */
 #define __ALIGNED__     __attribute__((__aligned__(8)))
 
diff --git a/drivers/char/ip2/Makefile b/drivers/char/ip2/Makefile
new file mode 100644
index 000000000000..6bfe2543ddc2
--- /dev/null
+++ b/drivers/char/ip2/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for the Computone IntelliPort Plus Driver
+#
+
+obj-$(CONFIG_COMPUTONE)         += ip2.o ip2main.o
+
+ip2-objs                        := ip2base.o
+
diff --git a/drivers/char/ip2.c b/drivers/char/ip2/ip2base.c
index 7cadfc6ef352..435ccfc74958 100644
--- a/drivers/char/ip2.c
+++ b/drivers/char/ip2/ip2base.c
@@ -20,14 +20,14 @@
 #define __initdata
 #endif
 
-#include "./ip2/ip2types.h"             
-#include "./ip2/fip_firm.h"             // the meat
+#include "ip2types.h"           
+#include "fip_firm.h"           // the meat
 
 int
 ip2_loadmain(int *, int  *, unsigned char *, int ); // ref into ip2main.c
 
 /* Note: Add compiled in defaults to these arrays, not to the structure
-        in ip2/ip2.h any longer.  That structure WILL get overridden
+        in ip2.h any longer.  That structure WILL get overridden
         by these values, or command line values, or insmod values!!!  =mhw=
 */
 static int io[IP2_MAX_BOARDS]= { 0, 0, 0, 0 };
diff --git a/drivers/char/ip2main.c b/drivers/char/ip2/ip2main.c
index 48fcfba37bfa..03db1cb3fa95 100644
--- a/drivers/char/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -35,7 +35,7 @@
 // Clean up potential NULL pointer dereferences
 // Clean up devfs registration
 // Add kernel command line parsing for io and irq
-//      Compile defaults for io and irq are now set in ip2.c not ip2/ip2.h!
+//      Compile defaults for io and irq are now set in ip2.c not ip2.h!
 // Reworked poll_only hack for explicit parameter setting
 //      You must now EXPLICITLY set poll_only = 1 or set all irqs to 0
 // Merged ip2_loadmain and old_ip2_init
@@ -123,12 +123,12 @@
 
 #include <asm/uaccess.h>
 
-#include "./ip2/ip2types.h"
-#include "./ip2/ip2trace.h"
-#include "./ip2/ip2ioctl.h"
-#include "./ip2/ip2.h"
-#include "./ip2/i2ellis.h"
-#include "./ip2/i2lib.h"
+#include "ip2types.h"
+#include "ip2trace.h"
+#include "ip2ioctl.h"
+#include "ip2.h"
+#include "i2ellis.h"
+#include "i2lib.h"
 
 /*****************
  * /proc/ip2mem  *
@@ -282,9 +282,9 @@ static int tracewrap;
 /* Code */
 /********/
 
-#include "./ip2/i2ellis.c"    /* Extremely low-level interface services */
-#include "./ip2/i2cmd.c"      /* Standard loadware command definitions */
-#include "./ip2/i2lib.c"      /* High level interface services */
+#include "i2ellis.c"    /* Extremely low-level interface services */
+#include "i2cmd.c"      /* Standard loadware command definitions */
+#include "i2lib.c"      /* High level interface services */
 
 /* Configuration area for modprobe */
 
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 28c5a3193b81..ede128356af2 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -181,7 +181,6 @@ static struct tty_driver	*stli_serial;
  *      is already swapping a shared buffer won't make things any worse.
  */
 static char                     *stli_tmpwritebuf;
-static DECLARE_MUTEX(stli_tmpwritesem);
 
 #define STLI_TXBUFSIZE          4096
 
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index ccad7ae94541..ede365d05387 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -132,7 +132,7 @@ static void put_tty_queue(unsigned char c, struct tty_struct *tty)
  *      We test the TTY_THROTTLED bit first so that it always
  *      indicates the current state. The decision about whether
  *      it is worth allowing more input has been taken by the caller.
- *      Can sleep, may be called under the atomic_read semaphore but
+ *      Can sleep, may be called under the atomic_read_lock mutex but
  *      this is not guaranteed.
  */
  
@@ -1132,7 +1132,7 @@ static inline int input_available_p(struct tty_struct *tty, int amt)
  *      buffer, and once to drain the space from the (physical) beginning of
  *      the buffer to head pointer.
  *
- *      Called under the tty->atomic_read sem and with TTY_DONT_FLIP set
+ *      Called under the tty->atomic_read_lock sem and with TTY_DONT_FLIP set
  *
  */
  
@@ -1262,11 +1262,11 @@ do_it_again:
          *      Internal serialization of reads.
          */
         if (file->f_flags & O_NONBLOCK) {
-                if (down_trylock(&tty->atomic_read))
+                if (!mutex_trylock(&tty->atomic_read_lock))
                         return -EAGAIN;
         }
         else {
-                if (down_interruptible(&tty->atomic_read))
+                if (mutex_lock_interruptible(&tty->atomic_read_lock))
                         return -ERESTARTSYS;
         }
 
@@ -1393,7 +1393,7 @@ do_it_again:
                         timeout = time;
         }
         clear_bit(TTY_DONT_FLIP, &tty->flags);
-        up(&tty->atomic_read);
+        mutex_unlock(&tty->atomic_read_lock);
         remove_wait_queue(&tty->read_wait, &wait);
 
         if (!waitqueue_active(&tty->read_wait))
diff --git a/drivers/char/nwflash.c b/drivers/char/nwflash.c
index ca41d62b1d9d..8865387d3448 100644
--- a/drivers/char/nwflash.c
+++ b/drivers/char/nwflash.c
@@ -27,6 +27,7 @@
 #include <linux/rwsem.h>
 #include <linux/init.h>
 #include <linux/smp_lock.h>
+#include <linux/mutex.h>
 
 #include <asm/hardware/dec21285.h>
 #include <asm/io.h>
@@ -56,7 +57,7 @@ static int gbWriteEnable;
 static int gbWriteBase64Enable;
 static volatile unsigned char *FLASH_BASE;
 static int gbFlashSize = KFLASH_SIZE;
-static DECLARE_MUTEX(nwflash_sem);
+static DEFINE_MUTEX(nwflash_mutex);
 
 extern spinlock_t gpio_lock;
 
@@ -140,7 +141,7 @@ static ssize_t flash_read(struct file *file, char __user *buf, size_t size,
                 /*
                  * We now lock against reads and writes. --rmk
                  */
-                if (down_interruptible(&nwflash_sem))
+                if (mutex_lock_interruptible(&nwflash_mutex))
                         return -ERESTARTSYS;
 
                 ret = copy_to_user(buf, (void *)(FLASH_BASE + p), count);
@@ -149,7 +150,7 @@ static ssize_t flash_read(struct file *file, char __user *buf, size_t size,
                         *ppos += count;
                 } else
                         ret = -EFAULT;
-                up(&nwflash_sem);
+                mutex_unlock(&nwflash_mutex);
         }
         return ret;
 }
@@ -188,7 +189,7 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
         /*
          * We now lock against reads and writes. --rmk
          */
-        if (down_interruptible(&nwflash_sem))
+        if (mutex_lock_interruptible(&nwflash_mutex))
                 return -ERESTARTSYS;
 
         written = 0;
@@ -277,7 +278,7 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
          */
         leds_event(led_release);
 
-        up(&nwflash_sem);
+        mutex_unlock(&nwflash_mutex);
 
         return written;
 }
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 30e4cbe16bb0..15a7b4086524 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -19,6 +19,7 @@
 #include <linux/uio.h>
 #include <linux/cdev.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 
 #include <asm/uaccess.h>
 
@@ -29,7 +30,7 @@ struct raw_device_data {
 
 static struct class *raw_class;
 static struct raw_device_data raw_devices[MAX_RAW_MINORS];
-static DECLARE_MUTEX(raw_mutex);
+static DEFINE_MUTEX(raw_mutex);
 static struct file_operations raw_ctl_fops;          /* forward declaration */
 
 /*
@@ -53,7 +54,7 @@ static int raw_open(struct inode *inode, struct file *filp)
                 return 0;
         }
 
-        down(&raw_mutex);
+        mutex_lock(&raw_mutex);
 
         /*
          * All we need to do on open is check that the device is bound.
@@ -78,7 +79,7 @@ static int raw_open(struct inode *inode, struct file *filp)
                 filp->f_dentry->d_inode->i_mapping =
                         bdev->bd_inode->i_mapping;
         filp->private_data = bdev;
-        up(&raw_mutex);
+        mutex_unlock(&raw_mutex);
         return 0;
 
 out2:
@@ -86,7 +87,7 @@ out2:
 out1:
         blkdev_put(bdev);
 out:
-        up(&raw_mutex);
+        mutex_unlock(&raw_mutex);
         return err;
 }
 
@@ -99,14 +100,14 @@ static int raw_release(struct inode *inode, struct file *filp)
         const int minor= iminor(inode);
         struct block_device *bdev;
 
-        down(&raw_mutex);
+        mutex_lock(&raw_mutex);
         bdev = raw_devices[minor].binding;
         if (--raw_devices[minor].inuse == 0) {
                 /* Here  inode->i_mapping == bdev->bd_inode->i_mapping  */
                 inode->i_mapping = &inode->i_data;
                 inode->i_mapping->backing_dev_info = &default_backing_dev_info;
         }
-        up(&raw_mutex);
+        mutex_unlock(&raw_mutex);
 
         bd_release(bdev);
         blkdev_put(bdev);
@@ -187,9 +188,9 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                                 goto out;
                         }
 
-                        down(&raw_mutex);
+                        mutex_lock(&raw_mutex);
                         if (rawdev->inuse) {
-                                up(&raw_mutex);
+                                mutex_unlock(&raw_mutex);
                                 err = -EBUSY;
                                 goto out;
                         }
@@ -211,11 +212,11 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                                         bind_device(&rq);
                                 }
                         }
-                        up(&raw_mutex);
+                        mutex_unlock(&raw_mutex);
                 } else {
                         struct block_device *bdev;
 
-                        down(&raw_mutex);
+                        mutex_lock(&raw_mutex);
                         bdev = rawdev->binding;
                         if (bdev) {
                                 rq.block_major = MAJOR(bdev->bd_dev);
@@ -223,7 +224,7 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                         } else {
                                 rq.block_major = rq.block_minor = 0;
                         }
-                        up(&raw_mutex);
+                        mutex_unlock(&raw_mutex);
                         if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) {
                                 err = -EFAULT;
                                 goto out;
diff --git a/drivers/char/s3c2410-rtc.c b/drivers/char/s3c2410-rtc.c
index 2e308657f6f6..b0038b19b505 100644
--- a/drivers/char/s3c2410-rtc.c
+++ b/drivers/char/s3c2410-rtc.c
@@ -448,13 +448,13 @@ static int s3c2410_rtc_probe(struct platform_device *pdev)
         /* find the IRQs */
 
         s3c2410_rtc_tickno = platform_get_irq(pdev, 1);
-        if (s3c2410_rtc_tickno <= 0) {
+        if (s3c2410_rtc_tickno < 0) {
                 dev_err(&pdev->dev, "no irq for rtc tick\n");
                 return -ENOENT;
         }
 
         s3c2410_rtc_alarmno = platform_get_irq(pdev, 0);
-        if (s3c2410_rtc_alarmno <= 0) {
+        if (s3c2410_rtc_alarmno < 0) {
                 dev_err(&pdev->dev, "no irq for alarm\n");
                 return -ENOENT;
         }
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index fee68cc895f8..510bd3e0e88b 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -97,7 +97,7 @@
 #include <asm/amigahw.h>
 #include <linux/zorro.h>
 #include <asm/irq.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include <linux/delay.h>
 
@@ -654,7 +654,7 @@ static void a2232_init_portstructs(void)
                 port->gs.closing_wait = 30 * HZ;
                 port->gs.rd = &a2232_real_driver;
 #ifdef NEW_WRITE_LOCKING
-                init_MUTEX(&(port->gs.port_write_sem));
+                init_MUTEX(&(port->gs.port_write_mutex));
 #endif
                 init_waitqueue_head(&port->gs.open_wait);
                 init_waitqueue_head(&port->gs.close_wait);
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 0e7d216e7eb0..b543821d8cb4 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2004 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2004, 2006 Silicon Graphics, Inc. All rights reserved.
  */
 
 /*
@@ -77,7 +77,7 @@ scdrv_open(struct inode *inode, struct file *file)
         scd = container_of(inode->i_cdev, struct sysctl_data_s, scd_cdev);
 
         /* allocate memory for subchannel data */
-        sd = kmalloc(sizeof (struct subch_data_s), GFP_KERNEL);
+        sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
         if (sd == NULL) {
                 printk("%s: couldn't allocate subchannel data\n",
                        __FUNCTION__);
@@ -85,7 +85,6 @@ scdrv_open(struct inode *inode, struct file *file)
         }
 
         /* initialize subch_data_s fields */
-        memset(sd, 0, sizeof (struct subch_data_s));
         sd->sd_nasid = scd->scd_nasid;
         sd->sd_subch = ia64_sn_irtr_open(scd->scd_nasid);
 
@@ -394,7 +393,7 @@ scdrv_init(void)
                         sprintf(devnamep, "#%d", geo_slab(geoid));
 
                         /* allocate sysctl device data */
-                        scd = kmalloc(sizeof (struct sysctl_data_s),
+                        scd = kzalloc(sizeof (struct sysctl_data_s),
                                       GFP_KERNEL);
                         if (!scd) {
                                 printk("%s: failed to allocate device info"
@@ -402,7 +401,6 @@ scdrv_init(void)
                                        SYSCTL_BASENAME, devname);
                                 continue;
                         }
-                        memset(scd, 0, sizeof (struct sysctl_data_s));
 
                         /* initialize sysctl device data fields */
                         scd->scd_nasid = cnodeid_to_nasid(cnode);
diff --git a/drivers/char/snsc.h b/drivers/char/snsc.h
index a9efc13cc858..8a98169b60c1 100644
--- a/drivers/char/snsc.h
+++ b/drivers/char/snsc.h
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2004 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
  */
 
 /*
@@ -70,6 +70,9 @@ struct sysctl_data_s {
 #define EV_CLASS_TEST_WARNING   0x6000ul
 #define EV_CLASS_PWRD_NOTIFY    0x8000ul
 
+/* ENV class codes */
+#define ENV_PWRDN_PEND          0x4101ul
+
 #define EV_SEVERITY_POWER_STABLE        0x0000ul
 #define EV_SEVERITY_POWER_LOW_WARNING   0x0100ul
 #define EV_SEVERITY_POWER_HIGH_WARNING  0x0200ul
diff --git a/drivers/char/snsc_event.c b/drivers/char/snsc_event.c
index baaa365285fa..e234d50e142a 100644
--- a/drivers/char/snsc_event.c
+++ b/drivers/char/snsc_event.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2004 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
  */
 
 /*
@@ -187,7 +187,8 @@ scdrv_event_severity(int code)
 static void
 scdrv_dispatch_event(char *event, int len)
 {
-        int code, esp_code, src;
+        static int snsc_shutting_down = 0;
+        int code, esp_code, src, class;
         char desc[CHUNKSIZE];
         char *severity;
 
@@ -199,9 +200,25 @@ scdrv_dispatch_event(char *event, int len)
         /* how urgent is the message? */
         severity = scdrv_event_severity(code);
 
-        if ((code & EV_CLASS_MASK) == EV_CLASS_PWRD_NOTIFY) {
+        class = (code & EV_CLASS_MASK);
+
+        if (class == EV_CLASS_PWRD_NOTIFY || code == ENV_PWRDN_PEND) {
                 struct task_struct *p;
 
+                if (snsc_shutting_down)
+                        return;
+
+                snsc_shutting_down = 1;
+
+                /* give a message for each type of event */
+                if (class == EV_CLASS_PWRD_NOTIFY)
+                        printk(KERN_NOTICE "Power off indication received."
+                               " Sending SIGPWR to init...\n");
+                else if (code == ENV_PWRDN_PEND)
+                        printk(KERN_CRIT "WARNING: Shutting down the system"
+                               " due to a critical environmental condition."
+                               " Sending SIGPWR to init...\n");
+
                 /* give a SIGPWR signal to init proc */
 
                 /* first find init's task */
@@ -210,12 +227,11 @@ scdrv_dispatch_event(char *event, int len)
                         if (p->pid == 1)
                                 break;
                 }
-                if (p) { /* we found init's task */
-                        printk(KERN_EMERG "Power off indication received. Initiating power fail sequence...\n");
+                if (p) {
                         force_sig(SIGPWR, p);
-                } else { /* failed to find init's task - just give message(s) */
-                        printk(KERN_WARNING "Failed to find init proc to handle power off!\n");
-                        printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
+                } else {
+                        printk(KERN_ERR "Failed to signal init!\n");
+                        snsc_shutting_down = 0; /* so can try again (?) */
                 }
                 read_unlock(&tasklist_lock);
         } else {
@@ -271,7 +287,7 @@ scdrv_event_init(struct sysctl_data_s *scd)
 {
         int rv;
 
-        event_sd = kmalloc(sizeof (struct subch_data_s), GFP_KERNEL);
+        event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
         if (event_sd == NULL) {
                 printk(KERN_WARNING "%s: couldn't allocate subchannel info"
                        " for event monitoring\n", __FUNCTION__);
@@ -279,7 +295,6 @@ scdrv_event_init(struct sysctl_data_s *scd)
         }
 
         /* initialize subch_data_s fields */
-        memset(event_sd, 0, sizeof (struct subch_data_s));
         event_sd->sd_nasid = scd->scd_nasid;
         spin_lock_init(&event_sd->sd_rlock);
 
@@ -305,5 +320,3 @@ scdrv_event_init(struct sysctl_data_s *scd)
                 return;
         }
 }
-
-
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index bdaab6992109..3f5d6077f39c 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -148,7 +148,6 @@ static struct tty_driver	*stl_serial;
  *      is already swapping a shared buffer won't make things any worse.
  */
 static char                     *stl_tmpwritebuf;
-static DECLARE_MUTEX(stl_tmpwritesem);
 
 /*
  *      Define a local default termios struct. All ports will be created
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index a6b4f02bdceb..3b4747230270 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -2318,7 +2318,7 @@ static int sx_init_portstructs (int nboards, int nports)
                         port->board = board;
                         port->gs.rd = &sx_real_driver;
 #ifdef NEW_WRITE_LOCKING
-                        port->gs.port_write_sem = MUTEX;
+                        port->gs.port_write_mutex = MUTEX;
 #endif
                         port->gs.driver_lock = SPIN_LOCK_UNLOCKED;
                         /*
diff --git a/drivers/char/tb0219.c b/drivers/char/tb0219.c
index ac2a297ce37c..a80c83210872 100644
--- a/drivers/char/tb0219.c
+++ b/drivers/char/tb0219.c
@@ -283,7 +283,7 @@ static void tb0219_pci_irq_init(void)
         vr41xx_set_irq_level(TB0219_PCI_SLOT3_PIN, IRQ_LEVEL_LOW);
 }
 
-static int tb0219_probe(struct platform_device *dev)
+static int __devinit tb0219_probe(struct platform_device *dev)
 {
         int retval;
 
@@ -319,7 +319,7 @@ static int tb0219_probe(struct platform_device *dev)
         return 0;
 }
 
-static int tb0219_remove(struct platform_device *dev)
+static int __devexit tb0219_remove(struct platform_device *dev)
 {
         _machine_restart = old_machine_restart;
 
@@ -335,19 +335,26 @@ static struct platform_device *tb0219_platform_device;
 
 static struct platform_driver tb0219_device_driver = {
         .probe          = tb0219_probe,
-        .remove         = tb0219_remove,
+        .remove         = __devexit_p(tb0219_remove),
         .driver         = {
                 .name   = "TB0219",
+                .owner  = THIS_MODULE,
         },
 };
 
-static int __devinit tanbac_tb0219_init(void)
+static int __init tanbac_tb0219_init(void)
 {
         int retval;
 
-        tb0219_platform_device = platform_device_register_simple("TB0219", -1, NULL, 0);
-        if (IS_ERR(tb0219_platform_device))
-                return PTR_ERR(tb0219_platform_device);
+        tb0219_platform_device = platform_device_alloc("TB0219", -1);
+        if (!tb0219_platform_device)
+                return -ENOMEM;
+
+        retval = platform_device_add(tb0219_platform_device);
+        if (retval < 0) {
+                platform_device_put(tb0219_platform_device);
+                return retval;
+        }
 
         retval = platform_driver_register(&tb0219_device_driver);
         if (retval < 0)
@@ -356,10 +363,9 @@ static int __devinit tanbac_tb0219_init(void)
         return retval;
 }
 
-static void __devexit tanbac_tb0219_exit(void)
+static void __exit tanbac_tb0219_exit(void)
 {
         platform_driver_unregister(&tb0219_device_driver);
-
         platform_device_unregister(tb0219_platform_device);
 }
 
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 53d3d066554e..76592ee1fb38 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -130,7 +130,7 @@ LIST_HEAD(tty_drivers);			/* linked list of tty drivers */
 
 /* Semaphore to protect creating and releasing a tty. This is shared with
    vt.c for deeply disgusting hack reasons */
-DECLARE_MUTEX(tty_sem);
+DEFINE_MUTEX(tty_mutex);
 
 #ifdef CONFIG_UNIX98_PTYS
 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
@@ -1188,11 +1188,11 @@ void disassociate_ctty(int on_exit)
 
         lock_kernel();
 
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         tty = current->signal->tty;
         if (tty) {
                 tty_pgrp = tty->pgrp;
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
                         tty_vhangup(tty);
         } else {
@@ -1200,7 +1200,7 @@ void disassociate_ctty(int on_exit)
                         kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
                         kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
                 }
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 unlock_kernel();        
                 return;
         }
@@ -1211,7 +1211,7 @@ void disassociate_ctty(int on_exit)
         }
 
         /* Must lock changes to tty_old_pgrp */
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         current->signal->tty_old_pgrp = 0;
         tty->session = 0;
         tty->pgrp = -1;
@@ -1222,7 +1222,7 @@ void disassociate_ctty(int on_exit)
                 p->signal->tty = NULL;
         } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
         read_unlock(&tasklist_lock);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         unlock_kernel();
 }
 
@@ -1306,7 +1306,7 @@ static inline ssize_t do_tty_write(
         ssize_t ret = 0, written = 0;
         unsigned int chunk;
         
-        if (down_interruptible(&tty->atomic_write)) {
+        if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
                 return -ERESTARTSYS;
         }
 
@@ -1329,7 +1329,7 @@ static inline ssize_t do_tty_write(
         if (count < chunk)
                 chunk = count;
 
-        /* write_buf/write_cnt is protected by the atomic_write semaphore */
+        /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
         if (tty->write_cnt < chunk) {
                 unsigned char *buf;
 
@@ -1338,7 +1338,7 @@ static inline ssize_t do_tty_write(
 
                 buf = kmalloc(chunk, GFP_KERNEL);
                 if (!buf) {
-                        up(&tty->atomic_write);
+                        mutex_unlock(&tty->atomic_write_lock);
                         return -ENOMEM;
                 }
                 kfree(tty->write_buf);
@@ -1374,7 +1374,7 @@ static inline ssize_t do_tty_write(
                 inode->i_mtime = current_fs_time(inode->i_sb);
                 ret = written;
         }
-        up(&tty->atomic_write);
+        mutex_unlock(&tty->atomic_write_lock);
         return ret;
 }
 
@@ -1442,8 +1442,8 @@ static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
 
 /*
  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
- * failed open.  The new code protects the open with a semaphore, so it's
- * really quite straightforward.  The semaphore locking can probably be
+ * failed open.  The new code protects the open with a mutex, so it's
+ * really quite straightforward.  The mutex locking can probably be
  * relaxed for the (most common) case of reopening a tty.
  */
 static int init_dev(struct tty_driver *driver, int idx,
@@ -1640,7 +1640,7 @@ fast_track:
 success:
         *ret_tty = tty;
         
-        /* All paths come through here to release the semaphore */
+        /* All paths come through here to release the mutex */
 end_init:
         return retval;
 
@@ -1837,7 +1837,7 @@ static void release_dev(struct file * filp)
                 /* Guard against races with tty->count changes elsewhere and
                    opens on /dev/tty */
                    
-                down(&tty_sem);
+                mutex_lock(&tty_mutex);
                 tty_closing = tty->count <= 1;
                 o_tty_closing = o_tty &&
                         (o_tty->count <= (pty_master ? 1 : 0));
@@ -1868,7 +1868,7 @@ static void release_dev(struct file * filp)
 
                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
                                     "active!\n", tty_name(tty, buf));
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 schedule();
         }       
 
@@ -1934,7 +1934,7 @@ static void release_dev(struct file * filp)
                 read_unlock(&tasklist_lock);
         }
 
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
 
         /* check whether both sides are closing ... */
         if (!tty_closing || (o_tty && !o_tty_closing))
@@ -2040,11 +2040,11 @@ retry_open:
         index  = -1;
         retval = 0;
         
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
 
         if (device == MKDEV(TTYAUX_MAJOR,0)) {
                 if (!current->signal->tty) {
-                        up(&tty_sem);
+                        mutex_unlock(&tty_mutex);
                         return -ENXIO;
                 }
                 driver = current->signal->tty->driver;
@@ -2070,18 +2070,18 @@ retry_open:
                         noctty = 1;
                         goto got_driver;
                 }
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 return -ENODEV;
         }
 
         driver = get_tty_driver(device, &index);
         if (!driver) {
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 return -ENODEV;
         }
 got_driver:
         retval = init_dev(driver, index, &tty);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         if (retval)
                 return retval;
 
@@ -2167,9 +2167,9 @@ static int ptmx_open(struct inode * inode, struct file * filp)
         }
         up(&allocated_ptys_lock);
 
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         retval = init_dev(ptm_driver, index, &tty);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         
         if (retval)
                 goto out;
@@ -2915,8 +2915,8 @@ static void initialize_tty_struct(struct tty_struct *tty)
         init_waitqueue_head(&tty->write_wait);
         init_waitqueue_head(&tty->read_wait);
         INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
-        sema_init(&tty->atomic_read, 1);
-        sema_init(&tty->atomic_write, 1);
+        mutex_init(&tty->atomic_read_lock);
+        mutex_init(&tty->atomic_write_lock);
         spin_lock_init(&tty->read_lock);
         INIT_LIST_HEAD(&tty->tty_files);
         INIT_WORK(&tty->SAK_work, NULL, NULL);
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index d9325281e482..fd00822ac145 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -184,7 +184,7 @@ static void scc_init_portstructs(void)
                 port->gs.closing_wait = 30 * HZ;
                 port->gs.rd = &scc_real_driver;
 #ifdef NEW_WRITE_LOCKING
-                port->gs.port_write_sem = MUTEX;
+                port->gs.port_write_mutex = MUTEX;
 #endif
                 init_waitqueue_head(&port->gs.open_wait);
                 init_waitqueue_head(&port->gs.close_wait);
diff --git a/drivers/char/vr41xx_giu.c b/drivers/char/vr41xx_giu.c
index 2267c7b81799..05e6e814d86f 100644
--- a/drivers/char/vr41xx_giu.c
+++ b/drivers/char/vr41xx_giu.c
@@ -613,7 +613,7 @@ static struct file_operations gpio_fops = {
         .release        = gpio_release,
 };
 
-static int giu_probe(struct platform_device *dev)
+static int __devinit giu_probe(struct platform_device *dev)
 {
         unsigned long start, size, flags = 0;
         unsigned int nr_pins = 0;
@@ -697,7 +697,7 @@ static int giu_probe(struct platform_device *dev)
         return cascade_irq(GIUINT_IRQ, giu_get_irq);
 }
 
-static int giu_remove(struct platform_device *dev)
+static int __devexit giu_remove(struct platform_device *dev)
 {
         iounmap(giu_base);
 
@@ -712,9 +712,10 @@ static struct platform_device *giu_platform_device;
 
 static struct platform_driver giu_device_driver = {
         .probe          = giu_probe,
-        .remove         = giu_remove,
+        .remove         = __devexit_p(giu_remove),
         .driver         = {
                 .name   = "GIU",
+                .owner  = THIS_MODULE,
         },
 };
 
@@ -722,9 +723,15 @@ static int __init vr41xx_giu_init(void)
 {
         int retval;
 
-        giu_platform_device = platform_device_register_simple("GIU", -1, NULL, 0);
-        if (IS_ERR(giu_platform_device))
-                return PTR_ERR(giu_platform_device);
+        giu_platform_device = platform_device_alloc("GIU", -1);
+        if (!giu_platform_device)
+                return -ENOMEM;
+
+        retval = platform_device_add(giu_platform_device);
+        if (retval < 0) {
+                platform_device_put(giu_platform_device);
+                return retval;
+        }
 
         retval = platform_driver_register(&giu_device_driver);
         if (retval < 0)
diff --git a/drivers/char/vr41xx_rtc.c b/drivers/char/vr41xx_rtc.c
index bc1b4a15212c..b109d9a502d6 100644
--- a/drivers/char/vr41xx_rtc.c
+++ b/drivers/char/vr41xx_rtc.c
@@ -558,7 +558,7 @@ static struct miscdevice rtc_miscdevice = {
         .fops   = &rtc_fops,
 };
 
-static int rtc_probe(struct platform_device *pdev)
+static int __devinit rtc_probe(struct platform_device *pdev)
 {
         unsigned int irq;
         int retval;
@@ -631,7 +631,7 @@ static int rtc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int rtc_remove(struct platform_device *dev)
+static int __devexit rtc_remove(struct platform_device *dev)
 {
         int retval;
 
@@ -653,13 +653,14 @@ static struct platform_device *rtc_platform_device;
 
 static struct platform_driver rtc_device_driver = {
         .probe          = rtc_probe,
-        .remove         = rtc_remove,
+        .remove         = __devexit_p(rtc_remove),
         .driver         = {
                 .name   = rtc_name,
+                .owner  = THIS_MODULE,
         },
 };
 
-static int __devinit vr41xx_rtc_init(void)
+static int __init vr41xx_rtc_init(void)
 {
         int retval;
 
@@ -684,10 +685,20 @@ static int __devinit vr41xx_rtc_init(void)
                 break;
         }
 
-        rtc_platform_device = platform_device_register_simple("RTC", -1,
-                              rtc_resource, ARRAY_SIZE(rtc_resource));
-        if (IS_ERR(rtc_platform_device))
-                return PTR_ERR(rtc_platform_device);
+        rtc_platform_device = platform_device_alloc("RTC", -1);
+        if (!rtc_platform_device)
+                return -ENOMEM;
+
+        retval = platform_device_add_resources(rtc_platform_device,
+                                rtc_resource, ARRAY_SIZE(rtc_resource));
+
+        if (retval == 0)
+                retval = platform_device_add(rtc_platform_device);
+
+        if (retval < 0) {
+                platform_device_put(rtc_platform_device);
+                return retval;
+        }
 
         retval = platform_driver_register(&rtc_device_driver);
         if (retval < 0)
@@ -696,10 +707,9 @@ static int __devinit vr41xx_rtc_init(void)
         return retval;
 }
 
-static void __devexit vr41xx_rtc_exit(void)
+static void __exit vr41xx_rtc_exit(void)
 {
         platform_driver_unregister(&rtc_device_driver);
-
         platform_device_unregister(rtc_platform_device);
 }
 
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 0900d1dbee59..ca4844c527da 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -2489,7 +2489,7 @@ static int con_open(struct tty_struct *tty, struct file *filp)
 }
 
 /*
- * We take tty_sem in here to prevent another thread from coming in via init_dev
+ * We take tty_mutex in here to prevent another thread from coming in via init_dev
  * and taking a ref against the tty while we're in the process of forgetting
  * about it and cleaning things up.
  *
@@ -2497,7 +2497,7 @@ static int con_open(struct tty_struct *tty, struct file *filp)
  */
 static void con_close(struct tty_struct *tty, struct file *filp)
 {
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         acquire_console_sem();
         if (tty && tty->count == 1) {
                 struct vc_data *vc = tty->driver_data;
@@ -2507,15 +2507,15 @@ static void con_close(struct tty_struct *tty, struct file *filp)
                 tty->driver_data = NULL;
                 release_console_sem();
                 vcs_remove_devfs(tty);
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 /*
-                 * tty_sem is released, but we still hold BKL, so there is
+                 * tty_mutex is released, but we still hold BKL, so there is
                  * still exclusion against init_dev()
                  */
                 return;
         }
         release_console_sem();
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
 }
 
 static void vc_init(struct vc_data *vc, unsigned int rows,
@@ -2869,9 +2869,9 @@ void unblank_screen(void)
 }
 
 /*
- * We defer the timer blanking to work queue so it can take the console semaphore
+ * We defer the timer blanking to work queue so it can take the console mutex
  * (console operations can still happen at irq time, but only from printk which
- * has the console semaphore. Not perfect yet, but better than no locking
+ * has the console mutex. Not perfect yet, but better than no locking
  */
 static void blank_screen_t(unsigned long dummy)
 {
@@ -3234,6 +3234,14 @@ void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org)
         }
 }
 
+int is_console_suspend_safe(void)
+{
+        /* It is unsafe to suspend devices while X has control of the
+         * hardware. Make sure we are running on a kernel-controlled console.
+         */
+        return vc_cons[fg_console].d->vc_mode == KD_TEXT;
+}
+
 /*
  *      Visible symbols for modules
  */
diff --git a/drivers/char/watchdog/mpcore_wdt.c b/drivers/char/watchdog/mpcore_wdt.c
index b4d843489881..2c2c51773200 100644
--- a/drivers/char/watchdog/mpcore_wdt.c
+++ b/drivers/char/watchdog/mpcore_wdt.c
@@ -338,6 +338,10 @@ static int __devinit mpcore_wdt_probe(struct platform_device *dev)
 
         wdt->dev = &dev->dev;
         wdt->irq = platform_get_irq(dev, 0);
+        if (wdt->irq < 0) {
+                ret = -ENXIO;
+                goto err_free;
+        }
         wdt->base = ioremap(res->start, res->end - res->start + 1);
         if (!wdt->base) {
                 ret = -ENOMEM;
diff --git a/drivers/char/watchdog/mv64x60_wdt.c b/drivers/char/watchdog/mv64x60_wdt.c
index 00d9ef04a369..f1b9cf89f153 100644
--- a/drivers/char/watchdog/mv64x60_wdt.c
+++ b/drivers/char/watchdog/mv64x60_wdt.c
@@ -228,15 +228,25 @@ static int __init mv64x60_wdt_init(void)
 
         printk(KERN_INFO "MV64x60 watchdog driver\n");
 
-        mv64x60_wdt_dev = platform_device_register_simple(MV64x60_WDT_NAME,
-                                                          -1, NULL, 0);
-        if (IS_ERR(mv64x60_wdt_dev)) {
-                ret = PTR_ERR(mv64x60_wdt_dev);
+        mv64x60_wdt_dev = platform_device_alloc(MV64x60_WDT_NAME, -1);
+        if (!mv64x60_wdt_dev) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        ret = platform_device_add(mv64x60_wdt_dev);
+        if (ret) {
+                platform_device_put(mv64x60_wdt_dev);
                 goto out;
         }
 
         ret = platform_driver_register(&mv64x60_wdt_driver);
-      out:
+        if (ret) {
+                platform_device_unregister(mv64x60_wdt_dev);
+                goto out;
+        }
+
+ out:
         return ret;
 }
 
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index 1533f56baa42..2700c5c45b8a 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -42,6 +42,7 @@
 #include <linux/completion.h>
 #include <asm/uaccess.h>
 #include <linux/usb.h>
+#include <linux/mutex.h>
 
 
 #ifdef CONFIG_USB_DEBUG
@@ -143,7 +144,7 @@ struct usb_pcwd_private {
 static struct usb_pcwd_private *usb_pcwd_device;
 
 /* prevent races between open() and disconnect() */
-static DECLARE_MUTEX (disconnect_sem);
+static DEFINE_MUTEX(disconnect_mutex);
 
 /* local function prototypes */
 static int usb_pcwd_probe       (struct usb_interface *interface, const struct usb_device_id *id);
@@ -723,7 +724,7 @@ static void usb_pcwd_disconnect(struct usb_interface *interface)
         struct usb_pcwd_private *usb_pcwd;
 
         /* prevent races with open() */
-        down (&disconnect_sem);
+        mutex_lock(&disconnect_mutex);
 
         usb_pcwd = usb_get_intfdata (interface);
         usb_set_intfdata (interface, NULL);
@@ -749,7 +750,7 @@ static void usb_pcwd_disconnect(struct usb_interface *interface)
 
         cards_found--;
 
-        up (&disconnect_sem);
+        mutex_unlock(&disconnect_mutex);
 
         printk(KERN_INFO PFX "USB PC Watchdog disconnected\n");
 }