154 files changed, 1573 insertions, 1022 deletions

diff --git a/Documentation/block/barrier.txt b/Documentation/block/barrier.txt
index 7d279f2f5bb..2c2f24f634e 100644
--- a/Documentation/block/barrier.txt
+++ b/Documentation/block/barrier.txt
@@ -79,9 +79,9 @@ and how to prepare flush requests.  Note that the term 'ordered' is
 used to indicate the whole sequence of performing barrier requests
 including draining and flushing.
 
-typedef void (prepare_flush_fn)(request_queue_t *q, struct request *rq);
+typedef void (prepare_flush_fn)(struct request_queue *q, struct request *rq);
 
-int blk_queue_ordered(request_queue_t *q, unsigned ordered,
+int blk_queue_ordered(struct request_queue *q, unsigned ordered,
                       prepare_flush_fn *prepare_flush_fn);
 
 @q                      : the queue in question
@@ -92,7 +92,7 @@ int blk_queue_ordered(request_queue_t *q, unsigned ordered,
 For example, SCSI disk driver's prepare_flush_fn looks like the
 following.
 
-static void sd_prepare_flush(request_queue_t *q, struct request *rq)
+static void sd_prepare_flush(struct request_queue *q, struct request *rq)
 {
         memset(rq->cmd, 0, sizeof(rq->cmd));
         rq->cmd_type = REQ_TYPE_BLOCK_PC;
diff --git a/Documentation/block/biodoc.txt b/Documentation/block/biodoc.txt
index 3adaace328a..8af392fc6ef 100644
--- a/Documentation/block/biodoc.txt
+++ b/Documentation/block/biodoc.txt
@@ -740,12 +740,12 @@ Block now offers some simple generic functionality to help support command
 queueing (typically known as tagged command queueing), ie manage more than
 one outstanding command on a queue at any given time.
 
-        blk_queue_init_tags(request_queue_t *q, int depth)
+        blk_queue_init_tags(struct request_queue *q, int depth)
 
         Initialize internal command tagging structures for a maximum
         depth of 'depth'.
 
-        blk_queue_free_tags((request_queue_t *q)
+        blk_queue_free_tags((struct request_queue *q)
 
         Teardown tag info associated with the queue. This will be done
         automatically by block if blk_queue_cleanup() is called on a queue
@@ -754,7 +754,7 @@ one outstanding command on a queue at any given time.
 The above are initialization and exit management, the main helpers during
 normal operations are:
 
-        blk_queue_start_tag(request_queue_t *q, struct request *rq)
+        blk_queue_start_tag(struct request_queue *q, struct request *rq)
 
         Start tagged operation for this request. A free tag number between
         0 and 'depth' is assigned to the request (rq->tag holds this number),
@@ -762,7 +762,7 @@ normal operations are:
         for this queue is already achieved (or if the tag wasn't started for
         some other reason), 1 is returned. Otherwise 0 is returned.
 
-        blk_queue_end_tag(request_queue_t *q, struct request *rq)
+        blk_queue_end_tag(struct request_queue *q, struct request *rq)
 
         End tagged operation on this request. 'rq' is removed from the internal
         book keeping structures.
@@ -781,7 +781,7 @@ queue. For instance, on IDE any tagged request error needs to clear both
 the hardware and software block queue and enable the driver to sanely restart
 all the outstanding requests. There's a third helper to do that:
 
-        blk_queue_invalidate_tags(request_queue_t *q)
+        blk_queue_invalidate_tags(struct request_queue *q)
 
         Clear the internal block tag queue and re-add all the pending requests
         to the request queue. The driver will receive them again on the
diff --git a/Documentation/block/request.txt b/Documentation/block/request.txt
index 75924e2a697..fff58acb40a 100644
--- a/Documentation/block/request.txt
+++ b/Documentation/block/request.txt
@@ -83,6 +83,6 @@ struct bio *bio			DBI	First bio in request
 
 struct bio *biotail             DBI     Last bio in request
 
-request_queue_t *q              DB      Request queue this request belongs to
+struct request_queue *q         DB      Request queue this request belongs to
 
 struct request_list *rl         B       Request list this request came from
diff --git a/Documentation/gpio.txt b/Documentation/gpio.txt
index 218a8650f48..6bc2ba215df 100644
--- a/Documentation/gpio.txt
+++ b/Documentation/gpio.txt
@@ -148,7 +148,7 @@ pin ... that won't always match the specified output value, because of
 issues including wire-OR and output latencies.
 
 The get/set calls have no error returns because "invalid GPIO" should have
-been reported earlier in gpio_set_direction().  However, note that not all
+been reported earlier from gpio_direction_*().  However, note that not all
 platforms can read the value of output pins; those that can't should always
 return zero.  Also, using these calls for GPIOs that can't safely be accessed
 without sleeping (see below) is an error.
@@ -239,7 +239,7 @@ map between them using calls like:
 Those return either the corresponding number in the other namespace, or
 else a negative errno code if the mapping can't be done.  (For example,
 some GPIOs can't used as IRQs.)  It is an unchecked error to use a GPIO
-number that hasn't been marked as an input using gpio_set_direction(), or
+number that wasn't set up as an input using gpio_direction_input(), or
 to use an IRQ number that didn't originally come from gpio_to_irq().
 
 These two mapping calls are expected to cost on the order of a single
diff --git a/Documentation/iostats.txt b/Documentation/iostats.txt
index 09a1bafe252..b963c3b4afa 100644
--- a/Documentation/iostats.txt
+++ b/Documentation/iostats.txt
@@ -79,7 +79,7 @@ Field  8 -- # of milliseconds spent writing
     measured from __make_request() to end_that_request_last()).
 Field  9 -- # of I/Os currently in progress
     The only field that should go to zero. Incremented as requests are
-    given to appropriate request_queue_t and decremented as they finish.
+    given to appropriate struct request_queue and decremented as they finish.
 Field 10 -- # of milliseconds spent doing I/Os
     This field is increases so long as field 9 is nonzero.
 Field 11 -- weighted # of milliseconds spent doing I/Os
diff --git a/Documentation/lguest/Makefile b/Documentation/lguest/Makefile
index b9b9427376e..31e794ef5f9 100644
--- a/Documentation/lguest/Makefile
+++ b/Documentation/lguest/Makefile
@@ -11,8 +11,7 @@ endif
 include $(KBUILD_OUTPUT)/.config
 LGUEST_GUEST_TOP := ($(CONFIG_PAGE_OFFSET) - 0x08000000)
 
-CFLAGS:=-Wall -Wmissing-declarations -Wmissing-prototypes -O3 \
-        -static -DLGUEST_GUEST_TOP="$(LGUEST_GUEST_TOP)" -Wl,-T,lguest.lds
+CFLAGS:=-Wall -Wmissing-declarations -Wmissing-prototypes -O3 -Wl,-T,lguest.lds
 LDLIBS:=-lz
 
 all: lguest.lds lguest
diff --git a/Documentation/lguest/lguest.c b/Documentation/lguest/lguest.c
index 1432b502a2d..62a8133393e 100644
--- a/Documentation/lguest/lguest.c
+++ b/Documentation/lguest/lguest.c
@@ -47,12 +47,14 @@ static bool verbose;
 #define verbose(args...) \
         do { if (verbose) printf(args); } while(0)
 static int waker_fd;
+static u32 top;
 
 struct device_list
 {
         fd_set infds;
         int max_infd;
 
+        struct lguest_device_desc *descs;
         struct device *dev;
         struct device **lastdev;
 };
@@ -324,8 +326,7 @@ static void concat(char *dst, char *args[])
 static int tell_kernel(u32 pgdir, u32 start, u32 page_offset)
 {
         u32 args[] = { LHREQ_INITIALIZE,
-                       LGUEST_GUEST_TOP/getpagesize(), /* Just below us */
-                       pgdir, start, page_offset };
+                       top/getpagesize(), pgdir, start, page_offset };
         int fd;
 
         fd = open_or_die("/dev/lguest", O_RDWR);
@@ -382,7 +383,7 @@ static int setup_waker(int lguest_fd, struct device_list *device_list)
 static void *_check_pointer(unsigned long addr, unsigned int size,
                             unsigned int line)
 {
-        if (addr >= LGUEST_GUEST_TOP || addr + size >= LGUEST_GUEST_TOP)
+        if (addr >= top || addr + size >= top)
                 errx(1, "%s:%i: Invalid address %li", __FILE__, line, addr);
         return (void *)addr;
 }
@@ -629,24 +630,26 @@ static void handle_input(int fd, struct device_list *devices)
         }
 }
 
-static struct lguest_device_desc *new_dev_desc(u16 type, u16 features,
-                                               u16 num_pages)
+static struct lguest_device_desc *
+new_dev_desc(struct lguest_device_desc *descs,
+             u16 type, u16 features, u16 num_pages)
 {
-        static unsigned long top = LGUEST_GUEST_TOP;
-        struct lguest_device_desc *desc;
+        unsigned int i;
 
-        desc = malloc(sizeof(*desc));
-        desc->type = type;
-        desc->num_pages = num_pages;
-        desc->features = features;
-        desc->status = 0;
-        if (num_pages) {
-                top -= num_pages*getpagesize();
-                map_zeroed_pages(top, num_pages);
-                desc->pfn = top / getpagesize();
-        } else
-                desc->pfn = 0;
-        return desc;
+        for (i = 0; i < LGUEST_MAX_DEVICES; i++) {
+                if (!descs[i].type) {
+                        descs[i].type = type;
+                        descs[i].features = features;
+                        descs[i].num_pages = num_pages;
+                        if (num_pages) {
+                                map_zeroed_pages(top, num_pages);
+                                descs[i].pfn = top/getpagesize();
+                                top += num_pages*getpagesize();
+                        }
+                        return &descs[i];
+                }
+        }
+        errx(1, "too many devices");
 }
 
 static struct device *new_device(struct device_list *devices,
@@ -669,7 +672,7 @@ static struct device *new_device(struct device_list *devices,
         dev->fd = fd;
         if (handle_input)
                 set_fd(dev->fd, devices);
-        dev->desc = new_dev_desc(type, features, num_pages);
+        dev->desc = new_dev_desc(devices->descs, type, features, num_pages);
         dev->mem = (void *)(dev->desc->pfn * getpagesize());
         dev->handle_input = handle_input;
         dev->watch_key = (unsigned long)dev->mem + watch_off;
@@ -866,30 +869,6 @@ static void setup_tun_net(const char *arg, struct device_list *devices)
                 verbose("attached to bridge: %s\n", br_name);
 }
 
-/* Now we know how much memory we have, we copy in device descriptors */
-static void map_device_descriptors(struct device_list *devs, unsigned long mem)
-{
-        struct device *i;
-        unsigned int num;
-        struct lguest_device_desc *descs;
-
-        /* Device descriptor array sits just above top of normal memory */
-        descs = map_zeroed_pages(mem, 1);
-
-        for (i = devs->dev, num = 0; i; i = i->next, num++) {
-                if (num == LGUEST_MAX_DEVICES)
-                        errx(1, "too many devices");
-                verbose("Device %i: %s\n", num,
-                        i->desc->type == LGUEST_DEVICE_T_NET ? "net"
-                        : i->desc->type == LGUEST_DEVICE_T_CONSOLE ? "console"
-                        : i->desc->type == LGUEST_DEVICE_T_BLOCK ? "block"
-                        : "unknown");
-                descs[num] = *i->desc;
-                free(i->desc);
-                i->desc = &descs[num];
-        }
-}
-
 static void __attribute__((noreturn))
 run_guest(int lguest_fd, struct device_list *device_list)
 {
@@ -934,8 +913,8 @@ static void usage(void)
 
 int main(int argc, char *argv[])
 {
-        unsigned long mem, pgdir, start, page_offset, initrd_size = 0;
-        int c, lguest_fd;
+        unsigned long mem = 0, pgdir, start, page_offset, initrd_size = 0;
+        int i, c, lguest_fd;
         struct device_list device_list;
         void *boot = (void *)0;
         const char *initrd_name = NULL;
@@ -945,6 +924,15 @@ int main(int argc, char *argv[])
         device_list.lastdev = &device_list.dev;
         FD_ZERO(&device_list.infds);
 
+        /* We need to know how much memory so we can allocate devices. */
+        for (i = 1; i < argc; i++) {
+                if (argv[i][0] != '-') {
+                        mem = top = atoi(argv[i]) * 1024 * 1024;
+                        device_list.descs = map_zeroed_pages(top, 1);
+                        top += getpagesize();
+                        break;
+                }
+        }
         while ((c = getopt_long(argc, argv, "v", opts, NULL)) != EOF) {
                 switch (c) {
                 case 'v':
@@ -974,16 +962,12 @@ int main(int argc, char *argv[])
         setup_console(&device_list);
 
         /* First we map /dev/zero over all of guest-physical memory. */
-        mem = atoi(argv[optind]) * 1024 * 1024;
         map_zeroed_pages(0, mem / getpagesize());
 
         /* Now we load the kernel */
         start = load_kernel(open_or_die(argv[optind+1], O_RDONLY),
                             &page_offset);
 
-        /* Write the device descriptors into memory. */
-        map_device_descriptors(&device_list, mem);
-
         /* Map the initrd image if requested */
         if (initrd_name) {
                 initrd_size = load_initrd(initrd_name, mem);
diff --git a/arch/arm/plat-omap/mailbox.c b/arch/arm/plat-omap/mailbox.c
index de7e6ef48bd..0360b1f14d1 100644
--- a/arch/arm/plat-omap/mailbox.c
+++ b/arch/arm/plat-omap/mailbox.c
@@ -161,11 +161,11 @@ static void mbox_rx_work(struct work_struct *work)
 /*
  * Mailbox interrupt handler
  */
-static void mbox_txq_fn(request_queue_t * q)
+static void mbox_txq_fn(struct request_queue * q)
 {
 }
 
-static void mbox_rxq_fn(request_queue_t * q)
+static void mbox_rxq_fn(struct request_queue * q)
 {
 }
 
@@ -180,7 +180,7 @@ static void __mbox_rx_interrupt(struct omap_mbox *mbox)
 {
         struct request *rq;
         mbox_msg_t msg;
-        request_queue_t *q = mbox->rxq->queue;
+        struct request_queue *q = mbox->rxq->queue;
 
         disable_mbox_irq(mbox, IRQ_RX);
 
@@ -297,7 +297,7 @@ static struct omap_mbox_queue *mbox_queue_alloc(struct omap_mbox *mbox,
                                         request_fn_proc * proc,
                                         void (*work) (struct work_struct *))
 {
-        request_queue_t *q;
+        struct request_queue *q;
         struct omap_mbox_queue *mq;
 
         mq = kzalloc(sizeof(struct omap_mbox_queue), GFP_KERNEL);
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index 8b20c0c1556..2bfdeb8ea8b 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -40,13 +40,10 @@ enum {
 struct spu_context_ops;
 struct spu_gang;
 
-enum {
-        SPU_SCHED_WAS_ACTIVE,   /* was active upon spu_acquire_saved()  */
-};
-
 /* ctx->sched_flags */
 enum {
         SPU_SCHED_NOTIFY_ACTIVE,
+        SPU_SCHED_WAS_ACTIVE,   /* was active upon spu_acquire_saved()  */
 };
 
 struct spu_context {
diff --git a/arch/sparc/defconfig b/arch/sparc/defconfig
index 38bd79fe6e7..fdc67238408 100644
--- a/arch/sparc/defconfig
+++ b/arch/sparc/defconfig
@@ -600,7 +600,7 @@ CONFIG_LEGACY_PTY_COUNT=256
 # CONFIG_IPMI_HANDLER is not set
 # CONFIG_WATCHDOG is not set
 CONFIG_HW_RANDOM=m
-CONFIG_RTC=m
+CONFIG_JS_RTC=m
 # CONFIG_R3964 is not set
 # CONFIG_APPLICOM is not set
 # CONFIG_DRM is not set
diff --git a/arch/sparc/kernel/sparc_ksyms.c b/arch/sparc/kernel/sparc_ksyms.c
index 55bac516dfe..7b4abde4302 100644
--- a/arch/sparc/kernel/sparc_ksyms.c
+++ b/arch/sparc/kernel/sparc_ksyms.c
@@ -161,6 +161,8 @@ EXPORT_SYMBOL(BTFIXUP_CALL(mmu_get_scsi_one));
 EXPORT_SYMBOL(BTFIXUP_CALL(mmu_release_scsi_sgl));
 EXPORT_SYMBOL(BTFIXUP_CALL(mmu_release_scsi_one));
 
+EXPORT_SYMBOL(BTFIXUP_CALL(pgprot_noncached));
+
 #ifdef CONFIG_SBUS
 EXPORT_SYMBOL(sbus_root);
 EXPORT_SYMBOL(dma_chain);
@@ -260,6 +262,7 @@ EXPORT_SYMBOL(__memmove);
 /* Moving data to/from userspace. */
 EXPORT_SYMBOL(__copy_user);
 EXPORT_SYMBOL(__strncpy_from_user);
+EXPORT_SYMBOL(__strnlen_user);
 
 /* Networking helper routines. */
 EXPORT_SYMBOL(__csum_partial_copy_sparc_generic);
diff --git a/arch/sparc/kernel/vmlinux.lds.S b/arch/sparc/kernel/vmlinux.lds.S
index 47583887abc..15109c156e8 100644
--- a/arch/sparc/kernel/vmlinux.lds.S
+++ b/arch/sparc/kernel/vmlinux.lds.S
@@ -35,6 +35,8 @@ SECTIONS
   __ex_table : { *(__ex_table) }
   __stop___ex_table = .;
 
+  NOTES
+
   . = ALIGN(4096);
   __init_begin = .;
   _sinittext = .;
diff --git a/arch/sparc/lib/memset.S b/arch/sparc/lib/memset.S
index a65eba41097..1c37ea892de 100644
--- a/arch/sparc/lib/memset.S
+++ b/arch/sparc/lib/memset.S
@@ -162,7 +162,7 @@ __bzero:
 8:
          add    %o0, 1, %o0
         subcc   %o1, 1, %o1
-        bne,a   8b
+        bne     8b
          EX(stb %g3, [%o0 - 1], add %o1, 1)
 0:
         retl
diff --git a/arch/sparc/prom/printf.c b/arch/sparc/prom/printf.c
index 27fdac99f79..a36ab9c5ee0 100644
--- a/arch/sparc/prom/printf.c
+++ b/arch/sparc/prom/printf.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 
 #include <asm/openprom.h>
 #include <asm/oplib.h>
@@ -44,3 +45,4 @@ prom_printf(char *fmt, ...)
 
         prom_write(ppbuf, i);
 }
+EXPORT_SYMBOL(prom_printf);
diff --git a/arch/sparc64/defconfig b/arch/sparc64/defconfig
index 10e301970a4..68338a601f7 100644
--- a/arch/sparc64/defconfig
+++ b/arch/sparc64/defconfig
@@ -1,11 +1,12 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.22
-# Thu Jul 19 21:30:37 2007
+# Linux kernel version: 2.6.23-rc1
+# Sun Jul 22 19:24:37 2007
 #
 CONFIG_SPARC=y
 CONFIG_SPARC64=y
 CONFIG_GENERIC_TIME=y
+CONFIG_GENERIC_CMOS_UPDATE=y
 CONFIG_GENERIC_CLOCKEVENTS=y
 CONFIG_64BIT=y
 CONFIG_MMU=y
@@ -17,6 +18,7 @@ CONFIG_ARCH_MAY_HAVE_PC_FDC=y
 # CONFIG_ARCH_HAS_ILOG2_U64 is not set
 CONFIG_AUDIT_ARCH=y
 CONFIG_ARCH_NO_VIRT_TO_BUS=y
+CONFIG_OF=y
 CONFIG_SPARC64_PAGE_SIZE_8KB=y
 # CONFIG_SPARC64_PAGE_SIZE_64KB is not set
 # CONFIG_SPARC64_PAGE_SIZE_512KB is not set
@@ -314,6 +316,7 @@ CONFIG_FW_LOADER=y
 # CONFIG_SYS_HYPERVISOR is not set
 CONFIG_CONNECTOR=m
 # CONFIG_MTD is not set
+CONFIG_OF_DEVICE=y
 # CONFIG_PARPORT is not set
 CONFIG_BLK_DEV=y
 # CONFIG_BLK_DEV_FD is not set
@@ -433,10 +436,7 @@ CONFIG_SCSI_FC_ATTRS=y
 CONFIG_SCSI_ISCSI_ATTRS=m
 # CONFIG_SCSI_SAS_ATTRS is not set
 # CONFIG_SCSI_SAS_LIBSAS is not set
-
-#
-# SCSI low-level drivers
-#
+CONFIG_SCSI_LOWLEVEL=y
 CONFIG_ISCSI_TCP=m
 # CONFIG_BLK_DEV_3W_XXXX_RAID is not set
 # CONFIG_SCSI_3W_9XXX is not set
@@ -701,7 +701,6 @@ CONFIG_UNIX98_PTYS=y
 # CONFIG_IPMI_HANDLER is not set
 # CONFIG_WATCHDOG is not set
 # CONFIG_HW_RANDOM is not set
-CONFIG_RTC=y
 # CONFIG_R3964 is not set
 # CONFIG_APPLICOM is not set
 # CONFIG_DRM is not set
@@ -844,6 +843,7 @@ CONFIG_HWMON=y
 #
 # CONFIG_DISPLAY_SUPPORT is not set
 # CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
 CONFIG_FB=y
 # CONFIG_FIRMWARE_EDID is not set
 CONFIG_FB_DDC=y
@@ -937,7 +937,6 @@ CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
 CONFIG_SND_PCM_OSS_PLUGINS=y
 CONFIG_SND_SEQUENCER_OSS=y
-# CONFIG_SND_RTCTIMER is not set
 # CONFIG_SND_DYNAMIC_MINORS is not set
 CONFIG_SND_SUPPORT_OLD_API=y
 CONFIG_SND_VERBOSE_PROCFS=y
@@ -1034,6 +1033,10 @@ CONFIG_SND_SUN_CS4231=m
 # CONFIG_SND_SOC is not set
 
 #
+# SoC Audio support for SuperH
+#
+
+#
 # Open Sound System
 #
 # CONFIG_SOUND_PRIME is not set
@@ -1157,19 +1160,7 @@ CONFIG_USB_STORAGE=m
 #
 # CONFIG_USB_GADGET is not set
 # CONFIG_MMC is not set
-
-#
-# LED devices
-#
 # CONFIG_NEW_LEDS is not set
-
-#
-# LED drivers
-#
-
-#
-# LED Triggers
-#
 # CONFIG_INFINIBAND is not set
 
 #
@@ -1199,7 +1190,6 @@ CONFIG_USB_STORAGE=m
 # Misc Linux/SPARC drivers
 #
 CONFIG_SUN_OPENPROMIO=m
-CONFIG_SUN_MOSTEK_RTC=y
 # CONFIG_OBP_FLASH is not set
 # CONFIG_SUN_BPP is not set
 # CONFIG_BBC_I2C is not set
diff --git a/arch/sparc64/kernel/head.S b/arch/sparc64/kernel/head.S
index 35feacb6b8e..9dbd833d79d 100644
--- a/arch/sparc64/kernel/head.S
+++ b/arch/sparc64/kernel/head.S
@@ -1,15 +1,15 @@
-/* $Id: head.S,v 1.87 2002/02/09 19:49:31 davem Exp $
- * head.S: Initial boot code for the Sparc64 port of Linux.
+/* head.S: Initial boot code for the Sparc64 port of Linux.
  *
- * Copyright (C) 1996,1997 David S. Miller (davem@caip.rutgers.edu)
+ * Copyright (C) 1996, 1997, 2007 David S. Miller (davem@davemloft.net)
  * Copyright (C) 1996 David Sitsky (David.Sitsky@anu.edu.au)
- * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ * Copyright (C) 1997, 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  * Copyright (C) 1997 Miguel de Icaza (miguel@nuclecu.unam.mx)
  */
 
 #include <linux/version.h>
 #include <linux/errno.h>
 #include <linux/threads.h>
+#include <linux/init.h>
 #include <asm/thread_info.h>
 #include <asm/asi.h>
 #include <asm/pstate.h>
@@ -374,6 +374,7 @@ jump_to_sun4u_init:
         jmpl    %g2 + %g0, %g0
          nop
 
+        .section        .text.init.refok
 sun4u_init:
         BRANCH_IF_SUN4V(g1, sun4v_init)
 
@@ -529,6 +530,8 @@ tlb_fixup_done:
          nop
         /* Not reached... */
 
+        .previous
+
         /* This is meant to allow the sharing of this code between
          * boot processor invocation (via setup_tba() below) and
          * secondary processor startup (via trampoline.S).  The
diff --git a/arch/sparc64/kernel/vmlinux.lds.S b/arch/sparc64/kernel/vmlinux.lds.S
index 481861764de..b982fa3dd74 100644
--- a/arch/sparc64/kernel/vmlinux.lds.S
+++ b/arch/sparc64/kernel/vmlinux.lds.S
@@ -45,6 +45,8 @@ SECTIONS
   __ex_table : { *(__ex_table) }
   __stop___ex_table = .;
 
+  NOTES
+
   . = ALIGN(PAGE_SIZE);
   __init_begin = .;
   .init.text : { 
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index 542c9ef858f..d8709050740 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -499,7 +499,7 @@ static struct mc_device mem_mc = {
         .remove         = mem_remove,
 };
 
-static int mem_mc_init(void)
+static int __init mem_mc_init(void)
 {
         if(can_drop_memory())
                 mconsole_register_dev(&mem_mc);
@@ -798,7 +798,7 @@ void mconsole_stack(struct mc_request *req)
  */
 static char *notify_socket = NULL;
 
-static int mconsole_init(void)
+static int __init mconsole_init(void)
 {
         /* long to avoid size mismatch warnings from gcc */
         long sock;
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index 72773dd5442..d35d0c1ee7f 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -623,7 +623,7 @@ static int eth_setup_common(char *str, int index)
         return found;
 }
 
-static int eth_setup(char *str)
+static int __init eth_setup(char *str)
 {
         struct eth_init *new;
         char *error;
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index fc27f6c72b4..aff661fe2ee 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -469,7 +469,7 @@ __uml_help(fakehd,
 "    Change the ubd device name to \"hd\".\n\n"
 );
 
-static void do_ubd_request(request_queue_t * q);
+static void do_ubd_request(struct request_queue * q);
 
 /* Only changed by ubd_init, which is an initcall. */
 int thread_fd = -1;
@@ -1081,7 +1081,7 @@ static void prepare_request(struct request *req, struct io_thread_req *io_req,
 }
 
 /* Called with dev->lock held */
-static void do_ubd_request(request_queue_t *q)
+static void do_ubd_request(struct request_queue *q)
 {
         struct io_thread_req *io_req;
         struct request *req;
diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
index 72ff85693a3..d2b11f24269 100644
--- a/arch/um/kernel/mem.c
+++ b/arch/um/kernel/mem.c
@@ -62,7 +62,7 @@ static void setup_highmem(unsigned long highmem_start,
 }
 #endif
 
-void mem_init(void)
+void __init mem_init(void)
 {
         /* clear the zero-page */
         memset((void *) empty_zero_page, 0, PAGE_SIZE);
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
index 3ba6e4c841d..5ee7e851bbc 100644
--- a/arch/um/kernel/physmem.c
+++ b/arch/um/kernel/physmem.c
@@ -28,7 +28,8 @@ unsigned long high_physmem;
 
 extern unsigned long long physmem_size;
 
-int init_maps(unsigned long physmem, unsigned long iomem, unsigned long highmem)
+int __init init_maps(unsigned long physmem, unsigned long iomem,
+                     unsigned long highmem)
 {
         struct page *p, *map;
         unsigned long phys_len, phys_pages, highmem_len, highmem_pages;
@@ -47,13 +48,7 @@ int init_maps(unsigned long physmem, unsigned long iomem, unsigned long highmem)
         total_pages = phys_pages + iomem_pages + highmem_pages;
         total_len = phys_len + iomem_len + highmem_len;
 
-        if(kmalloc_ok){
-                map = kmalloc(total_len, GFP_KERNEL);
-                if(map == NULL)
-                        map = vmalloc(total_len);
-        }
-        else map = alloc_bootmem_low_pages(total_len);
-
+        map = alloc_bootmem_low_pages(total_len);
         if(map == NULL)
                 return -ENOMEM;
 
@@ -98,8 +93,8 @@ void map_memory(unsigned long virt, unsigned long phys, unsigned long len,
 
 extern int __syscall_stub_start;
 
-void setup_physmem(unsigned long start, unsigned long reserve_end,
-                   unsigned long len, unsigned long long highmem)
+void __init setup_physmem(unsigned long start, unsigned long reserve_end,
+                          unsigned long len, unsigned long long highmem)
 {
         unsigned long reserve = reserve_end - start;
         int pfn = PFN_UP(__pa(reserve_end));
diff --git a/arch/um/kernel/skas/process.c b/arch/um/kernel/skas/process.c
index 2a69a7ce579..48051a98525 100644
--- a/arch/um/kernel/skas/process.c
+++ b/arch/um/kernel/skas/process.c
@@ -145,7 +145,7 @@ void init_idle_skas(void)
 
 extern void start_kernel(void);
 
-static int start_kernel_proc(void *unused)
+static int __init start_kernel_proc(void *unused)
 {
         int pid;
 
@@ -165,7 +165,7 @@ extern int userspace_pid[];
 
 extern char cpu0_irqstack[];
 
-int start_uml_skas(void)
+int __init start_uml_skas(void)
 {
         stack_protections((unsigned long) &cpu0_irqstack);
         set_sigstack(cpu0_irqstack, THREAD_SIZE);
diff --git a/arch/um/os-Linux/aio.c b/arch/um/os-Linux/aio.c
index b126df4ea16..59348359f9a 100644
--- a/arch/um/os-Linux/aio.c
+++ b/arch/um/os-Linux/aio.c
@@ -14,6 +14,7 @@
 #include "init.h"
 #include "user.h"
 #include "mode.h"
+#include "kern_constants.h"
 
 struct aio_thread_req {
         enum aio_type type;
@@ -65,47 +66,33 @@ static long io_getevents(aio_context_t ctx_id, long min_nr, long nr,
 static int do_aio(aio_context_t ctx, enum aio_type type, int fd, char *buf,
                   int len, unsigned long long offset, struct aio_context *aio)
 {
-        struct iocb iocb, *iocbp = &iocb;
+        struct iocb *iocbp = & ((struct iocb) {
+                                    .aio_data       = (unsigned long) aio,
+                                    .aio_fildes     = fd,
+                                    .aio_buf        = (unsigned long) buf,
+                                    .aio_nbytes     = len,
+                                    .aio_offset     = offset
+                             });
         char c;
-        int err;
 
-        iocb = ((struct iocb) { .aio_data       = (unsigned long) aio,
-                                .aio_reqprio    = 0,
-                                .aio_fildes     = fd,
-                                .aio_buf        = (unsigned long) buf,
-                                .aio_nbytes     = len,
-                                .aio_offset     = offset,
-                                .aio_reserved1  = 0,
-                                .aio_reserved2  = 0,
-                                .aio_reserved3  = 0 });
-
-        switch(type){
+        switch (type) {
         case AIO_READ:
-                iocb.aio_lio_opcode = IOCB_CMD_PREAD;
-                err = io_submit(ctx, 1, &iocbp);
+                iocbp->aio_lio_opcode = IOCB_CMD_PREAD;
                 break;
         case AIO_WRITE:
-                iocb.aio_lio_opcode = IOCB_CMD_PWRITE;
-                err = io_submit(ctx, 1, &iocbp);
+                iocbp->aio_lio_opcode = IOCB_CMD_PWRITE;
                 break;
         case AIO_MMAP:
-                iocb.aio_lio_opcode = IOCB_CMD_PREAD;
-                iocb.aio_buf = (unsigned long) &c;
-                iocb.aio_nbytes = sizeof(c);
-                err = io_submit(ctx, 1, &iocbp);
+                iocbp->aio_lio_opcode = IOCB_CMD_PREAD;
+                iocbp->aio_buf = (unsigned long) &c;
+                iocbp->aio_nbytes = sizeof(c);
                 break;
         default:
-                printk("Bogus op in do_aio - %d\n", type);
-                err = -EINVAL;
-                break;
+                printk(UM_KERN_ERR "Bogus op in do_aio - %d\n", type);
+                return -EINVAL;
         }
 
-        if(err > 0)
-                err = 0;
-        else
-                err = -errno;
-
-        return err;
+        return (io_submit(ctx, 1, &iocbp) > 0) ? 0 : -errno;
 }
 
 /* Initialized in an initcall and unchanged thereafter */
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
index 2d9d2ca3929..e9c14329751 100644
--- a/arch/um/os-Linux/process.c
+++ b/arch/um/os-Linux/process.c
@@ -194,7 +194,7 @@ int os_unmap_memory(void *addr, int len)
 #define MADV_REMOVE KERNEL_MADV_REMOVE
 #endif
 
-int __init os_drop_memory(void *addr, int length)
+int os_drop_memory(void *addr, int length)
 {
         int err;
 
diff --git a/arch/um/os-Linux/user_syms.c b/arch/um/os-Linux/user_syms.c
index 419b2d5ff6d..4c37b1b1d0b 100644
--- a/arch/um/os-Linux/user_syms.c
+++ b/arch/um/os-Linux/user_syms.c
@@ -19,10 +19,7 @@ extern void *memmove(void *, const void *, size_t);
 extern void *memset(void *, int, size_t);
 extern int printf(const char *, ...);
 
-/* If they're not defined, the export is included in lib/string.c.*/
-#ifdef __HAVE_ARCH_STRLEN
-EXPORT_SYMBOL(strlen);
-#endif
+/* If it's not defined, the export is included in lib/string.c.*/
 #ifdef __HAVE_ARCH_STRSTR
 EXPORT_SYMBOL(strstr);
 #endif
diff --git a/arch/um/sys-i386/Makefile b/arch/um/sys-i386/Makefile
index 098720be019..d6b3ecd4b77 100644
--- a/arch/um/sys-i386/Makefile
+++ b/arch/um/sys-i386/Makefile
@@ -4,7 +4,7 @@ obj-y = bug.o bugs.o checksum.o delay.o fault.o ksyms.o ldt.o ptrace.o \
 
 obj-$(CONFIG_MODE_SKAS) += stub.o stub_segv.o
 
-subarch-obj-y = lib/bitops.o lib/semaphore.o
+subarch-obj-y = lib/bitops.o lib/semaphore.o lib/string.o
 subarch-obj-$(CONFIG_HIGHMEM) += mm/highmem.o
 subarch-obj-$(CONFIG_MODULES) += kernel/module.o
 
diff --git a/block/as-iosched.c b/block/as-iosched.c
index 3e316dd7252..dc715a562e1 100644
--- a/block/as-iosched.c
+++ b/block/as-iosched.c
@@ -796,7 +796,7 @@ static void update_write_batch(struct as_data *ad)
  * as_completed_request is to be called when a request has completed and
  * returned something to the requesting process, be it an error or data.
  */
-static void as_completed_request(request_queue_t *q, struct request *rq)
+static void as_completed_request(struct request_queue *q, struct request *rq)
 {
         struct as_data *ad = q->elevator->elevator_data;
 
@@ -853,7 +853,8 @@ out:
  * reference unless it replaces the request at somepart of the elevator
  * (ie. the dispatch queue)
  */
-static void as_remove_queued_request(request_queue_t *q, struct request *rq)
+static void as_remove_queued_request(struct request_queue *q,
+                                     struct request *rq)
 {
         const int data_dir = rq_is_sync(rq);
         struct as_data *ad = q->elevator->elevator_data;
@@ -978,7 +979,7 @@ static void as_move_to_dispatch(struct as_data *ad, struct request *rq)
  * read/write expire, batch expire, etc, and moves it to the dispatch
  * queue. Returns 1 if a request was found, 0 otherwise.
  */
-static int as_dispatch_request(request_queue_t *q, int force)
+static int as_dispatch_request(struct request_queue *q, int force)
 {
         struct as_data *ad = q->elevator->elevator_data;
         const int reads = !list_empty(&ad->fifo_list[REQ_SYNC]);
@@ -1139,7 +1140,7 @@ fifo_expired:
 /*
  * add rq to rbtree and fifo
  */
-static void as_add_request(request_queue_t *q, struct request *rq)
+static void as_add_request(struct request_queue *q, struct request *rq)
 {
         struct as_data *ad = q->elevator->elevator_data;
         int data_dir;
@@ -1167,7 +1168,7 @@ static void as_add_request(request_queue_t *q, struct request *rq)
         RQ_SET_STATE(rq, AS_RQ_QUEUED);
 }
 
-static void as_activate_request(request_queue_t *q, struct request *rq)
+static void as_activate_request(struct request_queue *q, struct request *rq)
 {
         WARN_ON(RQ_STATE(rq) != AS_RQ_DISPATCHED);
         RQ_SET_STATE(rq, AS_RQ_REMOVED);
@@ -1175,7 +1176,7 @@ static void as_activate_request(request_queue_t *q, struct request *rq)
                 atomic_dec(&RQ_IOC(rq)->aic->nr_dispatched);
 }
 
-static void as_deactivate_request(request_queue_t *q, struct request *rq)
+static void as_deactivate_request(struct request_queue *q, struct request *rq)
 {
         WARN_ON(RQ_STATE(rq) != AS_RQ_REMOVED);
         RQ_SET_STATE(rq, AS_RQ_DISPATCHED);
@@ -1189,7 +1190,7 @@ static void as_deactivate_request(request_queue_t *q, struct request *rq)
  * is not empty - it is used in the block layer to check for plugging and
  * merging opportunities
  */
-static int as_queue_empty(request_queue_t *q)
+static int as_queue_empty(struct request_queue *q)
 {
         struct as_data *ad = q->elevator->elevator_data;
 
@@ -1198,7 +1199,7 @@ static int as_queue_empty(request_queue_t *q)
 }
 
 static int
-as_merge(request_queue_t *q, struct request **req, struct bio *bio)
+as_merge(struct request_queue *q, struct request **req, struct bio *bio)
 {
         struct as_data *ad = q->elevator->elevator_data;
         sector_t rb_key = bio->bi_sector + bio_sectors(bio);
@@ -1216,7 +1217,8 @@ as_merge(request_queue_t *q, struct request **req, struct bio *bio)
         return ELEVATOR_NO_MERGE;
 }
 
-static void as_merged_request(request_queue_t *q, struct request *req, int type)
+static void as_merged_request(struct request_queue *q, struct request *req,
+                              int type)
 {
         struct as_data *ad = q->elevator->elevator_data;
 
@@ -1234,7 +1236,7 @@ static void as_merged_request(request_queue_t *q, struct request *req, int type)
         }
 }
 
-static void as_merged_requests(request_queue_t *q, struct request *req,
+static void as_merged_requests(struct request_queue *q, struct request *req,
                                 struct request *next)
 {
         /*
@@ -1285,7 +1287,7 @@ static void as_work_handler(struct work_struct *work)
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
-static int as_may_queue(request_queue_t *q, int rw)
+static int as_may_queue(struct request_queue *q, int rw)
 {
         int ret = ELV_MQUEUE_MAY;
         struct as_data *ad = q->elevator->elevator_data;
@@ -1318,7 +1320,7 @@ static void as_exit_queue(elevator_t *e)
 /*
  * initialize elevator private data (as_data).
  */
-static void *as_init_queue(request_queue_t *q)
+static void *as_init_queue(struct request_queue *q)
 {
         struct as_data *ad;
 
diff --git a/block/blktrace.c b/block/blktrace.c
index 3f0e7c37c05..20c3e22587b 100644
--- a/block/blktrace.c
+++ b/block/blktrace.c
@@ -231,7 +231,7 @@ static void blk_trace_cleanup(struct blk_trace *bt)
         kfree(bt);
 }
 
-static int blk_trace_remove(request_queue_t *q)
+static int blk_trace_remove(struct request_queue *q)
 {
         struct blk_trace *bt;
 
@@ -312,7 +312,7 @@ static struct rchan_callbacks blk_relay_callbacks = {
 /*
  * Setup everything required to start tracing
  */
-static int blk_trace_setup(request_queue_t *q, struct block_device *bdev,
+static int blk_trace_setup(struct request_queue *q, struct block_device *bdev,
                            char __user *arg)
 {
         struct blk_user_trace_setup buts;
@@ -401,7 +401,7 @@ err:
         return ret;
 }
 
-static int blk_trace_startstop(request_queue_t *q, int start)
+static int blk_trace_startstop(struct request_queue *q, int start)
 {
         struct blk_trace *bt;
         int ret;
@@ -444,7 +444,7 @@ static int blk_trace_startstop(request_queue_t *q, int start)
  **/
 int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
 {
-        request_queue_t *q;
+        struct request_queue *q;
         int ret, start = 0;
 
         q = bdev_get_queue(bdev);
@@ -479,7 +479,7 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
  * @q:    the request queue associated with the device
  *
  **/
-void blk_trace_shutdown(request_queue_t *q)
+void blk_trace_shutdown(struct request_queue *q)
 {
         if (q->blk_trace) {
                 blk_trace_startstop(q, 0);
diff --git a/block/bsg.c b/block/bsg.c
index b571869928a..3b2f05258a9 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -37,7 +37,7 @@
 #define BSG_VERSION     "0.4"
 
 struct bsg_device {
-        request_queue_t *queue;
+        struct request_queue *queue;
         spinlock_t lock;
         struct list_head busy_list;
         struct list_head done_list;
@@ -180,7 +180,7 @@ unlock:
         return ret;
 }
 
-static int blk_fill_sgv4_hdr_rq(request_queue_t *q, struct request *rq,
+static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,
                                 struct sg_io_v4 *hdr, int has_write_perm)
 {
         memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
@@ -214,7 +214,7 @@ static int blk_fill_sgv4_hdr_rq(request_queue_t *q, struct request *rq,
  * Check if sg_io_v4 from user is allowed and valid
  */
 static int
-bsg_validate_sgv4_hdr(request_queue_t *q, struct sg_io_v4 *hdr, int *rw)
+bsg_validate_sgv4_hdr(struct request_queue *q, struct sg_io_v4 *hdr, int *rw)
 {
         int ret = 0;
 
@@ -250,7 +250,7 @@ bsg_validate_sgv4_hdr(request_queue_t *q, struct sg_io_v4 *hdr, int *rw)
 static struct request *
 bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr)
 {
-        request_queue_t *q = bd->queue;
+        struct request_queue *q = bd->queue;
         struct request *rq, *next_rq = NULL;
         int ret, rw;
         unsigned int dxfer_len;
@@ -345,7 +345,7 @@ static void bsg_rq_end_io(struct request *rq, int uptodate)
  * do final setup of a 'bc' and submit the matching 'rq' to the block
  * layer for io
  */
-static void bsg_add_command(struct bsg_device *bd, request_queue_t *q,
+static void bsg_add_command(struct bsg_device *bd, struct request_queue *q,
                             struct bsg_command *bc, struct request *rq)
 {
         rq->sense = bc->sense;
@@ -611,7 +611,7 @@ static int __bsg_write(struct bsg_device *bd, const char __user *buf,
         bc = NULL;
         ret = 0;
         while (nr_commands) {
-                request_queue_t *q = bd->queue;
+                struct request_queue *q = bd->queue;
 
                 bc = bsg_alloc_command(bd);
                 if (IS_ERR(bc)) {
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index d148ccbc36d..54dc0543900 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -71,7 +71,7 @@ struct cfq_rb_root {
  * Per block device queue structure
  */
 struct cfq_data {
-        request_queue_t *queue;
+        struct request_queue *queue;
 
         /*
          * rr list of queues with requests and the count of them
@@ -197,7 +197,7 @@ CFQ_CFQQ_FNS(slice_new);
 CFQ_CFQQ_FNS(sync);
 #undef CFQ_CFQQ_FNS
 
-static void cfq_dispatch_insert(request_queue_t *, struct request *);
+static void cfq_dispatch_insert(struct request_queue *, struct request *);
 static struct cfq_queue *cfq_get_queue(struct cfq_data *, int,
                                        struct task_struct *, gfp_t);
 static struct cfq_io_context *cfq_cic_rb_lookup(struct cfq_data *,
@@ -237,7 +237,7 @@ static inline void cfq_schedule_dispatch(struct cfq_data *cfqd)
                 kblockd_schedule_work(&cfqd->unplug_work);
 }
 
-static int cfq_queue_empty(request_queue_t *q)
+static int cfq_queue_empty(struct request_queue *q)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
 
@@ -623,7 +623,7 @@ cfq_find_rq_fmerge(struct cfq_data *cfqd, struct bio *bio)
         return NULL;
 }
 
-static void cfq_activate_request(request_queue_t *q, struct request *rq)
+static void cfq_activate_request(struct request_queue *q, struct request *rq)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
 
@@ -641,7 +641,7 @@ static void cfq_activate_request(request_queue_t *q, struct request *rq)
         cfqd->last_position = rq->hard_sector + rq->hard_nr_sectors;
 }
 
-static void cfq_deactivate_request(request_queue_t *q, struct request *rq)
+static void cfq_deactivate_request(struct request_queue *q, struct request *rq)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
 
@@ -665,7 +665,8 @@ static void cfq_remove_request(struct request *rq)
         }
 }
 
-static int cfq_merge(request_queue_t *q, struct request **req, struct bio *bio)
+static int cfq_merge(struct request_queue *q, struct request **req,
+                     struct bio *bio)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
         struct request *__rq;
@@ -679,7 +680,7 @@ static int cfq_merge(request_queue_t *q, struct request **req, struct bio *bio)
         return ELEVATOR_NO_MERGE;
 }
 
-static void cfq_merged_request(request_queue_t *q, struct request *req,
+static void cfq_merged_request(struct request_queue *q, struct request *req,
                                int type)
 {
         if (type == ELEVATOR_FRONT_MERGE) {
@@ -690,7 +691,7 @@ static void cfq_merged_request(request_queue_t *q, struct request *req,
 }
 
 static void
-cfq_merged_requests(request_queue_t *q, struct request *rq,
+cfq_merged_requests(struct request_queue *q, struct request *rq,
                     struct request *next)
 {
         /*
@@ -703,7 +704,7 @@ cfq_merged_requests(request_queue_t *q, struct request *rq,
         cfq_remove_request(next);
 }
 
-static int cfq_allow_merge(request_queue_t *q, struct request *rq,
+static int cfq_allow_merge(struct request_queue *q, struct request *rq,
                            struct bio *bio)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
@@ -913,7 +914,7 @@ static void cfq_arm_slice_timer(struct cfq_data *cfqd)
 /*
  * Move request from internal lists to the request queue dispatch list.
  */
-static void cfq_dispatch_insert(request_queue_t *q, struct request *rq)
+static void cfq_dispatch_insert(struct request_queue *q, struct request *rq)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
         struct cfq_queue *cfqq = RQ_CFQQ(rq);
@@ -1093,7 +1094,7 @@ static int cfq_forced_dispatch(struct cfq_data *cfqd)
         return dispatched;
 }
 
-static int cfq_dispatch_requests(request_queue_t *q, int force)
+static int cfq_dispatch_requests(struct request_queue *q, int force)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
         struct cfq_queue *cfqq;
@@ -1214,7 +1215,7 @@ static void cfq_exit_single_io_context(struct cfq_io_context *cic)
         struct cfq_data *cfqd = cic->key;
 
         if (cfqd) {
-                request_queue_t *q = cfqd->queue;
+                struct request_queue *q = cfqd->queue;
 
                 spin_lock_irq(q->queue_lock);
                 __cfq_exit_single_io_context(cfqd, cic);
@@ -1775,7 +1776,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
         }
 }
 
-static void cfq_insert_request(request_queue_t *q, struct request *rq)
+static void cfq_insert_request(struct request_queue *q, struct request *rq)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
         struct cfq_queue *cfqq = RQ_CFQQ(rq);
@@ -1789,7 +1790,7 @@ static void cfq_insert_request(request_queue_t *q, struct request *rq)
         cfq_rq_enqueued(cfqd, cfqq, rq);
 }
 
-static void cfq_completed_request(request_queue_t *q, struct request *rq)
+static void cfq_completed_request(struct request_queue *q, struct request *rq)
 {
         struct cfq_queue *cfqq = RQ_CFQQ(rq);
         struct cfq_data *cfqd = cfqq->cfqd;
@@ -1868,7 +1869,7 @@ static inline int __cfq_may_queue(struct cfq_queue *cfqq)
         return ELV_MQUEUE_MAY;
 }
 
-static int cfq_may_queue(request_queue_t *q, int rw)
+static int cfq_may_queue(struct request_queue *q, int rw)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
         struct task_struct *tsk = current;
@@ -1922,7 +1923,7 @@ static void cfq_put_request(struct request *rq)
  * Allocate cfq data structures associated with this request.
  */
 static int
-cfq_set_request(request_queue_t *q, struct request *rq, gfp_t gfp_mask)
+cfq_set_request(struct request_queue *q, struct request *rq, gfp_t gfp_mask)
 {
         struct cfq_data *cfqd = q->elevator->elevator_data;
         struct task_struct *tsk = current;
@@ -1974,7 +1975,7 @@ static void cfq_kick_queue(struct work_struct *work)
 {
         struct cfq_data *cfqd =
                 container_of(work, struct cfq_data, unplug_work);
-        request_queue_t *q = cfqd->queue;
+        struct request_queue *q = cfqd->queue;
         unsigned long flags;
 
         spin_lock_irqsave(q->queue_lock, flags);
@@ -2072,7 +2073,7 @@ static void cfq_put_async_queues(struct cfq_data *cfqd)
 static void cfq_exit_queue(elevator_t *e)
 {
         struct cfq_data *cfqd = e->elevator_data;
-        request_queue_t *q = cfqd->queue;
+        struct request_queue *q = cfqd->queue;
 
         cfq_shutdown_timer_wq(cfqd);
 
@@ -2098,7 +2099,7 @@ static void cfq_exit_queue(elevator_t *e)
         kfree(cfqd);
 }
 
-static void *cfq_init_queue(request_queue_t *q)
+static void *cfq_init_queue(struct request_queue *q)
 {
         struct cfq_data *cfqd;
 
diff --git a/block/deadline-iosched.c b/block/deadline-iosched.c
index 87ca02ac84c..1a511ffaf8a 100644
--- a/block/deadline-iosched.c
+++ b/block/deadline-iosched.c
@@ -106,7 +106,7 @@ deadline_add_request(struct request_queue *q, struct request *rq)
 /*
  * remove rq from rbtree and fifo.
  */
-static void deadline_remove_request(request_queue_t *q, struct request *rq)
+static void deadline_remove_request(struct request_queue *q, struct request *rq)
 {
         struct deadline_data *dd = q->elevator->elevator_data;
 
@@ -115,7 +115,7 @@ static void deadline_remove_request(request_queue_t *q, struct request *rq)
 }
 
 static int
-deadline_merge(request_queue_t *q, struct request **req, struct bio *bio)
+deadline_merge(struct request_queue *q, struct request **req, struct bio *bio)
 {
         struct deadline_data *dd = q->elevator->elevator_data;
         struct request *__rq;
@@ -144,8 +144,8 @@ out:
         return ret;
 }
 
-static void deadline_merged_request(request_queue_t *q, struct request *req,
-                                    int type)
+static void deadline_merged_request(struct request_queue *q,
+                                    struct request *req, int type)
 {
         struct deadline_data *dd = q->elevator->elevator_data;
 
@@ -159,7 +159,7 @@ static void deadline_merged_request(request_queue_t *q, struct request *req,
 }
 
 static void
-deadline_merged_requests(request_queue_t *q, struct request *req,
+deadline_merged_requests(struct request_queue *q, struct request *req,
                          struct request *next)
 {
         /*
@@ -185,7 +185,7 @@ deadline_merged_requests(request_queue_t *q, struct request *req,
 static inline void
 deadline_move_to_dispatch(struct deadline_data *dd, struct request *rq)
 {
-        request_queue_t *q = rq->q;
+        struct request_queue *q = rq->q;
 
         deadline_remove_request(q, rq);
         elv_dispatch_add_tail(q, rq);
@@ -236,7 +236,7 @@ static inline int deadline_check_fifo(struct deadline_data *dd, int ddir)
  * deadline_dispatch_requests selects the best request according to
  * read/write expire, fifo_batch, etc
  */
-static int deadline_dispatch_requests(request_queue_t *q, int force)
+static int deadline_dispatch_requests(struct request_queue *q, int force)
 {
         struct deadline_data *dd = q->elevator->elevator_data;
         const int reads = !list_empty(&dd->fifo_list[READ]);
@@ -335,7 +335,7 @@ dispatch_request:
         return 1;
 }
 
-static int deadline_queue_empty(request_queue_t *q)
+static int deadline_queue_empty(struct request_queue *q)
 {
         struct deadline_data *dd = q->elevator->elevator_data;
 
@@ -356,7 +356,7 @@ static void deadline_exit_queue(elevator_t *e)
 /*
  * initialize elevator private data (deadline_data).
  */
-static void *deadline_init_queue(request_queue_t *q)
+static void *deadline_init_queue(struct request_queue *q)
 {
         struct deadline_data *dd;
 
diff --git a/block/elevator.c b/block/elevator.c
index d265963d1ed..c6d153de9fd 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -56,7 +56,7 @@ static const int elv_hash_shift = 6;
  */
 static int elv_iosched_allow_merge(struct request *rq, struct bio *bio)
 {
-        request_queue_t *q = rq->q;
+        struct request_queue *q = rq->q;
         elevator_t *e = q->elevator;
 
         if (e->ops->elevator_allow_merge_fn)
@@ -141,12 +141,13 @@ static struct elevator_type *elevator_get(const char *name)
         return e;
 }
 
-static void *elevator_init_queue(request_queue_t *q, struct elevator_queue *eq)
+static void *elevator_init_queue(struct request_queue *q,
+                                 struct elevator_queue *eq)
 {
         return eq->ops->elevator_init_fn(q);
 }
 
-static void elevator_attach(request_queue_t *q, struct elevator_queue *eq,
+static void elevator_attach(struct request_queue *q, struct elevator_queue *eq,
                            void *data)
 {
         q->elevator = eq;
@@ -172,7 +173,8 @@ __setup("elevator=", elevator_setup);
 
 static struct kobj_type elv_ktype;
 
-static elevator_t *elevator_alloc(request_queue_t *q, struct elevator_type *e)
+static elevator_t *elevator_alloc(struct request_queue *q,
+                                  struct elevator_type *e)
 {
         elevator_t *eq;
         int i;
@@ -212,7 +214,7 @@ static void elevator_release(struct kobject *kobj)
         kfree(e);
 }
 
-int elevator_init(request_queue_t *q, char *name)
+int elevator_init(struct request_queue *q, char *name)
 {
         struct elevator_type *e = NULL;
         struct elevator_queue *eq;
@@ -264,7 +266,7 @@ void elevator_exit(elevator_t *e)
 
 EXPORT_SYMBOL(elevator_exit);
 
-static void elv_activate_rq(request_queue_t *q, struct request *rq)
+static void elv_activate_rq(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -272,7 +274,7 @@ static void elv_activate_rq(request_queue_t *q, struct request *rq)
                 e->ops->elevator_activate_req_fn(q, rq);
 }
 
-static void elv_deactivate_rq(request_queue_t *q, struct request *rq)
+static void elv_deactivate_rq(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -285,13 +287,13 @@ static inline void __elv_rqhash_del(struct request *rq)
         hlist_del_init(&rq->hash);
 }
 
-static void elv_rqhash_del(request_queue_t *q, struct request *rq)
+static void elv_rqhash_del(struct request_queue *q, struct request *rq)
 {
         if (ELV_ON_HASH(rq))
                 __elv_rqhash_del(rq);
 }
 
-static void elv_rqhash_add(request_queue_t *q, struct request *rq)
+static void elv_rqhash_add(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -299,13 +301,13 @@ static void elv_rqhash_add(request_queue_t *q, struct request *rq)
         hlist_add_head(&rq->hash, &e->hash[ELV_HASH_FN(rq_hash_key(rq))]);
 }
 
-static void elv_rqhash_reposition(request_queue_t *q, struct request *rq)
+static void elv_rqhash_reposition(struct request_queue *q, struct request *rq)
 {
         __elv_rqhash_del(rq);
         elv_rqhash_add(q, rq);
 }
 
-static struct request *elv_rqhash_find(request_queue_t *q, sector_t offset)
+static struct request *elv_rqhash_find(struct request_queue *q, sector_t offset)
 {
         elevator_t *e = q->elevator;
         struct hlist_head *hash_list = &e->hash[ELV_HASH_FN(offset)];
@@ -391,7 +393,7 @@ EXPORT_SYMBOL(elv_rb_find);
  * entry.  rq is sort insted into the dispatch queue. To be used by
  * specific elevators.
  */
-void elv_dispatch_sort(request_queue_t *q, struct request *rq)
+void elv_dispatch_sort(struct request_queue *q, struct request *rq)
 {
         sector_t boundary;
         struct list_head *entry;
@@ -449,7 +451,7 @@ void elv_dispatch_add_tail(struct request_queue *q, struct request *rq)
 
 EXPORT_SYMBOL(elv_dispatch_add_tail);
 
-int elv_merge(request_queue_t *q, struct request **req, struct bio *bio)
+int elv_merge(struct request_queue *q, struct request **req, struct bio *bio)
 {
         elevator_t *e = q->elevator;
         struct request *__rq;
@@ -481,7 +483,7 @@ int elv_merge(request_queue_t *q, struct request **req, struct bio *bio)
         return ELEVATOR_NO_MERGE;
 }
 
-void elv_merged_request(request_queue_t *q, struct request *rq, int type)
+void elv_merged_request(struct request_queue *q, struct request *rq, int type)
 {
         elevator_t *e = q->elevator;
 
@@ -494,7 +496,7 @@ void elv_merged_request(request_queue_t *q, struct request *rq, int type)
         q->last_merge = rq;
 }
 
-void elv_merge_requests(request_queue_t *q, struct request *rq,
+void elv_merge_requests(struct request_queue *q, struct request *rq,
                              struct request *next)
 {
         elevator_t *e = q->elevator;
@@ -509,7 +511,7 @@ void elv_merge_requests(request_queue_t *q, struct request *rq,
         q->last_merge = rq;
 }
 
-void elv_requeue_request(request_queue_t *q, struct request *rq)
+void elv_requeue_request(struct request_queue *q, struct request *rq)
 {
         /*
          * it already went through dequeue, we need to decrement the
@@ -526,7 +528,7 @@ void elv_requeue_request(request_queue_t *q, struct request *rq)
         elv_insert(q, rq, ELEVATOR_INSERT_REQUEUE);
 }
 
-static void elv_drain_elevator(request_queue_t *q)
+static void elv_drain_elevator(struct request_queue *q)
 {
         static int printed;
         while (q->elevator->ops->elevator_dispatch_fn(q, 1))
@@ -540,7 +542,7 @@ static void elv_drain_elevator(request_queue_t *q)
         }
 }
 
-void elv_insert(request_queue_t *q, struct request *rq, int where)
+void elv_insert(struct request_queue *q, struct request *rq, int where)
 {
         struct list_head *pos;
         unsigned ordseq;
@@ -638,7 +640,7 @@ void elv_insert(request_queue_t *q, struct request *rq, int where)
         }
 }
 
-void __elv_add_request(request_queue_t *q, struct request *rq, int where,
+void __elv_add_request(struct request_queue *q, struct request *rq, int where,
                        int plug)
 {
         if (q->ordcolor)
@@ -676,7 +678,7 @@ void __elv_add_request(request_queue_t *q, struct request *rq, int where,
 
 EXPORT_SYMBOL(__elv_add_request);
 
-void elv_add_request(request_queue_t *q, struct request *rq, int where,
+void elv_add_request(struct request_queue *q, struct request *rq, int where,
                      int plug)
 {
         unsigned long flags;
@@ -688,7 +690,7 @@ void elv_add_request(request_queue_t *q, struct request *rq, int where,
 
 EXPORT_SYMBOL(elv_add_request);
 
-static inline struct request *__elv_next_request(request_queue_t *q)
+static inline struct request *__elv_next_request(struct request_queue *q)
 {
         struct request *rq;
 
@@ -704,7 +706,7 @@ static inline struct request *__elv_next_request(request_queue_t *q)
         }
 }
 
-struct request *elv_next_request(request_queue_t *q)
+struct request *elv_next_request(struct request_queue *q)
 {
         struct request *rq;
         int ret;
@@ -770,7 +772,7 @@ struct request *elv_next_request(request_queue_t *q)
 
 EXPORT_SYMBOL(elv_next_request);
 
-void elv_dequeue_request(request_queue_t *q, struct request *rq)
+void elv_dequeue_request(struct request_queue *q, struct request *rq)
 {
         BUG_ON(list_empty(&rq->queuelist));
         BUG_ON(ELV_ON_HASH(rq));
@@ -788,7 +790,7 @@ void elv_dequeue_request(request_queue_t *q, struct request *rq)
 
 EXPORT_SYMBOL(elv_dequeue_request);
 
-int elv_queue_empty(request_queue_t *q)
+int elv_queue_empty(struct request_queue *q)
 {
         elevator_t *e = q->elevator;
 
@@ -803,7 +805,7 @@ int elv_queue_empty(request_queue_t *q)
 
 EXPORT_SYMBOL(elv_queue_empty);
 
-struct request *elv_latter_request(request_queue_t *q, struct request *rq)
+struct request *elv_latter_request(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -812,7 +814,7 @@ struct request *elv_latter_request(request_queue_t *q, struct request *rq)
         return NULL;
 }
 
-struct request *elv_former_request(request_queue_t *q, struct request *rq)
+struct request *elv_former_request(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -821,7 +823,7 @@ struct request *elv_former_request(request_queue_t *q, struct request *rq)
         return NULL;
 }
 
-int elv_set_request(request_queue_t *q, struct request *rq, gfp_t gfp_mask)
+int elv_set_request(struct request_queue *q, struct request *rq, gfp_t gfp_mask)
 {
         elevator_t *e = q->elevator;
 
@@ -832,7 +834,7 @@ int elv_set_request(request_queue_t *q, struct request *rq, gfp_t gfp_mask)
         return 0;
 }
 
-void elv_put_request(request_queue_t *q, struct request *rq)
+void elv_put_request(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -840,7 +842,7 @@ void elv_put_request(request_queue_t *q, struct request *rq)
                 e->ops->elevator_put_req_fn(rq);
 }
 
-int elv_may_queue(request_queue_t *q, int rw)
+int elv_may_queue(struct request_queue *q, int rw)
 {
         elevator_t *e = q->elevator;
 
@@ -850,7 +852,7 @@ int elv_may_queue(request_queue_t *q, int rw)
         return ELV_MQUEUE_MAY;
 }
 
-void elv_completed_request(request_queue_t *q, struct request *rq)
+void elv_completed_request(struct request_queue *q, struct request *rq)
 {
         elevator_t *e = q->elevator;
 
@@ -1006,7 +1008,7 @@ EXPORT_SYMBOL_GPL(elv_unregister);
  * need for the new one. this way we have a chance of going back to the old
  * one, if the new one fails init for some reason.
  */
-static int elevator_switch(request_queue_t *q, struct elevator_type *new_e)
+static int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
 {
         elevator_t *old_elevator, *e;
         void *data;
@@ -1078,7 +1080,8 @@ fail_register:
         return 0;
 }
 
-ssize_t elv_iosched_store(request_queue_t *q, const char *name, size_t count)
+ssize_t elv_iosched_store(struct request_queue *q, const char *name,
+                          size_t count)
 {
         char elevator_name[ELV_NAME_MAX];
         size_t len;
@@ -1107,7 +1110,7 @@ ssize_t elv_iosched_store(request_queue_t *q, const char *name, size_t count)
         return count;
 }
 
-ssize_t elv_iosched_show(request_queue_t *q, char *name)
+ssize_t elv_iosched_show(struct request_queue *q, char *name)
 {
         elevator_t *e = q->elevator;
         struct elevator_type *elv = e->elevator_type;
@@ -1127,7 +1130,8 @@ ssize_t elv_iosched_show(request_queue_t *q, char *name)
         return len;
 }
 
-struct request *elv_rb_former_request(request_queue_t *q, struct request *rq)
+struct request *elv_rb_former_request(struct request_queue *q,
+                                      struct request *rq)
 {
         struct rb_node *rbprev = rb_prev(&rq->rb_node);
 
@@ -1139,7 +1143,8 @@ struct request *elv_rb_former_request(request_queue_t *q, struct request *rq)
 
 EXPORT_SYMBOL(elv_rb_former_request);
 
-struct request *elv_rb_latter_request(request_queue_t *q, struct request *rq)
+struct request *elv_rb_latter_request(struct request_queue *q,
+                                      struct request *rq)
 {
         struct rb_node *rbnext = rb_next(&rq->rb_node);
 
diff --git a/block/ll_rw_blk.c b/block/ll_rw_blk.c
index 66056ca5e63..8c2caff87cc 100644
--- a/block/ll_rw_blk.c
+++ b/block/ll_rw_blk.c
@@ -40,7 +40,7 @@ static void blk_unplug_work(struct work_struct *work);
 static void blk_unplug_timeout(unsigned long data);
 static void drive_stat_acct(struct request *rq, int nr_sectors, int new_io);
 static void init_request_from_bio(struct request *req, struct bio *bio);
-static int __make_request(request_queue_t *q, struct bio *bio);
+static int __make_request(struct request_queue *q, struct bio *bio);
 static struct io_context *current_io_context(gfp_t gfp_flags, int node);
 
 /*
@@ -121,7 +121,7 @@ static void blk_queue_congestion_threshold(struct request_queue *q)
 struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev)
 {
         struct backing_dev_info *ret = NULL;
-        request_queue_t *q = bdev_get_queue(bdev);
+        struct request_queue *q = bdev_get_queue(bdev);
 
         if (q)
                 ret = &q->backing_dev_info;
@@ -140,7 +140,7 @@ EXPORT_SYMBOL(blk_get_backing_dev_info);
  * cdb from the request data for instance.
  *
  */
-void blk_queue_prep_rq(request_queue_t *q, prep_rq_fn *pfn)
+void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
 {
         q->prep_rq_fn = pfn;
 }
@@ -163,14 +163,14 @@ EXPORT_SYMBOL(blk_queue_prep_rq);
  * no merge_bvec_fn is defined for a queue, and only the fixed limits are
  * honored.
  */
-void blk_queue_merge_bvec(request_queue_t *q, merge_bvec_fn *mbfn)
+void blk_queue_merge_bvec(struct request_queue *q, merge_bvec_fn *mbfn)
 {
         q->merge_bvec_fn = mbfn;
 }
 
 EXPORT_SYMBOL(blk_queue_merge_bvec);
 
-void blk_queue_softirq_done(request_queue_t *q, softirq_done_fn *fn)
+void blk_queue_softirq_done(struct request_queue *q, softirq_done_fn *fn)
 {
         q->softirq_done_fn = fn;
 }
@@ -199,7 +199,7 @@ EXPORT_SYMBOL(blk_queue_softirq_done);
  *    __bio_kmap_atomic() to get a temporary kernel mapping, or by calling
  *    blk_queue_bounce() to create a buffer in normal memory.
  **/
-void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn)
+void blk_queue_make_request(struct request_queue * q, make_request_fn * mfn)
 {
         /*
          * set defaults
@@ -235,7 +235,7 @@ void blk_queue_make_request(request_queue_t * q, make_request_fn * mfn)
 
 EXPORT_SYMBOL(blk_queue_make_request);
 
-static void rq_init(request_queue_t *q, struct request *rq)
+static void rq_init(struct request_queue *q, struct request *rq)
 {
         INIT_LIST_HEAD(&rq->queuelist);
         INIT_LIST_HEAD(&rq->donelist);
@@ -272,7 +272,7 @@ static void rq_init(request_queue_t *q, struct request *rq)
  *   feature should call this function and indicate so.
  *
  **/
-int blk_queue_ordered(request_queue_t *q, unsigned ordered,
+int blk_queue_ordered(struct request_queue *q, unsigned ordered,
                       prepare_flush_fn *prepare_flush_fn)
 {
         if (ordered & (QUEUE_ORDERED_PREFLUSH | QUEUE_ORDERED_POSTFLUSH) &&
@@ -311,7 +311,7 @@ EXPORT_SYMBOL(blk_queue_ordered);
  *   to the block layer by defining it through this call.
  *
  **/
-void blk_queue_issue_flush_fn(request_queue_t *q, issue_flush_fn *iff)
+void blk_queue_issue_flush_fn(struct request_queue *q, issue_flush_fn *iff)
 {
         q->issue_flush_fn = iff;
 }
@@ -321,7 +321,7 @@ EXPORT_SYMBOL(blk_queue_issue_flush_fn);
 /*
  * Cache flushing for ordered writes handling
  */
-inline unsigned blk_ordered_cur_seq(request_queue_t *q)
+inline unsigned blk_ordered_cur_seq(struct request_queue *q)
 {
         if (!q->ordseq)
                 return 0;
@@ -330,7 +330,7 @@ inline unsigned blk_ordered_cur_seq(request_queue_t *q)
 
 unsigned blk_ordered_req_seq(struct request *rq)
 {
-        request_queue_t *q = rq->q;
+        struct request_queue *q = rq->q;
 
         BUG_ON(q->ordseq == 0);
 
@@ -357,7 +357,7 @@ unsigned blk_ordered_req_seq(struct request *rq)
                 return QUEUE_ORDSEQ_DONE;
 }
 
-void blk_ordered_complete_seq(request_queue_t *q, unsigned seq, int error)
+void blk_ordered_complete_seq(struct request_queue *q, unsigned seq, int error)
 {
         struct request *rq;
         int uptodate;
@@ -401,7 +401,7 @@ static void post_flush_end_io(struct request *rq, int error)
         blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_POSTFLUSH, error);
 }
 
-static void queue_flush(request_queue_t *q, unsigned which)
+static void queue_flush(struct request_queue *q, unsigned which)
 {
         struct request *rq;
         rq_end_io_fn *end_io;
@@ -425,7 +425,7 @@ static void queue_flush(request_queue_t *q, unsigned which)
         elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
 }
 
-static inline struct request *start_ordered(request_queue_t *q,
+static inline struct request *start_ordered(struct request_queue *q,
                                             struct request *rq)
 {
         q->bi_size = 0;
@@ -476,7 +476,7 @@ static inline struct request *start_ordered(request_queue_t *q,
         return rq;
 }
 
-int blk_do_ordered(request_queue_t *q, struct request **rqp)
+int blk_do_ordered(struct request_queue *q, struct request **rqp)
 {
         struct request *rq = *rqp;
         int is_barrier = blk_fs_request(rq) && blk_barrier_rq(rq);
@@ -527,7 +527,7 @@ int blk_do_ordered(request_queue_t *q, struct request **rqp)
 
 static int flush_dry_bio_endio(struct bio *bio, unsigned int bytes, int error)
 {
-        request_queue_t *q = bio->bi_private;
+        struct request_queue *q = bio->bi_private;
 
         /*
          * This is dry run, restore bio_sector and size.  We'll finish
@@ -551,7 +551,7 @@ static int flush_dry_bio_endio(struct bio *bio, unsigned int bytes, int error)
 static int ordered_bio_endio(struct request *rq, struct bio *bio,
                              unsigned int nbytes, int error)
 {
-        request_queue_t *q = rq->q;
+        struct request_queue *q = rq->q;
         bio_end_io_t *endio;
         void *private;
 
@@ -588,7 +588,7 @@ static int ordered_bio_endio(struct request *rq, struct bio *bio,
  *    blk_queue_bounce_limit to have lower memory pages allocated as bounce
  *    buffers for doing I/O to pages residing above @page.
  **/
-void blk_queue_bounce_limit(request_queue_t *q, u64 dma_addr)
+void blk_queue_bounce_limit(struct request_queue *q, u64 dma_addr)
 {
         unsigned long bounce_pfn = dma_addr >> PAGE_SHIFT;
         int dma = 0;
@@ -624,7 +624,7 @@ EXPORT_SYMBOL(blk_queue_bounce_limit);
  *    Enables a low level driver to set an upper limit on the size of
  *    received requests.
  **/
-void blk_queue_max_sectors(request_queue_t *q, unsigned int max_sectors)
+void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
 {
         if ((max_sectors << 9) < PAGE_CACHE_SIZE) {
                 max_sectors = 1 << (PAGE_CACHE_SHIFT - 9);
@@ -651,7 +651,8 @@ EXPORT_SYMBOL(blk_queue_max_sectors);
  *    physical data segments in a request.  This would be the largest sized
  *    scatter list the driver could handle.
  **/
-void blk_queue_max_phys_segments(request_queue_t *q, unsigned short max_segments)
+void blk_queue_max_phys_segments(struct request_queue *q,
+                                 unsigned short max_segments)
 {
         if (!max_segments) {
                 max_segments = 1;
@@ -674,7 +675,8 @@ EXPORT_SYMBOL(blk_queue_max_phys_segments);
  *    address/length pairs the host adapter can actually give as once
  *    to the device.
  **/
-void blk_queue_max_hw_segments(request_queue_t *q, unsigned short max_segments)
+void blk_queue_max_hw_segments(struct request_queue *q,
+                               unsigned short max_segments)
 {
         if (!max_segments) {
                 max_segments = 1;
@@ -695,7 +697,7 @@ EXPORT_SYMBOL(blk_queue_max_hw_segments);
  *    Enables a low level driver to set an upper limit on the size of a
  *    coalesced segment
  **/
-void blk_queue_max_segment_size(request_queue_t *q, unsigned int max_size)
+void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
 {
         if (max_size < PAGE_CACHE_SIZE) {
                 max_size = PAGE_CACHE_SIZE;
@@ -718,7 +720,7 @@ EXPORT_SYMBOL(blk_queue_max_segment_size);
  *   even internal read-modify-write operations). Usually the default
  *   of 512 covers most hardware.
  **/
-void blk_queue_hardsect_size(request_queue_t *q, unsigned short size)
+void blk_queue_hardsect_size(struct request_queue *q, unsigned short size)
 {
         q->hardsect_size = size;
 }
@@ -735,7 +737,7 @@ EXPORT_SYMBOL(blk_queue_hardsect_size);
  * @t:  the stacking driver (top)
  * @b:  the underlying device (bottom)
  **/
-void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b)
+void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
 {
         /* zero is "infinity" */
         t->max_sectors = min_not_zero(t->max_sectors,b->max_sectors);
@@ -756,7 +758,7 @@ EXPORT_SYMBOL(blk_queue_stack_limits);
  * @q:  the request queue for the device
  * @mask:  the memory boundary mask
  **/
-void blk_queue_segment_boundary(request_queue_t *q, unsigned long mask)
+void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
 {
         if (mask < PAGE_CACHE_SIZE - 1) {
                 mask = PAGE_CACHE_SIZE - 1;
@@ -778,7 +780,7 @@ EXPORT_SYMBOL(blk_queue_segment_boundary);
  *    this is used when buiding direct io requests for the queue.
  *
  **/
-void blk_queue_dma_alignment(request_queue_t *q, int mask)
+void blk_queue_dma_alignment(struct request_queue *q, int mask)
 {
         q->dma_alignment = mask;
 }
@@ -796,7 +798,7 @@ EXPORT_SYMBOL(blk_queue_dma_alignment);
  *
  *    no locks need be held.
  **/
-struct request *blk_queue_find_tag(request_queue_t *q, int tag)
+struct request *blk_queue_find_tag(struct request_queue *q, int tag)
 {
         return blk_map_queue_find_tag(q->queue_tags, tag);
 }
@@ -840,7 +842,7 @@ static int __blk_free_tags(struct blk_queue_tag *bqt)
  *    blk_cleanup_queue() will take care of calling this function, if tagging
  *    has been used. So there's no need to call this directly.
  **/
-static void __blk_queue_free_tags(request_queue_t *q)
+static void __blk_queue_free_tags(struct request_queue *q)
 {
         struct blk_queue_tag *bqt = q->queue_tags;
 
@@ -877,7 +879,7 @@ EXPORT_SYMBOL(blk_free_tags);
  *      This is used to disabled tagged queuing to a device, yet leave
  *      queue in function.
  **/
-void blk_queue_free_tags(request_queue_t *q)
+void blk_queue_free_tags(struct request_queue *q)
 {
         clear_bit(QUEUE_FLAG_QUEUED, &q->queue_flags);
 }
@@ -885,7 +887,7 @@ void blk_queue_free_tags(request_queue_t *q)
 EXPORT_SYMBOL(blk_queue_free_tags);
 
 static int
-init_tag_map(request_queue_t *q, struct blk_queue_tag *tags, int depth)
+init_tag_map(struct request_queue *q, struct blk_queue_tag *tags, int depth)
 {
         struct request **tag_index;
         unsigned long *tag_map;
@@ -955,7 +957,7 @@ EXPORT_SYMBOL(blk_init_tags);
  * @depth:  the maximum queue depth supported
  * @tags: the tag to use
  **/
-int blk_queue_init_tags(request_queue_t *q, int depth,
+int blk_queue_init_tags(struct request_queue *q, int depth,
                         struct blk_queue_tag *tags)
 {
         int rc;
@@ -996,7 +998,7 @@ EXPORT_SYMBOL(blk_queue_init_tags);
  *  Notes:
  *    Must be called with the queue lock held.
  **/
-int blk_queue_resize_tags(request_queue_t *q, int new_depth)
+int blk_queue_resize_tags(struct request_queue *q, int new_depth)
 {
         struct blk_queue_tag *bqt = q->queue_tags;
         struct request **tag_index;
@@ -1059,7 +1061,7 @@ EXPORT_SYMBOL(blk_queue_resize_tags);
  *  Notes:
  *   queue lock must be held.
  **/
-void blk_queue_end_tag(request_queue_t *q, struct request *rq)
+void blk_queue_end_tag(struct request_queue *q, struct request *rq)
 {
         struct blk_queue_tag *bqt = q->queue_tags;
         int tag = rq->tag;
@@ -1111,7 +1113,7 @@ EXPORT_SYMBOL(blk_queue_end_tag);
  *  Notes:
  *   queue lock must be held.
  **/
-int blk_queue_start_tag(request_queue_t *q, struct request *rq)
+int blk_queue_start_tag(struct request_queue *q, struct request *rq)
 {
         struct blk_queue_tag *bqt = q->queue_tags;
         int tag;
@@ -1158,7 +1160,7 @@ EXPORT_SYMBOL(blk_queue_start_tag);
  *  Notes:
  *   queue lock must be held.
  **/
-void blk_queue_invalidate_tags(request_queue_t *q)
+void blk_queue_invalidate_tags(struct request_queue *q)
 {
         struct blk_queue_tag *bqt = q->queue_tags;
         struct list_head *tmp, *n;
@@ -1205,7 +1207,7 @@ void blk_dump_rq_flags(struct request *rq, char *msg)
 
 EXPORT_SYMBOL(blk_dump_rq_flags);
 
-void blk_recount_segments(request_queue_t *q, struct bio *bio)
+void blk_recount_segments(struct request_queue *q, struct bio *bio)
 {
         struct bio_vec *bv, *bvprv = NULL;
         int i, nr_phys_segs, nr_hw_segs, seg_size, hw_seg_size, cluster;
@@ -1267,7 +1269,7 @@ new_hw_segment:
 }
 EXPORT_SYMBOL(blk_recount_segments);
 
-static int blk_phys_contig_segment(request_queue_t *q, struct bio *bio,
+static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio,
                                    struct bio *nxt)
 {
         if (!(q->queue_flags & (1 << QUEUE_FLAG_CLUSTER)))
@@ -1288,7 +1290,7 @@ static int blk_phys_contig_segment(request_queue_t *q, struct bio *bio,
         return 0;
 }
 
-static int blk_hw_contig_segment(request_queue_t *q, struct bio *bio,
+static int blk_hw_contig_segment(struct request_queue *q, struct bio *bio,
                                  struct bio *nxt)
 {
         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
@@ -1308,7 +1310,8 @@ static int blk_hw_contig_segment(request_queue_t *q, struct bio *bio,
  * map a request to scatterlist, return number of sg entries setup. Caller
  * must make sure sg can hold rq->nr_phys_segments entries
  */
-int blk_rq_map_sg(request_queue_t *q, struct request *rq, struct scatterlist *sg)
+int blk_rq_map_sg(struct request_queue *q, struct request *rq,
+                  struct scatterlist *sg)
 {
         struct bio_vec *bvec, *bvprv;
         struct bio *bio;
@@ -1361,7 +1364,7 @@ EXPORT_SYMBOL(blk_rq_map_sg);
  * specific ones if so desired
  */
 
-static inline int ll_new_mergeable(request_queue_t *q,
+static inline int ll_new_mergeable(struct request_queue *q,
                                    struct request *req,
                                    struct bio *bio)
 {
@@ -1382,7 +1385,7 @@ static inline int ll_new_mergeable(request_queue_t *q,
         return 1;
 }
 
-static inline int ll_new_hw_segment(request_queue_t *q,
+static inline int ll_new_hw_segment(struct request_queue *q,
                                     struct request *req,
                                     struct bio *bio)
 {
@@ -1406,7 +1409,7 @@ static inline int ll_new_hw_segment(request_queue_t *q,
         return 1;
 }
 
-int ll_back_merge_fn(request_queue_t *q, struct request *req, struct bio *bio)
+int ll_back_merge_fn(struct request_queue *q, struct request *req, struct bio *bio)
 {
         unsigned short max_sectors;
         int len;
@@ -1444,7 +1447,7 @@ int ll_back_merge_fn(request_queue_t *q, struct request *req, struct bio *bio)
 }
 EXPORT_SYMBOL(ll_back_merge_fn);
 
-static int ll_front_merge_fn(request_queue_t *q, struct request *req, 
+static int ll_front_merge_fn(struct request_queue *q, struct request *req, 
                              struct bio *bio)
 {
         unsigned short max_sectors;
@@ -1483,7 +1486,7 @@ static int ll_front_merge_fn(request_queue_t *q, struct request *req,
         return ll_new_hw_segment(q, req, bio);
 }
 
-static int ll_merge_requests_fn(request_queue_t *q, struct request *req,
+static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
                                 struct request *next)
 {
         int total_phys_segments;
@@ -1539,7 +1542,7 @@ static int ll_merge_requests_fn(request_queue_t *q, struct request *req,
  * This is called with interrupts off and no requests on the queue and
  * with the queue lock held.
  */
-void blk_plug_device(request_queue_t *q)
+void blk_plug_device(struct request_queue *q)
 {
         WARN_ON(!irqs_disabled());
 
@@ -1562,7 +1565,7 @@ EXPORT_SYMBOL(blk_plug_device);
  * remove the queue from the plugged list, if present. called with
  * queue lock held and interrupts disabled.
  */
-int blk_remove_plug(request_queue_t *q)
+int blk_remove_plug(struct request_queue *q)
 {
         WARN_ON(!irqs_disabled());
 
@@ -1578,7 +1581,7 @@ EXPORT_SYMBOL(blk_remove_plug);
 /*
  * remove the plug and let it rip..
  */
-void __generic_unplug_device(request_queue_t *q)
+void __generic_unplug_device(struct request_queue *q)
 {
         if (unlikely(blk_queue_stopped(q)))
                 return;
@@ -1592,7 +1595,7 @@ EXPORT_SYMBOL(__generic_unplug_device);
 
 /**
  * generic_unplug_device - fire a request queue
- * @q:    The &request_queue_t in question
+ * @q:    The &struct request_queue in question
  *
  * Description:
  *   Linux uses plugging to build bigger requests queues before letting
@@ -1601,7 +1604,7 @@ EXPORT_SYMBOL(__generic_unplug_device);
  *   gets unplugged, the request_fn defined for the queue is invoked and
  *   transfers started.
  **/
-void generic_unplug_device(request_queue_t *q)
+void generic_unplug_device(struct request_queue *q)
 {
         spin_lock_irq(q->queue_lock);
         __generic_unplug_device(q);
@@ -1612,7 +1615,7 @@ EXPORT_SYMBOL(generic_unplug_device);
 static void blk_backing_dev_unplug(struct backing_dev_info *bdi,
                                    struct page *page)
 {
-        request_queue_t *q = bdi->unplug_io_data;
+        struct request_queue *q = bdi->unplug_io_data;
 
         /*
          * devices don't necessarily have an ->unplug_fn defined
@@ -1627,7 +1630,8 @@ static void blk_backing_dev_unplug(struct backing_dev_info *bdi,
 
 static void blk_unplug_work(struct work_struct *work)
 {
-        request_queue_t *q = container_of(work, request_queue_t, unplug_work);
+        struct request_queue *q =
+                container_of(work, struct request_queue, unplug_work);
 
         blk_add_trace_pdu_int(q, BLK_TA_UNPLUG_IO, NULL,
                                 q->rq.count[READ] + q->rq.count[WRITE]);
@@ -1637,7 +1641,7 @@ static void blk_unplug_work(struct work_struct *work)
 
 static void blk_unplug_timeout(unsigned long data)
 {
-        request_queue_t *q = (request_queue_t *)data;
+        struct request_queue *q = (struct request_queue *)data;
 
         blk_add_trace_pdu_int(q, BLK_TA_UNPLUG_TIMER, NULL,
                                 q->rq.count[READ] + q->rq.count[WRITE]);
@@ -1647,14 +1651,14 @@ static void blk_unplug_timeout(unsigned long data)
 
 /**
  * blk_start_queue - restart a previously stopped queue
- * @q:    The &request_queue_t in question
+ * @q:    The &struct request_queue in question
  *
  * Description:
  *   blk_start_queue() will clear the stop flag on the queue, and call
  *   the request_fn for the queue if it was in a stopped state when
  *   entered. Also see blk_stop_queue(). Queue lock must be held.
  **/
-void blk_start_queue(request_queue_t *q)
+void blk_start_queue(struct request_queue *q)
 {
         WARN_ON(!irqs_disabled());
 
@@ -1677,7 +1681,7 @@ EXPORT_SYMBOL(blk_start_queue);
 
 /**
  * blk_stop_queue - stop a queue
- * @q:    The &request_queue_t in question
+ * @q:    The &struct request_queue in question
  *
  * Description:
  *   The Linux block layer assumes that a block driver will consume all
@@ -1689,7 +1693,7 @@ EXPORT_SYMBOL(blk_start_queue);
  *   the driver has signalled it's ready to go again. This happens by calling
  *   blk_start_queue() to restart queue operations. Queue lock must be held.
  **/
-void blk_stop_queue(request_queue_t *q)
+void blk_stop_queue(struct request_queue *q)
 {
         blk_remove_plug(q);
         set_bit(QUEUE_FLAG_STOPPED, &q->queue_flags);
@@ -1746,7 +1750,7 @@ void blk_run_queue(struct request_queue *q)
 EXPORT_SYMBOL(blk_run_queue);
 
 /**
- * blk_cleanup_queue: - release a &request_queue_t when it is no longer needed
+ * blk_cleanup_queue: - release a &struct request_queue when it is no longer needed
  * @kobj:    the kobj belonging of the request queue to be released
  *
  * Description:
@@ -1762,7 +1766,8 @@ EXPORT_SYMBOL(blk_run_queue);
  **/
 static void blk_release_queue(struct kobject *kobj)
 {
-        request_queue_t *q = container_of(kobj, struct request_queue, kobj);
+        struct request_queue *q =
+                container_of(kobj, struct request_queue, kobj);
         struct request_list *rl = &q->rq;
 
         blk_sync_queue(q);
@@ -1778,13 +1783,13 @@ static void blk_release_queue(struct kobject *kobj)
         kmem_cache_free(requestq_cachep, q);
 }
 
-void blk_put_queue(request_queue_t *q)
+void blk_put_queue(struct request_queue *q)
 {
         kobject_put(&q->kobj);
 }
 EXPORT_SYMBOL(blk_put_queue);
 
-void blk_cleanup_queue(request_queue_t * q)
+void blk_cleanup_queue(struct request_queue * q)
 {
         mutex_lock(&q->sysfs_lock);
         set_bit(QUEUE_FLAG_DEAD, &q->queue_flags);
@@ -1798,7 +1803,7 @@ void blk_cleanup_queue(request_queue_t * q)
 
 EXPORT_SYMBOL(blk_cleanup_queue);
 
-static int blk_init_free_list(request_queue_t *q)
+static int blk_init_free_list(struct request_queue *q)
 {
         struct request_list *rl = &q->rq;
 
@@ -1817,7 +1822,7 @@ static int blk_init_free_list(request_queue_t *q)
         return 0;
 }
 
-request_queue_t *blk_alloc_queue(gfp_t gfp_mask)
+struct request_queue *blk_alloc_queue(gfp_t gfp_mask)
 {
         return blk_alloc_queue_node(gfp_mask, -1);
 }
@@ -1825,9 +1830,9 @@ EXPORT_SYMBOL(blk_alloc_queue);
 
 static struct kobj_type queue_ktype;
 
-request_queue_t *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
+struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
 {
-        request_queue_t *q;
+        struct request_queue *q;
 
         q = kmem_cache_alloc_node(requestq_cachep,
                                 gfp_mask | __GFP_ZERO, node_id);
@@ -1882,16 +1887,16 @@ EXPORT_SYMBOL(blk_alloc_queue_node);
  *    when the block device is deactivated (such as at module unload).
  **/
 
-request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)
+struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)
 {
         return blk_init_queue_node(rfn, lock, -1);
 }
 EXPORT_SYMBOL(blk_init_queue);
 
-request_queue_t *
+struct request_queue *
 blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
 {
-        request_queue_t *q = blk_alloc_queue_node(GFP_KERNEL, node_id);
+        struct request_queue *q = blk_alloc_queue_node(GFP_KERNEL, node_id);
 
         if (!q)
                 return NULL;
@@ -1940,7 +1945,7 @@ blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id)
 }
 EXPORT_SYMBOL(blk_init_queue_node);
 
-int blk_get_queue(request_queue_t *q)
+int blk_get_queue(struct request_queue *q)
 {
         if (likely(!test_bit(QUEUE_FLAG_DEAD, &q->queue_flags))) {
                 kobject_get(&q->kobj);
@@ -1952,7 +1957,7 @@ int blk_get_queue(request_queue_t *q)
 
 EXPORT_SYMBOL(blk_get_queue);
 
-static inline void blk_free_request(request_queue_t *q, struct request *rq)
+static inline void blk_free_request(struct request_queue *q, struct request *rq)
 {
         if (rq->cmd_flags & REQ_ELVPRIV)
                 elv_put_request(q, rq);
@@ -1960,7 +1965,7 @@ static inline void blk_free_request(request_queue_t *q, struct request *rq)
 }
 
 static struct request *
-blk_alloc_request(request_queue_t *q, int rw, int priv, gfp_t gfp_mask)
+blk_alloc_request(struct request_queue *q, int rw, int priv, gfp_t gfp_mask)
 {
         struct request *rq = mempool_alloc(q->rq.rq_pool, gfp_mask);
 
@@ -1988,7 +1993,7 @@ blk_alloc_request(request_queue_t *q, int rw, int priv, gfp_t gfp_mask)
  * ioc_batching returns true if the ioc is a valid batching request and
  * should be given priority access to a request.
  */
-static inline int ioc_batching(request_queue_t *q, struct io_context *ioc)
+static inline int ioc_batching(struct request_queue *q, struct io_context *ioc)
 {
         if (!ioc)
                 return 0;
@@ -2009,7 +2014,7 @@ static inline int ioc_batching(request_queue_t *q, struct io_context *ioc)
  * is the behaviour we want though - once it gets a wakeup it should be given
  * a nice run.
  */
-static void ioc_set_batching(request_queue_t *q, struct io_context *ioc)
+static void ioc_set_batching(struct request_queue *q, struct io_context *ioc)
 {
         if (!ioc || ioc_batching(q, ioc))
                 return;
@@ -2018,7 +2023,7 @@ static void ioc_set_batching(request_queue_t *q, struct io_context *ioc)
         ioc->last_waited = jiffies;
 }
 
-static void __freed_request(request_queue_t *q, int rw)
+static void __freed_request(struct request_queue *q, int rw)
 {
         struct request_list *rl = &q->rq;
 
@@ -2037,7 +2042,7 @@ static void __freed_request(request_queue_t *q, int rw)
  * A request has just been released.  Account for it, update the full and
  * congestion status, wake up any waiters.   Called under q->queue_lock.
  */
-static void freed_request(request_queue_t *q, int rw, int priv)
+static void freed_request(struct request_queue *q, int rw, int priv)
 {
         struct request_list *rl = &q->rq;
 
@@ -2057,7 +2062,7 @@ static void freed_request(request_queue_t *q, int rw, int priv)
  * Returns NULL on failure, with queue_lock held.
  * Returns !NULL on success, with queue_lock *not held*.
  */
-static struct request *get_request(request_queue_t *q, int rw_flags,
+static struct request *get_request(struct request_queue *q, int rw_flags,
                                    struct bio *bio, gfp_t gfp_mask)
 {
         struct request *rq = NULL;
@@ -2162,7 +2167,7 @@ out:
  *
  * Called with q->queue_lock held, and returns with it unlocked.
  */
-static struct request *get_request_wait(request_queue_t *q, int rw_flags,
+static struct request *get_request_wait(struct request_queue *q, int rw_flags,
                                         struct bio *bio)
 {
         const int rw = rw_flags & 0x01;
@@ -2204,7 +2209,7 @@ static struct request *get_request_wait(request_queue_t *q, int rw_flags,
         return rq;
 }
 
-struct request *blk_get_request(request_queue_t *q, int rw, gfp_t gfp_mask)
+struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)
 {
         struct request *rq;
 
@@ -2234,7 +2239,7 @@ EXPORT_SYMBOL(blk_get_request);
  *
  * The queue lock must be held with interrupts disabled.
  */
-void blk_start_queueing(request_queue_t *q)
+void blk_start_queueing(struct request_queue *q)
 {
         if (!blk_queue_plugged(q))
                 q->request_fn(q);
@@ -2253,7 +2258,7 @@ EXPORT_SYMBOL(blk_start_queueing);
  *    more, when that condition happens we need to put the request back
  *    on the queue. Must be called with queue lock held.
  */
-void blk_requeue_request(request_queue_t *q, struct request *rq)
+void blk_requeue_request(struct request_queue *q, struct request *rq)
 {
         blk_add_trace_rq(q, rq, BLK_TA_REQUEUE);
 
@@ -2284,7 +2289,7 @@ EXPORT_SYMBOL(blk_requeue_request);
  *    of the queue for things like a QUEUE_FULL message from a device, or a
  *    host that is unable to accept a particular command.
  */
-void blk_insert_request(request_queue_t *q, struct request *rq,
+void blk_insert_request(struct request_queue *q, struct request *rq,
                         int at_head, void *data)
 {
         int where = at_head ? ELEVATOR_INSERT_FRONT : ELEVATOR_INSERT_BACK;
@@ -2330,7 +2335,7 @@ static int __blk_rq_unmap_user(struct bio *bio)
         return ret;
 }
 
-static int __blk_rq_map_user(request_queue_t *q, struct request *rq,
+static int __blk_rq_map_user(struct request_queue *q, struct request *rq,
                              void __user *ubuf, unsigned int len)
 {
         unsigned long uaddr;
@@ -2403,8 +2408,8 @@ unmap_bio:
  *    original bio must be passed back in to blk_rq_unmap_user() for proper
  *    unmapping.
  */
-int blk_rq_map_user(request_queue_t *q, struct request *rq, void __user *ubuf,
-                    unsigned long len)
+int blk_rq_map_user(struct request_queue *q, struct request *rq,
+                    void __user *ubuf, unsigned long len)
 {
         unsigned long bytes_read = 0;
         struct bio *bio = NULL;
@@ -2470,7 +2475,7 @@ EXPORT_SYMBOL(blk_rq_map_user);
  *    original bio must be passed back in to blk_rq_unmap_user() for proper
  *    unmapping.
  */
-int blk_rq_map_user_iov(request_queue_t *q, struct request *rq,
+int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
                         struct sg_iovec *iov, int iov_count, unsigned int len)
 {
         struct bio *bio;
@@ -2540,7 +2545,7 @@ EXPORT_SYMBOL(blk_rq_unmap_user);
  * @len:        length of user data
  * @gfp_mask:   memory allocation flags
  */
-int blk_rq_map_kern(request_queue_t *q, struct request *rq, void *kbuf,
+int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
                     unsigned int len, gfp_t gfp_mask)
 {
         struct bio *bio;
@@ -2577,7 +2582,7 @@ EXPORT_SYMBOL(blk_rq_map_kern);
  *    Insert a fully prepared request at the back of the io scheduler queue
  *    for execution.  Don't wait for completion.
  */
-void blk_execute_rq_nowait(request_queue_t *q, struct gendisk *bd_disk,
+void blk_execute_rq_nowait(struct request_queue *q, struct gendisk *bd_disk,
                            struct request *rq, int at_head,
                            rq_end_io_fn *done)
 {
@@ -2605,7 +2610,7 @@ EXPORT_SYMBOL_GPL(blk_execute_rq_nowait);
  *    Insert a fully prepared request at the back of the io scheduler queue
  *    for execution and wait for completion.
  */
-int blk_execute_rq(request_queue_t *q, struct gendisk *bd_disk,
+int blk_execute_rq(struct request_queue *q, struct gendisk *bd_disk,
                    struct request *rq, int at_head)
 {
         DECLARE_COMPLETION_ONSTACK(wait);
@@ -2648,7 +2653,7 @@ EXPORT_SYMBOL(blk_execute_rq);
  */
 int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
 {
-        request_queue_t *q;
+        struct request_queue *q;
 
         if (bdev->bd_disk == NULL)
                 return -ENXIO;
@@ -2684,7 +2689,7 @@ static void drive_stat_acct(struct request *rq, int nr_sectors, int new_io)
  * queue lock is held and interrupts disabled, as we muck with the
  * request queue list.
  */
-static inline void add_request(request_queue_t * q, struct request * req)
+static inline void add_request(struct request_queue * q, struct request * req)
 {
         drive_stat_acct(req, req->nr_sectors, 1);
 
@@ -2730,7 +2735,7 @@ EXPORT_SYMBOL_GPL(disk_round_stats);
 /*
  * queue lock must be held
  */
-void __blk_put_request(request_queue_t *q, struct request *req)
+void __blk_put_request(struct request_queue *q, struct request *req)
 {
         if (unlikely(!q))
                 return;
@@ -2760,7 +2765,7 @@ EXPORT_SYMBOL_GPL(__blk_put_request);
 void blk_put_request(struct request *req)
 {
         unsigned long flags;
-        request_queue_t *q = req->q;
+        struct request_queue *q = req->q;
 
         /*
          * Gee, IDE calls in w/ NULL q.  Fix IDE and remove the
@@ -2798,7 +2803,7 @@ EXPORT_SYMBOL(blk_end_sync_rq);
 /*
  * Has to be called with the request spinlock acquired
  */
-static int attempt_merge(request_queue_t *q, struct request *req,
+static int attempt_merge(struct request_queue *q, struct request *req,
                           struct request *next)
 {
         if (!rq_mergeable(req) || !rq_mergeable(next))
@@ -2851,7 +2856,8 @@ static int attempt_merge(request_queue_t *q, struct request *req,
         return 1;
 }
 
-static inline int attempt_back_merge(request_queue_t *q, struct request *rq)
+static inline int attempt_back_merge(struct request_queue *q,
+                                     struct request *rq)
 {
         struct request *next = elv_latter_request(q, rq);
 
@@ -2861,7 +2867,8 @@ static inline int attempt_back_merge(request_queue_t *q, struct request *rq)
         return 0;
 }
 
-static inline int attempt_front_merge(request_queue_t *q, struct request *rq)
+static inline int attempt_front_merge(struct request_queue *q,
+                                      struct request *rq)
 {
         struct request *prev = elv_former_request(q, rq);
 
@@ -2905,7 +2912,7 @@ static void init_request_from_bio(struct request *req, struct bio *bio)
         req->start_time = jiffies;
 }
 
-static int __make_request(request_queue_t *q, struct bio *bio)
+static int __make_request(struct request_queue *q, struct bio *bio)
 {
         struct request *req;
         int el_ret, nr_sectors, barrier, err;
@@ -3119,7 +3126,7 @@ static inline int should_fail_request(struct bio *bio)
  */
 static inline void __generic_make_request(struct bio *bio)
 {
-        request_queue_t *q;
+        struct request_queue *q;
         sector_t maxsector;
         sector_t old_sector;
         int ret, nr_sectors = bio_sectors(bio);
@@ -3312,7 +3319,7 @@ static void blk_recalc_rq_segments(struct request *rq)
         struct bio *bio, *prevbio = NULL;
         int nr_phys_segs, nr_hw_segs;
         unsigned int phys_size, hw_size;
-        request_queue_t *q = rq->q;
+        struct request_queue *q = rq->q;
 
         if (!rq->bio)
                 return;
@@ -3658,7 +3665,8 @@ void end_request(struct request *req, int uptodate)
 
 EXPORT_SYMBOL(end_request);
 
-void blk_rq_bio_prep(request_queue_t *q, struct request *rq, struct bio *bio)
+void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
+                     struct bio *bio)
 {
         /* first two bits are identical in rq->cmd_flags and bio->bi_rw */
         rq->cmd_flags |= (bio->bi_rw & 3);
@@ -3701,7 +3709,7 @@ int __init blk_dev_init(void)
                         sizeof(struct request), 0, SLAB_PANIC, NULL);
 
         requestq_cachep = kmem_cache_create("blkdev_queue",
-                        sizeof(request_queue_t), 0, SLAB_PANIC, NULL);
+                        sizeof(struct request_queue), 0, SLAB_PANIC, NULL);
 
         iocontext_cachep = kmem_cache_create("blkdev_ioc",
                         sizeof(struct io_context), 0, SLAB_PANIC, NULL);
@@ -4021,7 +4029,8 @@ static ssize_t
 queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
 {
         struct queue_sysfs_entry *entry = to_queue(attr);
-        request_queue_t *q = container_of(kobj, struct request_queue, kobj);
+        struct request_queue *q =
+                container_of(kobj, struct request_queue, kobj);
         ssize_t res;
 
         if (!entry->show)
@@ -4041,7 +4050,7 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,
                     const char *page, size_t length)
 {
         struct queue_sysfs_entry *entry = to_queue(attr);
-        request_queue_t *q = container_of(kobj, struct request_queue, kobj);
+        struct request_queue *q = container_of(kobj, struct request_queue, kobj);
 
         ssize_t res;
 
@@ -4072,7 +4081,7 @@ int blk_register_queue(struct gendisk *disk)
 {
         int ret;
 
-        request_queue_t *q = disk->queue;
+        struct request_queue *q = disk->queue;
 
         if (!q || !q->request_fn)
                 return -ENXIO;
@@ -4097,7 +4106,7 @@ int blk_register_queue(struct gendisk *disk)
 
 void blk_unregister_queue(struct gendisk *disk)
 {
-        request_queue_t *q = disk->queue;
+        struct request_queue *q = disk->queue;
 
         if (q && q->request_fn) {
                 elv_unregister_queue(q);
diff --git a/block/noop-iosched.c b/block/noop-iosched.c
index 1c3de2b9a6b..7563d8aa394 100644
--- a/block/noop-iosched.c
+++ b/block/noop-iosched.c
@@ -11,13 +11,13 @@ struct noop_data {
         struct list_head queue;
 };
 
-static void noop_merged_requests(request_queue_t *q, struct request *rq,
+static void noop_merged_requests(struct request_queue *q, struct request *rq,
                                  struct request *next)
 {
         list_del_init(&next->queuelist);
 }
 
-static int noop_dispatch(request_queue_t *q, int force)
+static int noop_dispatch(struct request_queue *q, int force)
 {
         struct noop_data *nd = q->elevator->elevator_data;
 
@@ -31,14 +31,14 @@ static int noop_dispatch(request_queue_t *q, int force)
         return 0;
 }
 
-static void noop_add_request(request_queue_t *q, struct request *rq)
+static void noop_add_request(struct request_queue *q, struct request *rq)
 {
         struct noop_data *nd = q->elevator->elevator_data;
 
         list_add_tail(&rq->queuelist, &nd->queue);
 }
 
-static int noop_queue_empty(request_queue_t *q)
+static int noop_queue_empty(struct request_queue *q)
 {
         struct noop_data *nd = q->elevator->elevator_data;
 
@@ -46,7 +46,7 @@ static int noop_queue_empty(request_queue_t *q)
 }
 
 static struct request *
-noop_former_request(request_queue_t *q, struct request *rq)
+noop_former_request(struct request_queue *q, struct request *rq)
 {
         struct noop_data *nd = q->elevator->elevator_data;
 
@@ -56,7 +56,7 @@ noop_former_request(request_queue_t *q, struct request *rq)
 }
 
 static struct request *
-noop_latter_request(request_queue_t *q, struct request *rq)
+noop_latter_request(struct request_queue *q, struct request *rq)
 {
         struct noop_data *nd = q->elevator->elevator_data;
 
@@ -65,7 +65,7 @@ noop_latter_request(request_queue_t *q, struct request *rq)
         return list_entry(rq->queuelist.next, struct request, queuelist);
 }
 
-static void *noop_init_queue(request_queue_t *q)
+static void *noop_init_queue(struct request_queue *q)
 {
         struct noop_data *nd;
 
diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index d359a715bbc..91c73224f4c 100644
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -49,22 +49,22 @@ static int sg_get_version(int __user *p)
         return put_user(sg_version_num, p);
 }
 
-static int scsi_get_idlun(request_queue_t *q, int __user *p)
+static int scsi_get_idlun(struct request_queue *q, int __user *p)
 {
         return put_user(0, p);
 }
 
-static int scsi_get_bus(request_queue_t *q, int __user *p)
+static int scsi_get_bus(struct request_queue *q, int __user *p)
 {
         return put_user(0, p);
 }
 
-static int sg_get_timeout(request_queue_t *q)
+static int sg_get_timeout(struct request_queue *q)
 {
         return q->sg_timeout / (HZ / USER_HZ);
 }
 
-static int sg_set_timeout(request_queue_t *q, int __user *p)
+static int sg_set_timeout(struct request_queue *q, int __user *p)
 {
         int timeout, err = get_user(timeout, p);
 
@@ -74,14 +74,14 @@ static int sg_set_timeout(request_queue_t *q, int __user *p)
         return err;
 }
 
-static int sg_get_reserved_size(request_queue_t *q, int __user *p)
+static int sg_get_reserved_size(struct request_queue *q, int __user *p)
 {
         unsigned val = min(q->sg_reserved_size, q->max_sectors << 9);
 
         return put_user(val, p);
 }
 
-static int sg_set_reserved_size(request_queue_t *q, int __user *p)
+static int sg_set_reserved_size(struct request_queue *q, int __user *p)
 {
         int size, err = get_user(size, p);
 
@@ -101,7 +101,7 @@ static int sg_set_reserved_size(request_queue_t *q, int __user *p)
  * will always return that we are ATAPI even for a real SCSI drive, I'm not
  * so sure this is worth doing anything about (why would you care??)
  */
-static int sg_emulated_host(request_queue_t *q, int __user *p)
+static int sg_emulated_host(struct request_queue *q, int __user *p)
 {
         return put_user(1, p);
 }
@@ -214,7 +214,7 @@ int blk_verify_command(unsigned char *cmd, int has_write_perm)
 }
 EXPORT_SYMBOL_GPL(blk_verify_command);
 
-static int blk_fill_sghdr_rq(request_queue_t *q, struct request *rq,
+static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
                              struct sg_io_hdr *hdr, int has_write_perm)
 {
         memset(rq->cmd, 0, BLK_MAX_CDB); /* ATAPI hates garbage after CDB */
@@ -286,7 +286,7 @@ static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
         return r;
 }
 
-static int sg_io(struct file *file, request_queue_t *q,
+static int sg_io(struct file *file, struct request_queue *q,
                 struct gendisk *bd_disk, struct sg_io_hdr *hdr)
 {
         unsigned long start_time;
@@ -519,7 +519,8 @@ error:
 EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
 
 /* Send basic block requests */
-static int __blk_send_generic(request_queue_t *q, struct gendisk *bd_disk, int cmd, int data)
+static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
+                              int cmd, int data)
 {
         struct request *rq;
         int err;
@@ -539,7 +540,8 @@ static int __blk_send_generic(request_queue_t *q, struct gendisk *bd_disk, int c
         return err;
 }
 
-static inline int blk_send_start_stop(request_queue_t *q, struct gendisk *bd_disk, int data)
+static inline int blk_send_start_stop(struct request_queue *q,
+                                      struct gendisk *bd_disk, int data)
 {
         return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
 }
diff --git a/drivers/acorn/block/fd1772.c b/drivers/acorn/block/fd1772.c
index 423ed08fb6f..d7e18ce8dad 100644
--- a/drivers/acorn/block/fd1772.c
+++ b/drivers/acorn/block/fd1772.c
@@ -372,7 +372,7 @@ static int fd_test_drive_present(int drive);
 static void config_types(void);
 static int floppy_open(struct inode *inode, struct file *filp);
 static int floppy_release(struct inode *inode, struct file *filp);
-static void do_fd_request(request_queue_t *);
+static void do_fd_request(struct request_queue *);
 
 /************************* End of Prototypes **************************/
 
@@ -1271,7 +1271,7 @@ static void fd1772_checkint(void)
         }
 }
 
-static void do_fd_request(request_queue_t* q)
+static void do_fd_request(struct request_queue* q)
 {
         unsigned long flags;
 
diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index d85520f78e6..74058db674d 100644
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -924,7 +924,7 @@ static void mfm_request(void)
         DBG("mfm_request: Dropping out bottom\n");
 }
 
-static void do_mfm_request(request_queue_t *q)
+static void do_mfm_request(struct request_queue *q)
 {
         DBG("do_mfm_request: about to mfm_request\n");
         mfm_request();
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 12ac0b511f7..e83647651b3 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -768,7 +768,7 @@ static void ata_scsi_dev_config(struct scsi_device *sdev,
          * Decrement max hw segments accordingly.
          */
         if (dev->class == ATA_DEV_ATAPI) {
-                request_queue_t *q = sdev->request_queue;
+                struct request_queue *q = sdev->request_queue;
                 blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
         }
 
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 6ce8b897e26..c9751b2b57e 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1422,7 +1422,7 @@ static void redo_fd_request(void)
         goto repeat;
 }
 
-static void do_fd_request(request_queue_t * q)
+static void do_fd_request(struct request_queue * q)
 {
         redo_fd_request();
 }
diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
index 1d846681794..ba07f762c4c 100644
--- a/drivers/block/aoe/aoe.h
+++ b/drivers/block/aoe/aoe.h
@@ -138,7 +138,7 @@ struct aoedev {
         u16 maxbcnt;
         struct work_struct work;/* disk create work struct */
         struct gendisk *gd;
-        request_queue_t blkq;
+        struct request_queue blkq;
         struct hd_geometry geo; 
         sector_t ssize;
         struct timer_list timer;
diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index 4f598270fa3..007faaf008e 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -125,7 +125,7 @@ aoeblk_release(struct inode *inode, struct file *filp)
 }
 
 static int
-aoeblk_make_request(request_queue_t *q, struct bio *bio)
+aoeblk_make_request(struct request_queue *q, struct bio *bio)
 {
         struct aoedev *d;
         struct buf *buf;
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index 14d6b949275..94268c75d04 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -1466,7 +1466,7 @@ repeat:
 }
 
 
-void do_fd_request(request_queue_t * q)
+void do_fd_request(struct request_queue * q)
 {
         unsigned long flags;
 
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index a2d6612b80d..1be82d544dc 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -139,7 +139,7 @@ static struct board_type products[] = {
 
 static ctlr_info_t *hba[MAX_CTLR];
 
-static void do_cciss_request(request_queue_t *q);
+static void do_cciss_request(struct request_queue *q);
 static irqreturn_t do_cciss_intr(int irq, void *dev_id);
 static int cciss_open(struct inode *inode, struct file *filep);
 static int cciss_release(struct inode *inode, struct file *filep);
@@ -1584,7 +1584,7 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
          */
         if (h->gendisk[0] != disk) {
                 if (disk) {
-                        request_queue_t *q = disk->queue;
+                        struct request_queue *q = disk->queue;
                         if (disk->flags & GENHD_FL_UP)
                                 del_gendisk(disk);
                         if (q) {
@@ -2511,7 +2511,7 @@ after_error_processing:
 /*
  * Get a request and submit it to the controller.
  */
-static void do_cciss_request(request_queue_t *q)
+static void do_cciss_request(struct request_queue *q)
 {
         ctlr_info_t *h = q->queuedata;
         CommandList_struct *c;
@@ -3380,7 +3380,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
         do {
                 drive_info_struct *drv = &(hba[i]->drv[j]);
                 struct gendisk *disk = hba[i]->gendisk[j];
-                request_queue_t *q;
+                struct request_queue *q;
 
                 /* Check if the disk was allocated already */
                 if (!disk){
@@ -3523,7 +3523,7 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
         for (j = 0; j < CISS_MAX_LUN; j++) {
                 struct gendisk *disk = hba[i]->gendisk[j];
                 if (disk) {
-                        request_queue_t *q = disk->queue;
+                        struct request_queue *q = disk->queue;
 
                         if (disk->flags & GENHD_FL_UP)
                                 del_gendisk(disk);
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index b94cd1c3213..be4e3477d83 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -161,7 +161,7 @@ static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io);
 
-static void do_ida_request(request_queue_t *q);
+static void do_ida_request(struct request_queue *q);
 static void start_io(ctlr_info_t *h);
 
 static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c);
@@ -391,7 +391,7 @@ static void __devexit cpqarray_remove_one_eisa (int i)
 /* pdev is NULL for eisa */
 static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
 {
-        request_queue_t *q;
+        struct request_queue *q;
         int j;
 
         /* 
@@ -886,7 +886,7 @@ static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c)
  * are in here (either via the dummy do_ida_request functions or by being
  * called from the interrupt handler
  */
-static void do_ida_request(request_queue_t *q)
+static void do_ida_request(struct request_queue *q)
 {
         ctlr_info_t *h = q->queuedata;
         cmdlist_t *c;
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index fe088045dd0..085b7794fb3 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -251,7 +251,7 @@ static int irqdma_allocated;
 
 static struct request *current_req;
 static struct request_queue *floppy_queue;
-static void do_fd_request(request_queue_t * q);
+static void do_fd_request(struct request_queue * q);
 
 #ifndef fd_get_dma_residue
 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
@@ -2981,7 +2981,7 @@ static void process_fd_request(void)
         schedule_bh(redo_fd_request);
 }
 
-static void do_fd_request(request_queue_t * q)
+static void do_fd_request(struct request_queue * q)
 {
         if (max_buffer_sectors == 0) {
                 printk("VFS: do_fd_request called on non-open device\n");
diff --git a/drivers/block/lguest_blk.c b/drivers/block/lguest_blk.c
index 1634c2dd25e..5b79d072417 100644
--- a/drivers/block/lguest_blk.c
+++ b/drivers/block/lguest_blk.c
@@ -137,7 +137,7 @@ static void do_read(struct blockdev *bd, struct request *req)
         lguest_send_dma(bd->phys_addr, &ping);
 }
 
-static void do_lgb_request(request_queue_t *q)
+static void do_lgb_request(struct request_queue *q)
 {
         struct blockdev *bd;
         struct request *req;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index e425daa1eac..9f015fce413 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -529,7 +529,7 @@ static struct bio *loop_get_bio(struct loop_device *lo)
         return bio;
 }
 
-static int loop_make_request(request_queue_t *q, struct bio *old_bio)
+static int loop_make_request(struct request_queue *q, struct bio *old_bio)
 {
         struct loop_device *lo = q->queuedata;
         int rw = bio_rw(old_bio);
@@ -558,7 +558,7 @@ out:
 /*
  * kick off io on the underlying address space
  */
-static void loop_unplug(request_queue_t *q)
+static void loop_unplug(struct request_queue *q)
 {
         struct loop_device *lo = q->queuedata;
 
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index c1295102409..be92c658f06 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -100,7 +100,7 @@ static const char *nbdcmd_to_ascii(int cmd)
 static void nbd_end_request(struct request *req)
 {
         int uptodate = (req->errors == 0) ? 1 : 0;
-        request_queue_t *q = req->q;
+        struct request_queue *q = req->q;
         unsigned long flags;
 
         dprintk(DBG_BLKDEV, "%s: request %p: %s\n", req->rq_disk->disk_name,
@@ -410,7 +410,7 @@ static void nbd_clear_que(struct nbd_device *lo)
  *   { printk( "Warning: Ignoring result!\n"); nbd_end_request( req ); }
  */
 
-static void do_nbd_request(request_queue_t * q)
+static void do_nbd_request(struct request_queue * q)
 {
         struct request *req;
         
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 1eeb8f2cde7..b8a994a2b01 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -183,7 +183,7 @@ static int pcd_packet(struct cdrom_device_info *cdi,
 static int pcd_detect(void);
 static void pcd_probe_capabilities(void);
 static void do_pcd_read_drq(void);
-static void do_pcd_request(request_queue_t * q);
+static void do_pcd_request(struct request_queue * q);
 static void do_pcd_read(void);
 
 struct pcd_unit {
@@ -713,7 +713,7 @@ static int pcd_detect(void)
 /* I/O request processing */
 static struct request_queue *pcd_queue;
 
-static void do_pcd_request(request_queue_t * q)
+static void do_pcd_request(struct request_queue * q)
 {
         if (pcd_busy)
                 return;
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 31e01488eb5..df819f8a95a 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -698,7 +698,7 @@ static enum action pd_identify(struct pd_unit *disk)
 
 /* end of io request engine */
 
-static void do_pd_request(request_queue_t * q)
+static void do_pd_request(struct request_queue * q)
 {
         if (pd_req)
                 return;
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 5826508f673..ceffa6034e2 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -202,7 +202,7 @@ module_param_array(drive3, int, NULL, 0);
 #define ATAPI_WRITE_10          0x2a
 
 static int pf_open(struct inode *inode, struct file *file);
-static void do_pf_request(request_queue_t * q);
+static void do_pf_request(struct request_queue * q);
 static int pf_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, unsigned long arg);
 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
@@ -760,7 +760,7 @@ static void pf_end_request(int uptodate)
         }
 }
 
-static void do_pf_request(request_queue_t * q)
+static void do_pf_request(struct request_queue * q)
 {
         if (pf_busy)
                 return;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 31be33e4f11..fadbfd880ba 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -752,7 +752,7 @@ static inline struct bio *pkt_get_list_first(struct bio **list_head, struct bio
  */
 static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *cgc)
 {
-        request_queue_t *q = bdev_get_queue(pd->bdev);
+        struct request_queue *q = bdev_get_queue(pd->bdev);
         struct request *rq;
         int ret = 0;
 
@@ -979,7 +979,7 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
  * Special care is needed if the underlying block device has a small
  * max_phys_segments value.
  */
-static int pkt_set_segment_merging(struct pktcdvd_device *pd, request_queue_t *q)
+static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
 {
         if ((pd->settings.size << 9) / CD_FRAMESIZE <= q->max_phys_segments) {
                 /*
@@ -2314,7 +2314,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, int write)
 {
         int ret;
         long lba;
-        request_queue_t *q;
+        struct request_queue *q;
 
         /*
          * We need to re-open the cdrom device without O_NONBLOCK to be able
@@ -2477,7 +2477,7 @@ static int pkt_end_io_read_cloned(struct bio *bio, unsigned int bytes_done, int
         return 0;
 }
 
-static int pkt_make_request(request_queue_t *q, struct bio *bio)
+static int pkt_make_request(struct request_queue *q, struct bio *bio)
 {
         struct pktcdvd_device *pd;
         char b[BDEVNAME_SIZE];
@@ -2626,7 +2626,7 @@ end_io:
 
 
 
-static int pkt_merge_bvec(request_queue_t *q, struct bio *bio, struct bio_vec *bvec)
+static int pkt_merge_bvec(struct request_queue *q, struct bio *bio, struct bio_vec *bvec)
 {
         struct pktcdvd_device *pd = q->queuedata;
         sector_t zone = ZONE(bio->bi_sector, pd);
@@ -2647,7 +2647,7 @@ static int pkt_merge_bvec(request_queue_t *q, struct bio *bio, struct bio_vec *b
 
 static void pkt_init_queue(struct pktcdvd_device *pd)
 {
-        request_queue_t *q = pd->disk->queue;
+        struct request_queue *q = pd->disk->queue;
 
         blk_queue_make_request(q, pkt_make_request);
         blk_queue_hardsect_size(q, CD_FRAMESIZE);
diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 688a4fb0dc9..3c796e23625 100644
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -64,7 +64,7 @@ static void reset_ctrl(void);
 
 static int ps2esdi_geninit(void);
 
-static void do_ps2esdi_request(request_queue_t * q);
+static void do_ps2esdi_request(struct request_queue * q);
 
 static void ps2esdi_readwrite(int cmd, struct request *req);
 
@@ -473,7 +473,7 @@ static void __init ps2esdi_get_device_cfg(void)
 }
 
 /* strategy routine that handles most of the IO requests */
-static void do_ps2esdi_request(request_queue_t * q)
+static void do_ps2esdi_request(struct request_queue * q)
 {
         struct request *req;
         /* since, this routine is called with interrupts cleared - they 
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 170fb33dba9..aa8b890c80d 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -190,7 +190,7 @@ static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
 }
 
 static void ps3disk_do_request(struct ps3_storage_device *dev,
-                               request_queue_t *q)
+                               struct request_queue *q)
 {
         struct request *req;
 
@@ -211,7 +211,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
         }
 }
 
-static void ps3disk_request(request_queue_t *q)
+static void ps3disk_request(struct request_queue *q)
 {
         struct ps3_storage_device *dev = q->queuedata;
         struct ps3disk_private *priv = dev->sbd.core.driver_data;
@@ -404,7 +404,7 @@ static int ps3disk_identify(struct ps3_storage_device *dev)
         return 0;
 }
 
-static void ps3disk_prepare_flush(request_queue_t *q, struct request *req)
+static void ps3disk_prepare_flush(struct request_queue *q, struct request *req)
 {
         struct ps3_storage_device *dev = q->queuedata;
 
@@ -414,7 +414,7 @@ static void ps3disk_prepare_flush(request_queue_t *q, struct request *req)
         req->cmd_type = REQ_TYPE_FLUSH;
 }
 
-static int ps3disk_issue_flush(request_queue_t *q, struct gendisk *gendisk,
+static int ps3disk_issue_flush(struct request_queue *q, struct gendisk *gendisk,
                                sector_t *sector)
 {
         struct ps3_storage_device *dev = q->queuedata;
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index a1512da3241..65150b548f3 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -264,7 +264,7 @@ static int rd_blkdev_pagecache_IO(int rw, struct bio_vec *vec, sector_t sector,
  * 19-JAN-1998  Richard Gooch <rgooch@atnf.csiro.au>  Added devfs support
  *
  */
-static int rd_make_request(request_queue_t *q, struct bio *bio)
+static int rd_make_request(struct request_queue *q, struct bio *bio)
 {
         struct block_device *bdev = bio->bi_bdev;
         struct address_space * mapping = bdev->bd_inode->i_mapping;
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index d50b8238115..4dff49256ac 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -444,7 +444,7 @@ out:
         return err;
 }
 
-static void do_vdc_request(request_queue_t *q)
+static void do_vdc_request(struct request_queue *q)
 {
         while (1) {
                 struct request *req = elv_next_request(q);
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 1a65979f1f0..b4e462f154e 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -225,7 +225,7 @@ static unsigned short write_postamble[] = {
 static void swim3_select(struct floppy_state *fs, int sel);
 static void swim3_action(struct floppy_state *fs, int action);
 static int swim3_readbit(struct floppy_state *fs, int bit);
-static void do_fd_request(request_queue_t * q);
+static void do_fd_request(struct request_queue * q);
 static void start_request(struct floppy_state *fs);
 static void set_timeout(struct floppy_state *fs, int nticks,
                         void (*proc)(unsigned long));
@@ -290,7 +290,7 @@ static int swim3_readbit(struct floppy_state *fs, int bit)
         return (stat & DATA) == 0;
 }
 
-static void do_fd_request(request_queue_t * q)
+static void do_fd_request(struct request_queue * q)
 {
         int i;
         for(i=0;i<floppy_count;i++)
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 949ae93499e..402209fec59 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -278,7 +278,7 @@ struct carm_host {
         unsigned int                    state;
         u32                             fw_ver;
 
-        request_queue_t                 *oob_q;
+        struct request_queue            *oob_q;
         unsigned int                    n_oob;
 
         unsigned int                    hw_sg_used;
@@ -287,7 +287,7 @@ struct carm_host {
 
         unsigned int                    wait_q_prod;
         unsigned int                    wait_q_cons;
-        request_queue_t                 *wait_q[CARM_MAX_WAIT_Q];
+        struct request_queue            *wait_q[CARM_MAX_WAIT_Q];
 
         unsigned int                    n_msgs;
         u64                             msg_alloc;
@@ -756,7 +756,7 @@ static inline void carm_end_request_queued(struct carm_host *host,
         assert(rc == 0);
 }
 
-static inline void carm_push_q (struct carm_host *host, request_queue_t *q)
+static inline void carm_push_q (struct carm_host *host, struct request_queue *q)
 {
         unsigned int idx = host->wait_q_prod % CARM_MAX_WAIT_Q;
 
@@ -768,7 +768,7 @@ static inline void carm_push_q (struct carm_host *host, request_queue_t *q)
         BUG_ON(host->wait_q_prod == host->wait_q_cons); /* overrun */
 }
 
-static inline request_queue_t *carm_pop_q(struct carm_host *host)
+static inline struct request_queue *carm_pop_q(struct carm_host *host)
 {
         unsigned int idx;
 
@@ -783,7 +783,7 @@ static inline request_queue_t *carm_pop_q(struct carm_host *host)
 
 static inline void carm_round_robin(struct carm_host *host)
 {
-        request_queue_t *q = carm_pop_q(host);
+        struct request_queue *q = carm_pop_q(host);
         if (q) {
                 blk_start_queue(q);
                 VPRINTK("STARTED QUEUE %p\n", q);
@@ -802,7 +802,7 @@ static inline void carm_end_rq(struct carm_host *host, struct carm_request *crq,
         }
 }
 
-static void carm_oob_rq_fn(request_queue_t *q)
+static void carm_oob_rq_fn(struct request_queue *q)
 {
         struct carm_host *host = q->queuedata;
         struct carm_request *crq;
@@ -833,7 +833,7 @@ static void carm_oob_rq_fn(request_queue_t *q)
         }
 }
 
-static void carm_rq_fn(request_queue_t *q)
+static void carm_rq_fn(struct request_queue *q)
 {
         struct carm_port *port = q->queuedata;
         struct carm_host *host = port->host;
@@ -1494,7 +1494,7 @@ static int carm_init_disks(struct carm_host *host)
 
         for (i = 0; i < CARM_MAX_PORTS; i++) {
                 struct gendisk *disk;
-                request_queue_t *q;
+                struct request_queue *q;
                 struct carm_port *port;
 
                 port = &host->port[i];
@@ -1538,7 +1538,7 @@ static void carm_free_disks(struct carm_host *host)
         for (i = 0; i < CARM_MAX_PORTS; i++) {
                 struct gendisk *disk = host->port[i].disk;
                 if (disk) {
-                        request_queue_t *q = disk->queue;
+                        struct request_queue *q = disk->queue;
 
                         if (disk->flags & GENHD_FL_UP)
                                 del_gendisk(disk);
@@ -1571,7 +1571,7 @@ static int carm_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         struct carm_host *host;
         unsigned int pci_dac;
         int rc;
-        request_queue_t *q;
+        struct request_queue *q;
         unsigned int i;
 
         if (!printed_version++)
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 8b13d7d2cb6..c57dd2b3a0c 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -503,7 +503,7 @@ static void ub_cleanup(struct ub_dev *sc)
 {
         struct list_head *p;
         struct ub_lun *lun;
-        request_queue_t *q;
+        struct request_queue *q;
 
         while (!list_empty(&sc->luns)) {
                 p = sc->luns.next;
@@ -619,7 +619,7 @@ static struct ub_scsi_cmd *ub_cmdq_pop(struct ub_dev *sc)
  * The request function is our main entry point
  */
 
-static void ub_request_fn(request_queue_t *q)
+static void ub_request_fn(struct request_queue *q)
 {
         struct ub_lun *lun = q->queuedata;
         struct request *rq;
@@ -2273,7 +2273,7 @@ err_core:
 static int ub_probe_lun(struct ub_dev *sc, int lnum)
 {
         struct ub_lun *lun;
-        request_queue_t *q;
+        struct request_queue *q;
         struct gendisk *disk;
         int rc;
 
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index dec74bd2349..6b7c02d6360 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -114,7 +114,7 @@ struct cardinfo {
                                     */
         struct bio      *bio, *currentbio, **biotail;
 
-        request_queue_t *queue;
+        struct request_queue *queue;
 
         struct mm_page {
                 dma_addr_t              page_dma;
@@ -357,7 +357,7 @@ static inline void reset_page(struct mm_page *page)
         page->biotail = & page->bio;
 }
 
-static void mm_unplug_device(request_queue_t *q)
+static void mm_unplug_device(struct request_queue *q)
 {
         struct cardinfo *card = q->queuedata;
         unsigned long flags;
@@ -541,7 +541,7 @@ static void process_page(unsigned long data)
 --                              mm_make_request
 -----------------------------------------------------------------------------------
 */
-static int mm_make_request(request_queue_t *q, struct bio *bio)
+static int mm_make_request(struct request_queue *q, struct bio *bio)
 {
         struct cardinfo *card = q->queuedata;
         pr_debug("mm_make_request %llu %u\n",
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index dae39911a11..85916e2665d 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -400,7 +400,7 @@ error_ret:
 /*
  * This is the external request processing routine
  */
-static void do_viodasd_request(request_queue_t *q)
+static void do_viodasd_request(struct request_queue *q)
 {
         struct request *req;
 
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 0d97b7eb818..624d30f7da3 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -298,7 +298,7 @@ static u_char __init xd_detect (u_char *controller, unsigned int *address)
 }
 
 /* do_xd_request: handle an incoming request */
-static void do_xd_request (request_queue_t * q)
+static void do_xd_request (struct request_queue * q)
 {
         struct request *req;
 
diff --git a/drivers/block/xd.h b/drivers/block/xd.h
index 82e090fea95..cffd44a2038 100644
--- a/drivers/block/xd.h
+++ b/drivers/block/xd.h
@@ -104,7 +104,7 @@ static int xd_manual_geo_init (char *command);
 static u_char xd_detect (u_char *controller, unsigned int *address);
 static u_char xd_initdrives (void (*init_drive)(u_char drive));
 
-static void do_xd_request (request_queue_t * q);
+static void do_xd_request (struct request_queue * q);
 static int xd_ioctl (struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg);
 static int xd_readwrite (u_char operation,XD_INFO *disk,char *buffer,u_int block,u_int count);
 static void xd_recalibrate (u_char drive);
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 6746c29181f..964e51634f2 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -241,7 +241,7 @@ static inline void flush_requests(struct blkfront_info *info)
  * do_blkif_request
  *  read a block; request is in a request queue
  */
-static void do_blkif_request(request_queue_t *rq)
+static void do_blkif_request(struct request_queue *rq)
 {
         struct blkfront_info *info = NULL;
         struct request *req;
@@ -287,7 +287,7 @@ wait:
 
 static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
 {
-        request_queue_t *rq;
+        struct request_queue *rq;
 
         rq = blk_init_queue(do_blkif_request, &blkif_io_lock);
         if (rq == NULL)
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 732ec63b6e9..cb27e8863d7 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -458,7 +458,7 @@ static inline void ace_fsm_yieldirq(struct ace_device *ace)
 }
 
 /* Get the next read/write request; ending requests that we don't handle */
-struct request *ace_get_next_request(request_queue_t * q)
+struct request *ace_get_next_request(struct request_queue * q)
 {
         struct request *req;
 
@@ -825,7 +825,7 @@ static irqreturn_t ace_interrupt(int irq, void *dev_id)
 /* ---------------------------------------------------------------------
  * Block ops
  */
-static void ace_request(request_queue_t * q)
+static void ace_request(struct request_queue * q)
 {
         struct request *req;
         struct ace_device *ace;
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index e40fa98842e..2d5853cbd4b 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -67,7 +67,7 @@ static DEFINE_SPINLOCK(z2ram_lock);
 static struct block_device_operations z2_fops;
 static struct gendisk *z2ram_gendisk;
 
-static void do_z2_request(request_queue_t *q)
+static void do_z2_request(struct request_queue *q)
 {
         struct request *req;
         while ((req = elv_next_request(q)) != NULL) {
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 499019bf8f4..67ee3d4b287 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -2094,7 +2094,7 @@ out:
 static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
                                int lba, int nframes)
 {
-        request_queue_t *q = cdi->disk->queue;
+        struct request_queue *q = cdi->disk->queue;
         struct request *rq;
         struct bio *bio;
         unsigned int len;
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 44cd7b2ddf0..e51550db157 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -398,7 +398,7 @@ static void viocd_end_request(struct request *req, int uptodate)
 
 static int rwreq;
 
-static void do_viocd_request(request_queue_t *q)
+static void do_viocd_request(struct request_queue *q)
 {
         struct request *req;
 
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index c8dfd18bea4..acdbcdc3e45 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -726,7 +726,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC64 && (!SPARC32 || PCI) && !FRV && !ARM && !SUPERH && !S390
+        depends on !PPC && !PARISC && !IA64 && !M68K && !SPARC && !FRV && !ARM && !SUPERH && !S390
         ---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
@@ -750,6 +750,28 @@ config RTC
           To compile this driver as a module, choose M here: the
           module will be called rtc.
 
+config JS_RTC
+        tristate "Enhanced Real Time Clock Support"
+        depends on SPARC32 && 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
+          will get access to the real time clock (or hardware clock) built
+          into your computer.
+
+          Every PC has such a clock built in. It can be used to generate
+          signals from as low as 1Hz up to 8192Hz, and can also be used
+          as a 24 hour alarm. It reports status information via the file
+          /proc/driver/rtc and its behaviour is set by various ioctls on
+          /dev/rtc.
+
+          If you think you have a use for such a device (such as periodic data
+          sampling), then say Y here, and read <file:Documentation/rtc.txt>
+          for details.
+
+          To compile this driver as a module, choose M here: the
+          module will be called js-rtc.
+
 config SGI_DS1286
         tristate "SGI DS1286 RTC support"
         depends on SGI_IP22
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 8fecaf4010b..23b26b87cc3 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -109,6 +109,9 @@ obj-$(CONFIG_TCG_TPM)		+= tpm/
 
 obj-$(CONFIG_PS3_FLASH)         += ps3flash.o
 
+obj-$(CONFIG_JS_RTC)            += js-rtc.o
+js-rtc-y = rtc.o
+
 # Files generated that shall be removed upon make clean
 clean-files := consolemap_deftbl.c defkeymap.c
 
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 1486eb212cc..ca843522f91 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -3071,7 +3071,7 @@ static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
 /*
  * standard prep_rq_fn that builds 10 byte cmds
  */
-static int ide_cdrom_prep_fs(request_queue_t *q, struct request *rq)
+static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
 {
         int hard_sect = queue_hardsect_size(q);
         long block = (long)rq->hard_sector / (hard_sect >> 9);
@@ -3137,7 +3137,7 @@ static int ide_cdrom_prep_pc(struct request *rq)
         return BLKPREP_OK;
 }
 
-static int ide_cdrom_prep_fn(request_queue_t *q, struct request *rq)
+static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
 {
         if (blk_fs_request(rq))
                 return ide_cdrom_prep_fs(q, rq);
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index b1304a7f3e0..5ce4216f72a 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -679,7 +679,7 @@ static ide_proc_entry_t idedisk_proc[] = {
 };
 #endif  /* CONFIG_IDE_PROC_FS */
 
-static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
+static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
 {
         ide_drive_t *drive = q->queuedata;
 
@@ -697,7 +697,7 @@ static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
         rq->buffer = rq->cmd;
 }
 
-static int idedisk_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int idedisk_issue_flush(struct request_queue *q, struct gendisk *disk,
                                sector_t *error_sector)
 {
         ide_drive_t *drive = q->queuedata;
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 484c50e7144..aa9f5f0b1e6 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -1327,7 +1327,7 @@ static void ide_do_request (ide_hwgroup_t *hwgroup, int masked_irq)
 /*
  * Passes the stuff to ide_do_request
  */
-void do_ide_request(request_queue_t *q)
+void do_ide_request(struct request_queue *q)
 {
         ide_drive_t *drive = q->queuedata;
 
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 5a4c5ea12f8..3a2a9a338fd 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -945,7 +945,7 @@ static void save_match(ide_hwif_t *hwif, ide_hwif_t *new, ide_hwif_t **match)
  */
 static int ide_init_queue(ide_drive_t *drive)
 {
-        request_queue_t *q;
+        struct request_queue *q;
         ide_hwif_t *hwif = HWIF(drive);
         int max_sectors = 256;
         int max_sg_entries = PRD_ENTRIES;
diff --git a/drivers/ide/legacy/hd.c b/drivers/ide/legacy/hd.c
index 8f2db8dd35f..8e05d88e81b 100644
--- a/drivers/ide/legacy/hd.c
+++ b/drivers/ide/legacy/hd.c
@@ -652,7 +652,7 @@ repeat:
         }
 }
 
-static void do_hd_request (request_queue_t * q)
+static void do_hd_request (struct request_queue * q)
 {
         disable_irq(HD_IRQ);
         hd_request();
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 2fc199b0016..2bcde5798b5 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -526,7 +526,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
 
 void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
 {
-        request_queue_t *q = bdev_get_queue(bdev);
+        struct request_queue *q = bdev_get_queue(bdev);
         struct io_restrictions *rs = &ti->limits;
 
         /*
@@ -979,7 +979,7 @@ int dm_table_any_congested(struct dm_table *t, int bdi_bits)
         devices = dm_table_get_devices(t);
         for (d = devices->next; d != devices; d = d->next) {
                 struct dm_dev *dd = list_entry(d, struct dm_dev, list);
-                request_queue_t *q = bdev_get_queue(dd->bdev);
+                struct request_queue *q = bdev_get_queue(dd->bdev);
                 r |= bdi_congested(&q->backing_dev_info, bdi_bits);
         }
 
@@ -992,7 +992,7 @@ void dm_table_unplug_all(struct dm_table *t)
 
         for (d = devices->next; d != devices; d = d->next) {
                 struct dm_dev *dd = list_entry(d, struct dm_dev, list);
-                request_queue_t *q = bdev_get_queue(dd->bdev);
+                struct request_queue *q = bdev_get_queue(dd->bdev);
 
                 if (q->unplug_fn)
                         q->unplug_fn(q);
@@ -1011,7 +1011,7 @@ int dm_table_flush_all(struct dm_table *t)
 
         for (d = devices->next; d != devices; d = d->next) {
                 struct dm_dev *dd = list_entry(d, struct dm_dev, list);
-                request_queue_t *q = bdev_get_queue(dd->bdev);
+                struct request_queue *q = bdev_get_queue(dd->bdev);
                 int err;
 
                 if (!q->issue_flush_fn)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 846614e676c..141ff9fa296 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -80,7 +80,7 @@ struct mapped_device {
 
         unsigned long flags;
 
-        request_queue_t *queue;
+        struct request_queue *queue;
         struct gendisk *disk;
         char name[16];
 
@@ -792,7 +792,7 @@ static void __split_bio(struct mapped_device *md, struct bio *bio)
  * The request function that just remaps the bio built up by
  * dm_merge_bvec.
  */
-static int dm_request(request_queue_t *q, struct bio *bio)
+static int dm_request(struct request_queue *q, struct bio *bio)
 {
         int r;
         int rw = bio_data_dir(bio);
@@ -844,7 +844,7 @@ static int dm_request(request_queue_t *q, struct bio *bio)
         return 0;
 }
 
-static int dm_flush_all(request_queue_t *q, struct gendisk *disk,
+static int dm_flush_all(struct request_queue *q, struct gendisk *disk,
                         sector_t *error_sector)
 {
         struct mapped_device *md = q->queuedata;
@@ -859,7 +859,7 @@ static int dm_flush_all(request_queue_t *q, struct gendisk *disk,
         return ret;
 }
 
-static void dm_unplug_all(request_queue_t *q)
+static void dm_unplug_all(struct request_queue *q)
 {
         struct mapped_device *md = q->queuedata;
         struct dm_table *map = dm_get_table(md);
@@ -1110,7 +1110,7 @@ static void __set_size(struct mapped_device *md, sector_t size)
 
 static int __bind(struct mapped_device *md, struct dm_table *t)
 {
-        request_queue_t *q = md->queue;
+        struct request_queue *q = md->queue;
         sector_t size;
 
         size = dm_table_get_size(t);
diff --git a/drivers/md/faulty.c b/drivers/md/faulty.c
index 4ebd0f2a75e..cb059cf14c2 100644
--- a/drivers/md/faulty.c
+++ b/drivers/md/faulty.c
@@ -167,7 +167,7 @@ static void add_sector(conf_t *conf, sector_t start, int mode)
                 conf->nfaults = n+1;
 }
 
-static int make_request(request_queue_t *q, struct bio *bio)
+static int make_request(struct request_queue *q, struct bio *bio)
 {
         mddev_t *mddev = q->queuedata;
         conf_t *conf = (conf_t*)mddev->private;
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 19274108319..17f795c3e0a 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -55,7 +55,7 @@ static inline dev_info_t *which_dev(mddev_t *mddev, sector_t sector)
  *
  *      Return amount of bytes we can take at this offset
  */
-static int linear_mergeable_bvec(request_queue_t *q, struct bio *bio, struct bio_vec *biovec)
+static int linear_mergeable_bvec(struct request_queue *q, struct bio *bio, struct bio_vec *biovec)
 {
         mddev_t *mddev = q->queuedata;
         dev_info_t *dev0;
@@ -79,20 +79,20 @@ static int linear_mergeable_bvec(request_queue_t *q, struct bio *bio, struct bio
         return maxsectors << 9;
 }
 
-static void linear_unplug(request_queue_t *q)
+static void linear_unplug(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
         linear_conf_t *conf = mddev_to_conf(mddev);
         int i;
 
         for (i=0; i < mddev->raid_disks; i++) {
-                request_queue_t *r_queue = bdev_get_queue(conf->disks[i].rdev->bdev);
+                struct request_queue *r_queue = bdev_get_queue(conf->disks[i].rdev->bdev);
                 if (r_queue->unplug_fn)
                         r_queue->unplug_fn(r_queue);
         }
 }
 
-static int linear_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int linear_issue_flush(struct request_queue *q, struct gendisk *disk,
                               sector_t *error_sector)
 {
         mddev_t *mddev = q->queuedata;
@@ -101,7 +101,7 @@ static int linear_issue_flush(request_queue_t *q, struct gendisk *disk,
 
         for (i=0; i < mddev->raid_disks && ret == 0; i++) {
                 struct block_device *bdev = conf->disks[i].rdev->bdev;
-                request_queue_t *r_queue = bdev_get_queue(bdev);
+                struct request_queue *r_queue = bdev_get_queue(bdev);
 
                 if (!r_queue->issue_flush_fn)
                         ret = -EOPNOTSUPP;
@@ -118,7 +118,7 @@ static int linear_congested(void *data, int bits)
         int i, ret = 0;
 
         for (i = 0; i < mddev->raid_disks && !ret ; i++) {
-                request_queue_t *q = bdev_get_queue(conf->disks[i].rdev->bdev);
+                struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev);
                 ret |= bdi_congested(&q->backing_dev_info, bits);
         }
         return ret;
@@ -330,7 +330,7 @@ static int linear_stop (mddev_t *mddev)
         return 0;
 }
 
-static int linear_make_request (request_queue_t *q, struct bio *bio)
+static int linear_make_request (struct request_queue *q, struct bio *bio)
 {
         const int rw = bio_data_dir(bio);
         mddev_t *mddev = q->queuedata;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 65ddc887dfd..f883b7e37f3 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -211,7 +211,7 @@ static DEFINE_SPINLOCK(all_mddevs_lock);
                 )
 
 
-static int md_fail_request (request_queue_t *q, struct bio *bio)
+static int md_fail_request (struct request_queue *q, struct bio *bio)
 {
         bio_io_error(bio, bio->bi_size);
         return 0;
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 14da37fee37..1e2af43a73b 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -125,7 +125,7 @@ static void unplug_slaves(mddev_t *mddev)
                 mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)
                     && atomic_read(&rdev->nr_pending)) {
-                        request_queue_t *r_queue = bdev_get_queue(rdev->bdev);
+                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
 
                         atomic_inc(&rdev->nr_pending);
                         rcu_read_unlock();
@@ -140,13 +140,13 @@ static void unplug_slaves(mddev_t *mddev)
         rcu_read_unlock();
 }
 
-static void multipath_unplug(request_queue_t *q)
+static void multipath_unplug(struct request_queue *q)
 {
         unplug_slaves(q->queuedata);
 }
 
 
-static int multipath_make_request (request_queue_t *q, struct bio * bio)
+static int multipath_make_request (struct request_queue *q, struct bio * bio)
 {
         mddev_t *mddev = q->queuedata;
         multipath_conf_t *conf = mddev_to_conf(mddev);
@@ -199,7 +199,7 @@ static void multipath_status (struct seq_file *seq, mddev_t *mddev)
         seq_printf (seq, "]");
 }
 
-static int multipath_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int multipath_issue_flush(struct request_queue *q, struct gendisk *disk,
                                  sector_t *error_sector)
 {
         mddev_t *mddev = q->queuedata;
@@ -211,7 +211,7 @@ static int multipath_issue_flush(request_queue_t *q, struct gendisk *disk,
                 mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
                         struct block_device *bdev = rdev->bdev;
-                        request_queue_t *r_queue = bdev_get_queue(bdev);
+                        struct request_queue *r_queue = bdev_get_queue(bdev);
 
                         if (!r_queue->issue_flush_fn)
                                 ret = -EOPNOTSUPP;
@@ -238,7 +238,7 @@ static int multipath_congested(void *data, int bits)
         for (i = 0; i < mddev->raid_disks ; i++) {
                 mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        request_queue_t *q = bdev_get_queue(rdev->bdev);
+                        struct request_queue *q = bdev_get_queue(rdev->bdev);
 
                         ret |= bdi_congested(&q->backing_dev_info, bits);
                         /* Just like multipath_map, we just check the
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 2c404f73a37..b8216bc6db4 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -25,7 +25,7 @@
 #define MD_DRIVER
 #define MD_PERSONALITY
 
-static void raid0_unplug(request_queue_t *q)
+static void raid0_unplug(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
         raid0_conf_t *conf = mddev_to_conf(mddev);
@@ -33,14 +33,14 @@ static void raid0_unplug(request_queue_t *q)
         int i;
 
         for (i=0; i<mddev->raid_disks; i++) {
-                request_queue_t *r_queue = bdev_get_queue(devlist[i]->bdev);
+                struct request_queue *r_queue = bdev_get_queue(devlist[i]->bdev);
 
                 if (r_queue->unplug_fn)
                         r_queue->unplug_fn(r_queue);
         }
 }
 
-static int raid0_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int raid0_issue_flush(struct request_queue *q, struct gendisk *disk,
                              sector_t *error_sector)
 {
         mddev_t *mddev = q->queuedata;
@@ -50,7 +50,7 @@ static int raid0_issue_flush(request_queue_t *q, struct gendisk *disk,
 
         for (i=0; i<mddev->raid_disks && ret == 0; i++) {
                 struct block_device *bdev = devlist[i]->bdev;
-                request_queue_t *r_queue = bdev_get_queue(bdev);
+                struct request_queue *r_queue = bdev_get_queue(bdev);
 
                 if (!r_queue->issue_flush_fn)
                         ret = -EOPNOTSUPP;
@@ -68,7 +68,7 @@ static int raid0_congested(void *data, int bits)
         int i, ret = 0;
 
         for (i = 0; i < mddev->raid_disks && !ret ; i++) {
-                request_queue_t *q = bdev_get_queue(devlist[i]->bdev);
+                struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
 
                 ret |= bdi_congested(&q->backing_dev_info, bits);
         }
@@ -268,7 +268,7 @@ static int create_strip_zones (mddev_t *mddev)
  *
  *      Return amount of bytes we can accept at this offset
  */
-static int raid0_mergeable_bvec(request_queue_t *q, struct bio *bio, struct bio_vec *biovec)
+static int raid0_mergeable_bvec(struct request_queue *q, struct bio *bio, struct bio_vec *biovec)
 {
         mddev_t *mddev = q->queuedata;
         sector_t sector = bio->bi_sector + get_start_sect(bio->bi_bdev);
@@ -408,7 +408,7 @@ static int raid0_stop (mddev_t *mddev)
         return 0;
 }
 
-static int raid0_make_request (request_queue_t *q, struct bio *bio)
+static int raid0_make_request (struct request_queue *q, struct bio *bio)
 {
         mddev_t *mddev = q->queuedata;
         unsigned int sect_in_chunk, chunksize_bits,  chunk_size, chunk_sects;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 00c78b77b13..650991bddd8 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -552,7 +552,7 @@ static void unplug_slaves(mddev_t *mddev)
         for (i=0; i<mddev->raid_disks; i++) {
                 mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        request_queue_t *r_queue = bdev_get_queue(rdev->bdev);
+                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
 
                         atomic_inc(&rdev->nr_pending);
                         rcu_read_unlock();
@@ -567,7 +567,7 @@ static void unplug_slaves(mddev_t *mddev)
         rcu_read_unlock();
 }
 
-static void raid1_unplug(request_queue_t *q)
+static void raid1_unplug(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
 
@@ -575,7 +575,7 @@ static void raid1_unplug(request_queue_t *q)
         md_wakeup_thread(mddev->thread);
 }
 
-static int raid1_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int raid1_issue_flush(struct request_queue *q, struct gendisk *disk,
                              sector_t *error_sector)
 {
         mddev_t *mddev = q->queuedata;
@@ -587,7 +587,7 @@ static int raid1_issue_flush(request_queue_t *q, struct gendisk *disk,
                 mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
                         struct block_device *bdev = rdev->bdev;
-                        request_queue_t *r_queue = bdev_get_queue(bdev);
+                        struct request_queue *r_queue = bdev_get_queue(bdev);
 
                         if (!r_queue->issue_flush_fn)
                                 ret = -EOPNOTSUPP;
@@ -615,7 +615,7 @@ static int raid1_congested(void *data, int bits)
         for (i = 0; i < mddev->raid_disks; i++) {
                 mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        request_queue_t *q = bdev_get_queue(rdev->bdev);
+                        struct request_queue *q = bdev_get_queue(rdev->bdev);
 
                         /* Note the '|| 1' - when read_balance prefers
                          * non-congested targets, it can be removed
@@ -765,7 +765,7 @@ do_sync_io:
         return NULL;
 }
 
-static int make_request(request_queue_t *q, struct bio * bio)
+static int make_request(struct request_queue *q, struct bio * bio)
 {
         mddev_t *mddev = q->queuedata;
         conf_t *conf = mddev_to_conf(mddev);
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index a95ada1cfac..f730a144baf 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -453,7 +453,7 @@ static sector_t raid10_find_virt(conf_t *conf, sector_t sector, int dev)
  *      If near_copies == raid_disk, there are no striping issues,
  *      but in that case, the function isn't called at all.
  */
-static int raid10_mergeable_bvec(request_queue_t *q, struct bio *bio,
+static int raid10_mergeable_bvec(struct request_queue *q, struct bio *bio,
                                 struct bio_vec *bio_vec)
 {
         mddev_t *mddev = q->queuedata;
@@ -595,7 +595,7 @@ static void unplug_slaves(mddev_t *mddev)
         for (i=0; i<mddev->raid_disks; i++) {
                 mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        request_queue_t *r_queue = bdev_get_queue(rdev->bdev);
+                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
 
                         atomic_inc(&rdev->nr_pending);
                         rcu_read_unlock();
@@ -610,7 +610,7 @@ static void unplug_slaves(mddev_t *mddev)
         rcu_read_unlock();
 }
 
-static void raid10_unplug(request_queue_t *q)
+static void raid10_unplug(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
 
@@ -618,7 +618,7 @@ static void raid10_unplug(request_queue_t *q)
         md_wakeup_thread(mddev->thread);
 }
 
-static int raid10_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int raid10_issue_flush(struct request_queue *q, struct gendisk *disk,
                              sector_t *error_sector)
 {
         mddev_t *mddev = q->queuedata;
@@ -630,7 +630,7 @@ static int raid10_issue_flush(request_queue_t *q, struct gendisk *disk,
                 mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
                         struct block_device *bdev = rdev->bdev;
-                        request_queue_t *r_queue = bdev_get_queue(bdev);
+                        struct request_queue *r_queue = bdev_get_queue(bdev);
 
                         if (!r_queue->issue_flush_fn)
                                 ret = -EOPNOTSUPP;
@@ -658,7 +658,7 @@ static int raid10_congested(void *data, int bits)
         for (i = 0; i < mddev->raid_disks && ret == 0; i++) {
                 mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
-                        request_queue_t *q = bdev_get_queue(rdev->bdev);
+                        struct request_queue *q = bdev_get_queue(rdev->bdev);
 
                         ret |= bdi_congested(&q->backing_dev_info, bits);
                 }
@@ -772,7 +772,7 @@ static void unfreeze_array(conf_t *conf)
         spin_unlock_irq(&conf->resync_lock);
 }
 
-static int make_request(request_queue_t *q, struct bio * bio)
+static int make_request(struct request_queue *q, struct bio * bio)
 {
         mddev_t *mddev = q->queuedata;
         conf_t *conf = mddev_to_conf(mddev);
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index d90ee145eff..2aff4be35dc 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -289,7 +289,7 @@ static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector, in
 }
 
 static void unplug_slaves(mddev_t *mddev);
-static void raid5_unplug_device(request_queue_t *q);
+static void raid5_unplug_device(struct request_queue *q);
 
 static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector, int disks,
                                              int pd_idx, int noblock)
@@ -3182,7 +3182,7 @@ static void unplug_slaves(mddev_t *mddev)
         for (i=0; i<mddev->raid_disks; i++) {
                 mdk_rdev_t *rdev = rcu_dereference(conf->disks[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        request_queue_t *r_queue = bdev_get_queue(rdev->bdev);
+                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
 
                         atomic_inc(&rdev->nr_pending);
                         rcu_read_unlock();
@@ -3197,7 +3197,7 @@ static void unplug_slaves(mddev_t *mddev)
         rcu_read_unlock();
 }
 
-static void raid5_unplug_device(request_queue_t *q)
+static void raid5_unplug_device(struct request_queue *q)
 {
         mddev_t *mddev = q->queuedata;
         raid5_conf_t *conf = mddev_to_conf(mddev);
@@ -3216,7 +3216,7 @@ static void raid5_unplug_device(request_queue_t *q)
         unplug_slaves(mddev);
 }
 
-static int raid5_issue_flush(request_queue_t *q, struct gendisk *disk,
+static int raid5_issue_flush(struct request_queue *q, struct gendisk *disk,
                              sector_t *error_sector)
 {
         mddev_t *mddev = q->queuedata;
@@ -3228,7 +3228,7 @@ static int raid5_issue_flush(request_queue_t *q, struct gendisk *disk,
                 mdk_rdev_t *rdev = rcu_dereference(conf->disks[i].rdev);
                 if (rdev && !test_bit(Faulty, &rdev->flags)) {
                         struct block_device *bdev = rdev->bdev;
-                        request_queue_t *r_queue = bdev_get_queue(bdev);
+                        struct request_queue *r_queue = bdev_get_queue(bdev);
 
                         if (!r_queue->issue_flush_fn)
                                 ret = -EOPNOTSUPP;
@@ -3267,7 +3267,7 @@ static int raid5_congested(void *data, int bits)
 /* We want read requests to align with chunks where possible,
  * but write requests don't need to.
  */
-static int raid5_mergeable_bvec(request_queue_t *q, struct bio *bio, struct bio_vec *biovec)
+static int raid5_mergeable_bvec(struct request_queue *q, struct bio *bio, struct bio_vec *biovec)
 {
         mddev_t *mddev = q->queuedata;
         sector_t sector = bio->bi_sector + get_start_sect(bio->bi_bdev);
@@ -3377,7 +3377,7 @@ static int raid5_align_endio(struct bio *bi, unsigned int bytes, int error)
 
 static int bio_fits_rdev(struct bio *bi)
 {
-        request_queue_t *q = bdev_get_queue(bi->bi_bdev);
+        struct request_queue *q = bdev_get_queue(bi->bi_bdev);
 
         if ((bi->bi_size>>9) > q->max_sectors)
                 return 0;
@@ -3396,7 +3396,7 @@ static int bio_fits_rdev(struct bio *bi)
 }
 
 
-static int chunk_aligned_read(request_queue_t *q, struct bio * raid_bio)
+static int chunk_aligned_read(struct request_queue *q, struct bio * raid_bio)
 {
         mddev_t *mddev = q->queuedata;
         raid5_conf_t *conf = mddev_to_conf(mddev);
@@ -3466,7 +3466,7 @@ static int chunk_aligned_read(request_queue_t *q, struct bio * raid_bio)
 }
 
 
-static int make_request(request_queue_t *q, struct bio * bi)
+static int make_request(struct request_queue *q, struct bio * bi)
 {
         mddev_t *mddev = q->queuedata;
         raid5_conf_t *conf = mddev_to_conf(mddev);
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 988c8ce47f5..5e1c99f83ab 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -159,7 +159,7 @@ static int i2o_block_device_flush(struct i2o_device *dev)
  *      Returns 0 on success or negative error code on failure.
  */
 
-static int i2o_block_issue_flush(request_queue_t * queue, struct gendisk *disk,
+static int i2o_block_issue_flush(struct request_queue * queue, struct gendisk *disk,
                                  sector_t * error_sector)
 {
         struct i2o_block_device *i2o_blk_dev = queue->queuedata;
@@ -445,7 +445,7 @@ static void i2o_block_end_request(struct request *req, int uptodate,
 {
         struct i2o_block_request *ireq = req->special;
         struct i2o_block_device *dev = ireq->i2o_blk_dev;
-        request_queue_t *q = req->q;
+        struct request_queue *q = req->q;
         unsigned long flags;
 
         if (end_that_request_chunk(req, uptodate, nr_bytes)) {
diff --git a/drivers/misc/asus-laptop.c b/drivers/misc/asus-laptop.c
index f7530605997..6b89854bd3f 100644
--- a/drivers/misc/asus-laptop.c
+++ b/drivers/misc/asus-laptop.c
@@ -1067,19 +1067,16 @@ static void asus_backlight_exit(void)
 }
 
 #define  ASUS_LED_UNREGISTER(object)                            \
-        if(object##_led.class_dev                               \
-           && !IS_ERR(object##_led.class_dev))                  \
-                led_classdev_unregister(&object##_led)
+        led_classdev_unregister(&object##_led)
 
 static void asus_led_exit(void)
 {
+        destroy_workqueue(led_workqueue);
         ASUS_LED_UNREGISTER(mled);
         ASUS_LED_UNREGISTER(tled);
         ASUS_LED_UNREGISTER(pled);
         ASUS_LED_UNREGISTER(rled);
         ASUS_LED_UNREGISTER(gled);
-
-        destroy_workqueue(led_workqueue);
 }
 
 static void __exit asus_laptop_exit(void)
@@ -1135,29 +1132,42 @@ static int asus_led_init(struct device *dev)
 
         rv = ASUS_LED_REGISTER(mled, dev);
         if (rv)
-                return rv;
+                goto out;
 
         rv = ASUS_LED_REGISTER(tled, dev);
         if (rv)
-                return rv;
+                goto out1;
 
         rv = ASUS_LED_REGISTER(rled, dev);
         if (rv)
-                return rv;
+                goto out2;
 
         rv = ASUS_LED_REGISTER(pled, dev);
         if (rv)
-                return rv;
+                goto out3;
 
         rv = ASUS_LED_REGISTER(gled, dev);
         if (rv)
-                return rv;
+                goto out4;
 
         led_workqueue = create_singlethread_workqueue("led_workqueue");
         if (!led_workqueue)
-                return -ENOMEM;
+                goto out5;
 
         return 0;
+out5:
+        rv = -ENOMEM;
+        ASUS_LED_UNREGISTER(gled);
+out4:
+        ASUS_LED_UNREGISTER(pled);
+out3:
+        ASUS_LED_UNREGISTER(rled);
+out2:
+        ASUS_LED_UNREGISTER(tled);
+out1:
+        ASUS_LED_UNREGISTER(mled);
+out:
+        return rv;
 }
 
 static int __init asus_laptop_init(void)
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index b53dac8d1b6..e02eac87636 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -83,7 +83,7 @@ static int mmc_queue_thread(void *d)
  * on any queue on this host, and attempt to issue it.  This may
  * not be the queue we were asked to process.
  */
-static void mmc_request(request_queue_t *q)
+static void mmc_request(struct request_queue *q)
 {
         struct mmc_queue *mq = q->queuedata;
         struct request *req;
@@ -211,7 +211,7 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock
 
 void mmc_cleanup_queue(struct mmc_queue *mq)
 {
-        request_queue_t *q = mq->queue;
+        struct request_queue *q = mq->queue;
         unsigned long flags;
 
         /* Mark that we should start throwing out stragglers */
@@ -252,7 +252,7 @@ EXPORT_SYMBOL(mmc_cleanup_queue);
  */
 void mmc_queue_suspend(struct mmc_queue *mq)
 {
-        request_queue_t *q = mq->queue;
+        struct request_queue *q = mq->queue;
         unsigned long flags;
 
         if (!(mq->flags & MMC_QUEUE_SUSPENDED)) {
@@ -272,7 +272,7 @@ void mmc_queue_suspend(struct mmc_queue *mq)
  */
 void mmc_queue_resume(struct mmc_queue *mq)
 {
-        request_queue_t *q = mq->queue;
+        struct request_queue *q = mq->queue;
         unsigned long flags;
 
         if (mq->flags & MMC_QUEUE_SUSPENDED) {
diff --git a/drivers/net/82596.c b/drivers/net/82596.c
index 3ff1155459a..d915837193c 100644
--- a/drivers/net/82596.c
+++ b/drivers/net/82596.c
@@ -57,6 +57,7 @@
 #include <asm/io.h>
 #include <asm/dma.h>
 #include <asm/pgtable.h>
+#include <asm/cacheflush.h>
 
 static char version[] __initdata =
         "82596.c $Revision: 1.5 $\n";
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index 336af0635df..94b78cc5fe8 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -18,7 +18,7 @@ gianfar_driver-objs := gianfar.o \
                 gianfar_sysfs.o
 
 obj-$(CONFIG_UCC_GETH) += ucc_geth_driver.o
-ucc_geth_driver-objs := ucc_geth.o ucc_geth_mii.o
+ucc_geth_driver-objs := ucc_geth.o ucc_geth_mii.o ucc_geth_ethtool.o
 
 #
 # link order important here
diff --git a/drivers/net/acenic.c b/drivers/net/acenic.c
index b78a4e5ceeb..62e660a7938 100644
--- a/drivers/net/acenic.c
+++ b/drivers/net/acenic.c
@@ -3128,12 +3128,6 @@ static int __devinit read_eeprom_byte(struct net_device *dev,
         int result = 0;
         short i;
 
-        if (!dev) {
-                printk(KERN_ERR "No device!\n");
-                result = -ENODEV;
-                goto out;
-        }
-
         /*
          * Don't take interrupts on this CPU will bit banging
          * the %#%#@$ I2C device
diff --git a/drivers/net/atl1/atl1_hw.h b/drivers/net/atl1/atl1_hw.h
index 100c09c66e6..939aa0f53f6 100644
--- a/drivers/net/atl1/atl1_hw.h
+++ b/drivers/net/atl1/atl1_hw.h
@@ -680,11 +680,6 @@ void atl1_check_options(struct atl1_adapter *adapter);
 #define AUTONEG_ADVERTISE_10_100_ALL    0x000F  /* All 10/100 speeds */
 #define AUTONEG_ADVERTISE_10_ALL        0x0003  /* 10Mbps Full & Half speeds */
 
-/* The size (in bytes) of a ethernet packet */
-#define ENET_HEADER_SIZE                14
-#define MAXIMUM_ETHERNET_FRAME_SIZE     1518    /* with FCS */
-#define MINIMUM_ETHERNET_FRAME_SIZE     64      /* with FCS */
-#define ETHERNET_FCS_SIZE               4
 #define MAX_JUMBO_FRAME_SIZE            0x2800
 
 #define PHY_AUTO_NEG_TIME       45      /* 4.5 Seconds */
@@ -929,8 +924,8 @@ enum atl1_dma_req_block {
         atl1_dma_req_128 = 0,
         atl1_dma_req_256 = 1,
         atl1_dma_req_512 = 2,
-        atl1_dam_req_1024 = 3,
-        atl1_dam_req_2048 = 4,
+        atl1_dma_req_1024 = 3,
+        atl1_dma_req_2048 = 4,
         atl1_dma_req_4096 = 5
 };
 
diff --git a/drivers/net/atl1/atl1_main.c b/drivers/net/atl1/atl1_main.c
index fd1e156f174..56f6389a300 100644
--- a/drivers/net/atl1/atl1_main.c
+++ b/drivers/net/atl1/atl1_main.c
@@ -59,6 +59,7 @@
 #include <linux/skbuff.h>
 #include <linux/etherdevice.h>
 #include <linux/if_vlan.h>
+#include <linux/if_ether.h>
 #include <linux/irqreturn.h>
 #include <linux/workqueue.h>
 #include <linux/timer.h>
@@ -120,8 +121,8 @@ static int __devinit atl1_sw_init(struct atl1_adapter *adapter)
         struct atl1_hw *hw = &adapter->hw;
         struct net_device *netdev = adapter->netdev;
 
-        hw->max_frame_size = netdev->mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
-        hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
+        hw->max_frame_size = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
+        hw->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
 
         adapter->wol = 0;
         adapter->rx_buffer_len = (hw->max_frame_size + 7) & ~7;
@@ -314,7 +315,7 @@ err_nomem:
         return -ENOMEM;
 }
 
-void atl1_init_ring_ptrs(struct atl1_adapter *adapter)
+static void atl1_init_ring_ptrs(struct atl1_adapter *adapter)
 {
         struct atl1_tpd_ring *tpd_ring = &adapter->tpd_ring;
         struct atl1_rfd_ring *rfd_ring = &adapter->rfd_ring;
@@ -688,9 +689,9 @@ static int atl1_change_mtu(struct net_device *netdev, int new_mtu)
 {
         struct atl1_adapter *adapter = netdev_priv(netdev);
         int old_mtu = netdev->mtu;
-        int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
+        int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
 
-        if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
+        if ((max_frame < ETH_ZLEN + ETH_FCS_LEN) ||
             (max_frame > MAX_JUMBO_FRAME_SIZE)) {
                 dev_warn(&adapter->pdev->dev, "invalid MTU setting\n");
                 return -EINVAL;
@@ -908,8 +909,8 @@ static u32 atl1_configure(struct atl1_adapter *adapter)
         /* config DMA Engine */
         value = ((((u32) hw->dmar_block) & DMA_CTRL_DMAR_BURST_LEN_MASK)
                 << DMA_CTRL_DMAR_BURST_LEN_SHIFT) |
-                ((((u32) hw->dmaw_block) & DMA_CTRL_DMAR_BURST_LEN_MASK)
-                << DMA_CTRL_DMAR_BURST_LEN_SHIFT) | DMA_CTRL_DMAR_EN |
+                ((((u32) hw->dmaw_block) & DMA_CTRL_DMAW_BURST_LEN_MASK)
+                << DMA_CTRL_DMAW_BURST_LEN_SHIFT) | DMA_CTRL_DMAR_EN |
                 DMA_CTRL_DMAW_EN;
         value |= (u32) hw->dma_ord;
         if (atl1_rcb_128 == hw->rcb_value)
@@ -917,7 +918,10 @@ static u32 atl1_configure(struct atl1_adapter *adapter)
         iowrite32(value, hw->hw_addr + REG_DMA_CTRL);
 
         /* config CMB / SMB */
-        value = hw->cmb_rrd | ((u32) hw->cmb_tpd << 16);
+        value = (hw->cmb_tpd > adapter->tpd_ring.count) ?
+                hw->cmb_tpd : adapter->tpd_ring.count;
+        value <<= 16;
+        value |= hw->cmb_rrd;
         iowrite32(value, hw->hw_addr + REG_CMB_WRITE_TH);
         value = hw->cmb_rx_timer | ((u32) hw->cmb_tx_timer << 16);
         iowrite32(value, hw->hw_addr + REG_CMB_WRITE_TIMER);
@@ -1334,7 +1338,7 @@ rrd_ok:
                 skb = buffer_info->skb;
                 length = le16_to_cpu(rrd->xsz.xsum_sz.pkt_size);
 
-                skb_put(skb, length - ETHERNET_FCS_SIZE);
+                skb_put(skb, length - ETH_FCS_LEN);
 
                 /* Receive Checksum Offload */
                 atl1_rx_checksum(adapter, rrd, skb);
@@ -1422,7 +1426,7 @@ static void atl1_intr_tx(struct atl1_adapter *adapter)
                 netif_wake_queue(adapter->netdev);
 }
 
-static u16 tpd_avail(struct atl1_tpd_ring *tpd_ring)
+static u16 atl1_tpd_avail(struct atl1_tpd_ring *tpd_ring)
 {
         u16 next_to_clean = atomic_read(&tpd_ring->next_to_clean);
         u16 next_to_use = atomic_read(&tpd_ring->next_to_use);
@@ -1453,7 +1457,7 @@ static int atl1_tso(struct atl1_adapter *adapter, struct sk_buff *skb,
                         tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
                                 iph->daddr, 0, IPPROTO_TCP, 0);
                         ipofst = skb_network_offset(skb);
-                        if (ipofst != ENET_HEADER_SIZE) /* 802.3 frame */
+                        if (ipofst != ETH_HLEN) /* 802.3 frame */
                                 tso->tsopl |= 1 << TSO_PARAM_ETHTYPE_SHIFT;
 
                         tso->tsopl |= (iph->ihl &
@@ -1708,7 +1712,7 @@ static int atl1_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 return NETDEV_TX_LOCKED;
         }
 
-        if (tpd_avail(&adapter->tpd_ring) < count) {
+        if (atl1_tpd_avail(&adapter->tpd_ring) < count) {
                 /* not enough descriptors */
                 netif_stop_queue(netdev);
                 spin_unlock_irqrestore(&adapter->lock, flags);
diff --git a/drivers/net/defxx.c b/drivers/net/defxx.c
index 7df23dc2819..9c8e3f9f5e5 100644
--- a/drivers/net/defxx.c
+++ b/drivers/net/defxx.c
@@ -200,6 +200,7 @@
 
 /* Include files */
 #include <linux/bitops.h>
+#include <linux/compiler.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
 #include <linux/eisa.h>
@@ -240,8 +241,6 @@ static char version[] __devinitdata =
  */
 #define NEW_SKB_SIZE (PI_RCV_DATA_K_SIZE_MAX+128)
 
-#define __unused __attribute__ ((unused))
-
 #ifdef CONFIG_PCI
 #define DFX_BUS_PCI(dev) (dev->bus == &pci_bus_type)
 #else
@@ -375,7 +374,7 @@ static inline void dfx_outl(DFX_board_t *bp, int offset, u32 data)
 
 static void dfx_port_write_long(DFX_board_t *bp, int offset, u32 data)
 {
-        struct device __unused *bdev = bp->bus_dev;
+        struct device __maybe_unused *bdev = bp->bus_dev;
         int dfx_bus_tc = DFX_BUS_TC(bdev);
         int dfx_use_mmio = DFX_MMIO || dfx_bus_tc;
 
@@ -399,7 +398,7 @@ static inline void dfx_inl(DFX_board_t *bp, int offset, u32 *data)
 
 static void dfx_port_read_long(DFX_board_t *bp, int offset, u32 *data)
 {
-        struct device __unused *bdev = bp->bus_dev;
+        struct device __maybe_unused *bdev = bp->bus_dev;
         int dfx_bus_tc = DFX_BUS_TC(bdev);
         int dfx_use_mmio = DFX_MMIO || dfx_bus_tc;
 
@@ -866,7 +865,7 @@ static void __devinit dfx_bus_uninit(struct net_device *dev)
 
 static void __devinit dfx_bus_config_check(DFX_board_t *bp)
 {
-        struct device __unused *bdev = bp->bus_dev;
+        struct device __maybe_unused *bdev = bp->bus_dev;
         int dfx_bus_eisa = DFX_BUS_EISA(bdev);
         int     status;                         /* return code from adapter port control call */
         u32     host_data;                      /* LW data returned from port control call */
@@ -3624,8 +3623,8 @@ static void __devexit dfx_unregister(struct device *bdev)
 }
 
 
-static int __devinit __unused dfx_dev_register(struct device *);
-static int __devexit __unused dfx_dev_unregister(struct device *);
+static int __devinit __maybe_unused dfx_dev_register(struct device *);
+static int __devexit __maybe_unused dfx_dev_unregister(struct device *);
 
 #ifdef CONFIG_PCI
 static int __devinit dfx_pci_register(struct pci_dev *,
@@ -3699,7 +3698,7 @@ static struct tc_driver dfx_tc_driver = {
 };
 #endif /* CONFIG_TC */
 
-static int __devinit __unused dfx_dev_register(struct device *dev)
+static int __devinit __maybe_unused dfx_dev_register(struct device *dev)
 {
         int status;
 
@@ -3709,7 +3708,7 @@ static int __devinit __unused dfx_dev_register(struct device *dev)
         return status;
 }
 
-static int __devexit __unused dfx_dev_unregister(struct device *dev)
+static int __devexit __maybe_unused dfx_dev_unregister(struct device *dev)
 {
         put_device(dev);
         dfx_unregister(dev);
diff --git a/drivers/net/ehea/ehea.h b/drivers/net/ehea/ehea.h
index 489c8b260dd..8ee2c2c86b4 100644
--- a/drivers/net/ehea/ehea.h
+++ b/drivers/net/ehea/ehea.h
@@ -39,7 +39,7 @@
 #include <asm/io.h>
 
 #define DRV_NAME        "ehea"
-#define DRV_VERSION     "EHEA_0071"
+#define DRV_VERSION     "EHEA_0072"
 
 /* eHEA capability flags */
 #define DLPAR_PORT_ADD_REM 1
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index 4c70a9301c1..58702f54c3f 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -589,6 +589,23 @@ static int ehea_poll(struct net_device *dev, int *budget)
         return 1;
 }
 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void ehea_netpoll(struct net_device *dev)
+{
+        struct ehea_port *port = netdev_priv(dev);
+
+        netif_rx_schedule(port->port_res[0].d_netdev);
+}
+#endif
+
+static int ehea_poll_firstqueue(struct net_device *dev, int *budget)
+{
+        struct ehea_port *port = netdev_priv(dev);
+        struct net_device *d_dev = port->port_res[0].d_netdev;
+
+        return ehea_poll(d_dev, budget);
+}
+
 static irqreturn_t ehea_recv_irq_handler(int irq, void *param)
 {
         struct ehea_port_res *pr = param;
@@ -2626,7 +2643,10 @@ struct ehea_port *ehea_setup_single_port(struct ehea_adapter *adapter,
         memcpy(dev->dev_addr, &port->mac_addr, ETH_ALEN);
 
         dev->open = ehea_open;
-        dev->poll = ehea_poll;
+        dev->poll = ehea_poll_firstqueue;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        dev->poll_controller = ehea_netpoll;
+#endif
         dev->weight = 64;
         dev->stop = ehea_stop;
         dev->hard_start_xmit = ehea_start_xmit;
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 6d1d50a1978..661c747389e 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -5546,6 +5546,22 @@ static struct pci_device_id pci_tbl[] = {
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_27),
                 .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
         },
+        {       /* MCP73 Ethernet Controller */
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_28),
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+        },
+        {       /* MCP73 Ethernet Controller */
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_29),
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+        },
+        {       /* MCP73 Ethernet Controller */
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_30),
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+        },
+        {       /* MCP73 Ethernet Controller */
+                PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_31),
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+        },
         {0,},
 };
 
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index 325269d8ae3..d4c92cc879d 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -1179,8 +1179,7 @@ dma_watchdog_shutdown_poll_result(struct netxen_adapter *adapter)
             NETXEN_CAM_RAM(NETXEN_CAM_RAM_DMA_WATCHDOG_CTRL), &ctrl, 4))
                 printk(KERN_ERR "failed to read dma watchdog status\n");
 
-        return ((netxen_get_dma_watchdog_enabled(ctrl) == 0) &&
-                (netxen_get_dma_watchdog_disabled(ctrl) == 0));
+        return (netxen_get_dma_watchdog_enabled(ctrl) == 0);
 }
 
 static inline int
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index b703ccfe040..19e2fa940ac 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -46,7 +46,7 @@ MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
 
-char netxen_nic_driver_name[] = "netxen-nic";
+char netxen_nic_driver_name[] = "netxen_nic";
 static char netxen_nic_driver_string[] = "NetXen Network Driver version "
     NETXEN_NIC_LINUX_VERSIONID;
 
@@ -640,6 +640,10 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         NETXEN_CRB_NORMALIZE(adapter,
                                 NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
                 /* Handshake with the card before we register the devices. */
+                writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
+                netxen_pinit_from_rom(adapter, 0);
+                msleep(1);
+                netxen_load_firmware(adapter);
                 netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
         }
 
@@ -782,19 +786,18 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
 
         if (adapter->portnum == 0) {
                 if (init_firmware_done) {
-                        dma_watchdog_shutdown_request(adapter);
-                        msleep(100);
                         i = 100;
-                        while ((dma_watchdog_shutdown_poll_result(adapter) != 1) && i) {
-                                printk(KERN_INFO "dma_watchdog_shutdown_poll still in progress\n");
+                        do {
+                                if (dma_watchdog_shutdown_request(adapter) == 1)
+                                        break;
                                 msleep(100);
-                                i--;
-                        }
+                                if (dma_watchdog_shutdown_poll_result(adapter) == 1)
+                                        break;
+                        } while (--i);
 
-                        if (i == 0) {
-                                printk(KERN_ERR "dma_watchdog_shutdown_request failed\n");
-                                return;
-                        }
+                        if (i == 0)
+                                printk(KERN_ERR "%s: dma_watchdog_shutdown failed\n",
+                                                netdev->name);
 
                         /* clear the register for future unloads/loads */
                         writel(0, NETXEN_CRB_NORMALIZE(adapter, NETXEN_CAM_RAM(0x1fc)));
@@ -803,11 +806,9 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
 
                         /* leave the hw in the same state as reboot */
                         writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
-                        if (netxen_pinit_from_rom(adapter, 0))
-                                return;
+                        netxen_pinit_from_rom(adapter, 0);
                         msleep(1);
-                        if (netxen_load_firmware(adapter))
-                                return;
+                        netxen_load_firmware(adapter);
                         netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
                 }
 
@@ -816,22 +817,21 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
                 printk(KERN_INFO "State: 0x%0x\n",
                         readl(NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE)));
 
-                dma_watchdog_shutdown_request(adapter);
-                msleep(100);
                 i = 100;
-                while ((dma_watchdog_shutdown_poll_result(adapter) != 1) && i) {
-                        printk(KERN_INFO "dma_watchdog_shutdown_poll still in progress\n");
+                do {
+                        if (dma_watchdog_shutdown_request(adapter) == 1)
+                                break;
                         msleep(100);
-                        i--;
-                }
+                        if (dma_watchdog_shutdown_poll_result(adapter) == 1)
+                                break;
+                } while (--i);
 
                 if (i) {
                         netxen_free_adapter_offload(adapter);
                 } else {
-                        printk(KERN_ERR "failed to dma shutdown\n");
-                        return;
+                        printk(KERN_ERR "%s: dma_watchdog_shutdown failed\n",
+                                        netdev->name);
                 }
-
         }
 
         iounmap(adapter->ahw.db_base);
diff --git a/drivers/net/phy/vitesse.c b/drivers/net/phy/vitesse.c
index 6a538564791..8874497b6bb 100644
--- a/drivers/net/phy/vitesse.c
+++ b/drivers/net/phy/vitesse.c
@@ -109,7 +109,7 @@ static int vsc824x_config_intr(struct phy_device *phydev)
                  */
                 err = phy_read(phydev, MII_VSC8244_ISTAT);
 
-                if (err)
+                if (err < 0)
                         return err;
 
                 err = phy_write(phydev, MII_VSC8244_IMASK, 0);
diff --git a/drivers/net/ps3_gelic_net.c b/drivers/net/ps3_gelic_net.c
index 08d25066f05..13d1c0a2a25 100644
--- a/drivers/net/ps3_gelic_net.c
+++ b/drivers/net/ps3_gelic_net.c
@@ -290,7 +290,8 @@ static void gelic_net_release_rx_chain(struct gelic_net_card *card)
                         descr->buf_addr = 0;
                         dev_kfree_skb_any(descr->skb);
                         descr->skb = NULL;
-                        descr->dmac_cmd_status = GELIC_NET_DESCR_NOT_IN_USE;
+                        gelic_net_set_descr_status(descr,
+                                                   GELIC_NET_DESCR_NOT_IN_USE);
                 }
                 descr = descr->next;
         } while (descr != card->rx_chain.head);
@@ -374,7 +375,7 @@ static void gelic_net_release_tx_descr(struct gelic_net_card *card,
         descr->skb = NULL;
 
         /* set descr status */
-        descr->dmac_cmd_status = GELIC_NET_DMAC_CMDSTAT_NOT_IN_USE;
+        gelic_net_set_descr_status(descr, GELIC_NET_DESCR_NOT_IN_USE);
 }
 
 /**
@@ -403,26 +404,29 @@ static void gelic_net_release_tx_chain(struct gelic_net_card *card, int stop)
                                          "%s: forcing end of tx descriptor " \
                                          "with status %x\n",
                                          __func__, status);
-                        card->netdev_stats.tx_dropped++;
+                        card->netdev->stats.tx_dropped++;
                         break;
 
                 case GELIC_NET_DESCR_COMPLETE:
-                        card->netdev_stats.tx_packets++;
-                        card->netdev_stats.tx_bytes +=
-                                tx_chain->tail->skb->len;
+                        if (tx_chain->tail->skb) {
+                                card->netdev->stats.tx_packets++;
+                                card->netdev->stats.tx_bytes +=
+                                        tx_chain->tail->skb->len;
+                        }
                         break;
 
                 case GELIC_NET_DESCR_CARDOWNED:
                         /* pending tx request */
                 default:
                         /* any other value (== GELIC_NET_DESCR_NOT_IN_USE) */
-                        goto out;
+                        if (!stop)
+                                goto out;
                 }
                 gelic_net_release_tx_descr(card, tx_chain->tail);
-                release = 1;
+                release ++;
         }
 out:
-        if (!stop && release)
+        if (!stop && (2 < release))
                 netif_wake_queue(card->netdev);
 }
 
@@ -659,19 +663,21 @@ static int gelic_net_prepare_tx_descr_v(struct gelic_net_card *card,
 {
         dma_addr_t buf[2];
         unsigned int vlan_len;
+        struct gelic_net_descr *sec_descr = descr->next;
 
         if (skb->len < GELIC_NET_VLAN_POS)
                 return -EINVAL;
 
-        memcpy(&descr->vlan, skb->data, GELIC_NET_VLAN_POS);
+        vlan_len = GELIC_NET_VLAN_POS;
+        memcpy(&descr->vlan, skb->data, vlan_len);
         if (card->vlan_index != -1) {
+                /* internal vlan tag used */
                 descr->vlan.h_vlan_proto = htons(ETH_P_8021Q); /* vlan 0x8100*/
                 descr->vlan.h_vlan_TCI = htons(card->vlan_id[card->vlan_index]);
-                vlan_len = GELIC_NET_VLAN_POS + VLAN_HLEN; /* VLAN_HLEN=4 */
-        } else
-                vlan_len = GELIC_NET_VLAN_POS; /* no vlan tag */
+                vlan_len += VLAN_HLEN; /* added for above two lines */
+        }
 
-        /* first descr */
+        /* map data area */
         buf[0] = dma_map_single(ctodev(card), &descr->vlan,
                              vlan_len, DMA_TO_DEVICE);
 
@@ -682,20 +688,6 @@ static int gelic_net_prepare_tx_descr_v(struct gelic_net_card *card,
                 return -ENOMEM;
         }
 
-        descr->buf_addr = buf[0];
-        descr->buf_size = vlan_len;
-        descr->skb = skb; /* not used */
-        descr->data_status = 0;
-        gelic_net_set_txdescr_cmdstat(descr, skb, 1); /* not the frame end */
-
-        /* second descr */
-        card->tx_chain.head = card->tx_chain.head->next;
-        descr->next_descr_addr = descr->next->bus_addr;
-        descr = descr->next;
-        if (gelic_net_get_descr_status(descr) != GELIC_NET_DESCR_NOT_IN_USE)
-                /* XXX will be removed */
-                dev_err(ctodev(card), "descr is not free!\n");
-
         buf[1] = dma_map_single(ctodev(card), skb->data + GELIC_NET_VLAN_POS,
                              skb->len - GELIC_NET_VLAN_POS,
                              DMA_TO_DEVICE);
@@ -710,13 +702,24 @@ static int gelic_net_prepare_tx_descr_v(struct gelic_net_card *card,
                 return -ENOMEM;
         }
 
-        descr->buf_addr = buf[1];
-        descr->buf_size = skb->len - GELIC_NET_VLAN_POS;
-        descr->skb = skb;
+        /* first descr */
+        descr->buf_addr = buf[0];
+        descr->buf_size = vlan_len;
+        descr->skb = NULL; /* not used */
         descr->data_status = 0;
-        descr->next_descr_addr = 0; /* terminate hw descr */
-        gelic_net_set_txdescr_cmdstat(descr, skb, 0);
+        descr->next_descr_addr = descr->next->bus_addr;
+        gelic_net_set_txdescr_cmdstat(descr, skb, 1); /* not the frame end */
 
+        /* second descr */
+        sec_descr->buf_addr = buf[1];
+        sec_descr->buf_size = skb->len - GELIC_NET_VLAN_POS;
+        sec_descr->skb = skb;
+        sec_descr->data_status = 0;
+        sec_descr->next_descr_addr = 0; /* terminate hw descr */
+        gelic_net_set_txdescr_cmdstat(sec_descr, skb, 0);
+
+        /* bump free descriptor pointer */
+        card->tx_chain.head = sec_descr->next;
         return 0;
 }
 
@@ -729,7 +732,7 @@ static int gelic_net_prepare_tx_descr_v(struct gelic_net_card *card,
 static int gelic_net_kick_txdma(struct gelic_net_card *card,
                                 struct gelic_net_descr *descr)
 {
-        int status = -ENXIO;
+        int status = 0;
         int count = 10;
 
         if (card->tx_dma_progress)
@@ -763,47 +766,62 @@ static int gelic_net_kick_txdma(struct gelic_net_card *card,
 static int gelic_net_xmit(struct sk_buff *skb, struct net_device *netdev)
 {
         struct gelic_net_card *card = netdev_priv(netdev);
-        struct gelic_net_descr *descr = NULL;
+        struct gelic_net_descr *descr;
         int result;
         unsigned long flags;
 
         spin_lock_irqsave(&card->tx_dma_lock, flags);
 
         gelic_net_release_tx_chain(card, 0);
-        if (!skb)
-                goto kick;
+
         descr = gelic_net_get_next_tx_descr(card);
         if (!descr) {
+                /*
+                 * no more descriptors free
+                 */
                 netif_stop_queue(netdev);
                 spin_unlock_irqrestore(&card->tx_dma_lock, flags);
                 return NETDEV_TX_BUSY;
         }
-        result = gelic_net_prepare_tx_descr_v(card, descr, skb);
-
-        if (result)
-                goto error;
 
-        card->tx_chain.head = card->tx_chain.head->next;
-
-        if (descr->prev)
-                descr->prev->next_descr_addr = descr->bus_addr;
-kick:
+        result = gelic_net_prepare_tx_descr_v(card, descr, skb);
+        if (result) {
+                /*
+                 * DMA map failed.  As chanses are that failure
+                 * would continue, just release skb and return
+                 */
+                card->netdev->stats.tx_dropped++;
+                dev_kfree_skb_any(skb);
+                spin_unlock_irqrestore(&card->tx_dma_lock, flags);
+                return NETDEV_TX_OK;
+        }
+        /*
+         * link this prepared descriptor to previous one
+         * to achieve high performance
+         */
+        descr->prev->next_descr_addr = descr->bus_addr;
         /*
          * as hardware descriptor is modified in the above lines,
          * ensure that the hardware sees it
          */
         wmb();
-        if (gelic_net_kick_txdma(card, card->tx_chain.tail))
-                goto error;
+        if (gelic_net_kick_txdma(card, descr)) {
+                /*
+                 * kick failed.
+                 * release descriptors which were just prepared
+                 */
+                card->netdev->stats.tx_dropped++;
+                gelic_net_release_tx_descr(card, descr);
+                gelic_net_release_tx_descr(card, descr->next);
+                card->tx_chain.tail = descr->next->next;
+                dev_info(ctodev(card), "%s: kick failure\n", __func__);
+        } else {
+                /* OK, DMA started/reserved */
+                netdev->trans_start = jiffies;
+        }
 
-        netdev->trans_start = jiffies;
         spin_unlock_irqrestore(&card->tx_dma_lock, flags);
         return NETDEV_TX_OK;
-
-error:
-        card->netdev_stats.tx_dropped++;
-        spin_unlock_irqrestore(&card->tx_dma_lock, flags);
-        return NETDEV_TX_LOCKED;
 }
 
 /**
@@ -854,8 +872,8 @@ static void gelic_net_pass_skb_up(struct gelic_net_descr *descr,
                 skb->ip_summed = CHECKSUM_NONE;
 
         /* update netdevice statistics */
-        card->netdev_stats.rx_packets++;
-        card->netdev_stats.rx_bytes += skb->len;
+        card->netdev->stats.rx_packets++;
+        card->netdev->stats.rx_bytes += skb->len;
 
         /* pass skb up to stack */
         netif_receive_skb(skb);
@@ -895,38 +913,67 @@ static int gelic_net_decode_one_descr(struct gelic_net_card *card)
             (status == GELIC_NET_DESCR_FORCE_END)) {
                 dev_info(ctodev(card), "dropping RX descriptor with state %x\n",
                          status);
-                card->netdev_stats.rx_dropped++;
+                card->netdev->stats.rx_dropped++;
                 goto refill;
         }
 
-        if ((status != GELIC_NET_DESCR_COMPLETE) &&
-            (status != GELIC_NET_DESCR_FRAME_END)) {
+        if (status == GELIC_NET_DESCR_BUFFER_FULL) {
+                /*
+                 * Buffer full would occur if and only if
+                 * the frame length was longer than the size of this
+                 * descriptor's buffer.  If the frame length was equal
+                 * to or shorter than buffer'size, FRAME_END condition
+                 * would occur.
+                 * Anyway this frame was longer than the MTU,
+                 * just drop it.
+                 */
+                dev_info(ctodev(card), "overlength frame\n");
+                goto refill;
+        }
+        /*
+         * descriptoers any other than FRAME_END here should
+         * be treated as error.
+         */
+        if (status != GELIC_NET_DESCR_FRAME_END) {
                 dev_dbg(ctodev(card), "RX descriptor with state %x\n",
                         status);
                 goto refill;
         }
 
         /* ok, we've got a packet in descr */
-        gelic_net_pass_skb_up(descr, card); /* 1: skb_up sccess */
-
+        gelic_net_pass_skb_up(descr, card);
 refill:
-        descr->next_descr_addr = 0; /* unlink the descr */
+        /*
+         * So that always DMAC can see the end
+         * of the descriptor chain to avoid
+         * from unwanted DMAC overrun.
+         */
+        descr->next_descr_addr = 0;
 
         /* change the descriptor state: */
         gelic_net_set_descr_status(descr, GELIC_NET_DESCR_NOT_IN_USE);
 
-        /* refill one desc
-         * FIXME: this can fail, but for now, just leave this
-         * descriptor without skb
+        /*
+         * this call can fail, but for now, just leave this
+         * decriptor without skb
          */
         gelic_net_prepare_rx_descr(card, descr);
+
         chain->head = descr;
         chain->tail = descr->next;
+
+        /*
+         * Set this descriptor the end of the chain.
+         */
         descr->prev->next_descr_addr = descr->bus_addr;
 
+        /*
+         * If dmac chain was met, DMAC stopped.
+         * thus re-enable it
+         */
         if (dmac_chain_ended) {
-                gelic_net_enable_rxdmac(card);
-                dev_dbg(ctodev(card), "reenable rx dma\n");
+                card->rx_dma_restart_required = 1;
+                dev_dbg(ctodev(card), "reenable rx dma scheduled\n");
         }
 
         return 1;
@@ -968,20 +1015,6 @@ static int gelic_net_poll(struct net_device *netdev, int *budget)
         } else
                 return 1;
 }
-
-/**
- * gelic_net_get_stats - get interface statistics
- * @netdev: interface device structure
- *
- * returns the interface statistics residing in the gelic_net_card struct
- */
-static struct net_device_stats *gelic_net_get_stats(struct net_device *netdev)
-{
-        struct gelic_net_card *card = netdev_priv(netdev);
-
-        return &card->netdev_stats;
-}
-
 /**
  * gelic_net_change_mtu - changes the MTU of an interface
  * @netdev: interface device structure
@@ -1016,6 +1049,11 @@ static irqreturn_t gelic_net_interrupt(int irq, void *ptr)
         if (!status)
                 return IRQ_NONE;
 
+        if (card->rx_dma_restart_required) {
+                card->rx_dma_restart_required = 0;
+                gelic_net_enable_rxdmac(card);
+        }
+
         if (status & GELIC_NET_RXINT) {
                 gelic_net_rx_irq_off(card);
                 netif_rx_schedule(netdev);
@@ -1024,9 +1062,10 @@ static irqreturn_t gelic_net_interrupt(int irq, void *ptr)
         if (status & GELIC_NET_TXINT) {
                 spin_lock_irqsave(&card->tx_dma_lock, flags);
                 card->tx_dma_progress = 0;
+                gelic_net_release_tx_chain(card, 0);
+                /* kick outstanding tx descriptor if any */
+                gelic_net_kick_txdma(card, card->tx_chain.tail);
                 spin_unlock_irqrestore(&card->tx_dma_lock, flags);
-                /* start pending DMA */
-                gelic_net_xmit(NULL, netdev);
         }
         return IRQ_HANDLED;
 }
@@ -1068,7 +1107,7 @@ static int gelic_net_open_device(struct gelic_net_card *card)
         }
 
         result = request_irq(card->netdev->irq, gelic_net_interrupt,
-                             IRQF_DISABLED, "gelic network", card->netdev);
+                             IRQF_DISABLED, card->netdev->name, card->netdev);
 
         if (result) {
                 dev_info(ctodev(card), "%s:%d: request_irq failed (%d)\n",
@@ -1107,7 +1146,7 @@ static int gelic_net_open(struct net_device *netdev)
                         card->descr, GELIC_NET_TX_DESCRIPTORS))
                 goto alloc_tx_failed;
         if (gelic_net_init_chain(card, &card->rx_chain,
-                                 card->descr + GELIC_NET_RX_DESCRIPTORS,
+                                 card->descr + GELIC_NET_TX_DESCRIPTORS,
                                  GELIC_NET_RX_DESCRIPTORS))
                 goto alloc_rx_failed;
 
@@ -1129,7 +1168,6 @@ static int gelic_net_open(struct net_device *netdev)
 
         netif_start_queue(netdev);
         netif_carrier_on(netdev);
-        netif_poll_enable(netdev);
 
         return 0;
 
@@ -1141,7 +1179,6 @@ alloc_tx_failed:
         return -ENOMEM;
 }
 
-#ifdef GELIC_NET_ETHTOOL
 static void gelic_net_get_drvinfo (struct net_device *netdev,
                                    struct ethtool_drvinfo *info)
 {
@@ -1261,7 +1298,6 @@ static struct ethtool_ops gelic_net_ethtool_ops = {
         .get_rx_csum    = gelic_net_get_rx_csum,
         .set_rx_csum    = gelic_net_set_rx_csum,
 };
-#endif
 
 /**
  * gelic_net_tx_timeout_task - task scheduled by the watchdog timeout
@@ -1320,7 +1356,6 @@ static void gelic_net_setup_netdev_ops(struct net_device *netdev)
         netdev->open = &gelic_net_open;
         netdev->stop = &gelic_net_stop;
         netdev->hard_start_xmit = &gelic_net_xmit;
-        netdev->get_stats = &gelic_net_get_stats;
         netdev->set_multicast_list = &gelic_net_set_multi;
         netdev->change_mtu = &gelic_net_change_mtu;
         /* tx watchdog */
@@ -1329,9 +1364,7 @@ static void gelic_net_setup_netdev_ops(struct net_device *netdev)
         /* NAPI */
         netdev->poll = &gelic_net_poll;
         netdev->weight = GELIC_NET_NAPI_WEIGHT;
-#ifdef GELIC_NET_ETHTOOL
         netdev->ethtool_ops = &gelic_net_ethtool_ops;
-#endif
 }
 
 /**
diff --git a/drivers/net/ps3_gelic_net.h b/drivers/net/ps3_gelic_net.h
index 5e1c28654e1..a9c4c4fc254 100644
--- a/drivers/net/ps3_gelic_net.h
+++ b/drivers/net/ps3_gelic_net.h
@@ -28,21 +28,12 @@
 #ifndef _GELIC_NET_H
 #define _GELIC_NET_H
 
-#define GELIC_NET_DRV_NAME "Gelic Network Driver"
-#define GELIC_NET_DRV_VERSION "1.0"
-
-#define GELIC_NET_ETHTOOL               /* use ethtool */
-
-/* ioctl */
-#define GELIC_NET_GET_MODE              (SIOCDEVPRIVATE + 0)
-#define GELIC_NET_SET_MODE              (SIOCDEVPRIVATE + 1)
-
 /* descriptors */
 #define GELIC_NET_RX_DESCRIPTORS        128 /* num of descriptors */
 #define GELIC_NET_TX_DESCRIPTORS        128 /* num of descriptors */
 
-#define GELIC_NET_MAX_MTU               2308
-#define GELIC_NET_MIN_MTU               64
+#define GELIC_NET_MAX_MTU               VLAN_ETH_FRAME_LEN
+#define GELIC_NET_MIN_MTU               VLAN_ETH_ZLEN
 #define GELIC_NET_RXBUF_ALIGN           128
 #define GELIC_NET_RX_CSUM_DEFAULT       1 /* hw chksum */
 #define GELIC_NET_WATCHDOG_TIMEOUT      5*HZ
@@ -90,7 +81,8 @@ enum gelic_net_int1_status {
                                             */
 #define GELIC_NET_RXVLNPKT      0x00200000 /* VLAN packet */
 /* bit 20..16 reserved */
-#define GELIC_NET_RXRECNUM      0x0000ff00 /* reception receipt number */
+#define GELIC_NET_RXRRECNUM     0x0000ff00 /* reception receipt number */
+#define GELIC_NET_RXRRECNUM_SHIFT       8
 /* bit 7..0 reserved */
 
 #define GELIC_NET_TXDESC_TAIL           0
@@ -133,19 +125,19 @@ enum gelic_net_int1_status {
                                                       * interrupt status */
 
 #define GELIC_NET_DMAC_CMDSTAT_CHAIN_END  0x00000002 /* RXDCEIS:DMA stopped */
-#define GELIC_NET_DMAC_CMDSTAT_NOT_IN_USE 0xb0000000
 #define GELIC_NET_DESCR_IND_PROC_SHIFT    28
 #define GELIC_NET_DESCR_IND_PROC_MASKO    0x0fffffff
 
 
 enum gelic_net_descr_status {
-        GELIC_NET_DESCR_COMPLETE            = 0x00, /* used in rx and tx */
+        GELIC_NET_DESCR_COMPLETE            = 0x00, /* used in tx */
+        GELIC_NET_DESCR_BUFFER_FULL         = 0x00, /* used in rx */
         GELIC_NET_DESCR_RESPONSE_ERROR      = 0x01, /* used in rx and tx */
         GELIC_NET_DESCR_PROTECTION_ERROR    = 0x02, /* used in rx and tx */
         GELIC_NET_DESCR_FRAME_END           = 0x04, /* used in rx */
         GELIC_NET_DESCR_FORCE_END           = 0x05, /* used in rx and tx */
         GELIC_NET_DESCR_CARDOWNED           = 0x0a, /* used in rx and tx */
-        GELIC_NET_DESCR_NOT_IN_USE                  /* any other value */
+        GELIC_NET_DESCR_NOT_IN_USE          = 0x0b  /* any other value */
 };
 /* for lv1_net_control */
 #define GELIC_NET_GET_MAC_ADDRESS               0x0000000000000001
@@ -216,10 +208,10 @@ struct gelic_net_card {
 
         struct gelic_net_descr_chain tx_chain;
         struct gelic_net_descr_chain rx_chain;
+        int rx_dma_restart_required;
         /* gurad dmac descriptor chain*/
         spinlock_t chain_lock;
 
-        struct net_device_stats netdev_stats;
         int rx_csum;
         /* guard tx_dma_progress */
         spinlock_t tx_dma_lock;
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index e4736a3b1b7..12e01b24105 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -43,10 +43,6 @@
 
 #undef DEBUG
 
-#define DRV_DESC "QE UCC Gigabit Ethernet Controller"
-#define DRV_NAME "ucc_geth"
-#define DRV_VERSION "1.1"
-
 #define ugeth_printk(level, format, arg...)  \
         printk(level format "\n", ## arg)
 
@@ -64,9 +60,19 @@
 #else
 #define ugeth_vdbg(fmt, args...) do { } while (0)
 #endif                          /* UGETH_VERBOSE_DEBUG */
+#define UGETH_MSG_DEFAULT       (NETIF_MSG_IFUP << 1 ) - 1
 
+void uec_set_ethtool_ops(struct net_device *netdev);
+        
 static DEFINE_SPINLOCK(ugeth_lock);
 
+static struct {
+        u32 msg_enable;
+} debug = { -1 };
+
+module_param_named(debug, debug.msg_enable, int, 0);
+MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 0xffff=all)");
+
 static struct ucc_geth_info ugeth_primary_info = {
         .uf_info = {
                     .bd_mem_part = MEM_PART_SYSTEM,
@@ -104,6 +110,7 @@ static struct ucc_geth_info ugeth_primary_info = {
         .maxRetransmission = 0xf,
         .collisionWindow = 0x37,
         .receiveFlowControl = 1,
+        .transmitFlowControl = 1,
         .maxGroupAddrInHash = 4,
         .maxIndAddrInHash = 4,
         .prel = 7,
@@ -139,7 +146,9 @@ static struct ucc_geth_info ugeth_primary_info = {
         .numStationAddresses = UCC_GETH_NUM_OF_STATION_ADDRESSES_1,
         .largestexternallookupkeysize =
             QE_FLTR_LARGEST_EXTERNAL_TABLE_LOOKUP_KEY_SIZE_NONE,
-        .statisticsMode = UCC_GETH_STATISTICS_GATHERING_MODE_NONE,
+        .statisticsMode = UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE |
+                UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX |
+                UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX,
         .vlanOperationTagged = UCC_GETH_VLAN_OPERATION_TAGGED_NOP,
         .vlanOperationNonTagged = UCC_GETH_VLAN_OPERATION_NON_TAGGED_NOP,
         .rxQoSMode = UCC_GETH_QOS_MODE_DEFAULT,
@@ -281,7 +290,8 @@ static int fill_init_enet_entries(struct ucc_geth_private *ugeth,
 
         for (i = 0; i < num_entries; i++) {
                 if ((snum = qe_get_snum()) < 0) {
-                        ugeth_err("fill_init_enet_entries: Can not get SNUM.");
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err("fill_init_enet_entries: Can not get SNUM.");
                         return snum;
                 }
                 if ((i == 0) && skip_page_for_first_entry)
@@ -291,8 +301,8 @@ static int fill_init_enet_entries(struct ucc_geth_private *ugeth,
                         init_enet_offset =
                             qe_muram_alloc(thread_size, thread_alignment);
                         if (IS_ERR_VALUE(init_enet_offset)) {
-                                ugeth_err
-                ("fill_init_enet_entries: Can not allocate DPRAM memory.");
+                                if (netif_msg_ifup(ugeth))
+                                        ugeth_err("fill_init_enet_entries: Can not allocate DPRAM memory.");
                                 qe_put_snum((u8) snum);
                                 return -ENOMEM;
                         }
@@ -1200,7 +1210,7 @@ static int init_inter_frame_gap_params(u8 non_btb_cs_ipg,
         return 0;
 }
 
-static int init_flow_control_params(u32 automatic_flow_control_mode,
+int init_flow_control_params(u32 automatic_flow_control_mode,
                                     int rx_flow_control_enable,
                                     int tx_flow_control_enable,
                                     u16 pause_period,
@@ -1486,9 +1496,9 @@ static int adjust_enet_interface(struct ucc_geth_private *ugeth)
 
         ret_val = init_preamble_length(ug_info->prel, &ug_regs->maccfg2);
         if (ret_val != 0) {
-                ugeth_err
-                    ("%s: Preamble length must be between 3 and 7 inclusive.",
-                     __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: Preamble length must be between 3 and 7 inclusive.",
+                             __FUNCTION__);
                 return ret_val;
         }
 
@@ -1726,7 +1736,8 @@ static int ugeth_enable(struct ucc_geth_private *ugeth, enum comm_dir mode)
 
         /* check if the UCC number is in range. */
         if (ugeth->ug_info->uf_info.ucc_num >= UCC_MAX_NUM) {
-                ugeth_err("%s: ucc_num out of range.", __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: ucc_num out of range.", __FUNCTION__);
                 return -EINVAL;
         }
 
@@ -1754,7 +1765,8 @@ static int ugeth_disable(struct ucc_geth_private * ugeth, enum comm_dir mode)
 
         /* check if the UCC number is in range. */
         if (ugeth->ug_info->uf_info.ucc_num >= UCC_MAX_NUM) {
-                ugeth_err("%s: ucc_num out of range.", __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: ucc_num out of range.", __FUNCTION__);
                 return -EINVAL;
         }
 
@@ -2306,7 +2318,9 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
 
         if (!((uf_info->bd_mem_part == MEM_PART_SYSTEM) ||
               (uf_info->bd_mem_part == MEM_PART_MURAM))) {
-                ugeth_err("%s: Bad memory partition value.", __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: Bad memory partition value.",
+                                        __FUNCTION__);
                 return -EINVAL;
         }
 
@@ -2315,9 +2329,10 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
                 if ((ug_info->bdRingLenRx[i] < UCC_GETH_RX_BD_RING_SIZE_MIN) ||
                     (ug_info->bdRingLenRx[i] %
                      UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT)) {
-                        ugeth_err
-                            ("%s: Rx BD ring length must be multiple of 4,"
-                                " no smaller than 8.", __FUNCTION__);
+                        if (netif_msg_probe(ugeth))
+                                ugeth_err
+                                    ("%s: Rx BD ring length must be multiple of 4, no smaller than 8.",
+                                        __FUNCTION__);
                         return -EINVAL;
                 }
         }
@@ -2325,9 +2340,10 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
         /* Tx BD lengths */
         for (i = 0; i < ug_info->numQueuesTx; i++) {
                 if (ug_info->bdRingLenTx[i] < UCC_GETH_TX_BD_RING_SIZE_MIN) {
-                        ugeth_err
-                            ("%s: Tx BD ring length must be no smaller than 2.",
-                             __FUNCTION__);
+                        if (netif_msg_probe(ugeth))
+                                ugeth_err
+                                    ("%s: Tx BD ring length must be no smaller than 2.",
+                                     __FUNCTION__);
                         return -EINVAL;
                 }
         }
@@ -2335,31 +2351,35 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
         /* mrblr */
         if ((uf_info->max_rx_buf_length == 0) ||
             (uf_info->max_rx_buf_length % UCC_GETH_MRBLR_ALIGNMENT)) {
-                ugeth_err
-                    ("%s: max_rx_buf_length must be non-zero multiple of 128.",
-                     __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err
+                            ("%s: max_rx_buf_length must be non-zero multiple of 128.",
+                             __FUNCTION__);
                 return -EINVAL;
         }
 
         /* num Tx queues */
         if (ug_info->numQueuesTx > NUM_TX_QUEUES) {
-                ugeth_err("%s: number of tx queues too large.", __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: number of tx queues too large.", __FUNCTION__);
                 return -EINVAL;
         }
 
         /* num Rx queues */
         if (ug_info->numQueuesRx > NUM_RX_QUEUES) {
-                ugeth_err("%s: number of rx queues too large.", __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: number of rx queues too large.", __FUNCTION__);
                 return -EINVAL;
         }
 
         /* l2qt */
         for (i = 0; i < UCC_GETH_VLAN_PRIORITY_MAX; i++) {
                 if (ug_info->l2qt[i] >= ug_info->numQueuesRx) {
-                        ugeth_err
-                            ("%s: VLAN priority table entry must not be"
-                                " larger than number of Rx queues.",
-                             __FUNCTION__);
+                        if (netif_msg_probe(ugeth))
+                                ugeth_err
+                                    ("%s: VLAN priority table entry must not be"
+                                        " larger than number of Rx queues.",
+                                     __FUNCTION__);
                         return -EINVAL;
                 }
         }
@@ -2367,26 +2387,29 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
         /* l3qt */
         for (i = 0; i < UCC_GETH_IP_PRIORITY_MAX; i++) {
                 if (ug_info->l3qt[i] >= ug_info->numQueuesRx) {
-                        ugeth_err
-                            ("%s: IP priority table entry must not be"
-                                " larger than number of Rx queues.",
-                             __FUNCTION__);
+                        if (netif_msg_probe(ugeth))
+                                ugeth_err
+                                    ("%s: IP priority table entry must not be"
+                                        " larger than number of Rx queues.",
+                                     __FUNCTION__);
                         return -EINVAL;
                 }
         }
 
         if (ug_info->cam && !ug_info->ecamptr) {
-                ugeth_err("%s: If cam mode is chosen, must supply cam ptr.",
-                          __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: If cam mode is chosen, must supply cam ptr.",
+                                  __FUNCTION__);
                 return -EINVAL;
         }
 
         if ((ug_info->numStationAddresses !=
              UCC_GETH_NUM_OF_STATION_ADDRESSES_1)
             && ug_info->rxExtendedFiltering) {
-                ugeth_err("%s: Number of station addresses greater than 1 "
-                          "not allowed in extended parsing mode.",
-                          __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: Number of station addresses greater than 1 "
+                                  "not allowed in extended parsing mode.",
+                                  __FUNCTION__);
                 return -EINVAL;
         }
 
@@ -2399,7 +2422,8 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
                 uf_info->uccm_mask |= (UCCE_TXBF_SINGLE_MASK << i);
         /* Initialize the general fast UCC block. */
         if (ucc_fast_init(uf_info, &ugeth->uccf)) {
-                ugeth_err("%s: Failed to init uccf.", __FUNCTION__);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: Failed to init uccf.", __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -2452,7 +2476,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 numThreadsRxNumerical = 8;
                 break;
         default:
-                ugeth_err("%s: Bad number of Rx threads value.", __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Bad number of Rx threads value.",
+                                        __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -EINVAL;
                 break;
@@ -2475,7 +2501,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 numThreadsTxNumerical = 8;
                 break;
         default:
-                ugeth_err("%s: Bad number of Tx threads value.", __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Bad number of Tx threads value.",
+                                        __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -EINVAL;
                 break;
@@ -2507,7 +2535,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         /* For more details see the hardware spec.           */
         init_flow_control_params(ug_info->aufc,
                                  ug_info->receiveFlowControl,
-                                 1,
+                                 ug_info->transmitFlowControl,
                                  ug_info->pausePeriod,
                                  ug_info->extensionField,
                                  &uf_regs->upsmr,
@@ -2527,8 +2555,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                               ug_info->backToBackInterFrameGap,
                                               &ug_regs->ipgifg);
         if (ret_val != 0) {
-                ugeth_err("%s: IPGIFG initialization parameter too large.",
-                          __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: IPGIFG initialization parameter too large.",
+                                  __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return ret_val;
         }
@@ -2544,7 +2573,8 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                           ug_info->collisionWindow,
                                           &ug_regs->hafdup);
         if (ret_val != 0) {
-                ugeth_err("%s: Half Duplex initialization parameter too large.",
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Half Duplex initialization parameter too large.",
                           __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return ret_val;
@@ -2597,9 +2627,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                                          tx_bd_ring_offset[j]);
                 }
                 if (!ugeth->p_tx_bd_ring[j]) {
-                        ugeth_err
-                            ("%s: Can not allocate memory for Tx bd rings.",
-                             __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err
+                                    ("%s: Can not allocate memory for Tx bd rings.",
+                                     __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2632,9 +2663,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                                          rx_bd_ring_offset[j]);
                 }
                 if (!ugeth->p_rx_bd_ring[j]) {
-                        ugeth_err
-                            ("%s: Can not allocate memory for Rx bd rings.",
-                             __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err
+                                    ("%s: Can not allocate memory for Rx bd rings.",
+                                     __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2648,8 +2680,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                               GFP_KERNEL);
 
                 if (ugeth->tx_skbuff[j] == NULL) {
-                        ugeth_err("%s: Could not allocate tx_skbuff",
-                                  __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err("%s: Could not allocate tx_skbuff",
+                                          __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2679,8 +2712,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                               GFP_KERNEL);
 
                 if (ugeth->rx_skbuff[j] == NULL) {
-                        ugeth_err("%s: Could not allocate rx_skbuff",
-                                  __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err("%s: Could not allocate rx_skbuff",
+                                          __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2711,9 +2745,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
             qe_muram_alloc(sizeof(struct ucc_geth_tx_global_pram),
                            UCC_GETH_TX_GLOBAL_PRAM_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->tx_glbl_pram_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_tx_glbl_pram.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_tx_glbl_pram.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -2733,9 +2768,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                            32 * (numThreadsTxNumerical == 1),
                            UCC_GETH_THREAD_DATA_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->thread_dat_tx_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_thread_data_tx.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_thread_data_tx.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -2761,9 +2797,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                            sizeof(struct ucc_geth_send_queue_qd),
                            UCC_GETH_SEND_QUEUE_QUEUE_DESCRIPTOR_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->send_q_mem_reg_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_send_q_mem_reg.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_send_q_mem_reg.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -2804,9 +2841,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                     qe_muram_alloc(sizeof(struct ucc_geth_scheduler),
                                    UCC_GETH_SCHEDULER_ALIGNMENT);
                 if (IS_ERR_VALUE(ugeth->scheduler_offset)) {
-                        ugeth_err
-                         ("%s: Can not allocate DPRAM memory for p_scheduler.",
-                             __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err
+                                 ("%s: Can not allocate DPRAM memory for p_scheduler.",
+                                     __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2852,9 +2890,11 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                    (struct ucc_geth_tx_firmware_statistics_pram),
                                    UCC_GETH_TX_STATISTICS_ALIGNMENT);
                 if (IS_ERR_VALUE(ugeth->tx_fw_statistics_pram_offset)) {
-                        ugeth_err
-                            ("%s: Can not allocate DPRAM memory for"
-                                " p_tx_fw_statistics_pram.", __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err
+                                    ("%s: Can not allocate DPRAM memory for"
+                                        " p_tx_fw_statistics_pram.",
+                                        __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2891,9 +2931,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
             qe_muram_alloc(sizeof(struct ucc_geth_rx_global_pram),
                            UCC_GETH_RX_GLOBAL_PRAM_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->rx_glbl_pram_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_rx_glbl_pram.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_rx_glbl_pram.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -2912,9 +2953,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                            sizeof(struct ucc_geth_thread_data_rx),
                            UCC_GETH_THREAD_DATA_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->thread_dat_rx_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_thread_data_rx.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_thread_data_rx.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -2935,9 +2977,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                    (struct ucc_geth_rx_firmware_statistics_pram),
                                    UCC_GETH_RX_STATISTICS_ALIGNMENT);
                 if (IS_ERR_VALUE(ugeth->rx_fw_statistics_pram_offset)) {
-                        ugeth_err
-                                ("%s: Can not allocate DPRAM memory for"
-                                " p_rx_fw_statistics_pram.", __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err
+                                        ("%s: Can not allocate DPRAM memory for"
+                                        " p_rx_fw_statistics_pram.", __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -2957,9 +3000,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                            sizeof(struct ucc_geth_rx_interrupt_coalescing_entry)
                            + 4, UCC_GETH_RX_INTERRUPT_COALESCING_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->rx_irq_coalescing_tbl_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for"
-                        " p_rx_irq_coalescing_tbl.", __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for"
+                                " p_rx_irq_coalescing_tbl.", __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -3025,9 +3069,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                             sizeof(struct ucc_geth_rx_prefetched_bds)),
                            UCC_GETH_RX_BD_QUEUES_ALIGNMENT);
         if (IS_ERR_VALUE(ugeth->rx_bd_qs_tbl_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_rx_bd_qs_tbl.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_rx_bd_qs_tbl.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -3102,8 +3147,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         /* initialize extended filtering */
         if (ug_info->rxExtendedFiltering) {
                 if (!ug_info->extendedFilteringChainPointer) {
-                        ugeth_err("%s: Null Extended Filtering Chain Pointer.",
-                                  __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err("%s: Null Extended Filtering Chain Pointer.",
+                                          __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -EINVAL;
                 }
@@ -3114,9 +3160,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                     qe_muram_alloc(sizeof(struct ucc_geth_exf_global_pram),
                 UCC_GETH_RX_EXTENDED_FILTERING_GLOBAL_PARAMETERS_ALIGNMENT);
                 if (IS_ERR_VALUE(ugeth->exf_glbl_param_offset)) {
-                        ugeth_err
-                                ("%s: Can not allocate DPRAM memory for"
-                                " p_exf_glbl_param.", __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err
+                                        ("%s: Can not allocate DPRAM memory for"
+                                        " p_exf_glbl_param.", __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return -ENOMEM;
                 }
@@ -3161,9 +3208,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
          */
         if (!(ugeth->p_init_enet_param_shadow =
               kmalloc(sizeof(struct ucc_geth_init_pram), GFP_KERNEL))) {
-                ugeth_err
-                    ("%s: Can not allocate memory for"
-                        " p_UccInitEnetParamShadows.", __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate memory for"
+                                " p_UccInitEnetParamShadows.", __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -3196,8 +3244,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 QE_FLTR_LARGEST_EXTERNAL_TABLE_LOOKUP_KEY_SIZE_8_BYTES)
             && (ug_info->largestexternallookupkeysize !=
                 QE_FLTR_LARGEST_EXTERNAL_TABLE_LOOKUP_KEY_SIZE_16_BYTES)) {
-                ugeth_err("%s: Invalid largest External Lookup Key Size.",
-                          __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Invalid largest External Lookup Key Size.",
+                                  __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -EINVAL;
         }
@@ -3222,8 +3271,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                 /* Rx needs one extra for terminator */
                 , size, UCC_GETH_THREAD_RX_PRAM_ALIGNMENT,
                 ug_info->riscRx, 1)) != 0) {
-                        ugeth_err("%s: Can not fill p_init_enet_param_shadow.",
-                                __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                                ugeth_err("%s: Can not fill p_init_enet_param_shadow.",
+                                        __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return ret_val;
         }
@@ -3237,8 +3287,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                     sizeof(struct ucc_geth_thread_tx_pram),
                                     UCC_GETH_THREAD_TX_PRAM_ALIGNMENT,
                                     ug_info->riscTx, 0)) != 0) {
-                ugeth_err("%s: Can not fill p_init_enet_param_shadow.",
-                          __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Can not fill p_init_enet_param_shadow.",
+                                  __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return ret_val;
         }
@@ -3246,8 +3297,9 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         /* Load Rx bds with buffers */
         for (i = 0; i < ug_info->numQueuesRx; i++) {
                 if ((ret_val = rx_bd_buffer_set(ugeth, (u8) i)) != 0) {
-                        ugeth_err("%s: Can not fill Rx bds with buffers.",
-                                  __FUNCTION__);
+                        if (netif_msg_ifup(ugeth))
+                                ugeth_err("%s: Can not fill Rx bds with buffers.",
+                                          __FUNCTION__);
                         ucc_geth_memclean(ugeth);
                         return ret_val;
                 }
@@ -3256,9 +3308,10 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         /* Allocate InitEnet command parameter structure */
         init_enet_pram_offset = qe_muram_alloc(sizeof(struct ucc_geth_init_pram), 4);
         if (IS_ERR_VALUE(init_enet_pram_offset)) {
-                ugeth_err
-                    ("%s: Can not allocate DPRAM memory for p_init_enet_pram.",
-                     __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err
+                            ("%s: Can not allocate DPRAM memory for p_init_enet_pram.",
+                             __FUNCTION__);
                 ucc_geth_memclean(ugeth);
                 return -ENOMEM;
         }
@@ -3428,8 +3481,9 @@ static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit
                 if (!skb ||
                     (!(bd_status & (R_F | R_L))) ||
                     (bd_status & R_ERRORS_FATAL)) {
-                        ugeth_vdbg("%s, %d: ERROR!!! skb - 0x%08x",
-                                   __FUNCTION__, __LINE__, (u32) skb);
+                        if (netif_msg_rx_err(ugeth))
+                                ugeth_err("%s, %d: ERROR!!! skb - 0x%08x",
+                                           __FUNCTION__, __LINE__, (u32) skb);
                         if (skb)
                                 dev_kfree_skb_any(skb);
 
@@ -3458,7 +3512,8 @@ static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit
 
                 skb = get_new_skb(ugeth, bd);
                 if (!skb) {
-                        ugeth_warn("%s: No Rx Data Buffer", __FUNCTION__);
+                        if (netif_msg_rx_err(ugeth))
+                                ugeth_warn("%s: No Rx Data Buffer", __FUNCTION__);
                         ugeth->stats.rx_dropped++;
                         break;
                 }
@@ -3649,28 +3704,32 @@ static int ucc_geth_open(struct net_device *dev)
 
         /* Test station address */
         if (dev->dev_addr[0] & ENET_GROUP_ADDR) {
-                ugeth_err("%s: Multicast address used for station address"
-                          " - is this what you wanted?", __FUNCTION__);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Multicast address used for station address"
+                                  " - is this what you wanted?", __FUNCTION__);
                 return -EINVAL;
         }
 
         err = ucc_struct_init(ugeth);
         if (err) {
-                ugeth_err("%s: Cannot configure internal struct, aborting.", dev->name);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Cannot configure internal struct, aborting.", dev->name);
                 return err;
         }
 
         err = ucc_geth_startup(ugeth);
         if (err) {
-                ugeth_err("%s: Cannot configure net device, aborting.",
-                          dev->name);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Cannot configure net device, aborting.",
+                                  dev->name);
                 return err;
         }
 
         err = adjust_enet_interface(ugeth);
         if (err) {
-                ugeth_err("%s: Cannot configure net device, aborting.",
-                          dev->name);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Cannot configure net device, aborting.",
+                                  dev->name);
                 return err;
         }
 
@@ -3687,7 +3746,8 @@ static int ucc_geth_open(struct net_device *dev)
 
         err = init_phy(dev);
         if (err) {
-                ugeth_err("%s: Cannot initialize PHY, aborting.", dev->name);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Cannot initialize PHY, aborting.", dev->name);
                 return err;
         }
 
@@ -3697,15 +3757,17 @@ static int ucc_geth_open(struct net_device *dev)
             request_irq(ugeth->ug_info->uf_info.irq, ucc_geth_irq_handler, 0,
                         "UCC Geth", dev);
         if (err) {
-                ugeth_err("%s: Cannot get IRQ for net device, aborting.",
-                          dev->name);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Cannot get IRQ for net device, aborting.",
+                                  dev->name);
                 ucc_geth_stop(ugeth);
                 return err;
         }
 
         err = ugeth_enable(ugeth, COMM_DIR_RX_AND_TX);
         if (err) {
-                ugeth_err("%s: Cannot enable net device, aborting.", dev->name);
+                if (netif_msg_ifup(ugeth))
+                        ugeth_err("%s: Cannot enable net device, aborting.", dev->name);
                 ucc_geth_stop(ugeth);
                 return err;
         }
@@ -3732,8 +3794,6 @@ static int ucc_geth_close(struct net_device *dev)
         return 0;
 }
 
-const struct ethtool_ops ucc_geth_ethtool_ops = { };
-
 static phy_interface_t to_phy_interface(const char *phy_connection_type)
 {
         if (strcasecmp(phy_connection_type, "mii") == 0)
@@ -3790,6 +3850,13 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
                 return -ENODEV;
 
         ug_info = &ugeth_info[ucc_num];
+        if (ug_info == NULL) {
+                if (netif_msg_probe(&debug))
+                        ugeth_err("%s: [%d] Missing additional data!",
+                                        __FUNCTION__, ucc_num);
+                return -ENODEV;
+        }
+
         ug_info->uf_info.ucc_num = ucc_num;
 
         prop = of_get_property(np, "rx-clock", NULL);
@@ -3868,15 +3935,10 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
 
         ug_info->mdio_bus = res.start;
 
-        printk(KERN_INFO "ucc_geth: UCC%1d at 0x%8x (irq = %d) \n",
-                ug_info->uf_info.ucc_num + 1, ug_info->uf_info.regs,
-                ug_info->uf_info.irq);
-
-        if (ug_info == NULL) {
-                ugeth_err("%s: [%d] Missing additional data!", __FUNCTION__,
-                          ucc_num);
-                return -ENODEV;
-        }
+        if (netif_msg_probe(&debug))
+                printk(KERN_INFO "ucc_geth: UCC%1d at 0x%8x (irq = %d) \n",
+                        ug_info->uf_info.ucc_num + 1, ug_info->uf_info.regs,
+                        ug_info->uf_info.irq);
 
         /* Create an ethernet device instance */
         dev = alloc_etherdev(sizeof(*ugeth));
@@ -3896,6 +3958,7 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
         SET_NETDEV_DEV(dev, device);
 
         /* Fill in the dev structure */
+        uec_set_ethtool_ops(dev);
         dev->open = ucc_geth_open;
         dev->hard_start_xmit = ucc_geth_start_xmit;
         dev->tx_timeout = ucc_geth_timeout;
@@ -3909,16 +3972,16 @@ static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *ma
 //    dev->change_mtu = ucc_geth_change_mtu;
         dev->mtu = 1500;
         dev->set_multicast_list = ucc_geth_set_multi;
-        dev->ethtool_ops = &ucc_geth_ethtool_ops;
 
-        ugeth->msg_enable = (NETIF_MSG_IFUP << 1 ) - 1;
+        ugeth->msg_enable = netif_msg_init(debug.msg_enable, UGETH_MSG_DEFAULT);
         ugeth->phy_interface = phy_interface;
         ugeth->max_speed = max_speed;
 
         err = register_netdev(dev);
         if (err) {
-                ugeth_err("%s: Cannot register net device, aborting.",
-                          dev->name);
+                if (netif_msg_probe(ugeth))
+                        ugeth_err("%s: Cannot register net device, aborting.",
+                                  dev->name);
                 free_netdev(dev);
                 return err;
         }
@@ -3972,7 +4035,8 @@ static int __init ucc_geth_init(void)
         if (ret)
                 return ret;
 
-        printk(KERN_INFO "ucc_geth: " DRV_DESC "\n");
+        if (netif_msg_drv(&debug))
+                printk(KERN_INFO "ucc_geth: " DRV_DESC "\n");
         for (i = 0; i < 8; i++)
                 memcpy(&(ugeth_info[i]), &ugeth_primary_info,
                        sizeof(ugeth_primary_info));
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index a29e1c3ca4b..bb4dac8c0c6 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -30,6 +30,10 @@
 
 #include "ucc_geth_mii.h"
 
+#define DRV_DESC "QE UCC Gigabit Ethernet Controller"
+#define DRV_NAME "ucc_geth"
+#define DRV_VERSION "1.1"
+
 #define NUM_TX_QUEUES                   8
 #define NUM_RX_QUEUES                   8
 #define NUM_BDS_IN_PREFETCHED_BDS       4
@@ -896,6 +900,7 @@ struct ucc_geth_hardware_statistics {
 #define UCC_GETH_TX_VTAG_TABLE_ENTRY_MAX        8
 #define UCC_GETH_RX_BD_RING_SIZE_MIN            8
 #define UCC_GETH_TX_BD_RING_SIZE_MIN            2
+#define UCC_GETH_BD_RING_SIZE_MAX               0xffff
 
 #define UCC_GETH_SIZE_OF_BD                     QE_SIZEOF_BD
 
@@ -1135,6 +1140,7 @@ struct ucc_geth_info {
         int bro;
         int ecm;
         int receiveFlowControl;
+        int transmitFlowControl;
         u8 maxGroupAddrInHash;
         u8 maxIndAddrInHash;
         u8 prel;
diff --git a/drivers/net/ucc_geth_ethtool.c b/drivers/net/ucc_geth_ethtool.c
new file mode 100644
index 00000000000..a8994c7b858
--- /dev/null
+++ b/drivers/net/ucc_geth_ethtool.c
@@ -0,0 +1,388 @@
+/*
+ * Copyright (c) 2007 Freescale Semiconductor, Inc. All rights reserved.
+ *
+ * Description: QE UCC Gigabit Ethernet Ethtool API Set
+ *
+ * Author: Li Yang <leoli@freescale.com>
+ *
+ * Limitation: 
+ * Can only get/set setttings of the first queue.
+ * Need to re-open the interface manually after changing some paramters.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/stddef.h>
+#include <linux/interrupt.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/fsl_devices.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+#include <asm/types.h>
+#include <asm/uaccess.h>
+
+#include "ucc_geth.h"
+#include "ucc_geth_mii.h"
+
+static char hw_stat_gstrings[][ETH_GSTRING_LEN] = {
+        "tx-64-frames",
+        "tx-65-127-frames",
+        "tx-128-255-frames",
+        "rx-64-frames",
+        "rx-65-127-frames",
+        "rx-128-255-frames",
+        "tx-bytes-ok",
+        "tx-pause-frames",
+        "tx-multicast-frames",
+        "tx-broadcast-frames",
+        "rx-frames",
+        "rx-bytes-ok",
+        "rx-bytes-all",
+        "rx-multicast-frames",
+        "rx-broadcast-frames",
+        "stats-counter-carry",
+        "stats-counter-mask",
+        "rx-dropped-frames",
+};
+
+static char tx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
+        "tx-single-collision",
+        "tx-multiple-collision",
+        "tx-late-collsion",
+        "tx-aborted-frames",
+        "tx-lost-frames",
+        "tx-carrier-sense-errors",
+        "tx-frames-ok",
+        "tx-excessive-differ-frames",
+        "tx-256-511-frames",
+        "tx-1024-1518-frames",
+        "tx-jumbo-frames",
+};
+
+static char rx_fw_stat_gstrings[][ETH_GSTRING_LEN] = {
+        "rx-crc-errors",
+        "rx-alignment-errors",
+        "rx-in-range-length-errors",
+        "rx-out-of-range-length-errors",
+        "rx-too-long-frames",
+        "rx-runt",
+        "rx-very-long-event",
+        "rx-symbol-errors",
+        "rx-busy-drop-frames",
+        "reserved",
+        "reserved",
+        "rx-mismatch-drop-frames",
+        "rx-small-than-64",
+        "rx-256-511-frames",
+        "rx-512-1023-frames",
+        "rx-1024-1518-frames",
+        "rx-jumbo-frames",
+        "rx-mac-error-loss",
+        "rx-pause-frames",
+        "reserved",
+        "rx-vlan-removed",
+        "rx-vlan-replaced",
+        "rx-vlan-inserted",
+        "rx-ip-checksum-errors",
+};
+
+#define UEC_HW_STATS_LEN ARRAY_SIZE(hw_stat_gstrings)
+#define UEC_TX_FW_STATS_LEN ARRAY_SIZE(tx_fw_stat_gstrings)
+#define UEC_RX_FW_STATS_LEN ARRAY_SIZE(rx_fw_stat_gstrings)
+
+extern int init_flow_control_params(u32 automatic_flow_control_mode,
+                int rx_flow_control_enable,
+                int tx_flow_control_enable, u16 pause_period,
+                u16 extension_field, volatile u32 *upsmr_register,
+                volatile u32 *uempr_register, volatile u32 *maccfg1_register);
+
+static int
+uec_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        struct phy_device *phydev = ugeth->phydev;
+        struct ucc_geth_info *ug_info = ugeth->ug_info;
+
+        if (!phydev)
+                return -ENODEV;
+
+        ecmd->maxtxpkt = 1;
+        ecmd->maxrxpkt = ug_info->interruptcoalescingmaxvalue[0];
+
+        return phy_ethtool_gset(phydev, ecmd);
+}
+
+static int
+uec_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        struct phy_device *phydev = ugeth->phydev;
+
+        if (!phydev)
+                return -ENODEV;
+
+        return phy_ethtool_sset(phydev, ecmd);
+}
+
+static void
+uec_get_pauseparam(struct net_device *netdev,
+                     struct ethtool_pauseparam *pause)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+
+        pause->autoneg = ugeth->phydev->autoneg;
+
+        if (ugeth->ug_info->receiveFlowControl)
+                pause->rx_pause = 1;
+        if (ugeth->ug_info->transmitFlowControl)
+                pause->tx_pause = 1;
+}
+
+static int
+uec_set_pauseparam(struct net_device *netdev,
+                     struct ethtool_pauseparam *pause)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        int ret = 0;
+
+        ugeth->ug_info->receiveFlowControl = pause->rx_pause;
+        ugeth->ug_info->transmitFlowControl = pause->tx_pause;
+        
+        if (ugeth->phydev->autoneg) {
+                if (netif_running(netdev)) {
+                        /* FIXME: automatically restart */
+                        printk(KERN_INFO
+                                "Please re-open the interface.\n");
+                }
+        } else {
+                struct ucc_geth_info *ug_info = ugeth->ug_info;
+
+                ret = init_flow_control_params(ug_info->aufc,
+                                        ug_info->receiveFlowControl,
+                                        ug_info->transmitFlowControl,
+                                        ug_info->pausePeriod,
+                                        ug_info->extensionField,
+                                        &ugeth->uccf->uf_regs->upsmr,
+                                        &ugeth->ug_regs->uempr,
+                                        &ugeth->ug_regs->maccfg1);
+        }
+
+        return ret;
+}
+
+static uint32_t
+uec_get_msglevel(struct net_device *netdev)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        return ugeth->msg_enable;
+}
+
+static void
+uec_set_msglevel(struct net_device *netdev, uint32_t data)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        ugeth->msg_enable = data;
+}
+
+static int
+uec_get_regs_len(struct net_device *netdev)
+{
+        return sizeof(struct ucc_geth);
+}
+
+static void
+uec_get_regs(struct net_device *netdev,
+               struct ethtool_regs *regs, void *p)
+{
+        int i;
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        u32 __iomem *ug_regs = (u32 __iomem *)ugeth->ug_regs;
+        u32 *buff = p;
+
+        for (i = 0; i < sizeof(struct ucc_geth) / sizeof(u32); i++)
+                buff[i] = in_be32(&ug_regs[i]);
+}
+
+static void
+uec_get_ringparam(struct net_device *netdev,
+                    struct ethtool_ringparam *ring)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        struct ucc_geth_info *ug_info = ugeth->ug_info;
+        int queue = 0;
+
+        ring->rx_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
+        ring->rx_mini_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
+        ring->rx_jumbo_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
+        ring->tx_max_pending = UCC_GETH_BD_RING_SIZE_MAX;
+
+        ring->rx_pending = ug_info->bdRingLenRx[queue];
+        ring->rx_mini_pending = ug_info->bdRingLenRx[queue];
+        ring->rx_jumbo_pending = ug_info->bdRingLenRx[queue];
+        ring->tx_pending = ug_info->bdRingLenTx[queue];
+}
+
+static int
+uec_set_ringparam(struct net_device *netdev,
+                    struct ethtool_ringparam *ring)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        struct ucc_geth_info *ug_info = ugeth->ug_info;
+        int queue = 0, ret = 0;
+
+        if (ring->rx_pending < UCC_GETH_RX_BD_RING_SIZE_MIN) {
+                printk("%s: RxBD ring size must be no smaller than %d.\n",
+                                netdev->name, UCC_GETH_RX_BD_RING_SIZE_MIN);
+                return -EINVAL;
+        }
+        if (ring->rx_pending % UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT) {
+                printk("%s: RxBD ring size must be multiple of %d.\n",
+                        netdev->name, UCC_GETH_RX_BD_RING_SIZE_ALIGNMENT);
+                return -EINVAL;
+        }
+        if (ring->tx_pending < UCC_GETH_TX_BD_RING_SIZE_MIN) {
+                printk("%s: TxBD ring size must be no smaller than %d.\n",
+                                netdev->name, UCC_GETH_TX_BD_RING_SIZE_MIN);
+                return -EINVAL;
+        }
+
+        ug_info->bdRingLenRx[queue] = ring->rx_pending;
+        ug_info->bdRingLenTx[queue] = ring->tx_pending;
+
+        if (netif_running(netdev)) {
+                /* FIXME: restart automatically */
+                printk(KERN_INFO
+                        "Please re-open the interface.\n");
+        }
+
+        return ret;
+}
+
+static int uec_get_stats_count(struct net_device *netdev)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        u32 stats_mode = ugeth->ug_info->statisticsMode;
+        int len = 0;
+
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE)
+                len += UEC_HW_STATS_LEN;
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX)
+                len += UEC_TX_FW_STATS_LEN;
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX)
+                len += UEC_RX_FW_STATS_LEN;
+
+        return len;
+}
+
+static void uec_get_strings(struct net_device *netdev, u32 stringset, u8 *buf)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        u32 stats_mode = ugeth->ug_info->statisticsMode;
+
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
+                memcpy(buf, hw_stat_gstrings, UEC_HW_STATS_LEN *
+                                ETH_GSTRING_LEN);
+                buf += UEC_HW_STATS_LEN * ETH_GSTRING_LEN;
+        }
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
+                memcpy(buf, tx_fw_stat_gstrings, UEC_TX_FW_STATS_LEN *
+                                ETH_GSTRING_LEN);
+                buf += UEC_TX_FW_STATS_LEN * ETH_GSTRING_LEN;
+        }
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX)
+                memcpy(buf, tx_fw_stat_gstrings, UEC_RX_FW_STATS_LEN *
+                                ETH_GSTRING_LEN);
+}
+
+static void uec_get_ethtool_stats(struct net_device *netdev,
+                struct ethtool_stats *stats, uint64_t *data)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+        u32 stats_mode = ugeth->ug_info->statisticsMode;
+        u32 __iomem *base;
+        int i, j = 0;
+
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_HARDWARE) {
+                base = (u32 __iomem *)&ugeth->ug_regs->tx64;
+                for (i = 0; i < UEC_HW_STATS_LEN; i++)
+                        data[j++] = (u64)in_be32(&base[i]);
+        }
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
+                base = (u32 __iomem *)ugeth->p_tx_fw_statistics_pram;
+                for (i = 0; i < UEC_TX_FW_STATS_LEN; i++)
+                        data[j++] = (u64)in_be32(&base[i]);
+        }
+        if (stats_mode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX) {
+                base = (u32 __iomem *)ugeth->p_rx_fw_statistics_pram;
+                for (i = 0; i < UEC_RX_FW_STATS_LEN; i++)
+                        data[j++] = (u64)in_be32(&base[i]);
+        }
+}
+
+static int uec_nway_reset(struct net_device *netdev)
+{
+        struct ucc_geth_private *ugeth = netdev_priv(netdev);
+
+        return phy_start_aneg(ugeth->phydev);
+}
+
+/* Report driver information */
+static void
+uec_get_drvinfo(struct net_device *netdev,
+                       struct ethtool_drvinfo *drvinfo)
+{
+        strncpy(drvinfo->driver, DRV_NAME, 32);
+        strncpy(drvinfo->version, DRV_VERSION, 32);
+        strncpy(drvinfo->fw_version, "N/A", 32);
+        strncpy(drvinfo->bus_info, "QUICC ENGINE", 32);
+        drvinfo->n_stats = uec_get_stats_count(netdev);
+        drvinfo->testinfo_len = 0;
+        drvinfo->eedump_len = 0;
+        drvinfo->regdump_len = uec_get_regs_len(netdev);
+}
+
+static const struct ethtool_ops uec_ethtool_ops = {
+        .get_settings           = uec_get_settings,
+        .set_settings           = uec_set_settings,
+        .get_drvinfo            = uec_get_drvinfo,
+        .get_regs_len           = uec_get_regs_len,
+        .get_regs               = uec_get_regs,
+        .get_msglevel           = uec_get_msglevel,
+        .set_msglevel           = uec_set_msglevel,
+        .nway_reset             = uec_nway_reset,
+        .get_link               = ethtool_op_get_link,
+        .get_ringparam          = uec_get_ringparam,
+        .set_ringparam          = uec_set_ringparam,
+        .get_pauseparam         = uec_get_pauseparam,
+        .set_pauseparam         = uec_set_pauseparam,
+        .get_sg                 = ethtool_op_get_sg,
+        .set_sg                 = ethtool_op_set_sg,
+        .get_tso                = ethtool_op_get_tso,
+        .get_stats_count        = uec_get_stats_count,
+        .get_strings            = uec_get_strings,
+        .get_ethtool_stats      = uec_get_ethtool_stats,
+        .get_perm_addr          = ethtool_op_get_perm_addr,
+};
+
+void uec_set_ethtool_ops(struct net_device *netdev)
+{
+        SET_ETHTOOL_OPS(netdev, &uec_ethtool_ops);
+}
diff --git a/drivers/net/ucc_geth_mii.c b/drivers/net/ucc_geth_mii.c
index 7bcb82f50cf..5f8c2d30a32 100644
--- a/drivers/net/ucc_geth_mii.c
+++ b/drivers/net/ucc_geth_mii.c
@@ -54,8 +54,8 @@
 #define vdbg(format, arg...) do {} while(0)
 #endif
 
-#define DRV_DESC "QE UCC Ethernet Controller MII Bus"
-#define DRV_NAME "fsl-uec_mdio"
+#define MII_DRV_DESC "QE UCC Ethernet Controller MII Bus"
+#define MII_DRV_NAME "fsl-uec_mdio"
 
 /* Write value to the PHY for this device to the register at regnum, */
 /* waiting until the write is done before it returns.  All PHY */
@@ -261,7 +261,7 @@ static struct of_device_id uec_mdio_match[] = {
 };
 
 static struct of_platform_driver uec_mdio_driver = {
-        .name   = DRV_NAME,
+        .name   = MII_DRV_NAME,
         .probe  = uec_mdio_probe,
         .remove = uec_mdio_remove,
         .match_table    = uec_mdio_match,
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index bfeca57098f..e6bfce690ca 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1187,7 +1187,7 @@ dasd_end_request_cb(struct dasd_ccw_req * cqr, void *data)
 static void
 __dasd_process_blk_queue(struct dasd_device * device)
 {
-        request_queue_t *queue;
+        struct request_queue *queue;
         struct request *req;
         struct dasd_ccw_req *cqr;
         int nr_queued;
@@ -1740,7 +1740,7 @@ dasd_cancel_req(struct dasd_ccw_req *cqr)
  * Dasd request queue function. Called from ll_rw_blk.c
  */
 static void
-do_dasd_request(request_queue_t * queue)
+do_dasd_request(struct request_queue * queue)
 {
         struct dasd_device *device;
 
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 241294cba41..aeda5268244 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -293,7 +293,7 @@ struct dasd_uid {
 struct dasd_device {
         /* Block device stuff. */
         struct gendisk *gdp;
-        request_queue_t *request_queue;
+        struct request_queue *request_queue;
         spinlock_t request_queue_lock;
         struct block_device *bdev;
         unsigned int devindex;
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 35765f6a86e..4d8798bacf9 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -621,7 +621,7 @@ out:
 }
 
 static int
-dcssblk_make_request(request_queue_t *q, struct bio *bio)
+dcssblk_make_request(struct request_queue *q, struct bio *bio)
 {
         struct dcssblk_dev_info *dev_info;
         struct bio_vec *bvec;
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index a04d9120cef..354a060e5be 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -191,7 +191,7 @@ static unsigned long __init xpram_highest_page_index(void)
 /*
  * Block device make request function.
  */
-static int xpram_make_request(request_queue_t *q, struct bio *bio)
+static int xpram_make_request(struct request_queue *q, struct bio *bio)
 {
         xpram_device_t *xdev = bio->bi_bdev->bd_disk->private_data;
         struct bio_vec *bvec;
diff --git a/drivers/s390/char/tape.h b/drivers/s390/char/tape.h
index 3b52f5c1dbe..dddf8d62c15 100644
--- a/drivers/s390/char/tape.h
+++ b/drivers/s390/char/tape.h
@@ -188,7 +188,7 @@ struct tape_blk_data
 {
         struct tape_device *    device;
         /* Block device request queue. */
-        request_queue_t *       request_queue;
+        struct request_queue *  request_queue;
         spinlock_t              request_queue_lock;
 
         /* Task to move entries from block request to CCS request queue. */
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index dd0ecaed592..eeb92e2ed0c 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -147,7 +147,7 @@ static void
 tapeblock_requeue(struct work_struct *work) {
         struct tape_blk_data *  blkdat;
         struct tape_device *    device;
-        request_queue_t *       queue;
+        struct request_queue *  queue;
         int                     nr_queued;
         struct request *        req;
         struct list_head *      l;
@@ -194,7 +194,7 @@ tapeblock_requeue(struct work_struct *work) {
  * Tape request queue function. Called from ll_rw_blk.c
  */
 static void
-tapeblock_request_fn(request_queue_t *queue)
+tapeblock_request_fn(struct request_queue *queue)
 {
         struct tape_device *device;
 
diff --git a/drivers/sbus/char/Kconfig b/drivers/sbus/char/Kconfig
index 35a73168333..400c65bfb8c 100644
--- a/drivers/sbus/char/Kconfig
+++ b/drivers/sbus/char/Kconfig
@@ -15,6 +15,7 @@ config SUN_OPENPROMIO
 
 config SUN_MOSTEK_RTC
         tristate "Mostek real time clock support"
+        depends on SPARC32
         help
           The Mostek RTC chip is used on all known Sun computers except
           some JavaStations. For a JavaStation you need to say Y both here
diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index 5157a2abc58..4b7079fdc10 100644
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -185,7 +185,7 @@ static void jsfd_read(char *buf, unsigned long p, size_t togo) {
         }
 }
 
-static void jsfd_do_request(request_queue_t *q)
+static void jsfd_do_request(struct request_queue *q)
 {
         struct request *req;
 
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index d76e1a8cb93..c709dc8ad99 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -636,6 +636,8 @@ static int aac_cfg_open(struct inode *inode, struct file *file)
 static int aac_cfg_ioctl(struct inode *inode,  struct file *file,
                 unsigned int cmd, unsigned long arg)
 {
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
         return aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
 }
 
@@ -689,6 +691,8 @@ static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
 
 static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 {
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
         return aac_compat_do_ioctl((struct aac_dev *)file->private_data, cmd, arg);
 }
 #endif
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index da63c544919..21c075d44db 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -654,7 +654,7 @@ void scsi_run_host_queues(struct Scsi_Host *shost)
 static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int uptodate,
                                           int bytes, int requeue)
 {
-        request_queue_t *q = cmd->device->request_queue;
+        struct request_queue *q = cmd->device->request_queue;
         struct request *req = cmd->request;
         unsigned long flags;
 
@@ -818,7 +818,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
 {
         int result = cmd->result;
         int this_count = cmd->request_bufflen;
-        request_queue_t *q = cmd->device->request_queue;
+        struct request_queue *q = cmd->device->request_queue;
         struct request *req = cmd->request;
         int clear_errors = 1;
         struct scsi_sense_hdr sshdr;
@@ -1038,7 +1038,7 @@ static int scsi_init_io(struct scsi_cmnd *cmd)
         return BLKPREP_KILL;
 }
 
-static int scsi_issue_flush_fn(request_queue_t *q, struct gendisk *disk,
+static int scsi_issue_flush_fn(struct request_queue *q, struct gendisk *disk,
                                sector_t *error_sector)
 {
         struct scsi_device *sdev = q->queuedata;
@@ -1340,7 +1340,7 @@ static inline int scsi_host_queue_ready(struct request_queue *q,
 /*
  * Kill a request for a dead device
  */
-static void scsi_kill_request(struct request *req, request_queue_t *q)
+static void scsi_kill_request(struct request *req, struct request_queue *q)
 {
         struct scsi_cmnd *cmd = req->special;
         struct scsi_device *sdev = cmd->device;
@@ -2119,7 +2119,7 @@ EXPORT_SYMBOL(scsi_target_resume);
 int
 scsi_internal_device_block(struct scsi_device *sdev)
 {
-        request_queue_t *q = sdev->request_queue;
+        struct request_queue *q = sdev->request_queue;
         unsigned long flags;
         int err = 0;
 
@@ -2159,7 +2159,7 @@ EXPORT_SYMBOL_GPL(scsi_internal_device_block);
 int
 scsi_internal_device_unblock(struct scsi_device *sdev)
 {
-        request_queue_t *q = sdev->request_queue; 
+        struct request_queue *q = sdev->request_queue; 
         int err;
         unsigned long flags;
         
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 424d557284a..e21c7142a3e 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -814,7 +814,7 @@ static int sd_issue_flush(struct device *dev, sector_t *error_sector)
         return ret;
 }
 
-static void sd_prepare_flush(request_queue_t *q, struct request *rq)
+static void sd_prepare_flush(struct request_queue *q, struct request *rq)
 {
         memset(rq->cmd, 0, sizeof(rq->cmd));
         rq->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -1285,7 +1285,7 @@ got_data:
                  */
                 int hard_sector = sector_size;
                 sector_t sz = (sdkp->capacity/2) * (hard_sector/256);
-                request_queue_t *queue = sdp->request_queue;
+                struct request_queue *queue = sdp->request_queue;
                 sector_t mb = sz;
 
                 blk_queue_hardsect_size(queue, hard_sector);
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index e7b6a7fde1c..902eb11ffe8 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -624,7 +624,7 @@ static void get_sectorsize(struct scsi_cd *cd)
         unsigned char *buffer;
         int the_result, retries = 3;
         int sector_size;
-        request_queue_t *queue;
+        struct request_queue *queue;
 
         buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
         if (!buffer)
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 0b3ec38ae61..2f5a5ac1b27 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2650,8 +2650,9 @@ static int __devinit serial8250_probe(struct platform_device *dev)
                 ret = serial8250_register_port(&port);
                 if (ret < 0) {
                         dev_err(&dev->dev, "unable to register port at index %d "
-                                "(IO%lx MEM%lx IRQ%d): %d\n", i,
-                                p->iobase, p->mapbase, p->irq, ret);
+                                "(IO%lx MEM%llx IRQ%d): %d\n", i,
+                                p->iobase, (unsigned long long)p->mapbase,
+                                p->irq, ret);
                 }
         }
         return 0;
diff --git a/drivers/serial/8250_early.c b/drivers/serial/8250_early.c
index 947c20507e1..150cad5c2eb 100644
--- a/drivers/serial/8250_early.c
+++ b/drivers/serial/8250_early.c
@@ -151,8 +151,9 @@ static int __init parse_options(struct early_serial8250_device *device, char *op
 #else
                 port->membase = ioremap(port->mapbase, 64);
                 if (!port->membase) {
-                        printk(KERN_ERR "%s: Couldn't ioremap 0x%lx\n",
-                                __FUNCTION__, port->mapbase);
+                        printk(KERN_ERR "%s: Couldn't ioremap 0x%llx\n",
+                                __FUNCTION__,
+                               (unsigned long long)port->mapbase);
                         return -ENOMEM;
                 }
 #endif
@@ -175,9 +176,10 @@ static int __init parse_options(struct early_serial8250_device *device, char *op
                         device->baud);
         }
 
-        printk(KERN_INFO "Early serial console at %s 0x%lx (options '%s')\n",
+        printk(KERN_INFO "Early serial console at %s 0x%llx (options '%s')\n",
                 mmio ? "MMIO" : "I/O port",
-                mmio ? port->mapbase : (unsigned long) port->iobase,
+                mmio ? (unsigned long long) port->mapbase
+                     : (unsigned long long) port->iobase,
                 device->options);
         return 0;
 }
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 9c57486c2e7..030a6063541 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -626,7 +626,7 @@ static int uart_get_info(struct uart_state *state,
         tmp.hub6            = port->hub6;
         tmp.io_type         = port->iotype;
         tmp.iomem_reg_shift = port->regshift;
-        tmp.iomem_base      = (void *)port->mapbase;
+        tmp.iomem_base      = (void *)(unsigned long)port->mapbase;
 
         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
                 return -EFAULT;
@@ -1666,10 +1666,11 @@ static int uart_line_info(char *buf, struct uart_driver *drv, int i)
                 return 0;
 
         mmio = port->iotype >= UPIO_MEM;
-        ret = sprintf(buf, "%d: uart:%s %s%08lX irq:%d",
+        ret = sprintf(buf, "%d: uart:%s %s%08llX irq:%d",
                         port->line, uart_type(port),
                         mmio ? "mmio:0x" : "port:",
-                        mmio ? port->mapbase : (unsigned long) port->iobase,
+                        mmio ? (unsigned long long)port->mapbase
+                             : (unsigned long long) port->iobase,
                         port->irq);
 
         if (port->type == PORT_UNKNOWN) {
@@ -2069,7 +2070,7 @@ uart_report_port(struct uart_driver *drv, struct uart_port *port)
         case UPIO_TSI:
         case UPIO_DWAPB:
                 snprintf(address, sizeof(address),
-                         "MMIO 0x%lx", port->mapbase);
+                         "MMIO 0x%llx", (unsigned long long)port->mapbase);
                 break;
         default:
                 strlcpy(address, "*unknown*", sizeof(address));
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 564cc9b5182..a7231d171bd 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -1571,7 +1571,14 @@ config FB_PM3
 
 config FB_AU1100
         bool "Au1100 LCD Driver"
-        depends on (FB = y) && EXPERIMENTAL && PCI && MIPS && MIPS_PB1100=y
+        depends on (FB = y) && MIPS && SOC_AU1100
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        help
+          This is the framebuffer driver for the AMD Au1100 SOC.  It can drive
+          various panels and CRTs by passing in kernel cmd line option
+          au1100fb:panel=<name>.
 
 config FB_AU1200
         bool "Au1200 LCD Driver"
diff --git a/fs/bio.c b/fs/bio.c
index 0d2c2d38b7b..29a44c1b64c 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -230,7 +230,7 @@ void bio_put(struct bio *bio)
         }
 }
 
-inline int bio_phys_segments(request_queue_t *q, struct bio *bio)
+inline int bio_phys_segments(struct request_queue *q, struct bio *bio)
 {
         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
                 blk_recount_segments(q, bio);
@@ -238,7 +238,7 @@ inline int bio_phys_segments(request_queue_t *q, struct bio *bio)
         return bio->bi_phys_segments;
 }
 
-inline int bio_hw_segments(request_queue_t *q, struct bio *bio)
+inline int bio_hw_segments(struct request_queue *q, struct bio *bio)
 {
         if (unlikely(!bio_flagged(bio, BIO_SEG_VALID)))
                 blk_recount_segments(q, bio);
@@ -257,7 +257,7 @@ inline int bio_hw_segments(request_queue_t *q, struct bio *bio)
  */
 void __bio_clone(struct bio *bio, struct bio *bio_src)
 {
-        request_queue_t *q = bdev_get_queue(bio_src->bi_bdev);
+        struct request_queue *q = bdev_get_queue(bio_src->bi_bdev);
 
         memcpy(bio->bi_io_vec, bio_src->bi_io_vec,
                 bio_src->bi_max_vecs * sizeof(struct bio_vec));
@@ -303,7 +303,7 @@ struct bio *bio_clone(struct bio *bio, gfp_t gfp_mask)
  */
 int bio_get_nr_vecs(struct block_device *bdev)
 {
-        request_queue_t *q = bdev_get_queue(bdev);
+        struct request_queue *q = bdev_get_queue(bdev);
         int nr_pages;
 
         nr_pages = ((q->max_sectors << 9) + PAGE_SIZE - 1) >> PAGE_SHIFT;
@@ -315,7 +315,7 @@ int bio_get_nr_vecs(struct block_device *bdev)
         return nr_pages;
 }
 
-static int __bio_add_page(request_queue_t *q, struct bio *bio, struct page
+static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
                           *page, unsigned int len, unsigned int offset,
                           unsigned short max_sectors)
 {
@@ -425,7 +425,7 @@ static int __bio_add_page(request_queue_t *q, struct bio *bio, struct page
  *      smaller than PAGE_SIZE, so it is always possible to add a single
  *      page to an empty bio. This should only be used by REQ_PC bios.
  */
-int bio_add_pc_page(request_queue_t *q, struct bio *bio, struct page *page,
+int bio_add_pc_page(struct request_queue *q, struct bio *bio, struct page *page,
                     unsigned int len, unsigned int offset)
 {
         return __bio_add_page(q, bio, page, len, offset, q->max_hw_sectors);
@@ -523,7 +523,7 @@ int bio_uncopy_user(struct bio *bio)
  *      to/from kernel pages as necessary. Must be paired with
  *      call bio_uncopy_user() on io completion.
  */
-struct bio *bio_copy_user(request_queue_t *q, unsigned long uaddr,
+struct bio *bio_copy_user(struct request_queue *q, unsigned long uaddr,
                           unsigned int len, int write_to_vm)
 {
         unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
@@ -600,7 +600,7 @@ out_bmd:
         return ERR_PTR(ret);
 }
 
-static struct bio *__bio_map_user_iov(request_queue_t *q,
+static struct bio *__bio_map_user_iov(struct request_queue *q,
                                       struct block_device *bdev,
                                       struct sg_iovec *iov, int iov_count,
                                       int write_to_vm)
@@ -712,7 +712,7 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
 
 /**
  *      bio_map_user    -       map user address into bio
- *      @q: the request_queue_t for the bio
+ *      @q: the struct request_queue for the bio
  *      @bdev: destination block device
  *      @uaddr: start of user address
  *      @len: length in bytes
@@ -721,7 +721,7 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
  *      Map the user space address into a bio suitable for io to a block
  *      device. Returns an error pointer in case of error.
  */
-struct bio *bio_map_user(request_queue_t *q, struct block_device *bdev,
+struct bio *bio_map_user(struct request_queue *q, struct block_device *bdev,
                          unsigned long uaddr, unsigned int len, int write_to_vm)
 {
         struct sg_iovec iov;
@@ -734,7 +734,7 @@ struct bio *bio_map_user(request_queue_t *q, struct block_device *bdev,
 
 /**
  *      bio_map_user_iov - map user sg_iovec table into bio
- *      @q: the request_queue_t for the bio
+ *      @q: the struct request_queue for the bio
  *      @bdev: destination block device
  *      @iov:   the iovec.
  *      @iov_count: number of elements in the iovec
@@ -743,7 +743,7 @@ struct bio *bio_map_user(request_queue_t *q, struct block_device *bdev,
  *      Map the user space address into a bio suitable for io to a block
  *      device. Returns an error pointer in case of error.
  */
-struct bio *bio_map_user_iov(request_queue_t *q, struct block_device *bdev,
+struct bio *bio_map_user_iov(struct request_queue *q, struct block_device *bdev,
                              struct sg_iovec *iov, int iov_count,
                              int write_to_vm)
 {
@@ -808,7 +808,7 @@ static int bio_map_kern_endio(struct bio *bio, unsigned int bytes_done, int err)
 }
 
 
-static struct bio *__bio_map_kern(request_queue_t *q, void *data,
+static struct bio *__bio_map_kern(struct request_queue *q, void *data,
                                   unsigned int len, gfp_t gfp_mask)
 {
         unsigned long kaddr = (unsigned long)data;
@@ -847,7 +847,7 @@ static struct bio *__bio_map_kern(request_queue_t *q, void *data,
 
 /**
  *      bio_map_kern    -       map kernel address into bio
- *      @q: the request_queue_t for the bio
+ *      @q: the struct request_queue for the bio
  *      @data: pointer to buffer to map
  *      @len: length in bytes
  *      @gfp_mask: allocation flags for bio allocation
@@ -855,7 +855,7 @@ static struct bio *__bio_map_kern(request_queue_t *q, void *data,
  *      Map the kernel address into a bio suitable for io to a block
  *      device. Returns an error pointer in case of error.
  */
-struct bio *bio_map_kern(request_queue_t *q, void *data, unsigned int len,
+struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
                          gfp_t gfp_mask)
 {
         struct bio *bio;
diff --git a/fs/open.c b/fs/open.c
index a6b054edacb..e27c205364d 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -403,7 +403,7 @@ asmlinkage long sys_fallocate(int fd, int mode, loff_t offset, loff_t len)
         if (inode->i_op && inode->i_op->fallocate)
                 ret = inode->i_op->fallocate(inode, mode, offset, len);
         else
-                ret = -ENOSYS;
+                ret = -EOPNOTSUPP;
 
 out_fput:
         fput(file);
diff --git a/include/asm-arm/arch-omap/mailbox.h b/include/asm-arm/arch-omap/mailbox.h
index 4bf0909461f..7cbed9332e1 100644
--- a/include/asm-arm/arch-omap/mailbox.h
+++ b/include/asm-arm/arch-omap/mailbox.h
@@ -37,7 +37,7 @@ struct omap_mbox_ops {
 
 struct omap_mbox_queue {
         spinlock_t              lock;
-        request_queue_t         *queue;
+        struct request_queue    *queue;
         struct work_struct      work;
         int     (*callback)(void *);
         struct omap_mbox        *mbox;
diff --git a/include/asm-xtensa/io.h b/include/asm-xtensa/io.h
index 31ffc3f119c..0faa614d969 100644
--- a/include/asm-xtensa/io.h
+++ b/include/asm-xtensa/io.h
@@ -13,6 +13,7 @@
 
 #ifdef __KERNEL__
 #include <asm/byteorder.h>
+#include <asm/page.h>
 
 #include <linux/types.h>
 
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 695e34964cb..a1c96d9ee72 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -37,7 +37,7 @@
 struct scsi_ioctl_command;
 
 struct request_queue;
-typedef struct request_queue request_queue_t;
+typedef struct request_queue request_queue_t __deprecated;
 struct elevator_queue;
 typedef struct elevator_queue elevator_t;
 struct request_pm_state;
@@ -233,7 +233,7 @@ struct request {
         struct list_head queuelist;
         struct list_head donelist;
 
-        request_queue_t *q;
+        struct request_queue *q;
 
         unsigned int cmd_flags;
         enum rq_cmd_type_bits cmd_type;
@@ -337,15 +337,15 @@ struct request_pm_state
 
 #include <linux/elevator.h>
 
-typedef void (request_fn_proc) (request_queue_t *q);
-typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);
-typedef int (prep_rq_fn) (request_queue_t *, struct request *);
-typedef void (unplug_fn) (request_queue_t *);
+typedef void (request_fn_proc) (struct request_queue *q);
+typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
+typedef int (prep_rq_fn) (struct request_queue *, struct request *);
+typedef void (unplug_fn) (struct request_queue *);
 
 struct bio_vec;
-typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);
-typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);
-typedef void (prepare_flush_fn) (request_queue_t *, struct request *);
+typedef int (merge_bvec_fn) (struct request_queue *, struct bio *, struct bio_vec *);
+typedef int (issue_flush_fn) (struct request_queue *, struct gendisk *, sector_t *);
+typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
 typedef void (softirq_done_fn)(struct request *);
 
 enum blk_queue_state {
@@ -626,13 +626,13 @@ extern unsigned long blk_max_low_pfn, blk_max_pfn;
 
 #ifdef CONFIG_BOUNCE
 extern int init_emergency_isa_pool(void);
-extern void blk_queue_bounce(request_queue_t *q, struct bio **bio);
+extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
 #else
 static inline int init_emergency_isa_pool(void)
 {
         return 0;
 }
-static inline void blk_queue_bounce(request_queue_t *q, struct bio **bio)
+static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
 {
 }
 #endif /* CONFIG_MMU */
@@ -646,14 +646,14 @@ extern void blk_unregister_queue(struct gendisk *disk);
 extern void register_disk(struct gendisk *dev);
 extern void generic_make_request(struct bio *bio);
 extern void blk_put_request(struct request *);
-extern void __blk_put_request(request_queue_t *, struct request *);
+extern void __blk_put_request(struct request_queue *, struct request *);
 extern void blk_end_sync_rq(struct request *rq, int error);
-extern struct request *blk_get_request(request_queue_t *, int, gfp_t);
-extern void blk_insert_request(request_queue_t *, struct request *, int, void *);
-extern void blk_requeue_request(request_queue_t *, struct request *);
-extern void blk_plug_device(request_queue_t *);
-extern int blk_remove_plug(request_queue_t *);
-extern void blk_recount_segments(request_queue_t *, struct bio *);
+extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
+extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
+extern void blk_requeue_request(struct request_queue *, struct request *);
+extern void blk_plug_device(struct request_queue *);
+extern int blk_remove_plug(struct request_queue *);
+extern void blk_recount_segments(struct request_queue *, struct bio *);
 extern int scsi_cmd_ioctl(struct file *, struct request_queue *,
                           struct gendisk *, unsigned int, void __user *);
 extern int sg_scsi_ioctl(struct file *, struct request_queue *,
@@ -662,14 +662,15 @@ extern int sg_scsi_ioctl(struct file *, struct request_queue *,
 /*
  * Temporary export, until SCSI gets fixed up.
  */
-extern int ll_back_merge_fn(request_queue_t *, struct request *, struct bio *);
+extern int ll_back_merge_fn(struct request_queue *, struct request *,
+                struct bio *);
 
 /*
  * A queue has just exitted congestion.  Note this in the global counter of
  * congested queues, and wake up anyone who was waiting for requests to be
  * put back.
  */
-static inline void blk_clear_queue_congested(request_queue_t *q, int rw)
+static inline void blk_clear_queue_congested(struct request_queue *q, int rw)
 {
         clear_bdi_congested(&q->backing_dev_info, rw);
 }
@@ -678,29 +679,29 @@ static inline void blk_clear_queue_congested(request_queue_t *q, int rw)
  * A queue has just entered congestion.  Flag that in the queue's VM-visible
  * state flags and increment the global gounter of congested queues.
  */
-static inline void blk_set_queue_congested(request_queue_t *q, int rw)
+static inline void blk_set_queue_congested(struct request_queue *q, int rw)
 {
         set_bdi_congested(&q->backing_dev_info, rw);
 }
 
-extern void blk_start_queue(request_queue_t *q);
-extern void blk_stop_queue(request_queue_t *q);
+extern void blk_start_queue(struct request_queue *q);
+extern void blk_stop_queue(struct request_queue *q);
 extern void blk_sync_queue(struct request_queue *q);
-extern void __blk_stop_queue(request_queue_t *q);
-extern void blk_run_queue(request_queue_t *);
-extern void blk_start_queueing(request_queue_t *);
-extern int blk_rq_map_user(request_queue_t *, struct request *, void __user *, unsigned long);
+extern void __blk_stop_queue(struct request_queue *q);
+extern void blk_run_queue(struct request_queue *);
+extern void blk_start_queueing(struct request_queue *);
+extern int blk_rq_map_user(struct request_queue *, struct request *, void __user *, unsigned long);
 extern int blk_rq_unmap_user(struct bio *);
-extern int blk_rq_map_kern(request_queue_t *, struct request *, void *, unsigned int, gfp_t);
-extern int blk_rq_map_user_iov(request_queue_t *, struct request *,
+extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
+extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
                                struct sg_iovec *, int, unsigned int);
-extern int blk_execute_rq(request_queue_t *, struct gendisk *,
+extern int blk_execute_rq(struct request_queue *, struct gendisk *,
                           struct request *, int);
-extern void blk_execute_rq_nowait(request_queue_t *, struct gendisk *,
+extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
                                   struct request *, int, rq_end_io_fn *);
 extern int blk_verify_command(unsigned char *, int);
 
-static inline request_queue_t *bdev_get_queue(struct block_device *bdev)
+static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 {
         return bdev->bd_disk->queue;
 }
@@ -749,41 +750,41 @@ static inline void blkdev_dequeue_request(struct request *req)
 /*
  * Access functions for manipulating queue properties
  */
-extern request_queue_t *blk_init_queue_node(request_fn_proc *rfn,
+extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
                                         spinlock_t *lock, int node_id);
-extern request_queue_t *blk_init_queue(request_fn_proc *, spinlock_t *);
-extern void blk_cleanup_queue(request_queue_t *);
-extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
-extern void blk_queue_bounce_limit(request_queue_t *, u64);
-extern void blk_queue_max_sectors(request_queue_t *, unsigned int);
-extern void blk_queue_max_phys_segments(request_queue_t *, unsigned short);
-extern void blk_queue_max_hw_segments(request_queue_t *, unsigned short);
-extern void blk_queue_max_segment_size(request_queue_t *, unsigned int);
-extern void blk_queue_hardsect_size(request_queue_t *, unsigned short);
-extern void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b);
-extern void blk_queue_segment_boundary(request_queue_t *, unsigned long);
-extern void blk_queue_prep_rq(request_queue_t *, prep_rq_fn *pfn);
-extern void blk_queue_merge_bvec(request_queue_t *, merge_bvec_fn *);
-extern void blk_queue_dma_alignment(request_queue_t *, int);
-extern void blk_queue_softirq_done(request_queue_t *, softirq_done_fn *);
+extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
+extern void blk_cleanup_queue(struct request_queue *);
+extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
+extern void blk_queue_bounce_limit(struct request_queue *, u64);
+extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
+extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
+extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
+extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
+extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
+extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
+extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
+extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
+extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
+extern void blk_queue_dma_alignment(struct request_queue *, int);
+extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
-extern int blk_queue_ordered(request_queue_t *, unsigned, prepare_flush_fn *);
-extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
-extern int blk_do_ordered(request_queue_t *, struct request **);
-extern unsigned blk_ordered_cur_seq(request_queue_t *);
+extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
+extern void blk_queue_issue_flush_fn(struct request_queue *, issue_flush_fn *);
+extern int blk_do_ordered(struct request_queue *, struct request **);
+extern unsigned blk_ordered_cur_seq(struct request_queue *);
 extern unsigned blk_ordered_req_seq(struct request *);
-extern void blk_ordered_complete_seq(request_queue_t *, unsigned, int);
+extern void blk_ordered_complete_seq(struct request_queue *, unsigned, int);
 
-extern int blk_rq_map_sg(request_queue_t *, struct request *, struct scatterlist *);
+extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
 extern void blk_dump_rq_flags(struct request *, char *);
-extern void generic_unplug_device(request_queue_t *);
-extern void __generic_unplug_device(request_queue_t *);
+extern void generic_unplug_device(struct request_queue *);
+extern void __generic_unplug_device(struct request_queue *);
 extern long nr_blockdev_pages(void);
 
-int blk_get_queue(request_queue_t *);
-request_queue_t *blk_alloc_queue(gfp_t);
-request_queue_t *blk_alloc_queue_node(gfp_t, int);
-extern void blk_put_queue(request_queue_t *);
+int blk_get_queue(struct request_queue *);
+struct request_queue *blk_alloc_queue(gfp_t);
+struct request_queue *blk_alloc_queue_node(gfp_t, int);
+extern void blk_put_queue(struct request_queue *);
 
 /*
  * tag stuff
@@ -791,13 +792,13 @@ extern void blk_put_queue(request_queue_t *);
 #define blk_queue_tag_depth(q)          ((q)->queue_tags->busy)
 #define blk_queue_tag_queue(q)          ((q)->queue_tags->busy < (q)->queue_tags->max_depth)
 #define blk_rq_tagged(rq)               ((rq)->cmd_flags & REQ_QUEUED)
-extern int blk_queue_start_tag(request_queue_t *, struct request *);
-extern struct request *blk_queue_find_tag(request_queue_t *, int);
-extern void blk_queue_end_tag(request_queue_t *, struct request *);
-extern int blk_queue_init_tags(request_queue_t *, int, struct blk_queue_tag *);
-extern void blk_queue_free_tags(request_queue_t *);
-extern int blk_queue_resize_tags(request_queue_t *, int);
-extern void blk_queue_invalidate_tags(request_queue_t *);
+extern int blk_queue_start_tag(struct request_queue *, struct request *);
+extern struct request *blk_queue_find_tag(struct request_queue *, int);
+extern void blk_queue_end_tag(struct request_queue *, struct request *);
+extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
+extern void blk_queue_free_tags(struct request_queue *);
+extern int blk_queue_resize_tags(struct request_queue *, int);
+extern void blk_queue_invalidate_tags(struct request_queue *);
 extern struct blk_queue_tag *blk_init_tags(int);
 extern void blk_free_tags(struct blk_queue_tag *);
 
@@ -809,7 +810,7 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
         return bqt->tag_index[tag];
 }
 
-extern void blk_rq_bio_prep(request_queue_t *, struct request *, struct bio *);
+extern void blk_rq_bio_prep(struct request_queue *, struct request *, struct bio *);
 extern int blkdev_issue_flush(struct block_device *, sector_t *);
 
 #define MAX_PHYS_SEGMENTS 128
@@ -821,7 +822,7 @@ extern int blkdev_issue_flush(struct block_device *, sector_t *);
 
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
 
-static inline int queue_hardsect_size(request_queue_t *q)
+static inline int queue_hardsect_size(struct request_queue *q)
 {
         int retval = 512;
 
@@ -836,7 +837,7 @@ static inline int bdev_hardsect_size(struct block_device *bdev)
         return queue_hardsect_size(bdev_get_queue(bdev));
 }
 
-static inline int queue_dma_alignment(request_queue_t *q)
+static inline int queue_dma_alignment(struct request_queue *q)
 {
         int retval = 511;
 
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 3680ff9a30e..90874a5d7d7 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -144,7 +144,7 @@ struct blk_user_trace_setup {
 
 #if defined(CONFIG_BLK_DEV_IO_TRACE)
 extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
-extern void blk_trace_shutdown(request_queue_t *);
+extern void blk_trace_shutdown(struct request_queue *);
 extern void __blk_add_trace(struct blk_trace *, sector_t, int, int, u32, int, int, void *);
 
 /**
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index e88fcbc77f8..e8f42133a61 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -5,29 +5,29 @@
 
 #ifdef CONFIG_BLOCK
 
-typedef int (elevator_merge_fn) (request_queue_t *, struct request **,
+typedef int (elevator_merge_fn) (struct request_queue *, struct request **,
                                  struct bio *);
 
-typedef void (elevator_merge_req_fn) (request_queue_t *, struct request *, struct request *);
+typedef void (elevator_merge_req_fn) (struct request_queue *, struct request *, struct request *);
 
-typedef void (elevator_merged_fn) (request_queue_t *, struct request *, int);
+typedef void (elevator_merged_fn) (struct request_queue *, struct request *, int);
 
-typedef int (elevator_allow_merge_fn) (request_queue_t *, struct request *, struct bio *);
+typedef int (elevator_allow_merge_fn) (struct request_queue *, struct request *, struct bio *);
 
-typedef int (elevator_dispatch_fn) (request_queue_t *, int);
+typedef int (elevator_dispatch_fn) (struct request_queue *, int);
 
-typedef void (elevator_add_req_fn) (request_queue_t *, struct request *);
-typedef int (elevator_queue_empty_fn) (request_queue_t *);
-typedef struct request *(elevator_request_list_fn) (request_queue_t *, struct request *);
-typedef void (elevator_completed_req_fn) (request_queue_t *, struct request *);
-typedef int (elevator_may_queue_fn) (request_queue_t *, int);
+typedef void (elevator_add_req_fn) (struct request_queue *, struct request *);
+typedef int (elevator_queue_empty_fn) (struct request_queue *);
+typedef struct request *(elevator_request_list_fn) (struct request_queue *, struct request *);
+typedef void (elevator_completed_req_fn) (struct request_queue *, struct request *);
+typedef int (elevator_may_queue_fn) (struct request_queue *, int);
 
-typedef int (elevator_set_req_fn) (request_queue_t *, struct request *, gfp_t);
+typedef int (elevator_set_req_fn) (struct request_queue *, struct request *, gfp_t);
 typedef void (elevator_put_req_fn) (struct request *);
-typedef void (elevator_activate_req_fn) (request_queue_t *, struct request *);
-typedef void (elevator_deactivate_req_fn) (request_queue_t *, struct request *);
+typedef void (elevator_activate_req_fn) (struct request_queue *, struct request *);
+typedef void (elevator_deactivate_req_fn) (struct request_queue *, struct request *);
 
-typedef void *(elevator_init_fn) (request_queue_t *);
+typedef void *(elevator_init_fn) (struct request_queue *);
 typedef void (elevator_exit_fn) (elevator_t *);
 
 struct elevator_ops
@@ -94,27 +94,27 @@ struct elevator_queue
 /*
  * block elevator interface
  */
-extern void elv_dispatch_sort(request_queue_t *, struct request *);
-extern void elv_dispatch_add_tail(request_queue_t *, struct request *);
-extern void elv_add_request(request_queue_t *, struct request *, int, int);
-extern void __elv_add_request(request_queue_t *, struct request *, int, int);
-extern void elv_insert(request_queue_t *, struct request *, int);
-extern int elv_merge(request_queue_t *, struct request **, struct bio *);
-extern void elv_merge_requests(request_queue_t *, struct request *,
+extern void elv_dispatch_sort(struct request_queue *, struct request *);
+extern void elv_dispatch_add_tail(struct request_queue *, struct request *);
+extern void elv_add_request(struct request_queue *, struct request *, int, int);
+extern void __elv_add_request(struct request_queue *, struct request *, int, int);
+extern void elv_insert(struct request_queue *, struct request *, int);
+extern int elv_merge(struct request_queue *, struct request **, struct bio *);
+extern void elv_merge_requests(struct request_queue *, struct request *,
                                struct request *);
-extern void elv_merged_request(request_queue_t *, struct request *, int);
-extern void elv_dequeue_request(request_queue_t *, struct request *);
-extern void elv_requeue_request(request_queue_t *, struct request *);
-extern int elv_queue_empty(request_queue_t *);
+extern void elv_merged_request(struct request_queue *, struct request *, int);
+extern void elv_dequeue_request(struct request_queue *, struct request *);
+extern void elv_requeue_request(struct request_queue *, struct request *);
+extern int elv_queue_empty(struct request_queue *);
 extern struct request *elv_next_request(struct request_queue *q);
-extern struct request *elv_former_request(request_queue_t *, struct request *);
-extern struct request *elv_latter_request(request_queue_t *, struct request *);
-extern int elv_register_queue(request_queue_t *q);
-extern void elv_unregister_queue(request_queue_t *q);
-extern int elv_may_queue(request_queue_t *, int);
-extern void elv_completed_request(request_queue_t *, struct request *);
-extern int elv_set_request(request_queue_t *, struct request *, gfp_t);
-extern void elv_put_request(request_queue_t *, struct request *);
+extern struct request *elv_former_request(struct request_queue *, struct request *);
+extern struct request *elv_latter_request(struct request_queue *, struct request *);
+extern int elv_register_queue(struct request_queue *q);
+extern void elv_unregister_queue(struct request_queue *q);
+extern int elv_may_queue(struct request_queue *, int);
+extern void elv_completed_request(struct request_queue *, struct request *);
+extern int elv_set_request(struct request_queue *, struct request *, gfp_t);
+extern void elv_put_request(struct request_queue *, struct request *);
 
 /*
  * io scheduler registration
@@ -125,18 +125,18 @@ extern void elv_unregister(struct elevator_type *);
 /*
  * io scheduler sysfs switching
  */
-extern ssize_t elv_iosched_show(request_queue_t *, char *);
-extern ssize_t elv_iosched_store(request_queue_t *, const char *, size_t);
+extern ssize_t elv_iosched_show(struct request_queue *, char *);
+extern ssize_t elv_iosched_store(struct request_queue *, const char *, size_t);
 
-extern int elevator_init(request_queue_t *, char *);
+extern int elevator_init(struct request_queue *, char *);
 extern void elevator_exit(elevator_t *);
 extern int elv_rq_merge_ok(struct request *, struct bio *);
 
 /*
  * Helper functions.
  */
-extern struct request *elv_rb_former_request(request_queue_t *, struct request *);
-extern struct request *elv_rb_latter_request(request_queue_t *, struct request *);
+extern struct request *elv_rb_former_request(struct request_queue *, struct request *);
+extern struct request *elv_rb_latter_request(struct request_queue *, struct request *);
 
 /*
  * rb support functions.
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 5f5daad8bc5..d71d0121b7f 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -555,7 +555,7 @@ typedef struct ide_drive_s {
         char            name[4];        /* drive name, such as "hda" */
         char            driver_req[10]; /* requests specific driver */
 
-        request_queue_t         *queue; /* request queue */
+        struct request_queue    *queue; /* request queue */
 
         struct request          *rq;    /* current request */
         struct ide_drive_s      *next;  /* circular list of hwgroup drives */
@@ -1206,7 +1206,7 @@ extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout);
 extern int ide_spin_wait_hwgroup(ide_drive_t *);
 extern void ide_timer_expiry(unsigned long);
 extern irqreturn_t ide_intr(int irq, void *dev_id);
-extern void do_ide_request(request_queue_t *);
+extern void do_ide_request(struct request_queue *);
 
 void ide_init_disk(struct gendisk *, ide_drive_t *);
 
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 0b99b31f017..26a0a103898 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -63,7 +63,7 @@ struct loop_device {
         struct task_struct      *lo_thread;
         wait_queue_head_t       lo_event;
 
-        request_queue_t         *lo_queue;
+        struct request_queue    *lo_queue;
         struct gendisk          *lo_disk;
         struct list_head        lo_list;
 };
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index cbabb9c675c..42d3278c6b5 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1225,6 +1225,10 @@
 #define PCI_DEVICE_ID_NVIDIA_NVENET_25              0x054D
 #define PCI_DEVICE_ID_NVIDIA_NVENET_26              0x054E
 #define PCI_DEVICE_ID_NVIDIA_NVENET_27              0x054F
+#define PCI_DEVICE_ID_NVIDIA_NVENET_28              0x07DC
+#define PCI_DEVICE_ID_NVIDIA_NVENET_29              0x07DD
+#define PCI_DEVICE_ID_NVIDIA_NVENET_30              0x07DE
+#define PCI_DEVICE_ID_NVIDIA_NVENET_31              0x07DF
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE       0x0560
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE       0x056C
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE       0x0759
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index 28ac632b42d..dcb729244f4 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -227,7 +227,7 @@ struct mddev_s
         unsigned int                    safemode_delay;
         struct timer_list               safemode_timer;
         atomic_t                        writes_pending; 
-        request_queue_t                 *queue; /* for plugging ... */
+        struct request_queue            *queue; /* for plugging ... */
 
         atomic_t                        write_behind; /* outstanding async IO */
         unsigned int                    max_write_behind; /* 0 = sync */
@@ -265,7 +265,7 @@ struct mdk_personality
         int level;
         struct list_head list;
         struct module *owner;
-        int (*make_request)(request_queue_t *q, struct bio *bio);
+        int (*make_request)(struct request_queue *q, struct bio *bio);
         int (*run)(mddev_t *mddev);
         int (*stop)(mddev_t *mddev);
         void (*status)(struct seq_file *seq, mddev_t *mddev);
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 8518fa2a6f8..afe0f6d9b9b 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -20,7 +20,7 @@
 struct plat_serial8250_port {
         unsigned long   iobase;         /* io base address */
         void __iomem    *membase;       /* ioremap cookie or NULL */
-        unsigned long   mapbase;        /* resource base */
+        resource_size_t mapbase;        /* resource base */
         unsigned int    irq;            /* interrupt number */
         unsigned int    uartclk;        /* UART clock rate */
         unsigned char   regshift;       /* register shift */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 773d8d8828a..09d17b06bf0 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -288,7 +288,7 @@ struct uart_port {
         const struct uart_ops   *ops;
         unsigned int            custom_divisor;
         unsigned int            line;                   /* port index */
-        unsigned long           mapbase;                /* for ioremap */
+        resource_size_t         mapbase;                /* for ioremap */
         struct device           *dev;                   /* parent device */
         unsigned char           hub6;                   /* this should be in the 8250 driver */
         unsigned char           unused[3];
diff --git a/include/scsi/sd.h b/include/scsi/sd.h
index 5261488e110..78583fee0ab 100644
--- a/include/scsi/sd.h
+++ b/include/scsi/sd.h
@@ -57,7 +57,7 @@ static int sd_resume(struct device *dev);
 static void sd_rescan(struct device *);
 static int  sd_init_command(struct scsi_cmnd *);
 static int  sd_issue_flush(struct device *, sector_t *);
-static void sd_prepare_flush(request_queue_t *, struct request *);
+static void sd_prepare_flush(struct request_queue *, struct request *);
 static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
 static void scsi_disk_release(struct class_device *cdev);
 static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index b18fc2ff9ff..23985a278bb 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -139,12 +139,14 @@ static void debugfs_ul_set(void *data, u64 val)
         *(unsigned long *)data = val;
 }
 
+#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
 static void debugfs_ul_set_MAX_STACK_TRACE_DEPTH(void *data, u64 val)
 {
         *(unsigned long *)data =
                 val < MAX_STACK_TRACE_DEPTH ?
                 val : MAX_STACK_TRACE_DEPTH;
 }
+#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
 
 static u64 debugfs_ul_get(void *data)
 {
@@ -159,6 +161,7 @@ static struct dentry *debugfs_create_ul(const char *name, mode_t mode,
         return debugfs_create_file(name, mode, parent, value, &fops_ul);
 }
 
+#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
 DEFINE_SIMPLE_ATTRIBUTE(fops_ul_MAX_STACK_TRACE_DEPTH, debugfs_ul_get,
                         debugfs_ul_set_MAX_STACK_TRACE_DEPTH, "%llu\n");
 
@@ -169,6 +172,7 @@ static struct dentry *debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
         return debugfs_create_file(name, mode, parent, value,
                                    &fops_ul_MAX_STACK_TRACE_DEPTH);
 }
+#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
 
 static void debugfs_atomic_t_set(void *data, u64 val)
 {
diff --git a/mm/bounce.c b/mm/bounce.c
index ad401fc5744..179fe38a241 100644
--- a/mm/bounce.c
+++ b/mm/bounce.c
@@ -190,7 +190,7 @@ static int bounce_end_io_read_isa(struct bio *bio, unsigned int bytes_done, int
         return 0;
 }
 
-static void __blk_queue_bounce(request_queue_t *q, struct bio **bio_orig,
+static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
                                mempool_t *pool)
 {
         struct page *page;
@@ -275,7 +275,7 @@ static void __blk_queue_bounce(request_queue_t *q, struct bio **bio_orig,
         *bio_orig = bio;
 }
 
-void blk_queue_bounce(request_queue_t *q, struct bio **bio_orig)
+void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
 {
         mempool_t *pool;
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index f127940ec24..d7ca59d66c5 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -84,6 +84,7 @@ static struct page *dequeue_huge_page(struct vm_area_struct *vma,
                         list_del(&page->lru);
                         free_huge_pages--;
                         free_huge_pages_node[nid]--;
+                        break;
                 }
         }
         return page;
diff --git a/mm/slab.c b/mm/slab.c
index bde271c001b..a684778b2b4 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -2776,7 +2776,7 @@ static int cache_grow(struct kmem_cache *cachep,
          * 'nodeid'.
          */
         if (!objp)
-                objp = kmem_getpages(cachep, flags, nodeid);
+                objp = kmem_getpages(cachep, local_flags, nodeid);
         if (!objp)
                 goto failed;
 
diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c
index cda936b77d2..1583c5ef963 100644
--- a/net/8021q/vlan.c
+++ b/net/8021q/vlan.c
@@ -810,6 +810,7 @@ static int vlan_ioctl_handler(void __user *arg)
                 err = -EINVAL;
                 break;
         case GET_VLAN_REALDEV_NAME_CMD:
+                err = 0;
                 vlan_dev_get_realdev_name(dev, args.u.device2);
                 if (copy_to_user(arg, &args,
                                  sizeof(struct vlan_ioctl_args))) {
@@ -818,6 +819,7 @@ static int vlan_ioctl_handler(void __user *arg)
                 break;
 
         case GET_VLAN_VID_CMD:
+                err = 0;
                 vlan_dev_get_vid(dev, &vid);
                 args.u.VID = vid;
                 if (copy_to_user(arg, &args,
diff --git a/net/bridge/netfilter/ebt_log.c b/net/bridge/netfilter/ebt_log.c
index 031bfa4a51f..457815fb558 100644
--- a/net/bridge/netfilter/ebt_log.c
+++ b/net/bridge/netfilter/ebt_log.c
@@ -9,7 +9,6 @@
  *
  */
 
-#include <linux/in.h>
 #include <linux/netfilter_bridge/ebtables.h>
 #include <linux/netfilter_bridge/ebt_log.h>
 #include <linux/netfilter.h>
@@ -196,10 +195,8 @@ static int __init ebt_log_init(void)
         ret = ebt_register_watcher(&log);
         if (ret < 0)
                 return ret;
-        ret = nf_log_register(PF_BRIDGE, &ebt_log_logger);
-        if (ret < 0 && ret != -EEXIST)
-                ebt_unregister_watcher(&log);
-        return ret;
+        nf_log_register(PF_BRIDGE, &ebt_log_logger);
+        return 0;
 }
 
 static void __exit ebt_log_fini(void)
diff --git a/net/bridge/netfilter/ebt_ulog.c b/net/bridge/netfilter/ebt_ulog.c
index 9411db62591..204c968fa86 100644
--- a/net/bridge/netfilter/ebt_ulog.c
+++ b/net/bridge/netfilter/ebt_ulog.c
@@ -36,7 +36,6 @@
 #include <linux/timer.h>
 #include <linux/netlink.h>
 #include <linux/netdevice.h>
-#include <linux/module.h>
 #include <linux/netfilter_bridge/ebtables.h>
 #include <linux/netfilter_bridge/ebt_ulog.h>
 #include <net/sock.h>
@@ -308,12 +307,8 @@ static int __init ebt_ulog_init(void)
         else if ((ret = ebt_register_watcher(&ulog)))
                 sock_release(ebtulognl->sk_socket);
 
-        if (nf_log_register(PF_BRIDGE, &ebt_ulog_logger) < 0) {
-                printk(KERN_WARNING "ebt_ulog: not logging via ulog "
-                       "since somebody else already registered for PF_BRIDGE\n");
-                /* we cannot make module load fail here, since otherwise
-                 * ebtables userspace would abort */
-        }
+        if (ret == 0)
+                nf_log_register(PF_BRIDGE, &ebt_ulog_logger);
 
         return ret;
 }
diff --git a/net/ipv4/netfilter/ipt_LOG.c b/net/ipv4/netfilter/ipt_LOG.c
index 5937ad150b9..127a5e89bf1 100644
--- a/net/ipv4/netfilter/ipt_LOG.c
+++ b/net/ipv4/netfilter/ipt_LOG.c
@@ -479,10 +479,8 @@ static int __init ipt_log_init(void)
         ret = xt_register_target(&ipt_log_reg);
         if (ret < 0)
                 return ret;
-        ret = nf_log_register(PF_INET, &ipt_log_logger);
-        if (ret < 0 && ret != -EEXIST)
-                xt_unregister_target(&ipt_log_reg);
-        return ret;
+        nf_log_register(PF_INET, &ipt_log_logger);
+        return 0;
 }
 
 static void __exit ipt_log_fini(void)
diff --git a/net/ipv6/netfilter/ip6t_LOG.c b/net/ipv6/netfilter/ip6t_LOG.c
index b05327ebd33..6ab99001dcc 100644
--- a/net/ipv6/netfilter/ip6t_LOG.c
+++ b/net/ipv6/netfilter/ip6t_LOG.c
@@ -493,10 +493,8 @@ static int __init ip6t_log_init(void)
         ret = xt_register_target(&ip6t_log_reg);
         if (ret < 0)
                 return ret;
-        ret = nf_log_register(PF_INET6, &ip6t_logger);
-        if (ret < 0 && ret != -EEXIST)
-                xt_unregister_target(&ip6t_log_reg);
-        return ret;
+        nf_log_register(PF_INET6, &ip6t_logger);
+        return 0;
 }
 
 static void __exit ip6t_log_fini(void)
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index d67fb1ef751..f10f3689d67 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -633,6 +633,7 @@ static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
                         if (tp->md5sig_info->entries6 == 0) {
                                 kfree(tp->md5sig_info->keys6);
                                 tp->md5sig_info->keys6 = NULL;
+                                tp->md5sig_info->alloced6 = 0;
 
                                 tcp_free_md5sig_pool();
 
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index 87ad3ccf8af..eb3fe740146 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -8,7 +8,6 @@
 
 #include <linux/types.h>
 #include <linux/timer.h>
-#include <linux/netfilter.h>
 #include <linux/module.h>
 #include <linux/in.h>
 #include <linux/tcp.h>
diff --git a/net/netfilter/nf_conntrack_proto_udp.c b/net/netfilter/nf_conntrack_proto_udp.c
index 13d94a02572..2a2fd1a764e 100644
--- a/net/netfilter/nf_conntrack_proto_udp.c
+++ b/net/netfilter/nf_conntrack_proto_udp.c
@@ -9,7 +9,6 @@
 #include <linux/types.h>
 #include <linux/timer.h>
 #include <linux/module.h>
-#include <linux/netfilter.h>
 #include <linux/udp.h>
 #include <linux/seq_file.h>
 #include <linux/skbuff.h>
diff --git a/net/netfilter/nf_conntrack_proto_udplite.c b/net/netfilter/nf_conntrack_proto_udplite.c
index 93e747b5396..b906b413997 100644
--- a/net/netfilter/nf_conntrack_proto_udplite.c
+++ b/net/netfilter/nf_conntrack_proto_udplite.c
@@ -10,7 +10,6 @@
 #include <linux/types.h>
 #include <linux/timer.h>
 #include <linux/module.h>
-#include <linux/netfilter.h>
 #include <linux/udp.h>
 #include <linux/seq_file.h>
 #include <linux/skbuff.h>
diff --git a/net/netfilter/xt_physdev.c b/net/netfilter/xt_physdev.c
index f47cab7a696..a4bab043a6d 100644
--- a/net/netfilter/xt_physdev.c
+++ b/net/netfilter/xt_physdev.c
@@ -13,7 +13,6 @@
 #include <linux/netfilter_bridge.h>
 #include <linux/netfilter/xt_physdev.h>
 #include <linux/netfilter/x_tables.h>
-#include <linux/netfilter_bridge.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Bart De Schuymer <bdschuym@pandora.be>");
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index e146531faf1..8c11ca4a212 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -184,7 +184,7 @@ int genl_register_mc_group(struct genl_family *family,
         }
 
         err = netlink_change_ngroups(genl_sock,
-                                     sizeof(unsigned long) * NETLINK_GENERIC);
+                                     mc_groups_longs * BITS_PER_LONG);
         if (err)
                 goto out;
 
@@ -196,10 +196,22 @@ int genl_register_mc_group(struct genl_family *family,
         genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp);
  out:
         genl_unlock();
-        return 0;
+        return err;
 }
 EXPORT_SYMBOL(genl_register_mc_group);
 
+static void __genl_unregister_mc_group(struct genl_family *family,
+                                       struct genl_multicast_group *grp)
+{
+        BUG_ON(grp->family != family);
+        netlink_clear_multicast_users(genl_sock, grp->id);
+        clear_bit(grp->id, mc_groups);
+        list_del(&grp->list);
+        genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
+        grp->id = 0;
+        grp->family = NULL;
+}
+
 /**
  * genl_unregister_mc_group - unregister a multicast group
  *
@@ -217,14 +229,8 @@ EXPORT_SYMBOL(genl_register_mc_group);
 void genl_unregister_mc_group(struct genl_family *family,
                               struct genl_multicast_group *grp)
 {
-        BUG_ON(grp->family != family);
         genl_lock();
-        netlink_clear_multicast_users(genl_sock, grp->id);
-        clear_bit(grp->id, mc_groups);
-        list_del(&grp->list);
-        genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
-        grp->id = 0;
-        grp->family = NULL;
+        __genl_unregister_mc_group(family, grp);
         genl_unlock();
 }
 
@@ -232,8 +238,10 @@ static void genl_unregister_mc_groups(struct genl_family *family)
 {
         struct genl_multicast_group *grp, *tmp;
 
+        genl_lock();
         list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list)
-                genl_unregister_mc_group(family, grp);
+                __genl_unregister_mc_group(family, grp);
+        genl_unlock();
 }
 
 /**
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 490697542fc..dc2f41e9f57 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -769,11 +769,12 @@ svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name)
         new->h.flavour = &svcauthops_gss;
         new->pseudoflavor = pseudoflavor;
 
+        stat = 0;
         test = auth_domain_lookup(name, &new->h);
-        if (test != &new->h) { /* XXX Duplicate registration? */
-                auth_domain_put(&new->h);
-                /* dangling ref-count... */
-                goto out;
+        if (test != &new->h) { /* Duplicate registration */
+                auth_domain_put(test);
+                kfree(new->h.name);
+                goto out_free_dom;
         }
         return 0;
 
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index b5f017f07a7..0ae032f3876 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -2417,8 +2417,10 @@ static void security_netlbl_cache_add(struct netlbl_lsm_secattr *secattr,
 
         cache->type = NETLBL_CACHE_T_MLS;
         if (ebitmap_cpy(&cache->data.mls_label.level[0].cat,
-                        &ctx->range.level[0].cat) != 0)
+                        &ctx->range.level[0].cat) != 0) {
+                kfree(cache);
                 return;
+        }
         cache->data.mls_label.level[1].cat.highbit =
                 cache->data.mls_label.level[0].cat.highbit;
         cache->data.mls_label.level[1].cat.node =