135 files changed, 2682 insertions, 2201 deletions
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 4cc619edf424..bde1c665d9f4 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -1006,6 +1006,7 @@ config GPIO_VR41XX
 config RAW_DRIVER
        tristate "RAW driver (/dev/raw/rawN) (OBSOLETE)"
+        depends on BLOCK
        help
          The raw driver permits block devices to be bound to /dev/raw/rawN. 
          Once bound, I/O against /dev/raw/rawN uses efficient zero-copy I/O. 
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 8cd52984cda5..00b17ae39736 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -409,7 +409,7 @@ static int __devinit uli_agp_init(struct pci_dev *pdev)
        int i;
        unsigned size = amd64_fetch_size();
        printk(KERN_INFO "Setting up ULi AGP.\n");
-        dev1 = pci_find_slot ((unsigned int)pdev->bus->number,PCI_DEVFN(0,0));
+        dev1 = pci_get_slot (pdev->bus,PCI_DEVFN(0,0));
        if (dev1 == NULL) {
                printk(KERN_INFO PFX "Detected a ULi chipset, "
                        "but could not fine the secondary device.\n");
@@ -442,6 +442,8 @@ static int __devinit uli_agp_init(struct pci_dev *pdev)
        enuscr= httfea+ (size * 1024 * 1024) - 1;
        pci_write_config_dword(dev1, ULI_X86_64_HTT_FEA_REG, httfea);
        pci_write_config_dword(dev1, ULI_X86_64_ENU_SCR_REG, enuscr);
+        pci_dev_put(dev1);
        return 0;
 }
@@ -466,7 +468,7 @@ static int __devinit nforce3_agp_init(struct pci_dev *pdev)
        printk(KERN_INFO PFX "Setting up Nforce3 AGP.\n");
-        dev1 = pci_find_slot((unsigned int)pdev->bus->number, PCI_DEVFN(11, 0));
+        dev1 = pci_get_slot(pdev->bus, PCI_DEVFN(11, 0));
        if (dev1 == NULL) {
                printk(KERN_INFO PFX "agpgart: Detected an NVIDIA "
                        "nForce3 chipset, but could not find "
@@ -510,6 +512,8 @@ static int __devinit nforce3_agp_init(struct pci_dev *pdev)
        pci_write_config_dword(dev1, NVIDIA_X86_64_1_APBASE2, apbase);
        pci_write_config_dword(dev1, NVIDIA_X86_64_1_APLIMIT2, aplimit);
+        pci_dev_put(dev1);
        return 0;
 }
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index 0dcdb363923f..c39200161688 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -581,18 +581,21 @@ static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_
                 * If not, we fall back to x4 mode.
                 */
                if ((*bridge_agpstat & AGPSTAT3_8X) && (*vga_agpstat & AGPSTAT3_8X)) {
-                        printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode supported by bridge & card (x8).\n");
+                        printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode "
+                                "supported by bridge & card (x8).\n");
                        *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
                        *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
                } else {
                        printk(KERN_INFO PFX "Fell back to AGPx4 mode because");
                        if (!(*bridge_agpstat & AGPSTAT3_8X)) {
-                                printk("bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n", *bridge_agpstat, origbridge);
+                                printk(KERN_INFO PFX "bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n",
+                                        *bridge_agpstat, origbridge);
                                *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
                                *bridge_agpstat |= AGPSTAT3_4X;
                        }
                        if (!(*vga_agpstat & AGPSTAT3_8X)) {
-                                printk("graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n", *vga_agpstat, origvga);
+                                printk(KERN_INFO PFX "graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n",
+                                        *vga_agpstat, origvga);
                                *vga_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
                                *vga_agpstat |= AGPSTAT3_4X;
                        }
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 9d6713a93ed7..d0e92ed0a367 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -1958,7 +1958,7 @@ static void show_serial_version(void)
 }
-static struct tty_operations serial_ops = {
+static const struct tty_operations serial_ops = {
        .open = rs_open,
        .close = rs_close,
        .write = rs_write,
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index c1c67281750d..f85b4eb16618 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -5205,7 +5205,7 @@ done:
    extra ports are ignored.
 */
-static struct tty_operations cy_ops = {
+static const struct tty_operations cy_ops = {
    .open = cy_open,
    .close = cy_close,
    .write = cy_write,
diff --git a/drivers/char/drm/Kconfig b/drivers/char/drm/Kconfig
index 5278c388d3e7..ef833a1c27eb 100644
--- a/drivers/char/drm/Kconfig
+++ b/drivers/char/drm/Kconfig
@@ -60,7 +60,9 @@ config DRM_I830
          Choose this option if you have a system that has Intel 830M, 845G,
          852GM, 855GM or 865G integrated graphics.  If M is selected, the
          module will be called i830.  AGP support is required for this driver
-          to work. This driver will eventually be replaced by the i915 one.
+          to work. This driver is used by the older X releases X.org 6.7 and
+          XFree86 4.3. If unsure, build this and i915 as modules and the X server
+          will load the correct one.
 config DRM_I915
        tristate "i915 driver"
@@ -68,8 +70,9 @@ config DRM_I915
          Choose this option if you have a system that has Intel 830M, 845G,
          852GM, 855GM 865G or 915G integrated graphics.  If M is selected, the
          module will be called i915.  AGP support is required for this driver
-          to work. This driver will eventually replace the I830 driver, when
+          to work. This driver is used by the Intel driver in X.org 6.8 and
-          later release of X start to use the new DDX and DRI.
+          XFree86 4.4 and above. If unsure, build this and i830 as modules and 
+          the X server will load the correct one.
        
 endchoice
diff --git a/drivers/char/drm/Makefile b/drivers/char/drm/Makefile
index 9d180c42816c..3ad0f648c6b2 100644
--- a/drivers/char/drm/Makefile
+++ b/drivers/char/drm/Makefile
@@ -6,7 +6,7 @@ drm-objs    :=	drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \
                drm_drv.o drm_fops.o drm_ioctl.o drm_irq.o \
                drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
                drm_agpsupport.o drm_scatter.o ati_pcigart.o drm_pci.o \
-                drm_sysfs.o
+                drm_sysfs.o drm_hashtab.o drm_sman.o drm_mm.o
 tdfx-objs   := tdfx_drv.o
 r128-objs   := r128_drv.o r128_cce.o r128_state.o r128_irq.o
@@ -16,9 +16,9 @@ i830-objs   := i830_drv.o i830_dma.o i830_irq.o
 i915-objs   := i915_drv.o i915_dma.o i915_irq.o i915_mem.o
 radeon-objs := radeon_drv.o radeon_cp.o radeon_state.o radeon_mem.o radeon_irq.o r300_cmdbuf.o
 ffb-objs    := ffb_drv.o ffb_context.o
-sis-objs    := sis_drv.o sis_ds.o sis_mm.o
+sis-objs    := sis_drv.o sis_mm.o
 savage-objs := savage_drv.o savage_bci.o savage_state.o
-via-objs    := via_irq.o via_drv.o via_ds.o via_map.o via_mm.o via_dma.o via_verifier.o via_video.o via_dmablit.o
+via-objs    := via_irq.o via_drv.o via_map.o via_mm.o via_dma.o via_verifier.o via_video.o via_dmablit.o
 ifeq ($(CONFIG_COMPAT),y)
 drm-objs    += drm_ioc32.o
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index d2a56182bc35..7690a59ace04 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -79,6 +79,7 @@
 #define __OS_HAS_MTRR (defined(CONFIG_MTRR))
 #include "drm_os_linux.h"
+#include "drm_hashtab.h"
 /***********************************************************************/
 /** \name DRM template customization defaults */
@@ -104,7 +105,7 @@
 #define DRM_DEBUG_CODE 2          /**< Include debugging code if > 1, then
                                     also include looping detection. */
-#define DRM_HASH_SIZE         16 /**< Size of key hash table. Must be power of 2. */
+#define DRM_MAGIC_HASH_ORDER  4  /**< Size of key hash table. Must be power of 2. */
 #define DRM_KERNEL_CONTEXT    0  /**< Change drm_resctx if changed */
 #define DRM_RESERVED_CONTEXTS 1  /**< Change drm_resctx if changed */
 #define DRM_LOOPING_LIMIT     5000000
@@ -134,19 +135,12 @@
 #define DRM_MEM_CTXBITMAP 18
 #define DRM_MEM_STUB      19
 #define DRM_MEM_SGLISTS   20
-#define DRM_MEM_CTXLIST  21
+#define DRM_MEM_CTXLIST   21
+#define DRM_MEM_MM        22
+#define DRM_MEM_HASHTAB   23
 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
+#define DRM_MAP_HASH_OFFSET 0x10000000
-/*@}*/
-/***********************************************************************/
-/** \name Backward compatibility section */
-/*@{*/
-#define DRM_RPR_ARG(vma) vma,
-#define VM_OFFSET(vma) ((vma)->vm_pgoff << PAGE_SHIFT)
 /*@}*/
@@ -211,8 +205,6 @@
 /*@{*/
 #define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
-#define DRM_MIN(a,b) min(a,b)
-#define DRM_MAX(a,b) max(a,b)
 #define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
 #define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
@@ -286,7 +278,8 @@ typedef struct drm_devstate {
 } drm_devstate_t;
 typedef struct drm_magic_entry {
-        drm_magic_t magic;
+        drm_hash_item_t hash_item;
+        struct list_head head;
        struct drm_file *priv;
        struct drm_magic_entry *next;
 } drm_magic_entry_t;
@@ -493,6 +486,7 @@ typedef struct drm_sigdata {
 */
 typedef struct drm_map_list {
        struct list_head head;          /**< list head */
+        drm_hash_item_t hash;
        drm_map_t *map;                 /**< mapping */
        unsigned int user_token;
 } drm_map_list_t;
@@ -527,6 +521,22 @@ typedef struct ati_pcigart_info {
        drm_local_map_t mapping;
 } drm_ati_pcigart_info;
+/*
+ * Generic memory manager structs
+ */
+typedef struct drm_mm_node {
+        struct list_head fl_entry;
+        struct list_head ml_entry;
+        int free;
+        unsigned long start;
+        unsigned long size;
+        void *private;
+} drm_mm_node_t;
+typedef struct drm_mm {
+        drm_mm_node_t root_node;
+} drm_mm_t;
 /**
 * DRM driver structure. This structure represent the common code for
 * a family of cards. There will one drm_device for each card present
@@ -646,13 +656,15 @@ typedef struct drm_device {
        /*@{ */
        drm_file_t *file_first;         /**< file list head */
        drm_file_t *file_last;          /**< file list tail */
-        drm_magic_head_t magiclist[DRM_HASH_SIZE];      /**< magic hash table */
+        drm_open_hash_t magiclist;      /**< magic hash table */
+        struct list_head magicfree;
        /*@} */
        /** \name Memory management */
        /*@{ */
        drm_map_list_t *maplist;        /**< Linked list of regions */
        int map_count;                  /**< Number of mappable regions */
+        drm_open_hash_t map_hash;       /**< User token hash table for maps */
        /** \name Context handle management */
        /*@{ */
@@ -711,10 +723,8 @@ typedef struct drm_device {
        drm_agp_head_t *agp;    /**< AGP data */
        struct pci_dev *pdev;           /**< PCI device structure */
-        int pci_domain;                 /**< PCI bus domain number */
+        int pci_vendor;                 /**< PCI vendor id */
-        int pci_bus;                    /**< PCI bus number */
+        int pci_device;                 /**< PCI device id */
-        int pci_slot;                   /**< PCI slot number */
-        int pci_func;                   /**< PCI function number */
 #ifdef __alpha__
        struct pci_controller *hose;
 #endif
@@ -736,6 +746,12 @@ static __inline__ int drm_core_check_feature(struct drm_device *dev,
        return ((dev->driver->driver_features & feature) ? 1 : 0);
 }
+#ifdef __alpha__
+#define drm_get_pci_domain(dev) dev->hose->bus->number
+#else
+#define drm_get_pci_domain(dev) 0
+#endif
 #if __OS_HAS_AGP
 static inline int drm_core_has_AGP(struct drm_device *dev)
 {
@@ -1011,6 +1027,18 @@ extern struct class_device *drm_sysfs_device_add(struct class *cs,
                                                 drm_head_t *head);
 extern void drm_sysfs_device_remove(struct class_device *class_dev);
+/*
+ * Basic memory manager support (drm_mm.c)
+ */
+extern drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
+                                       unsigned long size,
+                                       unsigned alignment);
+extern void drm_mm_put_block(drm_mm_t *mm, drm_mm_node_t *cur);
+extern drm_mm_node_t *drm_mm_search_free(const drm_mm_t *mm, unsigned long size,
+                                         unsigned alignment, int best_match);
+extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size);
+extern void drm_mm_takedown(drm_mm_t *mm);
 /* Inline replacements for DRM_IOREMAP macros */
 static __inline__ void drm_core_ioremap(struct drm_map *map,
                                        struct drm_device *dev)
diff --git a/drivers/char/drm/drm_auth.c b/drivers/char/drm/drm_auth.c
index 2a37586a7ee8..c7b19d35bcd6 100644
--- a/drivers/char/drm/drm_auth.c
+++ b/drivers/char/drm/drm_auth.c
@@ -36,20 +36,6 @@
 #include "drmP.h"
 /**
- * Generate a hash key from a magic.
- *
- * \param magic magic.
- * \return hash key.
- *
- * The key is the modulus of the hash table size, #DRM_HASH_SIZE, which must be
- * a power of 2.
- */
-static int drm_hash_magic(drm_magic_t magic)
-{
-        return magic & (DRM_HASH_SIZE - 1);
-}
-/**
 * Find the file with the given magic number.
 *
 * \param dev DRM device.
@@ -63,14 +49,12 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
 {
        drm_file_t *retval = NULL;
        drm_magic_entry_t *pt;
-        int hash = drm_hash_magic(magic);
+        drm_hash_item_t *hash;
        mutex_lock(&dev->struct_mutex);
-        for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
+        if (!drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
-                if (pt->magic == magic) {
+                pt = drm_hash_entry(hash, drm_magic_entry_t, hash_item);
-                        retval = pt->priv;
+                retval = pt->priv;
-                        break;
-                }
        }
        mutex_unlock(&dev->struct_mutex);
        return retval;
@@ -90,28 +74,20 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
 static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
                         drm_magic_t magic)
 {
-        int hash;
        drm_magic_entry_t *entry;
        DRM_DEBUG("%d\n", magic);
-        hash = drm_hash_magic(magic);
        entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
        if (!entry)
                return -ENOMEM;
        memset(entry, 0, sizeof(*entry));
-        entry->magic = magic;
        entry->priv = priv;
-        entry->next = NULL;
+        entry->hash_item.key = (unsigned long)magic;
        mutex_lock(&dev->struct_mutex);
-        if (dev->magiclist[hash].tail) {
+        drm_ht_insert_item(&dev->magiclist, &entry->hash_item);
-                dev->magiclist[hash].tail->next = entry;
+        list_add_tail(&entry->head, &dev->magicfree);
-                dev->magiclist[hash].tail = entry;
-        } else {
-                dev->magiclist[hash].head = entry;
-                dev->magiclist[hash].tail = entry;
-        }
        mutex_unlock(&dev->struct_mutex);
        return 0;
@@ -128,34 +104,24 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
 */
 static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
 {
-        drm_magic_entry_t *prev = NULL;
        drm_magic_entry_t *pt;
-        int hash;
+        drm_hash_item_t *hash;
        DRM_DEBUG("%d\n", magic);
-        hash = drm_hash_magic(magic);
        mutex_lock(&dev->struct_mutex);
-        for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
+        if (drm_ht_find_item(&dev->magiclist, (unsigned long)magic, &hash)) {
-                if (pt->magic == magic) {
+                mutex_unlock(&dev->struct_mutex);
-                        if (dev->magiclist[hash].head == pt) {
+                return -EINVAL;
-                                dev->magiclist[hash].head = pt->next;
-                        }
-                        if (dev->magiclist[hash].tail == pt) {
-                                dev->magiclist[hash].tail = prev;
-                        }
-                        if (prev) {
-                                prev->next = pt->next;
-                        }
-                        mutex_unlock(&dev->struct_mutex);
-                        return 0;
-                }
        }
+        pt = drm_hash_entry(hash, drm_magic_entry_t, hash_item);
+        drm_ht_remove_item(&dev->magiclist, hash);
+        list_del(&pt->head);
        mutex_unlock(&dev->struct_mutex);
        drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
-        return -EINVAL;
+        return 0;
 }
 /**
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index 006b06d29727..029baea33b62 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -65,43 +65,29 @@ static drm_map_list_t *drm_find_matching_map(drm_device_t *dev,
        return NULL;
 }
-/*
+static int drm_map_handle(drm_device_t *dev, drm_hash_item_t *hash,
- * Used to allocate 32-bit handles for mappings.
+                          unsigned long user_token, int hashed_handle)
- */
-#define START_RANGE 0x10000000
-#define END_RANGE 0x40000000
-#ifdef _LP64
-static __inline__ unsigned int HandleID(unsigned long lhandle,
-                                        drm_device_t *dev)
 {
-        static unsigned int map32_handle = START_RANGE;
+        int use_hashed_handle;
-        unsigned int hash;
+#if (BITS_PER_LONG == 64)
+        use_hashed_handle = ((user_token & 0xFFFFFFFF00000000UL) || hashed_handle);
-        if (lhandle & 0xffffffff00000000) {
+#elif (BITS_PER_LONG == 32)
-                hash = map32_handle;
+        use_hashed_handle = hashed_handle;
-                map32_handle += PAGE_SIZE;
+#else
-                if (map32_handle > END_RANGE)
+#error Unsupported long size. Neither 64 nor 32 bits.
-                        map32_handle = START_RANGE;
+#endif
-        } else
-                hash = lhandle;
-        while (1) {
-                drm_map_list_t *_entry;
-                list_for_each_entry(_entry, &dev->maplist->head, head) {
-                        if (_entry->user_token == hash)
-                                break;
-                }
-                if (&_entry->head == &dev->maplist->head)
-                        return hash;
-                hash += PAGE_SIZE;
+        if (!use_hashed_handle) {
-                map32_handle += PAGE_SIZE;
+                int ret;
+                hash->key = user_token;
+                ret = drm_ht_insert_item(&dev->map_hash, hash);
+                if (ret != -EINVAL)
+                        return ret;
        }
+        return drm_ht_just_insert_please(&dev->map_hash, hash,
+                                         user_token, 32 - PAGE_SHIFT - 3,
+                                         PAGE_SHIFT, DRM_MAP_HASH_OFFSET);
 }
-#else
-# define HandleID(x,dev) (unsigned int)(x)
-#endif
 /**
 * Ioctl to specify a range of memory that is available for mapping by a non-root process.
@@ -123,6 +109,8 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
        drm_map_t *map;
        drm_map_list_t *list;
        drm_dma_handle_t *dmah;
+        unsigned long user_token;
+        int ret;
        map = drm_alloc(sizeof(*map), DRM_MEM_MAPS);
        if (!map)
@@ -257,11 +245,20 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
        mutex_lock(&dev->struct_mutex);
        list_add(&list->head, &dev->maplist->head);
        /* Assign a 32-bit handle */
        /* We do it here so that dev->struct_mutex protects the increment */
-        list->user_token = HandleID(map->type == _DRM_SHM
+        user_token = (map->type == _DRM_SHM) ? (unsigned long)map->handle :
-                                    ? (unsigned long)map->handle
+                map->offset;
-                                    : map->offset, dev);
+        ret = drm_map_handle(dev, &list->hash, user_token, 0);
+        if (ret) {
+                drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                drm_free(list, sizeof(*list), DRM_MEM_MAPS);
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
+        list->user_token = list->hash.key;
        mutex_unlock(&dev->struct_mutex);
        *maplist = list;
@@ -346,6 +343,7 @@ int drm_rmmap_locked(drm_device_t *dev, drm_local_map_t *map)
                if (r_list->map == map) {
                        list_del(list);
+                        drm_ht_remove_key(&dev->map_hash, r_list->user_token);
                        drm_free(list, sizeof(*list), DRM_MEM_MAPS);
                        break;
                }
@@ -441,8 +439,10 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
                return -EINVAL;
        }
-        if (!map)
+        if (!map) {
+                mutex_unlock(&dev->struct_mutex);
                return -EINVAL;
+        }
        /* Register and framebuffer maps are permanent */
        if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index 3c0b882a8e72..b366c5b1bd16 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -118,7 +118,7 @@ static drm_ioctl_desc_t drm_ioctls[] = {
        [DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = {drm_wait_vblank, 0},
 };
-#define DRIVER_IOCTL_COUNT      DRM_ARRAY_SIZE( drm_ioctls )
+#define DRIVER_IOCTL_COUNT      ARRAY_SIZE( drm_ioctls )
 /**
 * Take down the DRM device.
@@ -155,12 +155,13 @@ int drm_lastclose(drm_device_t * dev)
        del_timer(&dev->timer);
        /* Clear pid list */
-        for (i = 0; i < DRM_HASH_SIZE; i++) {
+        if (dev->magicfree.next) {
-                for (pt = dev->magiclist[i].head; pt; pt = next) {
+                list_for_each_entry_safe(pt, next, &dev->magicfree, head) {
-                        next = pt->next;
+                        list_del(&pt->head);
+                        drm_ht_remove_item(&dev->magiclist, &pt->hash_item);
                        drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
                }
-                dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
+                drm_ht_remove(&dev->magiclist);
        }
        /* Clear AGP information */
@@ -299,6 +300,7 @@ static void drm_cleanup(drm_device_t * dev)
        if (dev->maplist) {
                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
                dev->maplist = NULL;
+                drm_ht_remove(&dev->map_hash);
        }
        drm_ctxbitmap_cleanup(dev);
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index b7f7951c4587..898f47dafec0 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -53,6 +53,8 @@ static int drm_setup(drm_device_t * dev)
                        return ret;
        }
+        dev->magicfree.next = NULL;
        /* prebuild the SAREA */
        i = drm_addmap(dev, 0, SAREA_MAX, _DRM_SHM, _DRM_CONTAINS_LOCK, &map);
        if (i != 0)
@@ -69,13 +71,11 @@ static int drm_setup(drm_device_t * dev)
                        return i;
        }
-        for (i = 0; i < DRM_ARRAY_SIZE(dev->counts); i++)
+        for (i = 0; i < ARRAY_SIZE(dev->counts); i++)
                atomic_set(&dev->counts[i], 0);
-        for (i = 0; i < DRM_HASH_SIZE; i++) {
+        drm_ht_create(&dev->magiclist, DRM_MAGIC_HASH_ORDER);
-                dev->magiclist[i].head = NULL;
+        INIT_LIST_HEAD(&dev->magicfree);
-                dev->magiclist[i].tail = NULL;
-        }
        dev->ctxlist = drm_alloc(sizeof(*dev->ctxlist), DRM_MEM_CTXLIST);
        if (dev->ctxlist == NULL)
diff --git a/drivers/char/drm/drm_hashtab.c b/drivers/char/drm/drm_hashtab.c
new file mode 100644
index 000000000000..a0b2d6802ae4
--- /dev/null
+++ b/drivers/char/drm/drm_hashtab.c
@@ -0,0 +1,190 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND. USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple open hash tab implementation.
+ *
+ * Authors:
+ * Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
+ */
+#include "drmP.h"
+#include "drm_hashtab.h"
+#include <linux/hash.h>
+int drm_ht_create(drm_open_hash_t *ht, unsigned int order)
+{
+        unsigned int i;
+        ht->size = 1 << order;
+        ht->order = order;
+        ht->fill = 0;
+        ht->table = vmalloc(ht->size*sizeof(*ht->table));
+        if (!ht->table) {
+                DRM_ERROR("Out of memory for hash table\n");
+                return -ENOMEM;
+        }
+        for (i=0; i< ht->size; ++i) {
+                INIT_HLIST_HEAD(&ht->table[i]);
+        }
+        return 0;
+}
+void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key)
+{
+        drm_hash_item_t *entry;
+        struct hlist_head *h_list;
+        struct hlist_node *list;
+        unsigned int hashed_key;
+        int count = 0;
+        hashed_key = hash_long(key, ht->order);
+        DRM_DEBUG("Key is 0x%08lx, Hashed key is 0x%08x\n", key, hashed_key);
+        h_list = &ht->table[hashed_key];
+        hlist_for_each(list, h_list) {
+                entry = hlist_entry(list, drm_hash_item_t, head);
+                DRM_DEBUG("count %d, key: 0x%08lx\n", count++, entry->key);
+        }
+}
+static struct hlist_node *drm_ht_find_key(drm_open_hash_t *ht, 
+                                          unsigned long key)
+{
+        drm_hash_item_t *entry;
+        struct hlist_head *h_list;
+        struct hlist_node *list;
+        unsigned int hashed_key;
+        hashed_key = hash_long(key, ht->order);
+        h_list = &ht->table[hashed_key];
+        hlist_for_each(list, h_list) {
+                entry = hlist_entry(list, drm_hash_item_t, head);
+                if (entry->key == key)
+                        return list;
+                if (entry->key > key)
+                        break;
+        }
+        return NULL;
+}
+int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item)
+{
+        drm_hash_item_t *entry;
+        struct hlist_head *h_list;
+        struct hlist_node *list, *parent;
+        unsigned int hashed_key;
+        unsigned long key = item->key;
+        hashed_key = hash_long(key, ht->order);
+        h_list = &ht->table[hashed_key];
+        parent = NULL;
+        hlist_for_each(list, h_list) {
+                entry = hlist_entry(list, drm_hash_item_t, head);
+                if (entry->key == key)
+                        return -EINVAL;
+                if (entry->key > key)
+                        break;
+                parent = list;
+        }
+        if (parent) {
+                hlist_add_after(parent, &item->head);
+        } else {
+                hlist_add_head(&item->head, h_list);
+        }
+        return 0;
+}
+/*
+ * Just insert an item and return any "bits" bit key that hasn't been 
+ * used before.
+ */
+int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
+                              unsigned long seed, int bits, int shift,
+                              unsigned long add)
+{
+        int ret;
+        unsigned long mask = (1 << bits) - 1;
+        unsigned long first, unshifted_key;
+        unshifted_key = hash_long(seed, bits);
+        first = unshifted_key;
+        do {
+                item->key = (unshifted_key << shift) + add;
+                ret = drm_ht_insert_item(ht, item);
+                if (ret)
+                        unshifted_key = (unshifted_key + 1) & mask;
+        } while(ret && (unshifted_key != first));
+        if (ret) {
+                DRM_ERROR("Available key bit space exhausted\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key,
+                     drm_hash_item_t **item)
+{
+        struct hlist_node *list;
+        list = drm_ht_find_key(ht, key);
+        if (!list)
+                return -EINVAL;
+        *item = hlist_entry(list, drm_hash_item_t, head);
+        return 0;
+}
+int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key)
+{
+        struct hlist_node *list;
+        list = drm_ht_find_key(ht, key);
+        if (list) {
+                hlist_del_init(list);
+                ht->fill--;
+                return 0;
+        }
+        return -EINVAL;
+}
+int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item)
+{
+        hlist_del_init(&item->head);
+        ht->fill--;
+        return 0;
+}
+void drm_ht_remove(drm_open_hash_t *ht)
+{
+        if (ht->table) {
+                vfree(ht->table);
+                ht->table = NULL;
+        }
+}
diff --git a/drivers/char/drm/drm_hashtab.h b/drivers/char/drm/drm_hashtab.h
new file mode 100644
index 000000000000..40afec05bff8
--- /dev/null
+++ b/drivers/char/drm/drm_hashtab.h
@@ -0,0 +1,67 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismack, ND. USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple open hash tab implementation.
+ *
+ * Authors:
+ * Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
+ */
+#ifndef DRM_HASHTAB_H
+#define DRM_HASHTAB_H
+#define drm_hash_entry(_ptr, _type, _member) container_of(_ptr, _type, _member)
+typedef struct drm_hash_item{
+        struct hlist_node head;
+        unsigned long key;
+} drm_hash_item_t;
+typedef struct drm_open_hash{
+        unsigned int size;
+        unsigned int order;
+        unsigned int fill;
+        struct hlist_head *table;
+} drm_open_hash_t;
+extern int drm_ht_create(drm_open_hash_t *ht, unsigned int order);
+extern int drm_ht_insert_item(drm_open_hash_t *ht, drm_hash_item_t *item);
+extern int drm_ht_just_insert_please(drm_open_hash_t *ht, drm_hash_item_t *item,
+                                     unsigned long seed, int bits, int shift,
+                                     unsigned long add);
+extern int drm_ht_find_item(drm_open_hash_t *ht, unsigned long key, drm_hash_item_t **item);
+extern void drm_ht_verbose_list(drm_open_hash_t *ht, unsigned long key);
+extern int drm_ht_remove_key(drm_open_hash_t *ht, unsigned long key);
+extern int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item);
+extern void drm_ht_remove(drm_open_hash_t *ht);
+#endif
diff --git a/drivers/char/drm/drm_ioc32.c b/drivers/char/drm/drm_ioc32.c
index e9e2db18952d..d4f874520082 100644
--- a/drivers/char/drm/drm_ioc32.c
+++ b/drivers/char/drm/drm_ioc32.c
@@ -1051,7 +1051,7 @@ long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
        drm_ioctl_compat_t *fn;
        int ret;
-        if (nr >= DRM_ARRAY_SIZE(drm_compat_ioctls))
+        if (nr >= ARRAY_SIZE(drm_compat_ioctls))
                return -ENOTTY;
        fn = drm_compat_ioctls[nr];
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index 555f323b8a32..565895547d75 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -127,9 +127,10 @@ int drm_setunique(struct inode *inode, struct file *filp,
        domain = bus >> 8;
        bus &= 0xff;
-        if ((domain != dev->pci_domain) ||
+        if ((domain != drm_get_pci_domain(dev)) ||
-            (bus != dev->pci_bus) ||
+            (bus != dev->pdev->bus->number) ||
-            (slot != dev->pci_slot) || (func != dev->pci_func))
+            (slot != PCI_SLOT(dev->pdev->devfn)) ||
+            (func != PCI_FUNC(dev->pdev->devfn)))
                return -EINVAL;
        return 0;
@@ -140,15 +141,17 @@ static int drm_set_busid(drm_device_t * dev)
        int len;
        if (dev->unique != NULL)
-                return EBUSY;
+                return 0;
        dev->unique_len = 40;
        dev->unique = drm_alloc(dev->unique_len + 1, DRM_MEM_DRIVER);
        if (dev->unique == NULL)
-                return ENOMEM;
+                return -ENOMEM;
        len = snprintf(dev->unique, dev->unique_len, "pci:%04x:%02x:%02x.%d",
-                 dev->pci_domain, dev->pci_bus, dev->pci_slot, dev->pci_func);
+                       drm_get_pci_domain(dev), dev->pdev->bus->number,
+                       PCI_SLOT(dev->pdev->devfn),
+                       PCI_FUNC(dev->pdev->devfn));
        if (len > dev->unique_len)
                DRM_ERROR("Unique buffer overflowed\n");
@@ -157,7 +160,7 @@ static int drm_set_busid(drm_device_t * dev)
            drm_alloc(strlen(dev->driver->pci_driver.name) + dev->unique_len +
                      2, DRM_MEM_DRIVER);
        if (dev->devname == NULL)
-                return ENOMEM;
+                return -ENOMEM;
        sprintf(dev->devname, "%s@%s", dev->driver->pci_driver.name,
                dev->unique);
@@ -330,27 +333,32 @@ int drm_setversion(DRM_IOCTL_ARGS)
        drm_set_version_t retv;
        int if_version;
        drm_set_version_t __user *argp = (void __user *)data;
+        int ret;
-        DRM_COPY_FROM_USER_IOCTL(sv, argp, sizeof(sv));
+        if (copy_from_user(&sv, argp, sizeof(sv)))
+                return -EFAULT;
        retv.drm_di_major = DRM_IF_MAJOR;
        retv.drm_di_minor = DRM_IF_MINOR;
        retv.drm_dd_major = dev->driver->major;
        retv.drm_dd_minor = dev->driver->minor;
-        DRM_COPY_TO_USER_IOCTL(argp, retv, sizeof(sv));
+        if (copy_to_user(argp, &retv, sizeof(retv)))
+                return -EFAULT;
        if (sv.drm_di_major != -1) {
                if (sv.drm_di_major != DRM_IF_MAJOR ||
                    sv.drm_di_minor < 0 || sv.drm_di_minor > DRM_IF_MINOR)
-                        return EINVAL;
+                        return -EINVAL;
                if_version = DRM_IF_VERSION(sv.drm_di_major, sv.drm_di_minor);
-                dev->if_version = DRM_MAX(if_version, dev->if_version);
+                dev->if_version = max(if_version, dev->if_version);
                if (sv.drm_di_minor >= 1) {
                        /*
                         * Version 1.1 includes tying of DRM to specific device
                         */
-                        drm_set_busid(dev);
+                        ret = drm_set_busid(dev);
+                        if (ret)
+                                return ret;
                }
        }
@@ -358,7 +366,7 @@ int drm_setversion(DRM_IOCTL_ARGS)
                if (sv.drm_dd_major != dev->driver->major ||
                    sv.drm_dd_minor < 0
                    || sv.drm_dd_minor > dev->driver->minor)
-                        return EINVAL;
+                        return -EINVAL;
                if (dev->driver->set_version)
                        dev->driver->set_version(dev, &sv);
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index ebdb7182c4fd..4553a3a1e496 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -64,9 +64,9 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
        if (copy_from_user(&p, argp, sizeof(p)))
                return -EFAULT;
-        if ((p.busnum >> 8) != dev->pci_domain ||
+        if ((p.busnum >> 8) != drm_get_pci_domain(dev) ||
-            (p.busnum & 0xff) != dev->pci_bus ||
+            (p.busnum & 0xff) != dev->pdev->bus->number ||
-            p.devnum != dev->pci_slot || p.funcnum != dev->pci_func)
+            p.devnum != PCI_SLOT(dev->pdev->devfn) || p.funcnum != PCI_FUNC(dev->pdev->devfn))
                return -EINVAL;
        p.irq = dev->irq;
@@ -255,7 +255,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
        if (!dev->irq)
                return -EINVAL;
-        DRM_COPY_FROM_USER_IOCTL(vblwait, argp, sizeof(vblwait));
+        if (copy_from_user(&vblwait, argp, sizeof(vblwait)))
+                return -EFAULT;
        switch (vblwait.request.type & ~_DRM_VBLANK_FLAGS_MASK) {
        case _DRM_VBLANK_RELATIVE:
@@ -329,7 +330,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
        }
      done:
-        DRM_COPY_TO_USER_IOCTL(argp, vblwait, sizeof(vblwait));
+        if (copy_to_user(argp, &vblwait, sizeof(vblwait)))
+                return -EFAULT;
        return ret;
 }
diff --git a/drivers/char/drm/drm_mm.c b/drivers/char/drm/drm_mm.c
new file mode 100644
index 000000000000..617526bd5b0c
--- /dev/null
+++ b/drivers/char/drm/drm_mm.c
@@ -0,0 +1,201 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Generic simple memory manager implementation. Intended to be used as a base
+ * class implementation for more advanced memory managers.
+ *
+ * Note that the algorithm used is quite simple and there might be substantial
+ * performance gains if a smarter free list is implemented. Currently it is just an
+ * unordered stack of free regions. This could easily be improved if an RB-tree
+ * is used instead. At least if we expect heavy fragmentation.
+ *
+ * Aligned allocations can also see improvement.
+ *
+ * Authors:
+ * Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
+ */
+#include "drmP.h"
+drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
+                                unsigned long size, unsigned alignment)
+{
+        drm_mm_node_t *child;
+        if (alignment)
+                size += alignment - 1;
+        if (parent->size == size) {
+                list_del_init(&parent->fl_entry);
+                parent->free = 0;
+                return parent;
+        } else {
+                child = (drm_mm_node_t *) drm_alloc(sizeof(*child), DRM_MEM_MM);
+                if (!child)
+                        return NULL;
+                INIT_LIST_HEAD(&child->ml_entry);
+                INIT_LIST_HEAD(&child->fl_entry);
+                child->free = 0;
+                child->size = size;
+                child->start = parent->start;
+                list_add_tail(&child->ml_entry, &parent->ml_entry);
+                parent->size -= size;
+                parent->start += size;
+        }
+        return child;
+}
+/*
+ * Put a block. Merge with the previous and / or next block if they are free.
+ * Otherwise add to the free stack.
+ */
+void drm_mm_put_block(drm_mm_t * mm, drm_mm_node_t * cur)
+{
+        drm_mm_node_t *list_root = &mm->root_node;
+        struct list_head *cur_head = &cur->ml_entry;
+        struct list_head *root_head = &list_root->ml_entry;
+        drm_mm_node_t *prev_node = NULL;
+        drm_mm_node_t *next_node;
+        int merged = 0;
+        if (cur_head->prev != root_head) {
+                prev_node = list_entry(cur_head->prev, drm_mm_node_t, ml_entry);
+                if (prev_node->free) {
+                        prev_node->size += cur->size;
+                        merged = 1;
+                }
+        }
+        if (cur_head->next != root_head) {
+                next_node = list_entry(cur_head->next, drm_mm_node_t, ml_entry);
+                if (next_node->free) {
+                        if (merged) {
+                                prev_node->size += next_node->size;
+                                list_del(&next_node->ml_entry);
+                                list_del(&next_node->fl_entry);
+                                drm_free(next_node, sizeof(*next_node),
+                                         DRM_MEM_MM);
+                        } else {
+                                next_node->size += cur->size;
+                                next_node->start = cur->start;
+                                merged = 1;
+                        }
+                }
+        }
+        if (!merged) {
+                cur->free = 1;
+                list_add(&cur->fl_entry, &list_root->fl_entry);
+        } else {
+                list_del(&cur->ml_entry);
+                drm_free(cur, sizeof(*cur), DRM_MEM_MM);
+        }
+}
+drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
+                                  unsigned long size,
+                                  unsigned alignment, int best_match)
+{
+        struct list_head *list;
+        const struct list_head *free_stack = &mm->root_node.fl_entry;
+        drm_mm_node_t *entry;
+        drm_mm_node_t *best;
+        unsigned long best_size;
+        best = NULL;
+        best_size = ~0UL;
+        if (alignment)
+                size += alignment - 1;
+        list_for_each(list, free_stack) {
+                entry = list_entry(list, drm_mm_node_t, fl_entry);
+                if (entry->size >= size) {
+                        if (!best_match)
+                                return entry;
+                        if (size < best_size) {
+                                best = entry;
+                                best_size = entry->size;
+                        }
+                }
+        }
+        return best;
+}
+int drm_mm_init(drm_mm_t * mm, unsigned long start, unsigned long size)
+{
+        drm_mm_node_t *child;
+        INIT_LIST_HEAD(&mm->root_node.ml_entry);
+        INIT_LIST_HEAD(&mm->root_node.fl_entry);
+        child = (drm_mm_node_t *) drm_alloc(sizeof(*child), DRM_MEM_MM);
+        if (!child)
+                return -ENOMEM;
+        INIT_LIST_HEAD(&child->ml_entry);
+        INIT_LIST_HEAD(&child->fl_entry);
+        child->start = start;
+        child->size = size;
+        child->free = 1;
+        list_add(&child->fl_entry, &mm->root_node.fl_entry);
+        list_add(&child->ml_entry, &mm->root_node.ml_entry);
+        return 0;
+}
+EXPORT_SYMBOL(drm_mm_init);
+void drm_mm_takedown(drm_mm_t * mm)
+{
+        struct list_head *bnode = mm->root_node.fl_entry.next;
+        drm_mm_node_t *entry;
+        entry = list_entry(bnode, drm_mm_node_t, fl_entry);
+        if (entry->ml_entry.next != &mm->root_node.ml_entry ||
+            entry->fl_entry.next != &mm->root_node.fl_entry) {
+                DRM_ERROR("Memory manager not clean. Delaying takedown\n");
+                return;
+        }
+        list_del(&entry->fl_entry);
+        list_del(&entry->ml_entry);
+        drm_free(entry, sizeof(*entry), DRM_MEM_MM);
+}
+EXPORT_SYMBOL(drm_mm_takedown);
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index b1bb3c7b568d..09398d5fbd3f 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -3,13 +3,13 @@
   Please contact dri-devel@lists.sf.net to add new cards to this list
 */
 #define radeon_PCI_IDS \
