From 6e54ab36e19d4c76a51acb9d86388e4957182618 Mon Sep 17 00:00:00 2001
From: Simon Burley <simonb@lipsyncpost.co.uk>
Date: Mon, 20 May 2002 01:40:50 -0700
Subject: Tigon3: Add Netgear GA320T support.

---
 include/linux/pci_ids.h | 1 +
 1 file changed, 1 insertion(+)

(limited to 'include/linux')

diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index bebaee7edb52..67a697940471 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1551,6 +1551,7 @@
 
 #define PCI_VENDOR_ID_ALTIMA		0x173b
 #define PCI_DEVICE_ID_ALTIMA_AC1000	0x03e8
+#define PCI_DEVICE_ID_ALTIMA_AC9100	0x03ea
 
 #define PCI_VENDOR_ID_SYMPHONY		0x1c1c
 #define PCI_DEVICE_ID_SYMPHONY_101	0x0001
-- 
cgit v1.2.3


From 0ed47278fbfb6f5a358fb0c5b401cc1e423ff861 Mon Sep 17 00:00:00 2001
From: Kai Germaschewski <kai@tp1.ruhr-uni-bochum.de>
Date: Mon, 20 May 2002 12:29:51 -0500
Subject: Fix UTS_MACHINE

Remove the default for UTS_MACHINE, it gets set in
include/linux/compile.h, just as UTS_RELEASE.

(noticed by David Gibson)
---
 include/linux/uts.h | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'include/linux')

diff --git a/include/linux/uts.h b/include/linux/uts.h
index 39e09ae10135..73eb1ed36ec4 100644
--- a/include/linux/uts.h
+++ b/include/linux/uts.h
@@ -8,10 +8,6 @@
 #define UTS_SYSNAME "Linux"
 #endif
 
-#ifndef UTS_MACHINE
-#define UTS_MACHINE "unknown"
-#endif
-
 #ifndef UTS_NODENAME
 #define UTS_NODENAME "(none)"	/* set by sethostname() */
 #endif
-- 
cgit v1.2.3


From 978364b96a712fa71888c5ab6f57f530d42fb418 Mon Sep 17 00:00:00 2001
From: Christoph Hellwig <hch@infradead.org>
Date: Mon, 20 May 2002 21:32:52 -0700
Subject: [PATCH] buffermem_pages removal (5/5)

No more users of buffermem_pages are left, remove it.
While at it also remove some orphaned externs around it in swap.h
---
 fs/buffer.c          | 15 ---------------
 include/linux/swap.h |  4 ----
 mm/page_alloc.c      |  5 -----
 3 files changed, 24 deletions(-)

(limited to 'include/linux')

diff --git a/fs/buffer.c b/fs/buffer.c
index 904fec39dd60..89f89c4e84d7 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -36,9 +36,6 @@
 
 #define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
 
-/* This is used by some architectures to estimate available memory. */
-atomic_t buffermem_pages = ATOMIC_INIT(0);
-
 /*
  * Hashed waitqueue_head's for wait_on_buffer()
  */
@@ -151,10 +148,6 @@ void __wait_on_buffer(struct buffer_head * bh)
 static inline void
 __set_page_buffers(struct page *page, struct buffer_head *head)
 {
-	struct inode *inode = page->mapping->host;
-
-	if (inode && S_ISBLK(inode->i_mode))
-		atomic_inc(&buffermem_pages);
 	if (page_has_buffers(page))
 		buffer_error();
 	set_page_buffers(page, head);
@@ -164,14 +157,6 @@ __set_page_buffers(struct page *page, struct buffer_head *head)
 static inline void
 __clear_page_buffers(struct page *page)
 {
-	struct address_space *mapping = page->mapping;
-
-	if (mapping) {
-		struct inode *inode = mapping->host;
-
-		if (S_ISBLK(inode->i_mode))
-			atomic_dec(&buffermem_pages);
-	}
 	clear_page_buffers(page);
 	page_cache_release(page);
 }
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 3a376842c21c..3d87e4334851 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -102,12 +102,8 @@ extern unsigned long totalhigh_pages;
 extern unsigned int nr_free_pages(void);
 extern unsigned int nr_free_buffer_pages(void);
 extern unsigned int nr_free_pagecache_pages(void);
-extern unsigned long nr_buffermem_pages(void);
 extern int nr_active_pages;
 extern int nr_inactive_pages;
-extern atomic_t nr_async_pages;
-extern atomic_t buffermem_pages;
-extern spinlock_t pagecache_lock;
 extern void __remove_inode_page(struct page *);
 
 /* Incomplete types for prototype declarations: */
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 09d14971c2e6..82e86a0c4d9a 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -569,11 +569,6 @@ unsigned int nr_free_highpages (void)
 }
 #endif
 
-unsigned long nr_buffermem_pages(void)
-{
-	return atomic_read(&buffermem_pages);
-}
-
 /*
  * Accumulate the page_state information across all CPUs.
  * The result is unavoidably approximate - it can change
-- 
cgit v1.2.3


From facdecfa750f3459f94b5b60cfd73b676fced0df Mon Sep 17 00:00:00 2001
From: Rusty Russell <rusty@rustcorp.com.au>
Date: Mon, 20 May 2002 21:36:42 -0700
Subject: [PATCH] Futex update.

This changes futex semantics to a simple "sleep if this address
equals this value" interface, which is more convenient for building
other primitives.  It also adds a timeout value.

Example library can be found at:
   http://www.kernel.org/pub/linux/kernel/people/rusty/futex-2.0.tar.gz
---
 include/linux/futex.h |   4 +-
 kernel/futex.c        | 132 +++++++++++++++++++++++++-------------------------
 2 files changed, 69 insertions(+), 67 deletions(-)

(limited to 'include/linux')

diff --git a/include/linux/futex.h b/include/linux/futex.h
index 5ebcc879b4c0..d913c30590df 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -2,7 +2,7 @@
 #define _LINUX_FUTEX_H
 
 /* Second argument to futex syscall */
-#define FUTEX_UP (0)
-#define FUTEX_DOWN (1)
+#define FUTEX_WAIT (0)
+#define FUTEX_WAKE (1)
 
 #endif
diff --git a/kernel/futex.c b/kernel/futex.c
index 4ef5ff0ff81b..4541b2448e49 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -32,7 +32,8 @@
 #include <linux/fs.h>
 #include <linux/futex.h>
 #include <linux/highmem.h>
-#include <asm/atomic.h>
+#include <linux/time.h>
+#include <asm/uaccess.h>
 
 /* These mutexes are a very simple counter: the winner is the one who
    decrements from 1 to 0.  The counter starts at 1 when the lock is
@@ -68,22 +69,27 @@ static inline struct list_head *hash_futex(struct page *page,
 	return &futex_queues[hash_long(h, FUTEX_HASHBITS)];
 }
 
-static inline void wake_one_waiter(struct list_head *head,
-				   struct page *page,
-				   unsigned int offset)
+static int futex_wake(struct list_head *head,
+		      struct page *page,
+		      unsigned int offset,
+		      int num)
 {
-	struct list_head *i;
+	struct list_head *i, *next;
+	int num_woken = 0;
 
 	spin_lock(&futex_lock);
-	list_for_each(i, head) {
+	list_for_each_safe(i, next, head) {
 		struct futex_q *this = list_entry(i, struct futex_q, list);
 
 		if (this->page == page && this->offset == offset) {
+			list_del_init(i);
 			wake_up_process(this->task);
-			break;
+			num_woken++;
+			if (num_woken >= num) break;
 		}
 	}
 	spin_unlock(&futex_lock);
+	return num_woken;
 }
 
 /* Add at end to avoid starvation */
@@ -101,11 +107,17 @@ static inline void queue_me(struct list_head *head,
 	spin_unlock(&futex_lock);
 }
 
-static inline void unqueue_me(struct futex_q *q)
+/* Return 1 if we were still queued (ie. 0 means we were woken) */
+static inline int unqueue_me(struct futex_q *q)
 {
+	int ret = 0;
 	spin_lock(&futex_lock);
-	list_del(&q->list);
+	if (!list_empty(&q->list)) {
+		list_del(&q->list);
+		ret = 1;
+	}
 	spin_unlock(&futex_lock);
+	return ret;
 }
 
 /* Get kernel address of the user page and pin it. */
@@ -129,74 +141,65 @@ static struct page *pin_page(unsigned long page_start)
 	return page;
 }
 
-/* Try to decrement the user count to zero. */
-static int decrement_to_zero(struct page *page, unsigned int offset)
-{
-	atomic_t *count;
-	int ret = 0;
-
-	count = kmap(page) + offset;
-	/* If we take the semaphore from 1 to 0, it's ours.  If it's
-           zero, decrement anyway, to indicate we are waiting.  If
-           it's negative, don't decrement so we don't wrap... */
-	if (atomic_read(count) >= 0 && atomic_dec_and_test(count))
-		ret = 1;
-	kunmap(page);
-	return ret;
-}
-
-/* Simplified from arch/ppc/kernel/semaphore.c: Paul M. is a genius. */
-static int futex_down(struct list_head *head, struct page *page, int offset)
+static int futex_wait(struct list_head *head,
+		      struct page *page,
+		      int offset,
+		      int val,
+		      int *uaddr,
+		      unsigned long time)
 {
-	int retval = 0;
+	int curval;
 	struct futex_q q;
+	int ret = 0;
 
-	current->state = TASK_INTERRUPTIBLE;
+	set_current_state(TASK_INTERRUPTIBLE);
 	queue_me(head, &q, page, offset);
 
-	while (!decrement_to_zero(page, offset)) {
-		if (signal_pending(current)) {
-			retval = -EINTR;
-			break;
-		}
-		schedule();
-		current->state = TASK_INTERRUPTIBLE;
-	}
-	current->state = TASK_RUNNING;
-	unqueue_me(&q);
-	/* If we were signalled, we might have just been woken: we
-	   must wake another one.  Otherwise we need to wake someone
-	   else (if they are waiting) so they drop the count below 0,
-	   and when we "up" in userspace, we know there is a
-	   waiter. */
-	wake_one_waiter(head, page, offset);
-	return retval;
-}
+	/* Page is pinned, can't fail */
+	if (get_user(curval, uaddr) != 0)
+		BUG();
 
-static int futex_up(struct list_head *head, struct page *page, int offset)
-{
-	atomic_t *count;
-
-	count = kmap(page) + offset;
-	atomic_set(count, 1);
-	smp_wmb();
-	kunmap(page);
-	wake_one_waiter(head, page, offset);
-	return 0;
+	if (curval != val) {
+		ret = -EWOULDBLOCK;
+		set_current_state(TASK_RUNNING);
+		goto out;
+	}
+	time = schedule_timeout(time);
+	if (time == 0) {
+		ret = -ETIMEDOUT;
+		goto out;
+	}
+	if (signal_pending(current)) {
+		ret = -EINTR;
+		goto out;
+	}
+ out:
+	/* Were we woken up anyway? */
+	if (!unqueue_me(&q))
+		return 0;
+	return ret;
 }
 
-asmlinkage int sys_futex(void *uaddr, int op)
+asmlinkage int sys_futex(void *uaddr, int op, int val, struct timespec *utime)
 {
 	int ret;
 	unsigned long pos_in_page;
 	struct list_head *head;
 	struct page *page;
+	unsigned long time = MAX_SCHEDULE_TIMEOUT;
+
+	if (utime) {
+		struct timespec t;
+		if (copy_from_user(&t, utime, sizeof(t)) != 0)
+			return -EFAULT;
+		time = timespec_to_jiffies(&t) + 1;
+	}
 
 	pos_in_page = ((unsigned long)uaddr) % PAGE_SIZE;
 
 	/* Must be "naturally" aligned, and not on page boundary. */
-	if ((pos_in_page % __alignof__(atomic_t)) != 0
-	    || pos_in_page + sizeof(atomic_t) > PAGE_SIZE)
+	if ((pos_in_page % __alignof__(int)) != 0
+	    || pos_in_page + sizeof(int) > PAGE_SIZE)
 		return -EINVAL;
 
 	/* Simpler if it doesn't vanish underneath us. */
@@ -206,13 +209,12 @@ asmlinkage int sys_futex(void *uaddr, int op)
 
 	head = hash_futex(page, pos_in_page);
 	switch (op) {
-	case FUTEX_UP:
-		ret = futex_up(head, page, pos_in_page);
+	case FUTEX_WAIT:
+		ret = futex_wait(head, page, pos_in_page, val, uaddr, time);
 		break;
-	case FUTEX_DOWN:
-		ret = futex_down(head, page, pos_in_page);
+	case FUTEX_WAKE:
+		ret = futex_wake(head, page, pos_in_page, val);
 		break;
-	/* Add other lock types here... */
 	default:
 		ret = -EINVAL;
 	}
-- 
cgit v1.2.3


From 2c6e92adaa8f0bfb73dc03658ebbb49a22cc9387 Mon Sep 17 00:00:00 2001
From: Rusty Russell <rusty@rustcorp.com.au>
Date: Mon, 20 May 2002 21:36:50 -0700
Subject: [PATCH] Tasklet cleanup

This makes tasklet_vec and tasklet_hi_vec static inside softirq.c, and
makes them __per_cpu_data.
---
 include/linux/interrupt.h |  8 --------
 kernel/ksyms.c            |  2 --
 kernel/softirq.c          | 45 +++++++++++++++++++++++----------------------
 3 files changed, 23 insertions(+), 32 deletions(-)

(limited to 'include/linux')

diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 67bce357a7a1..90446b0d75e5 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -124,14 +124,6 @@ enum
 	TASKLET_STATE_RUN	/* Tasklet is running (SMP only) */
 };
 
-struct tasklet_head
-{
-	struct tasklet_struct *list;
-} __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
-
-extern struct tasklet_head tasklet_vec[NR_CPUS];
-extern struct tasklet_head tasklet_hi_vec[NR_CPUS];
-
 #ifdef CONFIG_SMP
 static inline int tasklet_trylock(struct tasklet_struct *t)
 {
diff --git a/kernel/ksyms.c b/kernel/ksyms.c
index add2ac9dd8f3..cc335bff25a1 100644
--- a/kernel/ksyms.c
+++ b/kernel/ksyms.c
@@ -568,8 +568,6 @@ EXPORT_SYMBOL(strspn);
 EXPORT_SYMBOL(strsep);
 
 /* software interrupts */
-EXPORT_SYMBOL(tasklet_hi_vec);
-EXPORT_SYMBOL(tasklet_vec);
 EXPORT_SYMBOL(bh_task_vec);
 EXPORT_SYMBOL(init_bh);
 EXPORT_SYMBOL(remove_bh);
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 5b665bd72a11..c290a1d81e12 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -16,6 +16,7 @@
 #include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/tqueue.h>
+#include <linux/percpu.h>
 
 /*
    - No shared variables, all the data are CPU local.
@@ -145,42 +146,43 @@ void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
 
 
 /* Tasklets */
+struct tasklet_head
+{
+	struct tasklet_struct *list;
+};
 
-struct tasklet_head tasklet_vec[NR_CPUS] __cacheline_aligned_in_smp;
-struct tasklet_head tasklet_hi_vec[NR_CPUS] __cacheline_aligned_in_smp;
+static struct tasklet_head tasklet_vec __per_cpu_data;
+static struct tasklet_head tasklet_hi_vec __per_cpu_data;
 
 void __tasklet_schedule(struct tasklet_struct *t)
 {
-	int cpu = smp_processor_id();
 	unsigned long flags;
 
 	local_irq_save(flags);
-	t->next = tasklet_vec[cpu].list;
-	tasklet_vec[cpu].list = t;
-	cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);
+	t->next = this_cpu(tasklet_vec).list;
+	this_cpu(tasklet_vec).list = t;
+	cpu_raise_softirq(smp_processor_id(), TASKLET_SOFTIRQ);
 	local_irq_restore(flags);
 }
 
 void __tasklet_hi_schedule(struct tasklet_struct *t)
 {
-	int cpu = smp_processor_id();
 	unsigned long flags;
 
 	local_irq_save(flags);
-	t->next = tasklet_hi_vec[cpu].list;
-	tasklet_hi_vec[cpu].list = t;
-	cpu_raise_softirq(cpu, HI_SOFTIRQ);
+	t->next = this_cpu(tasklet_hi_vec).list;
+	this_cpu(tasklet_hi_vec).list = t;
+	cpu_raise_softirq(smp_processor_id(), HI_SOFTIRQ);
 	local_irq_restore(flags);
 }
 
 static void tasklet_action(struct softirq_action *a)
 {
-	int cpu = smp_processor_id();
 	struct tasklet_struct *list;
 
 	local_irq_disable();
-	list = tasklet_vec[cpu].list;
-	tasklet_vec[cpu].list = NULL;
+	list = this_cpu(tasklet_vec).list;
+	this_cpu(tasklet_vec).list = NULL;
 	local_irq_enable();
 
 	while (list) {
@@ -200,21 +202,20 @@ static void tasklet_action(struct softirq_action *a)
 		}
 
 		local_irq_disable();
-		t->next = tasklet_vec[cpu].list;
-		tasklet_vec[cpu].list = t;
-		__cpu_raise_softirq(cpu, TASKLET_SOFTIRQ);
+		t->next = this_cpu(tasklet_vec).list;
+		this_cpu(tasklet_vec).list = t;
+		__cpu_raise_softirq(smp_processor_id(), TASKLET_SOFTIRQ);
 		local_irq_enable();
 	}
 }
 
 static void tasklet_hi_action(struct softirq_action *a)
 {
-	int cpu = smp_processor_id();
 	struct tasklet_struct *list;
 
 	local_irq_disable();
-	list = tasklet_hi_vec[cpu].list;
-	tasklet_hi_vec[cpu].list = NULL;
+	list = this_cpu(tasklet_hi_vec).list;
+	this_cpu(tasklet_hi_vec).list = NULL;
 	local_irq_enable();
 
 	while (list) {
@@ -234,9 +235,9 @@ static void tasklet_hi_action(struct softirq_action *a)
 		}
 
 		local_irq_disable();
-		t->next = tasklet_hi_vec[cpu].list;
-		tasklet_hi_vec[cpu].list = t;
-		__cpu_raise_softirq(cpu, HI_SOFTIRQ);
+		t->next = this_cpu(tasklet_hi_vec).list;
+		this_cpu(tasklet_hi_vec).list = t;
+		__cpu_raise_softirq(smp_processor_id(), HI_SOFTIRQ);
 		local_irq_enable();
 	}
 }
-- 
cgit v1.2.3


From 70e08a38b2ded7518678bb1f2a89862b0fa5cc1f Mon Sep 17 00:00:00 2001
From: Christoph Hellwig <hch@infradead.org>
Date: Mon, 20 May 2002 21:39:34 -0700
Subject: [PATCH] bfs header move around + warning fix

(Patch has been ACKed by the bfs maintainer)

Now that bfs no more is included in the big unions in fs.h it makes
sense to move the contents of bfs_fs_i.h and bfs_fs_sb.h to a bfs-private
location.  I've created fs/bfs/bfs.h for that, also merging in bfs_defs.h.

In addition I've changed si_imap to an unsigned long pointer as the bitops
now use that type explicitly.
---
 fs/bfs/bfs.h              | 60 +++++++++++++++++++++++++++++++++++++++++++++++
 fs/bfs/bfs_defs.h         |  3 ---
 fs/bfs/dir.c              |  5 ++--
 fs/bfs/file.c             |  4 ++--
 fs/bfs/inode.c            |  6 ++---
 include/linux/bfs_fs.h    | 25 --------------------
 include/linux/bfs_fs_i.h  | 21 -----------------
 include/linux/bfs_fs_sb.h | 25 --------------------
 8 files changed, 66 insertions(+), 83 deletions(-)
 create mode 100644 fs/bfs/bfs.h
 delete mode 100644 fs/bfs/bfs_defs.h
 delete mode 100644 include/linux/bfs_fs_i.h
 delete mode 100644 include/linux/bfs_fs_sb.h

(limited to 'include/linux')

diff --git a/fs/bfs/bfs.h b/fs/bfs/bfs.h
new file mode 100644
index 000000000000..48da64e58fa4
--- /dev/null
+++ b/fs/bfs/bfs.h
@@ -0,0 +1,60 @@
+/*
+ *	fs/bfs/bfs.h
+ *	Copyright (C) 1999 Tigran Aivazian <tigran@veritas.com>
+ */
+#ifndef _FS_BFS_BFS_H
+#define _FS_BFS_BFS_H
+
+#include <linux/bfs_fs.h>
+
+/*
+ * BFS file system in-core superblock info
+ */
+struct bfs_sb_info {
+	unsigned long si_blocks;
+	unsigned long si_freeb;
+	unsigned long si_freei;
+	unsigned long si_lf_ioff;
+	unsigned long si_lf_sblk;
+	unsigned long si_lf_eblk;
+	unsigned long si_lasti;
+	unsigned long * si_imap;
+	struct buffer_head * si_sbh;		/* buffer header w/superblock */
+	struct bfs_super_block * si_bfs_sb;	/* superblock in si_sbh->b_data */
+};
+
+/*
+ * BFS file system in-core inode info
+ */
+struct bfs_inode_info {
+	unsigned long i_dsk_ino; /* inode number from the disk, can be 0 */
+	unsigned long i_sblock;
+	unsigned long i_eblock;
+	struct inode vfs_inode;
+};
+
+static inline struct bfs_sb_info *BFS_SB(struct super_block *sb)
+{
+	return sb->u.generic_sbp;
+}
+
+static inline struct bfs_inode_info *BFS_I(struct inode *inode)
+{
+	return list_entry(inode, struct bfs_inode_info, vfs_inode);
+}
+
+
+#define printf(format, args...) \
+	printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args)
+
+
+/* file.c */
+extern struct inode_operations bfs_file_inops;
+extern struct file_operations bfs_file_operations;
+extern struct address_space_operations bfs_aops;
+
+/* dir.c */
+extern struct inode_operations bfs_dir_inops;
+extern struct file_operations bfs_dir_operations;
+
+#endif /* _FS_BFS_BFS_H */
diff --git a/fs/bfs/bfs_defs.h b/fs/bfs/bfs_defs.h
deleted file mode 100644
index 207c95bdb594..000000000000
--- a/fs/bfs/bfs_defs.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#define printf(format, args...) \
-	printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args)
-
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 5913276d8d07..0fd7d362be4d 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -6,10 +6,9 @@
 
 #include <linux/time.h>
 #include <linux/string.h>
-#include <linux/bfs_fs.h>
+#include <linux/fs.h>
 #include <linux/smp_lock.h>
-
-#include "bfs_defs.h"
+#include "bfs.h"
 
 #undef DEBUG
 
diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index 313e5e4009ab..f0d01864f2f2 100644
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -5,9 +5,9 @@
  */
 
 #include <linux/fs.h>
-#include <linux/bfs_fs.h>
+#include <linux/fs.h>
 #include <linux/smp_lock.h>
-#include "bfs_defs.h"
+#include "bfs.h"
 
 #undef DEBUG
 
diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index df4cf556785a..1fd0fe66134e 100644
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -9,12 +9,10 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/init.h>
-#include <linux/bfs_fs.h>
+#include <linux/fs.h>
 #include <linux/smp_lock.h>
-
 #include <asm/uaccess.h>
-
-#include "bfs_defs.h"
+#include "bfs.h"
 
 MODULE_AUTHOR("Tigran A. Aivazian <tigran@veritas.com>");
 MODULE_DESCRIPTION("SCO UnixWare BFS filesystem for Linux");
diff --git a/include/linux/bfs_fs.h b/include/linux/bfs_fs.h
index 0c6349eec459..f7f0913cd110 100644
--- a/include/linux/bfs_fs.h
+++ b/include/linux/bfs_fs.h
@@ -6,9 +6,6 @@
 #ifndef _LINUX_BFS_FS_H
 #define _LINUX_BFS_FS_H
 
-#include <linux/bfs_fs_i.h>
-#include <linux/bfs_fs_sb.h>
-
 #define BFS_BSIZE_BITS		9
 #define BFS_BSIZE		(1<<BFS_BSIZE_BITS)
 
@@ -79,26 +76,4 @@ struct bfs_super_block {
 #define BFS_UNCLEAN(bfs_sb, sb)	\
 	((bfs_sb->s_from != -1) && (bfs_sb->s_to != -1) && !(sb->s_flags & MS_RDONLY))
 
-#ifdef __KERNEL__
-
-/* file.c */
-extern struct inode_operations bfs_file_inops;
-extern struct file_operations bfs_file_operations;
-extern struct address_space_operations bfs_aops;
-
-/* dir.c */
-extern struct inode_operations bfs_dir_inops;
-extern struct file_operations bfs_dir_operations;
-
-static inline struct bfs_sb_info *BFS_SB(struct super_block *sb)
-{
-	return sb->u.generic_sbp;
-}
-
-static inline struct bfs_inode_info *BFS_I(struct inode *inode)
-{
-	return list_entry(inode, struct bfs_inode_info, vfs_inode);
-}
-
-#endif /* __KERNEL__ */
 #endif	/* _LINUX_BFS_FS_H */
diff --git a/include/linux/bfs_fs_i.h b/include/linux/bfs_fs_i.h
deleted file mode 100644
index 5a85f1dc143f..000000000000
--- a/include/linux/bfs_fs_i.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- *	include/linux/bfs_fs_i.h
- *	Copyright (C) 1999 Tigran Aivazian <tigran@veritas.com>
- */
-
-#ifndef _LINUX_BFS_FS_I
-#define _LINUX_BFS_FS_I
-
-#include <linux/fs.h>
-
-/*
- * BFS file system in-core inode info
- */
-struct bfs_inode_info {
-	unsigned long i_dsk_ino; /* inode number from the disk, can be 0 */
-	unsigned long i_sblock;
-	unsigned long i_eblock;
-	struct inode vfs_inode;
-};
-
-#endif	/* _LINUX_BFS_FS_I */
diff --git a/include/linux/bfs_fs_sb.h b/include/linux/bfs_fs_sb.h
deleted file mode 100644
index efdc30ec7241..000000000000
--- a/include/linux/bfs_fs_sb.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- *	include/linux/bfs_fs_sb.h
- *	Copyright (C) 1999 Tigran Aivazian <tigran@veritas.com>
- */
-
-#ifndef _LINUX_BFS_FS_SB
-#define _LINUX_BFS_FS_SB
-
-/*
- * BFS file system in-core superblock info
- */
-struct bfs_sb_info {
-	unsigned long si_blocks;
-	unsigned long si_freeb;
-	unsigned long si_freei;
-	unsigned long si_lf_ioff;
-	unsigned long si_lf_sblk;
-	unsigned long si_lf_eblk;
-	unsigned long si_lasti;
-	char * si_imap;
-	struct buffer_head * si_sbh;		/* buffer header w/superblock */
-	struct bfs_super_block * si_bfs_sb;	/* superblock in si_sbh->b_data */
-};
-
-#endif	/* _LINUX_BFS_FS_SB */
-- 
cgit v1.2.3


From ea882f08613a6efa9929b3d6a7e7bfcbec22cf92 Mon Sep 17 00:00:00 2001
From: Chris Mason <mason@suse.com>
Date: Mon, 20 May 2002 21:43:46 -0700
Subject: [PATCH] reiserfs 64 bit bug in get_virtual_node_size

This patch fixes a problem with reiserfs on 64 bit machines.  Our
struct virtual_item is a different size there, and some calculations
that assume otherwise lead to this panic create_virtual_node:

vs-8030: create_virtual_node: virtual node space consumed
---
 fs/reiserfs/fix_node.c      | 20 ++++++++++++--------
 fs/reiserfs/item_ops.c      |  7 -------
 include/linux/reiserfs_fs.h |  7 +++++++
 3 files changed, 19 insertions(+), 15 deletions(-)

(limited to 'include/linux')

diff --git a/fs/reiserfs/fix_node.c b/fs/reiserfs/fix_node.c
index 802eefb3825d..86ac5cb83dd1 100644
--- a/fs/reiserfs/fix_node.c
+++ b/fs/reiserfs/fix_node.c
@@ -2011,16 +2011,20 @@ void reiserfs_kfree (const void * vp, size_t size, struct super_block * s)
 
 static int get_virtual_node_size (struct super_block * sb, struct buffer_head * bh)
 {
-  //  int size = sizeof (struct virtual_item); /* for new item in case of insert */
-  //  int i, nr_items;
-  //  struct item_head * ih;
+    int max_num_of_items;
+    int max_num_of_entries;
+    unsigned long blocksize = sb->s_blocksize;
 
-  // this is enough for _ALL_ currently possible cases. In 4 k block
-  // one may put < 170 empty items. Each virtual item eats 12
-  // byte. The biggest direntry item may have < 256 entries. Each
-  // entry would eat 2 byte of virtual node space
-  return sb->s_blocksize;
+#define MIN_NAME_LEN 1
 
+    max_num_of_items = (blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN);
+    max_num_of_entries = (blocksize - BLKH_SIZE - IH_SIZE) / 
+                         (DEH_SIZE + MIN_NAME_LEN);
+
+    return sizeof(struct virtual_node) + 
+           max(max_num_of_items * sizeof (struct virtual_item),
+	       sizeof (struct virtual_item) + sizeof(struct direntry_uarea) + 
+               (max_num_of_entries - 1) * sizeof (__u16));
 }
 
 
diff --git a/fs/reiserfs/item_ops.c b/fs/reiserfs/item_ops.c
index 7cf647e6f9b1..ac5c94b1500e 100644
--- a/fs/reiserfs/item_ops.c
+++ b/fs/reiserfs/item_ops.c
@@ -466,13 +466,6 @@ static void direntry_check_item (struct item_head * ih, char * item)
 
 #define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
 
-struct direntry_uarea {
-    int flags;
-    __u16 entry_count;
-    __u16 entry_sizes[1];
-} __attribute__ ((__packed__)) ;
-
-
 /*
  * function returns old entry number in directory item in real node
  * using new entry number in virtual item in virtual node */
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 173279f6ff0a..abe55b91a328 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -1342,6 +1342,13 @@ struct virtual_node
   struct virtual_item * vn_vi;	/* array of items (including a new one, excluding item to be deleted) */
 };
 
+/* used by directory items when creating virtual nodes */
+struct direntry_uarea {
+    int flags;
+    __u16 entry_count;
+    __u16 entry_sizes[1];
+} __attribute__ ((__packed__)) ;
+
 
 /***************************************************************************/
 /*                  TREE BALANCE                                           */
-- 
cgit v1.2.3


From 542f96a52f55f50dae8b82e11dac096b094202f0 Mon Sep 17 00:00:00 2001
From: Pavel Machek <pavel@ucw.cz>
Date: Tue, 21 May 2002 01:57:49 -0700
Subject: [PATCH] suspend-to-{RAM,disk}

Here's suspend-to-{RAM,disk} combined patch for
2.5.17. Suspend-to-disk is pretty stable and was tested in
2.4-ac. Suspend-to-RAM is little more experimental, but works for me,
and is certainly better than disk-eating version currently in kernel.

Major parts are: process stopper, S3 specific code, S4 specific
code.
---
 Documentation/driver-model.txt |   53 +-
 Documentation/swsusp.txt       |  159 +++++
 MAINTAINERS                    |    8 +
 arch/i386/Config.help          |   25 +
 arch/i386/boot/video.S         |    1 +
 arch/i386/config.in            |    3 +
 arch/i386/defconfig            |    1 +
 arch/i386/kernel/acpi.c        |   30 +
 arch/i386/kernel/acpi_wakeup.S |  178 +++++-
 arch/i386/kernel/apm.c         |    1 +
 arch/i386/kernel/i8259.c       |   15 +-
 arch/i386/kernel/setup.c       |    5 +
 arch/i386/kernel/signal.c      |    7 +
 arch/i386/kernel/time.c        |   12 +
 arch/i386/vmlinux.lds          |    6 +
 drivers/acpi/acpi_system.c     |   38 +-
 drivers/block/floppy.c         |    5 +
 drivers/block/ll_rw_blk.c      |    4 +-
 drivers/block/loop.c           |    5 +-
 drivers/char/sysrq.c           |   21 +
 drivers/ide/ide-disk.c         |    3 +
 drivers/pci/power.c            |    4 +-
 drivers/usb/storage/usb.c      |    1 +
 fs/buffer.c                    |    3 +
 fs/jbd/journal.c               |   12 +-
 fs/reiserfs/journal.c          |    9 +-
 include/asm-generic/bitops.h   |    6 +
 include/asm-i386/bitops.h      |    6 +
 include/asm-i386/suspend.h     |  304 +++++++++
 include/linux/bitops.h         |   43 +-
 include/linux/init.h           |    3 +
 include/linux/page-flags.h     |    7 +
 include/linux/reboot.h         |    9 +
 include/linux/sched.h          |    5 +
 include/linux/suspend.h        |   65 ++
 include/linux/tqueue.h         |    2 +-
 init/do_mounts.c               |    6 +
 kernel/Makefile                |    3 +-
 kernel/context.c               |    1 +
 kernel/signal.c                |    2 +-
 kernel/softirq.c               |    1 +
 kernel/suspend.c               | 1327 ++++++++++++++++++++++++++++++++++++++++
 kernel/sys.c                   |   11 +
 mm/page_alloc.c                |   41 ++
 mm/page_io.c                   |    4 +
 mm/pdflush.c                   |   12 +-
 mm/vmscan.c                    |    9 +-
 47 files changed, 2414 insertions(+), 62 deletions(-)
 create mode 100644 Documentation/swsusp.txt
 create mode 100644 include/asm-i386/suspend.h
 create mode 100644 include/linux/suspend.h
 create mode 100644 kernel/suspend.c

(limited to 'include/linux')

diff --git a/Documentation/driver-model.txt b/Documentation/driver-model.txt
index d2740203568f..69f20d2d9b70 100644
--- a/Documentation/driver-model.txt
+++ b/Documentation/driver-model.txt
@@ -52,7 +52,8 @@ appropriate callbacks that each device (or bridge) of that type share.
 Each bus layer should implement the callbacks for these drivers. It then
 forwards the calls on to the device-specific callbacks. This means that
 device-specific drivers must still implement callbacks for each operation.
-But, they are not called from the top level driver layer.
+But, they are not called from the top level driver layer. [So for example
+PCI devices will not call device_register but pci_device_register.]
 
 This does add another layer of indirection for calling one of these functions,
 but there are benefits that are believed to outweigh this slowdown.
@@ -60,7 +61,7 @@ but there are benefits that are believed to outweigh this slowdown.
 First, it prevents device-specific drivers from having to know about the
 global device layer. This speeds up integration time incredibly. It also
 allows drivers to be more portable across kernel versions. Note that the
-former was intentional, the latter is an added bonus.
+former was intentional, the latter is an added bonus. 
 
 Second, this added indirection allows the bus to perform any additional logic
 necessary for its child devices. A bus layer may add additional information to
@@ -225,7 +226,6 @@ platform_data:
 	It also allows the platform driver (e.g. ACPI) to a driver without the driver
 	having to have explicit knowledge of (atrocities like) ACPI.
 
-
 current_state:
 	Current power state of the device. For PCI and other modern devices, this is
 	0-3, though it's not necessarily limited to those values.
@@ -251,18 +251,24 @@ struct device_driver {
 }
 
 probe:
-	Check for device existence and associate driver with it.
+	Check for device existence and associate driver with it. In case of device 
+	insertion, *all* drivers are called. Struct device has parent and bus_id 
+	valid at this point. probe() may only be called from process context. Returns
+	0 if it handles that device, -ESRCH if this driver does not know how to handle
+	this device, valid error otherwise.
 
 remove:
 	Dissociate driver with device. Releases device so that it could be used by
 	another driver. Also, if it is a hotplug device (hotplug PCI, Cardbus), an
-	ejection event could take place here.
+	ejection event could take place here. remove() can be called from interrupt 
+	context. [Fixme: Is that good?] Returns 0 on success. [Can we recover from
+	failed remove or should I define that remove() never fails?]
 
 suspend:
-	Perform one step of the device suspend process.
+	Perform one step of the device suspend process. Returns 0 on success.
 
 resume:
-	Perform one step of the device resume process.
+	Perform one step of the device resume process. Returns 0 on success.
 
 The probe() and remove() callbacks are intended to be much simpler than the
 current PCI correspondents.
@@ -275,7 +281,7 @@ probe() should do the following only:
 
 Some device initialisation was done in probe(). This should not be the case
 anymore. All initialisation should take place in the open() call for the
-device.
+device. [FIXME: How do you "open" uhci?]
 
 Breaking initialisation code out must also be done for the resume() callback,
 as most devices will have to be completely reinitialised when coming back from
@@ -324,6 +330,7 @@ the stage:
 
 enum{
 	SUSPEND_NOTIFY,
+	SUSPEND_DISABLE,
 	SUSPEND_SAVE_STATE,
 	SUSPEND_POWER_DOWN,
 };
@@ -331,6 +338,7 @@ enum{
 enum {
 	RESUME_POWER_ON,
 	RESUME_RESTORE_STATE,
+	RESUME_ENABLE,
 };
 
 
@@ -352,9 +360,9 @@ shutting down the device(s) you want to save state to.
 Instead, the walking of the device tree has been moved to userspace. When a
 user requests the system to suspend, it will walk the device tree, as exported
 via driverfs, and tell each device to go to sleep. It will do this multiple
-times based on what the system policy is.
-
-[ FIXME: URL pointer to the corresponding utility is missing here! ]
+times based on what the system policy is. [Not possible. Take ACPI enabled 
+system, with battery critically low. In such state, you want to suspend-to-disk,
+*fast*. User maybe is not even running powerd (think system startup)!]
 
 Device resume should happen in the same manner when the system awakens.
 
@@ -366,22 +374,25 @@ This level to notify the driver that it is going to sleep. If it knows that it
 cannot resume the hardware from the requested level, or it feels that it is
 too important to be put to sleep, it should return an error from this function.
 
-It does not have to stop I/O requests or actually save state at this point.
+It does not have to stop I/O requests or actually save state at this point. Called
+from process context.
 
 SUSPEND_DISABLE:
 
 The driver should stop taking I/O requests at this stage. Because the save
 state stage happens afterwards, the driver may not want to physically disable
-the device; only mark itself unavailable if possible.
+the device; only mark itself unavailable if possible. Called from process 
+context.
 
 SUSPEND_SAVE_STATE:
 
 The driver should allocate memory and save any device state that is relevant
-for the state it is going to enter.
+for the state it is going to enter. Called from process context.
 
 SUSPEND_POWER_DOWN:
 
-The driver should place the device in the power state requested.
+The driver should place the device in the power state requested. May be called
+from interrupt context.
 
 
 For resume, the stages are defined as follows:
@@ -389,25 +400,27 @@ For resume, the stages are defined as follows:
 RESUME_POWER_ON:
 
 Devices should be powered on and reinitialised to some known working state.
+Called from process context.
 
 RESUME_RESTORE_STATE:
 
 The driver should restore device state to its pre-suspend state and free any
-memory allocated for its saved state.
+memory allocated for its saved state. Called from process context.
 
 RESUME_ENABLE:
 
-The device should start taking I/O requests again.
+The device should start taking I/O requests again. Called from process context.
 
 
 Each driver does not have to implement each stage. But, it if it does
-implemente a stage, it should do what is described above. It should not assume
+implement a stage, it should do what is described above. It should not assume
 that it performed any stage previously, or that it will perform any stage
-later.
+later. [Really? It makes sense to support SAVE_STATE only after DISABLE].
 
 It is quite possible that a driver can fail during the suspend process, for
 whatever reason. In this event, the calling process must gracefully recover
-and restore everything to their states before the suspend transition began.
+and restore everything to their states before the suspend transition began. 
+[Suspend may not fail, think battery low.]
 
 If a driver knows that it cannot suspend or resume properly, it should fail
 during the notify stage. Properly implemented power management schemes should
diff --git a/Documentation/swsusp.txt b/Documentation/swsusp.txt
new file mode 100644
index 000000000000..8412e524a18f
--- /dev/null
+++ b/Documentation/swsusp.txt
@@ -0,0 +1,159 @@
+From kernel/suspend.c:
+
+ * BIG FAT WARNING *********************************************************
+ *
+ * If you have unsupported (*) devices using DMA...
+ *				...say goodbye to your data.
+ *
+ * If you touch anything on disk between suspend and resume...
+ *				...kiss your data goodbye.
+ *
+ * If your disk driver does not support suspend... (IDE does)
+ *				...you'd better find out how to get along
+ *				   without your data.
+ *
+ * (*) pm interface support is needed to make it safe.
+
+You need to append resume=/dev/your_swap_partition to kernel command
+line. Then you suspend by echo 4 > /proc/acpi/sleep.
+
+[Notice. Rest docs is pretty outdated (see date!) It should be safe to
+use swsusp on ext3/reiserfs these days.]
+
+
+Article about goals and implementation of Software Suspend for Linux
+Author: G‚ábor Kuti
+Last revised: 2002-04-08
+
+Idea and goals to achieve
+
+Nowadays it is common in several laptops that they have a suspend button. It
+saves the state of the machine to a filesystem or to a partition and switches
+to standby mode. Later resuming the machine the saved state is loaded back to
+ram and the machine can continue its work. It has two real benefits. First we
+save ourselves the time machine goes down and later boots up, energy costs
+real high when running from batteries. The other gain is that we don't have to
+interrupt our programs so processes that are calculating something for a long
+time shouldn't need to be written interruptible.
+
+On desk machines the power saving function isn't as important as it is in
+laptops but we really may benefit from the second one. Nowadays the number of
+desk machines supporting suspend function in their APM is going up but there
+are (and there will still be for a long time) machines that don't even support
+APM of any kind. On the other hand it is reported that using APM's suspend
+some irqs (e.g. ATA disk irq) is lost and it is annoying for the user until
+the Linux kernel resets the device.
+
+So I started thinking about implementing Software Suspend which doesn't need
+any APM support and - since it uses pretty near only high-level routines - is
+supposed to be architecture independent code.
+
+Using the code
+
+The code is experimental right now - testers, extra eyes are welcome. To
+compile this support into the kernel, you need CONFIG_EXPERIMENTAL, 
+and then CONFIG_SOFTWARE_SUSPEND in menu General Setup to be  enabled. It
+cannot be used as a module and I don't think it will ever be needed.
+
+You have two ways to use this code. The first one is if you've compiled in
+sysrq support then you may press Sysrq-D to request suspend. The other way
+is with a patched SysVinit (my patch is against 2.76 and available at my
+home page). You might call 'swsusp' or 'shutdown -z <time>'. Next way is to
+echo 4 > /proc/acpi/sleep.
+
+Either way it saves the state of the machine into active swaps and then
+reboots. You must explicitly specify the swap partition to resume from with ``resume=''
+kernel option. If signature is found it loads and restores saved state. If the
+option ``noresume'' is specified as a boot parameter, it skips the resuming.
+Warning! Look at section ``Things to implement'' to see what isn't yet
+implemented.  Also I strongly suggest you to list all active swaps in
+/etc/fstab. Firstly because you don't have to specify anything to resume and
+secondly if you have more than one swap area you can't decide which one has the
+'root' signature. 
+
+In the meantime while the system is suspended you should not touch any of the
+hardware!
+
+About the code
+Goals reached
+
+The code can be downloaded from
+http://falcon.sch.bme.hu/~seasons/linux/. It mainly works but there are still
+some of XXXs, TODOs, FIXMEs in the code which seem not to be too important. It
+should work all right except for the problems listed in ``Things to
+implement''. Notes about the code are really welcome.
+
+How the code works
+
+When suspending is triggered it immediately wakes up process bdflush. Bdflush
+checks whether we have anything in our run queue tq_bdflush. Since we queued up
+function do_software_suspend, it is called. Here we shrink everything including
+dcache, inodes, buffers and memory (here mainly processes are swapped out). We
+count how many pages we need to duplicate (we have to be atomical!) then we
+create an appropiate sized page directory. It will point to the original and
+the new (copied) address of the page. We get the free pages by
+__get_free_pages() but since it changes state we have to be able to track it
+later so it also flips in a bit in page's flags (a new Nosave flag). We
+duplicate pages and then mark them as used (so atomicity is ensured). After
+this we write out the image to swaps, do another sync and the machine may
+reboot. We also save registers to stack.
+
+By resuming an ``inverse'' method is executed. The image if exists is loaded,
+loadling is either triggered by ``resume='' kernel option.  We
+change our task to bdflush (it is needed because if we don't do this init does
+an oops when it is waken up later) and then pages are copied back to their
+original location. We restore registers, free previously allocated memory,
+activate memory context and task information. Here we should restore hardware
+state but even without this the machine is restored and processes are continued
+to work. I think hardware state should be restored by some list (using
+notify_chain) and probably by some userland program (run-parts?) for users'
+pleasure. Check out my patch at the same location for the sysvinit patch.
+
+WARNINGS!
+- It does not like pcmcia cards. And this is logical: pcmcia cards need cardmgr to be
+  initialized. they are not initialized during singleuser boot, but "resumed" kernel does
+  expect them to be initialized. That leads to armagedon. You should eject any pcmcia cards
+  before suspending.
+
+Things to implement
+- SMP support. I've done an SMP support but since I don't have access to a kind
+  of this one I cannot test it. Please SMP people test it.  .. Tested it,
+  doesn't work. Had no time to figure out why. There is some mess with
+  interrupts AFAIK..
+- We should only make a copy of data related to kernel segment, since any
+  process data won't be changed.
+- By copying pages back to their original position, copy_page caused General
+  Protection Fault. Why?
+- Hardware state restoring.  Now there's support for notifying via the notify
+  chain, event handlers are welcome. Some devices may have microcodes loaded
+  into them. We should have event handlers for them aswell.
+- We should support other architectures (There are really only some arch
+  related functions..)
+- We should also restore original state of swaps if the ``noresume'' kernel
+  option is specified.. Or do we need such a feature to save state for some
+  other time? Do we need some kind of ``several saved states''?  (Linux-HA
+  people?). There's been some discussion about checkpointing on linux-future.
+- Should make more sanity checks. Or are these enough?
+
+Not so important ideas for implementing
+
+- If a real time process is running then don't suspend the machine.
+- Is there any sense in compressing the outwritten pages?
+- Support for power.conf file as in Solaris, autoshutdown, special
+  devicetypes support, maybe in sysctl.
+- Introduce timeout for SMP locking. But first locking ought to work :O
+- Pre-detect if we don't have enough swap space or free it instead of
+  calling panic.
+- Support for adding/removing hardware while suspended?
+- We should not free pages at the beginning so aggressively, most of them
+  go there anyway..
+- If X is active while suspending then by resuming calling svgatextmode
+  corrupts the virtual console of X.. (Maybe this has been fixed AFAIK).
+
+Any other idea you might have tell me!
+
+Contacting the author
+If you have any question or any patch that solves the above or detected
+problems please contact me at seasons@falcon.sch.bme.hu. I might delay
+answering, sorry about that.
+
diff --git a/MAINTAINERS b/MAINTAINERS
index 3729a6c838e7..e86bd6b4087e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1446,6 +1446,14 @@ M:	neilb@cse.unsw.edu.au
 L:	linux-raid@vger.kernel.org
 S:	Maintained
 
+SOFTWARE SUSPEND:
+P:	Gabor Kuti
+M:	seasons@falcon.sch.bme.hu
+M:	seasons@makosteszta.sote.hu
+L:	http://lister.fornax.hu/mailman/listinfo/swsusp
+W:	http://falcon.sch.bme.hu/~seasons/linux
+S:	Maintained
+
 SONIC NETWORK DRIVER
 P:	Thomas Bogendoerfer
 M:	tsbogend@alpha.franken.de
diff --git a/arch/i386/Config.help b/arch/i386/Config.help
index 3f6590c936dd..93ea2e0e5b94 100644
--- a/arch/i386/Config.help
+++ b/arch/i386/Config.help
@@ -940,3 +940,28 @@ CONFIG_DEBUG_BUGVERBOSE
 CONFIG_DEBUG_OBSOLETE
   Say Y here if you want to reduce the chances of the tree compiling,
   and are prepared to dig into driver internals to fix compile errors.
+
+Software Suspend
+CONFIG_SOFTWARE_SUSPEND
+  Enable the possibilty of suspendig machine. It doesn't need APM.
+  You may suspend your machine by either pressing Sysrq-d or with
+  'swsusp' or 'shutdown -z <time>' (patch for sysvinit needed). It
+  creates an image which is saved in your active swaps. By the next
+  booting the kernel detects the saved image, restores the memory from
+  it and then it continues to run as before you've suspended.
+  If you don't want the previous state to continue use the 'noresume'
+  kernel option. However note that your partitions will be fsck'd and
+  you must re-mkswap your swap partitions/files.
+
+  Right now you may boot without resuming and then later resume but
+  in meantime you cannot use those swap partitions/files which were
+  involved in suspending. Also in this case there is a risk that buffers
+  on disk won't match with saved ones.
+
+  SMP is supported ``as-is''. There's a code for it but doesn't work.
+  There have been problems reported relating SCSI.
+  
+  This option is about getting stable. However there is still some
+  absence of features.
+
+  For more information take a look at Documentation/swsusp.txt.
diff --git a/arch/i386/boot/video.S b/arch/i386/boot/video.S
index 1a49d97c9110..4a6d8e4b4fd0 100644
--- a/arch/i386/boot/video.S
+++ b/arch/i386/boot/video.S
@@ -438,6 +438,7 @@ setalias:
 
 # Setting of user mode (AX=mode ID) => CF=success
 mode_set:
+	movw	%ax, %fs:(0x01fa)		# Store mode for use in acpi_wakeup.S
 	movw	%ax, %bx
 	cmpb	$0xff, %ah
 	jz	setalias
diff --git a/arch/i386/config.in b/arch/i386/config.in
index 443141bee55a..1097c6a5e46c 100644
--- a/arch/i386/config.in
+++ b/arch/i386/config.in
@@ -396,6 +396,9 @@ source net/bluetooth/Config.in
 
 mainmenu_option next_comment
 comment 'Kernel hacking'
+if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+   dep_bool 'Software Suspend' CONFIG_SOFTWARE_SUSPEND $CONFIG_PM
+fi
 
 bool 'Kernel debugging' CONFIG_DEBUG_KERNEL
 if [ "$CONFIG_DEBUG_KERNEL" != "n" ]; then
diff --git a/arch/i386/defconfig b/arch/i386/defconfig
index 6ef1ec9b3d21..6d2703fac6d5 100644
--- a/arch/i386/defconfig
+++ b/arch/i386/defconfig
@@ -119,6 +119,7 @@ CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=y
 CONFIG_PM=y
 # CONFIG_APM is not set
+# CONFIG_SOFTWARE_SUSPEND is not set
 
 #
 # Memory Technology Devices (MTD)
diff --git a/arch/i386/kernel/acpi.c b/arch/i386/kernel/acpi.c
index 9bd888ac3501..aec2df596b20 100644
--- a/arch/i386/kernel/acpi.c
+++ b/arch/i386/kernel/acpi.c
@@ -44,6 +44,8 @@
 #include <asm/pgalloc.h>
 #include <asm/io_apic.h>
 #include <asm/tlbflush.h>
+#define ACPI_C
+#include <asm/suspend.h>
 
 
 #define PREFIX			"ACPI: "
@@ -623,5 +625,33 @@ void __init acpi_reserve_bootmem(void)
 	printk(KERN_DEBUG "ACPI: have wakeup address 0x%8.8lx\n", acpi_wakeup_address);
 }
 
+/*
+ * (KG): Since we affect stack here, we make this function as flat and easy
+ * as possible in order to not provoke gcc to use local variables on the stack.
+ * Note that on resume, all (expect nosave) variables will have the state from
+ * the time of writing (suspend_save_image) and the registers (including the
+ * stack pointer, but excluding the instruction pointer) will be loaded with 
+ * the values saved at save_processor_context() time.
+ */
+void do_suspend_magic(int resume)
+{
+	/* DANGER WILL ROBINSON!
+	 *
+	 * If this function is too difficult for gcc to optimize, it will crash and burn!
+	 * see above.
+	 *
+	 * DO NOT TOUCH.
+	 */
+	if (!resume) {
+		save_processor_context();
+		acpi_save_register_state((unsigned long)&&acpi_sleep_done);
+		acpi_enter_sleep_state(3);
+		return;
+	}
+acpi_sleep_done:
+	restore_processor_context();
+	printk("CPU context restored...\n");
+}
+
 #endif /*CONFIG_ACPI_SLEEP*/
 
diff --git a/arch/i386/kernel/acpi_wakeup.S b/arch/i386/kernel/acpi_wakeup.S
index 98ec946e2e83..80760b240294 100644
--- a/arch/i386/kernel/acpi_wakeup.S
+++ b/arch/i386/kernel/acpi_wakeup.S
@@ -3,6 +3,7 @@
 #include <linux/linkage.h>
 #include <asm/segment.h>
 
+# Do we need to deal with A20?
 
 ALIGN
 wakeup_start:
@@ -10,8 +11,16 @@ wakeup_code:
 	wakeup_code_start = .
 	.code16
 
+ 	movw	$0xb800, %ax
+	movw	%ax,%fs
+	movw	$0x0e00 + 'L', %fs:(0x10)
 	cli
 	cld
+	  
+# setup video mode
+#	movw	$0x4117, %bx		# 0x4000 for linear framebuffer
+#	movw	$0x4f02, %ax
+#	int	$0x10
 
 	# setup data segment
 	movw	%cs, %ax
@@ -20,6 +29,14 @@ wakeup_code:
 	movw	%ax, %ds
 	movw	%ax, %ss
 	mov	$(wakeup_stack - wakeup_data), %sp		# Private stack is needed for ASUS board
+	movw	$0x0e00 + 'S', %fs:(0x12)	
+
+	movl	real_magic - wakeup_data, %eax
+	cmpl	$0x12345678, %eax
+	jne	bogus_real_magic
+
+	mov	video_mode - wakeup_data, %ax
+	call	mode_set
 
 	# set up page table
 	movl	(real_save_cr3 - wakeup_data), %eax
@@ -28,40 +45,114 @@ wakeup_code:
 	# make sure %cr4 is set correctly (features, etc)
 	movl	(real_save_cr4 - wakeup_data), %eax
 	movl	%eax, %cr4
+	movw	$0xb800, %ax
+	movw	%ax,%fs
+	movw	$0x0e00 + 'i', %fs:(0x12)
 
 	# need a gdt
 	lgdt	real_save_gdt - wakeup_data
 
-	movl	%cr0, %eax
-	orl     $0x80000001, %eax
+	movl	(real_save_cr0 - wakeup_data), %eax
 	movl	%eax, %cr0
+	movw	$0x0e00 + 'n', %fs:(0x14)
+
+	movl	real_magic - wakeup_data, %eax
+	cmpl	$0x12345678, %eax
+	jne	bogus_real_magic
 
 	ljmpl	$__KERNEL_CS,$wakeup_pmode_return
 
+bogus_real_magic:
+	movw	$0x0e00 + 'B', %fs:(0x12)
+	jmp bogus_real_magic
+
+/* This code uses an extended set of video mode numbers. These include:
+ * Aliases for standard modes
+ *	NORMAL_VGA (-1)
+ *	EXTENDED_VGA (-2)
+ *	ASK_VGA (-3)
+ * Video modes numbered by menu position -- NOT RECOMMENDED because of lack
+ * of compatibility when extending the table. These are between 0x00 and 0xff.
+ */
+#define VIDEO_FIRST_MENU 0x0000
+
+/* Standard BIOS video modes (BIOS number + 0x0100) */
+#define VIDEO_FIRST_BIOS 0x0100
+
+/* VESA BIOS video modes (VESA number + 0x0200) */
+#define VIDEO_FIRST_VESA 0x0200
+
+/* Video7 special modes (BIOS number + 0x0900) */
+#define VIDEO_FIRST_V7 0x0900
+
+# Setting of user mode (AX=mode ID) => CF=success
+mode_set:
+	movw	%ax, %bx
+#if 0
+	cmpb	$0xff, %ah
+	jz	setalias
+
+	testb	$VIDEO_RECALC>>8, %ah
+	jnz	_setrec
+
+	cmpb	$VIDEO_FIRST_RESOLUTION>>8, %ah
+	jnc	setres
+	
+	cmpb	$VIDEO_FIRST_SPECIAL>>8, %ah
+	jz	setspc
+
+	cmpb	$VIDEO_FIRST_V7>>8, %ah
+	jz	setv7
+#endif
+	
+	cmpb	$VIDEO_FIRST_VESA>>8, %ah
+	jnc	check_vesa
+#if 0	
+	orb	%ah, %ah
+	jz	setmenu
+#endif
+	
+	decb	%ah
+#	jz	setbios				  Add bios modes later
+
+setbad:	clc
+	ret
+
+check_vesa:
+	subb	$VIDEO_FIRST_VESA>>8, %bh
+	orw	$0x4000, %bx			# Use linear frame buffer
+	movw	$0x4f02, %ax			# VESA BIOS mode set call
+	int	$0x10
+	cmpw	$0x004f, %ax			# AL=4f if implemented
+	jnz	_setbad				# AH=0 if OK
+
+	stc
+	ret
+
+_setbad: jmp setbad
+
 	.code32
 	ALIGN
 
-.org	0x100
+.org	0x300
 wakeup_data:
 		.word 0
 real_save_gdt:	.word 0
 		.long 0
+real_save_cr0:	.long 0
 real_save_cr3:	.long 0
 real_save_cr4:	.long 0
+real_magic:	.long 0
+video_mode:	.long 0
 
-.org	0x300
+.org	0x500
 wakeup_stack:
 wakeup_end:
 
 wakeup_pmode_return:
-	# restore data segment
 	movl	$__KERNEL_DS, %eax
-	movw	%ax, %ds
-	movw	%ax, %es
-
-	# and restore the stack
-	movw	%ax, %ss
-	movl	saved_esp, %esp
+	movl	%eax, %ds
+	movw	$0x0e00 + 'u', %ds:(0xb8016)
 
 	# restore other segment registers
 	xorl	%eax, %eax
@@ -72,6 +163,30 @@ wakeup_pmode_return:
 	lgdt	saved_gdt
 	lidt	saved_idt
 	lldt	saved_ldt
+	ljmp	$(__KERNEL_CS),$1f
+1:
+	movl	%cr3, %eax
+	movl	%eax, %cr3
+	wbinvd
+
+	# and restore the stack ... but you need gdt for this to work
+	movl	$__KERNEL_DS, %eax
+	movw	%ax, %ss
+	movw	%ax, %ds
+	movw	%ax, %es
+	movw	%ax, %fs
+	movw	%ax, %gs
+	movl	saved_esp, %esp
+
+	movw	$0x0e00 + 'W', %ds:(0xb8018)
+	movl	$(1024*1024*3), %ecx
+	movl	$0, %esi
+	rep	lodsb
+	movw	$0x0e00 + 'O', %ds:(0xb8018)
+
+	movl	%cs:saved_magic2, %eax
+	cmpl	$0x12345678, %eax
+	jne	bogus_magic
 
 	# restore the other general registers
 	movl	saved_ebx, %ebx
@@ -81,8 +196,21 @@ wakeup_pmode_return:
 
 	# jump to place where we left off
 	movl	saved_eip,%eax
+	movw	$0x0e00 + 'x', %ds:(0xb8018)
+	pushl	%eax
+	popl	%eax
+	movw	$0x0e00 + '!', %ds:(0xb801a)
 	jmp	*%eax
 
+bogus_magic:
+	movw	$0x0e00 + 'B', %ds:(0xb8018)
+	jmp bogus_magic
+
+bogus_magic2:
+	movw	$0x0e00 + '2', %ds:(0xb8018)
+	jmp bogus_magic2
+		
+
 ##
 # acpi_copy_wakeup_routine
 #
@@ -113,23 +241,22 @@ ENTRY(acpi_copy_wakeup_routine)
 	movl    %edx, real_save_cr3 - wakeup_start (%eax)
 	movl    %cr4, %edx
 	movl    %edx, real_save_cr4 - wakeup_start (%eax)
+	movl	%cr0, %edx
+	movl	%edx, real_save_cr0 - wakeup_start (%eax)
 	sgdt    real_save_gdt - wakeup_start (%eax)
 
+	movl	saved_videomode, %edx
+	movl	%edx, video_mode - wakeup_start (%eax)
+	movl	$0x12345678, real_magic - wakeup_start (%eax)
+	movl	$0x12345678, saved_magic2
+
 	# restore the regs we used
 	popl	%edi
 	popl	%esi
 	ret
 
-
 .data
 ALIGN
-# saved registers
-saved_gdt:	.long	0,0
-saved_idt:	.long	0,0
-saved_ldt:	.long	0
-saved_tss:	.long	0
-saved_cr0:	.long	0
-
 ENTRY(saved_ebp)	.long	0
 ENTRY(saved_esi)	.long	0
 ENTRY(saved_edi)	.long	0
@@ -137,3 +264,16 @@ ENTRY(saved_ebx)	.long	0
 
 ENTRY(saved_eip)	.long	0
 ENTRY(saved_esp)	.long	0
+
+ENTRY(saved_magic)	.long	0
+ENTRY(saved_magic2)	.long	0	
+ENTRY(saved_videomode)	.long	0
+
+ALIGN
+# saved registers
+saved_gdt:	.long	0,0
+saved_idt:	.long	0,0
+saved_ldt:	.long	0
+saved_tss:	.long	0
+saved_cr0:	.long	0
+
diff --git a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c
index 27dc68af512b..b904d5b8f90c 100644
--- a/arch/i386/kernel/apm.c
+++ b/arch/i386/kernel/apm.c
@@ -1667,6 +1667,7 @@ static int apm(void *unused)
 	daemonize();
 
 	strcpy(current->comm, "kapmd");
+	current->flags |= PF_IOTHREAD;
 	sigfillset(&current->blocked);
 
 	if (apm_info.connection_version == 0) {
diff --git a/arch/i386/kernel/i8259.c b/arch/i386/kernel/i8259.c
index 1c411fc02da6..c874358ce81c 100644
--- a/arch/i386/kernel/i8259.c
+++ b/arch/i386/kernel/i8259.c
@@ -11,6 +11,7 @@
 #include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/kernel_stat.h>
+#include <linux/device.h>
 
 #include <asm/atomic.h>
 #include <asm/system.h>
@@ -237,7 +238,19 @@ spurious_8259A_irq:
 	}
 }
 
-void __init init_8259A(int auto_eoi)
+static struct device device_i8259A = {
+	name:	       	"i8259A",
+	bus_id:		"0020",
+};
+
+static void __init init_8259A_devicefs(void)
+{
+	register_sys_device(&device_i8259A);
+}
+
+__initcall(init_8259A_devicefs);
+
+void init_8259A(int auto_eoi)
 {
 	unsigned long flags;
 
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index e444fd509748..23d00066aafb 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -168,6 +168,8 @@ void __init visws_get_board_type_and_rev(void);
 static int disable_x86_serial_nr __initdata = 1;
 static int disable_x86_fxsr __initdata = 0;
 
+extern unsigned long saved_videomode;
+
 /*
  * This is set up by the setup-routine at boot-time
  */
@@ -182,6 +184,7 @@ static int disable_x86_fxsr __initdata = 0;
 #define SYS_DESC_TABLE (*(struct sys_desc_table_struct*)(PARAM+0xa0))
 #define MOUNT_ROOT_RDONLY (*(unsigned short *) (PARAM+0x1F2))
 #define RAMDISK_FLAGS (*(unsigned short *) (PARAM+0x1F8))
+#define VIDEO_MODE (*(unsigned short *) (PARAM+0x1FA))
 #define ORIG_ROOT_DEV (*(unsigned short *) (PARAM+0x1FC))
 #define AUX_DEVICE_INFO (*(unsigned char *) (PARAM+0x1FF))
 #define LOADER_TYPE (*(unsigned char *) (PARAM+0x210))
@@ -681,6 +684,8 @@ void __init setup_arch(char **cmdline_p)
  	drive_info = DRIVE_INFO;
  	screen_info = SCREEN_INFO;
 	apm_info.bios = APM_BIOS_INFO;
+	saved_videomode = VIDEO_MODE;
+	printk("Video mode to be used for restore is %lx\n", saved_videomode);
 	if( SYS_DESC_TABLE.length != 0 ) {
 		MCA_bus = SYS_DESC_TABLE.table[3] &0x2;
 		machine_id = SYS_DESC_TABLE.table[0];
diff --git a/arch/i386/kernel/signal.c b/arch/i386/kernel/signal.c
index 842cb07e7eb9..981bf811e1b5 100644
--- a/arch/i386/kernel/signal.c
+++ b/arch/i386/kernel/signal.c
@@ -21,6 +21,7 @@
 #include <linux/tty.h>
 #include <linux/personality.h>
 #include <linux/binfmts.h>
+#include <linux/suspend.h>
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/i387.h>
@@ -594,6 +595,11 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset)
 	if ((regs->xcs & 3) != 3)
 		return 1;
 
+	if (current->flags & PF_FREEZE) {
+		refrigerator(0);
+		goto no_signal;
+	}
+
 	if (!oldset)
 		oldset = &current->blocked;
 
@@ -701,6 +707,7 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset)
 		return 1;
 	}
 
+ no_signal:
 	/* Did we come from a system call? */
 	if (regs->orig_eax >= 0) {
 		/* Restart the system call - no handlers present */
diff --git a/arch/i386/kernel/time.c b/arch/i386/kernel/time.c
index df5c150d3945..ae62beb9713d 100644
--- a/arch/i386/kernel/time.c
+++ b/arch/i386/kernel/time.c
@@ -42,6 +42,7 @@
 #include <linux/init.h>
 #include <linux/smp.h>
 #include <linux/module.h>
+#include <linux/device.h>
 
 #include <asm/io.h>
 #include <asm/smp.h>
@@ -636,6 +637,17 @@ bad_ctc:
 	return 0;
 }
 
+static struct device device_i8253;
+
+static void time_init_driverfs(void)
+{
+	strcpy(device_i8253.name, "i8253");
+	strcpy(device_i8253.bus_id, "0040");
+	register_sys_device(&device_i8253);
+}
+
+__initcall(time_init_driverfs);
+
 void __init time_init(void)
 {
 	extern int x86_udelay_tsc;
diff --git a/arch/i386/vmlinux.lds b/arch/i386/vmlinux.lds
index 2980f1836c73..05c8e1fde646 100644
--- a/arch/i386/vmlinux.lds
+++ b/arch/i386/vmlinux.lds
@@ -65,6 +65,12 @@ SECTIONS
   . = ALIGN(4096);
   __init_end = .;
 
+  . = ALIGN(4096);
+  __nosave_begin = .;
+  .data_nosave : { *(.data.nosave) }
+  . = ALIGN(4096);
+  __nosave_end = .;
+
   . = ALIGN(4096);
   .data.page_aligned : { *(.data.idt) }
 
diff --git a/drivers/acpi/acpi_system.c b/drivers/acpi/acpi_system.c
index 2339b6296124..3977d77a32ef 100644
--- a/drivers/acpi/acpi_system.c
+++ b/drivers/acpi/acpi_system.c
@@ -33,6 +33,7 @@
 #include <linux/delay.h>
 #include <linux/sysrq.h>
 #include <linux/pm.h>
+#include <linux/device.h>
 #include <asm/uaccess.h>
 #include <asm/acpi.h>
 #include "acpi_bus.h"
@@ -128,6 +129,12 @@ acpi_system_restore_state (
 	/* restore device context */
 	device_resume(RESUME_RESTORE_STATE);
 #endif
+
+	if (dmi_broken & BROKEN_INIT_AFTER_S1) {
+		printk("Broken toshiba laptop -> kicking interrupts\n");
+		init_8259A(0);
+	}
+
 	return AE_OK;
 }
 
@@ -254,23 +261,21 @@ acpi_system_suspend(
 	switch (state)
 	{
 	case ACPI_STATE_S1:
-		/* do nothing */
+		barrier();
+		status = acpi_enter_sleep_state(state);
 		break;
 
 	case ACPI_STATE_S2:
 	case ACPI_STATE_S3:
-		acpi_save_register_state((unsigned long)&&acpi_sleep_done);
+		do_suspend_magic(0);
 		break;
 	}
 
-	barrier();
-	status = acpi_enter_sleep_state(state);
-
-acpi_sleep_done:
-
+	printk("acpi_restore_register_state...");
 	acpi_restore_register_state();
 	restore_flags(flags);
 
+	printk("acpi returning...");
 	return status;
 }
 
@@ -290,6 +295,8 @@ acpi_suspend (
 	if (state < ACPI_STATE_S1 || state > ACPI_STATE_S5)
 		return AE_ERROR;
 
+	freeze_processes();
+
 	/* do we have a wakeup address for S2 and S3? */
 	if (state == ACPI_STATE_S2 || state == ACPI_STATE_S3) {
 		if (!acpi_wakeup_address)
@@ -315,7 +322,9 @@ acpi_suspend (
 	 * no matter what.
 	 */
 	acpi_system_restore_state(state);
+	printk("acpi_leave_sleep_state...");
 	acpi_leave_sleep_state(state);
+	printk("ook\n");
 
 	/* make sure interrupts are enabled */
 	ACPI_ENABLE_IRQS();
@@ -323,6 +332,8 @@ acpi_suspend (
 	/* reset firmware waking vector */
 	acpi_set_firmware_waking_vector((ACPI_PHYSICAL_ADDRESS) 0);
 
+	thaw_processes();
+
 	return status;
 }
 
@@ -700,8 +711,17 @@ acpi_system_write_sleep (
 	
 	if (!system->states[state])
 		return_VALUE(-ENODEV);
+
 	
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	if (state == 4) {
+		/* We are working from process context, that's why we may call it directly. */ 
+		do_software_suspend();
+		return_VALUE(count);
+	}
+#endif
 	status = acpi_suspend(state);
+
 	if (ACPI_FAILURE(status))
 		return_VALUE(-ENODEV);
 	
@@ -1180,6 +1200,10 @@ acpi_system_add (
 		}
 	}
 	printk(")\n");
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	printk(KERN_INFO "Software suspend => we can do S4.");
+	system->states[4] = 1;
+#endif
 
 #ifdef CONFIG_PM
 	/* Install the soft-off (S5) handler. */
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index b3d2a94c59ce..3b3dd40bc694 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -173,6 +173,7 @@ static int print_unex=1;
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/devfs_fs_kernel.h>
+#include <linux/device.h>
 
 /*
  * PS/2 floppies have much slower step rates than regular floppies.
@@ -4178,11 +4179,15 @@ static int __init floppy_setup(char *str)
 
 static int have_no_fdc= -ENODEV;
 
+static struct device device_floppy;
 
 int __init floppy_init(void)
 {
 	int i,unit,drive;
 
+	strcpy(device_floppy.name, "floppy");
+	strcpy(device_floppy.bus_id, "03?0");
+	register_sys_device(&device_floppy);
 
 	raw_cmd = NULL;
 
diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index 0ea76d978992..c0f8f5a46a32 100644
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -1418,7 +1418,9 @@ get_rq:
 	req->buffer = bio_data(bio);	/* see ->buffer comment above */
 	req->waiting = NULL;
 	req->bio = req->biotail = bio;
-	req->rq_dev = to_kdev_t(bio->bi_bdev->bd_dev);
+	if (bio->bi_bdev)
+		req->rq_dev = to_kdev_t(bio->bi_bdev->bd_dev);
+	else	req->rq_dev = NODEV;
 	add_request(q, req, insert_here);
 out:
 	if (freereq)
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 5bce942e8baa..1016fe70d1e5 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -71,11 +71,11 @@
 #include <linux/smp_lock.h>
 #include <linux/swap.h>
 #include <linux/slab.h>
+#include <linux/loop.h>
+#include <linux/suspend.h>
 
 #include <asm/uaccess.h>
 
-#include <linux/loop.h>		
-
 #define MAJOR_NR LOOP_MAJOR
 
 static int max_loop = 8;
@@ -534,6 +534,7 @@ static int loop_thread(void *data)
 	daemonize();
 
 	sprintf(current->comm, "loop%d", lo->lo_number);
+	current->flags |= PF_IOTHREAD;
 
 	spin_lock_irq(&current->sigmask_lock);
 	sigfillset(&current->blocked);
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index b0f05c72f902..631563965c44 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -27,6 +27,7 @@
 #include <linux/quotaops.h>
 #include <linux/smp_lock.h>
 #include <linux/module.h>
+#include <linux/suspend.h>
 
 #include <linux/spinlock.h>
 
@@ -317,6 +318,22 @@ static struct sysrq_key_op sysrq_kill_op = {
 	action_msg:	"Kill All Tasks",
 };
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+static void sysrq_handle_swsusp(int key, struct pt_regs *pt_regs,
+		struct kbd_struct *kbd, struct tty_struct *tty) {
+        if(!software_suspend_enabled) {
+		printk("Software Suspend is not possible now\n");
+		return;
+	}
+	software_suspend();
+}
+static struct sysrq_key_op sysrq_swsusp_op = {
+	handler:	sysrq_handle_swsusp,
+	help_msg:	"suspenD",
+	action_msg:	"Software suspend\n",
+};
+#endif
+
 /* END SIGNAL SYSRQ HANDLERS BLOCK */
 
 
@@ -339,7 +356,11 @@ static struct sysrq_key_op *sysrq_key_table[SYSRQ_KEY_TABLE_LENGTH] = {
 		 and will never arive */
 /* b */	&sysrq_reboot_op,
 /* c */	NULL,
+#ifdef CONFIG_SOFTWARE_SUSPEND
+/* d */	&sysrq_swsusp_op,
+#else
 /* d */	NULL,
+#endif
 /* e */	&sysrq_term_op,
 /* f */	NULL,
 /* g */	NULL,
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 0710ec89d184..6fdcb7a36365 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/ide.h>
+#include <linux/suspend.h>
 
 #include <asm/byteorder.h>
 #include <asm/irq.h>
@@ -562,6 +563,8 @@ static int idedisk_suspend(struct device *dev, u32 state, u32 level)
 	 * already been done...
 	 */
 
+	BUG_ON(in_interrupt());
+
 	if (level != SUSPEND_SAVE_STATE)
 		return 0;
 
diff --git a/drivers/pci/power.c b/drivers/pci/power.c
index f5fe84e75461..552046a3633f 100644
--- a/drivers/pci/power.c
+++ b/drivers/pci/power.c
@@ -110,7 +110,7 @@ static int pci_pm_save_state(u32 state)
 	return error;
 }
 
-static int pci_pm_suspend(u32 state)
+int pci_pm_suspend(u32 state)
 {
 	struct list_head *list;
 	struct pci_bus *bus;
@@ -123,7 +123,7 @@ static int pci_pm_suspend(u32 state)
 	return 0;
 }
 
-static int pci_pm_resume(void)
+int pci_pm_resume(void)
 {
 	struct list_head *list;
 	struct pci_bus *bus;
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index ab1cbcfd0028..1d0ce1536a40 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -323,6 +323,7 @@ static int usb_stor_control_thread(void * __us)
 	/* avoid getting signals */
 	spin_lock_irq(&current->sigmask_lock);
 	flush_signals(current);
+	current->flags |= PF_IOTHREAD;
 	sigfillset(&current->blocked);
 	recalc_sigpending();
 	spin_unlock_irq(&current->sigmask_lock);
diff --git a/fs/buffer.c b/fs/buffer.c
index 89f89c4e84d7..456aeec23b8f 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -32,6 +32,7 @@
 #include <linux/writeback.h>
 #include <linux/mempool.h>
 #include <linux/hash.h>
+#include <linux/suspend.h>
 #include <asm/bitops.h>
 
 #define BH_ENTRY(list) list_entry((list), struct buffer_head, b_assoc_buffers)
@@ -120,6 +121,8 @@ void unlock_buffer(struct buffer_head *bh)
 	wake_up_buffer(bh);
 }
 
+DECLARE_TASK_QUEUE(tq_bdflush);
+
 /*
  * Block until a buffer comes unlocked.  This doesn't stop it
  * from becoming locked again - you have to lock it yourself
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index a89f7e547581..d1f4d0ea3aed 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -32,6 +32,7 @@
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
+#include <linux/suspend.h>
 #include <linux/pagemap.h>
 #include <asm/uaccess.h>
 #include <linux/proc_fs.h>
@@ -225,6 +226,7 @@ int kjournald(void *arg)
 			journal->j_commit_interval / HZ);
 	list_add(&journal->j_all_journals, &all_journals);
 
+	current->flags |= PF_KERNTHREAD;
 	/* And now, wait forever for commit wakeup events. */
 	while (1) {
 		if (journal->j_flags & JFS_UNMOUNT)
@@ -245,7 +247,15 @@ int kjournald(void *arg)
 		}
 
 		wake_up(&journal->j_wait_done_commit);
-		interruptible_sleep_on(&journal->j_wait_commit);
+		if (current->flags & PF_FREEZE) { /* The simpler the better. Flushing journal isn't a
+						     good idea, because that depends on threads that
+						     may be already stopped. */
+			jbd_debug(1, "Now suspending kjournald\n");
+			refrigerator(PF_IOTHREAD);
+			jbd_debug(1, "Resuming kjournald\n");						
+		} else		/* we assume on resume that commits are already there,
+				   so we don't sleep */
+			interruptible_sleep_on(&journal->j_wait_commit);
 
 		jbd_debug(1, "kjournald wakes\n");
 
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index de6e7de3068f..cf4dd84fd758 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -57,6 +57,7 @@
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/smp_lock.h>
+#include <linux/suspend.h> 
 
 /* the number of mounted filesystems.  This is used to decide when to
 ** start and kill the commit thread
@@ -1886,6 +1887,7 @@ static int reiserfs_journal_commit_thread(void *nullp) {
   spin_unlock_irq(&current->sigmask_lock);
 
   sprintf(current->comm, "kreiserfsd") ;
+  current->flags |= PF_KERNTHREAD;
   lock_kernel() ;
   while(1) {
 
@@ -1899,7 +1901,12 @@ static int reiserfs_journal_commit_thread(void *nullp) {
       break ;
     }
     wake_up(&reiserfs_commit_thread_done) ;
-    interruptible_sleep_on_timeout(&reiserfs_commit_thread_wait, 5 * HZ) ;
+#ifdef CONFIG_SOFTWARE_SUSPEND
+    if (current->flags & PF_FREEZE) {
+	    refrigerator(PF_IOTHREAD);
+    } else
+#endif
+	    interruptible_sleep_on_timeout(&reiserfs_commit_thread_wait, 5 * HZ) ;
   }
   unlock_kernel() ;
   wake_up(&reiserfs_commit_thread_done) ;
diff --git a/include/asm-generic/bitops.h b/include/asm-generic/bitops.h
index 1428fd95b987..23ac5227b702 100644
--- a/include/asm-generic/bitops.h
+++ b/include/asm-generic/bitops.h
@@ -51,6 +51,12 @@ extern __inline__ int test_bit(int nr, long * addr)
 	return ((mask & *addr) != 0);
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff --git a/include/asm-i386/bitops.h b/include/asm-i386/bitops.h
index 4e1b7c04df41..4cf9d29ef4ad 100644
--- a/include/asm-i386/bitops.h
+++ b/include/asm-i386/bitops.h
@@ -414,6 +414,12 @@ static __inline__ unsigned long __ffs(unsigned long word)
 	return word;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff --git a/include/asm-i386/suspend.h b/include/asm-i386/suspend.h
new file mode 100644
index 000000000000..0bf90bb1c806
--- /dev/null
+++ b/include/asm-i386/suspend.h
@@ -0,0 +1,304 @@
+#ifndef __ASM_I386_SUSPEND_H
+#define __ASM_I386_SUSPEND_H
+#endif
+
+/*
+ * Copyright 2001-2002 Pavel Machek <pavel@suse.cz>
+ * Based on code
+ * Copyright 2001 Patrick Mochel <mochel@osdl.org>
+ */
+#if defined(SUSPEND_C) || defined(ACPI_C)
+#include <asm/desc.h>
+#include <asm/i387.h>
+
+static inline void
+arch_prepare_suspend(void)
+{
+	if (!cpu_has_pse)
+		panic("pse required");
+}
+
+/* image of the saved processor state */
+struct saved_context {
+	u32 eax, ebx, ecx, edx;
+	u32 esp, ebp, esi, edi;
+	u16 es, fs, gs, ss;
+	u32 cr0, cr2, cr3, cr4;
+	u16 gdt_pad;
+	u16 gdt_limit;
+	u32 gdt_base;
+	u16 idt_pad;
+	u16 idt_limit;
+	u32 idt_base;
+	u16 ldt;
+	u16 tss;
+	u32 tr;
+	u32 safety;
+	u32 return_address;
+	u32 eflags;
+} __attribute__((packed));
+
+static struct saved_context saved_context;
+
+#define loaddebug(thread,register) \
+               __asm__("movl %0,%%db" #register  \
+                       : /* no output */ \
+                       :"r" ((thread)->debugreg[register]))
+
+ 
+/*
+ * save_processor_context
+ * 
+ * Save the state of the processor before we go to sleep.
+ *
+ * return_stack is the value of the stack pointer (%esp) as the caller sees it.
+ * A good way could not be found to obtain it from here (don't want to make _too_
+ * many assumptions about the layout of the stack this far down.) Also, the 
+ * handy little __builtin_frame_pointer(level) where level > 0, is blatantly 
+ * buggy - it returns the value of the stack at the proper location, not the 
+ * location, like it should (as of gcc 2.91.66)
+ * 
+ * Note that the context and timing of this function is pretty critical.
+ * With a minimal amount of things going on in the caller and in here, gcc
+ * does a good job of being just a dumb compiler.  Watch the assembly output
+ * if anything changes, though, and make sure everything is going in the right
+ * place. 
+ */
+static inline void save_processor_context (void)
+{
+	kernel_fpu_begin();
+
+	/*
+	 * descriptor tables
+	 */
+	asm volatile ("sgdt (%0)" : "=m" (saved_context.gdt_limit));
+	asm volatile ("sidt (%0)" : "=m" (saved_context.idt_limit));
+	asm volatile ("sldt (%0)" : "=m" (saved_context.ldt));
+	asm volatile ("str (%0)"  : "=m" (saved_context.tr));
+
+	/*
+	 * save the general registers.
+	 * note that gcc has constructs to specify output of certain registers,
+	 * but they're not used here, because it assumes that you want to modify
+	 * those registers, so it tries to be smart and save them beforehand.
+	 * It's really not necessary, and kinda fishy (check the assembly output),
+	 * so it's avoided. 
+	 */
+	asm volatile ("movl %%esp, (%0)" : "=m" (saved_context.esp));
+	asm volatile ("movl %%eax, (%0)" : "=m" (saved_context.eax));
+	asm volatile ("movl %%ebx, (%0)" : "=m" (saved_context.ebx));
+	asm volatile ("movl %%ecx, (%0)" : "=m" (saved_context.ecx));
+	asm volatile ("movl %%edx, (%0)" : "=m" (saved_context.edx));
+	asm volatile ("movl %%ebp, (%0)" : "=m" (saved_context.ebp));
+	asm volatile ("movl %%esi, (%0)" : "=m" (saved_context.esi));
+	asm volatile ("movl %%edi, (%0)" : "=m" (saved_context.edi));
+
+	/*
+	 * segment registers
+	 */
+	asm volatile ("movw %%es, %0" : "=r" (saved_context.es));
+	asm volatile ("movw %%fs, %0" : "=r" (saved_context.fs));
+	asm volatile ("movw %%gs, %0" : "=r" (saved_context.gs));
+	asm volatile ("movw %%ss, %0" : "=r" (saved_context.ss));
+
+	/*
+	 * control registers 
+	 */
+	asm volatile ("movl %%cr0, %0" : "=r" (saved_context.cr0));
+	asm volatile ("movl %%cr2, %0" : "=r" (saved_context.cr2));
+	asm volatile ("movl %%cr3, %0" : "=r" (saved_context.cr3));
+	asm volatile ("movl %%cr4, %0" : "=r" (saved_context.cr4));
+
+	/*
+	 * eflags
+	 */
+	asm volatile ("pushfl ; popl (%0)" : "=m" (saved_context.eflags));
+}
+
+static void fix_processor_context(void)
+{
+	int nr = smp_processor_id();
+	struct tss_struct * t = &init_tss[nr];
+
+	set_tss_desc(nr,t);	/* This just modifies memory; should not be neccessary. But... This is neccessary, because 386 hardware has concept of busy tsc or some similar stupidity. */
+        gdt_table[__TSS(nr)].b &= 0xfffffdff;
+
+	load_TR(nr);		/* This does ltr */
+
+	load_LDT(&current->mm->context);	/* This does lldt */
+
+	/*
+	 * Now maybe reload the debug registers
+	 */
+	if (current->thread.debugreg[7]){
+                loaddebug(&current->thread, 0);
+                loaddebug(&current->thread, 1);
+                loaddebug(&current->thread, 2);
+                loaddebug(&current->thread, 3);
+                /* no 4 and 5 */
+                loaddebug(&current->thread, 6);
+                loaddebug(&current->thread, 7);
+	}
+
+}
+
+static void
+do_fpu_end(void)
+{
+        /* restore FPU regs if necessary */
+	/* Do it out of line so that gcc does not move cr0 load to some stupid place */
+        kernel_fpu_end();
+}
+
+/*
+ * restore_processor_context
+ * 
+ * Restore the processor context as it was before we went to sleep
+ * - descriptor tables
+ * - control registers
+ * - segment registers
+ * - flags
+ * 
+ * Note that it is critical that this function is declared inline.  
+ * It was separated out from restore_state to make that function
+ * a little clearer, but it needs to be inlined because we won't have a
+ * stack when we get here (so we can't push a return address).
+ */
+static inline void restore_processor_context (void)
+{
+	/*
+	 * first restore %ds, so we can access our data properly
+	 */
+	asm volatile (".align 4");
+	asm volatile ("movw %0, %%ds" :: "r" ((u16)__KERNEL_DS));
+
+
+	/*
+	 * control registers
+	 */
+	asm volatile ("movl %0, %%cr4" :: "r" (saved_context.cr4));
+	asm volatile ("movl %0, %%cr3" :: "r" (saved_context.cr3));
+	asm volatile ("movl %0, %%cr2" :: "r" (saved_context.cr2));
+	asm volatile ("movl %0, %%cr0" :: "r" (saved_context.cr0));
+	
+	/*
+	 * segment registers
+	 */
+	asm volatile ("movw %0, %%es" :: "r" (saved_context.es));
+	asm volatile ("movw %0, %%fs" :: "r" (saved_context.fs));
+	asm volatile ("movw %0, %%gs" :: "r" (saved_context.gs));
+	asm volatile ("movw %0, %%ss" :: "r" (saved_context.ss));
+
+	/*
+	 * the other general registers
+	 *
+	 * note that even though gcc has constructs to specify memory 
+	 * input into certain registers, it will try to be too smart
+	 * and save them at the beginning of the function.  This is esp.
+	 * bad since we don't have a stack set up when we enter, and we 
+	 * want to preserve the values on exit. So, we set them manually.
+	 */
+	asm volatile ("movl %0, %%esp" :: "m" (saved_context.esp));
+	asm volatile ("movl %0, %%ebp" :: "m" (saved_context.ebp));
+	asm volatile ("movl %0, %%eax" :: "m" (saved_context.eax));
+	asm volatile ("movl %0, %%ebx" :: "m" (saved_context.ebx));
+	asm volatile ("movl %0, %%ecx" :: "m" (saved_context.ecx));
+	asm volatile ("movl %0, %%edx" :: "m" (saved_context.edx));
+	asm volatile ("movl %0, %%esi" :: "m" (saved_context.esi));
+	asm volatile ("movl %0, %%edi" :: "m" (saved_context.edi));
+
+	/*
+	 * now restore the descriptor tables to their proper values
+	 */
+	asm volatile ("lgdt (%0)" :: "m" (saved_context.gdt_limit));
+	asm volatile ("lidt (%0)" :: "m" (saved_context.idt_limit));
+	asm volatile ("lldt (%0)" :: "m" (saved_context.ldt));
+
+#if 0
+	asm volatile ("ltr (%0)"  :: "m" (saved_context.tr));
+#endif
+
+	fix_processor_context();
+
+	/*
+	 * the flags
+	 */
+	asm volatile ("pushl %0 ; popfl" :: "m" (saved_context.eflags));
+
+	do_fpu_end();
+}
+
+#endif
+#ifdef SUSPEND_C
+#if 1
+/* Local variables for do_magic */
+static int loop __nosavedata = 0;
+static int loop2 __nosavedata = 0;
+
+/*
+ * (KG): Since we affect stack here, we make this function as flat and easy
+ * as possible in order to not provoke gcc to use local variables on the stack.
+ * Note that on resume, all (expect nosave) variables will have the state from
+ * the time of writing (suspend_save_image) and the registers (including the
+ * stack pointer, but excluding the instruction pointer) will be loaded with 
+ * the values saved at save_processor_context() time.
+ */
+static void do_magic(int resume)
+{
+	/* DANGER WILL ROBINSON!
+	 *
+	 * If this function is too difficult for gcc to optimize, it will crash and burn!
+	 * see above.
+	 *
+	 * DO NOT TOUCH.
+	 */
+
+	if (!resume) {
+		do_magic_suspend_1();
+		save_processor_context();	/* We need to capture registers and memory at "same time" */
+		do_magic_suspend_2();		/* If everything goes okay, this function does not return */
+		return;
+	}
+
+	/* We want to run from swapper_pg_dir, since swapper_pg_dir is stored in constant
+	 * place in memory 
+	 */
+
+        __asm__( "movl %%ecx,%%cr3\n" ::"c"(__pa(swapper_pg_dir)));
+
+/*
+ * Final function for resuming: after copying the pages to their original
+ * position, it restores the register state.
+ */
+
+	do_magic_resume_1();
+
+	/* Critical section here: noone should touch memory from now */
+	/* This works, because nr_copy_pages, pagedir_nosave, loop and loop2 are nosavedata */
+	for (loop=0; loop < nr_copy_pages; loop++) {
+		/* You may not call something (like copy_page) here:
+		   We may absolutely not use stack at this point */
+		for (loop2=0; loop2 < PAGE_SIZE; loop2++) {
+			*(((char *)((pagedir_nosave+loop)->orig_address))+loop2) =
+				*(((char *)((pagedir_nosave+loop)->address))+loop2);
+			__flush_tlb();
+		}
+	}
+/* FIXME: What about page tables? Writing data pages may toggle
+   accessed/dirty bits in our page tables. That should be no problems
+   with 4MB page tables. That's why we require have_pse. */
+
+/* Danger: previous loop probably destroyed our current stack. Better hope it did not use
+   any stack space, itself.
+
+   When this function is entered at resume time, we move stack to _old_ place.
+   This is means that this function must use no stack and no local variables in registers.
+*/
+	restore_processor_context();
+/* Ahah, we now run with our old stack, and with registers copied from suspend time */
+
+	do_magic_resume_2();
+}
+#endif
+#endif 
+
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index b155b779696b..39f3b34a75d5 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -1,6 +1,6 @@
 #ifndef _LINUX_BITOPS_H
 #define _LINUX_BITOPS_H
-
+#include <asm/bitops.h>
 
 /*
  * ffs: find first bit set. This is defined the same way as
@@ -37,6 +37,47 @@ static inline int generic_ffs(int x)
 	return r;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+extern __inline__ int generic_fls(int x)
+{
+	int r = 32;
+
+	if (!x)
+		return 0;
+	if (!(x & 0xffff0000)) {
+		x <<= 16;
+		r -= 16;
+	}
+	if (!(x & 0xff000000)) {
+		x <<= 8;
+		r -= 8;
+	}
+	if (!(x & 0xf0000000)) {
+		x <<= 4;
+		r -= 4;
+	}
+	if (!(x & 0xc0000000)) {
+		x <<= 2;
+		r -= 2;
+	}
+	if (!(x & 0x80000000)) {
+		x <<= 1;
+		r -= 1;
+	}
+	return r;
+}
+
+extern __inline__ int get_bitmask_order(unsigned int count)
+{
+	int order;
+	
+	order = fls(count);
+	return order;	/* We could be slightly more clever with -1 here... */
+}
+
 /*
  * hweightN: returns the hamming weight (i.e. the number
  * of bits set) of a N-bit word
diff --git a/include/linux/init.h b/include/linux/init.h
index 142ec2f3aa68..ca7e75f37883 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -169,6 +169,9 @@ typedef void (*__cleanup_module_func_t)(void);
 
 #endif
 
+/* Data marked not to be saved by software_suspend() */
+#define __nosavedata __attribute__ ((__section__ (".data.nosave")))
+
 #ifdef CONFIG_HOTPLUG
 #define __devinit
 #define __devinitdata
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 52b7117c4f64..23d6e6208432 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -64,6 +64,7 @@
 
 #define PG_private		12	/* Has something at ->private */
 #define PG_writeback		13	/* Page is under writeback */
+#define PG_nosave		15	/* Used for system suspend/resume */
 
 /*
  * Global page accounting.  One instance per CPU.
@@ -207,6 +208,12 @@ extern void get_page_state(struct page_state *ret);
 		ret;							\
 	})
 
+#define PageNosave(page)	test_bit(PG_nosave, &(page)->flags)
+#define SetPageNosave(page)	set_bit(PG_nosave, &(page)->flags)
+#define TestSetPageNosave(page)	test_and_set_bit(PG_nosave, &(page)->flags)
+#define ClearPageNosave(page)		clear_bit(PG_nosave, &(page)->flags)
+#define TestClearPageNosave(page)	test_and_clear_bit(PG_nosave, &(page)->flags)
+
 /*
  * The PageSwapCache predicate doesn't use a PG_flag at this time,
  * but it may again do so one day.
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 5f128a952550..4c8b4276c957 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -20,6 +20,7 @@
  * CAD_OFF     Ctrl-Alt-Del sequence sends SIGINT to init task.
  * POWER_OFF   Stop OS and remove all power from system, if possible.
  * RESTART2    Restart system using given command string.
+ * SW_SUSPEND  Suspend system using Software Suspend if compiled in
  */
 
 #define	LINUX_REBOOT_CMD_RESTART	0x01234567
@@ -28,6 +29,7 @@
 #define	LINUX_REBOOT_CMD_CAD_OFF	0x00000000
 #define	LINUX_REBOOT_CMD_POWER_OFF	0x4321FEDC
 #define	LINUX_REBOOT_CMD_RESTART2	0xA1B2C3D4
+#define	LINUX_REBOOT_CMD_SW_SUSPEND	0xD000FCE2
 
 
 #ifdef __KERNEL__
@@ -46,6 +48,13 @@ extern void machine_restart(char *cmd);
 extern void machine_halt(void);
 extern void machine_power_off(void);
 
+/*
+ * Architecture-independent suspend facility
+ */
+
+extern void software_suspend(void);
+extern unsigned char software_suspend_enabled;
+
 #endif
 
 #endif /* _LINUX_REBOOT_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 2ad9171a66b7..067c93387b77 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -388,6 +388,11 @@ do { if (atomic_dec_and_test(&(tsk)->usage)) __put_task_struct(tsk); } while(0)
 #define PF_FLUSHER	0x00004000	/* responsible for disk writeback */
 #define PF_RADIX_TREE	0x00008000	/* debug: performing radix tree alloc */
 
+#define PF_FREEZE	0x00010000	/* this task should be frozen for suspend */
+#define PF_IOTHREAD	0x00020000	/* this thread is needed for doing I/O to swap */
+#define PF_KERNTHREAD	0x00040000	/* this thread is a kernel thread that cannot be sent signals to */
+#define PF_FROZEN	0x00080000	/* frozen for system suspend */
+
 /*
  * Ptrace flags
  */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
new file mode 100644
index 000000000000..6de78341c4fc
--- /dev/null
+++ b/include/linux/suspend.h
@@ -0,0 +1,65 @@
+#ifndef _LINUX_SWSUSP_H
+#define _LINUX_SWSUSP_H
+
+#include <asm/suspend.h>
+#include <linux/swap.h>
+#include <linux/notifier.h>
+#include <linux/config.h>
+
+extern unsigned char software_suspend_enabled;
+
+#define NORESUME	 1
+#define RESUME_SPECIFIED 2
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+/* page backup entry */
+typedef struct pbe {
+	unsigned long address;		/* address of the copy */
+	unsigned long orig_address;	/* original address of page */
+	swp_entry_t swap_address;	
+	swp_entry_t dummy;		/* we need scratch space at 
+					 * end of page (see link, diskpage)
+					 */
+} suspend_pagedir_t;
+
+#define SWAP_FILENAME_MAXLENGTH	32
+
+struct suspend_header {
+	__u32 version_code;
+	unsigned long num_physpages;
+	char machine[8];
+	char version[20];
+	int num_cpus;
+	int page_size;
+	unsigned long suspend_pagedir;
+	unsigned int num_pbes;
+	struct swap_location {
+		char filename[SWAP_FILENAME_MAXLENGTH];
+	} swap_location[MAX_SWAPFILES];
+};
+
+#define SUSPEND_PD_PAGES(x)     (((x)*sizeof(struct pbe))/PAGE_SIZE+1)
+   
+extern struct tq_struct suspend_tq;
+
+/* mm/vmscan.c */
+extern int shrink_mem(void);
+
+/* kernel/suspend.c */
+extern void software_suspend(void);
+extern void software_resume(void);
+extern int resume_setup(char *str);
+
+extern int register_suspend_notifier(struct notifier_block *);
+extern int unregister_suspend_notifier(struct notifier_block *);
+extern void refrigerator(unsigned long);
+
+#else
+#define software_suspend()		do { } while(0)
+#define software_resume()		do { } while(0)
+#define register_suspend_notifier(a)	do { } while(0)
+#define unregister_suspend_notifier(a)	do { } while(0)
+#define refrigerator(a)			do { BUG(); } while(0)
+#endif
+
+#endif /* _LINUX_SWSUSP_H */
diff --git a/include/linux/tqueue.h b/include/linux/tqueue.h
index 5c518e91a8be..516108dcdbbf 100644
--- a/include/linux/tqueue.h
+++ b/include/linux/tqueue.h
@@ -66,7 +66,7 @@ typedef struct list_head task_queue;
 #define DECLARE_TASK_QUEUE(q)	LIST_HEAD(q)
 #define TQ_ACTIVE(q)		(!list_empty(&q))
 
-extern task_queue tq_timer, tq_immediate, tq_disk;
+extern task_queue tq_timer, tq_immediate, tq_disk, tq_bdflush;
 
 /*
  * To implement your own list of active bottom halfs, use the following
diff --git a/init/do_mounts.c b/init/do_mounts.c
index 29b870eb4809..910f4883855b 100644
--- a/init/do_mounts.c
+++ b/init/do_mounts.c
@@ -10,6 +10,7 @@
 #include <linux/fd.h>
 #include <linux/tty.h>
 #include <linux/init.h>
+#include <linux/suspend.h>
 
 #include <linux/nfs_fs.h>
 #include <linux/nfs_fs_sb.h>
@@ -825,6 +826,11 @@ void prepare_namespace(void)
 #endif
 
 	create_dev("/dev/root", ROOT_DEV, NULL);
+
+	/* This has to be before mounting root, because even readonly mount of reiserfs would replay
+	   log corrupting stuff */
+	software_resume();
+
 	if (mount_initrd) {
 		if (initrd_load() && !kdev_same(ROOT_DEV, mk_kdev(RAMDISK_MAJOR, 0))) {
 			handle_initrd();
diff --git a/kernel/Makefile b/kernel/Makefile
index 2c8154ed2778..23efe9a8698d 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -10,7 +10,7 @@
 O_TARGET := kernel.o
 
 export-objs = signal.o sys.o kmod.o context.o ksyms.o pm.o exec_domain.o \
-		printk.o platform.o 
+		printk.o platform.o suspend.o
 
 obj-y     = sched.o dma.o fork.o exec_domain.o panic.o printk.o \
 	    module.o exit.o itimer.o info.o time.o softirq.o resource.o \
@@ -21,6 +21,7 @@ obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += ksyms.o
 obj-$(CONFIG_PM) += pm.o
 obj-$(CONFIG_BSD_PROCESS_ACCT) += acct.o
+obj-$(CONFIG_SOFTWARE_SUSPEND) += suspend.o
 
 ifneq ($(CONFIG_IA64),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
diff --git a/kernel/context.c b/kernel/context.c
index 584e57aa2835..56bada438f61 100644
--- a/kernel/context.c
+++ b/kernel/context.c
@@ -72,6 +72,7 @@ static int context_thread(void *startup)
 
 	daemonize();
 	strcpy(curtask->comm, "keventd");
+	current->flags |= PF_IOTHREAD;
 	keventd_running = 1;
 	keventd_task = curtask;
 
diff --git a/kernel/signal.c b/kernel/signal.c
index c024988e0a6b..d45a2da06ad0 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -493,7 +493,7 @@ static int send_signal(int sig, struct siginfo *info, struct sigpending *signals
  * No need to set need_resched since signal event passing
  * goes through ->blocked
  */
-static inline void signal_wake_up(struct task_struct *t)
+inline void signal_wake_up(struct task_struct *t)
 {
 	set_tsk_thread_flag(t,TIF_SIGPENDING);
 
diff --git a/kernel/softirq.c b/kernel/softirq.c
index c290a1d81e12..208bc9c645b1 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -366,6 +366,7 @@ static int ksoftirqd(void * __bind_cpu)
 
 	daemonize();
 	set_user_nice(current, 19);
+	current->flags |= PF_IOTHREAD;
 	sigfillset(&current->blocked);
 
 	/* Migrate to the right CPU */
diff --git a/kernel/suspend.c b/kernel/suspend.c
new file mode 100644
index 000000000000..d0fde1a86046
--- /dev/null
+++ b/kernel/suspend.c
@@ -0,0 +1,1327 @@
+/*
+ * linux/kernel/swsusp.c
+ *
+ * This file is to realize architecture-independent
+ * machine suspend feature using pretty near only high-level routines
+ *
+ * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
+ * Copyright (C) 1998,2001,2002 Pavel Machek <pavel@suse.cz>
+ *
+ * I'd like to thank the following people for their work:
+ * 
+ * Pavel Machek <pavel@ucw.cz>:
+ * Modifications, defectiveness pointing, being with me at the very beginning,
+ * suspend to swap space, stop all tasks.
+ *
+ * Steve Doddi <dirk@loth.demon.co.uk>: 
+ * Support the possibility of hardware state restoring.
+ *
+ * Raph <grey.havens@earthling.net>:
+ * Support for preserving states of network devices and virtual console
+ * (including X and svgatextmode)
+ *
+ * Kurt Garloff <garloff@suse.de>:
+ * Straightened the critical function in order to prevent compilers from
+ * playing tricks with local variables.
+ *
+ * Andreas Mohr <a.mohr@mailto.de>
+ *
+ * Alex Badea <vampire@go.ro>:
+ * Fixed runaway init
+ *
+ * More state savers are welcome. Especially for the scsi layer...
+ *
+ * For TODOs,FIXMEs also look in Documentation/swsusp.txt
+ */
+
+/*
+ * TODO:
+ *
+ * - we should launch a kernel_thread to process suspend request, cleaning up
+ * bdflush from this task. (check apm.c for something similar).
+ */
+
+/* FIXME: try to poison to memory */
+
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/swapctl.h>
+#include <linux/suspend.h>
+#include <linux/smp_lock.h>
+#include <linux/file.h>
+#include <linux/utsname.h>
+#include <linux/version.h>
+#include <linux/compile.h>
+#include <linux/delay.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/vt_kern.h>
+#include <linux/bitops.h>
+#include <linux/interrupt.h>
+#include <linux/kbd_kern.h>
+#include <linux/keyboard.h>
+#include <linux/spinlock.h>
+#include <linux/genhd.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/blk.h>
+#include <linux/swap.h>
+#include <linux/pm.h>
+#include <linux/device.h>
+
+#include <asm/uaccess.h>
+#include <asm/mmu_context.h>
+#include <asm/pgtable.h>
+#include <asm/io.h>
+
+unsigned char software_suspend_enabled = 0;
+
+/* #define SUSPEND_CONSOLE	(MAX_NR_CONSOLES-1) */
+/* With SUSPEND_CONSOLE defined, it suspend looks *really* cool, but
+   we probably do not take enough locks for switching consoles, etc,
+   so bad things might happen.
+*/
+#ifndef CONFIG_VT
+#undef SUSPEND_CONSOLE
+#endif
+
+#define TIMEOUT	(6 * HZ)			/* Timeout for stopping processes */
+#define ADDRESS(x) ((unsigned long) phys_to_virt(((x) << PAGE_SHIFT)))
+
+extern void wakeup_bdflush(void);
+extern int C_A_D;
+
+/* References to section boundaries */
+extern char _text, _etext, _edata, __bss_start, _end;
+extern char __nosave_begin, __nosave_end;
+
+extern int console_loglevel;
+extern int is_head_of_free_region(struct page *);
+
+/* Locks */
+spinlock_t suspend_pagedir_lock __nosavedata = SPIN_LOCK_UNLOCKED;
+
+/* Variables to be preserved over suspend */
+static int new_loglevel = 7;
+static int orig_loglevel = 0;
+static int orig_fgconsole;
+static int pagedir_order_check;
+static int nr_copy_pages_check;
+
+static int resume_status = 0;
+static char resume_file[256] = "";			/* For resume= kernel option */
+static kdev_t resume_device;
+/* Local variables that should not be affected by save */
+static unsigned int nr_copy_pages __nosavedata = 0;
+
+static int pm_suspend_state = 0;
+
+/* Suspend pagedir is allocated before final copy, therefore it
+   must be freed after resume 
+
+   Warning: this is evil. There are actually two pagedirs at time of
+   resume. One is "pagedir_save", which is empty frame allocated at
+   time of suspend, that must be freed. Second is "pagedir_nosave", 
+   allocated at time of resume, that travells through memory not to
+   collide with anything.
+ */
+static suspend_pagedir_t *pagedir_nosave __nosavedata = NULL;
+static unsigned long pagedir_save;
+static int pagedir_order __nosavedata = 0;
+
+struct link {
+	char dummy[PAGE_SIZE - sizeof(swp_entry_t)];
+	swp_entry_t next;
+};
+
+union diskpage {
+	union swap_header swh;
+	struct link link;
+	struct suspend_header sh;
+};
+
+/*
+ * XXX: We try to keep some more pages free so that I/O operations succeed
+ * without paging. Might this be more?
+ *
+ * [If this is not enough, might it corrupt our data silently?]
+ */
+#define PAGES_FOR_IO	512
+
+static const char *name_suspend = "Suspend Machine: ";
+static const char *name_resume = "Resume Machine: ";
+
+/*
+ * Debug
+ */
+#define	DEBUG_DEFAULT	1
+#undef	DEBUG_PROCESS
+#undef	DEBUG_SLOW
+#define TEST_SWSUSP 0		/* Set to 1 to reboot instead of halt machine after suspension */
+
+#ifdef DEBUG_DEFAULT
+#define PRINTD(func, f, a...)	\
+	do { \
+		printk("%s", func); \
+		printk(f, ## a); \
+	} while(0)
+#define PRINTS(f, a...)	PRINTD(name_suspend, f, ## a)
+#define PRINTR(f, a...)	PRINTD(name_resume, f, ## a)
+#define PRINTK(f, a...)	printk(f, ## a)
+#else
+#define PRINTD(func, f, a...)
+#define PRINTS(f, a...)
+#define PRINTR(f, a...)
+#define PRINTK(f, a...)
+#endif
+#ifdef DEBUG_SLOW
+#define MDELAY(a) mdelay(a)
+#else
+#define MDELAY(a)
+#endif
+
+/*
+ * Refrigerator and related stuff
+ */
+
+#define INTERESTING(p) \
+			/* We don't want to touch kernel_threads..*/ \
+			if (p->flags & PF_IOTHREAD) \
+				continue; \
+			if (p == current) \
+				continue; \
+			if (p->state == TASK_ZOMBIE) \
+				continue;
+
+/* Refrigerator is place where frozen processes are stored :-). */
+void refrigerator(unsigned long flag)
+{
+	/* You need correct to work with real-time processes.
+	   OTOH, this way one process may see (via /proc/) some other
+	   process in stopped state (and thereby discovered we were
+	   suspended. We probably do not care. 
+	 */
+	long save;
+	save = current->state;
+	current->state = TASK_STOPPED;
+//	PRINTK("%s entered refrigerator\n", current->comm);
+	printk(":");
+	current->flags &= ~PF_FREEZE;
+	if (flag)
+		flush_signals(current); /* We have signaled a kernel thread, which isn't normal behaviour
+					   and that may lead to 100%CPU sucking because those threads
+					   just don't manage signals. */
+	current->flags |= PF_FROZEN;
+	while (current->flags & PF_FROZEN)
+		schedule();
+//	PRINTK("%s left refrigerator\n", current->comm);
+	printk(":");
+	current->state = save;
+}
+
+/* 0 = success, else # of processes that we failed to stop */
+int freeze_processes(void)
+{
+	int todo, start_time;
+	struct task_struct *p;
+	
+	PRINTS( "Waiting for tasks to stop... " );
+	
+	start_time = jiffies;
+	do {
+		todo = 0;
+		read_lock(&tasklist_lock);
+		for_each_task(p) {
+			unsigned long flags;
+			INTERESTING(p);
+			if (p->flags & PF_FROZEN)
+				continue;
+
+			/* FIXME: smp problem here: we may not access other process' flags
+			   without locking */
+			p->flags |= PF_FREEZE;
+			spin_lock_irqsave(&p->sigmask_lock, flags);
+			signal_wake_up(p);
+			spin_unlock_irqrestore(&p->sigmask_lock, flags);
+			todo++;
+		}
+		read_unlock(&tasklist_lock);
+		sys_sched_yield();
+		schedule();
+		if (time_after(jiffies, start_time + TIMEOUT)) {
+			PRINTK( "\n" );
+			printk(KERN_ERR " stopping tasks failed (%d tasks remaining)\n", todo );
+			return todo;
+		}
+	} while(todo);
+	
+	PRINTK( " ok\n" );
+	return 0;
+}
+
+void thaw_processes(void)
+{
+	struct task_struct *p;
+
+	PRINTR( "Restarting tasks..." );
+	read_lock(&tasklist_lock);
+	for_each_task(p) {
+		INTERESTING(p);
+		
+		if (p->flags & PF_FROZEN) p->flags &= ~PF_FROZEN;
+		else
+			printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
+		wake_up_process(p);
+	}
+	read_unlock(&tasklist_lock);
+	PRINTK( " done\n" );
+	MDELAY(500);
+}
+
+/*
+ * Saving part...
+ */
+
+static __inline__ int fill_suspend_header(struct suspend_header *sh)
+{
+	memset((char *)sh, 0, sizeof(*sh));
+
+	sh->version_code = LINUX_VERSION_CODE;
+	sh->num_physpages = num_physpages;
+	strncpy(sh->machine, system_utsname.machine, 8);
+	strncpy(sh->version, system_utsname.version, 20);
+	sh->num_cpus = smp_num_cpus;
+	sh->page_size = PAGE_SIZE;
+	sh->suspend_pagedir = (unsigned long)pagedir_nosave;
+	if (pagedir_save != pagedir_nosave)
+		panic("Must not happen");
+	sh->num_pbes = nr_copy_pages;
+	/* TODO: needed? mounted fs' last mounted date comparison
+	 * [so they haven't been mounted since last suspend.
+	 * Maybe it isn't.] [we'd need to do this for _all_ fs-es]
+	 */
+	return 0;
+}
+
+/*
+ * This is our sync function. With this solution we probably won't sleep
+ * but that should not be a problem since tasks are stopped..
+ */
+
+static void do_suspend_sync(void)
+{
+//	sync_dev(0); FIXME
+	while (1) {
+		run_task_queue(&tq_disk);
+		if (!TQ_ACTIVE(tq_disk))
+			break;
+		printk(KERN_ERR "Hm, tq_disk is not empty after run_task_queue\n");
+	}
+}
+
+/* We memorize in swapfile_used what swap devices are used for suspension */
+#define SWAPFILE_UNUSED    0
+#define SWAPFILE_SUSPEND   1	/* This is the suspending device */
+#define SWAPFILE_IGNORED   2	/* Those are other swap devices ignored for suspension */
+
+static unsigned short swapfile_used[MAX_SWAPFILES];
+static unsigned short root_swap;
+#define MARK_SWAP_SUSPEND 0
+#define MARK_SWAP_RESUME 2
+
+static void mark_swapfiles(swp_entry_t prev, int mode)
+{
+	swp_entry_t entry;
+	union diskpage *cur;
+	
+	cur = (union diskpage *)get_free_page(GFP_ATOMIC);
+	if (!cur)
+		panic("Out of memory in mark_swapfiles");
+	/* XXX: this is dirty hack to get first page of swap file */
+	entry = SWP_ENTRY(root_swap, 0);
+	lock_page(virt_to_page((unsigned long)cur));
+	rw_swap_page_nolock(READ, entry, (char *) cur);
+
+	if (mode == MARK_SWAP_RESUME) {
+	  	if (!memcmp("SUSP1R",cur->swh.magic.magic,6))
+		  	memcpy(cur->swh.magic.magic,"SWAP-SPACE",10);
+		else if (!memcmp("SUSP2R",cur->swh.magic.magic,6))
+			memcpy(cur->swh.magic.magic,"SWAPSPACE2",10);
+		else printk("%sUnable to find suspended-data signature (%.10s - misspelled?\n", 
+		      	name_resume, cur->swh.magic.magic);
+	} else {
+	  	if ((!memcmp("SWAP-SPACE",cur->swh.magic.magic,10)))
+		  	memcpy(cur->swh.magic.magic,"SUSP1R....",10);
+		else if ((!memcmp("SWAPSPACE2",cur->swh.magic.magic,10)))
+			memcpy(cur->swh.magic.magic,"SUSP2R....",10);
+		else panic("\nSwapspace is not swapspace (%.10s)\n", cur->swh.magic.magic);
+		cur->link.next = prev; /* prev is the first/last swap page of the resume area */
+		/* link.next lies *no more* in last 4 bytes of magic */
+	}
+	lock_page(virt_to_page((unsigned long)cur));
+	rw_swap_page_nolock(WRITE, entry, (char *)cur);
+	
+	free_page((unsigned long)cur);
+}
+
+static void read_swapfiles(void) /* This is called before saving image */
+{
+	int i, len;
+	
+	len=strlen(resume_file);
+	root_swap = 0xFFFF;
+	
+	swap_list_lock();
+	for(i=0; i<MAX_SWAPFILES; i++) {
+		if (swap_info[i].flags == 0) {
+			swapfile_used[i]=SWAPFILE_UNUSED;
+		} else {
+			if(!len) {
+	    			printk(KERN_WARNING "resume= option should be used to set suspend device" );
+				if(root_swap == 0xFFFF) {
+					swapfile_used[i] = SWAPFILE_SUSPEND;
+					root_swap = i;
+				} else
+					swapfile_used[i] = SWAPFILE_IGNORED;				  
+			} else {
+	  			/* we ignore all swap devices that are not the resume_file */
+				if (1) {
+// FIXME				if(resume_device == swap_info[i].swap_device) {
+					swapfile_used[i] = SWAPFILE_SUSPEND;
+					root_swap = i;
+				} else {
+#if 0
+					PRINTS( "device %s (%x != %x) ignored\n", swap_info[i].swap_file->d_name.name, swap_info[i].swap_device, resume_device );				  
+#endif
+				  	swapfile_used[i] = SWAPFILE_IGNORED;
+				}
+			}
+		}
+	}
+	swap_list_unlock();
+}
+
+static void lock_swapdevices(void) /* This is called after saving image so modification
+				      will be lost after resume... and that's what we want. */
+{
+	int i;
+
+	swap_list_lock();
+	for(i = 0; i< MAX_SWAPFILES; i++)
+		if(swapfile_used[i] == SWAPFILE_IGNORED) {
+//			PRINTS( "device %s locked\n", swap_info[i].swap_file->d_name.name );
+			swap_info[i].flags ^= 0xFF; /* we make the device unusable. A new call to
+						       lock_swapdevices can unlock the devices. */
+		}
+	swap_list_unlock();
+}
+
+kdev_t suspend_device;
+
+static int write_suspend_image(void)
+{
+	int i;
+	swp_entry_t entry, prev = { 0 };
+	int nr_pgdir_pages = SUSPEND_PD_PAGES(nr_copy_pages);
+	union diskpage *cur,  *buffer = (union diskpage *)get_free_page(GFP_ATOMIC);
+	unsigned long address;
+
+	PRINTS( "Writing data to swap (%d pages): ", nr_copy_pages );
+	for (i=0; i<nr_copy_pages; i++) {
+		if (!(i%100))
+			PRINTK( "." );
+		if (!(entry = get_swap_page()).val)
+			panic("\nNot enough swapspace when writing data" );
+		
+		if(swapfile_used[SWP_TYPE(entry)] != SWAPFILE_SUSPEND)
+			panic("\nPage %d: not enough swapspace on suspend device", i );
+	    
+		address = (pagedir_nosave+i)->address;
+		lock_page(virt_to_page(address));
+		{
+			long dummy1, dummy2;
+			get_swaphandle_info(entry, &dummy1, &suspend_device);
+		}
+		rw_swap_page_nolock(WRITE, entry, (char *) address);
+		(pagedir_nosave+i)->swap_address = entry;
+	}
+	PRINTK(" done\n");
+	PRINTS( "Writing pagedir (%d pages): ", nr_pgdir_pages);
+	for (i=0; i<nr_pgdir_pages; i++) {
+		cur = (union diskpage *)((char *) pagedir_nosave)+i;
+		if ((char *) cur != (((char *) pagedir_nosave) + i*PAGE_SIZE))
+			panic("Something is of wrong size");
+		PRINTK( "." );
+		if (!(entry = get_swap_page()).val) {
+			printk(KERN_CRIT "Not enough swapspace when writing pgdir\n" );
+			panic("Don't know how to recover");
+			free_page((unsigned long) buffer);
+			return -ENOSPC;
+		}
+
+		if(swapfile_used[SWP_TYPE(entry)] != SWAPFILE_SUSPEND)
+		  panic("\nNot enough swapspace for pagedir on suspend device" );
+
+		if (sizeof(swp_entry_t) != sizeof(long))
+			panic("I need swp_entry_t to be sizeof long, otherwise next assignment could damage pagedir");
+		if (PAGE_SIZE % sizeof(struct pbe))
+			panic("I need PAGE_SIZE to be integer multiple of struct pbe, otherwise next assignment could damage pagedir");
+		cur->link.next = prev;				
+		lock_page(virt_to_page((unsigned long)cur));
+		rw_swap_page_nolock(WRITE, entry, (char *) cur);
+		prev = entry;
+	}
+	PRINTK(", header");
+	if (sizeof(struct suspend_header) > PAGE_SIZE-sizeof(swp_entry_t))
+		panic("sizeof(struct suspend_header) too big: %d",
+				sizeof(struct suspend_header));
+	if (sizeof(union diskpage) != PAGE_SIZE)
+		panic("union diskpage has bad size");
+	if (!(entry = get_swap_page()).val)
+		panic( "\nNot enough swapspace when writing header" );
+	if(swapfile_used[SWP_TYPE(entry)] != SWAPFILE_SUSPEND)
+	  panic("\nNot enough swapspace for header on suspend device" );
+
+	cur = (void *) buffer;
+	if(fill_suspend_header(&cur->sh))
+		panic("\nOut of memory while writing header");
+		
+	cur->link.next = prev;
+
+	lock_page(virt_to_page((unsigned long)cur));
+	rw_swap_page_nolock(WRITE, entry, (char *) cur);
+	prev = entry;
+
+	PRINTK( ", signature" );
+#if 0
+	if (SWP_TYPE(entry) != 0)
+		panic("Need just one swapfile");
+#endif
+	mark_swapfiles(prev, MARK_SWAP_SUSPEND);
+	PRINTK( ", done\n" );
+
+	MDELAY(1000);
+	free_page((unsigned long) buffer);
+	return 0;
+}
+
+/* if pagedir_p != NULL it also copies the counted pages */
+static int count_and_copy_data_pages(struct pbe *pagedir_p)
+{
+	int chunk_size;
+	int nr_copy_pages = 0;
+	int loop;
+	
+	if (max_mapnr != num_physpages)
+		panic("mapnr is not expected");
+	for(loop = 0; loop < max_mapnr; loop++) {
+		if(PageHighMem(mem_map+loop))
+			panic("No highmem for me, sorry.");
+		if(!PageReserved(mem_map+loop)) {
+			if(PageNosave(mem_map+loop))
+				continue;
+
+			if((chunk_size=is_head_of_free_region(mem_map+loop))!=0) {
+				loop += chunk_size - 1;
+				continue;
+			}
+		} else if(PageReserved(mem_map+loop)) {
+			if(PageNosave(mem_map+loop))
+				panic("What?");
+
+			/*
+			 * Just copy whole code segment. Hopefully it is not that big.
+			 */
+			if (ADDRESS(loop) >= (unsigned long)
+				&__nosave_begin && ADDRESS(loop) < 
+				(unsigned long)&__nosave_end) {
+				printk("[nosave]");
+				continue;
+			}
+			/* Hmm, perhaps copying all reserved pages is not too healthy as they may contain 
+			   critical bios data? */
+		} else panic("No third thing should be possible");
+
+		nr_copy_pages++;
+		if(pagedir_p) {
+			pagedir_p->orig_address = ADDRESS(loop);
+			copy_page(pagedir_p->address, pagedir_p->orig_address);
+			pagedir_p++;
+		}
+	}
+	return nr_copy_pages;
+}
+
+static void free_suspend_pagedir(unsigned long this_pagedir)
+{
+	struct page *page = mem_map;
+	int i;
+	unsigned long this_pagedir_end = this_pagedir +
+		(PAGE_SIZE << pagedir_order);
+
+	for(i=0; i < num_physpages; i++, page++) {
+		if(!TestClearPageNosave(page))
+			continue;
+
+		if(ADDRESS(i) >= this_pagedir && ADDRESS(i) < this_pagedir_end)
+			continue; /* old pagedir gets freed in one */
+		
+		free_page(ADDRESS(i));
+	}
+	free_pages(this_pagedir, pagedir_order);
+}
+
+static suspend_pagedir_t *create_suspend_pagedir(int nr_copy_pages)
+{
+	int i;
+	suspend_pagedir_t *pagedir;
+	struct pbe *p;
+	struct page *page;
+
+	pagedir_order = get_bitmask_order(SUSPEND_PD_PAGES(nr_copy_pages));
+
+	p = pagedir = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+	if(!pagedir)
+		return NULL;
+
+	page = virt_to_page(pagedir);
+	for(i=0; i < 1<<pagedir_order; i++)
+		SetPageNosave(page++);
+		
+	while(nr_copy_pages--) {
+		p->address = get_free_page(GFP_ATOMIC);
+		if(!p->address) {
+			panic("oom");
+			free_suspend_pagedir((unsigned long) pagedir);
+			return NULL;
+		}
+		SetPageNosave(virt_to_page(p->address));
+		p->orig_address = 0;
+		p++;
+	}
+	return pagedir;
+}
+
+static int prepare_suspend_console(void)
+{
+	orig_loglevel = console_loglevel;
+	console_loglevel = new_loglevel;
+
+#ifdef CONFIG_VT
+	orig_fgconsole = fg_console;
+#ifdef SUSPEND_CONSOLE
+	if(vc_allocate(SUSPEND_CONSOLE))
+	  /* we can't have a free VC for now. Too bad,
+	   * we don't want to mess the screen for now. */
+		return 1;
+
+	set_console (SUSPEND_CONSOLE);
+	if(vt_waitactive(SUSPEND_CONSOLE)) {
+		PRINTS("Bummer. Can't switch VCs.");
+		return 1;
+	}
+#endif
+#endif
+	return 0;
+}
+
+static void restore_console(void)
+{
+	console_loglevel = orig_loglevel;
+#ifdef SUSPEND_CONSOLE
+	set_console (orig_fgconsole);
+#endif
+	return;
+}
+
+static int prepare_suspend_processes(void)
+{
+	PRINTS( "Stopping processes\n" );
+	MDELAY(1000);
+	if (freeze_processes()) {
+		PRINTS( "Not all processes stopped!\n" );
+//		panic("Some processes survived?\n");
+		thaw_processes();
+		return 1;
+	}
+	do_suspend_sync();
+	return 0;
+}
+
+/*
+ *	Free as much memory as possible
+ */
+
+static void **eaten_memory;
+
+static void eat_memory(void)
+{
+	int i = 0;
+	void **c= eaten_memory, *m;
+
+	printk("Eating pages ");
+	while ((m = (void *) get_free_page(GFP_HIGHUSER))) {
+		memset(m, 0, PAGE_SIZE);
+		eaten_memory = m;
+		if (!(i%100))
+			printk( ".(%d)", i ); 
+		*eaten_memory = c;
+		c = eaten_memory;
+		i++; 
+#if 1
+	/* 40000 == 160MB */
+	/* 10000 for 64MB */
+	/* 2500 for  16MB */
+		if (i > 40000)
+			break;
+#endif
+	}
+	printk("(%dK)\n", i*4);
+}
+
+static void free_memory(void)
+{
+	int i = 0;
+	void **c = eaten_memory, *f;
+	
+	printk( "Freeing pages " );
+	while (c) {
+		if (!(i%5000))
+		printk( "." ); 
+		f = *c;
+		c = *c;
+		if (f) { free_page( (long) f ); i++; }
+	}
+	printk( "(%dK)\n", i*4 );
+	eaten_memory = NULL;
+}
+
+/*
+ * Try to free as much memory as possible, but do not OOM-kill anyone
+ *
+ * Notice: all userland should be stopped at this point, or livelock is possible.
+ */
+static void free_some_memory(void)
+{
+#if 1
+	PRINTS("Freeing memory: ");
+	while (try_to_free_pages(&contig_page_data.node_zones[ZONE_HIGHMEM], GFP_KSWAPD, 0))
+		printk(".");
+	printk("\n");
+#else
+	printk("Using memeat\n");
+	eat_memory();
+	free_memory();
+#endif
+}
+
+/* Make disk drivers accept operations, again */
+static void drivers_unsuspend(void)
+{
+	device_resume(RESUME_ENABLE);
+	device_resume(RESUME_RESTORE_STATE);
+}
+
+/* Called from process context */
+static int drivers_suspend(void)
+{
+	device_suspend(4, SUSPEND_NOTIFY);
+	device_suspend(4, SUSPEND_SAVE_STATE);
+	device_suspend(4, SUSPEND_DISABLE);
+	if(!pm_suspend_state) {
+		if(pm_send_all(PM_SUSPEND,(void *)3)) {
+			printk(KERN_WARNING "Problem while sending suspend event\n");
+			return(1);
+		}
+		pm_suspend_state=1;
+	} else
+		printk(KERN_WARNING "PM suspend state already raised\n");
+	  
+	return(0);
+}
+
+#define RESUME_PHASE1 1 /* Called from interrupts disabled */
+#define RESUME_PHASE2 2 /* Called with interrupts enabled */
+#define RESUME_ALL_PHASES (RESUME_PHASE1 | RESUME_PHASE2)
+static void drivers_resume(int flags)
+{
+	device_resume(RESUME_ENABLE);
+	device_resume(RESUME_RESTORE_STATE);
+  	if(flags & RESUME_PHASE2) {
+		if(pm_suspend_state) {
+			if(pm_send_all(PM_RESUME,(void *)0))
+				printk(KERN_WARNING "Problem while sending resume event\n");
+			pm_suspend_state=0;
+		} else
+			printk(KERN_WARNING "PM suspend state wasn't raised\n");
+
+#ifdef SUSPEND_CONSOLE
+		update_screen(fg_console);	/* Hmm, is this the problem? */
+#endif
+	}
+}
+
+static int suspend_save_image(void)
+{
+	struct sysinfo i;
+	unsigned int nr_needed_pages = 0;
+
+	pagedir_nosave = NULL;
+	PRINTS( "/critical section: Counting pages to copy" );
+	nr_copy_pages = count_and_copy_data_pages(NULL);
+	nr_needed_pages = nr_copy_pages + PAGES_FOR_IO;
+	
+	PRINTK(" (pages needed: %d+%d=%d free: %d)\n",nr_copy_pages,PAGES_FOR_IO,nr_needed_pages,nr_free_pages());
+	if(nr_free_pages() < nr_needed_pages) {
+		printk(KERN_CRIT "%sCouldn't get enough free pages, on %d pages short\n",
+		       name_suspend, nr_needed_pages-nr_free_pages());
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+	si_swapinfo(&i);	/* FIXME: si_swapinfo(&i) returns all swap devices information.
+				   We should only consider resume_device. */
+	if (i.freeswap < nr_needed_pages)  {
+		printk(KERN_CRIT "%sThere's not enough swap space available, on %ld pages short\n",
+		       name_suspend, nr_needed_pages-i.freeswap);
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+
+	PRINTK( "Alloc pagedir\n" ); 
+	pagedir_save = pagedir_nosave = create_suspend_pagedir(nr_copy_pages);
+	if(!pagedir_nosave) {
+		/* Shouldn't happen */
+		printk(KERN_CRIT "%sCouldn't allocate enough pages\n",name_suspend);
+		panic("Really should not happen");
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+	nr_copy_pages_check = nr_copy_pages;
+	pagedir_order_check = pagedir_order;
+
+	if (nr_copy_pages != count_and_copy_data_pages(pagedir_nosave))	/* copy */
+		panic("Count and copy returned another count than when counting?\n");
+
+	/*
+	 * End of critical section. From now on, we can write to memory,
+	 * but we should not touch disk. This specially means we must _not_
+	 * touch swap space! Except we must write out our image of course.
+	 *
+	 * Following line enforces not writing to disk until we choose.
+	 */
+	suspend_device = NODEV;					/* We do not want any writes, thanx */
+	drivers_unsuspend();
+	spin_unlock_irq(&suspend_pagedir_lock);
+	PRINTS( "critical section/: done (%d pages copied)\n", nr_copy_pages );
+
+	lock_swapdevices();
+	write_suspend_image();
+	lock_swapdevices();	/* This will unlock ignored swap devices since writing is finished */
+
+	/* Image is saved, call sync & restart machine */
+	PRINTS( "Syncing disks\n" );
+	/* It is important _NOT_ to umount filesystems at this point. We want
+	 * them synced (in case something goes wrong) but we DO not want to mark
+	 * filesystem clean: it is not. (And it does not matter, if we resume
+	 * correctly, we'll mark system clean, anyway.)
+	 */
+	return 0;
+}
+
+void suspend_power_down(void)
+{
+	C_A_D = 0;
+	printk(KERN_EMERG "%sTrying to power down.\n", name_suspend);
+#ifdef CONFIG_VT
+	printk(KERN_EMERG "shift_state: %04x\n", shift_state);
+	mdelay(1000);
+	if (TEST_SWSUSP ^ (!!(shift_state & (1 << KG_CTRL))))
+		machine_restart(NULL);
+	else
+#endif
+		machine_power_off();
+
+	printk(KERN_EMERG "%sProbably not capable for powerdown. System halted.\n", name_suspend);
+	machine_halt();
+	while (1);
+	/* NOTREACHED */
+}
+
+/* forward decl */
+void do_software_suspend(void);
+
+/*
+ * Magic happens here
+ */
+
+static void do_magic_resume_1(void)
+{
+	barrier();
+	mb();
+	spin_lock_irq(&suspend_pagedir_lock);	/* Done to disable interrupts */ 
+
+	printk( "Waiting for DMAs to settle down...\n");
+	mdelay(1000);	/* We do not want some readahead with DMA to corrupt our memory, right?
+			   Do it with disabled interrupts for best effect. That way, if some
+			   driver scheduled DMA, we have good chance for DMA to finish ;-). */
+}
+
+static void do_magic_resume_2(void)
+{
+	if (nr_copy_pages_check != nr_copy_pages)
+		panic("nr_copy_pages changed?!");
+	if (pagedir_order_check != pagedir_order)
+		panic("pagedir_order changed?!");
+
+	PRINTR( "Freeing prev allocated pagedir\n" );
+	free_suspend_pagedir(pagedir_save);
+	__flush_tlb_global();		/* Even mappings of "global" things (vmalloc) need to be fixed */
+	drivers_resume(RESUME_ALL_PHASES);
+	spin_unlock_irq(&suspend_pagedir_lock);
+
+	PRINTK( "Fixing swap signatures... " );
+	mark_swapfiles(((swp_entry_t) {0}), MARK_SWAP_RESUME);
+	PRINTK( "ok\n" );
+
+#ifdef SUSPEND_CONSOLE
+	update_screen(fg_console);	/* Hmm, is this the problem? */
+#endif
+	suspend_tq.routine = (void *)do_software_suspend;
+}
+
+static void do_magic_suspend_1(void)
+{
+	mb();
+	barrier();
+	spin_lock_irq(&suspend_pagedir_lock);
+}
+
+static void do_magic_suspend_2(void)
+{
+	read_swapfiles();
+	if (!suspend_save_image()) {
+#if 1
+		suspend_power_down ();	/* FIXME: if suspend_power_down is commented out, console is lost after few suspends ?! */
+#endif
+	}
+
+	suspend_device = NODEV;
+	printk(KERN_WARNING "%sSuspend failed, trying to recover...\n", name_suspend);
+	MDELAY(1000); /* So user can wait and report us messages if armageddon comes :-) */
+
+	barrier();
+	mb();
+	drivers_resume(RESUME_PHASE2);
+	spin_lock_irq(&suspend_pagedir_lock);	/* Done to disable interrupts */ 
+	mdelay(1000);
+
+	free_pages((unsigned long) pagedir_nosave, pagedir_order);
+	drivers_resume(RESUME_PHASE1);
+	spin_unlock_irq(&suspend_pagedir_lock);
+	mark_swapfiles(((swp_entry_t) {0}), MARK_SWAP_RESUME);
+	suspend_tq.routine = (void *)do_software_suspend;
+	printk(KERN_WARNING "%sLeaving do_magic_suspend_2...\n", name_suspend);	
+}
+
+#define SUSPEND_C
+#include <asm/suspend.h>
+
+/*
+ * This function is triggered using process bdflush. We try to swap out as
+ * much as we can then make a copy of the occupied pages in memory so we can
+ * make a copy of kernel state atomically, the I/O needed by saving won't
+ * bother us anymore.
+ */
+void do_software_suspend(void)
+{
+	arch_prepare_suspend();
+	if (!prepare_suspend_console()) {
+		if (!prepare_suspend_processes()) {
+			free_some_memory();
+
+			/* No need to invalidate any vfsmnt list -- they will be valid after resume, anyway.
+			 *
+			 * We sync here -- so you have consistent filesystem state when things go wrong.
+			 * -- so that noone writes to disk after we do atomic copy of data.
+			 */
+			PRINTS( "Syncing disks before copy\n" );
+			do_suspend_sync();
+			drivers_suspend();
+			if(drivers_suspend()==0)
+				do_magic(0);			/* This function returns after machine woken up from resume */
+			PRINTR("Restarting processes...\n");
+			thaw_processes();
+		}
+	}
+	software_suspend_enabled = 1;
+	MDELAY(1000);
+	restore_console ();
+}
+
+struct tq_struct suspend_tq =
+	{ routine: (void *)(void *)do_software_suspend, 
+	  data: 0 };
+
+/*
+ * This is the trigger function, we must queue ourself since we
+ * can be called from interrupt && bdflush context is needed
+ */
+void software_suspend(void)
+{
+	if(!software_suspend_enabled)
+		return;
+
+	software_suspend_enabled = 0;
+	queue_task(&suspend_tq, &tq_bdflush);
+	wakeup_bdflush();
+}
+
+/* More restore stuff */
+
+/* FIXME: Why not memcpy(to, from, 1<<pagedir_order*PAGE_SIZE)? */
+static void copy_pagedir(suspend_pagedir_t *to, suspend_pagedir_t *from)
+{
+	int i;
+	char *topointer=(char *)to, *frompointer=(char *)from;
+
+	for(i=0; i < 1 << pagedir_order; i++) {
+		copy_page(topointer, frompointer);
+		topointer += PAGE_SIZE;
+		frompointer += PAGE_SIZE;
+	}
+}
+
+#define does_collide(addr)	\
+		does_collide_order(pagedir_nosave, addr, 0)
+
+/*
+ * Returns true if given address/order collides with any orig_address 
+ */
+static int does_collide_order(suspend_pagedir_t *pagedir, unsigned long addr,
+		int order)
+{
+	int i;
+	unsigned long addre = addr + (PAGE_SIZE<<order);
+	
+	for(i=0; i < nr_copy_pages; i++)
+		if((pagedir+i)->orig_address >= addr &&
+			(pagedir+i)->orig_address < addre)
+			return 1;
+
+	return 0;
+}
+
+/*
+ * We check here that pagedir & pages it points to won't collide with pages
+ * where we're going to restore from the loaded pages later
+ */
+
+static int check_pagedir(void)
+{
+	int i;
+
+	for(i=0; i < nr_copy_pages; i++) {
+		unsigned long addr;
+
+		do {
+			addr = get_free_page(GFP_ATOMIC);
+			if(!addr)
+				return -ENOMEM;
+		} while (does_collide(addr));
+
+		(pagedir_nosave+i)->address = addr;
+	}
+	return 0;
+}
+
+static int relocate_pagedir(void)
+{
+	/* This is deep magic
+	   We have to avoid recursion (not to overflow kernel stack), and that's why
+	   code looks pretty cryptic
+	*/
+	suspend_pagedir_t *new_pagedir, *old_pagedir = pagedir_nosave;
+	void **eaten_memory = NULL;
+	void **c = eaten_memory, *m, *f;
+
+
+	if(!does_collide_order(old_pagedir, (unsigned long)old_pagedir, pagedir_order)) {
+		printk("not neccessary\n");
+		return 0;
+	}
+
+	while ((m = (void *) __get_free_pages(GFP_ATOMIC, pagedir_order))) {
+		memset(m, 0, PAGE_SIZE);
+		if (!does_collide_order(old_pagedir, (unsigned long)m, pagedir_order))
+			break;
+		eaten_memory = m;
+		printk( "." ); 
+		*eaten_memory = c;
+		c = eaten_memory;
+	}
+
+	if (!m)
+		return -ENOMEM;
+
+	pagedir_nosave = new_pagedir = m;
+	copy_pagedir(new_pagedir, old_pagedir);
+
+	c = eaten_memory;
+	while(c) {
+		printk(":");
+		f = *c;
+		c = *c;
+		if (f)
+			free_pages((unsigned long)f, pagedir_order);
+	}
+	printk("okay\n");
+	return 0;
+}
+
+/*
+ * Sanity check if this image makes sense with this kernel/swap context
+ * I really don't think that it's foolproof but more than nothing..
+ */
+
+static int sanity_check_failed(char *reason)
+{
+	printk(KERN_ERR "%s%s\n",name_resume,reason);
+	return -EPERM;
+}
+
+static int sanity_check(struct suspend_header *sh)
+{
+	if(sh->version_code != LINUX_VERSION_CODE)
+		return sanity_check_failed("Incorrect kernel version");
+	if(sh->num_physpages != num_physpages)
+		return sanity_check_failed("Incorrect memory size");
+	if(strncmp(sh->machine, system_utsname.machine, 8))
+		return sanity_check_failed("Incorrect machine type");
+	if(strncmp(sh->version, system_utsname.version, 20))
+		return sanity_check_failed("Incorrect version");
+	if(sh->num_cpus != smp_num_cpus)
+		return sanity_check_failed("Incorrect number of cpus");
+	if(sh->page_size != PAGE_SIZE)
+		return sanity_check_failed("Incorrect PAGE_SIZE");
+	return 0;
+}
+
+static int bdev_read_page(kdev_t dev, long pos, void *buf)
+{
+	struct buffer_head *bh;
+	struct block_device *bdev;
+
+	if (pos%PAGE_SIZE) panic("Sorry, dave, I can't let you do that!\n");
+	bdev = bdget(kdev_t_to_nr(dev));
+	blkdev_get(bdev, FMODE_READ, O_RDONLY, BDEV_RAW);
+	if (!bdev) {
+		printk("No block device for %s\n", __bdevname(dev));
+		BUG();
+	}
+	set_blocksize(bdev, PAGE_SIZE);
+	bh = __bread(bdev, pos/PAGE_SIZE, PAGE_SIZE);
+	if (!bh || (!bh->b_data)) {
+		return -1;
+	}
+	memcpy(buf, bh->b_data, PAGE_SIZE);	/* FIXME: may need kmap() */
+	BUG_ON(!buffer_uptodate(bh));
+	brelse(bh);
+	blkdev_put(bdev, BDEV_RAW);
+	return 0;
+} 
+
+extern kdev_t __init name_to_kdev_t(char *line);
+
+static int resume_try_to_read(const char * specialfile, int noresume)
+{
+	union diskpage *cur;
+	swp_entry_t next;
+	int i, nr_pgdir_pages, error;
+	int blksize = 0;
+
+	resume_device = name_to_kdev_t(specialfile);
+	cur = (void *) get_free_page(GFP_ATOMIC);
+	if (!cur) {
+		printk( "%sNot enough memory?\n", name_resume );
+		error = -ENOMEM;
+		goto resume_read_error;
+	}
+
+	printk("Resuming from device %x\n", resume_device);
+
+#define READTO(pos, ptr) \
+	if (bdev_read_page(resume_device, pos, ptr)) { error = -EIO; goto resume_read_error; }
+#define PREPARENEXT \
+	{	next = cur->link.next; \
+		next.val = SWP_OFFSET(next) * PAGE_SIZE; \
+        }
+
+	error = -EIO;
+	READTO(0, cur);
+
+	if ((!memcmp("SWAP-SPACE",cur->swh.magic.magic,10)) ||
+	    (!memcmp("SWAPSPACE2",cur->swh.magic.magic,10))) {
+		printk(KERN_ERR "%sThis is normal swap space\n", name_resume );
+		error = -EINVAL;
+		goto resume_read_error;
+	}
+
+	PREPARENEXT; /* We have to read next position before we overwrite it */
+
+	if (!memcmp("SUSP1R",cur->swh.magic.magic,6))
+		memcpy(cur->swh.magic.magic,"SWAP-SPACE",10);
+	else if (!memcmp("SUSP2R",cur->swh.magic.magic,6))
+		memcpy(cur->swh.magic.magic,"SWAPSPACE2",10);
+	else {
+		panic("%sUnable to find suspended-data signature (%.10s - misspelled?\n", 
+			name_resume, cur->swh.magic.magic);
+	}
+	printk( "%sSignature found, resuming\n", name_resume );
+	MDELAY(1000);
+
+	READTO(next.val, cur);
+
+	error = -EPERM;
+	if (sanity_check(&cur->sh))
+		goto resume_read_error;
+
+	/* Probably this is the same machine */	
+
+	PREPARENEXT;
+
+	pagedir_save = cur->sh.suspend_pagedir;
+	nr_copy_pages = cur->sh.num_pbes;
+	nr_pgdir_pages = SUSPEND_PD_PAGES(nr_copy_pages);
+	pagedir_order = get_bitmask_order(nr_pgdir_pages);
+
+	error = -ENOMEM;
+	pagedir_nosave = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+	if(!pagedir_nosave)
+		goto resume_read_error;
+
+	PRINTR( "%sReading pagedir, ", name_resume );
+
+	/* We get pages in reverse order of saving! */
+	error=-EIO;
+	for (i=nr_pgdir_pages-1; i>=0; i--) {
+		if (!next.val)
+			panic( "Preliminary end of suspended data?" );
+		cur = (union diskpage *)((char *) pagedir_nosave)+i;
+		READTO(next.val, cur);
+		PREPARENEXT;
+	}
+	if (next.val)
+		panic( "Suspended data too long?" );
+
+	printk("Relocating pagedir");
+	if((error=relocate_pagedir())!=0)
+		goto resume_read_error;
+	if((error=check_pagedir())!=0)
+		goto resume_read_error;
+
+	PRINTK( "image data (%d pages): ", nr_copy_pages );
+	error = -EIO;
+	for(i=0; i < nr_copy_pages; i++) {
+		swp_entry_t swap_address = (pagedir_nosave+i)->swap_address;
+		if (!(i%100))
+			PRINTK( "." );
+		next.val = SWP_OFFSET (swap_address) * PAGE_SIZE;
+		/* You do not need to check for overlaps...
+		   ... check_pagedir already did this work */
+		READTO(next.val, (char *)((pagedir_nosave+i)->address));
+	}
+	PRINTK( " done\n" );
+	error = 0;
+
+resume_read_error:
+	switch (error) {
+		case 0:
+			PRINTR("Reading resume file was successful\n");
+			break;
+		case -EINVAL:
+			break;
+		case -EIO:
+			printk( "%sI/O error\n", name_resume);
+			panic("Wanted to resume but it did not work\n");
+			break;
+		case -ENOENT:
+			printk( "%s%s: No such file or directory\n", name_resume, specialfile);
+			panic("Wanted to resume but it did not work\n");
+			break;
+		default:
+			printk( "%sError %d resuming\n", name_resume, error );
+			panic("Wanted to resume but it did not work\n");
+	}
+	MDELAY(1000);
+	return error;
+}
+
+/*
+ * Called from init kernel_thread.
+ * We check if we have an image and if so we try to resume
+ */
+
+void software_resume(void)
+{
+#ifdef CONFIG_SMP
+	printk(KERN_WARNING "Software Suspend has a malfunctioning SMP support. Disabled :(\n");
+#else
+	/* We enable the possibility of machine suspend */
+	software_suspend_enabled = 1;
+#endif
+	if(!resume_status)
+		return;
+
+	printk( "%s", name_resume );
+	if(resume_status == NORESUME) {
+		/* FIXME: Signature should be restored here */
+		printk( "disabled\n" );
+		return;
+	}
+	MDELAY(1000);
+
+	orig_loglevel = console_loglevel;
+	console_loglevel = new_loglevel;
+
+	if(!resume_file[0] && resume_status == RESUME_SPECIFIED) {
+		printk( "nowhere to resume from\n" );
+		return;
+	}
+
+	printk( "resuming from %s\n", resume_file);
+	if(resume_try_to_read(resume_file, 0))
+		goto read_failure;
+	do_magic(1);
+	panic("This never returns");
+
+read_failure:
+	console_loglevel = orig_loglevel;
+	return;
+}
+
+static int __init resume_setup(char *str)
+{
+	if(resume_status)
+		return 1;
+
+	strncpy( resume_file, str, 255 );
+	resume_status = RESUME_SPECIFIED;
+
+	return 1;
+}
+
+static int __init software_noresume(char *str)
+{
+	if(!resume_status)
+		printk(KERN_WARNING "noresume option lacks a resume= option\n");
+	resume_status = NORESUME;
+	
+	return 1;
+}
+
+__setup("noresume", software_noresume);
+__setup("resume=", resume_setup);
+
+EXPORT_SYMBOL(software_suspend);
+EXPORT_SYMBOL(software_suspend_enabled);
+EXPORT_SYMBOL(refrigerator);
diff --git a/kernel/sys.c b/kernel/sys.c
index 143a77fedd7a..3bd38f344817 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -4,6 +4,7 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
+#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/utsname.h>
@@ -347,6 +348,16 @@ asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void * arg)
 		machine_restart(buffer);
 		break;
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	case LINUX_REBOOT_CMD_SW_SUSPEND:
+		if(!software_suspend_enabled)
+			return -EAGAIN;
+		
+		software_suspend();
+		do_exit(0);
+		break;
+#endif
+
 	default:
 		unlock_kernel();
 		return -EINVAL;
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 82e86a0c4d9a..592d8c9f48bb 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -22,6 +22,7 @@
 #include <linux/slab.h>
 #include <linux/compiler.h>
 #include <linux/module.h>
+#include <linux/suspend.h>
 
 unsigned long totalram_pages;
 unsigned long totalhigh_pages;
@@ -247,6 +248,46 @@ static struct page * rmqueue(zone_t *zone, unsigned int order)
 	return NULL;
 }
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+int is_head_of_free_region(struct page *p)
+{
+	pg_data_t *pgdat = pgdat_list;
+	unsigned type;
+	unsigned long flags;
+
+	for (type=0;type < MAX_NR_ZONES; type++) {
+		zone_t *zone = pgdat->node_zones + type;
+		int order = MAX_ORDER - 1;
+		free_area_t *area;
+		struct list_head *head, *curr;
+		spin_lock_irqsave(&zone->lock, flags);	/* Should not matter as we need quiescent system for suspend anyway, but... */
+
+		do {
+			area = zone->free_area + order;
+			head = &area->free_list;
+			curr = head;
+
+			for(;;) {
+				if(!curr) {
+//					printk("FIXME: this should not happen but it does!!!");
+					break;
+				}
+				if(p != memlist_entry(curr, struct page, list)) {
+					curr = memlist_next(curr);
+					if (curr == head)
+						break;
+					continue;
+				}
+				return 1 << order;
+			}
+		} while(order--);
+		spin_unlock_irqrestore(&zone->lock, flags);
+
+	}
+	return 0;
+}
+#endif /* CONFIG_SOFTWARE_SUSPEND */
+
 #ifndef CONFIG_DISCONTIGMEM
 struct page *_alloc_pages(unsigned int gfp_mask, unsigned int order)
 {
diff --git a/mm/page_io.c b/mm/page_io.c
index 85bb9049ee0f..3501f87b09fb 100644
--- a/mm/page_io.c
+++ b/mm/page_io.c
@@ -86,12 +86,16 @@ static int rw_swap_page_base(int rw, swp_entry_t entry, struct page *page)
  *  - it's marked as being swap-cache
  *  - it's associated with the swap inode
  */
+extern long suspend_device;
 void rw_swap_page(int rw, struct page *page)
 {
 	swp_entry_t entry;
 
 	entry.val = page->index;
 
+	if (suspend_device)
+		panic("I refuse to corrupt memory/swap.");
+
 	if (!PageLocked(page))
 		PAGE_BUG(page);
 	if (!PageSwapCache(page))
diff --git a/mm/pdflush.c b/mm/pdflush.c
index 5e7d0125c39d..44d292959a19 100644
--- a/mm/pdflush.c
+++ b/mm/pdflush.c
@@ -14,6 +14,7 @@
 #include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/suspend.h>
 
 
 /*
@@ -96,7 +97,7 @@ static int __pdflush(struct pdflush_work *my_work)
 	recalc_sigpending();
 	spin_unlock_irq(&current->sigmask_lock);
 
-	current->flags |= PF_FLUSHER;
+	current->flags |= PF_FLUSHER | PF_KERNTHREAD;
 	my_work->fn = NULL;
 	my_work->who = current;
 
@@ -107,15 +108,21 @@ static int __pdflush(struct pdflush_work *my_work)
 	for ( ; ; ) {
 		struct pdflush_work *pdf;
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+		run_task_queue(&tq_bdflush);
+#endif
 		list_add(&my_work->list, &pdflush_list);
 		my_work->when_i_went_to_sleep = jiffies;
 		set_current_state(TASK_INTERRUPTIBLE);
 		spin_unlock_irq(&pdflush_lock);
 
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
 		schedule();
 
 		preempt_enable();
-		(*my_work->fn)(my_work->arg0);
+		if (my_work->fn)
+			(*my_work->fn)(my_work->arg0);
 		preempt_disable();
 
 		/*
@@ -146,6 +153,7 @@ static int __pdflush(struct pdflush_work *my_work)
 			pdf->when_i_went_to_sleep = jiffies;	/* Limit exit rate */
 			break;					/* exeunt */
 		}
+		my_work->fn = NULL;
 	}
 	nr_pdflush_threads--;
 //	printk("pdflush %d [%d] ends\n", nr_pdflush_threads, current->pid);
diff --git a/mm/vmscan.c b/mm/vmscan.c
index c4ef073b682e..e26168f2d3b8 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -23,6 +23,7 @@
 #include <linux/file.h>
 #include <linux/writeback.h>
 #include <linux/compiler.h>
+#include <linux/suspend.h>
 
 #include <asm/pgalloc.h>
 #include <asm/tlbflush.h>
@@ -781,18 +782,22 @@ int kswapd(void *unused)
 	 * us from recursively trying to free more memory as we're
 	 * trying to free the first piece of memory in the first place).
 	 */
-	tsk->flags |= PF_MEMALLOC;
+	tsk->flags |= PF_MEMALLOC | PF_KERNTHREAD;
 
 	/*
 	 * Kswapd main loop.
 	 */
 	for (;;) {
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
 		__set_current_state(TASK_INTERRUPTIBLE);
 		add_wait_queue(&kswapd_wait, &wait);
 
 		mb();
-		if (kswapd_can_sleep())
+		if (kswapd_can_sleep()) {
 			schedule();
+		}
+		
 
 		__set_current_state(TASK_RUNNING);
 		remove_wait_queue(&kswapd_wait, &wait);
-- 
cgit v1.2.3


From 8e93dcc872459a0601273631848ccc3f319af02f Mon Sep 17 00:00:00 2001
From: Pavel Machek <pavel@ucw.cz>
Date: Tue, 21 May 2002 03:20:42 -0700
Subject: [PATCH] more suspend-to-{RAM,disk} fixes

One more build fix, this time for !CONFIG_SOFTWARE_SUSPEND but
CONFIG_ACPI:

I've choosen this solution for now, as it is safest for ACPI people.
I'll modify suspend.c so that freezing part can be included without
whole suspend-to-disk support being included.
---
 drivers/acpi/acpi_system.c | 1 +
 include/linux/suspend.h    | 2 ++
 2 files changed, 3 insertions(+)

(limited to 'include/linux')

diff --git a/drivers/acpi/acpi_system.c b/drivers/acpi/acpi_system.c
index 3977d77a32ef..4a533803cff6 100644
--- a/drivers/acpi/acpi_system.c
+++ b/drivers/acpi/acpi_system.c
@@ -34,6 +34,7 @@
 #include <linux/sysrq.h>
 #include <linux/pm.h>
 #include <linux/device.h>
+#include <linux/suspend.h>
 #include <asm/uaccess.h>
 #include <asm/acpi.h>
 #include "acpi_bus.h"
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 6de78341c4fc..3ede8ad27270 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -60,6 +60,8 @@ extern void refrigerator(unsigned long);
 #define register_suspend_notifier(a)	do { } while(0)
 #define unregister_suspend_notifier(a)	do { } while(0)
 #define refrigerator(a)			do { BUG(); } while(0)
+#define freeze_processes()		do { panic("You need CONFIG_SOFTWARE_SUSPEND to do sleeps."); } while(0)
+#define thaw_processes()		do { } while(0)
 #endif
 
 #endif /* _LINUX_SWSUSP_H */
-- 
cgit v1.2.3


From 79eb6a126211dc1cbb20f16f67bad69afa2f9703 Mon Sep 17 00:00:00 2001
From: Robert Love <rml@tech9.net>
Date: Tue, 21 May 2002 03:21:43 -0700
Subject: [PATCH] get/put_cpu methods

This implements a get_cpu() and matching put_cpu() to safely hand out
the current CPU to avoid preempt races.  Andrew and I have been bitching
about the need for such a method.

I also went ahead and replaced an example of current explicit
preempt-off with the new methods, as a case in point.
---
 Documentation/preempt-locking.txt | 2 ++
 include/linux/smp.h               | 8 ++++++--
 mm/page-writeback.c               | 7 +++----
 3 files changed, 11 insertions(+), 6 deletions(-)

(limited to 'include/linux')

diff --git a/Documentation/preempt-locking.txt b/Documentation/preempt-locking.txt
index 08e2b4719a23..a9eac1c15718 100644
--- a/Documentation/preempt-locking.txt
+++ b/Documentation/preempt-locking.txt
@@ -31,6 +31,8 @@ require it otherwise.  Second, when a preempted task is finally rescheduled,
 the previous value of smp_processor_id may not equal the current.  You must
 protect these situations by disabling preemption around them.
 
+You can also use put_cpu() and get_cpu(), which will disable preemption.
+
 
 RULE #2: CPU state must be protected.
 
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 85c6273694c9..b61435d369c8 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -96,5 +96,9 @@ static inline void smp_send_reschedule_all(void) { }
 #define per_cpu(var, cpu)			var
 #define this_cpu(var)				var
 
-#endif
-#endif
+#endif /* !SMP */
+
+#define get_cpu()	({ preempt_disable(); smp_processor_id(); })
+#define put_cpu()	preempt_enable()
+
+#endif /* __LINUX_SMP_H */
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 725a4bdb60e1..3918260b0c6a 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -117,15 +117,14 @@ void balance_dirty_pages_ratelimited(struct address_space *mapping)
 	} ____cacheline_aligned ratelimits[NR_CPUS];
 	int cpu;
 
-	preempt_disable();
-	cpu = smp_processor_id();
+	cpu = get_cpu();
 	if (ratelimits[cpu].count++ >= 1000) {
 		ratelimits[cpu].count = 0;
-		preempt_enable();
+		put_cpu();
 		balance_dirty_pages(mapping);
 		return;
 	}
-	preempt_enable();
+	put_cpu();
 }
 
 /*
-- 
cgit v1.2.3


From 1d13173b7c576c8ce31c5c30ddd766e27a9d8070 Mon Sep 17 00:00:00 2001
From: Alexander Viro <viro@math.psu.edu>
Date: Tue, 21 May 2002 21:12:28 -0700
Subject: [PATCH] add proper ->getattr()

 add proper ->getattr(), clean up do_getattr() and friends.
---
 fs/bad_inode.c          |  1 +
 fs/minix/file.c         |  1 +
 fs/minix/inode.c        | 19 +++++++++++++-
 fs/minix/itree_common.c | 15 +++++++++++
 fs/minix/itree_v1.c     |  5 ++++
 fs/minix/itree_v2.c     |  5 ++++
 fs/minix/minix.h        |  5 ++++
 fs/minix/namei.c        |  1 +
 fs/stat.c               | 70 ++++++++++++++++++-------------------------------
 fs/sysv/file.c          |  1 +
 fs/sysv/inode.c         |  1 +
 fs/sysv/itree.c         | 24 +++++++++++++++++
 fs/sysv/namei.c         |  1 +
 fs/sysv/sysv.h          |  1 +
 include/linux/fs.h      |  3 ++-
 kernel/ksyms.c          |  1 +
 16 files changed, 107 insertions(+), 47 deletions(-)

(limited to 'include/linux')

diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index ce59d5fdb3d6..f0c215c4a4e2 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -61,6 +61,7 @@ struct inode_operations bad_inode_ops =
 	truncate:	EIO_ERROR,
 	permission:	EIO_ERROR,
 	revalidate:	EIO_ERROR,
+	getattr:	EIO_ERROR,
 };
 
 
diff --git a/fs/minix/file.c b/fs/minix/file.c
index c9ac58fe9872..7c409043b4eb 100644
--- a/fs/minix/file.c
+++ b/fs/minix/file.c
@@ -24,6 +24,7 @@ struct file_operations minix_file_operations = {
 
 struct inode_operations minix_file_inode_operations = {
 	truncate:	minix_truncate,
+	getattr:	minix_getattr,
 };
 
 int minix_sync_file(struct file * file, struct dentry *dentry, int datasync)
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index c8d490c5d24f..7ed5c3418b81 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -340,6 +340,12 @@ static struct address_space_operations minix_aops = {
 	bmap: minix_bmap
 };
 
+static struct inode_operations minix_symlink_inode_operations = {
+	readlink:	page_readlink,
+	follow_link:	page_follow_link,
+	getattr:	minix_getattr,
+};
+
 void minix_set_inode(struct inode *inode, dev_t rdev)
 {
 	if (S_ISREG(inode->i_mode)) {
@@ -351,7 +357,7 @@ void minix_set_inode(struct inode *inode, dev_t rdev)
 		inode->i_fop = &minix_dir_operations;
 		inode->i_mapping->a_ops = &minix_aops;
 	} else if (S_ISLNK(inode->i_mode)) {
-		inode->i_op = &page_symlink_inode_operations;
+		inode->i_op = &minix_symlink_inode_operations;
 		inode->i_mapping->a_ops = &minix_aops;
 	} else
 		init_special_inode(inode, inode->i_mode, rdev);
@@ -518,6 +524,17 @@ int minix_sync_inode(struct inode * inode)
 	return err;
 }
 
+int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	generic_fillattr(dentry->d_inode, stat);
+	if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
+		stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size);
+	else
+		stat->blocks = (BLOCK_SIZE / 512) * V2_minix_blocks(stat->size);
+	stat->blksize = BLOCK_SIZE;
+	return 0;
+}
+
 /*
  * The function that is called for file truncation.
  */
diff --git a/fs/minix/itree_common.c b/fs/minix/itree_common.c
index d29b326f7bd0..f8e9bd831c90 100644
--- a/fs/minix/itree_common.c
+++ b/fs/minix/itree_common.c
@@ -345,3 +345,18 @@ do_indirects:
 	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 	mark_inode_dirty(inode);
 }
+
+static inline unsigned nblocks(loff_t size)
+{
+	unsigned blocks, res, direct = DIRECT, i = DEPTH;
+	blocks = (size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
+	res = blocks;
+	while (--i && blocks > direct) {
+		blocks -= direct;
+		blocks += BLOCK_SIZE/sizeof(block_t) - 1;
+		blocks /= BLOCK_SIZE/sizeof(block_t);
+		res += blocks;
+		direct = 1;
+	}
+	return blocks;
+}
diff --git a/fs/minix/itree_v1.c b/fs/minix/itree_v1.c
index 26216b80ab5a..79613dc7c425 100644
--- a/fs/minix/itree_v1.c
+++ b/fs/minix/itree_v1.c
@@ -53,3 +53,8 @@ void V1_minix_truncate(struct inode * inode)
 {
 	truncate(inode);
 }
+
+unsigned V1_minix_blocks(loff_t size)
+{
+	return nblocks(size);
+}
diff --git a/fs/minix/itree_v2.c b/fs/minix/itree_v2.c
index 732a878b1e4c..c3b35ce5ff0a 100644
--- a/fs/minix/itree_v2.c
+++ b/fs/minix/itree_v2.c
@@ -58,3 +58,8 @@ void V2_minix_truncate(struct inode * inode)
 {
 	truncate(inode);
 }
+
+unsigned V2_minix_blocks(loff_t size)
+{
+	return nblocks(size);
+}
diff --git a/fs/minix/minix.h b/fs/minix/minix.h
index 653fc977c31b..bc4a7eb83a04 100644
--- a/fs/minix/minix.h
+++ b/fs/minix/minix.h
@@ -55,6 +55,9 @@ extern int minix_new_block(struct inode * inode);
 extern void minix_free_block(struct inode * inode, int block);
 extern unsigned long minix_count_free_blocks(struct minix_sb_info *sbi);
 
+extern int minix_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+
+extern void V2_minix_truncate(struct inode *);
 extern void V1_minix_truncate(struct inode *);
 extern void V2_minix_truncate(struct inode *);
 extern void minix_truncate(struct inode *);
@@ -62,6 +65,8 @@ extern int minix_sync_inode(struct inode *);
 extern void minix_set_inode(struct inode *, dev_t);
 extern int V1_minix_get_block(struct inode *, long, struct buffer_head *, int);
 extern int V2_minix_get_block(struct inode *, long, struct buffer_head *, int);
+extern unsigned V1_minix_blocks(loff_t);
+extern unsigned V2_minix_blocks(loff_t);
 
 extern struct minix_dir_entry *minix_find_entry(struct dentry*, struct page**);
 extern int minix_add_link(struct dentry*, struct inode*);
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index a98fc9414cb5..40e10e10d29e 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -307,4 +307,5 @@ struct inode_operations minix_dir_inode_operations = {
 	rmdir:		minix_rmdir,
 	mknod:		minix_mknod,
 	rename:		minix_rename,
+	getattr:	minix_getattr,
 };
diff --git a/fs/stat.c b/fs/stat.c
index 925fc44f67ba..f9b489a1b9fb 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -20,22 +20,14 @@
 static __inline__ int
 do_revalidate(struct dentry *dentry)
 {
-	struct inode * inode = dentry->d_inode;
-	if (inode->i_op && inode->i_op->revalidate)
+	struct inode *inode = dentry->d_inode;
+	if (inode->i_op->revalidate)
 		return inode->i_op->revalidate(dentry);
 	return 0;
 }
 
-static int do_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+void generic_fillattr(struct inode *inode, struct kstat *stat)
 {
-	int res = 0;
-	unsigned int blocks, indirect;
-	struct inode *inode = dentry->d_inode;
-
-	res = do_revalidate(dentry);
-	if (res)
-		return res;
-
 	stat->dev = kdev_t_to_nr(inode->i_dev);
 	stat->ino = inode->i_ino;
 	stat->mode = inode->i_mode;
@@ -48,41 +40,29 @@ static int do_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat
 	stat->ctime = inode->i_ctime;
 	stat->ctime = inode->i_ctime;
 	stat->size = inode->i_size;
-/*
- * st_blocks and st_blksize are approximated with a simple algorithm if
- * they aren't supported directly by the filesystem. The minix and msdos
- * filesystems don't keep track of blocks, so they would either have to
- * be counted explicitly (by delving into the file itself), or by using
- * this simple algorithm to get a reasonable (although not 100% accurate)
- * value.
- */
+	stat->blocks = inode->i_blocks;
+	stat->blksize = inode->i_blksize;
+}
 
-/*
- * Use minix fs values for the number of direct and indirect blocks.  The
- * count is now exact for the minix fs except that it counts zero blocks.
- * Everything is in units of BLOCK_SIZE until the assignment to
- * tmp.st_blksize.
- */
-#define D_B   7
-#define I_B   (BLOCK_SIZE / sizeof(unsigned short))
-
-	if (!inode->i_blksize) {
-		blocks = (stat->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
-		if (blocks > D_B) {
-			indirect = (blocks - D_B + I_B - 1) / I_B;
-			blocks += indirect;
-			if (indirect > 1) {
-				indirect = (indirect - 1 + I_B - 1) / I_B;
-				blocks += indirect;
-				if (indirect > 1)
-					blocks++;
-			}
-		}
-		stat->blocks = (BLOCK_SIZE / 512) * blocks;
-		stat->blksize = BLOCK_SIZE;
-	} else {
-		stat->blocks = inode->i_blocks;
-		stat->blksize = inode->i_blksize;
+static int do_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	int res = 0;
+	struct inode *inode = dentry->d_inode;
+
+	if (inode->i_op->getattr)
+		return inode->i_op->getattr(mnt, dentry, stat);
+
+	res = do_revalidate(dentry);
+	if (res)
+		return res;
+
+	generic_fillattr(inode, stat);
+	if (!stat->blksize) {
+		struct super_block *s = inode->i_sb;
+		unsigned blocks;
+		blocks = (stat->size+s->s_blocksize-1) >> s->s_blocksize_bits;
+		stat->blocks = (s->s_blocksize / 512) * blocks;
+		stat->blksize = s->s_blocksize;
 	}
 	return 0;
 }
diff --git a/fs/sysv/file.c b/fs/sysv/file.c
index 9dce95103718..ab323a17ae37 100644
--- a/fs/sysv/file.c
+++ b/fs/sysv/file.c
@@ -29,6 +29,7 @@ struct file_operations sysv_file_operations = {
 
 struct inode_operations sysv_file_inode_operations = {
 	truncate:	sysv_truncate,
+	getattr:	sysv_getattr,
 };
 
 int sysv_sync_file(struct file * file, struct dentry *dentry, int datasync)
diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index 953a70c01df4..887ffe2bfff9 100644
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -132,6 +132,7 @@ static inline void write3byte(struct sysv_sb_info *sbi,
 static struct inode_operations sysv_symlink_inode_operations = {
 	readlink:	page_readlink,
 	follow_link:	page_follow_link,
+	getattr:	sysv_getattr,
 };
 
 void sysv_set_inode(struct inode *inode, dev_t rdev)
diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index bc6690583a1b..ba357ed424a4 100644
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -422,6 +422,30 @@ do_indirects:
 		mark_inode_dirty(inode);
 }
 
+static unsigned sysv_nblocks(struct super_block *s, loff_t size)
+{
+	struct sysv_sb_info *sbi = SYSV_SB(s);
+	int ptrs_bits = sbi->s_ind_per_block_bits;
+	unsigned blocks, res, direct = DIRECT, i = DEPTH;
+	blocks = (size + s->s_blocksize - 1) >> s->s_blocksize_bits;
+	res = blocks;
+	while (--i && blocks > direct) {
+		blocks = ((blocks - direct - 1) >> ptrs_bits) + 1;
+		res += blocks;
+		direct = 1;
+	}
+	return blocks;
+}
+
+int sysv_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	struct super_block *s = mnt->mnt_sb;
+	generic_fillattr(dentry->d_inode, stat);
+	stat->blocks = (s->s_blocksize / 512) * sysv_nblocks(s, stat->size);
+	stat->blksize = s->s_blocksize;
+	return 0;
+}
+
 static int sysv_writepage(struct page *page)
 {
 	return block_write_full_page(page,get_block);
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index dd770a681313..34cbff4f7c5f 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -317,4 +317,5 @@ struct inode_operations sysv_dir_inode_operations = {
 	rmdir:		sysv_rmdir,
 	mknod:		sysv_mknod,
 	rename:		sysv_rename,
+	getattr:	sysv_getattr,
 };
diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index cc0b9b18601e..d0ac45a0f88d 100644
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -137,6 +137,7 @@ extern void sysv_write_inode(struct inode *, int);
 extern int sysv_sync_inode(struct inode *);
 extern int sysv_sync_file(struct file *, struct dentry *, int);
 extern void sysv_set_inode(struct inode *, dev_t);
+extern int sysv_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 
 /* dir.c */
 extern struct sysv_dir_entry *sysv_find_entry(struct dentry *, struct page **);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index ab0a05dc8e26..b22e9121c1e9 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -783,7 +783,7 @@ struct inode_operations {
 	int (*permission) (struct inode *, int);
 	int (*revalidate) (struct dentry *);
 	int (*setattr) (struct dentry *, struct iattr *);
-	int (*getattr) (struct dentry *, struct iattr *);
+	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 	int (*setxattr) (struct dentry *, const char *, void *, size_t, int);
 	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 	ssize_t (*listxattr) (struct dentry *, char *, size_t);
@@ -1283,6 +1283,7 @@ extern int vfs_follow_link(struct nameidata *, const char *);
 extern int page_readlink(struct dentry *, char *, int);
 extern int page_follow_link(struct dentry *, struct nameidata *);
 extern struct inode_operations page_symlink_inode_operations;
+extern void generic_fillattr(struct inode *, struct kstat *);
 
 extern int vfs_readdir(struct file *, filldir_t, void *);
 
diff --git a/kernel/ksyms.c b/kernel/ksyms.c
index cc335bff25a1..678542ead676 100644
--- a/kernel/ksyms.c
+++ b/kernel/ksyms.c
@@ -258,6 +258,7 @@ EXPORT_SYMBOL(vfs_lstat);
 EXPORT_SYMBOL(lock_rename);
 EXPORT_SYMBOL(unlock_rename);
 EXPORT_SYMBOL(generic_read_dir);
+EXPORT_SYMBOL(generic_fillattr);
 EXPORT_SYMBOL(generic_file_llseek);
 EXPORT_SYMBOL(remote_llseek);
 EXPORT_SYMBOL(no_llseek);
-- 
cgit v1.2.3


From cc41b90f8a9ad3cd85a39dd4fcc71f965a675b0e Mon Sep 17 00:00:00 2001
From: Alexander Viro <viro@math.psu.edu>
Date: Tue, 21 May 2002 21:12:46 -0700
Subject: [PATCH] kill ->i_op->revalidate()

kill ->i_op->revalidate()
---
 Documentation/filesystems/Locking |  9 ++-------
 Documentation/filesystems/porting | 11 +++++++++++
 fs/bad_inode.c                    |  1 -
 fs/coda/cnode.c                   |  2 +-
 fs/coda/dir.c                     |  5 ++---
 fs/coda/inode.c                   | 14 +++++++++++---
 fs/coda/pioctl.c                  |  2 +-
 fs/nfs/dir.c                      |  6 +++---
 fs/nfs/file.c                     |  4 ++--
 fs/nfs/inode.c                    | 17 ++++++++---------
 fs/nfs/symlink.c                  | 12 +++++++-----
 fs/smbfs/dir.c                    |  2 +-
 fs/smbfs/file.c                   |  2 +-
 fs/smbfs/inode.c                  |  8 ++++++++
 fs/smbfs/proto.h                  |  1 +
 fs/stat.c                         | 20 +-------------------
 include/linux/coda_linux.h        |  3 ++-
 include/linux/fs.h                |  1 -
 include/linux/nfs_fs.h            |  4 ++--
 19 files changed, 64 insertions(+), 60 deletions(-)

(limited to 'include/linux')

diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking
index 72288b4d8f9e..cb0263288366 100644
--- a/Documentation/filesystems/Locking
+++ b/Documentation/filesystems/Locking
@@ -42,9 +42,8 @@ prototypes:
 	int (*follow_link) (struct dentry *, struct nameidata *);
 	void (*truncate) (struct inode *);
 	int (*permission) (struct inode *, int);
-	int (*revalidate) (struct dentry *);
 	int (*setattr) (struct dentry *, struct iattr *);
-	int (*getattr) (struct dentry *, struct iattr *);
+	int (*getattr) (struct vfsmount *, struct dentry *, struct kstat *);
 	int (*setxattr) (struct dentry *, const char *, void *, size_t, int);
 	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 	ssize_t (*listxattr) (struct dentry *, char *, size_t);
@@ -67,8 +66,7 @@ follow_link:	no	no
 truncate:	no	yes		(see below)
 setattr:	no	yes
 permission:	yes	no
-getattr:				(see below)
-revalidate:	no			(see below)
+getattr:	no	no
 setxattr:	no	yes
 getxattr:	no	yes
 listxattr:	no	yes
@@ -76,14 +74,11 @@ removexattr:	no	yes
 	Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_sem on
 victim.
 	cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem.
-	->revalidate(), it may be called both with and without the i_sem
-on dentry->d_inode.
 	->truncate() is never called directly - it's a callback, not a
 method. It's called by vmtruncate() - library function normally used by
 ->setattr(). Locking information above applies to that call (i.e. is
 inherited from ->setattr() - vmtruncate() is used when ATTR_SIZE had been
 passed).
-	->getattr() is currently unused.
 
 See Documentation/filesystems/directory-locking for more detailed discussion
 of the locking scheme for directory operations.
diff --git a/Documentation/filesystems/porting b/Documentation/filesystems/porting
index 5e1e47711009..304e81ae3b1d 100644
--- a/Documentation/filesystems/porting
+++ b/Documentation/filesystems/porting
@@ -187,3 +187,14 @@ e.g.
                unlock_new_inode(inode);
        }
 
+---
+[recommended]
+
+->getattr() finally getting used.  See instances in nfs, minix, etc.
+
+---
+[mandatory]
+
+->revalidate() is gone.  If your filesystem had it - provide ->getattr()
+and let it call whatever you had as ->revlidate() + (for symlinks that
+had ->revalidate()) add calls in ->follow_link()/->readlink().
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index f0c215c4a4e2..14d9ba149c52 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -60,7 +60,6 @@ struct inode_operations bad_inode_ops =
 	follow_link:	bad_follow_link,
 	truncate:	EIO_ERROR,
 	permission:	EIO_ERROR,
-	revalidate:	EIO_ERROR,
 	getattr:	EIO_ERROR,
 };
 
diff --git a/fs/coda/cnode.c b/fs/coda/cnode.c
index 60ee649aacc5..8aa3dfbee29e 100644
--- a/fs/coda/cnode.c
+++ b/fs/coda/cnode.c
@@ -28,7 +28,7 @@ inline int coda_isnullfid(ViceFid *fid)
 static struct inode_operations coda_symlink_inode_operations = {
 	readlink:	page_readlink,
 	follow_link:	page_follow_link,
-	setattr:	coda_notify_change,
+	setattr:	coda_setattr,
 };
 
 /* cnode.c */
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 40398f8b66c7..16bd5714cecf 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -72,8 +72,8 @@ struct inode_operations coda_dir_inode_operations =
 	mknod:		coda_mknod,
 	rename:		coda_rename,
 	permission:	coda_permission,
-        revalidate:	coda_revalidate_inode,
-	setattr:	coda_notify_change,
+        getattr:	coda_getattr,
+	setattr:	coda_setattr,
 };
 
 struct file_operations coda_dir_operations = {
@@ -147,7 +147,6 @@ exit:
 
 int coda_permission(struct inode *inode, int mask)
 {
-	umode_t mode = inode->i_mode;
         int error;
  
 	if (!mask)
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 5066d9a04984..016009ab7f53 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -237,7 +237,15 @@ static void coda_clear_inode(struct inode *inode)
 	coda_cache_clear_inode(inode);
 }
 
-int coda_notify_change(struct dentry *de, struct iattr *iattr)
+int coda_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	int err = coda_revalidate_inode(dentry);
+	if (!err)
+		generic_fillattr(dentry->d_inode, stat);
+	return err;
+}
+
+int coda_setattr(struct dentry *de, struct iattr *iattr)
 {
 	struct inode *inode = de->d_inode;
         struct coda_vattr vattr;
@@ -266,8 +274,8 @@ int coda_notify_change(struct dentry *de, struct iattr *iattr)
 
 struct inode_operations coda_file_inode_operations = {
 	permission:	coda_permission,
-	revalidate:	coda_revalidate_inode,
-	setattr:	coda_notify_change,
+	getattr:	coda_getattr,
+	setattr:	coda_setattr,
 };
 
 static int coda_statfs(struct super_block *sb, struct statfs *buf)
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index edfb9aa96544..53f4d2c714dc 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -32,7 +32,7 @@ static int coda_pioctl(struct inode * inode, struct file * filp,
 struct inode_operations coda_ioctl_inode_operations =
 {
 	permission:	coda_ioctl_permission,
-	setattr:	coda_notify_change,
+	setattr:	coda_setattr,
 };
 
 struct file_operations coda_ioctl_operations = {
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index e4fb5ffd1def..31d58c25914f 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -64,8 +64,8 @@ struct inode_operations nfs_dir_inode_operations = {
 	mknod:		nfs_mknod,
 	rename:		nfs_rename,
 	permission:	nfs_permission,
-	revalidate:	nfs_revalidate,
-	setattr:	nfs_notify_change,
+	getattr:	nfs_getattr,
+	setattr:	nfs_setattr,
 };
 
 typedef u32 * (*decode_dirent_t)(u32 *, struct nfs_entry *, int);
@@ -357,7 +357,7 @@ static int nfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
 
 	lock_kernel();
 
-	res = nfs_revalidate(dentry);
+	res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
 	if (res < 0) {
 		unlock_kernel();
 		return res;
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 0f66660f55d8..ead763518c4a 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -54,8 +54,8 @@ struct file_operations nfs_file_operations = {
 
 struct inode_operations nfs_file_inode_operations = {
 	permission:	nfs_permission,
-	revalidate:	nfs_revalidate,
-	setattr:	nfs_notify_change,
+	getattr:	nfs_getattr,
+	setattr:	nfs_setattr,
 };
 
 /* Hack for future NFS swap support */
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index d5bced0cdbde..770aab11d3dc 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -730,7 +730,7 @@ out_no_inode:
 }
 
 int
-nfs_notify_change(struct dentry *dentry, struct iattr *attr)
+nfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
 	struct inode *inode = dentry->d_inode;
 	struct nfs_fattr fattr;
@@ -744,7 +744,7 @@ nfs_notify_change(struct dentry *dentry, struct iattr *attr)
 	error = nfs_revalidate_inode(NFS_SERVER(inode),inode);
 	if (error) {
 #ifdef NFS_PARANOIA
-printk("nfs_notify_change: revalidate failed, error=%d\n", error);
+printk("nfs_setattr: revalidate failed, error=%d\n", error);
 #endif
 		goto out;
 	}
@@ -768,7 +768,7 @@ printk("nfs_notify_change: revalidate failed, error=%d\n", error);
 	 */
 	if (attr->ia_valid & ATTR_SIZE) {
 		if (attr->ia_size != fattr.size)
-			printk("nfs_notify_change: attr=%Ld, fattr=%Ld??\n",
+			printk("nfs_setattr: attr=%Ld, fattr=%Ld??\n",
 			       (long long) attr->ia_size, (long long)fattr.size);
 		vmtruncate(inode, attr->ia_size);
 	}
@@ -808,14 +808,13 @@ nfs_wait_on_inode(struct inode *inode, int flag)
 	return error;
 }
 
-/*
- * Externally visible revalidation function
- */
-int
-nfs_revalidate(struct dentry *dentry)
+int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
 	struct inode *inode = dentry->d_inode;
-	return nfs_revalidate_inode(NFS_SERVER(inode), inode);
+	int err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
+	if (!err)
+		generic_fillattr(inode, stat);
+	return err;
 }
 
 /*
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index 2c6e1ded5afe..5f0106639519 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -59,7 +59,9 @@ static char *nfs_getlink(struct inode *inode, struct page **ppage)
 	struct page *page;
 	u32 *p;
 
-	/* Caller revalidated the directory inode already. */
+	page = ERR_PTR(nfs_revalidate_inode(NFS_SERVER(inode), inode));
+	if (page)
+		goto read_failed;
 	page = read_cache_page(&inode->i_data, 0,
 				(filler_t *)nfs_symlink_filler, inode);
 	if (IS_ERR(page))
@@ -69,10 +71,10 @@ static char *nfs_getlink(struct inode *inode, struct page **ppage)
 	*ppage = page;
 	p = kmap(page);
 	return (char*)(p+1);
-		
+
 getlink_read_error:
 	page_cache_release(page);
-	return ERR_PTR(-EIO);
+	page = ERR_PTR(-EIO);
 read_failed:
 	return (char*)page;
 }
@@ -107,6 +109,6 @@ static int nfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 struct inode_operations nfs_symlink_inode_operations = {
 	readlink:	nfs_readlink,
 	follow_link:	nfs_follow_link,
-	revalidate:	nfs_revalidate,
-	setattr:	nfs_notify_change,
+	getattr:	nfs_getattr,
+	setattr:	nfs_setattr,
 };
diff --git a/fs/smbfs/dir.c b/fs/smbfs/dir.c
index 6a34c53e54f9..5817c5433052 100644
--- a/fs/smbfs/dir.c
+++ b/fs/smbfs/dir.c
@@ -47,7 +47,7 @@ struct inode_operations smb_dir_inode_operations =
 	mkdir:		smb_mkdir,
 	rmdir:		smb_rmdir,
 	rename:		smb_rename,
-	revalidate:	smb_revalidate_inode,
+	getattr:	smb_getattr,
 	setattr:	smb_notify_change,
 };
 
diff --git a/fs/smbfs/file.c b/fs/smbfs/file.c
index 79a830fcd515..e9c2bb2bc3a0 100644
--- a/fs/smbfs/file.c
+++ b/fs/smbfs/file.c
@@ -398,6 +398,6 @@ struct file_operations smb_file_operations =
 struct inode_operations smb_file_inode_operations =
 {
 	permission:	smb_file_permission,
-	revalidate:	smb_revalidate_inode,
+	getattr:	smb_getattr,
 	setattr:	smb_notify_change,
 };
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 22a8e371b0c3..54234f87fe2c 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -611,6 +611,14 @@ smb_statfs(struct super_block *sb, struct statfs *buf)
 	return result;
 }
 
+int smb_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+{
+	int err = smb_revalidate_inode(dentry);
+	if (!err)
+		generic_fillattr(dentry->d_inode, stat);
+	return err;
+}
+
 int
 smb_notify_change(struct dentry *dentry, struct iattr *attr)
 {
diff --git a/fs/smbfs/proto.h b/fs/smbfs/proto.h
index c269a838d007..5d8d0b569e27 100644
--- a/fs/smbfs/proto.h
+++ b/fs/smbfs/proto.h
@@ -49,6 +49,7 @@ extern void smb_get_inode_attr(struct inode *inode, struct smb_fattr *fattr);
 extern void smb_set_inode_attr(struct inode *inode, struct smb_fattr *fattr);
 extern void smb_invalidate_inodes(struct smb_sb_info *server);
 extern int smb_revalidate_inode(struct dentry *dentry);
+extern int smb_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat);
 extern int smb_notify_change(struct dentry *dentry, struct iattr *attr);
 /* file.c */
 extern struct address_space_operations smb_file_aops;
diff --git a/fs/stat.c b/fs/stat.c
index f9b489a1b9fb..a09b7f6abd73 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -14,18 +14,6 @@
 
 #include <asm/uaccess.h>
 
-/*
- * Revalidate the inode. This is required for proper NFS attribute caching.
- */
-static __inline__ int
-do_revalidate(struct dentry *dentry)
-{
-	struct inode *inode = dentry->d_inode;
-	if (inode->i_op->revalidate)
-		return inode->i_op->revalidate(dentry);
-	return 0;
-}
-
 void generic_fillattr(struct inode *inode, struct kstat *stat)
 {
 	stat->dev = kdev_t_to_nr(inode->i_dev);
@@ -46,16 +34,11 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
 
 static int do_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
-	int res = 0;
 	struct inode *inode = dentry->d_inode;
 
 	if (inode->i_op->getattr)
 		return inode->i_op->getattr(mnt, dentry, stat);
 
-	res = do_revalidate(dentry);
-	if (res)
-		return res;
-
 	generic_fillattr(inode, stat);
 	if (!stat->blksize) {
 		struct super_block *s = inode->i_sb;
@@ -247,8 +230,7 @@ asmlinkage long sys_readlink(const char * path, char * buf, int bufsiz)
 		struct inode * inode = nd.dentry->d_inode;
 
 		error = -EINVAL;
-		if (inode->i_op && inode->i_op->readlink &&
-		    !(error = do_revalidate(nd.dentry))) {
+		if (inode->i_op && inode->i_op->readlink) {
 			UPDATE_ATIME(inode);
 			error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
 		}
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index ff5363b19923..0847c29a9175 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -40,7 +40,8 @@ int coda_flush(struct file *f);
 int coda_release(struct inode *i, struct file *f);
 int coda_permission(struct inode *inode, int mask);
 int coda_revalidate_inode(struct dentry *);
-int coda_notify_change(struct dentry *, struct iattr *);
+int coda_getattr(struct vfsmount *, struct dentry *, struct kstat *);
+int coda_setattr(struct dentry *, struct iattr *);
 int coda_isnullfid(ViceFid *fid);
 
 /* global variables */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b22e9121c1e9..de84a3fb9f2e 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -781,7 +781,6 @@ struct inode_operations {
 	int (*follow_link) (struct dentry *, struct nameidata *);
 	void (*truncate) (struct inode *);
 	int (*permission) (struct inode *, int);
-	int (*revalidate) (struct dentry *);
 	int (*setattr) (struct dentry *, struct iattr *);
 	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 	int (*setxattr) (struct dentry *, const char *, void *, size_t, int);
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index a8a2259a8343..027986b2f336 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -234,12 +234,12 @@ extern int nfs_inode_is_stale(struct inode *, struct nfs_fh *,
 extern struct inode *nfs_fhget(struct dentry *, struct nfs_fh *,
 				struct nfs_fattr *);
 extern int __nfs_refresh_inode(struct inode *, struct nfs_fattr *);
-extern int nfs_revalidate(struct dentry *);
+extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int nfs_permission(struct inode *, int);
 extern int nfs_open(struct inode *, struct file *);
 extern int nfs_release(struct inode *, struct file *);
 extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
-extern int nfs_notify_change(struct dentry *, struct iattr *);
+extern int nfs_setattr(struct dentry *, struct iattr *);
 
 /*
  * linux/fs/nfs/file.c
-- 
cgit v1.2.3


From c6e6354f8e7cb66bdbb6e33a444beb959e3a70e8 Mon Sep 17 00:00:00 2001
From: Alexander Viro <viro@math.psu.edu>
Date: Tue, 21 May 2002 21:12:54 -0700
Subject: [PATCH] clean up readdir() for in-memory

sane readdir() for ramfs-style filesystems
---
 fs/autofs4/root.c  |   3 ++
 fs/libfs.c         | 128 +++++++++++++++++++++++++++++++++++------------------
 include/linux/fs.h |   3 ++
 kernel/ksyms.c     |   3 ++
 4 files changed, 93 insertions(+), 44 deletions(-)

(limited to 'include/linux')

diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index adb9c384af5f..54cba4bdbb0b 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -27,6 +27,9 @@ static int autofs4_root_ioctl(struct inode *, struct file *,unsigned int,unsigne
 static struct dentry *autofs4_root_lookup(struct inode *,struct dentry *);
 
 struct file_operations autofs4_root_operations = {
+	open:		dcache_dir_open,
+	release:	dcache_dir_close,
+	llseek:		dcache_dir_lseek,
 	read:		generic_read_dir,
 	readdir:	dcache_readdir,
 	ioctl:		autofs4_root_ioctl,
diff --git a/fs/libfs.c b/fs/libfs.c
index 70daadc19f89..8ec5c6878e0d 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -29,6 +29,59 @@ int simple_sync_file(struct file * file, struct dentry *dentry, int datasync)
 {
 	return 0;
 }
+ 
+int dcache_dir_open(struct inode *inode, struct file *file)
+{
+	static struct qstr cursor_name = {len:1, name:"."};
+
+	file->private_data = d_alloc(file->f_dentry, &cursor_name);
+
+	return file->private_data ? 0 : -ENOMEM;
+}
+
+int dcache_dir_close(struct inode *inode, struct file *file)
+{
+	dput(file->private_data);
+	return 0;
+}
+
+loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
+{
+	down(&file->f_dentry->d_inode->i_sem);
+	switch (origin) {
+		case 1:
+			offset += file->f_pos;
+		case 0:
+			if (offset >= 0)
+				break;
+		default:
+			up(&file->f_dentry->d_inode->i_sem);
+			return -EINVAL;
+	}
+	if (offset != file->f_pos) {
+		file->f_pos = offset;
+		if (file->f_pos >= 2) {
+			struct list_head *p;
+			struct dentry *cursor = file->private_data;
+			loff_t n = file->f_pos - 2;
+
+			spin_lock(&dcache_lock);
+			p = file->f_dentry->d_subdirs.next;
+			while (n && p != &file->f_dentry->d_subdirs) {
+				struct dentry *next;
+				next = list_entry(p, struct dentry, d_child);
+				if (!list_empty(&next->d_hash) && next->d_inode)
+					n--;
+				p = p->next;
+			}
+			list_del(&cursor->d_child);
+			list_add_tail(&cursor->d_child, p);
+			spin_unlock(&dcache_lock);
+		}
+	}
+	up(&file->f_dentry->d_inode->i_sem);
+	return offset;
+}
 
 /*
  * Directory is locked and all positive dentries in it are safe, since
@@ -38,67 +91,51 @@ int simple_sync_file(struct file * file, struct dentry *dentry, int datasync)
 
 int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
 {
-	int i;
 	struct dentry *dentry = filp->f_dentry;
+	struct dentry *cursor = filp->private_data;
+	struct list_head *p, *q = &cursor->d_child;
+	ino_t ino;
+	int i = filp->f_pos;
 
-	lock_kernel();
-
-	i = filp->f_pos;
 	switch (i) {
 		case 0:
-			if (filldir(dirent, ".", 1, i, dentry->d_inode->i_ino, DT_DIR) < 0)
+			ino = dentry->d_inode->i_ino;
+			if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
 				break;
-			i++;
 			filp->f_pos++;
+			i++;
 			/* fallthrough */
 		case 1:
-			if (filldir(dirent, "..", 2, i, parent_ino(dentry), DT_DIR) < 0)
+			ino = parent_ino(dentry);
+			if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
 				break;
-			i++;
 			filp->f_pos++;
+			i++;
 			/* fallthrough */
-		default: {
-			struct list_head *list;
-			int j = i-2;
-
+		default:
 			spin_lock(&dcache_lock);
-			list = dentry->d_subdirs.next;
-
-			for (;;) {
-				if (list == &dentry->d_subdirs) {
-					spin_unlock(&dcache_lock);
-					unlock_kernel();
-					return 0;
-				}
-				if (!j)
-					break;
-				j--;
-				list = list->next;
+			if (filp->f_pos == 2) {
+				list_del(q);
+				list_add(q, &dentry->d_subdirs);
 			}
-
-			while(1) {
-				struct dentry *de = list_entry(list, struct dentry, d_child);
-
-				/*
-				 * See comment on top of function on why we
-				 * can just drop the lock here..
-				 */
-				if (!list_empty(&de->d_hash) && de->d_inode) {
-					spin_unlock(&dcache_lock);
-					if (filldir(dirent, de->d_name.name, de->d_name.len, filp->f_pos, de->d_inode->i_ino, DT_UNKNOWN) < 0)
-						break;
-					spin_lock(&dcache_lock);
-				}
-				filp->f_pos++;
-				list = list->next;
-				if (list != &dentry->d_subdirs)
+			for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
+				struct dentry *next;
+				next = list_entry(p, struct dentry, d_child);
+				if (list_empty(&next->d_hash) || !next->d_inode)
 					continue;
+
 				spin_unlock(&dcache_lock);
-				break;
+				if (filldir(dirent, next->d_name.name, next->d_name.len, filp->f_pos, next->d_inode->i_ino, DT_UNKNOWN) < 0)
+					return 0;
+				spin_lock(&dcache_lock);
+				/* next is still alive */
+				list_del(q);
+				list_add(q, p);
+				p = q;
+				filp->f_pos++;
 			}
-		}
+			spin_unlock(&dcache_lock);
 	}
-	unlock_kernel();
 	return 0;
 }
 
@@ -108,6 +145,9 @@ ssize_t generic_read_dir(struct file *filp, char *buf, size_t siz, loff_t *ppos)
 }
 
 struct file_operations simple_dir_operations = {
+	open:		dcache_dir_open,
+	release:	dcache_dir_close,
+	llseek:		dcache_dir_lseek,
 	read:		generic_read_dir,
 	readdir:	dcache_readdir,
 };
diff --git a/include/linux/fs.h b/include/linux/fs.h
index de84a3fb9f2e..0f2ae2f148e6 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1296,6 +1296,9 @@ extern void drop_super(struct super_block *sb);
 extern kdev_t ROOT_DEV;
 extern char root_device_name[];
 
+extern int dcache_dir_open(struct inode *, struct file *);
+extern int dcache_dir_close(struct inode *, struct file *);
+extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
 extern int dcache_readdir(struct file *, void *, filldir_t);
 extern int simple_statfs(struct super_block *, struct statfs *);
 extern struct dentry *simple_lookup(struct inode *, struct dentry *);
diff --git a/kernel/ksyms.c b/kernel/ksyms.c
index 678542ead676..d5e7f689f7ed 100644
--- a/kernel/ksyms.c
+++ b/kernel/ksyms.c
@@ -281,6 +281,9 @@ EXPORT_SYMBOL(__get_lease);
 EXPORT_SYMBOL(lease_get_mtime);
 EXPORT_SYMBOL(lock_may_read);
 EXPORT_SYMBOL(lock_may_write);
+EXPORT_SYMBOL(dcache_dir_open);
+EXPORT_SYMBOL(dcache_dir_close);
+EXPORT_SYMBOL(dcache_dir_lseek);
 EXPORT_SYMBOL(dcache_readdir);
 EXPORT_SYMBOL(simple_statfs);
 EXPORT_SYMBOL(simple_lookup);
-- 
cgit v1.2.3


From ec3a47e78a7ecfe1172bac081c2e27cec34967da Mon Sep 17 00:00:00 2001
From: Alexander Viro <viro@math.psu.edu>
Date: Tue, 21 May 2002 21:13:05 -0700
Subject: [PATCH] new helpers for /proc

new helpers for seq_file - for cases where we don't have a non-trivial
iterator and just want to use seq_{printf,putc,...}.
---
 fs/proc/proc_misc.c      | 22 ++--------------------
 fs/seq_file.c            | 42 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/seq_file.h |  2 ++
 kernel/ksyms.c           |  2 ++
 net/wanrouter/wanproc.c  | 28 +++-------------------------
 5 files changed, 51 insertions(+), 45 deletions(-)

(limited to 'include/linux')

diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index dc54a4a17045..7443eee2ce4a 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -357,25 +357,7 @@ static int devices_read_proc(char *page, char **start, off_t off,
 	return proc_calc_metrics(page, start, off, count, eof, len);
 }
 
-static void *single_start(struct seq_file *p, loff_t *pos)
-{
-	return NULL + (*pos == 0);
-}
-static void *single_next(struct seq_file *p, void *v, loff_t *pos)
-{
-	++*pos;
-	return NULL;
-}
-static void single_stop(struct seq_file *p, void *v)
-{
-}
 extern int show_interrupts(struct seq_file *p, void *v);
-static struct seq_operations proc_interrupts_op = {
-	start:	single_start,
-	next:	single_next,
-	stop:	single_stop,
-	show:	show_interrupts,
-};
 static int interrupts_open(struct inode *inode, struct file *file)
 {
 	unsigned size = PAGE_SIZE;
@@ -389,7 +371,7 @@ static int interrupts_open(struct inode *inode, struct file *file)
 
 	if (!buf)
 		return -ENOMEM;
-	res = seq_open(file, &proc_interrupts_op);
+	res = single_open(file, show_interrupts, NULL);
 	if (!res) {
 		m = file->private_data;
 		m->buf = buf;
@@ -402,7 +384,7 @@ static struct file_operations proc_interrupts_operations = {
 	open:		interrupts_open,
 	read:		seq_read,
 	llseek:		seq_lseek,
-	release:	seq_release,
+	release:	single_release,
 };
 
 static int filesystems_read_proc(char *page, char **start, off_t off,
diff --git a/fs/seq_file.c b/fs/seq_file.c
index db6d59acb37d..00bdafb3af46 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -293,3 +293,45 @@ int seq_printf(struct seq_file *m, const char *f, ...)
 	m->count = m->size;
 	return -1;
 }
+
+static void *single_start(struct seq_file *p, loff_t *pos)
+{
+	return NULL + (*pos == 0);
+}
+
+static void *single_next(struct seq_file *p, void *v, loff_t *pos)
+{
+	++*pos;
+	return NULL;
+}
+
+static void single_stop(struct seq_file *p, void *v)
+{
+}
+
+int single_open(struct file *file, int (*show)(struct seq_file *, void*), void *data)
+{
+	struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
+	int res = -ENOMEM;
+
+	if (op) {
+		op->start = single_start;
+		op->next = single_next;
+		op->stop = single_stop;
+		op->show = show;
+		res = seq_open(file, op);
+		if (!res)
+			((struct seq_file *)file->private_data)->private = data;
+		else
+			kfree(op);
+	}
+	return res;
+}
+
+int single_release(struct inode *inode, struct file *file)
+{
+	struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
+	int res = seq_release(inode, file);
+	kfree(op);
+	return res;
+}
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index a1b29efb0666..ab12d2608f53 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -58,5 +58,7 @@ static inline int seq_puts(struct seq_file *m, const char *s)
 int seq_printf(struct seq_file *, const char *, ...)
 	__attribute__ ((format (printf,2,3)));
 
+int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
+int single_release(struct inode *, struct file *);
 #endif
 #endif
diff --git a/kernel/ksyms.c b/kernel/ksyms.c
index d5e7f689f7ed..9b1201822582 100644
--- a/kernel/ksyms.c
+++ b/kernel/ksyms.c
@@ -522,6 +522,8 @@ EXPORT_SYMBOL(seq_open);
 EXPORT_SYMBOL(seq_release);
 EXPORT_SYMBOL(seq_read);
 EXPORT_SYMBOL(seq_lseek);
+EXPORT_SYMBOL(single_open);
+EXPORT_SYMBOL(single_release);
 
 /* Program loader interfaces */
 EXPORT_SYMBOL(setup_arg_pages);
diff --git a/net/wanrouter/wanproc.c b/net/wanrouter/wanproc.c
index 0fb5206ca8f6..f27ee2df571b 100644
--- a/net/wanrouter/wanproc.c
+++ b/net/wanrouter/wanproc.c
@@ -233,18 +233,6 @@ static struct file_operations status_fops =
 	release:	seq_release,
 };
 
-static void *single_start(struct seq_file *p, loff_t *pos)
-{
-	return *pos == 0 ? p->private : NULL;
-}
-static void *single_next(struct seq_file *p, void *v, loff_t *pos)
-{
-	++*pos;
-	return NULL;
-}
-static void single_stop(struct seq_file *p, void *v)
-{
-}
 static int wandev_show(struct seq_file *m, void *v)
 {
 	wan_device_t *wandev = v;
@@ -306,20 +294,10 @@ static int wandev_show(struct seq_file *m, void *v)
 		"aborted frames transmitted", wandev->stats.tx_aborted_errors);
 	return 0;
 }
-static struct seq_operations wandev_op = {
-	start:	single_start,
-	next:	single_next,
-	stop:	single_stop,
-	show:	wandev_show,
-};
+
 static int wandev_open(struct inode *inode, struct file *file)
 {
-	int ret = seq_open(file, &wandev_op);
-	if (!ret) {
-		struct seq_file *m = file->private_data;
-		m->private = PDE(inode)->data;
-	}
-	return ret;
+	return single_open(file, wandev_show, PDE(inode)->data);
 }
 
 static struct file_operations wandev_fops =
@@ -327,7 +305,7 @@ static struct file_operations wandev_fops =
 	open:		wandev_open,
 	read:		seq_read,
 	llseek:		seq_lseek,
-	release:	seq_release,
+	release:	single_release,
 	ioctl:		wanrouter_ioctl,
 };
 
-- 
cgit v1.2.3


From 694793903207ecf6a4a1b508b636f02cfb3a3016 Mon Sep 17 00:00:00 2001
From: Martin Dalecki <dalecki@evision-ventures.com>
Date: Tue, 21 May 2002 21:22:01 -0700
Subject: [PATCH] 2.5.17 IDE 65

 - Apply cleanup of host chip drivers by Bartomiej Zonierkiewicz:

     affected drivers - aec62xx.c, alim15x3.c, cmd64x.c, hpt34x.c, sis5513.c

     new tuning scheme (wip) part 1:
	- introduce ratemask()
	- use ata_timing_mode()
	- use ide_config_drive_speed() return value

     forward port from convert.10:
	- support for AEC6280, AEC6280R
	- misc cleanups

     I had to fix a small typo in sis5513 code...

 - Add a new entry for an old VIA cell hiding as something new.
   (Pointed out by Kees Bakker.)

 - Make the synchronization token active resident on the same level as the
   spin lock. They interact with each other.

 - Synchronize with linux-2.5.17.

 - HPT366 driver typo fix by Andries Brouwer.

 - Export udma_tcq_enable() symbol right now. The blk_get_request() is undefined
   as well.
---
 drivers/ide/Config.help |   7 ++
 drivers/ide/Config.in   |   1 +
 drivers/ide/Makefile    |   2 +-
 drivers/ide/aec62xx.c   | 321 ++++++++++++++++++++++++++++--------------------
 drivers/ide/ali14xx.c   |   4 +-
 drivers/ide/alim15x3.c  | 135 +++++++++-----------
 drivers/ide/cmd64x.c    | 294 +++++++++++++++++---------------------------
 drivers/ide/hpt34x.c    |  61 +++------
 drivers/ide/ide-cd.c    |  80 ++++++------
 drivers/ide/ide-pci.c   |  15 ++-
 drivers/ide/ide-probe.c |  11 +-
 drivers/ide/ide-tape.c  | 246 ++++++++++++++++++-------------------
 drivers/ide/ide.c       |  32 ++---
 drivers/ide/piix.c      |   6 +-
 drivers/ide/sis5513.c   | 103 +++++++---------
 drivers/ide/tcq.c       |  16 ++-
 drivers/ide/trm290.c    |   4 +-
 drivers/ide/via82cxxx.c |  22 +---
 include/linux/ide.h     |   8 +-
 19 files changed, 647 insertions(+), 721 deletions(-)

(limited to 'include/linux')

diff --git a/drivers/ide/Config.help b/drivers/ide/Config.help
index ce23a9be1cde..1e934c633b35 100644
--- a/drivers/ide/Config.help
+++ b/drivers/ide/Config.help
@@ -304,6 +304,7 @@ CONFIG_BLK_DEV_AEC62XX
   The ATP850U/UF is an UltraDMA 33 chipset base.
   The ATP860 is an UltraDMA 66 chipset base.
   The ATP860M(acintosh) version is an UltraDMA 66 chipset base.
+  The ATP865 is an ATA100/133 chipset.
 
   Please read the comments at the top of <file:drivers/ide/aec62xx.c>.
   If you say Y here, then say Y to "Use DMA by default when available"
@@ -313,6 +314,12 @@ CONFIG_AEC62XX_TUNING
   Please read the comments at the top of <file:drivers/ide/aec62xx.c>.
   If unsure, say N.
 
+CONFIG_AEC6280_BURST
+  Use burst mode for DMA transfers. Higher speed, but causes more load
+  on the bus.
+
+  If unsure, say N.
+
 CONFIG_BLK_DEV_ALI15X3
   This driver ensures (U)DMA support for ALI 1533, 1543 and 1543C
   onboard chipsets.  It also tests for Simplex mode and enables
diff --git a/drivers/ide/Config.in b/drivers/ide/Config.in
index 637bec22aa7b..72b08c3a4cf7 100644
--- a/drivers/ide/Config.in
+++ b/drivers/ide/Config.in
@@ -54,6 +54,7 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
       dep_bool '    Good-Bad DMA Model-Firmware (EXPERIMENTAL)' CONFIG_IDEDMA_NEW_DRIVE_LISTINGS $CONFIG_EXPERIMENTAL
       dep_bool '    AEC62XX chip set support' CONFIG_BLK_DEV_AEC62XX $CONFIG_BLK_DEV_IDEDMA_PCI
       dep_mbool '      AEC62XX Tuning support' CONFIG_AEC62XX_TUNING $CONFIG_BLK_DEV_AEC62XX
+      dep_mbool '      AEC6280 Burst mode' CONFIG_AEC6280_BURST $CONFIG_BLK_DEV_AEC62XX
       dep_bool '    ALI M15x3 chipset support' CONFIG_BLK_DEV_ALI15X3 $CONFIG_BLK_DEV_IDEDMA_PCI
       dep_mbool '      ALI M15x3 WDC support (DANGEROUS)' CONFIG_WDC_ALI15X3 $CONFIG_BLK_DEV_ALI15X3 $CONFIG_EXPERIMENTAL
       dep_bool '    AMD and nVidia chipset support' CONFIG_BLK_DEV_AMD74XX $CONFIG_BLK_DEV_IDEDMA_PCI
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile
index 8655590ea98d..f96037cddf9f 100644
--- a/drivers/ide/Makefile
+++ b/drivers/ide/Makefile
@@ -10,7 +10,7 @@
 
 O_TARGET := idedriver.o
 
-export-objs	:= ide-taskfile.o ide.o ide-features.o ide-probe.o quirks.o pcidma.o ataraid.o
+export-objs	:= ide-taskfile.o ide.o ide-features.o ide-probe.o quirks.o pcidma.o tcq.o ataraid.o
 
 obj-y		:=
 obj-m		:=
diff --git a/drivers/ide/aec62xx.c b/drivers/ide/aec62xx.c
index 7c8b218cd1af..053200483109 100644
--- a/drivers/ide/aec62xx.c
+++ b/drivers/ide/aec62xx.c
@@ -1,9 +1,8 @@
 /**** vi:set ts=8 sts=8 sw=8:************************************************
  *
- * Version 0.09	June. 9, 2000
+ * Version 0.11	March 27, 2002
  *
  * Copyright (C) 1999-2000	Andre Hedrick (andre@linux-ide.org)
- * May be copied or modified under the terms of the GNU General Public License
  *
  */
 
@@ -52,6 +51,21 @@ static int aec62xx_get_info(char *, char **, off_t, int);
 extern int (*aec62xx_display_info)(char *, char **, off_t, int); /* ide-proc.c */
 static struct pci_dev *bmide_dev;
 
+static const char *aec6280_get_speed(u8 speed)
+{
+	switch(speed) {
+		case 7: return "6";
+		case 6: return "5";
+		case 5: return "4";
+		case 4: return "3";
+		case 3: return "2";
+		case 2: return "1";
+		case 1: return "0";
+		case 0: return "?";
+	}
+	return "?";
+}
+
 static int aec62xx_get_info (char *buffer, char **addr, off_t offset, int count)
 {
 	char *p = buffer;
@@ -70,6 +84,12 @@ static int aec62xx_get_info (char *buffer, char **addr, off_t offset, int count)
 		case PCI_DEVICE_ID_ARTOP_ATP860R:
 			p += sprintf(p, "\n                                AEC6260 Chipset.\n");
 			break;
+		case PCI_DEVICE_ID_ARTOP_ATP865:
+			p += sprintf(p, "\n                                AEC6280 Chipset without ROM.\n");
+			break;
+		case PCI_DEVICE_ID_ARTOP_ATP865R:
+			p += sprintf(p, "\n                                AEC6280 Chipset with ROM.\n");
+			break;
 		default:
 			p += sprintf(p, "\n                                AEC62?? Chipset.\n");
 			break;
@@ -154,6 +174,41 @@ static int aec62xx_get_info (char *buffer, char **addr, off_t offset, int count)
 			(void) pci_read_config_byte(bmide_dev, 0x4a, &uart);
 			p += sprintf(p, "reg4ah = 0x%02x\n", uart);
 			break;
+		case PCI_DEVICE_ID_ARTOP_ATP865:
+		case PCI_DEVICE_ID_ARTOP_ATP865R:
+			(void) pci_read_config_byte(bmide_dev, 0x44, &art);
+			p += sprintf(p, "DMA Mode:       %s(%s)          %s(%s)",
+				(c0&0x20)?((art&0x0f)?"UDMA":" DMA"):" PIO",
+				aec6280_get_speed(art&0x0f),
+				(c0&0x40)?((art&0xf0)?"UDMA":" DMA"):" PIO",
+				aec6280_get_speed(art>>4));
+			(void) pci_read_config_byte(bmide_dev, 0x45, &art);
+			p += sprintf(p, "         %s(%s)          %s(%s)\n",
+				(c0&0x20)?((art&0x0f)?"UDMA":" DMA"):" PIO",
+				aec6280_get_speed(art&0x0f),
+				(c0&0x40)?((art&0xf0)?"UDMA":" DMA"):" PIO",
+				aec6280_get_speed(art>>4));
+			(void) pci_read_config_byte(bmide_dev, 0x40, &art);
+			p += sprintf(p, "Active:         0x%02x", HIGH_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x41, &art);
+			p += sprintf(p, "             0x%02x", HIGH_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x42, &art);
+			p += sprintf(p, "            0x%02x", HIGH_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x43, &art);
+			p += sprintf(p, "              0x%02x\n", HIGH_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x40, &art);
+			p += sprintf(p, "Recovery:       0x%02x", LOW_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x41, &art);
+			p += sprintf(p, "             0x%02x", LOW_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x42, &art);
+			p += sprintf(p, "            0x%02x", LOW_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x43, &art);
+			p += sprintf(p, "              0x%02x\n", LOW_4(art));
+			(void) pci_read_config_byte(bmide_dev, 0x49, &uart);
+			p += sprintf(p, "reg49h = 0x%02x ", uart);
+			(void) pci_read_config_byte(bmide_dev, 0x4a, &uart);
+			p += sprintf(p, "reg4ah = 0x%02x\n", uart);
+			break;
 		default:
 			break;
 	}
@@ -164,8 +219,6 @@ static int aec62xx_get_info (char *buffer, char **addr, off_t offset, int count)
 
 byte aec62xx_proc = 0;
 
-#ifdef CONFIG_AEC62XX_TUNING
-
 struct chipset_bus_clock_list_entry {
 	byte		xfer_speed;
 
@@ -178,6 +231,8 @@ struct chipset_bus_clock_list_entry {
 
 struct chipset_bus_clock_list_entry aec62xx_base [] = {
 #ifdef CONFIG_BLK_DEV_IDEDMA
+	{	XFER_UDMA_6,	0x41,	0x06,	0x31,	0x07	},
+	{	XFER_UDMA_5,	0x41,	0x05,	0x31,	0x06	},
 	{	XFER_UDMA_4,	0x41,	0x04,	0x31,	0x05	},
 	{	XFER_UDMA_3,	0x41,	0x03,	0x31,	0x04	},
 	{	XFER_UDMA_2,	0x41,	0x02,	0x31,	0x03	},
@@ -196,8 +251,6 @@ struct chipset_bus_clock_list_entry aec62xx_base [] = {
 	{	0,		0x00,	0x00,	0x00,	0x00	}
 };
 
-extern char *ide_xfer_verbose (byte xfer_rate);
-
 /*
  * TO DO: active tuning and correction of cards without a bios.
  */
@@ -220,11 +273,34 @@ static byte pci_bus_clock_list_ultra (byte speed, struct chipset_bus_clock_list_
 	return 0x00;
 }
 
+static int aec62xx_ratemask(struct ata_device *drive)
+{
+	struct pci_dev *dev = drive->channel->pci_dev;
+	u32 bmide = pci_resource_start(dev, 4);
+	int map = 0;
+
+	if (!eighty_ninty_three(drive))
+		return XFER_UDMA;
+
+	switch(dev->device) {
+		case PCI_DEVICE_ID_ARTOP_ATP865R:
+		case PCI_DEVICE_ID_ARTOP_ATP865:
+			if (IN_BYTE(bmide+2) & 0x10)
+				map |= XFER_UDMA_133;
+			else
+				map |= XFER_UDMA_100;
+		case PCI_DEVICE_ID_ARTOP_ATP860R:
+		case PCI_DEVICE_ID_ARTOP_ATP860:
+			map |= XFER_UDMA_66;
+		case PCI_DEVICE_ID_ARTOP_ATP850UF:
+			map |= XFER_UDMA;
+	}
+	return map;
+}
+
 static int aec6210_tune_chipset(struct ata_device *drive, byte speed)
 {
-	struct ata_channel *hwif = drive->channel;
-	struct pci_dev *dev	= hwif->pci_dev;
-	int err			= 0;
+	struct pci_dev *dev = drive->channel->pci_dev;
 	unsigned short d_conf	= 0x0000;
 	byte ultra		= 0x00;
 	byte ultra_conf		= 0x00;
@@ -252,17 +328,14 @@ static int aec6210_tune_chipset(struct ata_device *drive, byte speed)
 
 	__restore_flags(flags);	/* local CPU only */
 
-	err = ide_config_drive_speed(drive, speed);
-	return(err);
+	return ide_config_drive_speed(drive, speed);
 }
 
 static int aec6260_tune_chipset(struct ata_device *drive, byte speed)
 {
-	struct ata_channel *hwif = drive->channel;
-	struct pci_dev *dev	= hwif->pci_dev;
+	struct pci_dev *dev = drive->channel->pci_dev;
 	byte unit		= (drive->select.b.unit & 0x01);
-	byte ultra_pci		= hwif->unit ? 0x45 : 0x44;
-	int err			= 0;
+	u8 ultra_pci = drive->channel->unit ? 0x45 : 0x44;
 	byte drive_conf		= 0x00;
 	byte ultra_conf		= 0x00;
 	byte ultra		= 0x00;
@@ -287,128 +360,47 @@ static int aec6260_tune_chipset(struct ata_device *drive, byte speed)
 	if (!drive->init_speed)
 		drive->init_speed = speed;
 
-	err = ide_config_drive_speed(drive, speed);
 	drive->current_speed = speed;
-	return(err);
+	return ide_config_drive_speed(drive, speed);
 }
 
 
 static int aec62xx_tune_chipset(struct ata_device *drive, byte speed)
 {
-	if (drive->channel->pci_dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF) {
-		return ((int) aec6210_tune_chipset(drive, speed));
-	} else {
-		return ((int) aec6260_tune_chipset(drive, speed));
+	switch (drive->channel->pci_dev->device) {
+		case PCI_DEVICE_ID_ARTOP_ATP865:
+		case PCI_DEVICE_ID_ARTOP_ATP865R:
+		case PCI_DEVICE_ID_ARTOP_ATP860:
+		case PCI_DEVICE_ID_ARTOP_ATP860R:
+			return aec6260_tune_chipset(drive, speed);
+		case PCI_DEVICE_ID_ARTOP_ATP850UF:
+			return aec6210_tune_chipset(drive, speed);
+		default:
+			return -1;
 	}
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-static int config_aec6210_chipset_for_dma(struct ata_device *drive, byte ultra)
+static int config_chipset_for_dma(struct ata_device *drive, u8 udma)
 {
-	struct hd_driveid *id	= drive->id;
-	struct ata_channel *hwif = drive->channel;
-	byte unit		= (drive->select.b.unit & 0x01);
-	unsigned long dma_base	= hwif->dma_base;
-	byte speed		= -1;
+	int map;
+	u8 mode;
 
 	if (drive->type != ATA_DISK)
 		return 0;
 
-	if (((id->dma_ultra & 0x0010) ||
-	     (id->dma_ultra & 0x0008) ||
-	     (id->dma_ultra & 0x0004)) && (ultra)) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0002) && (ultra)) {
-		speed = XFER_UDMA_1;
-	} else if ((id->dma_ultra & 0x0001) && (ultra)) {
-		speed = XFER_UDMA_0;
-	} else if (id->dma_mword & 0x0004) {
-		speed = XFER_MW_DMA_2;
-	} else if (id->dma_mword & 0x0002) {
-		speed = XFER_MW_DMA_1;
-	} else if (id->dma_mword & 0x0001) {
-		speed = XFER_MW_DMA_0;
-	} else if (id->dma_1word & 0x0004) {
-		speed = XFER_SW_DMA_2;
-	} else if (id->dma_1word & 0x0002) {
-		speed = XFER_SW_DMA_1;
-	} else if (id->dma_1word & 0x0001) {
-		speed = XFER_SW_DMA_0;
-	} else {
-		return 0;
-	}
-
-	outb(inb(dma_base+2) & ~(1<<(5+unit)), dma_base+2);
-	(void) aec6210_tune_chipset(drive, speed);
-
-	return ((int)	((id->dma_ultra >> 11) & 3) ? 0 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
-}
+	if (udma)
+		map = aec62xx_ratemask(drive);
+	else
+		map = XFER_SWDMA | XFER_MWDMA;
 
-static int config_aec6260_chipset_for_dma(struct ata_device *drive, byte ultra)
-{
-	struct hd_driveid *id	= drive->id;
-	struct ata_channel *hwif = drive->channel;
-	byte unit		= (drive->select.b.unit & 0x01);
-	unsigned long dma_base	= hwif->dma_base;
-	byte speed		= -1;
-	byte ultra66		= eighty_ninty_three(drive);
+	mode = ata_timing_mode(drive, map);
 
-	if (drive->type != ATA_DISK)
+	if (mode < XFER_SW_DMA_0)
 		return 0;
 
-	if ((id->dma_ultra & 0x0010) && (ultra) && (ultra66)) {
-		speed = XFER_UDMA_4;
-	} else if ((id->dma_ultra & 0x0008) && (ultra) && (ultra66)) {
-		speed = XFER_UDMA_3;
-	} else if ((id->dma_ultra & 0x0004) && (ultra)) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0002) && (ultra)) {
-		speed = XFER_UDMA_1;
-	} else if ((id->dma_ultra & 0x0001) && (ultra)) {
-		speed = XFER_UDMA_0;
-	} else if (id->dma_mword & 0x0004) {
-		speed = XFER_MW_DMA_2;
-	} else if (id->dma_mword & 0x0002) {
-		speed = XFER_MW_DMA_1;
-	} else if (id->dma_mword & 0x0001) {
-		speed = XFER_MW_DMA_0;
-	} else if (id->dma_1word & 0x0004) {
-		speed = XFER_SW_DMA_2;
-	} else if (id->dma_1word & 0x0002) {
-		speed = XFER_SW_DMA_1;
-	} else if (id->dma_1word & 0x0001) {
-		speed = XFER_SW_DMA_0;
-	} else {
-		return 0;
-	}
-
-	outb(inb(dma_base+2) & ~(1<<(5+unit)), dma_base+2);
-	(void) aec6260_tune_chipset(drive, speed);
-
-	return ((int)	((id->dma_ultra >> 11) & 3) ? 1 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
-}
-
-static int config_chipset_for_dma(struct ata_device *drive, byte ultra)
-{
-	switch(drive->channel->pci_dev->device) {
-		case PCI_DEVICE_ID_ARTOP_ATP850UF:
-			return config_aec6210_chipset_for_dma(drive, ultra);
-		case PCI_DEVICE_ID_ARTOP_ATP860:
-		case PCI_DEVICE_ID_ARTOP_ATP860R:
-			return config_aec6260_chipset_for_dma(drive, ultra);
-		default:
-			return 0;
-	}
+	return !aec62xx_tune_chipset(drive, mode);
 }
-
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 
 static void aec62xx_tune_drive(struct ata_device *drive, byte pio)
@@ -420,15 +412,7 @@ static void aec62xx_tune_drive(struct ata_device *drive, byte pio)
 	else
 		speed = XFER_PIO_0 + min_t(byte, pio, 4);
 
-	switch(drive->channel->pci_dev->device) {
-		case PCI_DEVICE_ID_ARTOP_ATP850UF:
-			(void) aec6210_tune_chipset(drive, speed);
-		case PCI_DEVICE_ID_ARTOP_ATP860:
-		case PCI_DEVICE_ID_ARTOP_ATP860R:
-			(void) aec6260_tune_chipset(drive, speed);
-		default:
-			break;
-        }
+	(void) aec62xx_tune_chipset(drive, speed);
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
@@ -447,7 +431,7 @@ static int config_drive_xfer_rate(struct ata_device *drive)
 		on = 0;
 		verbose = 0;
 		if (id->field_valid & 4) {
-			if (id->dma_ultra & 0x001F) {
+			if (id->dma_ultra & 0x007F) {
 				/* Force if Capable UltraDMA */
 				on = config_chipset_for_dma(drive, 1);
 				if ((id->field_valid & 2) &&
@@ -490,10 +474,33 @@ int aec62xx_dmaproc(struct ata_device *drive)
 	return config_drive_xfer_rate(drive);
 }
 #endif
-#endif
 
 static unsigned int __init aec62xx_init_chipset(struct pci_dev *dev)
 {
+	u8 reg49h = 0;
+	u8 reg4ah = 0;
+
+	switch(dev->device) {
+		case PCI_DEVICE_ID_ARTOP_ATP865:
+		case PCI_DEVICE_ID_ARTOP_ATP865R:
+			/* Clear reset and test bits.  */
+			pci_read_config_byte(dev, 0x49, &reg49h);
+			pci_write_config_byte(dev, 0x49, reg49h & ~0x30);
+			/* Enable chip interrupt output.  */
+			pci_read_config_byte(dev, 0x4a, &reg4ah);
+			pci_write_config_byte(dev, 0x4a, reg4ah & ~0x01);
+#ifdef CONFIG_AEC6280_BURST
+			/* Must be greater than 0x80 for burst mode.  */
+			pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x90);
+			/* Enable burst mode.  */
+			pci_read_config_byte(dev, 0x4a, &reg4ah);
+			pci_write_config_byte(dev, 0x4a, reg4ah | 0x80);
+#endif
+			break;
+		default:
+			break;
+	}
+
 	if (dev->resource[PCI_ROM_RESOURCE].start) {
 		pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
 		printk("%s: ROM enabled at 0x%08lx\n", dev->name, dev->resource[PCI_ROM_RESOURCE].start);
@@ -522,28 +529,30 @@ static unsigned int __init aec62xx_ata66_check(struct ata_channel *ch)
 
 static void __init aec62xx_init_channel(struct ata_channel *hwif)
 {
-#ifdef CONFIG_AEC62XX_TUNING
 	hwif->tuneproc = aec62xx_tune_drive;
 	hwif->speedproc = aec62xx_tune_chipset;
-# ifdef CONFIG_BLK_DEV_IDEDMA
-	if (hwif->dma_base)
-		hwif->XXX_udma = aec62xx_dmaproc;
-	hwif->highmem = 1;
-# else
 	hwif->drives[0].autotune = 1;
 	hwif->drives[1].autotune = 1;
+
+#ifdef CONFIG_BLK_DEV_IDEDMA
+	if (hwif->dma_base) {
+		hwif->XXX_udma = aec62xx_dmaproc;
+		hwif->highmem = 1;
+# ifdef CONFIG_IDEDMA_AUTO
+		if (!noautodma)
+			hwif->autodma = 1;
 # endif
+	}
 #endif
 }
 
 static void __init aec62xx_init_dma(struct ata_channel *hwif, unsigned long dmabase)
 {
-#ifdef CONFIG_AEC62XX_TUNING
 	u8 reg54h = 0;
 
+	/* FIXME: we need some locking here */
 	pci_read_config_byte(hwif->pci_dev, 0x54, &reg54h);
 	pci_write_config_byte(hwif->pci_dev, 0x54, reg54h & ~(hwif->unit ? 0xF0 : 0x0F));
-#endif
 	ata_init_dma(hwif, dmabase);
 }
 
@@ -579,6 +588,46 @@ static struct ata_pci_device chipsets[] __initdata = {
 		bootable: OFF_BOARD,
 		flags: ATA_F_IRQ | ATA_F_DMA
 	},
+	{
+		vendor: PCI_VENDOR_ID_ARTOP,
+		device: PCI_DEVICE_ID_ARTOP_ATP865,
+		init_chipset: aec62xx_init_chipset,
+		ata66_check: aec62xx_ata66_check,
+		init_channel: aec62xx_init_channel,
+		enablebits: { {0x00,0x00,0x00},	{0x00,0x00,0x00} },
+		bootable: NEVER_BOARD,
+		flags: ATA_F_IRQ | ATA_F_DMA
+	},
+	{
+		vendor: PCI_VENDOR_ID_ARTOP,
+		device: PCI_DEVICE_ID_ARTOP_ATP865R,
+		init_chipset: aec62xx_init_chipset,
+		ata66_check: aec62xx_ata66_check,
+		init_channel: aec62xx_init_channel,
+		enablebits: { {0x00,0x00,0x00},	{0x00,0x00,0x00} },
+		bootable: OFF_BOARD,
+		flags: ATA_F_IRQ | ATA_F_DMA
+	},
+	{
+		vendor: PCI_VENDOR_ID_ARTOP,
+		device: PCI_DEVICE_ID_ARTOP_ATP865,
+		init_chipset: aec62xx_init_chipset,
+		ata66_check: aec62xx_ata66_check,
+		init_channel: aec62xx_init_channel,
+		enablebits: { {0x00,0x00,0x00},	{0x00,0x00,0x00} },
+		bootable: NEVER_BOARD,
+		flags: ATA_F_IRQ | ATA_F_NOADMA | ATA_F_DMA
+	},
+	{
+		vendor: PCI_VENDOR_ID_ARTOP,
+		device: PCI_DEVICE_ID_ARTOP_ATP865R,
+		init_chipset: aec62xx_init_chipset,
+		ata66_check: aec62xx_ata66_check,
+		init_channel: aec62xx_init_channel,
+		enablebits: { {0x4a,0x02,0x02},	{0x4a,0x04,0x04} },
+		bootable: OFF_BOARD,
+		flags: ATA_F_IRQ | ATA_F_DMA
+	},
 };
 
 int __init init_aec62xx(void)
diff --git a/drivers/ide/ali14xx.c b/drivers/ide/ali14xx.c
index a735a8386c34..49b1e42f037a 100644
--- a/drivers/ide/ali14xx.c
+++ b/drivers/ide/ali14xx.c
@@ -106,11 +106,11 @@ static void outReg (byte data, byte reg)
  * This function computes timing parameters
  * and sets controller registers accordingly.
  */
-static void ali14xx_tune_drive (ide_drive_t *drive, byte pio)
+static void ali14xx_tune_drive(struct ata_device *drive, u8 pio)
 {
 	int driveNum;
 	int time1, time2;
-	byte param1, param2, param3, param4;
+	u8 param1, param2, param3, param4;
 	unsigned long flags;
 	struct ata_timing *t;
 
diff --git a/drivers/ide/alim15x3.c b/drivers/ide/alim15x3.c
index 2f0c38f9f0e6..87e5a8a18dd7 100644
--- a/drivers/ide/alim15x3.c
+++ b/drivers/ide/alim15x3.c
@@ -304,14 +304,49 @@ static void ali15x3_tune_drive(struct ata_device *drive, byte pio)
 	__restore_flags(flags);
 }
 
+static byte ali15x3_can_ultra(struct ata_device *drive)
+{
+	if (m5229_revision <= 0x20) {
+		return 0;
+	} else if ((m5229_revision < 0xC2) &&
+#ifndef CONFIG_WDC_ALI15X3
+		((chip_is_1543c_e && strstr(drive->id->model, "WDC ")) ||
+		 (drive->type != ATA_DISK))) {
+#else
+		(drive->type != ATA_DISK)) {
+#endif
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+static int ali15x3_ratemask(struct ata_device *drive)
+{
+	int map = 0;
+
+	if (!ali15x3_can_ultra(drive))
+		return 0;
+
+	map |= XFER_UDMA;
+
+	if (!eighty_ninty_three(drive))
+		return map;
+
+	if (m5229_revision >= 0xC4)
+		map |= XFER_UDMA_100;
+	if (m5229_revision >= 0xC2)
+		map |= XFER_UDMA_66;
+
+	return map;
+}
+
 static int ali15x3_tune_chipset(struct ata_device *drive, byte speed)
 {
-	struct ata_channel *hwif = drive->channel;
-	struct pci_dev *dev	= hwif->pci_dev;
+	struct pci_dev *dev = drive->channel->pci_dev;
 	byte unit		= (drive->select.b.unit & 0x01);
 	byte tmpbyte		= 0x00;
-	int m5229_udma		= hwif->unit ? 0x57 : 0x56;
-	int err			= 0;
+	int m5229_udma		= drive->channel->unit ? 0x57 : 0x56;
 
 	if (speed < XFER_UDMA_0) {
 		byte ultra_enable	= (unit) ? 0x7f : 0xf7;
@@ -323,16 +358,10 @@ static int ali15x3_tune_chipset(struct ata_device *drive, byte speed)
 		pci_write_config_byte(dev, m5229_udma, tmpbyte);
 	}
 
-	err = ide_config_drive_speed(drive, speed);
-
+	if (speed < XFER_SW_DMA_0)
+		ali15x3_tune_drive(drive, speed);
 #ifdef CONFIG_BLK_DEV_IDEDMA
-	if (speed >= XFER_SW_DMA_0) {
-		unsigned long dma_base = hwif->dma_base;
-
-		outb(inb(dma_base+2)|(1<<(5+unit)), dma_base+2);
-	}
-
-	if (speed >= XFER_UDMA_0) {
+	else if (speed >= XFER_UDMA_0) {
 		pci_read_config_byte(dev, m5229_udma, &tmpbyte);
 		tmpbyte &= (0x0f << ((1-unit) << 2));
 		/*
@@ -348,9 +377,11 @@ static int ali15x3_tune_chipset(struct ata_device *drive, byte speed)
 	}
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 
+	if (!drive->init_speed)
+		drive->init_speed = speed;
 	drive->current_speed = speed;
 
-	return (err);
+	return ide_config_drive_speed(drive, speed);
 }
 
 static void config_chipset_for_pio(struct ata_device *drive)
@@ -359,75 +390,21 @@ static void config_chipset_for_pio(struct ata_device *drive)
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-static int config_chipset_for_dma(struct ata_device *drive, byte ultra33)
+static int config_chipset_for_dma(struct ata_device *drive, u8 udma)
 {
-	struct hd_driveid *id	= drive->id;
-	byte speed		= 0x00;
-	byte ultra66		= eighty_ninty_three(drive);
-	byte ultra100		= (m5229_revision>=0xc4) ? 1 : 0;
-	int  rval;
-
-	if ((id->dma_ultra & 0x0020) && (ultra100) && (ultra66) && (ultra33)) {
-		speed = XFER_UDMA_5;
-	} else if ((id->dma_ultra & 0x0010) && (ultra66) && (ultra33)) {
-		speed = XFER_UDMA_4;
-	} else if ((id->dma_ultra & 0x0008) && (ultra66) && (ultra33)) {
-		speed = XFER_UDMA_3;
-	} else if ((id->dma_ultra & 0x0004) && (ultra33)) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0002) && (ultra33)) {
-		speed = XFER_UDMA_1;
-	} else if ((id->dma_ultra & 0x0001) && (ultra33)) {
-		speed = XFER_UDMA_0;
-	} else if (id->dma_mword & 0x0004) {
-		speed = XFER_MW_DMA_2;
-	} else if (id->dma_mword & 0x0002) {
-		speed = XFER_MW_DMA_1;
-	} else if (id->dma_mword & 0x0001) {
-		speed = XFER_MW_DMA_0;
-	} else if (id->dma_1word & 0x0004) {
-		speed = XFER_SW_DMA_2;
-	} else if (id->dma_1word & 0x0002) {
-		speed = XFER_SW_DMA_1;
-	} else if (id->dma_1word & 0x0001) {
-		speed = XFER_SW_DMA_0;
-	} else {
-		return 0;
-	}
-
-	(void) ali15x3_tune_chipset(drive, speed);
-
-	if (!drive->init_speed)
-		drive->init_speed = speed;
-
-	rval = (int)(	((id->dma_ultra >> 11) & 3) ? 1:
-			((id->dma_ultra >> 8) & 7) ? 1:
-			((id->dma_mword >> 8) & 7) ? 1:
-			((id->dma_1word >> 8) & 7) ? 1:
-						     0);
-
-	return rval;
-}
+	int map;
+	u8 mode;
 
-static byte ali15x3_can_ultra(struct ata_device *drive)
-{
-#ifndef CONFIG_WDC_ALI15X3
-	struct hd_driveid *id	= drive->id;
-#endif /* CONFIG_WDC_ALI15X3 */
+	if (udma)
+		map = ali15x3_ratemask(drive);
+	else
+		map = XFER_SWDMA | XFER_MWDMA;
 
-	if (m5229_revision <= 0x20) {
+	mode = ata_timing_mode(drive, map);
+	if (mode < XFER_SW_DMA_0)
 		return 0;
-	} else if ((m5229_revision < 0xC2) &&
-#ifndef CONFIG_WDC_ALI15X3
-		   ((chip_is_1543c_e && strstr(id->model, "WDC ")) ||
-		    (drive->type != ATA_DISK))) {
-#else /* CONFIG_WDC_ALI15X3 */
-		   (drive->type != ATA_DISK)) {
-#endif /* CONFIG_WDC_ALI15X3 */
-		return 0;
-	} else {
-		return 1;
-	}
+
+	return !ali15x3_tune_chipset(drive, mode);
 }
 
 static int ali15x3_config_drive_for_dma(struct ata_device *drive)
diff --git a/drivers/ide/cmd64x.c b/drivers/ide/cmd64x.c
index 79d31a12b1b2..ca1c8bae8cdd 100644
--- a/drivers/ide/cmd64x.c
+++ b/drivers/ide/cmd64x.c
@@ -10,9 +10,9 @@
  *           Due to massive hardware bugs, UltraDMA is only supported
  *           on the 646U2 and not on the 646U.
  *
- * Copyright (C) 1998       Eddie C. Dost  (ecd@skynet.be)
- * Copyright (C) 1998       David S. Miller (davem@redhat.com)
- * Copyright (C) 1999-2000  Andre Hedrick <andre@linux-ide.org>
+ * Copyright (C) 1998		Eddie C. Dost <ecd@skynet.be>
+ * Copyright (C) 1998		David S. Miller <davem@redhat.com>
+ * Copyright (C) 1999-2002	Andre Hedrick <andre@linux-ide.org>
  */
 
 #include <linux/config.h>
@@ -336,6 +336,59 @@ static void cmd64x_tuneproc(struct ata_device *drive, byte mode_wanted)
 		setup_count, active_count, recovery_count);
 }
 
+static int cmd64x_ratemask(struct ata_device *drive)
+{
+	struct pci_dev *dev = drive->channel->pci_dev;
+	int map = 0;
+
+	switch(dev->device) {
+		case PCI_DEVICE_ID_CMD_680:
+			map |= XFER_UDMA_133;
+		case PCI_DEVICE_ID_CMD_649:
+			map |= XFER_UDMA_100;
+		case PCI_DEVICE_ID_CMD_648:
+			map |= XFER_UDMA_66;
+		case PCI_DEVICE_ID_CMD_643:
+			map |= XFER_UDMA;
+			break;
+		case PCI_DEVICE_ID_CMD_646:
+		{
+			unsigned int class_rev	= 0;
+			pci_read_config_dword(dev,
+				PCI_CLASS_REVISION, &class_rev);
+			class_rev &= 0xff;
+		/*
+		 * UltraDMA only supported on PCI646U and PCI646U2, which
+		 * correspond to revisions 0x03, 0x05 and 0x07 respectively.
+		 * Actually, although the CMD tech support people won't
+		 * tell me the details, the 0x03 revision cannot support
+		 * UDMA correctly without hardware modifications, and even
+		 * then it only works with Quantum disks due to some
+		 * hold time assumptions in the 646U part which are fixed
+		 * in the 646U2.
+		 *
+		 * So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
+		 */
+			switch(class_rev) {
+				case 0x07:
+				case 0x05:
+					map |= XFER_UDMA;
+				case 0x03:
+				case 0x01:
+				default:
+					break;
+			}
+		}
+	}
+
+	if (!eighty_ninty_three(drive)) {
+		if (map & XFER_UDMA)
+			return XFER_UDMA;
+		return 0;
+	}
+	return map;
+}
+
 static byte cmd680_taskfile_timing(struct ata_channel *hwif)
 {
 	struct pci_dev *dev	= hwif->pci_dev;
@@ -435,7 +488,6 @@ static int cmd64x_tune_chipset(struct ata_device *drive, byte speed)
 #ifdef CONFIG_BLK_DEV_IDEDMA
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev	= hwif->pci_dev;
-	int err			= 0;
 
 	u8 unit			= (drive->select.b.unit & 0x01);
 	u8 pciU			= (hwif->unit) ? UDIDETCR1 : UDIDETCR0;
@@ -469,9 +521,7 @@ static int cmd64x_tune_chipset(struct ata_device *drive, byte speed)
 		case XFER_SW_DMA_1:	regD |= (unit ? 0x80 : 0x20); break;
 		case XFER_SW_DMA_0:	regD |= (unit ? 0xC0 : 0x30); break;
 #else
-	int err			= 0;
-
-		switch(speed) {
+	switch(speed) {
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 		case XFER_PIO_4:	cmd64x_tuneproc(drive, 4); break;
 		case XFER_PIO_3:	cmd64x_tuneproc(drive, 3); break;
@@ -487,8 +537,8 @@ static int cmd64x_tune_chipset(struct ata_device *drive, byte speed)
 	(void) pci_write_config_byte(dev, pciU, regU);
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 
-	err = ide_config_drive_speed(drive, speed);
-
+	if (!drive->init_speed)
+		drive->init_speed = speed;
 	drive->current_speed = speed;
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
@@ -496,7 +546,7 @@ static int cmd64x_tune_chipset(struct ata_device *drive, byte speed)
 	(void) pci_write_config_byte(dev, pciD, regD);
 #endif /* CONFIG_BLK_DEV_IDEDMA */
 
-	return err;
+	return ide_config_drive_speed(drive, speed);
 }
 
 static int cmd680_tune_chipset(struct ata_device *drive, byte speed)
@@ -511,7 +561,6 @@ static int cmd680_tune_chipset(struct ata_device *drive, byte speed)
 	u8 scsc			= 0;
 	u16 ultra		= 0;
 	u16 multi		= 0;
-	int err			= 0;
 
         pci_read_config_byte(dev, addr_mask, &mode_pci);
 	pci_read_config_byte(dev, 0x8A, &scsc);
@@ -594,7 +643,6 @@ speed_break :
 			return 1;
 	}
 
-	
 	if (speed >= XFER_MW_DMA_0) 
 		config_cmd680_chipset_for_pio(drive, 0);
 
@@ -609,183 +657,47 @@ speed_break :
 	pci_write_config_word(dev, dma_pci, multi);
 	pci_write_config_word(dev, udma_pci, ultra);
 
-	err = ide_config_drive_speed(drive, speed);
+	if (!drive->init_speed)
+		drive->init_speed = speed;
 	drive->current_speed = speed;
-	return err;
+
+	return ide_config_drive_speed(drive, speed);
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-static int config_cmd64x_chipset_for_dma(struct ata_device *drive, unsigned int rev, byte ultra_66)
+static int config_chipset_for_dma(struct ata_device *drive, u8 udma)
 {
-	struct hd_driveid *id	= drive->id;
-	struct ata_channel *hwif = drive->channel;
-	struct pci_dev *dev	= hwif->pci_dev;
-
-	byte speed		= 0x00;
-	byte set_pio		= 0x00;
-	byte udma_33		= ((rev >= 0x05) || (ultra_66)) ? 1 : 0;
-	byte udma_66		= eighty_ninty_three(drive);
-	byte udma_100		= 0;
-	int rval;
-
-	switch(dev->device) {
-		case PCI_DEVICE_ID_CMD_649: udma_100 = 1; break;
-		case PCI_DEVICE_ID_CMD_648:
-		case PCI_DEVICE_ID_CMD_646:
-		case PCI_DEVICE_ID_CMD_643:
-		default:
-			break;
-	}
+	int map;
+	u8 mode;
 
 	if (drive->type != ATA_DISK) {
 		cmdprintk("CMD64X: drive is not a disk at double check, inital check failed!!\n");
 		return 0;
 	}
 
-	/* UltraDMA only supported on PCI646U and PCI646U2,
-	 * which correspond to revisions 0x03, 0x05 and 0x07 respectively.
-	 * Actually, although the CMD tech support people won't
-	 * tell me the details, the 0x03 revision cannot support
-	 * UDMA correctly without hardware modifications, and even
-	 * then it only works with Quantum disks due to some
-	 * hold time assumptions in the 646U part which are fixed
-	 * in the 646U2.
-	 * So we only do UltraDMA on revision 0x05 and 0x07 chipsets.
-	 */
-	if ((id->dma_ultra & 0x0020) && (udma_100) && (udma_66) && (udma_33)) {
-		speed = XFER_UDMA_5;
-	} else if ((id->dma_ultra & 0x0010) && (udma_66) && (udma_33)) {
-		speed = XFER_UDMA_4;
-	} else if ((id->dma_ultra & 0x0008) && (udma_66) && (udma_33)) {
-		speed = XFER_UDMA_3;
-	} else if ((id->dma_ultra & 0x0004) && (udma_33)) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0002) && (udma_33)) {
-		speed = XFER_UDMA_1;
-	} else if ((id->dma_ultra & 0x0001) && (udma_33)) {
-		speed = XFER_UDMA_0;
-	} else if (id->dma_mword & 0x0004) {
-		speed = XFER_MW_DMA_2;
-	} else if (id->dma_mword & 0x0002) {
-		speed = XFER_MW_DMA_1;
-	} else if (id->dma_mword & 0x0001) {
-		speed = XFER_MW_DMA_0;
-	} else if (id->dma_1word & 0x0004) {
-		speed = XFER_SW_DMA_2;
-	} else if (id->dma_1word & 0x0002) {
-		speed = XFER_SW_DMA_1;
-	} else if (id->dma_1word & 0x0001) {
-		speed = XFER_SW_DMA_0;
-	} else {
-		set_pio = 1;
-	}
-
-	if (!drive->init_speed)
-		drive->init_speed = speed;
-
-	config_chipset_for_pio(drive, set_pio);
+	if (udma)
+		map = cmd64x_ratemask(drive);
+	else
+		map = XFER_SWDMA | XFER_MWDMA;
 
-	if (set_pio)
-		return 0;
+	mode = ata_timing_mode(drive, map);
 
-	if (cmd64x_tune_chipset(drive, speed))
+	if (mode < XFER_SW_DMA_0) {
+		config_chipset_for_pio(drive, 1);
 		return 0;
-
-	rval = (int)(	((id->dma_ultra >> 11) & 7) ? 1 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
-
-	return rval;
-}
-
-static int config_cmd680_chipset_for_dma(struct ata_device *drive)
-{
-	struct hd_driveid *id	= drive->id;
-	byte udma_66		= eighty_ninty_three(drive);
-	byte speed		= 0x00;
-	byte set_pio		= 0x00;
-	int rval;
-
-	if ((id->dma_ultra & 0x0040) && (udma_66))	speed = XFER_UDMA_6;
-	else if ((id->dma_ultra & 0x0020) && (udma_66))	speed = XFER_UDMA_5;
-	else if ((id->dma_ultra & 0x0010) && (udma_66))	speed = XFER_UDMA_4;
-	else if ((id->dma_ultra & 0x0008) && (udma_66))	speed = XFER_UDMA_3;
-	else if (id->dma_ultra & 0x0004)		speed = XFER_UDMA_2;
-	else if (id->dma_ultra & 0x0002)		speed = XFER_UDMA_1;
-	else if (id->dma_ultra & 0x0001)		speed = XFER_UDMA_0;
-	else if (id->dma_mword & 0x0004)		speed = XFER_MW_DMA_2;
-	else if (id->dma_mword & 0x0002)		speed = XFER_MW_DMA_1;
-	else if (id->dma_mword & 0x0001)		speed = XFER_MW_DMA_0;
-	else {
-		set_pio = 1;
 	}
 
-	if (!drive->init_speed)
-		drive->init_speed = speed;
-
-	config_chipset_for_pio(drive, set_pio);
-
-	if (set_pio)
-		return 0;
-
-	if (cmd680_tune_chipset(drive, speed))
-		return 0;
-
-	rval = (int)(	((id->dma_ultra >> 14) & 3) ? 1 :
-			((id->dma_ultra >> 11) & 7) ? 1 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
-	return rval;
-}
-
-static int config_chipset_for_dma(struct ata_device *drive, unsigned int rev, byte ultra_66)
-{
-	if (drive->channel->pci_dev->device == PCI_DEVICE_ID_CMD_680)
-		return (config_cmd680_chipset_for_dma(drive));
-	return (config_cmd64x_chipset_for_dma(drive, rev, ultra_66));
+	config_chipset_for_pio(drive, 0);
+	return !drive->channel->speedproc(drive, mode);
 }
 
 static int cmd64x_config_drive_for_dma(struct ata_device *drive)
 {
 	struct hd_driveid *id	= drive->id;
 	struct ata_channel *hwif = drive->channel;
-	struct pci_dev *dev	= hwif->pci_dev;
-	unsigned int class_rev	= 0;
-	byte can_ultra_33	= 0;
-	byte can_ultra_66	= 0;
-	byte can_ultra_100	= 0;
-	byte can_ultra_133	= 0;
 	int on = 1;
 	int verbose = 1;
 
-	pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
-	class_rev &= 0xff;
-
-	switch(dev->device) {
-		case PCI_DEVICE_ID_CMD_680:
-			can_ultra_133 = 1;
-		case PCI_DEVICE_ID_CMD_649:
-			can_ultra_100 = 1;
-		case PCI_DEVICE_ID_CMD_648:
-			can_ultra_66  = 1;
-		case PCI_DEVICE_ID_CMD_643:
-			can_ultra_33  = 1;
-			break;
-		case PCI_DEVICE_ID_CMD_646:
-			can_ultra_33  = (class_rev >= 0x05) ? 1 : 0;
-			can_ultra_66  = 0;
-			can_ultra_100 = 0;
-			break;
-		default:
-			udma_enable(drive, 0, 1);
-
-			return 0;
-	}
-
 	if ((id != NULL) && ((id->capability & 1) != 0) &&
 	    hwif->autodma && (drive->type == ATA_DISK)) {
 		/* Consult the list of known "bad" drives */
@@ -795,10 +707,10 @@ static int cmd64x_config_drive_for_dma(struct ata_device *drive)
 		}
 		on = 0;
 		verbose = 0;
-		if ((id->field_valid & 4) && (can_ultra_33)) {
+		if ((id->field_valid & 4)) {
 			if (id->dma_ultra & 0x007F) {
 				/* Force if Capable UltraDMA */
-				on = config_chipset_for_dma(drive, class_rev, can_ultra_66);
+				on = config_chipset_for_dma(drive, 1);
 				if ((id->field_valid & 2) &&
 				    (!on))
 					goto try_dma_modes;
@@ -808,7 +720,7 @@ try_dma_modes:
 			if ((id->dma_mword & 0x0007) ||
 			    (id->dma_1word & 0x0007)) {
 				/* Force if Capable regular DMA modes */
-				on = config_chipset_for_dma(drive, class_rev, 0);
+				on = config_chipset_for_dma(drive, 0);
 				if (!on)
 					goto no_dma_set;
 			}
@@ -817,7 +729,7 @@ try_dma_modes:
 				goto no_dma_set;
 			}
 			/* Consult the list of known "good" drives */
-			on = config_chipset_for_dma(drive, class_rev, 0);
+			on = config_chipset_for_dma(drive, 0);
 			if (!on)
 				goto no_dma_set;
 		} else {
@@ -1122,14 +1034,13 @@ static void __init cmd64x_init_channel(struct ata_channel *hwif)
 	hwif->drives[0].autotune = 1;
 	hwif->drives[1].autotune = 1;
 
-	if (!hwif->dma_base)
-		return;
-
-#ifdef CONFIG_BLK_DEV_IDEDMA
 	switch(dev->device) {
 		case PCI_DEVICE_ID_CMD_680:
 			hwif->busproc	= cmd680_busproc;
-			hwif->XXX_udma	= cmd680_dmaproc;
+#ifdef CONFIG_BLK_DEV_IDEDMA
+			if (hwif->dma_base)
+				hwif->XXX_udma	= cmd680_dmaproc;
+#endif
 			hwif->resetproc = cmd680_reset;
 			hwif->speedproc	= cmd680_tune_chipset;
 			hwif->tuneproc	= cmd680_tuneproc;
@@ -1137,22 +1048,30 @@ static void __init cmd64x_init_channel(struct ata_channel *hwif)
 		case PCI_DEVICE_ID_CMD_649:
 		case PCI_DEVICE_ID_CMD_648:
 		case PCI_DEVICE_ID_CMD_643:
-			hwif->udma_stop	= cmd64x_udma_stop;
-			hwif->udma_irq_status = cmd64x_udma_irq_status;
-			hwif->XXX_udma	= cmd64x_dmaproc;
+#ifdef CONFIG_BLK_DEV_IDEDMA
+			if (hwif->dma_base) {
+				hwif->XXX_udma	= cmd64x_dmaproc;
+				hwif->udma_stop	= cmd64x_udma_stop;
+				hwif->udma_irq_status = cmd64x_udma_irq_status;
+			}
+#endif
 			hwif->tuneproc	= cmd64x_tuneproc;
 			hwif->speedproc = cmd64x_tune_chipset;
 			break;
 		case PCI_DEVICE_ID_CMD_646:
 			hwif->chipset = ide_cmd646;
-			if (class_rev == 0x01) {
-				hwif->udma_stop = cmd646_1_udma_stop;
-				hwif->XXX_udma = cmd646_1_dmaproc;
-			} else {
-				hwif->udma_stop = cmd64x_udma_stop;
-				hwif->udma_irq_status = cmd64x_udma_irq_status;
-				hwif->XXX_udma = cmd64x_dmaproc;
+#ifdef CONFIG_BLK_DEV_IDEDMA
+			if (hwif->dma_base) {
+				if (class_rev == 0x01) {
+					hwif->XXX_udma = cmd646_1_dmaproc;
+					hwif->udma_stop = cmd646_1_udma_stop;
+				} else {
+					hwif->XXX_udma = cmd64x_dmaproc;
+					hwif->udma_stop = cmd64x_udma_stop;
+					hwif->udma_irq_status = cmd64x_udma_irq_status;
+				}
 			}
+#endif
 			hwif->tuneproc	= cmd64x_tuneproc;
 			hwif->speedproc	= cmd64x_tune_chipset;
 			break;
@@ -1160,7 +1079,14 @@ static void __init cmd64x_init_channel(struct ata_channel *hwif)
 			break;
 	}
 
-	hwif->highmem = 1;
+#ifdef CONFIG_BLK_DEV_IDEDMA
+	if (hwif->dma_base) {
+		hwif->highmem = 1;
+# ifdef CONFIG_IDEDMA_AUTO
+		if (!noautodma)
+			hwif->autodma = 1;
+# endif
+	}
 #endif
 }
 
diff --git a/drivers/ide/hpt34x.c b/drivers/ide/hpt34x.c
index 9096b202e919..e4ff0a4513d0 100644
--- a/drivers/ide/hpt34x.c
+++ b/drivers/ide/hpt34x.c
@@ -111,7 +111,6 @@ static void hpt34x_clear_chipset (ide_drive_t *drive)
 
 static int hpt34x_tune_chipset (ide_drive_t *drive, byte speed)
 {
-	int			err;
 	byte			hi_speed, lo_speed;
 	unsigned int reg1	= 0, tmp1 = 0;
 	unsigned int reg2	= 0, tmp2 = 0;
@@ -129,13 +128,9 @@ static int hpt34x_tune_chipset (ide_drive_t *drive, byte speed)
 	pci_read_config_dword(drive->channel->pci_dev, 0x48, &reg2);
 	tmp1 = ((lo_speed << (3*drive->dn)) | (reg1 & ~(7 << (3*drive->dn))));
 	tmp2 = ((hi_speed << drive->dn) | reg2);
-	err = ide_config_drive_speed(drive, speed);
 	pci_write_config_dword(drive->channel->pci_dev, 0x44, tmp1);
 	pci_write_config_dword(drive->channel->pci_dev, 0x48, tmp2);
 
-	if (!drive->init_speed)
-		drive->init_speed = speed;
-
 #if HPT343_DEBUG_DRIVE_INFO
 	printk("%s: %s drive%d (0x%04x 0x%04x) (0x%04x 0x%04x)" \
 		" (0x%02x 0x%02x) 0x%04x\n",
@@ -144,8 +139,10 @@ static int hpt34x_tune_chipset (ide_drive_t *drive, byte speed)
 		hi_speed, lo_speed, err);
 #endif /* HPT343_DEBUG_DRIVE_INFO */
 
+	if (!drive->init_speed)
+		drive->init_speed = speed;
 	drive->current_speed = speed;
-	return(err);
+	return ide_config_drive_speed(drive, speed);
 }
 
 static void config_chipset_for_pio(ide_drive_t *drive)
@@ -201,55 +198,25 @@ static void hpt34x_tune_drive (ide_drive_t *drive, byte pio)
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-/*
- * This allows the configuration of ide_pci chipset registers
- * for cards that learn about the drive's UDMA, DMA, PIO capabilities
- * after the drive is reported by the OS.  Initally for designed for
- * HPT343 UDMA chipset by HighPoint|Triones Technologies, Inc.
- */
-static int config_chipset_for_dma (ide_drive_t *drive, byte ultra)
+static int config_chipset_for_dma(struct ata_device *drive, u8 udma)
 {
-	struct hd_driveid *id	= drive->id;
-	byte speed		= 0x00;
+	int map;
+	u8 mode;
 
 	if (drive->type != ATA_DISK)
 		return 0;
 
-	hpt34x_clear_chipset(drive);
+	if (udma)
+		map = XFER_UDMA;
+	else
+		map = XFER_SWDMA | XFER_MWDMA;
 
-	if ((id->dma_ultra & 0x0010) && ultra) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0008) && ultra) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0004) && ultra) {
-		speed = XFER_UDMA_2;
-	} else if ((id->dma_ultra & 0x0002) && ultra) {
-		speed = XFER_UDMA_1;
-	} else if ((id->dma_ultra & 0x0001) && ultra) {
-		speed = XFER_UDMA_0;
-	} else if (id->dma_mword & 0x0004) {
-		speed = XFER_MW_DMA_2;
-	} else if (id->dma_mword & 0x0002) {
-		speed = XFER_MW_DMA_1;
-	} else if (id->dma_mword & 0x0001) {
-		speed = XFER_MW_DMA_0;
-	} else if (id->dma_1word & 0x0004) {
-		speed = XFER_SW_DMA_2;
-	} else if (id->dma_1word & 0x0002) {
-		speed = XFER_SW_DMA_1;
-	} else if (id->dma_1word & 0x0001) {
-		speed = XFER_SW_DMA_0;
-        } else {
+	mode = ata_timing_mode(drive, map);
+	if (mode < XFER_SW_DMA_0)
 		return 0;
-	}
 
-	(void) hpt34x_tune_chipset(drive, speed);
-
-	return ((int)	((id->dma_ultra >> 11) & 3) ? 0 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
+	hpt34x_clear_chipset(drive);
+	return !hpt34x_tune_chipset(drive, mode);
 }
 
 static int config_drive_xfer_rate(struct ata_device *drive)
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index cf481f70bc9f..bc33949757df 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -322,7 +322,7 @@
 
 /* Mark that we've seen a media change, and invalidate our internal
    buffers. */
-static void cdrom_saw_media_change (ide_drive_t *drive)
+static void cdrom_saw_media_change(struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
 
@@ -331,8 +331,7 @@ static void cdrom_saw_media_change (ide_drive_t *drive)
 	info->nsectors_buffered = 0;
 }
 
-static
-void cdrom_analyze_sense_data(ide_drive_t *drive, struct request *rq)
+static void cdrom_analyze_sense_data(struct ata_device *drive, struct request *rq)
 {
 	int log = 0;
 	/* FIXME --mdcki */
@@ -516,7 +515,7 @@ void cdrom_analyze_sense_data(ide_drive_t *drive, struct request *rq)
 #endif
 }
 
-static void cdrom_queue_request_sense(ide_drive_t *drive,
+static void cdrom_queue_request_sense(struct ata_device *drive,
 				      struct completion *wait,
 				      struct request_sense *sense,
 				      struct packet_command *failed_command)
@@ -813,7 +812,7 @@ static ide_startstop_t cdrom_transfer_packet_command(struct ata_device *drive,
  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
  * the buffer is cleared.)
  */
-static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
+static void cdrom_buffer_sectors(struct ata_device *drive, unsigned long sector,
                                   int sectors_to_transfer)
 {
 	struct cdrom_info *info = drive->driver_data;
@@ -1381,7 +1380,7 @@ void cdrom_sleep (int time)
 }
 
 static
-int cdrom_queue_packet_command(ide_drive_t *drive, unsigned char *cmd,
+int cdrom_queue_packet_command(struct ata_device *drive, unsigned char *cmd,
 		struct request_sense *sense, struct packet_command *pc)
 {
 	struct request rq;
@@ -1728,7 +1727,7 @@ int msf_to_lba (byte m, byte s, byte f)
 	return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
 }
 
-static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
+static int cdrom_check_status(struct ata_device *drive, struct request_sense *sense)
 {
 	unsigned char cmd[CDROM_PACKET_SIZE];
 	struct packet_command pc;
@@ -1753,7 +1752,7 @@ static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
 
 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
 static int
-cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
+cdrom_lockdoor(struct ata_device *drive, int lockflag, struct request_sense *sense)
 {
 	struct packet_command pc;
 	int stat;
@@ -1795,7 +1794,7 @@ cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
 
 /* Eject the disk if EJECTFLAG is 0.
    If EJECTFLAG is 1, try to reload the disk. */
-static int cdrom_eject(ide_drive_t *drive, int ejectflag,
+static int cdrom_eject(struct ata_device *drive, int ejectflag,
 		       struct request_sense *sense)
 {
 	struct packet_command pc;
@@ -1816,7 +1815,7 @@ static int cdrom_eject(ide_drive_t *drive, int ejectflag,
 	return cdrom_queue_packet_command(drive, cmd, sense, &pc);
 }
 
-static int cdrom_read_capacity(ide_drive_t *drive, u32 *capacity,
+static int cdrom_read_capacity(struct ata_device *drive, u32 *capacity,
 			       struct request_sense *sense)
 {
 	struct {
@@ -1841,7 +1840,7 @@ static int cdrom_read_capacity(ide_drive_t *drive, u32 *capacity,
 	return stat;
 }
 
-static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
+static int cdrom_read_tocentry(struct ata_device *drive, int trackno, int msf_flag,
 				int format, char *buf, int buflen,
 				struct request_sense *sense)
 {
@@ -1868,7 +1867,7 @@ static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
 
 
 /* Try to read the entire TOC for the disk into our internal buffer. */
-static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
+static int cdrom_read_toc(struct ata_device *drive, struct request_sense *sense)
 {
 	int minor, stat, ntracks, i;
 	kdev_t dev;
@@ -2023,7 +2022,7 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
 }
 
 
-static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
+static int cdrom_read_subchannel(struct ata_device *drive, int format, char *buf,
 				 int buflen, struct request_sense *sense)
 {
 	unsigned char cmd[CDROM_PACKET_SIZE];
@@ -2046,7 +2045,7 @@ static int cdrom_read_subchannel(ide_drive_t *drive, int format, char *buf,
 
 /* ATAPI cdrom drives are free to select the speed you request or any slower
    rate :-( Requesting too fast a speed will _not_ produce an error. */
-static int cdrom_select_speed(ide_drive_t *drive, int speed,
+static int cdrom_select_speed(struct ata_device *drive, int speed,
 			      struct request_sense *sense)
 {
 	unsigned char cmd[CDROM_PACKET_SIZE];
@@ -2076,7 +2075,7 @@ static int cdrom_select_speed(ide_drive_t *drive, int speed,
 	return cdrom_queue_packet_command(drive, cmd, sense, &pc);
 }
 
-static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
+static int cdrom_play_audio(struct ata_device *drive, int lba_start, int lba_end)
 {
 	struct request_sense sense;
 	unsigned char cmd[CDROM_PACKET_SIZE];
@@ -2092,7 +2091,7 @@ static int cdrom_play_audio(ide_drive_t *drive, int lba_start, int lba_end)
 	return cdrom_queue_packet_command(drive, cmd, &sense, &pc);
 }
 
-static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
+static int cdrom_get_toc_entry(struct ata_device *drive, int track,
 				struct atapi_toc_entry **ent)
 {
 	struct cdrom_info *info = drive->driver_data;
@@ -2124,7 +2123,7 @@ static int ide_cdrom_packet(struct cdrom_device_info *cdi,
 			    struct cdrom_generic_command *cgc)
 {
 	struct packet_command pc;
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 
 	if (cgc->timeout <= 0)
 		cgc->timeout = WAIT_CMD;
@@ -2196,7 +2195,7 @@ static
 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
 			   unsigned int cmd, void *arg)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	struct cdrom_info *info = drive->driver_data;
 	int stat;
 
@@ -2272,7 +2271,7 @@ int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
 static
 int ide_cdrom_reset (struct cdrom_device_info *cdi)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	struct request_sense sense;
 	struct request req;
 	int ret;
@@ -2295,7 +2294,7 @@ int ide_cdrom_reset (struct cdrom_device_info *cdi)
 static
 int ide_cdrom_tray_move(struct cdrom_device_info *cdi, int position)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	struct request_sense sense;
 
 	if (position) {
@@ -2310,7 +2309,7 @@ int ide_cdrom_tray_move(struct cdrom_device_info *cdi, int position)
 static
 int ide_cdrom_lock_door(struct cdrom_device_info *cdi, int lock)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	struct request_sense sense;
 
 	return cdrom_lockdoor(drive, lock, &sense);
@@ -2319,7 +2318,7 @@ int ide_cdrom_lock_door(struct cdrom_device_info *cdi, int lock)
 static
 int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	struct request_sense sense;
 	int stat;
 
@@ -2333,7 +2332,7 @@ int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
 static
 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 
 	if (slot_nr == CDSL_CURRENT) {
 		struct request_sense sense;
@@ -2368,7 +2367,7 @@ int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
 				struct cdrom_multisession *ms_info)
 {
 	struct atapi_toc *toc;
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	struct cdrom_info *info = drive->driver_data;
 	struct request_sense sense;
 	int ret;
@@ -2390,7 +2389,7 @@ int ide_cdrom_get_mcn (struct cdrom_device_info *cdi,
 {
 	int stat;
 	char mcnbuf[24];
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 
 /* get MCN */
 	if ((stat = cdrom_read_subchannel(drive, 2, mcnbuf, sizeof (mcnbuf), NULL)))
@@ -2414,7 +2413,7 @@ static
 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
 				       int slot_nr)
 {
-	ide_drive_t *drive = (ide_drive_t*) cdi->handle;
+	struct ata_device *drive = (struct ata_device *) cdi->handle;
 	int retval;
 
 	if (slot_nr == CDSL_CURRENT) {
@@ -2472,7 +2471,7 @@ static struct cdrom_device_ops ide_cdrom_dops = {
 	generic_packet:		ide_cdrom_packet,
 };
 
-static int ide_cdrom_register (ide_drive_t *drive, int nslots)
+static int ide_cdrom_register(struct ata_device *drive, int nslots)
 {
 	struct cdrom_info *info = drive->driver_data;
 	struct cdrom_device_info *devinfo = &info->devinfo;
@@ -2518,7 +2517,7 @@ static int ide_cdrom_register (ide_drive_t *drive, int nslots)
 }
 
 static
-int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_page *cap)
+int ide_cdrom_get_capabilities(struct ata_device *drive, struct atapi_capabilities_page *cap)
 {
 	struct cdrom_info *info = drive->driver_data;
 	struct cdrom_device_info *cdi = &info->devinfo;
@@ -2541,7 +2540,7 @@ int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_pag
 	 * registered with the Uniform layer yet, it can't do this.
 	 * Same goes for cdi->ops.
 	 */
-	cdi->handle = (ide_drive_t *) drive;
+	cdi->handle = (struct ata_device *) drive;
 	cdi->ops = &ide_cdrom_dops;
 	init_cdrom_command(&cgc, cap, size, CGC_DATA_UNKNOWN);
 	do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
@@ -2553,7 +2552,7 @@ int ide_cdrom_get_capabilities(ide_drive_t *drive, struct atapi_capabilities_pag
 }
 
 static
-int ide_cdrom_probe_capabilities (ide_drive_t *drive)
+int ide_cdrom_probe_capabilities(struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
 	struct cdrom_device_info *cdi = &info->devinfo;
@@ -2659,8 +2658,7 @@ int ide_cdrom_probe_capabilities (ide_drive_t *drive)
 	return nslots;
 }
 
-static
-int ide_cdrom_setup(ide_drive_t *drive)
+static int ide_cdrom_setup(struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
 	struct cdrom_device_info *cdi = &info->devinfo;
@@ -2797,16 +2795,14 @@ int ide_cdrom_setup(ide_drive_t *drive)
 }
 
 /* Forwarding functions to generic routines. */
-static
-int ide_cdrom_ioctl (ide_drive_t *drive,
+static int ide_cdrom_ioctl (struct ata_device *drive,
 		     struct inode *inode, struct file *file,
 		     unsigned int cmd, unsigned long arg)
 {
 	return cdrom_ioctl (inode, file, cmd, arg);
 }
 
-static
-int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
+static int ide_cdrom_open (struct inode *ip, struct file *fp, struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
 	int rc = -ENOMEM;
@@ -2823,21 +2819,21 @@ int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
 
 static
 void ide_cdrom_release (struct inode *inode, struct file *file,
-			ide_drive_t *drive)
+			struct ata_device *drive)
 {
 	cdrom_release (inode, file);
 	MOD_DEC_USE_COUNT;
 }
 
 static
-int ide_cdrom_check_media_change (ide_drive_t *drive)
+int ide_cdrom_check_media_change(struct ata_device *drive)
 {
 	return cdrom_media_changed(mk_kdev (drive->channel->major,
 			(drive->select.b.unit) << PARTN_BITS));
 }
 
 static
-void ide_cdrom_revalidate (ide_drive_t *drive)
+void ide_cdrom_revalidate(struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
 	struct atapi_toc *toc;
@@ -2868,7 +2864,7 @@ static sector_t ide_cdrom_capacity(struct ata_device *drive)
 }
 
 static
-int ide_cdrom_cleanup(ide_drive_t *drive)
+int ide_cdrom_cleanup(struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
 	struct cdrom_device_info *devinfo = &info->devinfo;
@@ -2910,7 +2906,7 @@ MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
 
 static void __exit ide_cdrom_exit(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	int failed = 0;
 
 	while ((drive = ide_scan_devices(ATA_ROM, "ide-cdrom", &ide_cdrom_driver, failed)) != NULL)
@@ -2922,7 +2918,7 @@ static void __exit ide_cdrom_exit(void)
 
 int ide_cdrom_init(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	struct cdrom_info *info;
 	int failed = 0;
 
diff --git a/drivers/ide/ide-pci.c b/drivers/ide/ide-pci.c
index 1d82e63b9410..52b99257b6a9 100644
--- a/drivers/ide/ide-pci.c
+++ b/drivers/ide/ide-pci.c
@@ -764,7 +764,7 @@ static struct ata_pci_device chipsets[] __initdata = {
 		vendor: PCI_VENDOR_ID_INTEL,
 		device: PCI_DEVICE_ID_INTEL_82371MX,
 		enablebits: {{0x6D,0x80,0x80}, {0x00,0x00,0x00}},
-		bootable: ON_BOARD, 0,
+		bootable: ON_BOARD,
 		flags: ATA_F_NODMA
 	},
 	{
@@ -790,6 +790,19 @@ static struct ata_pci_device chipsets[] __initdata = {
 		device: PCI_DEVICE_ID_VIA_82C561,
 		bootable: ON_BOARD,
 		flags: ATA_F_NOADMA
+	},
+	{
+		vendor: PCI_VENDOR_ID_VIA,
+		device: PCI_DEVICE_ID_VIA_82C586_1,
+		bootable: ON_BOARD,
+		flags: ATA_F_NOADMA
+	},
+	{
+		vendor: PCI_VENDOR_ID_TTI,
+		device: PCI_DEVICE_ID_TTI_HPT366,
+		bootable: OFF_BOARD,
+		extra: 240,
+		flags: ATA_F_IRQ | ATA_F_HPTHACK
 	}
 };
 
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 9b1b2fc0d76d..6c0e20c88965 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -580,10 +580,14 @@ static int init_irq(struct ata_channel *ch)
 	int i;
 	spinlock_t *lock;
 	spinlock_t *new_lock;
+	unsigned long *active;
+	unsigned long *new_active;
 	struct ata_channel *match = NULL;
 
 	/* Spare allocation before sleep. */
 	new_lock = kmalloc(sizeof(*lock), GFP_KERNEL);
+	new_active = kmalloc(sizeof(*active), GFP_KERNEL);
+	*new_active = 0L;
 
 	spin_lock_irqsave(&ide_lock, flags);
 	ch->lock = NULL;
@@ -619,6 +623,7 @@ static int init_irq(struct ata_channel *ch)
 	 */
 	if (!match) {
 		lock = new_lock;
+		active = new_active;
 		if (!lock) {
 			spin_unlock_irqrestore(&ide_lock, flags);
 
@@ -627,6 +632,7 @@ static int init_irq(struct ata_channel *ch)
 		spin_lock_init(lock);
 	} else {
 		lock = match->lock;
+		active = match->active;
 		if(new_lock)
 			kfree(new_lock);
 	}
@@ -645,8 +651,10 @@ static int init_irq(struct ata_channel *ch)
 			OUT_BYTE(0x08, ch->io_ports[IDE_CONTROL_OFFSET]); /* clear nIEN */
 
 		if (request_irq(ch->irq, &ata_irq_request, sa, ch->name, ch)) {
-			if (!match)
+			if (!match) {
 				kfree(lock);
+				kfree(active);
+			}
 
 			spin_unlock_irqrestore(&ide_lock, flags);
 
@@ -658,6 +666,7 @@ static int init_irq(struct ata_channel *ch)
 	 * Everything is okay. Tag us as member of this lock group.
 	 */
 	ch->lock = lock;
+	ch->active = active;
 
 	init_timer(&ch->timer);
 	ch->timer.function = &ide_timer_expiry;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 1b50fd2f0a7d..4f846398b0f4 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -843,7 +843,7 @@ typedef struct {
  *	of type idetape_tape_t, defined below.
  */
 typedef struct {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	devfs_handle_t de_r, de_n;
 
 	/*
@@ -1262,10 +1262,10 @@ typedef union {
 /*
  *	idetape_chrdev_t provides the link between out character device
  *	interface and our block device interface and the corresponding
- *	ide_drive_t structure.
+ *	ata_device structure.
  */
 typedef struct {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 } idetape_chrdev_t;
 
 /*
@@ -1422,7 +1422,7 @@ typedef struct {
 
 /*
  *	The variables below are used for the character device interface.
- *	Additional state variables are defined in our ide_drive_t structure.
+ *	Additional state variables are defined in our ata_device structure.
  */
 static idetape_chrdev_t idetape_chrdevs[MAX_HWIFS * MAX_DRIVES];
 static int idetape_chrdev_present = 0;
@@ -1478,7 +1478,7 @@ char *idetape_command_key_verbose (byte idetape_command_key)
  *      Function declarations
  *
  */
-static void idetape_onstream_mode_sense_tape_parameter_page(ide_drive_t *drive, int debug);
+static void idetape_onstream_mode_sense_tape_parameter_page(struct ata_device *drive, int debug);
 static int idetape_chrdev_release (struct inode *inode, struct file *filp);
 static void idetape_write_release (struct inode *inode);
 
@@ -1486,13 +1486,13 @@ static void idetape_write_release (struct inode *inode);
  *	Too bad. The drive wants to send us data which we are not ready to accept.
  *	Just throw it away.
  */
-static void idetape_discard_data (ide_drive_t *drive, unsigned int bcount)
+static void idetape_discard_data(struct ata_device *drive, unsigned int bcount)
 {
 	while (bcount--)
 		IN_BYTE (IDE_DATA_REG);
 }
 
-static void idetape_input_buffers (ide_drive_t *drive, idetape_pc_t *pc, unsigned int bcount)
+static void idetape_input_buffers(struct ata_device *drive, idetape_pc_t *pc, unsigned int bcount)
 {
 	struct bio *bio = pc->bio;
 	int count;
@@ -1518,7 +1518,7 @@ static void idetape_input_buffers (ide_drive_t *drive, idetape_pc_t *pc, unsigne
 	pc->bio = bio;
 }
 
-static void idetape_output_buffers (ide_drive_t *drive, idetape_pc_t *pc, unsigned int bcount)
+static void idetape_output_buffers(struct ata_device *drive, idetape_pc_t *pc, unsigned int bcount)
 {
 	struct bio *bio = pc->bio;
 	int count;
@@ -1576,7 +1576,7 @@ static void idetape_update_buffers (idetape_pc_t *pc)
  *	driver. A storage space for a maximum of IDETAPE_PC_STACK packet
  *	commands is allocated at initialization time.
  */
-static idetape_pc_t *idetape_next_pc_storage (ide_drive_t *drive)
+static idetape_pc_t *idetape_next_pc_storage(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -1602,7 +1602,7 @@ static idetape_pc_t *idetape_next_pc_storage (ide_drive_t *drive)
  *                                                            *
  **************************************************************/
  
-static struct request *idetape_next_rq_storage (ide_drive_t *drive)
+static struct request *idetape_next_rq_storage(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -1635,7 +1635,7 @@ static void idetape_init_pc (idetape_pc_t *pc)
  *	to analyze the request sense. We currently do not utilize this
  *	information.
  */
-static void idetape_analyze_error (ide_drive_t *drive, idetape_request_sense_result_t *result)
+static void idetape_analyze_error(struct ata_device *drive, idetape_request_sense_result_t *result)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t *pc = tape->failed_pc;
@@ -1697,7 +1697,7 @@ static void idetape_analyze_error (ide_drive_t *drive, idetape_request_sense_res
 	}
 }
 
-static void idetape_abort_pipeline (ide_drive_t *drive)
+static void idetape_abort_pipeline(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage = tape->next_stage;
@@ -1718,7 +1718,7 @@ static void idetape_abort_pipeline (ide_drive_t *drive)
 /*
  *	idetape_active_next_stage will declare the next stage as "active".
  */
-static void idetape_active_next_stage (ide_drive_t *drive)
+static void idetape_active_next_stage(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage = tape->next_stage;
@@ -1749,15 +1749,15 @@ static void idetape_active_next_stage (ide_drive_t *drive)
  *	stages, and if we sense that the pipeline is empty, we try to
  *	increase it, until we reach the user compile time memory limit.
  */
-static void idetape_increase_max_pipeline_stages (ide_drive_t *drive)
+static void idetape_increase_max_pipeline_stages(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int increase = (tape->max_pipeline - tape->min_pipeline) / 10;
-	
+
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_increase_max_pipeline_stages\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	tape->max_stages += increase;
 	tape->max_stages = max(tape->max_stages, tape->min_pipeline);
@@ -1798,19 +1798,19 @@ static void idetape_kfree_stage (idetape_tape_t *tape, idetape_stage_t *stage)
  *	idetape_remove_stage_head removes tape->first_stage from the pipeline.
  *	The caller should avoid race conditions.
  */
-static void idetape_remove_stage_head (ide_drive_t *drive)
+static void idetape_remove_stage_head(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage;
-	
+
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_remove_stage_head\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 #if IDETAPE_DEBUG_BUGS
 	if (tape->first_stage == NULL) {
 		printk (KERN_ERR "ide-tape: bug: tape->first_stage is NULL\n");
-		return;		
+		return;
 	}
 	if (tape->active_stage == tape->first_stage) {
 		printk (KERN_ERR "ide-tape: bug: Trying to free our active pipeline stage\n");
@@ -1981,7 +1981,7 @@ static void idetape_create_request_sense_cmd (idetape_pc_t *pc)
  *	and wait for their completion using idetape_queue_pc_tail or
  *	idetape_queue_rw_tail.
  */
-static void idetape_queue_pc_head (ide_drive_t *drive,idetape_pc_t *pc,struct request *rq)
+static void idetape_queue_pc_head(struct ata_device *drive, idetape_pc_t *pc, struct request *rq)
 {
 	ide_init_drive_cmd (rq);
 	rq->buffer = (char *) pc;
@@ -1994,7 +1994,7 @@ static void idetape_queue_pc_head (ide_drive_t *drive,idetape_pc_t *pc,struct re
  *	last packet command. We queue a request sense packet command in
  *	the head of the request list.
  */
-static ide_startstop_t idetape_retry_pc (ide_drive_t *drive)
+static ide_startstop_t idetape_retry_pc(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t *pc;
@@ -2407,7 +2407,7 @@ static ide_startstop_t idetape_onstream_buffer_fill_callback (struct ata_device
 	return ide_stopped;
 }
 
-static void idetape_queue_onstream_buffer_fill (ide_drive_t *drive)
+static void idetape_queue_onstream_buffer_fill(struct ata_device *drive)
 {
 	idetape_pc_t *pc;
 	struct request *rq;
@@ -2419,7 +2419,7 @@ static void idetape_queue_onstream_buffer_fill (ide_drive_t *drive)
 	idetape_queue_pc_head (drive, pc, rq);
 }
 
-static void calculate_speeds(ide_drive_t *drive)
+static void calculate_speeds(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int full = 125, empty = 75;
@@ -2993,15 +2993,15 @@ static void idetape_switch_buffers (idetape_tape_t *tape, idetape_stage_t *stage
 /*
  *	idetape_add_stage_tail adds a new stage at the end of the pipeline.
  */
-static void idetape_add_stage_tail (ide_drive_t *drive,idetape_stage_t *stage)
+static void idetape_add_stage_tail(struct ata_device *drive, idetape_stage_t *stage)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned long flags;
-	
+
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_add_stage_tail\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 	spin_lock_irqsave(&tape->spinlock, flags);
 	stage->next=NULL;
 	if (tape->last_stage != NULL)
@@ -3019,7 +3019,7 @@ static void idetape_add_stage_tail (ide_drive_t *drive,idetape_stage_t *stage)
 /*
  * Initialize the OnStream AUX
  */
-static void idetape_init_stage (ide_drive_t *drive, idetape_stage_t *stage, int frame_type, int logical_blk_num)
+static void idetape_init_stage(struct ata_device *drive, idetape_stage_t *stage, int frame_type, int logical_blk_num)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	os_aux_t *aux = stage->aux;
@@ -3082,7 +3082,7 @@ static void idetape_init_stage (ide_drive_t *drive, idetape_stage_t *stage, int
  *	The caller should ensure that the request will not be serviced
  *	before we install the completion (usually by disabling interrupts).
  */
-static void idetape_wait_for_request (ide_drive_t *drive, struct request *rq)
+static void idetape_wait_for_request(struct ata_device *drive, struct request *rq)
 {
 	DECLARE_COMPLETION(wait);
 	idetape_tape_t *tape = drive->driver_data;
@@ -3150,7 +3150,7 @@ static ide_startstop_t idetape_read_position_callback(struct ata_device *drive,
  *			if write_filemark=0.
  *
  */
-static void idetape_create_write_filemark_cmd (ide_drive_t *drive, idetape_pc_t *pc,int write_filemark)
+static void idetape_create_write_filemark_cmd(struct ata_device *drive, idetape_pc_t *pc,int write_filemark)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3190,7 +3190,7 @@ static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc)
  *	the request to the request list without waiting for it to be serviced !
  *	In that case, we usually use idetape_queue_pc_head.
  */
-static int __idetape_queue_pc_tail (ide_drive_t *drive, idetape_pc_t *pc)
+static int __idetape_queue_pc_tail(struct ata_device *drive, idetape_pc_t *pc)
 {
 	struct request rq;
 
@@ -3200,7 +3200,7 @@ static int __idetape_queue_pc_tail (ide_drive_t *drive, idetape_pc_t *pc)
 	return ide_do_drive_cmd(drive, &rq, ide_wait);
 }
 
-static void idetape_create_load_unload_cmd (ide_drive_t *drive, idetape_pc_t *pc,int cmd)
+static void idetape_create_load_unload_cmd(struct ata_device *drive, idetape_pc_t *pc,int cmd)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3216,7 +3216,7 @@ static void idetape_create_load_unload_cmd (ide_drive_t *drive, idetape_pc_t *pc
 	pc->callback = idetape_pc_callback;
 }
 
-static int idetape_wait_ready (ide_drive_t *drive, unsigned long long timeout)
+static int idetape_wait_ready(struct ata_device *drive, unsigned long long timeout)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
@@ -3239,12 +3239,12 @@ static int idetape_wait_ready (ide_drive_t *drive, unsigned long long timeout)
 		if (!(tape->sense_key == 2 && tape->asc == 4 && (tape->ascq == 1 || tape->ascq == 8)))
 			break;
 		current->state = TASK_INTERRUPTIBLE;
-  		schedule_timeout(HZ / 10);
+		schedule_timeout(HZ / 10);
 	}
 	return -EIO;
 }
 
-static int idetape_queue_pc_tail (ide_drive_t *drive,idetape_pc_t *pc)
+static int idetape_queue_pc_tail(struct ata_device *drive, idetape_pc_t *pc)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int rc;
@@ -3258,7 +3258,7 @@ static int idetape_queue_pc_tail (ide_drive_t *drive,idetape_pc_t *pc)
 	return rc;
 }
 
-static int idetape_flush_tape_buffers (ide_drive_t *drive)
+static int idetape_flush_tape_buffers(struct ata_device *drive)
 {
 	idetape_pc_t pc;
 	int rc;
@@ -3278,7 +3278,7 @@ static void idetape_create_read_position_cmd (idetape_pc_t *pc)
 	pc->callback = idetape_read_position_callback;
 }
 
-static int idetape_read_position (ide_drive_t *drive)
+static int idetape_read_position(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
@@ -3311,7 +3311,7 @@ static int idetape_read_position (ide_drive_t *drive)
 	return position;
 }
 
-static void idetape_create_locate_cmd (ide_drive_t *drive, idetape_pc_t *pc, unsigned int block, byte partition, int skip)
+static void idetape_create_locate_cmd(struct ata_device *drive, idetape_pc_t *pc, unsigned int block, byte partition, int skip)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3334,7 +3334,7 @@ static void idetape_create_locate_cmd (ide_drive_t *drive, idetape_pc_t *pc, uns
 	pc->callback = idetape_pc_callback;
 }
 
-static int idetape_create_prevent_cmd (ide_drive_t *drive, idetape_pc_t *pc, int prevent)
+static int idetape_create_prevent_cmd(struct ata_device *drive, idetape_pc_t *pc, int prevent)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3348,7 +3348,7 @@ static int idetape_create_prevent_cmd (ide_drive_t *drive, idetape_pc_t *pc, int
 	return 1;
 }
 
-static int __idetape_discard_read_pipeline (ide_drive_t *drive)
+static int __idetape_discard_read_pipeline(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned long flags;
@@ -3387,9 +3387,9 @@ static int __idetape_discard_read_pipeline (ide_drive_t *drive)
  *
  *	Like all higher level operations, we queue the commands at the tail
  *	of the request queue and wait for their completion.
- *	
+ *
  */
-static int idetape_position_tape (ide_drive_t *drive, unsigned int block, byte partition, int skip)
+static int idetape_position_tape(struct ata_device *drive, unsigned int block, byte partition, int skip)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int retval;
@@ -3407,7 +3407,7 @@ static int idetape_position_tape (ide_drive_t *drive, unsigned int block, byte p
 	return (idetape_queue_pc_tail (drive, &pc));
 }
 
-static void idetape_discard_read_pipeline (ide_drive_t *drive, int restore_position)
+static void idetape_discard_read_pipeline(struct ata_device *drive, int restore_position)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int cnt;
@@ -3428,7 +3428,7 @@ static void idetape_discard_read_pipeline (ide_drive_t *drive, int restore_posit
 	}
 }
 
-static void idetape_update_stats (ide_drive_t *drive)
+static void idetape_update_stats(struct ata_device *drive)
 {
 	idetape_pc_t pc;
 
@@ -3441,7 +3441,7 @@ static void idetape_update_stats (ide_drive_t *drive)
  *	idetape_queue_rw_tail generates a read/write request for the block
  *	device interface and wait for it to be serviced.
  */
-static int idetape_queue_rw_tail (ide_drive_t *drive, int cmd, int blocks, struct bio *bio)
+static int idetape_queue_rw_tail(struct ata_device *drive, int cmd, int blocks, struct bio *bio)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	struct request rq;
@@ -3481,7 +3481,7 @@ static int idetape_queue_rw_tail (ide_drive_t *drive, int cmd, int blocks, struc
  * of the write error recovery mechanism for old OnStream
  * firmware revisions.
  */
-static void idetape_onstream_read_back_buffer (ide_drive_t *drive)
+static void idetape_onstream_read_back_buffer(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int frames, i, logical_blk_num;
@@ -3535,7 +3535,7 @@ static void idetape_onstream_read_back_buffer (ide_drive_t *drive)
 /*
  * Error recovery algorithm for the OnStream tape.
  */
-static void idetape_onstream_write_error_recovery (ide_drive_t *drive)
+static void idetape_onstream_write_error_recovery(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned int block;
@@ -3545,7 +3545,7 @@ static void idetape_onstream_write_error_recovery (ide_drive_t *drive)
 			tape->name, ntohl(tape->sense.information), tape->logical_blk_num,
 			tape->first_frame_position, tape->last_frame_position,
 			tape->blocks_in_buffer, tape->nr_stages,
- 			(ntohl(tape->sense.command_specific) >> 16) & 0xff );
+			(ntohl(tape->sense.command_specific) >> 16) & 0xff );
 		block = ntohl(tape->sense.information) + ((ntohl(tape->sense.command_specific) >> 16) & 0xff);
 		idetape_update_stats(drive);
 		printk(KERN_ERR "ide-tape: %s: relocating %d buffered logical blocks to physical block %u\n", tape->name, tape->cur_frames, block);
@@ -3572,7 +3572,7 @@ static void idetape_onstream_write_error_recovery (ide_drive_t *drive)
 #endif
 		idetape_flush_tape_buffers(drive);
 		block = idetape_read_position(drive);
-		if (block != OS_DATA_ENDFRAME1)  
+		if (block != OS_DATA_ENDFRAME1)
 			printk(KERN_ERR "ide-tape: warning, current position %d, expected %d\n", block, OS_DATA_ENDFRAME1);
 		idetape_position_tape(drive, 0xbb8, 0, 0); /* 3000 */
 	}
@@ -3583,7 +3583,7 @@ static void idetape_onstream_write_error_recovery (ide_drive_t *drive)
  *	idetape_insert_pipeline_into_queue is used to start servicing the
  *	pipeline stages, starting from tape->next_stage.
  */
-static void idetape_insert_pipeline_into_queue (ide_drive_t *drive)
+static void idetape_insert_pipeline_into_queue(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3606,7 +3606,7 @@ static void idetape_create_inquiry_cmd (idetape_pc_t *pc)
 	pc->callback = idetape_pc_callback;
 }
 
-static void idetape_create_rewind_cmd (ide_drive_t *drive, idetape_pc_t *pc)
+static void idetape_create_rewind_cmd(struct ata_device *drive, idetape_pc_t *pc)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3651,7 +3651,7 @@ static void idetape_create_space_cmd (idetape_pc_t *pc,int count,byte cmd)
 /*
  * Verify that we have the correct tape frame
  */
-static int idetape_verify_stage (ide_drive_t *drive, idetape_stage_t *stage, int logical_blk_num, int quiet)
+static int idetape_verify_stage(struct ata_device *drive, idetape_stage_t *stage, int logical_blk_num, int quiet)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	os_aux_t *aux = stage->aux;
@@ -3724,7 +3724,7 @@ static int idetape_verify_stage (ide_drive_t *drive, idetape_stage_t *stage, int
 	return 1;
 }
 
-static void idetape_wait_first_stage (ide_drive_t *drive)
+static void idetape_wait_first_stage(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned long flags;
@@ -3748,7 +3748,7 @@ static void idetape_wait_first_stage (ide_drive_t *drive)
  *	3.	If we still can't allocate a stage, fallback to
  *		non-pipelined operation mode for this request.
  */
-static int idetape_add_chrdev_write_request (ide_drive_t *drive, int blocks)
+static int idetape_add_chrdev_write_request(struct ata_device *drive, int blocks)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *new_stage;
@@ -3836,7 +3836,7 @@ static int idetape_add_chrdev_write_request (ide_drive_t *drive, int blocks)
  *	idetape_wait_for_pipeline will wait until all pending pipeline
  *	requests are serviced. Typically called on device close.
  */
-static void idetape_wait_for_pipeline (ide_drive_t *drive)
+static void idetape_wait_for_pipeline(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned long flags;
@@ -3850,7 +3850,7 @@ static void idetape_wait_for_pipeline (ide_drive_t *drive)
 	}
 }
 
-static void idetape_empty_write_pipeline (ide_drive_t *drive)
+static void idetape_empty_write_pipeline(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int blocks, i, min;
@@ -3916,7 +3916,7 @@ static void idetape_empty_write_pipeline (ide_drive_t *drive)
 #endif /* IDETAPE_DEBUG_BUGS */
 }
 
-static void idetape_restart_speed_control (ide_drive_t *drive)
+static void idetape_restart_speed_control(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -3931,7 +3931,7 @@ static void idetape_restart_speed_control (ide_drive_t *drive)
 	tape->controlled_previous_head_time = tape->uncontrolled_previous_head_time = jiffies;
 }
 
-static int idetape_initiate_read (ide_drive_t *drive, int max_stages)
+static int idetape_initiate_read(struct ata_device *drive, int max_stages)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *new_stage;
@@ -4000,7 +4000,7 @@ static int idetape_initiate_read (ide_drive_t *drive, int max_stages)
 	return 0;
 }
 
-static int idetape_get_logical_blk (ide_drive_t *drive, int logical_blk_num, int max_stages, int quiet)
+static int idetape_get_logical_blk(struct ata_device *drive, int logical_blk_num, int max_stages, int quiet)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned long flags;
@@ -4071,7 +4071,7 @@ static int idetape_get_logical_blk (ide_drive_t *drive, int logical_blk_num, int
  *	to service a character device read request and add read-ahead
  *	requests to our pipeline.
  */
-static int idetape_add_chrdev_read_request (ide_drive_t *drive,int blocks)
+static int idetape_add_chrdev_read_request(struct ata_device *drive,int blocks)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned long flags;
@@ -4145,12 +4145,12 @@ static int idetape_add_chrdev_read_request (ide_drive_t *drive,int blocks)
 	return (bytes_read);
 }
 
-static void idetape_pad_zeros (ide_drive_t *drive, int bcount)
+static void idetape_pad_zeros(struct ata_device *drive, int bcount)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	struct bio *bio;
 	int count, blocks;
-	
+
 	while (bcount) {
 		bio = tape->merge_stage->bio;
 		count = min(tape->stage_size, bcount);
@@ -4166,7 +4166,7 @@ static void idetape_pad_zeros (ide_drive_t *drive, int bcount)
 	}
 }
 
-static int idetape_pipeline_size (ide_drive_t *drive)
+static int idetape_pipeline_size(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage;
@@ -4190,8 +4190,8 @@ static int idetape_pipeline_size (ide_drive_t *drive)
  *	Rewinds the tape to the Beginning Of the current Partition (BOP).
  *
  *	We currently support only one partition.
- */ 
-static int idetape_rewind_tape (ide_drive_t *drive)
+ */
+static int idetape_rewind_tape(struct ata_device *drive)
 {
 	int retval;
 	idetape_pc_t pc;
@@ -4199,8 +4199,8 @@ static int idetape_rewind_tape (ide_drive_t *drive)
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 2)
 		printk (KERN_INFO "ide-tape: Reached idetape_rewind_tape\n");
-#endif /* IDETAPE_DEBUG_LOG */	
-	
+#endif
+
 	idetape_create_rewind_cmd (drive, &pc);
 	retval = idetape_queue_pc_tail (drive, &pc);
 	if (retval)
@@ -4221,16 +4221,16 @@ static int idetape_rewind_tape (ide_drive_t *drive)
  *	mtio.h compatible commands should be issued to the character device
  *	interface.
  */
-static int idetape_blkdev_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
+static int idetape_blkdev_ioctl(struct ata_device *drive, struct inode *inode, struct file *file,
 				 unsigned int cmd, unsigned long arg)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_config_t config;
 
-#if IDETAPE_DEBUG_LOG	
+#if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_blkdev_ioctl\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 	switch (cmd) {
 		case 0x0340:
 			if (copy_from_user ((char *) &config, (char *) arg, sizeof (idetape_config_t)))
@@ -4240,7 +4240,7 @@ static int idetape_blkdev_ioctl (ide_drive_t *drive, struct inode *inode, struct
 			break;
 		case 0x0350:
 			config.dsc_rw_frequency = (int) tape->best_dsc_rw_frequency;
-			config.nr_stages = tape->max_stages; 
+			config.nr_stages = tape->max_stages;
 			if (copy_to_user ((char *) arg, (char *) &config, sizeof (idetape_config_t)))
 				return -EFAULT;
 			break;
@@ -4255,7 +4255,7 @@ static int idetape_blkdev_ioctl (ide_drive_t *drive, struct inode *inode, struct
  *	However, we still allow opening it so that we can issue general
  *	ide driver configuration ioctl's, such as the interrupt unmask feature.
  */
-static int idetape_blkdev_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
+static int idetape_blkdev_open(struct inode *inode, struct file *filp, struct ata_device *drive)
 {
 	MOD_INC_USE_COUNT;
 #if ONSTREAM_DEBUG
@@ -4264,7 +4264,7 @@ static int idetape_blkdev_open (struct inode *inode, struct file *filp, ide_driv
 	return 0;
 }
 
-static void idetape_blkdev_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
+static void idetape_blkdev_release(struct inode *inode, struct file *filp, struct ata_device *drive)
 {
 	MOD_DEC_USE_COUNT;
 #if ONSTREAM_DEBUG
@@ -4275,7 +4275,7 @@ static void idetape_blkdev_release (struct inode *inode, struct file *filp, ide_
 /*
  *	Character device interface functions
  */
-static ide_drive_t *get_drive_ptr (kdev_t i_rdev)
+static struct ata_device *get_drive_ptr (kdev_t i_rdev)
 {
 	unsigned int i = minor(i_rdev) & ~0xc0;
 
@@ -4284,7 +4284,7 @@ static ide_drive_t *get_drive_ptr (kdev_t i_rdev)
 	return (idetape_chrdevs[i].drive);
 }
 
-static int idetape_onstream_space_over_filemarks_backward (ide_drive_t *drive,short mt_op,int mt_count)
+static int idetape_onstream_space_over_filemarks_backward(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int cnt = 0;
@@ -4328,7 +4328,7 @@ static int idetape_onstream_space_over_filemarks_backward (ide_drive_t *drive,sh
  *
  * Just scans for the filemark sequentially.
  */
-static int idetape_onstream_space_over_filemarks_forward_slow (ide_drive_t *drive,short mt_op,int mt_count)
+static int idetape_onstream_space_over_filemarks_forward_slow(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int cnt = 0;
@@ -4371,7 +4371,7 @@ static int idetape_onstream_space_over_filemarks_forward_slow (ide_drive_t *driv
 /*
  * Fast linux specific version of OnStream FSF
  */
-static int idetape_onstream_space_over_filemarks_forward_fast (ide_drive_t *drive,short mt_op,int mt_count)
+static int idetape_onstream_space_over_filemarks_forward_fast(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int cnt = 0, next_mark_addr;
@@ -4455,7 +4455,7 @@ static int idetape_onstream_space_over_filemarks_forward_fast (ide_drive_t *driv
  *	the filemark is in our internal pipeline even if the tape doesn't
  *	support spacing over filemarks in the reverse direction.
  */
-static int idetape_space_over_filemarks (ide_drive_t *drive,short mt_op,int mt_count)
+static int idetape_space_over_filemarks(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
@@ -4563,7 +4563,7 @@ static ssize_t idetape_chrdev_read (struct file *file, char *buf,
 				    size_t count, loff_t *ppos)
 {
 	struct inode *inode = file->f_dentry->d_inode;
-	ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
+	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
 	idetape_tape_t *tape = drive->driver_data;
 	ssize_t bytes_read,temp, actually_read = 0, rc;
 
@@ -4632,7 +4632,7 @@ finish:
 	return actually_read;
 }
 
-static void idetape_update_last_marker (ide_drive_t *drive, int last_mark_addr, int next_mark_addr)
+static void idetape_update_last_marker(struct ata_device *drive, int last_mark_addr, int next_mark_addr)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage;
@@ -4686,7 +4686,7 @@ static void idetape_update_last_marker (ide_drive_t *drive, int last_mark_addr,
 	return;
 }
 
-static void idetape_write_filler (ide_drive_t *drive, int block, int cnt)
+static void idetape_write_filler(struct ata_device *drive, int block, int cnt)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage;
@@ -4717,7 +4717,7 @@ static void idetape_write_filler (ide_drive_t *drive, int block, int cnt)
 	__idetape_kfree_stage (stage);
 }
 
-static void __idetape_write_header (ide_drive_t *drive, int block, int cnt)
+static void __idetape_write_header(struct ata_device *drive, int block, int cnt)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage;
@@ -4752,7 +4752,7 @@ static void __idetape_write_header (ide_drive_t *drive, int block, int cnt)
 	idetape_flush_tape_buffers (drive);
 }
 
-static void idetape_write_header (ide_drive_t *drive, int locate_eod)
+static void idetape_write_header(struct ata_device *drive, int locate_eod)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -4778,7 +4778,7 @@ static ssize_t idetape_chrdev_write (struct file *file, const char *buf,
 				     size_t count, loff_t *ppos)
 {
 	struct inode *inode = file->f_dentry->d_inode;
-	ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
+	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
 	idetape_tape_t *tape = drive->driver_data;
 	ssize_t retval, actually_written = 0;
 	int position;
@@ -4914,7 +4914,7 @@ static ssize_t idetape_chrdev_write (struct file *file, const char *buf,
 	return (actually_written);
 }
 
-static int idetape_write_filemark (ide_drive_t *drive)
+static int idetape_write_filemark(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int last_mark_addr;
@@ -4945,7 +4945,7 @@ static int idetape_write_filemark (ide_drive_t *drive)
 	return 0;
 }
 
-static void idetape_write_eod (ide_drive_t *drive)
+static void idetape_write_eod(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -4962,7 +4962,7 @@ static void idetape_write_eod (ide_drive_t *drive)
 	return;
 }
 
-int idetape_seek_logical_blk (ide_drive_t *drive, int logical_blk_num)
+int idetape_seek_logical_blk(struct ata_device *drive, int logical_blk_num)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int estimated_address = logical_blk_num + 20;
@@ -5022,7 +5022,7 @@ ok:
  *		In this case, MTFSFM is also usually not supported (it is
  *		supported in the rare case in which we crossed the filemark
  *		during our read-ahead pipelined operation mode).
- *		
+ *
  *	MTWEOF	-	Writes mt_count filemarks. Tape is positioned after
  *			the last written filemark.
  *
@@ -5042,7 +5042,7 @@ ok:
  *
  *	MTERASE	-	Erases tape.
  *
- *	MTSETBLK - 	Sets the user block size to mt_count bytes. If
+ *	MTSETBLK -	Sets the user block size to mt_count bytes. If
  *			mt_count is 0, we will attempt to autodetect
  *			the block size.
  *
@@ -5050,18 +5050,18 @@ ok:
  *			each block is assumed to contain which user_block_size
  *			bytes.
  *
- *	MTSETPART - 	Switches to another tape partition.
+ *	MTSETPART -	Switches to another tape partition.
  *
- *	MTLOCK - 	Locks the tape door.
+ *	MTLOCK -	Locks the tape door.
  *
- *	MTUNLOCK - 	Unlocks the tape door.
+ *	MTUNLOCK -	Unlocks the tape door.
  *
  *	The following commands are currently not supported:
  *
  *	MTFSS, MTBSS, MTWSM, MTSETDENSITY,
  *	MTSETDRVBUFFER, MT_ST_BOOLEANS, MT_ST_WRITE_THRESHOLD.
  */
-static int idetape_mtioctop (ide_drive_t *drive,short mt_op,int mt_count)
+static int idetape_mtioctop(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
@@ -5237,7 +5237,7 @@ static int idetape_mtioctop (ide_drive_t *drive,short mt_op,int mt_count)
  */
 static int idetape_chrdev_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
-	ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
+	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
 	idetape_tape_t *tape = drive->driver_data;
 	struct mtop mtop;
 	struct mtget mtget;
@@ -5303,7 +5303,7 @@ static int idetape_chrdev_ioctl (struct inode *inode, struct file *file, unsigne
 	}
 }
 
-static int __idetape_analyze_headers (ide_drive_t *drive, int block)
+static int __idetape_analyze_headers(struct ata_device *drive, int block)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_stage_t *stage;
@@ -5369,7 +5369,7 @@ static int __idetape_analyze_headers (ide_drive_t *drive, int block)
 	return 1;
 }
 
-static int idetape_analyze_headers (ide_drive_t *drive)
+static int idetape_analyze_headers(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int position, block;
@@ -5401,15 +5401,15 @@ ok:
  */
 static int idetape_chrdev_open (struct inode *inode, struct file *filp)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	idetape_tape_t *tape;
 	idetape_pc_t pc;
 	unsigned int minor=minor(inode->i_rdev);
-			
+
 #if IDETAPE_DEBUG_LOG
 	printk (KERN_INFO "ide-tape: Reached idetape_chrdev_open\n");
-#endif /* IDETAPE_DEBUG_LOG */
-	
+#endif
+
 	if ((drive = get_drive_ptr (inode->i_rdev)) == NULL)
 		return -ENXIO;
 	tape = drive->driver_data;
@@ -5459,7 +5459,7 @@ static int idetape_chrdev_open (struct inode *inode, struct file *filp)
 
 static void idetape_write_release (struct inode *inode)
 {
-	ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
+	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
 	idetape_tape_t *tape = drive->driver_data;
 	unsigned int minor=minor(inode->i_rdev);
 
@@ -5484,7 +5484,7 @@ static void idetape_write_release (struct inode *inode)
  */
 static int idetape_chrdev_release (struct inode *inode, struct file *filp)
 {
-	ide_drive_t *drive = get_drive_ptr (inode->i_rdev);
+	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
 	idetape_tape_t *tape;
 	idetape_pc_t pc;
 	unsigned int minor=minor(inode->i_rdev);
@@ -5529,9 +5529,9 @@ static int idetape_chrdev_release (struct inode *inode, struct file *filp)
  *	1	If the tape can be supported by us, based on the information
  *		we have so far.
  *
- *	0 	If this tape driver is not currently supported by us.
+ *	0	If this tape driver is not currently supported by us.
  */
-static int idetape_identify_device (ide_drive_t *drive,struct hd_driveid *id)
+static int idetape_identify_device(struct ata_device *drive,struct hd_driveid *id)
 {
 	struct idetape_id_gcw gcw;
 #if IDETAPE_DEBUG_INFO
@@ -5653,7 +5653,7 @@ static int idetape_identify_device (ide_drive_t *drive,struct hd_driveid *id)
 /*
  * Notify vendor ID to the OnStream tape drive
  */
-static void idetape_onstream_set_vendor (ide_drive_t *drive, char *vendor)
+static void idetape_onstream_set_vendor(struct ata_device *drive, char *vendor)
 {
 	idetape_pc_t pc;
 	idetape_mode_parameter_header_t *header;
@@ -5680,7 +5680,7 @@ static void idetape_onstream_set_vendor (ide_drive_t *drive, char *vendor)
  * Various unused OnStream commands
  */
 #if ONSTREAM_DEBUG
-static void idetape_onstream_set_retries (ide_drive_t *drive, int retries)
+static void idetape_onstream_set_retries(struct ata_device *drive, int retries)
 {
 	idetape_pc_t pc;
 
@@ -5701,7 +5701,7 @@ static void idetape_onstream_set_retries (ide_drive_t *drive, int retries)
 /*
  * Configure 32.5KB block size.
  */
-static void idetape_onstream_configure_block_size (ide_drive_t *drive)
+static void idetape_onstream_configure_block_size(struct ata_device *drive)
 {
 	idetape_pc_t pc;
 	idetape_mode_parameter_header_t *header;
@@ -5747,13 +5747,13 @@ static void idetape_onstream_configure_block_size (ide_drive_t *drive)
 /*
  * Use INQUIRY to get the firmware revision
  */
-static void idetape_get_inquiry_results (ide_drive_t *drive)
+static void idetape_get_inquiry_results(struct ata_device *drive)
 {
 	char *r;
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
 	idetape_inquiry_result_t *inquiry;
-	
+
 	idetape_create_inquiry_cmd(&pc);
 	if (idetape_queue_pc_tail (drive, &pc)) {
 		printk (KERN_ERR "ide-tape: %s: can't get INQUIRY results\n", tape->name);
@@ -5777,7 +5777,7 @@ static void idetape_get_inquiry_results (ide_drive_t *drive)
 /*
  * Configure the OnStream ATAPI tape drive for default operation
  */
-static void idetape_configure_onstream (ide_drive_t *drive)
+static void idetape_configure_onstream(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -5801,7 +5801,7 @@ static void idetape_configure_onstream (ide_drive_t *drive)
  *	idetape_get_mode_sense_parameters asks the tape about its various
  *	parameters. This may work for other drives to???
  */
-static void idetape_onstream_mode_sense_tape_parameter_page(ide_drive_t *drive, int debug)
+static void idetape_onstream_mode_sense_tape_parameter_page(struct ata_device *drive, int debug)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
@@ -5830,13 +5830,13 @@ static void idetape_onstream_mode_sense_tape_parameter_page(ide_drive_t *drive,
  *	parameters. In particular, we will adjust our data transfer buffer
  *	size to the recommended value as returned by the tape.
  */
-static void idetape_get_mode_sense_results (ide_drive_t *drive)
+static void idetape_get_mode_sense_results(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
 	idetape_mode_parameter_header_t *header;
 	idetape_capabilities_page_t *capabilities;
-	
+
 	idetape_create_mode_sense_cmd (&pc, IDETAPE_CAPABILITIES_PAGE);
 	if (idetape_queue_pc_tail (drive, &pc)) {
 		printk (KERN_ERR "ide-tape: Can't get tape parameters - assuming some default values\n");
@@ -5895,7 +5895,7 @@ static void idetape_get_mode_sense_results (ide_drive_t *drive)
 	printk (KERN_INFO "ide-tape: Supports 32768 bytes block size / Restricted byte count for PIO transfers - %s\n",capabilities->blk32768 ? "Yes":"No");
 	printk (KERN_INFO "ide-tape: Maximum supported speed in KBps - %d\n",capabilities->max_speed);
 	printk (KERN_INFO "ide-tape: Continuous transfer limits in blocks - %d\n",capabilities->ctl);
-	printk (KERN_INFO "ide-tape: Current speed in KBps - %d\n",capabilities->speed);	
+	printk (KERN_INFO "ide-tape: Current speed in KBps - %d\n",capabilities->speed);
 	printk (KERN_INFO "ide-tape: Buffer size - %d\n",capabilities->buffer_size*512);
 #endif /* IDETAPE_DEBUG_INFO */
 }
@@ -5904,14 +5904,14 @@ static void idetape_get_mode_sense_results (ide_drive_t *drive)
  *	ide_get_blocksize_from_block_descriptor does a mode sense page 0 with block descriptor
  *	and if it succeeds sets the tape block size with the reported value
  */
-static void idetape_get_blocksize_from_block_descriptor(ide_drive_t *drive)
+static void idetape_get_blocksize_from_block_descriptor(struct ata_device *drive)
 {
 
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_pc_t pc;
 	idetape_mode_parameter_header_t *header;
 	idetape_parameter_block_descriptor_t *block_descrp;
-	
+
 	idetape_create_mode_sense_cmd (&pc, IDETAPE_BLOCK_DESCRIPTOR);
 	if (idetape_queue_pc_tail (drive, &pc)) {
 		printk (KERN_ERR "ide-tape: Can't get block descriptor\n");
@@ -5941,7 +5941,7 @@ static void idetape_get_blocksize_from_block_descriptor(ide_drive_t *drive)
  *	Note that at this point ide.c already assigned us an irq, so that
  *	we can queue requests here and wait for their completion.
  */
-static void idetape_setup (ide_drive_t *drive, idetape_tape_t *tape, int minor)
+static void idetape_setup(struct ata_device *drive, idetape_tape_t *tape, int minor)
 {
 	unsigned long t1, tmid, tn, t;
 	int speed;
@@ -6042,7 +6042,7 @@ static void idetape_setup (ide_drive_t *drive, idetape_tape_t *tape, int minor)
 		tape->best_dsc_rw_frequency * 1000 / HZ, drive->using_dma ? ", DMA":"");
 }
 
-static int idetape_cleanup (ide_drive_t *drive)
+static int idetape_cleanup(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int minor = tape->minor;
@@ -6072,7 +6072,7 @@ static int idetape_cleanup (ide_drive_t *drive)
 	return 0;
 }
 
-static void idetape_revalidate(ide_drive_t *_dummy)
+static void idetape_revalidate(struct ata_device *_dummy)
 {
 	/* We don't have to handle any partition information here, which is the
 	 * default behaviour of this method.
@@ -6110,9 +6110,9 @@ static struct file_operations idetape_fops = {
 MODULE_DESCRIPTION("ATAPI Streaming TAPE Driver");
 MODULE_LICENSE("GPL");
 
-static void __exit idetape_exit (void)
+static void __exit idetape_exit(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	int minor;
 
 	for (minor = 0; minor < MAX_HWIFS * MAX_DRIVES; minor++) {
@@ -6125,9 +6125,9 @@ static void __exit idetape_exit (void)
 /*
  *	idetape_init will register the driver for each tape.
  */
-int idetape_init (void)
+int idetape_init(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	idetape_tape_t *tape;
 	int minor, failed = 0, supported = 0;
 /* DRIVER(drive)->busy++; */
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 1279afbe463d..a64470c0450d 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -284,7 +284,7 @@ int drive_is_flashcard(struct ata_device *drive)
 	return 0;
 }
 
-int __ide_end_request(struct ata_device *drive, struct request *rq, int uptodate, int nr_secs)
+int __ide_end_request(struct ata_device *drive, struct request *rq, int uptodate, unsigned int nr_secs)
 {
 	unsigned long flags;
 	int ret = 1;
@@ -1199,14 +1199,14 @@ static struct ata_device *choose_urgent_device(struct ata_channel *channel)
 		if (timer_pending(&channel->timer))
 			printk(KERN_ERR "ide_set_handler: timer already active\n");
 #endif
-		set_bit(IDE_SLEEP, &channel->active);
+		set_bit(IDE_SLEEP, channel->active);
 		mod_timer(&channel->timer, sleep);
 		/* we purposely leave hwgroup busy while sleeping */
 	} else {
 		/* Ugly, but how can we sleep for the lock otherwise? perhaps
 		 * from tq_disk? */
 		ide_release_lock(&irq_lock);/* for atari only */
-		clear_bit(IDE_BUSY, &channel->active);
+		clear_bit(IDE_BUSY, channel->active);
 	}
 
 	return NULL;
@@ -1225,7 +1225,7 @@ static void queue_commands(struct ata_device *drive)
 	for (;;) {
 		struct request *rq = NULL;
 
-		if (!test_bit(IDE_BUSY, &ch->active))
+		if (!test_bit(IDE_BUSY, ch->active))
 			printk(KERN_ERR "%s: error: not busy while queueing!\n", drive->name);
 
 		/* Abort early if we can't queue another command. for non
@@ -1234,13 +1234,13 @@ static void queue_commands(struct ata_device *drive)
 		 */
 		if (!ata_can_queue(drive)) {
 			if (!ata_pending_commands(drive))
-				clear_bit(IDE_BUSY, &ch->active);
+				clear_bit(IDE_BUSY, ch->active);
 			break;
 		}
 
 		drive->sleep = 0;
 
-		if (test_bit(IDE_DMA, &ch->active)) {
+		if (test_bit(IDE_DMA, ch->active)) {
 			printk(KERN_ERR "%s: error: DMA in progress...\n", drive->name);
 			break;
 		}
@@ -1258,7 +1258,7 @@ static void queue_commands(struct ata_device *drive)
 
 		if (!(rq = elv_next_request(&drive->queue))) {
 			if (!ata_pending_commands(drive))
-				clear_bit(IDE_BUSY, &ch->active);
+				clear_bit(IDE_BUSY, ch->active);
 			drive->rq = NULL;
 			break;
 		}
@@ -1305,7 +1305,7 @@ static void do_request(struct ata_channel *channel)
 	ide_get_lock(&irq_lock, ata_irq_request, hwgroup);/* for atari only: POSSIBLY BROKEN HERE(?) */
 //	__cli();	/* necessary paranoia: ensure IRQs are masked on local CPU */
 
-	while (!test_and_set_bit(IDE_BUSY, &channel->active)) {
+	while (!test_and_set_bit(IDE_BUSY, channel->active)) {
 		struct ata_channel *ch;
 		struct ata_device *drive;
 
@@ -1408,8 +1408,8 @@ void ide_timer_expiry(unsigned long data)
 		 * complain about anything.
 		 */
 
-		if (test_and_clear_bit(IDE_SLEEP, &ch->active))
-			clear_bit(IDE_BUSY, &ch->active);
+		if (test_and_clear_bit(IDE_SLEEP, ch->active))
+			clear_bit(IDE_BUSY, ch->active);
 	} else {
 		struct ata_device *drive = ch->drive;
 		if (!drive) {
@@ -1419,7 +1419,7 @@ void ide_timer_expiry(unsigned long data)
 			ide_startstop_t startstop;
 
 			/* paranoia */
-			if (!test_and_set_bit(IDE_BUSY, &ch->active))
+			if (!test_and_set_bit(IDE_BUSY, ch->active))
 				printk(KERN_ERR "%s: ide_timer_expiry: IRQ handler was not busy??\n", drive->name);
 			if ((expiry = ch->expiry) != NULL) {
 				/* continue */
@@ -1470,7 +1470,7 @@ void ide_timer_expiry(unsigned long data)
 			spin_lock_irq(ch->lock);
 
 			if (startstop == ide_stopped)
-				clear_bit(IDE_BUSY, &ch->active);
+				clear_bit(IDE_BUSY, ch->active);
 		}
 	}
 
@@ -1593,7 +1593,7 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
 		goto out_lock;
 	}
 	/* paranoia */
-	if (!test_and_set_bit(IDE_BUSY, &ch->active))
+	if (!test_and_set_bit(IDE_BUSY, ch->active))
 		printk(KERN_ERR "%s: %s: hwgroup was not busy!?\n", drive->name, __FUNCTION__);
 	ch->handler = NULL;
 	del_timer(&ch->timer);
@@ -1617,7 +1617,7 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
 	set_recovery_timer(drive->channel);
 	if (startstop == ide_stopped) {
 		if (!ch->handler) {	/* paranoia */
-			clear_bit(IDE_BUSY, &ch->active);
+			clear_bit(IDE_BUSY, ch->active);
 			do_request(ch);
 		} else {
 			printk("%s: %s: huh? expected NULL handler on exit\n", drive->name, __FUNCTION__);
@@ -1951,7 +1951,9 @@ void ide_unregister(struct ata_channel *ch)
 		free_irq(ch->irq, ch);
 	if (n_ch == 1) {
 		kfree(ch->lock);
+		kfree(ch->active);
 		ch->lock = NULL;
+		ch->active = NULL;
 	}
 
 #if defined(CONFIG_BLK_DEV_IDEDMA) && !defined(CONFIG_DMA_NONPCI)
@@ -2133,7 +2135,7 @@ int ide_spin_wait_hwgroup(struct ata_device *drive)
 
 	spin_lock_irq(drive->channel->lock);
 
-	while (test_bit(IDE_BUSY, &drive->channel->active)) {
+	while (test_bit(IDE_BUSY, drive->channel->active)) {
 
 		spin_unlock_irq(drive->channel->lock);
 
diff --git a/drivers/ide/piix.c b/drivers/ide/piix.c
index 4b30e172900d..2070b29459a1 100644
--- a/drivers/ide/piix.c
+++ b/drivers/ide/piix.c
@@ -324,9 +324,9 @@ static void piix_set_speed(struct pci_dev *dev, unsigned char dn, struct ata_tim
  * by upper layers.
  */
 
-static int piix_set_drive(ide_drive_t *drive, unsigned char speed)
+static int piix_set_drive(struct ata_device *drive, unsigned char speed)
 {
-	ide_drive_t *peer = drive->channel->drives + (~drive->dn & 1);
+	struct ata_device *peer = drive->channel->drives + (~drive->dn & 1);
 	struct ata_timing t, p;
 	int err, T, UT, umul = 1;
 
@@ -364,7 +364,7 @@ static int piix_set_drive(ide_drive_t *drive, unsigned char speed)
  * PIO-only tuning.
  */
 
-static void piix_tune_drive(ide_drive_t *drive, unsigned char pio)
+static void piix_tune_drive(struct ata_device *drive, unsigned char pio)
 {
 	if (!((piix_enabled >> drive->channel->unit) & 1))
 		return;
diff --git a/drivers/ide/sis5513.c b/drivers/ide/sis5513.c
index 1f94a151f3ea..ef3d86c0f3b6 100644
--- a/drivers/ide/sis5513.c
+++ b/drivers/ide/sis5513.c
@@ -409,18 +409,43 @@ static int sis_get_info (char *buffer, char **addr, off_t offset, int count)
 byte sis_proc = 0;
 extern char *ide_xfer_verbose (byte xfer_rate);
 
+static int sis5513_ratemask(struct ata_device *drive)
+{
+	int map = 0;
+
+	switch(chipset_family) {
+		case ATA_133:	/* map |= XFER_UDMA_133; */
+		case ATA_100:
+		case ATA_100a:
+			map |= XFER_UDMA_100;
+		case ATA_66:
+			map |= XFER_UDMA_66;
+		case ATA_33:
+			map |= XFER_UDMA;
+			break;
+		case ATA_16:
+		case ATA_00:
+		default:
+			return 0;
+	}
+
+	if (!eighty_ninty_three(drive))
+		return XFER_UDMA;
+
+	return map;
+}
 
 /*
  * Configuration functions
  */
 /* Enables per-drive prefetch and postwrite */
-static void config_drive_art_rwp (ide_drive_t *drive)
+static void config_drive_art_rwp(struct ata_device *drive)
 {
 	struct ata_channel *hwif = drive->channel;
-	struct pci_dev *dev	= hwif->pci_dev;
+	struct pci_dev *dev = hwif->pci_dev;
 
-	byte reg4bh		= 0;
-	byte rw_prefetch	= (0x11 << drive->dn);
+	u8 reg4bh = 0;
+	u8 rw_prefetch = (0x11 << drive->dn);
 
 #ifdef DEBUG
 	printk("SIS5513: config_drive_art_rwp, drive %d\n", drive->dn);
@@ -440,7 +465,7 @@ static void config_drive_art_rwp (ide_drive_t *drive)
 
 
 /* Set per-drive active and recovery time */
-static void config_art_rwp_pio (ide_drive_t *drive, byte pio)
+static void config_art_rwp_pio(struct ata_device *drive, u8 pio)
 {
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev	= hwif->pci_dev;
@@ -523,9 +548,9 @@ static void config_art_rwp_pio (ide_drive_t *drive, byte pio)
 #endif
 }
 
-static int config_chipset_for_pio (ide_drive_t *drive, byte pio)
+static int config_chipset_for_pio(struct ata_device *drive, u8 pio)
 {
-	byte speed;
+	u8 speed;
 
 	switch(pio) {
 		case 4:		speed = XFER_PIO_4; break;
@@ -540,7 +565,7 @@ static int config_chipset_for_pio (ide_drive_t *drive, byte pio)
 	return ide_config_drive_speed(drive, speed);
 }
 
-static int sis5513_tune_chipset (ide_drive_t *drive, byte speed)
+static int sis5513_tune_chipset(struct ata_device *drive, u8 speed)
 {
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev	= hwif->pci_dev;
@@ -615,69 +640,35 @@ static int sis5513_tune_chipset (ide_drive_t *drive, byte speed)
 	return ((int) ide_config_drive_speed(drive, speed));
 }
 
-static void sis5513_tune_drive (ide_drive_t *drive, byte pio)
+static void sis5513_tune_drive(struct ata_device *drive, u8 pio)
 {
 	(void) config_chipset_for_pio(drive, pio);
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-/*
- * ((id->hw_config & 0x4000|0x2000) && (drive->channel->udma_four))
- */
-static int config_chipset_for_dma (ide_drive_t *drive, byte ultra)
+static int config_chipset_for_dma(struct ata_device *drive, u8 udma)
 {
-	struct hd_driveid *id = drive->id;
-	struct ata_channel *hwif = drive->channel;
-
-	byte			speed = 0;
-
-	byte unit		= (drive->select.b.unit & 0x01);
-	byte udma_66		= eighty_ninty_three(drive);
+	int map;
+	u8 mode;
 
 #ifdef DEBUG
-	printk("SIS5513: config_chipset_for_dma, drive %d, ultra %d\n",
-	       drive->dn, ultra);
+	printk("SIS5513: config_chipset_for_dma, drive %d, udma %d\n",
+	       drive->dn, udma);
 #endif
 
-	if ((id->dma_ultra & 0x0020) && ultra && udma_66 && (chipset_family >= ATA_100a))
-		speed = XFER_UDMA_5;
-	else if ((id->dma_ultra & 0x0010) && ultra && udma_66 && (chipset_family >= ATA_66))
-		speed = XFER_UDMA_4;
-	else if ((id->dma_ultra & 0x0008) && ultra && udma_66 && (chipset_family >= ATA_66))
-		speed = XFER_UDMA_3;
-	else if ((id->dma_ultra & 0x0004) && ultra && (chipset_family >= ATA_33))
-		speed = XFER_UDMA_2;
-	else if ((id->dma_ultra & 0x0002) && ultra && (chipset_family >= ATA_33))
-		speed = XFER_UDMA_1;
-	else if ((id->dma_ultra & 0x0001) && ultra && (chipset_family >= ATA_33))
-		speed = XFER_UDMA_0;
-	else if (id->dma_mword & 0x0004)
-		speed = XFER_MW_DMA_2;
-	else if (id->dma_mword & 0x0002)
-		speed = XFER_MW_DMA_1;
-	else if (id->dma_mword & 0x0001)
-		speed = XFER_MW_DMA_0;
-	else if (id->dma_1word & 0x0004)
-		speed = XFER_SW_DMA_2;
-	else if (id->dma_1word & 0x0002)
-		speed = XFER_SW_DMA_1;
-	else if (id->dma_1word & 0x0001)
-		speed = XFER_SW_DMA_0;
+	if (udma)
+		map = sis5513_ratemask(drive);
 	else
-		return 0;
-
-	outb(inb(hwif->dma_base+2)|(1<<(5+unit)), hwif->dma_base+2);
+		map = XFER_SWDMA | XFER_MWDMA;
 
-	sis5513_tune_chipset(drive, speed);
+	mode = ata_timing_mode(drive, map);
+	if (mode < XFER_SW_DMA_0)
+		return 0;
 
-	return ((int)	((id->dma_ultra >> 11) & 7) ? 1 :
-			((id->dma_ultra >> 8) & 7) ? 1 :
-			((id->dma_mword >> 8) & 7) ? 1 :
-			((id->dma_1word >> 8) & 7) ? 1 :
-						     0);
+	return !sis5513_tune_chipset(drive, mode);
 }
 
-static int config_drive_xfer_rate (ide_drive_t *drive)
+static int config_drive_xfer_rate(struct ata_device *drive)
 {
 	struct hd_driveid *id = drive->id;
 	int on = 0;
diff --git a/drivers/ide/tcq.c b/drivers/ide/tcq.c
index 7adae85e8740..144fde577b93 100644
--- a/drivers/ide/tcq.c
+++ b/drivers/ide/tcq.c
@@ -20,6 +20,7 @@
  * use tagged command queueing.
  */
 #include <linux/config.h>
+#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -94,15 +95,15 @@ static void tcq_invalidate_queue(struct ata_device *drive)
 
 	del_timer(&ch->timer);
 
-	if (test_bit(IDE_DMA, &ch->active))
+	if (test_bit(IDE_DMA, ch->active))
 		udma_stop(drive);
 
 	blk_queue_invalidate_tags(q);
 
 	drive->using_tcq = 0;
 	drive->queue_depth = 1;
-	clear_bit(IDE_BUSY, &ch->active);
-	clear_bit(IDE_DMA, &ch->active);
+	clear_bit(IDE_BUSY, ch->active);
+	clear_bit(IDE_DMA, ch->active);
 	ch->handler = NULL;
 
 	/*
@@ -158,7 +159,7 @@ static void ata_tcq_irq_timeout(unsigned long data)
 
 	spin_lock_irqsave(ch->lock, flags);
 
-	if (test_and_set_bit(IDE_BUSY, &ch->active))
+	if (test_and_set_bit(IDE_BUSY, ch->active))
 		printk(KERN_ERR "ATA: %s: IRQ handler not busy\n", __FUNCTION__);
 	if (!ch->handler)
 		printk(KERN_ERR "ATA: %s: missing ISR!\n", __FUNCTION__);
@@ -239,7 +240,7 @@ static ide_startstop_t service(struct ata_device *drive, struct request *rq)
 	 * Could be called with IDE_DMA in-progress from invalidate
 	 * handler, refuse to do anything.
 	 */
-	if (test_bit(IDE_DMA, &drive->channel->active))
+	if (test_bit(IDE_DMA, drive->channel->active))
 		return ide_stopped;
 
 	/*
@@ -527,7 +528,7 @@ static ide_startstop_t udma_tcq_start(struct ata_device *drive, struct request *
 	struct ata_channel *ch = drive->channel;
 
 	TCQ_PRINTK("%s: setting up queued %d\n", __FUNCTION__, rq->tag);
-	if (!test_bit(IDE_BUSY, &ch->active))
+	if (!test_bit(IDE_BUSY, ch->active))
 		printk("queued_rw: IDE_BUSY not set\n");
 
 	if (tcq_wait_dataphase(drive))
@@ -639,3 +640,6 @@ int udma_tcq_enable(struct ata_device *drive, int on)
 	drive->using_tcq = 1;
 	return 0;
 }
+
+/* FIXME: This should go away! */
+EXPORT_SYMBOL(udma_tcq_enable);
diff --git a/drivers/ide/trm290.c b/drivers/ide/trm290.c
index 1a35ec83616e..5a6e820afac5 100644
--- a/drivers/ide/trm290.c
+++ b/drivers/ide/trm290.c
@@ -142,7 +142,7 @@
 
 #include "pcihost.h"
 
-static void trm290_prepare_drive (ide_drive_t *drive, unsigned int use_dma)
+static void trm290_prepare_drive(struct ata_device *drive, unsigned int use_dma)
 {
 	struct ata_channel *hwif = drive->channel;
 	unsigned int reg;
@@ -170,7 +170,7 @@ static void trm290_prepare_drive (ide_drive_t *drive, unsigned int use_dma)
 	__restore_flags(flags);	/* local CPU only */
 }
 
-static void trm290_selectproc (ide_drive_t *drive)
+static void trm290_selectproc(struct ata_device *drive)
 {
 	trm290_prepare_drive(drive, drive->using_dma);
 }
diff --git a/drivers/ide/via82cxxx.c b/drivers/ide/via82cxxx.c
index 17e6d462079c..18cf5111b4c7 100644
--- a/drivers/ide/via82cxxx.c
+++ b/drivers/ide/via82cxxx.c
@@ -303,9 +303,9 @@ static void via_set_speed(struct pci_dev *dev, unsigned char dn, struct ata_timi
  * by upper layers.
  */
 
-static int via_set_drive(ide_drive_t *drive, unsigned char speed)
+static int via_set_drive(struct ata_device *drive, unsigned char speed)
 {
-	ide_drive_t *peer = drive->channel->drives + (~drive->dn & 1);
+	struct ata_device *peer = drive->channel->drives + (~drive->dn & 1);
 	struct ata_timing t, p;
 	unsigned int T, UT;
 
@@ -345,7 +345,7 @@ static int via_set_drive(ide_drive_t *drive, unsigned char speed)
  * PIO-only tuning.
  */
 
-static void via82cxxx_tune_drive(ide_drive_t *drive, unsigned char pio)
+static void via82cxxx_tune_drive(struct ata_device *drive, unsigned char pio)
 {
 	if (!((via_enabled >> drive->channel->unit) & 1))
 		return;
@@ -493,23 +493,9 @@ static unsigned int __init via82cxxx_init_chipset(struct pci_dev *dev)
  */
 
 	pci_read_config_byte(isa, PCI_REVISION_ID, &t);
-	printk(KERN_INFO "VP_IDE: VIA %s (rev %02x) IDE %s controller on pci%s\n",
+	printk(KERN_INFO "VP_IDE: VIA %s (rev %02x) ATA %s controller on PCI %s\n",
 		via_config->name, t, via_dma[via_config->flags & VIA_UDMA], dev->slot_name);
 
-/*
- * Setup /proc/ide/via entry.
- */
-
-#if 0 && defined(CONFIG_PROC_FS)
-	if (!via_proc) {
-		via_base = pci_resource_start(dev, 4);
-		bmide_dev = dev;
-		isa_dev = isa;
-		via_display_info = &via_get_info;
-		via_proc = 1;
-	}
-#endif
-
 	return 0;
 }
 
diff --git a/include/linux/ide.h b/include/linux/ide.h
index a66146efd024..e47e204deb5c 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -447,6 +447,7 @@ struct ata_channel {
 	 * between differen queues sharing the same irq line.
 	 */
 	spinlock_t *lock;
+	unsigned long *active;		/* active processing request */
 
 	ide_startstop_t (*handler)(struct ata_device *, struct request *);	/* irq handler, if active */
 	struct timer_list timer;				/* failsafe timer */
@@ -454,7 +455,6 @@ struct ata_channel {
 	unsigned long poll_timeout;				/* timeout value during polled operations */
 	struct ata_device *drive;				/* last serviced drive */
 
-	unsigned long active;		/* active processing request */
 
 	ide_ioreg_t io_ports[IDE_NR_PORTS];	/* task file registers */
 	hw_regs_t hw;				/* hardware info */
@@ -642,7 +642,7 @@ extern int noautodma;
 #define LOCAL_END_REQUEST	/* Don't generate end_request in blk.h */
 #include <linux/blk.h>
 
-extern int __ide_end_request(struct ata_device *, struct request *, int, int);
+extern int __ide_end_request(struct ata_device *, struct request *, int, unsigned int);
 extern int ide_end_request(struct ata_device *drive, struct request *, int);
 
 /*
@@ -784,11 +784,9 @@ void ide_init_subdrivers (void);
 
 extern struct block_device_operations ide_fops[];
 
-#ifdef CONFIG_BLK_DEV_IDE
 /* Probe for devices attached to the systems host controllers.
  */
-extern int ideprobe_init (void);
-#endif
+extern int ideprobe_init(void);
 #ifdef CONFIG_BLK_DEV_IDEDISK
 extern int idedisk_init (void);
 #endif
-- 
cgit v1.2.3


From 6b4fef7ad8297f840fc6c1a8e6ff3ca7a525fb2b Mon Sep 17 00:00:00 2001
From: Martin Dalecki <dalecki@evision-ventures.com>
Date: Tue, 21 May 2002 21:22:11 -0700
Subject: [PATCH] 2.5.17 IDE 66

 - Move ll_10byte_cmd_build to the only place where it's used: ide-cd.  The SCSI
   layer does have it's own implementation which additionally it's messing
   around with the hard_nr_sectors struct request value.  One should *not*
   provide "infrastructure" until its really used as such.

   If anywhere this should reside in a file called ATAPI.

 - Unfold the INIT_REQUEST macro from blk.h. This showed up plenty of duplicate
   checks for QUEUE_EMPTY. Clean them as well. Remove the over cautious
   major(CURRENT->rq_dev != MAJOR_NR) checks. During the last several years I
   never saw any report about it. Looking at the !CURRENT->bio it is clear that
   dereferencing NULL will provide the same kind of panic as the check.  Some
   comments around the code in question show nicely that indeed INIT_REQUEST
   was a good example of code obfuscation.

 - A short look at RQ_INACTIVE shows that it is only used inside the scsi.c file
   and during the removal of devices. This shows that the many checks for
   RQ_INACTIVE are not necessary. Looking closer even shows that some of them
   did happen before checks for an empty queue. Plenty of drivers didn't care
   about it and the CD-ROM ones should be handled properly, because the
   most common drivers would fail as well. Comments indicate that this
   was an leftover from 1.3 days...
---
 arch/m68k/atari/stram.c     |  7 +++++--
 drivers/acorn/block/mfmhd.c | 21 ++++-----------------
 drivers/block/ll_rw_blk.c   | 40 +---------------------------------------
 drivers/block/paride/pcd.c  |  7 +++++--
 drivers/block/paride/pd.c   |  6 ++++--
 drivers/block/paride/pf.c   |  6 ++++--
 drivers/block/ps2esdi.c     |  7 +++++--
 drivers/block/xd.c          |  9 +++++++--
 drivers/block/z2ram.c       |  5 ++++-
 drivers/cdrom/cdu31a.c      |  5 ++---
 drivers/cdrom/cm206.c       |  6 ++++--
 drivers/cdrom/gscd.c        |  8 +++++---
 drivers/cdrom/mcdx.c        | 12 ++----------
 drivers/cdrom/sbpcd.c       | 11 +++++++----
 drivers/cdrom/sonycd535.c   |  5 +++--
 drivers/ide/hd.c            |  8 ++++++--
 drivers/ide/ide-cd.c        | 41 +++++++++++++++++++++++++++++++++++++++++
 drivers/mtd/ftl.c           |  9 ++++++---
 drivers/mtd/mtdblock.c      |  6 +++++-
 drivers/mtd/mtdblock_ro.c   | 12 ++++++++----
 drivers/mtd/nftlcore.c      |  6 +++++-
 drivers/s390/block/xpram.c  |  5 ++++-
 drivers/sbus/char/jsflash.c |  6 +++++-
 include/linux/blk.h         | 21 +++++----------------
 include/linux/blkdev.h      |  1 -
 25 files changed, 147 insertions(+), 123 deletions(-)

(limited to 'include/linux')

diff --git a/arch/m68k/atari/stram.c b/arch/m68k/atari/stram.c
index 9a0d03f46c28..5d1e3c9eff9b 100644
--- a/arch/m68k/atari/stram.c
+++ b/arch/m68k/atari/stram.c
@@ -984,8 +984,11 @@ static void do_stram_request(request_queue_t *q)
 	unsigned long len;
 
 	while (1) {
-		INIT_REQUEST;
-		
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
+			return;
+		}
+
 		start = swap_start + (CURRENT->sector << 9);
 		len   = CURRENT->current_nr_sectors << 9;
 		if ((start + len) > swap_end) {
diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index 923b815f9ca7..3cb9a45529e3 100644
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -889,17 +889,6 @@ static void mfm_request(void)
 {
 	DBG("mfm_request CURRENT=%p Busy=%d\n", CURRENT, Busy);
 
-	if (QUEUE_EMPTY) {
-		DBG("mfm_request: Exited due to NULL Current 1\n");
-		return;
-	}
-
-	if (CURRENT->rq_status == RQ_INACTIVE) {
-		/* Hmm - seems to be happening a lot on 1.3.45 */
-		/*console_printf("mfm_request: Exited due to INACTIVE Current\n"); */
-		return;
-	}
-
 	/* If we are still processing then return; we will get called again */
 	if (Busy) {
 		/* Again seems to be common in 1.3.45 */
@@ -914,16 +903,14 @@ static void mfm_request(void)
 		DBG("mfm_request: loop start\n");
 		sti();
 
-		DBG("mfm_request: before INIT_REQUEST\n");
+		DBG("mfm_request: before blk_queue_empty\n");
 
-		if (QUEUE_EMPTY) {
-			printk("mfm_request: Exiting due to !CURRENT (pre)\n");
+		if (blk_queue_empty(QUEUE)) {
+			printk("mfm_request: Exiting due to empty queue (pre)\n");
 			CLEAR_INTR;
 			Busy = 0;
 			return;
-		};
-
-		INIT_REQUEST;
+		}
 
 		DBG("mfm_request:                 before arg extraction\n");
 
diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index c0f8f5a46a32..f904d7ad813d 100644
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -523,42 +523,6 @@ void blk_dump_rq_flags(struct request *rq, char *msg)
 	printk("\n");
 }
 
-/*
- * standard prep_rq_fn that builds 10 byte cmds
- */
-int ll_10byte_cmd_build(request_queue_t *q, struct request *rq)
-{
-	int hard_sect = queue_hardsect_size(q);
-	sector_t block = rq->hard_sector / (hard_sect >> 9);
-	unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
-
-	if (!(rq->flags & REQ_CMD))
-		return 0;
-
-	memset(rq->cmd, 0, sizeof(rq->cmd));
-
-	if (rq_data_dir(rq) == READ)
-		rq->cmd[0] = READ_10;
-	else 
-		rq->cmd[0] = WRITE_10;
-
-	/*
-	 * fill in lba
-	 */
-	rq->cmd[2] = (block >> 24) & 0xff;
-	rq->cmd[3] = (block >> 16) & 0xff;
-	rq->cmd[4] = (block >>  8) & 0xff;
-	rq->cmd[5] = block & 0xff;
-
-	/*
-	 * and transfer length
-	 */
-	rq->cmd[7] = (blocks >> 8) & 0xff;
-	rq->cmd[8] = blocks & 0xff;
-
-	return 0;
-}
-
 void blk_recount_segments(request_queue_t *q, struct bio *bio)
 {
 	struct bio_vec *bv, *bvprv = NULL;
@@ -1765,9 +1729,8 @@ inline void blk_recalc_rq_sectors(struct request *rq, int nsect)
 {
 	if (rq->flags & REQ_CMD) {
 		rq->hard_sector += nsect;
-		rq->hard_nr_sectors -= nsect;
+		rq->nr_sectors = rq->hard_nr_sectors -= nsect;
 		rq->sector = rq->hard_sector;
-		rq->nr_sectors = rq->hard_nr_sectors;
 
 		rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9;
 		rq->hard_cur_sectors = rq->current_nr_sectors;
@@ -1944,7 +1907,6 @@ EXPORT_SYMBOL(blk_queue_assign_lock);
 EXPORT_SYMBOL(blk_phys_contig_segment);
 EXPORT_SYMBOL(blk_hw_contig_segment);
 
-EXPORT_SYMBOL(ll_10byte_cmd_build);
 EXPORT_SYMBOL(blk_queue_prep_rq);
 
 EXPORT_SYMBOL(blk_queue_init_tags);
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 52632b029bc3..67c75f9ed4f5 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -760,8 +760,11 @@ static void do_pcd_request (request_queue_t * q)
 
 	if (pcd_busy) return;
         while (1) {
-	    if (QUEUE_EMPTY || (CURRENT->rq_status == RQ_INACTIVE)) return;
-	    INIT_REQUEST;
+	    if (blk_queue_empty(QUEUE)) {
+		    CLEAR_INTR;
+		    return;
+	    }
+
 	    if (rq_data_dir(CURRENT) == READ) {
 		unit = minor(CURRENT->rq_dev);
 		if (unit != pcd_unit) {
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 5ba9e148e6fc..331743a6addb 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -835,8 +835,10 @@ static void do_pd_request (request_queue_t * q)
 
         if (pd_busy) return;
 repeat:
-        if (QUEUE_EMPTY || (CURRENT->rq_status == RQ_INACTIVE)) return;
-        INIT_REQUEST;
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
 
         pd_dev = minor(CURRENT->rq_dev);
 	pd_unit = unit = DEVICE_NR(CURRENT->rq_dev);
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 35767a675fe3..505b4d05ea75 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -841,8 +841,10 @@ static void do_pf_request (request_queue_t * q)
 
         if (pf_busy) return;
 repeat:
-        if (QUEUE_EMPTY || (CURRENT->rq_status == RQ_INACTIVE)) return;
-        INIT_REQUEST;
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
 
         pf_unit = unit = DEVICE_NR(CURRENT->rq_dev);
         pf_block = CURRENT->sector;
diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index 0af57d6f4e33..756a905899ff 100644
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -471,9 +471,12 @@ static void do_ps2esdi_request(request_queue_t * q)
 	       CURRENT->current_nr_sectors, CURRENT->buffer);
 #endif
 
-	/* standard macro that ensures that requests are really on the
+	/* standard procedure to ensure that requests are really on the
 	   list + sanity checks.                     */
-	INIT_REQUEST;
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
 
 	if (isa_virt_to_bus(CURRENT->buffer + CURRENT->current_nr_sectors * 512) > 16 * MB) {
 		printk("%s: DMA above 16MB not supported\n", DEVICE_NAME);
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 0001fde07bbd..0e439263aab3 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -279,8 +279,13 @@ static void do_xd_request (request_queue_t * q)
 	sti();
 	if (xdc_busy)
 		return;
-	while (code = 0, !QUEUE_EMPTY) {
-		INIT_REQUEST;	/* do some checking on the request structure */
+	while (1) {
+		code = 0;
+		/* do some checking on the request structure */
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
+			return;
+		}
 
 		if (CURRENT_DEV < xd_drives
 		    && (CURRENT->flags & REQ_CMD)
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index c2d56ef20068..917f2ca3216c 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -76,7 +76,10 @@ do_z2_request( request_queue_t * q )
 
     while ( TRUE )
     {
-	INIT_REQUEST;
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
 
 	start = CURRENT->sector << 9;
 	len  = CURRENT->current_nr_sectors << 9;
diff --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index a11b304a4f6e..89d9cfe3cbdf 100644
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -1598,7 +1598,8 @@ static void do_cdu31a_request(request_queue_t * q)
 		 * The beginning here is stolen from the hard disk driver.  I hope
 		 * it's right.
 		 */
-		if (QUEUE_EMPTY || CURRENT->rq_status == RQ_INACTIVE) {
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
 			goto end_do_cdu31a_request;
 		}
 
@@ -1606,8 +1607,6 @@ static void do_cdu31a_request(request_queue_t * q)
 			scd_spinup();
 		}
 
-		INIT_REQUEST;
-
 		block = CURRENT->sector;
 		nblock = CURRENT->nr_sectors;
 
diff --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
index 031b79f7507f..c48978fe2b2f 100644
--- a/drivers/cdrom/cm206.c
+++ b/drivers/cdrom/cm206.c
@@ -856,9 +856,11 @@ static void do_cm206_request(request_queue_t * q)
 	uch *source, *dest;
 
 	while (1) {		/* repeat until all requests have been satisfied */
-		INIT_REQUEST;
-		if (QUEUE_EMPTY || CURRENT->rq_status == RQ_INACTIVE)
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
 			return;
+		}
+
 		if (CURRENT->cmd != READ) {
 			debug(("Non-read command %d on cdrom\n",
 			       CURRENT->cmd));
diff --git a/drivers/cdrom/gscd.c b/drivers/cdrom/gscd.c
index 8e767f3105a2..b572fe844bb5 100644
--- a/drivers/cdrom/gscd.c
+++ b/drivers/cdrom/gscd.c
@@ -279,9 +279,11 @@ static void __do_gscd_request(unsigned long dummy)
 	unsigned int nsect;
 
       repeat:
-	if (QUEUE_EMPTY || CURRENT->rq_status == RQ_INACTIVE)
-		goto out;
-	INIT_REQUEST;
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
+
 	dev = minor(CURRENT->rq_dev);
 	block = CURRENT->sector;
 	nsect = CURRENT->nr_sectors;
diff --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index c51740cbdba9..27578a9ffe6e 100644
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -562,19 +562,11 @@ void do_mcdx_request(request_queue_t * q)
 
       again:
 
-	if (QUEUE_EMPTY) {
-		xtrace(REQUEST, "end_request(0): CURRENT == NULL\n");
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
 		return;
 	}
 
-	if (CURRENT->rq_status == RQ_INACTIVE) {
-		xtrace(REQUEST,
-		       "end_request(0): rq_status == RQ_INACTIVE\n");
-		return;
-	}
-
-	INIT_REQUEST;
-
 	dev = minor(CURRENT->rq_dev);
 	stuffp = mcdx_stuffp[dev];
 
diff --git a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c
index fa9b57634276..3b24273bb278 100644
--- a/drivers/cdrom/sbpcd.c
+++ b/drivers/cdrom/sbpcd.c
@@ -4915,12 +4915,15 @@ static void DO_SBPCD_REQUEST(request_queue_t * q)
 	printk(" do_sbpcd_request[%di](%p:%ld+%ld), Pid:%d, Time:%li\n",
 		xnr, CURRENT, CURRENT->sector, CURRENT->nr_sectors, current->pid, jiffies);
 #endif
-	INIT_REQUEST;
+
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
+
 	req=CURRENT;		/* take out our request so no other */
 	blkdev_dequeue_request(req);	/* task can fuck it up         GTL  */
-	
-	if (req->rq_status == RQ_INACTIVE)
-		sbpcd_end_request(req, 0);
+
 	if (req -> sector == -1)
 		sbpcd_end_request(req, 0);
 	spin_unlock_irq(q->queue_lock);
diff --git a/drivers/cdrom/sonycd535.c b/drivers/cdrom/sonycd535.c
index ace141cfacb4..60566a95731d 100644
--- a/drivers/cdrom/sonycd535.c
+++ b/drivers/cdrom/sonycd535.c
@@ -806,10 +806,11 @@ do_cdu535_request(request_queue_t * q)
 		 * The beginning here is stolen from the hard disk driver.  I hope
 		 * it's right.
 		 */
-		if (QUEUE_EMPTY || CURRENT->rq_status == RQ_INACTIVE) {
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
 			return;
 		}
-		INIT_REQUEST;
+
 		dev = minor(CURRENT->rq_dev);
 		block = CURRENT->sector;
 		nsect = CURRENT->nr_sectors;
diff --git a/drivers/ide/hd.c b/drivers/ide/hd.c
index 03821aa1cd6d..844ed9472e56 100644
--- a/drivers/ide/hd.c
+++ b/drivers/ide/hd.c
@@ -544,13 +544,17 @@ static void hd_request(void)
 {
 	unsigned int dev, block, nsect, sec, track, head, cyl;
 
-	if (!QUEUE_EMPTY && CURRENT->rq_status == RQ_INACTIVE) return;
 	if (DEVICE_INTR)
 		return;
 repeat:
 	del_timer(&device_timer);
 	sti();
-	INIT_REQUEST;
+
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
+
 	if (reset) {
 		cli();
 		reset_hd();
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index bc33949757df..f14289905347 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -2658,6 +2658,47 @@ int ide_cdrom_probe_capabilities(struct ata_device *drive)
 	return nslots;
 }
 
+
+/*
+ * standard prep_rq_fn that builds 10 byte cmds
+ */
+static int ll_10byte_cmd_build(request_queue_t *q, struct request *rq)
+{
+	int hard_sect = queue_hardsect_size(q);
+	sector_t block = rq->hard_sector / (hard_sect >> 9);
+	unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
+
+	if (!(rq->flags & REQ_CMD))
+		return 0;
+
+	if (rq->hard_nr_sectors != rq->nr_sectors) {
+		printk(KERN_ERR "ide-cd: hard_nr_sectors differs from nr_sectors! %lu %lu\n",
+				rq->nr_sectors, rq->hard_nr_sectors);
+	}
+	memset(rq->cmd, 0, sizeof(rq->cmd));
+
+	if (rq_data_dir(rq) == READ)
+		rq->cmd[0] = GPCMD_READ_10;
+	else
+		rq->cmd[0] = GPCMD_WRITE_10;
+
+	/*
+	 * fill in lba
+	 */
+	rq->cmd[2] = (block >> 24) & 0xff;
+	rq->cmd[3] = (block >> 16) & 0xff;
+	rq->cmd[4] = (block >>  8) & 0xff;
+	rq->cmd[5] = block & 0xff;
+
+	/*
+	 * and transfer length
+	 */
+	rq->cmd[7] = (blocks >> 8) & 0xff;
+	rq->cmd[8] = blocks & 0xff;
+
+	return 0;
+}
+
 static int ide_cdrom_setup(struct ata_device *drive)
 {
 	struct cdrom_info *info = drive->driver_data;
diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index 889164aac0df..011d48b212a3 100644
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -1191,11 +1191,14 @@ static void do_ftl_request(request_arg_t)
     partition_t *part;
 
     do {
-      //	    sti();
-	INIT_REQUEST;
+	//	    sti();
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
 
 	minor = minor(CURRENT->rq_dev);
-	
+
 	part = myparts[minor >> 4];
 	if (part) {
 	  ret = 0;
diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 3262d574ee6f..b53c546135f3 100644
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -405,7 +405,11 @@ static void handle_mtdblock_request(void)
 	unsigned int res;
 
 	for (;;) {
-		INIT_REQUEST;
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
+			return;
+		}
+
 		req = CURRENT;
 		spin_unlock_irq(QUEUE->queue_lock);
 		mtdblk = mtdblks[minor(req->rq_dev)];
diff --git a/drivers/mtd/mtdblock_ro.c b/drivers/mtd/mtdblock_ro.c
index 62c3b3bb17bb..bbd17b5bb441 100644
--- a/drivers/mtd/mtdblock_ro.c
+++ b/drivers/mtd/mtdblock_ro.c
@@ -112,11 +112,15 @@ static void mtdblock_request(RQFUNC_ARG)
 
    while (1)
    {
-      /* Grab the Request and unlink it from the request list, INIT_REQUEST
-       	 will execute a return if we are done. */
-      INIT_REQUEST;
+      /* Grab the Request and unlink it from the request list, we
+	 will execute a return if we are done. */
+	if (blk_queue_empty(QUEUE)) {
+		CLEAR_INTR;
+		return;
+	}
+
       current_request = CURRENT;
-   
+
       if (minor(current_request->rq_dev) >= MAX_MTD_DEVICES)
       {
 	 printk("mtd: Unsupported device!\n");
diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index 60b3f30962d6..6c27f00f5133 100644
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -837,7 +837,11 @@ void nftl_request(RQFUNC_ARG)
 	int res;
 
 	while (1) {
-		INIT_REQUEST;	/* blk.h */
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
+			return;
+		}
+
 		req = CURRENT;
 		
 		/* We can do this because the generic code knows not to
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 42df4dc4ba17..7c85ee6565c4 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -747,7 +747,10 @@ void xpram_request(request_queue_t * queue)
 #endif /* V24 */
 
 	while(1) {
-		INIT_REQUEST;
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
+			return;
+		}
 
 		fault=0;
 #if ( XPRAM_VERSION == 24 )
diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index 5806be8d8f7d..b01d0175e5d7 100644
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -207,7 +207,11 @@ static void jsfd_do_request(request_queue_t *q)
 	size_t len;
 
 	for (;;) {
-		INIT_REQUEST;	/* if (QUEUE_EMPTY) return; */
+		if (blk_queue_empty(QUEUE)) {
+			CLEAR_INTR;
+			return;
+		}
+
 		req = CURRENT;
 
 		dev = MINOR(req->rq_dev);
diff --git a/include/linux/blk.h b/include/linux/blk.h
index 62d37b2b4c17..290e30367b8e 100644
--- a/include/linux/blk.h
+++ b/include/linux/blk.h
@@ -313,22 +313,11 @@ static void (*DEVICE_INTR)(void) = NULL;
 
 #define SET_INTR(x) (DEVICE_INTR = (x))
 
-#ifdef DEVICE_INTR
-#define CLEAR_INTR SET_INTR(NULL)
-#else
-#define CLEAR_INTR
-#endif
-
-#define INIT_REQUEST						\
-	if (QUEUE_EMPTY) {					\
-		CLEAR_INTR;					\
-		return;						\
-	}							\
-	if (major(CURRENT->rq_dev) != MAJOR_NR) 			\
-		panic(DEVICE_NAME ": request list destroyed");	\
-	if (!CURRENT->bio)					\
-		panic(DEVICE_NAME ": no bio");			\
-
+# ifdef DEVICE_INTR
+#  define CLEAR_INTR SET_INTR(NULL)
+# else
+#  define CLEAR_INTR
+# endif
 #endif /* !defined(IDE_DRIVER) */
 
 /*
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index ac373e6a2454..32729e1e3c5b 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -303,7 +303,6 @@ extern void blk_recount_segments(request_queue_t *, struct bio *);
 extern inline int blk_phys_contig_segment(request_queue_t *q, struct bio *, struct bio *);
 extern inline int blk_hw_contig_segment(request_queue_t *q, struct bio *, struct bio *);
 extern int block_ioctl(struct block_device *, unsigned int, unsigned long);
-extern int ll_10byte_cmd_build(request_queue_t *, struct request *);
 
 /*
  * get ready for proper ref counting
-- 
cgit v1.2.3


From c7c39840089beba1d84f2ed64f7760b726b251d8 Mon Sep 17 00:00:00 2001
From: Martin Dalecki <dalecki@evision-ventures.com>
Date: Tue, 21 May 2002 21:24:23 -0700
Subject: [PATCH] 2.5.16 IDE 68

 - Make the different ATAPI device type drivers use a unified packet command
   structure. We have to start to push them together.

This patch is rather trivial in itself, but the plentora of code duplication it
is trying to fight against is making it unfortunately rather big...
---
 drivers/ide/Config.in    |   7 +
 drivers/ide/Makefile     |   4 +-
 drivers/ide/atapi.c      |  75 ++++++++
 drivers/ide/ide-floppy.c | 327 +++++++++++++++--------------------
 drivers/ide/ide-tape.c   | 437 ++++++++++++++++++++++-------------------------
 drivers/scsi/ide-scsi.c  | 207 ++++++++++------------
 include/linux/atapi.h    |  65 +++++++
 7 files changed, 589 insertions(+), 533 deletions(-)
 create mode 100644 drivers/ide/atapi.c
 create mode 100644 include/linux/atapi.h

(limited to 'include/linux')

diff --git a/drivers/ide/Config.in b/drivers/ide/Config.in
index 18de75278d92..3d88e0186ac5 100644
--- a/drivers/ide/Config.in
+++ b/drivers/ide/Config.in
@@ -130,6 +130,13 @@ if [ "$CONFIG_BLK_DEV_IDE" != "n" ]; then
         "$CONFIG_BLK_DEV_IDEDMA_ICS" = "y" ]; then
       bool '  IGNORE word93 Validation BITS' CONFIG_IDEDMA_IVB
    fi
+   
+   if [ "$CONFIG_BLK_DEV_IDECD" != "n" -o \
+        "$CONFIG_BLK_DEV_IDETAPE" != "n" -o \
+        "$CONFIG_BLK_DEV_IDEFLOPPY" != "n" -o \
+        "$CONFIG_BLK_DEV_IDESCSI" != "n" ]; then
+	define_bool  CONFIG_ATAPI y
+   fi
 else
    bool 'Old hard disk (MFM/RLL/IDE) driver' CONFIG_BLK_DEV_HD_ONLY
    define_bool CONFIG_BLK_DEV_HD $CONFIG_BLK_DEV_HD_ONLY
diff --git a/drivers/ide/Makefile b/drivers/ide/Makefile
index f96037cddf9f..1cf1bf2120a8 100644
--- a/drivers/ide/Makefile
+++ b/drivers/ide/Makefile
@@ -10,7 +10,8 @@
 
 O_TARGET := idedriver.o
 
-export-objs	:= ide-taskfile.o ide.o ide-features.o ide-probe.o quirks.o pcidma.o tcq.o ataraid.o
+export-objs	:= ide-taskfile.o ide.o ide-features.o ide-probe.o quirks.o pcidma.o tcq.o \
+		   atapi.o ataraid.o
 
 obj-y		:=
 obj-m		:=
@@ -20,6 +21,7 @@ obj-$(CONFIG_BLK_DEV_HD)	+= hd.o
 obj-$(CONFIG_BLK_DEV_IDE)       += ide-mod.o
 obj-$(CONFIG_BLK_DEV_IDECS)     += ide-cs.o
 obj-$(CONFIG_BLK_DEV_IDEDISK)   += ide-disk.o
+obj-$(CONFIG_ATAPI)		+= atapi.o
 obj-$(CONFIG_BLK_DEV_IDECD)     += ide-cd.o
 obj-$(CONFIG_BLK_DEV_IDETAPE)   += ide-tape.o
 obj-$(CONFIG_BLK_DEV_IDEFLOPPY) += ide-floppy.o
diff --git a/drivers/ide/atapi.c b/drivers/ide/atapi.c
new file mode 100644
index 000000000000..dad3fb961014
--- /dev/null
+++ b/drivers/ide/atapi.c
@@ -0,0 +1,75 @@
+/**** vi:set ts=8 sts=8 sw=8:************************************************
+ *
+ * Copyright (C) 2002 Marcin Dalecki <martin@dalecki.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+/*
+ * Code common among all the ATAPI device drivers.
+ *
+ * Ideally this should evolve in to a unified driver.
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/ioport.h>
+#include <linux/blkdev.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/cdrom.h>
+#include <linux/hdreg.h>
+#include <linux/ide.h>
+#include <linux/atapi.h>
+
+#include <asm/byteorder.h>
+#include <asm/io.h>
+#include <asm/bitops.h>
+#include <asm/uaccess.h>
+
+/*
+ * Too bad. The drive wants to send us data which we are not ready to accept.
+ * Just throw it away.
+ */
+void atapi_discard_data(struct ata_device *drive, unsigned int bcount)
+{
+	while (bcount--)
+		IN_BYTE(IDE_DATA_REG);
+}
+
+void atapi_write_zeros(struct ata_device *drive, unsigned int bcount)
+{
+	while (bcount--)
+		OUT_BYTE(0, IDE_DATA_REG);
+}
+
+/*
+ * Initializes a packet command. Used by tape and floppy driver.
+ */
+void atapi_init_pc(struct atapi_packet_command *pc)
+{
+	memset(pc->c, 0, 12);
+	pc->retries = 0;
+	pc->flags = 0;
+	pc->request_transfer = 0;
+	pc->buffer = pc->pc_buffer;
+	pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
+	pc->b_data = NULL;
+	pc->bio = NULL;
+}
+
+EXPORT_SYMBOL(atapi_discard_data);
+EXPORT_SYMBOL(atapi_write_zeros);
+EXPORT_SYMBOL(atapi_init_pc);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 9d0e14a39c42..448b9ec4c721 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -97,6 +97,7 @@
 #include <linux/slab.h>
 #include <linux/cdrom.h>
 #include <linux/ide.h>
+#include <linux/atapi.h>
 
 #include <asm/byteorder.h>
 #include <asm/irq.h>
@@ -127,12 +128,6 @@
  */
 #define IDEFLOPPY_MAX_PC_RETRIES	3
 
-/*
- *	With each packet command, we allocate a buffer of
- *	IDEFLOPPY_PC_BUFFER_SIZE bytes.
- */
-#define IDEFLOPPY_PC_BUFFER_SIZE	256
-
 /*
  *	In various places in the driver, we need to allocate storage
  *	for packet commands and requests, which will remain valid while
@@ -140,25 +135,6 @@
  */
 #define IDEFLOPPY_PC_STACK		(10 + IDEFLOPPY_MAX_PC_RETRIES)
 
-/*
- *	Our view of a packet command.
- */
-typedef struct idefloppy_packet_command_s {
-	u8 c[12];				/* Actual packet bytes */
-	int retries;				/* On each retry, we increment retries */
-	int error;				/* Error code */
-	int request_transfer;			/* Bytes to transfer */
-	int actually_transferred;		/* Bytes actually transferred */
-	int buffer_size;			/* Size of our data buffer */
-	char *b_data;				/* Pointer which runs on the buffers */
-	int b_count;				/* Missing/Available data on the current buffer */
-	byte *buffer;				/* Data buffer */
-	byte *current_position;			/* Pointer into the above buffer */
-	void (*callback) (struct ata_device *, struct request *);	/* Called when this packet command is completed */
-	byte pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE];	/* Temporary buffer */
-	unsigned long flags;			/* Status/Action bit flags: long for set_bit */
-} idefloppy_pc_t;
-
 /*
  *	Packet command flag bits.
  */
@@ -269,11 +245,11 @@ typedef struct {
  *	of type idefloppy_floppy_t, defined below.
  */
 typedef struct {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 
-	idefloppy_pc_t *pc;			/* Current packet command */
-	idefloppy_pc_t *failed_pc; 		/* Last failed packet command */
-	idefloppy_pc_t pc_stack[IDEFLOPPY_PC_STACK];/* Packet command stack */
+	struct atapi_packet_command *pc;		/* Current packet command */
+	struct atapi_packet_command *failed_pc;		/* Last failed packet command */
+	struct atapi_packet_command pc_stack[IDEFLOPPY_PC_STACK];	/* Packet command stack */
 	int pc_stack_index;			/* Next free packet command storage space */
 	struct request rq_stack[IDEFLOPPY_PC_STACK];
 	int rq_stack_index;			/* We implement a circular array */
@@ -644,24 +620,6 @@ typedef struct {
 #define IDEFLOPPY_MIN(a,b)	((a)<(b) ? (a):(b))
 #define	IDEFLOPPY_MAX(a,b)	((a)>(b) ? (a):(b))
 
-/*
- *	Too bad. The drive wants to send us data which we are not ready to accept.
- *	Just throw it away.
- */
-static void idefloppy_discard_data (ide_drive_t *drive, unsigned int bcount)
-{
-	while (bcount--)
-		IN_BYTE (IDE_DATA_REG);
-}
-
-#if IDEFLOPPY_DEBUG_BUGS
-static void idefloppy_write_zeros (ide_drive_t *drive, unsigned int bcount)
-{
-	while (bcount--)
-		OUT_BYTE (0, IDE_DATA_REG);
-}
-#endif /* IDEFLOPPY_DEBUG_BUGS */
-
 /*
  *	idefloppy_end_request is used to finish servicing a request.
  *
@@ -698,7 +656,7 @@ static int idefloppy_end_request(struct ata_device *drive, struct request *rq, i
 }
 
 static void idefloppy_input_buffers(struct ata_device *drive, struct request *rq,
-	idefloppy_pc_t *pc, unsigned int bcount)
+	struct atapi_packet_command *pc, unsigned int bcount)
 {
 	struct bio *bio = rq->bio;
 	int count;
@@ -713,17 +671,17 @@ static void idefloppy_input_buffers(struct ata_device *drive, struct request *rq
 		}
 		if (bio == NULL) {
 			printk (KERN_ERR "%s: bio == NULL in %s, bcount == %d\n", drive->name, __FUNCTION__, bcount);
-			idefloppy_discard_data (drive, bcount);
+			atapi_discard_data(drive, bcount);
 			return;
 		}
-		count = IDEFLOPPY_MIN (bio->bi_size - pc->b_count, bcount);
+		count = IDEFLOPPY_MIN(bio->bi_size - pc->b_count, bcount);
 		atapi_read(drive, bio_data(bio) + pc->b_count, count);
 		bcount -= count; pc->b_count += count;
 	}
 }
 
 static void idefloppy_output_buffers(struct ata_device *drive, struct request *rq,
-	idefloppy_pc_t *pc, unsigned int bcount)
+		struct atapi_packet_command *pc, unsigned int bcount)
 {
 	struct bio *bio = rq->bio;
 	int count;
@@ -740,40 +698,41 @@ static void idefloppy_output_buffers(struct ata_device *drive, struct request *r
 		}
 		if (bio == NULL) {
 			printk (KERN_ERR "%s: bio == NULL in idefloppy_output_buffers, bcount == %d\n", drive->name, bcount);
-			idefloppy_write_zeros (drive, bcount);
+			atapi_write_zeros (drive, bcount);
 			return;
 		}
-		count = IDEFLOPPY_MIN (pc->b_count, bcount);
+		count = IDEFLOPPY_MIN(pc->b_count, bcount);
 		atapi_write(drive, pc->b_data, count);
 		bcount -= count; pc->b_data += count; pc->b_count -= count;
 	}
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-static void idefloppy_update_buffers (struct ata_device *drive, struct request *rq,
-	idefloppy_pc_t *pc)
+static void idefloppy_update_buffers(struct ata_device *drive, struct request *rq)
 {
 	struct bio *bio = rq->bio;
 
 	while ((bio = rq->bio) != NULL)
 		idefloppy_end_request(drive, rq, 1);
 }
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 
 /*
  *	idefloppy_queue_pc_head generates a new packet command request in front
  *	of the request queue, before the current request, so that it will be
  *	processed immediately, on the next pass through the driver.
  */
-static void idefloppy_queue_pc_head (ide_drive_t *drive,idefloppy_pc_t *pc,struct request *rq)
+static void idefloppy_queue_pc_head(struct ata_device *drive,
+		struct atapi_packet_command *pc, struct request *rq)
 {
 	ide_init_drive_cmd (rq);
+	/* FIXME: --mdcki */
 	rq->buffer = (char *) pc;
 	rq->flags = IDEFLOPPY_RQ;
 	(void) ide_do_drive_cmd (drive, rq, ide_preempt);
 }
 
-static idefloppy_pc_t *idefloppy_next_pc_storage (ide_drive_t *drive)
+static struct atapi_packet_command *idefloppy_next_pc_storage(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -782,7 +741,7 @@ static idefloppy_pc_t *idefloppy_next_pc_storage (ide_drive_t *drive)
 	return (&floppy->pc_stack[floppy->pc_stack_index++]);
 }
 
-static struct request *idefloppy_next_rq_storage (ide_drive_t *drive)
+static struct request *idefloppy_next_rq_storage(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -795,7 +754,7 @@ static struct request *idefloppy_next_rq_storage (ide_drive_t *drive)
  *	idefloppy_analyze_error is called on each failed packet command retry
  *	to analyze the request sense.
  */
-static void idefloppy_analyze_error (ide_drive_t *drive,idefloppy_request_sense_result_t *result)
+static void idefloppy_analyze_error(struct ata_device *drive, idefloppy_request_sense_result_t *result)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -807,7 +766,7 @@ static void idefloppy_analyze_error (ide_drive_t *drive,idefloppy_request_sense_
 		printk (KERN_INFO "ide-floppy: pc = %x, sense key = %x, asc = %x, ascq = %x\n",floppy->failed_pc->c[0],result->sense_key,result->asc,result->ascq);
 	else
 		printk (KERN_INFO "ide-floppy: sense key = %x, asc = %x, ascq = %x\n",result->sense_key,result->asc,result->ascq);
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 }
 
 static void idefloppy_request_sense_callback(struct ata_device *drive, struct request *rq)
@@ -816,9 +775,9 @@ static void idefloppy_request_sense_callback(struct ata_device *drive, struct re
 
 #if IDEFLOPPY_DEBUG_LOG
 	printk (KERN_INFO "ide-floppy: Reached idefloppy_request_sense_callback\n");
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 	if (!floppy->pc->error) {
-		idefloppy_analyze_error (drive,(idefloppy_request_sense_result_t *) floppy->pc->buffer);
+		idefloppy_analyze_error(drive,(idefloppy_request_sense_result_t *) floppy->pc->buffer);
 		idefloppy_end_request(drive, rq, 1);
 	} else {
 		printk (KERN_ERR "Error in REQUEST SENSE itself - Aborting request!\n");
@@ -835,29 +794,14 @@ static void idefloppy_pc_callback(struct ata_device *drive, struct request *rq)
 
 #if IDEFLOPPY_DEBUG_LOG
 	printk (KERN_INFO "ide-floppy: Reached idefloppy_pc_callback\n");
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 
 	idefloppy_end_request(drive, rq, floppy->pc->error ? 0:1);
 }
 
-/*
- *	idefloppy_init_pc initializes a packet command.
- */
-static void idefloppy_init_pc (idefloppy_pc_t *pc)
+static void idefloppy_create_request_sense_cmd(struct atapi_packet_command *pc)
 {
-	memset (pc->c, 0, 12);
-	pc->retries = 0;
-	pc->flags = 0;
-	pc->request_transfer = 0;
-	pc->buffer = pc->pc_buffer;
-	pc->buffer_size = IDEFLOPPY_PC_BUFFER_SIZE;
-	pc->b_data = NULL;
-	pc->callback = idefloppy_pc_callback;
-}
-
-static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc)
-{
-	idefloppy_init_pc (pc);	
+	atapi_init_pc(pc);
 	pc->c[0] = IDEFLOPPY_REQUEST_SENSE_CMD;
 	pc->c[4] = 255;
 	pc->request_transfer = 18;
@@ -869,16 +813,16 @@ static void idefloppy_create_request_sense_cmd (idefloppy_pc_t *pc)
  *	last packet command. We queue a request sense packet command in
  *	the head of the request list.
  */
-static void idefloppy_retry_pc (ide_drive_t *drive)
+static void idefloppy_retry_pc(struct ata_device *drive)
 {
-	idefloppy_pc_t *pc;
+	struct atapi_packet_command *pc;
 	struct request *rq;
 	idefloppy_error_reg_t error;
 
-	error.all = IN_BYTE (IDE_ERROR_REG);
-	pc = idefloppy_next_pc_storage (drive);
-	rq = idefloppy_next_rq_storage (drive);
-	idefloppy_create_request_sense_cmd (pc);
+	error.all = IN_BYTE(IDE_ERROR_REG);
+	pc = idefloppy_next_pc_storage(drive);
+	rq = idefloppy_next_rq_storage(drive);
+	idefloppy_create_request_sense_cmd(pc);
 	idefloppy_queue_pc_head(drive, pc, rq);
 }
 
@@ -892,7 +836,7 @@ static ide_startstop_t idefloppy_pc_intr(struct ata_device *drive, struct reques
 	idefloppy_status_reg_t status;
 	idefloppy_bcount_reg_t bcount;
 	idefloppy_ireason_reg_t ireason;
-	idefloppy_pc_t *pc=floppy->pc;
+	struct atapi_packet_command *pc = floppy->pc;
 	unsigned int temp;
 
 #if IDEFLOPPY_DEBUG_LOG
@@ -905,7 +849,7 @@ static ide_startstop_t idefloppy_pc_intr(struct ata_device *drive, struct reques
 			set_bit (PC_DMA_ERROR, &pc->flags);
 		} else {
 			pc->actually_transferred=pc->request_transfer;
-			idefloppy_update_buffers(drive, rq, pc);
+			idefloppy_update_buffers(drive, rq);
 		}
 # if IDEFLOPPY_DEBUG_LOG
 		printk (KERN_INFO "ide-floppy: DMA finished\n");
@@ -923,10 +867,10 @@ static ide_startstop_t idefloppy_pc_intr(struct ata_device *drive, struct reques
 
 		ide__sti();	/* local CPU only */
 
-		if (status.b.check || test_bit (PC_DMA_ERROR, &pc->flags)) {	/* Error detected */
+		if (status.b.check || test_bit(PC_DMA_ERROR, &pc->flags)) {	/* Error detected */
 #if IDEFLOPPY_DEBUG_LOG
 			printk (KERN_INFO "ide-floppy: %s: I/O error\n",drive->name);
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 			rq->errors++;
 			if (pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
 				printk (KERN_ERR "ide-floppy: I/O error in request sense command\n");
@@ -942,7 +886,7 @@ static ide_startstop_t idefloppy_pc_intr(struct ata_device *drive, struct reques
 		return ide_stopped;
 	}
 #ifdef CONFIG_BLK_DEV_IDEDMA
-	if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
+	if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {
 		printk (KERN_ERR "ide-floppy: The floppy wants to issue more interrupts in DMA mode\n");
 		udma_enable(drive, 0, 1);
 
@@ -957,23 +901,23 @@ static ide_startstop_t idefloppy_pc_intr(struct ata_device *drive, struct reques
 		printk (KERN_ERR "ide-floppy: CoD != 0 in idefloppy_pc_intr\n");
 		return ide_stopped;
 	}
-	if (ireason.b.io == test_bit (PC_WRITING, &pc->flags)) {	/* Hopefully, we will never get here */
+	if (ireason.b.io == test_bit(PC_WRITING, &pc->flags)) {	/* Hopefully, we will never get here */
 		printk (KERN_ERR "ide-floppy: We wanted to %s, ", ireason.b.io ? "Write":"Read");
 		printk (KERN_ERR "but the floppy wants us to %s !\n",ireason.b.io ? "Read":"Write");
 		return ide_stopped;
 	}
-	if (!test_bit (PC_WRITING, &pc->flags)) {			/* Reading - Check that we have enough space */
+	if (!test_bit(PC_WRITING, &pc->flags)) {			/* Reading - Check that we have enough space */
 		temp = pc->actually_transferred + bcount.all;
 		if ( temp > pc->request_transfer) {
 			if (temp > pc->buffer_size) {
 				printk (KERN_ERR "ide-floppy: The floppy wants to send us more data than expected - discarding data\n");
-				idefloppy_discard_data (drive,bcount.all);
+				atapi_discard_data (drive,bcount.all);
 				ide_set_handler(drive, idefloppy_pc_intr,IDEFLOPPY_WAIT_CMD, NULL);
 				return ide_started;
 			}
 #if IDEFLOPPY_DEBUG_LOG
 			printk (KERN_NOTICE "ide-floppy: The floppy wants to send us more data than expected - allowing transfer\n");
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 		}
 	}
 	if (test_bit (PC_WRITING, &pc->flags)) {
@@ -1076,7 +1020,8 @@ static ide_startstop_t idefloppy_transfer_pc1(struct ata_device *drive, struct r
 /*
  *	Issue a packet command
  */
-static ide_startstop_t idefloppy_issue_pc(struct ata_device *drive, struct request *rq, idefloppy_pc_t *pc)
+static ide_startstop_t idefloppy_issue_pc(struct ata_device *drive, struct request *rq,
+		struct atapi_packet_command *pc)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 	idefloppy_bcount_reg_t bcount;
@@ -1085,28 +1030,28 @@ static ide_startstop_t idefloppy_issue_pc(struct ata_device *drive, struct reque
 
 #if IDEFLOPPY_DEBUG_BUGS
 	if (floppy->pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD && pc->c[0] == IDEFLOPPY_REQUEST_SENSE_CMD) {
-		printk (KERN_ERR "ide-floppy: possible ide-floppy.c bug - Two request sense in serial were issued\n");
+		printk(KERN_ERR "ide-floppy: possible ide-floppy.c bug - Two request sense in serial were issued\n");
 	}
-#endif /* IDEFLOPPY_DEBUG_BUGS */
+#endif
 
 	if (floppy->failed_pc == NULL && pc->c[0] != IDEFLOPPY_REQUEST_SENSE_CMD)
 		floppy->failed_pc=pc;
 	floppy->pc=pc;							/* Set the current packet command */
 
-	if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES || test_bit (PC_ABORT, &pc->flags)) {
+	if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES || test_bit(PC_ABORT, &pc->flags)) {
 		/*
 		 *	We will "abort" retrying a packet command in case
 		 *	a legitimate error code was received.
 		 */
-		if (!test_bit (PC_ABORT, &pc->flags)) {
-			if (!test_bit (PC_SUPPRESS_ERROR, &pc->flags)) {
+		if (!test_bit(PC_ABORT, &pc->flags)) {
+			if (!test_bit(PC_SUPPRESS_ERROR, &pc->flags)) {
 				;
       printk( KERN_ERR "ide-floppy: %s: I/O error, pc = %2x, key = %2x, asc = %2x, ascq = %2x\n",
 				drive->name, pc->c[0], floppy->sense_key, floppy->asc, floppy->ascq);
 			}
 			pc->error = IDEFLOPPY_ERROR_GENERAL;		/* Giving up */
 		}
-		floppy->failed_pc=NULL;
+		floppy->failed_pc = NULL;
 		pc->callback(drive, rq);
 		return ide_stopped;
 	}
@@ -1129,7 +1074,7 @@ static ide_startstop_t idefloppy_issue_pc(struct ata_device *drive, struct reque
 		else
 			dma_ok = !udma_read(drive, rq);
 	}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 
 	if (IDE_CONTROL_REG)
 		OUT_BYTE (drive->ctl,IDE_CONTROL_REG);
@@ -1140,10 +1085,10 @@ static ide_startstop_t idefloppy_issue_pc(struct ata_device *drive, struct reque
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
 	if (dma_ok) {							/* Begin DMA, if necessary */
-		set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
+		set_bit(PC_DMA_IN_PROGRESS, &pc->flags);
 		udma_start(drive, rq);
 	}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 
 	/* Can we transfer the packet when we get the interrupt or wait? */
 	if (test_bit (IDEFLOPPY_ZIP_DRIVE, &floppy->flags)) {
@@ -1172,30 +1117,32 @@ static void idefloppy_rw_callback(struct ata_device *drive, struct request *rq)
 	return;
 }
 
-static void idefloppy_create_prevent_cmd (idefloppy_pc_t *pc, int prevent)
+static void idefloppy_create_prevent_cmd(struct atapi_packet_command *pc, int prevent)
 {
 #if IDEFLOPPY_DEBUG_LOG
 	printk (KERN_INFO "ide-floppy: creating prevent removal command, prevent = %d\n", prevent);
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 
-	idefloppy_init_pc (pc);
+	atapi_init_pc (pc);
 	pc->c[0] = IDEFLOPPY_PREVENT_REMOVAL_CMD;
 	pc->c[4] = prevent;
+	pc->callback = idefloppy_pc_callback;
 }
 
-static void idefloppy_create_read_capacity_cmd (idefloppy_pc_t *pc)
+static void idefloppy_create_read_capacity_cmd(struct atapi_packet_command *pc)
 {
-	idefloppy_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDEFLOPPY_READ_CAPACITY_CMD;
 	pc->c[7] = 255;
 	pc->c[8] = 255;
 	pc->request_transfer = 255;
+	pc->callback = idefloppy_pc_callback;
 }
 
-static void idefloppy_create_format_unit_cmd (idefloppy_pc_t *pc, int b, int l,
-					      int flags)
+static void idefloppy_create_format_unit_cmd(struct atapi_packet_command *pc,
+		int b, int l, int flags)
 {
-	idefloppy_init_pc (pc);
+	atapi_init_pc (pc);
 	pc->c[0] = IDEFLOPPY_FORMAT_UNIT_CMD;
 	pc->c[1] = 0x17;
 
@@ -1209,18 +1156,19 @@ static void idefloppy_create_format_unit_cmd (idefloppy_pc_t *pc, int b, int l,
 
 	put_unaligned(htonl(b), (unsigned int *)(&pc->buffer[4]));
 	put_unaligned(htonl(l), (unsigned int *)(&pc->buffer[8]));
-	pc->buffer_size=12;
+	pc->buffer_size = 12;
 	set_bit(PC_WRITING, &pc->flags);
+	pc->callback = idefloppy_pc_callback;
 }
 
 /*
  *	A mode sense command is used to "sense" floppy parameters.
  */
-static void idefloppy_create_mode_sense_cmd (idefloppy_pc_t *pc, byte page_code, byte type)
+static void idefloppy_create_mode_sense_cmd(struct atapi_packet_command *pc, u8 page_code, u8 type)
 {
-	unsigned short length = sizeof (idefloppy_mode_parameter_header_t);
-	
-	idefloppy_init_pc (pc);
+	unsigned short length = sizeof(idefloppy_mode_parameter_header_t);
+
+	atapi_init_pc(pc);
 	pc->c[0] = IDEFLOPPY_MODE_SENSE_CMD;
 	pc->c[1] = 0;
 	pc->c[2] = page_code + (type << 6);
@@ -1235,24 +1183,28 @@ static void idefloppy_create_mode_sense_cmd (idefloppy_pc_t *pc, byte page_code,
 		default:
 			printk (KERN_ERR "ide-floppy: unsupported page code in create_mode_sense_cmd\n");
 	}
-	put_unaligned (htons (length), (unsigned short *) &pc->c[7]);
+	put_unaligned(htons(length), (unsigned short *) &pc->c[7]);
 	pc->request_transfer = length;
+	pc->callback = idefloppy_pc_callback;
 }
 
-static void idefloppy_create_start_stop_cmd (idefloppy_pc_t *pc, int start)
+static void idefloppy_create_start_stop_cmd(struct atapi_packet_command *pc, int start)
 {
-	idefloppy_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDEFLOPPY_START_STOP_CMD;
 	pc->c[4] = start;
+	pc->callback = idefloppy_pc_callback;
 }
 
-static void idefloppy_create_test_unit_ready_cmd(idefloppy_pc_t *pc)
+static void idefloppy_create_test_unit_ready_cmd(struct atapi_packet_command *pc)
 {
-	idefloppy_init_pc(pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDEFLOPPY_TEST_UNIT_READY_CMD;
+	pc->callback = idefloppy_pc_callback;
 }
 
-static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy, idefloppy_pc_t *pc, struct request *rq, sector_t sector)
+static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy,
+		struct atapi_packet_command *pc, struct request *rq, sector_t sector)
 {
 	int block = sector / floppy->bs_factor;
 	int blocks = rq->nr_sectors / floppy->bs_factor;
@@ -1261,25 +1213,25 @@ static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy, idefloppy_pc_t *
 #if IDEFLOPPY_DEBUG_LOG
 	printk ("create_rw1%d_cmd: block == %d, blocks == %d\n",
 		2 * test_bit (IDEFLOPPY_USE_READ12, &floppy->flags), block, blocks);
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 
-	idefloppy_init_pc(pc);
+	atapi_init_pc(pc);
 	if (test_bit (IDEFLOPPY_USE_READ12, &floppy->flags)) {
 		pc->c[0] = cmd == READ ? IDEFLOPPY_READ12_CMD : IDEFLOPPY_WRITE12_CMD;
-		put_unaligned (htonl (blocks), (unsigned int *) &pc->c[6]);
+		put_unaligned(htonl (blocks), (unsigned int *) &pc->c[6]);
 	} else {
 		pc->c[0] = cmd == READ ? IDEFLOPPY_READ10_CMD : IDEFLOPPY_WRITE10_CMD;
-		put_unaligned (htons (blocks), (unsigned short *) &pc->c[7]);
+		put_unaligned(htons (blocks), (unsigned short *) &pc->c[7]);
 	}
-	put_unaligned (htonl (block), (unsigned int *) &pc->c[2]);
+	put_unaligned(htonl(block), (unsigned int *) &pc->c[2]);
 	pc->callback = idefloppy_rw_callback;
 	pc->b_data = rq->buffer;
 	pc->b_count = cmd == READ ? 0 : rq->bio->bi_size;
 	if (rq->flags & REQ_RW)
-		set_bit (PC_WRITING, &pc->flags);
+		set_bit(PC_WRITING, &pc->flags);
 	pc->buffer = NULL;
 	pc->request_transfer = pc->buffer_size = blocks * floppy->block_size;
-	set_bit (PC_DMA_RECOMMENDED, &pc->flags);
+	set_bit(PC_DMA_RECOMMENDED, &pc->flags);
 }
 
 /*
@@ -1288,7 +1240,7 @@ static void idefloppy_create_rw_cmd(idefloppy_floppy_t *floppy, idefloppy_pc_t *
 static ide_startstop_t idefloppy_do_request(struct ata_device *drive, struct request *rq, sector_t block)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
-	idefloppy_pc_t *pc;
+	struct atapi_packet_command *pc;
 
 #if IDEFLOPPY_DEBUG_LOG
 	printk (KERN_INFO "rq_status: %d, rq_dev: %u, flags: %lx, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->flags,rq->errors);
@@ -1313,7 +1265,8 @@ static ide_startstop_t idefloppy_do_request(struct ata_device *drive, struct req
 		pc = idefloppy_next_pc_storage(drive);
 		idefloppy_create_rw_cmd (floppy, pc, rq, block);
 	} else if (rq->flags & IDEFLOPPY_RQ) {
-		pc = (idefloppy_pc_t *) rq->buffer;
+		/* FIXME: --mdcki */
+		pc = (struct atapi_packet_command *) rq->buffer;
 	} else {
 		blk_dump_rq_flags(rq, "ide-floppy: unsupported command in queue");
 		idefloppy_end_request(drive, rq, 0);
@@ -1327,11 +1280,12 @@ static ide_startstop_t idefloppy_do_request(struct ata_device *drive, struct req
  *	idefloppy_queue_pc_tail adds a special packet command request to the
  *	tail of the request queue, and waits for it to be serviced.
  */
-static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
+static int idefloppy_queue_pc_tail(struct ata_device *drive, struct atapi_packet_command *pc)
 {
 	struct request rq;
 
 	ide_init_drive_cmd (&rq);
+	/* FIXME: --mdcki */
 	rq.buffer = (char *) pc;
 	rq.flags = IDEFLOPPY_RQ;
 	return ide_do_drive_cmd (drive, &rq, ide_wait);
@@ -1341,10 +1295,10 @@ static int idefloppy_queue_pc_tail (ide_drive_t *drive,idefloppy_pc_t *pc)
  *	Look at the flexible disk page parameters. We will ignore the CHS
  *	capacity parameters and use the LBA parameters instead.
  */
-static int idefloppy_get_flexible_disk_page (ide_drive_t *drive)
+static int idefloppy_get_flexible_disk_page(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
-	idefloppy_pc_t pc;
+	struct atapi_packet_command pc;
 	idefloppy_mode_parameter_header_t *header;
 	idefloppy_flexible_disk_page_t *page;
 	int capacity, lba_capacity;
@@ -1382,15 +1336,15 @@ static int idefloppy_get_flexible_disk_page (ide_drive_t *drive)
 	return 0;
 }
 
-static int idefloppy_get_capability_page(ide_drive_t *drive)
+static int idefloppy_get_capability_page(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
-	idefloppy_pc_t pc;
+	struct atapi_packet_command pc;
 	idefloppy_mode_parameter_header_t *header;
 	idefloppy_capabilities_page_t *page;
 
 	floppy->srfp=0;
-	idefloppy_create_mode_sense_cmd (&pc, IDEFLOPPY_CAPABILITIES_PAGE,
+	idefloppy_create_mode_sense_cmd(&pc, IDEFLOPPY_CAPABILITIES_PAGE,
 						 MODE_SENSE_CURRENT);
 
 	set_bit(PC_SUPPRESS_ERROR, &pc.flags);
@@ -1408,14 +1362,14 @@ static int idefloppy_get_capability_page(ide_drive_t *drive)
  *	Determine if a media is present in the floppy drive, and if so,
  *	its LBA capacity.
  */
-static int idefloppy_get_capacity (ide_drive_t *drive)
+static int idefloppy_get_capacity(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
-	idefloppy_pc_t pc;
+	struct atapi_packet_command pc;
 	idefloppy_capacity_header_t *header;
 	idefloppy_capacity_descriptor_t *descriptor;
 	int i, descriptors, rc = 1, blocks, length;
-	
+
 	drive->bios_cyl = 0;
 	drive->bios_head = drive->bios_sect = 0;
 	floppy->blocks = floppy->bs_factor = 0;
@@ -1434,9 +1388,9 @@ static int idefloppy_get_capacity (ide_drive_t *drive)
                 blocks = descriptor->blocks = ntohl (descriptor->blocks);
                 length = descriptor->length = ntohs (descriptor->length);
 
-		if (!i) 
+		if (!i)
 		{
-          	switch (descriptor->dc) {
+			switch (descriptor->dc) {
                 case CAPACITY_UNFORMATTED: /* Clik! drive returns this instead of CAPACITY_CURRENT */
                         if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags))
                                 break; /* If it is not a clik drive, break out (maintains previous driver behaviour) */
@@ -1500,12 +1454,12 @@ static int idefloppy_get_capacity (ide_drive_t *drive)
 **
 */
 
-static int idefloppy_get_format_capacities (ide_drive_t *drive,
-					    struct inode *inode,
-					    struct file *file,
-					    int *arg)	/* Cheater */
+static int idefloppy_get_format_capacities(struct ata_device *drive,
+		struct inode *inode,
+		struct file *file,
+		int *arg)	/* Cheater */
 {
-        idefloppy_pc_t pc;
+        struct atapi_packet_command pc;
 	idefloppy_capacity_header_t *header;
         idefloppy_capacity_descriptor_t *descriptor;
 	int i, descriptors, blocks, length;
@@ -1519,8 +1473,8 @@ static int idefloppy_get_format_capacities (ide_drive_t *drive,
 	if (u_array_size <= 0)
 		return (-EINVAL);
 
-	idefloppy_create_read_capacity_cmd (&pc);
-	if (idefloppy_queue_pc_tail (drive, &pc)) {
+	idefloppy_create_read_capacity_cmd(&pc);
+	if (idefloppy_queue_pc_tail(drive, &pc)) {
 		printk (KERN_ERR "ide-floppy: Can't get floppy parameters\n");
                 return (-EIO);
         }
@@ -1580,7 +1534,7 @@ static int idefloppy_get_format_capacities (ide_drive_t *drive,
 **        0x01 - verify media after format.
 */
 
-static int idefloppy_begin_format(ide_drive_t *drive,
+static int idefloppy_begin_format(struct ata_device *drive,
 				  struct inode *inode,
 				  struct file *file,
 				  int *arg)
@@ -1588,7 +1542,7 @@ static int idefloppy_begin_format(ide_drive_t *drive,
 	int blocks;
 	int length;
 	int flags;
-	idefloppy_pc_t pc;
+	struct atapi_packet_command pc;
 
 	if (get_user(blocks, arg)
 	    || get_user(length, arg+1)
@@ -1599,10 +1553,9 @@ static int idefloppy_begin_format(ide_drive_t *drive,
 
 	(void) idefloppy_get_capability_page (drive);	/* Get the SFRP bit */
 	idefloppy_create_format_unit_cmd(&pc, blocks, length, flags);
-	if (idefloppy_queue_pc_tail (drive, &pc))
-	{
-                return (-EIO);
-        }
+	if (idefloppy_queue_pc_tail(drive, &pc))
+                return -EIO;
+
 	return (0);
 }
 
@@ -1616,13 +1569,13 @@ static int idefloppy_begin_format(ide_drive_t *drive,
 ** the dsc bit, and return either 0 or 65536.
 */
 
-static int idefloppy_get_format_progress(ide_drive_t *drive,
-					 struct inode *inode,
-					 struct file *file,
-					 int *arg)
+static int idefloppy_get_format_progress(struct ata_device *drive,
+		struct inode *inode,
+		struct file *file,
+		int *arg)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
-	idefloppy_pc_t pc;
+	struct atapi_packet_command pc;
 	int progress_indication=0x10000;
 
 	if (floppy->srfp)
@@ -1664,10 +1617,10 @@ static int idefloppy_get_format_progress(ide_drive_t *drive,
  *
  *	Currently there aren't any ioctl's.
  */
-static int idefloppy_ioctl (ide_drive_t *drive, struct inode *inode, struct file *file,
+static int idefloppy_ioctl(struct ata_device *drive, struct inode *inode, struct file *file,
 				 unsigned int cmd, unsigned long arg)
 {
-	idefloppy_pc_t pc;
+	struct atapi_packet_command pc;
 	idefloppy_floppy_t *floppy = drive->driver_data;
 	int prevent = (arg) ? 1 : 0;
 
@@ -1681,8 +1634,8 @@ static int idefloppy_ioctl (ide_drive_t *drive, struct inode *inode, struct file
 
 		/* The IOMEGA Clik! Drive doesn't support this command - no room for an eject mechanism */
                 if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
-			idefloppy_create_prevent_cmd (&pc, prevent);
-			(void) idefloppy_queue_pc_tail (drive, &pc);
+			idefloppy_create_prevent_cmd(&pc, prevent);
+			(void) idefloppy_queue_pc_tail(drive, &pc);
 		}
 		if (cmd == CDROMEJECT) {
 			idefloppy_create_start_stop_cmd (&pc, 2);
@@ -1744,14 +1697,14 @@ static int idefloppy_ioctl (ide_drive_t *drive, struct inode *inode, struct file
 /*
  *	Our open/release functions
  */
-static int idefloppy_open (struct inode *inode, struct file *filp, ide_drive_t *drive)
+static int idefloppy_open(struct inode *inode, struct file *filp, struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
-	idefloppy_pc_t pc;
-	
+	struct atapi_packet_command pc;
+
 #if IDEFLOPPY_DEBUG_LOG
 	printk (KERN_INFO "Reached idefloppy_open\n");
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 
 	MOD_INC_USE_COUNT;
 	if (drive->usage == 1) {
@@ -1781,7 +1734,7 @@ static int idefloppy_open (struct inode *inode, struct file *filp, ide_drive_t *
 			drive->usage--;
 			MOD_DEC_USE_COUNT;
 			return -EROFS;
-		}		
+		}
 		set_bit (IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
 		/* IOMEGA Clik! drives do not support lock/unlock commands */
                 if (!test_bit(IDEFLOPPY_CLIK_DRIVE, &floppy->flags)) {
@@ -1799,13 +1752,13 @@ static int idefloppy_open (struct inode *inode, struct file *filp, ide_drive_t *
 	return 0;
 }
 
-static void idefloppy_release (struct inode *inode, struct file *filp, ide_drive_t *drive)
+static void idefloppy_release(struct inode *inode, struct file *filp, struct ata_device *drive)
 {
-	idefloppy_pc_t pc;
-	
+	struct atapi_packet_command pc;
+
 #if IDEFLOPPY_DEBUG_LOG
 	printk (KERN_INFO "Reached idefloppy_release\n");
-#endif /* IDEFLOPPY_DEBUG_LOG */
+#endif
 
 	if (!drive->usage) {
 		idefloppy_floppy_t *floppy = drive->driver_data;
@@ -1826,17 +1779,17 @@ static void idefloppy_release (struct inode *inode, struct file *filp, ide_drive
 /*
  *	Check media change. Use a simple algorithm for now.
  */
-static int idefloppy_check_media_change (ide_drive_t *drive)
+static int idefloppy_check_media_change(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 
-	return test_and_clear_bit (IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
+	return test_and_clear_bit(IDEFLOPPY_MEDIA_CHANGED, &floppy->flags);
 }
 
 /*
  *	Return the current floppy capacity to ide.c.
  */
-static unsigned long idefloppy_capacity (ide_drive_t *drive)
+static unsigned long idefloppy_capacity(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 	unsigned long capacity = floppy->blocks * floppy->bs_factor;
@@ -1848,7 +1801,7 @@ static unsigned long idefloppy_capacity (ide_drive_t *drive)
  *	idefloppy_identify_device checks if we can support a drive,
  *	based on the ATAPI IDENTIFY command results.
  */
-static int idefloppy_identify_device (ide_drive_t *drive,struct hd_driveid *id)
+static int idefloppy_identify_device(struct ata_device *drive,struct hd_driveid *id)
 {
 	struct idefloppy_id_gcw gcw;
 #if IDEFLOPPY_DEBUG_INFO
@@ -1963,7 +1916,7 @@ static int idefloppy_identify_device (ide_drive_t *drive,struct hd_driveid *id)
 /*
  *	Driver initialization.
  */
-static void idefloppy_setup (ide_drive_t *drive, idefloppy_floppy_t *floppy)
+static void idefloppy_setup(struct ata_device *drive, idefloppy_floppy_t *floppy)
 {
 	struct idefloppy_id_gcw gcw;
 	int i;
@@ -2013,7 +1966,7 @@ static void idefloppy_setup (ide_drive_t *drive, idefloppy_floppy_t *floppy)
 	}
 }
 
-static int idefloppy_cleanup (ide_drive_t *drive)
+static int idefloppy_cleanup(struct ata_device *drive)
 {
 	idefloppy_floppy_t *floppy = drive->driver_data;
 
@@ -2043,13 +1996,13 @@ static struct ata_operations idefloppy_driver = {
 
 MODULE_DESCRIPTION("ATAPI FLOPPY Driver");
 
-static void __exit idefloppy_exit (void)
+static void __exit idefloppy_exit(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	int failed = 0;
 
 	while ((drive = ide_scan_devices(ATA_FLOPPY, "ide-floppy", &idefloppy_driver, failed)) != NULL) {
-		if (idefloppy_cleanup (drive)) {
+		if (idefloppy_cleanup(drive)) {
 			printk ("%s: cleanup_module() called while still busy\n", drive->name);
 			failed++;
 		}
@@ -2059,9 +2012,9 @@ static void __exit idefloppy_exit (void)
 /*
  *	idefloppy_init will register the driver for each floppy.
  */
-int idefloppy_init (void)
+int idefloppy_init(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	idefloppy_floppy_t *floppy;
 	int failed = 0;
 
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 4f846398b0f4..0ab48ee6e583 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -12,14 +12,14 @@
  * It is hereby placed under the terms of the GNU general public license.
  * (See linux/COPYING).
  */
- 
+
 /*
  * IDE ATAPI streaming tape driver.
  *
  * This driver is a part of the Linux ide driver and works in co-operation
  * with linux/drivers/block/ide.c.
  *
- * The driver, in co-operation with ide.c, basically traverses the 
+ * The driver, in co-operation with ide.c, basically traverses the
  * request-list for the block device interface. The character device
  * interface, on the other hand, creates new requests, adds them
  * to the request-list of the block device, and waits for their completion.
@@ -417,9 +417,10 @@
 #include <linux/genhd.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
-#include <linux/ide.h>
 #include <linux/smp_lock.h>
 #include <linux/completion.h>
+#include <linux/ide.h>
+#include <linux/atapi.h>
 
 #include <asm/byteorder.h>
 #include <asm/irq.h>
@@ -614,13 +615,6 @@ typedef struct {
  */
 #define IDETAPE_MAX_PC_RETRIES		3
 
-/*
- *	With each packet command, we allocate a buffer of
- *	IDETAPE_PC_BUFFER_SIZE bytes. This is used for several packet
- *	commands (Not for READ/WRITE commands).
- */
-#define IDETAPE_PC_BUFFER_SIZE		256
-
 /*
  *	In various places in the driver, we need to allocate storage
  *	for packet commands and requests, which will remain valid while
@@ -711,27 +705,6 @@ typedef enum {
 	idetape_direction_write
 } idetape_chrdev_direction_t;
 
-/*
- *	Our view of a packet command.
- */
-typedef struct idetape_packet_command_s {
-	u8 c[12];				/* Actual packet bytes */
-	int retries;				/* On each retry, we increment retries */
-	int error;				/* Error code */
-	int request_transfer;			/* Bytes to transfer */
-	int actually_transferred;		/* Bytes actually transferred */
-	int buffer_size;			/* Size of our data buffer */
-	struct bio *bio;
-	char *b_data;
-	int b_count;
-	byte *buffer;				/* Data buffer */
-	byte *current_position;			/* Pointer into the above buffer */
-	/* Called when this packet command is completed */
-	ide_startstop_t (*callback) (struct ata_device *, struct request *);
-	byte pc_buffer[IDETAPE_PC_BUFFER_SIZE];	/* Temporary buffer */
-	unsigned long flags;			/* Status/Action bit flags: long for set_bit */
-} idetape_pc_t;
-
 /*
  *	Packet command flag bits.
  */
@@ -747,10 +720,10 @@ typedef struct idetape_packet_command_s {
  */
 typedef struct {
 	unsigned	page_code	:6;	/* Page code - Should be 0x2a */
-	__u8		reserved0_6	:1;
-	__u8		ps		:1;	/* parameters saveable */
-	__u8		page_length;		/* Page Length - Should be 0x12 */
-	__u8		reserved2, reserved3;
+	u8		reserved0_6	:1;
+	u8		ps		:1;	/* parameters saveable */
+	u8		page_length;		/* Page Length - Should be 0x12 */
+	u8		reserved2, reserved3;
 	unsigned	ro		:1;	/* Read Only Mode */
 	unsigned	reserved4_1234	:4;
 	unsigned	sprev		:1;	/* Supports SPACE in the reverse direction */
@@ -762,10 +735,10 @@ typedef struct {
 	unsigned	reserved5_67	:2;
 	unsigned	lock		:1;	/* Supports locking the volume */
 	unsigned	locked		:1;	/* The volume is locked */
-	unsigned	prevent		:1;	/* The device defaults in the prevent state after power up */	
+	unsigned	prevent		:1;	/* The device defaults in the prevent state after power up */
 	unsigned	eject		:1;	/* The device can eject the volume */
-	__u8		disconnect	:1;	/* The device can break request > ctl */	
-	__u8		reserved6_5	:1;
+	u8		disconnect	:1;	/* The device can break request > ctl */
+	u8		reserved6_5	:1;
 	unsigned	ecc		:1;	/* Supports error correction */
 	unsigned	cmprs		:1;	/* Supports data compression */
 	unsigned	reserved7_0	:1;
@@ -775,12 +748,12 @@ typedef struct {
 	unsigned	blk32768	:1;	/* slowb - the device restricts the byte count for PIO */
 						/* transfers for slow buffer memory ??? */
 						/* Also 32768 block size in some cases */
-	__u16		max_speed;		/* Maximum speed supported in KBps */
-	__u8		reserved10, reserved11;
-	__u16		ctl;			/* Continuous Transfer Limit in blocks */
-	__u16		speed;			/* Current Speed, in KBps */
-	__u16		buffer_size;		/* Buffer Size, in 512 bytes */
-	__u8		reserved18, reserved19;
+	u16		max_speed;		/* Maximum speed supported in KBps */
+	u8		reserved10, reserved11;
+	u16		ctl;			/* Continuous Transfer Limit in blocks */
+	u16		speed;			/* Current Speed, in KBps */
+	u16		buffer_size;		/* Buffer Size, in 512 bytes */
+	u8		reserved18, reserved19;
 } idetape_capabilities_page_t;
 
 /*
@@ -790,8 +763,8 @@ typedef struct {
 	unsigned	page_code	:6;	/* Page code - Should be 0x30 */
 	unsigned	reserved1_6	:1;
 	unsigned	ps		:1;
-	__u8		page_length;		/* Page Length - Should be 2 */
-	__u8		reserved2;
+	u8		page_length;		/* Page Length - Should be 2 */
+	u8		reserved2;
 	unsigned	play32		:1;
 	unsigned	play32_5	:1;
 	unsigned	reserved2_23	:2;
@@ -861,9 +834,9 @@ typedef struct {
 	 *	required since an additional packet command is needed before the
 	 *	retry, to get detailed information on what went wrong.
 	 */
-	idetape_pc_t *pc;			/* Current packet command */
-	idetape_pc_t *failed_pc; 		/* Last failed packet command */
-	idetape_pc_t pc_stack[IDETAPE_PC_STACK];/* Packet command stack */
+	struct atapi_packet_command *pc;			/* Current packet command */
+	struct atapi_packet_command *failed_pc;		/* Last failed packet command */
+	struct atapi_packet_command pc_stack[IDETAPE_PC_STACK];/* Packet command stack */
 	int pc_stack_index;			/* Next free packet command storage space */
 	struct request rq_stack[IDETAPE_PC_STACK];
 	int rq_stack_index;			/* We implement a circular array */
@@ -1248,7 +1221,7 @@ typedef union {
 /*
  *	ATAPI Device Control Register
  */
-typedef union {			
+typedef union {
 	unsigned all			:8;
 	struct {
 		unsigned zero0		:1;	/* Should be set to zero */
@@ -1482,17 +1455,9 @@ static void idetape_onstream_mode_sense_tape_parameter_page(struct ata_device *d
 static int idetape_chrdev_release (struct inode *inode, struct file *filp);
 static void idetape_write_release (struct inode *inode);
 
-/*
- *	Too bad. The drive wants to send us data which we are not ready to accept.
- *	Just throw it away.
- */
-static void idetape_discard_data(struct ata_device *drive, unsigned int bcount)
-{
-	while (bcount--)
-		IN_BYTE (IDE_DATA_REG);
-}
-
-static void idetape_input_buffers(struct ata_device *drive, idetape_pc_t *pc, unsigned int bcount)
+static void idetape_input_buffers(struct ata_device *drive,
+		struct atapi_packet_command *pc,
+		unsigned int bcount)
 {
 	struct bio *bio = pc->bio;
 	int count;
@@ -1501,7 +1466,7 @@ static void idetape_input_buffers(struct ata_device *drive, idetape_pc_t *pc, un
 #if IDETAPE_DEBUG_BUGS
 		if (bio == NULL) {
 			printk (KERN_ERR "ide-tape: bio == NULL in idetape_input_buffers\n");
-			idetape_discard_data (drive, bcount);
+			atapi_discard_data(drive, bcount);
 			return;
 		}
 #endif
@@ -1518,7 +1483,9 @@ static void idetape_input_buffers(struct ata_device *drive, idetape_pc_t *pc, un
 	pc->bio = bio;
 }
 
-static void idetape_output_buffers(struct ata_device *drive, idetape_pc_t *pc, unsigned int bcount)
+static void idetape_output_buffers(struct ata_device *drive,
+		struct atapi_packet_command *pc,
+		unsigned int bcount)
 {
 	struct bio *bio = pc->bio;
 	int count;
@@ -1529,7 +1496,7 @@ static void idetape_output_buffers(struct ata_device *drive, idetape_pc_t *pc, u
 			printk (KERN_ERR "ide-tape: bio == NULL in idetape_output_buffers\n");
 			return;
 		}
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 		count = min(pc->b_count, bcount);
 		atapi_write(drive, bio_data(bio), count);
 		bcount -= count;
@@ -1546,20 +1513,21 @@ static void idetape_output_buffers(struct ata_device *drive, idetape_pc_t *pc, u
 }
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
-static void idetape_update_buffers (idetape_pc_t *pc)
+static void idetape_update_buffers(struct atapi_packet_command *pc)
 {
 	struct bio *bio = pc->bio;
-	int count, bcount = pc->actually_transferred;
+	int count;
+	unsigned int bcount = pc->actually_transferred;
 
-	if (test_bit (PC_WRITING, &pc->flags))
+	if (test_bit(PC_WRITING, &pc->flags))
 		return;
 	while (bcount) {
-#if IDETAPE_DEBUG_BUGS
+# if IDETAPE_DEBUG_BUGS
 		if (bio == NULL) {
 			printk (KERN_ERR "ide-tape: bio == NULL in idetape_update_buffers\n");
 			return;
 		}
-#endif /* IDETAPE_DEBUG_BUGS */
+# endif
 		count = min(bio->bi_size, bcount);
 		pc->b_count = count;
 		if (pc->b_count == bio->bi_size)
@@ -1568,7 +1536,7 @@ static void idetape_update_buffers (idetape_pc_t *pc)
 	}
 	pc->bio = bio;
 }
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 
 /*
  *	idetape_next_pc_storage returns a pointer to a place in which we can
@@ -1576,7 +1544,7 @@ static void idetape_update_buffers (idetape_pc_t *pc)
  *	driver. A storage space for a maximum of IDETAPE_PC_STACK packet
  *	commands is allocated at initialization time.
  */
-static idetape_pc_t *idetape_next_pc_storage(struct ata_device *drive)
+static struct atapi_packet_command *idetape_next_pc_storage(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -1594,14 +1562,14 @@ static idetape_pc_t *idetape_next_pc_storage(struct ata_device *drive)
  *	Since we queue packet commands in the request queue, we need to
  *	allocate a request, along with the allocation of a packet command.
  */
- 
+
 /**************************************************************
  *                                                            *
  *  This should get fixed to use kmalloc(.., GFP_ATOMIC)      *
  *  followed later on by kfree().   -ml                       *
  *                                                            *
  **************************************************************/
- 
+
 static struct request *idetape_next_rq_storage(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
@@ -1609,27 +1577,12 @@ static struct request *idetape_next_rq_storage(struct ata_device *drive)
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 5)
 		printk (KERN_INFO "ide-tape: rq_stack_index=%d\n",tape->rq_stack_index);
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 	if (tape->rq_stack_index==IDETAPE_PC_STACK)
 		tape->rq_stack_index=0;
 	return (&tape->rq_stack[tape->rq_stack_index++]);
 }
 
-/*
- *	idetape_init_pc initializes a packet command.
- */
-static void idetape_init_pc (idetape_pc_t *pc)
-{
-	memset (pc->c, 0, 12);
-	pc->retries = 0;
-	pc->flags = 0;
-	pc->request_transfer = 0;
-	pc->buffer = pc->pc_buffer;
-	pc->buffer_size = IDETAPE_PC_BUFFER_SIZE;
-	pc->bio = NULL;
-	pc->b_data = NULL;
-}
-
 /*
  *	idetape_analyze_error is called on each failed packet command retry
  *	to analyze the request sense. We currently do not utilize this
@@ -1638,7 +1591,7 @@ static void idetape_init_pc (idetape_pc_t *pc)
 static void idetape_analyze_error(struct ata_device *drive, idetape_request_sense_result_t *result)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t *pc = tape->failed_pc;
+	struct atapi_packet_command *pc = tape->failed_pc;
 
 	tape->sense     = *result;
 	tape->sense_key = result->sense_key;
@@ -1652,15 +1605,15 @@ static void idetape_analyze_error(struct ata_device *drive, idetape_request_sens
 	if (tape->debug_level >= 1)
 		printk (KERN_INFO "ide-tape: pc = %x, sense key = %x, asc = %x, ascq = %x\n",
 				pc->c[0], result->sense_key, result->asc, result->ascq);
-#if IDETAPE_DEBUG_LOG_VERBOSE
+# if IDETAPE_DEBUG_LOG_VERBOSE
 	if (tape->debug_level >= 1)
 		printk (KERN_INFO "ide-tape: pc = %s, sense key = %x, asc = %x, ascq = %x\n",
 			idetape_command_key_verbose((byte) pc->c[0]),
 			result->sense_key,
 			result->asc,
 			result->ascq);
-#endif /* IDETAPE_DEBUG_LOG_VERBOSE */
-#endif /* IDETAPE_DEBUG_LOG */
+# endif
+#endif
 
 	if (tape->onstream && result->sense_key == 2 && result->asc == 0x53 && result->ascq == 2) {
 		clear_bit(PC_DMA_ERROR, &pc->flags);
@@ -1674,23 +1627,23 @@ static void idetape_analyze_error(struct ata_device *drive, idetape_request_sens
 	 */
 	if (test_bit (PC_DMA_ERROR, &pc->flags)) {
 		pc->actually_transferred = pc->request_transfer - tape->tape_block_size * ntohl (get_unaligned (&result->information));
-		idetape_update_buffers (pc);
+		idetape_update_buffers(pc);
 	}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 	if (pc->c[0] == IDETAPE_READ_CMD && result->filemark) {
 		pc->error = IDETAPE_ERROR_FILEMARK;
-		set_bit (PC_ABORT, &pc->flags);
+		set_bit(PC_ABORT, &pc->flags);
 	}
 	if (pc->c[0] == IDETAPE_WRITE_CMD) {
 		if (result->eom || (result->sense_key == 0xd && result->asc == 0x0 && result->ascq == 0x2)) {
 			pc->error = IDETAPE_ERROR_EOD;
-			set_bit (PC_ABORT, &pc->flags);
+			set_bit(PC_ABORT, &pc->flags);
 		}
 	}
 	if (pc->c[0] == IDETAPE_READ_CMD || pc->c[0] == IDETAPE_WRITE_CMD) {
 		if (result->sense_key == 8) {
 			pc->error = IDETAPE_ERROR_EOD;
-			set_bit (PC_ABORT, &pc->flags);
+			set_bit(PC_ABORT, &pc->flags);
 		}
 		if (!test_bit (PC_ABORT, &pc->flags) && (tape->onstream || pc->actually_transferred))
 			pc->retries = IDETAPE_MAX_PC_RETRIES + 1;
@@ -1727,13 +1680,13 @@ static void idetape_active_next_stage(struct ata_device *drive)
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_active_next_stage\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 #if IDETAPE_DEBUG_BUGS
 	if (stage == NULL) {
 		printk (KERN_ERR "ide-tape: bug: Trying to activate a non existing stage\n");
 		return;
 	}
-#endif /* IDETAPE_DEBUG_BUGS */	
+#endif
 
 	rq->buffer = NULL;
 	rq->bio = stage->bio;
@@ -1816,7 +1769,7 @@ static void idetape_remove_stage_head(struct ata_device *drive)
 		printk (KERN_ERR "ide-tape: bug: Trying to free our active pipeline stage\n");
 		return;
 	}
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 	stage = tape->first_stage;
 	tape->first_stage = stage->next;
 	idetape_kfree_stage (tape, stage);
@@ -1828,7 +1781,7 @@ static void idetape_remove_stage_head(struct ata_device *drive)
 			printk (KERN_ERR "ide-tape: bug: tape->next_stage != NULL\n");
 		if (tape->nr_stages)
 			printk (KERN_ERR "ide-tape: bug: nr_stages should be 0 now\n");
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 	}
 }
 
@@ -1880,7 +1833,7 @@ static int idetape_end_request(struct ata_device *drive, struct request *rq, int
 			}
 #endif
 			if (tape->onstream && !tape->raw) {
-				if (tape->first_frame_position == OS_DATA_ENDFRAME1) { 
+				if (tape->first_frame_position == OS_DATA_ENDFRAME1) {
 #if ONSTREAM_DEBUG
 					if (tape->debug_level >= 2)
 						printk("ide-tape: %s: skipping over config parition..\n", tape->name);
@@ -1935,14 +1888,14 @@ static int idetape_end_request(struct ata_device *drive, struct request *rq, int
 	return 0;
 }
 
-static ide_startstop_t idetape_request_sense_callback(struct ata_device *drive, struct request *rq)
+static void idetape_request_sense_callback(struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_request_sense_callback\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 	if (!tape->pc->error) {
 		idetape_analyze_error (drive, (idetape_request_sense_result_t *) tape->pc->buffer);
 		idetape_end_request(drive, rq, 1);
@@ -1950,12 +1903,11 @@ static ide_startstop_t idetape_request_sense_callback(struct ata_device *drive,
 		printk (KERN_ERR "ide-tape: Error in REQUEST SENSE itself - Aborting request!\n");
 		idetape_end_request(drive, rq, 0);
 	}
-	return ide_stopped;
 }
 
-static void idetape_create_request_sense_cmd (idetape_pc_t *pc)
+static void idetape_create_request_sense_cmd(struct atapi_packet_command *pc)
 {
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_REQUEST_SENSE_CMD;
 	pc->c[4] = 20;
 	pc->request_transfer = 18;
@@ -1981,7 +1933,7 @@ static void idetape_create_request_sense_cmd (idetape_pc_t *pc)
  *	and wait for their completion using idetape_queue_pc_tail or
  *	idetape_queue_rw_tail.
  */
-static void idetape_queue_pc_head(struct ata_device *drive, idetape_pc_t *pc, struct request *rq)
+static void idetape_queue_pc_head(struct ata_device *drive, struct atapi_packet_command *pc, struct request *rq)
 {
 	ide_init_drive_cmd (rq);
 	rq->buffer = (char *) pc;
@@ -1994,10 +1946,10 @@ static void idetape_queue_pc_head(struct ata_device *drive, idetape_pc_t *pc, st
  *	last packet command. We queue a request sense packet command in
  *	the head of the request list.
  */
-static ide_startstop_t idetape_retry_pc(struct ata_device *drive)
+static void idetape_retry_pc(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t *pc;
+	struct atapi_packet_command *pc;
 	struct request *rq;
 	idetape_error_reg_t error;
 
@@ -2007,7 +1959,6 @@ static ide_startstop_t idetape_retry_pc(struct ata_device *drive)
 	idetape_create_request_sense_cmd (pc);
 	set_bit (IDETAPE_IGNORE_DSC, &tape->flags);
 	idetape_queue_pc_head (drive, pc, rq);
-	return ide_stopped;
 }
 
 /*
@@ -2041,7 +1992,7 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 	idetape_status_reg_t status;
 	idetape_bcount_reg_t bcount;
 	idetape_ireason_reg_t ireason;
-	idetape_pc_t *pc = tape->pc;
+	struct atapi_packet_command *pc = tape->pc;
 
 	unsigned int temp;
 	unsigned long cmd_time;
@@ -2052,7 +2003,7 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_pc_intr interrupt handler\n");
-#endif /* IDETAPE_DEBUG_LOG */	
+#endif
 
 	status.all = GET_STAT();					/* Clear the interrupt */
 
@@ -2078,9 +2029,9 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 #if IDETAPE_DEBUG_LOG
 		if (tape->debug_level >= 4)
 			printk (KERN_INFO "ide-tape: DMA finished\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 	}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 
 	if (!status.b.drq) {						/* No more interrupts */
 		cmd_time = (jiffies - tape->cmd_start_time) * 1000 / HZ;
@@ -2088,7 +2039,7 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 #if IDETAPE_DEBUG_LOG
 		if (tape->debug_level >= 2)
 			printk (KERN_INFO "ide-tape: Packet command completed, %d bytes transferred\n", pc->actually_transferred);
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 		clear_bit (PC_DMA_IN_PROGRESS, &pc->flags);
 
 		ide__sti();	/* local CPU only */
@@ -2105,7 +2056,7 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 #if IDETAPE_DEBUG_LOG
 			if (tape->debug_level >= 1)
 				printk (KERN_INFO "ide-tape: %s: I/O error, ",tape->name);
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 			if (pc->c[0] == IDETAPE_REQUEST_SENSE_CMD) {
 				printk (KERN_ERR "ide-tape: I/O error in request sense command\n");
 				return ide_stopped;
@@ -2114,7 +2065,8 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 			if (tape->debug_level >= 1)
 				printk(KERN_INFO "ide-tape: [cmd %x]: check condition\n", pc->c[0]);
 #endif
-			return idetape_retry_pc (drive);				/* Retry operation */
+			idetape_retry_pc(drive);				/* Retry operation */
+			return ide_stopped;
 		}
 		pc->error = 0;
 		if (!tape->onstream && test_bit (PC_WAIT_FOR_DSC, &pc->flags) && !status.b.dsc) {	/* Media access command */
@@ -2126,7 +2078,8 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 		}
 		if (tape->failed_pc == pc)
 			tape->failed_pc = NULL;
-		return pc->callback(drive, rq);			/* Command finished - Call the callback function */
+		pc->callback(drive, rq);	/* Command finished - Call the callback function */
+		return ide_stopped;
 	}
 #ifdef CONFIG_BLK_DEV_IDEDMA
 	if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
@@ -2136,7 +2089,7 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 
 		return ide_stopped;
 	}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 	bcount.b.high = IN_BYTE (IDE_BCOUNTH_REG);			/* Get the number of bytes to transfer */
 	bcount.b.low  = IN_BYTE (IDE_BCOUNTL_REG);			/* on this interrupt */
 	ireason.all   = IN_BYTE (IDE_IREASON_REG);
@@ -2155,14 +2108,14 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 		if ( temp > pc->request_transfer) {
 			if (temp > pc->buffer_size) {
 				printk (KERN_ERR "ide-tape: The tape wants to send us more data than expected - discarding data\n");
-				idetape_discard_data (drive, bcount.all);
+				atapi_discard_data (drive, bcount.all);
 				ide_set_handler(drive, idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);
 				return ide_started;
 			}
 #if IDETAPE_DEBUG_LOG
 			if (tape->debug_level >= 2)
 				printk (KERN_NOTICE "ide-tape: The tape wants to send us more data than expected - allowing transfer\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 		}
 	}
 	if (test_bit (PC_WRITING, &pc->flags)) {
@@ -2206,11 +2159,11 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
  *	3.	ATAPI Tape media access commands have immediate status with a
  *		delayed process. In case of a successful initiation of a
  *		media access packet command, the DSC bit will be set when the
- *		actual execution of the command is finished. 
+ *		actual execution of the command is finished.
  *		Since the tape drive will not issue an interrupt, we have to
  *		poll for this event. In this case, we define the request as
  *		"low priority request" by setting rq_status to
- *		IDETAPE_RQ_POSTPONED, 	set a timer to poll for DSC and exit
+ *		IDETAPE_RQ_POSTPONED,	set a timer to poll for DSC and exit
  *		the driver.
  *
  *		ide.c will then give higher priority to requests which
@@ -2231,7 +2184,7 @@ static ide_startstop_t idetape_pc_intr(struct ata_device *drive, struct request
 static ide_startstop_t idetape_transfer_pc(struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t *pc = tape->pc;
+	struct atapi_packet_command *pc = tape->pc;
 	idetape_ireason_reg_t ireason;
 	int retries = 100;
 	ide_startstop_t startstop;
@@ -2258,10 +2211,12 @@ static ide_startstop_t idetape_transfer_pc(struct ata_device *drive, struct requ
 	tape->cmd_start_time = jiffies;
 	ide_set_handler(drive, idetape_pc_intr, IDETAPE_WAIT_CMD, NULL);	/* Set the interrupt routine */
 	atapi_write(drive,pc->c,12);	/* Send the actual packet */
+
 	return ide_started;
 }
 
-static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive, struct request *rq, idetape_pc_t *pc)
+static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive,
+		struct request *rq, struct atapi_packet_command *pc)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_bcount_reg_t bcount;
@@ -2277,7 +2232,7 @@ static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive, st
 		tape->failed_pc = pc;
 	tape->pc = pc;							/* Set the current packet command */
 
-	if (pc->retries > IDETAPE_MAX_PC_RETRIES || test_bit (PC_ABORT, &pc->flags)) {
+	if (pc->retries > IDETAPE_MAX_PC_RETRIES || test_bit(PC_ABORT, &pc->flags)) {
 		/*
 		 *	We will "abort" retrying a packet command in case
 		 *	a legitimate error code was received (crossing a
@@ -2295,12 +2250,13 @@ static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive, st
 			pc->error = IDETAPE_ERROR_GENERAL;		/* Giving up */
 		}
 		tape->failed_pc = NULL;
-		return pc->callback(drive, rq);
+		pc->callback(drive, rq);
+		return ide_stopped;
 	}
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 2)
 		printk (KERN_INFO "ide-tape: Retry number - %d\n", pc->retries);
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	pc->retries++;
 	pc->actually_transferred = 0;					/* We haven't transferred any data yet */
@@ -2328,10 +2284,10 @@ static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive, st
 	OUT_BYTE (drive->select.all, IDE_SELECT_REG);
 #ifdef CONFIG_BLK_DEV_IDEDMA
 	if (dma_ok) {						/* Begin DMA, if necessary */
-		set_bit (PC_DMA_IN_PROGRESS, &pc->flags);
+		set_bit(PC_DMA_IN_PROGRESS, &pc->flags);
 		udma_start(drive, rq);
 	}
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 	if (test_bit(IDETAPE_DRQ_INTERRUPT, &tape->flags)) {
 		ide_set_handler(drive, idetape_transfer_pc, IDETAPE_WAIT_CMD, NULL);
 		OUT_BYTE(WIN_PACKETCMD, IDE_COMMAND_REG);
@@ -2345,25 +2301,24 @@ static ide_startstop_t idetape_issue_packet_command(struct ata_device *drive, st
 /*
  *	General packet command callback function.
  */
-static ide_startstop_t idetape_pc_callback(struct ata_device *drive, struct request *rq)
+static void idetape_pc_callback(struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	
+
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_pc_callback\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	idetape_end_request(drive, rq, tape->pc->error ? 0 : 1);
-	return ide_stopped;
 }
 
 /*
  *	A mode sense command is used to "sense" tape parameters.
  */
-static void idetape_create_mode_sense_cmd (idetape_pc_t *pc, byte page_code)
+static void idetape_create_mode_sense_cmd(struct atapi_packet_command *pc, byte page_code)
 {
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_MODE_SENSE_CMD;
 	if (page_code != IDETAPE_BLOCK_DESCRIPTOR)
 		pc->c[1] = 8;			/* DBD = 1 - Don't return block descriptors */
@@ -2379,7 +2334,7 @@ static void idetape_create_mode_sense_cmd (idetape_pc_t *pc, byte page_code)
 	pc->callback = idetape_pc_callback;
 }
 
-static ide_startstop_t idetape_onstream_buffer_fill_callback (struct ata_device *drive, struct request *rq)
+static void idetape_onstream_buffer_fill_callback (struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
@@ -2404,12 +2359,11 @@ static ide_startstop_t idetape_onstream_buffer_fill_callback (struct ata_device
 		printk(KERN_INFO "ide-tape: buffer fill callback, %d/%d\n", tape->cur_frames, tape->max_frames);
 #endif
 	idetape_end_request(drive, rq, tape->pc->error ? 0 : 1);
-	return ide_stopped;
 }
 
 static void idetape_queue_onstream_buffer_fill(struct ata_device *drive)
 {
-	idetape_pc_t *pc;
+	struct atapi_packet_command *pc;
 	struct request *rq;
 
 	pc = idetape_next_pc_storage (drive);
@@ -2467,10 +2421,10 @@ static void calculate_speeds(struct ata_device *drive)
 	tape->max_insert_speed = max(tape->max_insert_speed, 500);
 }
 
-static ide_startstop_t idetape_media_access_finished(struct ata_device *drive, struct request *rq)
+static void idetape_media_access_finished(struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t *pc = tape->pc;
+	struct atapi_packet_command *pc = tape->pc;
 	idetape_status_reg_t status;
 
 	if (tape->onstream)
@@ -2479,7 +2433,8 @@ static ide_startstop_t idetape_media_access_finished(struct ata_device *drive, s
 	if (status.b.dsc) {
 		if (status.b.check) {					/* Error detected */
 			printk (KERN_ERR "ide-tape: %s: I/O error, ",tape->name);
-			return idetape_retry_pc (drive);			/* Retry operation */
+			idetape_retry_pc(drive);			/* Retry operation */
+			return;
 		}
 		pc->error = 0;
 		if (tape->failed_pc == pc)
@@ -2488,10 +2443,10 @@ static ide_startstop_t idetape_media_access_finished(struct ata_device *drive, s
 		pc->error = IDETAPE_ERROR_GENERAL;
 		tape->failed_pc = NULL;
 	}
-	return pc->callback(drive, rq);
+	pc->callback(drive, rq);
 }
 
-static ide_startstop_t idetape_rw_callback(struct ata_device *drive, struct request *rq)
+static void idetape_rw_callback(struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int blocks = tape->pc->actually_transferred / tape->tape_block_size;
@@ -2516,7 +2471,7 @@ static ide_startstop_t idetape_rw_callback(struct ata_device *drive, struct requ
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_rw_callback\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	tape->first_frame_position += blocks;
 	rq->current_nr_sectors -= blocks;
@@ -2525,14 +2480,15 @@ static ide_startstop_t idetape_rw_callback(struct ata_device *drive, struct requ
 		idetape_end_request(drive, rq, 1);
 	else
 		idetape_end_request(drive, rq, tape->pc->error);
-	return ide_stopped;
 }
 
-static void idetape_create_read_cmd (idetape_tape_t *tape, idetape_pc_t *pc, unsigned int length, struct bio *bio)
+static void idetape_create_read_cmd(idetape_tape_t *tape,
+		struct atapi_packet_command *pc,
+		unsigned int length, struct bio *bio)
 {
 	struct bio *p = bio;
 	struct bio_vec *bv = bio_iovec(p);
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_READ_CMD;
 	put_unaligned (htonl (length), (unsigned int *) &pc->c[1]);
 	pc->c[1] = 1;
@@ -2549,22 +2505,24 @@ static void idetape_create_read_cmd (idetape_tape_t *tape, idetape_pc_t *pc, uns
 	if (!tape->onstream) {
 		pc->request_transfer = pc->buffer_size = length * tape->tape_block_size;
 		if (pc->request_transfer == tape->stage_size)
-			set_bit (PC_DMA_RECOMMENDED, &pc->flags);
+			set_bit(PC_DMA_RECOMMENDED, &pc->flags);
 	} else  {
 		if (length) {
 			pc->request_transfer = pc->buffer_size = 32768 + 512;
-			set_bit (PC_DMA_RECOMMENDED, &pc->flags);
+			set_bit(PC_DMA_RECOMMENDED, &pc->flags);
 		} else
 			pc->request_transfer = 0;
 	}
 }
 
-static void idetape_create_read_buffer_cmd(idetape_tape_t *tape, idetape_pc_t *pc, unsigned int length, struct bio *bio)
+static void idetape_create_read_buffer_cmd(idetape_tape_t *tape,
+		struct atapi_packet_command *pc,
+		unsigned int length, struct bio *bio)
 {
 	int size = 32768;
 
 	struct bio *p = bio;
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_READ_BUFFER_CMD;
 	pc->c[1] = IDETAPE_RETRIEVE_FAULTY_BLOCK;
 	pc->c[7] = size >> 8;
@@ -2580,11 +2538,13 @@ static void idetape_create_read_buffer_cmd(idetape_tape_t *tape, idetape_pc_t *p
 	pc->request_transfer = pc->buffer_size = size;
 }
 
-static void idetape_create_write_cmd (idetape_tape_t *tape, idetape_pc_t *pc, unsigned int length, struct bio *bio)
+static void idetape_create_write_cmd(idetape_tape_t *tape,
+		struct atapi_packet_command *pc,
+		unsigned int length, struct bio *bio)
 {
 	struct bio *p = bio;
 	struct bio_vec *bv= bio_iovec(p);
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_WRITE_CMD;
 	put_unaligned (htonl (length), (unsigned int *) &pc->c[1]);
 	pc->c[1] = 1;
@@ -2619,16 +2579,16 @@ static void idetape_create_write_cmd (idetape_tape_t *tape, idetape_pc_t *pc, un
 static ide_startstop_t idetape_do_request(struct ata_device *drive, struct request *rq, sector_t block)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t *pc;
+	struct atapi_packet_command *pc;
 	struct request *postponed_rq = tape->postponed_rq;
 	idetape_status_reg_t status;
 
 #if IDETAPE_DEBUG_LOG
-	if (tape->debug_level >= 5)
-/*		printk (KERN_INFO "ide-tape: rq_status: %d, rq_dev: %u, cmd: %ld, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->flags,rq->errors); */
+/*	if (tape->debug_level >= 5)
+		printk (KERN_INFO "ide-tape: rq_status: %d, rq_dev: %u, cmd: %ld, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->flags,rq->errors); */
 	if (tape->debug_level >= 2)
 		printk (KERN_INFO "ide-tape: sector: %ld, nr_sectors: %ld, current_nr_sectors: %d\n",rq->sector,rq->nr_sectors,rq->current_nr_sectors);
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	if (!IDETAPE_RQ_CMD (rq->flags)) {
 		/*
@@ -2652,7 +2612,7 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
 			idetape_end_request(drive, rq, 0);
 			return ide_stopped;
 		}
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 
 	tape->postponed_rq = NULL;
 
@@ -2788,7 +2748,8 @@ static ide_startstop_t idetape_do_request(struct ata_device *drive, struct reque
 			idetape_end_request(drive, rq, IDETAPE_ERROR_EOD);
 			return ide_stopped;
 		case IDETAPE_PC_RQ1:
-			pc = (idetape_pc_t *) rq->buffer;
+			/* FIXME: --mdcki */
+			pc = (struct atapi_packet_command *) rq->buffer;
 			rq->flags = IDETAPE_PC_RQ2;
 			break;
 		case IDETAPE_PC_RQ2:
@@ -2912,7 +2873,8 @@ static idetape_stage_t *idetape_kmalloc_stage (idetape_tape_t *tape)
 	return __idetape_kmalloc_stage (tape, 0, 0);
 }
 
-static void idetape_copy_stage_from_user (idetape_tape_t *tape, idetape_stage_t *stage, const char *buf, int n)
+static void idetape_copy_stage_from_user(idetape_tape_t *tape, idetape_stage_t *stage,
+		const char *buf, unsigned int n)
 {
 	struct bio *bio = tape->bio;
 	int count;
@@ -2949,7 +2911,7 @@ static void idetape_copy_stage_to_user (idetape_tape_t *tape, char *buf, idetape
 			printk (KERN_ERR "ide-tape: bio == NULL in idetape_copy_stage_to_user\n");
 			return;
 		}
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 		count = min(tape->b_count, n);
 		copy_to_user (buf, tape->b_data, count);
 		n -= count;
@@ -2969,7 +2931,7 @@ static void idetape_copy_stage_to_user (idetape_tape_t *tape, char *buf, idetape
 static void idetape_init_merge_stage (idetape_tape_t *tape)
 {
 	struct bio *bio = tape->merge_stage->bio;
-	
+
 	tape->bio = bio;
 	if (tape->chrdev_direction == idetape_direction_write)
 		atomic_set(&bio->bi_cnt, 0);
@@ -3069,7 +3031,7 @@ static void idetape_init_stage(struct ata_device *drive, idetape_stage_t *stage,
 		else
 			dat->dat_list[0].flags = OS_DAT_FLAGS_DATA;
 		dat->dat_list[0].reserved = 0;
-	} 
+	}
 	aux->filemark_cnt = ntohl(tape->filemark_cnt);		/* shouldn't this be htonl ?? */
 	aux->phys_fm = ntohl(0xffffffff);			/* shouldn't this be htonl ?? */
 	aux->last_mark_addr = ntohl(tape->last_mark_addr);	/* shouldn't this be htonl ?? */
@@ -3102,15 +3064,15 @@ static void idetape_wait_for_request(struct ata_device *drive, struct request *r
 	spin_lock_irq(&tape->spinlock);
 }
 
-static ide_startstop_t idetape_read_position_callback(struct ata_device *drive, struct request *rq)
+static void idetape_read_position_callback(struct ata_device *drive, struct request *rq)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	idetape_read_position_result_t *result;
-	
+
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 		printk (KERN_INFO "ide-tape: Reached idetape_read_position_callback\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	if (!tape->pc->error) {
 		result = (idetape_read_position_result_t *) tape->pc->buffer;
@@ -3119,7 +3081,7 @@ static ide_startstop_t idetape_read_position_callback(struct ata_device *drive,
 			printk (KERN_INFO "ide-tape: BOP - %s\n",result->bop ? "Yes":"No");
 		if (tape->debug_level >= 2)
 			printk (KERN_INFO "ide-tape: EOP - %s\n",result->eop ? "Yes":"No");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 		if (result->bpu) {
 			printk (KERN_INFO "ide-tape: Block location is unknown to the tape\n");
 			clear_bit (IDETAPE_ADDRESS_VALID, &tape->flags);
@@ -3128,7 +3090,7 @@ static ide_startstop_t idetape_read_position_callback(struct ata_device *drive,
 #if IDETAPE_DEBUG_LOG
 			if (tape->debug_level >= 2)
 				printk (KERN_INFO "ide-tape: Block Location - %u\n", ntohl (result->first_block));
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 			tape->partition = result->partition;
 			tape->first_frame_position = ntohl (result->first_block);
 			tape->last_frame_position = ntohl (result->last_block);
@@ -3139,7 +3101,6 @@ static ide_startstop_t idetape_read_position_callback(struct ata_device *drive,
 	} else {
 		idetape_end_request(drive, rq, 0);
 	}
-	return ide_stopped;
 }
 
 /*
@@ -3150,22 +3111,23 @@ static ide_startstop_t idetape_read_position_callback(struct ata_device *drive,
  *			if write_filemark=0.
  *
  */
-static void idetape_create_write_filemark_cmd(struct ata_device *drive, idetape_pc_t *pc,int write_filemark)
+static void idetape_create_write_filemark_cmd(struct ata_device *drive,
+		struct atapi_packet_command *pc,int write_filemark)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_WRITE_FILEMARK_CMD;
 	if (tape->onstream)
 		pc->c[1] = 1; /* Immed bit */
 	pc->c[4] = write_filemark;  /* not used for OnStream ?? */
-	set_bit (PC_WAIT_FOR_DSC, &pc->flags);
+	set_bit(PC_WAIT_FOR_DSC, &pc->flags);
 	pc->callback = idetape_pc_callback;
 }
 
-static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc)
+static void idetape_create_test_unit_ready_cmd(struct atapi_packet_command *pc)
 {
-	idetape_init_pc(pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_TEST_UNIT_READY_CMD;
 	pc->callback = idetape_pc_callback;
 }
@@ -3190,21 +3152,23 @@ static void idetape_create_test_unit_ready_cmd(idetape_pc_t *pc)
  *	the request to the request list without waiting for it to be serviced !
  *	In that case, we usually use idetape_queue_pc_head.
  */
-static int __idetape_queue_pc_tail(struct ata_device *drive, idetape_pc_t *pc)
+static int __idetape_queue_pc_tail(struct ata_device *drive, struct atapi_packet_command *pc)
 {
 	struct request rq;
 
 	ide_init_drive_cmd (&rq);
+	/* FIXME: --mdcki */
 	rq.buffer = (char *) pc;
 	rq.flags = IDETAPE_PC_RQ1;
 	return ide_do_drive_cmd(drive, &rq, ide_wait);
 }
 
-static void idetape_create_load_unload_cmd(struct ata_device *drive, idetape_pc_t *pc,int cmd)
+static void idetape_create_load_unload_cmd(struct ata_device *drive,
+		struct atapi_packet_command *pc, int cmd)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_LOAD_UNLOAD_CMD;
 	pc->c[4] = cmd;
 	if (tape->onstream) {
@@ -3219,7 +3183,7 @@ static void idetape_create_load_unload_cmd(struct ata_device *drive, idetape_pc_
 static int idetape_wait_ready(struct ata_device *drive, unsigned long long timeout)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 
 	/*
 	 * Wait for the tape to become ready
@@ -3244,7 +3208,7 @@ static int idetape_wait_ready(struct ata_device *drive, unsigned long long timeo
 	return -EIO;
 }
 
-static int idetape_queue_pc_tail(struct ata_device *drive, idetape_pc_t *pc)
+static int idetape_queue_pc_tail(struct ata_device *drive, struct atapi_packet_command *pc)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int rc;
@@ -3260,7 +3224,7 @@ static int idetape_queue_pc_tail(struct ata_device *drive, idetape_pc_t *pc)
 
 static int idetape_flush_tape_buffers(struct ata_device *drive)
 {
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	int rc;
 
 	idetape_create_write_filemark_cmd(drive, &pc, 0);
@@ -3270,9 +3234,9 @@ static int idetape_flush_tape_buffers(struct ata_device *drive)
 	return 0;
 }
 
-static void idetape_create_read_position_cmd (idetape_pc_t *pc)
+static void idetape_create_read_position_cmd(struct atapi_packet_command *pc)
 {
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_READ_POSITION_CMD;
 	pc->request_transfer = 20;
 	pc->callback = idetape_read_position_callback;
@@ -3281,13 +3245,13 @@ static void idetape_create_read_position_cmd (idetape_pc_t *pc)
 static int idetape_read_position(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	int position;
 
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 4)
 	    printk (KERN_INFO "ide-tape: Reached idetape_read_position\n");
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 #ifdef NO_LONGER_REQUIRED
 	idetape_flush_tape_buffers(drive);
@@ -3311,11 +3275,13 @@ static int idetape_read_position(struct ata_device *drive)
 	return position;
 }
 
-static void idetape_create_locate_cmd(struct ata_device *drive, idetape_pc_t *pc, unsigned int block, byte partition, int skip)
+static void idetape_create_locate_cmd(struct ata_device *drive,
+		struct atapi_packet_command *pc,
+		unsigned int block, u8 partition, int skip)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_LOCATE_CMD;
 	if (tape->onstream)
 		pc->c[1] = 1; /* Immediate bit */
@@ -3334,17 +3300,19 @@ static void idetape_create_locate_cmd(struct ata_device *drive, idetape_pc_t *pc
 	pc->callback = idetape_pc_callback;
 }
 
-static int idetape_create_prevent_cmd(struct ata_device *drive, idetape_pc_t *pc, int prevent)
+static int idetape_create_prevent_cmd(struct ata_device *drive,
+		struct atapi_packet_command *pc, int prevent)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
 	if (!tape->capabilities.lock)
 		return 0;
 
-	idetape_init_pc(pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_PREVENT_CMD;
 	pc->c[4] = prevent;
 	pc->callback = idetape_pc_callback;
+
 	return 1;
 }
 
@@ -3393,7 +3361,7 @@ static int idetape_position_tape(struct ata_device *drive, unsigned int block, b
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int retval;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 
 	if (tape->chrdev_direction == idetape_direction_read)
 		__idetape_discard_read_pipeline(drive);
@@ -3430,7 +3398,7 @@ static void idetape_discard_read_pipeline(struct ata_device *drive, int restore_
 
 static void idetape_update_stats(struct ata_device *drive)
 {
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 
 	idetape_create_mode_sense_cmd (&pc, IDETAPE_BUFFER_FILLING_PAGE);
 	pc.callback = idetape_onstream_buffer_fill_callback;
@@ -3598,30 +3566,31 @@ static void idetape_insert_pipeline_into_queue(struct ata_device *drive)
 	}
 }
 
-static void idetape_create_inquiry_cmd (idetape_pc_t *pc)
+static void idetape_create_inquiry_cmd(struct atapi_packet_command *pc)
 {
-	idetape_init_pc(pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_INQUIRY_CMD;
 	pc->c[4] = pc->request_transfer = 254;
 	pc->callback = idetape_pc_callback;
 }
 
-static void idetape_create_rewind_cmd(struct ata_device *drive, idetape_pc_t *pc)
+static void idetape_create_rewind_cmd(struct ata_device *drive,
+		struct atapi_packet_command *pc)
 {
 	idetape_tape_t *tape = drive->driver_data;
 
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_REWIND_CMD;
 	if (tape->onstream)
 		pc->c[1] = 1;
-	set_bit (PC_WAIT_FOR_DSC, &pc->flags);
+	set_bit(PC_WAIT_FOR_DSC, &pc->flags);
 	pc->callback = idetape_pc_callback;
 }
 
-static void idetape_create_mode_select_cmd (idetape_pc_t *pc, int length)
+static void idetape_create_mode_select_cmd(struct atapi_packet_command *pc, int length)
 {
-	idetape_init_pc (pc);
-	set_bit (PC_WRITING, &pc->flags);
+	atapi_init_pc(pc);
+	set_bit(PC_WRITING, &pc->flags);
 	pc->c[0] = IDETAPE_MODE_SELECT_CMD;
 	pc->c[1] = 0x10;
 	put_unaligned (htons(length), (unsigned short *) &pc->c[3]);
@@ -3629,22 +3598,22 @@ static void idetape_create_mode_select_cmd (idetape_pc_t *pc, int length)
 	pc->callback = idetape_pc_callback;
 }
 
-static void idetape_create_erase_cmd (idetape_pc_t *pc)
+static void idetape_create_erase_cmd(struct atapi_packet_command *pc)
 {
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_ERASE_CMD;
 	pc->c[1] = 1;
-	set_bit (PC_WAIT_FOR_DSC, &pc->flags);
+	set_bit(PC_WAIT_FOR_DSC, &pc->flags);
 	pc->callback = idetape_pc_callback;
 }
 
-static void idetape_create_space_cmd (idetape_pc_t *pc,int count,byte cmd)
+static void idetape_create_space_cmd(struct atapi_packet_command *pc, int count, u8 cmd)
 {
-	idetape_init_pc (pc);
+	atapi_init_pc(pc);
 	pc->c[0] = IDETAPE_SPACE_CMD;
 	put_unaligned (htonl (count), (unsigned int *) &pc->c[1]);
 	pc->c[1] = cmd;
-	set_bit (PC_WAIT_FOR_DSC, &pc->flags);
+	set_bit(PC_WAIT_FOR_DSC, &pc->flags);
 	pc->callback = &idetape_pc_callback;
 }
 
@@ -3853,9 +3822,9 @@ static void idetape_wait_for_pipeline(struct ata_device *drive)
 static void idetape_empty_write_pipeline(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	int blocks, i, min;
+	int blocks, min;
 	struct bio *bio;
-	
+
 #if IDETAPE_DEBUG_BUGS
 	if (tape->chrdev_direction != idetape_direction_write) {
 		printk (KERN_ERR "ide-tape: bug: Trying to empty write pipeline, but we are not writing.\n");
@@ -3865,10 +3834,12 @@ static void idetape_empty_write_pipeline(struct ata_device *drive)
 		printk (KERN_ERR "ide-tape: bug: merge_buffer too big\n");
 		tape->merge_stage_size = tape->stage_size;
 	}
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 	if (tape->merge_stage_size) {
 		blocks = tape->merge_stage_size / tape->tape_block_size;
 		if (tape->merge_stage_size % tape->tape_block_size) {
+			unsigned int i;
+
 			blocks++;
 			i = tape->tape_block_size - tape->merge_stage_size % tape->tape_block_size;
 			bio = tape->bio->bi_next;
@@ -4149,9 +4120,11 @@ static void idetape_pad_zeros(struct ata_device *drive, int bcount)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	struct bio *bio;
-	int count, blocks;
+	int blocks;
 
 	while (bcount) {
+		unsigned int count;
+
 		bio = tape->merge_stage->bio;
 		count = min(tape->stage_size, bcount);
 		bcount -= count;
@@ -4194,7 +4167,7 @@ static int idetape_pipeline_size(struct ata_device *drive)
 static int idetape_rewind_tape(struct ata_device *drive)
 {
 	int retval;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_tape_t *tape = drive->driver_data;
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 2)
@@ -4458,7 +4431,7 @@ static int idetape_onstream_space_over_filemarks_forward_fast(struct ata_device
 static int idetape_space_over_filemarks(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	unsigned long flags;
 	int retval,count=0;
 	int speed_control;
@@ -4774,8 +4747,8 @@ static void idetape_write_header(struct ata_device *drive, int locate_eod)
 	}
 }
 
-static ssize_t idetape_chrdev_write (struct file *file, const char *buf,
-				     size_t count, loff_t *ppos)
+static ssize_t idetape_chrdev_write(struct file *file, const char *buf,
+		size_t count, loff_t *ppos)
 {
 	struct inode *inode = file->f_dentry->d_inode;
 	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
@@ -4791,7 +4764,7 @@ static ssize_t idetape_chrdev_write (struct file *file, const char *buf,
 #if IDETAPE_DEBUG_LOG
 	if (tape->debug_level >= 3)
 		printk (KERN_INFO "ide-tape: Reached idetape_chrdev_write, count %Zd\n", count);
-#endif /* IDETAPE_DEBUG_LOG */
+#endif
 
 	if (tape->onstream) {
 		if (count != tape->tape_block_size) {
@@ -4821,7 +4794,7 @@ static ssize_t idetape_chrdev_write (struct file *file, const char *buf,
 			printk (KERN_ERR "ide-tape: merge_stage_size should be 0 now\n");
 			tape->merge_stage_size = 0;
 		}
-#endif /* IDETAPE_DEBUG_BUGS */
+#endif
 		if ((tape->merge_stage = __idetape_kmalloc_stage (tape, 0, 0)) == NULL)
 			return -ENOMEM;
 		tape->chrdev_direction = idetape_direction_write;
@@ -4918,7 +4891,7 @@ static int idetape_write_filemark(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
 	int last_mark_addr;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 
 	if (!tape->onstream) {
 		idetape_create_write_filemark_cmd(drive, &pc, 1);	/* Write a filemark */
@@ -5064,7 +5037,7 @@ ok:
 static int idetape_mtioctop(struct ata_device *drive,short mt_op,int mt_count)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	int i,retval;
 
 #if IDETAPE_DEBUG_LOG
@@ -5403,7 +5376,7 @@ static int idetape_chrdev_open (struct inode *inode, struct file *filp)
 {
 	struct ata_device *drive;
 	idetape_tape_t *tape;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	unsigned int minor=minor(inode->i_rdev);
 
 #if IDETAPE_DEBUG_LOG
@@ -5486,7 +5459,7 @@ static int idetape_chrdev_release (struct inode *inode, struct file *filp)
 {
 	struct ata_device *drive = get_drive_ptr (inode->i_rdev);
 	idetape_tape_t *tape;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	unsigned int minor=minor(inode->i_rdev);
 
 	tape = drive->driver_data;
@@ -5655,7 +5628,7 @@ static int idetape_identify_device(struct ata_device *drive,struct hd_driveid *i
  */
 static void idetape_onstream_set_vendor(struct ata_device *drive, char *vendor)
 {
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_mode_parameter_header_t *header;
 
 	idetape_create_mode_select_cmd(&pc, sizeof(*header) + 8);
@@ -5682,7 +5655,7 @@ static void idetape_onstream_set_vendor(struct ata_device *drive, char *vendor)
 #if ONSTREAM_DEBUG
 static void idetape_onstream_set_retries(struct ata_device *drive, int retries)
 {
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 
 	idetape_create_mode_select_cmd(&pc, sizeof(idetape_mode_parameter_header_t) + 4);
 	pc.buffer[0] = 3 + 4;
@@ -5703,7 +5676,7 @@ static void idetape_onstream_set_retries(struct ata_device *drive, int retries)
  */
 static void idetape_onstream_configure_block_size(struct ata_device *drive)
 {
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_mode_parameter_header_t *header;
 	idetape_block_size_page_t *bs;
 
@@ -5751,7 +5724,7 @@ static void idetape_get_inquiry_results(struct ata_device *drive)
 {
 	char *r;
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_inquiry_result_t *inquiry;
 
 	idetape_create_inquiry_cmd(&pc);
@@ -5804,10 +5777,10 @@ static void idetape_configure_onstream(struct ata_device *drive)
 static void idetape_onstream_mode_sense_tape_parameter_page(struct ata_device *drive, int debug)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_mode_parameter_header_t *header;
 	onstream_tape_paramtr_page_t *prm;
-	
+
 	idetape_create_mode_sense_cmd (&pc, IDETAPE_PARAMTR_PAGE);
 	if (idetape_queue_pc_tail (drive, &pc)) {
 		printk (KERN_ERR "ide-tape: Can't get tape parameters page - probably no tape inserted in onstream drive\n");
@@ -5833,7 +5806,7 @@ static void idetape_onstream_mode_sense_tape_parameter_page(struct ata_device *d
 static void idetape_get_mode_sense_results(struct ata_device *drive)
 {
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_mode_parameter_header_t *header;
 	idetape_capabilities_page_t *capabilities;
 
@@ -5908,7 +5881,7 @@ static void idetape_get_blocksize_from_block_descriptor(struct ata_device *drive
 {
 
 	idetape_tape_t *tape = drive->driver_data;
-	idetape_pc_t pc;
+	struct atapi_packet_command pc;
 	idetape_mode_parameter_header_t *header;
 	idetape_parameter_block_descriptor_t *block_descrp;
 
@@ -5943,7 +5916,8 @@ static void idetape_get_blocksize_from_block_descriptor(struct ata_device *drive
  */
 static void idetape_setup(struct ata_device *drive, idetape_tape_t *tape, int minor)
 {
-	unsigned long t1, tmid, tn, t;
+	unsigned long t1, tmid, tn;
+	unsigned long t;
 	int speed;
 	struct idetape_id_gcw gcw;
 	int stage_size;
@@ -6035,7 +6009,8 @@ static void idetape_setup(struct ata_device *drive, idetape_tape_t *tape, int mi
 	 *	Ensure that the number we got makes sense; limit
 	 *	it within IDETAPE_DSC_RW_MIN and IDETAPE_DSC_RW_MAX.
 	 */
-	tape->best_dsc_rw_frequency = max(min(t, IDETAPE_DSC_RW_MAX), IDETAPE_DSC_RW_MIN);
+	tape->best_dsc_rw_frequency = max(min(t, (unsigned long) IDETAPE_DSC_RW_MAX),
+			(unsigned long) IDETAPE_DSC_RW_MIN);
 	printk (KERN_INFO "ide-tape: %s <-> %s: %dKBps, %d*%dkB buffer, %dkB pipeline, %lums tDSC%s\n",
 		drive->name, tape->name, tape->capabilities.speed, (tape->capabilities.buffer_size * 512) / tape->stage_size,
 		tape->stage_size / 1024, tape->max_stages * tape->stage_size / 1024,
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 8eebd967c347..a970d421091b 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -42,6 +42,7 @@
 #include <linux/hdreg.h>
 #include <linux/slab.h>
 #include <linux/ide.h>
+#include <linux/atapi.h>
 
 #include <asm/io.h>
 #include <asm/bitops.h>
@@ -54,21 +55,6 @@
 
 #define IDESCSI_DEBUG_LOG		0
 
-typedef struct idescsi_pc_s {
-	u8 c[12];				/* Actual packet bytes */
-	int request_transfer;			/* Bytes to transfer */
-	int actually_transferred;		/* Bytes actually transferred */
-	int buffer_size;			/* Size of our data buffer */
-	byte *buffer;				/* Data buffer */
-	byte *current_position;			/* Pointer into the above buffer */
-	struct scatterlist *sg;			/* Scatter gather table */
-	int b_count;				/* Bytes transferred from current entry */
-	Scsi_Cmnd *scsi_cmd;			/* SCSI command */
-	void (*done)(Scsi_Cmnd *);		/* Scsi completion routine */
-	unsigned long flags;			/* Status/Action flags */
-	unsigned long timeout;			/* Command timeout */
-} idescsi_pc_t;
-
 /*
  *	Packet command status bits.
  */
@@ -88,8 +74,8 @@ typedef struct idescsi_pc_s {
 #define IDESCSI_LOG_CMD			0	/* Log SCSI commands */
 
 typedef struct {
-	ide_drive_t *drive;
-	idescsi_pc_t *pc;			/* Current packet command */
+	struct ata_device *drive;
+	struct atapi_packet_command *pc;	/* Current packet command */
 	unsigned long flags;			/* Status/Action flags */
 	unsigned long transform;		/* SCSI cmd translation layer */
 	unsigned long log;			/* log flags */
@@ -111,61 +97,49 @@ typedef struct {
 #define IDESCSI_IREASON_COD	0x1		/* Information transferred is command */
 #define IDESCSI_IREASON_IO	0x2		/* The device requests us to read */
 
-static void idescsi_discard_data (ide_drive_t *drive, unsigned int bcount)
-{
-	while (bcount--)
-		IN_BYTE (IDE_DATA_REG);
-}
-
-static void idescsi_output_zeros (ide_drive_t *drive, unsigned int bcount)
-{
-	while (bcount--)
-		OUT_BYTE (0, IDE_DATA_REG);
-}
-
 /*
  *	PIO data transfer routines using the scatter gather table.
  */
-static void idescsi_input_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigned int bcount)
+static void idescsi_input_buffers(struct ata_device *drive, struct atapi_packet_command *pc, unsigned int bcount)
 {
 	int count;
 	char *buf;
 
 	while (bcount) {
-		if (pc->sg - (struct scatterlist *) pc->scsi_cmd->request_buffer > pc->scsi_cmd->use_sg) {
+		if (pc->s.sg - (struct scatterlist *) pc->s.scsi_cmd->request_buffer > pc->s.scsi_cmd->use_sg) {
 			printk (KERN_ERR "ide-scsi: scatter gather table too small, discarding data\n");
-			idescsi_discard_data (drive, bcount);
+			atapi_discard_data(drive, bcount);
 			return;
 		}
-		count = min(pc->sg->length - pc->b_count, bcount);
-		buf = page_address(pc->sg->page) + pc->sg->offset;
-		atapi_read(drive, buf + pc->b_count, count);
-		bcount -= count; pc->b_count += count;
-		if (pc->b_count == pc->sg->length) {
-			pc->sg++;
-			pc->b_count = 0;
+		count = min(pc->s.sg->length - pc->s.b_count, bcount);
+		buf = page_address(pc->s.sg->page) + pc->s.sg->offset;
+		atapi_read(drive, buf + pc->s.b_count, count);
+		bcount -= count; pc->s.b_count += count;
+		if (pc->s.b_count == pc->s.sg->length) {
+			pc->s.sg++;
+			pc->s.b_count = 0;
 		}
 	}
 }
 
-static void idescsi_output_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsigned int bcount)
+static void idescsi_output_buffers(struct ata_device *drive, struct atapi_packet_command *pc, unsigned int bcount)
 {
 	int count;
 	char *buf;
 
 	while (bcount) {
-		if (pc->sg - (struct scatterlist *) pc->scsi_cmd->request_buffer > pc->scsi_cmd->use_sg) {
+		if (pc->s.sg - (struct scatterlist *) pc->s.scsi_cmd->request_buffer > pc->s.scsi_cmd->use_sg) {
 			printk (KERN_ERR "ide-scsi: scatter gather table too small, padding with zeros\n");
-			idescsi_output_zeros (drive, bcount);
+			atapi_write_zeros(drive, bcount);
 			return;
 		}
-		count = min(pc->sg->length - pc->b_count, bcount);
-		buf = page_address(pc->sg->page) + pc->sg->offset;
-		atapi_write(drive, buf + pc->b_count, count);
-		bcount -= count; pc->b_count += count;
-		if (pc->b_count == pc->sg->length) {
-			pc->sg++;
-			pc->b_count = 0;
+		count = min(pc->s.sg->length - pc->s.b_count, bcount);
+		buf = page_address(pc->s.sg->page) + pc->s.sg->offset;
+		atapi_write(drive, buf + pc->s.b_count, count);
+		bcount -= count; pc->s.b_count += count;
+		if (pc->s.b_count == pc->s.sg->length) {
+			pc->s.sg++;
+			pc->s.b_count = 0;
 		}
 	}
 }
@@ -174,9 +148,11 @@ static void idescsi_output_buffers (ide_drive_t *drive, idescsi_pc_t *pc, unsign
  *	Most of the SCSI commands are supported directly by ATAPI devices.
  *	idescsi_transform_pc handles the few exceptions.
  */
-static inline void idescsi_transform_pc1 (ide_drive_t *drive, idescsi_pc_t *pc)
+static inline void idescsi_transform_pc1(struct ata_device *drive, struct atapi_packet_command *pc)
 {
-	u8 *c = pc->c, *scsi_buf = pc->buffer, *sc = pc->scsi_cmd->cmnd;
+	u8 *c = pc->c;
+	char *scsi_buf = pc->buffer;
+	u8 *sc = pc->s.scsi_cmd->cmnd;
 	char *atapi_buf;
 
 	if (!test_bit(PC_TRANSFORM, &pc->flags))
@@ -212,11 +188,11 @@ static inline void idescsi_transform_pc1 (ide_drive_t *drive, idescsi_pc_t *pc)
 	}
 }
 
-static inline void idescsi_transform_pc2 (ide_drive_t *drive, idescsi_pc_t *pc)
+static inline void idescsi_transform_pc2(struct ata_device *drive, struct atapi_packet_command *pc)
 {
 	u8 *atapi_buf = pc->buffer;
-	u8 *sc = pc->scsi_cmd->cmnd;
-	u8 *scsi_buf = pc->scsi_cmd->request_buffer;
+	u8 *sc = pc->s.scsi_cmd->cmnd;
+	u8 *scsi_buf = pc->s.scsi_cmd->request_buffer;
 
 	if (!test_bit(PC_TRANSFORM, &pc->flags))
 		return;
@@ -261,7 +237,7 @@ static void hexdump(u8 *x, int len)
 static int idescsi_end_request(struct ata_device *drive, struct request *rq, int uptodate)
 {
 	idescsi_scsi_t *scsi = drive->driver_data;
-	idescsi_pc_t *pc = (idescsi_pc_t *) rq->special;
+	struct atapi_packet_command *pc = (struct atapi_packet_command *) rq->special;
 	int log = test_bit(IDESCSI_LOG_CMD, &scsi->log);
 	struct Scsi_Host *host;
 	u8 *scsi_buf;
@@ -273,28 +249,28 @@ static int idescsi_end_request(struct ata_device *drive, struct request *rq, int
 	}
 	ide_end_drive_cmd(drive, rq, 0, 0);
 	if (rq->errors >= ERROR_MAX) {
-		pc->scsi_cmd->result = DID_ERROR << 16;
+		pc->s.scsi_cmd->result = DID_ERROR << 16;
 		if (log)
-			printk ("ide-scsi: %s: I/O error for %lu\n", drive->name, pc->scsi_cmd->serial_number);
+			printk ("ide-scsi: %s: I/O error for %lu\n", drive->name, pc->s.scsi_cmd->serial_number);
 	} else if (rq->errors) {
-		pc->scsi_cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
+		pc->s.scsi_cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
 		if (log)
-			printk ("ide-scsi: %s: check condition for %lu\n", drive->name, pc->scsi_cmd->serial_number);
+			printk ("ide-scsi: %s: check condition for %lu\n", drive->name, pc->s.scsi_cmd->serial_number);
 	} else {
-		pc->scsi_cmd->result = DID_OK << 16;
+		pc->s.scsi_cmd->result = DID_OK << 16;
 		idescsi_transform_pc2 (drive, pc);
 		if (log) {
-			printk ("ide-scsi: %s: suc %lu", drive->name, pc->scsi_cmd->serial_number);
+			printk ("ide-scsi: %s: suc %lu", drive->name, pc->s.scsi_cmd->serial_number);
 			if (!test_bit(PC_WRITING, &pc->flags) && pc->actually_transferred && pc->actually_transferred <= 1024 && pc->buffer) {
 				printk(", rst = ");
-				scsi_buf = pc->scsi_cmd->request_buffer;
-				hexdump(scsi_buf, min(16U, pc->scsi_cmd->request_bufflen));
+				scsi_buf = pc->s.scsi_cmd->request_buffer;
+				hexdump(scsi_buf, min(16U, pc->s.scsi_cmd->request_bufflen));
 			} else printk("\n");
 		}
 	}
-	host = pc->scsi_cmd->host;
+	host = pc->s.scsi_cmd->host;
 	spin_lock_irqsave(host->host_lock, flags);
-	pc->done(pc->scsi_cmd);
+	pc->s.done(pc->s.scsi_cmd);
 	spin_unlock_irqrestore(host->host_lock, flags);
 	idescsi_free_bio (rq->bio);
 	kfree(pc); kfree(rq);
@@ -303,9 +279,9 @@ static int idescsi_end_request(struct ata_device *drive, struct request *rq, int
 	return 0;
 }
 
-static inline unsigned long get_timeout(idescsi_pc_t *pc)
+static inline unsigned long get_timeout(struct atapi_packet_command *pc)
 {
-	return max((unsigned long) WAIT_CMD, pc->timeout - jiffies);
+	return max((unsigned long) WAIT_CMD, pc->s.timeout - jiffies);
 }
 
 /*
@@ -316,17 +292,17 @@ static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request
 	idescsi_scsi_t *scsi = drive->driver_data;
 	byte status, ireason;
 	int bcount;
-	idescsi_pc_t *pc=scsi->pc;
+	struct atapi_packet_command *pc = scsi->pc;
 	unsigned int temp;
 
 #if IDESCSI_DEBUG_LOG
 	printk (KERN_INFO "ide-scsi: Reached idescsi_pc_intr interrupt handler\n");
-#endif /* IDESCSI_DEBUG_LOG */
+#endif
 
-	if (test_and_clear_bit (PC_DMA_IN_PROGRESS, &pc->flags)) {
+	if (test_and_clear_bit(PC_DMA_IN_PROGRESS, &pc->flags)) {
 #if IDESCSI_DEBUG_LOG
 		printk ("ide-scsi: %s: DMA complete\n", drive->name);
-#endif /* IDESCSI_DEBUG_LOG */
+#endif
 		pc->actually_transferred=pc->request_transfer;
 		udma_stop(drive);
 	}
@@ -357,7 +333,7 @@ static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request
 				temp = pc->buffer_size - pc->actually_transferred;
 				if (temp) {
 					clear_bit(PC_WRITING, &pc->flags);
-					if (pc->sg)
+					if (pc->s.sg)
 						idescsi_input_buffers(drive, pc, temp);
 					else
 						atapi_read(drive, pc->current_position, temp);
@@ -365,24 +341,24 @@ static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request
 				}
 				pc->actually_transferred += temp;
 				pc->current_position += temp;
-				idescsi_discard_data (drive,bcount - temp);
+				atapi_discard_data(drive,bcount - temp);
 				ide_set_handler(drive, idescsi_pc_intr, get_timeout(pc), NULL);
 				return ide_started;
 			}
 #if IDESCSI_DEBUG_LOG
 			printk (KERN_NOTICE "ide-scsi: The scsi wants to send us more data than expected - allowing transfer\n");
-#endif /* IDESCSI_DEBUG_LOG */
+#endif
 		}
 	}
 	if (ireason & IDESCSI_IREASON_IO) {
 		clear_bit(PC_WRITING, &pc->flags);
-		if (pc->sg)
+		if (pc->s.sg)
 			idescsi_input_buffers (drive, pc, bcount);
 		else
 			atapi_read(drive,pc->current_position,bcount);
 	} else {
 		set_bit(PC_WRITING, &pc->flags);
-		if (pc->sg)
+		if (pc->s.sg)
 			idescsi_output_buffers (drive, pc, bcount);
 		else
 			atapi_write(drive,pc->current_position,bcount);
@@ -397,7 +373,7 @@ static ide_startstop_t idescsi_pc_intr(struct ata_device *drive, struct request
 static ide_startstop_t idescsi_transfer_pc(struct ata_device *drive, struct request *rq)
 {
 	idescsi_scsi_t *scsi = drive->driver_data;
-	idescsi_pc_t *pc = scsi->pc;
+	struct atapi_packet_command *pc = scsi->pc;
 	byte ireason;
 	ide_startstop_t startstop;
 
@@ -418,7 +394,8 @@ static ide_startstop_t idescsi_transfer_pc(struct ata_device *drive, struct requ
 /*
  *	Issue a packet command
  */
-static ide_startstop_t idescsi_issue_pc(struct ata_device *drive, struct request *rq, idescsi_pc_t *pc)
+static ide_startstop_t idescsi_issue_pc(struct ata_device *drive, struct request *rq,
+		struct atapi_packet_command *pc)
 {
 	idescsi_scsi_t *scsi = drive->driver_data;
 	int bcount;
@@ -465,10 +442,10 @@ static ide_startstop_t idescsi_do_request(struct ata_device *drive, struct reque
 #if IDESCSI_DEBUG_LOG
 	printk (KERN_INFO "rq_status: %d, rq_dev: %u, cmd: %d, errors: %d\n",rq->rq_status,(unsigned int) rq->rq_dev,rq->cmd,rq->errors);
 	printk (KERN_INFO "sector: %ld, nr_sectors: %ld, current_nr_sectors: %ld\n",rq->sector,rq->nr_sectors,rq->current_nr_sectors);
-#endif /* IDESCSI_DEBUG_LOG */
+#endif
 
 	if (rq->flags & REQ_SPECIAL) {
-		return idescsi_issue_pc(drive, rq, (idescsi_pc_t *) rq->special);
+		return idescsi_issue_pc(drive, rq, (struct atapi_packet_command *) rq->special);
 	}
 	blk_dump_rq_flags(rq, "ide-scsi: unsup command");
 	idescsi_end_request(drive, rq, 0);
@@ -486,16 +463,14 @@ static void idescsi_ide_release(struct inode *inode, struct file *filp, struct a
 	MOD_DEC_USE_COUNT;
 }
 
-static ide_drive_t *idescsi_drives[MAX_HWIFS * MAX_DRIVES];
+static struct ata_device *idescsi_drives[MAX_HWIFS * MAX_DRIVES];
 static int idescsi_initialized = 0;
 
 /*
  *	Driver initialization.
  */
-static void idescsi_setup (ide_drive_t *drive, idescsi_scsi_t *scsi, int id)
+static void idescsi_setup(struct ata_device *drive, idescsi_scsi_t *scsi, int id)
 {
-	MOD_INC_USE_COUNT;
-
 	idescsi_drives[id] = drive;
 	drive->driver_data = scsi;
 	drive->ready_stat = 0;
@@ -510,7 +485,7 @@ static void idescsi_setup (ide_drive_t *drive, idescsi_scsi_t *scsi, int id)
 #endif
 }
 
-static int idescsi_cleanup (ide_drive_t *drive)
+static int idescsi_cleanup(struct ata_device *drive)
 {
 	idescsi_scsi_t *scsi = drive->driver_data;
 
@@ -521,7 +496,7 @@ static int idescsi_cleanup (ide_drive_t *drive)
 	return 0;
 }
 
-static void idescsi_revalidate(ide_drive_t *_dummy)
+static void idescsi_revalidate(struct ata_device *_dummy)
 {
 	/* The partition information will be handled by the SCSI layer.
 	 */
@@ -549,7 +524,7 @@ static struct ata_operations idescsi_driver = {
  */
 int idescsi_init(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	idescsi_scsi_t *scsi;
 	/* FIXME: The following is just plain wrong, since those are definitely *not* the
 	 * media types supported by the ATA layer */
@@ -606,7 +581,7 @@ int idescsi_detect (Scsi_Host_Template *host_template)
 
 int idescsi_release (struct Scsi_Host *host)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	int id;
 
 	for (id = 0; id < MAX_HWIFS * MAX_DRIVES; id++) {
@@ -625,7 +600,7 @@ const char *idescsi_info (struct Scsi_Host *host)
 
 int idescsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
 {
-	ide_drive_t *drive = idescsi_drives[dev->id];
+	struct ata_device *drive = idescsi_drives[dev->id];
 	idescsi_scsi_t *scsi = drive->driver_data;
 
 	if (cmd == SG_SET_TRANSFORM) {
@@ -662,25 +637,29 @@ abort:
 	return NULL;
 }
 
-static inline int idescsi_set_direction (idescsi_pc_t *pc)
+static inline int idescsi_set_direction(struct atapi_packet_command *pc)
 {
 	switch (pc->c[0]) {
-		case READ_6: case READ_10: case READ_12:
-			clear_bit (PC_WRITING, &pc->flags);
+		case READ_6:
+		case READ_10:
+		case READ_12:
+			clear_bit(PC_WRITING, &pc->flags);
 			return 0;
-		case WRITE_6: case WRITE_10: case WRITE_12:
-			set_bit (PC_WRITING, &pc->flags);
+		case WRITE_6:
+		case WRITE_10:
+		case WRITE_12:
+			set_bit(PC_WRITING, &pc->flags);
 			return 0;
 		default:
 			return 1;
 	}
 }
 
-static inline struct bio *idescsi_dma_bio(ide_drive_t *drive, idescsi_pc_t *pc)
+static inline struct bio *idescsi_dma_bio(struct ata_device *drive, struct atapi_packet_command *pc)
 {
 	struct bio *bh = NULL, *first_bh = NULL;
-	int segments = pc->scsi_cmd->use_sg;
-	struct scatterlist *sg = pc->scsi_cmd->request_buffer;
+	int segments = pc->s.scsi_cmd->use_sg;
+	struct scatterlist *sg = pc->s.scsi_cmd->request_buffer;
 
 	if (!drive->using_dma || !pc->request_transfer || pc->request_transfer % 1024)
 		return NULL;
@@ -691,7 +670,7 @@ static inline struct bio *idescsi_dma_bio(ide_drive_t *drive, idescsi_pc_t *pc)
 			return NULL;
 #if IDESCSI_DEBUG_LOG
 		printk ("ide-scsi: %s: building DMA table, %d segments, %dkB total\n", drive->name, segments, pc->request_transfer >> 10);
-#endif /* IDESCSI_DEBUG_LOG */
+#endif
 		while (segments--) {
 			bh->bi_io_vec[0].bv_page = sg->page;
 			bh->bi_io_vec[0].bv_len = sg->length;
@@ -705,16 +684,16 @@ static inline struct bio *idescsi_dma_bio(ide_drive_t *drive, idescsi_pc_t *pc)
 			return NULL;
 #if IDESCSI_DEBUG_LOG
 		printk ("ide-scsi: %s: building DMA table for a single buffer (%dkB)\n", drive->name, pc->request_transfer >> 10);
-#endif /* IDESCSI_DEBUG_LOG */
-		bh->bi_io_vec[0].bv_page = virt_to_page(pc->scsi_cmd->request_buffer);
+#endif
+		bh->bi_io_vec[0].bv_page = virt_to_page(pc->s.scsi_cmd->request_buffer);
 		bh->bi_io_vec[0].bv_len = pc->request_transfer;
-		bh->bi_io_vec[0].bv_offset = (unsigned long) pc->scsi_cmd->request_buffer & ~PAGE_MASK;
+		bh->bi_io_vec[0].bv_offset = (unsigned long) pc->s.scsi_cmd->request_buffer & ~PAGE_MASK;
 		bh->bi_size = pc->request_transfer;
 	}
 	return first_bh;
 }
 
-static inline int should_transform(ide_drive_t *drive, Scsi_Cmnd *cmd)
+static inline int should_transform(struct ata_device *drive, Scsi_Cmnd *cmd)
 {
 	idescsi_scsi_t *scsi = drive->driver_data;
 
@@ -725,18 +704,18 @@ static inline int should_transform(ide_drive_t *drive, Scsi_Cmnd *cmd)
 
 int idescsi_queue (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
 {
-	ide_drive_t *drive = idescsi_drives[cmd->target];
+	struct ata_device *drive = idescsi_drives[cmd->target];
 	idescsi_scsi_t *scsi;
 	struct request *rq = NULL;
-	idescsi_pc_t *pc = NULL;
+	struct atapi_packet_command *pc = NULL;
 
 	if (!drive) {
 		printk (KERN_ERR "ide-scsi: drive id %d not present\n", cmd->target);
 		goto abort;
 	}
 	scsi = drive->driver_data;
-	pc = kmalloc (sizeof (idescsi_pc_t), GFP_ATOMIC);
-	rq = kmalloc (sizeof (struct request), GFP_ATOMIC);
+	pc = kmalloc(sizeof(*pc), GFP_ATOMIC);
+	rq = kmalloc(sizeof(*rq), GFP_ATOMIC);
 	if (rq == NULL || pc == NULL) {
 		printk (KERN_ERR "ide-scsi: %s: out of memory\n", drive->name);
 		goto abort;
@@ -747,16 +726,16 @@ int idescsi_queue (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
 	memcpy (pc->c, cmd->cmnd, cmd->cmd_len);
 	if (cmd->use_sg) {
 		pc->buffer = NULL;
-		pc->sg = cmd->request_buffer;
+		pc->s.sg = cmd->request_buffer;
 	} else {
 		pc->buffer = cmd->request_buffer;
-		pc->sg = NULL;
+		pc->s.sg = NULL;
 	}
-	pc->b_count = 0;
+	pc->s.b_count = 0;
 	pc->request_transfer = pc->buffer_size = cmd->request_bufflen;
-	pc->scsi_cmd = cmd;
-	pc->done = done;
-	pc->timeout = jiffies + cmd->timeout_per_command;
+	pc->s.scsi_cmd = cmd;
+	pc->s.done = done;
+	pc->s.timeout = jiffies + cmd->timeout_per_command;
 
 	if (should_transform(drive, cmd))
 		set_bit(PC_TRANSFORM, &pc->flags);
@@ -797,7 +776,7 @@ int idescsi_device_reset (Scsi_Cmnd *cmd)
 
 int idescsi_bios (Disk *disk, kdev_t dev, int *parm)
 {
-	ide_drive_t *drive = idescsi_drives[disk->device->id];
+	struct ata_device *drive = idescsi_drives[disk->device->id];
 
 	if (drive->bios_cyl && drive->bios_head && drive->bios_sect) {
 		parm[0] = drive->bios_head;
@@ -835,7 +814,7 @@ static int __init init_idescsi_module(void)
 
 static void __exit exit_idescsi_module(void)
 {
-	ide_drive_t *drive;
+	struct ata_device *drive;
 	byte media[] = {TYPE_DISK, TYPE_TAPE, TYPE_PROCESSOR, TYPE_WORM, TYPE_ROM, TYPE_SCANNER, TYPE_MOD, 255};
 	int i, failed;
 
diff --git a/include/linux/atapi.h b/include/linux/atapi.h
new file mode 100644
index 000000000000..6a6e2e36a6ff
--- /dev/null
+++ b/include/linux/atapi.h
@@ -0,0 +1,65 @@
+/**** vi:set ts=8 sts=8 sw=8:************************************************
+ *
+ * Copyright (C) 2002 Marcin Dalecki <martin@dalecki.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+/*
+ * With each packet command, we allocate a buffer.
+ * This is used for several packet
+ * commands (Not for READ/WRITE commands).
+ */
+#define IDEFLOPPY_PC_BUFFER_SIZE	256
+#define IDETAPE_PC_BUFFER_SIZE		256
+
+/* This struct get's shared between different drivers.
+ */
+struct atapi_packet_command {
+	u8 c[12];			/* Actual packet bytes */
+	char *buffer;			/* Data buffer */
+	int buffer_size;		/* Size of our data buffer */
+	char *current_position;		/* Pointer into the above buffer */
+	int request_transfer;		/* Bytes to transfer */
+	int actually_transferred;	/* Bytes actually transferred */
+
+	unsigned long flags;		/* Status/Action bit flags: long for set_bit */
+
+	/* FIXME: the following is ugly as hell, but the only way we can start
+	 * actually to unify the code.
+	 */
+	/* driver specific data. */
+	/* floppy/tape */
+	int retries;				/* On each retry, we increment retries */
+	int error;				/* Error code */
+	char *b_data;				/* Pointer which runs on the buffers */
+	unsigned int b_count;			/* Missing/Available data on the current buffer */
+	u8 pc_buffer[IDEFLOPPY_PC_BUFFER_SIZE];	/* Temporary buffer */
+	/* Called when this packet command is completed */
+	void (*callback) (struct ata_device *, struct request *);
+
+	/* only tape */
+	struct bio *bio;
+
+	/* only scsi */
+	struct {
+		unsigned int b_count;			/* Bytes transferred from current entry */
+		struct scatterlist *sg;			/* Scatter gather table */
+		struct scsi_cmnd *scsi_cmd;		/* SCSI command */
+		void (*done)(struct scsi_cmnd *);	/* Scsi completion routine */
+		unsigned long timeout;			/* Command timeout */
+	} s;
+};
+
+
+extern void atapi_discard_data(struct ata_device *drive, unsigned int bcount);
+extern void atapi_write_zeros(struct ata_device *drive, unsigned int bcount);
+
+extern void atapi_init_pc(struct atapi_packet_command *pc);
-- 
cgit v1.2.3


From 80d461c8a0c818d4918a8917ebc6233a3ed63560 Mon Sep 17 00:00:00 2001
From: Martin Dalecki <dalecki@evision-ventures.com>
Date: Tue, 21 May 2002 21:41:48 -0700
Subject: [PATCH] 2.5.17 IDE 69

 - Apply small host chip driver cosmetics by Andrej xxx Panin
   and Vojtech Pavlik.

 - Remove support for "disc recovery time". It could only supposedly
   help with really simplistic broken devices from the past,
   which didn't have moderately sophisticated controllers.
   And finally Vojtech voted for it as well... so I just trust him.

 - Apply icside host chip driver and other ARM related updates by Russell King,
   which finally settle the "portability" work a bit, well hopefully.
---
 drivers/ide/aec62xx.c     |   4 +-
 drivers/ide/ali14xx.c     |   4 +-
 drivers/ide/alim15x3.c    |   8 +-
 drivers/ide/amd74xx.c     |  45 +---
 drivers/ide/cmd640.c      |   2 +-
 drivers/ide/cmd64x.c      |   2 +-
 drivers/ide/cy82c693.c    |   2 +-
 drivers/ide/ht6560b.c     |   4 +-
 drivers/ide/icside.c      | 595 +++++++++++++++++++++++++++++-----------------
 drivers/ide/ide.c         | 178 +++++++-------
 drivers/ide/opti621.c     |   2 +-
 drivers/ide/pcidma.c      |  24 +-
 drivers/ide/pdc202xx.c    |   6 +-
 drivers/ide/piix.c        |  43 +---
 drivers/ide/qd65xx.c      |  14 +-
 drivers/ide/serverworks.c |   8 +-
 drivers/ide/sl82c105.c    | 178 +++++++++++---
 drivers/ide/via82cxxx.c   |  55 ++---
 include/linux/ide.h       |  19 +-
 19 files changed, 704 insertions(+), 489 deletions(-)

(limited to 'include/linux')

diff --git a/drivers/ide/aec62xx.c b/drivers/ide/aec62xx.c
index 053200483109..8e5186a5e88d 100644
--- a/drivers/ide/aec62xx.c
+++ b/drivers/ide/aec62xx.c
@@ -259,7 +259,7 @@ static byte pci_bus_clock_list (byte speed, struct chipset_bus_clock_list_entry
 {
 	for ( ; chipset_table->xfer_speed ; chipset_table++)
 		if (chipset_table->xfer_speed == speed) {
-			return ((byte) ((system_bus_speed <= 33) ? chipset_table->chipset_settings_33 : chipset_table->chipset_settings_34));
+			return ((byte) ((system_bus_speed <= 33333) ? chipset_table->chipset_settings_33 : chipset_table->chipset_settings_34));
 		}
 	return 0x00;
 }
@@ -268,7 +268,7 @@ static byte pci_bus_clock_list_ultra (byte speed, struct chipset_bus_clock_list_
 {
 	for ( ; chipset_table->xfer_speed ; chipset_table++)
 		if (chipset_table->xfer_speed == speed) {
-			return ((byte) ((system_bus_speed <= 33) ? chipset_table->ultra_settings_33 : chipset_table->ultra_settings_34));
+			return ((byte) ((system_bus_speed <= 33333) ? chipset_table->ultra_settings_33 : chipset_table->ultra_settings_34));
 		}
 	return 0x00;
 }
diff --git a/drivers/ide/ali14xx.c b/drivers/ide/ali14xx.c
index 49b1e42f037a..b172019c4fb8 100644
--- a/drivers/ide/ali14xx.c
+++ b/drivers/ide/ali14xx.c
@@ -124,8 +124,8 @@ static void ali14xx_tune_drive(struct ata_device *drive, u8 pio)
 	/* calculate timing, according to PIO mode */
 	time1 = t->cycle;
 	time2 = t->active;
-	param3 = param1 = (time2 * system_bus_speed + 999) / 1000;
-	param4 = param2 = (time1 * system_bus_speed + 999) / 1000 - param1;
+	param3 = param1 = (time2 * system_bus_speed + 999999) / 1000000;
+	param4 = param2 = (time1 * system_bus_speed + 999999) / 1000000 - param1;
 	if (pio < XFER_PIO_3) {
 		param3 += 8;
 		param4 += 8;
diff --git a/drivers/ide/alim15x3.c b/drivers/ide/alim15x3.c
index 87e5a8a18dd7..25acceb63fed 100644
--- a/drivers/ide/alim15x3.c
+++ b/drivers/ide/alim15x3.c
@@ -261,18 +261,18 @@ static void ali15x3_tune_drive(struct ata_device *drive, byte pio)
 
 	s_time = t->setup;
 	a_time = t->active;
-	if ((s_clc = (s_time * system_bus_speed + 999) / 1000) >= 8)
+	if ((s_clc = (s_time * system_bus_speed + 999999) / 1000000) >= 8)
 		s_clc = 0;
-	if ((a_clc = (a_time * system_bus_speed + 999) / 1000) >= 8)
+	if ((a_clc = (a_time * system_bus_speed + 999999) / 1000000) >= 8)
 		a_clc = 0;
 	c_time = t->cycle;
 
 #if 0
-	if ((r_clc = ((c_time - s_time - a_time) * system_bus_speed + 999) / 1000) >= 16)
+	if ((r_clc = ((c_time - s_time - a_time) * system_bus_speed + 999999) / 1000000) >= 16)
 		r_clc = 0;
 #endif
 
-	if (!(r_clc = (c_time * system_bus_speed + 999) / 1000 - a_clc - s_clc)) {
+	if (!(r_clc = (c_time * system_bus_speed + 999999) / 1000000 - a_clc - s_clc)) {
 		r_clc = 1;
 	} else {
 		if (r_clc >= 16)
diff --git a/drivers/ide/amd74xx.c b/drivers/ide/amd74xx.c
index fe91d5d8f123..f9d277bbfd39 100644
--- a/drivers/ide/amd74xx.c
+++ b/drivers/ide/amd74xx.c
@@ -87,7 +87,6 @@ static struct amd_ide_chip {
 static struct amd_ide_chip *amd_config;
 static unsigned char amd_enabled;
 static unsigned int amd_80w;
-static unsigned int amd_clock;
 
 static unsigned char amd_cyc2udma[] = { 6, 6, 5, 4, 0, 1, 1, 2, 2, 3, 3 };
 static unsigned char amd_udma2cyc[] = { 4, 6, 8, 10, 3, 2, 1, 1 };
@@ -131,7 +130,7 @@ static int amd_get_info(char *buffer, char **addr, off_t offset, int count)
 	amd_print("Highest DMA rate:                   %s", amd_dma[amd_config->flags & AMD_UDMA]);
 
 	amd_print("BM-DMA base:                        %#x", amd_base);
-	amd_print("PCI clock:                          %d.%dMHz", amd_clock / 1000, amd_clock / 100 % 10);
+	amd_print("PCI clock:                          %d.%dMHz", system_bus_speed / 1000, system_bus_speed / 100 % 10);
 	
 	amd_print("-----------------------Primary IDE-------Secondary IDE------");
 
@@ -147,7 +146,7 @@ static int amd_get_info(char *buffer, char **addr, off_t offset, int count)
 
 	amd_print("Cable Type:            %10s%20s", (amd_80w & 1) ? "80w" : "40w", (amd_80w & 2) ? "80w" : "40w");
 
-	if (!amd_clock)
+	if (!system_bus_speed)
                 return p - buffer;
 
 	amd_print("-------------------drive0----drive1----drive2----drive3-----");
@@ -169,22 +168,22 @@ static int amd_get_info(char *buffer, char **addr, off_t offset, int count)
 		den[i]  = (c & ((i & 1) ? 0x40 : 0x20) << ((i & 2) << 2));
 
 		if (den[i] && uen[i] && udma[i] == 1) {
-			speed[i] = amd_clock * 3;
-			cycle[i] = 666666 / amd_clock;
+			speed[i] = system_bus_speed * 3;
+			cycle[i] = 666666 / system_bus_speed;
 			continue;
 		}
 
-		speed[i] = 4 * amd_clock / ((den[i] && uen[i]) ? udma[i] : (active[i] + recover[i]) * 2);
-		cycle[i] = 1000000 * ((den[i] && uen[i]) ? udma[i] : (active[i] + recover[i]) * 2) / amd_clock / 2;
+		speed[i] = 4 * system_bus_speed / ((den[i] && uen[i]) ? udma[i] : (active[i] + recover[i]) * 2);
+		cycle[i] = 1000000 * ((den[i] && uen[i]) ? udma[i] : (active[i] + recover[i]) * 2) / system_bus_speed / 2;
 	}
 
 	amd_print_drive("Transfer Mode: ", "%10s", den[i] ? (uen[i] ? "UDMA" : "DMA") : "PIO");
 
-	amd_print_drive("Address Setup: ", "%8dns", 1000000 * setup[i] / amd_clock);
-	amd_print_drive("Cmd Active:    ", "%8dns", 1000000 * active8b[i] / amd_clock);
-	amd_print_drive("Cmd Recovery:  ", "%8dns", 1000000 * recover8b[i] / amd_clock);
-	amd_print_drive("Data Active:   ", "%8dns", 1000000 * active[i] / amd_clock);
-	amd_print_drive("Data Recovery: ", "%8dns", 1000000 * recover[i] / amd_clock);
+	amd_print_drive("Address Setup: ", "%8dns", 1000000 * setup[i] / system_bus_speed);
+	amd_print_drive("Cmd Active:    ", "%8dns", 1000000 * active8b[i] / system_bus_speed);
+	amd_print_drive("Cmd Recovery:  ", "%8dns", 1000000 * recover8b[i] / system_bus_speed);
+	amd_print_drive("Data Active:   ", "%8dns", 1000000 * active[i] / system_bus_speed);
+	amd_print_drive("Data Recovery: ", "%8dns", 1000000 * recover[i] / system_bus_speed);
 	amd_print_drive("Cycle Time:    ", "%8dns", cycle[i]);
 	amd_print_drive("Transfer Rate: ", "%4d.%dMB/s", speed[i] / 1000, speed[i] / 100 % 10);
 
@@ -238,7 +237,7 @@ static int amd_set_drive(ide_drive_t *drive, unsigned char speed)
 			printk(KERN_WARNING "ide%d: Drive %d didn't accept speed setting. Oh, well.\n",
 				drive->dn >> 1, drive->dn & 1);
 
-	T = 1000000000 / amd_clock;
+	T = 1000000000 / system_bus_speed;
 	UT = T / min_t(int, max_t(int, amd_config->flags & AMD_UDMA, 1), 2);
 
 	ata_timing_compute(drive, speed, &t, T, UT);
@@ -248,7 +247,7 @@ static int amd_set_drive(ide_drive_t *drive, unsigned char speed)
 		ata_timing_merge(&p, &t, &t, IDE_TIMING_8BIT);
 	}
 
-	if (speed == XFER_UDMA_5 && amd_clock <= 33333) t.udma = 1;
+	if (speed == XFER_UDMA_5 && system_bus_speed <= 33333) t.udma = 1;
 
 	amd_set_speed(drive->channel->pci_dev, drive->dn, &t);
 
@@ -357,24 +356,6 @@ static unsigned int __init amd74xx_init_chipset(struct pci_dev *dev)
 	pci_write_config_byte(dev, AMD_IDE_CONFIG,
 		(amd_config->flags & AMD_BAD_FIFO) ? (t & 0x0f) : (t | 0xf0));
 
-/*
- * Determine the system bus clock.
- */
-
-	amd_clock = system_bus_speed * 1000;
-
-	switch (amd_clock) {
-		case 33000: amd_clock = 33333; break;
-		case 37000: amd_clock = 37500; break;
-		case 41000: amd_clock = 41666; break;
-	}
-
-	if (amd_clock < 20000 || amd_clock > 50000) {
-		printk(KERN_WARNING "AMD_IDE: User given PCI clock speed impossible (%d), using 33 MHz instead.\n", amd_clock);
-		printk(KERN_WARNING "AMD_IDE: Use ide0=ata66 if you want to assume 80-wire cable\n");
-		amd_clock = 33333;
-	}
-
 /*
  * Print the boot message.
  */
diff --git a/drivers/ide/cmd640.c b/drivers/ide/cmd640.c
index 36c7f9c0cf9a..0c5f45be113a 100644
--- a/drivers/ide/cmd640.c
+++ b/drivers/ide/cmd640.c
@@ -603,7 +603,7 @@ static void cmd640_set_mode (unsigned int index, u8 pio_mode, unsigned int cycle
 	u8 cycle_count;
 
 	recovery_time = cycle_time - (setup_time + active_time);
-	clock_time = 1000 / system_bus_speed;
+	clock_time = 1000000 / system_bus_speed;
 	cycle_count = (cycle_time + clock_time - 1) / clock_time;
 
 	setup_count = (setup_time + clock_time - 1) / clock_time;
diff --git a/drivers/ide/cmd64x.c b/drivers/ide/cmd64x.c
index ca1c8bae8cdd..87d8abfe6fa5 100644
--- a/drivers/ide/cmd64x.c
+++ b/drivers/ide/cmd64x.c
@@ -305,7 +305,7 @@ static void cmd64x_tuneproc(struct ata_device *drive, byte mode_wanted)
 	 */
 
 	recovery_time = t->cycle - (t->setup + t->active);
-	clock_time = 1000 / system_bus_speed;
+	clock_time = 1000000 / system_bus_speed;
 	cycle_count = (t->cycle + clock_time - 1) / clock_time;
 	setup_count = (t->setup + clock_time - 1) / clock_time;
 	active_count = (t->active + clock_time - 1) / clock_time;
diff --git a/drivers/ide/cy82c693.c b/drivers/ide/cy82c693.c
index 70de2d39ccbf..418c945fb0e5 100644
--- a/drivers/ide/cy82c693.c
+++ b/drivers/ide/cy82c693.c
@@ -121,7 +121,7 @@ static int calc_clk (int time, int bus_speed)
 {
 	int clocks;
 
-	clocks = (time*bus_speed+999)/1000 -1;
+	clocks = (time*bus_speed+999999)/1000000 -1;
 
 	if (clocks < 0)
 		clocks = 0;
diff --git a/drivers/ide/ht6560b.c b/drivers/ide/ht6560b.c
index c8ba269356bb..35246a8ab09c 100644
--- a/drivers/ide/ht6560b.c
+++ b/drivers/ide/ht6560b.c
@@ -219,8 +219,8 @@ static byte ht_pio2timings(ide_drive_t *drive, byte pio)
 		/*
 		 *  Cycle times should be Vesa bus cycles
 		 */
-		active_cycles   = (active_time   * system_bus_speed + 999) / 1000;
-		recovery_cycles = (recovery_time * system_bus_speed + 999) / 1000;
+		active_cycles   = (active_time   * system_bus_speed + 999999) / 1000000;
+		recovery_cycles = (recovery_time * system_bus_speed + 999999) / 1000000;
 		/*
 		 *  Upper and lower limits
 		 */
diff --git a/drivers/ide/icside.c b/drivers/ide/icside.c
index ade05781fe5b..f596ff5d1417 100644
--- a/drivers/ide/icside.c
+++ b/drivers/ide/icside.c
@@ -1,7 +1,7 @@
 /*
  * linux/drivers/ide/icside.c
  *
- * Copyright (c) 1996,1997 Russell King.
+ * Copyright (c) 1996-2002 Russell King.
  *
  * Changelog:
  *  08-Jun-1996	RMK	Created
@@ -25,6 +25,7 @@
 #include <asm/dma.h>
 #include <asm/ecard.h>
 #include <asm/io.h>
+#include <asm/page.h>
 
 extern char *ide_xfer_verbose (byte xfer_rate);
 
@@ -75,6 +76,12 @@ static struct cardinfo icside_cardinfo_v6_2 = {
 	ICS_ARCIN_V6_IDESTEPPING
 };
 
+struct icside_state {
+	unsigned int channel;
+	unsigned int enabled;
+	unsigned int irq_port;
+};
+
 static const card_ids icside_cids[] = {
 	{ MANU_ICS,  PROD_ICS_IDE  },
 	{ MANU_ICS2, PROD_ICS2_IDE },
@@ -122,10 +129,21 @@ static const expansioncard_ops_t icside_ops_arcin_v5 = {
  */
 static void icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
 {
-	unsigned int ide_base_port = (unsigned int)ec->irq_data;
+	struct icside_state *state = ec->irq_data;
+	unsigned int base = state->irq_port;
+
+	state->enabled = 1;
 
-	outb (0, ide_base_port + ICS_ARCIN_V6_INTROFFSET_1);
-	outb (0, ide_base_port + ICS_ARCIN_V6_INTROFFSET_2);
+	switch (state->channel) {
+	case 0:
+		outb(0, base + ICS_ARCIN_V6_INTROFFSET_1);
+		inb(base + ICS_ARCIN_V6_INTROFFSET_2);
+		break;
+	case 1:
+		outb(0, base + ICS_ARCIN_V6_INTROFFSET_2);
+		inb(base + ICS_ARCIN_V6_INTROFFSET_1);
+		break;
+	}
 }
 
 /* Prototype: icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
@@ -133,10 +151,12 @@ static void icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
  */
 static void icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
 {
-	unsigned int ide_base_port = (unsigned int)ec->irq_data;
+	struct icside_state *state = ec->irq_data;
+
+	state->enabled = 0;
 
-	inb (ide_base_port + ICS_ARCIN_V6_INTROFFSET_1);
-	inb (ide_base_port + ICS_ARCIN_V6_INTROFFSET_2);
+	inb (state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
+	inb (state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
 }
 
 /* Prototype: icside_irqprobe(struct expansion_card *ec)
@@ -144,10 +164,10 @@ static void icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
  */
 static int icside_irqpending_arcin_v6(struct expansion_card *ec)
 {
-	unsigned int ide_base_port = (unsigned int)ec->irq_data;
+	struct icside_state *state = ec->irq_data;
 
-	return inb(ide_base_port + ICS_ARCIN_V6_INTRSTAT_1) & 1 ||
-	       inb(ide_base_port + ICS_ARCIN_V6_INTRSTAT_2) & 1;
+	return inb(state->irq_port + ICS_ARCIN_V6_INTRSTAT_1) & 1 ||
+	       inb(state->irq_port + ICS_ARCIN_V6_INTRSTAT_2) & 1;
 }
 
 static const expansioncard_ops_t icside_ops_arcin_v6 = {
@@ -210,6 +230,39 @@ static iftype_t __init icside_identifyif (struct expansion_card *ec)
 	return iftype;
 }
 
+/*
+ * Handle routing of interrupts.  This is called before
+ * we write the command to the drive.
+ */
+static void icside_maskproc(struct ata_device *drive, int mask)
+{
+	struct ata_channel *ch = drive->channel;
+	struct icside_state *state = ch->hw.priv;
+	unsigned long flags;
+
+	local_irq_save(flags);
+
+	state->channel = ch->unit;
+
+	if (state->enabled && !mask) {
+		switch (ch->unit) {
+		case 0:
+			outb(0, state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
+			inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
+			break;
+		case 1:
+			outb(0, state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
+			inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
+			break;
+		}
+	} else {
+		inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_2);
+		inb(state->irq_port + ICS_ARCIN_V6_INTROFFSET_1);
+	}
+
+	local_irq_restore(flags);
+}
+
 #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
 /*
  * SG-DMA support.
@@ -223,32 +276,42 @@ static iftype_t __init icside_identifyif (struct expansion_card *ec)
 #define NR_ENTRIES 256
 #define TABLE_SIZE (NR_ENTRIES * 8)
 
-static int ide_build_sglist(struct ata_channel *hwif, struct request *rq)
+static int ide_build_sglist(struct ata_channel *ch, struct request *rq)
 {
-	request_queue_t *q = &hwif->drives[DEVICE_NR(rq->rq_dev) & 1].queue;
-	struct scatterlist *sg = hwif->sg_table;
-	int nents = blk_rq_map_sg(q, rq, sg);
-
-	if (rq->q && nents > rq->nr_phys_segments)
-		printk("icside: received %d segments, build %d\n",
-			rq->nr_phys_segments, nents);
-
-	if (rq_data_dir(rq) == READ)
-		hwif->sg_dma_direction = PCI_DMA_FROMDEVICE;
-	else
-		hwif->sg_dma_direction = PCI_DMA_TODEVICE;
-
-	return pci_map_sg(NULL, sg, nents, hwif->sg_dma_direction);
-}
+	struct scatterlist *sg = ch->sg_table;
+	int nents;
+
+	if (rq->flags & REQ_DRIVE_ACB) {
+		struct ata_taskfile *args = rq->special;
+
+		if (args->command_type == IDE_DRIVE_TASK_RAW_WRITE)
+			ch->sg_dma_direction = PCI_DMA_TODEVICE;
+		else
+			ch->sg_dma_direction = PCI_DMA_FROMDEVICE;
+
+		memset(sg, 0, sizeof(*sg));
+		sg->page   = virt_to_page(rq->buffer);
+		sg->offset = ((unsigned long)rq->buffer) & ~PAGE_MASK;
+		sg->length = rq->nr_sectors * SECTOR_SIZE;
+		nents = 1;
+	} else {
+		nents = blk_rq_map_sg(rq->q, rq, sg);
+
+		if (rq->q && nents > rq->nr_phys_segments)
+			printk("icside: received %d segments, build %d\n",
+				rq->nr_phys_segments, nents);
+
+		if (rq_data_dir(rq) == READ)
+			ch->sg_dma_direction = PCI_DMA_FROMDEVICE;
+		else
+			ch->sg_dma_direction = PCI_DMA_TODEVICE;
+	}
 
-static int
-icside_udma_new_table(struct ata_channel *ch, struct request *rq)
-{
-	return ch->sg_nents = ide_build_sglist(ch, rq);
+	return pci_map_sg(NULL, sg, nents, ch->sg_dma_direction);
 }
 
 /* Teardown mappings after DMA has completed.  */
-static void icside_destroy_dmatable(ide_drive_t *drive)
+static void icside_destroy_dmatable(struct ata_device *drive)
 {
 	struct scatterlist *sg = drive->channel->sg_table;
 	int nents = drive->channel->sg_nents;
@@ -282,10 +345,9 @@ static void icside_destroy_dmatable(ide_drive_t *drive)
  *	MW2	70	25	25	120	C
  */
 static int
-icside_config_if(ide_drive_t *drive, int xfer_mode)
+icside_config_if(struct ata_device *drive, int xfer_mode)
 {
-	int func = ide_dma_off;
-	int cycle_time = 0, use_dma_info = 0;
+	int on = 0, cycle_time = 0, use_dma_info = 0;
 
 	switch (xfer_mode) {
 	case XFER_MW_DMA_2: cycle_time = 250; use_dma_info = 1;	break;
@@ -306,7 +368,7 @@ icside_config_if(ide_drive_t *drive, int xfer_mode)
 		drive->init_speed = xfer_mode;
 
 	if (cycle_time && ide_config_drive_speed(drive, xfer_mode) == 0)
-		func = ide_dma_on;
+		on = 1;
 	else
 		drive->drive_data = 480;
 
@@ -315,50 +377,45 @@ icside_config_if(ide_drive_t *drive, int xfer_mode)
 
 	drive->current_speed = xfer_mode;
 
-	return func;
+	return on;
 }
 
-static int
-icside_set_speed(ide_drive_t *drive, byte speed)
+static int icside_set_speed(struct ata_device *drive, byte speed)
 {
 	return icside_config_if(drive, speed);
 }
 
-/*
- * dma_intr() is the handler for disk read/write DMA interrupts
- */
-static ide_startstop_t icside_dmaintr(struct ata_device *drive, struct request *rq)
+static void icside_dma_enable(struct ata_device *drive, int on, int verbose)
 {
-	int i;
-	byte stat, dma_stat;
-
-	dma_stat = drive->channel->udma(ide_dma_end, drive, rq);
-	stat = GET_STAT();			/* get drive status */
-	if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
-		if (!dma_stat) {
-			for (i = rq->nr_sectors; i > 0;) {
-				i -= rq->current_nr_sectors;
-				ide_end_request(drive, 1);
-			}
-			return ide_stopped;
-		}
-		printk("%s: dma_intr: bad DMA status (dma_stat=%x)\n",
-		       drive->name, dma_stat);
+	if (!on) {
+		if (verbose)
+			printk("%s: DMA disabled\n", drive->name);
+#ifdef CONFIG_BLK_DEV_IDE_TCQ
+		udma_tcq_enable(drive, 0);
+#endif
 	}
-	return ide_error(drive, "dma_intr", stat);
-}
+	
+	/*
+	 * We don't need any bouncing.  Yes, this looks the
+	 * wrong way around, but it is correct.
+	 */
+	blk_queue_bounce_limit(&drive->queue, BLK_BOUNCE_ANY);
+	drive->using_dma = on;
 
+#ifdef CONFIG_CLK_DEV_IDE_TCQ_DEFAULT
+	if (on)
+		udma_tcq_enable(drive, 1);
+#endif
+}
 
-static int
-icside_dma_check(struct ata_device *drive, struct request *rq)
+static int icside_dma_check(struct ata_device *drive)
 {
 	struct hd_driveid *id = drive->id;
-	struct ata_channel *hwif = drive->channel;
-	int autodma = hwif->autodma;
+	struct ata_channel *ch = drive->channel;
 	int xfer_mode = XFER_PIO_2;
-	int func = ide_dma_off_quietly;
+	int on;
 
-	if (!id || !(id->capability & 1) || !autodma)
+	if (!id || !(id->capability & 1) || !ch->autodma)
 		goto out;
 
 	/*
@@ -367,188 +424,284 @@ icside_dma_check(struct ata_device *drive, struct request *rq)
 	if (id->field_valid & 2) {
 		if (id->dma_mword & 4) {
 			xfer_mode = XFER_MW_DMA_2;
-			func = ide_dma_on;
 		} else if (id->dma_mword & 2) {
 			xfer_mode = XFER_MW_DMA_1;
-			func = ide_dma_on;
 		} else if (id->dma_mword & 1) {
 			xfer_mode = XFER_MW_DMA_0;
-			func = ide_dma_on;
 		}
-		goto out;
 	}
 
 out:
-	func = icside_config_if(drive, xfer_mode);
+	on = icside_config_if(drive, xfer_mode);
+
+	icside_dma_enable(drive, on, 0);
+
+	return 0;
+}
+
+static int icside_dma_stop(struct ata_device *drive)
+{
+	struct ata_channel *ch = drive->channel;
+
+	drive->waiting_for_dma = 0;
+	disable_dma(ch->hw.dma);
+	icside_destroy_dmatable(drive);
+
+	return get_dma_residue(ch->hw.dma) != 0;
+}
 
-	return hwif->udma(func, drive, rq);
+static int icside_dma_start(struct ata_device *drive, struct request *rq)
+{
+	struct ata_channel *ch = drive->channel;
+
+	/*
+	 * We can not enable DMA on both channels.
+	 */
+	BUG_ON(dma_channel_active(ch->hw.dma));
+
+	enable_dma(ch->hw.dma);
+
+	return 0;
+}
+
+/*
+ * dma_intr() is the handler for disk read/write DMA interrupts
+ */
+static ide_startstop_t icside_dmaintr(struct ata_device *drive, struct request *rq)
+{
+	int dma_stat;
+	byte stat;
+
+	dma_stat = icside_dma_stop(drive);
+
+	stat = GET_STAT();			/* get drive status */
+	if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
+		if (!dma_stat) {
+			__ide_end_request(drive, rq, 1, rq->nr_sectors);
+			return ide_stopped;
+		}
+		printk("%s: dma_intr: bad DMA status (dma_stat=%x)\n",
+		       drive->name, dma_stat);
+	}
+	return ide_error(drive, rq, "dma_intr", stat);
 }
 
 static int
-icside_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
+icside_dma_common(struct ata_device *drive, struct request *rq,
+		  unsigned int dma_mode)
 {
-	struct ata_channel *hwif = drive->channel;
-	int count, reading = 0;
-
-	switch (func) {
-	case ide_dma_off:
-		printk("%s: DMA disabled\n", drive->name);
-		/*FALLTHROUGH*/
-
-	case ide_dma_off_quietly:
-	case ide_dma_on:
-		/*
-		 * We don't need any bouncing.  Yes, this looks the
-		 * wrong way around, but it is correct.
-		 */
-		blk_queue_bounce_limit(&drive->queue, BLK_BOUNCE_ANY);
-		drive->using_dma = (func == ide_dma_on);
-		return 0;
+	struct ata_channel *ch = drive->channel;
+	unsigned int count;
+
+	/*
+	 * We can not enable DMA on both channels.
+	 */
+	BUG_ON(dma_channel_active(ch->hw.dma));
+
+	count = ch->sg_nents = ide_build_sglist(ch, rq);
+	if (!count)
+		return 1;
+
+	/*
+	 * Route the DMA signals to to this channel.
+	 */
+	outb(ch->select_data, ch->config_data);
+
+	/*
+	 * Select the correct timing for this drive.
+	 */
+	set_dma_speed(ch->hw.dma, drive->drive_data);
+
+	/*
+	 * Tell the DMA engine about the SG table and
+	 * data direction.
+	 */
+	set_dma_sg(ch->hw.dma, ch->sg_table, count);
+	set_dma_mode(ch->hw.dma, dma_mode);
 
-	case ide_dma_check:
-		return icside_dma_check(drive, rq);
-
-	case ide_dma_read:
-		reading = 1;
-	case ide_dma_write:
-		count = icside_udma_new_table(hwif, rq);
-		if (!count)
-			return 1;
-		disable_dma(hwif->hw.dma);
-
-		/* Route the DMA signals to
-		 * to the correct interface.
-		 */
-		outb(hwif->select_data, hwif->config_data);
-
-		/* Select the correct timing
-		 * for this drive
-		 */
-		set_dma_speed(hwif->hw.dma, drive->drive_data);
-
-		set_dma_sg(hwif->hw.dma, drive->channel->sg_table, count);
-		set_dma_mode(hwif->hw.dma, reading ? DMA_MODE_READ
-			     : DMA_MODE_WRITE);
-
-		drive->waiting_for_dma = 1;
-		if (drive->type != ATA_DISK)
-			return 0;
-
-		ide_set_handler(drive, icside_dmaintr, WAIT_CMD, NULL);
-		OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA,
-			 IDE_COMMAND_REG);
-
-	case ide_dma_begin:
-		enable_dma(hwif->hw.dma);
+	drive->waiting_for_dma = 1;
+
+	return 0;
+}
+
+static int icside_dma_read(struct ata_device *drive, struct request *rq)
+{
+	struct ata_channel *ch = drive->channel;
+	unsigned int cmd;
+
+	if (icside_dma_common(drive, rq, DMA_MODE_READ))
+		return 1;
+
+	if (drive->type != ATA_DISK)
 		return 0;
 
-	case ide_dma_end:
-		drive->waiting_for_dma = 0;
-		disable_dma(hwif->hw.dma);
-		icside_destroy_dmatable(drive);
-		return get_dma_residue(hwif->hw.dma) != 0;
+	ide_set_handler(drive, icside_dmaintr, WAIT_CMD, NULL);
 
-	case ide_dma_test_irq:
-		return inb((unsigned long)hwif->hw.priv) & 1;
+	if ((rq->flags & REQ_DRIVE_ACB) && drive->addressing == 1) {
+		struct ata_taskfile *args = rq->special;
+		cmd = args->taskfile.command;
+	} else if (drive->addressing) {
+		cmd = WIN_READDMA_EXT;
+	} else {
+		cmd = WIN_READDMA;
+	}
 
-	case ide_dma_timeout:
-	default:
-		printk("icside_dmaproc: unsupported function: %d\n", func);
+	OUT_BYTE(cmd, IDE_COMMAND_REG);
+	enable_dma(ch->hw.dma);
+	return 0;
+}
+
+static int icside_dma_write(struct ata_device *drive, struct request *rq)
+{
+	struct ata_channel *ch = drive->channel;
+	unsigned int cmd;
+
+	if (icside_dma_common(drive, rq, DMA_MODE_WRITE))
+		return 1;
+
+	if (drive->type != ATA_DISK)
+		return 0;
+
+	ide_set_handler(drive, icside_dmaintr, WAIT_CMD, NULL);
+
+	if ((rq->flags & REQ_DRIVE_ACB) && drive->addressing == 1) {
+		struct ata_taskfile *args = rq->special;
+		cmd = args->taskfile.command;
+	} else if (drive->addressing) {
+		cmd = WIN_WRITEDMA_EXT;
+	} else {
+		cmd = WIN_WRITEDMA;
 	}
-	return 1;
+	OUT_BYTE(cmd, IDE_COMMAND_REG);
+
+	enable_dma(ch->hw.dma);
+	return 0;
 }
 
-static int
-icside_setup_dma(struct ata_channel *hwif, int autodma)
+static int icside_irq_status(struct ata_device *drive)
+{
+	struct ata_channel *ch = drive->channel;
+	struct icside_state *state = ch->hw.priv;
+
+	return inb(state->irq_port +
+		   (ch->unit ?
+			ICS_ARCIN_V6_INTRSTAT_2 :
+			ICS_ARCIN_V6_INTRSTAT_1)) & 1;
+}
+
+static void icside_dma_timeout(struct ata_device *drive)
 {
-	printk("    %s: SG-DMA", hwif->name);
+	printk(KERN_ERR "ATA: %s: UDMA timeout occured:", drive->name);
+	ide_dump_status(drive, NULL, "UDMA timeout", GET_STAT());
+}
+
+static void icside_irq_lost(struct ata_device *drive)
+{
+	printk(KERN_ERR "ATA: %s: IRQ lost\n", drive->name);
+}
 
-	hwif->sg_table = kmalloc(sizeof(struct scatterlist) * NR_ENTRIES,
+static int icside_setup_dma(struct ata_channel *ch)
+{
+	int autodma = 0;
+
+#ifdef CONFIG_IDEDMA_ICS_AUTO
+	autodma = 1;
+#endif
+
+	printk("    %s: SG-DMA", ch->name);
+
+	ch->sg_table = kmalloc(sizeof(struct scatterlist) * NR_ENTRIES,
 				 GFP_KERNEL);
-	if (!hwif->sg_table)
+	if (!ch->sg_table)
 		goto failed;
 
-	hwif->dmatable_cpu = NULL;
-	hwif->dmatable_dma = 0;
-	hwif->speedproc = icside_set_speed;
-	hwif->dmaproc = icside_dmaproc;
-	hwif->autodma = autodma;
-
-	printk(" capable%s\n", autodma ?
-		", auto-enable" : "");
+	ch->dmatable_cpu    = NULL;
+	ch->dmatable_dma    = 0;
+	ch->speedproc       = icside_set_speed;
+	ch->XXX_udma        = icside_dma_check;
+	ch->udma_enable     = icside_dma_enable;
+	ch->udma_start      = icside_dma_start;
+	ch->udma_stop       = icside_dma_stop;
+	ch->udma_read       = icside_dma_read;
+	ch->udma_write      = icside_dma_write;
+	ch->udma_irq_status = icside_irq_status;
+	ch->udma_timeout    = icside_dma_timeout;
+	ch->udma_irq_lost   = icside_irq_lost;
+	ch->autodma         = autodma;
+
+	printk(" capable%s\n", autodma ? ", auto-enable" : "");
 
 	return 1;
 
 failed:
-	printk(" -- ERROR, unable to allocate DMA table\n");
+	printk(" disabled, unable to allocate DMA table\n");
 	return 0;
 }
 
-void ide_release_dma(struct ata_channel *hwif)
+void ide_release_dma(struct ata_channel *ch)
 {
-	if (hwif->sg_table) {
-		kfree(hwif->sg_table);
-		hwif->sg_table = NULL;
+	if (ch->sg_table) {
+		kfree(ch->sg_table);
+		ch->sg_table = NULL;
 	}
 }
 #endif
 
-static struct ata_channel *
-icside_find_hwif(unsigned long dataport)
+static struct ata_channel *icside_find_hwif(unsigned long dataport)
 {
-	struct ata_channel *hwif;
+	struct ata_channel *ch;
 	int index;
 
 	for (index = 0; index < MAX_HWIFS; ++index) {
-		hwif = &ide_hwifs[index];
-		if (hwif->io_ports[IDE_DATA_OFFSET] == (ide_ioreg_t)dataport)
+		ch = &ide_hwifs[index];
+		if (ch->io_ports[IDE_DATA_OFFSET] == (ide_ioreg_t)dataport)
 			goto found;
 	}
 
 	for (index = 0; index < MAX_HWIFS; ++index) {
-		hwif = &ide_hwifs[index];
-		if (!hwif->io_ports[IDE_DATA_OFFSET])
+		ch = &ide_hwifs[index];
+		if (!ch->io_ports[IDE_DATA_OFFSET])
 			goto found;
 	}
 
 	return NULL;
 found:
-	return hwif;
+	return ch;
 }
 
 static struct ata_channel *
 icside_setup(unsigned long base, struct cardinfo *info, int irq)
 {
 	unsigned long port = base + info->dataoffset;
-	struct ata_channel *hwif;
+	struct ata_channel *ch;
 
-	hwif = icside_find_hwif(base);
-	if (hwif) {
+	ch = icside_find_hwif(base);
+	if (ch) {
 		int i;
 
-		memset(&hwif->hw, 0, sizeof(hw_regs_t));
+		memset(&ch->hw, 0, sizeof(hw_regs_t));
 
 		for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
-			hwif->hw.io_ports[i] = (ide_ioreg_t)port;
-			hwif->io_ports[i] = (ide_ioreg_t)port;
+			ch->hw.io_ports[i] = (ide_ioreg_t)port;
+			ch->io_ports[i] = (ide_ioreg_t)port;
 			port += 1 << info->stepping;
 		}
-		hwif->hw.io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
-		hwif->io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
-		hwif->hw.irq  = irq;
-		hwif->irq     = irq;
-		hwif->hw.dma  = NO_DMA;
-		hwif->noprobe = 0;
-		hwif->chipset = ide_acorn;
+		ch->hw.io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
+		ch->io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
+		ch->hw.irq  = irq;
+		ch->irq     = irq;
+		ch->hw.dma  = NO_DMA;
+		ch->noprobe = 0;
+		ch->chipset = ide_acorn;
 	}
 
-	return hwif;
+	return ch;
 }
 
-static int __init icside_register_v5(struct expansion_card *ec, int autodma)
+static int __init icside_register_v5(struct expansion_card *ec)
 {
 	unsigned long slot_port;
-	struct ata_channel *hwif;
+	struct ata_channel *ch;
 
 	slot_port = ecard_address(ec, ECARD_MEMC, 0);
 
@@ -562,17 +715,17 @@ static int __init icside_register_v5(struct expansion_card *ec, int autodma)
 	 */
 	inb(slot_port + ICS_ARCIN_V5_INTROFFSET);
 
-	hwif = icside_setup(slot_port, &icside_cardinfo_v5, ec->irq);
+	ch = icside_setup(slot_port, &icside_cardinfo_v5, ec->irq);
 
-	return hwif ? 0 : -1;
+	return ch ? 0 : -1;
 }
 
-static int __init icside_register_v6(struct expansion_card *ec, int autodma)
+static int __init icside_register_v6(struct expansion_card *ec)
 {
 	unsigned long slot_port, port;
-	struct ata_channel *hwif;
-	struct ata_channel *mate;
-	int sel = 0;
+	struct icside_state *state;
+	struct ata_channel *ch0, *ch1;
+	unsigned int sel = 0;
 
 	slot_port = ecard_address(ec, ECARD_IOC, ECARD_FAST);
 	port      = ecard_address(ec, ECARD_EASI, ECARD_FAST);
@@ -584,55 +737,57 @@ static int __init icside_register_v6(struct expansion_card *ec, int autodma)
 
 	outb(sel, slot_port);
 
-	ec->irq_data = (void *)port;
-	ec->ops      = (expansioncard_ops_t *)&icside_ops_arcin_v6;
-
 	/*
 	 * Be on the safe side - disable interrupts
 	 */
 	inb(port + ICS_ARCIN_V6_INTROFFSET_1);
 	inb(port + ICS_ARCIN_V6_INTROFFSET_2);
 
-	hwif = icside_setup(port, &icside_cardinfo_v6_1, ec->irq);
-	mate = icside_setup(port, &icside_cardinfo_v6_2, ec->irq);
+	/*
+	 * Find and register the interfaces.
+	 */
+	ch0 = icside_setup(port, &icside_cardinfo_v6_1, ec->irq);
+	ch1 = icside_setup(port, &icside_cardinfo_v6_2, ec->irq);
+
+	if (!ch0 || !ch1)
+		return -ENODEV;
+
+	state = kmalloc(sizeof(struct icside_state), GFP_KERNEL);
+	if (!state)
+		return -ENOMEM;
+
+	state->channel    = 0;
+	state->enabled    = 0;
+	state->irq_port   = port;
+
+	ec->irq_data      = state;
+	ec->ops           = (expansioncard_ops_t *)&icside_ops_arcin_v6;
+
+	ch0->maskproc     = icside_maskproc;
+	ch0->unit         = 0;
+	ch0->hw.priv      = state;
+	ch0->config_data  = slot_port;
+	ch0->select_data  = sel;
+	ch0->hw.dma       = ec->dma;
+
+	ch1->maskproc     = icside_maskproc;
+	ch1->unit         = 1;
+	ch1->hw.priv      = state;
+	ch1->config_data  = slot_port;
+	ch1->select_data  = sel | 1;
+	ch1->hw.dma       = ec->dma;
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
-	if (ec->dma != NO_DMA) {
-		if (request_dma(ec->dma, hwif->name))
-			goto no_dma;
-
-		if (hwif) {
-			hwif->config_data = slot_port;
-			hwif->select_data = sel;
-			hwif->hw.dma  = ec->dma;
-			hwif->hw.priv = (void *)
-					(port + ICS_ARCIN_V6_INTRSTAT_1);
-			hwif->unit = 0;
-			icside_setup_dma(hwif, autodma);
-		}
-		if (mate) {
-			mate->config_data = slot_port;
-			mate->select_data = sel | 1;
-			mate->hw.dma  = ec->dma;
-			mate->hw.priv = (void *)
-					(port + ICS_ARCIN_V6_INTRSTAT_2);
-			mate->unit = 1;
-			icside_setup_dma(mate, autodma);
-		}
+	if (ec->dma != NO_DMA && !request_dma(ec->dma, ch0->name)) {
+		icside_setup_dma(ch0);
+		icside_setup_dma(ch1);
 	}
-no_dma:
 #endif
-	return hwif || mate ? 0 : -1;
+	return 0;
 }
 
 int __init icside_init(void)
 {
-	int autodma = 0;
-
-#ifdef CONFIG_IDEDMA_ICS_AUTO
-	autodma = 1;
-#endif
-
 	ecard_startfind ();
 
 	do {
@@ -647,11 +802,11 @@ int __init icside_init(void)
 
 		switch (icside_identifyif(ec)) {
 		case ics_if_arcin_v5:
-			result = icside_register_v5(ec, autodma);
+			result = icside_register_v5(ec);
 			break;
 
 		case ics_if_arcin_v6:
-			result = icside_register_v6(ec, autodma);
+			result = icside_register_v6(ec);
 			break;
 
 		default:
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index ec753919c063..0bd016e69241 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -139,34 +139,6 @@ int noautodma = 0;
  */
 struct ata_channel ide_hwifs[MAX_HWIFS];	/* master data repository */
 
-#if (DISK_RECOVERY_TIME > 0)
-/*
- * For really screwed hardware (hey, at least it *can* be used with Linux)
- * we can enforce a minimum delay time between successive operations.
- */
-static unsigned long read_timer (void)
-{
-	unsigned long t, flags;
-	int i;
-
-	__save_flags(flags);	/* local CPU only */
-	__cli();		/* local CPU only */
-	t = jiffies * 11932;
-	outb_p(0, 0x43);
-	i = inb_p(0x40);
-	i |= inb(0x40) << 8;
-	__restore_flags(flags);	/* local CPU only */
-	return (t - i);
-}
-#endif
-
-static inline void set_recovery_timer(struct ata_channel *channel)
-{
-#if (DISK_RECOVERY_TIME > 0)
-	channel->last_time = read_timer();
-#endif
-}
-
 static void init_hwif_data(struct ata_channel *ch, unsigned int index)
 {
 	static const byte ide_major[] = {
@@ -241,8 +213,6 @@ static void __init init_ide_data (void)
 
 	/* Add default hw interfaces */
 	ide_init_default_hwifs();
-
-	idebus_parameter = 0;
 }
 
 /*
@@ -667,6 +637,50 @@ void ide_end_drive_cmd(struct ata_device *drive, struct request *rq, u8 stat, u8
 	end_that_request_last(rq);
 }
 
+#if FANCY_STATUS_DUMPS
+struct ata_bit_messages {
+	u8 mask;
+	u8 match;
+	const char *msg;
+};
+
+static struct ata_bit_messages ata_status_msgs[] = {
+	{ BUSY_STAT,  BUSY_STAT,  "Busy"           },
+	{ READY_STAT, READY_STAT, "DriveReady"     },
+	{ WRERR_STAT, WRERR_STAT, "DeviceFault"    },
+	{ SEEK_STAT,  SEEK_STAT,  "SeekComplete"   },
+	{ DRQ_STAT,   DRQ_STAT,   "DataRequest"    },
+	{ ECC_STAT,   ECC_STAT,   "CorrectedError" },
+	{ INDEX_STAT, INDEX_STAT, "Index"          },
+	{ ERR_STAT,   ERR_STAT,   "Error"          }
+};
+
+static struct ata_bit_messages ata_error_msgs[] = {
+	{ ICRC_ERR|ABRT_ERR,	ABRT_ERR,		"DriveStatusError"   },
+	{ ICRC_ERR|ABRT_ERR,	ICRC_ERR,		"BadSector"	     },
+	{ ICRC_ERR|ABRT_ERR,	ICRC_ERR|ABRT_ERR,	"BadCRC"	     },
+	{ ECC_ERR,		ECC_ERR,		"UncorrectableError" },
+	{ ID_ERR,		ID_ERR,			"SectorIdNotFound"   },
+	{ TRK0_ERR,		TRK0_ERR,		"TrackZeroNotFound"  },
+	{ MARK_ERR,		MARK_ERR,		"AddrMarkNotFound"   }
+};
+
+static void ata_dump_bits(struct ata_bit_messages *msgs, int nr, byte bits)
+{
+	int i;
+
+	printk(" { ");
+
+	for (i = 0; i < nr; i++, msgs++)
+		if ((bits & msgs->mask) == msgs->match)
+			printk("%s ", msgs->msg);
+
+	printk("} ");
+}
+#else
+#define ata_dump_bits(msgs,nr,bits) do { } while (0)
+#endif
+
 /*
  * Error reporting, in human readable form (luxurious, but a memory hog).
  */
@@ -674,49 +688,22 @@ u8 ide_dump_status(struct ata_device *drive, struct request * rq, const char *ms
 {
 	unsigned long flags;
 	byte err = 0;
+	int i;
 
 	__save_flags (flags);	/* local CPU only */
 	ide__sti();		/* local CPU only */
-#if !(FANCY_STATUS_DUMPS)
-	printk("%s: %s: status=0x%02x\n", drive->name, msg, stat);
-#else
-	printk(" { ");
-	{
-		char *msg = "";
-		if (stat & BUSY_STAT)
-			msg = "Busy";
-		else {
-			if (stat & READY_STAT)
-				msg = "DriveReady";
-			if (stat & WRERR_STAT)
-				msg = "DeviceFault";
-			if (stat & SEEK_STAT)
-				msg = "SeekComplete";
-			if (stat & DRQ_STAT)
-				msg = "DataRequest";
-			if (stat & ECC_STAT)
-				msg = "CorrectedError";
-			if (stat & INDEX_STAT)
-				msg = "Index";
-			if (stat & ERR_STAT)
-				msg = "Error";
-		}
-	}
-	printk("%s }\n", msg);
-#endif
+
+	printk("%s: %s: status=0x%02x", drive->name, msg, stat);
+	ata_dump_bits(ata_status_msgs, ARRAY_SIZE(ata_status_msgs), stat);
+	printk("\n");
+
 	if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
 		err = GET_ERR();
 		printk("%s: %s: error=0x%02x", drive->name, msg, err);
 #if FANCY_STATUS_DUMPS
 		if (drive->type == ATA_DISK) {
-			printk(" { ");
-			if (err & ABRT_ERR)	printk("DriveStatusError ");
-			if (err & ICRC_ERR)	printk("%s", (err & ABRT_ERR) ? "BadCRC " : "BadSector ");
-			if (err & ECC_ERR)	printk("UncorrectableError ");
-			if (err & ID_ERR)	printk("SectorIdNotFound ");
-			if (err & TRK0_ERR)	printk("TrackZeroNotFound ");
-			if (err & MARK_ERR)	printk("AddrMarkNotFound ");
-			printk("}");
+			ata_dump_bits(ata_error_msgs, ARRAY_SIZE(ata_error_msgs), err);
+
 			if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR || (err & (ECC_ERR|ID_ERR|MARK_ERR))) {
 				if ((drive->id->command_set_2 & 0x0400) &&
 				    (drive->id->cfs_enable_2 & 0x0400) &&
@@ -988,11 +975,6 @@ static ide_startstop_t start_request(struct ata_device *drive, struct request *r
 	 */
 	if (block == 0 && drive->remap_0_to_1 == 1)
 		block = 1;  /* redirect MBR access to EZ-Drive partn table */
-
-#if (DISK_RECOVERY_TIME > 0)
-	while ((read_timer() - ch->last_time) < DISK_RECOVERY_TIME);
-#endif
-
 	{
 		ide_startstop_t res;
 
@@ -1464,7 +1446,6 @@ void ide_timer_expiry(unsigned long data)
 				} else
 					startstop = ide_error(drive, drive->rq, "irq timeout", GET_STAT());
 			}
-			set_recovery_timer(ch);
 			enable_irq(ch->irq);
 
 			spin_lock_irq(ch->lock);
@@ -1614,7 +1595,6 @@ void ata_irq_request(int irq, void *data, struct pt_regs *regs)
 	 * same irq as is currently being serviced here, and Linux
 	 * won't allow another of the same (on any CPU) until we return.
 	 */
-	set_recovery_timer(drive->channel);
 	if (startstop == ide_stopped) {
 		if (!ch->handler) {	/* paranoia */
 			clear_bit(IDE_BUSY, ch->active);
@@ -2787,10 +2767,7 @@ int __init ide_setup (char *s)
 	if (!strncmp(s, "idebus", 6)) {
 		if (match_parm(&s[6], NULL, vals, 1) != 1)
 			goto bad_option;
-		if (vals[0] >= 20 && vals[0] <= 66) {
-			idebus_parameter = vals[0];
-		} else
-			printk(" -- BAD BUS SPEED! Expected value from 20 to 66");
+		idebus_parameter = vals[0];
 		goto done;
 	}
 
@@ -3219,27 +3196,40 @@ static int __init ata_module_init(void)
 
 	ide_devfs_handle = devfs_mk_dir (NULL, "ide", NULL);
 
-	/* Initialize system bus speed.
-	 *
-	 * This can be changed by a particular chipse initialization module.
-	 * Otherwise we assume 33MHz as a safe value for PCI bus based systems.
-	 * 50MHz will be assumed for abolitions like VESA, since higher values
-	 * result in more conservative timing setups.
-	 *
-	 * The kernel parameter idebus=XX overrides the default settings.
-	 */
+/*
+ * Because most of the ATA adapters represent the timings in unit of bus
+ * clocks, and there is no known reliable way to detect the bus clock
+ * frequency, we assume 50 MHz for non-PCI (VLB, EISA) and 33 MHz for PCI based
+ * systems. Since assuming only hurts performance and not stability, this is
+ * OK. The user can change this on the command line by using the "idebus=XX"
+ * parameter. While the system_bus_speed variable is in kHz units, we accept
+ * both MHz and kHz entry on the command line for backward compatibility.
+ */
 
-	system_bus_speed = 50;
-	if (idebus_parameter)
-	    system_bus_speed = idebus_parameter;
-#ifdef CONFIG_PCI
-	else if (pci_present())
-	    system_bus_speed = 33;
-#endif
+	system_bus_speed = 50000;
 
-	printk(KERN_INFO "ATA: system bus speed %dMHz\n", system_bus_speed);
+	if (pci_present())
+	    system_bus_speed = 33333;
 
-	init_ide_data ();
+	if (idebus_parameter >= 20 && idebus_parameter <= 80) {
+
+		system_bus_speed = idebus_parameter * 1000;
+
+		switch (system_bus_speed) {
+			case 33000: system_bus_speed = 33333; break;
+			case 37000: system_bus_speed = 37500; break;
+			case 41000: system_bus_speed = 41666; break;
+			case 66000: system_bus_speed = 66666; break;
+		}
+	}
+
+	if (idebus_parameter >= 20000 && idebus_parameter <= 80000)
+	    system_bus_speed = idebus_parameter;
+	
+	printk(KERN_INFO "ATA: %s bus speed %d.%dMHz\n",
+		pci_present() ? "PCI" : "System", system_bus_speed / 1000, system_bus_speed / 100 % 10);
+
+	init_ide_data();
 
 	initializing = 1;
 
diff --git a/drivers/ide/opti621.c b/drivers/ide/opti621.c
index 279681d1441d..02768318def8 100644
--- a/drivers/ide/opti621.c
+++ b/drivers/ide/opti621.c
@@ -175,7 +175,7 @@ static int cmpt_clk(int time, int bus_speed)
  * Use idebus=xx to select right frequency.
  */
 {
-	return ((time*bus_speed+999)/1000);
+	return ((time*bus_speed+999999)/1000000);
 }
 
 static void write_reg(byte value, int reg)
diff --git a/drivers/ide/pcidma.c b/drivers/ide/pcidma.c
index b9a33e5c73f7..644de2844f75 100644
--- a/drivers/ide/pcidma.c
+++ b/drivers/ide/pcidma.c
@@ -258,7 +258,7 @@ void ide_release_dma(struct ata_channel *ch)
  * recovery" in the ATAPI drivers. This was just plain wrong before, in esp.
  * not portable, and just got uncovered now.
  */
-static void udma_pci_enable(struct ata_device *drive, int on, int verbose)
+void udma_pci_enable(struct ata_device *drive, int on, int verbose)
 {
 	struct ata_channel *ch = drive->channel;
 	int set_high = 1;
@@ -396,7 +396,7 @@ void udma_destroy_table(struct ata_channel *ch)
  * about addressing modes.
  */
 
-static int udma_pci_start(struct ata_device *drive, struct request *rq)
+int udma_pci_start(struct ata_device *drive, struct request *rq)
 {
 	struct ata_channel *ch = drive->channel;
 	unsigned long dma_base = ch->dma_base;
@@ -410,7 +410,7 @@ static int udma_pci_start(struct ata_device *drive, struct request *rq)
 	return 0;
 }
 
-static int udma_pci_stop(struct ata_device *drive)
+int udma_pci_stop(struct ata_device *drive)
 {
 	struct ata_channel *ch = drive->channel;
 	unsigned long dma_base = ch->dma_base;
@@ -425,12 +425,12 @@ static int udma_pci_stop(struct ata_device *drive)
 	return (dma_stat & 7) != 4 ? (0x10 | dma_stat) : 0;	/* verify good DMA status */
 }
 
-static int udma_pci_read(struct ata_device *drive, struct request *rq)
+int udma_pci_read(struct ata_device *drive, struct request *rq)
 {
 	return ata_do_udma(1, drive, rq);
 }
 
-static int udma_pci_write(struct ata_device *drive, struct request *rq)
+int udma_pci_write(struct ata_device *drive, struct request *rq)
 {
 	return ata_do_udma(0, drive, rq);
 }
@@ -438,7 +438,7 @@ static int udma_pci_write(struct ata_device *drive, struct request *rq)
 /*
  * FIXME: This should be attached to a channel as we can see now!
  */
-static int udma_pci_irq_status(struct ata_device *drive)
+int udma_pci_irq_status(struct ata_device *drive)
 {
 	struct ata_channel *ch = drive->channel;
 	u8 dma_stat;
@@ -449,12 +449,12 @@ static int udma_pci_irq_status(struct ata_device *drive)
 	return (dma_stat & 4) == 4;	/* return 1 if INTR asserted */
 }
 
-static void udma_pci_timeout(struct ata_device *drive)
+void udma_pci_timeout(struct ata_device *drive)
 {
 	printk(KERN_ERR "ATA: UDMA timeout occured %s!\n", drive->name);
 }
 
-static void udma_pci_irq_lost(struct ata_device *drive)
+void udma_pci_irq_lost(struct ata_device *drive)
 {
 }
 
@@ -553,3 +553,11 @@ int ata_do_udma(unsigned int reading, struct ata_device *drive, struct request *
 
 EXPORT_SYMBOL(ata_do_udma);
 EXPORT_SYMBOL(ide_dma_intr);
+EXPORT_SYMBOL(udma_pci_enable);
+EXPORT_SYMBOL(udma_pci_start);
+EXPORT_SYMBOL(udma_pci_stop);
+EXPORT_SYMBOL(udma_pci_read);
+EXPORT_SYMBOL(udma_pci_write);
+EXPORT_SYMBOL(udma_pci_irq_status);
+EXPORT_SYMBOL(udma_pci_timeout);
+EXPORT_SYMBOL(udma_pci_irq_lost);
diff --git a/drivers/ide/pdc202xx.c b/drivers/ide/pdc202xx.c
index 8eaa72565344..30445573f2b5 100644
--- a/drivers/ide/pdc202xx.c
+++ b/drivers/ide/pdc202xx.c
@@ -166,10 +166,12 @@ static void decode_registers (byte registers, byte value)
 
 #endif /* PDC202XX_DECODE_REGISTER_INFO */
 
-int check_in_drive_lists(struct ata_device *drive) {
-	const char *pdc_quirk_drives[] = {
+int check_in_drive_lists(struct ata_device *drive)
+{
+	static const char *pdc_quirk_drives[] = {
 		"QUANTUM FIREBALLlct08 08",
 		"QUANTUM FIREBALLP KA6.4",
+		"QUANTUM FIREBALLP KA9.1",
 		"QUANTUM FIREBALLP LM20.4",
 		"QUANTUM FIREBALLP KX20.5",
 		"QUANTUM FIREBALLP KX27.3",
diff --git a/drivers/ide/piix.c b/drivers/ide/piix.c
index 2070b29459a1..9eb34d7c1f6c 100644
--- a/drivers/ide/piix.c
+++ b/drivers/ide/piix.c
@@ -105,7 +105,6 @@ static struct piix_ide_chip {
 static struct piix_ide_chip *piix_config;
 static unsigned char piix_enabled;
 static unsigned int piix_80w;
-static unsigned int piix_clock;
 
 static char *piix_dma[] = { "MWDMA16", "UDMA33", "UDMA66", "UDMA100", "UDMA133" };
 
@@ -147,7 +146,7 @@ static int piix_get_info(char *buffer, char **addr, off_t offset, int count)
 								: piix_dma[piix_config->flags & PIIX_UDMA]);
 
 	piix_print("BM-DMA base:                        %#x", piix_base);
-	piix_print("PCI clock:                          %d.%dMHz", piix_clock / 1000, piix_clock / 100 % 10);
+	piix_print("PCI clock:                          %d.%dMHz", system_bus_speed / 1000, system_bus_speed / 100 % 10);
 
 	piix_print("-----------------------Primary IDE-------Secondary IDE------");
 
@@ -160,7 +159,7 @@ static int piix_get_info(char *buffer, char **addr, off_t offset, int count)
 
 	piix_print("Cable Type:            %10s%20s", (piix_80w & 1) ? "80w" : "40w", (piix_80w & 2) ? "80w" : "40w");
 
-	if (!piix_clock)
+	if (!system_bus_speed)
                 return p - buffer;
 
 	piix_print("-------------------drive0----drive1----drive2----drive3-----");
@@ -192,8 +191,8 @@ static int piix_get_info(char *buffer, char **addr, off_t offset, int count)
 		}
 
 		dmaen[i] = (c & ((i & 1) ? 0x40 : 0x20) << ((i & 2) << 2));
-		cycle[i] = 1000000 / piix_clock * (active[i] + recover[i]);
-		speed[i] = 2 * piix_clock / (active[i] + recover[i]);
+		cycle[i] = 1000000 / system_bus_speed * (active[i] + recover[i]);
+		speed[i] = 2 * system_bus_speed / (active[i] + recover[i]);
 
 		if (!(piix_config->flags & PIIX_UDMA))
 			continue;
@@ -213,17 +212,17 @@ static int piix_get_info(char *buffer, char **addr, off_t offset, int count)
 			udma[i] = (4 - ((e >> (i << 2)) & 3)) * umul;
 		} else  udma[i] = (8 - ((e >> (i << 2)) & 7)) * 2;
 
-		speed[i] = 8 * piix_clock / udma[i];
-		cycle[i] = 250000 * udma[i] / piix_clock;
+		speed[i] = 8 * system_bus_speed / udma[i];
+		cycle[i] = 250000 * udma[i] / system_bus_speed;
 	}
 
 	piix_print_drive("Transfer Mode: ", "%10s", dmaen[i] ? (uen[i] ? "UDMA" : "DMA") : "PIO");
 
-	piix_print_drive("Address Setup: ", "%8dns", (1000000 / piix_clock) * 3);
-	piix_print_drive("Cmd Active:    ", "%8dns", (1000000 / piix_clock) * 12);
-	piix_print_drive("Cmd Recovery:  ", "%8dns", (1000000 / piix_clock) * 18);
-	piix_print_drive("Data Active:   ", "%8dns", (1000000 / piix_clock) * active[i]);
-	piix_print_drive("Data Recovery: ", "%8dns", (1000000 / piix_clock) * recover[i]);
+	piix_print_drive("Address Setup: ", "%8dns", (1000000 / system_bus_speed) * 3);
+	piix_print_drive("Cmd Active:    ", "%8dns", (1000000 / system_bus_speed) * 12);
+	piix_print_drive("Cmd Recovery:  ", "%8dns", (1000000 / system_bus_speed) * 18);
+	piix_print_drive("Data Active:   ", "%8dns", (1000000 / system_bus_speed) * active[i]);
+	piix_print_drive("Data Recovery: ", "%8dns", (1000000 / system_bus_speed) * recover[i]);
 	piix_print_drive("Cycle Time:    ", "%8dns", cycle[i]);
 	piix_print_drive("Transfer Rate: ", "%4d.%dMB/s", speed[i] / 1000, speed[i] / 100 % 10);
 
@@ -339,7 +338,7 @@ static int piix_set_drive(struct ata_device *drive, unsigned char speed)
 	if (speed > XFER_UDMA_4 && (piix_config->flags & PIIX_UDMA) >= PIIX_UDMA_100)
 		umul = 4;
 	
-	T = 1000000000 / piix_clock;
+	T = 1000000000 / system_bus_speed;
 	UT = T / umul;
 
 	ata_timing_compute(drive, speed, &t, T, UT);
@@ -493,24 +492,6 @@ static unsigned int __init piix_init_chipset(struct pci_dev *dev)
 		pci_write_config_word(dev, PIIX_IDETIM0 + (i << 1), w);
 	}
 
-/*
- * Determine the system bus clock.
- */
-
-	piix_clock = system_bus_speed * 1000;
-
-	switch (piix_clock) {
-		case 33000: piix_clock = 33333; break;
-		case 37000: piix_clock = 37500; break;
-		case 41000: piix_clock = 41666; break;
-	}
-
-	if (piix_clock < 20000 || piix_clock > 50000) {
-		printk(KERN_WARNING "PIIX: User given PCI clock speed impossible (%d), using 33 MHz instead.\n", piix_clock);
-		printk(KERN_WARNING "PIIX: Use ide0=ata66 if you want to assume 80-wire cable\n");
-		piix_clock = 33333;
-	}
-
 /*
  * Print the boot message.
  */
diff --git a/drivers/ide/qd65xx.c b/drivers/ide/qd65xx.c
index e2fa7625125c..655fdeadbeff 100644
--- a/drivers/ide/qd65xx.c
+++ b/drivers/ide/qd65xx.c
@@ -133,12 +133,12 @@ static byte qd6500_compute_timing(struct ata_channel *hwif, int active_time, int
 {
 	byte active_cycle,recovery_cycle;
 
-	if (system_bus_speed <= 33) {
-		active_cycle =   9  - IDE_IN(active_time   * system_bus_speed / 1000 + 1, 2, 9);
-		recovery_cycle = 15 - IDE_IN(recovery_time * system_bus_speed / 1000 + 1, 0, 15);
+	if (system_bus_speed <= 33333) {
+		active_cycle =   9  - IDE_IN(active_time   * system_bus_speed / 1000000 + 1, 2, 9);
+		recovery_cycle = 15 - IDE_IN(recovery_time * system_bus_speed / 1000000 + 1, 0, 15);
 	} else {
-		active_cycle =   8  - IDE_IN(active_time   * system_bus_speed / 1000 + 1, 1, 8);
-		recovery_cycle = 18 - IDE_IN(recovery_time * system_bus_speed / 1000 + 1, 3, 18);
+		active_cycle =   8  - IDE_IN(active_time   * system_bus_speed / 1000000 + 1, 1, 8);
+		recovery_cycle = 18 - IDE_IN(recovery_time * system_bus_speed / 1000000 + 1, 3, 18);
 	}
 
 	return((recovery_cycle<<4) | 0x08 | active_cycle);
@@ -152,8 +152,8 @@ static byte qd6500_compute_timing(struct ata_channel *hwif, int active_time, int
 
 static byte qd6580_compute_timing (int active_time, int recovery_time)
 {
-	byte active_cycle   = 17-IDE_IN(active_time   * system_bus_speed / 1000 + 1, 2, 17);
-	byte recovery_cycle = 15-IDE_IN(recovery_time * system_bus_speed / 1000 + 1, 2, 15);
+	byte active_cycle   = 17-IDE_IN(active_time   * system_bus_speed / 1000000 + 1, 2, 17);
+	byte recovery_cycle = 15-IDE_IN(recovery_time * system_bus_speed / 1000000 + 1, 2, 15);
 
 	return((recovery_cycle<<4) | active_cycle);
 }
diff --git a/drivers/ide/serverworks.c b/drivers/ide/serverworks.c
index 1f4807cbfeb0..6d99297a45c8 100644
--- a/drivers/ide/serverworks.c
+++ b/drivers/ide/serverworks.c
@@ -242,9 +242,9 @@ static struct pci_dev *isa_dev;
 
 static int svwks_tune_chipset(struct ata_device *drive, byte speed)
 {
-	byte udma_modes[]	= { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
-	byte dma_modes[]	= { 0x77, 0x21, 0x20 };
-	byte pio_modes[]	= { 0x5d, 0x47, 0x34, 0x22, 0x20 };
+	static u8 udma_modes[]	= { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
+	static u8 dma_modes[]	= { 0x77, 0x21, 0x20 };
+	static u8 pio_modes[]	= { 0x5d, 0x47, 0x34, 0x22, 0x20 };
 
 	struct ata_channel *hwif = drive->channel;
 	struct pci_dev *dev	= hwif->pci_dev;
@@ -253,7 +253,7 @@ static int svwks_tune_chipset(struct ata_device *drive, byte speed)
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
 	unsigned long dma_base	= hwif->dma_base;
-#endif /* CONFIG_BLK_DEV_IDEDMA */
+#endif
 	int err;
 
 	byte drive_pci		= 0x00;
diff --git a/drivers/ide/sl82c105.c b/drivers/ide/sl82c105.c
index 12b35343b053..7187d6b73126 100644
--- a/drivers/ide/sl82c105.c
+++ b/drivers/ide/sl82c105.c
@@ -5,8 +5,12 @@
  *
  * Maintainer unknown.
  *
- * Drive tuning added from Rebel.com's kernel sources
- *  -- Russell King (15/11/98) linux@arm.linux.org.uk
+ * Changelog:
+ *
+ * 15/11/1998	RMK	Drive tuning added from Rebel.com's kernel
+ *			sources
+ * 30/03/2002	RMK	Add fixes specified in W83C553F errata.
+ *			(with special thanks to Todd Inglett)
  */
 #include <linux/types.h>
 #include <linux/kernel.h>
@@ -27,6 +31,17 @@
 
 extern char *ide_xfer_verbose (byte xfer_rate);
 
+/*
+ * SL82C105 PCI config register 0x40 bits.
+ */
+#define CTRL_IDE_IRQB	(1 << 30)
+#define CTRL_IDE_IRQA	(1 << 28)
+#define CTRL_LEGIRQ	(1 << 11)
+#define CTRL_P1F16	(1 << 5)
+#define CTRL_P1EN	(1 << 4)
+#define CTRL_P0F16	(1 << 1)
+#define	CTRL_P0EN	(1 << 0)
+
 /*
  * Convert a PIO mode and cycle time to the required on/off
  * times for the interface.  This has protection against run-away
@@ -111,6 +126,7 @@ static int config_for_dma(ide_drive_t *drive)
 	return 0;
 }
 
+
 /*
  * Check to see if the drive and
  * chipset is capable of DMA mode
@@ -146,6 +162,7 @@ static int sl82c105_check_drive(ide_drive_t *drive)
 			break;
 		}
 	} while (0);
+
 	if (on)
 		config_for_dma(drive);
 	else
@@ -153,18 +170,105 @@ static int sl82c105_check_drive(ide_drive_t *drive)
 
 	udma_enable(drive, on, 0);
 
-
 	return 0;
 }
 
 /*
- * Our own dmaproc, only to intercept ide_dma_check
+ * Our very own dmaproc.  We need to intercept various calls
+ * to fix up the SL82C105 specific behaviour.
  */
 static int sl82c105_dmaproc(struct ata_device *drive)
 {
 	return sl82c105_check_drive(drive);
 }
 
+/*
+ * The SL82C105 holds off all IDE interrupts while in DMA mode until
+ * all DMA activity is completed.  Sometimes this causes problems (eg,
+ * when the drive wants to report an error condition).
+ *
+ * 0x7e is a "chip testing" register.  Bit 2 resets the DMA controller
+ * state machine.  We need to kick this to work around various bugs.
+ */
+static inline void sl82c105_reset_host(struct pci_dev *dev)
+{
+	u16 val;
+
+	pci_read_config_word(dev, 0x7e, &val);
+	pci_write_config_word(dev, 0x7e, val | (1 << 2));
+	pci_write_config_word(dev, 0x7e, val & ~(1 << 2));
+}
+
+static void sl82c105_dma_enable(struct ata_device *drive, int on, int verbose)
+{
+	if (!on || config_for_dma(drive)) {
+		config_for_pio(drive, 4, 0);
+		on = 0;
+	}
+	udma_pci_enable(drive, on, verbose);
+}
+
+/*
+ * ATAPI devices can cause the SL82C105 DMA state machine to go gaga.
+ * Winbond recommend that the DMA state machine is reset prior to
+ * setting the bus master DMA enable bit.
+ *
+ * The generic IDE core will have disabled the BMEN bit before this
+ * function is called.
+ */
+static int sl82c105_dma_read(struct ata_device *drive, struct request *rq)
+{
+	sl82c105_reset_host(drive->channel->pci_dev);
+	return udma_pci_read(drive, rq);
+}
+
+static int sl82c105_dma_write(struct ata_device *drive, struct request *rq)
+{
+	sl82c105_reset_host(drive->channel->pci_dev);
+	return udma_pci_write(drive, rq);
+}
+
+static void sl82c105_timeout(struct ata_device *drive)
+{
+	sl82c105_reset_host(drive->channel->pci_dev);
+}
+
+/*
+ * If we get an IRQ timeout, it might be that the DMA state machine
+ * got confused.  Fix from Todd Inglett.  Details from Winbond.
+ *
+ * This function is called when the IDE timer expires, the drive
+ * indicates that it is READY, and we were waiting for DMA to complete.
+ */
+static void sl82c105_lostirq(ide_drive_t *drive)
+{
+	struct ata_channel *ch = drive->channel;
+	struct pci_dev *dev = ch->pci_dev;
+	u32 val, mask = ch->unit ? CTRL_IDE_IRQB : CTRL_IDE_IRQA;
+	unsigned long dma_base = ch->dma_base;
+
+	printk("sl82c105: lost IRQ: resetting host\n");
+
+	/*
+	 * Check the raw interrupt from the drive.
+	 */
+	pci_read_config_dword(dev, 0x40, &val);
+	if (val & mask)
+		printk("sl82c105: drive was requesting IRQ, but host lost it\n");
+
+	/*
+	 * Was DMA enabled?  If so, disable it - we're resetting the
+	 * host.  The IDE layer will be handling the drive for us.
+	 */
+	val = inb(dma_base);
+	if (val & 1) {
+		outb(val & ~1, dma_base);
+		printk("sl82c105: DMA was enabled\n");
+	}
+
+	sl82c105_reset_host(dev);
+}
+
 /*
  * We only deal with PIO mode here - DMA mode 'using_dma' is not
  * initialised at the point that this function is called.
@@ -185,21 +289,25 @@ static void tune_sl82c105(ide_drive_t *drive, byte pio)
  * Return the revision of the Winbond bridge
  * which this function is part of.
  */
-static unsigned int sl82c105_bridge_revision(struct pci_dev *dev)
+static __init unsigned int sl82c105_bridge_revision(struct pci_dev *dev)
 {
 	struct pci_dev *bridge;
 	unsigned char rev;
 
-	bridge = pci_find_device(PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_83C553, NULL);
-
 	/*
-	 * If we are part of a Winbond 553
+	 * The bridge should be part of the same device, but function 0.
 	 */
-	if (!bridge || bridge->class >> 8 != PCI_CLASS_BRIDGE_ISA)
+	bridge = pci_find_slot(dev->bus->number,
+			       PCI_DEVFN(PCI_SLOT(dev->devfn), 0));
+	if (!bridge)
 		return -1;
 
-	if (bridge->bus != dev->bus ||
-	    PCI_SLOT(bridge->devfn) != PCI_SLOT(dev->devfn))
+	/*
+	 * Make sure it is a Winbond 553 and is an ISA bridge.
+	 */
+	if (bridge->vendor != PCI_VENDOR_ID_WINBOND ||
+	    bridge->device != PCI_DEVICE_ID_WINBOND_83C553 ||
+	    bridge->class >> 8 != PCI_CLASS_BRIDGE_ISA)
 		return -1;
 
 	/*
@@ -215,49 +323,55 @@ static unsigned int sl82c105_bridge_revision(struct pci_dev *dev)
  */
 static unsigned int __init sl82c105_init_chipset(struct pci_dev *dev)
 {
-	unsigned char ctrl_stat;
+	u32 val;
 
-	/*
-	 * Enable the ports
-	 */
-	pci_read_config_byte(dev, 0x40, &ctrl_stat);
-	pci_write_config_byte(dev, 0x40, ctrl_stat | 0x33);
+	pci_read_config_dword(dev, 0x40, &val);
+	val |= CTRL_P0EN | CTRL_P0F16 | CTRL_P1EN | CTRL_P1F16;
+	pci_write_config_dword(dev, 0x40, val);
 
 	return dev->irq;
 }
 
-static void __init sl82c105_init_dma(struct ata_channel *hwif, unsigned long dma_base)
+static void __init sl82c105_init_dma(struct ata_channel *ch, unsigned long dma_base)
 {
-	unsigned int rev;
+	unsigned int bridge_rev;
 	byte dma_state;
 
 	dma_state = inb(dma_base + 2);
-	rev = sl82c105_bridge_revision(hwif->pci_dev);
-	if (rev <= 5) {
-		hwif->autodma = 0;
-		hwif->drives[0].autotune = 1;
-		hwif->drives[1].autotune = 1;
+	bridge_rev = sl82c105_bridge_revision(ch->pci_dev);
+	if (bridge_rev <= 5) {
+		ch->autodma = 0;
+		ch->drives[0].autotune = 1;
+		ch->drives[1].autotune = 1;
 		printk("    %s: Winbond 553 bridge revision %d, BM-DMA disabled\n",
-		       hwif->name, rev);
+		       ch->name, bridge_rev);
 		dma_state &= ~0x60;
 	} else {
 		dma_state |= 0x60;
-		hwif->autodma = 1;
+		ch->autodma = 1;
 	}
 	outb(dma_state, dma_base + 2);
 
-	hwif->XXX_udma = NULL;
-	ata_init_dma(hwif, dma_base);
-	if (hwif->XXX_udma)
-		hwif->XXX_udma = sl82c105_dmaproc;
+	ata_init_dma(ch, dma_base);
+
+	if (bridge_rev <= 5)
+		ch->XXX_udma = NULL;
+	else {
+		ch->XXX_udma      = sl82c105_dmaproc;
+		ch->udma_enable   = sl82c105_dma_enable;
+		ch->udma_read     = sl82c105_dma_read;
+		ch->udma_write    = sl82c105_dma_write;
+		ch->udma_timeout  = sl82c105_timeout;
+		ch->udma_irq_lost = sl82c105_lostirq;
+	}
 }
 
 /*
  * Initialise the chip
  */
-static void __init sl82c105_init_channel(struct ata_channel *hwif)
+static void __init sl82c105_init_channel(struct ata_channel *ch)
 {
-	hwif->tuneproc = tune_sl82c105;
+	ch->tuneproc = tune_sl82c105;
 }
 
 
diff --git a/drivers/ide/via82cxxx.c b/drivers/ide/via82cxxx.c
index 18cf5111b4c7..2b341805ef22 100644
--- a/drivers/ide/via82cxxx.c
+++ b/drivers/ide/via82cxxx.c
@@ -105,7 +105,7 @@ static struct via_isa_bridge {
 	unsigned char rev_min;
 	unsigned char rev_max;
 	unsigned short flags;
-} via_isa_bridges[] = {
+} via_isa_bridges [] __initdata = {
 #ifdef FUTURE_BRIDGES
 	{ "vt8237",	PCI_DEVICE_ID_VIA_8237,     0x00, 0x2f, VIA_UDMA_133 },
 	{ "vt8235",	PCI_DEVICE_ID_VIA_8235,     0x00, 0x2f, VIA_UDMA_133 },
@@ -132,7 +132,6 @@ static struct via_isa_bridge {
 static struct via_isa_bridge *via_config;
 static unsigned char via_enabled;
 static unsigned int via_80w;
-static unsigned int via_clock;
 static char *via_dma[] = { "MWDMA16", "UDMA33", "UDMA66", "UDMA100", "UDMA133" };
 
 /*
@@ -175,7 +174,7 @@ static int via_get_info(char *buffer, char **addr, off_t offset, int count)
 	via_print("Highest DMA rate:                   %s", via_dma[via_config->flags & VIA_UDMA]);
 
 	via_print("BM-DMA base:                        %#x", via_base);
-	via_print("PCI clock:                          %d.%dMHz", via_clock / 1000, via_clock / 100 % 10);
+	via_print("PCI clock:                          %d.%dMHz", system_bus_speed / 1000, system_bus_speed / 100 % 10);
 
 	pci_read_config_byte(dev, VIA_MISC_1, &t);
 	via_print("Master Read  Cycle IRDY:            %dws", (t & 64) >> 6);
@@ -223,8 +222,8 @@ static int via_get_info(char *buffer, char **addr, off_t offset, int count)
 		uen[i]       = ((u >> ((3 - i) << 3)) & 0x20);
 		den[i]       = (c & ((i & 1) ? 0x40 : 0x20) << ((i & 2) << 2));
 
-		speed[i] = 2 * via_clock / (active[i] + recover[i]);
-		cycle[i] = 1000000 * (active[i] + recover[i]) / via_clock;
+		speed[i] = 2 * system_bus_speed / (active[i] + recover[i]);
+		cycle[i] = 1000000 * (active[i] + recover[i]) / system_bus_speed;
 
 		if (!uen[i] || !den[i])
 			continue;
@@ -232,34 +231,34 @@ static int via_get_info(char *buffer, char **addr, off_t offset, int count)
 		switch (via_config->flags & VIA_UDMA) {
 
 			case VIA_UDMA_33:
-				speed[i] = 2 * via_clock / udma[i];
-				cycle[i] = 1000000 * udma[i] / via_clock;
+				speed[i] = 2 * system_bus_speed / udma[i];
+				cycle[i] = 1000000 * udma[i] / system_bus_speed;
 				break;
 
 			case VIA_UDMA_66:
-				speed[i] = 4 * via_clock / (udma[i] * umul[i]);
-				cycle[i] = 500000 * (udma[i] * umul[i]) / via_clock;
+				speed[i] = 4 * system_bus_speed / (udma[i] * umul[i]);
+				cycle[i] = 500000 * (udma[i] * umul[i]) / system_bus_speed;
 				break;
 
 			case VIA_UDMA_100:
-				speed[i] = 6 * via_clock / udma[i];
-				cycle[i] = 333333 * udma[i] / via_clock;
+				speed[i] = 6 * system_bus_speed / udma[i];
+				cycle[i] = 333333 * udma[i] / system_bus_speed;
 				break;
 
 			case VIA_UDMA_133:
-				speed[i] = 8 * via_clock / udma[i];
-				cycle[i] = 250000 * udma[i] / via_clock;
+				speed[i] = 8 * system_bus_speed / udma[i];
+				cycle[i] = 250000 * udma[i] / system_bus_speed;
 				break;
 		}
 	}
 
 	via_print_drive("Transfer Mode: ", "%10s", den[i] ? (uen[i] ? "UDMA" : "DMA") : "PIO");
 
-	via_print_drive("Address Setup: ", "%8dns", 1000000 * setup[i] / via_clock);
-	via_print_drive("Cmd Active:    ", "%8dns", 1000000 * active8b[i] / via_clock);
-	via_print_drive("Cmd Recovery:  ", "%8dns", 1000000 * recover8b[i] / via_clock);
-	via_print_drive("Data Active:   ", "%8dns", 1000000 * active[i] / via_clock);
-	via_print_drive("Data Recovery: ", "%8dns", 1000000 * recover[i] / via_clock);
+	via_print_drive("Address Setup: ", "%8dns", 1000000 * setup[i] / system_bus_speed);
+	via_print_drive("Cmd Active:    ", "%8dns", 1000000 * active8b[i] / system_bus_speed);
+	via_print_drive("Cmd Recovery:  ", "%8dns", 1000000 * recover8b[i] / system_bus_speed);
+	via_print_drive("Data Active:   ", "%8dns", 1000000 * active[i] / system_bus_speed);
+	via_print_drive("Data Recovery: ", "%8dns", 1000000 * recover[i] / system_bus_speed);
 	via_print_drive("Cycle Time:    ", "%8dns", cycle[i]);
 	via_print_drive("Transfer Rate: ", "%4d.%dMB/s", speed[i] / 1000, speed[i] / 100 % 10);
 
@@ -314,7 +313,7 @@ static int via_set_drive(struct ata_device *drive, unsigned char speed)
 			printk(KERN_WARNING "ide%d: Drive %d didn't accept speed setting. Oh, well.\n",
 				drive->dn >> 1, drive->dn & 1);
 
-	T = 1000000000 / via_clock;
+	T = 1000000000 / system_bus_speed;
 
 	switch (via_config->flags & VIA_UDMA) {
 		case VIA_UDMA_33:   UT = T;   break;
@@ -470,24 +469,6 @@ static unsigned int __init via82cxxx_init_chipset(struct pci_dev *dev)
 
 	pci_write_config_byte(dev, VIA_FIFO_CONFIG, t);
 
-/*
- * Determine system bus clock.
- */
-
-	via_clock = system_bus_speed * 1000;
-
-	switch (via_clock) {
-		case 33000: via_clock = 33333; break;
-		case 37000: via_clock = 37500; break;
-		case 41000: via_clock = 41666; break;
-	}
-
-	if (via_clock < 20000 || via_clock > 50000) {
-		printk(KERN_WARNING "VP_IDE: User given PCI clock speed impossible (%d), using 33 MHz instead.\n", via_clock);
-		printk(KERN_WARNING "VP_IDE: Use ide0=ata66 if you want to assume 80-wire cable.\n");
-		via_clock = 33333;
-	}
-
 /*
  * Print the boot message.
  */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index e47e204deb5c..16b7c97aff33 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -40,9 +40,6 @@
 
 /* Right now this is only needed by a promise controlled.
  */
-#ifndef DISK_RECOVERY_TIME		/* off=0; on=access_delay_time */
-# define DISK_RECOVERY_TIME	0	/*  for hardware that needs it */
-#endif
 #ifndef OK_TO_RESET_CONTROLLER		/* 1 needed for good error recovery */
 # define OK_TO_RESET_CONTROLLER	0	/* 0 for use with AH2372A/B interface */
 #endif
@@ -202,7 +199,8 @@ typedef enum {
 	ide_cmd646,
 	ide_cy82c693,
 	ide_pmac,
-	ide_etrax100
+	ide_etrax100,
+	ide_acorn
 } hwif_chipset_t;
 
 
@@ -547,10 +545,6 @@ struct ata_channel {
 	unsigned slow		: 1;	/* flag: slow data port */
 	unsigned io_32bit	: 1;	/* 0=16-bit, 1=32-bit */
 	unsigned char bus_state;	/* power state of the IDE bus */
-
-#if (DISK_RECOVERY_TIME > 0)
-	unsigned long last_time;	/* time when previous rq was done */
-#endif
 };
 
 /*
@@ -861,6 +855,15 @@ static inline void udma_irq_lost(struct ata_device *drive)
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
 
+void udma_pci_enable(struct ata_device *drive, int on, int verbose);
+int udma_pci_start(struct ata_device *drive, struct request *rq);
+int udma_pci_stop(struct ata_device *drive);
+int udma_pci_read(struct ata_device *drive, struct request *rq);
+int udma_pci_write(struct ata_device *drive, struct request *rq);
+int udma_pci_irq_status(struct ata_device *drive);
+void udma_pci_timeout(struct ata_device *drive);
+void udma_pci_irq_lost(struct ata_device *);
+
 extern int udma_new_table(struct ata_channel *, struct request *);
 extern void udma_destroy_table(struct ata_channel *);
 extern void udma_print(struct ata_device *);
-- 
cgit v1.2.3


From 96479c1684b9818af5fbb6d4e6b3550ca1bc739d Mon Sep 17 00:00:00 2001
From: David Brownell <david-b@pacbell.net>
Date: Tue, 21 May 2002 21:46:54 -0700
Subject: [PATCH] usbcore, remove urb->next

Given the discussions of last week, this removes urb->next from
the USB core API.  This change simplifies the driver API by getting
rid of a superfluous feature (and related new-developer confusion),
gets rid of a hidden failure mode (drivers can now see resubmit
failures), lets us get rid of a HCD feature that isn't consistently
implemented, and so on.

This will break some code.  There are ISO drivers that don't use
urb->next (like audio), but most video drivers do.  My patch #2
fixes one such driver.  My patch #3 fixes host controller drivers,
most of which were already converted.
---
 drivers/usb/core/devio.c     |  1 -
 drivers/usb/core/hcd.c       |  9 ---------
 drivers/usb/core/usb-debug.c |  1 -
 include/linux/usb.h          | 13 +++++++------
 4 files changed, 7 insertions(+), 17 deletions(-)

(limited to 'include/linux')

diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 3e06620b8bef..e6217fba77ba 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -892,7 +892,6 @@ static int proc_submiturb(struct dev_state *ps, void *arg)
 		free_async(as);
 		return -ENOMEM;
 	}
-        as->urb->next = NULL;
         as->urb->dev = ps->dev;
         as->urb->pipe = (uurb.type << 30) | __create_pipe(ps->dev, uurb.endpoint & 0xf) | (uurb.endpoint & USB_DIR_IN);
         as->urb->transfer_flags = uurb.flags;
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 82fe7a7de7ab..fba95ebff001 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1407,11 +1407,6 @@ static int hcd_submit_urb (struct urb *urb, int mem_flags)
 	if (urb->transfer_buffer_length < 0)
 		return -EINVAL;
 
-	if (urb->next) {
-		warn ("use explicit queuing not urb->next");
-		return -EINVAL;
-	}
-
 #ifdef DEBUG
 	/* stuff that drivers shouldn't do, but which shouldn't
 	 * cause problems in HCDs if they get it wrong.
@@ -1785,10 +1780,6 @@ static void hcd_irq (int irq, void *__hcd, struct pt_regs * r)
  * HCDs must not use this for periodic URBs that are still scheduled
  * and will be reissued.  They should just call their completion handlers
  * until the urb is returned to the device driver by unlinking.
- *
- * NOTE that no urb->next processing is done, even for isochronous URBs.
- * ISO streaming functionality can be achieved by having completion handlers
- * re-queue URBs.  Such explicit queuing doesn't discard error reports.
  */
 void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)
 {
diff --git a/drivers/usb/core/usb-debug.c b/drivers/usb/core/usb-debug.c
index 35bebc612c47..a29393e06dcb 100644
--- a/drivers/usb/core/usb-debug.c
+++ b/drivers/usb/core/usb-debug.c
@@ -184,7 +184,6 @@ void usb_show_string(struct usb_device *dev, char *id, int index)
 void usb_dump_urb (struct urb *urb)
 {
 	printk ("urb                   :%p\n", urb);
-	printk ("next                  :%p\n", urb->next);
 	printk ("dev                   :%p\n", urb->dev);
 	printk ("pipe                  :%08X\n", urb->pipe);
 	printk ("status                :%d\n", urb->status);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 7a62399fd5e8..8e8f953ed2c7 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -767,7 +767,6 @@ typedef void (*usb_complete_t)(struct urb *);
 /**
  * struct urb - USB Request Block
  * @urb_list: For use by current owner of the URB.
- * @next: Used to link ISO requests into rings.
  * @pipe: Holds endpoint number, direction, type, and max packet size.
  *	Create these values with the eight macros available;
  *	usb_{snd,rcv}TYPEpipe(dev,endpoint), where the type is "ctrl"
@@ -827,7 +826,7 @@ typedef void (*usb_complete_t)(struct urb *);
  *
  * Initialization:
  *
- * All URBs submitted must initialize dev, pipe, next (may be null),
+ * All URBs submitted must initialize dev, pipe,
  * transfer_flags (may be zero), complete, timeout (may be zero).
  * The USB_ASYNC_UNLINK transfer flag affects later invocations of
  * the usb_unlink_urb() routine.
@@ -873,7 +872,9 @@ typedef void (*usb_complete_t)(struct urb *);
  * the quality of service is only "best effort".  Callers provide specially
  * allocated URBs, with number_of_packets worth of iso_frame_desc structures
  * at the end.  Each such packet is an individual ISO transfer.  Isochronous
- * URBs are normally submitted with urb->next fields set up as a ring, so
+ * URBs are normally queued (no flag like USB_BULK_QUEUE is needed) so that
+ * transfers are at least double buffered, and then explicitly resubmitted
+ * in completion handlers, so
  * that data (such as audio or video) streams at as constant a rate as the
  * host controller scheduler can support.
  *
@@ -891,14 +892,15 @@ typedef void (*usb_complete_t)(struct urb *);
  * When completion callback is invoked for non-isochronous URBs, the
  * actual_length field tells how many bytes were transferred.
  *
- * For interrupt and isochronous URBs, the URB provided to the callback
+ * For interrupt URBs, the URB provided to the callback
  * function is still "owned" by the USB core subsystem unless the status
  * indicates that the URB has been unlinked.  Completion handlers should
  * not modify such URBs until they have been unlinked.
  *
  * ISO transfer status is reported in the status and actual_length fields
  * of the iso_frame_desc array, and the number of errors is reported in
- * error_count.
+ * error_count.  Completion callbacks for ISO transfers will normally
+ * (re)submit URBs to ensure a constant transfer rate.
  */
 struct urb
 {
@@ -906,7 +908,6 @@ struct urb
 	atomic_t count;			/* reference count of the URB */
 	void *hcpriv;			/* private data for host controller */
 	struct list_head urb_list;	/* list pointer to all active urbs */
-	struct urb *next; 		/* (in) pointer to next URB */
 	struct usb_device *dev; 	/* (in) pointer to associated device */
 	unsigned int pipe;		/* (in) pipe information */
 	int status;			/* (return) non-ISO status */
-- 
cgit v1.2.3


From 17eb4a37572617e20ac06ef6ff096efb901b0a36 Mon Sep 17 00:00:00 2001
From: Martin Dalecki <dalecki@evision-ventures.com>
Date: Tue, 21 May 2002 21:49:08 -0700
Subject: [PATCH] 2.5.17 dquota punishment

Transform new quota code to use sysctl instead of /proc/fs.
---
 fs/dquot.c             | 92 +++++++++++++++-----------------------------------
 fs/quota.c             |  6 ++--
 fs/quota_v1.c          |  6 ++--
 fs/quota_v2.c          |  6 ++--
 include/linux/quota.h  | 26 +++++++-------
 include/linux/sysctl.h |  1 +
 6 files changed, 53 insertions(+), 84 deletions(-)

(limited to 'include/linux')

diff --git a/fs/dquot.c b/fs/dquot.c
index b585d30fee7a..0304056b4c2e 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -118,11 +118,11 @@ static void put_quota_format(struct quota_format_type *fmt)
  * list is used for the sync and invalidate operations, which must look
  * at every dquot.
  *
- * Unused dquots (dq_count == 0) are added to the free_dquots list when
- * freed, and this list is searched whenever we need an available dquot.
- * Dquots are removed from the list as soon as they are used again, and
- * nr_free_dquots gives the number of dquots on the list. When dquot is
- * invalidated it's completely released from memory.
+ * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
+ * and this list is searched whenever we need an available dquot.  Dquots are
+ * removed from the list as soon as they are used again, and
+ * dqstats_array[DQSTATS_FREE] gives the number of dquots on the list. When
+ * dquot is invalidated it's completely released from memory.
  *
  * Dquots with a specific identity (device, type and id) are placed on
  * one of the dquot_hash[] hash chains. The provides an efficient search
@@ -148,7 +148,7 @@ static LIST_HEAD(inuse_list);
 static LIST_HEAD(free_dquots);
 static struct list_head dquot_hash[NR_DQHASH];
 
-struct dqstats dqstats;
+__u32 dqstats_array[DQSTATS_SIZE];
 
 static void dqput(struct dquot *);
 static struct dquot *dqduplicate(struct dquot *);
@@ -207,14 +207,14 @@ static inline struct dquot *find_dquot(unsigned int hashent, struct super_block
 static inline void put_dquot_head(struct dquot *dquot)
 {
 	list_add(&dquot->dq_free, &free_dquots);
-	nr_free_dquots++;
+	++dqstats_array[DQSTATS_FREE];
 }
 
 /* Add a dquot to the tail of the free list */
 static inline void put_dquot_last(struct dquot *dquot)
 {
 	list_add(&dquot->dq_free, free_dquots.prev);
-	nr_free_dquots++;
+	++dqstats_array[DQSTATS_FREE];
 }
 
 /* Move dquot to the head of free list (it must be already on it) */
@@ -230,7 +230,7 @@ static inline void remove_free_dquot(struct dquot *dquot)
 		return;
 	list_del(&dquot->dq_free);
 	INIT_LIST_HEAD(&dquot->dq_free);
-	nr_free_dquots--;
+	--dqstats_array[DQSTATS_FREE];
 }
 
 static inline void put_inuse(struct dquot *dquot)
@@ -238,12 +238,12 @@ static inline void put_inuse(struct dquot *dquot)
 	/* We add to the back of inuse list so we don't have to restart
 	 * when traversing this list and we block */
 	list_add(&dquot->dq_inuse, inuse_list.prev);
-	nr_dquots++;
+	++dqstats_array[DQSTATS_ALLOCATED];
 }
 
 static inline void remove_inuse(struct dquot *dquot)
 {
-	nr_dquots--;
+	--dqstats_array[DQSTATS_ALLOCATED];
 	list_del(&dquot->dq_inuse);
 }
 
@@ -403,7 +403,8 @@ restart:
 	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
 		if ((cnt == type || type == -1) && sb_has_quota_enabled(sb, cnt) && info_dirty(&dqopt->info[cnt]))
 			dqopt->ops[cnt]->write_file_info(sb, cnt);
-	dqstats.syncs++;
+	++dqstats_array[DQSTATS_SYNCS];
+
 	return 0;
 }
 
@@ -490,7 +491,7 @@ int shrink_dqcache_memory(int priority, unsigned int gfp_mask)
 	int count = 0;
 
 	lock_kernel();
-	count = nr_free_dquots / priority;
+	count = dqstats_array[DQSTATS_FREE] / priority;
 	prune_dqcache(count);
 	unlock_kernel();
 	kmem_cache_shrink(dquot_cachep);
@@ -516,7 +517,7 @@ static void dqput(struct dquot *dquot)
 	}
 #endif
 
-	dqstats.drops++;
+	++dqstats_array[DQSTATS_DROPS];
 we_slept:
 	if (dquot->dq_dup_ref && dquot->dq_count - dquot->dq_dup_ref <= 1) {	/* Last unduplicated reference? */
 		__wait_dup_drop(dquot);
@@ -588,15 +589,15 @@ we_slept:
 			goto we_slept;
 		}
 		dquot = empty;
-        	dquot->dq_id = id;
+		dquot->dq_id = id;
 		/* hash it first so it can be found */
 		insert_dquot_hash(dquot);
-        	read_dqblk(dquot);
+		read_dqblk(dquot);
 	} else {
 		if (!dquot->dq_count)
 			remove_free_dquot(dquot);
 		get_dquot_ref(dquot);
-		dqstats.cache_hits++;
+		++dqstats_array[DQSTATS_CACHE_HITS];
 		wait_on_dquot(dquot);
 		if (empty)
 			dqput(empty);
@@ -607,8 +608,8 @@ we_slept:
 		dqput(dquot);
 		return NODQUOT;
 	}
-	dquot->dq_referenced++;
-	dqstats.lookups++;
+	++dquot->dq_referenced;
+	++dqstats_array[DQSTATS_LOOKUPS];
 
 	return dquot;
 }
@@ -628,7 +629,8 @@ static struct dquot *dqduplicate(struct dquot *dquot)
 		printk(KERN_ERR "VFS: dqduplicate(): Locked quota to be duplicated!\n");
 	get_dquot_dup_ref(dquot);
 	dquot->dq_referenced++;
-	dqstats.lookups++;
+	++dqstats_array[DQSTATS_LOOKUPS];
+
 	return dquot;
 }
 
@@ -643,7 +645,7 @@ static void dqputduplicate(struct dquot *dquot)
 	if (!dquot->dq_dup_ref)
 		wake_up(&dquot->dq_wait_free);
 	put_dquot_ref(dquot);
-	dqstats.drops++;
+	++dqstats_array[DQSTATS_DROPS];
 }
 
 static int dqinit_needed(struct inode *inode, int type)
@@ -1277,7 +1279,7 @@ int vfs_quota_off(struct super_block *sb, int type)
 		dqopt->info[cnt].dqi_igrace = 0;
 		dqopt->info[cnt].dqi_bgrace = 0;
 		dqopt->ops[cnt] = NULL;
-	}	
+	}
 	up(&dqopt->dqoff_sem);
 out:
 	unlock_kernel();
@@ -1461,41 +1463,6 @@ int vfs_set_info(struct super_block *sb, int type, struct if_dqinfo *ii)
 	return 0;
 }
 
-#ifdef CONFIG_PROC_FS
-static int read_stats(char *buffer, char **start, off_t offset, int count, int *eof, void *data)
-{
-	int len;
-	struct quota_format_type *actqf;
-
-	dqstats.allocated_dquots = nr_dquots;
-	dqstats.free_dquots = nr_free_dquots;
-
-	len = sprintf(buffer, "Version %u\n", __DQUOT_NUM_VERSION__);
-	len += sprintf(buffer + len, "Formats");
-	lock_kernel();
-	for (actqf = quota_formats; actqf; actqf = actqf->qf_next)
-		len += sprintf(buffer + len, " %u", actqf->qf_fmt_id);
-	unlock_kernel();
-	len += sprintf(buffer + len, "\n%u %u %u %u %u %u %u %u\n",
-			dqstats.lookups, dqstats.drops,
-			dqstats.reads, dqstats.writes,
-			dqstats.cache_hits, dqstats.allocated_dquots,
-			dqstats.free_dquots, dqstats.syncs);
-
-	if (offset >= len) {
-		*start = buffer;
-		*eof = 1;
-		return 0;
-	}
-	*start = buffer + offset;
-	if ((len -= offset) > count)
-		return count;
-	*eof = 1;
-
-	return len;
-}
-#endif
-
 struct quotactl_ops vfs_quotactl_ops = {
 	quota_on:	vfs_quota_on,
 	quota_off:	vfs_quota_off,
@@ -1507,8 +1474,7 @@ struct quotactl_ops vfs_quotactl_ops = {
 };
 
 static ctl_table fs_table[] = {
-	{FS_NRDQUOT, "dquot-nr", &nr_dquots, 2*sizeof(int),
-	 0444, NULL, &proc_dointvec},
+	{FS_DQSTATS, "dqstats", dqstats_array, sizeof(dqstats_array), 0444, NULL, &proc_dointvec},
 	{},
 };
 
@@ -1524,14 +1490,12 @@ static int __init dquot_init(void)
 	register_sysctl_table(dquot_table, 0);
 	for (i = 0; i < NR_DQHASH; i++)
 		INIT_LIST_HEAD(dquot_hash + i);
-	printk(KERN_NOTICE "VFS: Diskquotas version %s initialized\n", __DQUOT_VERSION__);
-#ifdef CONFIG_PROC_FS
-	create_proc_read_entry("fs/quota", 0, 0, read_stats, NULL);
-#endif
+	printk(KERN_NOTICE "VFS: Disk quotas v%s\n", __DQUOT_VERSION__);
+
 	return 0;
 }
 __initcall(dquot_init);
 
 EXPORT_SYMBOL(register_quota_format);
 EXPORT_SYMBOL(unregister_quota_format);
-EXPORT_SYMBOL(dqstats);
+EXPORT_SYMBOL(dqstats_array);
diff --git a/fs/quota.c b/fs/quota.c
index 45ef892edc5c..e877afd9a9e2 100644
--- a/fs/quota.c
+++ b/fs/quota.c
@@ -16,8 +16,6 @@
 #endif
 
 
-int nr_dquots, nr_free_dquots;
-
 /* Check validity of quotactl */
 static int check_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id)
 {
@@ -411,7 +409,7 @@ static int v1_set_dqblk(struct super_block *sb, int type, int cmd, qid_t id, str
 
 static void v1_get_stats(struct v1c_dqstats *dst)
 {
-	memcpy(dst, &dqstats, sizeof(dqstats));
+	memcpy(dst, &dqstats_array, sizeof(dqstats_array));
 }
 #endif
 
@@ -490,7 +488,7 @@ static int v2_set_dqblk(struct super_block *sb, int type, int cmd, qid_t id, str
 
 static void v2_get_stats(struct v2c_dqstats *dst)
 {
-	memcpy(dst, &dqstats, sizeof(dqstats));
+	memcpy(dst, &dqstats_array, sizeof(dqstats_array));
 	dst->version = __DQUOT_NUM_VERSION__;
 }
 #endif
diff --git a/fs/quota_v1.c b/fs/quota_v1.c
index aa3b7842399d..455238c7d584 100644
--- a/fs/quota_v1.c
+++ b/fs/quota_v1.c
@@ -57,7 +57,8 @@ static int v1_read_dqblk(struct dquot *dquot)
 	if (dquot->dq_dqb.dqb_bhardlimit == 0 && dquot->dq_dqb.dqb_bsoftlimit == 0 &&
 	    dquot->dq_dqb.dqb_ihardlimit == 0 && dquot->dq_dqb.dqb_isoftlimit == 0)
 		dquot->dq_flags |= DQ_FAKE;
-	dqstats.reads++;
+	++dqstats_array[DQSTATS_READS];
+
 	return 0;
 }
 
@@ -100,7 +101,8 @@ static int v1_commit_dqblk(struct dquot *dquot)
 
 out:
 	set_fs(fs);
-	dqstats.writes++;
+	++dqstats_array[DQSTATS_WRITES];
+
 	return ret;
 }
 
diff --git a/fs/quota_v2.c b/fs/quota_v2.c
index e28bee8c52ab..23c9d09c0302 100644
--- a/fs/quota_v2.c
+++ b/fs/quota_v2.c
@@ -430,7 +430,8 @@ static int v2_write_dquot(struct dquot *dquot)
 	}
 	else
 		ret = 0;
-	dqstats.writes++;
+	++dqstats_array[DQSTATS_WRITES];
+
 	return ret;
 }
 
@@ -644,7 +645,8 @@ static int v2_read_dquot(struct dquot *dquot)
 		set_fs(fs);
 		disk2memdqb(&dquot->dq_dqb, &ddquot);
 	}
-	dqstats.reads++;
+	++dqstats_array[DQSTATS_READS];
+
 	return ret;
 }
 
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 0a36a5e59caf..1a9d178c57bc 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -184,20 +184,22 @@ extern inline void mark_info_dirty(struct mem_dqinfo *info)
 
 #define sb_dqopt(sb) (&(sb)->s_dquot)
 
-extern int nr_dquots, nr_free_dquots;
-
-struct dqstats {
-	__u32 lookups;
-	__u32 drops;
-	__u32 reads;
-	__u32 writes;
-	__u32 cache_hits;
-	__u32 allocated_dquots;
-	__u32 free_dquots;
-	__u32 syncs;
+/*
+ * Statistics about disc quota.
+ */
+enum {
+	DQSTATS_LOOKUPS,
+	DQSTATS_DROPS,
+	DQSTATS_READS,
+	DQSTATS_WRITES,
+	DQSTATS_CACHE_HITS,
+	DQSTATS_ALLOCATED,
+	DQSTATS_FREE,
+	DQSTATS_SYNCS,
+	DQSTATS_SIZE
 };
 
-extern struct dqstats dqstats;
+extern __u32 dqstats_array[DQSTATS_SIZE];
 
 #define NR_DQHASH 43            /* Just an arbitrary number */
 
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 2f25df04d925..373d20b4c4a7 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -544,6 +544,7 @@ enum
 	FS_LEASES=13,	/* int: leases enabled */
 	FS_DIR_NOTIFY=14,	/* int: directory notification enabled */
 	FS_LEASE_TIME=15,	/* int: maximum time to wait for a lease break */
+	FS_DQSTATS=16,	/* int: disc quota suage statistics */
 };
 
 /* CTL_DEBUG names: */
-- 
cgit v1.2.3


From 26d7de1889cd9af635e5e8d9f515537ea3871d26 Mon Sep 17 00:00:00 2001
From: Christoph Hellwig <hch@infradead.org>
Date: Tue, 21 May 2002 21:50:24 -0700
Subject: [PATCH] split namei.h out of fs.h

Currently fs.h is full of unrelated declarations and included in almost
any source file. Thus it makes sense to spilt certain aspects out that are
only used by few users.

This patch starts with the namei/path lookup interface and splits it into
<linux/namei.h> which is now directly included by the 24 files that actually
need it.
---
 drivers/usb/core/inode.c |  1 +
 fs/autofs/dirhash.c      |  2 ++
 fs/binfmt_misc.c         |  1 +
 fs/coda/pioctl.c         |  1 +
 fs/driverfs/inode.c      |  1 +
 fs/exec.c                |  1 +
 fs/exportfs/expfs.c      |  1 +
 fs/namei.c               |  1 +
 fs/namespace.c           |  1 +
 fs/nfs/dir.c             |  1 +
 fs/nfsctl.c              |  1 +
 fs/nfsd/export.c         |  1 +
 fs/nfsd/nfs3xdr.c        |  2 ++
 fs/nfsd/nfsproc.c        |  1 +
 fs/nfsd/vfs.c            |  1 +
 fs/open.c                |  1 +
 fs/proc/base.c           |  1 +
 fs/quota.c               |  1 +
 fs/stat.c                |  1 +
 fs/super.c               |  1 +
 fs/xattr.c               |  1 +
 include/linux/fs.h       | 46 +--------------------------------------
 include/linux/namei.h    | 56 ++++++++++++++++++++++++++++++++++++++++++++++++
 kernel/ksyms.c           |  1 +
 mm/swapfile.c            |  1 +
 net/unix/af_unix.c       |  1 +
 26 files changed, 83 insertions(+), 45 deletions(-)
 create mode 100644 include/linux/namei.h

(limited to 'include/linux')

diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 73527b766d81..5b7fac56a9a7 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/usb.h>
+#include <linux/namei.h>
 #include <linux/usbdevice_fs.h>
 #include <linux/smp_lock.h>
 #include <asm/byteorder.h>
diff --git a/fs/autofs/dirhash.c b/fs/autofs/dirhash.c
index 448143fd0796..6b0a3595db05 100644
--- a/fs/autofs/dirhash.c
+++ b/fs/autofs/dirhash.c
@@ -10,6 +10,8 @@
  *
  * ------------------------------------------------------------------------- */
 
+#include <linux/dcache.h>
+#include <linux/namei.h>
 #include "autofs_i.h"
 
 /* Functions for maintenance of expiry queue */
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 49e76ddda8cc..926ff80a8bcc 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -24,6 +24,7 @@
 #include <linux/ctype.h>
 #include <linux/file.h>
 #include <linux/pagemap.h>
+#include <linux/namei.h>
 
 #include <asm/uaccess.h>
 
diff --git a/fs/coda/pioctl.c b/fs/coda/pioctl.c
index 53f4d2c714dc..e4633745e1e5 100644
--- a/fs/coda/pioctl.c
+++ b/fs/coda/pioctl.c
@@ -15,6 +15,7 @@
 #include <linux/errno.h>
 #include <linux/string.h>
 #define __NO_VERSION__
+#include <linux/namei.h>
 #include <linux/module.h>
 #include <asm/uaccess.h>
 
diff --git a/fs/driverfs/inode.c b/fs/driverfs/inode.c
index 438dc6fa38ff..5de6cd337e74 100644
--- a/fs/driverfs/inode.c
+++ b/fs/driverfs/inode.c
@@ -29,6 +29,7 @@
 #include <linux/stat.h>
 #include <linux/fs.h>
 #include <linux/dcache.h>
+#include <linux/namei.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/device.h>
diff --git a/fs/exec.c b/fs/exec.c
index e7e4da3c3a8d..532d18eadc3e 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -38,6 +38,7 @@
 #include <linux/binfmts.h>
 #define __NO_VERSION__
 #include <linux/module.h>
+#include <linux/namei.h>
 
 #include <asm/uaccess.h>
 #include <asm/pgalloc.h>
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 9046e59def5e..3a3e2ffdfe48 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -2,6 +2,7 @@
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/smp_lock.h>
+#include <linux/namei.h>
 
 struct export_operations export_op_default;
 
diff --git a/fs/namei.c b/fs/namei.c
index 8ed094ea90b0..5b6e0cf59ec8 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -17,6 +17,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
+#include <linux/namei.h>
 #include <linux/quotaops.h>
 #include <linux/pagemap.h>
 #include <linux/dnotify.h>
diff --git a/fs/namespace.c b/fs/namespace.c
index 1225bac1bafa..64515aa0025e 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/seq_file.h>
 #include <linux/namespace.h>
+#include <linux/namei.h>
 
 #include <asm/uaccess.h>
 
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 31d58c25914f..40c622741d69 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -30,6 +30,7 @@
 #include <linux/nfs_mount.h>
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
+#include <linux/namei.h>
 
 #define NFS_PARANOIA 1
 /* #define NFS_DEBUG_VERBOSE 1 */
diff --git a/fs/nfsctl.c b/fs/nfsctl.c
index 99afff5ad4ce..42a0d1125f49 100644
--- a/fs/nfsctl.c
+++ b/fs/nfsctl.c
@@ -11,6 +11,7 @@
 #include <linux/nfsd/nfsd.h>
 #include <linux/nfsd/syscall.h>
 #include <linux/linkage.h>
+#include <linux/namei.h>
 #include <asm/uaccess.h>
 
 /*
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 936781bb107b..1ccea370c9aa 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -21,6 +21,7 @@
 #include <linux/in.h>
 #include <linux/seq_file.h>
 #include <linux/rwsem.h>
+#include <linux/namei.h>
 
 #include <linux/sunrpc/svc.h>
 #include <linux/nfsd/nfsd.h>
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index 20b86a0e79df..b5994d6b36cf 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -9,6 +9,8 @@
 #include <linux/types.h>
 #include <linux/time.h>
 #include <linux/nfs3.h>
+#include <linux/dcache.h>
+#include <linux/namei.h>
 
 #include <linux/sunrpc/xdr.h>
 #include <linux/sunrpc/svc.h>
diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
index 5527f0d6b5d4..139a76099c7d 100644
--- a/fs/nfsd/nfsproc.c
+++ b/fs/nfsd/nfsproc.c
@@ -15,6 +15,7 @@
 #include <linux/fcntl.h>
 #include <linux/net.h>
 #include <linux/in.h>
+#include <linux/namei.h>
 #include <linux/version.h>
 #include <linux/unistd.h>
 #include <linux/slab.h>
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index b9d0bbfb333a..02419edd0250 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -32,6 +32,7 @@
 #include <linux/in.h>
 #define __NO_VERSION__
 #include <linux/module.h>
+#include <linux/namei.h>
 
 #include <linux/sunrpc/svc.h>
 #include <linux/nfsd/nfsd.h>
diff --git a/fs/open.c b/fs/open.c
index 2ef917feadb7..55f8b0083f0d 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -15,6 +15,7 @@
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/iobuf.h>
+#include <linux/namei.h>
 #include <linux/backing-dev.h>
 
 #include <asm/uaccess.h>
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 4e839bd9eade..c8a80b066a72 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -24,6 +24,7 @@
 #include <linux/file.h>
 #include <linux/string.h>
 #include <linux/seq_file.h>
+#include <linux/namei.h>
 #include <linux/namespace.h>
 #include <linux/mm.h>
 #include <linux/smp_lock.h>
diff --git a/fs/quota.c b/fs/quota.c
index e877afd9a9e2..422e4cf7ce12 100644
--- a/fs/quota.c
+++ b/fs/quota.c
@@ -11,6 +11,7 @@
 #include <asm/uaccess.h>
 #include <linux/kernel.h>
 #include <linux/smp_lock.h>
+#include <linux/namei.h>
 #ifdef CONFIG_QIFACE_COMPAT
 #include <linux/quotacompat.h>
 #endif
diff --git a/fs/stat.c b/fs/stat.c
index a09b7f6abd73..3f963e9d9c93 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -11,6 +11,7 @@
 #include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/fs.h>
+#include <linux/namei.h>
 
 #include <asm/uaccess.h>
 
diff --git a/fs/super.c b/fs/super.c
index 13f1b7a7e34d..1d45d67fc611 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -27,6 +27,7 @@
 #include <linux/acct.h>
 #include <linux/blkdev.h>
 #include <linux/quotaops.h>
+#include <linux/namei.h>
 #include <asm/uaccess.h>
 
 void get_filesystem(struct file_system_type *fs);
diff --git a/fs/xattr.c b/fs/xattr.c
index 20a7f5b049f9..387d7dc74fe5 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -12,6 +12,7 @@
 #include <linux/smp_lock.h>
 #include <linux/file.h>
 #include <linux/xattr.h>
+#include <linux/namei.h>
 #include <asm/uaccess.h>
 
 /*
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 0f2ae2f148e6..95cd02771592 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -27,6 +27,7 @@
 #include <asm/atomic.h>
 
 struct poll_table_struct;
+struct nameidata;
 
 
 /*
@@ -605,16 +606,6 @@ extern void kill_fasync(struct fasync_struct **, int, int);
 /* only for net: no internal synchronization */
 extern void __kill_fasync(struct fasync_struct *, int, int);
 
-struct nameidata {
-	struct dentry *dentry;
-	struct vfsmount *mnt;
-	struct qstr last;
-	unsigned int flags;
-	int last_type;
-	struct dentry *old_dentry;
-	struct vfsmount *old_mnt;
-};
-
 /*
  *	Umount options
  */
@@ -707,9 +698,6 @@ extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 
-extern struct dentry *lock_rename(struct dentry *, struct dentry *);
-extern void unlock_rename(struct dentry *, struct dentry *);
-
 /*
  * File types
  */
@@ -1166,25 +1154,6 @@ extern ino_t find_inode_number(struct dentry *, struct qstr *);
 
 #include <linux/err.h>
 
-/*
- * The bitmask for a lookup event:
- *  - follow links at the end
- *  - require a directory
- *  - ending slashes ok even for nonexistent files
- *  - internal "there are more path compnents" flag
- *  - locked when lookup done with dcache_lock held
- */
-#define LOOKUP_FOLLOW		(1)
-#define LOOKUP_DIRECTORY	(2)
-#define LOOKUP_CONTINUE		(4)
-#define LOOKUP_PARENT		(16)
-#define LOOKUP_NOALT		(32)
-
-/*
- * Type of the last component on LOOKUP_PARENT
- */
-enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
-
 /*
  * "descriptor" for what we're up to with a read for sendfile().
  * This allows us to use the same read code yet
@@ -1206,19 +1175,6 @@ typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, u
 /* needed for stackable file system support */
 extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
 
-extern int FASTCALL(__user_walk(const char *, unsigned, struct nameidata *));
-extern int FASTCALL(path_init(const char *, unsigned, struct nameidata *));
-extern int FASTCALL(path_walk(const char *, struct nameidata *));
-extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
-extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
-extern void path_release(struct nameidata *);
-extern int follow_down(struct vfsmount **, struct dentry **);
-extern int follow_up(struct vfsmount **, struct dentry **);
-extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
-extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
-#define user_path_walk(name,nd)	 __user_walk(name, LOOKUP_FOLLOW, nd)
-#define user_path_walk_link(name,nd) __user_walk(name, 0, nd)
-
 extern void inode_init_once(struct inode *);
 extern void iput(struct inode *);
 extern void force_delete(struct inode *);
diff --git a/include/linux/namei.h b/include/linux/namei.h
new file mode 100644
index 000000000000..2c789cf0d4fc
--- /dev/null
+++ b/include/linux/namei.h
@@ -0,0 +1,56 @@
+#ifndef _LINUX_NAMEI_H
+#define _LINUX_NAMEI_H
+
+struct vfsmount;
+
+struct nameidata {
+	struct dentry	*dentry;
+	struct vfsmount *mnt;
+	struct qstr	last;
+	unsigned int	flags;
+	int		last_type;
+	struct dentry	*old_dentry;
+	struct vfsmount	*old_mnt;
+};
+
+/*
+ * Type of the last component on LOOKUP_PARENT
+ */
+enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
+
+/*
+ * The bitmask for a lookup event:
+ *  - follow links at the end
+ *  - require a directory
+ *  - ending slashes ok even for nonexistent files
+ *  - internal "there are more path compnents" flag
+ *  - locked when lookup done with dcache_lock held
+ */
+#define LOOKUP_FOLLOW		 1
+#define LOOKUP_DIRECTORY	 2
+#define LOOKUP_CONTINUE		 4
+#define LOOKUP_PARENT		16
+#define LOOKUP_NOALT		32
+
+
+extern int FASTCALL(__user_walk(const char *, unsigned, struct nameidata *));
+#define user_path_walk(name,nd) \
+	__user_walk(name, LOOKUP_FOLLOW, nd)
+#define user_path_walk_link(name,nd) \
+	__user_walk(name, 0, nd)
+extern int FASTCALL(path_init(const char *, unsigned, struct nameidata *));
+extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
+extern int FASTCALL(path_walk(const char *, struct nameidata *));
+extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
+extern void path_release(struct nameidata *);
+
+extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
+extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
+
+extern int follow_down(struct vfsmount **, struct dentry **);
+extern int follow_up(struct vfsmount **, struct dentry **);
+
+extern struct dentry *lock_rename(struct dentry *, struct dentry *);
+extern void unlock_rename(struct dentry *, struct dentry *);
+
+#endif /* _LINUX_NAMEI_H */
diff --git a/kernel/ksyms.c b/kernel/ksyms.c
index 9b1201822582..9c38804e4694 100644
--- a/kernel/ksyms.c
+++ b/kernel/ksyms.c
@@ -47,6 +47,7 @@
 #include <linux/completion.h>
 #include <linux/seq_file.h>
 #include <linux/binfmts.h>
+#include <linux/namei.h>
 #include <asm/checksum.h>
 
 #if defined(CONFIG_PROC_FS)
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 504c34fbbaf0..a1fe966321e7 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -13,6 +13,7 @@
 #include <linux/swapctl.h>
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
+#include <linux/namei.h>
 #include <linux/shm.h>
 #include <linux/blkdev.h>
 #include <linux/compiler.h>
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 2891751d9b5f..bd6fb1b8f9f2 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -88,6 +88,7 @@
 #include <linux/errno.h>
 #include <linux/string.h>
 #include <linux/stat.h>
+#include <linux/namei.h>
 #include <linux/socket.h>
 #include <linux/un.h>
 #include <linux/fcntl.h>
-- 
cgit v1.2.3


From 190cd5e56e8416f60e158ac1ad884d5e13cdf5f1 Mon Sep 17 00:00:00 2001
From: Rusty Russell <rusty@rustcorp.com.au>
Date: Tue, 21 May 2002 22:23:11 -0700
Subject: [PATCH] min/max elimination in netfilter.h

Rusty Russell <rusty@rustcorp.com.au>: Trivial patch to remove minmax macros:
  Hi Harald,
  	The MIN & MAX etc. macros aren't used anywhere, and kernel.h
  has the new min & max anyway, which should be used.

  Cheers,
  Rusty.
---
 include/linux/netfilter.h | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'include/linux')

diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 46c2b72e33f3..5899abd26a44 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -158,26 +158,5 @@ extern void nf_invalidate_cache(int pf);
 #define NF_HOOK(pf, hook, skb, indev, outdev, okfn) (okfn)(skb)
 #endif /*CONFIG_NETFILTER*/
 
-/* From arch/i386/kernel/smp.c:
- *
- *	Why isn't this somewhere standard ??
- *
- * Maybe because this procedure is horribly buggy, and does
- * not deserve to live.  Think about signedness issues for five
- * seconds to see why.		- Linus
- */
-
-/* Two signed, return a signed. */
-#define SMAX(a,b) ((ssize_t)(a)>(ssize_t)(b) ? (ssize_t)(a) : (ssize_t)(b))
-#define SMIN(a,b) ((ssize_t)(a)<(ssize_t)(b) ? (ssize_t)(a) : (ssize_t)(b))
-
-/* Two unsigned, return an unsigned. */
-#define UMAX(a,b) ((size_t)(a)>(size_t)(b) ? (size_t)(a) : (size_t)(b))
-#define UMIN(a,b) ((size_t)(a)<(size_t)(b) ? (size_t)(a) : (size_t)(b))
-
-/* Two unsigned, return a signed. */
-#define SUMAX(a,b) ((size_t)(a)>(size_t)(b) ? (ssize_t)(a) : (ssize_t)(b))
-#define SUMIN(a,b) ((size_t)(a)<(size_t)(b) ? (ssize_t)(a) : (ssize_t)(b))
 #endif /*__KERNEL__*/
-
 #endif /*__LINUX_NETFILTER_H*/
-- 
cgit v1.2.3


From a58a8db0f4be44d14283b337b07e30f7ed26d474 Mon Sep 17 00:00:00 2001
From: Rusty Russell <rusty@rustcorp.com.au>
Date: Tue, 21 May 2002 22:24:15 -0700
Subject: [PATCH] jiffies.h

Trivial patch update against 2.5.17:
Tim Schmielau <tim@physik3.uni-rostock.de>: move jiffies from sched.h to it's own jiffies.h:
  Move 'jiffies' from sched.h to their own header.
  Then pull the sched.h dependency from 67 files that include sched.h for
  no apparent reason other than the jiffies declaration.

  Move the time_[before,after}{_eq}() macros from timer.h to jiffies.h,
  since there are *no* files using them that don't also use jiffies.

  Many more sched.h dependencies can be killed after capable(),
  request_irq(), and free_irq() are moved out of <linux/sched.h>.


  Tim Schmielau <tim@physik3.uni-rostock.de>
---
 Documentation/DocBook/procfs_example.c     |  2 +-
 arch/i386/kernel/bluesmoke.c               |  2 +-
 arch/ia64/kernel/irq_ia64.c                |  2 +-
 arch/ia64/sn/kernel/mca.c                  |  2 +-
 arch/m68k/amiga/amisound.c                 |  2 +-
 arch/m68k/amiga/pcmcia.c                   |  2 +-
 arch/m68k/apollo/dn_ints.c                 |  2 +-
 arch/mips/jazz/reset.c                     |  2 +-
 arch/ppc/kernel/temp.c                     |  2 +-
 arch/sparc64/kernel/central.c              |  2 +-
 arch/x86_64/kernel/bluesmoke.c             |  2 +-
 drivers/atm/suni.c                         |  2 +-
 drivers/char/agp/agpgart_be.c              |  2 +-
 drivers/char/drm/drmP.h                    |  2 +-
 drivers/char/ftape/lowlevel/ftape-calibr.c |  2 +-
 drivers/char/machzwd.c                     |  2 +-
 drivers/char/sbc60xxwdt.c                  |  2 +-
 drivers/char/w83877f_wdt.c                 |  2 +-
 drivers/fc4/fc.c                           |  2 +-
 drivers/ide/ide-pmac.c                     |  2 +-
 drivers/message/i2o/i2o_scsi.c             |  2 +-
 drivers/mtd/ftl.c                          |  2 +-
 drivers/net/8390.c                         |  2 +-
 drivers/net/atari_bionet.c                 |  2 +-
 drivers/net/atari_pamsnet.c                |  2 +-
 drivers/net/auto_irq.c                     |  2 +-
 drivers/net/ethertap.c                     |  2 +-
 drivers/net/loopback.c                     |  2 +-
 drivers/net/wan/comx-proto-fr.c            |  2 +-
 drivers/net/wan/comx-proto-ppp.c           |  2 +-
 drivers/net/wan/comx.c                     |  2 +-
 drivers/net/wan/hd6457x.c                  |  2 +-
 drivers/net/wan/sdladrv.c                  |  2 +-
 drivers/scsi/i60uscsi.c                    |  2 +-
 drivers/scsi/i91uscsi.c                    |  2 +-
 drivers/usb/host/usb-uhci-hcd.c            |  2 +-
 drivers/usb/net/cdc-ether.c                |  2 +-
 drivers/usb/storage/isd200.c               |  2 +-
 drivers/usb/storage/sddr55.c               |  2 +-
 fs/vfat/namei.c                            |  2 +-
 include/linux/jiffies.h                    | 30 ++++++++++++++++++++++++++++++
 include/linux/sched.h                      |  7 +------
 include/linux/timer.h                      | 19 -------------------
 include/net/inetpeer.h                     |  2 +-
 net/802/tr.c                               |  2 +-
 net/ax25/ax25_ds_timer.c                   |  2 +-
 net/ax25/ax25_timer.c                      |  2 +-
 net/core/profile.c                         |  2 +-
 net/core/utils.c                           |  2 +-
 net/ipv4/fib_semantics.c                   |  2 +-
 net/ipv4/icmp.c                            |  2 +-
 net/ipv4/igmp.c                            |  2 +-
 net/ipv4/ip_fragment.c                     |  2 +-
 net/ipv4/ipconfig.c                        |  2 +-
 net/ipv6/mcast.c                           |  2 +-
 net/ipv6/reassembly.c                      |  2 +-
 net/ipv6/tcp_ipv6.c                        |  2 +-
 net/lapb/lapb_iface.c                      |  2 +-
 net/lapb/lapb_timer.c                      |  2 +-
 net/netrom/nr_timer.c                      |  2 +-
 net/rose/rose_link.c                       |  2 +-
 net/rose/rose_timer.c                      |  2 +-
 net/sched/estimator.c                      |  2 +-
 net/sched/sch_csz.c                        |  2 +-
 net/sched/sch_sfq.c                        |  2 +-
 net/sched/sch_tbf.c                        |  2 +-
 net/x25/x25_link.c                         |  2 +-
 net/x25/x25_timer.c                        |  2 +-
 sound/drivers/dummy.c                      |  2 +-
 sound/oss/emu10k1/cardmi.c                 |  2 +-
 70 files changed, 98 insertions(+), 92 deletions(-)
 create mode 100644 include/linux/jiffies.h

(limited to 'include/linux')

diff --git a/Documentation/DocBook/procfs_example.c b/Documentation/DocBook/procfs_example.c
index 4b46e0e003fb..ed786f64da2e 100644
--- a/Documentation/DocBook/procfs_example.c
+++ b/Documentation/DocBook/procfs_example.c
@@ -47,7 +47,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <asm/uaccess.h>
 
 
diff --git a/arch/i386/kernel/bluesmoke.c b/arch/i386/kernel/bluesmoke.c
index 11f8296919b8..84933b92e7f5 100644
--- a/arch/i386/kernel/bluesmoke.c
+++ b/arch/i386/kernel/bluesmoke.c
@@ -5,7 +5,7 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/smp.h>
 #include <linux/config.h>
 #include <linux/irq.h>
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index fe2ef585b493..615cbbb59536 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -14,7 +14,7 @@
 
 #include <linux/config.h>
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
diff --git a/arch/ia64/sn/kernel/mca.c b/arch/ia64/sn/kernel/mca.c
index 02a14c3f9b00..5b3e0e1e9fd1 100644
--- a/arch/ia64/sn/kernel/mca.c
+++ b/arch/ia64/sn/kernel/mca.c
@@ -35,7 +35,7 @@
 
 #include <linux/types.h>
 #include <linux/init.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/threads.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
diff --git a/arch/m68k/amiga/amisound.c b/arch/m68k/amiga/amisound.c
index fd110d2d990c..efec739136fe 100644
--- a/arch/m68k/amiga/amisound.c
+++ b/arch/m68k/amiga/amisound.c
@@ -9,7 +9,7 @@
  */
 
 #include <linux/config.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/init.h>
 
diff --git a/arch/m68k/amiga/pcmcia.c b/arch/m68k/amiga/pcmcia.c
index e503a5a9533a..fc57c6e72acf 100644
--- a/arch/m68k/amiga/pcmcia.c
+++ b/arch/m68k/amiga/pcmcia.c
@@ -13,7 +13,7 @@
 */
 
 #include <linux/types.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <asm/amigayle.h>
 #include <asm/amipcmcia.h>
diff --git a/arch/m68k/apollo/dn_ints.c b/arch/m68k/apollo/dn_ints.c
index 95097695d6ef..18184bcd9c2d 100644
--- a/arch/m68k/apollo/dn_ints.c
+++ b/arch/m68k/apollo/dn_ints.c
@@ -1,6 +1,6 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/kernel_stat.h>
 
 #include <asm/system.h>
diff --git a/arch/mips/jazz/reset.c b/arch/mips/jazz/reset.c
index f1aac5388ad3..b930afed303d 100644
--- a/arch/mips/jazz/reset.c
+++ b/arch/mips/jazz/reset.c
@@ -6,7 +6,7 @@
  *  $Id:$
  */
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <asm/jazz.h>
 #include <asm/io.h>
 #include <asm/system.h>
diff --git a/arch/ppc/kernel/temp.c b/arch/ppc/kernel/temp.c
index 6af5375142b5..33b3dee67338 100644
--- a/arch/ppc/kernel/temp.c
+++ b/arch/ppc/kernel/temp.c
@@ -13,7 +13,7 @@
 
 #include <linux/config.h>
 #include <linux/errno.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/param.h>
 #include <linux/string.h>
diff --git a/arch/sparc64/kernel/central.c b/arch/sparc64/kernel/central.c
index 15a372db13b0..ba3b4e81a1f5 100644
--- a/arch/sparc64/kernel/central.c
+++ b/arch/sparc64/kernel/central.c
@@ -8,7 +8,7 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/timer.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
diff --git a/arch/x86_64/kernel/bluesmoke.c b/arch/x86_64/kernel/bluesmoke.c
index 80f48c54d50b..f92ef7cdeb1a 100644
--- a/arch/x86_64/kernel/bluesmoke.c
+++ b/arch/x86_64/kernel/bluesmoke.c
@@ -5,7 +5,7 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/smp.h>
 #include <linux/config.h>
 #include <linux/irq.h>
diff --git a/drivers/atm/suni.c b/drivers/atm/suni.c
index 3d7605c1fd6d..6e9f3dc74332 100644
--- a/drivers/atm/suni.c
+++ b/drivers/atm/suni.c
@@ -4,7 +4,7 @@
 
 
 #include <linux/module.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
diff --git a/drivers/char/agp/agpgart_be.c b/drivers/char/agp/agpgart_be.c
index 822e16d070c0..a28a2ab1dafb 100644
--- a/drivers/char/agp/agpgart_be.c
+++ b/drivers/char/agp/agpgart_be.c
@@ -28,7 +28,7 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index 02bdb661252c..780942105b04 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -50,7 +50,7 @@
 #include <linux/pci.h>
 #include <linux/wrapper.h>
 #include <linux/version.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/smp_lock.h>	/* For (un)lock_kernel */
 #include <linux/mm.h>
 #if defined(__alpha__) || defined(__powerpc__)
diff --git a/drivers/char/ftape/lowlevel/ftape-calibr.c b/drivers/char/ftape/lowlevel/ftape-calibr.c
index e21e6d2419cc..1c9de0eed842 100644
--- a/drivers/char/ftape/lowlevel/ftape-calibr.c
+++ b/drivers/char/ftape/lowlevel/ftape-calibr.c
@@ -26,7 +26,7 @@
 
 #include <linux/config.h>
 #include <linux/errno.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <asm/system.h>
 #include <asm/io.h>
 #if defined(__alpha__)
diff --git a/drivers/char/machzwd.c b/drivers/char/machzwd.c
index 4145913cf5fc..eabf3fe878a2 100644
--- a/drivers/char/machzwd.c
+++ b/drivers/char/machzwd.c
@@ -35,7 +35,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/slab.h>
diff --git a/drivers/char/sbc60xxwdt.c b/drivers/char/sbc60xxwdt.c
index ac7aeda9bfb5..408853344023 100644
--- a/drivers/char/sbc60xxwdt.c
+++ b/drivers/char/sbc60xxwdt.c
@@ -61,7 +61,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/slab.h>
diff --git a/drivers/char/w83877f_wdt.c b/drivers/char/w83877f_wdt.c
index 0f1b815ecbc5..c2237e0ec1b5 100644
--- a/drivers/char/w83877f_wdt.c
+++ b/drivers/char/w83877f_wdt.c
@@ -46,7 +46,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/slab.h>
diff --git a/drivers/fc4/fc.c b/drivers/fc4/fc.c
index f4691f9662f3..885be2e77623 100644
--- a/drivers/fc4/fc.c
+++ b/drivers/fc4/fc.c
@@ -23,7 +23,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/interrupt.h>
diff --git a/drivers/ide/ide-pmac.c b/drivers/ide/ide-pmac.c
index 6ddd94b1b547..41808eb43eca 100644
--- a/drivers/ide/ide-pmac.c
+++ b/drivers/ide/ide-pmac.c
@@ -33,7 +33,7 @@
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/ide.h>
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index a14399223c85..a25603a79897 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -38,7 +38,7 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/interrupt.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index 011d48b212a3..9c32bfc7bd09 100644
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -61,7 +61,7 @@
 /*#define PSYCHO_DEBUG */
 
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/ptrace.h>
 #include <linux/slab.h>
 #include <linux/string.h>
diff --git a/drivers/net/8390.c b/drivers/net/8390.c
index 06e0746a9061..31a5dcd3cfce 100644
--- a/drivers/net/8390.c
+++ b/drivers/net/8390.c
@@ -52,7 +52,7 @@ static const char version[] =
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/fs.h>
 #include <linux/types.h>
 #include <linux/ptrace.h>
diff --git a/drivers/net/atari_bionet.c b/drivers/net/atari_bionet.c
index 2994d6f73099..e2a4a87fd8a7 100644
--- a/drivers/net/atari_bionet.c
+++ b/drivers/net/atari_bionet.c
@@ -86,7 +86,7 @@ static char version[] =
 
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/interrupt.h>
diff --git a/drivers/net/atari_pamsnet.c b/drivers/net/atari_pamsnet.c
index 175c23466a73..3b583c453914 100644
--- a/drivers/net/atari_pamsnet.c
+++ b/drivers/net/atari_pamsnet.c
@@ -80,7 +80,7 @@ static char *version =
 #include <linux/module.h>
 
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/interrupt.h>
diff --git a/drivers/net/auto_irq.c b/drivers/net/auto_irq.c
index f2fba5074295..96ddc77b7193 100644
--- a/drivers/net/auto_irq.c
+++ b/drivers/net/auto_irq.c
@@ -31,7 +31,7 @@ static const char *version=
 #endif
 
 #include <linux/module.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/delay.h>
 #include <asm/bitops.h>
 #include <asm/io.h>
diff --git a/drivers/net/ethertap.c b/drivers/net/ethertap.c
index 6bb635be09c9..ca38587fefab 100644
--- a/drivers/net/ethertap.c
+++ b/drivers/net/ethertap.c
@@ -15,7 +15,7 @@
 #include <linux/module.h>
 
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c
index de0c5322d5b1..4ae862f66b7f 100644
--- a/drivers/net/loopback.c
+++ b/drivers/net/loopback.c
@@ -29,7 +29,7 @@
  *		2 of the License, or (at your option) any later version.
  */
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/interrupt.h>
 #include <linux/fs.h>
 #include <linux/types.h>
diff --git a/drivers/net/wan/comx-proto-fr.c b/drivers/net/wan/comx-proto-fr.c
index bd3f996e3aa9..4460b6a3cea6 100644
--- a/drivers/net/wan/comx-proto-fr.c
+++ b/drivers/net/wan/comx-proto-fr.c
@@ -39,7 +39,7 @@
 #include <linux/module.h>
 #include <linux/version.h>
 #include <linux/types.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/if_arp.h>
diff --git a/drivers/net/wan/comx-proto-ppp.c b/drivers/net/wan/comx-proto-ppp.c
index 5610c736fa02..4153b9dd63c0 100644
--- a/drivers/net/wan/comx-proto-ppp.c
+++ b/drivers/net/wan/comx-proto-ppp.c
@@ -36,7 +36,7 @@
 #include <linux/module.h>
 #include <linux/version.h>
 #include <linux/types.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/if_arp.h>
diff --git a/drivers/net/wan/comx.c b/drivers/net/wan/comx.c
index 71da5c7776ff..739c19d39b37 100644
--- a/drivers/net/wan/comx.c
+++ b/drivers/net/wan/comx.c
@@ -58,7 +58,7 @@
 #include <linux/version.h>
 
 #include <linux/types.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <asm/uaccess.h>
diff --git a/drivers/net/wan/hd6457x.c b/drivers/net/wan/hd6457x.c
index cd2645791d1e..a96c3cce0157 100644
--- a/drivers/net/wan/hd6457x.c
+++ b/drivers/net/wan/hd6457x.c
@@ -16,7 +16,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/types.h>
 #include <linux/fcntl.h>
 #include <linux/interrupt.h>
diff --git a/drivers/net/wan/sdladrv.c b/drivers/net/wan/sdladrv.c
index be2b7f78b1c7..151fd7b90a16 100644
--- a/drivers/net/wan/sdladrv.c
+++ b/drivers/net/wan/sdladrv.c
@@ -97,7 +97,7 @@
 #include <linux/errno.h>	/* return codes */
 #include <linux/string.h>	/* inline memset(), etc. */
 #include <linux/module.h>	/* support for loadable modules */
-#include <linux/sched.h>	/* for jiffies, HZ, etc. */
+#include <linux/jiffies.h>	/* for jiffies, HZ, etc. */
 #include <linux/sdladrv.h>	/* API definitions */
 #include <linux/sdlasfm.h>	/* SDLA firmware module definitions */
 #include <linux/sdlapci.h>	/* SDLA PCI hardware definitions */
diff --git a/drivers/scsi/i60uscsi.c b/drivers/scsi/i60uscsi.c
index 13699ad53eb3..732533329cab 100644
--- a/drivers/scsi/i60uscsi.c
+++ b/drivers/scsi/i60uscsi.c
@@ -69,7 +69,7 @@
  **************************************************************************/
 
 #include <linux/version.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <asm/io.h>
 #include "i60uscsi.h"
 
diff --git a/drivers/scsi/i91uscsi.c b/drivers/scsi/i91uscsi.c
index 0b7739a51575..ee7e36d9ec85 100644
--- a/drivers/scsi/i91uscsi.c
+++ b/drivers/scsi/i91uscsi.c
@@ -88,7 +88,7 @@
 #include <linux/version.h>
 #endif
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/delay.h>
 #include <linux/blk.h>
 #include <asm/io.h>
diff --git a/drivers/usb/host/usb-uhci-hcd.c b/drivers/usb/host/usb-uhci-hcd.c
index c970c4a36bf8..fd20be978747 100644
--- a/drivers/usb/host/usb-uhci-hcd.c
+++ b/drivers/usb/host/usb-uhci-hcd.c
@@ -22,7 +22,7 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/ioport.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/errno.h>
diff --git a/drivers/usb/net/cdc-ether.c b/drivers/usb/net/cdc-ether.c
index db03b9df9695..c257e9185dcf 100644
--- a/drivers/usb/net/cdc-ether.c
+++ b/drivers/usb/net/cdc-ether.c
@@ -19,7 +19,7 @@
  */
 
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/delay.h>
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index ba87e2285d7e..1625226022af 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -49,7 +49,7 @@
 #include "scsiglue.h"
 #include "isd200.h"
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/hdreg.h>
diff --git a/drivers/usb/storage/sddr55.c b/drivers/usb/storage/sddr55.c
index e0a31fc58635..ce3642144062 100644
--- a/drivers/usb/storage/sddr55.c
+++ b/drivers/usb/storage/sddr55.c
@@ -31,7 +31,7 @@
 #include "debug.h"
 #include "sddr55.h"
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 
diff --git a/fs/vfat/namei.c b/fs/vfat/namei.c
index ad8d4ffcb301..25758acea219 100644
--- a/fs/vfat/namei.c
+++ b/fs/vfat/namei.c
@@ -17,7 +17,7 @@
 
 #include <linux/module.h>
 
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/msdos_fs.h>
 #include <linux/ctype.h>
 #include <linux/slab.h>
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
new file mode 100644
index 000000000000..a33b2bcfc625
--- /dev/null
+++ b/include/linux/jiffies.h
@@ -0,0 +1,30 @@
+#ifndef _LINUX_JIFFIES_H
+#define _LINUX_JIFFIES_H
+
+/*
+ * The 64-bit value is not volatile - you MUST NOT read it
+ * without holding read_lock_irq(&xtime_lock)
+ */
+extern u64 jiffies_64;
+extern unsigned long volatile jiffies;
+
+/*
+ *	These inlines deal with timer wrapping correctly. You are 
+ *	strongly encouraged to use them
+ *	1. Because people otherwise forget
+ *	2. Because if the timer wrap changes in future you wont have to
+ *	   alter your driver code.
+ *
+ * time_after(a,b) returns true if the time a is after time b.
+ *
+ * Do this with "<0" and ">=0" to only test the sign of the result. A
+ * good compiler would generate better code (and a really good compiler
+ * wouldn't care). Gcc is currently neither.
+ */
+#define time_after(a,b)		((long)(b) - (long)(a) < 0)
+#define time_before(a,b)	time_after(b,a)
+
+#define time_after_eq(a,b)	((long)(a) - (long)(b) >= 0)
+#define time_before_eq(a,b)	time_after_eq(b,a)
+
+#endif
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 067c93387b77..743b1aea2aca 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -13,6 +13,7 @@ extern unsigned long event;
 #include <linux/types.h>
 #include <linux/times.h>
 #include <linux/timex.h>
+#include <linux/jiffies.h>
 #include <linux/rbtree.h>
 #include <linux/thread_info.h>
 
@@ -481,12 +482,6 @@ extern void free_uid(struct user_struct *);
 
 #include <asm/current.h>
 
-/*
- * The 64-bit value is not volatile - you MUST NOT read it
- * without holding read_lock_irq(&xtime_lock)
- */
-extern u64 jiffies_64;
-extern unsigned long volatile jiffies;
 extern unsigned long itimer_ticks;
 extern unsigned long itimer_next;
 extern void do_timer(struct pt_regs *);
diff --git a/include/linux/timer.h b/include/linux/timer.h
index c4f01ada5975..d6f0ce5f8740 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -52,23 +52,4 @@ static inline int timer_pending (const struct timer_list * timer)
 	return timer->list.next != NULL;
 }
 
-/*
- *	These inlines deal with timer wrapping correctly. You are 
- *	strongly encouraged to use them
- *	1. Because people otherwise forget
- *	2. Because if the timer wrap changes in future you wont have to
- *	   alter your driver code.
- *
- * time_after(a,b) returns true if the time a is after time b.
- *
- * Do this with "<0" and ">=0" to only test the sign of the result. A
- * good compiler would generate better code (and a really good compiler
- * wouldn't care). Gcc is currently neither.
- */
-#define time_after(a,b)		((long)(b) - (long)(a) < 0)
-#define time_before(a,b)	time_after(b,a)
-
-#define time_after_eq(a,b)	((long)(a) - (long)(b) >= 0)
-#define time_before_eq(a,b)	time_after_eq(b,a)
-
 #endif
diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h
index f71621990094..33105051f304 100644
--- a/include/net/inetpeer.h
+++ b/include/net/inetpeer.h
@@ -11,7 +11,7 @@
 
 #include <linux/types.h>
 #include <linux/init.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/spinlock.h>
 #include <asm/atomic.h>
 
diff --git a/net/802/tr.c b/net/802/tr.c
index 73c938486409..6249e319efab 100644
--- a/net/802/tr.c
+++ b/net/802/tr.c
@@ -20,7 +20,7 @@
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/ax25/ax25_ds_timer.c b/net/ax25/ax25_ds_timer.c
index b11045192e07..02c189e4cb11 100644
--- a/net/ax25/ax25_ds_timer.c
+++ b/net/ax25/ax25_ds_timer.c
@@ -20,7 +20,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/ax25/ax25_timer.c b/net/ax25/ax25_timer.c
index 01e7596f3d3a..8ea87b01df41 100644
--- a/net/ax25/ax25_timer.c
+++ b/net/ax25/ax25_timer.c
@@ -31,7 +31,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/core/profile.c b/net/core/profile.c
index a3ff364175ec..403556b6c745 100644
--- a/net/core/profile.c
+++ b/net/core/profile.c
@@ -1,7 +1,7 @@
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/netdevice.h>
diff --git a/net/core/utils.c b/net/core/utils.c
index 310393453181..6a69fe47f483 100644
--- a/net/core/utils.c
+++ b/net/core/utils.c
@@ -17,7 +17,7 @@
 #include <asm/system.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index 3c75a6577ea1..071b4af2b05b 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -21,7 +21,7 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/icmp.c b/net/ipv4/icmp.c
index a5b7dbb0d0e1..b9966cb78cae 100644
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
@@ -65,7 +65,7 @@
 
 #include <linux/config.h>
 #include <linux/types.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/fcntl.h>
 #include <linux/socket.h>
diff --git a/net/ipv4/igmp.c b/net/ipv4/igmp.c
index de716fe63d79..1ac00c0c296e 100644
--- a/net/ipv4/igmp.c
+++ b/net/ipv4/igmp.c
@@ -76,7 +76,7 @@
 #include <asm/system.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
diff --git a/net/ipv4/ip_fragment.c b/net/ipv4/ip_fragment.c
index 6ecca3122582..041dc0a89142 100644
--- a/net/ipv4/ip_fragment.c
+++ b/net/ipv4/ip_fragment.c
@@ -24,7 +24,7 @@
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/mm.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/skbuff.h>
 #include <linux/ip.h>
 #include <linux/icmp.h>
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index bff4322e144a..f2be65844221 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -32,7 +32,7 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/random.h>
 #include <linux/init.h>
 #include <linux/utsname.h>
diff --git a/net/ipv6/mcast.c b/net/ipv6/mcast.c
index fde4cf68498f..62815e2f65c0 100644
--- a/net/ipv6/mcast.c
+++ b/net/ipv6/mcast.c
@@ -28,7 +28,7 @@
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/net.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/ipv6/reassembly.c b/net/ipv6/reassembly.c
index c8582f592a4f..4b510958db4c 100644
--- a/net/ipv6/reassembly.c
+++ b/net/ipv6/reassembly.c
@@ -29,7 +29,7 @@
 #include <linux/string.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/net.h>
 #include <linux/netdevice.h>
 #include <linux/in6.h>
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 27a49a6260ce..2ad1b597364b 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -29,7 +29,7 @@
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
diff --git a/net/lapb/lapb_iface.c b/net/lapb/lapb_iface.c
index 5142e74ae9aa..f932afcea4b8 100644
--- a/net/lapb/lapb_iface.c
+++ b/net/lapb/lapb_iface.c
@@ -21,7 +21,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/lapb/lapb_timer.c b/net/lapb/lapb_timer.c
index d65e32e5e1cb..a010ac9d63fc 100644
--- a/net/lapb/lapb_timer.c
+++ b/net/lapb/lapb_timer.c
@@ -19,7 +19,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/netrom/nr_timer.c b/net/netrom/nr_timer.c
index ba9c70e5042a..cdeab2e21f55 100644
--- a/net/netrom/nr_timer.c
+++ b/net/netrom/nr_timer.c
@@ -20,7 +20,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/rose/rose_link.c b/net/rose/rose_link.c
index 1cd86a1d6948..3935526edc3a 100644
--- a/net/rose/rose_link.c
+++ b/net/rose/rose_link.c
@@ -19,7 +19,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/rose/rose_timer.c b/net/rose/rose_timer.c
index 3de5e475b31c..4f66adbaf8a7 100644
--- a/net/rose/rose_timer.c
+++ b/net/rose/rose_timer.c
@@ -20,7 +20,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/sched/estimator.c b/net/sched/estimator.c
index e70066f9c1bb..15781929dbb4 100644
--- a/net/sched/estimator.c
+++ b/net/sched/estimator.c
@@ -14,7 +14,7 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_csz.c b/net/sched/sch_csz.c
index 6f68572373b7..b90ce1838d35 100644
--- a/net/sched/sch_csz.c
+++ b/net/sched/sch_csz.c
@@ -17,7 +17,7 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index c96762fbdcb9..9c20875674a4 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -16,7 +16,7 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c
index 19a3de99aafe..4012cf0b6215 100644
--- a/net/sched/sch_tbf.c
+++ b/net/sched/sch_tbf.c
@@ -17,7 +17,7 @@
 #include <asm/bitops.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
diff --git a/net/x25/x25_link.c b/net/x25/x25_link.c
index cce5b6a3afaa..35056521ac3e 100644
--- a/net/x25/x25_link.c
+++ b/net/x25/x25_link.c
@@ -25,7 +25,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/net/x25/x25_timer.c b/net/x25/x25_timer.c
index 5568d19b1349..47e1c5823496 100644
--- a/net/x25/x25_timer.c
+++ b/net/x25/x25_timer.c
@@ -23,7 +23,7 @@
 #include <linux/socket.h>
 #include <linux/in.h>
 #include <linux/kernel.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/sockios.h>
diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c
index d749dfa0a0ca..7e43380a52b7 100644
--- a/sound/drivers/dummy.c
+++ b/sound/drivers/dummy.c
@@ -20,7 +20,7 @@
 
 #include <sound/driver.h>
 #include <linux/init.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/wait.h>
diff --git a/sound/oss/emu10k1/cardmi.c b/sound/oss/emu10k1/cardmi.c
index 5bc18eb1627f..a6140b00f884 100644
--- a/sound/oss/emu10k1/cardmi.c
+++ b/sound/oss/emu10k1/cardmi.c
@@ -31,7 +31,7 @@
  */
 
 #include <linux/slab.h>
-#include <linux/sched.h>
+#include <linux/jiffies.h>
 
 #include "hwaccess.h"
 #include "8010.h"
-- 
cgit v1.2.3