-        {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x3E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x3E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x3E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x3E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|CHIP_IS_IGP}, \
+        {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|RADEON_IS_IGP}, \
-        {0x1002, 0x4137, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP}, \
+        {0x1002, 0x4137, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP}, \
        {0x1002, 0x4144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
        {0x1002, 0x4145, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
        {0x1002, 0x4146, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
@@ -25,35 +25,35 @@
        {0x1002, 0x4154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
        {0x1002, 0x4155, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
        {0x1002, 0x4156, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350}, \
-        {0x1002, 0x4237, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP}, \
+        {0x1002, 0x4237, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP}, \
        {0x1002, 0x4242, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
        {0x1002, 0x4243, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
-        {0x1002, 0x4336, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4336, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4337, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4337, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4437, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4437, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
        {0x1002, 0x4966, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250}, \
        {0x1002, 0x4967, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250}, \
-        {0x1002, 0x4A48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A4D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A4D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A4E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A4E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A4F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A4F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4A54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4A54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4B49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4B49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4B4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4B4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4B4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4B4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4B4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x4B4C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x4C57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4C58, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C58, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV200|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4C59, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C59, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4C5A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C5A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4C64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4C66, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C66, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4C67, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4C67, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \
        {0x1002, 0x4E44, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
        {0x1002, 0x4E45, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
        {0x1002, 0x4E46, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
@@ -62,16 +62,16 @@
        {0x1002, 0x4E49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R350}, \
        {0x1002, 0x4E4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R350}, \
        {0x1002, 0x4E4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R350}, \
-        {0x1002, 0x4E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4E50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4E51, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4E51, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4E52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4E52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4E53, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4E53, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4E54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x4E56, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x4E56, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x5144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
+        {0x1002, 0x5144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
-        {0x1002, 0x5145, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
+        {0x1002, 0x5145, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
-        {0x1002, 0x5146, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
+        {0x1002, 0x5146, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
-        {0x1002, 0x5147, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|CHIP_SINGLE_CRTC}, \
+        {0x1002, 0x5147, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R100|RADEON_SINGLE_CRTC}, \
        {0x1002, 0x5148, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
        {0x1002, 0x514C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
        {0x1002, 0x514D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R200}, \
@@ -80,59 +80,59 @@
        {0x1002, 0x5159, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
        {0x1002, 0x515A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
        {0x1002, 0x515E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
-        {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5464, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5548, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5549, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x554A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x554B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x554B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x554C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x554C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x554D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x554D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x554E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x554E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x554F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x554F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5550, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5550, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5551, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5551, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5554, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5554, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x564A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x564A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x564B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x564B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x564F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5652, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5653, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP}, \
+        {0x1002, 0x5834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP}, \
-        {0x1002, 0x5835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY}, \
        {0x1002, 0x5960, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
        {0x1002, 0x5961, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
        {0x1002, 0x5962, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
        {0x1002, 0x5964, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
        {0x1002, 0x5965, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280}, \
        {0x1002, 0x5969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV100}, \
-        {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5b60, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5b62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5b62, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5b63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5b63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5b64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5b64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5b65, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5b65, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5c61, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|CHIP_IS_MOBILITY}, \
+        {0x1002, 0x5c63, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \
-        {0x1002, 0x5d48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d4e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d4e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d52, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5d57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5d57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5e48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5e48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5e4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5e4a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5e4b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5e4b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5e4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5e4c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5e4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5e4d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x5e4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x5e4f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV410|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x7834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x7834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|CHIP_IS_IGP|CHIP_IS_MOBILITY|CHIP_NEW_MEMMAP}, \
+        {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
        {0, 0, 0}
 #define r128_PCI_IDS \
@@ -209,6 +209,7 @@
        {0x1039, 0x0300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0x1039, 0x5300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0x1039, 0x6300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1039, 0x6330, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_CHIP_315}, \
        {0x1039, 0x7300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0, 0, 0}
@@ -227,6 +228,10 @@
        {0x1106, 0x3122, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0x1106, 0x7205, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0x1106, 0x3108, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x3304, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x3157, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x3344, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x1106, 0x7204, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0, 0, 0}
 #define i810_PCI_IDS \
@@ -285,5 +290,9 @@
        {0x8086, 0x2592, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0x8086, 0x2772, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0x8086, 0x27a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x2972, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x2982, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x2992, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x29a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
        {0, 0, 0}
diff --git a/drivers/char/drm/drm_proc.c b/drivers/char/drm/drm_proc.c
index 362a270af0f1..62d5fe15f046 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -510,7 +510,7 @@ static int drm__vma_info(char *buf, char **start, off_t offset, int request,
                               vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
                               vma->vm_flags & VM_LOCKED ? 'l' : '-',
                               vma->vm_flags & VM_IO ? 'i' : '-',
-                               VM_OFFSET(vma));
+                               vma->vm_pgoff << PAGE_SHIFT);
 #if defined(__i386__)
                pgprot = pgprot_val(vma->vm_page_prot);
diff --git a/drivers/char/drm/drm_sman.c b/drivers/char/drm/drm_sman.c
new file mode 100644
index 000000000000..425c82336ee0
--- /dev/null
+++ b/drivers/char/drm/drm_sman.c
@@ -0,0 +1,352 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck., ND., USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple memory manager interface that keeps track on allocate regions on a
+ * per "owner" basis. All regions associated with an "owner" can be released
+ * with a simple call. Typically if the "owner" exists. The owner is any
+ * "unsigned long" identifier. Can typically be a pointer to a file private
+ * struct or a context identifier.
+ *
+ * Authors:
+ * Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
+ */
+#include "drm_sman.h"
+typedef struct drm_owner_item {
+        drm_hash_item_t owner_hash;
+        struct list_head sman_list;
+        struct list_head mem_blocks;
+} drm_owner_item_t;
+void drm_sman_takedown(drm_sman_t * sman)
+{
+        drm_ht_remove(&sman->user_hash_tab);
+        drm_ht_remove(&sman->owner_hash_tab);
+        if (sman->mm)
+                drm_free(sman->mm, sman->num_managers * sizeof(*sman->mm),
+                         DRM_MEM_MM);
+}
+EXPORT_SYMBOL(drm_sman_takedown);
+int
+drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
+              unsigned int user_order, unsigned int owner_order)
+{
+        int ret = 0;
+        sman->mm = (drm_sman_mm_t *) drm_calloc(num_managers, sizeof(*sman->mm),
+                                                DRM_MEM_MM);
+        if (!sman->mm) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        sman->num_managers = num_managers;
+        INIT_LIST_HEAD(&sman->owner_items);
+        ret = drm_ht_create(&sman->owner_hash_tab, owner_order);
+        if (ret)
+                goto out1;
+        ret = drm_ht_create(&sman->user_hash_tab, user_order);
+        if (!ret)
+                goto out;
+        drm_ht_remove(&sman->owner_hash_tab);
+out1:
+        drm_free(sman->mm, num_managers * sizeof(*sman->mm), DRM_MEM_MM);
+out:
+        return ret;
+}
+EXPORT_SYMBOL(drm_sman_init);
+static void *drm_sman_mm_allocate(void *private, unsigned long size,
+                                  unsigned alignment)
+{
+        drm_mm_t *mm = (drm_mm_t *) private;
+        drm_mm_node_t *tmp;
+        tmp = drm_mm_search_free(mm, size, alignment, 1);
+        if (!tmp) {
+                return NULL;
+        }
+        tmp = drm_mm_get_block(tmp, size, alignment);
+        return tmp;
+}
+static void drm_sman_mm_free(void *private, void *ref)
+{
+        drm_mm_t *mm = (drm_mm_t *) private;
+        drm_mm_node_t *node = (drm_mm_node_t *) ref;
+        drm_mm_put_block(mm, node);
+}
+static void drm_sman_mm_destroy(void *private)
+{
+        drm_mm_t *mm = (drm_mm_t *) private;
+        drm_mm_takedown(mm);
+        drm_free(mm, sizeof(*mm), DRM_MEM_MM);
+}
+static unsigned long drm_sman_mm_offset(void *private, void *ref)
+{
+        drm_mm_node_t *node = (drm_mm_node_t *) ref;
+        return node->start;
+}
+int
+drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
+                   unsigned long start, unsigned long size)
+{
+        drm_sman_mm_t *sman_mm;
+        drm_mm_t *mm;
+        int ret;
+        BUG_ON(manager >= sman->num_managers);
+        sman_mm = &sman->mm[manager];
+        mm = drm_calloc(1, sizeof(*mm), DRM_MEM_MM);
+        if (!mm) {
+                return -ENOMEM;
+        }
+        sman_mm->private = mm;
+        ret = drm_mm_init(mm, start, size);
+        if (ret) {
+                drm_free(mm, sizeof(*mm), DRM_MEM_MM);
+                return ret;
+        }
+        sman_mm->allocate = drm_sman_mm_allocate;
+        sman_mm->free = drm_sman_mm_free;
+        sman_mm->destroy = drm_sman_mm_destroy;
+        sman_mm->offset = drm_sman_mm_offset;
+        return 0;
+}
+EXPORT_SYMBOL(drm_sman_set_range);
+int
+drm_sman_set_manager(drm_sman_t * sman, unsigned int manager,
+                     drm_sman_mm_t * allocator)
+{
+        BUG_ON(manager >= sman->num_managers);
+        sman->mm[manager] = *allocator;
+        return 0;
+}
+static drm_owner_item_t *drm_sman_get_owner_item(drm_sman_t * sman,
+                                                 unsigned long owner)
+{
+        int ret;
+        drm_hash_item_t *owner_hash_item;
+        drm_owner_item_t *owner_item;
+        ret = drm_ht_find_item(&sman->owner_hash_tab, owner, &owner_hash_item);
+        if (!ret) {
+                return drm_hash_entry(owner_hash_item, drm_owner_item_t,
+                                      owner_hash);
+        }
+        owner_item = drm_calloc(1, sizeof(*owner_item), DRM_MEM_MM);
+        if (!owner_item)
+                goto out;
+        INIT_LIST_HEAD(&owner_item->mem_blocks);
+        owner_item->owner_hash.key = owner;
+        if (drm_ht_insert_item(&sman->owner_hash_tab, &owner_item->owner_hash))
+                goto out1;
+        list_add_tail(&owner_item->sman_list, &sman->owner_items);
+        return owner_item;
+out1:
+        drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
+out:
+        return NULL;
+}
+drm_memblock_item_t *drm_sman_alloc(drm_sman_t *sman, unsigned int manager,
+                                    unsigned long size, unsigned alignment,
+                                    unsigned long owner)
+{
+        void *tmp;
+        drm_sman_mm_t *sman_mm;
+        drm_owner_item_t *owner_item;
+        drm_memblock_item_t *memblock;
+        BUG_ON(manager >= sman->num_managers);
+        sman_mm = &sman->mm[manager];
+        tmp = sman_mm->allocate(sman_mm->private, size, alignment);
+        if (!tmp) {
+                return NULL;
+        }
+        memblock = drm_calloc(1, sizeof(*memblock), DRM_MEM_MM);
+        if (!memblock)
+                goto out;
+        memblock->mm_info = tmp;
+        memblock->mm = sman_mm;
+        memblock->sman = sman;
+        if (drm_ht_just_insert_please
+            (&sman->user_hash_tab, &memblock->user_hash,
+             (unsigned long)memblock, 32, 0, 0))
+                goto out1;
+        owner_item = drm_sman_get_owner_item(sman, owner);
+        if (!owner_item)
+                goto out2;
+        list_add_tail(&memblock->owner_list, &owner_item->mem_blocks);
+        return memblock;
+out2:
+        drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
+out1:
+        drm_free(memblock, sizeof(*memblock), DRM_MEM_MM);
+out:
+        sman_mm->free(sman_mm->private, tmp);
+        return NULL;
+}
+EXPORT_SYMBOL(drm_sman_alloc);
+static void drm_sman_free(drm_memblock_item_t *item)
+{
+        drm_sman_t *sman = item->sman;
+        list_del(&item->owner_list);
+        drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
+        item->mm->free(item->mm->private, item->mm_info);
+        drm_free(item, sizeof(*item), DRM_MEM_MM);
+}
+int drm_sman_free_key(drm_sman_t *sman, unsigned int key)
+{
+        drm_hash_item_t *hash_item;
+        drm_memblock_item_t *memblock_item;
+        if (drm_ht_find_item(&sman->user_hash_tab, key, &hash_item))
+                return -EINVAL;
+        memblock_item = drm_hash_entry(hash_item, drm_memblock_item_t, user_hash);
+        drm_sman_free(memblock_item);
+        return 0;
+}
+EXPORT_SYMBOL(drm_sman_free_key);
+static void drm_sman_remove_owner(drm_sman_t *sman,
+                                  drm_owner_item_t *owner_item)
+{
+        list_del(&owner_item->sman_list);
+        drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
+        drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
+}
+int drm_sman_owner_clean(drm_sman_t *sman, unsigned long owner)
+{
+        drm_hash_item_t *hash_item;
+        drm_owner_item_t *owner_item;
+        if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
+                return -1;
+        }
+        owner_item = drm_hash_entry(hash_item, drm_owner_item_t, owner_hash);
+        if (owner_item->mem_blocks.next == &owner_item->mem_blocks) {
+                drm_sman_remove_owner(sman, owner_item);
+                return -1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(drm_sman_owner_clean);
+static void drm_sman_do_owner_cleanup(drm_sman_t *sman,
+                                      drm_owner_item_t *owner_item)
+{
+        drm_memblock_item_t *entry, *next;
+        list_for_each_entry_safe(entry, next, &owner_item->mem_blocks,
+                                 owner_list) {
+                drm_sman_free(entry);
+        }
+        drm_sman_remove_owner(sman, owner_item);
+}
+void drm_sman_owner_cleanup(drm_sman_t *sman, unsigned long owner)
+{
+        drm_hash_item_t *hash_item;
+        drm_owner_item_t *owner_item;
+        if (drm_ht_find_item(&sman->owner_hash_tab, owner, &hash_item)) {
+                return;
+        }
+        owner_item = drm_hash_entry(hash_item, drm_owner_item_t, owner_hash);
+        drm_sman_do_owner_cleanup(sman, owner_item);
+}
+EXPORT_SYMBOL(drm_sman_owner_cleanup);
+void drm_sman_cleanup(drm_sman_t *sman)
+{
+        drm_owner_item_t *entry, *next;
+        unsigned int i;
+        drm_sman_mm_t *sman_mm;
+        list_for_each_entry_safe(entry, next, &sman->owner_items, sman_list) {
+                drm_sman_do_owner_cleanup(sman, entry);
+        }
+        if (sman->mm) {
+                for (i = 0; i < sman->num_managers; ++i) {
+                        sman_mm = &sman->mm[i];
+                        if (sman_mm->private) {
+                                sman_mm->destroy(sman_mm->private);
+                                sman_mm->private = NULL;
+                        }
+                }
+        }
+}
+EXPORT_SYMBOL(drm_sman_cleanup);
diff --git a/drivers/char/drm/drm_sman.h b/drivers/char/drm/drm_sman.h
new file mode 100644
index 000000000000..ddc732a1bf27
--- /dev/null
+++ b/drivers/char/drm/drm_sman.h
@@ -0,0 +1,176 @@
+/**************************************************************************
+ *
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Simple memory MANager interface that keeps track on allocate regions on a
+ * per "owner" basis. All regions associated with an "owner" can be released
+ * with a simple call. Typically if the "owner" exists. The owner is any
+ * "unsigned long" identifier. Can typically be a pointer to a file private
+ * struct or a context identifier.
+ *
+ * Authors:
+ * Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
+ */
+#ifndef DRM_SMAN_H
+#define DRM_SMAN_H
+#include "drmP.h"
+#include "drm_hashtab.h"
+/*
+ * A class that is an abstration of a simple memory allocator.
+ * The sman implementation provides a default such allocator
+ * using the drm_mm.c implementation. But the user can replace it.
+ * See the SiS implementation, which may use the SiS FB kernel module
+ * for memory management.
+ */
+typedef struct drm_sman_mm {
+        /* private info. If allocated, needs to be destroyed by the destroy
+           function */
+        void *private;
+        /* Allocate a memory block with given size and alignment.
+           Return an opaque reference to the memory block */
+        void *(*allocate) (void *private, unsigned long size,
+                           unsigned alignment);
+        /* Free a memory block. "ref" is the opaque reference that we got from
+           the "alloc" function */
+        void (*free) (void *private, void *ref);
+        /* Free all resources associated with this allocator */
+        void (*destroy) (void *private);
+        /* Return a memory offset from the opaque reference returned from the
+           "alloc" function */
+        unsigned long (*offset) (void *private, void *ref);
+} drm_sman_mm_t;
+typedef struct drm_memblock_item {
+        struct list_head owner_list;
+        drm_hash_item_t user_hash;
+        void *mm_info;
+        drm_sman_mm_t *mm;
+        struct drm_sman *sman;
+} drm_memblock_item_t;
+typedef struct drm_sman {
+        drm_sman_mm_t *mm;
+        int num_managers;
+        drm_open_hash_t owner_hash_tab;
+        drm_open_hash_t user_hash_tab;
+        struct list_head owner_items;
+} drm_sman_t;
+/*
+ * Take down a memory manager. This function should only be called after a
+ * successful init and after a call to drm_sman_cleanup.
+ */
+extern void drm_sman_takedown(drm_sman_t * sman);
+/*
+ * Allocate structures for a manager.
+ * num_managers are the number of memory pools to manage. (VRAM, AGP, ....)
+ * user_order is the log2 of the number of buckets in the user hash table.
+ *          set this to approximately log2 of the max number of memory regions
+ *          that will be allocated for _all_ pools together.
+ * owner_order is the log2 of the number of buckets in the owner hash table.
+ *          set this to approximately log2 of
+ *          the number of client file connections that will
+ *          be using the manager.
+ *
+ */
+extern int drm_sman_init(drm_sman_t * sman, unsigned int num_managers,
+                         unsigned int user_order, unsigned int owner_order);
+/*
+ * Initialize a drm_mm.c allocator. Should be called only once for each
+ * manager unless a customized allogator is used.
+ */
+extern int drm_sman_set_range(drm_sman_t * sman, unsigned int manager,
+                              unsigned long start, unsigned long size);
+/*
+ * Initialize a customized allocator for one of the managers.
+ * (See the SiS module). The object pointed to by "allocator" is copied,
+ * so it can be destroyed after this call.
+ */
+extern int drm_sman_set_manager(drm_sman_t * sman, unsigned int mananger,
+                                drm_sman_mm_t * allocator);
+/*
+ * Allocate a memory block. Aligment is not implemented yet.
+ */
+extern drm_memblock_item_t *drm_sman_alloc(drm_sman_t * sman,
+                                           unsigned int manager,
+                                           unsigned long size,
+                                           unsigned alignment,
+                                           unsigned long owner);
+/*
+ * Free a memory block identified by its user hash key.
+ */
+extern int drm_sman_free_key(drm_sman_t * sman, unsigned int key);
+/*
+ * returns 1 iff there are no stale memory blocks associated with this owner.
+ * Typically called to determine if we need to idle the hardware and call
+ * drm_sman_owner_cleanup. If there are no stale memory blocks, it removes all
+ * resources associated with owner.
+ */
+extern int drm_sman_owner_clean(drm_sman_t * sman, unsigned long owner);
+/*
+ * Frees all stale memory blocks associated with this owner. Note that this
+ * requires that the hardware is finished with all blocks, so the graphics engine
+ * should be idled before this call is made. This function also frees
+ * any resources associated with "owner" and should be called when owner
+ * is not going to be referenced anymore.
+ */
+extern void drm_sman_owner_cleanup(drm_sman_t * sman, unsigned long owner);
+/*
+ * Frees all stale memory blocks associated with the memory manager.
+ * See idling above.
+ */
+extern void drm_sman_cleanup(drm_sman_t * sman);
+#endif
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 9a842a36bb27..7b1d4e8659ba 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -65,22 +65,22 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
        mutex_init(&dev->ctxlist_mutex);
        dev->pdev = pdev;
+        dev->pci_device = pdev->device;
+        dev->pci_vendor = pdev->vendor;
 #ifdef __alpha__
        dev->hose = pdev->sysdata;
-        dev->pci_domain = dev->hose->bus->number;
-#else
-        dev->pci_domain = 0;
 #endif
-        dev->pci_bus = pdev->bus->number;
-        dev->pci_slot = PCI_SLOT(pdev->devfn);
-        dev->pci_func = PCI_FUNC(pdev->devfn);
        dev->irq = pdev->irq;
        dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS);
        if (dev->maplist == NULL)
                return -ENOMEM;
        INIT_LIST_HEAD(&dev->maplist->head);
+        if (drm_ht_create(&dev->map_hash, 12)) {
+                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
+                return -ENOMEM;
+        }
        /* the DRM has 6 basic counters */
        dev->counters = 6;
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index ffd0800ed601..b40ae438f531 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -59,7 +59,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
        drm_device_t *dev = priv->head->dev;
        drm_map_t *map = NULL;
        drm_map_list_t *r_list;
-        struct list_head *list;
+        drm_hash_item_t *hash;
        /*
         * Find the right map
@@ -70,14 +70,11 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
        if (!dev->agp || !dev->agp->cant_use_aperture)
                goto vm_nopage_error;
-        list_for_each(list, &dev->maplist->head) {
+        if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff << PAGE_SHIFT, &hash))
-                r_list = list_entry(list, drm_map_list_t, head);
+                goto vm_nopage_error;
-                map = r_list->map;
-                if (!map)
+        r_list = drm_hash_entry(hash, drm_map_list_t, hash);
-                        continue;
+        map = r_list->map;
-                if (r_list->user_token == VM_OFFSET(vma))
-                        break;
-        }
        if (map && map->type == _DRM_AGP) {
                unsigned long offset = address - vma->vm_start;
@@ -467,7 +464,7 @@ static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
        dev = priv->head->dev;
        dma = dev->dma;
        DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
-                  vma->vm_start, vma->vm_end, VM_OFFSET(vma));
+                  vma->vm_start, vma->vm_end, vma->vm_pgoff << PAGE_SHIFT);
        /* Length must match exact page count */
        if (!dma || (length >> PAGE_SHIFT) != dma->page_count) {
@@ -521,12 +518,11 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
        drm_file_t *priv = filp->private_data;
        drm_device_t *dev = priv->head->dev;
        drm_map_t *map = NULL;
-        drm_map_list_t *r_list;
        unsigned long offset = 0;
-        struct list_head *list;
+        drm_hash_item_t *hash;
        DRM_DEBUG("start = 0x%lx, end = 0x%lx, offset = 0x%lx\n",
-                  vma->vm_start, vma->vm_end, VM_OFFSET(vma));
+                  vma->vm_start, vma->vm_end, vma->vm_pgoff << PAGE_SHIFT);
        if (!priv->authenticated)
                return -EACCES;
@@ -535,7 +531,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
         * the AGP mapped at physical address 0
         * --BenH.
         */
-        if (!VM_OFFSET(vma)
+        if (!(vma->vm_pgoff << PAGE_SHIFT)
 #if __OS_HAS_AGP
            && (!dev->agp
                || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
@@ -543,23 +539,12 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
            )
                return drm_mmap_dma(filp, vma);
-        /* A sequential search of a linked list is
+        if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff << PAGE_SHIFT, &hash)) {
-           fine here because: 1) there will only be
+                DRM_ERROR("Could not find map\n");
-           about 5-10 entries in the list and, 2) a
+                return -EINVAL;
-           DRI client only has to do this mapping
-           once, so it doesn't have to be optimized
-           for performance, even if the list was a
-           bit longer. */
-        list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
-                map = r_list->map;
-                if (!map)
-                        continue;
-                if (r_list->user_token == VM_OFFSET(vma))
-                        break;
        }
+        map = drm_hash_entry(hash, drm_map_list_t, hash)->map;
        if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
                return -EPERM;
@@ -620,7 +605,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
                offset = dev->driver->get_reg_ofs(dev);
 #ifdef __sparc__
                vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-                if (io_remap_pfn_range(DRM_RPR_ARG(vma) vma->vm_start,
+                if (io_remap_pfn_range(vma, vma->vm_start,
                                       (map->offset + offset) >> PAGE_SHIFT,
                                       vma->vm_end - vma->vm_start,
                                       vma->vm_page_prot))
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index c658dde3633b..fa2de70f7401 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -106,7 +106,7 @@ static int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
        unlock_kernel();
        if (io_remap_pfn_range(vma, vma->vm_start,
-                               VM_OFFSET(vma) >> PAGE_SHIFT,
+                               vma->vm_pgoff,
                               vma->vm_end - vma->vm_start, vma->vm_page_prot))
                return -EAGAIN;
        return 0;
@@ -141,10 +141,10 @@ static int i810_map_buffer(drm_buf_t * buf, struct file *filp)
                                            MAP_SHARED, buf->bus_address);
        dev_priv->mmap_buffer = NULL;
        filp->f_op = old_fops;
-        if ((unsigned long)buf_priv->virtual > -1024UL) {
+        if (IS_ERR(buf_priv->virtual)) {
                /* Real error */
                DRM_ERROR("mmap error\n");
-                retcode = (signed int)buf_priv->virtual;
+                retcode = PTR_ERR(buf_priv->virtual);
                buf_priv->virtual = NULL;
        }
        up_write(&current->mm->mmap_sem);
@@ -808,7 +808,7 @@ static void i810_dma_dispatch_vertex(drm_device_t * dev,
                    ((GFX_OP_PRIMITIVE | prim | ((used / 4) - 2)));
                if (used & 4) {
-                        *(u32 *) ((u32) buf_priv->kernel_virtual + used) = 0;
+                        *(u32 *) ((char *) buf_priv->kernel_virtual + used) = 0;
                        used += 4;
                }
@@ -1166,7 +1166,7 @@ static void i810_dma_dispatch_mc(drm_device_t * dev, drm_buf_t * buf, int used,
        if (buf_priv->currently_mapped == I810_BUF_MAPPED) {
                if (used & 4) {
-                        *(u32 *) ((u32) buf_priv->virtual + used) = 0;
+                        *(u32 *) ((char *) buf_priv->virtual + used) = 0;
                        used += 4;
                }
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index b0f815d8cea8..4f0e5746ab33 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -108,7 +108,7 @@ static int i830_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
        unlock_kernel();
        if (io_remap_pfn_range(vma, vma->vm_start,
-                               VM_OFFSET(vma) >> PAGE_SHIFT,
+                               vma->vm_pgoff,
                               vma->vm_end - vma->vm_start, vma->vm_page_prot))
                return -EAGAIN;
        return 0;
@@ -146,7 +146,7 @@ static int i830_map_buffer(drm_buf_t * buf, struct file *filp)
        if (IS_ERR((void *)virtual)) {  /* ugh */
                /* Real error */
                DRM_ERROR("mmap error\n");
-                retcode = virtual;
+                retcode = PTR_ERR((void *)virtual);
                buf_priv->virtual = NULL;
        } else {
                buf_priv->virtual = (void __user *)virtual;
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
index a94233bdbc0e..fb7913ff5286 100644
--- a/drivers/char/drm/i915_dma.c
+++ b/drivers/char/drm/i915_dma.c
@@ -31,6 +31,11 @@
 #include "i915_drm.h"
 #include "i915_drv.h"
+#define IS_I965G(dev) (dev->pci_device == 0x2972 || \
+                       dev->pci_device == 0x2982 || \
+                       dev->pci_device == 0x2992 || \
+                       dev->pci_device == 0x29A2)
 /* Really want an OS-independent resettable timer.  Would like to have
 * this loop run for (eg) 3 sec, but have the timer reset every time
 * the head pointer changes, so that EBUSY only happens if the ring
@@ -255,7 +260,7 @@ static int i915_dma_init(DRM_IOCTL_ARGS)
                retcode = i915_dma_resume(dev);
                break;
        default:
-                retcode = -EINVAL;
+                retcode = DRM_ERR(EINVAL);
                break;
        }
@@ -347,7 +352,7 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
        if ((dwords+1) * sizeof(int) >= dev_priv->ring.Size - 8)
                return DRM_ERR(EINVAL);
-        BEGIN_LP_RING(((dwords+1)&~1));
+        BEGIN_LP_RING((dwords+1)&~1);
        for (i = 0; i < dwords;) {
                int cmd, sz;
@@ -386,7 +391,7 @@ static int i915_emit_box(drm_device_t * dev,
        RING_LOCALS;
        if (DRM_COPY_FROM_USER_UNCHECKED(&box, &boxes[i], sizeof(box))) {
-                return EFAULT;
+                return DRM_ERR(EFAULT);
        }
        if (box.y2 <= box.y1 || box.x2 <= box.x1 || box.y2 <= 0 || box.x2 <= 0) {
@@ -395,24 +400,40 @@ static int i915_emit_box(drm_device_t * dev,
                return DRM_ERR(EINVAL);
        }
-        BEGIN_LP_RING(6);
+        if (IS_I965G(dev)) {
-        OUT_RING(GFX_OP_DRAWRECT_INFO);
+                BEGIN_LP_RING(4);
-        OUT_RING(DR1);
+                OUT_RING(GFX_OP_DRAWRECT_INFO_I965);
-        OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
+                OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
-        OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
+                OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
-        OUT_RING(DR4);
+                OUT_RING(DR4);
-        OUT_RING(0);
+                ADVANCE_LP_RING();
-        ADVANCE_LP_RING();
+        } else {
+                BEGIN_LP_RING(6);
+                OUT_RING(GFX_OP_DRAWRECT_INFO);
+                OUT_RING(DR1);
+                OUT_RING((box.x1 & 0xffff) | (box.y1 << 16));
+                OUT_RING(((box.x2 - 1) & 0xffff) | ((box.y2 - 1) << 16));
+                OUT_RING(DR4);
+                OUT_RING(0);
+                ADVANCE_LP_RING();
+        }
        return 0;
 }
+/* XXX: Emitting the counter should really be moved to part of the IRQ
+ * emit. For now, do it in both places:
+ */
 static void i915_emit_breadcrumb(drm_device_t *dev)
 {
        drm_i915_private_t *dev_priv = dev->dev_private;
        RING_LOCALS;
-        dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
+        dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
+        if (dev_priv->counter > 0x7FFFFFFFUL)
+                dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
        BEGIN_LP_RING(4);
        OUT_RING(CMD_STORE_DWORD_IDX);
diff --git a/drivers/char/drm/i915_drm.h b/drivers/char/drm/i915_drm.h
index 5aa3e0e3bb45..6af83e613f27 100644
--- a/drivers/char/drm/i915_drm.h
+++ b/drivers/char/drm/i915_drm.h
@@ -98,6 +98,12 @@ typedef struct _drm_i915_sarea {
        int rotated_size;
        int rotated_pitch;
        int virtualX, virtualY;
+        unsigned int front_tiled;
+        unsigned int back_tiled;
+        unsigned int depth_tiled;
+        unsigned int rotated_tiled;
+        unsigned int rotated2_tiled;
 } drm_i915_sarea_t;
 /* Flags for perf_boxes
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index 2d565031c002..fdc2bf192714 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -146,9 +146,9 @@ extern void i915_mem_release(drm_device_t * dev,
 #define BEGIN_LP_RING(n) do {                           \
        if (I915_VERBOSE)                               \
                DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n",  \
-                          n, __FUNCTION__);             \
+                          (n), __FUNCTION__);           \
-        if (dev_priv->ring.space < n*4)                 \
+        if (dev_priv->ring.space < (n)*4)                       \
-                i915_wait_ring(dev, n*4, __FUNCTION__);         \
+                i915_wait_ring(dev, (n)*4, __FUNCTION__);               \
        outcount = 0;                                   \
        outring = dev_priv->ring.tail;                  \
        ringmask = dev_priv->ring.tail_mask;            \
@@ -157,7 +157,7 @@ extern void i915_mem_release(drm_device_t * dev,
 #define OUT_RING(n) do {                                        \
        if (I915_VERBOSE) DRM_DEBUG("   OUT_RING %x\n", (int)(n));      \
-        *(volatile unsigned int *)(virt + outring) = n;         \
+        *(volatile unsigned int *)(virt + outring) = (n);       \
        outcount++;                                             \
        outring += 4;                                           \
        outring &= ringmask;                                    \
@@ -254,6 +254,8 @@ extern int i915_wait_ring(drm_device_t * dev, int n, const char *caller);
 #define GFX_OP_DESTBUFFER_VARS   ((0x3<<29)|(0x1d<<24)|(0x85<<16)|0x0)
 #define GFX_OP_DRAWRECT_INFO     ((0x3<<29)|(0x1d<<24)|(0x80<<16)|(0x3))
+#define GFX_OP_DRAWRECT_INFO_I965 ((0x7900<<16)|0x2)
 #define MI_BATCH_BUFFER         ((0x30<<23)|1)
 #define MI_BATCH_BUFFER_START   (0x31<<23)
 #define MI_BATCH_BUFFER_END     (0xA<<23)
diff --git a/drivers/char/drm/i915_irq.c b/drivers/char/drm/i915_irq.c
index cd96cfa430db..0d4a162aa385 100644
--- a/drivers/char/drm/i915_irq.c
+++ b/drivers/char/drm/i915_irq.c
@@ -71,21 +71,27 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 static int i915_emit_irq(drm_device_t * dev)
 {
        drm_i915_private_t *dev_priv = dev->dev_private;
-        u32 ret;
        RING_LOCALS;
        i915_kernel_lost_context(dev);
        DRM_DEBUG("%s\n", __FUNCTION__);
-        ret = dev_priv->counter;
+        dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
-        BEGIN_LP_RING(2);
+        if (dev_priv->counter > 0x7FFFFFFFUL)
+                dev_priv->sarea_priv->last_enqueue = dev_priv->counter = 1;
+        BEGIN_LP_RING(6);
+        OUT_RING(CMD_STORE_DWORD_IDX);
+        OUT_RING(20);
+        OUT_RING(dev_priv->counter);
+        OUT_RING(0);
        OUT_RING(0);
        OUT_RING(GFX_OP_USER_INTERRUPT);
        ADVANCE_LP_RING();
+        
-        return ret;
+        return dev_priv->counter;
 }
 static int i915_wait_irq(drm_device_t * dev, int irq_nr)
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 5ad43ba7b5aa..5ed965688293 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -864,13 +864,13 @@ static int radeon_do_pixcache_flush(drm_radeon_private_t * dev_priv)
        dev_priv->stats.boxes |= RADEON_BOX_WAIT_IDLE;
-        tmp = RADEON_READ(RADEON_RB2D_DSTCACHE_CTLSTAT);
+        tmp = RADEON_READ(RADEON_RB3D_DSTCACHE_CTLSTAT);
-        tmp |= RADEON_RB2D_DC_FLUSH_ALL;
+        tmp |= RADEON_RB3D_DC_FLUSH_ALL;
-        RADEON_WRITE(RADEON_RB2D_DSTCACHE_CTLSTAT, tmp);
+        RADEON_WRITE(RADEON_RB3D_DSTCACHE_CTLSTAT, tmp);
        for (i = 0; i < dev_priv->usec_timeout; i++) {
-                if (!(RADEON_READ(RADEON_RB2D_DSTCACHE_CTLSTAT)
+                if (!(RADEON_READ(RADEON_RB3D_DSTCACHE_CTLSTAT)
-                      & RADEON_RB2D_DC_BUSY)) {
+                      & RADEON_RB3D_DC_BUSY)) {
                        return 0;
                }
                DRM_UDELAY(1);
@@ -1130,7 +1130,7 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
                             | (dev_priv->fb_location >> 16));
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                RADEON_WRITE(RADEON_AGP_BASE, (unsigned int)dev->agp->base);
                RADEON_WRITE(RADEON_MC_AGP_LOCATION,
                             (((dev_priv->gart_vm_start - 1 +
@@ -1158,7 +1158,7 @@ static void radeon_cp_init_ring_buffer(drm_device_t * dev,
        dev_priv->ring.tail = cur_read_ptr;
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                RADEON_WRITE(RADEON_CP_RB_RPTR_ADDR,
                             dev_priv->ring_rptr->offset
                             - dev->agp->base + dev_priv->gart_vm_start);
@@ -1258,6 +1258,13 @@ static void radeon_test_writeback(drm_radeon_private_t * dev_priv)
                dev_priv->writeback_works = 0;
                DRM_INFO("writeback forced off\n");
        }
+        if (!dev_priv->writeback_works) {
+                /* Disable writeback to avoid unnecessary bus master transfer */
+                RADEON_WRITE(RADEON_CP_RB_CNTL, RADEON_READ(RADEON_CP_RB_CNTL) |
+                             RADEON_RB_NO_UPDATE);
+                RADEON_WRITE(RADEON_SCRATCH_UMSK, 0);
+        }
 }
 /* Enable or disable PCI-E GART on the chip */
@@ -1295,7 +1302,7 @@ static void radeon_set_pcigart(drm_radeon_private_t * dev_priv, int on)
 {
        u32 tmp;
-        if (dev_priv->flags & CHIP_IS_PCIE) {
+        if (dev_priv->flags & RADEON_IS_PCIE) {
                radeon_set_pciegart(dev_priv, on);
                return;
        }
@@ -1333,20 +1340,22 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
        DRM_DEBUG("\n");
        /* if we require new memory map but we don't have it fail */
-        if ((dev_priv->flags & CHIP_NEW_MEMMAP) && !dev_priv->new_memmap)
+        if ((dev_priv->flags & RADEON_NEW_MEMMAP) && !dev_priv->new_memmap) {
-        {
+                DRM_ERROR("Cannot initialise DRM on this card\nThis card requires a new X.org DDX for 3D\n");
-                DRM_ERROR("Cannot initialise DRM on this card\nThis card requires a new X.org DDX\n");
                radeon_do_cleanup_cp(dev);
                return DRM_ERR(EINVAL);
        }
-        if (init->is_pci && (dev_priv->flags & CHIP_IS_AGP))
+        if (init->is_pci && (dev_priv->flags & RADEON_IS_AGP)) {
-        {
                DRM_DEBUG("Forcing AGP card to PCI mode\n");
-                dev_priv->flags &= ~CHIP_IS_AGP;
+                dev_priv->flags &= ~RADEON_IS_AGP;
+        } else if (!(dev_priv->flags & (RADEON_IS_AGP | RADEON_IS_PCI | RADEON_IS_PCIE))
+                   && !init->is_pci) {
+                DRM_DEBUG("Restoring AGP flag\n");
+                dev_priv->flags |= RADEON_IS_AGP;
        }
-        if ((!(dev_priv->flags & CHIP_IS_AGP)) && !dev->sg) {
+        if ((!(dev_priv->flags & RADEON_IS_AGP)) && !dev->sg) {
                DRM_ERROR("PCI GART memory not allocated!\n");
                radeon_do_cleanup_cp(dev);
                return DRM_ERR(EINVAL);
@@ -1489,7 +1498,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                                    init->sarea_priv_offset);
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                drm_core_ioremap(dev_priv->cp_ring, dev);
                drm_core_ioremap(dev_priv->ring_rptr, dev);
                drm_core_ioremap(dev->agp_buffer_map, dev);
@@ -1548,7 +1557,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                 * align it down.
                 */
 #if __OS_HAS_AGP
-                if (dev_priv->flags & CHIP_IS_AGP) {
+                if (dev_priv->flags & RADEON_IS_AGP) {
                        base = dev->agp->base;
                        /* Check if valid */
                        if ((base + dev_priv->gart_size) > dev_priv->fb_location &&
@@ -1578,7 +1587,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
        }
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP)
+        if (dev_priv->flags & RADEON_IS_AGP)
                dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
                                                 - dev->agp->base
                                                 + dev_priv->gart_vm_start);
@@ -1604,7 +1613,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
        dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                /* Turn off PCI GART */
                radeon_set_pcigart(dev_priv, 0);
        } else
@@ -1624,7 +1633,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                            dev_priv->gart_info.mapping.handle;
                        dev_priv->gart_info.is_pcie =
-                            !!(dev_priv->flags & CHIP_IS_PCIE);
+                            !!(dev_priv->flags & RADEON_IS_PCIE);
                        dev_priv->gart_info.gart_table_location =
                            DRM_ATI_GART_FB;
@@ -1636,7 +1645,7 @@ static int radeon_do_init_cp(drm_device_t * dev, drm_radeon_init_t * init)
                            DRM_ATI_GART_MAIN;
                        dev_priv->gart_info.addr = NULL;
                        dev_priv->gart_info.bus_addr = 0;
-                        if (dev_priv->flags & CHIP_IS_PCIE) {
+                        if (dev_priv->flags & RADEON_IS_PCIE) {
                                DRM_ERROR
                                    ("Cannot use PCI Express without GART in FB memory\n");
                                radeon_do_cleanup_cp(dev);
@@ -1678,7 +1687,7 @@ static int radeon_do_cleanup_cp(drm_device_t * dev)
                drm_irq_uninstall(dev);
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                if (dev_priv->cp_ring != NULL) {
                        drm_core_ioremapfree(dev_priv->cp_ring, dev);
                        dev_priv->cp_ring = NULL;
@@ -1733,7 +1742,7 @@ static int radeon_do_resume_cp(drm_device_t * dev)
        DRM_DEBUG("Starting radeon_do_resume_cp()\n");
 #if __OS_HAS_AGP
-        if (dev_priv->flags & CHIP_IS_AGP) {
+        if (dev_priv->flags & RADEON_IS_AGP) {
                /* Turn off PCI GART */
                radeon_set_pcigart(dev_priv, 0);
        } else
@@ -2177,13 +2186,15 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
        dev->dev_private = (void *)dev_priv;
        dev_priv->flags = flags;
-        switch (flags & CHIP_FAMILY_MASK) {
+        switch (flags & RADEON_FAMILY_MASK) {
        case CHIP_R100:
        case CHIP_RV200:
        case CHIP_R200:
        case CHIP_R300:
+        case CHIP_R350:
        case CHIP_R420:
-                dev_priv->flags |= CHIP_HAS_HIERZ;
+        case CHIP_RV410:
+                dev_priv->flags |= RADEON_HAS_HIERZ;
                break;
        default:
                /* all other chips have no hierarchical z buffer */
@@ -2191,13 +2202,14 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
        }
        if (drm_device_is_agp(dev))
-                dev_priv->flags |= CHIP_IS_AGP;
+                dev_priv->flags |= RADEON_IS_AGP;
+        else if (drm_device_is_pcie(dev))
-        if (drm_device_is_pcie(dev))
+                dev_priv->flags |= RADEON_IS_PCIE;
-                dev_priv->flags |= CHIP_IS_PCIE;
+        else
+                dev_priv->flags |= RADEON_IS_PCI;
        DRM_DEBUG("%s card detected\n",
-                  ((dev_priv->flags & CHIP_IS_AGP) ? "AGP" : (((dev_priv->flags & CHIP_IS_PCIE) ? "PCIE" : "PCI"))));
+                  ((dev_priv->flags & RADEON_IS_AGP) ? "AGP" : (((dev_priv->flags & RADEON_IS_PCIE) ? "PCIE" : "PCI"))));
        return ret;
 }
diff --git a/drivers/char/drm/radeon_drv.c b/drivers/char/drm/radeon_drv.c
index eb985c2a31e9..2eb652ec6745 100644
--- a/drivers/char/drm/radeon_drv.c
+++ b/drivers/char/drm/radeon_drv.c
@@ -44,7 +44,7 @@ module_param_named(no_wb, radeon_no_wb, int, 0444);
 static int dri_library_name(struct drm_device *dev, char *buf)
 {
        drm_radeon_private_t *dev_priv = dev->dev_private;
-        int family = dev_priv->flags & CHIP_FAMILY_MASK;
+        int family = dev_priv->flags & RADEON_FAMILY_MASK;
        return snprintf(buf, PAGE_SIZE, "%s\n",
                        (family < CHIP_R200) ? "radeon" :
diff --git a/drivers/char/drm/radeon_drv.h b/drivers/char/drm/radeon_drv.h
index e5a256f5429c..f45cd7f147a5 100644
--- a/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@ -133,15 +133,16 @@ enum radeon_cp_microcode_version {
 * Chip flags
 */
 enum radeon_chip_flags {
-        CHIP_FAMILY_MASK = 0x0000ffffUL,
+        RADEON_FAMILY_MASK = 0x0000ffffUL,
-        CHIP_FLAGS_MASK = 0xffff0000UL,
+        RADEON_FLAGS_MASK = 0xffff0000UL,
-        CHIP_IS_MOBILITY = 0x00010000UL,
+        RADEON_IS_MOBILITY = 0x00010000UL,
-        CHIP_IS_IGP = 0x00020000UL,
+        RADEON_IS_IGP = 0x00020000UL,
-        CHIP_SINGLE_CRTC = 0x00040000UL,
+        RADEON_SINGLE_CRTC = 0x00040000UL,
-        CHIP_IS_AGP = 0x00080000UL,
+        RADEON_IS_AGP = 0x00080000UL,
-        CHIP_HAS_HIERZ = 0x00100000UL,
+        RADEON_HAS_HIERZ = 0x00100000UL,
-        CHIP_IS_PCIE = 0x00200000UL,
+        RADEON_IS_PCIE = 0x00200000UL,
-        CHIP_NEW_MEMMAP = 0x00400000UL,
+        RADEON_NEW_MEMMAP = 0x00400000UL,
+        RADEON_IS_PCI = 0x00800000UL,
 };
 #define GET_RING_HEAD(dev_priv) (dev_priv->writeback_works ? \
@@ -424,6 +425,8 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #define RADEON_RB3D_COLOROFFSET         0x1c40
 #define RADEON_RB3D_COLORPITCH          0x1c48
+#define RADEON_SRC_X_Y                  0x1590
 #define RADEON_DP_GUI_MASTER_CNTL       0x146c
 #       define RADEON_GMC_SRC_PITCH_OFFSET_CNTL (1 << 0)
 #       define RADEON_GMC_DST_PITCH_OFFSET_CNTL (1 << 1)
@@ -441,6 +444,7 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #       define RADEON_ROP3_S                    0x00cc0000
 #       define RADEON_ROP3_P                    0x00f00000
 #define RADEON_DP_WRITE_MASK            0x16cc
+#define RADEON_SRC_PITCH_OFFSET         0x1428
 #define RADEON_DST_PITCH_OFFSET         0x142c
 #define RADEON_DST_PITCH_OFFSET_C       0x1c80
 #       define RADEON_DST_TILE_LINEAR           (0 << 30)
@@ -545,6 +549,11 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #       define RADEON_RB3D_ZC_FREE              (1 << 2)
 #       define RADEON_RB3D_ZC_FLUSH_ALL         0x5
 #       define RADEON_RB3D_ZC_BUSY              (1 << 31)
+#define RADEON_RB3D_DSTCACHE_CTLSTAT    0x325c
+#       define RADEON_RB3D_DC_FLUSH             (3 << 0)
+#       define RADEON_RB3D_DC_FREE              (3 << 2)
+#       define RADEON_RB3D_DC_FLUSH_ALL         0xf
+#       define RADEON_RB3D_DC_BUSY              (1 << 31)
 #define RADEON_RB3D_ZSTENCILCNTL        0x1c2c
 #       define RADEON_Z_TEST_MASK               (7 << 4)
 #       define RADEON_Z_TEST_ALWAYS             (7 << 4)
@@ -681,6 +690,7 @@ extern int r300_do_cp_cmdbuf(drm_device_t * dev, DRMFILE filp,
 #define RADEON_CP_RB_BASE               0x0700
 #define RADEON_CP_RB_CNTL               0x0704
 #       define RADEON_BUF_SWAP_32BIT            (2 << 16)
+#       define RADEON_RB_NO_UPDATE              (1 << 27)
 #define RADEON_CP_RB_RPTR_ADDR          0x070c
 #define RADEON_CP_RB_RPTR               0x0710
 #define RADEON_CP_RB_WPTR               0x0714
@@ -986,13 +996,13 @@ do {									\
 } while (0)
 #define RADEON_FLUSH_CACHE() do {                                       \
-        OUT_RING( CP_PACKET0( RADEON_RB2D_DSTCACHE_CTLSTAT, 0 ) );      \
+        OUT_RING( CP_PACKET0( RADEON_RB3D_DSTCACHE_CTLSTAT, 0 ) );      \
-        OUT_RING( RADEON_RB2D_DC_FLUSH );                               \
+        OUT_RING( RADEON_RB3D_DC_FLUSH );                               \
 } while (0)
 #define RADEON_PURGE_CACHE() do {                                       \
-        OUT_RING( CP_PACKET0( RADEON_RB2D_DSTCACHE_CTLSTAT, 0 ) );      \
+        OUT_RING( CP_PACKET0( RADEON_RB3D_DSTCACHE_CTLSTAT, 0 ) );      \
-        OUT_RING( RADEON_RB2D_DC_FLUSH_ALL );                           \
+        OUT_RING( RADEON_RB3D_DC_FLUSH_ALL );                           \
 } while (0)
 #define RADEON_FLUSH_ZCACHE() do {                                      \
diff --git a/drivers/char/drm/radeon_state.c b/drivers/char/drm/radeon_state.c
index 39a7f685e3fd..feac5f005d47 100644
--- a/drivers/char/drm/radeon_state.c
+++ b/drivers/char/drm/radeon_state.c
@@ -42,7 +42,11 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
                                                    drm_file_t * filp_priv,
                                                    u32 *offset)
 {
-        u32 off = *offset;
+        u64 off = *offset;
+        u32 fb_start = dev_priv->fb_location;
+        u32 fb_end = fb_start + dev_priv->fb_size - 1;
+        u32 gart_start = dev_priv->gart_vm_start;
+        u32 gart_end = gart_start + dev_priv->gart_size - 1;
        struct drm_radeon_driver_file_fields *radeon_priv;
        /* Hrm ... the story of the offset ... So this function converts
@@ -62,10 +66,8 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
        /* First, the best case, the offset already lands in either the
         * framebuffer or the GART mapped space
         */
-        if ((off >= dev_priv->fb_location &&
+        if ((off >= fb_start && off <= fb_end) ||
-             off < (dev_priv->fb_location + dev_priv->fb_size)) ||
+            (off >= gart_start && off <= gart_end))
-            (off >= dev_priv->gart_vm_start &&
-             off < (dev_priv->gart_vm_start + dev_priv->gart_size)))
                return 0;
        /* Ok, that didn't happen... now check if we have a zero based
@@ -78,16 +80,13 @@ static __inline__ int radeon_check_and_fixup_offset(drm_radeon_private_t *
        }
        /* Finally, assume we aimed at a GART offset if beyond the fb */
-        if (off > (dev_priv->fb_location + dev_priv->fb_size))
+        if (off > fb_end)
-                off = off - (dev_priv->fb_location + dev_priv->fb_size) +
+                off = off - fb_end - 1 + gart_start;
-                        dev_priv->gart_vm_start;
        /* Now recheck and fail if out of bounds */
-        if ((off >= dev_priv->fb_location &&
+        if ((off >= fb_start && off <= fb_end) ||
-             off < (dev_priv->fb_location + dev_priv->fb_size)) ||
+            (off >= gart_start && off <= gart_end)) {
-            (off >= dev_priv->gart_vm_start &&
+                DRM_DEBUG("offset fixed up to 0x%x\n", (unsigned int)off);
-             off < (dev_priv->gart_vm_start + dev_priv->gart_size))) {
-                DRM_DEBUG("offset fixed up to 0x%x\n", off);
                *offset = off;
                return 0;
        }
@@ -869,7 +868,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
                 */
                dev_priv->sarea_priv->ctx_owner = 0;
-                if ((dev_priv->flags & CHIP_HAS_HIERZ)
+                if ((dev_priv->flags & RADEON_HAS_HIERZ)
                    && (flags & RADEON_USE_HIERZ)) {
                        /* FIXME : reverse engineer that for Rx00 cards */
                        /* FIXME : the mask supposedly contains low-res z values. So can't set
@@ -914,7 +913,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
                for (i = 0; i < nbox; i++) {
                        int tileoffset, nrtilesx, nrtilesy, j;
                        /* it looks like r200 needs rv-style clears, at least if hierz is not enabled? */
-                        if ((dev_priv->flags & CHIP_HAS_HIERZ)
+                        if ((dev_priv->flags & RADEON_HAS_HIERZ)
                            && !(dev_priv->microcode_version == UCODE_R200)) {
                                /* FIXME : figure this out for r200 (when hierz is enabled). Or
                                   maybe r200 actually doesn't need to put the low-res z value into
@@ -998,7 +997,7 @@ static void radeon_cp_dispatch_clear(drm_device_t * dev,
                }
                /* TODO don't always clear all hi-level z tiles */
-                if ((dev_priv->flags & CHIP_HAS_HIERZ)
+                if ((dev_priv->flags & RADEON_HAS_HIERZ)
                    && (dev_priv->microcode_version == UCODE_R200)
                    && (flags & RADEON_USE_HIERZ))
                        /* r100 and cards without hierarchical z-buffer have no high-level z-buffer */
@@ -1270,9 +1269,9 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
                DRM_DEBUG("dispatch swap %d,%d-%d,%d\n", x, y, w, h);
-                BEGIN_RING(7);
+                BEGIN_RING(9);
-                OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT_MULTI, 5));
+                OUT_RING(CP_PACKET0(RADEON_DP_GUI_MASTER_CNTL, 0));
                OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL |
                         RADEON_GMC_DST_PITCH_OFFSET_CNTL |
                         RADEON_GMC_BRUSH_NONE |
@@ -1284,6 +1283,7 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
                /* Make this work even if front & back are flipped:
                 */
+                OUT_RING(CP_PACKET0(RADEON_SRC_PITCH_OFFSET, 1));
                if (dev_priv->current_page == 0) {
                        OUT_RING(dev_priv->back_pitch_offset);
                        OUT_RING(dev_priv->front_pitch_offset);
@@ -1292,6 +1292,7 @@ static void radeon_cp_dispatch_swap(drm_device_t * dev)
                        OUT_RING(dev_priv->back_pitch_offset);
                }
+                OUT_RING(CP_PACKET0(RADEON_SRC_X_Y, 2));
                OUT_RING((x << 16) | y);
                OUT_RING((x << 16) | y);
                OUT_RING((w << 16) | h);
@@ -2987,16 +2988,21 @@ static int radeon_cp_getparam(DRM_IOCTL_ARGS)
        case RADEON_PARAM_GART_TEX_HANDLE:
                value = dev_priv->gart_textures_offset;
                break;
-        
+        case RADEON_PARAM_SCRATCH_OFFSET:
+                if (!dev_priv->writeback_works)
+                        return DRM_ERR(EINVAL);
+                value = RADEON_SCRATCH_REG_OFFSET;
+                break;
        case RADEON_PARAM_CARD_TYPE:
-                if (dev_priv->flags & CHIP_IS_PCIE)
+                if (dev_priv->flags & RADEON_IS_PCIE)
                        value = RADEON_CARD_PCIE;
-                else if (dev_priv->flags & CHIP_IS_AGP)
+                else if (dev_priv->flags & RADEON_IS_AGP)
                        value = RADEON_CARD_AGP;
                else
                        value = RADEON_CARD_PCI;
                break;
        default:
+                DRM_DEBUG("Invalid parameter %d\n", param.param);
                return DRM_ERR(EINVAL);
        }
diff --git a/drivers/char/drm/sis_drv.c b/drivers/char/drm/sis_drv.c
index 5e9dc86f2956..3d5b3218b6ff 100644
--- a/drivers/char/drm/sis_drv.c
+++ b/drivers/char/drm/sis_drv.c
@@ -35,11 +35,44 @@ static struct pci_device_id pciidlist[] = {
        sisdrv_PCI_IDS
 };
+static int sis_driver_load(drm_device_t *dev, unsigned long chipset)
+{
+        drm_sis_private_t *dev_priv;
+        int ret;
+        dev_priv = drm_calloc(1, sizeof(drm_sis_private_t), DRM_MEM_DRIVER);
+        if (dev_priv == NULL)
+                return DRM_ERR(ENOMEM);
+        dev->dev_private = (void *)dev_priv;
+        dev_priv->chipset = chipset;
+        ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
+        if (ret) {
+                drm_free(dev_priv, sizeof(dev_priv), DRM_MEM_DRIVER);
+        }
+        return ret;
+}
+static int sis_driver_unload(drm_device_t *dev)
+{
+        drm_sis_private_t *dev_priv = dev->dev_private;
+        drm_sman_takedown(&dev_priv->sman);
+        drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+        return 0;
+}
 static struct drm_driver driver = {
        .driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR,
-        .context_ctor = sis_init_context,
+        .load = sis_driver_load,
-        .context_dtor = sis_final_context,
+        .unload = sis_driver_unload,
-        .reclaim_buffers = drm_core_reclaim_buffers,
+        .context_dtor = NULL,
+        .dma_quiescent = sis_idle,
+        .reclaim_buffers = NULL,
+        .reclaim_buffers_locked = sis_reclaim_buffers_locked,
+        .lastclose = sis_lastclose,
        .get_map_ofs = drm_core_get_map_ofs,
        .get_reg_ofs = drm_core_get_reg_ofs,
        .ioctls = sis_ioctls,
diff --git a/drivers/char/drm/sis_drv.h b/drivers/char/drm/sis_drv.h
index e218e5269503..2b8d6f6ed7c0 100644
--- a/drivers/char/drm/sis_drv.h
+++ b/drivers/char/drm/sis_drv.h
@@ -31,23 +31,39 @@
 /* General customization:
 */
-#define DRIVER_AUTHOR           "SIS"
+#define DRIVER_AUTHOR           "SIS, Tungsten Graphics"
 #define DRIVER_NAME             "sis"
 #define DRIVER_DESC             "SIS 300/630/540"
-#define DRIVER_DATE             "20030826"
+#define DRIVER_DATE             "20060704"
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            1
+#define DRIVER_MINOR            2
-#define DRIVER_PATCHLEVEL       0
+#define DRIVER_PATCHLEVEL       1
-#include "sis_ds.h"
+enum sis_family {
+        SIS_OTHER = 0,
+        SIS_CHIP_315 = 1,
+};
+#include "drm_sman.h"
+#define SIS_BASE (dev_priv->mmio)
+#define SIS_READ(reg)         DRM_READ32(SIS_BASE, reg);
+#define SIS_WRITE(reg, val)   DRM_WRITE32(SIS_BASE, reg, val);
 typedef struct drm_sis_private {
-        memHeap_t *AGPHeap;
+        drm_local_map_t *mmio;
-        memHeap_t *FBHeap;
+        unsigned int idle_fault;
+        drm_sman_t sman;
+        unsigned int chipset;
+        int vram_initialized;
+        int agp_initialized;
+        unsigned long vram_offset;
+        unsigned long agp_offset;
 } drm_sis_private_t;
-extern int sis_init_context(drm_device_t * dev, int context);
+extern int sis_idle(drm_device_t *dev);
-extern int sis_final_context(drm_device_t * dev, int context);
+extern void sis_reclaim_buffers_locked(drm_device_t *dev, struct file *filp);
+extern void sis_lastclose(drm_device_t *dev);
 extern drm_ioctl_desc_t sis_ioctls[];
 extern int sis_max_ioctl;
diff --git a/drivers/char/drm/sis_ds.c b/drivers/char/drm/sis_ds.c
deleted file mode 100644
index 2e485d482943..000000000000
--- a/drivers/char/drm/sis_ds.c
+++ /dev/null
@@ -1,299 +0,0 @@
-/* sis_ds.c -- Private header for Direct Rendering Manager -*- linux-c -*-
- * Created: Mon Jan  4 10:05:05 1999 by sclin@sis.com.tw
- *
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Sung-Ching Lin <sclin@sis.com.tw>
- *
- */
-#include "drmP.h"
-#include "drm.h"
-#include "sis_ds.h"
-/* Set Data Structure, not check repeated value
- * temporarily used
- */
-set_t *setInit(void)
-{
-        int i;
-        set_t *set;
-        set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
-        if (set != NULL) {
-                for (i = 0; i < SET_SIZE; i++) {
-                        set->list[i].free_next = i + 1;
-                        set->list[i].alloc_next = -1;
-                }
-                set->list[SET_SIZE - 1].free_next = -1;
-                set->free = 0;
-                set->alloc = -1;
-                set->trace = -1;
-        }
-        return set;
-}
-int setAdd(set_t * set, ITEM_TYPE item)
-{
-        int free = set->free;
-        if (free != -1) {
-                set->list[free].val = item;
-                set->free = set->list[free].free_next;
-        } else {
-                return 0;
-        }
-        set->list[free].alloc_next = set->alloc;
-        set->alloc = free;
-        set->list[free].free_next = -1;
-        return 1;
-}
-int setDel(set_t * set, ITEM_TYPE item)
-{
-        int alloc = set->alloc;
-        int prev = -1;
-        while (alloc != -1) {
-                if (set->list[alloc].val == item) {
-                        if (prev != -1)
-                                set->list[prev].alloc_next =
-                                    set->list[alloc].alloc_next;
-                        else
-                                set->alloc = set->list[alloc].alloc_next;
-                        break;
-                }
-                prev = alloc;
-                alloc = set->list[alloc].alloc_next;
-        }
-        if (alloc == -1)
-                return 0;
-        set->list[alloc].free_next = set->free;
-        set->free = alloc;
-        set->list[alloc].alloc_next = -1;
-        return 1;
-}
-/* setFirst -> setAdd -> setNext is wrong */
-int setFirst(set_t * set, ITEM_TYPE * item)
-{
-        if (set->alloc == -1)
-                return 0;
-        *item = set->list[set->alloc].val;
-        set->trace = set->list[set->alloc].alloc_next;
-        return 1;
-}
-int setNext(set_t * set, ITEM_TYPE * item)
-{
-        if (set->trace == -1)
-                return 0;
-        *item = set->list[set->trace].val;
-        set->trace = set->list[set->trace].alloc_next;
-        return 1;
-}
-int setDestroy(set_t * set)
-{
-        drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
-        return 1;
-}
-/*
- * GLX Hardware Device Driver common code
- * Copyright (C) 1999 Wittawat Yamwong
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-#define ISFREE(bptr) ((bptr)->free)
-memHeap_t *mmInit(int ofs, int size)
-{
-        PMemBlock blocks;
-        if (size <= 0)
-                return NULL;
-        blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
-        if (blocks != NULL) {
-                blocks->ofs = ofs;
-                blocks->size = size;
-                blocks->free = 1;
-                return (memHeap_t *) blocks;
-        } else
-                return NULL;
-}
-/* Checks if a pointer 'b' is part of the heap 'heap' */
-int mmBlockInHeap(memHeap_t * heap, PMemBlock b)
-{
-        TMemBlock *p;
-        if (heap == NULL || b == NULL)
-                return 0;
-        p = heap;
-        while (p != NULL && p != b) {
-                p = p->next;
-        }
-        if (p == b)
-                return 1;
-        else
-                return 0;
-}
-static TMemBlock *SliceBlock(TMemBlock * p,
-                             int startofs, int size,
-                             int reserved, int alignment)
-{
-        TMemBlock *newblock;
-        /* break left */
-        if (startofs > p->ofs) {
-                newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                                    DRM_MEM_DRIVER);
-                newblock->ofs = startofs;
-                newblock->size = p->size - (startofs - p->ofs);
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size -= newblock->size;
-                p->next = newblock;
-                p = newblock;
-        }
-        /* break right */
-        if (size < p->size) {
-                newblock = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                                    DRM_MEM_DRIVER);
-                newblock->ofs = startofs + size;
-                newblock->size = p->size - size;
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size = size;
-                p->next = newblock;
-        }
-        /* p = middle block */
-        p->align = alignment;
-        p->free = 0;
-        p->reserved = reserved;
-        return p;
-}
-PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch)
-{
-        int mask, startofs, endofs;
-        TMemBlock *p;
-        if (heap == NULL || align2 < 0 || size <= 0)
-                return NULL;
-        mask = (1 << align2) - 1;
-        startofs = 0;
-        p = (TMemBlock *) heap;
-        while (p != NULL) {
-                if (ISFREE(p)) {
-                        startofs = (p->ofs + mask) & ~mask;
-                        if (startofs < startSearch) {
-                                startofs = startSearch;
-                        }
-                        endofs = startofs + size;
-                        if (endofs <= (p->ofs + p->size))
-                                break;
-                }
-                p = p->next;
-        }
-        if (p == NULL)
-                return NULL;
-        p = SliceBlock(p, startofs, size, 0, mask + 1);
-        p->heap = heap;
-        return p;
-}
-static __inline__ int Join2Blocks(TMemBlock * p)
-{
-        if (p->free && p->next && p->next->free) {
-                TMemBlock *q = p->next;
-                p->size += q->size;
-                p->next = q->next;
-                drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
-                return 1;
-        }
-        return 0;
-}
-int mmFreeMem(PMemBlock b)
-{
-        TMemBlock *p, *prev;
-        if (b == NULL)
-                return 0;
-        if (b->heap == NULL)
-                return -1;
-        p = b->heap;
-        prev = NULL;
-        while (p != NULL && p != b) {
-                prev = p;
-                p = p->next;
-        }
-        if (p == NULL || p->free || p->reserved)
-                return -1;
-        p->free = 1;
-        Join2Blocks(p);
-        if (prev)
-                Join2Blocks(prev);
-        return 0;
-}
diff --git a/drivers/char/drm/sis_ds.h b/drivers/char/drm/sis_ds.h
deleted file mode 100644
index 94f2b4728b63..000000000000
--- a/drivers/char/drm/sis_ds.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/* sis_ds.h -- Private header for Direct Rendering Manager -*- linux-c -*- 
- * Created: Mon Jan  4 10:05:05 1999 by sclin@sis.com.tw
- */
-/*
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Sung-Ching Lin <sclin@sis.com.tw>
- *
- */
-#ifndef __SIS_DS_H__
-#define __SIS_DS_H__
-/* Set Data Structure */
-#define SET_SIZE 5000
-typedef unsigned long ITEM_TYPE;
-typedef struct {
-        ITEM_TYPE val;
-        int alloc_next, free_next;
-} list_item_t;
-typedef struct {
-        int alloc;
-        int free;
-        int trace;
-        list_item_t list[SET_SIZE];
-} set_t;
-set_t *setInit(void);
-int setAdd(set_t * set, ITEM_TYPE item);
-int setDel(set_t * set, ITEM_TYPE item);
-int setFirst(set_t * set, ITEM_TYPE * item);
-int setNext(set_t * set, ITEM_TYPE * item);
-int setDestroy(set_t * set);
-/*
- * GLX Hardware Device Driver common code
- * Copyright (C) 1999 Wittawat Yamwong
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * WITTAWAT YAMWONG, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
- * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- */
-struct mem_block_t {
-        struct mem_block_t *next;
-        struct mem_block_t *heap;
-        int ofs, size;
-        int align;
-        unsigned int free:1;
-        unsigned int reserved:1;
-};
-typedef struct mem_block_t TMemBlock;
-typedef struct mem_block_t *PMemBlock;
-/* a heap is just the first block in a chain */
-typedef struct mem_block_t memHeap_t;
-static __inline__ int mmBlockSize(PMemBlock b)
-{
-        return b->size;
-}
-static __inline__ int mmOffset(PMemBlock b)
-{
-        return b->ofs;
-}
-static __inline__ void mmMarkReserved(PMemBlock b)
-{
-        b->reserved = 1;
-}
-/*
- * input: total size in bytes
- * return: a heap pointer if OK, NULL if error
- */
-memHeap_t *mmInit(int ofs, int size);
-/*
- * Allocate 'size' bytes with 2^align2 bytes alignment,
- * restrict the search to free memory after 'startSearch'
- * depth and back buffers should be in different 4mb banks
- * to get better page hits if possible
- * input:       size = size of block
- *              align2 = 2^align2 bytes alignment
- *              startSearch = linear offset from start of heap to begin search
- * return: pointer to the allocated block, 0 if error
- */
-PMemBlock mmAllocMem(memHeap_t * heap, int size, int align2, int startSearch);
-/*
- * Returns 1 if the block 'b' is part of the heap 'heap'
- */
-int mmBlockInHeap(PMemBlock heap, PMemBlock b);
-/*
- * Free block starts at offset
- * input: pointer to a block
- * return: 0 if OK, -1 if error
- */
-int mmFreeMem(PMemBlock b);
-/* For debuging purpose. */
-void mmDumpMemInfo(memHeap_t * mmInit);
-#endif                          /* __SIS_DS_H__ */
diff --git a/drivers/char/drm/sis_mm.c b/drivers/char/drm/sis_mm.c
index 5e9936bc307f..d26f5dbb7853 100644
--- a/drivers/char/drm/sis_mm.c
+++ b/drivers/char/drm/sis_mm.c
@@ -1,414 +1,348 @@
-/* sis_mm.c -- Private header for Direct Rendering Manager -*- linux-c -*-
+/**************************************************************************
- * Created: Mon Jan  4 10:05:05 1999 by sclin@sis.com.tw
 *
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
- * All rights reserved.
+ * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
+ * copy of this software and associated documentation files (the
- * to deal in the Software without restriction, including without limitation
+ * "Software"), to deal in the Software without restriction, including
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * without limitation the rights to use, copy, modify, merge, publish,
- * and/or sell copies of the Software, and to permit persons to whom the
+ * distribute, sub license, and/or sell copies of the Software, and to
- * Software is furnished to do so, subject to the following conditions:
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
 *
- * The above copyright notice and this permission notice (including the next
+ * The above copyright notice and this permission notice (including the
- * paragraph) shall be included in all copies or substantial portions of the
+ * next paragraph) shall be included in all copies or substantial portions
- * Software.
+ * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * DEALINGS IN THE SOFTWARE.
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
- * Authors:
- *    Sung-Ching Lin <sclin@sis.com.tw>
 *
+ **************************************************************************/
+/*
+ * Authors:
+ *    Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
 */
 #include "drmP.h"
 #include "sis_drm.h"
 #include "sis_drv.h"
-#include "sis_ds.h"
-#if defined(__linux__) && defined(CONFIG_FB_SIS)
 #include <video/sisfb.h>
-#endif
-#define MAX_CONTEXT 100
 #define VIDEO_TYPE 0
 #define AGP_TYPE 1
-typedef struct {
-        int used;
-        int context;
-        set_t *sets[2];         /* 0 for video, 1 for AGP */
-} sis_context_t;
-static sis_context_t global_ppriv[MAX_CONTEXT];
+#if defined(CONFIG_FB_SIS)
+/* fb management via fb device */
-static int add_alloc_set(int context, int type, unsigned int val)
+#define SIS_MM_ALIGN_SHIFT 0
-{
+#define SIS_MM_ALIGN_MASK 0
-        int i, retval = 0;
-        for (i = 0; i < MAX_CONTEXT; i++) {
+static void *sis_sman_mm_allocate(void *private, unsigned long size,
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
+                                  unsigned alignment)
-                        retval = setAdd(global_ppriv[i].sets[type], val);
-                        break;
-                }
-        }
-        return retval;
-}
-static int del_alloc_set(int context, int type, unsigned int val)
 {
-        int i, retval = 0;
+        struct sis_memreq req;
-        for (i = 0; i < MAX_CONTEXT; i++) {
+        req.size = size;
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
+        sis_malloc(&req);
-                        retval = setDel(global_ppriv[i].sets[type], val);
+        if (req.size == 0)
-                        break;
+                return NULL;
-                }
+        else
-        }
+                return (void *)~req.offset;
-        return retval;
 }
-/* fb management via fb device */
+static void sis_sman_mm_free(void *private, void *ref)
-#if defined(__linux__) && defined(CONFIG_FB_SIS)
-static int sis_fb_init(DRM_IOCTL_ARGS)
 {
-        return 0;
+        sis_free(~((unsigned long)ref));
 }
-static int sis_fb_alloc(DRM_IOCTL_ARGS)
+static void sis_sman_mm_destroy(void *private)
 {
-        drm_sis_mem_t fb;
+        ;
-        struct sis_memreq req;
-        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *)data;
-        int retval = 0;
-        DRM_COPY_FROM_USER_IOCTL(fb, argp, sizeof(fb));
-        req.size = fb.size;
-        sis_malloc(&req);
-        if (req.offset) {
-                /* TODO */
-                fb.offset = req.offset;
-                fb.free = req.offset;
-                if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        sis_free(req.offset);
-                        retval = DRM_ERR(EINVAL);
-                }
-        } else {
-                fb.offset = 0;
-                fb.size = 0;
-                fb.free = 0;
-        }
-        DRM_COPY_TO_USER_IOCTL(argp, fb, sizeof(fb));
-        DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, req.offset);
-        return retval;
 }
-static int sis_fb_free(DRM_IOCTL_ARGS)
+static unsigned long sis_sman_mm_offset(void *private, void *ref)
 {
-        drm_sis_mem_t fb;
+        return ~((unsigned long)ref);
-        int retval = 0;
+}
-        DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t __user *) data, sizeof(fb));
-        if (!fb.free)
-                return DRM_ERR(EINVAL);
-        if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
+#else /* CONFIG_FB_SIS */
-                retval = DRM_ERR(EINVAL);
-        sis_free(fb.free);
-        DRM_DEBUG("free fb, offset = 0x%lx\n", fb.free);
+#define SIS_MM_ALIGN_SHIFT 4
+#define SIS_MM_ALIGN_MASK ( (1 << SIS_MM_ALIGN_SHIFT) - 1)
-        return retval;
+#endif /* CONFIG_FB_SIS */
-}
-#else
-/* Called by the X Server to initialize the FB heap.  Allocations will fail
- * unless this is called.  Offset is the beginning of the heap from the
- * framebuffer offset (MaxXFBMem in XFree86).
- *
- * Memory layout according to Thomas Winischofer:
- * |------------------|DDDDDDDDDDDDDDDDDDDDDDDDDDDDD|HHHH|CCCCCCCCCCC|
- *
- *    X driver/sisfb                                  HW-   Command-
- *  framebuffer memory           DRI heap           Cursor   queue
- */
 static int sis_fb_init(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
        drm_sis_private_t *dev_priv = dev->dev_private;
        drm_sis_fb_t fb;
+        int ret;
        DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_fb_t __user *) data, sizeof(fb));
-        if (dev_priv == NULL) {
+        mutex_lock(&dev->struct_mutex);
-                dev->dev_private = drm_calloc(1, sizeof(drm_sis_private_t),
+#if defined(CONFIG_FB_SIS)
-                                              DRM_MEM_DRIVER);
+        {
-                dev_priv = dev->dev_private;
+                drm_sman_mm_t sman_mm;
-                if (dev_priv == NULL)
+                sman_mm.private = (void *)0xFFFFFFFF;
-                        return ENOMEM;
+                sman_mm.allocate = sis_sman_mm_allocate;
+                sman_mm.free = sis_sman_mm_free;
+                sman_mm.destroy = sis_sman_mm_destroy;
+                sman_mm.offset = sis_sman_mm_offset;
+                ret =
+                    drm_sman_set_manager(&dev_priv->sman, VIDEO_TYPE, &sman_mm);
        }
+#else
+        ret = drm_sman_set_range(&dev_priv->sman, VIDEO_TYPE, 0,
+                                 fb.size >> SIS_MM_ALIGN_SHIFT);
+#endif
-        if (dev_priv->FBHeap != NULL)
+        if (ret) {
-                return DRM_ERR(EINVAL);
+                DRM_ERROR("VRAM memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
-        dev_priv->FBHeap = mmInit(fb.offset, fb.size);
+        dev_priv->vram_initialized = 1;
+        dev_priv->vram_offset = fb.offset;
+        mutex_unlock(&dev->struct_mutex);
        DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
        return 0;
 }
-static int sis_fb_alloc(DRM_IOCTL_ARGS)
+static int sis_drm_alloc(drm_device_t * dev, drm_file_t * priv,
+                         unsigned long data, int pool)
 {
-        DRM_DEVICE;
        drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *)data;
+        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *) data;
-        drm_sis_mem_t fb;
+        drm_sis_mem_t mem;
-        PMemBlock block;
        int retval = 0;
+        drm_memblock_item_t *item;
+        DRM_COPY_FROM_USER_IOCTL(mem, argp, sizeof(mem));
-        if (dev_priv == NULL || dev_priv->FBHeap == NULL)
+        mutex_lock(&dev->struct_mutex);
+        if (0 == ((pool == 0) ? dev_priv->vram_initialized :
+                      dev_priv->agp_initialized)) {
+                DRM_ERROR
+                    ("Attempt to allocate from uninitialized memory manager.\n");
                return DRM_ERR(EINVAL);
+        }
-        DRM_COPY_FROM_USER_IOCTL(fb, argp, sizeof(fb));
+        mem.size = (mem.size + SIS_MM_ALIGN_MASK) >> SIS_MM_ALIGN_SHIFT;
+        item = drm_sman_alloc(&dev_priv->sman, pool, mem.size, 0,
-        block = mmAllocMem(dev_priv->FBHeap, fb.size, 0, 0);
+                              (unsigned long)priv);
-        if (block) {
-                /* TODO */
+        mutex_unlock(&dev->struct_mutex);
-                fb.offset = block->ofs;
+        if (item) {
-                fb.free = (unsigned long)block;
+                mem.offset = ((pool == 0) ?
-                if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {
+                              dev_priv->vram_offset : dev_priv->agp_offset) +
-                        DRM_DEBUG("adding to allocation set fails\n");
+                    (item->mm->
-                        mmFreeMem((PMemBlock) fb.free);
+                     offset(item->mm, item->mm_info) << SIS_MM_ALIGN_SHIFT);
-                        retval = DRM_ERR(EINVAL);
+                mem.free = item->user_hash.key;
-                }
+                mem.size = mem.size << SIS_MM_ALIGN_SHIFT;
        } else {
-                fb.offset = 0;
+                mem.offset = 0;
-                fb.size = 0;
+                mem.size = 0;
-                fb.free = 0;
+                mem.free = 0;
+                retval = DRM_ERR(ENOMEM);
        }
-        DRM_COPY_TO_USER_IOCTL(argp, fb, sizeof(fb));
+        DRM_COPY_TO_USER_IOCTL(argp, mem, sizeof(mem));
-        DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, fb.offset);
+        DRM_DEBUG("alloc %d, size = %d, offset = %d\n", pool, mem.size,
+                  mem.offset);
        return retval;
 }
-static int sis_fb_free(DRM_IOCTL_ARGS)
+static int sis_drm_free(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
        drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t fb;
+        drm_sis_mem_t mem;
+        int ret;
-        if (dev_priv == NULL || dev_priv->FBHeap == NULL)
+        DRM_COPY_FROM_USER_IOCTL(mem, (drm_sis_mem_t __user *) data,
-                return DRM_ERR(EINVAL);
+                                 sizeof(mem));
-        DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t __user *) data, sizeof(fb));
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_free_key(&dev_priv->sman, mem.free);
+        mutex_unlock(&dev->struct_mutex);
+        DRM_DEBUG("free = 0x%lx\n", mem.free);
-        if (!mmBlockInHeap(dev_priv->FBHeap, (PMemBlock) fb.free))
+        return ret;
-                return DRM_ERR(EINVAL);
-        if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
-                return DRM_ERR(EINVAL);
-        mmFreeMem((PMemBlock) fb.free);
-        DRM_DEBUG("free fb, free = 0x%lx\n", fb.free);
-        return 0;
 }
-#endif
+static int sis_fb_alloc(DRM_IOCTL_ARGS)
+{
-/* agp memory management */
+        DRM_DEVICE;
+        return sis_drm_alloc(dev, priv, data, VIDEO_TYPE);
+}
 static int sis_ioctl_agp_init(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
        drm_sis_private_t *dev_priv = dev->dev_private;
        drm_sis_agp_t agp;
+        int ret;
-        if (dev_priv == NULL) {
+        dev_priv = dev->dev_private;
-                dev->dev_private = drm_calloc(1, sizeof(drm_sis_private_t),
-                                              DRM_MEM_DRIVER);
-                dev_priv = dev->dev_private;
-                if (dev_priv == NULL)
-                        return ENOMEM;
-        }
-        if (dev_priv->AGPHeap != NULL)
-                return DRM_ERR(EINVAL);
        DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_agp_t __user *) data,
                                 sizeof(agp));
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_set_range(&dev_priv->sman, AGP_TYPE, 0,
+                                 agp.size >> SIS_MM_ALIGN_SHIFT);
+        if (ret) {
+                DRM_ERROR("AGP memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
-        dev_priv->AGPHeap = mmInit(agp.offset, agp.size);
+        dev_priv->agp_initialized = 1;
+        dev_priv->agp_offset = agp.offset;
+        mutex_unlock(&dev->struct_mutex);
        DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
        return 0;
 }
 static int sis_ioctl_agp_alloc(DRM_IOCTL_ARGS)
 {
        DRM_DEVICE;
-        drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *)data;
-        drm_sis_mem_t agp;
-        PMemBlock block;
-        int retval = 0;
-        if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
+        return sis_drm_alloc(dev, priv, data, AGP_TYPE);
-                return DRM_ERR(EINVAL);
+}
-        DRM_COPY_FROM_USER_IOCTL(agp, argp, sizeof(agp));
+static drm_local_map_t *sis_reg_init(drm_device_t *dev)
+{
-        block = mmAllocMem(dev_priv->AGPHeap, agp.size, 0, 0);
+        drm_map_list_t *entry;
-        if (block) {
+        drm_local_map_t *map;
-                /* TODO */
-                agp.offset = block->ofs;
+        list_for_each_entry(entry, &dev->maplist->head, head) {
-                agp.free = (unsigned long)block;
+                map = entry->map;
-                if (!add_alloc_set(agp.context, AGP_TYPE, agp.free)) {
+                if (!map)
-                        DRM_DEBUG("adding to allocation set fails\n");
+                        continue;
-                        mmFreeMem((PMemBlock) agp.free);
+                if (map->type == _DRM_REGISTERS) {
-                        retval = -1;
+                        return map;
                }
-        } else {
-                agp.offset = 0;
-                agp.size = 0;
-                agp.free = 0;
        }
+        return NULL;
-        DRM_COPY_TO_USER_IOCTL(argp, agp, sizeof(agp));
-        DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, agp.offset);
-        return retval;
 }
-static int sis_ioctl_agp_free(DRM_IOCTL_ARGS)
+int sis_idle(drm_device_t *dev)
 {
-        DRM_DEVICE;
        drm_sis_private_t *dev_priv = dev->dev_private;
-        drm_sis_mem_t agp;
+        uint32_t idle_reg;
+        unsigned long end;
-        if (dev_priv == NULL || dev_priv->AGPHeap == NULL)
+        int i;
-                return DRM_ERR(EINVAL);
-        DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_mem_t __user *) data,
+        if (dev_priv->idle_fault)
-                                 sizeof(agp));
+                return 0;
-        if (!mmBlockInHeap(dev_priv->AGPHeap, (PMemBlock) agp.free))
+        if (dev_priv->mmio == NULL) {
-                return DRM_ERR(EINVAL);
+                dev_priv->mmio = sis_reg_init(dev);
+                if (dev_priv->mmio == NULL) {
+                        DRM_ERROR("Could not find register map.\n");
+                        return 0;
+                }
+        }
+        
+        /*
+         * Implement a device switch here if needed
+         */
+        if (dev_priv->chipset != SIS_CHIP_315)
+                return 0;
+        /*
+         * Timeout after 3 seconds. We cannot use DRM_WAIT_ON here
+         * because its polling frequency is too low.
+         */
+        end = jiffies + (DRM_HZ * 3);
+        for (i=0; i<4; ++i) {
+                do {
+                        idle_reg = SIS_READ(0x85cc);
+                } while ( !time_after_eq(jiffies, end) &&
+                          ((idle_reg & 0x80000000) != 0x80000000));
+        }
-        mmFreeMem((PMemBlock) agp.free);
+        if (time_after_eq(jiffies, end)) {
-        if (!del_alloc_set(agp.context, AGP_TYPE, agp.free))
+                DRM_ERROR("Graphics engine idle timeout. "
-                return DRM_ERR(EINVAL);
+                          "Disabling idle check\n");
+                dev_priv->idle_fault = 1;
+        }
-        DRM_DEBUG("free agp, free = 0x%lx\n", agp.free);
+        /*
+         * The caller never sees an error code. It gets trapped
+         * in libdrm.
+         */
        return 0;
 }
-int sis_init_context(struct drm_device *dev, int context)
-{
-        int i;
-        for (i = 0; i < MAX_CONTEXT; i++) {
+void sis_lastclose(struct drm_device *dev)
-                if (global_ppriv[i].used &&
+{
-                    (global_ppriv[i].context == context))
+        drm_sis_private_t *dev_priv = dev->dev_private;
-                        break;
-        }
-        if (i >= MAX_CONTEXT) {
+        if (!dev_priv)
-                for (i = 0; i < MAX_CONTEXT; i++) {
+                return;
-                        if (!global_ppriv[i].used) {
-                                global_ppriv[i].context = context;
-                                global_ppriv[i].used = 1;
-                                global_ppriv[i].sets[0] = setInit();
-                                global_ppriv[i].sets[1] = setInit();
-                                DRM_DEBUG("init allocation set, socket=%d, "
-                                          "context = %d\n", i, context);
-                                break;
-                        }
-                }
-                if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
-                    (global_ppriv[i].sets[1] == NULL)) {
-                        return 0;
-                }
-        }
-        return 1;
+        mutex_lock(&dev->struct_mutex);
+        drm_sman_cleanup(&dev_priv->sman);
+        dev_priv->vram_initialized = 0;
+        dev_priv->agp_initialized = 0;
+        dev_priv->mmio = NULL;
+        mutex_unlock(&dev->struct_mutex);
 }
-int sis_final_context(struct drm_device *dev, int context)
+void sis_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
 {
-        int i;
+        drm_sis_private_t *dev_priv = dev->dev_private;
+        drm_file_t *priv = filp->private_data;
-        for (i = 0; i < MAX_CONTEXT; i++) {
+        mutex_lock(&dev->struct_mutex);
-                if (global_ppriv[i].used &&
+        if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
-                    (global_ppriv[i].context == context))
+                mutex_unlock(&dev->struct_mutex);
-                        break;
+                return;
        }
-        if (i < MAX_CONTEXT) {
+        if (dev->driver->dma_quiescent) {
-                set_t *set;
+                dev->driver->dma_quiescent(dev);
-                ITEM_TYPE item;
-                int retval;
-                DRM_DEBUG("find socket %d, context = %d\n", i, context);
-                /* Video Memory */
-                set = global_ppriv[i].sets[0];
-                retval = setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free video memory 0x%lx\n", item);
-#if defined(__linux__) && defined(CONFIG_FB_SIS)
-                        sis_free(item);
-#else
-                        mmFreeMem((PMemBlock) item);
-#endif
-                        retval = setNext(set, &item);
-                }
-                setDestroy(set);
-                /* AGP Memory */
-                set = global_ppriv[i].sets[1];
-                retval = setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free agp memory 0x%lx\n", item);
-                        mmFreeMem((PMemBlock) item);
-                        retval = setNext(set, &item);
-                }
-                setDestroy(set);
-                global_ppriv[i].used = 0;
        }
-        return 1;
+        drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)priv);
+        mutex_unlock(&dev->struct_mutex);
+        return;
 }
 drm_ioctl_desc_t sis_ioctls[] = {
        [DRM_IOCTL_NR(DRM_SIS_FB_ALLOC)] = {sis_fb_alloc, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_FB_FREE)] = {sis_fb_free, DRM_AUTH},
+        [DRM_IOCTL_NR(DRM_SIS_FB_FREE)] = {sis_drm_free, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_AGP_INIT)] = {sis_ioctl_agp_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+        [DRM_IOCTL_NR(DRM_SIS_AGP_INIT)] =
+            {sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY},
        [DRM_IOCTL_NR(DRM_SIS_AGP_ALLOC)] = {sis_ioctl_agp_alloc, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_AGP_FREE)] = {sis_ioctl_agp_free, DRM_AUTH},
+        [DRM_IOCTL_NR(DRM_SIS_AGP_FREE)] = {sis_drm_free, DRM_AUTH},
-        [DRM_IOCTL_NR(DRM_SIS_FB_INIT)] = {sis_fb_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY}
+        [DRM_IOCTL_NR(DRM_SIS_FB_INIT)] =
+            {sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY}
 };
 int sis_max_ioctl = DRM_ARRAY_SIZE(sis_ioctls);
diff --git a/drivers/char/drm/via_dmablit.c b/drivers/char/drm/via_dmablit.c
index 78a81a4a99c5..60c1695db300 100644
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -41,9 +41,9 @@
 #include <linux/pagemap.h>
-#define VIA_PGDN(x)             (((unsigned long)(x)) & PAGE_MASK)
+#define VIA_PGDN(x)          (((unsigned long)(x)) & PAGE_MASK)
-#define VIA_PGOFF(x)            (((unsigned long)(x)) & ~PAGE_MASK)
+#define VIA_PGOFF(x)        (((unsigned long)(x)) & ~PAGE_MASK)
-#define VIA_PFN(x)              ((unsigned long)(x) >> PAGE_SHIFT)
+#define VIA_PFN(x)            ((unsigned long)(x) >> PAGE_SHIFT)
 typedef struct _drm_via_descriptor {
        uint32_t mem_addr;
@@ -121,19 +121,19 @@ via_map_blit_for_device(struct pci_dev *pdev,
                
                while (line_len > 0) {
-                        remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem), line_len);
+                        remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem), line_len);
                        line_len -= remaining_len;
                        if (mode == 1) {
-                                desc_ptr->mem_addr = 
+                                desc_ptr->mem_addr = 
                                        dma_map_page(&pdev->dev, 
                                                     vsg->pages[VIA_PFN(cur_mem) - 
                                                                VIA_PFN(first_addr)],
                                                     VIA_PGOFF(cur_mem), remaining_len, 
                                                     vsg->direction);
-                                desc_ptr->dev_addr = cur_fb;
+                                desc_ptr->dev_addr = cur_fb;
                                
-                                desc_ptr->size = remaining_len;
+                                desc_ptr->size = remaining_len;
                                desc_ptr->next = (uint32_t) next;
                                next = dma_map_single(&pdev->dev, desc_ptr, sizeof(*desc_ptr), 
                                                      DMA_TO_DEVICE);
@@ -162,7 +162,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
 /*
 * Function that frees up all resources for a blit. It is usable even if the 
- * blit info has only be partially built as long as the status enum is consistent
+ * blit info has only been partially built as long as the status enum is consistent
 * with the actual status of the used resources.
 */
@@ -238,8 +238,11 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg,  drm_via_dmablit_t *xfer)
                return DRM_ERR(ENOMEM);
        memset(vsg->pages, 0, sizeof(struct page *) * vsg->num_pages);
        down_read(&current->mm->mmap_sem);
-        ret = get_user_pages(current, current->mm, (unsigned long) xfer->mem_addr,
+        ret = get_user_pages(current, current->mm,
-                             vsg->num_pages, vsg->direction, 0, vsg->pages, NULL);
+                             (unsigned long)xfer->mem_addr,
+                             vsg->num_pages,
+                             (vsg->direction == DMA_FROM_DEVICE),
+                             0, vsg->pages, NULL);
        up_read(&current->mm->mmap_sem);
        if (ret != vsg->num_pages) {
@@ -475,9 +478,15 @@ via_dmablit_timer(unsigned long data)
        if (!timer_pending(&blitq->poll_timer)) {
                blitq->poll_timer.expires = jiffies+1;
                add_timer(&blitq->poll_timer);
-        }
-        via_dmablit_handler(dev, engine, 0);
+               /*
+                * Rerun handler to delete timer if engines are off, and
+                * to shorten abort latency. This is a little nasty.
+                */
+               via_dmablit_handler(dev, engine, 0);
+        }
 }
@@ -597,15 +606,27 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
         * (Not a big limitation anyway.)
         */
-        if (((xfer->mem_stride - xfer->line_length) >= PAGE_SIZE) ||
+        if ((xfer->mem_stride - xfer->line_length) >= PAGE_SIZE) {
-            (xfer->mem_stride > 2048*4)) {
                DRM_ERROR("Too large system memory stride. Stride: %d, "
                          "Length: %d\n", xfer->mem_stride, xfer->line_length);
                return DRM_ERR(EINVAL);
        }
-        if (xfer->num_lines > 2048) {
+        if ((xfer->mem_stride == xfer->line_length) &&
-                DRM_ERROR("Too many PCI DMA bitblt lines.\n");
+           (xfer->fb_stride == xfer->line_length)) {
+                xfer->mem_stride *= xfer->num_lines;
+                xfer->line_length = xfer->mem_stride;
+                xfer->fb_stride = xfer->mem_stride;
+                xfer->num_lines = 1;
+        }
+        /*
+         * Don't lock an arbitrary large number of pages, since that causes a
+         * DOS security hole.
+         */
+        if (xfer->num_lines > 2048 || (xfer->num_lines*xfer->mem_stride > (2048*2048*4))) {
+                DRM_ERROR("Too large PCI DMA bitblt.\n");
                return DRM_ERR(EINVAL);
        }               
@@ -628,16 +649,17 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
 #ifdef VIA_BUGFREE
        if ((((unsigned long)xfer->mem_addr & 3) != ((unsigned long)xfer->fb_addr & 3)) ||
-            ((xfer->mem_stride & 3) != (xfer->fb_stride & 3))) {
+            ((xfer->num_lines > 1) && ((xfer->mem_stride & 3) != (xfer->fb_stride & 3)))) {
                DRM_ERROR("Invalid DRM bitblt alignment.\n");
-                return DRM_ERR(EINVAL);
+                return DRM_ERR(EINVAL);
        }
 #else
        if ((((unsigned long)xfer->mem_addr & 15) ||
-            ((unsigned long)xfer->fb_addr & 3)) || (xfer->mem_stride & 15) ||
+              ((unsigned long)xfer->fb_addr & 3)) ||
-            (xfer->fb_stride & 3)) {
+           ((xfer->num_lines > 1) && 
+           ((xfer->mem_stride & 15) || (xfer->fb_stride & 3)))) {
                DRM_ERROR("Invalid DRM bitblt alignment.\n");
-                return DRM_ERR(EINVAL);
+                return DRM_ERR(EINVAL);
        }       
 #endif
@@ -715,7 +737,7 @@ via_dmablit(drm_device_t *dev, drm_via_dmablit_t *xfer)
        drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
        drm_via_sg_info_t *vsg;
        drm_via_blitq_t *blitq;
-        int ret;
+        int ret;
        int engine;
        unsigned long irqsave;
@@ -756,7 +778,7 @@ via_dmablit(drm_device_t *dev, drm_via_dmablit_t *xfer)
 /*
 * Sync on a previously submitted blit. Note that the X server use signals extensively, and
- * that there is a very big proability that this IOCTL will be interrupted by a signal. In that
+ * that there is a very big probability that this IOCTL will be interrupted by a signal. In that
 * case it returns with -EAGAIN for the signal to be delivered. 
 * The caller should then reissue the IOCTL. This is similar to what is being done for drmGetLock().
 */
diff --git a/drivers/char/drm/via_drm.h b/drivers/char/drm/via_drm.h
index 47f0b5b26379..e4ee97d7156f 100644
--- a/drivers/char/drm/via_drm.h
+++ b/drivers/char/drm/via_drm.h
@@ -250,6 +250,12 @@ typedef struct drm_via_blitsync {
        unsigned engine;
 } drm_via_blitsync_t;
+/* - * Below,"flags" is currently unused but will be used for possible future
+ * extensions like kernel space bounce buffers for bad alignments and
+ * blit engine busy-wait polling for better latency in the absence of
+ * interrupts.
+ */
 typedef struct drm_via_dmablit {
        uint32_t num_lines;
        uint32_t line_length;
@@ -260,7 +266,7 @@ typedef struct drm_via_dmablit {
        unsigned char *mem_addr;
        uint32_t mem_stride;
-        int bounce_buffer;
+        uint32_t flags;
        int to_fb;
        drm_via_blitsync_t sync;
diff --git a/drivers/char/drm/via_drv.c b/drivers/char/drm/via_drv.c
index b3d364d793d7..bb9dde8b1911 100644
--- a/drivers/char/drm/via_drv.c
+++ b/drivers/char/drm/via_drv.c
@@ -43,7 +43,6 @@ static struct drm_driver driver = {
            DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
        .load = via_driver_load,
        .unload = via_driver_unload,
-        .context_ctor = via_init_context,
        .context_dtor = via_final_context,
        .vblank_wait = via_driver_vblank_wait,
        .irq_preinstall = via_driver_irq_preinstall,
@@ -53,6 +52,8 @@ static struct drm_driver driver = {
        .dma_quiescent = via_driver_dma_quiescent,
        .dri_library_name = dri_library_name,
        .reclaim_buffers = drm_core_reclaim_buffers,
+        .reclaim_buffers_locked = via_reclaim_buffers_locked,
+        .lastclose = via_lastclose,
        .get_map_ofs = drm_core_get_map_ofs,
        .get_reg_ofs = drm_core_get_reg_ofs,
        .ioctls = via_ioctls,
diff --git a/drivers/char/drm/via_drv.h b/drivers/char/drm/via_drv.h
index 52bcc7b1ba45..d21b5b75da0f 100644
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -24,15 +24,16 @@
 #ifndef _VIA_DRV_H_
 #define _VIA_DRV_H_
+#include "drm_sman.h"
 #define DRIVER_AUTHOR   "Various"
 #define DRIVER_NAME             "via"
 #define DRIVER_DESC             "VIA Unichrome / Pro"
-#define DRIVER_DATE             "20051116"
+#define DRIVER_DATE             "20060529"
 #define DRIVER_MAJOR            2
-#define DRIVER_MINOR            7
+#define DRIVER_MINOR            10
-#define DRIVER_PATCHLEVEL       4
+#define DRIVER_PATCHLEVEL       0
 #include "via_verifier.h"
@@ -85,6 +86,12 @@ typedef struct drm_via_private {
        uint32_t irq_enable_mask;
        uint32_t irq_pending_mask;
        int *irq_map;
+        unsigned int idle_fault;
+        drm_sman_t sman;
+        int vram_initialized;
+        int agp_initialized;
+        unsigned long vram_offset;
+        unsigned long agp_offset;
        drm_via_blitq_t blit_queues[VIA_NUM_BLIT_ENGINES];
 } drm_via_private_t;
@@ -135,6 +142,9 @@ extern void via_init_futex(drm_via_private_t * dev_priv);
 extern void via_cleanup_futex(drm_via_private_t * dev_priv);
 extern void via_release_futex(drm_via_private_t * dev_priv, int context);
+extern void via_reclaim_buffers_locked(drm_device_t *dev, struct file *filp);
+extern void via_lastclose(drm_device_t *dev);
 extern void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq);
 extern void via_init_dmablit(drm_device_t *dev);
diff --git a/drivers/char/drm/via_ds.c b/drivers/char/drm/via_ds.c
deleted file mode 100644
index 9429736b3b96..000000000000
--- a/drivers/char/drm/via_ds.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#include "drmP.h"
-#include "via_ds.h"
-extern unsigned int VIA_DEBUG;
-set_t *via_setInit(void)
-{
-        int i;
-        set_t *set;
-        set = (set_t *) drm_alloc(sizeof(set_t), DRM_MEM_DRIVER);
-        for (i = 0; i < SET_SIZE; i++) {
-                set->list[i].free_next = i + 1;
-                set->list[i].alloc_next = -1;
-        }
-        set->list[SET_SIZE - 1].free_next = -1;
-        set->free = 0;
-        set->alloc = -1;
-        set->trace = -1;
-        return set;
-}
-int via_setAdd(set_t * set, ITEM_TYPE item)
-{
-        int free = set->free;
-        if (free != -1) {
-                set->list[free].val = item;
-                set->free = set->list[free].free_next;
-        } else {
-                return 0;
-        }
-        set->list[free].alloc_next = set->alloc;
-        set->alloc = free;
-        set->list[free].free_next = -1;
-        return 1;
-}
-int via_setDel(set_t * set, ITEM_TYPE item)
-{
-        int alloc = set->alloc;
-        int prev = -1;
-        while (alloc != -1) {
-                if (set->list[alloc].val == item) {
-                        if (prev != -1)
-                                set->list[prev].alloc_next =
-                                    set->list[alloc].alloc_next;
-                        else
-                                set->alloc = set->list[alloc].alloc_next;
-                        break;
-                }
-                prev = alloc;
-                alloc = set->list[alloc].alloc_next;
-        }
-        if (alloc == -1)
-                return 0;
-        set->list[alloc].free_next = set->free;
-        set->free = alloc;
-        set->list[alloc].alloc_next = -1;
-        return 1;
-}
-/* setFirst -> setAdd -> setNext is wrong */
-int via_setFirst(set_t * set, ITEM_TYPE * item)
-{
-        if (set->alloc == -1)
-                return 0;
-        *item = set->list[set->alloc].val;
-        set->trace = set->list[set->alloc].alloc_next;
-        return 1;
-}
-int via_setNext(set_t * set, ITEM_TYPE * item)
-{
-        if (set->trace == -1)
-                return 0;
-        *item = set->list[set->trace].val;
-        set->trace = set->list[set->trace].alloc_next;
-        return 1;
-}
-int via_setDestroy(set_t * set)
-{
-        drm_free(set, sizeof(set_t), DRM_MEM_DRIVER);
-        return 1;
-}
-#define ISFREE(bptr) ((bptr)->free)
-#define fprintf(fmt, arg...) do{}while(0)
-memHeap_t *via_mmInit(int ofs, int size)
-{
-        PMemBlock blocks;
-        if (size <= 0)
-                return NULL;
-        blocks = (TMemBlock *) drm_calloc(1, sizeof(TMemBlock), DRM_MEM_DRIVER);
-        if (blocks) {
-                blocks->ofs = ofs;
-                blocks->size = size;
-                blocks->free = 1;
-                return (memHeap_t *) blocks;
-        } else
-                return NULL;
-}
-static TMemBlock *SliceBlock(TMemBlock * p,
-                             int startofs, int size,
-                             int reserved, int alignment)
-{
-        TMemBlock *newblock;
-        /* break left */
-        if (startofs > p->ofs) {
-                newblock =
-                    (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                             DRM_MEM_DRIVER);
-                newblock->ofs = startofs;
-                newblock->size = p->size - (startofs - p->ofs);
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size -= newblock->size;
-                p->next = newblock;
-                p = newblock;
-        }
-        /* break right */
-        if (size < p->size) {
-                newblock =
-                    (TMemBlock *) drm_calloc(1, sizeof(TMemBlock),
-                                             DRM_MEM_DRIVER);
-                newblock->ofs = startofs + size;
-                newblock->size = p->size - size;
-                newblock->free = 1;
-                newblock->next = p->next;
-                p->size = size;
-                p->next = newblock;
-        }
-        /* p = middle block */
-        p->align = alignment;
-        p->free = 0;
-        p->reserved = reserved;
-        return p;
-}
-PMemBlock via_mmAllocMem(memHeap_t * heap, int size, int align2,
-                         int startSearch)
-{
-        int mask, startofs, endofs;
-        TMemBlock *p;
-        if (!heap || align2 < 0 || size <= 0)
-                return NULL;
-        mask = (1 << align2) - 1;
-        startofs = 0;
-        p = (TMemBlock *) heap;
-        while (p) {
-                if (ISFREE(p)) {
-                        startofs = (p->ofs + mask) & ~mask;
-                        if (startofs < startSearch)
-                                startofs = startSearch;
-                        endofs = startofs + size;
-                        if (endofs <= (p->ofs + p->size))
-                                break;
-                }
-                p = p->next;
-        }
-        if (!p)
-                return NULL;
-        p = SliceBlock(p, startofs, size, 0, mask + 1);
-        p->heap = heap;
-        return p;
-}
-static __inline__ int Join2Blocks(TMemBlock * p)
-{
-        if (p->free && p->next && p->next->free) {
-                TMemBlock *q = p->next;
-                p->size += q->size;
-                p->next = q->next;
-                drm_free(q, sizeof(TMemBlock), DRM_MEM_DRIVER);
-                return 1;
-        }
-        return 0;
-}
-int via_mmFreeMem(PMemBlock b)
-{
-        TMemBlock *p, *prev;
-        if (!b)
-                return 0;
-        if (!b->heap) {
-                fprintf(stderr, "no heap\n");
-                return -1;
-        }
-        p = b->heap;
-        prev = NULL;
-        while (p && p != b) {
-                prev = p;
-                p = p->next;
-        }
-        if (!p || p->free || p->reserved) {
-                if (!p)
-                        fprintf(stderr, "block not found in heap\n");
-                else if (p->free)
-                        fprintf(stderr, "block already free\n");
-                else
-                        fprintf(stderr, "block is reserved\n");
-                return -1;
-        }
-        p->free = 1;
-        Join2Blocks(p);
-        if (prev)
-                Join2Blocks(prev);
-        return 0;
-}
diff --git a/drivers/char/drm/via_ds.h b/drivers/char/drm/via_ds.h
deleted file mode 100644
index d2bb9f37ca38..000000000000
--- a/drivers/char/drm/via_ds.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
- * Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-#ifndef _via_ds_h_
-#define _via_ds_h_
-#include "drmP.h"
-/* Set Data Structure */
-#define SET_SIZE 5000
-typedef unsigned long ITEM_TYPE;
-typedef struct {
-        ITEM_TYPE val;
-        int alloc_next, free_next;
-} list_item_t;
-typedef struct {
-        int alloc;
-        int free;
-        int trace;
-        list_item_t list[SET_SIZE];
-} set_t;
-set_t *via_setInit(void);
-int via_setAdd(set_t * set, ITEM_TYPE item);
-int via_setDel(set_t * set, ITEM_TYPE item);
-int via_setFirst(set_t * set, ITEM_TYPE * item);
-int via_setNext(set_t * set, ITEM_TYPE * item);
-int via_setDestroy(set_t * set);
-#endif
-#ifndef MM_INC
-#define MM_INC
-struct mem_block_t {
-        struct mem_block_t *next;
-        struct mem_block_t *heap;
-        int ofs, size;
-        int align;
-        unsigned int free:1;
-        unsigned int reserved:1;
-};
-typedef struct mem_block_t TMemBlock;
-typedef struct mem_block_t *PMemBlock;
-/* a heap is just the first block in a chain */
-typedef struct mem_block_t memHeap_t;
-static __inline__ int mmBlockSize(PMemBlock b)
-{
-        return b->size;
-}
-static __inline__ int mmOffset(PMemBlock b)
-{
-        return b->ofs;
-}
-static __inline__ void mmMarkReserved(PMemBlock b)
-{
-        b->reserved = 1;
-}
-/*
- * input: total size in bytes
- * return: a heap pointer if OK, NULL if error
- */
-memHeap_t *via_mmInit(int ofs, int size);
-PMemBlock via_mmAllocMem(memHeap_t * heap, int size, int align2,
-                         int startSearch);
-/*
- * Free block starts at offset
- * input: pointer to a block
- * return: 0 if OK, -1 if error
- */
-int via_mmFreeMem(PMemBlock b);
-#endif
diff --git a/drivers/char/drm/via_map.c b/drivers/char/drm/via_map.c
index c6a08e96285b..782011e0a58d 100644
--- a/drivers/char/drm/via_map.c
+++ b/drivers/char/drm/via_map.c
@@ -98,6 +98,7 @@ int via_map_init(DRM_IOCTL_ARGS)
 int via_driver_load(drm_device_t *dev, unsigned long chipset)
 {
        drm_via_private_t *dev_priv;
+        int ret = 0;
        dev_priv = drm_calloc(1, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
        if (dev_priv == NULL)
@@ -108,13 +109,19 @@ int via_driver_load(drm_device_t *dev, unsigned long chipset)
        if (chipset == VIA_PRO_GROUP_A)
                dev_priv->pro_group_a = 1;
-        return 0;
+        ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
+        if (ret) {
+                drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+        }
+        return ret;
 }
 int via_driver_unload(drm_device_t *dev)
 {
        drm_via_private_t *dev_priv = dev->dev_private;
+        drm_sman_takedown(&dev_priv->sman);
        drm_free(dev_priv, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
        return 0;
diff --git a/drivers/char/drm/via_mm.c b/drivers/char/drm/via_mm.c
index 33e0cb12e4c3..2fcf0577a7aa 100644
--- a/drivers/char/drm/via_mm.c
+++ b/drivers/char/drm/via_mm.c
@@ -1,6 +1,6 @@
 /*
- * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
+ * Copyright 2006 Tungsten Graphics Inc., Bismarck, ND., USA.
- * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
+ * All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -16,347 +16,194 @@
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * THE AUTHORS OR COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
+/*
+ * Authors: Thomas Hellstr�m <thomas-at-tungstengraphics-dot-com>
+ */
 #include "drmP.h"
 #include "via_drm.h"
 #include "via_drv.h"
-#include "via_ds.h"
+#include "drm_sman.h"
-#include "via_mm.h"
-#define MAX_CONTEXT 100
-typedef struct {
-        int used;
-        int context;
-        set_t *sets[2];         /* 0 for frame buffer, 1 for AGP , 2 for System */
-} via_context_t;
-static via_context_t global_ppriv[MAX_CONTEXT];
-static int via_agp_alloc(drm_via_mem_t * mem);
+#define VIA_MM_ALIGN_SHIFT 4
-static int via_agp_free(drm_via_mem_t * mem);
+#define VIA_MM_ALIGN_MASK ( (1 << VIA_MM_ALIGN_SHIFT) - 1)
-static int via_fb_alloc(drm_via_mem_t * mem);
-static int via_fb_free(drm_via_mem_t * mem);
-static int add_alloc_set(int context, int type, unsigned long val)
-{
-        int i, retval = 0;
-        for (i = 0; i < MAX_CONTEXT; i++) {
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
-                        retval = via_setAdd(global_ppriv[i].sets[type], val);
-                        break;
-                }
-        }
-        return retval;
-}
-static int del_alloc_set(int context, int type, unsigned long val)
-{
-        int i, retval = 0;
-        for (i = 0; i < MAX_CONTEXT; i++)
-                if (global_ppriv[i].used && global_ppriv[i].context == context) {
-                        retval = via_setDel(global_ppriv[i].sets[type], val);
-                        break;
-                }
-        return retval;
-}
-/* agp memory management */
-static memHeap_t *AgpHeap = NULL;
 int via_agp_init(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
        drm_via_agp_t agp;
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        int ret;
        DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t __user *) data,
                                 sizeof(agp));
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_AGP, 0,
+                                 agp.size >> VIA_MM_ALIGN_SHIFT);
+        if (ret) {
+                DRM_ERROR("AGP memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
-        AgpHeap = via_mmInit(agp.offset, agp.size);
+        dev_priv->agp_initialized = 1;
+        dev_priv->agp_offset = agp.offset;
-        DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset,
+        mutex_unlock(&dev->struct_mutex);
-                  (unsigned long)agp.size);
+        DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
        return 0;
 }
-/* fb memory management */
-static memHeap_t *FBHeap = NULL;
 int via_fb_init(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
        drm_via_fb_t fb;
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        int ret;
        DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t __user *) data, sizeof(fb));
-        FBHeap = via_mmInit(fb.offset, fb.size);
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_VIDEO, 0,
+                                 fb.size >> VIA_MM_ALIGN_SHIFT);
-        DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset,
+        if (ret) {
-                  (unsigned long)fb.size);
+                DRM_ERROR("VRAM memory manager initialisation error\n");
+                mutex_unlock(&dev->struct_mutex);
+                return ret;
+        }
-        return 0;
+        dev_priv->vram_initialized = 1;
-}
+        dev_priv->vram_offset = fb.offset;
-int via_init_context(struct drm_device *dev, int context)
+        mutex_unlock(&dev->struct_mutex);
-{
+        DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
-        int i;
+        return 0;
-        for (i = 0; i < MAX_CONTEXT; i++)
-                if (global_ppriv[i].used &&
-                    (global_ppriv[i].context == context))
-                        break;
-        if (i >= MAX_CONTEXT) {
-                for (i = 0; i < MAX_CONTEXT; i++) {
-                        if (!global_ppriv[i].used) {
-                                global_ppriv[i].context = context;
-                                global_ppriv[i].used = 1;
-                                global_ppriv[i].sets[0] = via_setInit();
-                                global_ppriv[i].sets[1] = via_setInit();
-                                DRM_DEBUG("init allocation set, socket=%d,"
-                                          " context = %d\n", i, context);
-                                break;
-                        }
-                }
-                if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
-                    (global_ppriv[i].sets[1] == NULL)) {
-                        return 0;
-                }
-        }
-        return 1;
 }
 int via_final_context(struct drm_device *dev, int context)
 {
-        int i;
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
-        for (i = 0; i < MAX_CONTEXT; i++)
-                if (global_ppriv[i].used &&
-                    (global_ppriv[i].context == context))
-                        break;
-        if (i < MAX_CONTEXT) {
-                set_t *set;
-                ITEM_TYPE item;
-                int retval;
-                DRM_DEBUG("find socket %d, context = %d\n", i, context);
-                /* Video Memory */
-                set = global_ppriv[i].sets[0];
-                retval = via_setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free video memory 0x%lx\n", item);
-                        via_mmFreeMem((PMemBlock) item);
-                        retval = via_setNext(set, &item);
-                }
-                via_setDestroy(set);
-                /* AGP Memory */
-                set = global_ppriv[i].sets[1];
-                retval = via_setFirst(set, &item);
-                while (retval) {
-                        DRM_DEBUG("free agp memory 0x%lx\n", item);
-                        via_mmFreeMem((PMemBlock) item);
-                        retval = via_setNext(set, &item);
-                }
-                via_setDestroy(set);
-                global_ppriv[i].used = 0;
-        }
        via_release_futex(dev_priv, context);
-#if defined(__linux__)
        /* Linux specific until context tracking code gets ported to BSD */
        /* Last context, perform cleanup */
        if (dev->ctx_count == 1 && dev->dev_private) {
                DRM_DEBUG("Last Context\n");
                if (dev->irq)
                        drm_irq_uninstall(dev);
                via_cleanup_futex(dev_priv);
                via_do_cleanup_map(dev);
        }
-#endif
        return 1;
 }
+void via_lastclose(struct drm_device *dev)
+{
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        if (!dev_priv)
+                return;
+        mutex_lock(&dev->struct_mutex);
+        drm_sman_cleanup(&dev_priv->sman);
+        dev_priv->vram_initialized = 0;
+        dev_priv->agp_initialized = 0;
+        mutex_unlock(&dev->struct_mutex);
+}       
 int via_mem_alloc(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
        drm_via_mem_t mem;
+        int retval = 0;
+        drm_memblock_item_t *item;
+        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+        unsigned long tmpSize;
        DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
                                 sizeof(mem));
-        switch (mem.type) {
+        if (mem.type > VIA_MEM_AGP) {
-        case VIA_MEM_VIDEO:
+                DRM_ERROR("Unknown memory type allocation\n");
-                if (via_fb_alloc(&mem) < 0)
+                return DRM_ERR(EINVAL);
-                        return -EFAULT;
-                DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
-                                       sizeof(mem));
-                return 0;
-        case VIA_MEM_AGP:
-                if (via_agp_alloc(&mem) < 0)
-                        return -EFAULT;
-                DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem,
-                                       sizeof(mem));
-                return 0;
        }
+        mutex_lock(&dev->struct_mutex);
-        return -EFAULT;
+        if (0 == ((mem.type == VIA_MEM_VIDEO) ? dev_priv->vram_initialized :
-}
+                      dev_priv->agp_initialized)) {
+                DRM_ERROR
-static int via_fb_alloc(drm_via_mem_t * mem)
+                    ("Attempt to allocate from uninitialized memory manager.\n");
-{
+                mutex_unlock(&dev->struct_mutex);
-        drm_via_mm_t fb;
+                return DRM_ERR(EINVAL);
-        PMemBlock block;
-        int retval = 0;
-        if (!FBHeap)
-                return -1;
-        fb.size = mem->size;
-        fb.context = mem->context;
-        block = via_mmAllocMem(FBHeap, fb.size, 5, 0);
-        if (block) {
-                fb.offset = block->ofs;
-                fb.free = (unsigned long)block;
-                if (!add_alloc_set(fb.context, VIA_MEM_VIDEO, fb.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        via_mmFreeMem((PMemBlock) fb.free);
-                        retval = -1;
-                }
-        } else {
-                fb.offset = 0;
-                fb.size = 0;
-                fb.free = 0;
-                retval = -1;
        }
-        mem->offset = fb.offset;
+        tmpSize = (mem.size + VIA_MM_ALIGN_MASK) >> VIA_MM_ALIGN_SHIFT;
-        mem->index = fb.free;
+        item = drm_sman_alloc(&dev_priv->sman, mem.type, tmpSize, 0,
+                              (unsigned long)priv);
-        DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size,
+        mutex_unlock(&dev->struct_mutex);
-                  (int)fb.offset);
+        if (item) {
+                mem.offset = ((mem.type == VIA_MEM_VIDEO) ?
-        return retval;
+                              dev_priv->vram_offset : dev_priv->agp_offset) +
-}
+                    (item->mm->
+                     offset(item->mm, item->mm_info) << VIA_MM_ALIGN_SHIFT);
-static int via_agp_alloc(drm_via_mem_t * mem)
+                mem.index = item->user_hash.key;
-{
-        drm_via_mm_t agp;
-        PMemBlock block;
-        int retval = 0;
-        if (!AgpHeap)
-                return -1;
-        agp.size = mem->size;
-        agp.context = mem->context;
-        block = via_mmAllocMem(AgpHeap, agp.size, 5, 0);
-        if (block) {
-                agp.offset = block->ofs;
-                agp.free = (unsigned long)block;
-                if (!add_alloc_set(agp.context, VIA_MEM_AGP, agp.free)) {
-                        DRM_DEBUG("adding to allocation set fails\n");
-                        via_mmFreeMem((PMemBlock) agp.free);
-                        retval = -1;
-                }
        } else {
-                agp.offset = 0;
+                mem.offset = 0;
-                agp.size = 0;
+                mem.size = 0;
-                agp.free = 0;
+                mem.index = 0;
+                DRM_DEBUG("Video memory allocation failed\n");
+                retval = DRM_ERR(ENOMEM);
        }
+        DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem, sizeof(mem));
-        mem->offset = agp.offset;
-        mem->index = agp.free;
-        DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size,
-                  (unsigned int)agp.offset);
        return retval;
 }
 int via_mem_free(DRM_IOCTL_ARGS)
 {
+        DRM_DEVICE;
+        drm_via_private_t *dev_priv = dev->dev_private;
        drm_via_mem_t mem;
+        int ret;
        DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
                                 sizeof(mem));
-        switch (mem.type) {
+        mutex_lock(&dev->struct_mutex);
+        ret = drm_sman_free_key(&dev_priv->sman, mem.index);
+        mutex_unlock(&dev->struct_mutex);
+        DRM_DEBUG("free = 0x%lx\n", mem.index);
-        case VIA_MEM_VIDEO:
+        return ret;
-                if (via_fb_free(&mem) == 0)
-                        return 0;
-                break;
-        case VIA_MEM_AGP:
-                if (via_agp_free(&mem) == 0)
-                        return 0;
-                break;
-        }
-        return -EFAULT;
 }
-static int via_fb_free(drm_via_mem_t * mem)
-{
-        drm_via_mm_t fb;
-        int retval = 0;
-        if (!FBHeap) {
-                return -1;
-        }
-        fb.free = mem->index;
-        fb.context = mem->context;
-        if (!fb.free) {
-                return -1;
-        }
-        via_mmFreeMem((PMemBlock) fb.free);
-        if (!del_alloc_set(fb.context, VIA_MEM_VIDEO, fb.free)) {
-                retval = -1;
-        }
-        DRM_DEBUG("free fb, free = %ld\n", fb.free);
-        return retval;
+void via_reclaim_buffers_locked(drm_device_t * dev, struct file *filp)
-}
-static int via_agp_free(drm_via_mem_t * mem)
 {
-        drm_via_mm_t agp;
+        drm_via_private_t *dev_priv = dev->dev_private;
+        drm_file_t *priv = filp->private_data;
-        int retval = 0;
-        agp.free = mem->index;
+        mutex_lock(&dev->struct_mutex);
-        agp.context = mem->context;
+        if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
+                mutex_unlock(&dev->struct_mutex);
-        if (!agp.free)
+                return;
-                return -1;
-        via_mmFreeMem((PMemBlock) agp.free);
-        if (!del_alloc_set(agp.context, VIA_MEM_AGP, agp.free)) {
-                retval = -1;
        }
-        DRM_DEBUG("free agp, free = %ld\n", agp.free);
+        if (dev->driver->dma_quiescent) {
+                dev->driver->dma_quiescent(dev);
+        }
-        return retval;
+        drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)priv);
+        mutex_unlock(&dev->struct_mutex);
+        return;
 }
diff --git a/drivers/char/ds1286.c b/drivers/char/ds1286.c
index 21c8229f5443..6d58b0370802 100644
--- a/drivers/char/ds1286.c
+++ b/drivers/char/ds1286.c
@@ -104,7 +104,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
        switch (cmd) {
        case RTC_AIE_OFF:       /* Mask alarm int. enab. bit    */
        {
-                unsigned int flags;
+                unsigned long flags;
                unsigned char val;
                if (!capable(CAP_SYS_TIME))
@@ -120,7 +120,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
        }
        case RTC_AIE_ON:        /* Allow alarm interrupts.      */
        {
-                unsigned int flags;
+                unsigned long flags;
                unsigned char val;
                if (!capable(CAP_SYS_TIME))
@@ -136,7 +136,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
        }
        case RTC_WIE_OFF:       /* Mask watchdog int. enab. bit */
        {
-                unsigned int flags;
+                unsigned long flags;
                unsigned char val;
                if (!capable(CAP_SYS_TIME))
@@ -152,7 +152,7 @@ static int ds1286_ioctl(struct inode *inode, struct file *file,
        }
        case RTC_WIE_ON:        /* Allow watchdog interrupts.   */
        {
-                unsigned int flags;
+                unsigned long flags;
                unsigned char val;
                if (!capable(CAP_SYS_TIME))
@@ -434,7 +434,7 @@ static inline unsigned char ds1286_is_updating(void)
 static void ds1286_get_time(struct rtc_time *rtc_tm)
 {
        unsigned char save_control;
-        unsigned int flags;
+        unsigned long flags;
        unsigned long uip_watchdog = jiffies;
        /*
@@ -494,7 +494,8 @@ static int ds1286_set_time(struct rtc_time *rtc_tm)
 {
        unsigned char mon, day, hrs, min, sec, leap_yr;
        unsigned char save_control;
-        unsigned int yrs, flags;
+        unsigned int yrs;
+        unsigned long flags;
        yrs = rtc_tm->tm_year + 1900;
@@ -552,7 +553,7 @@ static int ds1286_set_time(struct rtc_time *rtc_tm)
 static void ds1286_get_alm_time(struct rtc_time *alm_tm)
 {
        unsigned char cmd;
-        unsigned int flags;
+        unsigned long flags;
        /*
         * Only the values that we read from the RTC are set. That
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 86d290e9f307..3baa2ab8cbd4 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -1125,7 +1125,7 @@ static void __exit epca_module_exit(void)
 module_exit(epca_module_exit);
-static struct tty_operations pc_ops = {
+static const struct tty_operations pc_ops = {
        .open = pc_open,
        .close = pc_close,
        .write = pc_write,
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index afcd83d9984b..05788c75d7fc 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -2376,7 +2376,7 @@ static inline int autoconfig(struct esp_struct * info)
        return (port_detected);
 }
-static struct tty_operations esp_ops = {
+static const struct tty_operations esp_ops = {
        .open = esp_open,
        .close = rs_close,
        .write = rs_write,
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index a76d2c40dd5e..4053d1cd393f 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -696,7 +696,7 @@ int khvcd(void *unused)
        return 0;
 }
-static struct tty_operations hvc_ops = {
+static const struct tty_operations hvc_ops = {
        .open = hvc_open,
        .close = hvc_close,
        .write = hvc_write,
diff --git a/drivers/char/hvc_iseries.c b/drivers/char/hvc_iseries.c
index 4747729459c7..8b6f197e5f8c 100644
--- a/drivers/char/hvc_iseries.c
+++ b/drivers/char/hvc_iseries.c
@@ -153,9 +153,7 @@ static int put_chars(uint32_t vtermno, const char *buf, int count)
        spin_lock_irqsave(&consolelock, flags);
        if (viochar_is_console(pi) && !viopath_isactive(pi->lp)) {
-                spin_lock_irqsave(&consoleloglock, flags);
                HvCall_writeLogBuffer(buf, count);
-                spin_unlock_irqrestore(&consoleloglock, flags);
                sent = count;
                goto done;
        }
@@ -171,11 +169,8 @@ static int put_chars(uint32_t vtermno, const char *buf, int count)
                len = (count > VIOCHAR_MAX_DATA) ? VIOCHAR_MAX_DATA : count;
-                if (viochar_is_console(pi)) {
+                if (viochar_is_console(pi))
-                        spin_lock_irqsave(&consoleloglock, flags);
                        HvCall_writeLogBuffer(buf, len);
-                        spin_unlock_irqrestore(&consoleloglock, flags);
-                }
                init_data_event(viochar, pi->lp);
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index 4589ff302b07..0b89bcde8c52 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -1306,7 +1306,7 @@ static int hvcs_chars_in_buffer(struct tty_struct *tty)
        return hvcsd->chars_in_buffer;
 }
-static struct tty_operations hvcs_ops = {
+static const struct tty_operations hvcs_ops = {
        .open = hvcs_open,
        .close = hvcs_close,
        .hangup = hvcs_hangup,
diff --git a/drivers/char/hvsi.c b/drivers/char/hvsi.c
index a89a95fb5e40..c07dc58d5c1d 100644
--- a/drivers/char/hvsi.c
+++ b/drivers/char/hvsi.c
@@ -1130,7 +1130,7 @@ static int hvsi_tiocmset(struct tty_struct *tty, struct file *file,
 }
-static struct tty_operations hvsi_ops = {
+static const struct tty_operations hvsi_ops = {
        .open = hvsi_open,
        .close = hvsi_close,
        .write = hvsi_write,
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index 7907ae88c2f4..62ef511d143b 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -436,6 +436,7 @@ cleanup_module(void)
 #ifdef CONFIG_PCI
                if (ip2config.type[i] == PCI && ip2config.pci_dev[i]) {
                        pci_disable_device(ip2config.pci_dev[i]);
+                        pci_dev_put(ip2config.pci_dev[i]);
                        ip2config.pci_dev[i] = NULL;
                }
 #endif
@@ -457,7 +458,7 @@ cleanup_module(void)
 }
 #endif /* MODULE */
-static struct tty_operations ip2_ops = {
+static const struct tty_operations ip2_ops = {
        .open            = ip2_open,
        .close           = ip2_close,
        .write           = ip2_write,
@@ -505,6 +506,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
        static int loaded;
        i2eBordStrPtr pB = NULL;
        int rc = -1;
+        static struct pci_dev *pci_dev_i = NULL;
        ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_ENTER, 0 );
@@ -588,8 +590,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                case PCI:
 #ifdef CONFIG_PCI
                        {
-                                struct pci_dev *pci_dev_i = NULL;
+                                pci_dev_i = pci_get_device(PCI_VENDOR_ID_COMPUTONE,
-                                pci_dev_i = pci_find_device(PCI_VENDOR_ID_COMPUTONE,
                                                          PCI_DEVICE_ID_COMPUTONE_IP2EX, pci_dev_i);
                                if (pci_dev_i != NULL) {
                                        unsigned int addr;
@@ -600,7 +601,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                                                break;
                                        }
                                        ip2config.type[i] = PCI;
-                                        ip2config.pci_dev[i] = pci_dev_i;
+                                        ip2config.pci_dev[i] = pci_dev_get(pci_dev_i);
                                        status =
                                        pci_read_config_dword(pci_dev_i, PCI_BASE_ADDRESS_1, &addr);
                                        if ( addr & 1 ) {
@@ -641,6 +642,9 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                        break;
                }       /* switch */
        }       /* for */
+        if (pci_dev_i)
+                pci_dev_put(pci_dev_i);
        for ( i = 0; i < IP2_MAX_BOARDS; ++i ) {
                if ( ip2config.addr[i] ) {
                        pB = kmalloc( sizeof(i2eBordStr), GFP_KERNEL);
@@ -775,8 +779,6 @@ retry:
        ip2trace (ITRC_NO_PORT, ITRC_INIT, ITRC_RETURN, 0 );
        goto out;
-out_class:
-        class_destroy(ip2_class);
 out_chrdev:
        unregister_chrdev(IP2_IPL_MAJOR, "ip2");
 out:
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index 68d7c61a864e..81fcf0ce21d1 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -377,7 +377,8 @@ static int ipmi_ioctl(struct inode  *inode,
                        break;
                }
-                rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
+                rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
+                                           IPMI_CHAN_ALL);
                break;
        }
@@ -390,7 +391,36 @@ static int ipmi_ioctl(struct inode  *inode,
                        break;
                }
-                rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
+                rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd,
+                                             IPMI_CHAN_ALL);
+                break;
+        }
+        case IPMICTL_REGISTER_FOR_CMD_CHANS:
+        {
+                struct ipmi_cmdspec_chans val;
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+                rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
+                                           val.chans);
+                break;
+        }
+        case IPMICTL_UNREGISTER_FOR_CMD_CHANS:
+        {
+                struct ipmi_cmdspec_chans val;
+                if (copy_from_user(&val, arg, sizeof(val))) {
+                        rv = -EFAULT;
+                        break;
+                }
+                rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd,
+                                             val.chans);
                break;
        }
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 843d34c8627c..2455e8d478ac 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -96,6 +96,7 @@ struct cmd_rcvr
        ipmi_user_t   user;
        unsigned char netfn;
        unsigned char cmd;
+        unsigned int  chans;
        /*
         * This is used to form a linked lised during mass deletion.
@@ -953,24 +954,41 @@ int ipmi_set_gets_events(ipmi_user_t user, int val)
 static struct cmd_rcvr *find_cmd_rcvr(ipmi_smi_t    intf,
                                      unsigned char netfn,
-                                      unsigned char cmd)
+                                      unsigned char cmd,
+                                      unsigned char chan)
 {
        struct cmd_rcvr *rcvr;
        list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
-                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd))
+                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)
+                                        && (rcvr->chans & (1 << chan)))
                        return rcvr;
        }
        return NULL;
 }
+static int is_cmd_rcvr_exclusive(ipmi_smi_t    intf,
+                                 unsigned char netfn,
+                                 unsigned char cmd,
+                                 unsigned int  chans)
+{
+        struct cmd_rcvr *rcvr;
+        list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
+                if ((rcvr->netfn == netfn) && (rcvr->cmd == cmd)
+                                        && (rcvr->chans & chans))
+                        return 0;
+        }
+        return 1;
+}
 int ipmi_register_for_cmd(ipmi_user_t   user,
                          unsigned char netfn,
-                          unsigned char cmd)
+                          unsigned char cmd,
+                          unsigned int  chans)
 {
        ipmi_smi_t      intf = user->intf;
        struct cmd_rcvr *rcvr;
-        struct cmd_rcvr *entry;
        int             rv = 0;
@@ -979,12 +997,12 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
                return -ENOMEM;
        rcvr->cmd = cmd;
        rcvr->netfn = netfn;
+        rcvr->chans = chans;
        rcvr->user = user;
        mutex_lock(&intf->cmd_rcvrs_mutex);
        /* Make sure the command/netfn is not already registered. */
-        entry = find_cmd_rcvr(intf, netfn, cmd);
+        if (!is_cmd_rcvr_exclusive(intf, netfn, cmd, chans)) {
-        if (entry) {
                rv = -EBUSY;
                goto out_unlock;
        }
@@ -1001,24 +1019,39 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
 int ipmi_unregister_for_cmd(ipmi_user_t   user,
                            unsigned char netfn,
-                            unsigned char cmd)
+                            unsigned char cmd,
+                            unsigned int  chans)
 {
        ipmi_smi_t      intf = user->intf;
        struct cmd_rcvr *rcvr;
+        struct cmd_rcvr *rcvrs = NULL;
+        int i, rv = -ENOENT;
        mutex_lock(&intf->cmd_rcvrs_mutex);
-        /* Make sure the command/netfn is not already registered. */
+        for (i = 0; i < IPMI_NUM_CHANNELS; i++) {
-        rcvr = find_cmd_rcvr(intf, netfn, cmd);
+                if (((1 << i) & chans) == 0)
-        if ((rcvr) && (rcvr->user == user)) {
+                        continue;
-                list_del_rcu(&rcvr->link);
+                rcvr = find_cmd_rcvr(intf, netfn, cmd, i);
-                mutex_unlock(&intf->cmd_rcvrs_mutex);
+                if (rcvr == NULL)
-                synchronize_rcu();
+                        continue;
+                if (rcvr->user == user) {
+                        rv = 0;
+                        rcvr->chans &= ~chans;
+                        if (rcvr->chans == 0) {
+                                list_del_rcu(&rcvr->link);
+                                rcvr->next = rcvrs;
+                                rcvrs = rcvr;
+                        }
+                }
+        }
+        mutex_unlock(&intf->cmd_rcvrs_mutex);
+        synchronize_rcu();
+        while (rcvrs) {
+                rcvr = rcvrs;
+                rcvrs = rcvr->next;
                kfree(rcvr);
-                return 0;
-        } else {
-                mutex_unlock(&intf->cmd_rcvrs_mutex);
-                return -ENOENT;
        }
+        return rv;
 }
 void ipmi_user_set_run_to_completion(ipmi_user_t user, int val)
@@ -2548,6 +2581,7 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
        int                      rv = 0;
        unsigned char            netfn;
        unsigned char            cmd;
+        unsigned char            chan;
        ipmi_user_t              user = NULL;
        struct ipmi_ipmb_addr    *ipmb_addr;
        struct ipmi_recv_msg     *recv_msg;
@@ -2568,9 +2602,10 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
        netfn = msg->rsp[4] >> 2;
        cmd = msg->rsp[8];
+        chan = msg->rsp[3] & 0xf;
        rcu_read_lock();
-        rcvr = find_cmd_rcvr(intf, netfn, cmd);
+        rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
        if (rcvr) {
                user = rcvr->user;
                kref_get(&user->refcount);
@@ -2728,6 +2763,7 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
        int                      rv = 0;
        unsigned char            netfn;
        unsigned char            cmd;
+        unsigned char            chan;
        ipmi_user_t              user = NULL;
        struct ipmi_lan_addr     *lan_addr;
        struct ipmi_recv_msg     *recv_msg;
@@ -2748,9 +2784,10 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
        netfn = msg->rsp[6] >> 2;
        cmd = msg->rsp[10];
+        chan = msg->rsp[3] & 0xf;
        rcu_read_lock();
-        rcvr = find_cmd_rcvr(intf, netfn, cmd);
+        rcvr = find_cmd_rcvr(intf, netfn, cmd, chan);
        if (rcvr) {
                user = rcvr->user;
                kref_get(&user->refcount);
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index abca98beac14..b106c45abfc9 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -217,6 +217,11 @@ struct smi_info
        struct list_head link;
 };
+#define SI_MAX_PARMS 4
+static int force_kipmid[SI_MAX_PARMS];
+static int num_force_kipmid;
 static int try_smi_init(struct smi_info *smi);
 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
@@ -908,6 +913,7 @@ static int smi_start_processing(void       *send_info,
                                ipmi_smi_t intf)
 {
        struct smi_info *new_smi = send_info;
+        int             enable = 0;
        new_smi->intf = intf;
@@ -916,7 +922,19 @@ static int smi_start_processing(void       *send_info,
        new_smi->last_timeout_jiffies = jiffies;
        mod_timer(&new_smi->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
-        if (new_smi->si_type != SI_BT) {
+        /*
+         * Check if the user forcefully enabled the daemon.
+         */
+        if (new_smi->intf_num < num_force_kipmid)
+                enable = force_kipmid[new_smi->intf_num];
+        /*
+         * The BT interface is efficient enough to not need a thread,
+         * and there is no need for a thread if we have interrupts.
+         */
+        else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
+                enable = 1;
+        if (enable) {
                new_smi->thread = kthread_run(ipmi_thread, new_smi,
                                              "kipmi%d", new_smi->intf_num);
                if (IS_ERR(new_smi->thread)) {
@@ -944,7 +962,6 @@ static struct ipmi_smi_handlers handlers =
 /* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
   a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */
-#define SI_MAX_PARMS 4
 static LIST_HEAD(smi_infos);
 static DEFINE_MUTEX(smi_infos_lock);
 static int smi_num; /* Used to sequence the SMIs */
@@ -1017,6 +1034,10 @@ MODULE_PARM_DESC(slave_addrs, "Set the default IPMB slave address for"
                 " the controller.  Normally this is 0x20, but can be"
                 " overridden by this parm.  This is an array indexed"
                 " by interface number.");
+module_param_array(force_kipmid, int, &num_force_kipmid, 0);
+MODULE_PARM_DESC(force_kipmid, "Force the kipmi daemon to be enabled (1) or"
+                 " disabled(0).  Normally the IPMI driver auto-detects"
+                 " this, but the value may be overridden by this parm.");
 #define IPMI_IO_ADDR_SPACE  0
@@ -1730,6 +1751,7 @@ static void __devinit dmi_find_bmc(void)
        int                  rv;
        while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev))) {
+                memset(&data, 0, sizeof(data));
                rv = decode_dmi((struct dmi_header *) dev->device_data, &data);
                if (!rv)
                        try_init_dmi(&data);
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 913be23e0a24..ea2bbf80ad33 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -1550,7 +1550,7 @@ static void isicom_unregister_ioregion(struct pci_dev *pdev)
        board->base = 0;
 }
-static struct tty_operations isicom_ops = {
+static const struct tty_operations isicom_ops = {
        .open                   = isicom_open,
        .close                  = isicom_close,
        .write                  = isicom_write,
@@ -1756,9 +1756,12 @@ static int __devinit load_firmware(struct pci_dev *pdev,
        if (retval)
                goto end;
+        retval = -EIO;
        for (frame = (struct stframe *)fw->data;
                        frame < (struct stframe *)(fw->data + fw->size);
-                        frame++) {
+                        frame = (struct stframe *)((u8 *)(frame + 1) +
+                                frame->count)) {
                if (WaitTillCardIsFree(base))
                        goto errrelfw;
@@ -1797,23 +1800,12 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                }
        }
-        retval = -EIO;
-        if (WaitTillCardIsFree(base))
-                goto errrelfw;
-        outw(0xf2, base);
-        outw(0x800, base);
-        outw(0x0, base);
-        outw(0x0, base);
-        InterruptTheCard(base);
-        outw(0x0, base + 0x4); /* for ISI4608 cards */
 /* XXX: should we test it by reading it back and comparing with original like
 * in load firmware package? */
-        for (frame = (struct stframe*)fw->data;
+        for (frame = (struct stframe *)fw->data;
-                        frame < (struct stframe*)(fw->data + fw->size);
+                        frame < (struct stframe *)(fw->data + fw->size);
-                        frame++) {
+                        frame = (struct stframe *)((u8 *)(frame + 1) +
+                                frame->count)) {
                if (WaitTillCardIsFree(base))
                        goto errrelfw;
@@ -1863,6 +1855,17 @@ static int __devinit load_firmware(struct pci_dev *pdev,
                }
        }
+        /* xfer ctrl */
+        if (WaitTillCardIsFree(base))
+                goto errrelfw;
+        outw(0xf2, base);
+        outw(0x800, base);
+        outw(0x0, base);
+        outw(0x0, base);
+        InterruptTheCard(base);
+        outw(0x0, base + 0x4); /* for ISI4608 cards */
        board->status |= FIRMWARE_LOADED;
        retval = 0;
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 6b4d82a4565f..d6e031542c6b 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -4636,7 +4636,7 @@ static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, un
        return rc;
 }
-static struct tty_operations stli_ops = {
+static const struct tty_operations stli_ops = {
        .open = stli_open,
        .close = stli_close,
        .write = stli_write,
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 3e90aac37510..e2011669c7bb 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -108,7 +108,11 @@ const int NR_TYPES = ARRAY_SIZE(max_vals);
 struct kbd_struct kbd_table[MAX_NR_CONSOLES];
 static struct kbd_struct *kbd = kbd_table;
-int spawnpid, spawnsig;
+struct vt_spawn_console vt_spawn_con = {
+        .lock = SPIN_LOCK_UNLOCKED,
+        .pid  = NULL,
+        .sig  = 0,
+};
 /*
 * Variables exported for vt.c
@@ -578,9 +582,13 @@ static void fn_compose(struct vc_data *vc, struct pt_regs *regs)
 static void fn_spawn_con(struct vc_data *vc, struct pt_regs *regs)
 {
-        if (spawnpid)
+        spin_lock(&vt_spawn_con.lock);
-                if (kill_proc(spawnpid, spawnsig, 1))
+        if (vt_spawn_con.pid)
-                        spawnpid = 0;
+                if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
+                        put_pid(vt_spawn_con.pid);
+                        vt_spawn_con.pid = NULL;
+                }
+        spin_unlock(&vt_spawn_con.lock);
 }
 static void fn_SAK(struct vc_data *vc, struct pt_regs *regs)
@@ -1285,7 +1293,7 @@ static void kbd_event(struct input_handle *handle, unsigned int event_type,
 */
 static struct input_handle *kbd_connect(struct input_handler *handler,
                                        struct input_dev *dev,
-                                        struct input_device_id *id)
+                                        const struct input_device_id *id)
 {
        struct input_handle *handle;
        int i;
@@ -1334,7 +1342,7 @@ static void kbd_start(struct input_handle *handle)
        tasklet_enable(&keyboard_tasklet);
 }
-static struct input_device_id kbd_ids[] = {
+static const struct input_device_id kbd_ids[] = {
        {
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
                .evbit = { BIT(EV_KEY) },
@@ -1362,6 +1370,7 @@ static struct input_handler kbd_handler = {
 int __init kbd_init(void)
 {
        int i;
+        int error;
        for (i = 0; i < MAX_NR_CONSOLES; i++) {
                kbd_table[i].ledflagstate = KBD_DEFLEDS;
@@ -1373,7 +1382,9 @@ int __init kbd_init(void)
                kbd_table[i].kbdmode = VC_XLATE;
        }
-        input_register_handler(&kbd_handler);
+        error = input_register_handler(&kbd_handler);
+        if (error)
+                return error;
        tasklet_enable(&keyboard_tasklet);
        tasklet_schedule(&keyboard_tasklet);
diff --git a/drivers/char/mbcs.c b/drivers/char/mbcs.c
index 0385650f6077..636354722658 100644
--- a/drivers/char/mbcs.c
+++ b/drivers/char/mbcs.c
@@ -22,6 +22,7 @@
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/mm.h>
+#include <linux/fs.h>
 #include <linux/uio.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -447,15 +448,15 @@ loff_t mbcs_sram_llseek(struct file * filp, loff_t off, int whence)
        loff_t newpos;
        switch (whence) {
-        case 0:         /* SEEK_SET */
+        case SEEK_SET:
                newpos = off;
                break;
-        case 1:         /* SEEK_CUR */
+        case SEEK_CUR:
                newpos = filp->f_pos + off;
                break;
-        case 2:         /* SEEK_END */
+        case SEEK_END:
                newpos = MBCS_SRAM_SIZE + off;
                break;
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index a369dd6877d8..b401383808c2 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -260,7 +260,7 @@ static void MoxaPortEnable(int);
 static void MoxaPortDisable(int);
 static long MoxaPortGetMaxBaud(int);
 static long MoxaPortSetBaud(int, long);
-static int MoxaPortSetTermio(int, struct termios *);
+static int MoxaPortSetTermio(int, struct termios *, speed_t);
 static int MoxaPortGetLineOut(int, int *, int *);
 static void MoxaPortLineCtrl(int, int, int);
 static void MoxaPortFlowCtrl(int, int, int, int, int, int);
@@ -281,7 +281,7 @@ static int moxa_get_serial_info(struct moxa_str *, struct serial_struct __user *
 static int moxa_set_serial_info(struct moxa_str *, struct serial_struct __user *);
 static void MoxaSetFifo(int port, int enable);
-static struct tty_operations moxa_ops = {
+static const struct tty_operations moxa_ops = {
        .open = moxa_open,
        .close = moxa_close,
        .write = moxa_write,
@@ -986,7 +986,7 @@ static void set_tty_param(struct tty_struct *tty)
        if (ts->c_iflag & IXANY)
                xany = 1;
        MoxaPortFlowCtrl(ch->port, rts, cts, txflow, rxflow, xany);
-        MoxaPortSetTermio(ch->port, ts);
+        MoxaPortSetTermio(ch->port, ts, tty_get_baud_rate(tty));
 }
 static int block_till_ready(struct tty_struct *tty, struct file *filp,
@@ -1900,9 +1900,10 @@ int MoxaPortsOfCard(int cardno)
 *
 *      Function 12:    Configure the port.
 *      Syntax:
- *      int  MoxaPortSetTermio(int port, struct termios *termio);
+ *      int  MoxaPortSetTermio(int port, struct termios *termio, speed_t baud);
 *           int port           : port number (0 - 127)
 *           struct termios * termio : termio structure pointer
+ *           speed_t baud       : baud rate
 *
 *           return:    -1      : this port is invalid or termio == NULL
 *                      0       : setting O.K.
@@ -2182,11 +2183,10 @@ long MoxaPortSetBaud(int port, long baud)
        return (baud);
 }
-int MoxaPortSetTermio(int port, struct termios *termio)
+int MoxaPortSetTermio(int port, struct termios *termio, speed_t baud)
 {
        void __iomem *ofsAddr;
        tcflag_t cflag;
-        long baud;
        tcflag_t mode = 0;
        if (moxaChkPort[port] == 0 || termio == 0)
@@ -2222,77 +2222,9 @@ int MoxaPortSetTermio(int port, struct termios *termio)
        moxafunc(ofsAddr, FC_SetDataMode, (ushort) mode);
-        cflag &= (CBAUD | CBAUDEX);
-#ifndef B921600
-#define B921600 (B460800+1)
-#endif
-        switch (cflag) {
-        case B921600:
-                baud = 921600L;
-                break;
-        case B460800:
-                baud = 460800L;
-                break;
-        case B230400:
-                baud = 230400L;
-                break;
-        case B115200:
-                baud = 115200L;
-                break;
-        case B57600:
-                baud = 57600L;
-                break;
-        case B38400:
-                baud = 38400L;
-                break;
-        case B19200:
-                baud = 19200L;
-                break;
-        case B9600:
-                baud = 9600L;
-                break;
-        case B4800:
-                baud = 4800L;
-                break;
-        case B2400:
-                baud = 2400L;
-                break;
-        case B1800:
-                baud = 1800L;
-                break;
-        case B1200:
-                baud = 1200L;
-                break;
-        case B600:
-                baud = 600L;
-                break;
-        case B300:
-                baud = 300L;
-                break;
-        case B200:
-                baud = 200L;
-                break;
-        case B150:
-                baud = 150L;
-                break;
-        case B134:
-                baud = 134L;
-                break;
-        case B110:
-                baud = 110L;
-                break;
-        case B75:
-                baud = 75L;
-                break;
-        case B50:
-                baud = 50L;
-                break;
-        default:
-                baud = 0;
-        }
        if ((moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_ISA) ||
            (moxa_boards[port / MAX_PORTS_PER_BOARD].boardType == MOXA_BOARD_C320_PCI)) {
-                if (baud == 921600L)
+                if (baud >= 921600L)
                        return (-1);
        }
        MoxaPortSetBaud(port, baud);
diff --git a/drivers/char/mwave/mwavedd.c b/drivers/char/mwave/mwavedd.c
index 39a2e661ff55..8d14823b0514 100644
--- a/drivers/char/mwave/mwavedd.c
+++ b/drivers/char/mwave/mwavedd.c
@@ -297,7 +297,7 @@ static int mwave_ioctl(struct inode *inode, struct file *file,
                                " ipcnum %x, usIntCount %x\n",
                                ipcnum,
                                pDrvData->IPCs[ipcnum].usIntCount);
-                        if (ipcnum > ARRAY_SIZE(pDrvData->IPCs)) {
+                        if (ipcnum >= ARRAY_SIZE(pDrvData->IPCs)) {
                                PRINTK_ERROR(KERN_ERR_MWAVE
                                                "mwavedd::mwave_ioctl:"
                                                " IOCTL_MW_GET_IPC: Error:"
@@ -355,7 +355,7 @@ static int mwave_ioctl(struct inode *inode, struct file *file,
                                "mwavedd::mwave_ioctl IOCTL_MW_UNREGISTER_IPC"
                                " ipcnum %x\n",
                                ipcnum);
-                        if (ipcnum > ARRAY_SIZE(pDrvData->IPCs)) {
+                        if (ipcnum >= ARRAY_SIZE(pDrvData->IPCs)) {
                                PRINTK_ERROR(KERN_ERR_MWAVE
                                                "mwavedd::mwave_ioctl:"
                                                " IOCTL_MW_UNREGISTER_IPC:"
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 556abd3e0d07..8253fca8efd5 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -453,7 +453,7 @@ static int CheckIsMoxaMust(int io)
 /* above is modified by Victor Yu. 08-15-2002 */
-static struct tty_operations mxser_ops = {
+static const struct tty_operations mxser_ops = {
        .open = mxser_open,
        .close = mxser_close,
        .write = mxser_write,
@@ -2554,71 +2554,7 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
 #define B921600 (B460800 +1)
 #endif
        if (mxser_set_baud_method[info->port] == 0) {
-                switch (cflag & (CBAUD | CBAUDEX)) {
+                baud = tty_get_baud_rate(info->tty);
-                case B921600:
-                        baud = 921600;
-                        break;
-                case B460800:
-                        baud = 460800;
-                        break;
-                case B230400:
-                        baud = 230400;
-                        break;
-                case B115200:
-                        baud = 115200;
-                        break;
-                case B57600:
-                        baud = 57600;
-                        break;
-                case B38400:
-                        baud = 38400;
-                        break;
-                case B19200:
-                        baud = 19200;
-                        break;
-                case B9600:
-                        baud = 9600;
-                        break;
-                case B4800:
-                        baud = 4800;
-                        break;
-                case B2400:
-                        baud = 2400;
-                        break;
-                case B1800:
-                        baud = 1800;
-                        break;
-                case B1200:
-                        baud = 1200;
-                        break;
-                case B600:
-                        baud = 600;
-                        break;
-                case B300:
-                        baud = 300;
-                        break;
-                case B200:
-                        baud = 200;
-                        break;
-                case B150:
-                        baud = 150;
-                        break;
-                case B134:
-                        baud = 134;
-                        break;
-                case B110:
-                        baud = 110;
-                        break;
-                case B75:
-                        baud = 75;
-                        break;
-                case B50:
-                        baud = 50;
-                        break;
-                default:
-                        baud = 0;
-                        break;
-                }
                mxser_set_baud(info, baud);
        }
diff --git a/drivers/char/nwbutton.c b/drivers/char/nwbutton.c
index 7c57ebfa8640..ea1aa7764f8e 100644
--- a/drivers/char/nwbutton.c
+++ b/drivers/char/nwbutton.c
@@ -127,9 +127,8 @@ static void button_consume_callbacks (int bpcount)
 static void button_sequence_finished (unsigned long parameters)
 {
 #ifdef CONFIG_NWBUTTON_REBOOT           /* Reboot using button is enabled */
-        if (button_press_count == reboot_count) {
+        if (button_press_count == reboot_count)
-                kill_proc (1, SIGINT, 1);       /* Ask init to reboot us */
+                kill_cad_pid(SIGINT, 1);        /* Ask init to reboot us */
-        }
 #endif /* CONFIG_NWBUTTON_REBOOT */
        button_consume_callbacks (button_press_count);
        bcount = sprintf (button_output_buffer, "%d\n", button_press_count);
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 539efe782618..d1ecb2c6de98 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -3009,7 +3009,7 @@ static struct pcmcia_driver mgslpc_driver = {
        .resume         = mgslpc_resume,
 };
-static struct tty_operations mgslpc_ops = {
+static const struct tty_operations mgslpc_ops = {
        .open = mgslpc_open,
        .close = mgslpc_close,
        .write = mgslpc_write,
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 34dd4c38110e..80d3eedd7f96 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -224,7 +224,7 @@ static void pty_set_termios(struct tty_struct *tty, struct termios *old_termios)
        tty->termios->c_cflag |= (CS8 | CREAD);
 }
-static struct tty_operations pty_ops = {
+static const struct tty_operations pty_ops = {
        .open = pty_open,
        .close = pty_close,
        .write = pty_write,
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 4c3a5ca9d8f7..07f47a0208a7 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -655,6 +655,7 @@ void add_interrupt_randomness(int irq)
        add_timer_randomness(irq_timer_state[irq], 0x100 + irq);
 }
+#ifdef CONFIG_BLOCK
 void add_disk_randomness(struct gendisk *disk)
 {
        if (!disk || !disk->random)
@@ -667,6 +668,7 @@ void add_disk_randomness(struct gendisk *disk)
 }
 EXPORT_SYMBOL(add_disk_randomness);
+#endif
 #define EXTRACT_SIZE 10
@@ -887,8 +889,8 @@ static void init_std_data(struct entropy_store *r)
        do_gettimeofday(&tv);
        add_entropy_words(r, (__u32 *)&tv, sizeof(tv)/4);
-        add_entropy_words(r, (__u32 *)&system_utsname,
+        add_entropy_words(r, (__u32 *)utsname(),
-                          sizeof(system_utsname)/4);
+                          sizeof(*(utsname()))/4);
 }
 static int __init rand_initialize(void)
@@ -918,6 +920,7 @@ void rand_initialize_irq(int irq)
        }
 }
+#ifdef CONFIG_BLOCK
 void rand_initialize_disk(struct gendisk *disk)
 {
        struct timer_rand_state *state;
@@ -932,6 +935,7 @@ void rand_initialize_disk(struct gendisk *disk)
                disk->random = state;
        }
 }
+#endif
 static ssize_t
 random_read(struct file * file, char __user * buf, size_t nbytes, loff_t *ppos)
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index c596a08c07b3..89b718e326e5 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -238,39 +238,14 @@ out:
        return err;
 }
-static ssize_t raw_file_write(struct file *file, const char __user *buf,
-                                   size_t count, loff_t *ppos)
-{
-        struct iovec local_iov = {
-                .iov_base = (char __user *)buf,
-                .iov_len = count
-        };
-        return generic_file_write_nolock(file, &local_iov, 1, ppos);
-}
-static ssize_t raw_file_aio_write(struct kiocb *iocb, const char __user *buf,
-                                        size_t count, loff_t pos)
-{
-        struct iovec local_iov = {
-                .iov_base = (char __user *)buf,
-                .iov_len = count
-        };
-        return generic_file_aio_write_nolock(iocb, &local_iov, 1, &iocb->ki_pos);
-}
 static const struct file_operations raw_fops = {
-        .read   =       generic_file_read,
+        .read   =       do_sync_read,
        .aio_read =     generic_file_aio_read,
-        .write  =       raw_file_write,
+        .write  =       do_sync_write,
-        .aio_write =    raw_file_aio_write,
+        .aio_write =    generic_file_aio_write_nolock,
        .open   =       raw_open,
        .release=       raw_release,
        .ioctl  =       raw_ioctl,
-        .readv  =       generic_file_readv,
-        .writev =       generic_file_writev,
        .owner  =       THIS_MODULE,
 };
diff --git a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c
index 3fa80aaf4527..202a3b0945b7 100644
--- a/drivers/char/rio/rio_linux.c
+++ b/drivers/char/rio/rio_linux.c
@@ -727,7 +727,7 @@ static struct vpd_prom *get_VPD_PROM(struct Host *hp)
        return &vpdp;
 }
-static struct tty_operations rio_ops = {
+static const struct tty_operations rio_ops = {
        .open = riotopen,
        .close = gs_close,
        .write = gs_write,
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index f1c94f771af5..214d850112fd 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -675,26 +675,12 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
        port->COR2 = 0;
        port->MSVR = MSVR_RTS;
        
-        baud = C_BAUD(tty);
+        baud = tty_get_baud_rate(tty);
-        
-        if (baud & CBAUDEX) {
-                baud &= ~CBAUDEX;
-                if (baud < 1 || baud > 2) 
-                        port->tty->termios->c_cflag &= ~CBAUDEX;
-                else
-                        baud += 15;
-        }
-        if (baud == 15)  {
-                if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        baud ++;
-                if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        baud += 2;
-        }
        
        /* Select port on the board */
        rc_out(bp, CD180_CAR, port_No(port));
        
-        if (!baud_table[baud])  {
+        if (!baud)  {
                /* Drop DTR & exit */
                bp->DTR |= (1u << port_No(port));
                rc_out(bp, RC_DTR, bp->DTR);
@@ -710,7 +696,7 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
         */
        
        /* Set baud rate for port */
-        tmp = (((RC_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
+        tmp = (((RC_OSCFREQ + baud/2) / baud +
                CD180_TPC/2) / CD180_TPC);
        rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff); 
@@ -718,7 +704,7 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
        rc_out(bp, CD180_RBPRL, tmp & 0xff); 
        rc_out(bp, CD180_TBPRL, tmp & 0xff);
        
-        baud = (baud_table[baud] + 5) / 10;   /* Estimated CPS */
+        baud = (baud + 5) / 10;   /* Estimated CPS */
        
        /* Two timer ticks seems enough to wakeup something like SLIP driver */
        tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;           
@@ -1597,7 +1583,7 @@ static void do_softint(void *private_)
        }
 }
-static struct tty_operations riscom_ops = {
+static const struct tty_operations riscom_ops = {
        .open  = rc_open,
        .close = rc_close,
        .write = rc_write,
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 0ac131881322..bac80056f7e0 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -2334,7 +2334,7 @@ static int __init init_ISA(int i)
        return (1);
 }
-static struct tty_operations rocket_ops = {
+static const struct tty_operations rocket_ops = {
        .open = rp_open,
        .close = rp_close,
        .write = rp_write,
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 510bd3e0e88b..65c751d0d643 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -661,7 +661,7 @@ static void a2232_init_portstructs(void)
        }
 }
-static struct tty_operations a2232_ops = {
+static const struct tty_operations a2232_ops = {
        .open = a2232_open,
        .close = gs_close,
        .write = gs_write,
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index 21a710cb4bba..b4ea1266b663 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -2158,7 +2158,7 @@ mvme167_serial_console_setup(int cflag)
                                        rcor >> 5, rbpr);
 } /* serial_console_init */
-static struct tty_operations cy_ops = {
+static const struct tty_operations cy_ops = {
        .open = cy_open,
        .close = cy_close,
        .write = cy_write,
diff --git a/drivers/char/snsc_event.c b/drivers/char/snsc_event.c
index d12d4f629cec..864854c58866 100644
--- a/drivers/char/snsc_event.c
+++ b/drivers/char/snsc_event.c
@@ -220,7 +220,7 @@ scdrv_dispatch_event(char *event, int len)
                               " Sending SIGPWR to init...\n");
                /* give a SIGPWR signal to init proc */
-                kill_proc(1, SIGPWR, 0);
+                kill_cad_pid(SIGPWR, 0);
        } else {
                /* print to system log */
                printk("%s|$(0x%x)%s\n", severity, esp_code, desc);
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index c0ef0f0e5800..902c48dca3bc 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -182,7 +182,6 @@ static int sx_poll = HZ;
 #define RS_EVENT_WRITE_WAKEUP   0
 static struct tty_driver *specialix_driver;
-static unsigned char * tmp_buf;
 static unsigned long baud_table[] =  {
        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
@@ -1674,7 +1673,7 @@ static int sx_write(struct tty_struct * tty,
        bp = port_Board(port);
-        if (!port->xmit_buf || !tmp_buf) {
+        if (!port->xmit_buf) {
                func_exit();
                return 0;
        }
@@ -2364,7 +2363,7 @@ static void do_softint(void *private_)
        func_exit();
 }
-static struct tty_operations sx_ops = {
+static const struct tty_operations sx_ops = {
        .open  = sx_open,
        .close = sx_close,
        .write = sx_write,
@@ -2398,12 +2397,6 @@ static int sx_init_drivers(void)
                return 1;
        }
-        if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
-                printk(KERN_ERR "sx: Couldn't get free page.\n");
-                put_tty_driver(specialix_driver);
-                func_exit();
-                return 1;
-        }
        specialix_driver->owner = THIS_MODULE;
        specialix_driver->name = "ttyW";
        specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
@@ -2417,7 +2410,6 @@ static int sx_init_drivers(void)
        if ((error = tty_register_driver(specialix_driver))) {
                put_tty_driver(specialix_driver);
-                free_page((unsigned long)tmp_buf);
                printk(KERN_ERR "sx: Couldn't register specialix IO8+ driver, error = %d\n",
                       error);
                func_exit();
@@ -2443,7 +2435,6 @@ static void sx_release_drivers(void)
 {
        func_enter();
-        free_page((unsigned long)tmp_buf);
        tty_unregister_driver(specialix_driver);
        put_tty_driver(specialix_driver);
        func_exit();
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 3beb2203d24b..bd711537ec4e 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -2993,7 +2993,7 @@ static int stl_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, uns
        return(rc);
 }
-static struct tty_operations stl_ops = {
+static const struct tty_operations stl_ops = {
        .open = stl_open,
        .close = stl_close,
        .write = stl_write,
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index e1cd2bc4b1e4..57e31e5eaedb 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -2226,7 +2226,7 @@ static int probe_si (struct sx_board *board)
        return 1;
 }
-static struct tty_operations sx_ops = {
+static const struct tty_operations sx_ops = {
        .break_ctl = sx_break,
        .open   = sx_open,
        .close = gs_close,
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index c53f4579a59f..38d94987de83 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -4359,7 +4359,7 @@ static struct mgsl_struct* mgsl_allocate_device(void)
 }       /* end of mgsl_allocate_device()*/
-static struct tty_operations mgsl_ops = {
+static const struct tty_operations mgsl_ops = {
        .open = mgsl_open,
        .close = mgsl_close,
        .write = mgsl_write,
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 2f07b085536b..bdc7cb248b8f 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -1,5 +1,5 @@
 /*
- * $Id: synclink_gt.c,v 4.25 2006/02/06 21:20:33 paulkf Exp $
+ * $Id: synclink_gt.c,v 4.36 2006/08/28 20:47:14 paulkf Exp $
 *
 * Device driver for Microgate SyncLink GT serial adapters.
 *
@@ -91,12 +91,12 @@
 * module identification
 */
 static char *driver_name     = "SyncLink GT";
-static char *driver_version  = "$Revision: 4.25 $";
+static char *driver_version  = "$Revision: 4.36 $";
 static char *tty_driver_name = "synclink_gt";
 static char *tty_dev_prefix  = "ttySLG";
 MODULE_LICENSE("GPL");
 #define MGSL_MAGIC 0x5401
-#define MAX_DEVICES 12
+#define MAX_DEVICES 32
 static struct pci_device_id pci_table[] = {
        {PCI_VENDOR_ID_MICROGATE, SYNCLINK_GT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
@@ -461,7 +461,7 @@ static int  adapter_test(struct slgt_info *info);
 static void reset_adapter(struct slgt_info *info);
 static void reset_port(struct slgt_info *info);
 static void async_mode(struct slgt_info *info);
-static void hdlc_mode(struct slgt_info *info);
+static void sync_mode(struct slgt_info *info);
 static void rx_stop(struct slgt_info *info);
 static void rx_start(struct slgt_info *info);
@@ -881,7 +881,9 @@ static int write(struct tty_struct *tty,
        if (!count)
                goto cleanup;
-        if (info->params.mode == MGSL_MODE_RAW) {
+        if (info->params.mode == MGSL_MODE_RAW ||
+            info->params.mode == MGSL_MODE_MONOSYNC ||
+            info->params.mode == MGSL_MODE_BISYNC) {
                unsigned int bufs_needed = (count/DMABUFSIZE);
                unsigned int bufs_free = free_tbuf_count(info);
                if (count % DMABUFSIZE)
@@ -1897,6 +1899,8 @@ static void bh_handler(void* context)
                                while(rx_get_frame(info));
                                break;
                        case MGSL_MODE_RAW:
+                        case MGSL_MODE_MONOSYNC:
+                        case MGSL_MODE_BISYNC:
                                while(rx_get_buf(info));
                                break;
                        }
@@ -2362,10 +2366,9 @@ static void program_hw(struct slgt_info *info)
        rx_stop(info);
        tx_stop(info);
-        if (info->params.mode == MGSL_MODE_HDLC ||
+        if (info->params.mode != MGSL_MODE_ASYNC ||
-            info->params.mode == MGSL_MODE_RAW ||
            info->netcount)
-                hdlc_mode(info);
+                sync_mode(info);
        else
                async_mode(info);
@@ -2564,6 +2567,10 @@ static int rx_enable(struct slgt_info *info, int enable)
        if (enable) {
                if (!info->rx_enabled)
                        rx_start(info);
+                else if (enable == 2) {
+                        /* force hunt mode (write 1 to RCR[3]) */
+                        wr_reg16(info, RCR, rd_reg16(info, RCR) | BIT3);
+                }
        } else {
                if (info->rx_enabled)
                        rx_stop(info);
@@ -3434,7 +3441,7 @@ static void __devexit remove_one(struct pci_dev *dev)
 {
 }
-static struct tty_operations ops = {
+static const struct tty_operations ops = {
        .open = open,
        .close = close,
        .write = write,
@@ -3748,7 +3755,7 @@ static void tx_start(struct slgt_info *info)
 {
        if (!info->tx_enabled) {
                wr_reg16(info, TCR,
-                        (unsigned short)(rd_reg16(info, TCR) | BIT1));
+                         (unsigned short)((rd_reg16(info, TCR) | BIT1) & ~BIT2));
                info->tx_enabled = TRUE;
        }
@@ -3775,13 +3782,18 @@ static void tx_start(struct slgt_info *info)
                                tdma_reset(info);
                                /* set 1st descriptor address */
                                wr_reg32(info, TDDAR, info->tbufs[info->tbuf_start].pdesc);
-                                if (info->params.mode == MGSL_MODE_RAW)
+                                switch(info->params.mode) {
+                                case MGSL_MODE_RAW:
+                                case MGSL_MODE_MONOSYNC:
+                                case MGSL_MODE_BISYNC:
                                        wr_reg32(info, TDCSR, BIT2 + BIT0); /* IRQ + DMA enable */
-                                else
+                                        break;
+                                default:
                                        wr_reg32(info, TDCSR, BIT0); /* DMA enable */
+                                }
                        }
-                        if (info->params.mode != MGSL_MODE_RAW) {
+                        if (info->params.mode == MGSL_MODE_HDLC) {
                                info->tx_timer.expires = jiffies + msecs_to_jiffies(5000);
                                add_timer(&info->tx_timer);
                        }
@@ -3814,7 +3826,6 @@ static void tx_stop(struct slgt_info *info)
        /* reset and disable transmitter */
        val = rd_reg16(info, TCR) & ~BIT1;          /* clear enable bit */
        wr_reg16(info, TCR, (unsigned short)(val | BIT2)); /* set reset bit */
-        wr_reg16(info, TCR, val);                  /* clear reset */
        slgt_irq_off(info, IRQ_TXDATA + IRQ_TXIDLE + IRQ_TXUNDER);
@@ -3982,7 +3993,7 @@ static void async_mode(struct slgt_info *info)
                enable_loopback(info);
 }
-static void hdlc_mode(struct slgt_info *info)
+static void sync_mode(struct slgt_info *info)
 {
        unsigned short val;
@@ -3992,7 +4003,7 @@ static void hdlc_mode(struct slgt_info *info)
        /* TCR (tx control)
         *
-         * 15..13  mode, 000=HDLC 001=raw sync
+         * 15..13  mode, 000=HDLC 001=raw 010=async 011=monosync 100=bisync
         * 12..10  encoding
         * 09      CRC enable
         * 08      CRC32
@@ -4006,8 +4017,11 @@ static void hdlc_mode(struct slgt_info *info)
         */
        val = 0;
-        if (info->params.mode == MGSL_MODE_RAW)
+        switch(info->params.mode) {
-                val |= BIT13;
+        case MGSL_MODE_MONOSYNC: val |= BIT14 + BIT13; break;
+        case MGSL_MODE_BISYNC:   val |= BIT15; break;
+        case MGSL_MODE_RAW:      val |= BIT13; break;
+        }
        if (info->if_mode & MGSL_INTERFACE_RTS_EN)
                val |= BIT7;
@@ -4058,7 +4072,7 @@ static void hdlc_mode(struct slgt_info *info)
        /* RCR (rx control)
         *
-         * 15..13  mode, 000=HDLC 001=raw sync
+         * 15..13  mode, 000=HDLC 001=raw 010=async 011=monosync 100=bisync
         * 12..10  encoding
         * 09      CRC enable
         * 08      CRC32
@@ -4069,8 +4083,11 @@ static void hdlc_mode(struct slgt_info *info)
         */
        val = 0;
-        if (info->params.mode == MGSL_MODE_RAW)
+        switch(info->params.mode) {
-                val |= BIT13;
+        case MGSL_MODE_MONOSYNC: val |= BIT14 + BIT13; break;
+        case MGSL_MODE_BISYNC:   val |= BIT15; break;
+        case MGSL_MODE_RAW:      val |= BIT13; break;
+        }
        switch(info->params.encoding)
        {
@@ -4309,10 +4326,15 @@ static void free_rbufs(struct slgt_info *info, unsigned int i, unsigned int last
        while(!done) {
                /* reset current buffer for reuse */
                info->rbufs[i].status = 0;
-                if (info->params.mode == MGSL_MODE_RAW)
+                switch(info->params.mode) {
+                case MGSL_MODE_RAW:
+                case MGSL_MODE_MONOSYNC:
+                case MGSL_MODE_BISYNC:
                        set_desc_count(info->rbufs[i], info->raw_rx_size);
-                else
+                        break;
+                default:
                        set_desc_count(info->rbufs[i], DMABUFSIZE);
+                }
                if (i == last)
                        done = 1;
@@ -4477,13 +4499,24 @@ cleanup:
 static int rx_get_buf(struct slgt_info *info)
 {
        unsigned int i = info->rbuf_current;
+        unsigned int count;
        if (!desc_complete(info->rbufs[i]))
                return 0;
-        DBGDATA(info, info->rbufs[i].buf, desc_count(info->rbufs[i]), "rx");
+        count = desc_count(info->rbufs[i]);
-        DBGINFO(("rx_get_buf size=%d\n", desc_count(info->rbufs[i])));
+        switch(info->params.mode) {
-        ldisc_receive_buf(info->tty, info->rbufs[i].buf,
+        case MGSL_MODE_MONOSYNC:
-                          info->flag_buf, desc_count(info->rbufs[i]));
+        case MGSL_MODE_BISYNC:
+                /* ignore residue in byte synchronous modes */
+                if (desc_residue(info->rbufs[i]))
+                        count--;
+                break;
+        }
+        DBGDATA(info, info->rbufs[i].buf, count, "rx");
+        DBGINFO(("rx_get_buf size=%d\n", count));
+        if (count)
+                ldisc_receive_buf(info->tty, info->rbufs[i].buf,
+                                  info->flag_buf, count);
        free_rbufs(info, i, i);
        return 1;
 }
@@ -4549,8 +4582,13 @@ static void tx_load(struct slgt_info *info, const char *buf, unsigned int size)
                size -= count;
                buf  += count;
-                if (!size && info->params.mode != MGSL_MODE_RAW)
+                /*
-                        set_desc_eof(*d, 1); /* HDLC: set EOF of last desc */
+                 * set EOF bit for last buffer of HDLC frame or
+                 * for every buffer in raw mode
+                 */
+                if ((!size && info->params.mode == MGSL_MODE_HDLC) ||
+                    info->params.mode == MGSL_MODE_RAW)
+                        set_desc_eof(*d, 1);
                else
                        set_desc_eof(*d, 0);
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 66f3754fbbdf..6eb75dcd7961 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -3929,7 +3929,7 @@ void device_init(int adapter_num, struct pci_dev *pdev)
        }
 }
-static struct tty_operations ops = {
+static const struct tty_operations ops = {
        .open = open,
        .close = close,
        .write = write,
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 0ad6cb081db4..6b4d4d1e343d 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -113,6 +113,7 @@ static struct sysrq_key_op sysrq_crashdump_op = {
 static void sysrq_handle_reboot(int key, struct pt_regs *pt_regs,
                                struct tty_struct *tty)
 {
+        lockdep_off();
        local_irq_enable();
        emergency_restart();
 }
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c
index d30dc09dbbc9..9df0ca1be0e3 100644
--- a/drivers/char/tipar.c
+++ b/drivers/char/tipar.c
@@ -224,14 +224,16 @@ probe_ti_parallel(int minor)
 {
        int i;
        int seq[] = { 0x00, 0x20, 0x10, 0x30 };
+        int data;
        for (i = 3; i >= 0; i--) {
                outbyte(3, minor);
                outbyte(i, minor);
                udelay(delay);
+                data = inbyte(minor) & 0x30;
                pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i,
-                        data & 0x30, seq[i]);
+                        data, seq[i]);
-                if ((inbyte(minor) & 0x30) != seq[i]) {
+                if (data != seq[i]) {
                        outbyte(3, minor);
                        return -1;
                }
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 333741770f1e..e90ea39c7c4b 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -3680,7 +3680,8 @@ void put_tty_driver(struct tty_driver *driver)
        kfree(driver);
 }
-void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
+void tty_set_operations(struct tty_driver *driver,
+                        const struct tty_operations *op)
 {
        driver->open = op->open;
        driver->close = op->close;
diff --git a/drivers/char/viocons.c b/drivers/char/viocons.c
index f3efeaf2826e..a362ee9c92dd 100644
--- a/drivers/char/viocons.c
+++ b/drivers/char/viocons.c
@@ -1047,7 +1047,7 @@ static int send_open(HvLpIndex remoteLp, void *sem)
                        0, 0, 0, 0);
 }
-static struct tty_operations serial_ops = {
+static const struct tty_operations serial_ops = {
        .open = viotty_open,
        .close = viotty_close,
        .write = viotty_write,
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index bfe5ea948f6a..c2ca31eb850b 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -113,7 +113,7 @@ static struct real_driver scc_real_driver = {
 };
-static struct tty_operations scc_ops = {
+static const struct tty_operations scc_ops = {
        .open   = scc_open,
        .close = gs_close,
        .write = gs_write,
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index fb75da940b59..8e4413f6fbaf 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -106,7 +106,8 @@
 #define MAX_NR_CON_DRIVER 16
 #define CON_DRIVER_FLAG_MODULE 1
-#define CON_DRIVER_FLAG_INIT 2
+#define CON_DRIVER_FLAG_INIT   2
+#define CON_DRIVER_FLAG_ATTR   4
 struct con_driver {
        const struct consw *con;
@@ -138,14 +139,6 @@ const struct consw *conswitchp;
 extern void vcs_make_sysfs(struct tty_struct *tty);
 extern void vcs_remove_sysfs(struct tty_struct *tty);
-extern void console_map_init(void);
-#ifdef CONFIG_PROM_CONSOLE
-extern void prom_con_init(void);
-#endif
-#ifdef CONFIG_MDA_CONSOLE
-extern int mda_console_init(void);
-#endif
 struct vc vc_cons [MAX_NR_CONSOLES];
 #ifndef VT_SINGLE_DRIVER
@@ -903,6 +896,7 @@ void vc_deallocate(unsigned int currcons)
        if (vc_cons_allocated(currcons)) {
                struct vc_data *vc = vc_cons[currcons].d;
                vc->vc_sw->con_deinit(vc);
+                put_pid(vc->vt_pid);
                module_put(vc->vc_sw->owner);
                if (vc->vc_kmalloced)
                        kfree(vc->vc_screenbuf);
@@ -2674,7 +2668,7 @@ static int __init con_init(void)
 }
 console_initcall(con_init);
-static struct tty_operations con_ops = {
+static const struct tty_operations con_ops = {
        .open = con_open,
        .close = con_close,
        .write = con_write,
@@ -3069,22 +3063,37 @@ static struct class_device_attribute class_device_attrs[] = {
 static int vtconsole_init_class_device(struct con_driver *con)
 {
        int i;
+        int error = 0;
+        con->flag |= CON_DRIVER_FLAG_ATTR;
        class_set_devdata(con->class_dev, con);
-        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
+        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++) {
-                class_device_create_file(con->class_dev,
+                error = class_device_create_file(con->class_dev,
+                                         &class_device_attrs[i]);
+                if (error)
+                        break;
+        }
+        if (error) {
+                while (--i >= 0)
+                        class_device_remove_file(con->class_dev,
                                         &class_device_attrs[i]);
+                con->flag &= ~CON_DRIVER_FLAG_ATTR;
+        }
-        return 0;
+        return error;
 }
 static void vtconsole_deinit_class_device(struct con_driver *con)
 {
        int i;
-        for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
+        if (con->flag & CON_DRIVER_FLAG_ATTR) {
-                class_device_remove_file(con->class_dev,
+                for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                                         &class_device_attrs[i]);
+                        class_device_remove_file(con->class_dev,
+                                                 &class_device_attrs[i]);
+                con->flag &= ~CON_DRIVER_FLAG_ATTR;
+        }
 }
 /**
@@ -3183,6 +3192,7 @@ int register_con_driver(const struct consw *csw, int first, int last)
        } else {
                vtconsole_init_class_device(con_driver);
        }
 err:
        release_console_sem();
        module_put(owner);
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index a53e382cc107..ac5d60edbafa 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -645,13 +645,16 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
         */
        case KDSIGACCEPT:
        {
-                extern int spawnpid, spawnsig;
                if (!perm || !capable(CAP_KILL))
                  return -EPERM;
                if (!valid_signal(arg) || arg < 1 || arg == SIGKILL)
                  return -EINVAL;
-                spawnpid = current->pid;
-                spawnsig = arg;
+                spin_lock_irq(&vt_spawn_con.lock);
+                put_pid(vt_spawn_con.pid);
+                vt_spawn_con.pid = get_pid(task_pid(current));
+                vt_spawn_con.sig = arg;
+                spin_unlock_irq(&vt_spawn_con.lock);
                return 0;
        }
@@ -669,7 +672,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                vc->vt_mode = tmp;
                /* the frsig is ignored, so we set it to 0 */
                vc->vt_mode.frsig = 0;
-                vc->vt_pid = current->pid;
+                put_pid(xchg(&vc->vt_pid, get_pid(task_pid(current))));
                /* no switch is required -- saw@shade.msu.ru */
                vc->vt_newvt = -1;
                release_console_sem();
@@ -1060,7 +1063,7 @@ void reset_vc(struct vc_data *vc)
        vc->vt_mode.relsig = 0;
        vc->vt_mode.acqsig = 0;
        vc->vt_mode.frsig = 0;
-        vc->vt_pid = -1;
+        put_pid(xchg(&vc->vt_pid, NULL));
        vc->vt_newvt = -1;
        if (!in_interrupt())    /* Via keyboard.c:SAK() - akpm */
                reset_palette(vc);
@@ -1111,7 +1114,7 @@ static void complete_change_console(struct vc_data *vc)
                 * tell us if the process has gone or something else
                 * is awry
                 */
-                if (kill_proc(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
+                if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
                /*
                 * The controlling process has died, so we revert back to
                 * normal operation. In this case, we'll also change back
@@ -1171,7 +1174,7 @@ void change_console(struct vc_data *new_vc)
                 * tell us if the process has gone or something else
                 * is awry
                 */
-                if (kill_proc(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
+                if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
                        /*
                         * It worked. Mark the vt to switch to and
                         * return. The process needs to send us a
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig
index 77ab7e020da0..06f3fa2fe877 100644
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -172,6 +172,17 @@ config OMAP_WATCHDOG
          Support for TI OMAP1610/OMAP1710/OMAP2420 watchdog.  Say 'Y' here to
          enable the OMAP1610/OMAP1710 watchdog timer.
+config PNX4008_WATCHDOG
+        tristate "PNX4008 Watchdog"
+        depends on WATCHDOG && ARCH_PNX4008
+        help
+          Say Y here if to include support for the watchdog timer
+          in the PNX4008 processor.
+          This driver can be built as a module by choosing M. The module
+          will be called pnx4008_wdt.
+          Say N if you are unsure.
 # X86 (i386 + ia64 + x86_64) Architecture
 config ACQUIRE_WDT
diff --git a/drivers/char/watchdog/Makefile b/drivers/char/watchdog/Makefile
index 5099f8be8cc5..6ffca7cb56ab 100644
--- a/drivers/char/watchdog/Makefile
+++ b/drivers/char/watchdog/Makefile
@@ -33,6 +33,7 @@ obj-$(CONFIG_S3C2410_WATCHDOG) += s3c2410_wdt.o
 obj-$(CONFIG_SA1100_WATCHDOG) += sa1100_wdt.o
 obj-$(CONFIG_MPCORE_WATCHDOG) += mpcore_wdt.o
 obj-$(CONFIG_EP93XX_WATCHDOG) += ep93xx_wdt.o
+obj-$(CONFIG_PNX4008_WATCHDOG) += pnx4008_wdt.o
 # X86 (i386 + ia64 + x86_64) Architecture
 obj-$(CONFIG_ACQUIRE_WDT) += acquirewdt.o
diff --git a/drivers/char/watchdog/acquirewdt.c b/drivers/char/watchdog/acquirewdt.c
index c77fe3cf2852..154d67e591e5 100644
--- a/drivers/char/watchdog/acquirewdt.c
+++ b/drivers/char/watchdog/acquirewdt.c
@@ -183,7 +183,7 @@ static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        }
        default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/advantechwdt.c b/drivers/char/watchdog/advantechwdt.c
index 8069be445edc..9d732769ba01 100644
--- a/drivers/char/watchdog/advantechwdt.c
+++ b/drivers/char/watchdog/advantechwdt.c
@@ -176,7 +176,7 @@ advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        }
        default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
        }
        return 0;
 }
diff --git a/drivers/char/watchdog/alim1535_wdt.c b/drivers/char/watchdog/alim1535_wdt.c
index c5c94e4c9495..01b0d132ee41 100644
--- a/drivers/char/watchdog/alim1535_wdt.c
+++ b/drivers/char/watchdog/alim1535_wdt.c
@@ -236,7 +236,7 @@ static int ali_ioctl(struct inode *inode, struct file *file,
                        return put_user(timeout, p);
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
@@ -330,17 +330,20 @@ static int __init ali_find_watchdog(void)
        u32 wdog;
        /* Check for a 1535 series bridge */
-        pdev = pci_find_device(PCI_VENDOR_ID_AL, 0x1535, NULL);
+        pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x1535, NULL);
        if(pdev == NULL)
                return -ENODEV;
+        pci_dev_put(pdev);
        /* Check for the a 7101 PMU */
-        pdev = pci_find_device(PCI_VENDOR_ID_AL, 0x7101, NULL);
+        pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x7101, NULL);
        if(pdev == NULL)
                return -ENODEV;
-        if(pci_enable_device(pdev))
+        if(pci_enable_device(pdev)) {
+                pci_dev_put(pdev);
                return -EIO;
+        }
        ali_pci = pdev;
@@ -447,6 +450,7 @@ static void __exit watchdog_exit(void)
        /* Deregister */
        unregister_reboot_notifier(&ali_notifier);
        misc_deregister(&ali_miscdev);
+        pci_dev_put(ali_pci);
 }
 module_init(watchdog_init);
diff --git a/drivers/char/watchdog/alim7101_wdt.c b/drivers/char/watchdog/alim7101_wdt.c
index ffd7684f999b..5948863b592b 100644
--- a/drivers/char/watchdog/alim7101_wdt.c
+++ b/drivers/char/watchdog/alim7101_wdt.c
@@ -277,7 +277,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
                case WDIOC_GETTIMEOUT:
                        return put_user(timeout, p);
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
@@ -333,6 +333,7 @@ static void __exit alim7101_wdt_unload(void)
        /* Deregister */
        misc_deregister(&wdt_miscdev);
        unregister_reboot_notifier(&wdt_notifier);
+        pci_dev_put(alim7101_pmu);
 }
 static int __init alim7101_wdt_init(void)
@@ -342,7 +343,8 @@ static int __init alim7101_wdt_init(void)
        char tmp;
        printk(KERN_INFO PFX "Steve Hill <steve@navaho.co.uk>.\n");
-        alim7101_pmu = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,NULL);
+        alim7101_pmu = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M7101,
+                NULL);
        if (!alim7101_pmu) {
                printk(KERN_INFO PFX "ALi M7101 PMU not present - WDT not set\n");
                return -EBUSY;
@@ -351,21 +353,23 @@ static int __init alim7101_wdt_init(void)
        /* Set the WDT in the PMU to 1 second */
        pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, 0x02);
-        ali1543_south = pci_find_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
+        ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
+                NULL);
        if (!ali1543_south) {
                printk(KERN_INFO PFX "ALi 1543 South-Bridge not present - WDT not set\n");
-                return -EBUSY;
+                goto err_out;
        }
        pci_read_config_byte(ali1543_south, 0x5e, &tmp);
+        pci_dev_put(ali1543_south);
        if ((tmp & 0x1e) == 0x00) {
                if (!use_gpio) {
                        printk(KERN_INFO PFX "Detected old alim7101 revision 'a1d'.  If this is a cobalt board, set the 'use_gpio' module parameter.\n");
-                        return -EBUSY;
+                        goto err_out;
                } 
                nowayout = 1;
        } else if ((tmp & 0x1e) != 0x12 && (tmp & 0x1e) != 0x00) {
                printk(KERN_INFO PFX "ALi 1543 South-Bridge does not have the correct revision number (???1001?) - WDT not set\n");
-                return -EBUSY;
+                goto err_out;
        }
        if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
@@ -404,6 +408,7 @@ static int __init alim7101_wdt_init(void)
 err_out_miscdev:
        misc_deregister(&wdt_miscdev);
 err_out:
+        pci_dev_put(alim7101_pmu);
        return rc;
 }
diff --git a/drivers/char/watchdog/at91_wdt.c b/drivers/char/watchdog/at91_wdt.c
index cc266715ea32..4e7a1145e78f 100644
--- a/drivers/char/watchdog/at91_wdt.c
+++ b/drivers/char/watchdog/at91_wdt.c
@@ -168,7 +168,7 @@ static int at91_wdt_ioctl(struct inode *inode, struct file *file,
                        return 0;
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/booke_wdt.c b/drivers/char/watchdog/booke_wdt.c
index e3cefc538b40..488902231cc2 100644
--- a/drivers/char/watchdog/booke_wdt.c
+++ b/drivers/char/watchdog/booke_wdt.c
@@ -125,7 +125,7 @@ static int booke_wdt_ioctl (struct inode *inode, struct file *file,
                        return -EINVAL;
                return 0;
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
        return 0;
diff --git a/drivers/char/watchdog/cpu5wdt.c b/drivers/char/watchdog/cpu5wdt.c
index 04c7e49918db..00bdabb90f27 100644
--- a/drivers/char/watchdog/cpu5wdt.c
+++ b/drivers/char/watchdog/cpu5wdt.c
@@ -183,7 +183,7 @@ static int cpu5wdt_ioctl(struct inode *inode, struct file *file, unsigned int cm
                        }
                        break;
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
        return 0;
 }
diff --git a/drivers/char/watchdog/ep93xx_wdt.c b/drivers/char/watchdog/ep93xx_wdt.c
index 77c8a955ae9e..01cf123b1616 100644
--- a/drivers/char/watchdog/ep93xx_wdt.c
+++ b/drivers/char/watchdog/ep93xx_wdt.c
@@ -144,7 +144,7 @@ static int
 ep93xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
        switch (cmd) {
        case WDIOC_GETSUPPORT:
diff --git a/drivers/char/watchdog/eurotechwdt.c b/drivers/char/watchdog/eurotechwdt.c
index 62dbccb2f6df..4f4269754c46 100644
--- a/drivers/char/watchdog/eurotechwdt.c
+++ b/drivers/char/watchdog/eurotechwdt.c
@@ -240,7 +240,7 @@ static int eurwdt_ioctl(struct inode *inode, struct file *file,
        switch(cmd) {
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        case WDIOC_GETSUPPORT:
                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
diff --git a/drivers/char/watchdog/i6300esb.c b/drivers/char/watchdog/i6300esb.c
index 870539eabbf3..fb64df4d7c87 100644
--- a/drivers/char/watchdog/i6300esb.c
+++ b/drivers/char/watchdog/i6300esb.c
@@ -315,7 +315,7 @@ static int esb_ioctl (struct inode *inode, struct file *file,
                        return put_user(heartbeat, p);
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/i8xx_tco.c b/drivers/char/watchdog/i8xx_tco.c
index 8385dd36eefe..e0627d79707b 100644
--- a/drivers/char/watchdog/i8xx_tco.c
+++ b/drivers/char/watchdog/i8xx_tco.c
@@ -356,7 +356,7 @@ static int i8xx_tco_ioctl (struct inode *inode, struct file *file,
                }
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
@@ -406,18 +406,18 @@ static struct notifier_block i8xx_tco_notifier = {
 * want to register another driver on the same PCI id.
 */
 static struct pci_device_id i8xx_tco_pci_tbl[] = {
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0,   PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0,   PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0,   PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10,  PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0,   PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12,  PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0,   PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12,  PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0,    PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0,   PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0) },
-        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1,       PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1) },
-        { 0, },                 /* End of list */
+        { },                    /* End of list */
 };
 MODULE_DEVICE_TABLE (pci, i8xx_tco_pci_tbl);
@@ -434,12 +434,11 @@ static unsigned char __init i8xx_tco_getdevice (void)
         *      Find the PCI device
         */
-        while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+        for_each_pci_dev(dev)
                if (pci_match_id(i8xx_tco_pci_tbl, dev)) {
                        i8xx_tco_pci = dev;
                        break;
                }
-        }
        if (i8xx_tco_pci) {
                /*
@@ -454,6 +453,7 @@ static unsigned char __init i8xx_tco_getdevice (void)
                /* Something's wrong here, ACPIBASE has to be set */
                if (badr == 0x0001 || badr == 0x0000) {
                        printk (KERN_ERR PFX "failed to get TCOBASE address\n");
+                        pci_dev_put(i8xx_tco_pci);
                        return 0;
                }
@@ -465,6 +465,7 @@ static unsigned char __init i8xx_tco_getdevice (void)
                        pci_read_config_byte (i8xx_tco_pci, 0xd4, &val1);
                        if (val1 & 0x02) {
                                printk (KERN_ERR PFX "failed to reset NO_REBOOT flag, reboot disabled by hardware\n");
+                                pci_dev_put(i8xx_tco_pci);
                                return 0;       /* Cannot reset NO_REBOOT bit */
                        }
                }
@@ -476,6 +477,7 @@ static unsigned char __init i8xx_tco_getdevice (void)
                if (!request_region (SMI_EN + 1, 1, "i8xx TCO")) {
                        printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
                                SMI_EN + 1);
+                        pci_dev_put(i8xx_tco_pci);
                        return 0;
                }
                val1 = inb (SMI_EN + 1);
@@ -542,6 +544,7 @@ unreg_notifier:
 unreg_region:
        release_region (TCOBASE, 0x10);
 out:
+        pci_dev_put(i8xx_tco_pci);
        return ret;
 }
@@ -555,6 +558,8 @@ static void __exit watchdog_cleanup (void)
        misc_deregister (&i8xx_tco_miscdev);
        unregister_reboot_notifier(&i8xx_tco_notifier);
        release_region (TCOBASE, 0x10);
+        pci_dev_put(i8xx_tco_pci);
 }
 module_init(watchdog_init);
diff --git a/drivers/char/watchdog/ib700wdt.c b/drivers/char/watchdog/ib700wdt.c
index fd95f7327798..c1ed209a138c 100644
--- a/drivers/char/watchdog/ib700wdt.c
+++ b/drivers/char/watchdog/ib700wdt.c
@@ -199,7 +199,7 @@ ibwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
          break;
        default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
        }
        return 0;
 }
diff --git a/drivers/char/watchdog/ibmasr.c b/drivers/char/watchdog/ibmasr.c
index 26ceee7a4df0..dd6760f1a23b 100644
--- a/drivers/char/watchdog/ibmasr.c
+++ b/drivers/char/watchdog/ibmasr.c
@@ -295,7 +295,7 @@ static int asr_ioctl(struct inode *inode, struct file *file,
                }
        }
-        return -ENOIOCTLCMD;
+        return -ENOTTY;
 }
 static int asr_open(struct inode *inode, struct file *file)
diff --git a/drivers/char/watchdog/indydog.c b/drivers/char/watchdog/indydog.c
index dacc1c20a310..0bc239308989 100644
--- a/drivers/char/watchdog/indydog.c
+++ b/drivers/char/watchdog/indydog.c
@@ -112,7 +112,7 @@ static int indydog_ioctl(struct inode *inode, struct file *file,
        switch (cmd) {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        if (copy_to_user((struct watchdog_info *)arg,
                                         &ident, sizeof(ident)))
diff --git a/drivers/char/watchdog/ixp2000_wdt.c b/drivers/char/watchdog/ixp2000_wdt.c
index 692908819e26..c91d9a660ec0 100644
--- a/drivers/char/watchdog/ixp2000_wdt.c
+++ b/drivers/char/watchdog/ixp2000_wdt.c
@@ -107,7 +107,7 @@ static int
 ixp2000_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                        unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
        int time;
        switch (cmd) {
diff --git a/drivers/char/watchdog/ixp4xx_wdt.c b/drivers/char/watchdog/ixp4xx_wdt.c
index 9db5cf2c38c3..db477f712388 100644
--- a/drivers/char/watchdog/ixp4xx_wdt.c
+++ b/drivers/char/watchdog/ixp4xx_wdt.c
@@ -102,7 +102,7 @@ static int
 ixp4xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                        unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
        int time;
        switch (cmd) {
diff --git a/drivers/char/watchdog/machzwd.c b/drivers/char/watchdog/machzwd.c
index 23734e07fb22..276577d08fba 100644
--- a/drivers/char/watchdog/machzwd.c
+++ b/drivers/char/watchdog/machzwd.c
@@ -329,7 +329,7 @@ static int zf_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                        break;
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
        return 0;
@@ -426,8 +426,7 @@ static int __init zf_init(void)
        printk(KERN_INFO PFX ": MachZ ZF-Logic Watchdog driver initializing.\n");
        ret = zf_get_ZFL_version();
-        printk("%#x\n", ret);
+        if ((!ret) || (ret == 0xffff)) {
-        if((!ret) || (ret != 0xffff)){
                printk(KERN_WARNING PFX ": no ZF-Logic found\n");
                return -ENODEV;
        }
diff --git a/drivers/char/watchdog/mixcomwd.c b/drivers/char/watchdog/mixcomwd.c
index ae943324d251..c2dac0aa1d62 100644
--- a/drivers/char/watchdog/mixcomwd.c
+++ b/drivers/char/watchdog/mixcomwd.c
@@ -185,7 +185,7 @@ static int mixcomwd_ioctl(struct inode *inode, struct file *file,
                        mixcomwd_ping();
                        break;
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
        return 0;
 }
diff --git a/drivers/char/watchdog/mpc83xx_wdt.c b/drivers/char/watchdog/mpc83xx_wdt.c
index a480903ee1a5..18ca752e2f90 100644
--- a/drivers/char/watchdog/mpc83xx_wdt.c
+++ b/drivers/char/watchdog/mpc83xx_wdt.c
@@ -125,7 +125,7 @@ static int mpc83xx_wdt_ioctl(struct inode *inode, struct file *file,
        case WDIOC_GETTIMEOUT:
                return put_user(timeout_sec, p);
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/mpc8xx_wdt.c b/drivers/char/watchdog/mpc8xx_wdt.c
index 35dd9e6e1140..8aaed10dd499 100644
--- a/drivers/char/watchdog/mpc8xx_wdt.c
+++ b/drivers/char/watchdog/mpc8xx_wdt.c
@@ -126,7 +126,7 @@ static int mpc8xx_wdt_ioctl(struct inode *inode, struct file *file,
                break;
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
        return 0;
diff --git a/drivers/char/watchdog/mpcore_wdt.c b/drivers/char/watchdog/mpcore_wdt.c
index 54b3c56ead0d..02d336ace504 100644
--- a/drivers/char/watchdog/mpcore_wdt.c
+++ b/drivers/char/watchdog/mpcore_wdt.c
@@ -221,7 +221,7 @@ static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
        } uarg;
        if (_IOC_DIR(cmd) && _IOC_SIZE(cmd) > sizeof(uarg))
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        if (_IOC_DIR(cmd) & _IOC_WRITE) {
                ret = copy_from_user(&uarg, (void __user *)arg, _IOC_SIZE(cmd));
@@ -271,7 +271,7 @@ static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
                break;
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
        if (ret == 0 && _IOC_DIR(cmd) & _IOC_READ) {
diff --git a/drivers/char/watchdog/mv64x60_wdt.c b/drivers/char/watchdog/mv64x60_wdt.c
index 5c8fab345b40..b887cdb01334 100644
--- a/drivers/char/watchdog/mv64x60_wdt.c
+++ b/drivers/char/watchdog/mv64x60_wdt.c
@@ -160,7 +160,7 @@ static int mv64x60_wdt_ioctl(struct inode *inode, struct file *file,
                break;
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
        return 0;
diff --git a/drivers/char/watchdog/pcwd.c b/drivers/char/watchdog/pcwd.c
index cd7d1b6a5d9f..6f8515db5b07 100644
--- a/drivers/char/watchdog/pcwd.c
+++ b/drivers/char/watchdog/pcwd.c
@@ -572,7 +572,7 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
        switch(cmd) {
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        case WDIOC_GETSUPPORT:
                if(copy_to_user(argp, &ident, sizeof(ident)))
diff --git a/drivers/char/watchdog/pcwd_pci.c b/drivers/char/watchdog/pcwd_pci.c
index c7cfd6dbfe1b..2de6e497c140 100644
--- a/drivers/char/watchdog/pcwd_pci.c
+++ b/drivers/char/watchdog/pcwd_pci.c
@@ -541,7 +541,7 @@ static int pcipcwd_ioctl(struct inode *inode, struct file *file,
                }
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index b7ae73dcdd08..77662cb0ac46 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -445,7 +445,7 @@ static int usb_pcwd_ioctl(struct inode *inode, struct file *file,
                }
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/pnx4008_wdt.c b/drivers/char/watchdog/pnx4008_wdt.c
new file mode 100644
index 000000000000..e7f0450a939d
--- /dev/null
+++ b/drivers/char/watchdog/pnx4008_wdt.c
@@ -0,0 +1,362 @@
+/*
+ * drivers/char/watchdog/pnx4008_wdt.c
+ *
+ * Watchdog driver for PNX4008 board
+ *
+ * Authors: Dmitry Chigirev <source@mvista.com>,
+ *          Vitaly Wool <vitalywool@gmail.com>
+ * Based on sa1100 driver,
+ * Copyright (C) 2000 Oleg Drokin <green@crimea.edu>
+ *
+ * 2005-2006 (c) MontaVista Software, Inc. This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/spinlock.h>
+#include <asm/hardware.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+#define MODULE_NAME "PNX4008-WDT: "
+/* WatchDog Timer - Chapter 23 Page 207 */
+#define DEFAULT_HEARTBEAT 19
+#define MAX_HEARTBEAT     60
+/* Watchdog timer register set definition */
+#define WDTIM_INT(p)     ((p) + 0x0)
+#define WDTIM_CTRL(p)    ((p) + 0x4)
+#define WDTIM_COUNTER(p) ((p) + 0x8)
+#define WDTIM_MCTRL(p)   ((p) + 0xC)
+#define WDTIM_MATCH0(p)  ((p) + 0x10)
+#define WDTIM_EMR(p)     ((p) + 0x14)
+#define WDTIM_PULSE(p)   ((p) + 0x18)
+#define WDTIM_RES(p)     ((p) + 0x1C)
+/* WDTIM_INT bit definitions */
+#define MATCH_INT      1
+/* WDTIM_CTRL bit definitions */
+#define COUNT_ENAB     1
+#define RESET_COUNT    (1<<1)
+#define DEBUG_EN       (1<<2)
+/* WDTIM_MCTRL bit definitions */
+#define MR0_INT        1
+#undef  RESET_COUNT0
+#define RESET_COUNT0   (1<<2)
+#define STOP_COUNT0    (1<<2)
+#define M_RES1         (1<<3)
+#define M_RES2         (1<<4)
+#define RESFRC1        (1<<5)
+#define RESFRC2        (1<<6)
+/* WDTIM_EMR bit definitions */
+#define EXT_MATCH0      1
+#define MATCH_OUTPUT_HIGH (2<<4)        /*a MATCH_CTRL setting */
+/* WDTIM_RES bit definitions */
+#define WDOG_RESET      1       /* read only */
+#define WDOG_COUNTER_RATE 13000000      /*the counter clock is 13 MHz fixed */
+static int nowayout = WATCHDOG_NOWAYOUT;
+static int heartbeat = DEFAULT_HEARTBEAT;
+static spinlock_t io_lock;
+static unsigned long wdt_status;
+#define WDT_IN_USE        0
+#define WDT_OK_TO_CLOSE   1
+#define WDT_REGION_INITED 2
+#define WDT_DEVICE_INITED 3
+static unsigned long boot_status;
+static struct resource  *wdt_mem;
+static void __iomem     *wdt_base;
+struct clk              *wdt_clk;
+static void wdt_enable(void)
+{
+        spin_lock(&io_lock);
+        if (wdt_clk)
+                clk_set_rate(wdt_clk, 1);
+        /* stop counter, initiate counter reset */
+        __raw_writel(RESET_COUNT, WDTIM_CTRL(wdt_base));
+        /*wait for reset to complete. 100% guarantee event */
+        while (__raw_readl(WDTIM_COUNTER(wdt_base)))
+                cpu_relax();
+        /* internal and external reset, stop after that */
+        __raw_writel(M_RES2 | STOP_COUNT0 | RESET_COUNT0,
+                WDTIM_MCTRL(wdt_base));
+        /* configure match output */
+        __raw_writel(MATCH_OUTPUT_HIGH, WDTIM_EMR(wdt_base));
+        /* clear interrupt, just in case */
+        __raw_writel(MATCH_INT, WDTIM_INT(wdt_base));
+        /* the longest pulse period 65541/(13*10^6) seconds ~ 5 ms. */
+        __raw_writel(0xFFFF, WDTIM_PULSE(wdt_base));
+        __raw_writel(heartbeat * WDOG_COUNTER_RATE, WDTIM_MATCH0(wdt_base));
+        /*enable counter, stop when debugger active */
+        __raw_writel(COUNT_ENAB | DEBUG_EN, WDTIM_CTRL(wdt_base));
+        spin_unlock(&io_lock);
+}
+static void wdt_disable(void)
+{
+        spin_lock(&io_lock);
+        __raw_writel(0, WDTIM_CTRL(wdt_base));  /*stop counter */
+        if (wdt_clk)
+                clk_set_rate(wdt_clk, 0);
+        spin_unlock(&io_lock);
+}
+static int pnx4008_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(WDT_IN_USE, &wdt_status))
+                return -EBUSY;
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+        wdt_enable();
+        return nonseekable_open(inode, file);
+}
+static ssize_t
+pnx4008_wdt_write(struct file *file, const char *data, size_t len,
+                  loff_t * ppos)
+{
+        /*  Can't seek (pwrite) on this device  */
+        if (ppos != &file->f_pos)
+                return -ESPIPE;
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+                        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        set_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                        }
+                }
+                wdt_enable();
+        }
+        return len;
+}
+static struct watchdog_info ident = {
+        .options = WDIOF_CARDRESET | WDIOF_MAGICCLOSE |
+            WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+        .identity = "PNX4008 Watchdog",
+};
+static int
+pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+                  unsigned long arg)
+{
+        int ret = -ENOIOCTLCMD;
+        int time;
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user((struct watchdog_info *)arg, &ident,
+                                   sizeof(ident)) ? -EFAULT : 0;
+                break;
+        case WDIOC_GETSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(boot_status, (int *)arg);
+                break;
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, (int *)arg);
+                if (ret)
+                        break;
+                if (time <= 0 || time > MAX_HEARTBEAT) {
+                        ret = -EINVAL;
+                        break;
+                }
+                heartbeat = time;
+                wdt_enable();
+                /* Fall through */
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(heartbeat, (int *)arg);
+                break;
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+        }
+        return ret;
+}
+static int pnx4008_wdt_release(struct inode *inode, struct file *file)
+{
+        if (!test_bit(WDT_OK_TO_CLOSE, &wdt_status))
+                printk(KERN_WARNING "WATCHDOG: Device closed unexpectdly\n");
+        wdt_disable();
+        clear_bit(WDT_IN_USE, &wdt_status);
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+        return 0;
+}
+static struct file_operations pnx4008_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = pnx4008_wdt_write,
+        .ioctl = pnx4008_wdt_ioctl,
+        .open = pnx4008_wdt_open,
+        .release = pnx4008_wdt_release,
+};
+static struct miscdevice pnx4008_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &pnx4008_wdt_fops,
+};
+static int pnx4008_wdt_probe(struct platform_device *pdev)
+{
+        int ret = 0, size;
+        struct resource *res;
+        spin_lock_init(&io_lock);
+        if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
+                heartbeat = DEFAULT_HEARTBEAT;
+        printk(KERN_INFO MODULE_NAME
+                "PNX4008 Watchdog Timer: heartbeat %d sec\n", heartbeat);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                printk(KERN_INFO MODULE_NAME
+                        "failed to get memory region resouce\n");
+                return -ENOENT;
+        }
+        size = res->end - res->start + 1;
+        wdt_mem = request_mem_region(res->start, size, pdev->name);
+        if (wdt_mem == NULL) {
+                printk(KERN_INFO MODULE_NAME "failed to get memory region\n");
+                return -ENOENT;
+        }
+        wdt_base = (void __iomem *)IO_ADDRESS(res->start);
+        wdt_clk = clk_get(&pdev->dev, "wdt_ck");
+        if (!wdt_clk) {
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                goto out;
+        } else
+                clk_set_rate(wdt_clk, 1);
+        ret = misc_register(&pnx4008_wdt_miscdev);
+        if (ret < 0) {
+                printk(KERN_ERR MODULE_NAME "cannot register misc device\n");
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                clk_set_rate(wdt_clk, 0);
+        } else {
+                boot_status = (__raw_readl(WDTIM_RES(wdt_base)) & WDOG_RESET) ?
+                    WDIOF_CARDRESET : 0;
+                wdt_disable();          /*disable for now */
+                set_bit(WDT_DEVICE_INITED, &wdt_status);
+        }
+out:
+        return ret;
+}
+static int pnx4008_wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&pnx4008_wdt_miscdev);
+        if (wdt_clk) {
+                clk_set_rate(wdt_clk, 0);
+                clk_put(wdt_clk);
+                wdt_clk = NULL;
+        }
+        if (wdt_mem) {
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                wdt_mem = NULL;
+        }
+        return 0;
+}
+static struct platform_driver platform_wdt_driver = {
+        .driver = {
+                .name = "watchdog",
+        },
+        .probe = pnx4008_wdt_probe,
+        .remove = pnx4008_wdt_remove,
+};
+static int __init pnx4008_wdt_init(void)
+{
+        return platform_driver_register(&platform_wdt_driver);
+}
+static void __exit pnx4008_wdt_exit(void)
+{
+        return platform_driver_unregister(&platform_wdt_driver);
+}
+module_init(pnx4008_wdt_init);
+module_exit(pnx4008_wdt_exit);
+MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
+MODULE_DESCRIPTION("PNX4008 Watchdog Driver");
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat,
+                 "Watchdog heartbeat period in seconds from 1 to "
+                 __MODULE_STRING(MAX_HEARTBEAT) ", default "
+                 __MODULE_STRING(DEFAULT_HEARTBEAT));
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+                 "Set to 1 to keep watchdog running after device release");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/char/watchdog/s3c2410_wdt.c b/drivers/char/watchdog/s3c2410_wdt.c
index be978e8ed754..b36a04ae9ab8 100644
--- a/drivers/char/watchdog/s3c2410_wdt.c
+++ b/drivers/char/watchdog/s3c2410_wdt.c
@@ -62,7 +62,7 @@
 #define CONFIG_S3C2410_WATCHDOG_ATBOOT          (0)
 #define CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME    (15)
-static int nowayout = WATCHDOG_NOWAYOUT;
+static int nowayout     = WATCHDOG_NOWAYOUT;
 static int tmr_margin   = CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME;
 static int tmr_atboot   = CONFIG_S3C2410_WATCHDOG_ATBOOT;
 static int soft_noboot  = 0;
@@ -213,11 +213,10 @@ static int s3c2410wdt_open(struct inode *inode, struct file *file)
        if(down_trylock(&open_lock))
                return -EBUSY;
-        if (nowayout) {
+        if (nowayout)
                __module_get(THIS_MODULE);
-        } else {
-                allow_close = CLOSE_STATE_ALLOW;
+        allow_close = CLOSE_STATE_NOT;
-        }
        /* start the timer */
        s3c2410wdt_start();
@@ -230,6 +229,7 @@ static int s3c2410wdt_release(struct inode *inode, struct file *file)
         *      Shut off the timer.
         *      Lock it in if it's a module and we set nowayout
         */
        if (allow_close == CLOSE_STATE_ALLOW) {
                s3c2410wdt_stop();
        } else {
@@ -288,7 +288,7 @@ static int s3c2410wdt_ioctl(struct inode *inode, struct file *file,
        switch (cmd) {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &s3c2410_wdt_ident,
diff --git a/drivers/char/watchdog/sa1100_wdt.c b/drivers/char/watchdog/sa1100_wdt.c
index 1fc16d995788..33c1137f17d6 100644
--- a/drivers/char/watchdog/sa1100_wdt.c
+++ b/drivers/char/watchdog/sa1100_wdt.c
@@ -90,7 +90,7 @@ static struct watchdog_info ident = {
 static int sa1100dog_ioctl(struct inode *inode, struct file *file,
        unsigned int cmd, unsigned long arg)
 {
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
        int time;
        void __user *argp = (void __user *)arg;
        int __user *p = argp;
diff --git a/drivers/char/watchdog/sbc60xxwdt.c b/drivers/char/watchdog/sbc60xxwdt.c
index 4663c2fd53cd..c7b2045bc76b 100644
--- a/drivers/char/watchdog/sbc60xxwdt.c
+++ b/drivers/char/watchdog/sbc60xxwdt.c
@@ -235,7 +235,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        switch(cmd)
        {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                case WDIOC_GETSTATUS:
diff --git a/drivers/char/watchdog/sbc_epx_c3.c b/drivers/char/watchdog/sbc_epx_c3.c
index bfc475dabe6d..8882b427d24f 100644
--- a/drivers/char/watchdog/sbc_epx_c3.c
+++ b/drivers/char/watchdog/sbc_epx_c3.c
@@ -141,7 +141,7 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
                return retval;
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/sc1200wdt.c b/drivers/char/watchdog/sc1200wdt.c
index 7c3cf293a5af..d8d0f28e0acf 100644
--- a/drivers/char/watchdog/sc1200wdt.c
+++ b/drivers/char/watchdog/sc1200wdt.c
@@ -180,7 +180,7 @@ static int sc1200wdt_ioctl(struct inode *inode, struct file *file, unsigned int
        switch (cmd) {
                default:
-                        return -ENOIOCTLCMD;    /* Keep Pavel Machek amused ;) */
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        if (copy_to_user(argp, &ident, sizeof ident))
diff --git a/drivers/char/watchdog/sc520_wdt.c b/drivers/char/watchdog/sc520_wdt.c
index 2c7c9db71be8..caec37ba750a 100644
--- a/drivers/char/watchdog/sc520_wdt.c
+++ b/drivers/char/watchdog/sc520_wdt.c
@@ -290,7 +290,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        switch(cmd)
        {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                case WDIOC_GETSTATUS:
diff --git a/drivers/char/watchdog/scx200_wdt.c b/drivers/char/watchdog/scx200_wdt.c
index c561299a5537..fc0e0347f9d2 100644
--- a/drivers/char/watchdog/scx200_wdt.c
+++ b/drivers/char/watchdog/scx200_wdt.c
@@ -166,7 +166,7 @@ static int scx200_wdt_ioctl(struct inode *inode, struct file *file,
        switch (cmd) {
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        case WDIOC_GETSUPPORT:
                if(copy_to_user(argp, &ident, sizeof(ident)))
                        return -EFAULT;
diff --git a/drivers/char/watchdog/shwdt.c b/drivers/char/watchdog/shwdt.c
index e5b8c64f1d65..dc403629aeb3 100644
--- a/drivers/char/watchdog/shwdt.c
+++ b/drivers/char/watchdog/shwdt.c
@@ -360,7 +360,7 @@ static int sh_wdt_ioctl(struct inode *inode, struct file *file,
                        return retval;
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
        }
        return 0;
diff --git a/drivers/char/watchdog/softdog.c b/drivers/char/watchdog/softdog.c
index ef8da517545a..4067e1f8a368 100644
--- a/drivers/char/watchdog/softdog.c
+++ b/drivers/char/watchdog/softdog.c
@@ -203,7 +203,7 @@ static int softdog_ioctl(struct inode *inode, struct file *file,
        };
        switch (cmd) {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident,
                                sizeof(ident)) ? -EFAULT : 0;
diff --git a/drivers/char/watchdog/w83627hf_wdt.c b/drivers/char/watchdog/w83627hf_wdt.c
index 13f16d41c2fd..b4adc527e687 100644
--- a/drivers/char/watchdog/w83627hf_wdt.c
+++ b/drivers/char/watchdog/w83627hf_wdt.c
@@ -223,7 +223,7 @@ wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        }
        default:
-          return -ENOIOCTLCMD;
+          return -ENOTTY;
        }
        return 0;
 }
diff --git a/drivers/char/watchdog/w83877f_wdt.c b/drivers/char/watchdog/w83877f_wdt.c
index ccf6c0915945..b0e5f84d6baf 100644
--- a/drivers/char/watchdog/w83877f_wdt.c
+++ b/drivers/char/watchdog/w83877f_wdt.c
@@ -252,7 +252,7 @@ static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        switch(cmd)
        {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
                case WDIOC_GETSTATUS:
diff --git a/drivers/char/watchdog/w83977f_wdt.c b/drivers/char/watchdog/w83977f_wdt.c
index 98f4e17db70a..2c8d5d8bd4e8 100644
--- a/drivers/char/watchdog/w83977f_wdt.c
+++ b/drivers/char/watchdog/w83977f_wdt.c
@@ -393,7 +393,7 @@ static int wdt_ioctl(struct inode *inode, struct file *file,
        switch(cmd)
        {
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        case WDIOC_GETSUPPORT:
                return copy_to_user(uarg.ident, &ident, sizeof(ident)) ? -EFAULT : 0;
diff --git a/drivers/char/watchdog/wafer5823wdt.c b/drivers/char/watchdog/wafer5823wdt.c
index 2bb6a9d6ad28..163e028ef9ed 100644
--- a/drivers/char/watchdog/wafer5823wdt.c
+++ b/drivers/char/watchdog/wafer5823wdt.c
@@ -174,7 +174,7 @@ static int wafwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd
        }
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
        return 0;
 }
diff --git a/drivers/char/watchdog/wdrtas.c b/drivers/char/watchdog/wdrtas.c
index 5c38cdf41731..1d64e277567d 100644
--- a/drivers/char/watchdog/wdrtas.c
+++ b/drivers/char/watchdog/wdrtas.c
@@ -385,7 +385,7 @@ wdrtas_ioctl(struct inode *inode, struct file *file,
                return put_user(wdrtas_interval, argp);
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        }
 }
diff --git a/drivers/char/watchdog/wdt.c b/drivers/char/watchdog/wdt.c
index 70be81e39a61..13f23f4a2233 100644
--- a/drivers/char/watchdog/wdt.c
+++ b/drivers/char/watchdog/wdt.c
@@ -341,7 +341,7 @@ static int wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        switch(cmd)
        {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
diff --git a/drivers/char/watchdog/wdt285.c b/drivers/char/watchdog/wdt285.c
index 6555fb844f23..89a249e23fde 100644
--- a/drivers/char/watchdog/wdt285.c
+++ b/drivers/char/watchdog/wdt285.c
@@ -137,7 +137,7 @@ watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
               unsigned long arg)
 {
        unsigned int new_margin;
-        int ret = -ENOIOCTLCMD;
+        int ret = -ENOTTY;
        switch(cmd) {
        case WDIOC_GETSUPPORT:
diff --git a/drivers/char/watchdog/wdt977.c b/drivers/char/watchdog/wdt977.c
index a0935bc775f8..6253041b235b 100644
--- a/drivers/char/watchdog/wdt977.c
+++ b/drivers/char/watchdog/wdt977.c
@@ -361,7 +361,7 @@ static int wdt977_ioctl(struct inode *inode, struct file *file,
        switch(cmd)
        {
        default:
-                return -ENOIOCTLCMD;
+                return -ENOTTY;
        case WDIOC_GETSUPPORT:
                return copy_to_user(uarg.ident, &ident,
diff --git a/drivers/char/watchdog/wdt_pci.c b/drivers/char/watchdog/wdt_pci.c
index 5918ca2c9c35..74d8cf836e13 100644
--- a/drivers/char/watchdog/wdt_pci.c
+++ b/drivers/char/watchdog/wdt_pci.c
@@ -386,7 +386,7 @@ static int wdtpci_ioctl(struct inode *inode, struct file *file, unsigned int cmd
        switch(cmd)
        {
                default:
-                        return -ENOIOCTLCMD;
+                        return -ENOTTY;
                case WDIOC_GETSUPPORT:
                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;