summaryrefslogtreecommitdiff
path: root/packages/linux/ixp4xx-kernel/2.6.16
diff options
context:
space:
mode:
Diffstat (limited to 'packages/linux/ixp4xx-kernel/2.6.16')
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/06-remove-extraversion.patch2
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/40-rtc-class.patch2076
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch378
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch14
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/91-maclist.patch405
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/94-nas100d-setup.patch2
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/951-ixp4xx-leds-cpu-activity.patch57
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/96-nas100d-leds.patch3
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/97-ds101-buttons.patch122
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/97-ds101-includes.patch139
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/97-ds101-misc.patch36
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/97-ds101-pci.patch13
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/97-ds101-power.patch75
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/97-ds101-setup.patch360
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/defconfig3
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/leds-class.patch2069
-rw-r--r--packages/linux/ixp4xx-kernel/2.6.16/patch-2.6.16-rc4-ide118260
17 files changed, 23251 insertions, 763 deletions
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/06-remove-extraversion.patch b/packages/linux/ixp4xx-kernel/2.6.16/06-remove-extraversion.patch
index 65aba13703..8f2ce831b2 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/06-remove-extraversion.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/06-remove-extraversion.patch
@@ -4,7 +4,7 @@
VERSION = 2
PATCHLEVEL = 6
SUBLEVEL = 16
--EXTRAVERSION =-rc2
+-EXTRAVERSION =-rc4
+EXTRAVERSION =
NAME=Sliding Snow Leopard
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/40-rtc-class.patch b/packages/linux/ixp4xx-kernel/2.6.16/40-rtc-class.patch
index 38359a1bc0..3cc84b2a9b 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/40-rtc-class.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/40-rtc-class.patch
@@ -1,6 +1,6 @@
---- linux-nslu2.orig/include/linux/rtc.h 2006-02-06 20:37:43.000000000 +0100
-+++ linux-nslu2/include/linux/rtc.h 2006-02-06 21:41:39.000000000 +0100
-@@ -93,8 +93,91 @@ struct rtc_pll_info {
+--- linux-rtc.orig/include/linux/rtc.h 2006-02-19 23:33:10.000000000 +0100
++++ linux-rtc/include/linux/rtc.h 2006-02-19 23:33:15.000000000 +0100
+@@ -93,8 +93,97 @@ struct rtc_pll_info {
#define RTC_PLL_GET _IOR('p', 0x11, struct rtc_pll_info) /* Get PLL correction */
#define RTC_PLL_SET _IOW('p', 0x12, struct rtc_pll_info) /* Set PLL correction */
@@ -16,6 +16,7 @@
+#include <linux/seq_file.h>
+#include <linux/cdev.h>
+#include <linux/poll.h>
++#include <linux/mutex.h>
+
+struct rtc_class_ops {
+ int (*open)(struct device *);
@@ -29,6 +30,7 @@
+ int (*set_mmss)(struct device *, unsigned long secs);
+ int (*irq_set_state)(struct device *, int enabled);
+ int (*irq_set_freq)(struct device *, int freq);
++ int (*read_callback)(struct device *, int data);
+};
+
+#define RTC_DEVICE_NAME_SIZE 20
@@ -36,23 +38,25 @@
+
+struct rtc_device
+{
-+ int id;
-+ struct module *owner;
+ struct class_device class_dev;
-+ struct semaphore ops_lock;
-+ struct rtc_class_ops *ops;
++ struct module *owner;
++
++ int id;
+ char name[RTC_DEVICE_NAME_SIZE];
+
++ struct rtc_class_ops *ops;
++ struct mutex ops_lock;
++
+ struct cdev char_dev;
-+ struct semaphore char_sem;
++ struct mutex char_lock;
+
+ unsigned long irq_data;
+ spinlock_t irq_lock;
+ wait_queue_head_t irq_queue;
+ struct fasync_struct *async_queue;
+
-+ spinlock_t irq_task_lock;
+ struct rtc_task *irq_task;
++ spinlock_t irq_task_lock;
+ int irq_freq;
+};
+#define to_rtc_device(d) container_of(d, struct rtc_device, class_dev)
@@ -71,15 +75,17 @@
+
+extern int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm);
+extern int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm);
++extern int rtc_set_mmss(struct class_device *class_dev, unsigned long secs);
+extern int rtc_read_alarm(struct class_device *class_dev,
-+ struct rtc_wkalrm *alrm);
++ struct rtc_wkalrm *alrm);
+extern int rtc_set_alarm(struct class_device *class_dev,
+ struct rtc_wkalrm *alrm);
+extern void rtc_update_irq(struct class_device *class_dev,
+ unsigned long num, unsigned long events);
+
-+extern struct class_device *rtc_open(char *name);
-+extern void rtc_close(struct class_device *class_dev);
++extern struct class_device *rtc_class_open(char *name);
++extern void rtc_class_close(struct class_device *class_dev);
++
+extern int rtc_irq_register(struct class_device *class_dev,
+ struct rtc_task *task);
+extern void rtc_irq_unregister(struct class_device *class_dev,
@@ -92,8 +98,8 @@
typedef struct rtc_task {
void (*func)(void *private_data);
void *private_data;
---- linux-nslu2.orig/drivers/Kconfig 2006-02-06 20:37:14.000000000 +0100
-+++ linux-nslu2/drivers/Kconfig 2006-02-06 21:11:33.000000000 +0100
+--- linux-rtc.orig/drivers/Kconfig 2006-02-19 23:33:10.000000000 +0100
++++ linux-rtc/drivers/Kconfig 2006-02-19 23:33:15.000000000 +0100
@@ -70,4 +70,6 @@ source "drivers/sn/Kconfig"
source "drivers/edac/Kconfig"
@@ -101,8 +107,8 @@
+source "drivers/rtc/Kconfig"
+
endmenu
---- linux-nslu2.orig/drivers/Makefile 2006-02-06 20:37:14.000000000 +0100
-+++ linux-nslu2/drivers/Makefile 2006-02-06 21:11:33.000000000 +0100
+--- linux-rtc.orig/drivers/Makefile 2006-02-19 23:33:10.000000000 +0100
++++ linux-rtc/drivers/Makefile 2006-02-19 23:33:15.000000000 +0100
@@ -56,6 +56,7 @@ obj-$(CONFIG_USB_GADGET) += usb/gadget/
obj-$(CONFIG_GAMEPORT) += input/gameport/
obj-$(CONFIG_INPUT) += input/
@@ -112,7 +118,7 @@
obj-$(CONFIG_W1) += w1/
obj-$(CONFIG_HWMON) += hwmon/
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/class.c 2006-02-06 21:41:25.000000000 +0100
++++ linux-rtc/drivers/rtc/class.c 2006-02-19 23:33:15.000000000 +0100
@@ -0,0 +1,143 @@
+/*
+ * RTC subsystem, base class
@@ -133,15 +139,15 @@
+#include <linux/idr.h>
+
+static DEFINE_IDR(rtc_idr);
-+static DECLARE_MUTEX(idr_lock);
++static DEFINE_MUTEX(idr_lock);
+struct class *rtc_class;
+
+static void rtc_device_release(struct class_device *class_dev)
+{
+ struct rtc_device *rtc = to_rtc_device(class_dev);
-+ down(&idr_lock);
++ mutex_lock(&idr_lock);
+ idr_remove(&rtc_idr, rtc->id);
-+ up(&idr_lock);
++ mutex_unlock(&idr_lock);
+ kfree(rtc);
+}
+
@@ -167,9 +173,9 @@
+ }
+
+
-+ down(&idr_lock);
++ mutex_lock(&idr_lock);
+ err = idr_get_new(&rtc_idr, NULL, &id);
-+ up(&idr_lock);
++ mutex_unlock(&idr_lock);
+
+ if (err < 0)
+ goto exit;
@@ -188,7 +194,7 @@
+ rtc->class_dev.class = rtc_class;
+ rtc->class_dev.release = rtc_device_release;
+
-+ init_MUTEX(&rtc->ops_lock);
++ mutex_init(&rtc->ops_lock);
+ spin_lock_init(&rtc->irq_lock);
+ spin_lock_init(&rtc->irq_task_lock);
+
@@ -222,9 +228,9 @@
+ */
+void rtc_device_unregister(struct rtc_device *rtc)
+{
-+ down(&rtc->ops_lock);
++ mutex_lock(&rtc->ops_lock);
+ rtc->ops = NULL;
-+ up(&rtc->ops_lock);
++ mutex_unlock(&rtc->ops_lock);
+ class_device_unregister(&rtc->class_dev);
+}
+EXPORT_SYMBOL_GPL(rtc_device_unregister);
@@ -258,8 +264,8 @@
+MODULE_DESCRIPTION("RTC class support");
+MODULE_LICENSE("GPL");
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/Kconfig 2006-02-06 23:58:32.000000000 +0100
-@@ -0,0 +1,121 @@
++++ linux-rtc/drivers/rtc/Kconfig 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,131 @@
+#
+# RTC class/drivers configuration
+#
@@ -365,6 +371,16 @@
+ This driver can also be built as a module. If so, the module
+ will be called rtc-pcf8563.
+
++config RTC_DRV_RS5C372
++ tristate "Ricoh RS5C372A/B"
++ depends on RTC_CLASS && I2C
++ help
++ If you say yes here you get support for the
++ Ricoh RS5C372A and RS5C372B RTC chips.
++
++ This driver can also be built as a module. If so, the module
++ will be called rtc-rs5c372.
++
+config RTC_DRV_TEST
+ tristate "Test driver/device"
+ depends on RTC_CLASS
@@ -382,8 +398,8 @@
+
+endmenu
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/Makefile 2006-02-06 23:58:32.000000000 +0100
-@@ -0,0 +1,17 @@
++++ linux-rtc/drivers/rtc/Makefile 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,18 @@
+#
+# Makefile for RTC class/drivers.
+#
@@ -400,10 +416,11 @@
+obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o
+obj-$(CONFIG_RTC_DRV_DS1672) += rtc-ds1672.o
+obj-$(CONFIG_RTC_DRV_PCF8563) += rtc-pcf8563.o
++obj-$(CONFIG_RTC_DRV_RS5C372) += rtc-rs5c372.o
+
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/interface.c 2006-02-07 01:32:10.000000000 +0100
-@@ -0,0 +1,232 @@
++++ linux-rtc/drivers/rtc/interface.c 2006-02-19 23:33:15.000000000 +0100
+@@ -0,0 +1,274 @@
+/*
+ * RTC subsystem, interface functions
+ *
@@ -426,7 +443,7 @@
+ int err;
+ struct rtc_device *rtc = to_rtc_device(class_dev);
+
-+ if ((err = down_interruptible(&rtc->ops_lock)))
++ if ((err = mutex_lock_interruptible(&rtc->ops_lock)))
+ return err;
+
+ if (!rtc->ops)
@@ -438,7 +455,7 @@
+ err = rtc->ops->read_time(class_dev->dev, tm);
+ }
+
-+ up(&rtc->ops_lock);
++ mutex_unlock(&rtc->ops_lock);
+ return err;
+}
+EXPORT_SYMBOL(rtc_read_time);
@@ -451,7 +468,7 @@
+ if ((err = rtc_valid_tm(tm)) != 0)
+ return err;
+
-+ if ((err = down_interruptible(&rtc->ops_lock)))
++ if ((err = mutex_lock_interruptible(&rtc->ops_lock)))
+ return err;
+
+ if (!rtc->ops)
@@ -461,17 +478,59 @@
+ else
+ err = rtc->ops->set_time(class_dev->dev, tm);
+
-+ up(&rtc->ops_lock);
++ mutex_unlock(&rtc->ops_lock);
+ return err;
+}
+EXPORT_SYMBOL(rtc_set_time);
+
++int rtc_set_mmss(struct class_device *class_dev, unsigned long secs)
++{
++ int err;
++ struct rtc_device *rtc = to_rtc_device(class_dev);
++
++ if ((err = mutex_lock_interruptible(&rtc->ops_lock)))
++ return err;
++
++ if (!rtc->ops)
++ err = -ENODEV;
++ else if (!rtc->ops->set_mmss) {
++ if (rtc->ops->read_time && rtc->ops->set_time) {
++ struct rtc_time new, old;
++
++ new.tm_sec = secs % 60;
++ secs /= 60;
++ new.tm_min = secs % 60;
++ secs /= 60;
++ new.tm_hour = secs % 24;
++
++ /*
++ * avoid writing when we're going to change the day
++ * of the month. We will retry in the next minute.
++ * This basically means that if the RTC must not drift
++ * by more than 1 minute in 11 minutes.
++ */
++ if (!((old.tm_hour == 23 && old.tm_min == 59) ||
++ (new.tm_hour == 23 && new.tm_min == 59)))
++ err = rtc->ops->set_time(class_dev->dev, &new);
++ }
++ else
++ err = -EINVAL;
++ }
++ else
++ err = rtc->ops->set_mmss(class_dev->dev, secs);
++
++ mutex_unlock(&rtc->ops_lock);
++
++ return err;
++}
++EXPORT_SYMBOL(rtc_set_mmss);
++
+int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
+{
+ int err;
+ struct rtc_device *rtc = to_rtc_device(class_dev);
+
-+ if ((err = down_interruptible(&rtc->ops_lock)))
++ if ((err = mutex_lock_interruptible(&rtc->ops_lock)))
+ return err;
+
+ if (rtc->ops == NULL)
@@ -483,7 +542,7 @@
+ err = rtc->ops->read_alarm(class_dev->dev, alarm);
+ }
+
-+ up(&rtc->ops_lock);
++ mutex_unlock(&rtc->ops_lock);
+ return err;
+}
+EXPORT_SYMBOL(rtc_read_alarm);
@@ -493,7 +552,7 @@
+ int err;
+ struct rtc_device *rtc = to_rtc_device(class_dev);
+
-+ if ((err = down_interruptible(&rtc->ops_lock)))
++ if ((err = mutex_lock_interruptible(&rtc->ops_lock)))
+ return err;
+
+ if (!rtc->ops)
@@ -503,7 +562,7 @@
+ else
+ err = rtc->ops->set_alarm(class_dev->dev, alarm);
+
-+ up(&rtc->ops_lock);
++ mutex_unlock(&rtc->ops_lock);
+ return err;
+}
+EXPORT_SYMBOL(rtc_set_alarm);
@@ -527,7 +586,7 @@
+}
+EXPORT_SYMBOL(rtc_update_irq);
+
-+struct class_device *rtc_open(char *name)
++struct class_device *rtc_class_open(char *name)
+{
+ struct class_device *class_dev = NULL,
+ *class_dev_tmp;
@@ -548,13 +607,13 @@
+
+ return class_dev;
+}
-+EXPORT_SYMBOL(rtc_open);
++EXPORT_SYMBOL(rtc_class_open);
+
-+void rtc_close(struct class_device *class_dev)
++void rtc_class_close(struct class_device *class_dev)
+{
+ module_put(to_rtc_device(class_dev)->owner);
+}
-+EXPORT_SYMBOL(rtc_close);
++EXPORT_SYMBOL(rtc_class_close);
+
+int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
+{
@@ -637,7 +696,7 @@
+
+}
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/utils.c 2006-02-06 21:11:33.000000000 +0100
++++ linux-rtc/drivers/rtc/utils.c 2006-02-19 23:33:15.000000000 +0100
@@ -0,0 +1,97 @@
+/*
+ * RTC subsystem, utility functions
@@ -737,8 +796,8 @@
+}
+EXPORT_SYMBOL(rtc_tm_to_time);
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/hctosys.c 2006-02-06 21:11:33.000000000 +0100
-@@ -0,0 +1,62 @@
++++ linux-rtc/drivers/rtc/hctosys.c 2006-02-21 00:34:57.000000000 +0100
+@@ -0,0 +1,67 @@
+/*
+ * RTC subsystem, initialize system time on startup
+ *
@@ -766,12 +825,17 @@
+static int __init rtc_hctosys(void)
+{
+ int err;
-+ struct class_device *class_dev = rtc_open(CONFIG_RTC_HCTOSYS_DEVICE);
++ struct rtc_time tm;
++ struct class_device *class_dev = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
+
-+ if (class_dev) {
-+ struct rtc_time tm;
++ if (class_dev == NULL) {
++ printk("%s: unable to open rtc device (%s)\n",
++ __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
++ return -ENODEV;
++ }
+
-+ if ((err = rtc_read_time(class_dev, &tm)) == 0) {
++ if ((err = rtc_read_time(class_dev, &tm)) == 0) {
++ if (rtc_valid_tm(&tm) == 0) {
+ struct timespec tv;
+
+ tv.tv_nsec = NSEC_PER_SEC >> 1;
@@ -789,21 +853,21 @@
+ }
+ else
+ dev_err(class_dev->dev,
-+ "unable to set the system clock\n");
-+
-+ rtc_close(class_dev);
++ "hctosys: invalid date/time\n");
+ }
+ else
-+ printk("%s: unable to open rtc device (%s)\n",
-+ __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
++ dev_err(class_dev->dev,
++ "hctosys: unable to read the hardware clock\n");
++
++ rtc_class_close(class_dev);
+
+ return 0;
+}
+
+late_initcall(rtc_hctosys);
---- linux-nslu2.orig/arch/arm/Kconfig 2006-02-06 23:52:28.000000000 +0100
-+++ linux-nslu2/arch/arm/Kconfig 2006-02-06 23:53:25.000000000 +0100
-@@ -784,6 +784,8 @@ source "drivers/usb/Kconfig"
+--- linux-rtc.orig/arch/arm/Kconfig 2006-02-21 00:34:27.000000000 +0100
++++ linux-rtc/arch/arm/Kconfig 2006-02-21 00:36:42.000000000 +0100
+@@ -817,6 +817,8 @@ source "drivers/usb/Kconfig"
source "drivers/mmc/Kconfig"
@@ -812,8 +876,8 @@
endmenu
source "fs/Kconfig"
---- linux-nslu2.orig/arch/arm/common/rtctime.c 2006-02-06 23:52:28.000000000 +0100
-+++ linux-nslu2/arch/arm/common/rtctime.c 2006-02-06 23:53:25.000000000 +0100
+--- linux-rtc.orig/arch/arm/common/rtctime.c 2006-02-21 00:34:27.000000000 +0100
++++ linux-rtc/arch/arm/common/rtctime.c 2006-02-21 00:36:42.000000000 +0100
@@ -42,89 +42,6 @@ static struct rtc_ops *rtc_ops;
#define rtc_epoch 1900UL
@@ -984,24 +1048,6 @@
if (ret)
break;
ret = copy_to_user(uarg, &alrm, sizeof(alrm));
-@@ -353,7 +270,7 @@ static int rtc_ioctl(struct inode *inode
- return ret;
- }
-
--static int rtc_open(struct inode *inode, struct file *file)
-+static int rtc_arm_open(struct inode *inode, struct file *file)
- {
- int ret;
-
-@@ -408,7 +325,7 @@ static struct file_operations rtc_fops =
- .read = rtc_read,
- .poll = rtc_poll,
- .ioctl = rtc_ioctl,
-- .open = rtc_open,
-+ .open = rtc_arm_open,
- .release = rtc_release,
- .fasync = rtc_fasync,
- };
@@ -427,7 +344,7 @@ static int rtc_read_proc(char *page, cha
struct rtc_time tm;
char *p = page;
@@ -1020,8 +1066,8 @@
p += sprintf(p, "alrm_time\t: ");
if ((unsigned int)alrm.time.tm_hour <= 24)
p += sprintf(p, "%02d:", alrm.time.tm_hour);
---- linux-nslu2.orig/include/asm-arm/rtc.h 2006-02-06 23:52:28.000000000 +0100
-+++ linux-nslu2/include/asm-arm/rtc.h 2006-02-06 23:53:25.000000000 +0100
+--- linux-rtc.orig/include/asm-arm/rtc.h 2006-02-21 00:34:27.000000000 +0100
++++ linux-rtc/include/asm-arm/rtc.h 2006-02-21 00:36:42.000000000 +0100
@@ -25,9 +25,6 @@ struct rtc_ops {
int (*proc)(char *buf);
};
@@ -1032,9 +1078,1269 @@
void rtc_next_alarm_time(struct rtc_time *, struct rtc_time *, struct rtc_time *);
void rtc_update(unsigned long, unsigned long);
int register_rtc(struct rtc_ops *);
+--- linux-rtc.orig/drivers/char/Kconfig 2006-02-21 00:34:27.000000000 +0100
++++ linux-rtc/drivers/char/Kconfig 2006-02-21 00:36:42.000000000 +0100
+@@ -695,7 +695,7 @@ config NVRAM
+
+ config RTC
+ tristate "Enhanced Real Time Clock Support"
+- depends on !PPC32 && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
++ depends on !PPC32 && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV && !ARM
+ ---help---
+ If you say Y here and create a character special file /dev/rtc with
+ major number 10 and minor number 135 using mknod ("man mknod"), you
+--- linux-rtc.orig/drivers/i2c/chips/x1205.c 2006-02-21 00:34:27.000000000 +0100
++++ /dev/null 1970-01-01 00:00:00.000000000 +0000
+@@ -1,698 +0,0 @@
+-/*
+- * x1205.c - An i2c driver for the Xicor X1205 RTC
+- * Copyright 2004 Karen Spearel
+- * Copyright 2005 Alessandro Zummo
+- *
+- * please send all reports to:
+- * kas11 at tampabay dot rr dot com
+- * a dot zummo at towertech dot it
+- *
+- * based on the other drivers in this same directory.
+- *
+- * This program is free software; you can redistribute it and/or modify
+- * it under the terms of the GNU General Public License as published by
+- * the Free Software Foundation; either version 2 of the License, or
+- * (at your option) any later version.
+- */
+-
+-#include <linux/module.h>
+-#include <linux/init.h>
+-#include <linux/slab.h>
+-#include <linux/i2c.h>
+-#include <linux/string.h>
+-#include <linux/bcd.h>
+-#include <linux/rtc.h>
+-#include <linux/list.h>
+-
+-#include <linux/x1205.h>
+-
+-#define DRV_VERSION "0.9.9"
+-
+-/* Addresses to scan: none. This chip is located at
+- * 0x6f and uses a two bytes register addressing.
+- * Two bytes need to be written to read a single register,
+- * while most other chips just require one and take the second
+- * one as the data to be written. To prevent corrupting
+- * unknown chips, the user must explicitely set the probe parameter.
+- */
+-
+-static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+-
+-/* Insmod parameters */
+-I2C_CLIENT_INSMOD;
+-I2C_CLIENT_MODULE_PARM(hctosys,
+- "Set the system time from the hardware clock upon initialization");
+-
+-/* offsets into CCR area */
+-
+-#define CCR_SEC 0
+-#define CCR_MIN 1
+-#define CCR_HOUR 2
+-#define CCR_MDAY 3
+-#define CCR_MONTH 4
+-#define CCR_YEAR 5
+-#define CCR_WDAY 6
+-#define CCR_Y2K 7
+-
+-#define X1205_REG_SR 0x3F /* status register */
+-#define X1205_REG_Y2K 0x37
+-#define X1205_REG_DW 0x36
+-#define X1205_REG_YR 0x35
+-#define X1205_REG_MO 0x34
+-#define X1205_REG_DT 0x33
+-#define X1205_REG_HR 0x32
+-#define X1205_REG_MN 0x31
+-#define X1205_REG_SC 0x30
+-#define X1205_REG_DTR 0x13
+-#define X1205_REG_ATR 0x12
+-#define X1205_REG_INT 0x11
+-#define X1205_REG_0 0x10
+-#define X1205_REG_Y2K1 0x0F
+-#define X1205_REG_DWA1 0x0E
+-#define X1205_REG_YRA1 0x0D
+-#define X1205_REG_MOA1 0x0C
+-#define X1205_REG_DTA1 0x0B
+-#define X1205_REG_HRA1 0x0A
+-#define X1205_REG_MNA1 0x09
+-#define X1205_REG_SCA1 0x08
+-#define X1205_REG_Y2K0 0x07
+-#define X1205_REG_DWA0 0x06
+-#define X1205_REG_YRA0 0x05
+-#define X1205_REG_MOA0 0x04
+-#define X1205_REG_DTA0 0x03
+-#define X1205_REG_HRA0 0x02
+-#define X1205_REG_MNA0 0x01
+-#define X1205_REG_SCA0 0x00
+-
+-#define X1205_CCR_BASE 0x30 /* Base address of CCR */
+-#define X1205_ALM0_BASE 0x00 /* Base address of ALARM0 */
+-
+-#define X1205_SR_RTCF 0x01 /* Clock failure */
+-#define X1205_SR_WEL 0x02 /* Write Enable Latch */
+-#define X1205_SR_RWEL 0x04 /* Register Write Enable */
+-
+-#define X1205_DTR_DTR0 0x01
+-#define X1205_DTR_DTR1 0x02
+-#define X1205_DTR_DTR2 0x04
+-
+-#define X1205_HR_MIL 0x80 /* Set in ccr.hour for 24 hr mode */
+-
+-/* Prototypes */
+-static int x1205_attach(struct i2c_adapter *adapter);
+-static int x1205_detach(struct i2c_client *client);
+-static int x1205_probe(struct i2c_adapter *adapter, int address, int kind);
+-static int x1205_command(struct i2c_client *client, unsigned int cmd,
+- void *arg);
+-
+-static struct i2c_driver x1205_driver = {
+- .driver = {
+- .name = "x1205",
+- },
+- .attach_adapter = &x1205_attach,
+- .detach_client = &x1205_detach,
+-};
+-
+-struct x1205_data {
+- struct i2c_client client;
+- struct list_head list;
+- unsigned int epoch;
+-};
+-
+-static const unsigned char days_in_mo[] =
+- { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+-
+-static LIST_HEAD(x1205_clients);
+-
+-/* Workaround until the I2C subsytem will allow to send
+- * commands to a specific client. This function will send the command
+- * to the first client.
+- */
+-int x1205_do_command(unsigned int cmd, void *arg)
+-{
+- struct list_head *walk;
+- struct list_head *tmp;
+- struct x1205_data *data;
+-
+- list_for_each_safe(walk, tmp, &x1205_clients) {
+- data = list_entry(walk, struct x1205_data, list);
+- return x1205_command(&data->client, cmd, arg);
+- }
+-
+- return -ENODEV;
+-}
+-
+-#define is_leap(year) \
+- ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+-
+-/* make sure the rtc_time values are in bounds */
+-static int x1205_validate_tm(struct rtc_time *tm)
+-{
+- int year = tm->tm_year + 1900;
+-
+- if ((tm->tm_year < 70) || (tm->tm_year > 255))
+- return -EINVAL;
+-
+- if ((tm->tm_mon > 11) || (tm->tm_mday == 0))
+- return -EINVAL;
+-
+- if (tm->tm_mday > days_in_mo[tm->tm_mon]
+- + ((tm->tm_mon == 1) && is_leap(year)))
+- return -EINVAL;
+-
+- if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60))
+- return -EINVAL;
+-
+- return 0;
+-}
+-
+-/*
+- * In the routines that deal directly with the x1205 hardware, we use
+- * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
+- * Epoch is initialized as 2000. Time is set to UTC.
+- */
+-static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
+- u8 reg_base)
+-{
+- unsigned char dt_addr[2] = { 0, reg_base };
+- static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
+-
+- unsigned char buf[8], sr;
+-
+- struct i2c_msg msgs[] = {
+- { client->addr, 0, 2, sr_addr }, /* setup read ptr */
+- { client->addr, I2C_M_RD, 1, &sr }, /* read status */
+- { client->addr, 0, 2, dt_addr }, /* setup read ptr */
+- { client->addr, I2C_M_RD, 8, buf }, /* read date */
+- };
+-
+- struct x1205_data *data = i2c_get_clientdata(client);
+-
+- /* read status register */
+- if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+- dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+- return -EIO;
+- }
+-
+- /* check for battery failure */
+- if (sr & X1205_SR_RTCF) {
+- dev_warn(&client->dev,
+- "Clock had a power failure, you must set the date.\n");
+- return -EINVAL;
+- }
+-
+- /* read date registers */
+- if ((i2c_transfer(client->adapter, &msgs[2], 2)) != 2) {
+- dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+- return -EIO;
+- }
+-
+- dev_dbg(&client->dev,
+- "%s: raw read data - sec=%02x, min=%02x, hr=%02x, "
+- "mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n",
+- __FUNCTION__,
+- buf[0], buf[1], buf[2], buf[3],
+- buf[4], buf[5], buf[6], buf[7]);
+-
+- tm->tm_sec = BCD2BIN(buf[CCR_SEC]);
+- tm->tm_min = BCD2BIN(buf[CCR_MIN]);
+- tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
+- tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
+- tm->tm_mon = BCD2BIN(buf[CCR_MONTH]);
+- data->epoch = BCD2BIN(buf[CCR_Y2K]) * 100;
+- tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + data->epoch - 1900;
+- tm->tm_wday = buf[CCR_WDAY];
+-
+- dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
+- "mday=%d, mon=%d, year=%d, wday=%d\n",
+- __FUNCTION__,
+- tm->tm_sec, tm->tm_min, tm->tm_hour,
+- tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+-
+- return 0;
+-}
+-
+-static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
+- int datetoo, u8 reg_base)
+-{
+- int i, err, xfer;
+-
+- unsigned char buf[8];
+-
+- static const unsigned char wel[3] = { 0, X1205_REG_SR,
+- X1205_SR_WEL };
+-
+- static const unsigned char rwel[3] = { 0, X1205_REG_SR,
+- X1205_SR_WEL | X1205_SR_RWEL };
+-
+- static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
+-
+- struct x1205_data *data = i2c_get_clientdata(client);
+-
+- /* check if all values in the tm struct are correct */
+- if ((err = x1205_validate_tm(tm)) < 0)
+- return err;
+-
+- dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
+- "mday=%d, mon=%d, year=%d, wday=%d\n",
+- __FUNCTION__,
+- tm->tm_sec, tm->tm_min, tm->tm_hour,
+- tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
+-
+- buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
+- buf[CCR_MIN] = BIN2BCD(tm->tm_min);
+-
+- /* set hour and 24hr bit */
+- buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL;
+-
+- /* should we also set the date? */
+- if (datetoo) {
+- buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
+-
+- /* month, 0 - 11 */
+- buf[CCR_MONTH] = BIN2BCD(tm->tm_mon);
+-
+- /* year, since 1900 */
+- buf[CCR_YEAR] = BIN2BCD(tm->tm_year + 1900 - data->epoch);
+- buf[CCR_WDAY] = tm->tm_wday & 0x07;
+- buf[CCR_Y2K] = BIN2BCD(data->epoch / 100);
+- }
+-
+- /* this sequence is required to unlock the chip */
+- xfer = i2c_master_send(client, wel, 3);
+- if (xfer != 3) {
+- dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
+- return -EIO;
+- }
+-
+- xfer = i2c_master_send(client, rwel, 3);
+- if (xfer != 3) {
+- dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
+- return -EIO;
+- }
+-
+- /* write register's data */
+- for (i = 0; i < (datetoo ? 8 : 3); i++) {
+- unsigned char rdata[3] = { 0, reg_base + i, buf[i] };
+-
+- xfer = i2c_master_send(client, rdata, 3);
+- if (xfer != 3) {
+- dev_err(&client->dev,
+- "%s: xfer=%d addr=%02x, data=%02x\n",
+- __FUNCTION__,
+- xfer, rdata[1], rdata[2]);
+- return -EIO;
+- }
+- };
+-
+- /* disable further writes */
+- xfer = i2c_master_send(client, diswe, 3);
+- if (xfer != 3) {
+- dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
+- return -EIO;
+- }
+-
+- return 0;
+-}
+-
+-static int x1205_get_dtrim(struct i2c_client *client, int *trim)
+-{
+- unsigned char dtr;
+- static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR };
+-
+- struct i2c_msg msgs[] = {
+- { client->addr, 0, 2, dtr_addr }, /* setup read ptr */
+- { client->addr, I2C_M_RD, 1, &dtr }, /* read dtr */
+- };
+-
+- /* read dtr register */
+- if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+- dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+- return -EIO;
+- }
+-
+- dev_dbg(&client->dev, "%s: raw dtr=%x\n", __FUNCTION__, dtr);
+-
+- *trim = 0;
+-
+- if (dtr & X1205_DTR_DTR0)
+- *trim += 20;
+-
+- if (dtr & X1205_DTR_DTR1)
+- *trim += 10;
+-
+- if (dtr & X1205_DTR_DTR2)
+- *trim = -*trim;
+-
+- return 0;
+-}
+-
+-static int x1205_get_atrim(struct i2c_client *client, int *trim)
+-{
+- s8 atr;
+- static unsigned char atr_addr[2] = { 0, X1205_REG_ATR };
+-
+- struct i2c_msg msgs[] = {
+- { client->addr, 0, 2, atr_addr }, /* setup read ptr */
+- { client->addr, I2C_M_RD, 1, &atr }, /* read atr */
+- };
+-
+- /* read atr register */
+- if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+- dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+- return -EIO;
+- }
+-
+- dev_dbg(&client->dev, "%s: raw atr=%x\n", __FUNCTION__, atr);
+-
+- /* atr is a two's complement value on 6 bits,
+- * perform sign extension. The formula is
+- * Catr = (atr * 0.25pF) + 11.00pF.
+- */
+- if (atr & 0x20)
+- atr |= 0xC0;
+-
+- dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __FUNCTION__, atr, atr);
+-
+- *trim = (atr * 250) + 11000;
+-
+- dev_dbg(&client->dev, "%s: real=%d\n", __FUNCTION__, *trim);
+-
+- return 0;
+-}
+-
+-static int x1205_hctosys(struct i2c_client *client)
+-{
+- int err;
+-
+- struct rtc_time tm;
+- struct timespec tv;
+-
+- err = x1205_command(client, X1205_CMD_GETDATETIME, &tm);
+-
+- if (err) {
+- dev_err(&client->dev,
+- "Unable to set the system clock\n");
+- return err;
+- }
+-
+- /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
+- * whether it stores the most close value or the value with partial
+- * seconds truncated. However, it is important that we use it to store
+- * the truncated value. This is because otherwise it is necessary,
+- * in an rtc sync function, to read both xtime.tv_sec and
+- * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
+- * of >32bits is not possible. So storing the most close value would
+- * slow down the sync API. So here we have the truncated value and
+- * the best guess is to add 0.5s.
+- */
+-
+- tv.tv_nsec = NSEC_PER_SEC >> 1;
+-
+- /* WARNING: this is not the C library 'mktime' call, it is a built in
+- * inline function from include/linux/time.h. It expects (requires)
+- * the month to be in the range 1-12
+- */
+-
+- tv.tv_sec = mktime(tm.tm_year + 1900, tm.tm_mon + 1,
+- tm.tm_mday, tm.tm_hour,
+- tm.tm_min, tm.tm_sec);
+-
+- do_settimeofday(&tv);
+-
+- dev_info(&client->dev,
+- "setting the system clock to %d-%d-%d %d:%d:%d\n",
+- tm.tm_year + 1900, tm.tm_mon + 1,
+- tm.tm_mday, tm.tm_hour, tm.tm_min,
+- tm.tm_sec);
+-
+- return 0;
+-}
+-
+-struct x1205_limit
+-{
+- unsigned char reg;
+- unsigned char mask;
+- unsigned char min;
+- unsigned char max;
+-};
+-
+-static int x1205_validate_client(struct i2c_client *client)
+-{
+- int i, xfer;
+-
+- /* Probe array. We will read the register at the specified
+- * address and check if the given bits are zero.
+- */
+- static const unsigned char probe_zero_pattern[] = {
+- /* register, mask */
+- X1205_REG_SR, 0x18,
+- X1205_REG_DTR, 0xF8,
+- X1205_REG_ATR, 0xC0,
+- X1205_REG_INT, 0x18,
+- X1205_REG_0, 0xFF,
+- };
+-
+- static const struct x1205_limit probe_limits_pattern[] = {
+- /* register, mask, min, max */
+- { X1205_REG_Y2K, 0xFF, 19, 20 },
+- { X1205_REG_DW, 0xFF, 0, 6 },
+- { X1205_REG_YR, 0xFF, 0, 99 },
+- { X1205_REG_MO, 0xFF, 0, 12 },
+- { X1205_REG_DT, 0xFF, 0, 31 },
+- { X1205_REG_HR, 0x7F, 0, 23 },
+- { X1205_REG_MN, 0xFF, 0, 59 },
+- { X1205_REG_SC, 0xFF, 0, 59 },
+- { X1205_REG_Y2K1, 0xFF, 19, 20 },
+- { X1205_REG_Y2K0, 0xFF, 19, 20 },
+- };
+-
+- /* check that registers have bits a 0 where expected */
+- for (i = 0; i < ARRAY_SIZE(probe_zero_pattern); i += 2) {
+- unsigned char buf;
+-
+- unsigned char addr[2] = { 0, probe_zero_pattern[i] };
+-
+- struct i2c_msg msgs[2] = {
+- { client->addr, 0, 2, addr },
+- { client->addr, I2C_M_RD, 1, &buf },
+- };
+-
+- xfer = i2c_transfer(client->adapter, msgs, 2);
+- if (xfer != 2) {
+- dev_err(&client->adapter->dev,
+- "%s: could not read register %x\n",
+- __FUNCTION__, addr[1]);
+-
+- return -EIO;
+- }
+-
+- if ((buf & probe_zero_pattern[i+1]) != 0) {
+- dev_err(&client->adapter->dev,
+- "%s: register=%02x, zero pattern=%d, value=%x\n",
+- __FUNCTION__, addr[1], i, buf);
+-
+- return -ENODEV;
+- }
+- }
+-
+- /* check limits (only registers with bcd values) */
+- for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) {
+- unsigned char reg, value;
+-
+- unsigned char addr[2] = { 0, probe_limits_pattern[i].reg };
+-
+- struct i2c_msg msgs[2] = {
+- { client->addr, 0, 2, addr },
+- { client->addr, I2C_M_RD, 1, &reg },
+- };
+-
+- xfer = i2c_transfer(client->adapter, msgs, 2);
+-
+- if (xfer != 2) {
+- dev_err(&client->adapter->dev,
+- "%s: could not read register %x\n",
+- __FUNCTION__, addr[1]);
+-
+- return -EIO;
+- }
+-
+- value = BCD2BIN(reg & probe_limits_pattern[i].mask);
+-
+- if (value > probe_limits_pattern[i].max ||
+- value < probe_limits_pattern[i].min) {
+- dev_dbg(&client->adapter->dev,
+- "%s: register=%x, lim pattern=%d, value=%d\n",
+- __FUNCTION__, addr[1], i, value);
+-
+- return -ENODEV;
+- }
+- }
+-
+- return 0;
+-}
+-
+-static int x1205_attach(struct i2c_adapter *adapter)
+-{
+- dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+-
+- return i2c_probe(adapter, &addr_data, x1205_probe);
+-}
+-
+-int x1205_direct_attach(int adapter_id,
+- struct i2c_client_address_data *address_data)
+-{
+- int err;
+- struct i2c_adapter *adapter = i2c_get_adapter(adapter_id);
+-
+- if (adapter) {
+- err = i2c_probe(adapter,
+- address_data, x1205_probe);
+-
+- i2c_put_adapter(adapter);
+-
+- return err;
+- }
+-
+- return -ENODEV;
+-}
+-
+-static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
+-{
+- struct i2c_client *client;
+- struct x1205_data *data;
+-
+- int err = 0;
+-
+- dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+-
+- if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+- err = -ENODEV;
+- goto exit;
+- }
+-
+- if (!(data = kzalloc(sizeof(struct x1205_data), GFP_KERNEL))) {
+- err = -ENOMEM;
+- goto exit;
+- }
+-
+- /* Initialize our structures */
+- data->epoch = 2000;
+-
+- client = &data->client;
+- client->addr = address;
+- client->driver = &x1205_driver;
+- client->adapter = adapter;
+-
+- strlcpy(client->name, "x1205", I2C_NAME_SIZE);
+-
+- i2c_set_clientdata(client, data);
+-
+- /* Verify the chip is really an X1205 */
+- if (kind < 0) {
+- if (x1205_validate_client(client) < 0) {
+- err = -ENODEV;
+- goto exit_kfree;
+- }
+- }
+-
+- /* Inform the i2c layer */
+- if ((err = i2c_attach_client(client)))
+- goto exit_kfree;
+-
+- list_add(&data->list, &x1205_clients);
+-
+- dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+-
+- /* If requested, set the system time */
+- if (hctosys)
+- x1205_hctosys(client);
+-
+- return 0;
+-
+-exit_kfree:
+- kfree(data);
+-
+-exit:
+- return err;
+-}
+-
+-static int x1205_detach(struct i2c_client *client)
+-{
+- int err;
+- struct x1205_data *data = i2c_get_clientdata(client);
+-
+- dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+-
+- if ((err = i2c_detach_client(client)))
+- return err;
+-
+- list_del(&data->list);
+-
+- kfree(data);
+-
+- return 0;
+-}
+-
+-static int x1205_command(struct i2c_client *client, unsigned int cmd,
+- void *param)
+-{
+- if (param == NULL)
+- return -EINVAL;
+-
+- if (!capable(CAP_SYS_TIME))
+- return -EACCES;
+-
+- dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd);
+-
+- switch (cmd) {
+- case X1205_CMD_GETDATETIME:
+- return x1205_get_datetime(client, param, X1205_CCR_BASE);
+-
+- case X1205_CMD_SETTIME:
+- return x1205_set_datetime(client, param, 0,
+- X1205_CCR_BASE);
+-
+- case X1205_CMD_SETDATETIME:
+- return x1205_set_datetime(client, param, 1,
+- X1205_CCR_BASE);
+-
+- case X1205_CMD_GETALARM:
+- return x1205_get_datetime(client, param, X1205_ALM0_BASE);
+-
+- case X1205_CMD_SETALARM:
+- return x1205_set_datetime(client, param, 1,
+- X1205_ALM0_BASE);
+-
+- case X1205_CMD_GETDTRIM:
+- return x1205_get_dtrim(client, param);
+-
+- case X1205_CMD_GETATRIM:
+- return x1205_get_atrim(client, param);
+-
+- default:
+- return -EINVAL;
+- }
+-}
+-
+-static int __init x1205_init(void)
+-{
+- return i2c_add_driver(&x1205_driver);
+-}
+-
+-static void __exit x1205_exit(void)
+-{
+- i2c_del_driver(&x1205_driver);
+-}
+-
+-MODULE_AUTHOR(
+- "Karen Spearel <kas11@tampabay.rr.com>, "
+- "Alessandro Zummo <a.zummo@towertech.it>");
+-MODULE_DESCRIPTION("Xicor X1205 RTC driver");
+-MODULE_LICENSE("GPL");
+-MODULE_VERSION(DRV_VERSION);
+-
+-EXPORT_SYMBOL_GPL(x1205_do_command);
+-EXPORT_SYMBOL_GPL(x1205_direct_attach);
+-
+-module_init(x1205_init);
+-module_exit(x1205_exit);
+--- linux-rtc.orig/drivers/i2c/chips/Makefile 2006-02-21 00:34:27.000000000 +0100
++++ linux-rtc/drivers/i2c/chips/Makefile 2006-02-21 00:36:43.000000000 +0100
+@@ -10,10 +10,8 @@ obj-$(CONFIG_SENSORS_M41T00) += m41t00.o
+ obj-$(CONFIG_SENSORS_PCA9539) += pca9539.o
+ obj-$(CONFIG_SENSORS_PCF8574) += pcf8574.o
+ obj-$(CONFIG_SENSORS_PCF8591) += pcf8591.o
+-obj-$(CONFIG_SENSORS_RTC8564) += rtc8564.o
+ obj-$(CONFIG_ISP1301_OMAP) += isp1301_omap.o
+ obj-$(CONFIG_TPS65010) += tps65010.o
+-obj-$(CONFIG_RTC_X1205_I2C) += x1205.o
+
+ ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
+ EXTRA_CFLAGS += -DDEBUG
+--- linux-rtc.orig/drivers/i2c/chips/rtc8564.c 2006-02-21 00:34:27.000000000 +0100
++++ /dev/null 1970-01-01 00:00:00.000000000 +0000
+@@ -1,385 +0,0 @@
+-/*
+- * linux/drivers/i2c/chips/rtc8564.c
+- *
+- * Copyright (C) 2002-2004 Stefan Eletzhofer
+- *
+- * based on linux/drivers/acron/char/pcf8583.c
+- * Copyright (C) 2000 Russell King
+- *
+- * 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.
+- *
+- * Driver for system3's EPSON RTC 8564 chip
+- */
+-#include <linux/module.h>
+-#include <linux/kernel.h>
+-#include <linux/bcd.h>
+-#include <linux/i2c.h>
+-#include <linux/slab.h>
+-#include <linux/string.h>
+-#include <linux/rtc.h> /* get the user-level API */
+-#include <linux/init.h>
+-
+-#include "rtc8564.h"
+-
+-#ifdef DEBUG
+-# define _DBG(x, fmt, args...) do{ if (debug>=x) printk(KERN_DEBUG"%s: " fmt "\n", __FUNCTION__, ##args); } while(0);
+-#else
+-# define _DBG(x, fmt, args...) do { } while(0);
+-#endif
+-
+-#define _DBGRTCTM(x, rtctm) if (debug>=x) printk("%s: secs=%d, mins=%d, hours=%d, mday=%d, " \
+- "mon=%d, year=%d, wday=%d VL=%d\n", __FUNCTION__, \
+- (rtctm).secs, (rtctm).mins, (rtctm).hours, (rtctm).mday, \
+- (rtctm).mon, (rtctm).year, (rtctm).wday, (rtctm).vl);
+-
+-struct rtc8564_data {
+- struct i2c_client client;
+- u16 ctrl;
+-};
+-
+-static inline u8 _rtc8564_ctrl1(struct i2c_client *client)
+-{
+- struct rtc8564_data *data = i2c_get_clientdata(client);
+- return data->ctrl & 0xff;
+-}
+-static inline u8 _rtc8564_ctrl2(struct i2c_client *client)
+-{
+- struct rtc8564_data *data = i2c_get_clientdata(client);
+- return (data->ctrl & 0xff00) >> 8;
+-}
+-
+-#define CTRL1(c) _rtc8564_ctrl1(c)
+-#define CTRL2(c) _rtc8564_ctrl2(c)
+-
+-static int debug;;
+-module_param(debug, int, S_IRUGO | S_IWUSR);
+-
+-static struct i2c_driver rtc8564_driver;
+-
+-static unsigned short ignore[] = { I2C_CLIENT_END };
+-static unsigned short normal_addr[] = { 0x51, I2C_CLIENT_END };
+-
+-static struct i2c_client_address_data addr_data = {
+- .normal_i2c = normal_addr,
+- .probe = ignore,
+- .ignore = ignore,
+-};
+-
+-static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem);
+-static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem);
+-
+-static int rtc8564_read(struct i2c_client *client, unsigned char adr,
+- unsigned char *buf, unsigned char len)
+-{
+- int ret = -EIO;
+- unsigned char addr[1] = { adr };
+- struct i2c_msg msgs[2] = {
+- {client->addr, 0, 1, addr},
+- {client->addr, I2C_M_RD, len, buf}
+- };
+-
+- _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, buf, len);
+-
+- if (!buf) {
+- ret = -EINVAL;
+- goto done;
+- }
+-
+- ret = i2c_transfer(client->adapter, msgs, 2);
+- if (ret == 2) {
+- ret = 0;
+- }
+-
+-done:
+- return ret;
+-}
+-
+-static int rtc8564_write(struct i2c_client *client, unsigned char adr,
+- unsigned char *data, unsigned char len)
+-{
+- int ret = 0;
+- unsigned char _data[16];
+- struct i2c_msg wr;
+- int i;
+-
+- if (!data || len > 15) {
+- ret = -EINVAL;
+- goto done;
+- }
+-
+- _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, data, len);
+-
+- _data[0] = adr;
+- for (i = 0; i < len; i++) {
+- _data[i + 1] = data[i];
+- _DBG(5, "data[%d] = 0x%02x (%d)", i, data[i], data[i]);
+- }
+-
+- wr.addr = client->addr;
+- wr.flags = 0;
+- wr.len = len + 1;
+- wr.buf = _data;
+-
+- ret = i2c_transfer(client->adapter, &wr, 1);
+- if (ret == 1) {
+- ret = 0;
+- }
+-
+-done:
+- return ret;
+-}
+-
+-static int rtc8564_attach(struct i2c_adapter *adap, int addr, int kind)
+-{
+- int ret;
+- struct i2c_client *new_client;
+- struct rtc8564_data *d;
+- unsigned char data[10];
+- unsigned char ad[1] = { 0 };
+- struct i2c_msg ctrl_wr[1] = {
+- {addr, 0, 2, data}
+- };
+- struct i2c_msg ctrl_rd[2] = {
+- {addr, 0, 1, ad},
+- {addr, I2C_M_RD, 2, data}
+- };
+-
+- d = kzalloc(sizeof(struct rtc8564_data), GFP_KERNEL);
+- if (!d) {
+- ret = -ENOMEM;
+- goto done;
+- }
+- new_client = &d->client;
+-
+- strlcpy(new_client->name, "RTC8564", I2C_NAME_SIZE);
+- i2c_set_clientdata(new_client, d);
+- new_client->addr = addr;
+- new_client->adapter = adap;
+- new_client->driver = &rtc8564_driver;
+-
+- _DBG(1, "client=%p", new_client);
+-
+- /* init ctrl1 reg */
+- data[0] = 0;
+- data[1] = 0;
+- ret = i2c_transfer(new_client->adapter, ctrl_wr, 1);
+- if (ret != 1) {
+- printk(KERN_INFO "rtc8564: cant init ctrl1\n");
+- ret = -ENODEV;
+- goto done;
+- }
+-
+- /* read back ctrl1 and ctrl2 */
+- ret = i2c_transfer(new_client->adapter, ctrl_rd, 2);
+- if (ret != 2) {
+- printk(KERN_INFO "rtc8564: cant read ctrl\n");
+- ret = -ENODEV;
+- goto done;
+- }
+-
+- d->ctrl = data[0] | (data[1] << 8);
+-
+- _DBG(1, "RTC8564_REG_CTRL1=%02x, RTC8564_REG_CTRL2=%02x",
+- data[0], data[1]);
+-
+- ret = i2c_attach_client(new_client);
+-done:
+- if (ret) {
+- kfree(d);
+- }
+- return ret;
+-}
+-
+-static int rtc8564_probe(struct i2c_adapter *adap)
+-{
+- return i2c_probe(adap, &addr_data, rtc8564_attach);
+-}
+-
+-static int rtc8564_detach(struct i2c_client *client)
+-{
+- i2c_detach_client(client);
+- kfree(i2c_get_clientdata(client));
+- return 0;
+-}
+-
+-static int rtc8564_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
+-{
+- int ret = -EIO;
+- unsigned char buf[15];
+-
+- _DBG(1, "client=%p, dt=%p", client, dt);
+-
+- if (!dt)
+- return -EINVAL;
+-
+- memset(buf, 0, sizeof(buf));
+-
+- ret = rtc8564_read(client, 0, buf, 15);
+- if (ret)
+- return ret;
+-
+- /* century stored in minute alarm reg */
+- dt->year = BCD2BIN(buf[RTC8564_REG_YEAR]);
+- dt->year += 100 * BCD2BIN(buf[RTC8564_REG_AL_MIN] & 0x3f);
+- dt->mday = BCD2BIN(buf[RTC8564_REG_DAY] & 0x3f);
+- dt->wday = BCD2BIN(buf[RTC8564_REG_WDAY] & 7);
+- dt->mon = BCD2BIN(buf[RTC8564_REG_MON_CENT] & 0x1f);
+-
+- dt->secs = BCD2BIN(buf[RTC8564_REG_SEC] & 0x7f);
+- dt->vl = (buf[RTC8564_REG_SEC] & 0x80) == 0x80;
+- dt->mins = BCD2BIN(buf[RTC8564_REG_MIN] & 0x7f);
+- dt->hours = BCD2BIN(buf[RTC8564_REG_HR] & 0x3f);
+-
+- _DBGRTCTM(2, *dt);
+-
+- return 0;
+-}
+-
+-static int
+-rtc8564_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
+-{
+- int ret, len = 5;
+- unsigned char buf[15];
+-
+- _DBG(1, "client=%p, dt=%p", client, dt);
+-
+- if (!dt)
+- return -EINVAL;
+-
+- _DBGRTCTM(2, *dt);
+-
+- buf[RTC8564_REG_CTRL1] = CTRL1(client) | RTC8564_CTRL1_STOP;
+- buf[RTC8564_REG_CTRL2] = CTRL2(client);
+- buf[RTC8564_REG_SEC] = BIN2BCD(dt->secs);
+- buf[RTC8564_REG_MIN] = BIN2BCD(dt->mins);
+- buf[RTC8564_REG_HR] = BIN2BCD(dt->hours);
+-
+- if (datetoo) {
+- len += 5;
+- buf[RTC8564_REG_DAY] = BIN2BCD(dt->mday);
+- buf[RTC8564_REG_WDAY] = BIN2BCD(dt->wday);
+- buf[RTC8564_REG_MON_CENT] = BIN2BCD(dt->mon) & 0x1f;
+- /* century stored in minute alarm reg */
+- buf[RTC8564_REG_YEAR] = BIN2BCD(dt->year % 100);
+- buf[RTC8564_REG_AL_MIN] = BIN2BCD(dt->year / 100);
+- }
+-
+- ret = rtc8564_write(client, 0, buf, len);
+- if (ret) {
+- _DBG(1, "error writing data! %d", ret);
+- }
+-
+- buf[RTC8564_REG_CTRL1] = CTRL1(client);
+- ret = rtc8564_write(client, 0, buf, 1);
+- if (ret) {
+- _DBG(1, "error writing data! %d", ret);
+- }
+-
+- return ret;
+-}
+-
+-static int rtc8564_get_ctrl(struct i2c_client *client, unsigned int *ctrl)
+-{
+- struct rtc8564_data *data = i2c_get_clientdata(client);
+-
+- if (!ctrl)
+- return -1;
+-
+- *ctrl = data->ctrl;
+- return 0;
+-}
+-
+-static int rtc8564_set_ctrl(struct i2c_client *client, unsigned int *ctrl)
+-{
+- struct rtc8564_data *data = i2c_get_clientdata(client);
+- unsigned char buf[2];
+-
+- if (!ctrl)
+- return -1;
+-
+- buf[0] = *ctrl & 0xff;
+- buf[1] = (*ctrl & 0xff00) >> 8;
+- data->ctrl = *ctrl;
+-
+- return rtc8564_write(client, 0, buf, 2);
+-}
+-
+-static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem)
+-{
+-
+- if (!mem)
+- return -EINVAL;
+-
+- return rtc8564_read(client, mem->loc, mem->data, mem->nr);
+-}
+-
+-static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem)
+-{
+-
+- if (!mem)
+- return -EINVAL;
+-
+- return rtc8564_write(client, mem->loc, mem->data, mem->nr);
+-}
+-
+-static int
+-rtc8564_command(struct i2c_client *client, unsigned int cmd, void *arg)
+-{
+-
+- _DBG(1, "cmd=%d", cmd);
+-
+- switch (cmd) {
+- case RTC_GETDATETIME:
+- return rtc8564_get_datetime(client, arg);
+-
+- case RTC_SETTIME:
+- return rtc8564_set_datetime(client, arg, 0);
+-
+- case RTC_SETDATETIME:
+- return rtc8564_set_datetime(client, arg, 1);
+-
+- case RTC_GETCTRL:
+- return rtc8564_get_ctrl(client, arg);
+-
+- case RTC_SETCTRL:
+- return rtc8564_set_ctrl(client, arg);
+-
+- case MEM_READ:
+- return rtc8564_read_mem(client, arg);
+-
+- case MEM_WRITE:
+- return rtc8564_write_mem(client, arg);
+-
+- default:
+- return -EINVAL;
+- }
+-}
+-
+-static struct i2c_driver rtc8564_driver = {
+- .driver = {
+- .name = "RTC8564",
+- },
+- .id = I2C_DRIVERID_RTC8564,
+- .attach_adapter = rtc8564_probe,
+- .detach_client = rtc8564_detach,
+- .command = rtc8564_command
+-};
+-
+-static __init int rtc8564_init(void)
+-{
+- return i2c_add_driver(&rtc8564_driver);
+-}
+-
+-static __exit void rtc8564_exit(void)
+-{
+- i2c_del_driver(&rtc8564_driver);
+-}
+-
+-MODULE_AUTHOR("Stefan Eletzhofer <Stefan.Eletzhofer@eletztrick.de>");
+-MODULE_DESCRIPTION("EPSON RTC8564 Driver");
+-MODULE_LICENSE("GPL");
+-
+-module_init(rtc8564_init);
+-module_exit(rtc8564_exit);
+--- linux-rtc.orig/drivers/i2c/chips/rtc8564.h 2006-02-21 00:34:27.000000000 +0100
++++ /dev/null 1970-01-01 00:00:00.000000000 +0000
+@@ -1,78 +0,0 @@
+-/*
+- * linux/drivers/i2c/chips/rtc8564.h
+- *
+- * Copyright (C) 2002-2004 Stefan Eletzhofer
+- *
+- * based on linux/drivers/acron/char/pcf8583.h
+- * Copyright (C) 2000 Russell King
+- *
+- * 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.
+- */
+-struct rtc_tm {
+- unsigned char secs;
+- unsigned char mins;
+- unsigned char hours;
+- unsigned char mday;
+- unsigned char mon;
+- unsigned short year; /* xxxx 4 digits :) */
+- unsigned char wday;
+- unsigned char vl;
+-};
+-
+-struct mem {
+- unsigned int loc;
+- unsigned int nr;
+- unsigned char *data;
+-};
+-
+-#define RTC_GETDATETIME 0
+-#define RTC_SETTIME 1
+-#define RTC_SETDATETIME 2
+-#define RTC_GETCTRL 3
+-#define RTC_SETCTRL 4
+-#define MEM_READ 5
+-#define MEM_WRITE 6
+-
+-#define RTC8564_REG_CTRL1 0x0 /* T 0 S 0 | T 0 0 0 */
+-#define RTC8564_REG_CTRL2 0x1 /* 0 0 0 TI/TP | AF TF AIE TIE */
+-#define RTC8564_REG_SEC 0x2 /* VL 4 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_MIN 0x3 /* x 4 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_HR 0x4 /* x x 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_DAY 0x5 /* x x 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_WDAY 0x6 /* x x x x | x 4 2 1 */
+-#define RTC8564_REG_MON_CENT 0x7 /* C x x 1 | 8 4 2 1 */
+-#define RTC8564_REG_YEAR 0x8 /* 8 4 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_AL_MIN 0x9 /* AE 4 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_AL_HR 0xa /* AE 4 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_AL_DAY 0xb /* AE x 2 1 | 8 4 2 1 */
+-#define RTC8564_REG_AL_WDAY 0xc /* AE x x x | x 4 2 1 */
+-#define RTC8564_REG_CLKOUT 0xd /* FE x x x | x x FD1 FD0 */
+-#define RTC8564_REG_TCTL 0xe /* TE x x x | x x FD1 FD0 */
+-#define RTC8564_REG_TIMER 0xf /* 8 bit binary */
+-
+-/* Control reg */
+-#define RTC8564_CTRL1_TEST1 (1<<3)
+-#define RTC8564_CTRL1_STOP (1<<5)
+-#define RTC8564_CTRL1_TEST2 (1<<7)
+-
+-#define RTC8564_CTRL2_TIE (1<<0)
+-#define RTC8564_CTRL2_AIE (1<<1)
+-#define RTC8564_CTRL2_TF (1<<2)
+-#define RTC8564_CTRL2_AF (1<<3)
+-#define RTC8564_CTRL2_TI_TP (1<<4)
+-
+-/* CLKOUT frequencies */
+-#define RTC8564_FD_32768HZ (0x0)
+-#define RTC8564_FD_1024HZ (0x1)
+-#define RTC8564_FD_32 (0x2)
+-#define RTC8564_FD_1HZ (0x3)
+-
+-/* Timer CTRL */
+-#define RTC8564_TD_4096HZ (0x0)
+-#define RTC8564_TD_64HZ (0x1)
+-#define RTC8564_TD_1HZ (0x2)
+-#define RTC8564_TD_1_60HZ (0x3)
+-
+-#define I2C_DRIVERID_RTC8564 0xf000
+--- linux-rtc.orig/include/linux/x1205.h 2006-02-21 00:34:27.000000000 +0100
++++ /dev/null 1970-01-01 00:00:00.000000000 +0000
+@@ -1,31 +0,0 @@
+-/*
+- * x1205.h - defines for drivers/i2c/chips/x1205.c
+- * Copyright 2004 Karen Spearel
+- * Copyright 2005 Alessandro Zummo
+- *
+- * This program is free software; you can redistribute it and/or modify
+- * it under the terms of the GNU General Public License as published by
+- * the Free Software Foundation; either version 2 of the License, or
+- * (at your option) any later version.
+- */
+-
+-#ifndef __LINUX_X1205_H__
+-#define __LINUX_X1205_H__
+-
+-/* commands */
+-
+-#define X1205_CMD_GETDATETIME 0
+-#define X1205_CMD_SETTIME 1
+-#define X1205_CMD_SETDATETIME 2
+-#define X1205_CMD_GETALARM 3
+-#define X1205_CMD_SETALARM 4
+-#define X1205_CMD_GETDTRIM 5
+-#define X1205_CMD_SETDTRIM 6
+-#define X1205_CMD_GETATRIM 7
+-#define X1205_CMD_SETATRIM 8
+-
+-extern int x1205_do_command(unsigned int cmd, void *arg);
+-extern int x1205_direct_attach(int adapter_id,
+- struct i2c_client_address_data *address_data);
+-
+-#endif /* __LINUX_X1205_H__ */
+--- linux-rtc.orig/drivers/i2c/chips/Kconfig 2006-02-21 00:34:27.000000000 +0100
++++ linux-rtc/drivers/i2c/chips/Kconfig 2006-02-21 00:36:43.000000000 +0100
+@@ -65,15 +65,6 @@ config SENSORS_PCF8591
+ This driver can also be built as a module. If so, the module
+ will be called pcf8591.
+
+-config SENSORS_RTC8564
+- tristate "Epson 8564 RTC chip"
+- depends on I2C && EXPERIMENTAL
+- help
+- If you say yes here you get support for the Epson 8564 RTC chip.
+-
+- This driver can also be built as a module. If so, the module
+- will be called i2c-rtc8564.
+-
+ config ISP1301_OMAP
+ tristate "Philips ISP1301 with OMAP OTG"
+ depends on I2C && ARCH_OMAP_OTG
+@@ -126,13 +117,4 @@ config SENSORS_MAX6875
+ This driver can also be built as a module. If so, the module
+ will be called max6875.
+
+-config RTC_X1205_I2C
+- tristate "Xicor X1205 RTC chip"
+- depends on I2C && EXPERIMENTAL
+- help
+- If you say yes here you get support for the Xicor X1205 RTC chip.
+-
+- This driver can also be built as a module. If so, the module
+- will be called x1205.
+-
+ endmenu
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-sysfs.c 2006-02-06 23:56:37.000000000 +0100
-@@ -0,0 +1,113 @@
++++ linux-rtc/drivers/rtc/rtc-sysfs.c 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,120 @@
+/*
+ * RTC subsystem, sysfs interface
+ *
@@ -1059,8 +2365,7 @@
+
+static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf)
+{
-+ ssize_t retval = -ENODEV;
-+ struct rtc_device *rtc = to_rtc_device(dev);
++ ssize_t retval;
+ struct rtc_time tm;
+
+ if ((retval = rtc_read_time(dev, &tm)) == 0) {
@@ -1074,8 +2379,7 @@
+
+static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf)
+{
-+ ssize_t retval = -ENODEV;
-+ struct rtc_device *rtc = to_rtc_device(dev);
++ ssize_t retval;
+ struct rtc_time tm;
+
+ if ((retval = rtc_read_time(dev, &tm)) == 0) {
@@ -1089,8 +2393,7 @@
+
+static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf)
+{
-+ ssize_t retval = -ENODEV;
-+ struct rtc_device *rtc = to_rtc_device(dev);
++ ssize_t retval;
+ struct rtc_time tm;
+
+ if ((retval = rtc_read_time(dev, &tm)) == 0) {
@@ -1103,26 +2406,36 @@
+}
+static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL);
+
-+/* insertion/removal hooks */
++static struct attribute *rtc_attrs[] = {
++ &class_device_attr_name.attr,
++ &class_device_attr_date.attr,
++ &class_device_attr_time.attr,
++ &class_device_attr_since_epoch.attr,
++ NULL,
++};
++
++static struct attribute_group rtc_attr_group = {
++ .attrs = rtc_attrs,
++};
+
+static int __devinit rtc_sysfs_add_device(struct class_device *class_dev,
+ struct class_interface *class_intf)
+{
-+ class_device_create_file(class_dev, &class_device_attr_name);
-+ class_device_create_file(class_dev, &class_device_attr_date);
-+ class_device_create_file(class_dev, &class_device_attr_time);
-+ class_device_create_file(class_dev, &class_device_attr_since_epoch);
++ int err;
++
+ dev_info(class_dev->dev, "rtc intf: sysfs\n");
-+ return 0;
++
++ if ((err = sysfs_create_group(&class_dev->kobj, &rtc_attr_group)) != 0)
++ dev_err(class_dev->dev,
++ "failed to create sysfs attributes\n");
++
++ return err;
+}
+
+static void rtc_sysfs_remove_device(struct class_device *class_dev,
+ struct class_interface *class_intf)
+{
-+ class_device_remove_file(class_dev, &class_device_attr_name);
-+ class_device_remove_file(class_dev, &class_device_attr_date);
-+ class_device_remove_file(class_dev, &class_device_attr_time);
-+ class_device_remove_file(class_dev, &class_device_attr_since_epoch);
++ sysfs_remove_group(&class_dev->kobj, &rtc_attr_group);
+}
+
+/* interface registration */
@@ -1149,7 +2462,7 @@
+MODULE_DESCRIPTION("RTC class sysfs interface");
+MODULE_LICENSE("GPL");
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-proc.c 2006-02-06 23:58:32.000000000 +0100
++++ linux-rtc/drivers/rtc/rtc-proc.c 2006-02-21 00:36:43.000000000 +0100
@@ -0,0 +1,158 @@
+/*
+ * RTC subsystem, proc interface
@@ -1170,7 +2483,7 @@
+#include <linux/seq_file.h>
+
+static struct class_device *rtc_dev = NULL;
-+static DECLARE_MUTEX(rtc_sem);
++static DEFINE_MUTEX(rtc_lock);
+
+static int rtc_proc_show(struct seq_file *seq, void *offset)
+{
@@ -1254,7 +2567,7 @@
+static int rtc_proc_add_device(struct class_device *class_dev,
+ struct class_interface *class_intf)
+{
-+ down(&rtc_sem);
++ mutex_lock(&rtc_lock);
+ if (rtc_dev == NULL) {
+ struct proc_dir_entry *ent;
+
@@ -1272,7 +2585,7 @@
+ else
+ rtc_dev = NULL;
+ }
-+ up(&rtc_sem);
++ mutex_unlock(&rtc_lock);
+
+ return 0;
+}
@@ -1280,12 +2593,12 @@
+static void rtc_proc_remove_device(struct class_device *class_dev,
+ struct class_interface *class_intf)
+{
-+ down(&rtc_sem);
++ mutex_lock(&rtc_lock);
+ if (rtc_dev == class_dev) {
+ remove_proc_entry("driver/rtc", NULL);
+ rtc_dev = NULL;
+ }
-+ up(&rtc_sem);
++ mutex_unlock(&rtc_lock);
+}
+
+struct class_interface rtc_proc_interface = {
@@ -1310,8 +2623,8 @@
+MODULE_DESCRIPTION("RTC class proc interface");
+MODULE_LICENSE("GPL");
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-dev.c 2006-02-06 23:58:32.000000000 +0100
-@@ -0,0 +1,366 @@
++++ linux-rtc/drivers/rtc/rtc-dev.c 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,370 @@
+/*
+ * RTC subsystem, dev interface
+ *
@@ -1342,7 +2655,7 @@
+ /* We keep the lock as long as the device is in use
+ * and return immediately if busy
+ */
-+ if (down_trylock(&rtc->char_sem))
++ if (!(mutex_trylock(&rtc->char_lock)))
+ return -EBUSY;
+
+ file->private_data = &rtc->class_dev;
@@ -1358,7 +2671,7 @@
+ }
+
+ /* something has gone wrong, release the lock */
-+ up(&rtc->char_sem);
++ mutex_unlock(&rtc->char_lock);
+ return err;
+}
+
@@ -1402,6 +2715,10 @@
+ remove_wait_queue(&rtc->irq_queue, &wait);
+
+ if (ret == 0) {
++ /* Check for any data updates */
++ if (rtc->ops->read_callback)
++ data = rtc->ops->read_callback(rtc->class_dev.dev, data);
++
+ ret = put_user(data, (unsigned long __user *)buf);
+ if (ret == 0)
+ ret = sizeof(unsigned long);
@@ -1549,7 +2866,7 @@
+ if (rtc->ops->release)
+ rtc->ops->release(rtc->class_dev.dev);
+
-+ up(&rtc->char_sem);
++ mutex_unlock(&rtc->char_lock);
+ return 0;
+}
+
@@ -1588,7 +2905,7 @@
+ return -EINVAL;
+ }
+
-+ init_MUTEX(&rtc->char_sem);
++ mutex_init(&rtc->char_lock);
+ spin_lock_init(&rtc->irq_lock);
+ init_waitqueue_head(&rtc->irq_queue);
+
@@ -1679,16 +2996,16 @@
+MODULE_DESCRIPTION("RTC class dev interface");
+MODULE_LICENSE("GPL");
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-x1205.c 2006-02-06 23:58:32.000000000 +0100
-@@ -0,0 +1,672 @@
++++ linux-rtc/drivers/rtc/rtc-x1205.c 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,619 @@
+/*
+ * An i2c driver for the Xicor/Intersil X1205 RTC
+ * Copyright 2004 Karen Spearel
+ * Copyright 2005 Alessandro Zummo
+ *
+ * please send all reports to:
-+ * kas11 at tampabay dot rr dot com
-+ * a dot zummo at towertech dot it
++ * Karen Spearel <kas111 at gmail dot com>
++ * Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * based on a lot of other RTC drivers.
+ *
@@ -1698,17 +3015,12 @@
+ * (at your option) any later version.
+ */
+
-+#include <linux/module.h>
-+#include <linux/init.h>
-+#include <linux/slab.h>
-+#include <linux/err.h>
+#include <linux/i2c.h>
-+#include <linux/string.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/delay.h>
+
-+#define DRV_VERSION "1.0.5"
++#define DRV_VERSION "1.0.6"
+
+/* Addresses to scan: none. This chip is located at
+ * 0x6f and uses a two bytes register addressing.
@@ -1900,14 +3212,12 @@
+ }
+
+ /* this sequence is required to unlock the chip */
-+ xfer = i2c_master_send(client, wel, 3);
-+ if (xfer != 3) {
++ if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
+ dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
+ return -EIO;
+ }
+
-+ xfer = i2c_master_send(client, rwel, 3);
-+ if (xfer != 3) {
++ if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
+ dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
+ return -EIO;
+ }
@@ -1927,8 +3237,7 @@
+ };
+
+ /* disable further writes */
-+ xfer = i2c_master_send(client, diswe, 3);
-+ if (xfer != 3) {
++ if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
+ dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
+ return -EIO;
+ }
@@ -1941,13 +3250,11 @@
+ int err;
+ struct rtc_time tm;
+
-+ tm.tm_hour = 0;
-+ tm.tm_min = 0;
-+ tm.tm_sec = 0;
++ tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
+
+ if ((err = x1205_set_datetime(client, &tm, 0, X1205_CCR_BASE)) < 0)
+ dev_err(&client->dev,
-+ "unable to restart the clock\n");
++ "unable to restart the oscillator\n");
+
+ return err;
+}
@@ -2020,10 +3327,7 @@
+
+struct x1205_limit
+{
-+ unsigned char reg;
-+ unsigned char mask;
-+ unsigned char min;
-+ unsigned char max;
++ unsigned char reg, mask, min, max;
+};
+
+static int x1205_validate_client(struct i2c_client *client)
@@ -2067,11 +3371,10 @@
+ { client->addr, I2C_M_RD, 1, &buf },
+ };
+
-+ xfer = i2c_transfer(client->adapter, msgs, 2);
-+ if (xfer != 2) {
++ if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
+ dev_err(&client->adapter->dev,
+ "%s: could not read register %x\n",
-+ __FUNCTION__, addr[1]);
++ __FUNCTION__, probe_zero_pattern[i]);
+
+ return -EIO;
+ }
@@ -2079,7 +3382,7 @@
+ if ((buf & probe_zero_pattern[i+1]) != 0) {
+ dev_err(&client->adapter->dev,
+ "%s: register=%02x, zero pattern=%d, value=%x\n",
-+ __FUNCTION__, addr[1], i, buf);
++ __FUNCTION__, probe_zero_pattern[i], i, buf);
+
+ return -ENODEV;
+ }
@@ -2096,12 +3399,10 @@
+ { client->addr, I2C_M_RD, 1, &reg },
+ };
+
-+ xfer = i2c_transfer(client->adapter, msgs, 2);
-+
-+ if (xfer != 2) {
++ if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
+ dev_err(&client->adapter->dev,
+ "%s: could not read register %x\n",
-+ __FUNCTION__, addr[1]);
++ __FUNCTION__, probe_limits_pattern[i].reg);
+
+ return -EIO;
+ }
@@ -2112,7 +3413,8 @@
+ value < probe_limits_pattern[i].min) {
+ dev_dbg(&client->adapter->dev,
+ "%s: register=%x, lim pattern=%d, value=%d\n",
-+ __FUNCTION__, addr[1], i, value);
++ __FUNCTION__, probe_limits_pattern[i].reg,
++ i, value);
+
+ return -ENODEV;
+ }
@@ -2121,87 +3423,51 @@
+ return 0;
+}
+
-+static int x1205_rtc_read_alarm(struct device *dev,
-+ struct rtc_wkalrm *alrm)
++static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+ return x1205_get_datetime(to_i2c_client(dev),
+ &alrm->time, X1205_ALM0_BASE);
+}
+
-+static int x1205_rtc_set_alarm(struct device *dev,
-+ struct rtc_wkalrm *alrm)
++static int x1205_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+ return x1205_set_datetime(to_i2c_client(dev),
+ &alrm->time, 1, X1205_ALM0_BASE);
+}
+
-+static int x1205_rtc_read_time(struct device *dev,
-+ struct rtc_time *tm)
++static int x1205_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+ return x1205_get_datetime(to_i2c_client(dev),
+ tm, X1205_CCR_BASE);
+}
+
-+static int x1205_rtc_set_time(struct device *dev,
-+ struct rtc_time *tm)
++static int x1205_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+ return x1205_set_datetime(to_i2c_client(dev),
+ tm, 1, X1205_CCR_BASE);
+}
+
-+static int x1205_rtc_set_mmss(struct device *dev, unsigned long secs)
-+{
-+ int err;
-+
-+ struct rtc_time new_tm, old_tm;
-+
-+ if ((err = x1205_rtc_read_time(dev, &old_tm) == 0))
-+ return err;
-+
-+ /* FIXME xtime.tv_nsec = old_tm.tm_sec * 10000000; */
-+ new_tm.tm_sec = secs % 60;
-+ secs /= 60;
-+ new_tm.tm_min = secs % 60;
-+ secs /= 60;
-+ new_tm.tm_hour = secs % 24;
-+
-+ /*
-+ * avoid writing when we're going to change the day
-+ * of the month. We will retry in the next minute.
-+ * This basically means that if the RTC must not drift
-+ * by more than 1 minute in 11 minutes.
-+ */
-+ if ((old_tm.tm_hour == 23 && old_tm.tm_min == 59) ||
-+ (new_tm.tm_hour == 23 && new_tm.tm_min == 59))
-+ return 1;
-+
-+ return x1205_rtc_set_time(dev, &new_tm);
-+}
-+
+static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+ int err, dtrim, atrim;
+
+ seq_printf(seq, "24hr\t\t: yes\n");
+
-+ err = x1205_get_dtrim(to_i2c_client(dev), &dtrim);
-+ if (err == 0)
++ if ((err = x1205_get_dtrim(to_i2c_client(dev), &dtrim)) == 0)
+ seq_printf(seq, "digital_trim\t: %d ppm\n", dtrim);
+
-+ err = x1205_get_atrim(to_i2c_client(dev), &atrim);
-+ if (err == 0)
++ if ((err = x1205_get_atrim(to_i2c_client(dev), &atrim)) == 0)
+ seq_printf(seq, "analog_trim\t: %d.%02d pF\n",
+ atrim / 1000, atrim % 1000);
+ return 0;
+}
+
+static struct rtc_class_ops x1205_rtc_ops = {
-+ .proc = x1205_rtc_proc,
-+ .read_time = x1205_rtc_read_time,
-+ .set_time = x1205_rtc_set_time,
-+ .read_alarm = x1205_rtc_read_alarm,
-+ .set_alarm = x1205_rtc_set_alarm,
-+ .set_mmss = x1205_rtc_set_mmss,
++ .proc = x1205_rtc_proc,
++ .read_time = x1205_rtc_read_time,
++ .set_time = x1205_rtc_set_time,
++ .read_alarm = x1205_rtc_read_alarm,
++ .set_alarm = x1205_rtc_set_alarm,
+};
+
+static ssize_t x1205_sysfs_show_atrim(struct device *dev,
@@ -2209,10 +3475,10 @@
+{
+ int atrim;
+
-+ if (x1205_get_atrim(to_i2c_client(dev), &atrim) == 0) {
-+ return sprintf(buf, "%d.%02d pF\n",
-+ atrim / 1000, atrim % 1000); }
-+ return 0;
++ if (x1205_get_atrim(to_i2c_client(dev), &atrim) == 0)
++ return sprintf(buf, "%d.%02d pF\n",
++ atrim / 1000, atrim % 1000);
++ return 0;
+}
+static DEVICE_ATTR(atrim, S_IRUGO, x1205_sysfs_show_atrim, NULL);
+
@@ -2221,18 +3487,16 @@
+{
+ int dtrim;
+
-+ if (x1205_get_dtrim(to_i2c_client(dev), &dtrim) == 0) {
-+ return sprintf(buf, "%d ppm\n", dtrim);
-+ }
-+ return 0;
++ if (x1205_get_dtrim(to_i2c_client(dev), &dtrim) == 0)
++ return sprintf(buf, "%d ppm\n", dtrim);
++
++ return 0;
+}
+static DEVICE_ATTR(dtrim, S_IRUGO, x1205_sysfs_show_dtrim, NULL);
+
-+
+static int x1205_attach(struct i2c_adapter *adapter)
+{
+ dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
-+
+ return i2c_probe(adapter, &addr_data, x1205_probe);
+}
+
@@ -2345,7 +3609,7 @@
+}
+
+MODULE_AUTHOR(
-+ "Karen Spearel <kas11@tampabay.rr.com>, "
++ "Karen Spearel <kas111 at gmail dot com>, "
+ "Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("Xicor/Intersil X1205 RTC driver");
+MODULE_LICENSE("GPL");
@@ -2354,7 +3618,7 @@
+module_init(x1205_init);
+module_exit(x1205_exit);
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-test.c 2006-02-06 23:58:32.000000000 +0100
++++ linux-rtc/drivers/rtc/rtc-test.c 2006-02-21 00:36:43.000000000 +0100
@@ -0,0 +1,206 @@
+/*
+ * An RTC test device/driver
@@ -2563,8 +3827,8 @@
+module_init(test_init);
+module_exit(test_exit);
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-ds1672.c 2006-02-06 23:58:32.000000000 +0100
-@@ -0,0 +1,234 @@
++++ linux-rtc/drivers/rtc/rtc-ds1672.c 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,233 @@
+/*
+ * An rtc/i2c driver for the Dallas DS1672
+ * Copyright 2005 Alessandro Zummo
@@ -2689,15 +3953,14 @@
+}
+
+static struct rtc_class_ops ds1672_rtc_ops = {
-+ .read_time = ds1672_rtc_read_time,
-+ .set_time = ds1672_rtc_set_time,
-+ .set_mmss = ds1672_rtc_set_mmss,
++ .read_time = ds1672_rtc_read_time,
++ .set_time = ds1672_rtc_set_time,
++ .set_mmss = ds1672_rtc_set_mmss,
+};
+
+static int ds1672_attach(struct i2c_adapter *adapter)
+{
+ dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
-+
+ return i2c_probe(adapter, &addr_data, ds1672_probe);
+}
+
@@ -2800,8 +4063,8 @@
+module_init(ds1672_init);
+module_exit(ds1672_exit);
--- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/rtc/rtc-pcf8563.c 2006-02-06 23:58:32.000000000 +0100
-@@ -0,0 +1,384 @@
++++ linux-rtc/drivers/rtc/rtc-pcf8563.c 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,355 @@
+/*
+ * An I2C driver for the Philips PCF8563 RTC
+ * Copyright 2005-06 Tower Technologies
@@ -2819,15 +4082,18 @@
+ * (at your option) any later version.
+ */
+
-+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+
-+#define DRV_VERSION "0.4.0"
++#define DRV_VERSION "0.4.2"
+
-+/* Addresses to scan */
-+static unsigned short normal_i2c[] = { 0x51, I2C_CLIENT_END };
++/* Addresses to scan: none
++ * This chip cannot be reliably autodetected. An empty eeprom
++ * located at 0x51 will pass the validation routine due to
++ * the way the registers are implemented.
++ */
++static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+
+/* Module parameters */
+I2C_CLIENT_INSMOD;
@@ -2874,11 +4140,10 @@
+ */
+static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
+{
-+ unsigned char buf[13];
-+ unsigned char addr = PCF8563_REG_ST1;
++ unsigned char buf[13] = { PCF8563_REG_ST1 };
+
+ struct i2c_msg msgs[] = {
-+ { client->addr, 0, 1, &addr }, /* setup read ptr */
++ { client->addr, 0, 1, buf }, /* setup read ptr */
+ { client->addr, I2C_M_RD, 13, buf }, /* read status + date */
+ };
+
@@ -2980,46 +4245,48 @@
+
+static int pcf8563_validate_client(struct i2c_client *client)
+{
-+ int i, xfer;
++ int i;
+
-+ static const struct pcf8563_limit probe_limits_pattern[] = {
++ static const struct pcf8563_limit pattern[] = {
+ /* register, mask, min, max */
+ { PCF8563_REG_SC, 0x7F, 0, 59 },
+ { PCF8563_REG_MN, 0x7F, 0, 59 },
+ { PCF8563_REG_HR, 0x3F, 0, 23 },
+ { PCF8563_REG_DM, 0x3F, 0, 31 },
+ { PCF8563_REG_MO, 0x1F, 0, 12 },
-+ { PCF8563_REG_YR, 0xFF, 0, 99 },
+ };
+
+ /* check limits (only registers with bcd values) */
-+ for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) {
-+ unsigned char addr, buf, value;
++ for (i = 0; i < ARRAY_SIZE(pattern); i++) {
++ int xfer;
++ unsigned char value;
++ unsigned char buf = pattern[i].reg;
+
-+ addr = probe_limits_pattern[i].reg;
-+
-+ struct i2c_msg msgs[2] = {
-+ { client->addr, 0, 2, &addr },
++ struct i2c_msg msgs[] = {
++ { client->addr, 0, 1, &buf },
+ { client->addr, I2C_M_RD, 1, &buf },
+ };
+
-+ xfer = i2c_transfer(client->adapter, msgs, 2);
++ xfer = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
+
-+ if (xfer != 2) {
++ if (xfer != ARRAY_SIZE(msgs)) {
+ dev_err(&client->adapter->dev,
-+ "%s: could not read register %x\n",
-+ __FUNCTION__, probe_limits_pattern[i].reg);
++ "%s: could not read register 0x%02X\n",
++ __FUNCTION__, pattern[i].reg);
+
+ return -EIO;
+ }
+
-+ value = BCD2BIN(buf & probe_limits_pattern[i].mask);
++ value = BCD2BIN(buf & pattern[i].mask);
+
-+ if (value > probe_limits_pattern[i].max ||
-+ value < probe_limits_pattern[i].min) {
++ if (value > pattern[i].max ||
++ value < pattern[i].min) {
+ dev_dbg(&client->adapter->dev,
-+ "%s: register=%x, lim pattern=%d, value=%d\n",
-+ __FUNCTION__, probe_limits_pattern[i].reg, i, value);
++ "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, "
++ "max=%d, value=%d, raw=0x%02X\n",
++ __FUNCTION__, i, pattern[i].reg, pattern[i].mask,
++ pattern[i].min, pattern[i].max,
++ value, buf);
+
+ return -ENODEV;
+ }
@@ -3028,47 +4295,16 @@
+ return 0;
+}
+
-+static int pcf8563_rtc_read_time(struct device *dev,
-+ struct rtc_time *tm)
++static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+ return pcf8563_get_datetime(to_i2c_client(dev), tm);
+}
+
-+static int pcf8563_rtc_set_time(struct device *dev,
-+ struct rtc_time *tm)
++static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+ return pcf8563_set_datetime(to_i2c_client(dev), tm);
+}
+
-+static int pcf8563_rtc_set_mmss(struct device *dev, unsigned long secs)
-+{
-+ int err;
-+
-+ struct rtc_time new_tm, old_tm;
-+
-+ if ((err = pcf8563_rtc_read_time(dev, &old_tm) == 0))
-+ return err;
-+
-+ /* FIXME xtime.tv_nsec = old_tm.tm_sec * 10000000; */
-+ new_tm.tm_sec = secs % 60;
-+ secs /= 60;
-+ new_tm.tm_min = secs % 60;
-+ secs /= 60;
-+ new_tm.tm_hour = secs % 24;
-+
-+ /*
-+ * avoid writing when we're going to change the day
-+ * of the month. We will retry in the next minute.
-+ * This basically means that if the RTC must not drift
-+ * by more than 1 minute in 11 minutes.
-+ */
-+ if ((old_tm.tm_hour == 23 && old_tm.tm_min == 59) ||
-+ (new_tm.tm_hour == 23 && new_tm.tm_min == 59))
-+ return 1;
-+
-+ return pcf8563_rtc_set_time(dev, &new_tm);
-+}
-+
+static int pcf8563_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+ seq_printf(seq, "24hr\t\t: yes\n");
@@ -3076,10 +4312,9 @@
+}
+
+static struct rtc_class_ops pcf8563_rtc_ops = {
-+ .proc = pcf8563_rtc_proc,
-+ .read_time = pcf8563_rtc_read_time,
-+ .set_time = pcf8563_rtc_set_time,
-+ .set_mmss = pcf8563_rtc_set_mmss,
++ .proc = pcf8563_rtc_proc,
++ .read_time = pcf8563_rtc_read_time,
++ .set_time = pcf8563_rtc_set_time,
+};
+
+static int pcf8563_attach(struct i2c_adapter *adapter)
@@ -3185,4 +4420,301 @@
+
+module_init(pcf8563_init);
+module_exit(pcf8563_exit);
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-rtc/drivers/rtc/rtc-rs5c372.c 2006-02-21 00:36:43.000000000 +0100
+@@ -0,0 +1,295 @@
++/*
++ * An I2C driver for the Ricoh RS5C372 RTC
++ *
++ * Copyright (C) 2005 Pavel Mironchik pmironchik@optifacio.net
++ * Copyright (C) 2006 Tower Technologies
++ *
++ * 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.
++ *
++ */
+
++#include <linux/i2c.h>
++#include <linux/rtc.h>
++#include <linux/bcd.h>
++
++#define DRV_VERSION "0.2"
++
++/* Addresses to scan */
++static unsigned short normal_i2c[] = { /* 0x32,*/ I2C_CLIENT_END };
++
++/* Insmod parameters */
++I2C_CLIENT_INSMOD;
++
++#define RS5C372_REG_SECS 0
++#define RS5C372_REG_MINS 1
++#define RS5C372_REG_HOURS 2
++#define RS5C372_REG_WDAY 3
++#define RS5C372_REG_DAY 4
++#define RS5C372_REG_MONTH 5
++#define RS5C372_REG_YEAR 6
++#define RS5C372_REG_TRIM 7
++
++#define RS5C372_TRIM_XSL 0x80
++#define RS5C372_TRIM_MASK 0x7F
++
++#define RS5C372_REG_BASE 0
++
++static int rs5c372_attach(struct i2c_adapter *adapter);
++static int rs5c372_detach(struct i2c_client *client);
++static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind);
++
++static struct i2c_driver rs5c372_driver = {
++ .driver = {
++ .name = "rs5c372",
++ },
++ .attach_adapter = &rs5c372_attach,
++ .detach_client = &rs5c372_detach,
++};
++
++static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
++{
++ unsigned char buf[7] = { RS5C372_REG_BASE };
++
++ /* this implements the 1st reading method, according
++ * to the datasheet. buf[0] is initialized with
++ * address ptr and transmission format register.
++ */
++ struct i2c_msg msgs[] = {
++ { client->addr, 0, 1, buf },
++ { client->addr, I2C_M_RD, 7, buf },
++ };
++
++ if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
++ dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++ return -EIO;
++ }
++
++ tm->tm_sec = BCD2BIN(buf[RS5C372_REG_SECS] & 0x7f);
++ tm->tm_min = BCD2BIN(buf[RS5C372_REG_MINS] & 0x7f);
++ tm->tm_hour = BCD2BIN(buf[RS5C372_REG_HOURS] & 0x3f);
++ tm->tm_wday = BCD2BIN(buf[RS5C372_REG_WDAY] & 0x07);
++ tm->tm_mday = BCD2BIN(buf[RS5C372_REG_DAY] & 0x3f);
++
++ /* tm->tm_mon is zero-based */
++ tm->tm_mon = BCD2BIN(buf[RS5C372_REG_MONTH] & 0x1f) - 1;
++
++ /* year is 1900 + tm->tm_year */
++ tm->tm_year = BCD2BIN(buf[RS5C372_REG_YEAR]) + 100;
++
++ dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
++ "mday=%d, mon=%d, year=%d, wday=%d\n",
++ __FUNCTION__,
++ tm->tm_sec, tm->tm_min, tm->tm_hour,
++ tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++ return 0;
++}
++
++static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
++{
++ unsigned char buf[8] = { RS5C372_REG_BASE };
++
++ dev_dbg(&client->dev,
++ "%s: secs=%d, mins=%d, hours=%d ",
++ "mday=%d, mon=%d, year=%d, wday=%d\n",
++ __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
++ tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++ buf[1] = BIN2BCD(tm->tm_sec);
++ buf[2] = BIN2BCD(tm->tm_min);
++ buf[3] = BIN2BCD(tm->tm_hour);
++ buf[4] = BIN2BCD(tm->tm_wday);
++ buf[5] = BIN2BCD(tm->tm_mday);
++ buf[6] = BIN2BCD(tm->tm_mon + 1);
++ buf[7] = BIN2BCD(tm->tm_year - 100);
++
++ if ((i2c_master_send(client, buf, 8)) != 8) {
++ dev_err(&client->dev, "%s: write error\n", __FUNCTION__);
++ return -EIO;
++ }
++
++ return 0;
++}
++
++static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
++{
++ unsigned char buf = RS5C372_REG_TRIM;
++
++ struct i2c_msg msgs[] = {
++ { client->addr, 0, 1, &buf },
++ { client->addr, I2C_M_RD, 1, &buf },
++ };
++
++ if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
++ dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++ return -EIO;
++ }
++
++ dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, trim);
++
++ if (osc)
++ *osc = (buf & RS5C372_TRIM_XSL) ? 32000 : 32768;
++
++ if (trim)
++ *trim = buf & RS5C372_TRIM_MASK;
++
++ return 0;
++}
++
++static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
++{
++ return rs5c372_get_datetime(to_i2c_client(dev), tm);
++}
++
++static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
++{
++ return rs5c372_set_datetime(to_i2c_client(dev), tm);
++}
++
++static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
++{
++ int err, osc, trim;
++
++ seq_printf(seq, "24hr\t\t: yes\n");
++
++ if ((err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim)) == 0) {
++ seq_printf(seq, "%d.%03d KHz\n", osc / 1000, osc % 1000);
++ seq_printf(seq, "trim\t: %d\n", trim);
++ }
++
++ return 0;
++}
++
++static struct rtc_class_ops rs5c372_rtc_ops = {
++ .proc = rs5c372_rtc_proc,
++ .read_time = rs5c372_rtc_read_time,
++ .set_time = rs5c372_rtc_set_time,
++};
++
++static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ int trim;
++
++ if (rs5c372_get_trim(to_i2c_client(dev), NULL, &trim) == 0)
++ return sprintf(buf, "0x%2x\n", trim);
++
++ return 0;
++}
++static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
++
++static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ int osc;
++
++ if (rs5c372_get_trim(to_i2c_client(dev), &osc, NULL) == 0)
++ return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
++
++ return 0;
++}
++static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
++
++static int rs5c372_attach(struct i2c_adapter *adapter)
++{
++ dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++ return i2c_probe(adapter, &addr_data, rs5c372_probe);
++}
++
++static int rs5c372_probe(struct i2c_adapter *adapter, int address, int kind)
++{
++ int err = 0;
++ struct i2c_client *client;
++ struct rtc_device *rtc;
++
++ dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++
++ if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
++ err = -ENODEV;
++ goto exit;
++ }
++
++ if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
++ err = -ENOMEM;
++ goto exit;
++ }
++
++ /* I2C client */
++ client->addr = address;
++ client->driver = &rs5c372_driver;
++ client->adapter = adapter;
++
++ strlcpy(client->name, rs5c372_driver.driver.name, I2C_NAME_SIZE);
++
++ /* Inform the i2c layer */
++ if ((err = i2c_attach_client(client)))
++ goto exit_kfree;
++
++ dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
++
++ rtc = rtc_device_register(rs5c372_driver.driver.name, &client->dev,
++ &rs5c372_rtc_ops, THIS_MODULE);
++
++ if (IS_ERR(rtc)) {
++ err = PTR_ERR(rtc);
++ dev_err(&client->dev,
++ "unable to register the class device\n");
++ goto exit_detach;
++ }
++
++ i2c_set_clientdata(client, rtc);
++
++ device_create_file(&client->dev, &dev_attr_trim);
++ device_create_file(&client->dev, &dev_attr_osc);
++
++ return 0;
++
++exit_detach:
++ i2c_detach_client(client);
++
++exit_kfree:
++ kfree(client);
++
++exit:
++ return err;
++}
++
++static int rs5c372_detach(struct i2c_client *client)
++{
++ int err;
++ struct rtc_device *rtc = i2c_get_clientdata(client);
++
++ dev_dbg(&client->dev, "%s\n", __FUNCTION__);
++
++ if (rtc)
++ rtc_device_unregister(rtc);
++
++ if ((err = i2c_detach_client(client)))
++ return err;
++
++ kfree(client);
++
++ return 0;
++}
++
++static __init int rs5c372_init(void)
++{
++ return i2c_add_driver(&rs5c372_driver);
++}
++
++static __exit void rs5c372_exit(void)
++{
++ i2c_del_driver(&rs5c372_driver);
++}
++
++module_init(rs5c372_init);
++module_exit(rs5c372_exit);
++
++MODULE_AUTHOR(
++ "Pavel Mironchik <pmironchik@optifacio.net>, "
++ "Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch b/packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch
new file mode 100644
index 0000000000..9d0a35b3fa
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/50-hwmon-ad741x.patch
@@ -0,0 +1,378 @@
+---
+ drivers/hwmon/Kconfig | 10 +
+ drivers/hwmon/Makefile | 1
+ drivers/hwmon/ad741x.c | 340 +++++++++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 351 insertions(+)
+
+--- linux-ixp4xx.orig/drivers/hwmon/Makefile 2006-02-19 17:45:45.000000000 +0100
++++ linux-ixp4xx/drivers/hwmon/Makefile 2006-02-19 17:46:12.000000000 +0100
+@@ -44,6 +44,7 @@ obj-$(CONFIG_SENSORS_VIA686A) += via686a
+ obj-$(CONFIG_SENSORS_VT8231) += vt8231.o
+ obj-$(CONFIG_SENSORS_W83627EHF) += w83627ehf.o
+ obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o
++obj-$(CONFIG_SENSORS_AD741X) += ad741x.o
+
+ ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
+ EXTRA_CFLAGS += -DDEBUG
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-ixp4xx/drivers/hwmon/ad741x.c 2006-02-19 17:45:59.000000000 +0100
+@@ -0,0 +1,340 @@
++/*
++ * An hwmon driver for the Analog Devices AD7417/18
++ * Copyright 2006 Tower Technologies
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * Based on lm75.c
++ * Copyright 1998-99 Frodo Looijaard <frodol@dds.nl>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ */
++
++#include <linux/module.h>
++#include <linux/jiffies.h>
++#include <linux/i2c.h>
++#include <linux/hwmon.h>
++#include <linux/err.h>
++#include <linux/mutex.h>
++
++#define DRV_VERSION "0.1"
++
++/* straight from the datasheet */
++#define AD741X_TEMP_MIN (-55000)
++#define AD741X_TEMP_MAX 125000
++
++/* Addresses to scan */
++static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2A, 0x2B, 0x2C,
++ 0x2D, 0x2E, 0x2F, I2C_CLIENT_END };
++
++/* Insmod parameters */
++I2C_CLIENT_INSMOD;
++
++/* AD741X registers */
++#define AD741X_REG_TEMP 0x00
++#define AD741X_REG_CONF 0x01
++#define AD741X_REG_TEMP_HYST 0x02
++#define AD741X_REG_TEMP_OS 0x03
++#define AD741X_REG_ADC 0x04
++#define AD741X_REG_CONF2 0x05
++
++#define AD741X_REG_ADC_CH(x) (x << 5)
++
++#define AD741X_CH_TEMP AD741X_REG_ADC_CH(0)
++#define AD741X_CH_AIN1 AD741X_REG_ADC_CH(1)
++#define AD741X_CH_AIN2 AD741X_REG_ADC_CH(2)
++#define AD741X_CH_AIN3 AD741X_REG_ADC_CH(3)
++#define AD741X_CH_AIN4 AD741X_REG_ADC_CH(4)
++
++struct ad741x_data {
++ struct i2c_client client;
++ struct class_device *class_dev;
++ struct mutex lock;
++ char valid; /* !=0 if following fields are valid */
++ unsigned long last_updated; /* In jiffies */
++ u16 temp_input; /* Register values */
++ u16 temp_max;
++ u16 temp_hyst;
++ u16 in1;
++ u16 in2;
++ u16 in3;
++ u16 in4;
++};
++
++static int ad741x_attach_adapter(struct i2c_adapter *adapter);
++static int ad741x_detect(struct i2c_adapter *adapter, int address, int kind);
++static int ad741x_detach_client(struct i2c_client *client);
++
++static struct i2c_driver ad741x_driver = {
++ .driver = {
++ .name = "ad741x",
++ },
++ .attach_adapter = ad741x_attach_adapter,
++ .detach_client = ad741x_detach_client,
++};
++
++/* TEMP: 0.001C/bit (-55C to +125C)
++ * REG: (0.5C/bit, two's complement) << 7
++ */
++static inline u16 AD741X_TEMP_TO_REG(int temp)
++{
++ int ntemp = SENSORS_LIMIT(temp, AD741X_TEMP_MIN, AD741X_TEMP_MAX);
++ ntemp += (ntemp < 0 ? -250 : 250);
++ return (u16)((ntemp / 500) << 7);
++}
++
++static inline int AD741X_TEMP_FROM_REG(u16 reg)
++{
++ /* use integer division instead of equivalent right shift to
++ * guarantee arithmetic shift and preserve the sign
++ */
++ return ((s16)reg / 128) * 500;
++}
++
++/* All registers are word-sized, except for the configuration registers.
++ * AD741X uses a high-byte first convention, which is exactly opposite to
++ * the usual practice.
++ */
++static int ad741x_read(struct i2c_client *client, u8 reg)
++{
++ if (reg == AD741X_REG_CONF || reg == AD741X_REG_CONF2)
++ return i2c_smbus_read_byte_data(client, reg);
++ else
++ return swab16(i2c_smbus_read_word_data(client, reg));
++}
++
++static int ad741x_write(struct i2c_client *client, u8 reg, u16 value)
++{
++ if (reg == AD741X_REG_CONF || reg == AD741X_REG_CONF2)
++ return i2c_smbus_write_byte_data(client, reg, value);
++ else
++ return i2c_smbus_write_word_data(client, reg, swab16(value));
++}
++
++static void ad741x_init_client(struct i2c_client *client)
++{
++ /* Enable if in shutdown mode */
++ int reg = ad741x_read(client, AD741X_REG_CONF);
++ if (reg >= 0 && (reg & 0x01))
++ ad741x_write(client, AD741X_REG_CONF, reg & 0xfe);
++}
++
++static struct ad741x_data *ad741x_update_device(struct device *dev)
++{
++ struct i2c_client *client = to_i2c_client(dev);
++ struct ad741x_data *data = i2c_get_clientdata(client);
++
++ mutex_lock(&data->lock);
++
++ if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
++ || !data->valid) {
++ u8 cfg;
++ dev_dbg(&client->dev, "starting ad741x update\n");
++
++ data->temp_input = ad741x_read(client, AD741X_REG_TEMP);
++ data->temp_max = ad741x_read(client, AD741X_REG_TEMP_OS);
++ data->temp_hyst = ad741x_read(client, AD741X_REG_TEMP_HYST);
++
++ /* read config register and clear channel bits */
++ cfg = ad741x_read(client, AD741X_REG_CONF);
++ cfg &= 0x1F;
++
++ ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN1);
++ data->in1 = ad741x_read(client, AD741X_REG_ADC);
++
++ ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN2);
++ data->in2 = ad741x_read(client, AD741X_REG_ADC);
++
++ ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN3);
++ data->in3 = ad741x_read(client, AD741X_REG_ADC);
++
++ ad741x_write(client, AD741X_REG_CONF, cfg | AD741X_CH_AIN4);
++ data->in4 = ad741x_read(client, AD741X_REG_ADC);
++
++ /* restore old configuration value */
++ ad741x_write(client, AD741X_REG_CONF, cfg);
++
++ data->last_updated = jiffies;
++ data->valid = 1;
++ }
++
++ mutex_unlock(&data->lock);
++
++ return data;
++}
++
++#define show(value) \
++static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \
++{ \
++ struct ad741x_data *data = ad741x_update_device(dev); \
++ return sprintf(buf, "%d\n", AD741X_TEMP_FROM_REG(data->value)); \
++}
++show(temp_max);
++show(temp_hyst);
++show(temp_input);
++
++#define show_adc(value) \
++static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \
++{ \
++ struct ad741x_data *data = ad741x_update_device(dev); \
++ return sprintf(buf, "%d\n", data->value >> 6); \
++}
++
++show_adc(in1);
++show_adc(in2);
++show_adc(in3);
++show_adc(in4);
++
++#define set(value, reg) \
++static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
++{ \
++ struct i2c_client *client = to_i2c_client(dev); \
++ struct ad741x_data *data = i2c_get_clientdata(client); \
++ int temp = simple_strtoul(buf, NULL, 10); \
++ \
++ mutex_lock(&data->lock); \
++ data->value = AD741X_TEMP_TO_REG(temp); \
++ ad741x_write(client, reg, data->value); \
++ mutex_unlock(&data->lock); \
++ return count; \
++}
++set(temp_max, AD741X_REG_TEMP_OS);
++set(temp_hyst, AD741X_REG_TEMP_HYST);
++
++static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, set_temp_max);
++static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hyst, set_temp_hyst);
++static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL);
++
++static DEVICE_ATTR(in1, S_IRUGO, show_in1, NULL);
++static DEVICE_ATTR(in2, S_IRUGO, show_in2, NULL);
++static DEVICE_ATTR(in3, S_IRUGO, show_in3, NULL);
++static DEVICE_ATTR(in4, S_IRUGO, show_in4, NULL);
++
++static int ad741x_attach_adapter(struct i2c_adapter *adapter)
++{
++ if (!(adapter->class & I2C_CLASS_HWMON))
++ return 0;
++ return i2c_probe(adapter, &addr_data, ad741x_detect);
++}
++
++static int ad741x_detect(struct i2c_adapter *adapter, int address, int kind)
++{
++ struct i2c_client *client;
++ struct ad741x_data *data;
++ int err = 0;
++
++ if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
++ I2C_FUNC_SMBUS_WORD_DATA))
++ goto exit;
++
++ if (!(data = kzalloc(sizeof(struct ad741x_data), GFP_KERNEL))) {
++ err = -ENOMEM;
++ goto exit;
++ }
++
++ client = &data->client;
++ client->addr = address;
++ client->adapter = adapter;
++ client->driver = &ad741x_driver;
++ client->flags = 0;
++
++ i2c_set_clientdata(client, data);
++
++ mutex_init(&data->lock);
++
++ /* AD7418 has a curious behaviour on registers 6 and 7. They
++ * both always read 0xC071 and are not documented on the datasheet.
++ * We use them to detect the chip.
++ */
++ if (kind < 0) {
++ int reg;
++
++ reg = i2c_smbus_read_word_data(client, 0x06);
++ if (reg != 0xC071) {
++ dev_dbg(&adapter->dev, "failed detection at %d: %x\n", 6, reg);
++ err = -ENODEV;
++ goto exit_free;
++ }
++
++ reg = i2c_smbus_read_word_data(client, 0x07);
++ if (reg != 0xC071) {
++ dev_dbg(&adapter->dev, "failed detection at %d: %x\n", 7, reg);
++ err = -ENODEV;
++ goto exit_free;
++ }
++
++ reg = i2c_smbus_read_byte_data(client, AD741X_REG_CONF2);
++
++ /* bits 0-5 must be at 0 */
++ if (reg & 0x3F) {
++ dev_dbg(&adapter->dev, "failed detection at %d: %x\n",
++ AD741X_REG_CONF2, reg);
++ err = -ENODEV;
++ goto exit_free;
++ }
++ }
++
++ strlcpy(client->name, ad741x_driver.driver.name, I2C_NAME_SIZE);
++
++ if ((err = i2c_attach_client(client)))
++ goto exit_free;
++
++ dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
++
++ /* Initialize the AD741X chip */
++ ad741x_init_client(client);
++
++ /* Register sysfs hooks */
++ data->class_dev = hwmon_device_register(&client->dev);
++ if (IS_ERR(data->class_dev)) {
++ err = PTR_ERR(data->class_dev);
++ goto exit_detach;
++ }
++
++ device_create_file(&client->dev, &dev_attr_temp1_max);
++ device_create_file(&client->dev, &dev_attr_temp1_max_hyst);
++ device_create_file(&client->dev, &dev_attr_temp1_input);
++ device_create_file(&client->dev, &dev_attr_in1);
++ device_create_file(&client->dev, &dev_attr_in2);
++ device_create_file(&client->dev, &dev_attr_in3);
++ device_create_file(&client->dev, &dev_attr_in4);
++
++ return 0;
++
++exit_detach:
++ i2c_detach_client(client);
++exit_free:
++ kfree(data);
++exit:
++ return err;
++}
++
++static int ad741x_detach_client(struct i2c_client *client)
++{
++ struct ad741x_data *data = i2c_get_clientdata(client);
++ hwmon_device_unregister(data->class_dev);
++ i2c_detach_client(client);
++ kfree(data);
++ return 0;
++}
++
++static int __init ad741x_init(void)
++{
++ return i2c_add_driver(&ad741x_driver);
++}
++
++static void __exit ad741x_exit(void)
++{
++ i2c_del_driver(&ad741x_driver);
++}
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("AD741X driver");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(ad741x_init);
++module_exit(ad741x_exit);
+--- linux-ixp4xx.orig/drivers/hwmon/Kconfig 2006-02-19 17:45:45.000000000 +0100
++++ linux-ixp4xx/drivers/hwmon/Kconfig 2006-02-19 17:47:07.000000000 +0100
+@@ -433,6 +433,16 @@ config SENSORS_W83627EHF
+ This driver can also be built as a module. If so, the module
+ will be called w83627ehf.
+
++config SENSORS_AD741X
++ tristate "Analog Devices AD7417/18"
++ depends on HWMON && I2C && EXPERIMENTAL
++ help
++ If you say yes here you get support for the Analog Devices AD7417
++ and AD7418 chips.
++
++ This driver can also be built as a module. If so, the module
++ will be called ad741x.
++
+ config SENSORS_HDAPS
+ tristate "IBM Hard Drive Active Protection System (hdaps)"
+ depends on HWMON && INPUT && X86
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch b/packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch
new file mode 100644
index 0000000000..d7fb8e55dc
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/50-i2c-bus-ixp4xx-hwmon.patch
@@ -0,0 +1,14 @@
+---
+ drivers/i2c/busses/i2c-ixp4xx.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+--- linux-ixp4xx.orig/drivers/i2c/busses/i2c-ixp4xx.c 2006-02-11 15:18:29.000000000 +0100
++++ linux-ixp4xx/drivers/i2c/busses/i2c-ixp4xx.c 2006-02-18 16:20:12.000000000 +0100
+@@ -126,6 +126,7 @@ static int ixp4xx_i2c_probe(struct platf
+ drv_data->algo_data.timeout = 100;
+
+ drv_data->adapter.id = I2C_HW_B_IXP4XX;
++ drv_data->adapter.class = I2C_CLASS_HWMON;
+ strlcpy(drv_data->adapter.name, plat_dev->dev.driver->name,
+ I2C_NAME_SIZE);
+ drv_data->adapter.algo_data = &drv_data->algo_data;
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/91-maclist.patch b/packages/linux/ixp4xx-kernel/2.6.16/91-maclist.patch
index 3915c50cb7..72b9fa9a7d 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/91-maclist.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/91-maclist.patch
@@ -1,38 +1,55 @@
- drivers/net/Kconfig | 15 ++
- drivers/net/Makefile | 1
- drivers/net/maclist.c | 314 ++++++++++++++++++++++++++++++++++++++++++++++++++
- include/net/maclist.h | 23 +++
- 4 files changed, 353 insertions(+)
+Ethernet MAC repository.
---- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/include/net/maclist.h 2006-02-06 22:35:23.000000000 +0100
-@@ -0,0 +1,23 @@
-+#ifndef _MACLIST_H
-+#define _MACLIST_H 1
-+/*
-+ * Interfaces to the MAC repository
-+ */
-+/*
-+ * Add a single entry, returns 0 on success else an error
-+ * code. Must *not* be called from an interrupt handler.
-+ */
-+extern int maclist_add(const u8 id_to_add[6]);
-+
-+/*
-+ * Return the current entry count (valid in any context).
-+ */
-+extern int maclist_count(void);
-+
-+/*
-+ * Return the ID from the n'th entry (valid in any context),
-+ * returns 0 on success, -EINVAL if 'n' is out of range.
-+ */
-+extern int maclist_read(u8 (*buffer_for_id)[6], int index_of_id_to_return);
+Some ethernet controllers have no built-in way of obtaining an
+appropriate Ethernet MAC address. Such controllers have to be
+initialised in a board-specific way, depending on how the allocated
+MAC is stored. The MAC repository provides a set of APIs and a
+proc entry (/proc/net/maclist) to store MAC values from the board
+so that such drivers can obtain a MAC address without board-specific
+code.
+
+Signed-off-by: John Bowler <jbowler@acm.org>
+
+diff -rup linux-2.6.15.1/.pc/91-maclist.patch/drivers/net/Kconfig linux-2.6.15.1/drivers/net/Kconfig
+--- linux-2.6.15/drivers/net/Kconfig 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/net/Kconfig 1970-01-01 00:00:00.000000000 +0000
+@@ -166,6 +166,21 @@ config NET_ETHERNET
+ kernel: saying N will just cause the configurator to skip all
+ the questions about Ethernet network cards. If unsure, say N.
+
++config MACLIST
++ tristate "Ethernet MAC repository"
++ depends on NET_ETHERNET
++ help
++ Some ethernet controllers have no built-in way of obtaining an
++ appropriate Ethernet MAC address. Such controllers have to be
++ initialised in a board-specific way, depending on how the allocated
++ MAC is stored. The MAC repository provides a set of APIs and a
++ proc entry (/proc/net/maclist) to store MAC values from the board
++ so that such drivers can obtain a MAC address without board-specific
++ code. You do not need to enable this device - it will be selected
++ automatically by any device which requires it. It is only useful
++ to enable it manually when building a device driver independently
++ of the kernel build.
+
-+#endif /*_MACLIST_H*/
---- /dev/null 1970-01-01 00:00:00.000000000 +0000
-+++ linux-nslu2/drivers/net/maclist.c 2006-02-06 22:35:23.000000000 +0100
-@@ -0,0 +1,314 @@
+ config MII
+ tristate "Generic Media Independent Interface device support"
+ depends on NET_ETHERNET
+diff -rup linux-2.6.15.1/.pc/91-maclist.patch/drivers/net/Makefile linux-2.6.15.1/drivers/net/Makefile
+--- linux-2.6.15/drivers/net/Makefile 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/net/Makefile 1970-01-01 00:00:00.000000000 +0000
+@@ -70,6 +70,7 @@ obj-$(CONFIG_RIONET) += rionet.o
+ # end link order section
+ #
+
++obj-$(CONFIG_MACLIST) += maclist.o
+ obj-$(CONFIG_MII) += mii.o
+ obj-$(CONFIG_PHYLIB) += phy/
+
+diff -rup linux-2.6.15.1/.pc/91-maclist.patch/drivers/net/maclist.c linux-2.6.15.1/drivers/net/maclist.c
+--- linux-2.6.15/drivers/net/maclist.c 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/net/maclist.c 1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,465 @@
+/*
+ * drivers/net/maclist.c
+ *
@@ -61,15 +78,70 @@
+ * 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.
-+ *
++ */
++
++/*
+ * External interfaces:
+ * Interfaces to linux kernel (and modules)
-+ * maclist_add: add a single MAC
++ * maclist_add: add a single MAC, sequenced with a single
++ * writer lock (reads may happen simultaneously
++ * because of the way the list is built)
+ * maclist_count: total number of MACs stored
-+ * maclist_read: read a MAC 0..(maclist_count-1)
++ * maclist_read: read a MAC 0..(maclist_count-1). Call this
++ * to get a specific MAC. If the argument is
++ * a new key and all the allocaed MACs have been
++ * assigned a random but valid MAC will be return
++ * (and this will be stored for later retrieval
++ * under the given key.)
++ *
++ * Sequencing:
++ * The MAC ids must be added before any driver tries to use them
++ * (this is obvious isn't it?) This can be made to happen by
++ * sequencing the initcalls correctly. The module or kernel
++ * parameters have been handled before any init call happens.
++ * The important trick here is to ensure that the platform
++ * initialises any devices with MAC ids *before* any devices
++ * which might use them.
++ *
++ * When this code is a module any other module which adds a
++ * MAC should be modprobed before modules for ethernet
++ * devices.
++ *
++ * The failure case is 'soft' - the device will get a valid, but
++ * random, MAC and the real allocated MACs will never get used.
++ * This can be seen by looking at the list of ids in sysfs (there
++ * will be extra, random, ones after the allocated ones).
++ *
++ * Recommendations:
++ * For ethernet drivers which are known to be the sole driver on
++ * the board (without a built in MAC) and where the number of
++ * devices driven is known simply use an index 0..(n-1) as a
++ * key for each of the n devices.
++ *
++ * This is the common case, it works where one driver handles
++ * multiple devices so long as the total number of devices can
++ * be determined reliably. It is sufficient merely to maintain
++ * a global count of the number of devices initialised so far,
++ * just so long as the initialisation order is consistent.
++ *
++ * When the driver is generic and the board may be populated with
++ * other devices which allocate MACs from the maclist pool and
++ * use different drivers create a random key and compile this into
++ * the code. Use this as the base for all devices from the driver
++ * (using a global device count for this driver if necessary).
++ *
++ * With the second strategy the assignment of MACs will depend on
++ * the order of initialisation of the different drivers. To avoid
++ * this provide a kernel (or module) command line parameter to
++ * specify a base index and (optional) count for each driver or
++ * pass in a (struct resource) with the start and end of the keys
++ * to pass to maclist_read. Either method allows the higher levels
++ * (boot loader or machine description) to specify which MACs in
++ * the list to assign to each device.
+ */
+#include <linux/module.h>
+#include <linux/moduleparam.h>
++#include <linux/spinlock.h>
+#include <linux/etherdevice.h>
+#include <linux/proc_fs.h>
+#include <linux/errno.h>
@@ -84,22 +156,27 @@
+
+typedef struct maclist_entry {
+ struct maclist_entry *next; /* Linked list, first first */
++ u32 key; /* count or key for this entry */
++ u16 flags;
+ u8 id[6]; /* 6 byte Ethernet MAC */
+} maclist_entry_t;
+
-+/* Access to this list is possible at any time - entries in
-+ * the list are never destroyed. Modification of the list is
-+ * safe only from the init code (i.e. modification must be
-+ * single threaded), but read from an interrupt at the same
-+ * time is possible and safe.
++/*
++ * flag definitions
+ */
++#define MACLIST_ALLOCATED 1
++#define MACLIST_RANDOM 2
++
++/* Access to this list is protected by a standard rwlock_t. */
+static maclist_entry_t *maclist_list = 0;
+
++static DEFINE_RWLOCK(maclist_lock);
++
+/*
+ * External interfaces.
+ *
+ * Add a single entry, returns 0 on success else an error
-+ * code. Must be single threaded.
++ * code. Checks for invalid addresses.
+ */
+int maclist_add(const u8 new_id[6]) {
+ maclist_entry_t *new_entry, **tail;
@@ -111,21 +188,27 @@
+ new_entry = kmalloc(sizeof *new_entry, GFP_KERNEL);
+ if (new_entry == 0)
+ return -ENOMEM;
-+ new_entry->next = 0;
++ new_entry->next = 0;
++ new_entry->key = 0;
++ new_entry->flags = 0;
+ memcpy(new_entry->id, new_id, sizeof new_entry->id);
+
+ tail = &maclist_list;
++
++ write_lock(&maclist_lock);
+ while (*tail != 0)
+ tail = &(*tail)->next;
+ *tail = new_entry;
++ write_unlock(&maclist_lock);
++
+ return 0;
+}
+EXPORT_SYMBOL(maclist_add);
+
+/*
-+ * Return the current entry count (valid in any context).
++ * Return the current entry count.
+ */
-+int maclist_count(void) {
++static int maclist_count_unlocked(void) {
+ maclist_entry_t *tail = maclist_list;
+ int count = 0;
+
@@ -136,27 +219,73 @@
+
+ return count;
+}
++
++int maclist_count(void) {
++ int count;
++
++ read_lock(&maclist_lock);
++ count = maclist_count_unlocked();
++ read_unlock(&maclist_lock);
++
++ return count;
++}
+EXPORT_SYMBOL(maclist_count);
+
+/*
-+ * Return the ID from the n'th entry (valid in any context),
-+ * returns 0 on success, -EINVAL if 'n' is out of range.
++ * Return the ID with the given key (the key is allocated
++ * to an entry if not found).
+ */
-+int maclist_read(u8 (*id)[6], int n) {
-+ maclist_entry_t *entry = maclist_list;
-+
-+ while (n > 0 && entry != 0) {
-+ --n;
-+ entry = entry->next;
-+ }
++void maclist_read(u8 (*id)[6], u32 key) {
++ int count, index;
++ maclist_entry_t *entry, *entry_to_allocate;
++
++ /* Do this under a write lock to avoid the SMP race
++ * where we find the key isn't assigned, drop the lock,
++ * have another CPU assign it, then assign it on this
++ * CPU too - very bad...
++ */
++ write_lock(&maclist_lock);
++ count = maclist_count_unlocked();
++ index = key % count; /* index of entry to allocate */
++ entry_to_allocate = 0;
++
++ entry = maclist_list;
++ while (entry != 0) {
++ if ((entry->flags & MACLIST_ALLOCATED) != 0) {
++ if (entry->key == key) {
++ /* Found it, use this entry. */
++ entry_to_allocate = entry;
++ break;
++ }
++ } else if (entry_to_allocate == 0 || count <= index) {
++ /* The algorithm is to try for entry
++ * (key % count), but if this isn't possible
++ * return the prior unallocated entry.
++ */
++ entry_to_allocate = entry;
++ }
++
++ ++count;
++ entry = entry->next;
++ }
+
-+ if (n == 0 && entry != 0) {
-+ memcpy(id, entry->id, sizeof *id);
-+ return 0;
++ /* Use entry_to_allocate, allocating it if necessary. */
++ if (entry_to_allocate != 0) {
++ if ((entry_to_allocate->flags & MACLIST_ALLOCATED) == 0) {
++ entry_to_allocate->key = key;
++ entry_to_allocate->flags |= MACLIST_ALLOCATED;
++ }
++ memcpy(id, entry_to_allocate->id, sizeof *id);
++ }
++ write_unlock(&maclist_lock);
++
++ if (entry_to_allocate == 0) {
++ /* No unallocated entries. Make a new one and return it. */
++ printk(KERN_INFO MACLIST_NAME ": adding random MAC for key 0x%x\n", key);
++ random_ether_addr(*id);
++ if (maclist_add(*id) == 0)
++ maclist_read(id, key);
+ }
-+
-+ printk(KERN_ERR MACLIST_NAME ": id does not exist\n");
-+ return -EINVAL;
+}
+EXPORT_SYMBOL(maclist_read);
+
@@ -165,7 +294,7 @@
+ * addresses, comma separated. (The parsing really should
+ * be somewhere central...)
+ */
-+static int __init maclist_setup(char *param) {
++static int __init maclist_setup(const char *param) {
+ int bytes = 0, seen_a_digit = 0;
+ u8 id[6];
+
@@ -219,7 +348,7 @@
+
+ if (bytes >= 12) {
+ int rc = maclist_add(id);
-+ if (rc)
++ if (unlikely(rc))
+ return rc;
+ bytes = 0;
+ seen_a_digit = 0;
@@ -233,10 +362,7 @@
+ return 0;
+}
+
-+/*
-+ * procfs support, if compiled in.
-+ */
-+#ifdef CONFIG_PROC_FS
++#if (defined CONFIG_PROC_FS) || (defined MODULE)
+/*
+ * Character device read
+ */
@@ -264,8 +390,13 @@
+ default: return ':';
+ }
+}
++#endif
+
+/*
++ * procfs support, if compiled in.
++ */
++#ifdef CONFIG_PROC_FS
++/*
+ * The extensively undocumented proc_read_t callback is implemented here.
+ * Go look in fs/proc/generic.c:
+ *
@@ -306,6 +437,49 @@
+#endif
+
+/*
++ * set works once, at init time (the param is set to 0444 below),
++ * get works any time.
++ */
++static int param_set_maclist(const char *val, struct kernel_param *kp)
++{
++ if (maclist_list == 0)
++ return maclist_setup(val);
++
++ printk(KERN_ERR MACLIST_NAME ": call to set parameters too late\n");
++ return -EINVAL;
++}
++
++static int param_get_maclist(char *buffer, struct kernel_param *kp)
++{
++#ifdef MODULE
++ off_t offset = 0;
++
++ /* buffer is only 4k! */
++ while (offset < 4096) {
++ int ch = maclist_getchar(offset++);
++ if (ch < 0) {
++ *buffer = 0;
++ return 0;
++ }
++ *buffer++ = ch;
++ }
++
++ *--buffer = 0;
++ return -ENOMEM;
++#else
++ return -EINVAL;
++#endif
++}
++
++/*
++ * module: the argument is ids=mac,mac,mac
++ * kernel command line: maclist.ids=mac,mac,mac
++ */
++#define param_check_maclist(name, p) __param_check(name, p, maclist_entry_t*)
++module_param_named(ids, maclist_list, maclist, 0444);
++MODULE_PARM_DESC(ids, "comma separated list of MAC ids\n");
++
++/*
+ * Finally, the init/exit functions.
+ */
+static void __exit maclist_exit(void)
@@ -314,8 +488,10 @@
+
+ remove_proc_entry(MACLIST_NAME, proc_net);
+
-+ list = maclist_list;
-+ maclist_list = 0;
++ write_lock(&maclist_lock);
++ list = maclist_list;
++ maclist_list = 0;
++ write_unlock(&maclist_lock);
+
+ while (list != 0) {
+ maclist_entry_t *head = list;
@@ -324,14 +500,6 @@
+ }
+}
+
-+#ifdef MODULE
-+static char ids[256];
-+module_param_string(ids, ids, sizeof ids, 0);
-+MODULE_PARM_DESC(ids, "comma separated list of MAC ids\n");
-+#else
-+__setup("maclist_ids=", maclist_setup);
-+#endif
-+
+static int __init maclist_init(void)
+{
+# ifdef MODULE
@@ -347,37 +515,56 @@
+
+module_init(maclist_init);
+module_exit(maclist_exit);
---- linux-nslu2.orig/drivers/net/Makefile 2006-02-06 22:35:18.000000000 +0100
-+++ linux-nslu2/drivers/net/Makefile 2006-02-06 22:35:23.000000000 +0100
-@@ -74,6 +74,7 @@ obj-$(CONFIG_RIONET) += rionet.o
- # end link order section
- #
-
-+obj-$(CONFIG_MACLIST) += maclist.o
- obj-$(CONFIG_MII) += mii.o
- obj-$(CONFIG_PHYLIB) += phy/
-
---- linux-nslu2.orig/drivers/net/Kconfig 2006-02-06 22:35:18.000000000 +0100
-+++ linux-nslu2/drivers/net/Kconfig 2006-02-06 22:35:23.000000000 +0100
-@@ -180,6 +180,21 @@ config NET_ETHERNET
- kernel: saying N will just cause the configurator to skip all
- the questions about Ethernet network cards. If unsure, say N.
-
-+config MACLIST
-+ tristate "Ethernet MAC repository"
-+ depends on NET_ETHERNET
-+ help
-+ Some ethernet controllers have no built-in way of obtaining an
-+ appropriate Ethernet MAC address. Such controllers have to be
-+ initialised in a board-specific way, depending on how the allocated
-+ MAC is stored. The MAC repository provides a set of APIs and a
-+ proc entry (/proc/net/maclist) to store MAC values from the board
-+ so that such drivers can obtain a MAC address without board-specific
-+ code. You do not need to enable this device - it will be selected
-+ automatically by any device which requires it. It is only useful
-+ to enable it manually when building a device driver independently
-+ of the kernel build.
+diff -rup linux-2.6.15.1/.pc/91-maclist.patch/include/net/maclist.h linux-2.6.15.1/include/net/maclist.h
+--- linux-2.6.15/include/net/maclist.h 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/include/net/maclist.h 1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,49 @@
++#ifndef _MACLIST_H
++#define _MACLIST_H 1
++/*
++ * Interfaces to the MAC repository
++ *
++ * Copyright (C) 2005 John Bowler
++ * Author: John Bowler <jbowler@acm.org>
++ * Maintainers: http://www.nslu2-linux.org/
++ *
++ * 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.
++ */
+
- config MII
- tristate "Generic Media Independent Interface device support"
- depends on NET_ETHERNET
++/*
++ * Add a single entry, returns 0 on success else an error
++ * code. Allocates memory, claims and releases a write
++ * lock.
++ */
++extern int maclist_add(const u8 id_to_add[6]);
++
++/*
++ * Return the current entry count, claims and releases a
++ * read lock.
++ */
++extern int maclist_count(void);
++
++/*
++ * Return the ID from the given entry. Always succeeds.
++ * Claims and releases a write lock.
++ *
++ * If any entry has not been allocated for this key one
++ * is allocated. If there are no remaining unallocated
++ * entries a new one is created.
++ *
++ * If the value of the key is less than maclist_count()
++ * the entry indexed by the key (i.e. for key 'n' the
++ * n'th entry starting at 0) will be returned if available.
++ * Otherwise the entry to be returned will be unpredictable
++ * but consistent for a given value of maclist_count().
++ */
++extern void maclist_read(u8 (*buffer_for_id)[6],
++ u32 key_of_entry_to_return);
++
++/*
++ * See the implementation in drivers/net/maclist.c for
++ * more information.
++ */
++#endif /*_MACLIST_H*/
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/94-nas100d-setup.patch b/packages/linux/ixp4xx-kernel/2.6.16/94-nas100d-setup.patch
index 15ddc44584..cdca7d2766 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/94-nas100d-setup.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/94-nas100d-setup.patch
@@ -41,7 +41,7 @@ Signed-off-by: John Bowler <jbowler@acm.org>
+ */
+static char nas100d_command_line[] __initdata =
+ "root=/dev/mtdblock2 rootfstype=jffs2 init=/linuxrc "
-+ "rtc-pcf8563.force=0,0x51 "
++ "rtc-pcf8563.probe=0,0x51 "
+ CONFIG_CMDLINE;
+
+static void __init nas100d_fixup(struct machine_desc *desc,
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/951-ixp4xx-leds-cpu-activity.patch b/packages/linux/ixp4xx-kernel/2.6.16/951-ixp4xx-leds-cpu-activity.patch
index b6b3897005..92b03836d4 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/951-ixp4xx-leds-cpu-activity.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/951-ixp4xx-leds-cpu-activity.patch
@@ -6,18 +6,25 @@ are idle.
Signed-off-by: John Bowler <jbowler@acm.org>
-diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/arch/arm/kernel/process.c linux-2.6.15.2/arch/arm/kernel/process.c
---- linux-2.6.15/arch/arm/kernel/process.c 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/arch/arm/kernel/process.c 1970-01-01 00:00:00.000000000 +0000
+---
+ arch/arm/kernel/process.c | 11
+ drivers/leds/Kconfig | 9
+ drivers/leds/Makefile | 1
+ drivers/leds/ledtrig-cpu.c | 501 +++++++++++++++++++++++++++++++++++++++++++++
+ include/linux/leds.h | 9
+ 5 files changed, 531 insertions(+)
+
+--- linux-ixp4xx.orig/arch/arm/kernel/process.c 2006-02-21 00:53:28.000000000 +0100
++++ linux-ixp4xx/arch/arm/kernel/process.c 2006-02-21 01:03:33.000000000 +0100
@@ -27,6 +27,7 @@
#include <linux/kallsyms.h>
#include <linux/init.h>
#include <linux/cpu.h>
+#include <linux/leds.h>
- #include <asm/system.h>
- #include <asm/io.h>
-@@ -81,6 +82,12 @@ void (*pm_power_off)(void);
+ #include <asm/leds.h>
+ #include <asm/processor.h>
+@@ -80,6 +81,12 @@ void (*pm_power_off)(void);
EXPORT_SYMBOL(pm_power_off);
/*
@@ -30,7 +37,7 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/arch/arm/kernel/
* This is our default idle handler. We need to disable
* interrupts here to ensure we don't miss a wakeup call.
*/
-@@ -121,8 +128,12 @@ void cpu_idle(void)
+@@ -120,8 +127,12 @@ void cpu_idle(void)
if (!idle)
idle = default_idle;
leds_event(led_idle_start);
@@ -43,9 +50,8 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/arch/arm/kernel/
leds_event(led_idle_end);
preempt_enable_no_resched();
schedule();
-diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/Kconfig linux-2.6.15.2/drivers/leds/Kconfig
---- linux-2.6.15/drivers/leds/Kconfig 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/leds/Kconfig 1970-01-01 00:00:00.000000000 +0000
+--- linux-ixp4xx.orig/drivers/leds/Kconfig 2006-02-21 00:58:36.000000000 +0100
++++ linux-ixp4xx/drivers/leds/Kconfig 2006-02-21 01:03:33.000000000 +0100
@@ -66,5 +66,14 @@ config LEDS_TRIGGER_TIMER
This allows LEDs to be controlled by a programmable timer
via sysfs. If unsure, say Y.
@@ -61,17 +67,15 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/Kco
+
endmenu
-diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/Makefile linux-2.6.15.2/drivers/leds/Makefile
---- linux-2.6.15/drivers/leds/Makefile 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/leds/Makefile 1970-01-01 00:00:00.000000000 +0000
+--- linux-ixp4xx.orig/drivers/leds/Makefile 2006-02-21 00:58:36.000000000 +0100
++++ linux-ixp4xx/drivers/leds/Makefile 2006-02-21 01:03:33.000000000 +0100
@@ -13,3 +13,4 @@ obj-$(CONFIG_LEDS_TOSA) += leds-tosa.o
# LED Triggers
obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o
+obj-$(CONFIG_LEDS_TRIGGER_CPU_ACTIVITY) += ledtrig-cpu.o
-diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/ledtrig-cpu.c linux-2.6.15.2/drivers/leds/ledtrig-cpu.c
---- linux-2.6.15/drivers/leds/ledtrig-cpu.c 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/leds/ledtrig-cpu.c 1970-01-01 00:00:00.000000000 +0000
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-ixp4xx/drivers/leds/ledtrig-cpu.c 2006-02-21 01:08:57.000000000 +0100
@@ -0,0 +1,501 @@
+/*
+ * LEDs CPU activity trigger
@@ -182,7 +186,7 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+ * have changed. Returns true if the LED is blinking. The argument
+ * is the blink state - the brightness of the blinking LED.
+ */
-+static int leds_cpu_trigger_led_state_change(struct led_device *led,
++static int leds_cpu_trigger_led_state_change(struct led_classdev *led,
+ int is_active, enum led_brightness brightness)
+{
+ int is_blinking = 0;
@@ -218,7 +222,7 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+static ssize_t leds_cpu_trigger_show_prop(struct class_device *dev, char *buf,
+ size_t where)
+{
-+ struct led_device *led = dev->class_data;
++ struct led_classdev *led = dev->class_data;
+ cpu_trigger_led_state item = cpu_led_invalid, i;
+ char *next;
+
@@ -270,7 +274,7 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+{
+ size_t rc = 0;
+ cpu_trigger_led_state value = 0/*sic*/;
-+ struct led_device *led;
++ struct led_classdev *led;
+
+ /* ignore space characters before the value. */
+ while (rc < size && isspace(buf[rc]))
@@ -336,7 +340,7 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+ * Activate and deactivate are called on individual LEDs when the
+ * LED trigger property is changed. The LED write lock is held.
+ */
-+static void leds_cpu_trigger_activate(struct led_device *led)
++static void leds_cpu_trigger_activate(struct led_classdev *led)
+{
+ /*
+ * The initial setting of the trigger is simple CPU activity
@@ -358,7 +362,7 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+ led_set_brightness(led, LED_FULL);
+}
+
-+static void leds_cpu_trigger_deactivate(struct led_device *led)
++static void leds_cpu_trigger_deactivate(struct led_classdev *led)
+{
+ struct cpu_trigger_data *data = led->trigger_data;
+ if (likely(data != 0)) {
@@ -422,9 +426,9 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+ leds_cpu_trigger_mark(data, now) ? LED_FULL : LED_OFF;
+ struct list_head *entry;
+
-+ list_for_each(entry, &data->trigger.led_devs) {
-+ struct led_device *led =
-+ list_entry(entry, struct led_device, trig_list);
++ list_for_each(entry, &data->trigger.led_cdevs) {
++ struct led_classdev *led =
++ list_entry(entry, struct led_classdev, trig_list);
+
+ blinking |= leds_cpu_trigger_led_state_change(led,
+ active, brightness);
@@ -574,9 +578,8 @@ diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/drivers/leds/led
+MODULE_AUTHOR("John Bowler <jbowler@acm.org>");
+MODULE_DESCRIPTION("CPU activity LED trigger");
+MODULE_LICENSE("MIT");
-diff -rup linux-2.6.15.2/.pc/951-ixp4xx-leds-cpu-activity.patch/include/linux/leds.h linux-2.6.15.2/include/linux/leds.h
---- linux-2.6.15/include/linux/leds.h 1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/include/linux/leds.h 1970-01-01 00:00:00.000000000 +0000
+--- linux-ixp4xx.orig/include/linux/leds.h 2006-02-21 00:54:33.000000000 +0100
++++ linux-ixp4xx/include/linux/leds.h 2006-02-21 01:03:33.000000000 +0100
@@ -95,3 +95,12 @@ void led_trigger_event(struct led_trigge
#define led_trigger_event(x, y) do {} while(0)
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/96-nas100d-leds.patch b/packages/linux/ixp4xx-kernel/2.6.16/96-nas100d-leds.patch
index 796ca87718..d78a779127 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/96-nas100d-leds.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/96-nas100d-leds.patch
@@ -1,7 +1,6 @@
NEW_LEDS support for the IOMega NAS100D
Signed-off-by: John Bowler <jbowler@acm.org>
-Signed-off-by: Rod Whitby <rod@whitby.id.au>
--- linux-2.6.15/arch/arm/mach-ixp4xx/nas100d-setup.c 1970-01-01 00:00:00.000000000 +0000
+++ linux-2.6.15/arch/arm/mach-ixp4xx/nas100d-setup.c 1970-01-01 00:00:00.000000000 +0000
@@ -32,7 +31,7 @@ Signed-off-by: Rod Whitby <rod@whitby.id.au>
+ .flags = IXP4XX_GPIO_LOW,
+ },
+ {
-+ .name = "disk", /* green flashing (off) and yellow (on) led */
++ .name = "disk-1", /* yellow led */
+ .start = 3,
+ .end = 3,
+ .flags = IXP4XX_GPIO_LOW,
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-buttons.patch b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-buttons.patch
new file mode 100644
index 0000000000..b72c880259
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-buttons.patch
@@ -0,0 +1,122 @@
+Index: linux-2.6.15/arch/arm/mach-ixp4xx/ds101-buttons.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/ds101-buttons.c 2006-02-16 20:04:47.000000000 +0100
+@@ -0,0 +1,117 @@
++/*
++ * arch/arm/mach-ixp4xx/ds101-buttons.c
++ *
++ * DS101 Button driver
++ *
++ * 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.
++ *
++ */
++
++#include <linux/module.h>
++#include <linux/reboot.h>
++#include <linux/interrupt.h>
++#include <asm/mach-types.h>
++
++extern void ctrl_alt_del(void);
++static int usbcopyb_irqcount = 0;
++static int resetb_irqcount = 0;
++static int powerb_irqcount = 0;
++
++static irqreturn_t ds101_usbcopy_handler(int irq, void *dev_id, struct pt_regs *regs)
++{
++ usbcopyb_irqcount++;
++ if (usbcopyb_irqcount > 1) /* Init creates one IRQ. Ignore it */
++ {
++ /* The GPIO line is shared between the button and the led.
++ * Make sure the GPIO is GPIO_OUT, so we don't recieve
++ * irqs from the led going on/off. Disable the irq just in
++ * case.
++ */
++ gpio_line_config(DS101_USBCOPYB_IRQ, DS101_GPIO_OUT);
++ disable_irq(DS101_USBCOPYB_IRQ);
++ printk(KERN_INFO "Usbcopy\n");
++ }
++ return IRQ_HANDLED;
++}
++
++static irqreturn_t ds101_power_handler(int irq, void *dev_id, struct pt_regs *regs)
++{
++ powerb_irqcount++;
++ if (powerb_irqcount > 1)
++ {
++ /* Make the power led flash */
++ gpio_line_set(DS101_POWER_LED, DS101_GPIO_LOW);
++ ctrl_alt_del();
++ }
++ return IRQ_HANDLED;
++}
++
++static irqreturn_t ds101_reset_handler(int irq, void *dev_id, struct pt_regs *regs)
++{
++ resetb_irqcount++;
++ if (resetb_irqcount > 1)
++ {
++ machine_power_off();
++ }
++ return IRQ_HANDLED;
++}
++
++static int __init ds101_buttons_init(void)
++{
++ if (!(machine_is_ds101()))
++ return 0;
++ printk(KERN_INFO "DiskStation DS101 button driver v0.2\n");
++ gpio_line_config(DS101_POWERB_GPIO, (DS101_GPIO_IN|IRQT_FALLING));
++ gpio_line_config(DS101_RESETB_GPIO, (DS101_GPIO_IN|IRQT_FALLING));
++ gpio_line_config(DS101_USBCOPYB_GPIO, (DS101_GPIO_IN|IRQT_FALLING));
++ set_irq_type(DS101_USBCOPYB_IRQ, IRQT_FALLING);
++ set_irq_type(DS101_POWERB_IRQ, IRQT_FALLING);
++ set_irq_type(DS101_RESETB_IRQ, IRQT_FALLING);
++ if (request_irq(DS101_USBCOPYB_IRQ, &ds101_usbcopy_handler, SA_INTERRUPT,
++ "DS101 USBCopy button", NULL) < 0)
++ {
++ printk(KERN_DEBUG "Could not get USBCopy button IRQ (%d)\n",
++ DS101_USBCOPYB_IRQ);
++
++ return -EIO;
++ }
++
++ if (request_irq(DS101_POWERB_IRQ, &ds101_power_handler, SA_INTERRUPT,
++ "DS101 Powerbutton", NULL) < 0)
++ {
++ printk(KERN_DEBUG "Could not get powerbutton IRQ (%d)\n",
++ DS101_POWERB_IRQ);
++ return -EIO;
++ }
++
++ if (request_irq(DS101_RESETB_IRQ, &ds101_reset_handler, SA_INTERRUPT,
++ "DS101 Resetbutton", NULL) < 0)
++ {
++ printk(KERN_DEBUG "Could not get resetbutton IRQ (%d)\n",
++ DS101_RESETB_IRQ);
++ return -EIO;
++ }
++ return 0;
++}
++
++static void __exit ds101_buttons_exit(void)
++{
++ if (!(machine_is_ds101()))
++ return;
++
++ disable_irq(DS101_USBCOPYB_IRQ);
++ disable_irq(DS101_POWERB_IRQ);
++ disable_irq(DS101_RESETB_IRQ);
++ free_irq(DS101_USBCOPYB_IRQ, NULL);
++ free_irq(DS101_POWERB_IRQ, NULL);
++ free_irq(DS101_RESETB_IRQ, NULL);
++}
++
++module_init(ds101_buttons_init);
++module_exit(ds101_buttons_exit);
++
++MODULE_AUTHOR("OEyvind Repvik <nail@nslu2-linux.org>");
++MODULE_DESCRIPTION("DS101 Button driver");
++MODULE_LICENSE("GPL");
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-includes.patch b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-includes.patch
index d9a5f07494..e9127dbbb4 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-includes.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-includes.patch
@@ -1,41 +1,19 @@
-diff -ruN linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/hardware.h linux-2.6.15.new/include/asm-arm/arch-ixp4xx/hardware.h
---- linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/hardware.h 2006-02-11 02:58:47.000000000 +0100
-+++ linux-2.6.15.new/include/asm-arm/arch-ixp4xx/hardware.h 2006-02-10 22:26:54.000000000 +0100
-@@ -46,5 +46,6 @@
- #include "prpmc1100.h"
- #include "nslu2.h"
- #include "nas100d.h"
-+#include "ds101.h"
+ include/asm-arm/arch-ixp4xx/ds101.h | 70 +++++++++++++++++++++++++++++++++
+ include/asm-arm/arch-ixp4xx/hardware.h | 1
+ include/asm-arm/arch-ixp4xx/irqs.h | 7 +++
+ 3 files changed, 78 insertions(+)
- #endif /* _ASM_ARCH_HARDWARE_H */
-diff -ruN linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/irqs.h linux-2.6.15.new/include/asm-arm/arch-ixp4xx/irqs.h
---- linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/irqs.h 2006-02-11 02:58:47.000000000 +0100
-+++ linux-2.6.15.new/include/asm-arm/arch-ixp4xx/irqs.h 2006-02-10 22:56:11.000000000 +0100
-@@ -108,5 +108,12 @@
- #define IRQ_NAS100D_PCI_INTC IRQ_IXP4XX_GPIO9
- #define IRQ_NAS100D_PCI_INTD IRQ_IXP4XX_GPIO8
- #define IRQ_NAS100D_PCI_INTE IRQ_IXP4XX_GPIO7
-+/*
-+ * DS101 board IRQs
-+ */
-+
-+#define IRQ_DS101_PCI_INTA IRQ_IXP4XX_GPIO11
-+#define IRQ_DS101_PCI_INTB IRQ_IXP4XX_GPIO10
-+#define IRQ_DS101_PCI_INTC IRQ_IXP4XX_GPIO9
-
- #endif
-diff -ruN linux-2.6.15.orig/include/asm-arm/arch/ds101.h linux-2.6.15.new/include/asm-arm/arch/ds101.h
---- linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/ds101.h 1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.15.new/include/asm-arm/arch-ixp4xx/ds101.h 2006-02-10 22:16:24.000000000 +0100
-@@ -0,0 +1,72 @@
+Index: linux-2.6.15/include/asm-arm/arch-ixp4xx/ds101.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/include/asm-arm/arch-ixp4xx/ds101.h 2006-02-15 22:35:31.000000000 +0100
+@@ -0,0 +1,89 @@
+/*
+ * include/asm-arm/arch-ixp4xx/ds101.h
+ *
+ * DS101 platform specific definitions
+ *
-+ * Copyright (c) 2005 Tower Technologies
-+ *
-+ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Author: Øyvind Repvik <nail@nslu2-linux.org>
+ *
+ * based on ixdp425.h:
+ * Copyright 2004 (c) MontaVista, Software, Inc.
@@ -49,23 +27,37 @@ diff -ruN linux-2.6.15.orig/include/asm-arm/arch/ds101.h linux-2.6.15.new/includ
+#error "Do not include this directly, instead #include <asm/hardware.h>"
+#endif
+
-+#define DS101_SDA_PIN 1
-+#define DS101_SCL_PIN 0
++#define DS101_SCL_PIN DS101_GPIO0
++#define DS101_SDA_PIN DS101_GPIO1
++#define DS101_GPIO_BUZZ DS101_GPIO2
++#define DS101_POWER_LED DS101_GPIO3
++#define DS101_USBCOPYB_GPIO DS101_GPIO4
++#define DS101_USBCOPY_SOLID_LED DS101_GPIO4 /* The led and button share GPIO */
++#define DS101_USBCOPY_BLINK_LED DS101_GPIO5
++/* GPIO6 is unknown */
++#define DS101_POWEROFF_GPIO DS101_GPIO7
++#define DS101_POWERB_GPIO DS101_GPIO8
++#define DS101_PCI_INTC_PIN DS101_GPIO9
++#define DS101_PCI_INTB_PIN DS101_GPIO10
++#define DS101_PCI_INTA_PIN DS101_GPIO11
++#define DS101_RESETB_GPIO DS101_GPIO12
++#define DS101_STATUSOK_LED DS101_GPIO14
++#define DS101_STATUSBAD_LED DS101_GPIO15
+
-+/*
-+ * DS101 PCI IRQs
-+ */
-+#define DS101_PCI_MAX_DEV 3
-+#define DS101_PCI_IRQ_LINES 3
++#define DS101_PCI_MAX_DEV 2
++#define DS101_PCI_IRQ_LINES 3
+
++#define DS101_POWERB_IRQ IRQ_IXP4XX_GPIO8
++#define DS101_RESETB_IRQ IRQ_IXP4XX_GPIO12
++#define DS101_USBCOPYB_IRQ IRQ_IXP4XX_GPIO4
+
-+/* PCI controller GPIO to IRQ pin mappings */
-+#define DS101_PCI_INTA_PIN 11
-+#define DS101_PCI_INTB_PIN 10
-+#define DS101_PCI_INTC_PIN 9
-+// #define DS101_PCI_INTD_PIN 8
-+// #define DS101_PCI_INTE_PIN 7
++#define DS101_GPIO_IN IXP4XX_GPIO_IN
++#define DS101_GPIO_OUT IXP4XX_GPIO_OUT
++#define DS101_GPIO_HIGH 1
++#define DS101_GPIO_LOW 0
+
++#define DS101_GPIO_CLK0_ENABLE 0x100
++#define DS101_GPIO_CLK1_ENABLE 0x1000000
+/* GPIO */
+
+#define DS101_GPIO0 0
@@ -85,18 +77,51 @@ diff -ruN linux-2.6.15.orig/include/asm-arm/arch/ds101.h linux-2.6.15.new/includ
+#define DS101_GPIO14 14
+#define DS101_GPIO15 15
+
++/* Stuff needed to setup the IXP expansion
++ * bus on the DS101
++ */
++
++#define DS101_EXP_RECOVERY_T(x) (((x) & 15) << 16)
++#define DS101_EXP_HOLD_T(x) (((x) & 3) << 20)
++#define DS101_EXP_STROBE_T(x) (((x) & 15) << 22)
++#define DS101_EXP_SETUP_T(x) (((x) & 3) << 26)
++#define DS101_EXP_ADDR_T(x) (((x) & 3) << 28)
+
-+/* Buttons */
-+
-+#define DS101_PB_GPIO DS101_GPIO8
-+#define DS101_RB_GPIO DS101_GPIO12
-+#define DS101_PO_GPIO DS101_GPIO7 /* power off */
-+
-+#define DS101_PB_IRQ IRQ_IXP4XX_GPIO8
-+#define DS101_RB_IRQ IRQ_IXP4XX_GPIO12
++#define DS101_EXP_SZ_16M (15 << 10)
++#define DS101_EXP_WR_EN (1 << 1)
++#define DS101_EXP_BYTE_RD16 (1 << 6)
++#define DS101_EXP_CS_EN (1 << 31)
+
++#define DS101_EXP_CS0_INIT (DS101_EXP_ADDR_T(1) | \
++ DS101_EXP_SETUP_T(1) | DS101_EXP_STROBE_T(1) | \
++ DS101_EXP_HOLD_T(1) | DS101_EXP_RECOVERY_T(1)| \
++ DS101_EXP_SZ_16M | DS101_EXP_WR_EN | \
++ DS101_EXP_BYTE_RD16 | DS101_EXP_CS_EN)
+Index: linux-2.6.15/include/asm-arm/arch-ixp4xx/hardware.h
+===================================================================
+--- linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/hardware.h 2006-02-13 21:23:22.000000000 +0100
++++ linux-2.6.15/include/asm-arm/arch-ixp4xx/hardware.h 2006-02-13 21:23:26.000000000 +0100
+@@ -46,5 +46,6 @@
+ #include "prpmc1100.h"
+ #include "nslu2.h"
+ #include "nas100d.h"
++#include "ds101.h"
+
+ #endif /* _ASM_ARCH_HARDWARE_H */
+Index: linux-2.6.15/include/asm-arm/arch-ixp4xx/irqs.h
+===================================================================
+--- linux-2.6.15.orig/include/asm-arm/arch-ixp4xx/irqs.h 2006-02-13 21:23:22.000000000 +0100
++++ linux-2.6.15/include/asm-arm/arch-ixp4xx/irqs.h 2006-02-13 21:23:26.000000000 +0100
+@@ -108,5 +108,12 @@
+ #define IRQ_NAS100D_PCI_INTC IRQ_IXP4XX_GPIO9
+ #define IRQ_NAS100D_PCI_INTD IRQ_IXP4XX_GPIO8
+ #define IRQ_NAS100D_PCI_INTE IRQ_IXP4XX_GPIO7
+/*
-+#define DS101_PB_BM (1L << DS101_PB_GPIO)
-+#define DS101_PO_BM (1L << DS101_PO_GPIO)
-+#define DS101_RB_BM (1L << DS101_RB_GPIO)
-+*/
++ * DS101 board IRQs
++ */
++
++#define IRQ_DS101_PCI_INTA IRQ_IXP4XX_GPIO11
++#define IRQ_DS101_PCI_INTB IRQ_IXP4XX_GPIO10
++#define IRQ_DS101_PCI_INTC IRQ_IXP4XX_GPIO9
+
+ #endif
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-misc.patch b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-misc.patch
index ea5f91b45f..6f62a7debb 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-misc.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-misc.patch
@@ -1,19 +1,15 @@
-diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/Makefile linux-2.6.15.new/arch/arm/mach-ixp4xx/Makefile
---- linux-2.6.15.orig/arch/arm/mach-ixp4xx/Makefile 2006-02-11 02:57:58.000000000 +0100
-+++ linux-2.6.15.new/arch/arm/mach-ixp4xx/Makefile 2006-02-10 22:13:27.000000000 +0100
-@@ -10,4 +10,4 @@
- obj-$(CONFIG_MACH_GTWX5715) += gtwx5715-pci.o gtwx5715-setup.o
- obj-$(CONFIG_MACH_NSLU2) += nslu2-pci.o nslu2-setup.o nslu2-power.o
- obj-$(CONFIG_MACH_NAS100D) += nas100d-pci.o nas100d-setup.o nas100d-power.o
--
-+obj-$(CONFIG_MACH_DS101) += ds101-pci.o ds101-setup.o ds101-power.o
-diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/Kconfig linux-2.6.15.new/arch/arm/mach-ixp4xx/Kconfig
---- linux-2.6.15.orig/arch/arm/mach-ixp4xx/Kconfig 2006-02-11 03:00:07.000000000 +0100
-+++ linux-2.6.15.new/arch/arm/mach-ixp4xx/Kconfig 2006-02-10 22:21:09.000000000 +0100
-@@ -86,6 +86,14 @@
- NAS 100d device. For more information on this platform,
- see http://www.nslu2-linux.org/wiki/NAS100d/HomePage
+ arch/arm/mach-ixp4xx/Kconfig | 8 ++++++++
+ arch/arm/mach-ixp4xx/Makefile | 2 +-
+ 2 files changed, 9 insertions(+), 1 deletion(-)
+Index: linux-2.6.15/arch/arm/mach-ixp4xx/Kconfig
+===================================================================
+--- linux-2.6.15.orig/arch/arm/mach-ixp4xx/Kconfig 2006-02-14 19:20:21.000000000 +0100
++++ linux-2.6.15/arch/arm/mach-ixp4xx/Kconfig 2006-02-14 19:20:26.000000000 +0100
+@@ -86,6 +86,14 @@
+ NAS 100d device. For more information on this platform,
+ see http://www.nslu2-linux.org/wiki/NAS100d/HomePage
+
+config MACH_DS101
+ bool
+ prompt "DS101"
@@ -25,3 +21,13 @@ diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/Kconfig linux-2.6.15.new/arch/a
#
# Avila and IXDP share the same source for now. Will change in future
#
+Index: linux-2.6.15/arch/arm/mach-ixp4xx/Makefile
+===================================================================
+--- linux-2.6.15.orig/arch/arm/mach-ixp4xx/Makefile 2006-02-14 19:20:21.000000000 +0100
++++ linux-2.6.15/arch/arm/mach-ixp4xx/Makefile 2006-02-14 19:20:36.000000000 +0100
+@@ -10,4 +10,4 @@
+ obj-$(CONFIG_MACH_GTWX5715) += gtwx5715-pci.o gtwx5715-setup.o
+ obj-$(CONFIG_MACH_NSLU2) += nslu2-pci.o nslu2-setup.o nslu2-power.o
+ obj-$(CONFIG_MACH_NAS100D) += nas100d-pci.o nas100d-setup.o nas100d-power.o
+-
++obj-$(CONFIG_MACH_DS101) += ds101-pci.o ds101-setup.o ds101-buttons.o
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-pci.patch b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-pci.patch
index 8940bd63a6..46556f7cee 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-pci.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-pci.patch
@@ -1,7 +1,9 @@
-diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-pci.c linux-2.6.15.new/arch/arm/mach-ixp4xx/ds101-pci.c
---- linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-pci.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.15.new/arch/arm/mach-ixp4xx/ds101-pci.c 2006-02-10 22:31:00.000000000 +0100
-@@ -0,0 +1,69 @@
+ arch/arm/mach-ixp4xx/ds101-pci.c | 68 +++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 68 insertions(+)
+
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-ixp4xx/arch/arm/mach-ixp4xx/ds101-pci.c 2006-02-11 16:27:21.000000000 +0100
+@@ -0,0 +1,68 @@
+/*
+ * arch/arm/mach-ixp4xx/ds101-pci.c
+ *
@@ -40,8 +42,7 @@ diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-pci.c linux-2.6.15.new/ar
+ static int pci_irq_table[DS101_PCI_MAX_DEV][DS101_PCI_IRQ_LINES] =
+ {
+ { IRQ_DS101_PCI_INTA, -1, -1 },
-+ { IRQ_DS101_PCI_INTB, -1, -1 },
-+ { IRQ_DS101_PCI_INTC, -1, -1 },
++ { IRQ_DS101_PCI_INTB, IRQ_DS101_PCI_INTB, IRQ_DS101_PCI_INTC },
+ };
+
+ int irq = -1;
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-power.patch b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-power.patch
deleted file mode 100644
index 3c309f3536..0000000000
--- a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-power.patch
+++ /dev/null
@@ -1,75 +0,0 @@
-diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-power.c linux-2.6.15.new/arch/arm/mach-ixp4xx/ds101-power.c
---- linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-power.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.15.new/arch/arm/mach-ixp4xx/ds101-power.c 2006-02-10 23:54:40.000000000 +0100
-@@ -0,0 +1,71 @@
-+/*
-+ * arch/arm/mach-ixp4xx/ds101-power.c
-+ *
-+ * DS101 Power/Reset driver
-+ *
-+ * Copyright (C) 2005 Tower Technologies
-+ *
-+ * based on ds101-io.c
-+ * Copyright (C) 2004 Karen Spearel
-+ *
-+ * Author: Alessandro Zummo <a.zummo@towertech.it>
-+ * Author: OEyvind Repvik <oyvind@repvik.org>
-+ * Maintainers: http://www.nslu2-linux.org/
-+ *
-+ * 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.
-+ *
-+ */
-+
-+#include <linux/module.h>
-+#include <linux/reboot.h>
-+#include <linux/interrupt.h>
-+
-+#include <asm/mach-types.h>
-+
-+extern void ctrl_alt_del(void);
-+
-+static irqreturn_t ds101_reset_handler(int irq, void *dev_id, struct pt_regs *regs)
-+{
-+ /* Signal init to do the ctrlaltdel action, this will bypass init if
-+ * it hasn't started and do a kernel_restart.
-+ */
-+ ctrl_alt_del();
-+
-+ return IRQ_HANDLED;
-+}
-+
-+static int __init ds101_power_init(void)
-+{
-+ if (!(machine_is_ds101()))
-+ return 0;
-+
-+ set_irq_type(DS101_RB_IRQ, IRQT_LOW);
-+
-+ if (request_irq(DS101_RB_IRQ, &ds101_reset_handler,
-+ SA_INTERRUPT, "DS101 reset button", NULL) < 0) {
-+
-+ printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
-+ DS101_RB_IRQ);
-+
-+ return -EIO;
-+ }
-+
-+ return 0;
-+}
-+
-+static void __exit ds101_power_exit(void)
-+{
-+ if (!(machine_is_ds101()))
-+ return;
-+
-+ free_irq(DS101_RB_IRQ, NULL);
-+}
-+
-+module_init(ds101_power_init);
-+module_exit(ds101_power_exit);
-+
-+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
-+MODULE_DESCRIPTION("DS101 Power/Reset driver");
-+MODULE_LICENSE("GPL");
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-setup.patch b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-setup.patch
index ac3f7d19c7..107808f6b8 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-setup.patch
+++ b/packages/linux/ixp4xx-kernel/2.6.16/97-ds101-setup.patch
@@ -1,7 +1,11 @@
-diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-setup.c linux-2.6.15.new/arch/arm/mach-ixp4xx/ds101-setup.c
---- linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-setup.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-2.6.15.new/arch/arm/mach-ixp4xx/ds101-setup.c 2006-02-11 02:17:35.000000000 +0100
-@@ -0,0 +1,284 @@
+ arch/arm/mach-ixp4xx/ds101-setup.c | 287 +++++++++++++++++++++++++++++++++++++
+ 1 file changed, 287 insertions(+)
+
+Index: linux-2.6.15/arch/arm/mach-ixp4xx/ds101-setup.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/ds101-setup.c 2006-02-16 19:44:23.000000000 +0100
+@@ -0,0 +1,246 @@
+/*
+ * arch/arm/mach-ixp4xx/ds101-setup.c
+ *
@@ -20,8 +24,9 @@ diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-setup.c linux-2.6.15.new/
+#include <linux/kernel.h>
+#include <linux/serial.h>
+#include <linux/serial_8250.h>
-+#include <linux/mtd/mtd.h>
++/* #include <linux/mtd/mtd.h> */
+#include <linux/leds.h>
++#include <linux/pci.h>
+
+#include <asm/setup.h>
+#include <asm/memory.h>
@@ -29,260 +34,221 @@ diff -ruN linux-2.6.15.orig/arch/arm/mach-ixp4xx/ds101-setup.c linux-2.6.15.new/
+#include <asm/mach/arch.h>
+#include <asm/mach/flash.h>
+
++#ifdef CONFIG_MACLIST
+#include <net/maclist.h>
-+
-+static struct flash_platform_data ds101_flash_data = {
-+ .map_name = "cfi_probe",
-+ .width = 2,
-+};
-+
-+static struct resource ds101_flash_resource = {
-+ .flags = IORESOURCE_MEM,
-+};
-+
-+static struct platform_device ds101_flash = {
-+ .name = "IXP4XX-Flash",
-+ .id = 0,
-+ .dev.platform_data = &ds101_flash_data,
-+ .num_resources = 1,
-+ .resource = &ds101_flash_resource,
-+};
++#endif
+
+#ifdef CONFIG_LEDS_CLASS
+static struct resource ds101_led_resources[] = {
-+ {
-+ .name = "power", /* blue power led */
-+ .start = 3,
-+ .end = 3,
-+ .flags = IXP4XX_GPIO_LOW,
-+ },
-+ {
-+ .name = "status-1",
-+ .start = 14,
-+ .end = 14,
-+ .flags = IXP4XX_GPIO_LOW,
-+ },
-+ {
-+ .name = "status-2",
-+ .start = 15,
-+ .end = 15,
-+ .flags = IXP4XX_GPIO_LOW,
-+ },
-+ {
-+ .name = "usb-1", /* The usb-copy-button led */
-+ .start = 5,
-+ .end = 5,
-+ .flags = IXP4XX_GPIO_LOW,
-+ },
-+ {
-+ .name = "usb-2", /* also the usb-copy-button led */
-+ .start = 4,
-+ .end = 4,
-+ .flags = IXP4XX_GPIO_LOW,
-+ },
-+ {
-+ .name = "test",
-+ .start = 6,
-+ .end = 6,
-+ .flags = IXP4XX_GPIO_LOW,
-+ },
++ {
++ .name = "power",
++ .start = DS101_POWER_LED,
++ .end = DS101_POWER_LED,
++ .flags = IXP4XX_GPIO_LOW,
++ },
++ {
++ .name = "usbcopy-solid",
++ .start = DS101_USBCOPY_SOLID_LED,
++ .end = DS101_USBCOPY_SOLID_LED,
++ .flags = IXP4XX_GPIO_LOW,
++ },
++ {
++ .name = "usbcopy-blink",
++ .start = DS101_USBCOPY_BLINK_LED,
++ .end = DS101_USBCOPY_BLINK_LED,
++ .flags = IXP4XX_GPIO_LOW,
++ },
++ {
++ .name = "status-ready",
++ .start = DS101_STATUSOK_LED,
++ .end = DS101_STATUSOK_LED,
++ .flags = IXP4XX_GPIO_LOW,
++ },
++ {
++ .name = "status-error",
++ .start = DS101_STATUSBAD_LED,
++ .start = DS101_STATUSBAD_LED,
++ .flags = IXP4XX_GPIO_LOW,
++ }
+};
+
+
+static struct platform_device ds101_leds = {
-+ .name = "IXP4XX-GPIO-LED",
-+ .id = -1,
-+ .num_resources = ARRAY_SIZE(ds101_led_resources),
-+ .resource = ds101_led_resources,
++ .name = "IXP4XX-GPIO-LED",
++ .id = -1,
++ .num_resources = ARRAY_SIZE(ds101_led_resources),
++ .resource = ds101_led_resources,
+};
+#endif
+
+static struct ixp4xx_i2c_pins ds101_i2c_gpio_pins = {
-+ .sda_pin = DS101_SDA_PIN,
-+ .scl_pin = DS101_SCL_PIN,
++ .sda_pin = DS101_SDA_PIN,
++ .scl_pin = DS101_SCL_PIN,
+};
+
+static struct platform_device ds101_i2c_controller = {
-+ .name = "IXP4XX-I2C",
-+ .id = 0,
-+ .dev.platform_data = &ds101_i2c_gpio_pins,
-+ .num_resources = 0,
++ .name = "IXP4XX-I2C",
++ .id = 0,
++ .dev.platform_data = &ds101_i2c_gpio_pins,
++ .num_resources = 0,
+};
+
+static struct platform_device ds101_beeper = {
-+ .name = "ixp4xx-beeper",
-+ .id = 2,
-+ .num_resources = 0,
++ .name = "ixp4xx-beeper",
++ .id = DS101_GPIO_BUZZ,
++ .num_resources = 0,
+};
+
+static struct resource ds101_uart_resources[] = {
-+ {
-+ .start = IXP4XX_UART1_BASE_PHYS,
-+ .end = IXP4XX_UART1_BASE_PHYS + 0x0fff,
-+ .flags = IORESOURCE_MEM,
-+ },
-+ {
-+ .start = IXP4XX_UART2_BASE_PHYS,
-+ .end = IXP4XX_UART2_BASE_PHYS + 0x0fff,
-+ .flags = IORESOURCE_MEM,
-+ }
++ {
++ .start = IXP4XX_UART1_BASE_PHYS,
++ .end = IXP4XX_UART1_BASE_PHYS + 0x0fff,
++ .flags = IORESOURCE_MEM,
++ },
++ {
++ .start = IXP4XX_UART2_BASE_PHYS,
++ .end = IXP4XX_UART2_BASE_PHYS + 0x0fff,
++ .flags = IORESOURCE_MEM,
++ }
+};
+
+static struct plat_serial8250_port ds101_uart_data[] = {
-+ {
-+ .mapbase = IXP4XX_UART1_BASE_PHYS,
-+ .membase = (char *)IXP4XX_UART1_BASE_VIRT + REG_OFFSET,
-+ .irq = IRQ_IXP4XX_UART1,
-+ .flags = UPF_BOOT_AUTOCONF,
-+ .iotype = UPIO_MEM,
-+ .regshift = 2,
-+ .uartclk = IXP4XX_UART_XTAL,
-+ },
-+ {
-+ .mapbase = IXP4XX_UART2_BASE_PHYS,
-+ .membase = (char *)IXP4XX_UART2_BASE_VIRT + REG_OFFSET,
-+ .irq = IRQ_IXP4XX_UART2,
-+ .flags = UPF_BOOT_AUTOCONF,
-+ .iotype = UPIO_MEM,
-+ .regshift = 2,
-+ .uartclk = IXP4XX_UART_XTAL,
-+ },
-+ { }
++ {
++ .mapbase = IXP4XX_UART1_BASE_PHYS,
++ .membase = (char *)IXP4XX_UART1_BASE_VIRT + REG_OFFSET,
++ .irq = IRQ_IXP4XX_UART1,
++ .flags = UPF_BOOT_AUTOCONF,
++ .iotype = UPIO_MEM,
++ .regshift = 2,
++ .uartclk = IXP4XX_UART_XTAL,
++ },
++ {
++ .mapbase = IXP4XX_UART2_BASE_PHYS,
++ .membase = (char *)IXP4XX_UART2_BASE_VIRT + REG_OFFSET,
++ .irq = IRQ_IXP4XX_UART2,
++ .flags = UPF_BOOT_AUTOCONF,
++ .iotype = UPIO_MEM,
++ .regshift = 2,
++ .uartclk = IXP4XX_UART_XTAL,
++ },
++ { }
+};
+
+static struct platform_device ds101_uart = {
-+ .name = "serial8250",
-+ .id = PLAT8250_DEV_PLATFORM,
-+ .dev.platform_data = ds101_uart_data,
-+ .num_resources = 2,
-+ .resource = ds101_uart_resources,
++ .name = "serial8250",
++ .id = PLAT8250_DEV_PLATFORM,
++ .dev.platform_data = ds101_uart_data,
++ .num_resources = 2,
++ .resource = ds101_uart_resources,
+};
+
+static struct platform_device *ds101_devices[] __initdata = {
-+ &ds101_i2c_controller,
-+ &ds101_flash,
-+ &ds101_beeper,
++ &ds101_i2c_controller,
++ &ds101_beeper,
+};
+
+static void ds101_power_off(void)
+{
-+ /* This causes the box to drop the power and go dead. */
-+
-+ /* enable the pwr cntl gpio */
-+ gpio_line_config(DS101_PO_GPIO, IXP4XX_GPIO_OUT);
-+
-+ /* do the deed */
-+ gpio_line_set(DS101_PO_GPIO, IXP4XX_GPIO_HIGH);
++ /* Simple, but effective */
++ gpio_line_set(DS101_POWEROFF_GPIO, IXP4XX_GPIO_LOW);
+}
+
-+/*
-+ * When the RedBoot config partition is added the MAC address is read from
-+ * it.
-+ * FIXME: This isn't correct on the DS101!
-+ */
-+static void ds101_flash_add(struct mtd_info *mtd) {
-+ if (strcmp(mtd->name, "RedBoot config") == 0) {
-+ size_t retlen;
-+ u_char mac[6];
-+
-+ /* The MAC is at a known offset... */
-+ if (mtd->read(mtd, 0x0FD8, 6, &retlen, mac) == 0 && retlen == 6) {
-+ printk(KERN_INFO "DS101 MAC: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
-+ mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-+ maclist_add(mac);
-+ } else {
-+ printk(KERN_ERR "DS101 MAC: read failed\n");
-+ }
-+ }
-+}
-+
-+/*
-+ * Nothing to do on remove at present.
-+ */
-+static void ds101_flash_remove(struct mtd_info *mtd) {
-+}
++static void ds101_gpio_setup(void)
++{
++ /* Set up buzzer */
++ gpio_line_config(DS101_GPIO_BUZZ, DS101_GPIO_OUT);
++ gpio_line_set(DS101_GPIO_BUZZ, DS101_GPIO_LOW);
++
++ /* Set up powerled */
++ gpio_line_config(DS101_POWER_LED, DS101_GPIO_OUT);
++ gpio_line_set(DS101_POWER_LED, DS101_GPIO_LOW);
++
++ /* Poweroff */
++ gpio_line_config(DS101_POWEROFF_GPIO, DS101_GPIO_OUT);
++ gpio_line_set(DS101_POWEROFF_GPIO, DS101_GPIO_HIGH);
++
++ /* Status leds */
++ (*IXP4XX_GPIO_GPCLKR) = ((*IXP4XX_GPIO_GPCLKR) & ~DS101_GPIO_CLK0_ENABLE);
++ (*IXP4XX_GPIO_GPCLKR) = ((*IXP4XX_GPIO_GPCLKR) & ~DS101_GPIO_CLK1_ENABLE);
++ gpio_line_config(DS101_STATUSOK_LED, DS101_GPIO_OUT);
++ gpio_line_config(DS101_STATUSBAD_LED, DS101_GPIO_OUT);
++ gpio_line_set(DS101_STATUSOK_LED, DS101_GPIO_HIGH);
++ gpio_line_set(DS101_STATUSBAD_LED, DS101_GPIO_LOW);
++};
+
-+static struct mtd_notifier ds101_flash_notifier = {
-+ .add = ds101_flash_add,
-+ .remove = ds101_flash_remove,
++static void ds101_cs0_setup(void)
++{
++ *IXP4XX_EXP_CS0 = DS101_EXP_CS0_INIT;
+};
+
+static void __init ds101_init(void)
+{
-+ /* The flash has an ethernet MAC embedded in it which we need,
-+ * that is all this notifier does.
-+ */
-+ register_mtd_user(&ds101_flash_notifier);
-+
-+ ixp4xx_sys_init();
-+
-+ ds101_flash_resource.start = IXP4XX_EXP_BUS_BASE(0);
-+ ds101_flash_resource.end =
-+ IXP4XX_EXP_BUS_BASE(0) + ixp4xx_exp_bus_size - 1;
-+
-+ pm_power_off = ds101_power_off;
-+
-+ /* This is only useful on a modified machine, but it is valuable
-+ * to have it first in order to see debug messages, and so that
-+ * it does *not* get removed if platform_add_devices fails!
-+ */
-+ (void)platform_device_register(&ds101_uart);
-+
-+ platform_add_devices(ds101_devices, ARRAY_SIZE(ds101_devices));
-+
++ ixp4xx_sys_init();
++ ds101_cs0_setup(); /* Needed for DoC support */
++ ds101_gpio_setup();
++ pm_power_off = ds101_power_off;
++
++ /* This is only useful on a modified machine, but it is valuable
++ * to have it first in order to see debug messages, and so that
++ * it does *not* get removed if platform_add_devices fails!
++ */
++ (void)platform_device_register(&ds101_uart);
++ platform_add_devices(ds101_devices, ARRAY_SIZE(ds101_devices));
+#ifdef CONFIG_LEDS_CLASS
-+ /* We don't care whether or not this works. */
-+ (void)platform_device_register(&ds101_leds);
++ /* We don't care whether or not this works. */
++ (void)platform_device_register(&ds101_leds);
+#endif
+}
+
+/*
+ * DS101 bootstrap may pass in parameters, but we zap the mem
-+ * settings to be safe (the box always has 64MByte at 0). The
-+ * passed in command line can override this default, we prepend
-+ * to the config'ed default.
++ * settings to be safe (DS101 always has 64MByte at 0, DS101J has
++ * 32MB). The passed in command line can override this default, we
++ * prepend to the config'ed default.
+ *
+ * NOTE: the startup sequence is:
+ * 1) Call the machine fixup
+ * 2) Parse the ATAG list, the ATAG_CMDLINE is copied in
-+ * to default_command_line which is the value of *from
++ * to default_command_line which is the value of *from
+ * 3) Parse the command line in *from (*not*
-+ * default_command_line unless they are the same!)
++ * default_command_line unless they are the same!)
+ *
+ * Setting mi->nr_banks causes (2) to 'squash' (set to ATAG_NONE)
+ * any ATAG_MEM tags, but mem= command line options cause nr_banks
+ * to be reset to 0 (on the first mem=)
+ */
++
+static char ds101_command_line[] __initdata =
-+ "root=/dev/sda1 rootfstype=ext3 init=/sbin/init "
-+ CONFIG_CMDLINE;
++ "root=/dev/sda1 rootfstype=ext3 init=/sbin/init "
++ "rtc-rs5c372.probe=0,0x32 "
++ CONFIG_CMDLINE;
+
+static void __init ds101_fixup(struct machine_desc *desc,
-+ struct tag *tags, char **cmdline, struct meminfo *mi)
++ struct tag *tags, char **cmdline, struct meminfo *mi)
+{
-+ /* The DS101 has one bank of 64MByte memory.
-+ * NOTE: setting nr_banks != 0 causes kernel/setup.c to remove
-+ * the mem tags from the tag list. We need do nothing here!
-+ */
-+ mi->nr_banks=1;
-+ mi->bank[0].start = 0;
-+ mi->bank[0].size = (64*1024*1024);
-+ mi->bank[0].node = PHYS_TO_NID(0);
-+
-+ /* A command line in the ATAG list will override this one,
-+ * as is intended.
-+ */
-+ strlcpy(*cmdline, ds101_command_line, COMMAND_LINE_SIZE);
++ /* The DS101 has one bank of 64MByte memory.
++ * NOTE: setting nr_banks != 0 causes kernel/setup.c to remove
++ * the mem tags from the tag list. We need do nothing here!
++ */
++ mi->nr_banks=1;
++ mi->bank[0].start = 0;
++ mi->bank[0].size = (64*1024*1024);
++ mi->bank[0].node = PHYS_TO_NID(0);
++ /* A command line in the ATAG list will override this one,
++ * as is intended.
++ */
++ strlcpy(*cmdline, ds101_command_line, COMMAND_LINE_SIZE);
+}
+
+MACHINE_START(DS101, "Synology DiskStation DS101")
-+ /* Maintainer: www.nslu2-linux.org */
-+ .phys_io = IXP4XX_PERIPHERAL_BASE_PHYS,
-+ .io_pg_offst = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xFFFC,
-+ .boot_params = 0x00000100,
-+ .fixup = ds101_fixup,
-+ .map_io = ixp4xx_map_io,
-+ .init_irq = ixp4xx_init_irq,
-+ .timer = &ixp4xx_timer,
-+ .init_machine = ds101_init,
++ /* Maintainer: www.nslu2-linux.org */
++ .phys_io = IXP4XX_PERIPHERAL_BASE_PHYS,
++ .io_pg_offst = ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xFFFC,
++ .boot_params = 0x00000100,
++ .fixup = ds101_fixup,
++ .map_io = ixp4xx_map_io,
++ .init_irq = ixp4xx_init_irq,
++ .timer = &ixp4xx_timer,
++ .init_machine = ds101_init,
+MACHINE_END
++
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/defconfig b/packages/linux/ixp4xx-kernel/2.6.16/defconfig
index 0862199528..472a692a32 100644
--- a/packages/linux/ixp4xx-kernel/2.6.16/defconfig
+++ b/packages/linux/ixp4xx-kernel/2.6.16/defconfig
@@ -1469,6 +1469,7 @@ CONFIG_RTC_INTF_DEV=y
CONFIG_RTC_DRV_X1205=y
CONFIG_RTC_DRV_DS1672=y
CONFIG_RTC_DRV_PCF8563=y
+CONFIG_RTC_DRV_RS5C372=y
# CONFIG_RTC_DRV_TEST is not set
#
@@ -1596,7 +1597,7 @@ CONFIG_CIFS_XATTR=y
CONFIG_CIFS_POSIX=y
# CONFIG_CIFS_EXPERIMENTAL is not set
# CONFIG_NCP_FS is not set
-CONFIG_CODA_FS=m
+# CONFIG_CODA_FS is not set
# CONFIG_AFS_FS is not set
# CONFIG_9P_FS is not set
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/leds-class.patch b/packages/linux/ixp4xx-kernel/2.6.16/leds-class.patch
new file mode 100644
index 0000000000..9fbcae79b9
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/leds-class.patch
@@ -0,0 +1,2069 @@
+Add the foundations of a new LEDs subsystem. This patch adds a class
+which presents LED devices within sysfs and allows their brightness to
+be controlled.
+
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/drivers/leds/Kconfig
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 2006-01-29 16:02:38.000000000 +0000
+@@ -0,0 +1,18 @@
++
++menu "LED devices"
++
++config NEW_LEDS
++ bool "LED Support"
++ help
++ Say Y to enable Linux LED support. This is not related to standard
++ keyboard LEDs which are controlled via the input system.
++
++config LEDS_CLASS
++ tristate "LED Class Support"
++ depends NEW_LEDS
++ help
++ This option enables the led sysfs class in /sys/class/leds. You'll
++ need this to do anything useful with LEDs. If unsure, say N.
++
++endmenu
++
+Index: linux-2.6.15/drivers/leds/Makefile
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 2006-01-29 16:02:38.000000000 +0000
+@@ -0,0 +1,4 @@
++
++# LED Core
++obj-$(CONFIG_NEW_LEDS) += led-core.o
++obj-$(CONFIG_LEDS_CLASS) += led-class.o
+Index: linux-2.6.15/include/linux/leds.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/include/linux/leds.h 2006-01-29 16:03:21.000000000 +0000
+@@ -0,0 +1,48 @@
++/*
++ * Driver model for leds and led triggers
++ *
++ * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
++ * Copyright (C) 2005 Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++struct device;
++struct class_device;
++/*
++ * LED Core
++ */
++
++enum led_brightness {
++ LED_OFF = 0,
++ LED_HALF = 127,
++ LED_FULL = 255,
++};
++
++struct led_classdev {
++ const char *name;
++ int brightness;
++ int flags;
++#define LED_SUSPENDED (1 << 0)
++
++ /* A function to set the brightness of the led */
++ void (*brightness_set)(struct led_classdev *led_cdev, enum led_brightness brightness);
++
++ struct class_device *class_dev;
++ /* LED Device linked list */
++ struct list_head node;
++
++ /* Trigger data */
++ char *default_trigger;
++
++ /* This protects the data in this structure */
++ rwlock_t lock;
++};
++
++extern int led_classdev_register(struct device *parent, struct led_classdev *led_cdev);
++extern void led_classdev_unregister(struct led_classdev *led_cdev);
++extern void led_classdev_suspend(struct led_classdev *led_cdev);
++extern void led_classdev_resume(struct led_classdev *led_cdev);
+Index: linux-2.6.15/arch/arm/Kconfig
+===================================================================
+--- linux-2.6.15.orig/arch/arm/Kconfig 2006-01-29 14:37:31.000000000 +0000
++++ linux-2.6.15/arch/arm/Kconfig 2006-01-29 16:02:15.000000000 +0000
+@@ -774,6 +774,8 @@
+
+ source "drivers/mfd/Kconfig"
+
++source "drivers/leds/Kconfig"
++
+ source "drivers/media/Kconfig"
+
+ source "drivers/video/Kconfig"
+Index: linux-2.6.15/drivers/Makefile
+===================================================================
+--- linux-2.6.15.orig/drivers/Makefile 2006-01-29 14:42:52.000000000 +0000
++++ linux-2.6.15/drivers/Makefile 2006-01-29 14:43:11.000000000 +0000
+@@ -68,6 +68,7 @@
+ obj-$(CONFIG_EISA) += eisa/
+ obj-$(CONFIG_CPU_FREQ) += cpufreq/
+ obj-$(CONFIG_MMC) += mmc/
++obj-$(CONFIG_NEW_LEDS) += leds/
+ obj-$(CONFIG_INFINIBAND) += infiniband/
+ obj-$(CONFIG_SGI_IOC4) += sn/
+ obj-y += firmware/
+Index: linux-2.6.15/drivers/Kconfig
+===================================================================
+--- linux-2.6.15.orig/drivers/Kconfig 2006-01-29 14:42:51.000000000 +0000
++++ linux-2.6.15/drivers/Kconfig 2006-01-29 14:43:11.000000000 +0000
+@@ -64,6 +64,8 @@
+
+ source "drivers/mmc/Kconfig"
+
++source "drivers/leds/Kconfig"
++
+ source "drivers/infiniband/Kconfig"
+
+ source "drivers/sn/Kconfig"
+Index: linux-2.6.15/drivers/leds/leds.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds.h 2006-01-29 16:02:38.000000000 +0000
+@@ -0,0 +1,26 @@
++/*
++ * LED Core
++ *
++ * Copyright 2005 Openedhand Ltd.
++ *
++ * Author: Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++/* led_cdev->lock must be held as write */
++static inline void led_set_brightness(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value > LED_FULL)
++ value = LED_FULL;
++ led_cdev->brightness = value;
++ if (!(led_cdev->flags & LED_SUSPENDED))
++ led_cdev->brightness_set(led_cdev, value);
++}
++
++extern rwlock_t leds_list_lock;
++extern struct list_head leds_list;
++
+Index: linux-2.6.15/drivers/leds/led-class.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/led-class.c 2006-01-29 16:02:38.000000000 +0000
+@@ -0,0 +1,150 @@
++/*
++ * LED Class Core
++ *
++ * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
++ * Copyright (C) 2005-2006 Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/spinlock.h>
++#include <linux/device.h>
++#include <linux/sysdev.h>
++#include <linux/timer.h>
++#include <linux/err.h>
++#include <linux/leds.h>
++#include "leds.h"
++
++static struct class *leds_class;
++
++static ssize_t led_brightness_show(struct class_device *dev, char *buf)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ ssize_t ret = 0;
++
++ /* no lock needed for this */
++ sprintf(buf, "%u\n", led_cdev->brightness);
++ ret = strlen(buf) + 1;
++
++ return ret;
++}
++
++static ssize_t led_brightness_store(struct class_device *dev, const char *buf, size_t size)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ ssize_t ret = -EINVAL;
++ char *after;
++
++ unsigned long state = simple_strtoul(buf, &after, 10);
++ if (after - buf > 0) {
++ ret = after - buf;
++ write_lock(&led_cdev->lock);
++ led_set_brightness(led_cdev, state);
++ write_unlock(&led_cdev->lock);
++ }
++
++ return ret;
++}
++
++static CLASS_DEVICE_ATTR(brightness, 0644, led_brightness_show, led_brightness_store);
++
++
++/**
++ * led_classdev_suspend - suspend an led_classdev.
++ * @led_cdev: the led_classdev to suspend.
++ */
++void led_classdev_suspend(struct led_classdev *led_cdev)
++{
++ write_lock(&led_cdev->lock);
++ led_cdev->flags |= LED_SUSPENDED;
++ led_cdev->brightness_set(led_cdev, 0);
++ write_unlock(&led_cdev->lock);
++}
++
++/**
++ * led_classdev_resume - resume an led_classdev.
++ * @led_cdev: the led_classdev to resume.
++ */
++void led_classdev_resume(struct led_classdev *led_cdev)
++{
++ write_lock(&led_cdev->lock);
++ led_cdev->flags &= ~LED_SUSPENDED;
++ led_cdev->brightness_set(led_cdev, led_cdev->brightness);
++ write_unlock(&led_cdev->lock);
++}
++
++/**
++ * led_classdev_register - register a new object of led_classdev class.
++ * @dev: The device to register.
++ * @led_cdev: the led_classdev structure for this device.
++ */
++int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
++{
++ led_cdev->class_dev = class_device_create(leds_class, NULL, 0, parent, "%s", led_cdev->name);
++ if (unlikely(IS_ERR(led_cdev->class_dev)))
++ return PTR_ERR(led_cdev->class_dev);
++
++ rwlock_init(&led_cdev->lock);
++ led_cdev->class_dev->class_data = led_cdev;
++
++ /* register the attributes */
++ class_device_create_file(led_cdev->class_dev, &class_device_attr_brightness);
++
++ /* add to the list of leds */
++ write_lock(&leds_list_lock);
++ list_add_tail(&led_cdev->node, &leds_list);
++ write_unlock(&leds_list_lock);
++
++ printk(KERN_INFO "Registered led device: %s\n", led_cdev->class_dev->class_id);
++
++ return 0;
++}
++
++/**
++ * led_classdev_unregister - unregisters a object of led_properties class.
++ * @led_cdev: the led device to unreigister
++ *
++ * Unregisters a previously registered via led_classdev_register object.
++ */
++void led_classdev_unregister(struct led_classdev *led_cdev)
++{
++ class_device_remove_file(led_cdev->class_dev, &class_device_attr_brightness);
++
++ class_device_unregister(led_cdev->class_dev);
++
++ write_lock(&leds_list_lock);
++ list_del(&led_cdev->node);
++ write_unlock(&leds_list_lock);
++}
++
++EXPORT_SYMBOL_GPL(led_classdev_suspend);
++EXPORT_SYMBOL_GPL(led_classdev_resume);
++EXPORT_SYMBOL_GPL(led_classdev_register);
++EXPORT_SYMBOL_GPL(led_classdev_unregister);
++
++static int __init leds_init(void)
++{
++ leds_class = class_create(THIS_MODULE, "leds");
++ if (IS_ERR(leds_class))
++ return PTR_ERR(leds_class);
++ return 0;
++}
++
++static void __exit leds_exit(void)
++{
++ class_destroy(leds_class);
++}
++
++subsys_initcall(leds_init);
++module_exit(leds_exit);
++
++MODULE_AUTHOR("John Lenz, Richard Purdie");
++MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("LED Class Interface");
+Index: linux-2.6.15/drivers/leds/led-core.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/led-core.c 2006-01-29 14:43:11.000000000 +0000
+@@ -0,0 +1,24 @@
++/*
++ * LED Class Core
++ *
++ * Copyright 2005-2006 Openedhand Ltd.
++ *
++ * Author: Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/list.h>
++#include <linux/module.h>
++#include <linux/spinlock.h>
++#include <linux/leds.h>
++#include "leds.h"
++
++rwlock_t leds_list_lock = RW_LOCK_UNLOCKED;
++LIST_HEAD(leds_list);
++
++EXPORT_SYMBOL_GPL(leds_list);
+Add support for LED triggers to the LED subsystem. "Triggers" are events
+which change the state of an LED. Two kinds of trigger are available,
+simple ones which can be added to exising code with minimum disruption
+and complex ones for implementing new or more complex functionality.
+
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/drivers/leds/Kconfig
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Kconfig 2006-01-29 15:52:16.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 2006-01-29 16:02:35.000000000 +0000
+@@ -14,5 +14,13 @@
+ This option enables the led sysfs class in /sys/class/leds. You'll
+ need this to do anything useful with LEDs. If unsure, say N.
+
++config LEDS_TRIGGERS
++ bool "LED Trigger support"
++ depends NEW_LEDS
++ help
++ This option enables trigger support for the leds class.
++ These triggers allow kernel events to drive the LEDs and can
++ be configured via sysfs. If unsure, say Y.
++
+ endmenu
+
+Index: linux-2.6.15/drivers/leds/Makefile
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Makefile 2006-01-29 15:52:16.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 2006-01-29 16:02:35.000000000 +0000
+@@ -2,3 +2,4 @@
+ # LED Core
+ obj-$(CONFIG_NEW_LEDS) += led-core.o
+ obj-$(CONFIG_LEDS_CLASS) += led-class.o
++obj-$(CONFIG_LEDS_TRIGGERS) += led-triggers.o
+Index: linux-2.6.15/drivers/leds/leds.h
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/leds.h 2006-01-29 15:54:46.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds.h 2006-01-29 15:55:02.000000000 +0000
+@@ -24,3 +24,13 @@
+ extern rwlock_t leds_list_lock;
+ extern struct list_head leds_list;
+
++#ifdef CONFIG_LEDS_TRIGGERS
++void led_trigger_set_default(struct led_classdev *led_cdev);
++void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger);
++#else
++#define led_trigger_set_default(x) do {} while(0)
++#define led_trigger_set(x, y) do {} while(0)
++#endif
++
++ssize_t led_trigger_store(struct class_device *dev, const char *buf, size_t count);
++ssize_t led_trigger_show(struct class_device *dev, char *buf);
+Index: linux-2.6.15/include/linux/leds.h
+===================================================================
+--- linux-2.6.15.orig/include/linux/leds.h 2006-01-29 15:52:16.000000000 +0000
++++ linux-2.6.15/include/linux/leds.h 2006-01-29 15:55:02.000000000 +0000
+@@ -38,6 +38,11 @@
+
+ /* Trigger data */
+ char *default_trigger;
++#ifdef CONFIG_LEDS_TRIGGERS
++ struct led_trigger *trigger;
++ struct list_head trig_list;
++ void *trigger_data;
++#endif
+
+ /* This protects the data in this structure */
+ rwlock_t lock;
+@@ -47,3 +52,47 @@
+ extern void led_classdev_unregister(struct led_classdev *led_cdev);
+ extern void led_classdev_suspend(struct led_classdev *led_cdev);
+ extern void led_classdev_resume(struct led_classdev *led_cdev);
++
++
++/*
++ * LED Triggers
++ */
++#ifdef CONFIG_LEDS_TRIGGERS
++
++#define TRIG_NAME_MAX 50
++
++struct led_trigger {
++ /* Trigger Properties */
++ const char *name;
++ void (*activate)(struct led_classdev *led_cdev);
++ void (*deactivate)(struct led_classdev *led_cdev);
++
++ /* LEDs under control by this trigger (for simple triggers) */
++ rwlock_t leddev_list_lock;
++ struct list_head led_cdevs;
++
++ /* Link to next registered trigger */
++ struct list_head next_trig;
++};
++
++/* Registration functions for complex triggers */
++int led_trigger_register(struct led_trigger *trigger);
++void led_trigger_unregister(struct led_trigger *trigger);
++
++/* Registration functions for simple triggers */
++#define INIT_LED_TRIGGER(x) static struct led_trigger *x;
++#define INIT_LED_TRIGGER_GLOBAL(x) struct led_trigger *x;
++void led_trigger_register_simple(const char *name, struct led_trigger **trigger);
++void led_trigger_unregister_simple(struct led_trigger *trigger);
++void led_trigger_event(struct led_trigger *trigger, enum led_brightness event);
++
++#else
++
++/* Triggers aren't active - null macros */
++#define INIT_LED_TRIGGER(x)
++#define INIT_LED_TRIGGER_GLOBAL(x)
++#define led_trigger_register_simple(x, y) do {} while(0)
++#define led_trigger_unregister_simple(x) do {} while(0)
++#define led_trigger_event(x, y) do {} while(0)
++
++#endif
+Index: linux-2.6.15/drivers/leds/led-class.c
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/led-class.c 2006-01-29 15:54:02.000000000 +0000
++++ linux-2.6.15/drivers/leds/led-class.c 2006-01-29 15:55:02.000000000 +0000
+@@ -55,6 +55,9 @@
+
+ static CLASS_DEVICE_ATTR(brightness, 0644, led_brightness_show, led_brightness_store);
+
++#ifdef CONFIG_LEDS_TRIGGERS
++static CLASS_DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
++#endif
+
+ /**
+ * led_classdev_suspend - suspend an led_classdev.
+@@ -96,12 +99,17 @@
+
+ /* register the attributes */
+ class_device_create_file(led_cdev->class_dev, &class_device_attr_brightness);
++#ifdef CONFIG_LEDS_TRIGGERS
++ class_device_create_file(led_cdev->class_dev, &class_device_attr_trigger);
++#endif
+
+ /* add to the list of leds */
+ write_lock(&leds_list_lock);
+ list_add_tail(&led_cdev->node, &leds_list);
+ write_unlock(&leds_list_lock);
+
++ led_trigger_set_default(led_cdev);
++
+ printk(KERN_INFO "Registered led device: %s\n", led_cdev->class_dev->class_id);
+
+ return 0;
+@@ -116,6 +124,12 @@
+ void led_classdev_unregister(struct led_classdev *led_cdev)
+ {
+ class_device_remove_file(led_cdev->class_dev, &class_device_attr_brightness);
++#ifdef CONFIG_LEDS_TRIGGERS
++ class_device_remove_file(led_cdev->class_dev, &class_device_attr_trigger);
++#endif
++
++ if (led_cdev->trigger)
++ led_trigger_set(led_cdev, NULL);
+
+ class_device_unregister(led_cdev->class_dev);
+
+Index: linux-2.6.15/drivers/leds/led-triggers.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/led-triggers.c 2006-01-29 15:56:15.000000000 +0000
+@@ -0,0 +1,236 @@
++/*
++ * LED Triggers Core
++ *
++ * Copyright 2005-2006 Openedhand Ltd.
++ *
++ * Author: Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/spinlock.h>
++#include <linux/device.h>
++#include <linux/sysdev.h>
++#include <linux/timer.h>
++#include <linux/leds.h>
++#include "leds.h"
++
++static rwlock_t triggers_list_lock = RW_LOCK_UNLOCKED;
++static LIST_HEAD(trigger_list);
++
++ssize_t led_trigger_store(struct class_device *dev, const char *buf, size_t count)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ char trigger_name[TRIG_NAME_MAX];
++ struct led_trigger *trig;
++ size_t len;
++
++ trigger_name[sizeof(trigger_name) - 1] = '\0';
++ strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
++ len = strlen(trigger_name);
++
++ if (len && trigger_name[len - 1] == '\n')
++ trigger_name[len - 1] = '\0';
++
++ if (!strcmp(trigger_name, "none")) {
++ write_lock(&led_cdev->lock);
++ led_trigger_set(led_cdev, NULL);
++ write_unlock(&led_cdev->lock);
++ return count;
++ }
++
++ read_lock(&triggers_list_lock);
++ list_for_each_entry(trig, &trigger_list, next_trig) {
++ if (!strcmp(trigger_name, trig->name)) {
++ write_lock(&led_cdev->lock);
++ led_trigger_set(led_cdev, trig);
++ write_unlock(&led_cdev->lock);
++
++ read_unlock(&triggers_list_lock);
++ return count;
++ }
++ }
++ read_unlock(&triggers_list_lock);
++
++ return -EINVAL;
++}
++
++
++ssize_t led_trigger_show(struct class_device *dev, char *buf)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ struct led_trigger *trig;
++ int len = 0;
++
++ read_lock(&led_cdev->lock);
++
++ if (!led_cdev->trigger)
++ len += sprintf(buf+len, "[none] ");
++ else
++ len += sprintf(buf+len, "none ");
++
++ read_lock(&triggers_list_lock);
++ list_for_each_entry(trig, &trigger_list, next_trig) {
++ if (led_cdev->trigger && !strcmp(led_cdev->trigger->name, trig->name))
++ len += sprintf(buf+len, "[%s] ", trig->name);
++ else
++ len += sprintf(buf+len, "%s ", trig->name);
++ }
++ read_unlock(&triggers_list_lock);
++ read_unlock(&led_cdev->lock);
++
++ len += sprintf(len+buf, "\n");
++ return len;
++}
++
++void led_trigger_event(struct led_trigger *trigger, enum led_brightness brightness)
++{
++ struct list_head *entry;
++
++ if (!trigger)
++ return;
++
++ read_lock(&trigger->leddev_list_lock);
++ list_for_each(entry, &trigger->led_cdevs) {
++ struct led_classdev *led_cdev;
++
++ led_cdev = list_entry(entry, struct led_classdev, trig_list);
++ write_lock(&led_cdev->lock);
++ led_set_brightness(led_cdev, brightness);
++ write_unlock(&led_cdev->lock);
++ }
++ read_unlock(&trigger->leddev_list_lock);
++}
++
++/* Caller must ensure led_cdev->lock held for write */
++void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger)
++{
++ /* Remove any existing trigger */
++ if (led_cdev->trigger) {
++ write_lock(&led_cdev->trigger->leddev_list_lock);
++ list_del(&led_cdev->trig_list);
++ write_unlock(&led_cdev->trigger->leddev_list_lock);
++ if (led_cdev->trigger->deactivate)
++ led_cdev->trigger->deactivate(led_cdev);
++
++ }
++ if (trigger) {
++ write_lock(&trigger->leddev_list_lock);
++ list_add_tail(&led_cdev->trig_list, &trigger->led_cdevs);
++ write_unlock(&trigger->leddev_list_lock);
++ if (trigger->activate)
++ trigger->activate(led_cdev);
++ }
++ led_cdev->trigger = trigger;
++}
++
++void led_trigger_set_default(struct led_classdev *led_cdev)
++{
++ struct led_trigger *trig;
++
++ if (!led_cdev->default_trigger)
++ return;
++
++ write_lock(&led_cdev->lock);
++ read_lock(&triggers_list_lock);
++ list_for_each_entry(trig, &trigger_list, next_trig) {
++ if (!strcmp(led_cdev->default_trigger, trig->name))
++ led_trigger_set(led_cdev, trig);
++ }
++ read_unlock(&triggers_list_lock);
++ write_unlock(&led_cdev->lock);
++}
++
++int led_trigger_register(struct led_trigger *trigger)
++{
++ struct led_classdev *led_cdev;
++
++ rwlock_init(&trigger->leddev_list_lock);
++ INIT_LIST_HEAD(&trigger->led_cdevs);
++
++ /* Add to the list of led triggers */
++ write_lock(&triggers_list_lock);
++ list_add_tail(&trigger->next_trig, &trigger_list);
++ write_unlock(&triggers_list_lock);
++
++ /* Register with any LEDs that have this as a default trigger */
++ read_lock(&leds_list);
++ list_for_each_entry(led_cdev, &leds_list, node) {
++ write_lock(&led_cdev->lock);
++ if (!led_cdev->trigger && led_cdev->default_trigger &&
++ !strcmp(led_cdev->default_trigger, trigger->name))
++ led_trigger_set(led_cdev, trigger);
++ write_unlock(&led_cdev->lock);
++ }
++ read_unlock(&leds_list);
++
++ return 0;
++}
++
++void led_trigger_register_simple(const char *name, struct led_trigger **tp)
++{
++ struct led_trigger *trigger;
++
++ trigger = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
++
++ if (trigger) {
++ trigger->name = name;
++ led_trigger_register(trigger);
++ }
++ *tp = trigger;
++}
++
++
++void led_trigger_unregister(struct led_trigger *trigger)
++{
++ struct led_classdev *led_cdev;
++
++ /* Remove from the list of led triggers */
++ write_lock(&triggers_list_lock);
++ list_del(&trigger->next_trig);
++ write_unlock(&triggers_list_lock);
++
++ /* Remove anyone actively using this trigger */
++ read_lock(&leds_list);
++ list_for_each_entry(led_cdev, &leds_list, node) {
++ write_lock(&led_cdev->lock);
++ if (led_cdev->trigger == trigger)
++ led_trigger_set(led_cdev, NULL);
++ write_unlock(&led_cdev->lock);
++ }
++ read_unlock(&leds_list);
++}
++
++void led_trigger_unregister_simple(struct led_trigger *trigger)
++{
++ led_trigger_unregister(trigger);
++ kfree(trigger);
++}
++
++/* Used by LED Class */
++EXPORT_SYMBOL_GPL(led_trigger_set);
++EXPORT_SYMBOL_GPL(led_trigger_set_default);
++EXPORT_SYMBOL_GPL(led_trigger_show);
++EXPORT_SYMBOL_GPL(led_trigger_store);
++
++/* LED Trigger Interface */
++EXPORT_SYMBOL_GPL(led_trigger_register);
++EXPORT_SYMBOL_GPL(led_trigger_unregister);
++
++/* Simple LED Tigger Interface */
++EXPORT_SYMBOL_GPL(led_trigger_register_simple);
++EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
++EXPORT_SYMBOL_GPL(led_trigger_event);
++
++MODULE_AUTHOR("Richard Purdie");
++MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("LED Triggers Core");
++
+Add an example of a complex LED trigger in the form of a generic timer
+which triggers the LED its attached to at a user specified frequency
+and duty cycle.
+
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/drivers/leds/Kconfig
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Kconfig 2006-01-29 16:13:48.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 2006-01-29 20:32:16.000000000 +0000
+@@ -22,5 +22,12 @@
+ These triggers allow kernel events to drive the LEDs and can
+ be configured via sysfs. If unsure, say Y.
+
++config LEDS_TRIGGER_TIMER
++ tristate "LED Timer Trigger"
++ depends LEDS_TRIGGERS
++ help
++ This allows LEDs to be controlled by a programmable timer
++ via sysfs. If unsure, say Y.
++
+ endmenu
+
+Index: linux-2.6.15/drivers/leds/Makefile
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Makefile 2006-01-29 16:13:48.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 2006-01-29 20:32:16.000000000 +0000
+@@ -3,3 +3,6 @@
+ obj-$(CONFIG_NEW_LEDS) += led-core.o
+ obj-$(CONFIG_LEDS_CLASS) += led-class.o
+ obj-$(CONFIG_LEDS_TRIGGERS) += led-triggers.o
++
++# LED Triggers
++obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o
+Index: linux-2.6.15/drivers/leds/ledtrig-timer.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/ledtrig-timer.c 2006-01-29 17:40:11.000000000 +0000
+@@ -0,0 +1,205 @@
++/*
++ * LED Kernel Timer Trigger
++ *
++ * Copyright 2005-2006 Openedhand Ltd.
++ *
++ * Author: Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/spinlock.h>
++#include <linux/device.h>
++#include <linux/sysdev.h>
++#include <linux/timer.h>
++#include <linux/leds.h>
++#include "leds.h"
++
++struct timer_trig_data {
++ unsigned long duty; /* duty cycle, as a percentage */
++ unsigned long frequency; /* frequency of blinking, in Hz */
++ unsigned long delay_on; /* milliseconds on */
++ unsigned long delay_off; /* milliseconds off */
++ struct timer_list timer;
++};
++
++static void led_timer_function(unsigned long data)
++{
++ struct led_classdev *led_cdev = (struct led_classdev *) data;
++ struct timer_trig_data *timer_data = led_cdev->trigger_data;
++ unsigned long brightness = LED_OFF;
++ unsigned long delay = timer_data->delay_off;
++
++ write_lock(&led_cdev->lock);
++
++ if (!timer_data->frequency) {
++ led_set_brightness(led_cdev, LED_OFF);
++ write_unlock(&led_cdev->lock);
++ return;
++ }
++
++ if (!led_cdev->brightness) {
++ brightness = LED_FULL;
++ delay = timer_data->delay_on;
++ }
++
++ led_set_brightness(led_cdev, brightness);
++
++ mod_timer(&timer_data->timer, jiffies + msecs_to_jiffies(delay));
++ write_unlock(&led_cdev->lock);
++}
++
++/* led_cdev write lock needs to be held */
++static int led_timer_setdata(struct led_classdev *led_cdev, unsigned long duty, unsigned long frequency)
++{
++ struct timer_trig_data *timer_data = led_cdev->trigger_data;
++
++ if (frequency > 500)
++ return -EINVAL;
++
++ if (duty > 100)
++ return -EINVAL;
++
++ timer_data->duty = duty;
++ timer_data->frequency = frequency;
++ if (frequency != 0) {
++ timer_data->delay_on = duty * 1000 / 50 / frequency / 2;
++ timer_data->delay_off = (100 - duty) * 1000 / 50 / frequency / 2;
++ }
++
++ mod_timer(&timer_data->timer, jiffies + 1);
++
++ return 0;
++}
++
++static ssize_t led_duty_show(struct class_device *dev, char *buf)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ struct timer_trig_data *timer_data;
++
++ read_lock(&led_cdev->lock);
++ timer_data = led_cdev->trigger_data;
++ sprintf(buf, "%lu\n", timer_data->duty);
++ read_unlock(&led_cdev->lock);
++
++ return strlen(buf) + 1;
++}
++
++static ssize_t led_duty_store(struct class_device *dev, const char *buf, size_t size)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ struct timer_trig_data *timer_data;
++ int ret = -EINVAL;
++ char *after;
++
++ unsigned long state = simple_strtoul(buf, &after, 10);
++ if (after - buf > 0) {
++ write_lock(&led_cdev->lock);
++ timer_data = led_cdev->trigger_data;
++ ret = led_timer_setdata(led_cdev, state, timer_data->frequency);
++ if (!ret)
++ ret = after - buf;
++ write_unlock(&led_cdev->lock);
++ }
++
++ return ret;
++}
++
++
++static ssize_t led_frequency_show(struct class_device *dev, char *buf)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ struct timer_trig_data *timer_data;
++
++ read_lock(&led_cdev->lock);
++ timer_data = led_cdev->trigger_data;
++ sprintf(buf, "%lu\n", timer_data->frequency);
++ read_unlock(&led_cdev->lock);
++
++ return strlen(buf) + 1;
++}
++
++static ssize_t led_frequency_store(struct class_device *dev, const char *buf, size_t size)
++{
++ struct led_classdev *led_cdev = dev->class_data;
++ struct timer_trig_data *timer_data;
++ int ret = -EINVAL;
++ char *after;
++
++ unsigned long state = simple_strtoul(buf, &after, 10);
++ if (after - buf > 0) {
++ write_lock(&led_cdev->lock);
++ timer_data = led_cdev->trigger_data;
++ ret = led_timer_setdata(led_cdev, timer_data->duty, state);
++ if (!ret)
++ ret = after - buf;
++ write_unlock(&led_cdev->lock);
++ }
++
++ return ret;
++}
++
++static CLASS_DEVICE_ATTR(duty, 0644, led_duty_show, led_duty_store);
++static CLASS_DEVICE_ATTR(frequency, 0644, led_frequency_show, led_frequency_store);
++
++static void timer_trig_activate(struct led_classdev *led_cdev)
++{
++ struct timer_trig_data *timer_data;
++
++ timer_data = kzalloc(sizeof(struct timer_trig_data), GFP_KERNEL);
++ if (!timer_data)
++ return;
++
++ led_cdev->trigger_data = timer_data;
++
++ init_timer(&timer_data->timer);
++ timer_data->timer.function = led_timer_function;
++ timer_data->timer.data = (unsigned long) led_cdev;
++
++ timer_data->duty = 50;
++
++ class_device_create_file(led_cdev->class_dev, &class_device_attr_duty);
++ class_device_create_file(led_cdev->class_dev, &class_device_attr_frequency);
++}
++
++static void timer_trig_deactivate(struct led_classdev *led_cdev)
++{
++ struct timer_trig_data *timer_data = led_cdev->trigger_data;
++ if (timer_data) {
++ class_device_remove_file(led_cdev->class_dev, &class_device_attr_duty);
++ class_device_remove_file(led_cdev->class_dev, &class_device_attr_frequency);
++ del_timer_sync(&timer_data->timer);
++ kfree(timer_data);
++ }
++}
++
++static struct led_trigger timer_led_trigger = {
++ .name = "timer",
++ .activate = timer_trig_activate,
++ .deactivate = timer_trig_deactivate,
++};
++
++static int __init timer_trig_init(void)
++{
++ return led_trigger_register(&timer_led_trigger);
++}
++
++static void __exit timer_trig_exit (void)
++{
++ led_trigger_unregister(&timer_led_trigger);
++}
++
++module_init(timer_trig_init);
++module_exit(timer_trig_exit);
++
++MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");
++MODULE_DESCRIPTION("Timer LED trigger");
++MODULE_LICENSE("GPL");
+Adds LED drivers for LEDs found on the Sharp Zaurus c7x0 (corgi,
+shepherd, husky) and cxx00 (akita, spitz, borzoi) models.
+
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/arch/arm/mach-pxa/corgi.c
+===================================================================
+--- linux-2.6.15.orig/arch/arm/mach-pxa/corgi.c 2006-01-29 16:02:30.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-pxa/corgi.c 2006-01-29 16:11:47.000000000 +0000
+@@ -165,6 +165,15 @@
+
+
+ /*
++ * Corgi LEDs
++ */
++static struct platform_device corgiled_device = {
++ .name = "corgi-led",
++ .id = -1,
++};
++
++
++/*
+ * Corgi Touch Screen Device
+ */
+ static struct resource corgits_resources[] = {
+@@ -298,6 +307,7 @@
+ &corgikbd_device,
+ &corgibl_device,
+ &corgits_device,
++ &corgiled_device,
+ };
+
+ static void __init corgi_init(void)
+Index: linux-2.6.15/arch/arm/mach-pxa/spitz.c
+===================================================================
+--- linux-2.6.15.orig/arch/arm/mach-pxa/spitz.c 2006-01-29 16:02:30.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-pxa/spitz.c 2006-01-29 16:11:48.000000000 +0000
+@@ -243,6 +243,15 @@
+
+
+ /*
++ * Spitz LEDs
++ */
++static struct platform_device spitzled_device = {
++ .name = "spitz-led",
++ .id = -1,
++};
++
++
++/*
+ * Spitz Touch Screen Device
+ */
+ static struct resource spitzts_resources[] = {
+@@ -419,6 +428,7 @@
+ &spitzkbd_device,
+ &spitzts_device,
+ &spitzbl_device,
++ &spitzled_device,
+ };
+
+ static void __init common_init(void)
+Index: linux-2.6.15/drivers/leds/Kconfig
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Kconfig 2006-01-29 16:04:20.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 2006-01-29 16:11:54.000000000 +0000
+@@ -22,6 +22,20 @@
+ These triggers allow kernel events to drive the LEDs and can
+ be configured via sysfs. If unsure, say Y.
+
++config LEDS_CORGI
++ tristate "LED Support for the Sharp SL-C7x0 series"
++ depends LEDS_CLASS && PXA_SHARP_C7xx
++ help
++ This option enables support for the LEDs on Sharp Zaurus
++ SL-C7x0 series (C700, C750, C760, C860).
++
++config LEDS_SPITZ
++ tristate "LED Support for the Sharp SL-Cxx00 series"
++ depends LEDS_CLASS && PXA_SHARP_Cxx00
++ help
++ This option enables support for the LEDs on Sharp Zaurus
++ SL-Cxx00 series (C1000, C3000, C3100).
++
+ config LEDS_TRIGGER_TIMER
+ tristate "LED Timer Trigger"
+ depends LEDS_TRIGGERS
+Index: linux-2.6.15/drivers/leds/Makefile
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Makefile 2006-01-29 16:04:20.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 2006-01-29 16:11:54.000000000 +0000
+@@ -4,5 +4,9 @@
+ obj-$(CONFIG_LEDS_CLASS) += led-class.o
+ obj-$(CONFIG_LEDS_TRIGGERS) += led-triggers.o
+
++# LED Platform Drivers
++obj-$(CONFIG_LEDS_CORGI) += leds-corgi.o
++obj-$(CONFIG_LEDS_SPITZ) += leds-spitz.o
++
+ # LED Triggers
+ obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o
+Index: linux-2.6.15/drivers/leds/leds-corgi.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds-corgi.c 2006-01-29 16:08:42.000000000 +0000
+@@ -0,0 +1,121 @@
++/*
++ * LED Triggers Core
++ *
++ * Copyright 2005-2006 Openedhand Ltd.
++ *
++ * Author: Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/platform_device.h>
++#include <linux/leds.h>
++#include <asm/mach-types.h>
++#include <asm/arch/corgi.h>
++#include <asm/arch/hardware.h>
++#include <asm/arch/pxa-regs.h>
++#include <asm/hardware/scoop.h>
++
++static void corgiled_amber_set(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value)
++ GPSR0 = GPIO_bit(CORGI_GPIO_LED_ORANGE);
++ else
++ GPCR0 = GPIO_bit(CORGI_GPIO_LED_ORANGE);
++}
++
++static void corgiled_green_set(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value)
++ set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
++ else
++ reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
++}
++
++static struct led_classdev corgi_amber_led = {
++ .name = "corgi:amber",
++ .default_trigger = "sharpsl-charge",
++ .brightness_set = corgiled_amber_set,
++};
++
++static struct led_classdev corgi_green_led = {
++ .name = "corgi:green",
++ .default_trigger = "nand-disk",
++ .brightness_set = corgiled_green_set,
++};
++
++#ifdef CONFIG_PM
++static int corgiled_suspend(struct platform_device *dev, pm_message_t state)
++{
++#ifdef CONFIG_LEDS_TRIGGERS
++ if (corgi_amber_led.trigger && strcmp(corgi_amber_led.trigger->name, "sharpsl-charge"))
++#endif
++ led_classdev_suspend(&corgi_amber_led);
++ led_classdev_suspend(&corgi_green_led);
++ return 0;
++}
++
++static int corgiled_resume(struct platform_device *dev)
++{
++ led_classdev_resume(&corgi_amber_led);
++ led_classdev_resume(&corgi_green_led);
++ return 0;
++}
++#endif
++
++static int corgiled_probe(struct platform_device *pdev)
++{
++ int ret;
++
++ ret = led_classdev_register(&pdev->dev, &corgi_amber_led);
++ if (ret < 0)
++ return ret;
++
++ ret = led_classdev_register(&pdev->dev, &corgi_green_led);
++ if (ret < 0)
++ led_classdev_unregister(&corgi_amber_led);
++
++ return ret;
++}
++
++static int corgiled_remove(struct platform_device *pdev)
++{
++ led_classdev_unregister(&corgi_amber_led);
++ led_classdev_unregister(&corgi_green_led);
++ return 0;
++}
++
++static struct platform_driver corgiled_driver = {
++ .probe = corgiled_probe,
++ .remove = corgiled_remove,
++#ifdef CONFIG_PM
++ .suspend = corgiled_suspend,
++ .resume = corgiled_resume,
++#endif
++ .driver = {
++ .name = "corgi-led",
++ },
++};
++
++static int __devinit corgiled_init(void)
++{
++ return platform_driver_register(&corgiled_driver);
++}
++
++static void corgiled_exit(void)
++{
++ platform_driver_unregister(&corgiled_driver);
++}
++
++module_init(corgiled_init);
++module_exit(corgiled_exit);
++
++MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");
++MODULE_DESCRIPTION("Corgi LED driver");
++MODULE_LICENSE("GPL");
+Index: linux-2.6.15/drivers/leds/leds-spitz.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds-spitz.c 2006-01-29 16:08:09.000000000 +0000
+@@ -0,0 +1,125 @@
++/*
++ * LED Triggers Core
++ *
++ * Copyright 2005-2006 Openedhand Ltd.
++ *
++ * Author: Richard Purdie <rpurdie@openedhand.com>
++ *
++ * 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.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/platform_device.h>
++#include <linux/leds.h>
++#include <asm/hardware/scoop.h>
++#include <asm/mach-types.h>
++#include <asm/arch/hardware.h>
++#include <asm/arch/pxa-regs.h>
++#include <asm/arch/spitz.h>
++
++static void spitzled_amber_set(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value)
++ set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_LED_ORANGE);
++ else
++ reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_LED_ORANGE);
++}
++
++static void spitzled_green_set(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value)
++ set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_LED_GREEN);
++ else
++ reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_LED_GREEN);
++}
++
++static struct led_classdev spitz_amber_led = {
++ .name = "spitz:amber",
++ .default_trigger = "sharpsl-charge",
++ .brightness_set = spitzled_amber_set,
++};
++
++static struct led_classdev spitz_green_led = {
++ .name = "spitz:green",
++ .default_trigger = "ide-disk",
++ .brightness_set = spitzled_green_set,
++};
++
++#ifdef CONFIG_PM
++static int spitzled_suspend(struct platform_device *dev, pm_message_t state)
++{
++#ifdef CONFIG_LEDS_TRIGGERS
++ if (spitz_amber_led.trigger && strcmp(spitz_amber_led.trigger->name, "sharpsl-charge"))
++#endif
++ led_classdev_suspend(&spitz_amber_led);
++ led_classdev_suspend(&spitz_green_led);
++ return 0;
++}
++
++static int spitzled_resume(struct platform_device *dev)
++{
++ led_classdev_resume(&spitz_amber_led);
++ led_classdev_resume(&spitz_green_led);
++ return 0;
++}
++#endif
++
++static int spitzled_probe(struct platform_device *pdev)
++{
++ int ret;
++
++ if (machine_is_akita())
++ spitz_green_led.default_trigger = "nand-disk";
++
++ ret = led_classdev_register(&pdev->dev, &spitz_amber_led);
++ if (ret < 0)
++ return ret;
++
++ ret = led_classdev_register(&pdev->dev, &spitz_green_led);
++ if (ret < 0)
++ led_classdev_unregister(&spitz_amber_led);
++
++ return ret;
++}
++
++static int spitzled_remove(struct platform_device *pdev)
++{
++ led_classdev_unregister(&spitz_amber_led);
++ led_classdev_unregister(&spitz_green_led);
++
++ return 0;
++}
++
++static struct platform_driver spitzled_driver = {
++ .probe = spitzled_probe,
++ .remove = spitzled_remove,
++#ifdef CONFIG_PM
++ .suspend = spitzled_suspend,
++ .resume = spitzled_resume,
++#endif
++ .driver = {
++ .name = "spitz-led",
++ },
++};
++
++static int __devinit spitzled_init(void)
++{
++ return platform_driver_register(&spitzled_driver);
++}
++
++static void spitzled_exit(void)
++{
++ platform_driver_unregister(&spitzled_driver);
++}
++
++module_init(spitzled_init);
++module_exit(spitzled_exit);
++
++MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");
++MODULE_DESCRIPTION("Spitz LED driver");
++MODULE_LICENSE("GPL");
+Adds an LED driver for LEDs exported by the Sharp LOCOMO chip as found on
+some models of Sharp Zaurus.
+
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/drivers/leds/Kconfig
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Kconfig 2006-01-29 16:04:22.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 2006-01-29 16:04:23.000000000 +0000
+@@ -29,6 +29,13 @@
+ This option enables support for the LEDs on Sharp Zaurus
+ SL-C7x0 series (C700, C750, C760, C860).
+
++config LEDS_LOCOMO
++ tristate "LED Support for Locomo device"
++ depends LEDS_CLASS && SHARP_LOCOMO
++ help
++ This option enables support for the LEDs on Sharp Locomo.
++ Zaurus models SL-5500 and SL-5600.
++
+ config LEDS_SPITZ
+ tristate "LED Support for the Sharp SL-Cxx00 series"
+ depends LEDS_CLASS && PXA_SHARP_Cxx00
+Index: linux-2.6.15/drivers/leds/Makefile
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Makefile 2006-01-29 16:04:22.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 2006-01-29 16:04:23.000000000 +0000
+@@ -6,6 +6,7 @@
+
+ # LED Platform Drivers
+ obj-$(CONFIG_LEDS_CORGI) += leds-corgi.o
++obj-$(CONFIG_LEDS_LOCOMO) += leds-locomo.o
+ obj-$(CONFIG_LEDS_SPITZ) += leds-spitz.o
+
+ # LED Triggers
+Index: linux-2.6.15/drivers/leds/leds-locomo.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds-locomo.c 2006-01-29 16:09:46.000000000 +0000
+@@ -0,0 +1,91 @@
++/*
++ * linux/drivers/leds/locomo.c
++ *
++ * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
++ *
++ * 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.
++ */
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/device.h>
++#include <linux/leds.h>
++
++#include <asm/hardware.h>
++#include <asm/hardware/locomo.h>
++
++static void locomoled_brightness_set(struct led_classdev *led_cdev, enum led_brightness value, int offset)
++{
++ struct locomo_dev *locomo_dev = LOCOMO_DEV(led_cdev->class_dev->dev);
++ unsigned long flags;
++
++ local_irq_save(flags);
++ if (value)
++ locomo_writel(LOCOMO_LPT_TOFH, locomo_dev->mapbase + offset);
++ else
++ locomo_writel(LOCOMO_LPT_TOFL, locomo_dev->mapbase + offset);
++ local_irq_restore(flags);
++}
++
++static void locomoled_brightness_set0(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ locomoled_brightness_set(led_cdev, value, LOCOMO_LPT0);
++}
++
++static void locomoled_brightness_set1(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ locomoled_brightness_set(led_cdev, value, LOCOMO_LPT1);
++}
++
++static struct led_classdev locomo_led0 = {
++ .name = "locomo:amber",
++ .brightness_set = locomoled_brightness_set0,
++};
++
++static struct led_classdev locomo_led1 = {
++ .name = "locomo:green",
++ .brightness_set = locomoled_brightness_set1,
++};
++
++static int locomoled_probe(struct locomo_dev *ldev)
++{
++ int ret;
++
++ ret = led_classdev_register(&ldev->dev, &locomo_led0);
++ if (ret < 0)
++ return ret;
++
++ ret = led_classdev_register(&ldev->dev, &locomo_led1);
++ if (ret < 0)
++ led_classdev_unregister(&locomo_led0);
++
++ return ret;
++}
++
++static int locomoled_remove(struct locomo_dev *dev)
++{
++ led_classdev_unregister(&locomo_led0);
++ led_classdev_unregister(&locomo_led1);
++ return 0;
++}
++
++static struct locomo_driver locomoled_driver = {
++ .drv = {
++ .name = "locomoled"
++ },
++ .devid = LOCOMO_DEVID_LED,
++ .probe = locomoled_probe,
++ .remove = locomoled_remove,
++};
++
++static int __init locomoled_init(void) {
++ return locomo_driver_register(&locomoled_driver);
++}
++module_init(locomoled_init);
++
++MODULE_AUTHOR("John Lenz <lenz@cs.wisc.edu>");
++MODULE_DESCRIPTION("Locomo LED driver");
++MODULE_LICENSE("GPL");
+From: John Bowler <jbowler@acm.org>
+
+NEW_LEDS support for ixp4xx boards where LEDs are connected
+to the GPIO lines.
+
+This includes a new generic ixp4xx driver (leds-ixp4xx-gpio.c
+name "IXP4XX-GPIO-LED")
+
+Signed-off-by: John Bowler <jbowler@acm.org>
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+--- linux-2.6.15/drivers/leds/Kconfig 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 1970-01-01 00:00:00.000000000 +0000
+@@ -43,6 +43,15 @@ config LEDS_SPITZ
+ This option enables support for the LEDs on Sharp Zaurus
+ SL-Cxx00 series (C1000, C3000, C3100).
+
++config LEDS_IXP4XX
++ tristate "LED Support for GPIO connected LEDs on IXP4XX processors"
++ depends LEDS_CLASS && ARCH_IXP4XX
++ help
++ This option enables support for the LEDs connected to GPIO
++ outputs of the Intel IXP4XX processors. To be useful the
++ particular board must have LEDs and they must be connected
++ to the GPIO lines. If unsure, say Y.
++
+ config LEDS_TRIGGER_TIMER
+ tristate "LED Timer Trigger"
+ depends LEDS_TRIGGERS
+--- linux-2.6.15/drivers/leds/Makefile 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 1970-01-01 00:00:00.000000000 +0000
+@@ -8,6 +8,7 @@ obj-$(CONFIG_LEDS_TRIGGERS) += led-trig
+ obj-$(CONFIG_LEDS_CORGI) += leds-corgi.o
+ obj-$(CONFIG_LEDS_LOCOMO) += leds-locomo.o
+ obj-$(CONFIG_LEDS_SPITZ) += leds-spitz.o
++obj-$(CONFIG_LEDS_IXP4XX) += leds-ixp4xx-gpio.o
+
+ # LED Triggers
+ obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o
+--- linux-2.6.15/drivers/leds/leds-ixp4xx-gpio.c 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds-ixp4xx-gpio.c 1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,209 @@
++/*
++ * IXP4XX GPIO driver LED driver
++ *
++ * Author: John Bowler <jbowler@acm.org>
++ *
++ * Copyright (c) 2006 John Bowler
++ *
++ * Permission is hereby granted, free of charge, to any
++ * person obtaining a copy of this software and associated
++ * documentation files (the "Software"), to deal in the
++ * Software without restriction, including without
++ * limitation the rights to use, copy, modify, merge,
++ * publish, distribute, sublicense, and/or sell copies of
++ * the Software, and to permit persons to whom the
++ * Software is furnished to do so, subject to the
++ * following conditions:
++ *
++ * The above copyright notice and this permission notice
++ * shall be included in all copies or substantial portions
++ * of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
++ * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
++ * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
++ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
++ * SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
++ * OTHER DEALINGS IN THE SOFTWARE.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/platform_device.h>
++#include <linux/spinlock.h>
++#include <linux/leds.h>
++#include <asm/arch/hardware.h>
++
++extern spinlock_t gpio_lock;
++
++/* Up to 16 gpio lines are possible. */
++#define GPIO_MAX 16
++static struct ixp4xxgpioled_device {
++ struct led_classdev ancestor;
++ int flags;
++} ixp4xxgpioled_devices[GPIO_MAX];
++
++void ixp4xxgpioled_brightness_set(struct led_classdev *pled, enum led_brightness value)
++{
++ const struct ixp4xxgpioled_device *const ixp4xx_dev =
++ container_of(pled, struct ixp4xxgpioled_device, ancestor);
++ const u32 gpio_pin = ixp4xx_dev - ixp4xxgpioled_devices;
++
++ if (gpio_pin < GPIO_MAX && ixp4xx_dev->ancestor.name != 0) {
++ /* Set or clear the 'gpio_pin' bit according to the style
++ * and the required setting (value > 0 == on)
++ */
++ const int gpio_value =
++ (value > 0) == (ixp4xx_dev->flags != IXP4XX_GPIO_LOW) ?
++ IXP4XX_GPIO_HIGH : IXP4XX_GPIO_LOW;
++
++ {
++ unsigned long flags;
++ spin_lock_irqsave(&gpio_lock, flags);
++ gpio_line_set(gpio_pin, gpio_value);
++ spin_unlock_irqrestore(&gpio_lock, flags);
++ }
++ }
++}
++
++/* LEDs are described in resources, the following iterates over the valid
++ * LED resources.
++ */
++#define for_all_leds(i, pdev) \
++ for (i=0; i<pdev->num_resources; ++i) \
++ if (pdev->resource[i].start < GPIO_MAX && \
++ pdev->resource[i].name != 0)
++
++/* The following applies 'operation' to each LED from the given platform,
++ * the function always returns 0 to allow tail call elimination.
++ */
++static int apply_to_all_leds(struct platform_device *pdev,
++ void (*operation)(struct led_classdev *pled)) {
++ int i;
++ for_all_leds(i, pdev)
++ operation(&ixp4xxgpioled_devices[pdev->resource[i].start].ancestor);
++ return 0;
++}
++
++#ifdef CONFIG_PM
++static int ixp4xxgpioled_suspend(struct platform_device *pdev, pm_message_t state)
++{
++ return apply_to_all_leds(pdev, led_classdev_suspend);
++}
++
++static int ixp4xxgpioled_resume(struct platform_device *pdev)
++{
++ return apply_to_all_leds(pdev, led_classdev_resume);
++}
++#endif
++
++static void ixp4xxgpioled_remove_one_led(struct led_classdev *pled) {
++ led_classdev_unregister(pled);
++ pled->name = 0;
++}
++
++static int ixp4xxgpioled_remove(struct platform_device *pdev)
++{
++ return apply_to_all_leds(pdev, ixp4xxgpioled_remove_one_led);
++}
++
++static int ixp4xxgpioled_probe(struct platform_device *pdev)
++{
++ /* The board level has to tell the driver where the
++ * LEDs are connected - there is no way to find out
++ * electrically. It must also say whether the GPIO
++ * lines are active high or active low.
++ *
++ * To do this read the num_resources (the number of
++ * LEDs) and the struct resource (the data for each
++ * LED). The name comes from the resource, and it
++ * isn't copied.
++ */
++ int i;
++ for_all_leds(i, pdev) {
++ const u8 gpio_pin = pdev->resource[i].start;
++ int rc;
++
++ if (ixp4xxgpioled_devices[gpio_pin].ancestor.name == 0) {
++ unsigned long flags;
++
++ spin_lock_irqsave(&gpio_lock, flags);
++ gpio_line_config(gpio_pin, IXP4XX_GPIO_OUT);
++ /* The config can, apparently, reset the state,
++ * I suspect the gpio line may be an input and
++ * the config may cause the line to be latched,
++ * so the setting depends on how the LED is
++ * connected to the line (which affects how it
++ * floats if not driven).
++ */
++ gpio_line_set(gpio_pin, IXP4XX_GPIO_HIGH);
++ spin_unlock_irqrestore(&gpio_lock, flags);
++
++ ixp4xxgpioled_devices[gpio_pin].flags =
++ pdev->resource[i].flags & IORESOURCE_BITS;
++
++ ixp4xxgpioled_devices[gpio_pin].ancestor.name =
++ pdev->resource[i].name;
++
++ /* This is how a board manufacturer makes the LED
++ * come on on reset - the GPIO line will be high, so
++ * make the LED light when the line is low...
++ */
++ if (ixp4xxgpioled_devices[gpio_pin].flags != IXP4XX_GPIO_LOW)
++ ixp4xxgpioled_devices[gpio_pin].ancestor.brightness = 100;
++ else
++ ixp4xxgpioled_devices[gpio_pin].ancestor.brightness = 0;
++
++ ixp4xxgpioled_devices[gpio_pin].ancestor.flags = 0;
++
++ ixp4xxgpioled_devices[gpio_pin].ancestor.brightness_set =
++ ixp4xxgpioled_brightness_set;
++
++ ixp4xxgpioled_devices[gpio_pin].ancestor.default_trigger = 0;
++ }
++
++ rc = led_classdev_register(&pdev->dev,
++ &ixp4xxgpioled_devices[gpio_pin].ancestor);
++ if (rc < 0) {
++ ixp4xxgpioled_devices[gpio_pin].ancestor.name = 0;
++ ixp4xxgpioled_remove(pdev);
++ return rc;
++ }
++ }
++
++ return 0;
++}
++
++static struct platform_driver ixp4xxgpioled_driver = {
++ .probe = ixp4xxgpioled_probe,
++ .remove = ixp4xxgpioled_remove,
++#ifdef CONFIG_PM
++ .suspend = ixp4xxgpioled_suspend,
++ .resume = ixp4xxgpioled_resume,
++#endif
++ .driver = {
++ .name = "IXP4XX-GPIO-LED",
++ },
++};
++
++static int __devinit ixp4xxgpioled_init(void)
++{
++ return platform_driver_register(&ixp4xxgpioled_driver);
++}
++
++static void ixp4xxgpioled_exit(void)
++{
++ platform_driver_unregister(&ixp4xxgpioled_driver);
++}
++
++module_init(ixp4xxgpioled_init);
++module_exit(ixp4xxgpioled_exit);
++
++MODULE_AUTHOR("John Bowler <jbowler@acm.org>");
++MODULE_DESCRIPTION("IXP4XX GPIO LED driver");
++MODULE_LICENSE("MIT");
+From: Dirk Opfer <dirk@opfer-online.de>
+
+Adds LED drivers for LEDs found on the Sharp Zaurus c6000 model (tosa).
+
+Signed-off-by: Dirk Opfer <dirk@opfer-online.de>
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/drivers/leds/Kconfig
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Kconfig 2006-01-30 00:25:28.000000000 +0000
++++ linux-2.6.15/drivers/leds/Kconfig 2006-01-30 00:25:52.000000000 +0000
+@@ -52,6 +52,13 @@
+ particular board must have LEDs and they must be connected
+ to the GPIO lines. If unsure, say Y.
+
++config LEDS_TOSA
++ tristate "LED Support for the Sharp SL-6000 series"
++ depends LEDS_CLASS && PXA_SHARPSL
++ help
++ This option enables support for the LEDs on Sharp Zaurus
++ SL-6000 series.
++
+ config LEDS_TRIGGER_TIMER
+ tristate "LED Timer Trigger"
+ depends LEDS_TRIGGERS
+Index: linux-2.6.15/drivers/leds/Makefile
+===================================================================
+--- linux-2.6.15.orig/drivers/leds/Makefile 2006-01-30 00:25:28.000000000 +0000
++++ linux-2.6.15/drivers/leds/Makefile 2006-01-30 00:26:48.000000000 +0000
+@@ -9,6 +9,7 @@
+ obj-$(CONFIG_LEDS_LOCOMO) += leds-locomo.o
+ obj-$(CONFIG_LEDS_SPITZ) += leds-spitz.o
+ obj-$(CONFIG_LEDS_IXP4XX) += leds-ixp4xx-gpio.o
++obj-$(CONFIG_LEDS_TOSA) += leds-tosa.o
+
+ # LED Triggers
+ obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o
+Index: linux-2.6.15/drivers/leds/leds-tosa.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/leds/leds-tosa.c 2006-01-30 00:28:15.000000000 +0000
+@@ -0,0 +1,123 @@
++/*
++ * LED Triggers Core
++ *
++ * Copyright 2005 Dirk Opfer
++ *
++ * Author: Dirk Opfer <Dirk@Opfer-Online.de>
++ * based on spitz.c
++ *
++ * 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.
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/platform_device.h>
++#include <linux/leds.h>
++#include <asm/hardware/scoop.h>
++#include <asm/mach-types.h>
++#include <asm/arch/hardware.h>
++#include <asm/arch/pxa-regs.h>
++#include <asm/arch/tosa.h>
++
++static void tosaled_amber_set(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value)
++ set_scoop_gpio(&tosascoop_jc_device.dev, TOSA_SCOOP_JC_CHRG_ERR_LED);
++ else
++ reset_scoop_gpio(&tosascoop_jc_device.dev, TOSA_SCOOP_JC_CHRG_ERR_LED);
++}
++
++static void tosaled_green_set(struct led_classdev *led_cdev, enum led_brightness value)
++{
++ if (value)
++ set_scoop_gpio(&tosascoop_jc_device.dev, TOSA_SCOOP_JC_NOTE_LED);
++ else
++ reset_scoop_gpio(&tosascoop_jc_device.dev, TOSA_SCOOP_JC_NOTE_LED);
++}
++
++static struct led_classdev tosa_amber_led = {
++ .name = "tosa:amber",
++ .default_trigger = "sharpsl-charge",
++ .brightness_set = tosaled_amber_set,
++};
++
++static struct led_classdev tosa_green_led = {
++ .name = "tosa:green",
++ .default_trigger = "nand-disk",
++ .brightness_set = tosaled_green_set,
++};
++
++#ifdef CONFIG_PM
++static int tosaled_suspend(struct platform_device *dev, pm_message_t state)
++{
++#ifdef CONFIG_LEDS_TRIGGERS
++ if (tosa_amber_led.trigger && strcmp(tosa_amber_led.trigger->name, "sharpsl-charge"))
++#endif
++ led_classdev_suspend(&tosa_amber_led);
++ led_classdev_suspend(&tosa_green_led);
++ return 0;
++}
++
++static int tosaled_resume(struct platform_device *dev)
++{
++ led_classdev_resume(&tosa_amber_led);
++ led_classdev_resume(&tosa_green_led);
++ return 0;
++}
++#endif
++
++static int tosaled_probe(struct platform_device *pdev)
++{
++ int ret;
++
++ ret = led_classdev_register(&pdev->dev, &tosa_amber_led);
++ if (ret < 0)
++ return ret;
++
++ ret = led_classdev_register(&pdev->dev, &tosa_green_led);
++ if (ret < 0)
++ led_classdev_unregister(&tosa_amber_led);
++
++ return ret;
++}
++
++static int tosaled_remove(struct platform_device *pdev)
++{
++ led_classdev_unregister(&tosa_amber_led);
++ led_classdev_unregister(&tosa_green_led);
++
++ return 0;
++}
++
++static struct platform_driver tosaled_driver = {
++ .probe = tosaled_probe,
++ .remove = tosaled_remove,
++#ifdef CONFIG_PM
++ .suspend = tosaled_suspend,
++ .resume = tosaled_resume,
++#endif
++ .driver = {
++ .name = "tosa-led",
++ },
++};
++
++static int __devinit tosaled_init(void)
++{
++ return platform_driver_register(&tosaled_driver);
++}
++
++static void tosaled_exit(void)
++{
++ platform_driver_unregister(&tosaled_driver);
++}
++
++module_init(tosaled_init);
++module_exit(tosaled_exit);
++
++MODULE_AUTHOR("Dirk Opfer <Dirk@Opfer-Online.de>");
++MODULE_DESCRIPTION("Tosa LED driver");
++MODULE_LICENSE("GPL");
+Index: linux-2.6.15/arch/arm/mach-pxa/tosa.c
+===================================================================
+--- linux-2.6.15.orig/arch/arm/mach-pxa/tosa.c 2006-01-03 03:21:10.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-pxa/tosa.c 2006-01-30 00:29:25.000000000 +0000
+@@ -252,10 +252,19 @@
+ .id = -1,
+ };
+
++/*
++ * Tosa LEDs
++ */
++static struct platform_device tosaled_device = {
++ .name = "tosa-led",
++ .id = -1,
++};
++
+ static struct platform_device *devices[] __initdata = {
+ &tosascoop_device,
+ &tosascoop_jc_device,
+ &tosakbd_device,
++ &tosaled_device,
+ };
+
+ static void __init tosa_init(void)
+Add an LED trigger for IDE disk activity to the IDE subsystem.
+
+Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
+
+Index: linux-2.6.15/drivers/ide/ide-disk.c
+===================================================================
+--- linux-2.6.15.orig/drivers/ide/ide-disk.c 2006-02-04 13:35:37.000000000 +0000
++++ linux-2.6.15/drivers/ide/ide-disk.c 2006-02-04 15:17:18.000000000 +0000
+@@ -60,6 +60,7 @@
+ #include <linux/genhd.h>
+ #include <linux/slab.h>
+ #include <linux/delay.h>
++#include <linux/leds.h>
+
+ #define _IDE_DISK
+
+@@ -80,6 +81,8 @@
+
+ static DECLARE_MUTEX(idedisk_ref_sem);
+
++INIT_LED_TRIGGER(ide_led_trigger);
++
+ #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
+
+ #define ide_disk_g(disk) \
+@@ -311,10 +314,12 @@
+
+ if (!blk_fs_request(rq)) {
+ blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
+- ide_end_request(drive, 0, 0);
++ ide_end_rw_disk(drive, 0, 0);
+ return ide_stopped;
+ }
+
++ led_trigger_event(ide_led_trigger, LED_FULL);
++
+ pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
+ drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
+ block, rq->nr_sectors, (unsigned long)rq->buffer);
+@@ -325,6 +330,12 @@
+ return __ide_do_rw_disk(drive, rq, block);
+ }
+
++static int ide_end_rw_disk(ide_drive_t *drive, int uptodate, int nr_sectors)
++{
++ led_trigger_event(ide_led_trigger, LED_OFF);
++ ide_end_request(drive, uptodate, nr_sectors);
++}
++
+ /*
+ * Queries for true maximum capacity of the drive.
+ * Returns maximum LBA address (> 0) of the drive, 0 if failed.
+@@ -1097,7 +1108,7 @@
+ .media = ide_disk,
+ .supports_dsc_overlap = 0,
+ .do_request = ide_do_rw_disk,
+- .end_request = ide_end_request,
++ .end_request = ide_end_rw_disk,
+ .error = __ide_error,
+ .abort = __ide_abort,
+ .proc = idedisk_proc,
+@@ -1259,11 +1270,13 @@
+
+ static void __exit idedisk_exit (void)
+ {
++ led_trigger_unregister_simple(ide_led_trigger);
+ driver_unregister(&idedisk_driver.gen_driver);
+ }
+
+ static int __init idedisk_init(void)
+ {
++ led_trigger_register_simple("ide-disk", &ide_led_trigger);
+ return driver_register(&idedisk_driver.gen_driver);
+ }
+
+Index: linux-2.6.15/drivers/mtd/nand/nand_base.c
+===================================================================
+--- linux-2.6.15.orig/drivers/mtd/nand/nand_base.c 2006-01-29 14:37:20.000000000 +0000
++++ linux-2.6.15/drivers/mtd/nand/nand_base.c 2006-01-29 15:25:11.000000000 +0000
+@@ -80,6 +80,7 @@
+ #include <linux/mtd/compatmac.h>
+ #include <linux/interrupt.h>
+ #include <linux/bitops.h>
++#include <linux/leds.h>
+ #include <asm/io.h>
+
+ #ifdef CONFIG_MTD_PARTITIONS
+@@ -515,6 +516,8 @@
+ return nand_isbad_bbt (mtd, ofs, allowbbt);
+ }
+
++INIT_LED_TRIGGER(nand_led_trigger);
++
+ /*
+ * Wait for the ready pin, after a command
+ * The timeout is catched later.
+@@ -524,12 +527,14 @@
+ struct nand_chip *this = mtd->priv;
+ unsigned long timeo = jiffies + 2;
+
++ led_trigger_event(nand_led_trigger, LED_FULL);
+ /* wait until command is processed or timeout occures */
+ do {
+ if (this->dev_ready(mtd))
+- return;
++ break;
+ touch_softlockup_watchdog();
+ } while (time_before(jiffies, timeo));
++ led_trigger_event(nand_led_trigger, LED_OFF);
+ }
+
+ /**
+@@ -817,6 +822,8 @@
+ else
+ timeo += (HZ * 20) / 1000;
+
++ led_trigger_event(nand_led_trigger, LED_FULL);
++
+ /* Apply this short delay always to ensure that we do wait tWB in
+ * any case on any machine. */
+ ndelay (100);
+@@ -840,6 +847,8 @@
+ }
+ cond_resched();
+ }
++ led_trigger_event(nand_led_trigger, LED_OFF);
++
+ status = (int) this->read_byte(mtd);
+ return status;
+ }
+@@ -2724,6 +2733,21 @@
+ EXPORT_SYMBOL_GPL (nand_scan);
+ EXPORT_SYMBOL_GPL (nand_release);
+
++
++static int __init nand_base_init(void)
++{
++ led_trigger_register_simple("nand-disk", &nand_led_trigger);
++ return 0;
++}
++
++static void nand_base_exit(void)
++{
++ led_trigger_unregister_simple(nand_led_trigger);
++}
++
++module_init(nand_base_init);
++module_exit(nand_base_exit);
++
+ MODULE_LICENSE ("GPL");
+ MODULE_AUTHOR ("Steven J. Hill <sjhill@realitydiluted.com>, Thomas Gleixner <tglx@linutronix.de>");
+ MODULE_DESCRIPTION ("Generic NAND flash driver code");
diff --git a/packages/linux/ixp4xx-kernel/2.6.16/patch-2.6.16-rc4-ide1 b/packages/linux/ixp4xx-kernel/2.6.16/patch-2.6.16-rc4-ide1
new file mode 100644
index 0000000000..7e2561c0f9
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.16/patch-2.6.16-rc4-ide1
@@ -0,0 +1,18260 @@
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/arch/i386/pci/fixup.c linux-2.6.16-rc4/arch/i386/pci/fixup.c
+--- linux.vanilla-2.6.16-rc4/arch/i386/pci/fixup.c 2006-02-20 11:22:15.000000000 +0000
++++ linux-2.6.16-rc4/arch/i386/pci/fixup.c 2006-02-01 14:49:17.000000000 +0000
+@@ -74,52 +74,6 @@
+ }
+ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C810, pci_fixup_ncr53c810);
+
+-static void __devinit pci_fixup_ide_bases(struct pci_dev *d)
+-{
+- int i;
+-
+- /*
+- * PCI IDE controllers use non-standard I/O port decoding, respect it.
+- */
+- if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE)
+- return;
+- DBG("PCI: IDE base address fixup for %s\n", pci_name(d));
+- for(i=0; i<4; i++) {
+- struct resource *r = &d->resource[i];
+- if ((r->start & ~0x80) == 0x374) {
+- r->start |= 2;
+- r->end = r->start;
+- }
+- }
+-}
+-DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_ide_bases);
+-
+-static void __devinit pci_fixup_ide_trash(struct pci_dev *d)
+-{
+- int i;
+-
+- /*
+- * Runs the fixup only for the first IDE controller
+- * (Shai Fultheim - shai@ftcon.com)
+- */
+- static int called = 0;
+- if (called)
+- return;
+- called = 1;
+-
+- /*
+- * There exist PCI IDE controllers which have utter garbage
+- * in first four base registers. Ignore that.
+- */
+- DBG("PCI: IDE base address trash cleared for %s\n", pci_name(d));
+- for(i=0; i<4; i++)
+- d->resource[i].start = d->resource[i].end = d->resource[i].flags = 0;
+-}
+-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_5513, pci_fixup_ide_trash);
+-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_10, pci_fixup_ide_trash);
+-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_11, pci_fixup_ide_trash);
+-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_9, pci_fixup_ide_trash);
+-
+ static void __devinit pci_fixup_latency(struct pci_dev *d)
+ {
+ /*
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/pci/probe.c linux-2.6.16-rc4/drivers/pci/probe.c
+--- linux.vanilla-2.6.16-rc4/drivers/pci/probe.c 2006-02-20 11:22:17.000000000 +0000
++++ linux-2.6.16-rc4/drivers/pci/probe.c 2006-02-01 15:56:28.000000000 +0000
+@@ -627,6 +627,7 @@
+ static int pci_setup_device(struct pci_dev * dev)
+ {
+ u32 class;
++ u16 cmd;
+
+ sprintf(pci_name(dev), "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
+ dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
+@@ -654,6 +655,31 @@
+ pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
+ pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
+ pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
++
++ /*
++ * Do the ugly legacy mode stuff here rather than broken chip
++ * quirk code. Legacy mode ATA controllers have fixed
++ * addresses. These are not always echoed in BAR0-3, and
++ * BAR0-3 in a few cases contain junk!
++ */
++ if (class == PCI_CLASS_STORAGE_IDE) {
++ u8 progif;
++ pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
++ if ((progif & 5) != 5) {
++ dev->resource[0].start = 0x1F0;
++ dev->resource[0].end = 0x1F7;
++ dev->resource[0].flags = IORESOURCE_IO;
++ dev->resource[1].start = 0x3F6;
++ dev->resource[1].end = 0x3F6;
++ dev->resource[1].flags = IORESOURCE_IO;
++ dev->resource[2].start = 0x170;
++ dev->resource[2].end = 0x177;
++ dev->resource[2].flags = IORESOURCE_IO;
++ dev->resource[3].start = 0x376;
++ dev->resource[3].end = 0x376;
++ dev->resource[3].flags = IORESOURCE_IO;
++ }
++ }
+ break;
+
+ case PCI_HEADER_TYPE_BRIDGE: /* bridge header */
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/ata_generic.c linux-2.6.16-rc4/drivers/scsi/ata_generic.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/ata_generic.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/ata_generic.c 2006-02-16 15:35:41.000000000 +0000
+@@ -0,0 +1,241 @@
++/*
++ * ata_generic.c - Generic PATA/SATA controller driver.
++ * Copyright 2005 Red Hat Inc <alan@redhat.com>, all rights reserved.
++ *
++ * Elements from ide/pci/generic.c
++ * Copyright (C) 2001-2002 Andre Hedrick <andre@linux-ide.org>
++ * Portions (C) Copyright 2002 Red Hat Inc <alan@redhat.com>
++ *
++ * May be copied or modified under the terms of the GNU General Public License
++ *
++ * Driver for PCI IDE interfaces implementing the standard bus mastering
++ * interface functionality. This assumes the BIOS did the drive set up and
++ * tuning for us. By default we do not grab all IDE class devices as they
++ * may have other drivers or need fixups to avoid problems. Instead we keep
++ * a default list of stuff without documentation/driver that appears to
++ * work.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include "scsi.h"
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "generic"
++#define DRV_VERSION "0.1"
++
++/*
++ * A generic parallel ATA driver using libata
++ */
++
++static void genpata_phy_reset(struct ata_port *ap)
++{
++ /* We know the BIOS already did the mode work. Don't tempt any
++ one else to "fix" things */
++ ap->cbl = ATA_CBL_PATA80;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * genpata_set_mode - mode setting
++ * @ap: interface to set up
++ *
++ * Use a non standard set_mode function. We don't want to be tuned.
++ * The BIOS configured everything. Our job is not to fiddle. We
++ * read the dma enabled bits from the PCI configuration of the device
++ * and respect them.
++ */
++
++static void genpata_set_mode(struct ata_port *ap)
++{
++ int dma_enabled;
++ int i;
++
++ /* Bits 5 and 6 indicate if DMA is active on master/slave */
++ dma_enabled = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
++
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *dev = &ap->device[i];
++ if (ata_dev_present(dev)) {
++ /* We don't really care */
++ dev->pio_mode = XFER_PIO_0;
++ dev->dma_mode = XFER_MW_DMA_0;
++ /* We do need the right mode information for DMA or PIO
++ and this comes from the current configuration flags */
++ /* FIXME: at some point in the future this should become
++ a library helper which reads the disk modes from the
++ disk as well */
++ if (dma_enabled & (1 << (5 + i))) {
++ dev->xfer_mode = XFER_MW_DMA_0;
++ dev->xfer_shift = ATA_SHIFT_MWDMA;
++ dev->flags &= ~ATA_DFLAG_PIO;
++ } else {
++ dev->xfer_mode = XFER_PIO_0;
++ dev->xfer_shift = ATA_SHIFT_PIO;
++ dev->flags |= ATA_DFLAG_PIO;
++ }
++ }
++ }
++}
++
++static struct scsi_host_template genpata_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations genpata_port_ops = {
++ .set_mode = genpata_set_mode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = genpata_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .data_xfer = ata_pio_data_xfer,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int ide_generic_all; /* Set to claim all devices */
++
++static int __init ide_generic_all_on(char *unused)
++{
++ ide_generic_all = 1;
++ printk(KERN_INFO "ATA generic will claim all unknown PCI IDE class storage controllers.\n");
++ return 1;
++}
++
++__setup("all-generic-ide", ide_generic_all_on);
++
++/**
++ * pata_generic_init - attach generic IDE
++ * @dev: PCI device found
++ * @id: match entry
++ *
++ * Called each time a matching IDE interface is found. We check if the
++ * interface is one we wish to claim and if so we perform any chip
++ * specific hacks then let the ATA layer do the heavy lifting.
++ */
++
++static int pata_generic_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ u16 command;
++ static struct ata_port_info info = {
++ .sht = &genpata_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_IRQ_MASK,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &genpata_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ /* Don't use the generic entry unless instructed to do so */
++ if (id->driver_data == 1 && ide_generic_all == 0)
++ return -ENODEV;
++
++ /* Devices that need care */
++ if (dev->vendor == PCI_VENDOR_ID_UMC &&
++ dev->device == PCI_DEVICE_ID_UMC_UM8886A &&
++ (!(PCI_FUNC(dev->devfn) & 1)))
++ return -ENODEV;
++
++ if (dev->vendor == PCI_VENDOR_ID_OPTI &&
++ dev->device == PCI_DEVICE_ID_OPTI_82C558 &&
++ (!(PCI_FUNC(dev->devfn) & 1)))
++ return -ENODEV;
++
++ /* Don't re-enable devices in generic mode or we will break some
++ motherboards with disabled and unused IDE controllers */
++ pci_read_config_word(dev, PCI_COMMAND, &command);
++ if (!(command & PCI_COMMAND_IO))
++ return -ENODEV;
++
++ if (dev->vendor == PCI_VENDOR_ID_AL)
++ ata_pci_clear_simplex(dev);
++
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id pata_generic[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_SAMURAI_IDE), },
++ { PCI_DEVICE(PCI_VENDOR_ID_HOLTEK, PCI_DEVICE_ID_HOLTEK_6565), },
++ { PCI_DEVICE(PCI_VENDOR_ID_UMC, PCI_DEVICE_ID_UMC_UM8673F), },
++ { PCI_DEVICE(PCI_VENDOR_ID_UMC, PCI_DEVICE_ID_UMC_UM8886A), },
++ { PCI_DEVICE(PCI_VENDOR_ID_UMC, PCI_DEVICE_ID_UMC_UM8886BF), },
++ { PCI_DEVICE(PCI_VENDOR_ID_HINT, PCI_DEVICE_ID_HINT_VXPROII_IDE), },
++ { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C561), },
++ { PCI_DEVICE(PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C558), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA,PCI_DEVICE_ID_TOSHIBA_PICCOLO), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA,PCI_DEVICE_ID_TOSHIBA_PICCOLO_1), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA,PCI_DEVICE_ID_TOSHIBA_PICCOLO_2), },
++ /* Must come last. If you add entries adjust this table appropriately */
++ { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_IDE << 8, 0xFFFFFF00UL, 1},
++ { 0, },
++};
++
++static struct pci_driver pata_generic_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = pata_generic,
++ .probe = pata_generic_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init pata_generic_init(void)
++{
++ return pci_module_init(&pata_generic_pci_driver);
++}
++
++
++static void __exit pata_generic_exit(void)
++{
++ pci_unregister_driver(&pata_generic_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for generic ATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, pata_generic);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(pata_generic_init);
++module_exit(pata_generic_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/ata_piix.c linux-2.6.16-rc4/drivers/scsi/ata_piix.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/ata_piix.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/ata_piix.c 2006-02-16 15:35:51.000000000 +0000
+@@ -91,9 +91,10 @@
+ #include <linux/device.h>
+ #include <scsi/scsi_host.h>
+ #include <linux/libata.h>
++#include <linux/ata.h>
+
+ #define DRV_NAME "ata_piix"
+-#define DRV_VERSION "1.05"
++#define DRV_VERSION "1.05-ac1"
+
+ enum {
+ PIIX_IOCFG = 0x54, /* IDE I/O configuration register */
+@@ -122,6 +123,17 @@
+ piix4_pata = 2,
+ ich6_sata = 3,
+ ich6_sata_ahci = 4,
++ ich0_pata = 5,
++ ich2_pata = 6,
++ ich3_pata = 7,
++ ich4_pata = 8,
++ cich_pata = 9,
++ piix3_pata = 10,
++ esb_pata = 11,
++ ich_pata = 12,
++ ich6_pata = 13,
++ ich7_pata = 14,
++ esb2_pata = 15,
+
+ PIIX_AHCI_DEVICE = 6,
+ };
+@@ -130,20 +142,69 @@
+ const struct pci_device_id *ent);
+
+ static void piix_pata_phy_reset(struct ata_port *ap);
++static void ich_pata_phy_reset(struct ata_port *ap);
+ static void piix_sata_phy_reset(struct ata_port *ap);
+ static void piix_set_piomode (struct ata_port *ap, struct ata_device *adev);
+ static void piix_set_dmamode (struct ata_port *ap, struct ata_device *adev);
++static void ich_set_dmamode (struct ata_port *ap, struct ata_device *adev);
+
+ static unsigned int in_module_init = 1;
+
+ static const struct pci_device_id piix_pci_tbl[] = {
+ #ifdef ATA_ENABLE_PATA
++#if 0
++ /* Neptune and earlier are simple PIO */
++ /* 430HX and friends. MWDMA */
++ { 0x8086, 0x122e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix3_pata },
++ { 0x8086, 0x1230, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix3_pata },
++ /* Intel PIIX3 */
++ { 0x8086, 0x7010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix3_pata },
++#endif
++ /* Intel PIIX4 for the 430TX/440BX/MX chipset: UDMA 33 */
++ /* Also PIIX4E (fn3 rev 2) and PIIX4M (fn3 rev 3) */
+ { 0x8086, 0x7111, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix4_pata },
+ { 0x8086, 0x24db, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_pata },
+ { 0x8086, 0x25a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_pata },
++ /* Intel PIIX4 */
++ { 0x8086, 0x7199, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix4_pata },
++ /* Intel PIIX4 */
++ { 0x8086, 0x7601, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix4_pata },
++ /* Intel PIIX */
++ { 0x8086, 0x84CA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, piix4_pata },
++ /* Intel ICH (i810, i815, i840) UDMA 66*/
++ { 0x8086, 0x2411, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata },
++ /* Intel ICH0 : UDMA 33*/
++ { 0x8086, 0x2421, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich0_pata },
++ /* Intel ICH2M */
++ { 0x8086, 0x244A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich2_pata },
++ /* Intel ICH2 (i810E2, i845, 850, 860) UDMA 100 */
++ { 0x8086, 0x244B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich2_pata },
++ /* Intel ICH3M */
++ { 0x8086, 0x248A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich3_pata },
++ /* Intel ICH3 (E7500/1) UDMA 100 */
++ { 0x8086, 0x248B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich3_pata },
++#if 0
++ { 0x8086, 0x24C1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, dunno_pata },
++#endif
++ /* Intel ICH4 (i845GV, i845E, i852, i855) UDMA 100 */
++ { 0x8086, 0x24CA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich4_pata },
++ { 0x8086, 0x24CB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich4_pata },
++ /* Intel ICH5 */
++ { 0x8086, 0x24DB, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_pata },
++ /* C-ICH (i810E2) */
++ { 0x8086, 0x245B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, cich_pata },
++ /* ESB (855GME/875P + 6300ESB) UDMA 100 */
++ { 0x8086, 0x25A2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, esb_pata },
++ /* ICH6 (and 6) (i915) UDMA 100 */
++ { 0x8086, 0x266F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich6_pata },
++ /* ICH7/7-R (i945, i975) UDMA 100*/
++ { 0x8086, 0x27DF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich7_pata },
++ { 0x8086, 0x269E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, esb2_pata },
+ #endif
+-
+- /* NOTE: The following PCI ids must be kept in sync with the
++ /*
++ * SATA ports
++ *
++ * NOTE: The following PCI ids must be kept in sync with the
+ * list in drivers/pci/quirks.c.
+ */
+
+@@ -213,6 +274,40 @@
+ .bmdma_status = ata_bmdma_status,
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static const struct ata_port_operations ich_pata_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = piix_set_piomode,
++ .set_dmamode = ich_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = ich_pata_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++
++ .data_xfer = ata_pio_data_xfer,
+
+ .eng_timeout = ata_eng_timeout,
+
+@@ -242,6 +337,8 @@
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
+
++ .data_xfer = ata_pio_data_xfer,
++
+ .eng_timeout = ata_eng_timeout,
+
+ .irq_handler = ata_interrupt,
+@@ -259,13 +356,9 @@
+ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST |
+ PIIX_FLAG_CHECKINTR,
+ .pio_mask = 0x1f, /* pio0-4 */
+-#if 0
+ .mwdma_mask = 0x06, /* mwdma1-2 */
+-#else
+- .mwdma_mask = 0x00, /* mwdma broken */
+-#endif
+ .udma_mask = 0x3f, /* udma0-5 */
+- .port_ops = &piix_pata_ops,
++ .port_ops = &ich_pata_ops,
+ },
+
+ /* ich5_sata */
+@@ -284,11 +377,7 @@
+ .sht = &piix_sht,
+ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
+ .pio_mask = 0x1f, /* pio0-4 */
+-#if 0
+ .mwdma_mask = 0x06, /* mwdma1-2 */
+-#else
+- .mwdma_mask = 0x00, /* mwdma broken */
+-#endif
+ .udma_mask = ATA_UDMA_MASK_40C,
+ .port_ops = &piix_pata_ops,
+ },
+@@ -316,6 +405,116 @@
+ .udma_mask = 0x7f, /* udma0-6 */
+ .port_ops = &piix_sata_ops,
+ },
++
++ /* ich0_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* MWDMA0 is broken on chip */
++ .udma_mask = 0x07, /* UDMA33 only */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* ich2_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* MWDMA0 is broken on chip */
++ .udma_mask = 0x1f, /* UDMA100 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* ich3_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* MWDMA0 is broken on chip */
++ .udma_mask = 0x1f, /* UDMA100 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* ich4_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x1f, /* UDMA100 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* cich_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x1f, /* UDMA100 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* piix3_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma1-2 */
++ .udma_mask = ATA_UDMA_MASK_40C,
++ .port_ops = &piix_pata_ops,
++ },
++
++ /* esb_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x1f, /* UDMA100 */
++ .port_ops = &piix_pata_ops,
++ },
++
++ /* ich_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x07, /* UDMA66 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* ich6_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x3f, /* UDMA133 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* ich7_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x3f, /* UDMA133 */
++ .port_ops = &ich_pata_ops,
++ },
++
++ /* esb2_pata */
++ {
++ .sht = &piix_sht,
++ .host_flags = ATA_FLAG_SRST | ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f, /* pio 0-4 */
++ .mwdma_mask = 0x06, /* Check: maybe 0x07 */
++ .udma_mask = 0x1f, /* UDMA100 -- CHECKME --*/
++ .port_ops = &ich_pata_ops,
++ },
+ };
+
+ static struct pci_bits piix_enable_bits[] = {
+@@ -339,7 +538,7 @@
+ * LOCKING:
+ * None (inherited from caller).
+ */
+-static void piix_pata_cbl_detect(struct ata_port *ap)
++static void ich_pata_cbl_detect(struct ata_port *ap)
+ {
+ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
+ u8 tmp, mask;
+@@ -366,8 +565,9 @@
+ * piix_pata_phy_reset - Probe specified port on PATA host controller
+ * @ap: Port to probe
+ *
+- * Probe PATA phy.
+- *
++ * Probe PATA phy. Unlike the ICH we have no IOCFG register and
++ * don't do UDMA66+ anyway.
++
+ * LOCKING:
+ * None (inherited from caller).
+ */
+@@ -381,11 +581,34 @@
+ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
+ return;
+ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
+
+- piix_pata_cbl_detect(ap);
+
+- ata_port_probe(ap);
++/**
++ * ich_pata_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * Probe PATA phy.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void ich_pata_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
+
++ if (!pci_test_config_bits(pdev, &piix_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++
++ ich_pata_cbl_detect(ap);
++ ata_port_probe(ap);
+ ata_bus_reset(ap);
+ }
+
+@@ -481,6 +704,13 @@
+ unsigned int slave_port = 0x44;
+ u16 master_data;
+ u8 slave_data;
++ u8 udma_enable;
++ int control = 0;
++
++ /*
++ * See Intel Document 298600-004 for the timing programing rules
++ * for ICH controllers.
++ */
+
+ static const /* ISP RTC */
+ u8 timings[][2] = { { 0, 0 },
+@@ -489,20 +719,30 @@
+ { 2, 1 },
+ { 2, 3 }, };
+
++ if (pio > 2)
++ control |= 1; /* TIME1 enable */
++ if (ata_pio_need_iordy(adev))
++ control |= 2; /* IE enable */
++
++ /* Intel specifies that the PPE functionality is for disk only */
++ if (adev->class == ATA_DEV_ATA)
++ control |= 4; /* PPE enable */
++
+ pci_read_config_word(dev, master_port, &master_data);
+ if (is_slave) {
++ /* Enable SITRE (seperate slave timing register) */
+ master_data |= 0x4000;
+- /* enable PPE, IE and TIME */
+- master_data |= 0x0070;
++ /* enable PPE1, IE1 and TIME1 as needed */
++ master_data |= (control << 4);
+ pci_read_config_byte(dev, slave_port, &slave_data);
+ slave_data &= (ap->hard_port_no ? 0x0f : 0xf0);
+- slave_data |=
+- (timings[pio][0] << 2) |
+- (timings[pio][1] << (ap->hard_port_no ? 4 : 0));
++ /* Load the timing nibble for this slave */
++ slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << (ap->hard_port_no ? 4 : 0);
+ } else {
++ /* Master keeps the bits in a different format */
+ master_data &= 0xccf8;
+- /* enable PPE, IE and TIME */
+- master_data |= 0x0007;
++ /* Enable PPE, IE and TIME as appropriate */
++ master_data |= control;
+ master_data |=
+ (timings[pio][0] << 12) |
+ (timings[pio][1] << 8);
+@@ -510,84 +750,165 @@
+ pci_write_config_word(dev, master_port, master_data);
+ if (is_slave)
+ pci_write_config_byte(dev, slave_port, slave_data);
++
++ /* Ensure the UDMA bit is off - it will be turned back on if
++ UDMA is selected */
++
++ if (ap->udma_mask) {
++ pci_read_config_byte(dev, 0x48, &udma_enable);
++ udma_enable &= ~(1 << (2 * ap->hard_port_no + adev->devno));
++ pci_write_config_byte(dev, 0x48, udma_enable);
++ }
+ }
+
+ /**
+- * piix_set_dmamode - Initialize host controller PATA PIO timings
++ * do_piix_set_dmamode - Initialize host controller PATA PIO timings
+ * @ap: Port whose timings we are configuring
+- * @adev: um
+- * @udma: udma mode, 0 - 6
++ * @adev: device to configure
++ * @isich: True if the device is an ICH and has IOCFG registers
+ *
+- * Set UDMA mode for device, in host controller PCI config space.
++ * Set MW/UDMA mode for device, in host controller PCI config space.
++ * Note: We know the caller has already set the PIO mode. In doing
++ * so it has correctly set PPE, SITRE, IORDY and TIME1. We rely on that.
+ *
+ * LOCKING:
+ * None (inherited from caller).
+ */
+
+-static void piix_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++static void do_pata_set_dmamode (struct ata_port *ap, struct ata_device *adev, int isich)
+ {
+- unsigned int udma = adev->dma_mode; /* FIXME: MWDMA too */
+ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
+- u8 maslave = ap->hard_port_no ? 0x42 : 0x40;
+- u8 speed = udma;
+- unsigned int drive_dn = (ap->hard_port_no ? 2 : 0) + adev->devno;
+- int a_speed = 3 << (drive_dn * 4);
+- int u_flag = 1 << drive_dn;
+- int v_flag = 0x01 << drive_dn;
+- int w_flag = 0x10 << drive_dn;
+- int u_speed = 0;
+- int sitre;
+- u16 reg4042, reg4a;
+- u8 reg48, reg54, reg55;
+-
+- pci_read_config_word(dev, maslave, &reg4042);
+- DPRINTK("reg4042 = 0x%04x\n", reg4042);
+- sitre = (reg4042 & 0x4000) ? 1 : 0;
+- pci_read_config_byte(dev, 0x48, &reg48);
+- pci_read_config_word(dev, 0x4a, &reg4a);
+- pci_read_config_byte(dev, 0x54, &reg54);
+- pci_read_config_byte(dev, 0x55, &reg55);
+-
+- switch(speed) {
+- case XFER_UDMA_4:
+- case XFER_UDMA_2: u_speed = 2 << (drive_dn * 4); break;
+- case XFER_UDMA_6:
+- case XFER_UDMA_5:
+- case XFER_UDMA_3:
+- case XFER_UDMA_1: u_speed = 1 << (drive_dn * 4); break;
+- case XFER_UDMA_0: u_speed = 0 << (drive_dn * 4); break;
+- case XFER_MW_DMA_2:
+- case XFER_MW_DMA_1: break;
+- default:
+- BUG();
+- return;
+- }
++ u8 master_port = ap->hard_port_no ? 0x42 : 0x40;
++ u16 master_data;
++ u8 speed = adev->dma_mode;
++ int devid = adev->devno + 2 * ap->hard_port_no;
++ u8 udma_enable;
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 0 },
++ { 2, 1 },
++ { 2, 3 }, };
+
++ pci_read_config_word(dev, master_port, &master_data);
++ pci_read_config_byte(dev, 0x48, &udma_enable);
++
+ if (speed >= XFER_UDMA_0) {
+- if (!(reg48 & u_flag))
+- pci_write_config_byte(dev, 0x48, reg48 | u_flag);
+- if (speed == XFER_UDMA_5) {
+- pci_write_config_byte(dev, 0x55, (u8) reg55|w_flag);
+- } else {
+- pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
++ unsigned int udma = adev->dma_mode - XFER_UDMA_0;
++ u16 udma_timing;
++ u16 ideconf;
++ int u_clock, u_speed;
++
++ /*
++ * UDMA is handled by a combination of clock switching and
++ * selection of dividers
++ *
++ * Handy rule: Odd modes are UDMATIMx 01, even are 02
++ * except UDMA0 which is 00
++ */
++ u_speed = min(2 - (udma & 1), udma);
++ if (udma == 5)
++ u_clock = 0x1000; /* 100Mhz */
++ else if (udma > 2)
++ u_clock = 1; /* 66Mhz */
++ else
++ u_clock = 0; /* 33Mhz */
++
++ udma_enable |= (1 << devid);
++
++ /* Load the CT/RP selection */
++ pci_read_config_word(dev, 0x4A, &udma_timing);
++ udma_timing &= ~(3 << (4 * devid));
++ udma_timing |= u_speed << (4 * devid);
++ pci_write_config_word(dev, 0x4A, udma_timing);
++
++ if (isich) {
++ /* Select a 33/66/100Mhz clock */
++ pci_read_config_word(dev, 0x54, &ideconf);
++ ideconf &= ~(0x1001 << devid);
++ ideconf |= u_clock << devid;
++ /* For ICH or later we should set bit 10 for better
++ performance (WR_PingPong_En) */
++ pci_write_config_word(dev, 0x54, ideconf);
+ }
+- if ((reg4a & a_speed) != u_speed)
+- pci_write_config_word(dev, 0x4a, (reg4a & ~a_speed) | u_speed);
+- if (speed > XFER_UDMA_2) {
+- if (!(reg54 & v_flag))
+- pci_write_config_byte(dev, 0x54, reg54 | v_flag);
+- } else
+- pci_write_config_byte(dev, 0x54, reg54 & ~v_flag);
+ } else {
+- if (reg48 & u_flag)
+- pci_write_config_byte(dev, 0x48, reg48 & ~u_flag);
+- if (reg4a & a_speed)
+- pci_write_config_word(dev, 0x4a, reg4a & ~a_speed);
+- if (reg54 & v_flag)
+- pci_write_config_byte(dev, 0x54, reg54 & ~v_flag);
+- if (reg55 & w_flag)
+- pci_write_config_byte(dev, 0x55, (u8) reg55 & ~w_flag);
++ /*
++ * MWDMA is driven by the PIO timings. We must also enable
++ * IORDY unconditionally along with TIME1. PPE has already
++ * been set when the PIO timing was set.
++ */
++ unsigned int mwdma = adev->dma_mode - XFER_MW_DMA_0;
++ unsigned int control;
++ u8 slave_data;
++ const unsigned int needed_pio[3] = {
++ XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
++ };
++ int pio = needed_pio[mwdma] - XFER_PIO_0;
++
++ control = 3; /* IORDY|TIME1 */
++
++ /* If the drive MWDMA is faster than it can do PIO then
++ we must force PIO into PIO0 */
++
++ if (adev->pio_mode < needed_pio[mwdma])
++ /* Enable DMA timing only */
++ control |= 8; /* PIO cycles in PIO0 */
++
++ if (adev->devno) { /* Slave */
++ master_data &= 0xFF4F; /* Mask out IORDY|TIME1|DMAONLY */
++ master_data |= control << 4;
++ pci_read_config_byte(dev, 0x44, &slave_data);
++ slave_data &= (0x0F + 0xE1 * ap->hard_port_no);
++ /* Load the matching timing */
++ slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << (ap->hard_port_no ? 4 : 0);
++ pci_write_config_byte(dev, 0x44, slave_data);
++ } else { /* Master */
++ master_data &= 0xCCF4; /* Mask out IORDY|TIME1|DMAONLY
++ and master timing bits */
++ master_data |= control;
++ master_data |=
++ (timings[pio][0] << 12) |
++ (timings[pio][1] << 8);
++ }
++ udma_enable &= ~(1 << devid);
++ pci_write_config_word(dev, master_port, master_data);
+ }
++ /* Don't scribble on 0x48 if the controller does not support UDMA */
++ if (ap->udma_mask)
++ pci_write_config_byte(dev, 0x48, udma_enable);
++}
++
++/**
++ * piix_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: um
++ *
++ * Set MW/UDMA mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void piix_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ do_pata_set_dmamode(ap, adev, 0);
++}
++
++/**
++ * ich_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: um
++ *
++ * Set MW/UDMA mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void ich_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ do_pata_set_dmamode(ap, adev, 1);
+ }
+
+ #define AHCI_PCI_BAR 5
+@@ -646,15 +967,15 @@
+ pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
+ pci_read_config_word(pdev, 0x41, &cfg);
+ /* Only on the original revision: IDE DMA can hang */
+- if(rev == 0x00)
++ if (rev == 0x00)
+ no_piix_dma = 1;
+ /* On all revisions below 5 PXB bus lock must be disabled for IDE */
+- else if(cfg & (1<<14) && rev < 5)
++ else if (cfg & (1<<14) && rev < 5)
+ no_piix_dma = 2;
+ }
+- if(no_piix_dma)
++ if (no_piix_dma)
+ dev_printk(KERN_WARNING, &ata_dev->dev, "450NX errata present, disabling IDE DMA.\n");
+- if(no_piix_dma == 2)
++ if (no_piix_dma == 2)
+ dev_printk(KERN_WARNING, &ata_dev->dev, "A BIOS update may resolve this.\n");
+ return no_piix_dma;
+ }
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/Kconfig linux-2.6.16-rc4/drivers/scsi/Kconfig
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/Kconfig 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/Kconfig 2006-02-17 18:22:18.000000000 +0000
+@@ -599,6 +599,316 @@
+ depends on IDE=y && !BLK_DEV_IDE_SATA && (SCSI_SATA_AHCI || SCSI_ATA_PIIX)
+ default y
+
++config SCSI_PATA_ALI
++ tristate "ALi PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the ALi ATA interfaces
++ found on the many ALi chipsets.
++
++ If unsure, say N.
++
++config SCSI_PATA_AMD
++ tristate "AMD/NVidia PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the AMD and NVidia PATA
++ interfaces found on the chipsets for Athlon/Athlon64.
++
++ If unsure, say N.
++
++config SCSI_PATA_ARTOP
++ tristate "ARTOP 6210/6260 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for ARTOP PATA controllers.
++
++ If unsure, say N.
++
++config SCSI_PATA_ATIIXP
++ tristate "ATI PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the ATI ATA interfaces
++ found on the many ATI chipsets.
++
++ If unsure, say N.
++
++config SCSI_PATA_CMD64X
++ tristate "CMD64x PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the CMD64x series chips
++ except for the CMD640.
++
++ If unsure, say N.
++
++config SCSI_PATA_CS5520
++ tristate "CS5510/5520 PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the Cyrix 5510/5520
++ companion chip used with the MediaGX/Geode processor family.
++
++ If unsure, say N.
++
++config SCSI_PATA_CS5530
++ tristate "CS5530 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the Cyrix/NatSemi/AMD CS5530
++ companion chip used with the MediaGX/Geode processor family.
++
++ If unsure, say N.
++
++config SCSI_PATA_CS5535
++ tristate "CS5535 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && X86 && !X86_64 && EXPERIMENTAL
++ help
++ This option enables support for the NatSemi/AMD CS5535
++ companion chip used with the Geode processor family.
++
++ If unsure, say N.
++
++config SCSI_PATA_CYPRESS
++ tristate "Cypress CY82C693 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the Cypress/Contaq CY82C693
++ chipset found in some Alpha systems
++
++ If unsure, say N.
++
++config SCSI_PATA_EFAR
++ tristate "EFAR SLC90E66 support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the EFAR SLC90E66
++ IDE controller found on some older machines.
++
++ If unsure, say N.
++
++config SCSI_ATA_GENERIC
++ tristate "Generic PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for generic BIOS configured
++ PATA controllers via the new ATA layer
++
++ If unsure, say N.
++
++config SCSI_PATA_HPT37X
++ tristate "HPT 370/370A/371/372/374/302 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the majority of the later HPT
++ PATA controllers via the new ATA layer.
++
++ If unsure, say N.
++
++config SCSI_PATA_HPT3X2N
++ tristate "HPT 372N/302N PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the N variant HPT PATA
++ controllers via the new ATA layer
++
++ If unsure, say N.
++
++config SCSI_PATA_HPT3X3
++ tristate "HPT 343/363 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the HPT 343/363
++ PATA controllers via the new ATA layer
++
++ If unsure, say N.
++
++config SCSI_PATA_ISAPNP
++ tristate "ISA Plug and Play PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && EXPERIMENTAL
++ help
++ This option enables support for ISA plug & play ATA
++ controllers such as those found on old soundcards.
++
++ If unsure, say N.
++
++config SCSI_PATA_IT8172
++ tristate "IT8172 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the ITE 8172 PATA controller
++ via the new ATA layer.
++
++ If unsure, say N.
++
++config SCSI_PATA_IT821X
++ tristate "IT821x PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the ITE 8211 and 8212
++ PATA controllers via the new ATA layer, including RAID
++ mode.
++
++ If unsure, say N.
++
++config SCSI_PATA_LEGACY
++ tristate "Legacy ISA PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for ISA bus legacy PATA
++ interfaces on ide2-5 and allows them to be accessed via
++ the new ATA layer.
++
++ If unsure, say N.
++
++config SCSI_PATA_MPIIX
++ tristate "Intel PATA MPIIX support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for MPIIX PATA support.
++
++ If unsure, say N.
++
++config SCSI_PATA_NETCELL
++ tristate "NETCELL Revolution RAID support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the Netcell Revolution RAID
++ PATA controller.
++
++ If unsure, say N.
++
++config SCSI_PATA_NS87410
++ tristate "Nat Semi NS87410 PATA support (Experimental)"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the National Semiconductor
++ NS87410 PCI-IDE controller.
++
++ If unsure, say N.
++
++config SCSI_PATA_OLDPIIX
++ tristate "Intel PATA old PIIX support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for early PIIX PATA interfaces.
++
++ If unsure, say N.
++
++config SCSI_PATA_OPTI
++ tristate "OPTI621/6215 PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables full PIO support for the early Opti ATA
++ controllers found on some old motherboards.
++
++ If unsure, say N.
++
++config SCSI_PATA_PCMCIA
++ tristate "PCMCIA PATA support (Raving Lunatic)"
++ depends on SCSI_SATA
++ help
++ This option enables support for PCMCIA ATA interfaces, including
++ compact flash card adapters via the new ATA layer.
++
++ If unsure, say N.
++
++config SCSI_PATA_PDC_OLD
++ tristate "Older Promise PATA controller support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the Promise 20246, 20262, 20263,
++ 20265 and 20267 adapters.
++
++ If unsure, say N.
++
++config SCSI_PATA_QDI
++ tristate "QDI VLB PATA support"
++ depends on SCSI_SATA
++ help
++ Support for QDI 6500 and 6580 PATA controllers on VESA local bus.
++
++config SCSI_PATA_RADISYS
++ tristate "RADISYS 82600 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the RADISYS 82600
++ PATA controllers via the new ATA layer
++
++ If unsure, say N.
++
++config SCSI_PATA_RZ1000
++ tristate "PC Tech RZ1000 PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables basic support for the PC Tech RZ1000/1
++ PATA controllers via the new ATA layer
++
++ If unsure, say N.
++
++config SCSI_PATA_SC1200
++ tristate "SC1200 PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the NatSemi/AMD SC1200 SoC
++ companion chip used with the Geode processor family.
++
++ If unsure, say N.
++
++config SCSI_PATA_SERVERWORKS
++ tristate "SERVERWORKS OSB4/CSB5/CSB6 PATA support (Experimental)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for the Serverworks OSB4/CSB5 and
++ CSB6 IDE controllers, via the new ATA layer.
++
++ If unsure, say N.
++
++config SCSI_PATA_SIL680
++ tristate "CMD / Silicon Image 680 PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for CMD / Silicon Image 680 PATA.
++
++ If unsure, say N.
++
++config SCSI_PATA_SIS
++ tristate "SiS PATA support (Experimental)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ This option enables support for SiS PATA controllers
++
++ If unsure, say N.
++
++config SCSI_PATA_TRIFLEX
++ tristate "Compaq Triflex PATA support (Raving Lunatic)"
++ depends on SCSI_SATA && PCI && EXPERIMENTAL
++ help
++ Enable support for the Compaq 'Triflex' IDE controller as found
++ on many Compaq Pentium-Pro systems, via the new ATA layer.
++
++ If unsure, say N.
++
++config SCSI_PATA_VIA
++ tristate "VIA PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for the VIA PATA interfaces
++ found on the many VIA chipsets.
++
++ If unsure, say N.
++
++config SCSI_PATA_WINBOND
++ tristate "Winbond SL82C105 PATA support"
++ depends on SCSI_SATA && PCI
++ help
++ This option enables support for SL82C105 PATA devices found in the
++ Netwinder and some other systems
++
++ If unsure, say N.
++
++
+ config SCSI_BUSLOGIC
+ tristate "BusLogic SCSI support"
+ depends on (PCI || ISA || MCA) && SCSI && ISA_DMA_API
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/libata-core.c linux-2.6.16-rc4/drivers/scsi/libata-core.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/libata-core.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/libata-core.c 2006-02-20 11:28:03.000000000 +0000
+@@ -68,9 +68,10 @@
+ static void ata_dev_init_params(struct ata_port *ap, struct ata_device *dev);
+ static void ata_set_mode(struct ata_port *ap);
+ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
+-static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift);
++static unsigned int ata_get_mode_mask(const struct ata_port *ap, struct ata_device *adev, int shift);
+ static int fgb(u32 bitmap);
+ static int ata_choose_xfer_mode(const struct ata_port *ap,
++ struct ata_device *adev,
+ u8 *xfer_mode_out,
+ unsigned int *xfer_shift_out);
+ static void __ata_qc_complete(struct ata_queued_cmd *qc);
+@@ -1205,6 +1206,48 @@
+ return 0;
+ }
+
++static void ata_dev_check_hpa(struct ata_port *ap, struct ata_device *dev)
++{
++ struct ata_taskfile tf;
++ unsigned long long true_size;
++ unsigned int err_mask;
++
++ if (!ata_id_has_hpa(dev->id) || !ata_id_hpa_enabled(dev->id))
++ return;
++
++ /* Issue a query for HPA */
++ ata_dev_select(ap, dev->devno, 1, 1);
++ ata_tf_init(ap, &tf, dev->devno);
++
++ if (dev->flags & ATA_DFLAG_LBA48) {
++ tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
++ tf.device |= 0x40;
++ err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
++ if (err_mask)
++ return;
++ /* Ok HPA is live */
++ true_size = (tf.hob_lbah << 16) | (tf.hob_lbam << 8) | (tf.hob_lbal);
++ true_size <<= 24;
++ true_size |= (tf.lbah << 16) | (tf.lbam << 8) | tf.lbal;
++ } else {
++ tf.command = ATA_CMD_READ_NATIVE_MAX;
++ tf.device |= 0x40;
++ err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
++ if (err_mask)
++ return;
++ /* Ok HPA is live */
++ true_size = ((tf.device & 0x0F) << 24) |
++ (tf.lbah << 16) |
++ (tf.lbam << 8) |
++ tf.lbal;
++ }
++ dev->flags |= ATA_DFLAG_HPA;
++ /* Should save the HPA value and expose it for dmraid then
++ remove the clipping */
++ printk(KERN_INFO "HPA present: true size %lld sectors.\n",
++ true_size + 1);
++}
++
+ /**
+ * ata_dev_identify - obtain IDENTIFY x DEVICE page
+ * @ap: port on which device we wish to probe resides
+@@ -1328,7 +1371,7 @@
+
+ /* ATA-specific feature tests */
+ if (dev->class == ATA_DEV_ATA) {
+- if (!ata_id_is_ata(dev->id)) /* sanity check */
++ if (!ata_id_is_ata(dev->id) && !ata_id_is_cfa(dev->id)) /* sanity check */
+ goto err_out_nosup;
+
+ /* get major version */
+@@ -1400,6 +1443,13 @@
+ }
+
+ ap->host->max_cmd_len = 16;
++
++ /*
++ * See if we have the HPA misfeature on the drive
++ */
++#if 0 /* TESTING */
++ ata_dev_check_hpa(ap, dev);
++#endif
+ }
+
+ /* ATAPI-specific feature tests */
+@@ -1485,10 +1535,23 @@
+ ap->ops->phy_reset(ap);
+ if (ap->flags & ATA_FLAG_PORT_DISABLED)
+ goto err_out;
++
++ /* The reset means we are in PIO 0, but the controller may not
++ yet be correctly set up and may have old BIOS settings, or just
++ no settings at all. Set all the devices to PIO 0 */
++
++ for (i = 0; i < ATA_MAX_DEVICES; i++)
++ ap->device[i].pio_mode = XFER_PIO_0;
+
+ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *adev = & ap->device[i];
++
++ /* Set up the controller on this port for PIO 0. We must not
++ send the drive speed setting commands at this point */
++ ap->ops->set_piomode(ap, adev);
++
+ ata_dev_identify(ap, i);
+- if (ata_dev_present(&ap->device[i])) {
++ if (ata_dev_present(adev)) {
+ found = 1;
+ ata_dev_config(ap,i);
+ }
+@@ -1497,7 +1560,11 @@
+ if ((!found) || (ap->flags & ATA_FLAG_PORT_DISABLED))
+ goto err_out_disable;
+
+- ata_set_mode(ap);
++ if(ap->ops->set_mode)
++ ap->ops->set_mode(ap);
++ else
++ ata_set_mode(ap);
++
+ if (ap->flags & ATA_FLAG_PORT_DISABLED)
+ goto err_out_disable;
+
+@@ -1612,6 +1679,23 @@
+ }
+
+ /**
++ * ata_dev_pair - return other device on cable
++ * @ap: port
++ * @adev: device
++ *
++ * Obtain the other device on the same cable, or if none is
++ * present NULL is returned
++ */
++
++struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
++{
++ struct ata_device *pair = &ap->device[1 - adev->devno];
++ if (!ata_dev_present(pair))
++ return NULL;
++ return pair;
++}
++
++/**
+ * ata_port_disable - Disable port.
+ * @ap: Port to be disabled.
+ *
+@@ -1824,16 +1908,19 @@
+ ap->id, dev->devno, xfer_mode_str[idx]);
+ }
+
+-static int ata_host_set_pio(struct ata_port *ap)
++static int ata_host_set_pio(struct ata_port *ap, struct ata_device *adev)
+ {
+ unsigned int mask;
+- int x, i;
++ int x;
+ u8 base, xfer_mode;
+
+- mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
++ if (!ata_dev_present(adev))
++ return 0;
++
++ mask = ata_get_mode_mask(ap, adev, ATA_SHIFT_PIO);
+ x = fgb(mask);
+ if (x < 0) {
+- printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
++ printk(KERN_WARNING "ata%u: no PIO support for device %d.\n", ap->id, adev->devno);
+ return -1;
+ }
+
+@@ -1843,34 +1930,24 @@
+ DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
+ (int)base, (int)xfer_mode, mask, x);
+
+- for (i = 0; i < ATA_MAX_DEVICES; i++) {
+- struct ata_device *dev = &ap->device[i];
+- if (ata_dev_present(dev)) {
+- dev->pio_mode = xfer_mode;
+- dev->xfer_mode = xfer_mode;
+- dev->xfer_shift = ATA_SHIFT_PIO;
+- if (ap->ops->set_piomode)
+- ap->ops->set_piomode(ap, dev);
+- }
+- }
++ adev->pio_mode = xfer_mode;
++ adev->xfer_mode = xfer_mode;
++ adev->xfer_shift = ATA_SHIFT_PIO;
++ if (ap->ops->set_piomode)
++ ap->ops->set_piomode(ap, adev);
+
+ return 0;
+ }
+
+-static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
+- unsigned int xfer_shift)
++static void ata_host_set_dma(struct ata_port *ap, struct ata_device *adev,
++ u8 xfer_mode, unsigned int xfer_shift)
+ {
+- int i;
+-
+- for (i = 0; i < ATA_MAX_DEVICES; i++) {
+- struct ata_device *dev = &ap->device[i];
+- if (ata_dev_present(dev)) {
+- dev->dma_mode = xfer_mode;
+- dev->xfer_mode = xfer_mode;
+- dev->xfer_shift = xfer_shift;
+- if (ap->ops->set_dmamode)
+- ap->ops->set_dmamode(ap, dev);
+- }
++ if (ata_dev_present(adev)) {
++ adev->dma_mode = xfer_mode;
++ adev->xfer_mode = xfer_mode;
++ adev->xfer_shift = xfer_shift;
++ if (ap->ops->set_dmamode)
++ ap->ops->set_dmamode(ap, adev);
+ }
+ }
+
+@@ -1886,32 +1963,64 @@
+ */
+ static void ata_set_mode(struct ata_port *ap)
+ {
+- unsigned int xfer_shift;
+- u8 xfer_mode;
++ unsigned int xfer_shift[ATA_MAX_DEVICES];
++ u8 xfer_mode[ATA_MAX_DEVICES];
+ int rc;
++ int i;
++ int used_dma = 0; /* Track if DMA was used for this setup */
+
+- /* step 1: always set host PIO timings */
+- rc = ata_host_set_pio(ap);
+- if (rc)
+- goto err_out;
++ /* We need to set timings individually for each device */
+
+- /* step 2: choose the best data xfer mode */
+- xfer_mode = xfer_shift = 0;
+- rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
+- if (rc)
+- goto err_out;
++ /* Compute the timings first so that when we ask the device to do
++ speed configuration it can see all the intended device state in
++ full */
+
+- /* step 3: if that xfer mode isn't PIO, set host DMA timings */
+- if (xfer_shift != ATA_SHIFT_PIO)
+- ata_host_set_dma(ap, xfer_mode, xfer_shift);
+-
+- /* step 4: update devices' xfer mode */
+- ata_dev_set_mode(ap, &ap->device[0]);
+- ata_dev_set_mode(ap, &ap->device[1]);
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *adev = &ap->device[i];
++ /* Choose the best data xfer mode */
++ xfer_mode[i] = xfer_shift[i] = 0;
++ rc = ata_choose_xfer_mode(ap, adev, &xfer_mode[i], &xfer_shift[i]);
++ if (rc)
++ goto err_out;
++
++ }
++
++ /* Now set the mode tables we have computed */
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *adev = &ap->device[i];
++ /* step 1: always set host PIO timings */
++ rc = ata_host_set_pio(ap, adev);
++ if (rc)
++ goto err_out;
++
++ /* step 2: if that xfer mode isn't PIO, set host DMA timings */
++ if (xfer_shift[i] != ATA_SHIFT_PIO) {
++ ata_host_set_dma(ap, adev, xfer_mode[i], xfer_shift[i]);
++ used_dma = 1;
++ }
++
++ /* In some cases the DMA mode will cause the driver to
++ update the pio mode to match chip limits. */
++
++ /* step 3: update devices' xfer mode */
++ ata_dev_set_mode(ap, adev);
++ }
+
+ if (ap->flags & ATA_FLAG_PORT_DISABLED)
+ return;
+
++ /*
++ * Record simplex status. If we selected DMA then the other
++ * host channels are not permitted to do so.
++ */
++
++ if (used_dma && (ap->host_set->host_set_flags & ATA_HOST_SIMPLEX))
++ ap->host_set->simplex_claimed = 1;
++
++ /*
++ * Chip specific finalisation
++ */
++
+ if (ap->ops->post_set_mode)
+ ap->ops->post_set_mode(ap);
+
+@@ -2256,76 +2365,57 @@
+ return 0;
+ }
+
+-static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift)
++static unsigned int ata_get_mode_mask(const struct ata_port *ap, struct ata_device *adev, int shift)
+ {
+- const struct ata_device *master, *slave;
+ unsigned int mask;
++ struct ata_host_set *hs = ap->host_set;
+
+- master = &ap->device[0];
+- slave = &ap->device[1];
++ if (!ata_dev_present(adev))
++ return 0xFF; /* Drive isn't limiting anything */
++
++ if (shift == ATA_SHIFT_PIO) {
++ u16 tmp_mode = ata_pio_modes(adev);
++ mask = ap->pio_mask;
++ mask &= tmp_mode;
++ }
+
+- assert (ata_dev_present(master) || ata_dev_present(slave));
++ /*
++ * Enforce simplex rules if host is simplex
++ */
++
++ if (hs->host_set_flags & ATA_HOST_SIMPLEX) {
++ if (hs->simplex_claimed) {
++ if (shift != ATA_SHIFT_PIO)
++ return 0;
++ }
++ }
+
+ if (shift == ATA_SHIFT_UDMA) {
+ mask = ap->udma_mask;
+- if (ata_dev_present(master)) {
+- mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
+- if (ata_dma_blacklisted(master)) {
+- mask = 0;
+- ata_pr_blacklisted(ap, master);
+- }
+- }
+- if (ata_dev_present(slave)) {
+- mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
+- if (ata_dma_blacklisted(slave)) {
+- mask = 0;
+- ata_pr_blacklisted(ap, slave);
+- }
++ mask &= (adev->id[ATA_ID_UDMA_MODES] & 0xff);
++ if (ata_dma_blacklisted(adev)) {
++ mask = 0;
++ ata_pr_blacklisted(ap, adev);
+ }
+ }
+ else if (shift == ATA_SHIFT_MWDMA) {
+ mask = ap->mwdma_mask;
+- if (ata_dev_present(master)) {
+- mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
+- if (ata_dma_blacklisted(master)) {
+- mask = 0;
+- ata_pr_blacklisted(ap, master);
+- }
+- }
+- if (ata_dev_present(slave)) {
+- mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
+- if (ata_dma_blacklisted(slave)) {
+- mask = 0;
+- ata_pr_blacklisted(ap, slave);
+- }
++ mask &= (adev->id[ATA_ID_MWDMA_MODES] & 0x07);
++ if (ata_dma_blacklisted(adev)) {
++ mask = 0;
++ ata_pr_blacklisted(ap, adev);
+ }
+- }
+- else if (shift == ATA_SHIFT_PIO) {
+- mask = ap->pio_mask;
+- if (ata_dev_present(master)) {
+- /* spec doesn't return explicit support for
+- * PIO0-2, so we fake it
+- */
+- u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
+- tmp_mode <<= 3;
+- tmp_mode |= 0x7;
+- mask &= tmp_mode;
+- }
+- if (ata_dev_present(slave)) {
+- /* spec doesn't return explicit support for
+- * PIO0-2, so we fake it
+- */
+- u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
+- tmp_mode <<= 3;
+- tmp_mode |= 0x7;
+- mask &= tmp_mode;
+- }
+- }
+- else {
++ } else if (shift != ATA_SHIFT_PIO) {
+ mask = 0xffffffff; /* shut up compiler warning */
+ BUG();
+ }
+
++ /*
++ * Allow the controller to see the proposed mode and
++ * device data to do any custom filtering rules.
++ */
++ if(ap->ops->mode_filter)
++ mask = ap->ops->mode_filter(ap, adev, mask, shift);
+ return mask;
+ }
+
+@@ -2345,6 +2435,7 @@
+ /**
+ * ata_choose_xfer_mode - attempt to find best transfer mode
+ * @ap: Port for which an xfer mode will be selected
++ * @adev: ATA device for which xfer mode is being selected
+ * @xfer_mode_out: (output) SET FEATURES - XFER MODE code
+ * @xfer_shift_out: (output) bit shift that selects this mode
+ *
+@@ -2359,6 +2450,7 @@
+ */
+
+ static int ata_choose_xfer_mode(const struct ata_port *ap,
++ struct ata_device *adev,
+ u8 *xfer_mode_out,
+ unsigned int *xfer_shift_out)
+ {
+@@ -2367,7 +2459,7 @@
+
+ for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
+ shift = xfer_mode_classes[i].shift;
+- mask = ata_get_mode_mask(ap, shift);
++ mask = ata_get_mode_mask(ap, adev, shift);
+
+ x = fgb(mask);
+ if (x >= 0) {
+@@ -3000,6 +3092,7 @@
+ /**
+ * ata_mmio_data_xfer - Transfer data by MMIO
+ * @ap: port to read/write
++ * @adev: device to target
+ * @buf: data buffer
+ * @buflen: buffer length
+ * @write_data: read/write
+@@ -3010,8 +3103,8 @@
+ * Inherited from caller.
+ */
+
+-static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
+- unsigned int buflen, int write_data)
++void ata_mmio_data_xfer(struct ata_port *ap, struct ata_device *adev,
++ unsigned char *buf, unsigned int buflen, int write_data)
+ {
+ unsigned int i;
+ unsigned int words = buflen >> 1;
+@@ -3045,6 +3138,7 @@
+ /**
+ * ata_pio_data_xfer - Transfer data by PIO
+ * @ap: port to read/write
++ * @adev: device to target
+ * @buf: data buffer
+ * @buflen: buffer length
+ * @write_data: read/write
+@@ -3055,11 +3149,11 @@
+ * Inherited from caller.
+ */
+
+-static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
+- unsigned int buflen, int write_data)
++void ata_pio_data_xfer(struct ata_port *ap, struct ata_device *adev,
++ unsigned char *buf, unsigned int buflen, int write_data)
+ {
+ unsigned int words = buflen >> 1;
+-
++
+ /* Transfer multiple of 2 bytes */
+ if (write_data)
+ outsw(ap->ioaddr.data_addr, buf, words);
+@@ -3082,36 +3176,55 @@
+ }
+
+ /**
+- * ata_data_xfer - Transfer data from/to the data register.
++ * ata_pio_data_xfer_noirq - Transfer data from/to the data register.
+ * @ap: port to read/write
++ * @adev: device to target
+ * @buf: data buffer
+ * @buflen: buffer length
+ * @do_write: read/write
+ *
+- * Transfer data from/to the device data register.
++ * Transfer data from/to the device data register. This variant
++ * ensures local IRQs do not interrupt the data stream and this
++ * is needed for some controllers.
+ *
+ * LOCKING:
+ * Inherited from caller.
+ */
+
+-static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
+- unsigned int buflen, int do_write)
++void ata_pio_data_xfer_noirq(struct ata_port *ap, struct ata_device *adev,
++ unsigned char *buf, unsigned int buflen, int do_write)
+ {
+ /* Make the crap hardware pay the costs not the good stuff */
+- if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
+- unsigned long flags;
+- local_irq_save(flags);
+- if (ap->flags & ATA_FLAG_MMIO)
+- ata_mmio_data_xfer(ap, buf, buflen, do_write);
+- else
+- ata_pio_data_xfer(ap, buf, buflen, do_write);
+- local_irq_restore(flags);
+- } else {
+- if (ap->flags & ATA_FLAG_MMIO)
+- ata_mmio_data_xfer(ap, buf, buflen, do_write);
+- else
+- ata_pio_data_xfer(ap, buf, buflen, do_write);
+- }
++ unsigned long flags;
++ local_irq_save(flags);
++ ata_pio_data_xfer(ap, adev, buf, buflen, do_write);
++ local_irq_restore(flags);
++}
++
++/**
++ * ata_mmio_data_xfer_noirq - Transfer data from/to the data register.
++ * @ap: address to read/write
++ * @adev: device to target
++ * @buf: data buffer
++ * @buflen: buffer length
++ * @do_write: read/write
++ *
++ * Transfer data from/to the device data register. This variant
++ * ensures local IRQs do not interrupt the data stream and this
++ * is needed for some controllers.
++ *
++ * LOCKING:
++ * Inherited from caller.
++ */
++
++void ata_mmio_data_xfer_noirq(struct ata_port *ap, struct ata_device *adev,
++ unsigned char *buf, unsigned int buflen, int do_write)
++{
++ /* Make the crap hardware pay the costs not the good stuff */
++ unsigned long flags;
++ local_irq_save(flags);
++ ata_mmio_data_xfer(ap, adev, buf, buflen, do_write);
++ local_irq_restore(flags);
+ }
+
+ /**
+@@ -3157,7 +3270,7 @@
+
+ /* do the actual data transfer */
+ do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
+- ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
++ ap->ops->data_xfer(ap, qc->dev, buf, ATA_SECT_SIZE, do_write);
+
+ kunmap(page);
+ }
+@@ -3204,7 +3317,7 @@
+ ap->id, bytes);
+
+ for (i = 0; i < words; i++)
+- ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
++ ap->ops->data_xfer(ap, qc->dev, (unsigned char*)pad_buf, 2, do_write);
+
+ ap->hsm_task_state = HSM_ST_LAST;
+ return;
+@@ -3239,7 +3352,7 @@
+ DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
+
+ /* do the actual data transfer */
+- ata_data_xfer(ap, buf, count, do_write);
++ ap->ops->data_xfer(ap, qc->dev, buf, count, do_write);
+
+ kunmap(page);
+
+@@ -3948,14 +4061,15 @@
+
+ void ata_bmdma_irq_clear(struct ata_port *ap)
+ {
+- if (ap->flags & ATA_FLAG_MMIO) {
+- void __iomem *mmio = ((void __iomem *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
+- writeb(readb(mmio), mmio);
+- } else {
+- unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
+- outb(inb(addr), addr);
+- }
+-
++ if (ap->ioaddr.bmdma_addr) {
++ if (ap->flags & ATA_FLAG_MMIO) {
++ void __iomem *mmio = ((void __iomem *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
++ writeb(readb(mmio), mmio);
++ } else {
++ unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
++ outb(inb(addr), addr);
++ }
++ }
+ }
+
+
+@@ -4194,12 +4308,12 @@
+ */
+ spin_lock_irqsave(&ap->host_set->lock, flags);
+ ap->flags &= ~ATA_FLAG_NOINTR;
+- ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
++ ap->ops->data_xfer(ap, qc->dev, qc->cdb, ap->cdb_len, 1);
+ if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
+ ap->ops->bmdma_start(qc); /* initiate bmdma */
+ spin_unlock_irqrestore(&ap->host_set->lock, flags);
+ } else {
+- ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
++ ap->ops->data_xfer(ap, qc->dev, qc->cdb, ap->cdb_len, 1);
+
+ /* PIO commands are handled by polling */
+ ap->hsm_task_state = HSM_ST;
+@@ -4505,7 +4619,7 @@
+ * Number of ports registered. Zero on error (no ports registered).
+ */
+
+-int ata_device_add(const struct ata_probe_ent *ent)
++int ata_device_add(struct ata_probe_ent *ent)
+ {
+ unsigned int count = 0, i;
+ struct device *dev = ent->dev;
+@@ -4525,6 +4639,9 @@
+ host_set->mmio_base = ent->mmio_base;
+ host_set->private_data = ent->private_data;
+ host_set->ops = ent->port_ops;
++ host_set->host_set_flags = ent->host_set_flags;
++
++ ent->host_set = host_set;
+
+ /* register each port bound to this device */
+ for (i = 0; i < ent->n_ports; i++) {
+@@ -4536,6 +4653,14 @@
+ goto err_out;
+
+ host_set->ports[i] = ap;
++
++ /* Tidy up if we have no bus master base
++ Not sure this is the right spot to do it */
++ if (ap->ioaddr.bmdma_addr == 0) {
++ ap->udma_mask = 0;
++ ap->mwdma_mask = 0;
++ }
++
+ xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
+ (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
+ (ap->pio_mask << ATA_SHIFT_PIO);
+@@ -4552,6 +4677,7 @@
+ ent->irq);
+
+ ata_chk_status(ap);
++ /* This last call probably should be conditional on bmdma */
+ host_set->ops->irq_clear(ap);
+ count++;
+ }
+@@ -4605,7 +4731,8 @@
+ ata_scsi_scan_host(ap);
+ }
+
+- dev_set_drvdata(dev, host_set);
++ if(dev)
++ dev_set_drvdata(dev, host_set);
+
+ VPRINTK("EXIT, returning %u\n", ent->n_ports);
+ return ent->n_ports; /* success */
+@@ -4779,6 +4906,7 @@
+ {
+ struct ata_probe_ent *probe_ent =
+ ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
++ unsigned long bmdma;
+ int p = 0;
+
+ if (!probe_ent)
+@@ -4793,7 +4921,13 @@
+ probe_ent->port[p].altstatus_addr =
+ probe_ent->port[p].ctl_addr =
+ pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
+- probe_ent->port[p].bmdma_addr = pci_resource_start(pdev, 4);
++ bmdma = pci_resource_start(pdev, 4);
++
++ if (bmdma) {
++ if (inb(bmdma + 2) & 0x80)
++ probe_ent->host_set_flags |= ATA_HOST_SIMPLEX;
++ probe_ent->port[p].bmdma_addr = bmdma;
++ }
+ ata_std_ports(&probe_ent->port[p]);
+ p++;
+ }
+@@ -4803,7 +4937,14 @@
+ probe_ent->port[p].altstatus_addr =
+ probe_ent->port[p].ctl_addr =
+ pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
+- probe_ent->port[p].bmdma_addr = pci_resource_start(pdev, 4) + 8;
++ bmdma = pci_resource_start(pdev, 4);
++
++ if (bmdma) {
++ bmdma += 8;
++ if(inb(bmdma + 2) & 0x80)
++ probe_ent->host_set_flags |= ATA_HOST_SIMPLEX;
++ probe_ent->port[p].bmdma_addr = bmdma;
++ }
+ ata_std_ports(&probe_ent->port[p]);
+ p++;
+ }
+@@ -4815,6 +4956,7 @@
+ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev, struct ata_port_info *port, int port_num)
+ {
+ struct ata_probe_ent *probe_ent;
++ unsigned long bmdma;
+
+ probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port);
+ if (!probe_ent)
+@@ -4840,7 +4982,13 @@
+ probe_ent->port[0].ctl_addr = 0x376;
+ break;
+ }
+- probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4) + 8 * port_num;
++ bmdma = pci_resource_start(pdev, 4);
++ if(bmdma != 0) {
++ bmdma += 8 * port_num;
++ probe_ent->port[0].bmdma_addr = bmdma;
++ if (inb(bmdma + 2) & 0x80)
++ probe_ent->host_set_flags |= ATA_HOST_SIMPLEX;
++ }
+ ata_std_ports(&probe_ent->port[0]);
+ return probe_ent;
+ }
+@@ -5081,6 +5229,33 @@
+ pci_set_master(pdev);
+ return 0;
+ }
++
++/**
++ * ata_pci_clear_simplex - attempt to kick device out of simplex
++ * @pdev: PCI device
++ *
++ * Some PCI ATA devices report simplex mode but in fact can be told to
++ * enter non simplex mode. This implements the neccessary logic to
++ * perform the task on such devices. Calling it on other devices will
++ * have -undefined- behaviour.
++ */
++
++int ata_pci_clear_simplex(struct pci_dev *pdev)
++{
++ unsigned long bmdma = pci_resource_start(pdev, 4);
++ u8 simplex;
++
++ if (bmdma == 0)
++ return -ENOENT;
++
++ simplex = inb(bmdma + 0x02);
++ outb(simplex & 0x60, bmdma + 0x02);
++ simplex = inb(bmdma + 0x02);
++ if (simplex & 0x80)
++ return -EOPNOTSUPP;
++ return 0;
++}
++
+ #endif /* CONFIG_PCI */
+
+
+@@ -5158,6 +5333,10 @@
+ EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
+ EXPORT_SYMBOL_GPL(ata_bmdma_status);
+ EXPORT_SYMBOL_GPL(ata_bmdma_stop);
++EXPORT_SYMBOL_GPL(ata_mmio_data_xfer);
++EXPORT_SYMBOL_GPL(ata_pio_data_xfer);
++EXPORT_SYMBOL_GPL(ata_mmio_data_xfer_noirq);
++EXPORT_SYMBOL_GPL(ata_pio_data_xfer_noirq);
+ EXPORT_SYMBOL_GPL(ata_port_probe);
+ EXPORT_SYMBOL_GPL(sata_phy_reset);
+ EXPORT_SYMBOL_GPL(__sata_phy_reset);
+@@ -5175,6 +5354,7 @@
+ EXPORT_SYMBOL_GPL(ata_dev_config);
+ EXPORT_SYMBOL_GPL(ata_scsi_simulate);
+
++EXPORT_SYMBOL_GPL(ata_dev_pair);
+ EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
+ EXPORT_SYMBOL_GPL(ata_timing_compute);
+ EXPORT_SYMBOL_GPL(ata_timing_merge);
+@@ -5187,6 +5367,8 @@
+ EXPORT_SYMBOL_GPL(ata_pci_remove_one);
+ EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
+ EXPORT_SYMBOL_GPL(ata_pci_device_resume);
++EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
++
+ #endif /* CONFIG_PCI */
+
+ EXPORT_SYMBOL_GPL(ata_device_suspend);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/Makefile linux-2.6.16-rc4/drivers/scsi/Makefile
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/Makefile 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/Makefile 2006-02-17 18:20:44.000000000 +0000
+@@ -139,6 +139,42 @@
+ obj-$(CONFIG_SCSI_SATA_MV) += libata.o sata_mv.o
+ obj-$(CONFIG_SCSI_PDC_ADMA) += libata.o pdc_adma.o
+
++obj-$(CONFIG_SCSI_PATA_ALI) += libata.o pata_ali.o
++obj-$(CONFIG_SCSI_PATA_AMD) += libata.o pata_amd.o
++obj-$(CONFIG_SCSI_PATA_ARTOP) += libata.o pata_artop.o
++obj-$(CONFIG_SCSI_PATA_ATIIXP) += libata.o pata_atiixp.o
++obj-$(CONFIG_SCSI_PATA_CMD64X) += libata.o pata_cmd64x.o
++obj-$(CONFIG_SCSI_PATA_CS5520) += libata.o pata_cs5520.o
++obj-$(CONFIG_SCSI_PATA_CS5530) += libata.o pata_cs5530.o
++obj-$(CONFIG_SCSI_PATA_CS5535) += libata.o pata_cs5535.o
++obj-$(CONFIG_SCSI_PATA_CYPRESS) += libata.o pata_cypress.o
++obj-$(CONFIG_SCSI_PATA_EFAR) += libata.o pata_efar.o
++obj-$(CONFIG_SCSI_PATA_ISAPNP) += libata.o pata_isapnp.o
++obj-$(CONFIG_SCSI_PATA_HPT37X) += libata.o pata_hpt37x.o
++obj-$(CONFIG_SCSI_PATA_HPT3X2N) += libata.o pata_hpt3x2n.o
++obj-$(CONFIG_SCSI_PATA_HPT3X3) += libata.o pata_hpt34x.o
++obj-$(CONFIG_SCSI_PATA_IT8172) += libata.o pata_it8172.o
++obj-$(CONFIG_SCSI_PATA_IT821X) += libata.o pata_it821x.o
++obj-$(CONFIG_SCSI_PATA_MPIIX) += libata.o pata_mpiix.o
++obj-$(CONFIG_SCSI_PATA_NETCELL) += libata.o pata_netcell.o
++obj-$(CONFIG_SCSI_PATA_NS87410) += libata.o pata_ns87410.o
++obj-$(CONFIG_SCSI_PATA_OLDPIIX) += libata.o pata_oldpiix.o
++obj-$(CONFIG_SCSI_PATA_OPTI) += libata.o pata_opti.o
++obj-$(CONFIG_SCSI_PATA_PCMCIA) += libata.o pata_pcmcia.o
++obj-$(CONFIG_SCSI_PATA_PDC_OLD) += libata.o pata_pdc202xx_old.o
++obj-$(CONFIG_SCSI_PATA_QDI) += libata.o pata_qdi.o
++obj-$(CONFIG_SCSI_PATA_RADISYS) += libata.o pata_radisys.o
++obj-$(CONFIG_SCSI_PATA_RZ1000) += libata.o pata_rz1000.o
++obj-$(CONFIG_SCSI_PATA_SERVERWORKS) += libata.o pata_serverworks.o
++obj-$(CONFIG_SCSI_PATA_SC1200) += libata.o pata_sc1200.o
++obj-$(CONFIG_SCSI_PATA_SIL680) += libata.o pata_sil680.o
++obj-$(CONFIG_SCSI_PATA_SIS) += libata.o pata_sis.o
++obj-$(CONFIG_SCSI_PATA_TRIFLEX) += libata.o pata_triflex.o
++obj-$(CONFIG_SCSI_PATA_VIA) += libata.o pata_via.o
++obj-$(CONFIG_SCSI_PATA_WINBOND) += libata.o pata_sl82c105.o
++obj-$(CONFIG_SCSI_ATA_GENERIC) += libata.o ata_generic.o
++obj-$(CONFIG_SCSI_PATA_LEGACY) += libata.o pata_legacy.o
++
+ obj-$(CONFIG_ARM) += arm/
+
+ obj-$(CONFIG_CHR_DEV_ST) += st.o
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_ali.c linux-2.6.16-rc4/drivers/scsi/pata_ali.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_ali.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_ali.c 2006-02-20 12:28:04.000000000 +0000
+@@ -0,0 +1,606 @@
++/*
++ * ata-ali.c - ALI 15x3 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * TODO
++ * MWDMA timings
++ *
++ * based in part upon
++ * linux/drivers/ide/pci/alim15x3.c Version 0.17 2003/01/02
++ *
++ * Copyright (C) 1998-2000 Michel Aubry, Maintainer
++ * Copyright (C) 1998-2000 Andrzej Krzysztofowicz, Maintainer
++ * Copyright (C) 1999-2000 CJ, cjtsai@ali.com.tw, Maintainer
++ *
++ * Copyright (C) 1998-2000 Andre Hedrick (andre@linux-ide.org)
++ * May be copied or modified under the terms of the GNU General Public License
++ * Copyright (C) 2002 Alan Cox <alan@redhat.com>
++ * ALi (now ULi M5228) support by Clear Zhang <Clear.Zhang@ali.com.tw>
++ *
++ * Documentation
++ * Chipset documentation available under NDA only
++ *
++ * TODO
++ * Cannot have ATAPI on both master & slave for rev < c2 but
++ * otherwise should do atapi DMA.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "ali"
++#define DRV_VERSION "0.2.2"
++
++/**
++ * ali_c2_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection for C2 and later revisions
++ */
++
++static int ali_c2_cable_detect(struct ata_port *ap) {
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 ata66;
++
++ /* Certain laptops use short but suitable cables and don't
++ implement the detect logic */
++
++ /* Fujitsu P2000 */
++ if (pdev->subsystem_vendor == 0x10CF && pdev->subsystem_device == 0x10AF)
++ return ATA_CBL_PATA80;
++
++ /* Host view cable detect 0x4A bit 0 primary bit 1 secondary
++ Bit set for 40 pin */
++ pci_read_config_byte(pdev, 0x4A, &ata66);
++ if (ata66 & (1 << ap->hard_port_no))
++ return ATA_CBL_PATA40;
++ else
++ return ATA_CBL_PATA80;
++}
++
++/**
++ * ali_early_phy_reset - reset for eary chip
++ * @ap: ATA port
++ *
++ * Handle the reset callback for the later chips with cable detect
++ */
++
++static void ali_c2_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ali_c2_cable_detect(ap);
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * ali_early_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection for older chipsets. This turns out to be
++ * rather easy to implement
++ */
++
++static int ali_early_cable_detect(struct ata_port *ap) {
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * ali_early_phy_reset - reset for eary chip
++ * @ap: ATA port
++ *
++ * Handle the reset callback for the early (pre cable detect) chips.
++ */
++
++static void ali_early_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ali_early_cable_detect(ap);
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * ali_20_filter - filter for earlier ALI DMA
++ * @ap: ALi ATA port
++ * @adev: attached device
++ *
++ * Ensure that we do not do DMA on CD devices. We may be able to
++ * fix that later on. Also ensure we do not do UDMA on WDC drives
++ */
++
++static unsigned int ali_20_filter(const struct ata_port *ap, struct ata_device *adev, unsigned int mask, int shift)
++{
++ char model_num[40];
++ /* No DMA on CD for now */
++ if (adev->class != ATA_DEV_ATA && shift != ATA_SHIFT_PIO)
++ return 0;
++
++ if (shift != ATA_SHIFT_UDMA)
++ return mask;
++
++ ata_dev_id_string(adev->id, model_num, ATA_ID_PROD_OFS, sizeof(model_num));
++ if (strstr(model_num, "WDC"))
++ return 0;
++ return mask;
++}
++
++/**
++ * ali_fifo_control - FIFO manager
++ * @ap: ALi channel to control
++ * @adev: device for FIFO control
++ * @on: 0 for off 1 for on
++ *
++ * Enable or disable the FIFO on a given device. Because of the way the
++ * ALi FIFO works it provides a boost on ATA disk but can be confused by
++ * ATAPI and we must therefore manage it.
++ */
++
++static void ali_fifo_control(struct ata_port *ap, struct ata_device *adev, int on)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int pio_fifo = 0x54 + ap->hard_port_no;
++ u8 fifo;
++ int shift = 4 * adev->devno;
++
++ /* Bits 3:2 (7:6 for slave) control the PIO. 00 is off 01
++ is on. The FIFO must not be used for ATAPI. We preserve
++ BIOS set thresholds */
++ pci_read_config_byte(pdev, pio_fifo, &fifo);
++ fifo &= ~(0x0C << shift);
++ if (on)
++ fifo |= (0x04 << shift);
++ pci_write_config_byte(pdev, pio_fifo, fifo);
++}
++
++/**
++ * ali_program_modes - load mode registers
++ * @ap: ALi channel to load
++ * @adev: Device the timing is for
++ * @cmd: Command timing
++ * @data: Data timing
++ * @udma: UDMA timing or zero for off
++ *
++ * Loads the timing registers for cmd/data and disable UDMA if
++ * udma is zero. If udma is set then load and enable the UDMA
++ * timing but do not touch the command/data timing.
++ */
++
++static void ali_program_modes(struct ata_port *ap, struct ata_device *adev, u8 cmd, u8 data, u8 ultra)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int cbt = 0x59 + 4 * ap->hard_port_no; /* Command timing */
++ int drwt = 0x5A + 4 * ap->hard_port_no + adev->devno; /* R/W timing */
++ int udmat = 0x56 + ap->hard_port_no; /* UDMA timing */
++ int shift = 4 * adev->devno;
++ u8 udma;
++
++ if (ultra == 0) {
++ /* FIXME: We ought to set up pcas not rely on the BIOS */
++ /* Load the command block timing register */
++ pci_write_config_byte(pdev, cbt, cmd);
++
++ /* Load the data transfer timing register */
++ pci_write_config_byte(pdev, drwt, data);
++ }
++
++ /* Set up the UDMA enable */
++ pci_read_config_byte(pdev, udmat, &udma);
++ udma &= ~(0x0F << shift);
++ udma |= ultra << shift;
++ pci_write_config_byte(pdev, udmat, udma);
++}
++
++/**
++ * ali_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the ALi registers for PIO mode. FIXME: add timings for
++ * PIO5.
++ */
++
++static void ali_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++ int pio = adev->pio_mode - XFER_PIO_0;
++ int cmdpio = pio;
++
++ /* These values are from the BIOS programming guide */
++ static u8 cmd_block_timing[5] = { 0x0A, 0x03, 0x01, 0x33, 0x31 };
++ static u8 data_block_timing[5] = { 0x88, 0x58, 0x44, 0x33, 0x31 };
++
++ if (adev->class != ATA_DEV_ATA)
++ ali_fifo_control(ap, adev, 0);
++
++ /* Command timing is shared, so pick the best we can use */
++ if (pair)
++ cmdpio = min(pair->pio_mode, adev->pio_mode) - XFER_PIO_0;
++
++ ali_program_modes(ap, adev, cmd_block_timing[cmdpio],
++ data_block_timing[pio], 0);
++
++ if (adev->class == ATA_DEV_ATA)
++ ali_fifo_control(ap, adev, 1);
++
++}
++
++/**
++ * ali_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * FIXME: MWDMA timings
++ */
++
++static void ali_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u8 udma_timing[7] = { 0xC, 0xB, 0xA, 0x9, 0x8, 0xF, 0xD };
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ ali_program_modes(ap, adev, 0, 0, udma_timing[adev->dma_mode - XFER_UDMA_0]);
++ } else {
++ /* MWDMA is not yet supported */
++ /* ali_program_modes(ap, adev, cmd, data, 0); */
++ }
++}
++
++/**
++ * ali_lock_sectors - Keep older devices to 255 sector mode
++ * @ap: ATA port
++ * @adev: Device
++ *
++ * Called during the bus probe for each device that is found. We use
++ * this call to lock the sector count of the device to 255 or less on
++ * older ALi controllers. If we didn't do this then large I/O's would
++ * require LBA48 commands which the older ALi requires are issued by
++ * slower PIO methods
++ */
++
++static void ali_lock_sectors(struct ata_port *ap, struct ata_device *adev)
++{
++ if(ap->host->max_sectors > 255) {
++ ap->host->max_sectors = 255;
++ ap->host->hostt->max_sectors = 255;
++ }
++ adev->flags |= ATA_DFLAG_LOCK_SECTORS;
++}
++
++static struct scsi_host_template ali_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ /* Keep LBA28 counts so large I/O's don't turn LBA48 and PIO
++ with older controllers. Not locked so will grow on C5 or later */
++ .max_sectors = 255,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++/*
++ * Port operations for PIO only ALi
++ */
++
++static struct ata_port_operations ali_early_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = ali_set_piomode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = ali_early_phy_reset,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Port operations for DMA capable ALi without cable
++ * detect
++ */
++static struct ata_port_operations ali_20_port_ops = {
++ .port_disable = ata_port_disable,
++
++ .set_piomode = ali_set_piomode,
++ .set_dmamode = ali_set_dmamode,
++ .mode_filter = ali_20_filter,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++ .dev_config = ali_lock_sectors,
++
++ .phy_reset = ali_early_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Port operations for DMA capable ALi with cable detect
++ */
++static struct ata_port_operations ali_c2_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = ali_set_piomode,
++ .set_dmamode = ali_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++ .dev_config = ali_lock_sectors,
++
++ .phy_reset = ali_c2_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Port operations for DMA capable ALi with cable detect and LBA48
++ */
++static struct ata_port_operations ali_c5_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = ali_set_piomode,
++ .set_dmamode = ali_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = ali_c2_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * ali_init_one - discovery callback
++ * @pdev: PCI device ID
++ * @id: PCI table info
++ *
++ * An ALi IDE interface has been discovered. Figure out what revision
++ * and perform configuration work before handing it to the ATA layer
++ */
++
++static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info_early = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .port_ops = &ali_early_port_ops
++ };
++ /* Revision 0x20 added DMA */
++ static struct ata_port_info info_20 = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_PIO_LBA48,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &ali_20_port_ops
++ };
++ /* Revision 0x20 with support logic added UDMA */
++ static struct ata_port_info info_20_udma = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_PIO_LBA48,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x07, /* UDMA33 */
++ .port_ops = &ali_20_port_ops
++ };
++ /* Revision 0xC2 adds UDMA66 */
++ static struct ata_port_info info_c2 = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_PIO_LBA48,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f,
++ .port_ops = &ali_c2_port_ops
++ };
++ /* Revision 0xC3 is UDMA100 */
++ static struct ata_port_info info_c3 = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_PIO_LBA48,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &ali_c2_port_ops
++ };
++ /* Revision 0xC4 is UDMA133 */
++ static struct ata_port_info info_c4 = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_PIO_LBA48,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &ali_c2_port_ops
++ };
++ /* Revision 0xC5 is UDMA133 with LBA48 DMA */
++ static struct ata_port_info info_c5 = {
++ .sht = &ali_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &ali_c5_port_ops
++ };
++
++ static struct ata_port_info *port_info[2];
++ u8 rev, tmp;
++ struct pci_dev *north, *isa_bridge;
++
++ pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
++
++ /*
++ * The chipset revision selects the driver operations and
++ * mode data.
++ */
++
++ if (rev < 0x20) {
++ port_info[0] = port_info[1] = &info_early;
++ } else if (rev < 0xC2) {
++ /* 1543-E/F, 1543C-C, 1543C-D, 1543C-E */
++ pci_read_config_byte(pdev, 0x4B, &tmp);
++ /* Clear CD-ROM DMA write bit */
++ tmp &= 0x7F;
++ pci_write_config_byte(pdev, 0x4B, tmp);
++ port_info[0] = port_info[1] = &info_20;
++ } else if (rev == 0xC2) {
++ port_info[0] = port_info[1] = &info_c2;
++ } else if (rev == 0xC3) {
++ port_info[0] = port_info[1] = &info_c3;
++ } else if (rev == 0xC4) {
++ port_info[0] = port_info[1] = &info_c4;
++ } else
++ port_info[0] = port_info[1] = &info_c5;
++
++ if (rev >= 0xC2) {
++ /* Enable cable detection logic */
++ pci_read_config_byte(pdev, 0x4B, &tmp);
++ pci_write_config_byte(pdev, 0x4B, tmp | 0x08);
++ }
++
++ north = pci_get_slot(pdev->bus, PCI_DEVFN(0,0));
++ isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
++
++ if (north && north->vendor == PCI_VENDOR_ID_AL) {
++ /* Configure the ALi bridge logic. For non ALi rely on BIOS.
++ Set the south bridge enable bit */
++ pci_read_config_byte(isa_bridge, 0x79, &tmp);
++ if (rev == 0xC2)
++ pci_write_config_byte(isa_bridge, 0x79, tmp | 0x04);
++ else if (rev > 0xC2)
++ pci_write_config_byte(isa_bridge, 0x79, tmp | 0x02);
++ }
++
++ if (rev >= 0x20) {
++ if (rev < 0xC2) {
++ /* Are we paired with a UDMA capable chip */
++ pci_read_config_byte(isa_bridge, 0x5E, &tmp);
++ if ((tmp & 0x1E) == 0x12)
++ port_info[0] = port_info[1] = &info_20_udma;
++ }
++ /*
++ * CD_ROM DMA on (0x53 bit 0). Enable this even if we want
++ * to use PIO. 0x53 bit 1 (rev 20 only) - enable FIFO control
++ * via 0x54/55.
++ */
++ pci_read_config_byte(pdev, 0x53, &tmp);
++ if (rev == 0x20)
++ tmp &= ~0x02;
++ tmp |= 0x01;
++ pci_write_config_byte(pdev, 0x53, tmp);
++ }
++
++ pci_dev_put(isa_bridge);
++ pci_dev_put(north);
++
++ ata_pci_clear_simplex(pdev);
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static struct pci_device_id ali[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5228), },
++ { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5229), },
++ { 0, },
++};
++
++static struct pci_driver ali_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = ali,
++ .probe = ali_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init ali_init(void)
++{
++ return pci_register_driver(&ali_pci_driver);
++}
++
++
++static void __exit ali_exit(void)
++{
++ pci_unregister_driver(&ali_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for ALi PATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, ali);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(ali_init);
++module_exit(ali_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_amd.c linux-2.6.16-rc4/drivers/scsi/pata_amd.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_amd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_amd.c 2006-02-16 15:37:39.000000000 +0000
+@@ -0,0 +1,650 @@
++/*
++ * pata_amd.c - AMD PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based on pata-sil680. Errata information is taken from data sheets
++ * and the amd74xx.c driver by Vojtech Pavlik. Nvidia SATA devices are
++ * claimed by sata-nv.c.
++ *
++ * TODO:
++ * Nvidia support here or seperated ?
++ * Debug cable detect
++ * Variable system clock when/if it makes sense
++ * Power management on ports
++ *
++ *
++ * Documentation publically available.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_amd"
++#define DRV_VERSION "0.1.3"
++
++/**
++ * timing_setup - shared timing computation and load
++ * @ap: ATA port being set up
++ * @adev: drive being configured
++ * @offset: port offset
++ * @speed: target speed
++ * @clock: clock multiplier (number of times 33MHz for this part)
++ *
++ * Perform the actual timing set up for Nvidia or AMD PATA devices.
++ * The actual devices vary so they all call into this helper function
++ * providing the clock multipler and offset (because AMD and Nvidia put
++ * the ports at different locations).
++ */
++
++static void timing_setup(struct ata_port *ap, struct ata_device *adev, int offset, int speed, int clock)
++{
++ static const unsigned char amd_cyc2udma[] = {
++ 6, 6, 5, 4, 0, 1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 7
++ };
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct ata_device *peer = ata_dev_pair(ap, adev);
++ int dn = ap->hard_port_no * 2 + adev->devno;
++ struct ata_timing at, apeer;
++ int T, UT;
++ const int amd_clock = 33333; /* KHz. */
++ u8 t;
++
++ T = 1000000000 / amd_clock;
++ UT = T / min_t(int, max_t(int, clock, 1), 2);
++
++ if (ata_timing_compute(adev, speed, &at, T, UT) < 0) {
++ dev_printk(KERN_ERR, &pdev->dev, "unknown mode %d.\n", speed);
++ return;
++ }
++
++ if (peer) {
++ /* This may be over conservative */
++ if (peer->dma_mode) {
++ ata_timing_compute(peer, peer->dma_mode, &apeer, T, UT);
++ ata_timing_merge(&apeer, &at, &at, ATA_TIMING_8BIT);
++ }
++ ata_timing_compute(peer, peer->pio_mode, &apeer, T, UT);
++ ata_timing_merge(&apeer, &at, &at, ATA_TIMING_8BIT);
++ }
++
++ if (speed == XFER_UDMA_5 && amd_clock <= 33333) at.udma = 1;
++ if (speed == XFER_UDMA_6 && amd_clock <= 33333) at.udma = 15;
++
++ /*
++ * Now do the setup work
++ */
++
++ /* Configure the address set up timing */
++ pci_read_config_byte(pdev, offset + 0x0C, &t);
++ t = (t & ~(3 << ((3 - dn) << 1))) | ((FIT(at.setup, 1, 4) - 1) << ((3 - dn) << 1));
++ pci_write_config_byte(pdev, offset + 0x0C , t);
++
++ /* Configure the 8bit I/O timing */
++ pci_write_config_byte(pdev, offset + 0x0E + (1 - (dn >> 1)),
++ ((FIT(at.act8b, 1, 16) - 1) << 4) | (FIT(at.rec8b, 1, 16) - 1));
++
++ /* Drive timing */
++ pci_write_config_byte(pdev, offset + 0x08 + (3 - dn),
++ ((FIT(at.active, 1, 16) - 1) << 4) | (FIT(at.recover, 1, 16) - 1));
++
++ switch (clock) {
++ case 1:
++ t = at.udma ? (0xc0 | (FIT(at.udma, 2, 5) - 2)) : 0x03;
++ break;
++
++ case 2:
++ t = at.udma ? (0xc0 | amd_cyc2udma[FIT(at.udma, 2, 10)]) : 0x03;
++ break;
++
++ case 3:
++ t = at.udma ? (0xc0 | amd_cyc2udma[FIT(at.udma, 1, 10)]) : 0x03;
++ break;
++
++ case 4:
++ t = at.udma ? (0xc0 | amd_cyc2udma[FIT(at.udma, 1, 15)]) : 0x03;
++ break;
++
++ default:
++ return;
++ }
++
++ /* UDMA timing */
++ pci_write_config_byte(pdev, offset + 0x10 + (3 - dn), t);
++}
++
++/**
++ * amd_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection. The BIOS stores this in PCI config
++ * space for us.
++ */
++
++static int amd_cable_detect(struct ata_port *ap) {
++ static u32 bitmask[2] = {0x00030000, 0x00C00000};
++ u32 ata66;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_dword(pdev, 0x42, &ata66);
++ if (ata66 & bitmask[ap->hard_port_no])
++ return ATA_CBL_PATA80;
++ else
++ return ATA_CBL_PATA40;
++
++}
++
++static void amd_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits amd_enable_bits[] = {
++ { 0x40, 1, 0x02, 0x02 },
++ { 0x40, 1, 0x01, 0x01 }
++ };
++
++ if (!pci_test_config_bits(pdev, &amd_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = amd_cable_detect(ap);
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * amd33_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the AMD registers for PIO mode.
++ */
++
++static void amd33_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->pio_mode, 1);
++}
++
++static void amd66_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->pio_mode, 2);
++}
++
++static void amd100_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->pio_mode, 3);
++}
++
++static void amd133_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->pio_mode, 4);
++}
++
++/**
++ * amd33_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the MWDMA/UDMA modes for the AMD and Nvidia
++ * chipset.
++ */
++
++static void amd33_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->dma_mode, 1);
++}
++
++static void amd66_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->dma_mode, 2);
++}
++
++static void amd100_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->dma_mode, 3);
++}
++
++static void amd133_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x40, adev->dma_mode, 4);
++}
++
++
++/**
++ * nv_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection. The BIOS stores this in PCI config
++ * space for us.
++ */
++
++static int nv_cable_detect(struct ata_port *ap) {
++ static u32 bitmask[2] = {0x00030000, 0x00C00000};
++ u32 ata66;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_dword(pdev, 0x52, &ata66);
++ if (ata66 & bitmask[ap->hard_port_no])
++ return ATA_CBL_PATA80;
++ else
++ return ATA_CBL_PATA40;
++
++}
++
++static void nv_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = nv_cable_detect(ap);
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * nv100_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the AMD registers for PIO mode.
++ */
++
++static void nv100_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x50, adev->pio_mode, 3);
++}
++
++static void nv133_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x50, adev->pio_mode, 4);
++}
++
++/**
++ * nv100_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the MWDMA/UDMA modes for the AMD and Nvidia
++ * chipset.
++ */
++
++static void nv100_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x50, adev->dma_mode, 3);
++}
++
++static void nv133_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ timing_setup(ap, adev, 0x50, adev->dma_mode, 4);
++}
++
++static struct scsi_host_template amd_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations amd33_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = amd33_set_piomode,
++ .set_dmamode = amd33_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = amd_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations amd66_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = amd66_set_piomode,
++ .set_dmamode = amd66_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = amd_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations amd100_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = amd100_set_piomode,
++ .set_dmamode = amd100_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = amd_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations amd133_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = amd133_set_piomode,
++ .set_dmamode = amd133_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = amd_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations nv100_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = nv100_set_piomode,
++ .set_dmamode = nv100_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = nv_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations nv133_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = nv133_set_piomode,
++ .set_dmamode = nv133_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = nv_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int amd_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info[10] = {
++ { /* 0: AMD 7401 */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07, /* No SWDMA */
++ .udma_mask = 0x07, /* UDMA 33 */
++ .port_ops = &amd33_port_ops
++ },
++ { /* 1: Early AMD7409 - no swdma */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f, /* UDMA 66 */
++ .port_ops = &amd66_port_ops
++ },
++ { /* 2: AMD 7409, no swdma errata */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f, /* UDMA 66 */
++ .port_ops = &amd66_port_ops
++ },
++ { /* 3: AMD 7411 */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f, /* UDMA 100 */
++ .port_ops = &amd100_port_ops
++ },
++ { /* 4: AMD 7441 */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f, /* UDMA 100 */
++ .port_ops = &amd100_port_ops
++ },
++ { /* 5: AMD 8111*/
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f, /* UDMA 133, no swdma */
++ .port_ops = &amd133_port_ops
++ },
++ { /* 6: AMD 8111 UDMA 100 (Serenade) */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f, /* UDMA 100, no swdma */
++ .port_ops = &amd133_port_ops
++ },
++ { /* 7: Nvidia Nforce */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f, /* UDMA 100 */
++ .port_ops = &nv100_port_ops
++ },
++ { /* 8: Nvidia Nforce2 and later */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f, /* UDMA 133, no swdma */
++ .port_ops = &nv133_port_ops
++ },
++ { /* 9: AMD CS5536 (Geode companion) */
++ .sht = &amd_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f, /* UDMA 100 */
++ .port_ops = &amd100_port_ops
++ }
++ };
++ static struct ata_port_info *port_info[2];
++ static int printed_version;
++ int type = id->driver_data;
++ u8 rev;
++ u8 fifo;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
++
++ pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
++ pci_read_config_byte(pdev, 0x41, &fifo);
++
++ /* Check for AMD7409 without swdma errata and if found adjust type */
++ if (type == 1 && rev > 0x7)
++ type = 2;
++
++ /* Check for AMD7411 */
++ if (type == 3)
++ /* FIFO is broken */
++ pci_write_config_byte(pdev, 0x41, fifo & 0x0F);
++ else
++ pci_write_config_byte(pdev, 0x41, fifo | 0xF0);
++
++ /* Serenade ? */
++ if (type == 5 && pdev->subsystem_vendor == PCI_VENDOR_ID_AMD &&
++ pdev->subsystem_device == PCI_DEVICE_ID_AMD_SERENADE)
++ type = 6; /* UDMA 100 only */
++
++ if (type < 3)
++ ata_pci_clear_simplex(pdev);
++
++ /* And fire it up */
++
++ port_info[0] = port_info[1] = &info[type];
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id amd[] = {
++ { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_COBRA_7401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
++ { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_7409, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
++ { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_7411, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
++ { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_OPUS_7441, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
++ { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8111_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
++ { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
++ { 0, },
++};
++
++static struct pci_driver amd_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = amd,
++ .probe = amd_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init amd_init(void)
++{
++ return pci_register_driver(&amd_pci_driver);
++}
++
++static void __exit amd_exit(void)
++{
++ pci_unregister_driver(&amd_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for AMD PATA IDE");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, amd);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(amd_init);
++module_exit(amd_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_artop.c linux-2.6.16-rc4/drivers/scsi/pata_artop.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_artop.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_artop.c 2006-02-07 13:41:48.000000000 +0000
+@@ -0,0 +1,497 @@
++/*
++ * pata_artop.c - ARTOP ATA controller driver
++ *
++ * (C) 2006 Red Hat <alan@redhat.com>
++ *
++ * Based in part on drivers/ide/pci/aec62xx.c
++ * Copyright (C) 1999-2002 Andre Hedrick <andre@linux-ide.org>
++ * 865/865R fixes for Macintosh card version from a patch to the old
++ * driver by Thibaut VARENE <varenet@parisc-linux.org>
++ *
++ * TODO
++ * 850 serialization once the core supports it
++ * Investigate no_dsc on 850R
++ * Clock detect
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <linux/ata.h>
++
++#define DRV_NAME "pata_artop"
++#define DRV_VERSION "0.2"
++
++/*
++ * The ARTOP has 33 Mhz and "over clocked" timing tables. Until we
++ * get PCI bus speed functionality we leave this as 0. Its a variable
++ * for when we get the functionality and also for folks wanting to
++ * test stuff.
++ */
++
++static int clock = 0;
++
++/**
++ * artop6210_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6210_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ const struct pci_bits artop_enable_bits[] = {
++ { 0x4AU, 1U, 0x02UL, 0x02UL }, /* port 0 */
++ { 0x4AU, 1U, 0x04UL, 0x04UL }, /* port 1 */
++ };
++
++ if (!pci_test_config_bits(pdev, &artop_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * artop6260_cable_detect - check for 40/80 pin
++ * @ap: Port
++ *
++ * The ARTOP hardware reports the cable detect bits in register 0x49.
++ * Nothing complicated needed here.
++ */
++
++static int artop6260_cable_detect(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 tmp;
++
++ pci_read_config_byte(pdev, 0x49, &tmp);
++ if (tmp & (1 >> ap->hard_port_no))
++ return ATA_CBL_PATA40;
++ return ATA_CBL_PATA80;
++}
++
++/**
++ * artop6260_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6260_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ const struct pci_bits artop_enable_bits[] = {
++ { 0x4AU, 1U, 0x02UL, 0x02UL }, /* port 0 */
++ { 0x4AU, 1U, 0x04UL, 0x04UL }, /* port 1 */
++ };
++
++ /* Odd numbered device ids are the units with enable bits (the -R cards) */
++ if (pdev->device % 1 && !pci_test_config_bits(pdev, &artop_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = artop6260_cable_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * artop6210_load_piomode - Load a set of PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device
++ * @pio: PIO mode
++ *
++ * Set PIO mode for device, in host controller PCI config space. This
++ * is used both to set PIO timings in PIO mode and also to set the
++ * matching PIO clocking for UDMA, as well as the MWDMA timings.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6210_load_piomode(struct ata_port *ap, struct ata_device *adev, unsigned int pio)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = adev->devno + 2 * ap->hard_port_no;
++ const u16 timing[2][5] = {
++ { 0x0000, 0x000A, 0x0008, 0x0303, 0x0301 },
++ { 0x0700, 0x070A, 0x0708, 0x0403, 0x0401 }
++
++ };
++ /* Load the PIO timing active/recovery bits */
++ pci_write_config_word(pdev, 0x40 + 2 * dn, timing[clock][pio]);
++}
++
++/**
++ * artop6210_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring
++ *
++ * Set PIO mode for device, in host controller PCI config space. For
++ * ARTOP we must also clear the UDMA bits if we are not doing UDMA. In
++ * the event UDMA is used the later call to set_dmamode will set the
++ * bits as required.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6210_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = adev->devno + 2 * ap->hard_port_no;
++ u8 ultra;
++
++ artop6210_load_piomode(ap, adev, adev->pio_mode - XFER_PIO_0);
++
++ /* Clear the UDMA mode bits (set_dmamode will redo this if needed) */
++ pci_read_config_byte(pdev, 0x54, &ultra);
++ ultra &= ~(3 << (2 * dn));
++ pci_write_config_byte(pdev, 0x54, ultra);
++}
++
++/**
++ * artop6260_load_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring
++ * @pio: PIO mode
++ *
++ * Set PIO mode for device, in host controller PCI config space. The
++ * ARTOP6260 and relatives store the timing data differently.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6260_load_piomode (struct ata_port *ap, struct ata_device *adev, unsigned int pio)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = adev->devno + 2 * ap->hard_port_no;
++ const u8 timing[2][5] = {
++ { 0x00, 0x0A, 0x08, 0x33, 0x31 },
++ { 0x70, 0x7A, 0x78, 0x43, 0x41 }
++
++ };
++ /* Load the PIO timing active/recovery bits */
++ pci_write_config_byte(pdev, 0x40 + dn, timing[clock][pio]);
++}
++
++/**
++ * artop6260_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring
++ *
++ * Set PIO mode for device, in host controller PCI config space. For
++ * ARTOP we must also clear the UDMA bits if we are not doing UDMA. In
++ * the event UDMA is used the later call to set_dmamode will set the
++ * bits as required.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6260_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 ultra;
++
++ artop6260_load_piomode(ap, adev, adev->pio_mode - XFER_PIO_0);
++
++ /* Clear the UDMA mode bits (set_dmamode will redo this if needed) */
++ pci_read_config_byte(pdev, 0x44 + ap->hard_port_no, &ultra);
++ ultra &= ~(7 << (4 * adev->devno)); /* One nibble per drive */
++ pci_write_config_byte(pdev, 0x44 + ap->hard_port_no, ultra);
++}
++
++/**
++ * artop6210_set_dmamode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: um
++ *
++ * Set DMA mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6210_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int pio;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = adev->devno + 2 * ap->hard_port_no;
++ u8 ultra;
++
++ if (adev->dma_mode == XFER_MW_DMA_0)
++ pio = 1;
++ else
++ pio = 4;
++
++ /* Load the PIO timing active/recovery bits */
++ artop6210_load_piomode(ap, adev, pio);
++
++ pci_read_config_byte(pdev, 0x54, &ultra);
++ ultra &= ~(3 << (2 * dn));
++
++ /* Add ultra DMA bits if in UDMA mode */
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ u8 mode = (adev->dma_mode - XFER_UDMA_0) + 1 - clock;
++ if (mode == 0)
++ mode = 1;
++ ultra |= (mode << (2 * dn));
++ }
++ pci_write_config_byte(pdev, 0x54, ultra);
++}
++
++/**
++ * artop6260_set_dmamode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring
++ *
++ * Set DMA mode for device, in host controller PCI config space. The
++ * ARTOP6260 and relatives store the timing data differently.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void artop6260_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int pio = adev->pio_mode - XFER_PIO_0;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 ultra;
++
++ if (adev->dma_mode == XFER_MW_DMA_0)
++ pio = 1;
++ else
++ pio = 4;
++
++ /* Load the PIO timing active/recovery bits */
++ artop6260_load_piomode(ap, adev, pio);
++
++ /* Add ultra DMA bits if in UDMA mode */
++ pci_read_config_byte(pdev, 0x44 + ap->hard_port_no, &ultra);
++ ultra &= ~(7 << (4 * adev->devno)); /* One nibble per drive */
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ u8 mode = adev->dma_mode - XFER_UDMA_0 + 1 - clock;
++ if (mode == 0)
++ mode = 1;
++ ultra |= (mode << (4 * adev->devno));
++ }
++ pci_write_config_byte(pdev, 0x44 + ap->hard_port_no, ultra);
++}
++
++static struct scsi_host_template artop_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static const struct ata_port_operations artop6210_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = artop6210_set_piomode,
++ .set_dmamode = artop6210_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = artop6210_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static const struct ata_port_operations artop6260_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = artop6260_set_piomode,
++ .set_dmamode = artop6260_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = artop6260_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++
++/**
++ * artop_init_one - Register ARTOP ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in artop_pci_tbl matching with @pdev
++ *
++ * Called from kernel PCI layer.
++ *
++ * LOCKING:
++ * Inherited from PCI layer (may sleep).
++ *
++ * RETURNS:
++ * Zero on success, or -ERRNO value.
++ */
++
++static int artop_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ static int printed_version;
++ static struct ata_port_info info_6210 = {
++ .sht = &artop_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma0-2 */
++ .udma_mask = ATA_UDMA2,
++ .port_ops = &artop6210_ops,
++ };
++ static struct ata_port_info info_626x = {
++ .sht = &artop_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma0-2 */
++ .udma_mask = ATA_UDMA4,
++ .port_ops = &artop6260_ops,
++ };
++ static struct ata_port_info info_626x_fast = {
++ .sht = &artop_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma0-2 */
++ .udma_mask = ATA_UDMA5,
++ .port_ops = &artop6260_ops,
++ };
++ struct ata_port_info *port_info[2];
++ struct ata_port_info *info;
++ int ports = 2;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev,
++ "version " DRV_VERSION "\n");
++
++ if (id->driver_data == 0) { /* 6210 variant */
++ info = &info_6210;
++ /* BIOS may have left us in UDMA, clear it before libata probe */
++ pci_write_config_byte(pdev, 0x54, 0);
++ /* For the moment (also lacks dsc) */
++ printk(KERN_WARNING "ARTOP 6210 requires serialize functionality not yet supported by libata.\n");
++ printk(KERN_WARNING "Secondary ATA ports will not be activated.\n");
++ ports = 1;
++ }
++ else if (id->driver_data == 1) /* 6260 */
++ info = &info_626x;
++ else if (id->driver_data == 2) { /* 6260 or 6260 + fast */
++ unsigned long io = pci_resource_start(pdev, 4);
++ u8 reg;
++
++ info = &info_626x;
++ if (inb(io) & 0x10)
++ info = &info_626x_fast;
++ /* Mac systems come up with some registers not set as we
++ will need them */
++
++ /* Clear reset & test bits */
++ pci_read_config_byte(pdev, 0x49, &reg);
++ pci_write_config_byte(pdev, 0x49, reg & ~ 0x30);
++
++ /* Enable IRQ output and burst mode */
++ pci_read_config_byte(pdev, 0x4a, &reg);
++ pci_write_config_byte(pdev, 0x4a, (reg & ~0x01) | 0x80);
++
++ }
++ port_info[0] = port_info[1] = info;
++ return ata_pci_init_one(pdev, port_info, ports);
++}
++
++static const struct pci_device_id artop_pci_tbl[] = {
++ { 0x1191, 0x0005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { 0x1191, 0x0006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
++ { 0x1191, 0x0007, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
++ { 0x1191, 0x0008, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { 0x1191, 0x0009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { } /* terminate list */
++};
++
++static struct pci_driver artop_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = artop_pci_tbl,
++ .probe = artop_init_one,
++ .remove = ata_pci_remove_one,
++};
++
++static int __init artop_init(void)
++{
++ return pci_register_driver(&artop_pci_driver);
++}
++
++static void __exit artop_exit(void)
++{
++ pci_unregister_driver(&artop_pci_driver);
++}
++
++
++module_init(artop_init);
++module_exit(artop_exit);
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("SCSI low-level driver for ARTOP PATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, artop_pci_tbl);
++MODULE_VERSION(DRV_VERSION);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_atiixp.c linux-2.6.16-rc4/drivers/scsi/pata_atiixp.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_atiixp.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_atiixp.c 2006-02-07 13:42:02.000000000 +0000
+@@ -0,0 +1,299 @@
++/*
++ * pata_atiixp.c - ATI PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based on
++ *
++ * linux/drivers/ide/pci/atiixp.c Version 0.01-bart2 Feb. 26, 2004
++ *
++ * Copyright (C) 2003 ATI Inc. <hyu@ati.com>
++ * Copyright (C) 2004 Bartlomiej Zolnierkiewicz
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_atiixp"
++#define DRV_VERSION "0.1.1"
++
++enum {
++ ATIIXP_IDE_PIO_TIMING = 0x40,
++ ATIIXP_IDE_MWDMA_TIMING = 0x44,
++ ATIIXP_IDE_PIO_CONTROL = 0x48,
++ ATIIXP_IDE_PIO_MODE = 0x4a,
++ ATIIXP_IDE_UDMA_CONTROL = 0x54,
++ ATIIXP_IDE_UDMA_MODE = 0x56
++};
++
++static void atiixp_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits atiixp_enable_bits[] = {
++ { 0x48, 1, 0x01, 0x00 },
++ { 0x48, 1, 0x08, 0x00 }
++ };
++
++ if (!pci_test_config_bits(pdev, &atiixp_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA80;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * atiixp_set_pio_timing - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called by both the pio and dma setup functions to set the controller
++ * timings for PIO transfers. We must load both the mode number and
++ * timing values into the controller.
++ */
++
++static void atiixp_set_pio_timing(struct ata_port *ap, struct ata_device *adev, int pio)
++{
++ static u8 pio_timings[5] = { 0x5D, 0x47, 0x34, 0x22, 0x20 };
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = 2 * ap->hard_port_no + adev->devno;
++
++ /* Check this is correct - the order is odd in both drivers */
++ int timing_shift = (16 * ap->hard_port_no) + 8 * (adev->devno ^ 1);
++ u16 pio_mode_data, pio_timing_data;
++
++ pci_read_config_word(pdev, ATIIXP_IDE_PIO_MODE, &pio_mode_data);
++ pio_mode_data &= ~(0x7 << (4 * dn));
++ pio_mode_data |= pio << (4 * dn);
++ pci_write_config_word(pdev, ATIIXP_IDE_PIO_MODE, pio_mode_data);
++
++ pci_read_config_word(pdev, ATIIXP_IDE_PIO_TIMING, &pio_timing_data);
++ pio_mode_data &= ~(0xFF << timing_shift);
++ pio_mode_data |= (pio_timings[pio] << timing_shift);
++ pci_write_config_word(pdev, ATIIXP_IDE_PIO_TIMING, pio_timing_data);
++}
++
++/**
++ * atiixp_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup. We use a shared helper for this
++ * as the DMA setup must also adjust the PIO timing information.
++ */
++
++static void atiixp_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ atiixp_set_pio_timing(ap, adev, adev->pio_mode - XFER_PIO_0);
++}
++
++/**
++ * atiixp_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the DMA mode setup. We use timing tables for most
++ * modes but must tune an appropriate PIO mode to match.
++ */
++
++static void atiixp_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u8 mwdma_timings[5] = { 0x77, 0x21, 0x20 };
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dma = adev->dma_mode;
++ int dn = 2 * ap->hard_port_no + adev->devno;
++ int wanted_pio;
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ u16 udma_mode_data;
++
++ dma -= XFER_UDMA_0;
++
++ pci_read_config_word(pdev, ATIIXP_IDE_UDMA_MODE, &udma_mode_data);
++ udma_mode_data &= ~(0x7 << (4 * dn));
++ udma_mode_data |= dma << (4 * dn);
++ pci_write_config_word(pdev, ATIIXP_IDE_UDMA_MODE, udma_mode_data);
++ } else {
++ u16 mwdma_timing_data;
++ /* Check this is correct - the order is odd in both drivers */
++ int timing_shift = (16 * ap->hard_port_no) + 8 * (adev->devno ^ 1);
++
++ dma -= XFER_MW_DMA_0;
++
++ pci_read_config_word(pdev, ATIIXP_IDE_MWDMA_TIMING, &mwdma_timing_data);
++ mwdma_timing_data &= ~(0xFF << timing_shift);
++ mwdma_timing_data |= (mwdma_timings[dma] << timing_shift);
++ pci_write_config_word(pdev, ATIIXP_IDE_MWDMA_TIMING, mwdma_timing_data);
++ }
++ /*
++ * We must now look at the PIO mode situation. We may need to
++ * adjust the PIO mode to keep the timings acceptable
++ */
++ if (adev->dma_mode >= XFER_MW_DMA_2)
++ wanted_pio = 4;
++ else if (adev->dma_mode == XFER_MW_DMA_1)
++ wanted_pio = 3;
++ else if (adev->dma_mode == XFER_MW_DMA_0)
++ wanted_pio = 0;
++ else BUG();
++
++ if (adev->pio_mode != wanted_pio)
++ atiixp_set_pio_timing(ap, adev, wanted_pio);
++}
++
++/**
++ * atiixp_bmdma_start - DMA start callback
++ * @qc: Command in progress
++ *
++ * When DMA begins we need to ensure that the UDMA control
++ * register for the channel is correctly set.
++ */
++
++static void atiixp_bmdma_start(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = (2 * ap->hard_port_no) + adev->devno;
++ u16 tmp16;
++
++ pci_read_config_word(pdev, ATIIXP_IDE_UDMA_CONTROL, &tmp16);
++ if (adev->dma_mode >= XFER_UDMA_0)
++ tmp16 |= (1 << dn);
++ else
++ tmp16 &= ~(1 << dn);
++ pci_write_config_word(pdev, ATIIXP_IDE_UDMA_CONTROL, tmp16);
++ ata_bmdma_start(qc);
++}
++
++/**
++ * atiixp_dma_stop - DMA stop callback
++ * @qc: Command in progress
++ *
++ * DMA has completed. Clear the UDMA flag as the next operations will
++ * be PIO ones not UDMA data transfer.
++ */
++
++static void atiixp_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = (2 * ap->hard_port_no) + qc->dev->devno;
++ u16 tmp16;
++
++ pci_read_config_word(pdev, ATIIXP_IDE_UDMA_CONTROL, &tmp16);
++ tmp16 &= ~(1 << dn);
++ pci_write_config_word(pdev, ATIIXP_IDE_UDMA_CONTROL, tmp16);
++ ata_bmdma_stop(qc);
++}
++
++static struct scsi_host_template atiixp_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations atiixp_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = atiixp_set_piomode,
++ .set_dmamode = atiixp_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = atiixp_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = atiixp_bmdma_start,
++ .bmdma_stop = atiixp_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &atiixp_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x06, /* No MWDMA0 support */
++ .udma_mask = 0x3F,
++ .port_ops = &atiixp_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id atiixp[] = {
++ { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP200_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP300_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { 0, },
++};
++
++static struct pci_driver atiixp_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = atiixp,
++ .probe = atiixp_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init atiixp_init(void)
++{
++ return pci_register_driver(&atiixp_pci_driver);
++}
++
++
++static void __exit atiixp_exit(void)
++{
++ pci_unregister_driver(&atiixp_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for ATI IXP200/300/400");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, atiixp);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(atiixp_init);
++module_exit(atiixp_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cmd64x.c linux-2.6.16-rc4/drivers/scsi/pata_cmd64x.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cmd64x.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_cmd64x.c 2006-02-16 15:34:39.000000000 +0000
+@@ -0,0 +1,486 @@
++/*
++ * pata_cmd64x.c - ATI PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based upon
++ * linux/drivers/ide/pci/cmd64x.c Version 1.30 Sept 10, 2002
++ *
++ * cmd64x.c: Enable interrupts at initialization time on Ultra/PCI machines.
++ * Note, this driver is not used at all on other systems because
++ * there the "BIOS" has done all of the following already.
++ * 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-2002 Andre Hedrick <andre@linux-ide.org>
++ *
++ * TODO
++ * Testing work
++ * Non x86 needs PIO 0 loading before we commence ident
++ * - but this belongs in libata-core
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_cmd64x"
++#define DRV_VERSION "0.1.1"
++
++/*
++ * CMD64x specific registers definition.
++ */
++
++enum {
++ CFR = 0x50,
++ CFR_INTR_CH0 = 0x02,
++ CNTRL = 0x51,
++ CNTRL_DIS_RA0 = 0x40,
++ CNTRL_DIS_RA1 = 0x80,
++ CNTRL_ENA_2ND = 0x08,
++ CMDTIM = 0x52,
++ ARTTIM0 = 0x53,
++ DRWTIM0 = 0x54,
++ ARTTIM1 = 0x55,
++ DRWTIM1 = 0x56,
++ ARTTIM23 = 0x57,
++ ARTTIM23_DIS_RA2 = 0x04,
++ ARTTIM23_DIS_RA3 = 0x08,
++ ARTTIM23_INTR_CH1 = 0x10,
++ ARTTIM2 = 0x57,
++ ARTTIM3 = 0x57,
++ DRWTIM23 = 0x58,
++ DRWTIM2 = 0x58,
++ BRST = 0x59,
++ DRWTIM3 = 0x5b,
++ BMIDECR0 = 0x70,
++ MRDMODE = 0x71,
++ MRDMODE_INTR_CH0 = 0x04,
++ MRDMODE_INTR_CH1 = 0x08,
++ MRDMODE_BLK_CH0 = 0x10,
++ MRDMODE_BLK_CH1 = 0x20,
++ BMIDESR0 = 0x72,
++ UDIDETCR0 = 0x73,
++ DTPR0 = 0x74,
++ BMIDECR1 = 0x78,
++ BMIDECSR = 0x79,
++ BMIDESR1 = 0x7A,
++ UDIDETCR1 = 0x7B,
++ DTPR1 = 0x7C
++};
++
++/* Phee Phy Pho Phum */
++
++static void cmd64x_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++static void cmd648_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 r;
++
++ /* Check cable detect bits */
++ pci_read_config_byte(pdev, BMIDECSR, &r);
++ if (r & (1 << ap->hard_port_no))
++ ap->cbl = ATA_CBL_PATA80;
++ else
++ ap->cbl = ATA_CBL_PATA40;
++
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * cmd64x_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup.
++ */
++
++static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct ata_timing t;
++ const unsigned long T = 1000000 / 33;
++ const u8 setup_data[] = { 0x40, 0x40, 0x40, 0x80, 0x00 };
++
++ u8 reg;
++
++ /* Port layout is not logical so use a table */
++ const u8 arttim_port[2][2] = {
++ { ARTTIM0, ARTTIM1 },
++ { ARTTIM23, ARTTIM23 }
++ };
++ const u8 drwtim_port[2][2] = {
++ { DRWTIM0, DRWTIM1 },
++ { DRWTIM2, DRWTIM3 }
++ };
++
++ int arttim = arttim_port[ap->hard_port_no][adev->devno];
++ int drwtim = drwtim_port[ap->hard_port_no][adev->devno];
++
++
++ if (ata_timing_compute(adev, adev->pio_mode, &t, T, 0) < 0) {
++ printk(KERN_ERR DRV_NAME ": mome computation failed.\n");
++ return;
++ }
++ if (ap->hard_port_no) {
++ /* Slave has shared address setup */
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++
++ if (pair) {
++ struct ata_timing tp;
++ ata_timing_compute(pair, pair->pio_mode, &tp, T, 0);
++ ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
++ }
++ }
++
++ printk(KERN_DEBUG DRV_NAME ": active %d recovery %d setup %d.\n",
++ t.active, t.recover, t.setup);
++ if (t.recover > 16) {
++ t.active += t.recover - 16;
++ t.recover = 16;
++ }
++ if (t.active > 16)
++ t.active = 16;
++
++ /* Now convert the clocks into values we can actually stuff into
++ the chip */
++
++ if (t.recover > 1)
++ t.recover--;
++ else
++ t.recover = 15;
++
++ if (t.setup > 4)
++ t.setup = 0xC0;
++ else
++ t.setup = setup_data[t.setup];
++
++ t.active &= 0x0F; /* 0 = 16 */
++
++ /* Load setup timing */
++ pci_read_config_byte(pdev, arttim, &reg);
++ reg &= 0x3F;
++ reg |= t.setup;
++ pci_write_config_byte(pdev, arttim, reg);
++
++ /* Load active/recovery */
++ pci_write_config_byte(pdev, drwtim, (t.active << 4) | t.recover);
++}
++
++/**
++ * cmd64x_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the DMA mode setup.
++ */
++
++static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 regU, regD;
++
++ int pciU = UDIDETCR0 + 8 * ap->hard_port_no;
++ int pciD = BMIDESR0 + 8 * ap->hard_port_no;
++ int shift = 2 * adev->devno;
++ const u8 udma_data[] = { 0x31, 0x21, 0x11, 0x25, 0x15, 0x05 };
++ const u8 mwdma_data[] = { 0x30, 0x20, 0x10 };
++
++ pci_read_config_byte(pdev, pciD, &regD);
++ pci_read_config_byte(pdev, pciU, &regU);
++
++ regD &= ~(0x20 << shift);
++ regU &= ~(0x35 << shift);
++
++ if (adev->dma_mode >= XFER_UDMA_0)
++ regU |= udma_data[adev->dma_mode - XFER_UDMA_0] << shift;
++ else
++ regD |= mwdma_data[adev->dma_mode - XFER_MW_DMA_0] << shift;
++
++ regD |= 0x20 << adev->devno;
++
++ pci_write_config_byte(pdev, pciU, regU);
++ pci_write_config_byte(pdev, pciD, regD);
++}
++
++/**
++ * cmd648_dma_stop - DMA stop callback
++ * @qc: Command in progress
++ *
++ * DMA has completed.
++ */
++
++static void cmd648_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 dma_intr;
++ int dma_reg = ap->hard_port_no ? ARTTIM23_INTR_CH1 : CFR_INTR_CH0;
++ int dma_mask = ap->hard_port_no ? ARTTIM2 : CFR;
++
++ ata_bmdma_stop(qc);
++
++ pci_read_config_byte(pdev, dma_reg, &dma_intr);
++ pci_write_config_byte(pdev, dma_reg, dma_intr | dma_mask);
++}
++
++/**
++ * cmd646r1_dma_stop - DMA stop callback
++ * @qc: Command in progress
++ *
++ * Stub for now while investigating the r1 quirk in the old driver.
++ */
++
++static void cmd646r1_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ ata_bmdma_stop(qc);
++}
++
++static struct scsi_host_template cmd64x_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations cmd64x_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cmd64x_set_piomode,
++ .set_dmamode = cmd64x_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = cmd64x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations cmd646r1_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cmd64x_set_piomode,
++ .set_dmamode = cmd64x_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = cmd64x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = cmd646r1_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations cmd648_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cmd64x_set_piomode,
++ .set_dmamode = cmd64x_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = cmd648_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = cmd648_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ u32 class_rev;
++
++ static struct ata_port_info cmd_info[6] = {
++ { /* CMD 643 - no UDMA */
++ .sht = &cmd64x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &cmd64x_port_ops
++ },
++ { /* CMD 646 with broken UDMA */
++ .sht = &cmd64x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &cmd64x_port_ops
++ },
++ { /* CMD 646 with working UDMA */
++ .sht = &cmd64x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA1,
++ .port_ops = &cmd64x_port_ops
++ },
++ { /* CMD 646 rev 1 */
++ .sht = &cmd64x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &cmd646r1_port_ops
++ },
++ { /* CMD 648 */
++ .sht = &cmd64x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA2,
++ .port_ops = &cmd648_port_ops
++ },
++ { /* CMD 649 */
++ .sht = &cmd64x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA3,
++ .port_ops = &cmd648_port_ops
++ }
++ };
++ static struct ata_port_info *port_info[2], *info;
++ u8 mrdmode;
++
++ info = &cmd_info[id->driver_data];
++
++ pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
++ class_rev &= 0xFF;
++
++ if (id->driver_data == 0) /* 643 */
++ ata_pci_clear_simplex(pdev);
++
++ if (pdev->device == PCI_DEVICE_ID_CMD_646) {
++ /* Does UDMA work ? */
++ if (class_rev > 4)
++ info = &cmd_info[2];
++ /* Early rev with other problems ? */
++ else if (class_rev == 1)
++ info = &cmd_info[3];
++ }
++
++ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
++ pci_read_config_byte(pdev, MRDMODE, &mrdmode);
++ mrdmode &= ~ 0x30; /* IRQ set up */
++ mrdmode |= 0x02; /* Memory read line enable */
++ pci_write_config_byte(pdev, MRDMODE, mrdmode);
++
++ /* Force PIO 0 here.. */
++
++ /* PPC specific fixup copied from old driver */
++#ifdef CONFIG_PPC
++ pci_write_config_byte(pdev, UDIDETCR0, 0xF0);
++#endif
++
++ port_info[0] = port_info[1] = info;
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static struct pci_device_id cmd64x[] = {
++ { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_643, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
++ { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_648, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
++ { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_649, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
++ { 0, },
++};
++
++static struct pci_driver cmd64x_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = cmd64x,
++ .probe = cmd64x_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init cmd64x_init(void)
++{
++ return pci_register_driver(&cmd64x_pci_driver);
++}
++
++
++static void __exit cmd64x_exit(void)
++{
++ pci_unregister_driver(&cmd64x_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for CMD64x series PATA controllers");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, cmd64x);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(cmd64x_init);
++module_exit(cmd64x_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cs5520.c linux-2.6.16-rc4/drivers/scsi/pata_cs5520.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cs5520.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_cs5520.c 2006-02-20 13:17:11.000000000 +0000
+@@ -0,0 +1,322 @@
++/*
++ * IDE tuning and bus mastering support for the CS5510/CS5520
++ * chipsets
++ *
++ * The CS5510/CS5520 are slightly unusual devices. Unlike the
++ * typical IDE controllers they do bus mastering with the drive in
++ * PIO mode and smarter silicon.
++ *
++ * The practical upshot of this is that we must always tune the
++ * drive for the right PIO mode. We must also ignore all the blacklists
++ * and the drive bus mastering DMA information. Also to confuse matters
++ * further we can do DMA on PIO only drives.
++ *
++ * DMA on the 5510 also requires we disable_hlt() during DMA on early
++ * revisions.
++ *
++ * *** This driver is strictly experimental ***
++ *
++ * (c) Copyright Red Hat Inc 2002
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License as published by the
++ * Free Software Foundation; either version 2, or (at your option) any
++ * later version.
++ *
++ * 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.
++ *
++ * Documentation:
++ * Not publically available.
++ */
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "cs5520"
++#define DRV_VERSION "0.4"
++
++struct pio_clocks
++{
++ int address;
++ int assert;
++ int recovery;
++};
++
++static struct pio_clocks cs5520_pio_clocks[]={
++ {3, 6, 11},
++ {2, 5, 6},
++ {1, 4, 3},
++ {1, 3, 2},
++ {1, 2, 1}
++};
++
++/**
++ * cs5520_set_timings - program PIO timings
++ * @ap: ATA port
++ * @adev: ATA device
++ *
++ * Program the PIO mode timings for the controller according to the pio
++ * clocking table.
++ */
++
++static void cs5520_set_timings(struct ata_port *ap, struct ata_device *adev, int pio)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int slave = adev->devno;
++
++ pio -= XFER_PIO_0;
++
++ /* Channel command timing */
++ pci_write_config_byte(pdev, 0x62 + ap->hard_port_no,
++ (cs5520_pio_clocks[pio].recovery << 4) |
++ (cs5520_pio_clocks[pio].assert));
++ /* FIXME: should these use address ? */
++ /* Read command timing */
++ pci_write_config_byte(pdev, 0x64 + 4*ap->hard_port_no + slave,
++ (cs5520_pio_clocks[pio].recovery << 4) |
++ (cs5520_pio_clocks[pio].assert));
++ /* Write command timing */
++ pci_write_config_byte(pdev, 0x66 + 4*ap->hard_port_no + slave,
++ (cs5520_pio_clocks[pio].recovery << 4) |
++ (cs5520_pio_clocks[pio].assert));
++}
++
++/**
++ * cs5520_enable_dma - turn on DMA bits
++ *
++ * Turn on the DMA bits for this disk. Needed because the BIOS probably
++ * has not done the work for us. Belongs in the core SATA code.
++ */
++
++static int cs5520_enable_dma(struct ata_port *ap, struct ata_device *adev)
++{
++ /* Set the DMA enable/disable flag */
++ u8 reg = inb(ap->ioaddr.bmdma_addr + 0x02);
++ reg |= 1<<(adev->devno + 5);
++ outb(reg, ap->ioaddr.bmdma_addr + 0x02);
++}
++
++/**
++ * cs5520_set_dmamode - program DMA timings
++ * @ap: ATA port
++ * @adev: ATA device
++ *
++ * Program the DMA mode timings for the controller according to the pio
++ * clocking table. Note that this device sets the DMA timings to PIO
++ * mode values. This may seem bizarre but the 5520 architecture talks
++ * PIO mode to the disk and DMA mode to the controller so the underlying
++ * transfers are PIO timed.
++ */
++
++static void cs5520_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static const int dma_xlate[3] = { XFER_PIO_0, XFER_PIO_3, XFER_PIO_4 };
++ cs5520_set_timings(ap, adev, dma_xlate[adev->dma_mode]);
++ cs5520_enable_dma(ap, adev);
++}
++
++/**
++ * cs5520_set_piomode - program PIO timings
++ * @ap: ATA port
++ * @adev: ATA device
++ *
++ * Program the PIO mode timings for the controller according to the pio
++ * clocking table. We know pio_mode will equal dma_mode because of the
++ * CS5520 architecture. At least once we turned DMA on and wrote a
++ * mode setter.
++ */
++
++static void cs5520_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ cs5520_set_timings(ap, adev, adev->pio_mode);
++}
++
++static struct scsi_host_template cs5520_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations cs5520_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cs5520_set_piomode,
++ .set_dmamode = cs5520_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static int __devinit cs5520_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ u8 pcicfg;
++ static struct ata_probe_ent probe[2];
++ int ports = 0;
++
++ pci_read_config_byte(dev, 0x60, &pcicfg);
++
++ /* Check if the ATA ports are enabled */
++ if ((pcicfg & 3) == 0)
++ return -ENODEV;
++
++ if ((pcicfg & 0x40) == 0) {
++ printk(KERN_WARNING DRV_NAME ": DMA mode disabled. Enabling.\n");
++ pci_write_config_byte(dev, 0x60, pcicfg | 0x40);
++ }
++
++ /* Perform set up for DMA */
++ if (pci_enable_device_bars(dev, 1<<2)) {
++ printk(KERN_ERR DRV_NAME ": unable to configure BAR2.\n");
++ return -ENODEV;
++ }
++ pci_set_master(dev);
++ if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
++ printk(KERN_ERR DRV_NAME ": unable to configure DMA mask.\n");
++ return -ENODEV;
++ }
++ if (pci_set_consistent_dma_mask(dev, DMA_32BIT_MASK)) {
++ printk(KERN_ERR DRV_NAME ": unable to configure consistent DMA mask.\n");
++ return -ENODEV;
++ }
++
++ /* We have to do our own plumbing as the PCI setup for this
++ chipset is non-standard so we can't punt to the libata code */
++
++ INIT_LIST_HEAD(&probe[0].node);
++ probe[0].dev = pci_dev_to_dev(dev);
++ probe[0].port_ops = &cs5520_port_ops;
++ probe[0].sht = &cs5520_sht;
++ probe[0].pio_mask = 0x1F;
++ probe[0].mwdma_mask = id->driver_data;
++ probe[0].irq = 14;
++ probe[0].irq_flags = SA_SHIRQ;
++ probe[0].host_flags = ATA_FLAG_SLAVE_POSS;
++ probe[0].legacy_mode = 1;
++ probe[0].n_ports = 1;
++ probe[0].port[0].cmd_addr = 0x1F0;
++ probe[0].port[0].ctl_addr = 0x3F6;
++ probe[0].port[0].altstatus_addr = 0x3F6;
++ probe[0].port[0].bmdma_addr = pci_resource_start(dev, 2);
++
++ /* The secondary lurks at different addresses but is otherwise
++ the same beastie */
++
++ probe[1] = probe[0];
++ INIT_LIST_HEAD(&probe[1].node);
++ probe[1].irq = 15;
++ probe[1].hard_port_no = 1;
++ probe[1].port[0].cmd_addr = 0x170;
++ probe[1].port[0].ctl_addr = 0x376;
++ probe[1].port[0].altstatus_addr = 0x376;
++ probe[1].port[0].bmdma_addr = pci_resource_start(dev, 2) + 8;
++
++ /* Let libata fill in the port details */
++ ata_std_ports(&probe[0].port[0]);
++ ata_std_ports(&probe[1].port[0]);
++
++ /* Now add the ports that are active */
++ if (pcicfg & 1)
++ ports += ata_device_add(&probe[0]);
++ if (pcicfg & 2)
++ ports += ata_device_add(&probe[1]);
++ if (ports)
++ return 0;
++ return -ENODEV;
++}
++
++/**
++ * cs5520_remove_one - device unload
++ * @pdev: PCI device being removed
++ *
++ * Handle an unplug/unload event for a PCI device. Unload the
++ * PCI driver but do not use the default handler as we manage
++ * resources ourself and *MUST NOT* disable the device as it has
++ * other functions.
++ */
++
++static void __devexit cs5520_remove_one(struct pci_dev *pdev)
++{
++ struct device *dev = pci_dev_to_dev(pdev);
++ struct ata_host_set *host_set = dev_get_drvdata(dev);
++
++ ata_host_set_remove(host_set);
++ dev_set_drvdata(dev, NULL);
++}
++
++/* For now keep DMA off. We can set it for all but A rev CS5510 once the
++ core ATA code can handle it */
++
++static struct pci_device_id pata_cs5520[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5510), },
++ { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520), },
++ { 0, },
++};
++
++static struct pci_driver cs5520_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = pata_cs5520,
++ .probe = cs5520_init_one,
++ .remove = cs5520_remove_one
++};
++
++
++static int __init cs5520_init(void)
++{
++ return pci_register_driver(&cs5520_pci_driver);
++}
++
++static void __exit cs5520_exit(void)
++{
++ pci_unregister_driver(&cs5520_pci_driver);
++}
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Cyrix CS5510/5520");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, pata_cs5520);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(cs5520_init);
++module_exit(cs5520_exit);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cs5530.c linux-2.6.16-rc4/drivers/scsi/pata_cs5530.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cs5530.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_cs5530.c 2006-02-16 15:43:34.000000000 +0000
+@@ -0,0 +1,340 @@
++/*
++ * pata-cs5530.c - CS5530 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * based upon cs5530.c by Mark Lord.
++ *
++ * 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.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ * Loosely based on the piix & svwks drivers.
++ *
++ * Documentation:
++ * Available from AMD web site.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "cs5530"
++#define DRV_VERSION "0.3"
++
++/**
++ * cs5530_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Set our PIO requirements. This is fairly simple on the CS5530
++ * chips.
++ */
++
++static void cs5530_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ static unsigned int cs5530_pio_timings[2][5] = {
++ {0x00009172, 0x00012171, 0x00020080, 0x00032010, 0x00040010},
++ {0xd1329172, 0x71212171, 0x30200080, 0x20102010, 0x00100010}
++ };
++ unsigned long base = ( ap->ioaddr.bmdma_addr & ~0x0F) + 0x20 + 0x10 * ap->hard_port_no;
++ u32 tuning;
++ int format;
++
++ /* Find out which table to use */
++ tuning = inl(base + 0x04);
++ format = (tuning & 0x80000000UL) ? 1 : 0;
++
++ /* Now load the right timing register */
++ if (adev->devno)
++ base += 0x08;
++
++ outl(cs5530_pio_timings[format][adev->pio_mode - XFER_PIO_0], base);
++}
++
++/**
++ * cs5530_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * We cannot mix MWDMA and UDMA without reloading timings each switch
++ * master to slave. We track the last DMA setup in order to minimise
++ * reloads.
++ */
++
++static void cs5530_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned long base = ( ap->ioaddr.bmdma_addr & ~0x0F) + 0x20 + 0x10 * ap->hard_port_no;
++ u32 tuning, timing = 0;
++ u8 reg;
++
++ /* Find out which table to use */
++ tuning = inl(base + 0x04);
++
++ switch(adev->dma_mode) {
++ case XFER_UDMA_0:
++ timing = 0x00921250;break;
++ case XFER_UDMA_1:
++ timing = 0x00911140;break;
++ case XFER_UDMA_2:
++ timing = 0x00911030;break;
++ case XFER_MW_DMA_0:
++ timing = 0x00077771;break;
++ case XFER_MW_DMA_1:
++ timing = 0x00012121;break;
++ case XFER_MW_DMA_2:
++ timing = 0x00002020;break;
++ default:
++ BUG();
++ }
++ /* Merge in the PIO format bit */
++ timing |= (tuning & 0x80000000UL);
++ if (adev->devno == 0) /* Master */
++ outl(timing, base + 0x04);
++ else {
++ if (timing & 0x00100000)
++ tuning |= 0x00100000; /* UDMA for both */
++ else
++ tuning &= ~0x00100000; /* MWDMA for both */
++ outl(tuning, base + 0x04);
++ outl(timing, base + 0x0C);
++ }
++
++ /* Set the DMA capable bit in the BMDMA area */
++ reg = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
++ reg |= (1 << (5 + adev->devno));
++ outb(reg, ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
++
++ /* Remember the last DMA setup we did */
++
++ ap->private_data = adev;
++}
++
++/**
++ * cs5530_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings if
++ * neccessary. Specifically we have a problem that there is only
++ * one MWDMA/UDMA bit.
++ */
++
++static int cs5530_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ struct ata_device *prev = ap->private_data;
++
++ /* See if the DMA settings could be wrong */
++ if (adev->dma_mode != 0 && adev != prev && prev != NULL) {
++ /* Maybe, but do the channels match MWDMA/UDMA ? */
++ if ((adev->dma_mode >= XFER_UDMA_0 && prev->dma_mode < XFER_UDMA_0) ||
++ (adev->dma_mode < XFER_UDMA_0 && prev->dma_mode >= XFER_UDMA_0))
++ /* Switch the mode bits */
++ cs5530_set_dmamode(ap, adev);
++ }
++
++ return ata_qc_issue_prot(qc);
++}
++
++static struct scsi_host_template cs5530_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations cs5530_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cs5530_set_piomode,
++ .set_dmamode = cs5530_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = cs5530_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * cs5530_init_one - Initialise a CS5530
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Install a driver for the newly found CS5530 companion chip. Most of
++ * this is just housekeeping. We have to set the chip up correctly and
++ * turn off various bits of emulation magic.
++ */
++
++static int cs5530_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ int compiler_warning_pointless_fix;
++ struct pci_dev *master_0 = NULL, *cs5530_0 = NULL;
++ static struct ata_port_info info = {
++ .sht = &cs5530_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x07,
++ .port_ops = &cs5530_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ dev = NULL;
++ while ((dev = pci_get_device(PCI_VENDOR_ID_CYRIX, PCI_ANY_ID, dev)) != NULL) {
++ switch (dev->device) {
++ case PCI_DEVICE_ID_CYRIX_PCI_MASTER:
++ master_0 = pci_dev_get(dev);
++ break;
++ case PCI_DEVICE_ID_CYRIX_5530_LEGACY:
++ cs5530_0 = pci_dev_get(dev);
++ break;
++ }
++ }
++ if (!master_0) {
++ printk(KERN_ERR DRV_NAME ": unable to locate PCI MASTER function\n");
++ goto fail_put;
++ }
++ if (!cs5530_0) {
++ printk(KERN_ERR DRV_NAME ": unable to locate CS5530 LEGACY function\n");
++ goto fail_put;
++ }
++
++ pci_set_master(cs5530_0);
++ compiler_warning_pointless_fix = pci_set_mwi(cs5530_0);
++
++ /*
++ * Set PCI CacheLineSize to 16-bytes:
++ * --> Write 0x04 into 8-bit PCI CACHELINESIZE reg of function 0 of the cs5530
++ *
++ * Note: This value is constant because the 5530 is only a Geode companion
++ */
++
++ pci_write_config_byte(cs5530_0, PCI_CACHE_LINE_SIZE, 0x04);
++
++ /*
++ * Disable trapping of UDMA register accesses (Win98 hack):
++ * --> Write 0x5006 into 16-bit reg at offset 0xd0 of function 0 of the cs5530
++ */
++
++ pci_write_config_word(cs5530_0, 0xd0, 0x5006);
++
++ /*
++ * Bit-1 at 0x40 enables MemoryWriteAndInvalidate on internal X-bus:
++ * The other settings are what is necessary to get the register
++ * into a sane state for IDE DMA operation.
++ */
++
++ pci_write_config_byte(master_0, 0x40, 0x1e);
++
++ /*
++ * Set max PCI burst size (16-bytes seems to work best):
++ * 16bytes: set bit-1 at 0x41 (reg value of 0x16)
++ * all others: clear bit-1 at 0x41, and do:
++ * 128bytes: OR 0x00 at 0x41
++ * 256bytes: OR 0x04 at 0x41
++ * 512bytes: OR 0x08 at 0x41
++ * 1024bytes: OR 0x0c at 0x41
++ */
++
++ pci_write_config_byte(master_0, 0x41, 0x14);
++
++ /*
++ * These settings are necessary to get the chip
++ * into a sane state for IDE DMA operation.
++ */
++
++ pci_write_config_byte(master_0, 0x42, 0x00);
++ pci_write_config_byte(master_0, 0x43, 0xc1);
++
++ pci_dev_put(master_0);
++ pci_dev_put(cs5530_0);
++
++ /* Now kick off ATA set up */
++ return ata_pci_init_one(dev, port_info, 2);
++
++fail_put:
++ if (master_0)
++ pci_dev_put(master_0);
++ if (cs5530_0)
++ pci_dev_put(cs5530_0);
++ return -ENODEV;
++}
++
++static struct pci_device_id cs5530[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_IDE), },
++ { 0, },
++};
++
++static struct pci_driver cs5530_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = cs5530,
++ .probe = cs5530_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init cs5530_init(void)
++{
++ return pci_register_driver(&cs5530_pci_driver);
++}
++
++
++static void __exit cs5530_exit(void)
++{
++ pci_unregister_driver(&cs5530_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the Cyrix/NS/AMD 5530");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, cs5530);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(cs5530_init);
++module_exit(cs5530_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cs5535.c linux-2.6.16-rc4/drivers/scsi/pata_cs5535.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cs5535.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_cs5535.c 2006-02-16 15:37:21.000000000 +0000
+@@ -0,0 +1,286 @@
++/*
++ * pata-cs5535.c - CS5535 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * based upon cs5535.c from AMD <Jens.Altmann@amd.com> as cleaned up and
++ * made readable and Linux style by Wolfgang Zuleger <wolfgang.zuleger@gmx.de
++ * and Alexander Kiausch <alex.kiausch@t-online.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.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ * Loosely based on the piix & svwks drivers.
++ *
++ * Documentation:
++ * Available from AMD web site.
++ * TODO
++ * Review errata to see if serializing is neccessary
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <asm/msr.h>
++
++#define DRV_NAME "cs5535"
++#define DRV_VERSION "0.2.1"
++
++/*
++ * The Geode (Aka Athlon GX now) uses an internal MSR based
++ * bus system for control. Demented but there you go.
++ */
++
++#define MSR_ATAC_BASE 0x51300000
++#define ATAC_GLD_MSR_CAP (MSR_ATAC_BASE+0)
++#define ATAC_GLD_MSR_CONFIG (MSR_ATAC_BASE+0x01)
++#define ATAC_GLD_MSR_SMI (MSR_ATAC_BASE+0x02)
++#define ATAC_GLD_MSR_ERROR (MSR_ATAC_BASE+0x03)
++#define ATAC_GLD_MSR_PM (MSR_ATAC_BASE+0x04)
++#define ATAC_GLD_MSR_DIAG (MSR_ATAC_BASE+0x05)
++#define ATAC_IO_BAR (MSR_ATAC_BASE+0x08)
++#define ATAC_RESET (MSR_ATAC_BASE+0x10)
++#define ATAC_CH0D0_PIO (MSR_ATAC_BASE+0x20)
++#define ATAC_CH0D0_DMA (MSR_ATAC_BASE+0x21)
++#define ATAC_CH0D1_PIO (MSR_ATAC_BASE+0x22)
++#define ATAC_CH0D1_DMA (MSR_ATAC_BASE+0x23)
++#define ATAC_PCI_ABRTERR (MSR_ATAC_BASE+0x24)
++
++#define ATAC_BM0_CMD_PRIM 0x00
++#define ATAC_BM0_STS_PRIM 0x02
++#define ATAC_BM0_PRD 0x04
++
++#define CS5535_CABLE_DETECT 0x48
++
++#define CS5535_BAD_PIO(timings) ( (timings&~0x80000000UL)==0x00009172 )
++
++/**
++ * cs5535_cable_detect - detect cable type
++ * @ap: Port to detect on
++ *
++ * Perform cable detection for ATA66 capable cable. Return a libata
++ * cable type.
++ */
++
++static int cs5535_cable_detect(struct ata_port *ap)
++{
++ u8 cable;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_byte(pdev, CS5535_CABLE_DETECT, &cable);
++ if (cable & 1)
++ return ATA_CBL_PATA80;
++ else
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * cs5535_phy_reset - reset/probe
++ * @ap: Port to reset
++ *
++ * Reset and configure a port
++ */
++
++static void cs5535_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = cs5535_cable_detect(ap);
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * cs5535_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Set our PIO requirements. The CS5535 is pretty clean about all this
++ */
++
++static void cs5535_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u16 pio_timings[5] = {
++ 0xF7F4, 0x53F3, 0x13F1, 0x5131, 0x1131
++ };
++ static u16 pio_cmd_timings[5] = {
++ 0xF7F4, 0x53F3, 0x13F1, 0x5131, 0x1131
++ };
++ u32 reg, dummy;
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++
++ int mode = adev->pio_mode - XFER_PIO_0;
++ int cmdmode = mode;
++
++ /* Command timing has to be for the lowest of the pair of devices */
++ if (pair) {
++ int pairmode = pair->pio_mode - XFER_PIO_0;
++ cmdmode = min(mode, pairmode);
++ /* Write the other drive timing register if it changed */
++ if (cmdmode < pairmode)
++ wrmsr(ATAC_CH0D0_PIO + 2 * pair->devno,
++ pio_cmd_timings[cmdmode] << 16 | pio_timings[pairmode], 0);
++ }
++ /* Write the drive timing register */
++ wrmsr(ATAC_CH0D0_PIO + 2 * adev->devno,
++ pio_cmd_timings[cmdmode] << 16 | pio_timings[mode], 0);
++
++ /* Set the PIO "format 1" bit in the DMA timing register */
++ rdmsr(ATAC_CH0D0_DMA + 2 * adev->devno, reg, dummy);
++ wrmsr(ATAC_CH0D0_DMA + 2 * adev->devno, reg | 0x80000000UL, 0);
++}
++
++/**
++ * cs5535_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ */
++
++static void cs5535_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u32 udma_timings[5] = { 0x7F7436A1, 0x7F733481, 0x7F723261, 0x7F713161, 0x7F703061 };
++ static u32 mwdma_timings[3] = { 0x7F0FFFF3, 0x7F035352, 0x7F024241 };
++ u32 reg, dummy;
++ int mode = adev->dma_mode;
++
++ rdmsr(ATAC_CH0D0_DMA + 2 * adev->devno, reg, dummy);
++ reg &= 0x80000000UL;
++ if (mode >= XFER_UDMA_0)
++ reg |= udma_timings[mode - XFER_UDMA_0];
++ else
++ reg |= mwdma_timings[mode - XFER_MW_DMA_0];
++ wrmsr(ATAC_CH0D0_DMA + 2 * adev->devno, reg, 0);
++}
++
++static struct scsi_host_template cs5535_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations cs5535_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cs5535_set_piomode,
++ .set_dmamode = cs5535_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = cs5535_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * cs5535_init_one - Initialise a CS5530
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Install a driver for the newly found CS5530 companion chip. Most of
++ * this is just housekeeping. We have to set the chip up correctly and
++ * turn off various bits of emulation magic.
++ */
++
++static int cs5535_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &cs5535_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f,
++ .port_ops = &cs5535_port_ops
++ };
++ struct ata_port_info *ports[1] = { &info };
++
++ u32 timings, dummy;
++
++ /* Check the BIOS set the initial timing clock. If not set the
++ timings for PIO0 */
++ rdmsr(ATAC_CH0D0_PIO, timings, dummy);
++ if (CS5535_BAD_PIO(timings))
++ wrmsr(ATAC_CH0D0_PIO, 0xF7F4F7F4UL, 0);
++ rdmsr(ATAC_CH0D1_PIO, timings, dummy);
++ if (CS5535_BAD_PIO(timings))
++ wrmsr(ATAC_CH0D1_PIO, 0xF7F4F7F4UL, 0);
++ return ata_pci_init_one(dev, ports, 1);
++}
++
++static struct pci_device_id cs5535[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_NS, 0x002D), },
++ { 0, },
++};
++
++static struct pci_driver cs5535_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = cs5535,
++ .probe = cs5535_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init cs5535_init(void)
++{
++ return pci_register_driver(&cs5535_pci_driver);
++}
++
++
++static void __exit cs5535_exit(void)
++{
++ pci_unregister_driver(&cs5535_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox, Jens Altmann, Wolfgan Zuleger, Alexander Kiausch");
++MODULE_DESCRIPTION("low-level driver for the NS/AMD 5530");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, cs5535);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(cs5535_init);
++module_exit(cs5535_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cypress.c linux-2.6.16-rc4/drivers/scsi/pata_cypress.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_cypress.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_cypress.c 2006-02-16 15:37:46.000000000 +0000
+@@ -0,0 +1,215 @@
++/*
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_cypress"
++#define DRV_VERSION "0.1"
++
++/* here are the offset definitions for the registers */
++
++enum {
++ CY82_IDE_CMDREG = 0x04,
++ CY82_IDE_ADDRSETUP = 0x48,
++ CY82_IDE_MASTER_IOR = 0x4C,
++ CY82_IDE_MASTER_IOW = 0x4D,
++ CY82_IDE_SLAVE_IOR = 0x4E,
++ CY82_IDE_SLAVE_IOW = 0x4F,
++ CY82_IDE_MASTER_8BIT = 0x50,
++ CY82_IDE_SLAVE_8BIT = 0x51,
++
++ CY82_INDEX_PORT = 0x22,
++ CY82_DATA_PORT = 0x23,
++
++ CY82_INDEX_CTRLREG1 = 0x01,
++ CY82_INDEX_CHANNEL0 = 0x30,
++ CY82_INDEX_CHANNEL1 = 0x31,
++ CY82_INDEX_TIMEOUT = 0x32
++};
++
++/* Phee Phy Pho Phum */
++
++static void cy82c693_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * cy82c693_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup.
++ */
++
++static void cy82c693_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct ata_timing t;
++ const unsigned long T = 1000000 / 33;
++ short time_16, time_8;
++ u32 addr;
++
++ if (ata_timing_compute(adev, adev->pio_mode, &t, T, 1) < 0) {
++ printk(KERN_ERR DRV_NAME ": mome computation failed.\n");
++ return;
++ }
++
++ time_16 = FIT(t.recover, 0, 15) | (FIT(t.active, 0, 15) << 4);
++ time_8 = FIT(t.act8b, 0, 15) | (FIT(t.rec8b, 0, 15) << 4);
++
++ if (adev->devno == 0) {
++ pci_read_config_dword(pdev, CY82_IDE_ADDRSETUP, &addr);
++
++ addr &= ~0x0F; /* Mask bits */
++ addr |= FIT(t.setup, 0, 15);
++
++ pci_write_config_dword(pdev, CY82_IDE_ADDRSETUP, addr);
++ pci_write_config_byte(pdev, CY82_IDE_MASTER_IOR, time_16);
++ pci_write_config_byte(pdev, CY82_IDE_MASTER_IOW, time_16);
++ pci_write_config_byte(pdev, CY82_IDE_MASTER_8BIT, time_8);
++ } else {
++ pci_read_config_dword(pdev, CY82_IDE_ADDRSETUP, &addr);
++
++ addr &= ~0xF0; /* Mask bits */
++ addr |= (FIT(t.setup, 0, 15) << 4);
++
++ pci_write_config_dword(pdev, CY82_IDE_ADDRSETUP, addr);
++ pci_write_config_byte(pdev, CY82_IDE_SLAVE_IOR, time_16);
++ pci_write_config_byte(pdev, CY82_IDE_SLAVE_IOW, time_16);
++ pci_write_config_byte(pdev, CY82_IDE_SLAVE_8BIT, time_8);
++ }
++}
++
++/**
++ * cy82c693_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the DMA mode setup.
++ */
++
++static void cy82c693_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ int reg = CY82_INDEX_CHANNEL0 + ap->hard_port_no;
++
++ /* Be afraid, be very afraid. Magic registers in low I/O space */
++ outb(reg, 0x22);
++ outb(adev->dma_mode - XFER_MW_DMA_0, 0x23);
++
++ /* 0x50 gives the best behaviour on the Alpha's using this chip */
++ outb(CY82_INDEX_TIMEOUT, 0x22);
++ outb(0x50, 0x23);
++}
++
++static struct scsi_host_template cy82c693_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations cy82c693_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = cy82c693_set_piomode,
++ .set_dmamode = cy82c693_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = cy82c693_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &cy82c693_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &cy82c693_port_ops
++ };
++ static struct ata_port_info *port_info[1] = { &info };
++
++ /* Devfn 1 is the ATA primary. The secondary is magic and on devfn2. For the
++ moment we don't handle the secondary. FIXME */
++
++ if (PCI_FUNC(pdev->devfn) != 1)
++ return -ENODEV;
++
++ return ata_pci_init_one(pdev, port_info, 1);
++}
++
++static struct pci_device_id cy82c693[] = {
++ { PCI_VENDOR_ID_CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { 0, },
++};
++
++static struct pci_driver cy82c693_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = cy82c693,
++ .probe = cy82c693_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init cy82c693_init(void)
++{
++ return pci_register_driver(&cy82c693_pci_driver);
++}
++
++
++static void __exit cy82c693_exit(void)
++{
++ pci_unregister_driver(&cy82c693_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the CY82C693 PATA controller");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, cy82c693);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(cy82c693_init);
++module_exit(cy82c693_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_efar.c linux-2.6.16-rc4/drivers/scsi/pata_efar.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_efar.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_efar.c 2006-02-16 15:37:53.000000000 +0000
+@@ -0,0 +1,341 @@
++/*
++ * pata_efar.c - EFAR PIIX clone controller driver
++ *
++ * (C) 2005 Red Hat <alan@redhat.com>
++ *
++ * Some parts based on ata_piix.c by Jeff Garzik and others.
++ *
++ * The EFAR is a PIIX4 clone with UDMA66 support. Unlike the later
++ * Intel ICH controllers the EFAR widened the UDMA mode register bits
++ * and doesn't require the funky clock selection.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <linux/ata.h>
++
++#define DRV_NAME "pata_efar"
++#define DRV_VERSION "0.1"
++
++/**
++ * efar_cable_detect - check for 40/80 pin
++ * @ap: Port
++ *
++ * Perform cable detection for the EFAR ATA interface. This is
++ * different to the PIIX arrangement
++ */
++
++static int efar_cable_detect(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 tmp;
++
++ pci_read_config_byte(pdev, 0x47, &tmp);
++ if (tmp & (2 >> ap->hard_port_no))
++ return ATA_CBL_PATA40;
++ return ATA_CBL_PATA80;
++}
++
++/**
++ * efar_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void efar_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ const struct pci_bits efar_enable_bits[] = {
++ { 0x41U, 1U, 0x80UL, 0x80UL }, /* port 0 */
++ { 0x43U, 1U, 0x80UL, 0x80UL }, /* port 1 */
++ };
++
++ if (!pci_test_config_bits(pdev, &efar_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = efar_cable_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * efar_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: um
++ *
++ * Set PIO mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void efar_set_piomode (struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int pio = adev->pio_mode - XFER_PIO_0;
++ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
++ unsigned int idetm_port= ap->hard_port_no ? 0x42 : 0x40;
++ u16 idetm_data;
++ int control = 0;
++
++ /*
++ * See Intel Document 298600-004 for the timing programing rules
++ * for PIIX/ICH. The EFAR is a clone so very similar
++ */
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 0 },
++ { 2, 1 },
++ { 2, 3 }, };
++
++ if (pio > 2)
++ control |= 1; /* TIME1 enable */
++ if (ata_pio_need_iordy(adev)) /* PIO 3/4 require IORDY */
++ control |= 2; /* IE enable */
++ /* Intel specifies that the PPE functionality is for disk only */
++ if (adev->class == ATA_DEV_ATA)
++ control |= 4; /* PPE enable */
++
++ pci_read_config_word(dev, idetm_port, &idetm_data);
++
++ /* Enable PPE, IE and TIME as appropriate */
++
++ if (adev->devno == 0) {
++ idetm_data &= 0xCCF0;
++ idetm_data |= control;
++ idetm_data |= (timings[pio][0] << 12) |
++ (timings[pio][1] << 8);
++ } else {
++ int shift = 4 * ap->hard_port_no;
++ u8 slave_data;
++
++ idetm_data &= 0xCC0F;
++ idetm_data |= (control << 4);
++
++ /* Slave timing in seperate register */
++ pci_read_config_byte(dev, 0x44, &slave_data);
++ slave_data &= 0x0F << shift;
++ slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << shift;
++ pci_write_config_byte(dev, 0x44, slave_data);
++ }
++
++ idetm_data |= 0x4000; /* Ensure SITRE is enabled */
++ pci_write_config_word(dev, idetm_port, idetm_data);
++}
++
++/**
++ * efar_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ *
++ * Set UDMA/MWDMA mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void efar_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
++ u8 master_port = ap->hard_port_no ? 0x42 : 0x40;
++ u16 master_data;
++ u8 speed = adev->dma_mode;
++ int devid = adev->devno + 2 * ap->hard_port_no;
++ u8 udma_enable;
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 0 },
++ { 2, 1 },
++ { 2, 3 }, };
++
++ pci_read_config_word(dev, master_port, &master_data);
++ pci_read_config_byte(dev, 0x48, &udma_enable);
++
++ if (speed >= XFER_UDMA_0) {
++ unsigned int udma = adev->dma_mode - XFER_UDMA_0;
++ u16 udma_timing;
++
++ udma_enable |= (1 << devid);
++
++ /* Load the UDMA mode number */
++ pci_read_config_word(dev, 0x4A, &udma_timing);
++ udma_timing &= ~(7 << (4 * devid));
++ udma_timing |= udma << (4 * devid);
++ pci_write_config_word(dev, 0x4A, udma_timing);
++ } else {
++ /*
++ * MWDMA is driven by the PIO timings. We must also enable
++ * IORDY unconditionally along with TIME1. PPE has already
++ * been set when the PIO timing was set.
++ */
++ unsigned int mwdma = adev->dma_mode - XFER_MW_DMA_0;
++ unsigned int control;
++ u8 slave_data;
++ const unsigned int needed_pio[3] = {
++ XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
++ };
++ int pio = needed_pio[mwdma] - XFER_PIO_0;
++
++ control = 3; /* IORDY|TIME1 */
++
++ /* If the drive MWDMA is faster than it can do PIO then
++ we must force PIO into PIO0 */
++
++ if (adev->pio_mode < needed_pio[mwdma])
++ /* Enable DMA timing only */
++ control |= 8; /* PIO cycles in PIO0 */
++
++ if (adev->devno) { /* Slave */
++ master_data &= 0xFF4F; /* Mask out IORDY|TIME1|DMAONLY */
++ master_data |= control << 4;
++ pci_read_config_byte(dev, 0x44, &slave_data);
++ slave_data &= (0x0F + 0xE1 * ap->hard_port_no);
++ /* Load the matching timing */
++ slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << (ap->hard_port_no ? 4 : 0);
++ pci_write_config_byte(dev, 0x44, slave_data);
++ } else { /* Master */
++ master_data &= 0xCCF4; /* Mask out IORDY|TIME1|DMAONLY
++ and master timing bits */
++ master_data |= control;
++ master_data |=
++ (timings[pio][0] << 12) |
++ (timings[pio][1] << 8);
++ }
++ udma_enable &= ~(1 << devid);
++ pci_write_config_word(dev, master_port, master_data);
++ }
++ pci_write_config_byte(dev, 0x48, udma_enable);
++}
++
++static struct scsi_host_template efar_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static const struct ata_port_operations efar_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = efar_set_piomode,
++ .set_dmamode = efar_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = efar_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++
++/**
++ * efar_init_one - Register EFAR ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in efar_pci_tbl matching with @pdev
++ *
++ * Called from kernel PCI layer.
++ *
++ * LOCKING:
++ * Inherited from PCI layer (may sleep).
++ *
++ * RETURNS:
++ * Zero on success, or -ERRNO value.
++ */
++
++static int efar_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ static struct ata_port_info info = {
++ .sht = &efar_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma1-2 */
++ .udma_mask = 0x0f, /* UDMA 66 */
++ .port_ops = &efar_ops,
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev,
++ "version " DRV_VERSION "\n");
++
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id efar_pci_tbl[] = {
++ { 0x1055, 0x9130, PCI_ANY_ID, PCI_ANY_ID, },
++ { } /* terminate list */
++};
++
++static struct pci_driver efar_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = efar_pci_tbl,
++ .probe = efar_init_one,
++ .remove = ata_pci_remove_one,
++};
++
++static int __init efar_init(void)
++{
++ return pci_register_driver(&efar_pci_driver);
++}
++
++static void __exit efar_exit(void)
++{
++ pci_unregister_driver(&efar_pci_driver);
++}
++
++
++module_init(efar_init);
++module_exit(efar_exit);
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("SCSI low-level driver for EFAR PIIX clones");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, efar_pci_tbl);
++MODULE_VERSION(DRV_VERSION);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt34x.c linux-2.6.16-rc4/drivers/scsi/pata_hpt34x.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt34x.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_hpt34x.c 2006-02-16 15:38:47.000000000 +0000
+@@ -0,0 +1,206 @@
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "hpt34x"
++#define DRV_VERSION "0.1"
++
++/**
++ * hpt34x_bus_reset - reset the hpt34x bus
++ * @ap: ATA port to reset
++ *
++ * Perform the housekeeping when doing an ATA bus reeset. We just
++ * need to force the cable type.
++ */
++
++static void hpt34x_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA40;
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * hpt34x_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Set our PIO requirements. This is fairly simple on the HPT34x as
++ * all we have to do is clear the MWDMA and UDMA bits then load the
++ * mode number.
++ */
++
++static void hpt34x_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 r1, r2;
++ int dn = 2 * ap->hard_port_no + adev->devno;
++
++ pci_read_config_dword(pdev, 0x44, &r1);
++ pci_read_config_dword(pdev, 0x48, &r2);
++ /* Load the PIO timing number */
++ r1 &= ~(7 << (3 * dn));
++ r1 |= (adev->pio_mode - XFER_PIO_0) << (3 * dn);
++ r2 &= ~(0x11 << dn); /* Clear MWDMA and UDMA bits */
++
++ pci_write_config_dword(pdev, 0x44, r1);
++ pci_write_config_dword(pdev, 0x48, r2);
++}
++
++/**
++ * hpt34x_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * Set up the channel for MWDMA or UDMA modes. Much the same as with
++ * PIO, load the mode number and then set MWDMA or UDMA flag.
++ */
++
++static void hpt34x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 r1, r2;
++ int dn = 2 * ap->hard_port_no + adev->devno;
++ int mode_num = adev->dma_mode & 0x0F;
++
++ pci_read_config_dword(pdev, 0x44, &r1);
++ pci_read_config_dword(pdev, 0x48, &r2);
++ /* Load the timing number */
++ r1 &= ~(7 << (3 * dn));
++ r1 |= (mode_num << (3 * dn));
++ r2 &= ~(0x11 << dn); /* Clear MWDMA and UDMA bits */
++
++ if (adev->dma_mode >= XFER_UDMA_0)
++ r2 |= 0x01 << dn; /* Ultra mode */
++ else
++ r2 |= 0x10 << dn; /* MWDMA */
++
++ pci_write_config_dword(pdev, 0x44, r1);
++ pci_write_config_dword(pdev, 0x48, r2);
++}
++
++static struct scsi_host_template hpt34x_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations hpt34x_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt34x_set_piomode,
++ .set_dmamode = hpt34x_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt34x_phy_reset,
++
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * hpt34x_init_one - Initialise an HPT343/363
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Perform basic initialisation. The chip has a quirk that it won't
++ * function unless it is at XX00. The old ATA driver touched this up
++ * but we leave it for pci quirks to do properly.
++ */
++
++static int hpt34x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &hpt34x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x07,
++ .port_ops = &hpt34x_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++ u16 cmd;
++
++ /* Initialize the board */
++ pci_write_config_word(dev, 0x80, 0x00);
++ /* Check if it is a 343 or a 363. 363 has COMMAND_MEMORY set */
++ pci_read_config_word(dev, PCI_COMMAND, &cmd);
++ if (cmd & PCI_COMMAND_MEMORY)
++ pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xF0);
++ else
++ pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x20);
++
++ /* Now kick off ATA set up */
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id hpt34x[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT343), },
++ { 0, },
++};
++
++static struct pci_driver hpt34x_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = hpt34x,
++ .probe = hpt34x_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init hpt34x_init(void)
++{
++ return pci_register_driver(&hpt34x_pci_driver);
++}
++
++
++static void __exit hpt34x_exit(void)
++{
++ pci_unregister_driver(&hpt34x_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the Highpoint HPT343/363");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, hpt34x);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(hpt34x_init);
++module_exit(hpt34x_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt366.c linux-2.6.16-rc4/drivers/scsi/pata_hpt366.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt366.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_hpt366.c 2006-02-16 15:45:36.000000000 +0000
+@@ -0,0 +1,479 @@
++/*
++ * Libata driver for the highpoint 366 and 368 UDMA66 ATA controllers.
++ *
++ * This driver is heavily based upon:
++ *
++ * linux/drivers/ide/pci/hpt366.c Version 0.36 April 25, 2003
++ *
++ * Copyright (C) 1999-2003 Andre Hedrick <andre@linux-ide.org>
++ * Portions Copyright (C) 2001 Sun Microsystems, Inc.
++ * Portions Copyright (C) 2003 Red Hat Inc
++ *
++ *
++ * TODO
++ * Maybe PLL mode
++ * Look into engine reset on timeout errors. Should not be
++ * required.
++ */
++
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "hpt36x"
++#define DRV_VERSION "0.2"
++
++struct hpt_clock {
++ u8 xfer_speed;
++ u32 timing;
++};
++
++/* key for bus clock timings
++ * bit
++ * 0:3 data_high_time. inactive time of DIOW_/DIOR_ for PIO and MW
++ * DMA. cycles = value + 1
++ * 4:8 data_low_time. active time of DIOW_/DIOR_ for PIO and MW
++ * DMA. cycles = value + 1
++ * 9:12 cmd_high_time. inactive time of DIOW_/DIOR_ during task file
++ * register access.
++ * 13:17 cmd_low_time. active time of DIOW_/DIOR_ during task file
++ * register access.
++ * 18:21 udma_cycle_time. clock freq and clock cycles for UDMA xfer.
++ * during task file register access.
++ * 22:24 pre_high_time. time to initialize 1st cycle for PIO and MW DMA
++ * xfer.
++ * 25:27 cmd_pre_high_time. time to initialize 1st PIO cycle for task
++ * register access.
++ * 28 UDMA enable
++ * 29 DMA enable
++ * 30 PIO_MST enable. if set, the chip is in bus master mode during
++ * PIO.
++ * 31 FIFO enable.
++ */
++
++static struct chipset_bus_clock_list_entry hpt366_40[] = {
++ { XFER_UDMA_4, 0x900fd943 },
++ { XFER_UDMA_3, 0x900ad943 },
++ { XFER_UDMA_2, 0x900bd943 },
++ { XFER_UDMA_1, 0x9008d943 },
++ { XFER_UDMA_0, 0x9008d943 },
++
++ { XFER_MW_DMA_2, 0xa008d943 },
++ { XFER_MW_DMA_1, 0xa010d955 },
++ { XFER_MW_DMA_0, 0xa010d9fc },
++
++ { XFER_PIO_4, 0xc008d963 },
++ { XFER_PIO_3, 0xc010d974 },
++ { XFER_PIO_2, 0xc010d997 },
++ { XFER_PIO_1, 0xc010d9c7 },
++ { XFER_PIO_0, 0xc018d9d9 },
++ { 0, 0x0120d9d9 }
++};
++
++static struct chipset_bus_clock_list_entry hpt366_33[] = {
++ { XFER_UDMA_4, 0x90c9a731 },
++ { XFER_UDMA_3, 0x90cfa731 },
++ { XFER_UDMA_2, 0x90caa731 },
++ { XFER_UDMA_1, 0x90cba731 },
++ { XFER_UDMA_0, 0x90c8a731 },
++
++ { XFER_MW_DMA_2, 0xa0c8a731 },
++ { XFER_MW_DMA_1, 0xa0c8a732 }, /* 0xa0c8a733 */
++ { XFER_MW_DMA_0, 0xa0c8a797 },
++
++ { XFER_PIO_4, 0xc0c8a731 },
++ { XFER_PIO_3, 0xc0c8a742 },
++ { XFER_PIO_2, 0xc0d0a753 },
++ { XFER_PIO_1, 0xc0d0a7a3 }, /* 0xc0d0a793 */
++ { XFER_PIO_0, 0xc0d0a7aa }, /* 0xc0d0a7a7 */
++ { 0, 0x0120a7a7 }
++};
++
++static struct chipset_bus_clock_list_entry hpt366_25[] = {
++ { XFER_UDMA_4, 0x90c98521 },
++ { XFER_UDMA_3, 0x90cf8521 },
++ { XFER_UDMA_2, 0x90cf8521 },
++ { XFER_UDMA_1, 0x90cb8521 },
++ { XFER_UDMA_0, 0x90cb8521 },
++
++ { XFER_MW_DMA_2, 0xa0ca8521 },
++ { XFER_MW_DMA_1, 0xa0ca8532 },
++ { XFER_MW_DMA_0, 0xa0ca8575 },
++
++ { XFER_PIO_4, 0xc0ca8521 },
++ { XFER_PIO_3, 0xc0ca8532 },
++ { XFER_PIO_2, 0xc0ca8542 },
++ { XFER_PIO_1, 0xc0d08572 },
++ { XFER_PIO_0, 0xc0d08585 },
++ { 0, 0x01208585 }
++};
++
++static const char *bad_ata33[] = {
++ "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3", "Maxtor 90845U3", "Maxtor 90650U2",
++ "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5", "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
++ "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6", "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
++ "Maxtor 90510D4",
++ "Maxtor 90432D3", "Maxtor 90288D2", "Maxtor 90256D2",
++ "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7", "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
++ "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5", "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
++ NULL
++};
++
++static const char *bad_ata66_4[] = {
++ "IBM-DTLA-307075",
++ "IBM-DTLA-307060",
++ "IBM-DTLA-307045",
++ "IBM-DTLA-307030",
++ "IBM-DTLA-307020",
++ "IBM-DTLA-307015",
++ "IBM-DTLA-305040",
++ "IBM-DTLA-305030",
++ "IBM-DTLA-305020",
++ "IC35L010AVER07-0",
++ "IC35L020AVER07-0",
++ "IC35L030AVER07-0",
++ "IC35L040AVER07-0",
++ "IC35L060AVER07-0",
++ "WDC AC310200R",
++ NULL
++};
++
++static const char *bad_ata66_3[] = {
++ "WDC AC310200R",
++ NULL
++};
++
++static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, const char *list[])
++{
++ unsigned char model_num[40];
++ char *s;
++ unsigned int len;
++ int i = 0;
++
++ ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
++ sizeof(model_num));
++ s = &model_num[0];
++ len = strnlen(s, sizeof(model_num));
++
++ /* ATAPI specifies that empty space is blank-filled; remove blanks */
++ while ((len > 0) && (s[len - 1] == ' ')) {
++ len--;
++ s[len] = 0;
++ }
++
++ while(list[i] != NULL) {
++ if (!strncmp(list[i], s, len)) {
++ printk(KERN_WARNING DRV_NAME ": %s is not supported for %s.\n",
++ modestr, list[i]);
++ return 1;
++ }
++ i++;
++ }
++ return 0;
++}
++
++/**
++ * hpt366_filter - mode selection filter
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Block UDMA on devices that cause trouble with this controller.
++ */
++
++static unsigned int hpt366_filter(const struct ata_port *ap, struct ata_device *adev, unsigned int mask, int shift)
++{
++ if (shift != ATA_SHIFT_UDMA)
++ return mask;
++ if (adev->class != ATA_DEV_ATA)
++ return mask;
++ if (hpt_dma_blacklisted(adev, "UDMA", bad_ata33))
++ return 0;
++ if (hpt_dma_blacklisted(adev, "UDMA3", bad_ata66_3))
++ return mask & 0x07;
++ if (hpt_dma_blacklisted(adev, "UDMA4", bad_ata66_4))
++ return mask & 0x0F;
++ return mask;
++}
++
++/**
++ * hpt36x_find_mode - reset the hpt36x bus
++ * @ap: ATA port
++ * @speed: transfer mode
++ *
++ * Return the 32bit register programming information for this channel
++ * that matches the speed provided.
++ */
++
++static u32 hpt36x_find_mode(struct ata_port *ap, int speed)
++{
++ struct hpt_clock *clocks = ap->host_set->private_data;
++
++ while(clocks->xfer_speed) {
++ if (clocks->xfer_speed == speed)
++ return clocks->timing;
++ clocks++;
++ }
++ BUG();
++}
++
++/**
++ * hpt36x_phy_reset - reset the hpt36x bus
++ * @ap: ATA port to reset
++ *
++ * Perform the PHY reset handling for the 366/368
++ */
++
++static void hpt36x_phy_reset(struct ata_port *ap)
++{
++ u8 scr2, ata66;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_byte(pdev, 0x5A, &ata66);
++ if (ata66 & (1 << ap->hard_port_no))
++ ap->cbl = ATA_CBL_PATA40;
++ else
++ ap->cbl = ATA_CBL_PATA80;
++
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * hpt366_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Perform PIO mode setup.
++ */
++
++static void hpt366_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ if (fast & 0x80) {
++ fast &= ~0x80;
++ pci_write_config_byte(pdev, addr2, fast);
++ }
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt36x_find_mode(ap, adev->pio_mode);
++ mode &= ~0x8000000; /* No FIFO in PIO */
++ mode &= ~0x30070000; /* Leave config bits alone */
++ reg &= 0x30070000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt366_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * Set up the channel for MWDMA or UDMA modes. Much the same as with
++ * PIO, load the mode number and then set MWDMA or UDMA flag.
++ */
++
++static void hpt366_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ if (fast & 0x80) {
++ fast &= ~0x80;
++ pci_write_config_byte(pdev, addr2, fast);
++ }
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt36x_find_mode(ap, adev->dma_mode);
++ mode |= 0x8000000; /* FIFO in MWDMA or UDMA */
++ mode &= ~0xC0000000; /* Leave config bits alone */
++ reg &= 0xC0000000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++static struct scsi_host_template hpt36x_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++/*
++ * Configuration for HPT366/68
++ */
++
++static struct ata_port_operations hpt366_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt366_set_piomode,
++ .set_dmamode = hpt366_set_dmamode,
++ .mode_filter = hpt366_filter,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt36x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * hpt36x_init_one - Initialise an HPT366/368
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Initialise an HPT36x device. There are some interesting complications
++ * here. Firstly the chip may report 366 and be one of several variants.
++ * Secondly all the timings depend on the clock for the chip which we must
++ * detect and look up
++ *
++ * This is the known chip mappings. It may be missing a couple of later
++ * releases.
++ *
++ * Chip version PCI Rev Notes
++ * HPT366 4 (HPT366) 0 UDMA66
++ * HPT366 4 (HPT366) 1 UDMA66
++ * HPT368 4 (HPT366) 2 UDMA66
++ * HPT37x/30x 4 (HPT366) 3+ Other driver
++ *
++ */
++
++static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info_hpt366 = {
++ .sht = &hpt366_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f,
++ .port_ops = &hpt370_port_ops
++ };
++ struct ata_port_info *port_info[2] = {&info_hpt366, &info_hpt366};
++
++ u8 irqmask;
++ u32 class_rev;
++ u32 reg1;
++
++ struct hpt_chip *chip_table;
++ int clock_slot;
++
++ pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
++ class_rev &= 0xFF;
++
++ /* May be a later chip in disguise. Check */
++ /* Newer chips are in the HPT36x driver. Ignore them */
++ if (class_rev > 2)
++ return -ENODEV;
++
++ pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, (L1_CACHE_BYTES / 4));
++ pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x78);
++ pci_write_config_byte(dev, PCI_MIN_GNT, 0x08);
++ pci_write_config_byte(dev, PCI_MAX_LAT, 0x08);
++
++ pci_read_config_byte(dev, 0x51, &drive_fast);
++ if (drive_fast & 0x80)
++ pci_write_config_byte(dev, 0x51, drive_fast & ~0x80);
++
++ pci_read_config_dword(dev, 0x40, &reg1);
++
++ /* PCI clocking determines the ATA timing values to use */
++ switch((reg1 & 0x700) {
++ case 5:
++ port->private_data = hpt366_40;
++ break;
++ case 9:
++ port->private_data = hpt366_25;
++ break;
++ default:
++ port->private_data = hpt366_33;
++ break;
++ }
++ port_info[0] = port_info[1] = port;
++ /* Now kick off ATA set up */
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id hpt36x[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT366), },
++ { 0, },
++};
++
++static struct pci_driver hpt36x_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = hpt36x,
++ .probe = hpt36x_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init hpt36x_init(void)
++{
++ return pci_register_driver(&hpt36x_pci_driver);
++}
++
++
++static void __exit hpt36x_exit(void)
++{
++ pci_unregister_driver(&hpt36x_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the Highpoint HPT366/368");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, hpt36x);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(hpt36x_init);
++module_exit(hpt36x_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt37x.c linux-2.6.16-rc4/drivers/scsi/pata_hpt37x.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt37x.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_hpt37x.c 2006-02-16 15:45:27.000000000 +0000
+@@ -0,0 +1,1232 @@
++/*
++ * Libata driver for the highpoint 37x and 30x UDMA66 ATA controllers.
++ *
++ * This driver is heavily based upon:
++ *
++ * linux/drivers/ide/pci/hpt366.c Version 0.36 April 25, 2003
++ *
++ * Copyright (C) 1999-2003 Andre Hedrick <andre@linux-ide.org>
++ * Portions Copyright (C) 2001 Sun Microsystems, Inc.
++ * Portions Copyright (C) 2003 Red Hat Inc
++ *
++ * TODO
++ * PLL mode
++ * Look into engine reset on timeout errors. Should not be
++ * required.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "hpt37x"
++#define DRV_VERSION "0.2"
++
++struct hpt_clock {
++ u8 xfer_speed;
++ u32 timing;
++};
++
++struct hpt_chip {
++ const char *name;
++ unsigned int base;
++ struct hpt_clock *clocks[4];
++};
++
++/* key for bus clock timings
++ * bit
++ * 0:3 data_high_time. inactive time of DIOW_/DIOR_ for PIO and MW
++ * DMA. cycles = value + 1
++ * 4:8 data_low_time. active time of DIOW_/DIOR_ for PIO and MW
++ * DMA. cycles = value + 1
++ * 9:12 cmd_high_time. inactive time of DIOW_/DIOR_ during task file
++ * register access.
++ * 13:17 cmd_low_time. active time of DIOW_/DIOR_ during task file
++ * register access.
++ * 18:21 udma_cycle_time. clock freq and clock cycles for UDMA xfer.
++ * during task file register access.
++ * 22:24 pre_high_time. time to initialize 1st cycle for PIO and MW DMA
++ * xfer.
++ * 25:27 cmd_pre_high_time. time to initialize 1st PIO cycle for task
++ * register access.
++ * 28 UDMA enable
++ * 29 DMA enable
++ * 30 PIO_MST enable. if set, the chip is in bus master mode during
++ * PIO.
++ * 31 FIFO enable.
++ */
++
++/* from highpoint documentation. these are old values */
++static struct hpt_clock hpt370_timings_33[] = {
++/* { XFER_UDMA_5, 0x1A85F442, 0x16454e31 }, */
++ { XFER_UDMA_5, 0x16454e31 },
++ { XFER_UDMA_4, 0x16454e31 },
++ { XFER_UDMA_3, 0x166d4e31 },
++ { XFER_UDMA_2, 0x16494e31 },
++ { XFER_UDMA_1, 0x164d4e31 },
++ { XFER_UDMA_0, 0x16514e31 },
++
++ { XFER_MW_DMA_2, 0x26514e21 },
++ { XFER_MW_DMA_1, 0x26514e33 },
++ { XFER_MW_DMA_0, 0x26514e97 },
++
++ { XFER_PIO_4, 0x06514e21 },
++ { XFER_PIO_3, 0x06514e22 },
++ { XFER_PIO_2, 0x06514e33 },
++ { XFER_PIO_1, 0x06914e43 },
++ { XFER_PIO_0, 0x06914e57 },
++ { 0, 0x06514e57 }
++};
++
++static struct hpt_clock hpt370_timings_66[] = {
++ { XFER_UDMA_5, 0x14846231 },
++ { XFER_UDMA_4, 0x14886231 },
++ { XFER_UDMA_3, 0x148c6231 },
++ { XFER_UDMA_2, 0x148c6231 },
++ { XFER_UDMA_1, 0x14906231 },
++ { XFER_UDMA_0, 0x14986231 },
++
++ { XFER_MW_DMA_2, 0x26514e21 },
++ { XFER_MW_DMA_1, 0x26514e33 },
++ { XFER_MW_DMA_0, 0x26514e97 },
++
++ { XFER_PIO_4, 0x06514e21 },
++ { XFER_PIO_3, 0x06514e22 },
++ { XFER_PIO_2, 0x06514e33 },
++ { XFER_PIO_1, 0x06914e43 },
++ { XFER_PIO_0, 0x06914e57 },
++ { 0, 0x06514e57 }
++};
++
++/* these are the current (4 sep 2001) timings from highpoint */
++static struct hpt_clock hpt370a_timings_33[] = {
++ { XFER_UDMA_5, 0x12446231 },
++ { XFER_UDMA_4, 0x12446231 },
++ { XFER_UDMA_3, 0x126c6231 },
++ { XFER_UDMA_2, 0x12486231 },
++ { XFER_UDMA_1, 0x124c6233 },
++ { XFER_UDMA_0, 0x12506297 },
++
++ { XFER_MW_DMA_2, 0x22406c31 },
++ { XFER_MW_DMA_1, 0x22406c33 },
++ { XFER_MW_DMA_0, 0x22406c97 },
++
++ { XFER_PIO_4, 0x06414e31 },
++ { XFER_PIO_3, 0x06414e42 },
++ { XFER_PIO_2, 0x06414e53 },
++ { XFER_PIO_1, 0x06814e93 },
++ { XFER_PIO_0, 0x06814ea7 },
++ { 0, 0x06814ea7 }
++};
++
++/* 2x 33MHz timings */
++static struct hpt_clock hpt370a_timings_66[] = {
++ { XFER_UDMA_5, 0x1488e673 },
++ { XFER_UDMA_4, 0x1488e673 },
++ { XFER_UDMA_3, 0x1498e673 },
++ { XFER_UDMA_2, 0x1490e673 },
++ { XFER_UDMA_1, 0x1498e677 },
++ { XFER_UDMA_0, 0x14a0e73f },
++
++ { XFER_MW_DMA_2, 0x2480fa73 },
++ { XFER_MW_DMA_1, 0x2480fa77 },
++ { XFER_MW_DMA_0, 0x2480fb3f },
++
++ { XFER_PIO_4, 0x0c82be73 },
++ { XFER_PIO_3, 0x0c82be95 },
++ { XFER_PIO_2, 0x0c82beb7 },
++ { XFER_PIO_1, 0x0d02bf37 },
++ { XFER_PIO_0, 0x0d02bf5f },
++ { 0, 0x0d02bf5f }
++};
++
++static struct hpt_clock hpt370a_timings_50[] = {
++ { XFER_UDMA_5, 0x12848242 },
++ { XFER_UDMA_4, 0x12ac8242 },
++ { XFER_UDMA_3, 0x128c8242 },
++ { XFER_UDMA_2, 0x120c8242 },
++ { XFER_UDMA_1, 0x12148254 },
++ { XFER_UDMA_0, 0x121882ea },
++
++ { XFER_MW_DMA_2, 0x22808242 },
++ { XFER_MW_DMA_1, 0x22808254 },
++ { XFER_MW_DMA_0, 0x228082ea },
++
++ { XFER_PIO_4, 0x0a81f442 },
++ { XFER_PIO_3, 0x0a81f443 },
++ { XFER_PIO_2, 0x0a81f454 },
++ { XFER_PIO_1, 0x0ac1f465 },
++ { XFER_PIO_0, 0x0ac1f48a },
++ { 0, 0x0ac1f48a }
++};
++
++static struct hpt_clock hpt372_timings_33[] = {
++ { XFER_UDMA_6, 0x1c81dc62 },
++ { XFER_UDMA_5, 0x1c6ddc62 },
++ { XFER_UDMA_4, 0x1c8ddc62 },
++ { XFER_UDMA_3, 0x1c8edc62 }, /* checkme */
++ { XFER_UDMA_2, 0x1c91dc62 },
++ { XFER_UDMA_1, 0x1c9adc62 }, /* checkme */
++ { XFER_UDMA_0, 0x1c82dc62 }, /* checkme */
++
++ { XFER_MW_DMA_2, 0x2c829262 },
++ { XFER_MW_DMA_1, 0x2c829266 }, /* checkme */
++ { XFER_MW_DMA_0, 0x2c82922e }, /* checkme */
++
++ { XFER_PIO_4, 0x0c829c62 },
++ { XFER_PIO_3, 0x0c829c84 },
++ { XFER_PIO_2, 0x0c829ca6 },
++ { XFER_PIO_1, 0x0d029d26 },
++ { XFER_PIO_0, 0x0d029d5e },
++ { 0, 0x0d029d5e }
++};
++
++static struct hpt_clock hpt372_timings_50[] = {
++ { XFER_UDMA_5, 0x12848242 },
++ { XFER_UDMA_4, 0x12ac8242 },
++ { XFER_UDMA_3, 0x128c8242 },
++ { XFER_UDMA_2, 0x120c8242 },
++ { XFER_UDMA_1, 0x12148254 },
++ { XFER_UDMA_0, 0x121882ea },
++
++ { XFER_MW_DMA_2, 0x22808242 },
++ { XFER_MW_DMA_1, 0x22808254 },
++ { XFER_MW_DMA_0, 0x228082ea },
++
++ { XFER_PIO_4, 0x0a81f442 },
++ { XFER_PIO_3, 0x0a81f443 },
++ { XFER_PIO_2, 0x0a81f454 },
++ { XFER_PIO_1, 0x0ac1f465 },
++ { XFER_PIO_0, 0x0ac1f48a },
++ { 0, 0x0a81f443 }
++};
++
++static struct hpt_clock hpt372_timings_66[] = {
++ { XFER_UDMA_6, 0x1c869c62 },
++ { XFER_UDMA_5, 0x1cae9c62 },
++ { XFER_UDMA_4, 0x1c8a9c62 },
++ { XFER_UDMA_3, 0x1c8e9c62 },
++ { XFER_UDMA_2, 0x1c929c62 },
++ { XFER_UDMA_1, 0x1c9a9c62 },
++ { XFER_UDMA_0, 0x1c829c62 },
++
++ { XFER_MW_DMA_2, 0x2c829c62 },
++ { XFER_MW_DMA_1, 0x2c829c66 },
++ { XFER_MW_DMA_0, 0x2c829d2e },
++
++ { XFER_PIO_4, 0x0c829c62 },
++ { XFER_PIO_3, 0x0c829c84 },
++ { XFER_PIO_2, 0x0c829ca6 },
++ { XFER_PIO_1, 0x0d029d26 },
++ { XFER_PIO_0, 0x0d029d5e },
++ { 0, 0x0d029d26 }
++};
++
++static struct hpt_clock hpt374_timings_33[] = {
++ { XFER_UDMA_6, 0x12808242 },
++ { XFER_UDMA_5, 0x12848242 },
++ { XFER_UDMA_4, 0x12ac8242 },
++ { XFER_UDMA_3, 0x128c8242 },
++ { XFER_UDMA_2, 0x120c8242 },
++ { XFER_UDMA_1, 0x12148254 },
++ { XFER_UDMA_0, 0x121882ea },
++
++ { XFER_MW_DMA_2, 0x22808242 },
++ { XFER_MW_DMA_1, 0x22808254 },
++ { XFER_MW_DMA_0, 0x228082ea },
++
++ { XFER_PIO_4, 0x0a81f442 },
++ { XFER_PIO_3, 0x0a81f443 },
++ { XFER_PIO_2, 0x0a81f454 },
++ { XFER_PIO_1, 0x0ac1f465 },
++ { XFER_PIO_0, 0x0ac1f48a },
++ { 0, 0x06814e93 }
++};
++
++static struct hpt_chip hpt370 = {
++ "HPT370",
++ 48,
++ {
++ hpt370_timings_33,
++ NULL,
++ NULL,
++ hpt370_timings_66
++ }
++};
++
++static struct hpt_chip hpt370a = {
++ "HPT370A",
++ 48,
++ {
++ hpt370a_timings_33,
++ NULL,
++ hpt370a_timings_50,
++ hpt370a_timings_66
++ }
++};
++
++static struct hpt_chip hpt372 = {
++ "HPT372",
++ 55,
++ {
++ hpt372_timings_33,
++ NULL,
++ hpt372_timings_50,
++ hpt372_timings_66
++ }
++};
++
++static struct hpt_chip hpt302 = {
++ "HPT302",
++ 66,
++ {
++ hpt372_timings_33,
++ NULL,
++ hpt372_timings_50,
++ hpt372_timings_66
++ }
++};
++
++static struct hpt_chip hpt371 = {
++ "HPT371",
++ 66,
++ {
++ hpt372_timings_33,
++ NULL,
++ hpt372_timings_50,
++ hpt372_timings_66
++ }
++};
++
++static struct hpt_chip hpt372a = {
++ "HPT372A",
++ 66,
++ {
++ hpt372_timings_33,
++ NULL,
++ hpt372_timings_50,
++ hpt372_timings_66
++ }
++};
++
++static struct hpt_chip hpt374 = {
++ "HPT374",
++ 48,
++ {
++ hpt374_timings_33,
++ NULL,
++ NULL,
++ NULL
++ }
++};
++
++/**
++ * hpt37x_find_mode - reset the hpt37x bus
++ * @ap: ATA port
++ * @speed: transfer mode
++ *
++ * Return the 32bit register programming information for this channel
++ * that matches the speed provided.
++ */
++
++static u32 hpt37x_find_mode(struct ata_port *ap, int speed)
++{
++ struct hpt_clock *clocks = ap->host_set->private_data;
++
++ while(clocks->xfer_speed) {
++ if (clocks->xfer_speed == speed)
++ return clocks->timing;
++ clocks++;
++ }
++ BUG();
++}
++
++static int hpt_dma_blacklisted(const struct ata_device *dev, char *modestr, const char *list[])
++{
++ unsigned char model_num[40];
++ char *s;
++ unsigned int len;
++ int i = 0;
++
++ ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
++ sizeof(model_num));
++ s = &model_num[0];
++ len = strnlen(s, sizeof(model_num));
++
++ /* ATAPI specifies that empty space is blank-filled; remove blanks */
++ while ((len > 0) && (s[len - 1] == ' ')) {
++ len--;
++ s[len] = 0;
++ }
++
++ while(list[i] != NULL) {
++ if (!strncmp(list[i], s, len)) {
++ printk(KERN_WARNING DRV_NAME ": %s is not supported for %s.\n",
++ modestr, list[i]);
++ return 1;
++ }
++ i++;
++ }
++ return 0;
++}
++
++static const char *bad_ata33[] = {
++ "Maxtor 92720U8", "Maxtor 92040U6", "Maxtor 91360U4", "Maxtor 91020U3", "Maxtor 90845U3", "Maxtor 90650U2",
++ "Maxtor 91360D8", "Maxtor 91190D7", "Maxtor 91020D6", "Maxtor 90845D5", "Maxtor 90680D4", "Maxtor 90510D3", "Maxtor 90340D2",
++ "Maxtor 91152D8", "Maxtor 91008D7", "Maxtor 90845D6", "Maxtor 90840D6", "Maxtor 90720D5", "Maxtor 90648D5", "Maxtor 90576D4",
++ "Maxtor 90510D4",
++ "Maxtor 90432D3", "Maxtor 90288D2", "Maxtor 90256D2",
++ "Maxtor 91000D8", "Maxtor 90910D8", "Maxtor 90875D7", "Maxtor 90840D7", "Maxtor 90750D6", "Maxtor 90625D5", "Maxtor 90500D4",
++ "Maxtor 91728D8", "Maxtor 91512D7", "Maxtor 91303D6", "Maxtor 91080D5", "Maxtor 90845D4", "Maxtor 90680D4", "Maxtor 90648D3", "Maxtor 90432D2",
++ NULL
++};
++
++static const char *bad_ata100_5[] = {
++ "IBM-DTLA-307075",
++ "IBM-DTLA-307060",
++ "IBM-DTLA-307045",
++ "IBM-DTLA-307030",
++ "IBM-DTLA-307020",
++ "IBM-DTLA-307015",
++ "IBM-DTLA-305040",
++ "IBM-DTLA-305030",
++ "IBM-DTLA-305020",
++ "IC35L010AVER07-0",
++ "IC35L020AVER07-0",
++ "IC35L030AVER07-0",
++ "IC35L040AVER07-0",
++ "IC35L060AVER07-0",
++ "WDC AC310200R",
++ NULL
++};
++
++/**
++ * hpt370_filter - mode selection filter
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Block UDMA on devices that cause trouble with this controller.
++ */
++
++static unsigned int hpt370_filter(const struct ata_port *ap, struct ata_device *adev, unsigned int mask, int shift)
++{
++ if (shift != ATA_SHIFT_UDMA)
++ return mask;
++ if (adev->class != ATA_DEV_ATA)
++ return mask;
++ if (hpt_dma_blacklisted(adev, "UDMA", bad_ata33))
++ return mask & 0x1F;
++ if (hpt_dma_blacklisted(adev, "UDMA100", bad_ata100_5))
++ return mask & 0x1F;
++ return mask;
++}
++
++/**
++ * hpt370a_filter - mode selection filter
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Block UDMA on devices that cause trouble with this controller.
++ */
++
++static unsigned int hpt370a_filter(const struct ata_port *ap, struct ata_device *adev, unsigned int mask, int shift)
++{
++ if (shift != ATA_SHIFT_UDMA)
++ return mask;
++ if (adev->class != ATA_DEV_ATA)
++ return mask;
++ if (hpt_dma_blacklisted(adev, "UDMA100", bad_ata100_5))
++ return mask & 0x1F;
++ return mask;
++}
++
++/**
++ * hpt37x_phy_reset - reset the hpt37x bus
++ * @ap: ATA port to reset
++ *
++ * Perform the PHY reset handling for the 370/372 and 374 func 0
++ */
++
++static void hpt37x_phy_reset(struct ata_port *ap)
++{
++ u8 scr2, ata66;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_byte(pdev, 0x5B, &scr2);
++ pci_write_config_byte(pdev, 0x5B, scr2 & ~0x01);
++ /* Cable register now active */
++ pci_read_config_byte(pdev, 0x5A, &ata66);
++ /* Restore state */
++ pci_write_config_byte(pdev, 0x5B, scr2);
++
++ if (ata66 & (1 << ap->hard_port_no))
++ ap->cbl = ATA_CBL_PATA40;
++ else
++ ap->cbl = ATA_CBL_PATA80;
++
++ /* Reset the state machine */
++ pci_write_config_byte(pdev, 0x50, 0x37);
++ pci_write_config_byte(pdev, 0x54, 0x37);
++ udelay(100);
++
++ printk("BUS RESET\n");
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * hpt374_phy_reset - reset the hpt374
++ * @ap: ATA port to reset
++ *
++ * The 374 cable detect is a little different due to the extra
++ * channels. The function 0 channels work like usual but function 1
++ * is special
++ */
++
++static void hpt374_phy_reset(struct ata_port *ap)
++{
++ u16 mcr3, mcr6;
++ u8 ata66;
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ if (!(PCI_FUNC(pdev->devfn) & 1)) {
++ hpt37x_phy_reset(ap);
++ return;
++ }
++ /* Do the extra channel work */
++ pci_read_config_word(pdev, 0x52, &mcr3);
++ pci_read_config_word(pdev, 0x56, &mcr6);
++ /* Set bit 15 of 0x52 to enable TCBLID as input
++ Set bit 15 of 0x56 to enable FCBLID as input
++ */
++ pci_write_config_word(pdev, 0x52, mcr3 | 0x8000);
++ pci_write_config_word(pdev, 0x56, mcr6 | 0x8000);
++ pci_read_config_byte(pdev, 0x5A, &ata66);
++ /* Reset TCBLID/FCBLID to output */
++ pci_write_config_word(pdev, 0x52, mcr3);
++ pci_write_config_word(pdev, 0x56, mcr6);
++
++ if (ata66 & (1 << ap->hard_port_no))
++ ap->cbl = ATA_CBL_PATA40;
++ else
++ ap->cbl = ATA_CBL_PATA80;
++
++ /* Reset the state machine */
++ pci_write_config_byte(pdev, 0x50, 0x37);
++ pci_write_config_byte(pdev, 0x54, 0x37);
++ udelay(100);
++
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++
++/**
++ * hpt370_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Perform PIO mode setup.
++ */
++
++static void hpt370_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ fast &= ~0x02;
++ fast |= 0x01;
++ pci_write_config_byte(pdev, addr2, fast);
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt37x_find_mode(ap, adev->pio_mode);
++ mode &= ~0x8000000; /* No FIFO in PIO */
++ mode &= ~0x30070000; /* Leave config bits alone */
++ reg &= 0x30070000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt370_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * Set up the channel for MWDMA or UDMA modes. Much the same as with
++ * PIO, load the mode number and then set MWDMA or UDMA flag.
++ */
++
++static void hpt370_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ fast &= ~0x02;
++ fast |= 0x01;
++ pci_write_config_byte(pdev, addr2, fast);
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt37x_find_mode(ap, adev->dma_mode);
++ mode |= 0x8000000; /* FIFO in MWDMA or UDMA */
++ mode &= ~0xC0000000; /* Leave config bits alone */
++ reg &= 0xC0000000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt370_bmdma_start - DMA engine begin
++ * @qc: ATA command
++ *
++ * The 370 and 370A want us to reset the DMA engine each time we
++ * use it. The 372 and later are fine.
++ */
++
++static void hpt370_bmdma_start(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ pci_write_config_byte(pdev, 0x50 + 4 * ap->hard_port_no, 0x37);
++ udelay(10);
++ ata_bmdma_start(qc);
++}
++
++/**
++ * hpt370_bmdma_end - DMA engine stop
++ * @qc: ATA command
++ *
++ * Work around the HPT370 DMA engine.
++ */
++
++static void hpt370_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 dma_stat = inb(ap->ioaddr.bmdma_addr + 2);
++ u8 dma_cmd;
++ unsigned long bmdma = ap->ioaddr.bmdma_addr;
++
++ if (dma_stat & 0x01) {
++ udelay(20);
++ dma_stat = inb(bmdma + 2);
++ }
++ if (dma_stat & 0x01) {
++ /* Clear the engine */
++ pci_write_config_byte(pdev, 0x50 + 4 * ap->hard_port_no, 0x37);
++ udelay(10);
++ /* Stop DMA */
++ dma_cmd = inb(bmdma );
++ outb(dma_cmd & 0xFE, bmdma);
++ /* Clear Error */
++ dma_stat = inb(bmdma + 2);
++ outb(dma_stat | 0x06 , bmdma + 2);
++ /* Clear the engine */
++ pci_write_config_byte(pdev, 0x50 + 4 * ap->hard_port_no, 0x37);
++ udelay(10);
++ }
++ ata_bmdma_stop(qc);
++}
++
++/**
++ * hpt372_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Perform PIO mode setup.
++ */
++
++static void hpt372_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ fast &= ~0x07;
++ pci_write_config_byte(pdev, addr2, fast);
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt37x_find_mode(ap, adev->pio_mode);
++
++ printk("Find mode for %d reports %X\n", adev->pio_mode, mode);
++ mode &= ~0x8000000; /* No FIFO in PIO */
++ mode &= ~0x30070000; /* Leave config bits alone */
++ reg &= 0x30070000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt372_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * Set up the channel for MWDMA or UDMA modes. Much the same as with
++ * PIO, load the mode number and then set MWDMA or UDMA flag.
++ */
++
++static void hpt372_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ fast &= ~0x07;
++ pci_write_config_byte(pdev, addr2, fast);
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt37x_find_mode(ap, adev->dma_mode);
++ printk("Find mode for DMA %d reports %X\n", adev->dma_mode, mode);
++ mode &= ~0xC0000000; /* Leave config bits alone */
++ mode |= 0x8000000; /* FIFO in MWDMA or UDMA */
++ reg &= 0xC0000000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt37x_bmdma_end - DMA engine stop
++ * @qc: ATA command
++ *
++ * Clean up after the HPT372 and later DMA engine
++ */
++
++static void hpt37x_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int mscreg = 0x50 + 2 * ap->hard_port_no;
++ u8 bwsr_stat, msc_stat;
++
++ pci_read_config_byte(pdev, 0x6A, &bwsr_stat);
++ pci_read_config_byte(pdev, mscreg, &msc_stat);
++ if (bwsr_stat & (1 << ap->hard_port_no))
++ pci_write_config_byte(pdev, mscreg, msc_stat | 0x30);
++ ata_bmdma_stop(qc);
++}
++
++
++static struct scsi_host_template hpt37x_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++/*
++ * Configuration for HPT370
++ */
++
++static struct ata_port_operations hpt370_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt370_set_piomode,
++ .set_dmamode = hpt370_set_dmamode,
++ .mode_filter = hpt370_filter,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt37x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = hpt370_bmdma_start,
++ .bmdma_stop = hpt370_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Configuration for HPT370A. Close to 370 but less filters
++ */
++
++static struct ata_port_operations hpt370a_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt370_set_piomode,
++ .set_dmamode = hpt370_set_dmamode,
++ .mode_filter = hpt370a_filter,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt37x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = hpt370_bmdma_start,
++ .bmdma_stop = hpt370_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Configuration for HPT372, HPT371, HPT302. Slightly different PIO
++ * and DMA mode setting functionality.
++ */
++
++static struct ata_port_operations hpt372_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt372_set_piomode,
++ .set_dmamode = hpt372_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt37x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = hpt37x_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Configuration for HPT374. Mode setting works like 372 and friends
++ * but we have a different cable detection procedure.
++ */
++
++static struct ata_port_operations hpt374_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt372_set_piomode,
++ .set_dmamode = hpt372_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt374_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = hpt37x_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * htp37x_clock_slot - Turn timing to PC clock entry
++ * @freq: Reported frequency timing
++ * @base: Base timing
++ *
++ * Turn the timing data intoa clock slot (0 for 33, 1 for 40, 2 for 50
++ * and 3 for 66Mhz)
++ */
++
++static int hpt37x_clock_slot(unsigned int freq, unsigned int base)
++{
++ unsigned int f = (base * freq) / 192; /* Mhz */
++ if (f < 40)
++ return 0; /* 33Mhz slot */
++ if (f < 45)
++ return 1; /* 40Mhz slot */
++ if (f < 55)
++ return 2; /* 50Mhz slot */
++ return 3; /* 60Mhz slot */
++}
++
++/**
++ * hpt37x_calibrate_dpll - Calibrate the DPLL loop
++ * @dev: PCI device
++ *
++ * Perform a calibration cycle on the HPT37x DPLL. Returns 1 if this
++ * succeeds
++ */
++
++static int hpt37x_calibrate_dpll(struct pci_dev *dev)
++{
++ u8 reg5b;
++ u32 reg5c;
++ int tries;
++
++ for(tries = 0; tries < 0x5000; tries++) {
++ udelay(50);
++ pci_read_config_byte(dev, 0x5b, &reg5b);
++ if (reg5b & 0x80) {
++ /* See if it stays set */
++ for(tries = 0; tries < 0x1000; tries ++) {
++ pci_read_config_byte(dev, 0x5b, &reg5b);
++ /* Failed ? */
++ if ((reg5b & 0x80) == 0)
++ return 0;
++ }
++ /* Turn off tuning, we have the DPLL set */
++ pci_read_config_dword(dev, 0x5c, &reg5c);
++ pci_write_config_dword(dev, 0x5c, reg5c & ~ 0x100);
++ return 1;
++ }
++ }
++ /* Never went stable */
++ return 0;
++}
++/**
++ * hpt37x_init_one - Initialise an HPT37X/302
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Initialise an HPT37x device. There are some interesting complications
++ * here. Firstly the chip may report 366 and be one of several variants.
++ * Secondly all the timings depend on the clock for the chip which we must
++ * detect and look up
++ *
++ * This is the known chip mappings. It may be missing a couple of later
++ * releases.
++ *
++ * Chip version PCI Rev Notes
++ * HPT366 4 (HPT366) 0 Other driver
++ * HPT366 4 (HPT366) 1 Other driver
++ * HPT368 4 (HPT366) 2 Other driver
++ * HPT370 4 (HPT366) 3 UDMA100
++ * HPT370A 4 (HPT366) 4 UDMA100
++ * HPT372 4 (HPT366) 5 UDMA133 (1)
++ * HPT372N 4 (HPT366) 6 Other driver
++ * HPT372A 5 (HPT372) 1 UDMA133 (1)
++ * HPT372N 5 (HPT372) 2 Other driver
++ * HPT302 6 (HPT302) 1 UDMA133
++ * HPT302N 6 (HPT302) 2 Other driver
++ * HPT371 7 (HPT371) * UDMA133
++ * HPT374 8 (HPT374) * UDMA133 4 channel
++ * HPT372N 9 (HPT372N) * Other driver
++ *
++ * (1) UDMA133 support depends on the bus clock
++ */
++
++static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ /* HPT370 - UDMA100 */
++ static struct ata_port_info info_hpt370 = {
++ .sht = &hpt37x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &hpt370_port_ops
++ };
++ /* HPT370A - UDMA100 */
++ static struct ata_port_info info_hpt370a = {
++ .sht = &hpt37x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &hpt370a_port_ops
++ };
++ /* HPT371, 372 and friends - UDMA133 */
++ static struct ata_port_info info_hpt372 = {
++ .sht = &hpt37x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &hpt372_port_ops
++ };
++ /* HPT371, 372 and friends - UDMA100 at 50MHz clock */
++ static struct ata_port_info info_hpt372_50 = {
++ .sht = &hpt37x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &hpt372_port_ops
++ };
++ /* HPT374 - UDMA133 */
++ static struct ata_port_info info_hpt374 = {
++ .sht = &hpt37x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &hpt374_port_ops
++ };
++
++ struct ata_port_info *port_info[2];
++ struct ata_port_info *port;
++
++ u8 irqmask;
++ u32 class_rev;
++ u32 freq;
++
++ int MHz[4] = { 33, 40, 50, 66 };
++ struct hpt_chip *chip_table;
++ int clock_slot;
++
++ pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
++ class_rev &= 0xFF;
++
++ if (dev->device == PCI_DEVICE_ID_TTI_HPT366) {
++ /* May be a later chip in disguise. Check */
++ /* Older chips are in the HPT366 driver. Ignore them */
++ if (class_rev < 3)
++ return -ENODEV;
++ /* N series chips have their own driver. Ignore */
++ if (class_rev == 6)
++ return -ENODEV;
++
++ switch(class_rev) {
++ case 3:
++ port = &info_hpt370;
++ chip_table = &hpt370;
++ break;
++ case 4:
++ port = &info_hpt370a;
++ chip_table = &hpt370a;
++ break;
++ case 5:
++ port = &info_hpt372;
++ chip_table = &hpt372;
++ break;
++ default:
++ printk(KERN_ERR "pata_hpt37x: Unknown HPT366 subtype please report (%d).\n", class_rev);
++ return -ENODEV;
++ }
++ } else {
++ switch(dev->device) {
++ case PCI_DEVICE_ID_TTI_HPT372:
++ /* 372N if rev >= 2*/
++ if (class_rev >= 2)
++ return -ENODEV;
++ port = &info_hpt372;
++ chip_table = &hpt372a;
++ break;
++ case PCI_DEVICE_ID_TTI_HPT302:
++ /* 302N if rev > 1 */
++ if (class_rev > 1)
++ return -ENODEV;
++ port = &info_hpt372;
++ /* Check this */
++ chip_table = &hpt302;
++ break;
++ case PCI_DEVICE_ID_TTI_HPT371:
++ port = &info_hpt372;
++ chip_table = &hpt371;
++ break;
++ case PCI_DEVICE_ID_TTI_HPT374:
++ chip_table = &hpt374;
++ port = &info_hpt374;
++ break;
++ default:
++ printk(KERN_ERR "pata_hpt37x: PCI table is bogus please report (%d).\n", dev->device);
++ return -ENODEV;
++ }
++ }
++ /* Ok so this is a chip we support */
++
++ pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, (L1_CACHE_BYTES / 4));
++ pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x78);
++ pci_write_config_byte(dev, PCI_MIN_GNT, 0x08);
++ pci_write_config_byte(dev, PCI_MAX_LAT, 0x08);
++
++ pci_read_config_byte(dev, 0x5A, &irqmask);
++ irqmask &= ~0x10;
++ pci_write_config_byte(dev, 0x5a, irqmask);
++
++ /*
++ * default to pci clock. make sure MA15/16 are set to output
++ * to prevent drives having problems with 40-pin cables. Needed
++ * for some drives such as IBM-DTLA which will not enter ready
++ * state on reset when PDIAG is a input.
++ */
++
++ pci_write_config_byte(dev, 0x5b, 0x23);
++
++ pci_read_config_dword(dev, 0x70, &freq);
++ if ((freq >> 12) != 0xABCDE) {
++ int i;
++ u8 sr;
++ u32 total = 0;
++
++ printk(KERN_WARNING "pata_hpt37x: BIOS has not set timing clocks.\n");
++
++ /* This is the process the HPT371 BIOS is reported to use */
++ for(i = 0; i < 128; i++) {
++ pci_read_config_byte(dev, 0x78, &sr);
++ total += sr;
++ udelay(15);
++ }
++ freq = total / 128;
++ }
++ freq &= 0x1FF;
++
++ /*
++ * Turn the frequency check into a band and then find a timing
++ * table to match it.
++ */
++
++ clock_slot = hpt37x_clock_slot(freq, chip_table->base);
++ if (chip_table->clocks[clock_slot] == NULL) {
++ /*
++ * We need to try PLL mode instead
++ */
++ unsigned int f_low = (MHz[clock_slot] * chip_table->base) / 192;
++ unsigned int f_high = f_low + 2;
++ int adjust;
++
++ for(adjust = 0; adjust < 8; adjust++) {
++ if (hpt37x_calibrate_dpll(dev))
++ break;
++ /* See if it'll settle at a fractionally different clock */
++ if ((adjust & 3) == 3) {
++ f_low --;
++ f_high ++;
++ }
++ pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low);
++ }
++ if (adjust == 8) {
++ printk(KERN_WARNING "hpt37x: DPLL did not stabilize.\n");
++ return -ENODEV;
++ }
++ /* Check if this works for all cases */
++ port->private_data = hpt370_timings_66;
++
++ printk(KERN_INFO "hpt37x: Bus clock %dMHz, using DPLL.\n", MHz[clock_slot]);
++ } else {
++ port->private_data = chip_table->clocks[clock_slot];
++ /*
++ * Perform a final fixup. The 371 and 372 clock determines
++ * if UDMA133 is available.
++ */
++
++ if (clock_slot == 2 && chip_table == &hpt372) { /* 50Mhz */
++ printk(KERN_WARNING "pata_hpt37x: No UDMA133 support available with 50MHz bus clock.\n");
++ if (port == &info_hpt372)
++ port = &info_hpt372_50;
++ else BUG();
++ }
++ printk(KERN_INFO "hpt37x: %s: Bus clock %dMHz.\n", chip_table->name, MHz[clock_slot]);
++ }
++ port_info[0] = port_info[1] = port;
++ /* Now kick off ATA set up */
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id hpt37x[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT366), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT371), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT372), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT374), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT302), },
++ { 0, },
++};
++
++static struct pci_driver hpt37x_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = hpt37x,
++ .probe = hpt37x_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init hpt37x_init(void)
++{
++ return pci_register_driver(&hpt37x_pci_driver);
++}
++
++
++static void __exit hpt37x_exit(void)
++{
++ pci_unregister_driver(&hpt37x_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the Highpoint HPT37x/30x");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, hpt37x);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(hpt37x_init);
++module_exit(hpt37x_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt3x2n.c linux-2.6.16-rc4/drivers/scsi/pata_hpt3x2n.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_hpt3x2n.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_hpt3x2n.c 2006-02-16 15:36:58.000000000 +0000
+@@ -0,0 +1,580 @@
++/*
++ * Libata driver for the highpoint 372N and 302N UDMA66 ATA controllers.
++ *
++ * This driver is heavily based upon:
++ *
++ * linux/drivers/ide/pci/hpt366.c Version 0.36 April 25, 2003
++ *
++ * Copyright (C) 1999-2003 Andre Hedrick <andre@linux-ide.org>
++ * Portions Copyright (C) 2001 Sun Microsystems, Inc.
++ * Portions Copyright (C) 2003 Red Hat Inc
++ *
++ *
++ * TODO
++ * 371N
++ * Work out best PLL policy
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "hpt3x2n"
++#define DRV_VERSION "0.1"
++
++enum {
++ HPT_PCI_FAST = (1 << 31),
++ PCI66 = (1 << 1),
++ USE_DPLL = (1 << 0)
++};
++
++struct hpt_clock {
++ u8 xfer_speed;
++ u32 timing;
++};
++
++struct hpt_chip {
++ const char *name;
++ struct hpt_clock *clocks[3];
++};
++
++/* key for bus clock timings
++ * bit
++ * 0:3 data_high_time. inactive time of DIOW_/DIOR_ for PIO and MW
++ * DMA. cycles = value + 1
++ * 4:8 data_low_time. active time of DIOW_/DIOR_ for PIO and MW
++ * DMA. cycles = value + 1
++ * 9:12 cmd_high_time. inactive time of DIOW_/DIOR_ during task file
++ * register access.
++ * 13:17 cmd_low_time. active time of DIOW_/DIOR_ during task file
++ * register access.
++ * 18:21 udma_cycle_time. clock freq and clock cycles for UDMA xfer.
++ * during task file register access.
++ * 22:24 pre_high_time. time to initialize 1st cycle for PIO and MW DMA
++ * xfer.
++ * 25:27 cmd_pre_high_time. time to initialize 1st PIO cycle for task
++ * register access.
++ * 28 UDMA enable
++ * 29 DMA enable
++ * 30 PIO_MST enable. if set, the chip is in bus master mode during
++ * PIO.
++ * 31 FIFO enable.
++ */
++
++/* 66MHz DPLL clocks */
++
++static struct hpt_clock hpt3x2n_clocks[] = {
++ { XFER_UDMA_7, 0x1c869c62 },
++ { XFER_UDMA_6, 0x1c869c62 },
++ { XFER_UDMA_5, 0x1c8a9c62 },
++ { XFER_UDMA_4, 0x1c8a9c62 },
++ { XFER_UDMA_3, 0x1c8e9c62 },
++ { XFER_UDMA_2, 0x1c929c62 },
++ { XFER_UDMA_1, 0x1c9a9c62 },
++ { XFER_UDMA_0, 0x1c829c62 },
++
++ { XFER_MW_DMA_2, 0x2c829c62 },
++ { XFER_MW_DMA_1, 0x2c829c66 },
++ { XFER_MW_DMA_0, 0x2c829d2c },
++
++ { XFER_PIO_4, 0x0c829c62 },
++ { XFER_PIO_3, 0x0c829c84 },
++ { XFER_PIO_2, 0x0c829ca6 },
++ { XFER_PIO_1, 0x0d029d26 },
++ { XFER_PIO_0, 0x0d029d5e },
++ { 0, 0x0d029d5e }
++};
++
++/**
++ * hpt3x2n_find_mode - reset the hpt3x2n bus
++ * @ap: ATA port
++ * @speed: transfer mode
++ *
++ * Return the 32bit register programming information for this channel
++ * that matches the speed provided. For the moment the clocks table
++ * is hard coded but easy to change. This will be needed if we use
++ * different DPLLs
++ */
++
++static u32 hpt3x2n_find_mode(struct ata_port *ap, int speed)
++{
++ struct hpt_clock *clocks = hpt3x2n_clocks;
++
++ while(clocks->xfer_speed) {
++ if (clocks->xfer_speed == speed)
++ return clocks->timing;
++ clocks++;
++ }
++ BUG();
++}
++
++/**
++ * hpt3x2n_phy_reset - reset the hpt3x2n bus
++ * @ap: ATA port to reset
++ *
++ * Perform the PHY reset handling for the 3x2N
++ */
++
++static void hpt3x2n_phy_reset(struct ata_port *ap)
++{
++ u8 scr2, ata66;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_byte(pdev, 0x5B, &scr2);
++ pci_write_config_byte(pdev, 0x5B, scr2 & ~0x01);
++ /* Cable register now active */
++ pci_read_config_byte(pdev, 0x5A, &ata66);
++ /* Restore state */
++ pci_write_config_byte(pdev, 0x5B, scr2);
++
++ if (ata66 & (1 << ap->hard_port_no))
++ ap->cbl = ATA_CBL_PATA40;
++ else
++ ap->cbl = ATA_CBL_PATA80;
++
++ /* Reset the state machine */
++ pci_write_config_byte(pdev, 0x50, 0x37);
++ pci_write_config_byte(pdev, 0x54, 0x37);
++ udelay(100);
++
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++/**
++ * hpt3x2n_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Perform PIO mode setup.
++ */
++
++static void hpt3x2n_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ fast &= ~0x07;
++ pci_write_config_byte(pdev, addr2, fast);
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt3x2n_find_mode(ap, adev->pio_mode);
++ mode &= ~0x8000000; /* No FIFO in PIO */
++ mode &= ~0x30070000; /* Leave config bits alone */
++ reg &= 0x30070000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt3x2n_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * Set up the channel for MWDMA or UDMA modes. Much the same as with
++ * PIO, load the mode number and then set MWDMA or UDMA flag.
++ */
++
++static void hpt3x2n_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 addr1, addr2;
++ u32 reg;
++ u32 mode;
++ u8 fast;
++
++ addr1 = 0x40 + 4 * (adev->devno + 2 * ap->hard_port_no);
++ addr2 = 0x51 + 4 * ap->hard_port_no;
++
++ /* Fast interrupt prediction disable, hold off interrupt disable */
++ pci_read_config_byte(pdev, addr2, &fast);
++ fast &= ~0x07;
++ pci_write_config_byte(pdev, addr2, fast);
++
++ pci_read_config_dword(pdev, addr1, &reg);
++ mode = hpt3x2n_find_mode(ap, adev->dma_mode);
++ mode |= 0x8000000; /* FIFO in MWDMA or UDMA */
++ mode &= ~0xC0000000; /* Leave config bits alone */
++ reg &= 0xC0000000; /* Strip timing bits */
++ pci_write_config_dword(pdev, addr1, reg | mode);
++}
++
++/**
++ * hpt3x2n_bmdma_end - DMA engine stop
++ * @qc: ATA command
++ *
++ * Clean up after the HPT3x2n and later DMA engine
++ */
++
++static void hpt3x2n_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int mscreg = 0x50 + 2 * ap->hard_port_no;
++ u8 bwsr_stat, msc_stat;
++
++ pci_read_config_byte(pdev, 0x6A, &bwsr_stat);
++ pci_read_config_byte(pdev, mscreg, &msc_stat);
++ if (bwsr_stat & (1 << ap->hard_port_no))
++ pci_write_config_byte(pdev, mscreg, msc_stat | 0x30);
++ ata_bmdma_stop(qc);
++}
++
++/**
++ * hpt3x2n_set_clock - clock control
++ * @ap: ATA port
++ * @source: 0x21 or 0x23 for PLL or PCI sourced clock
++ *
++ * Switch the ATA bus clock between the PLL and PCI clock sources
++ * while correctly isolating the bus and resetting internal logic
++ *
++ * We must use the DPLL for
++ * - writing
++ * - second channel UDMA7 (SATA ports) or higher
++ * - 66MHz PCI
++ *
++ * or we will underclock the device and get reduced performance.
++ */
++
++static void hpt3x2n_set_clock(struct ata_port *ap, int source)
++{
++ unsigned long bmdma = ap->ioaddr.bmdma_addr;
++
++ /* Tristate the bus */
++ outb(0x80, bmdma+0x73);
++ outb(0x80, bmdma+0x77);
++
++ /* Switch clock and reset channels */
++ outb(source, bmdma+0x7B);
++ outb(0xC0, bmdma+0x79);
++
++ /* Reset state machines */
++ outb(0x37, bmdma+0x70);
++ outb(0x37, bmdma+0x74);
++
++ /* Complete reset */
++ outb(0x00, bmdma+0x79);
++
++ /* Reconnect channels to bus */
++ outb(0x00, bmdma+0x73);
++ outb(0x00, bmdma+0x77);
++}
++
++/* Check if our partner interface is busy */
++
++static int hpt3x2n_pair_idle(struct ata_port *ap)
++{
++ struct ata_host_set *host = ap->host_set;
++ struct ata_port *pair = host->ports[ap->hard_port_no ^ 1];
++
++ if (pair->hsm_task_state == HSM_ST_IDLE)
++ return 1;
++ return 0;
++}
++
++static int hpt3x2n_use_dpll(struct ata_port *ap, int reading)
++{
++ long flags = (long)ap->host_set->private_data;
++ /* See if we should use the DPLL */
++ if (reading == 0)
++ return USE_DPLL; /* Needed for write */
++ if (flags & PCI66)
++ return USE_DPLL; /* Needed at 66Mhz */
++ return 0;
++}
++
++static int hpt3x2n_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_taskfile *tf = &qc->tf;
++ struct ata_port *ap = qc->ap;
++ int flags = (long)ap->host_set->private_data;
++
++ if (hpt3x2n_pair_idle(ap)) {
++ int dpll = hpt3x2n_use_dpll(ap, (tf->flags & ATA_TFLAG_WRITE));
++ if ((flags & USE_DPLL) != dpll) {
++ if (dpll == 1)
++ hpt3x2n_set_clock(ap, 0x21);
++ else
++ hpt3x2n_set_clock(ap, 0x23);
++ }
++ }
++ return ata_qc_issue_prot(qc);
++}
++
++static struct scsi_host_template hpt3x2n_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++/*
++ * Configuration for HPT3x2n.
++ */
++
++static struct ata_port_operations hpt3x2n_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = hpt3x2n_set_piomode,
++ .set_dmamode = hpt3x2n_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = hpt3x2n_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = hpt3x2n_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = hpt3x2n_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * hpt3xn_calibrate_dpll - Calibrate the DPLL loop
++ * @dev: PCI device
++ *
++ * Perform a calibration cycle on the HPT3xN DPLL. Returns 1 if this
++ * succeeds
++ */
++
++static int hpt3xn_calibrate_dpll(struct pci_dev *dev)
++{
++ u8 reg5b;
++ u32 reg5c;
++ int tries;
++
++ for(tries = 0; tries < 0x5000; tries++) {
++ udelay(50);
++ pci_read_config_byte(dev, 0x5b, &reg5b);
++ if (reg5b & 0x80) {
++ /* See if it stays set */
++ for(tries = 0; tries < 0x1000; tries ++) {
++ pci_read_config_byte(dev, 0x5b, &reg5b);
++ /* Failed ? */
++ if ((reg5b & 0x80) == 0)
++ return 0;
++ }
++ /* Turn off tuning, we have the DPLL set */
++ pci_read_config_dword(dev, 0x5c, &reg5c);
++ pci_write_config_dword(dev, 0x5c, reg5c & ~ 0x100);
++ return 1;
++ }
++ }
++ /* Never went stable */
++ return 0;
++}
++
++static int hpt3x2n_pci_clock(struct pci_dev *pdev)
++{
++ unsigned long freq;
++ u32 fcnt;
++
++ pci_read_config_dword(pdev, 0x70/*CHECKME*/, &fcnt);
++ if ((fcnt >> 12) != 0xABCDE) {
++ printk(KERN_WARNING "hpt3xn: BIOS clock data not set.\n");
++ return 33; /* Not BIOS set */
++ }
++ fcnt &= 0x1FF;
++
++ freq = (fcnt * 77) / 192;
++
++ /* Clamp to bands */
++ if (freq < 40)
++ return 33;
++ if (freq < 45)
++ return 40;
++ if (freq < 55)
++ return 50;
++ return 66;
++}
++
++/**
++ * hpt3x2n_init_one - Initialise an HPT37X/302
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Initialise an HPT3x2n device. There are some interesting complications
++ * here. Firstly the chip may report 366 and be one of several variants.
++ * Secondly all the timings depend on the clock for the chip which we must
++ * detect and look up
++ *
++ * This is the known chip mappings. It may be missing a couple of later
++ * releases.
++ *
++ * Chip version PCI Rev Notes
++ * HPT372 4 (HPT366) 5 Other driver
++ * HPT372N 4 (HPT366) 6 UDMA133
++ * HPT372 5 (HPT372) 1 Other driver
++ * HPT372N 5 (HPT372) 2 UDMA133
++ * HPT302 6 (HPT302) * Other driver
++ * HPT302N 6 (HPT302) > 1 UDMA133
++ * HPT371 7 (HPT371) * Other driver
++ * HPT371N 7 (HPT371) > 1 UDMA133
++ * HPT374 8 (HPT374) * Other driver
++ * HPT372N 9 (HPT372N) * UDMA133
++ *
++ * (1) UDMA133 support depends on the bus clock
++ *
++ * To pin down HPT371N
++ */
++
++static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ /* HPT372N and friends - UDMA133 */
++ static struct ata_port_info info = {
++ .sht = &hpt3x2n_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &hpt3x2n_port_ops
++ };
++ struct ata_port_info *port_info[2];
++ struct ata_port_info *port = &info;
++
++ u8 irqmask;
++ u32 class_rev;
++
++ unsigned int pci_mhz;
++ unsigned int f_low, f_high;
++ int adjust;
++
++ pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
++ class_rev &= 0xFF;
++
++ switch(dev->device) {
++ case PCI_DEVICE_ID_TTI_HPT366:
++ if (class_rev < 6)
++ return -ENODEV;
++ break;
++ case PCI_DEVICE_ID_TTI_HPT372:
++ /* 372N if rev >= 1*/
++ if (class_rev == 0)
++ return -ENODEV;
++ break;
++ case PCI_DEVICE_ID_TTI_HPT302:
++ if (class_rev < 2)
++ return -ENODEV;
++ break;
++ case PCI_DEVICE_ID_TTI_HPT372N:
++ break;
++ default:
++ printk(KERN_ERR "pata_hpt3x2n: PCI table is bogus please report (%d).\n", dev->device);
++ return -ENODEV;
++ }
++
++ /* Ok so this is a chip we support */
++
++ pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, (L1_CACHE_BYTES / 4));
++ pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x78);
++ pci_write_config_byte(dev, PCI_MIN_GNT, 0x08);
++ pci_write_config_byte(dev, PCI_MAX_LAT, 0x08);
++
++ pci_read_config_byte(dev, 0x5A, &irqmask);
++ irqmask &= ~0x10;
++ pci_write_config_byte(dev, 0x5a, irqmask);
++
++ /* Tune the PLL. HPT recommend using 75 for SATA, 66 for UDMA133 or
++ 50 for UDMA100. Right now we always use 66 */
++
++ pci_mhz = hpt3x2n_pci_clock(dev);
++
++ f_low = (pci_mhz * 48) / 66; /* PCI Mhz for 66Mhz DPLL */
++ f_high = f_low + 2; /* Tolerance */
++
++ pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low | 0x100);
++ /* PLL clock */
++ pci_write_config_byte(dev, 0x5B, 0x21);
++
++ /* Unlike the 37x we don't try jiggling the frequency */
++ for(adjust = 0; adjust < 8; adjust++) {
++ if (hpt3xn_calibrate_dpll(dev))
++ break;
++ pci_write_config_dword(dev, 0x5C, (f_high << 16) | f_low);
++ }
++ if (adjust == 8)
++ printk(KERN_WARNING "hpt3xn: DPLL did not stabilize.\n");
++
++ /* Set our private data up. We only need a few flags so we use
++ it directly */
++ port->private_data = NULL;
++ if (pci_mhz > 60)
++ port->private_data = (void *)PCI66;
++
++ /* Now kick off ATA set up */
++ port_info[0] = port_info[1] = port;
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id hpt3x2n[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT366), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT372), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT302), },
++ { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT372N), },
++ { 0, },
++};
++
++static struct pci_driver hpt3x2n_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = hpt3x2n,
++ .probe = hpt3x2n_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init hpt3x2n_init(void)
++{
++ return pci_register_driver(&hpt3x2n_pci_driver);
++}
++
++
++static void __exit hpt3x2n_exit(void)
++{
++ pci_unregister_driver(&hpt3x2n_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the Highpoint HPT3x2n/30x");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, hpt3x2n);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(hpt3x2n_init);
++module_exit(hpt3x2n_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_isapnp.c linux-2.6.16-rc4/drivers/scsi/pata_isapnp.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_isapnp.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_isapnp.c 2006-01-21 16:52:31.000000000 +0000
+@@ -0,0 +1,151 @@
++
++/*
++ * pata-isapnp.c - ISA PnP PATA controller driver.
++ * Copyright 2005/2006 Red Hat Inc <alan@redhat.com>, all rights reserved.
++ *
++ * Based in part on ide-pnp.c by Andrey Panin <pazke@donpac.ru>
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/isapnp.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/ata.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_isapnp"
++#define DRV_VERSION "0.1"
++
++static struct scsi_host_template isapnp_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations isapnp_port_ops = {
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * isapnp_init_one - attach an isapnp interface
++ * @idev: PnP device
++ * @dev_id: matching detect line
++ *
++ * Register an ISA bus IDE interface. Such interfaces are PIO 0 and
++ * non shared IRQ.
++ */
++
++static int isapnp_init_one(struct pnp_dev *idev, const struct pnp_device_id *dev_id)
++{
++ struct ata_probe_ent ae;
++
++ if (pnp_port_valid(idev, 0) == 0)
++ return -ENODEV;
++ if (pnp_port_valid(idev, 1) == 0)
++ return -ENODEV;
++
++ /* FIXME: Should selected polled PIO here not fail */
++ if (pnp_irq_valid(idev, 0) == 0)
++ return -ENODEV;
++
++ memset(&ae, 0, sizeof(struct ata_probe_ent));
++ INIT_LIST_HEAD(&ae.node);
++ ae.dev = &idev->dev;
++ ae.port_ops = &isapnp_port_ops;
++ ae.sht = &isapnp_sht;
++ ae.n_ports = 1;
++ ae.pio_mask = 1; /* ISA so PIO 0 cycles */
++ ae.irq = pnp_irq(idev, 0);
++ ae.irq_flags = 0;
++ ae.host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_IRQ_MASK;
++ ae.port[0].cmd_addr = pnp_port_start(idev, 0);
++ ae.port[0].altstatus_addr = pnp_port_start(idev, 1);
++ ae.port[0].ctl_addr = pnp_port_start(idev, 1);
++ ata_std_ports(&ae.port[0]);
++
++ if (ata_device_add(&ae) == 0)
++ return -ENODEV;
++ return 0;
++}
++
++/**
++ * isapnp_remove_one - unplug an isapnp interface
++ * @idev: PnP device
++ *
++ * Remove a previously configured PnP ATA port. Called only on module
++ * unload events as the core does not currently deal with ISAPnP docking.
++ */
++
++static void isapnp_remove_one(struct pnp_dev *idev)
++{
++ struct device *dev = &idev->dev;
++ struct ata_host_set *host_set = dev_get_drvdata(dev);
++
++ ata_host_set_remove(host_set);
++ dev_set_drvdata(dev, NULL);
++}
++
++static struct pnp_device_id isapnp_devices[] = {
++ /* Generic ESDI/IDE/ATA compatible hard disk controller */
++ {.id = "PNP0600", .driver_data = 0},
++ {.id = ""}
++};
++
++static struct pnp_driver isapnp_driver = {
++ .name = DRV_NAME,
++ .id_table = isapnp_devices,
++ .probe = isapnp_init_one,
++ .remove = isapnp_remove_one,
++};
++
++static int __init isapnp_init(void)
++{
++ return pnp_register_driver(&isapnp_driver);
++}
++
++static void __exit isapnp_exit(void)
++{
++ pnp_unregister_driver(&isapnp_driver);
++}
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for ISA PnP ATA");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(isapnp_init);
++module_exit(isapnp_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_it8172.c linux-2.6.16-rc4/drivers/scsi/pata_it8172.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_it8172.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_it8172.c 2006-02-16 15:39:11.000000000 +0000
+@@ -0,0 +1,280 @@
++/*
++ * pata_it8172.c - IT8172 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based heavily on
++ *
++ * BRIEF MODULE DESCRIPTION
++ * IT8172 IDE controller support
++ *
++ * Copyright 2000 MontaVista Software Inc.
++ * Author: MontaVista Software, Inc.
++ * stevel@mvista.com or source@mvista.com
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License as published by the
++ * Free Software Foundation; either version 2 of the License, or (at your
++ * option) any later version.
++ *
++ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
++ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
++ * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
++ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
++ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write to the Free Software Foundation, Inc.,
++ * 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ * TODO
++ * Check for errata
++ * See if we really need to force native mode
++ * PIO timings (also lacking in original)
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "it8172"
++#define DRV_VERSION "0.1.1"
++
++static void it8172_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits it8172_enable_bits[] = {
++ { 0x00, 0, 0x00, 0x00 },
++ { 0x40, 1, 0x00, 0x01 }
++ };
++
++ if (ap->hard_port_no && !pci_test_config_bits(pdev, &it8172_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * it8172_set_pio_timing - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called by both the pio and dma setup functions to set the controller
++ * timings for PIO transfers. We must load both the mode number and
++ * timing values into the controller.
++ */
++
++static void it8172_set_pio_timing(struct ata_port *ap, struct ata_device *adev, int pio)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u16 reg40;
++
++ pci_read_config_word(pdev, 0x40, &reg40);
++
++ /*
++ * FIX! The DIOR/DIOW pulse width and recovery times in port 0x44
++ * are being left at the default values of 8 PCI clocks (242 nsec
++ * for a 33 MHz clock). These can be safely shortened at higher
++ * PIO modes. The DIOR/DIOW pulse width and recovery times only
++ * apply to PIO modes, not to the DMA modes.
++ */
++
++ /*
++ * Enable port 0x44. The IT8172G spec is confused; it calls
++ * this register the "Slave IDE Timing Register", but in fact,
++ * it controls timing for both master and slave drives.
++ */
++
++ reg40 |= 0x4000;
++ if (adev->devno) {
++ reg40 |= 0xC006;
++ if (pio > 1)
++ /* Enable prefetch and IORDY sample-point */
++ reg40 |= 0x0060;
++ } else {
++ reg40 |= 0xC060;
++ if (pio > 1)
++ /* Enable prefetch and IORDY sample-point */
++ reg40 |= 0x0006;
++ }
++ /* Write back the enables */
++ pci_write_config_word(pdev, 0x40, reg40);
++}
++
++/**
++ * it8172_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup. We use a shared helper for this
++ * as the DMA setup must also adjust the PIO timing information.
++ */
++
++static void it8172_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ it8172_set_pio_timing(ap, adev, adev->pio_mode - XFER_PIO_0);
++}
++
++/**
++ * it8172_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the DMA mode setup. We must tune an appropriate PIO
++ * mode to match.
++ */
++
++static void it8172_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int dn = (2 * ap->hard_port_no) + adev->devno;
++ u8 reg48, reg4a;
++ int pio;
++
++ static int pio_map[] = { 1, 3, 4};
++ /*
++ * Setting the DMA cycle time to 2 or 3 PCI clocks (60 and 91 nsec
++ * at 33 MHz PCI clock) seems to cause BadCRC errors during DMA
++ * transfers on some drives, even though both numbers meet the minimum
++ * ATAPI-4 spec of 73 and 54 nsec for UDMA 1 and 2 respectively.
++ * So the faster times are just commented out here. The good news is
++ * that the slower cycle time has very little affect on transfer
++ * performance.
++ */
++
++ pci_read_config_byte(pdev, 0x48, &reg48);
++ pci_read_config_byte(pdev, 0x4A, &reg4a);
++
++ reg4a &= ~(3 << (4 * dn));
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ reg48 |= 1 << dn;
++#ifdef UDMA_TIMING_SET
++ reg4a |= ((adev->dma_mode - XFER_UDMA_0) << (4 * dn));
++#endif
++ pio = 4;
++ } else {
++ pio = pio_map[adev->dma_mode - XFER_MW_DMA_0];
++ reg48 &= ~ (1 << dn);
++ }
++ pci_write_config_byte(pdev, 0x48, reg48);
++ pci_write_config_byte(pdev, 0x4A, reg4a);
++ it8172_set_pio_timing(ap, adev, pio);
++
++}
++
++static struct scsi_host_template it8172_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations it8172_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = it8172_set_piomode,
++ .set_dmamode = it8172_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = it8172_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int it8172_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &it8172_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x06, /* No MWDMA0 support */
++ .udma_mask = 0x7,
++ .port_ops = &it8172_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ if ((!(PCI_FUNC(dev->devfn) & 1) ||
++ (!((dev->class >> 8) == PCI_CLASS_STORAGE_IDE))))
++ return -ENODEV; /* IT8172 is more than an IDE controller */
++
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id it8172[] = {
++ { PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_IT8172G, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { 0, },
++};
++
++static struct pci_driver it8172_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = it8172,
++ .probe = it8172_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init it8172_init(void)
++{
++ return pci_register_driver(&it8172_pci_driver);
++}
++
++
++static void __exit it8172_exit(void)
++{
++ pci_unregister_driver(&it8172_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for ITE IT8172");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, it8172);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(it8172_init);
++module_exit(it8172_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_it821x.c linux-2.6.16-rc4/drivers/scsi/pata_it821x.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_it821x.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_it821x.c 2006-02-20 12:27:55.000000000 +0000
+@@ -0,0 +1,743 @@
++/*
++ * ata-it821x.c - IT821x PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * based upon
++ *
++ * it821x.c
++ *
++ * linux/drivers/ide/pci/it821x.c Version 0.09 December 2004
++ *
++ * Copyright (C) 2004 Red Hat <alan@redhat.com>
++ *
++ * May be copied or modified under the terms of the GNU General Public License
++ * Based in part on the ITE vendor provided SCSI driver.
++ *
++ * Documentation available from
++ * http://www.ite.com.tw/pc/IT8212F_V04.pdf
++ * Some other documents are NDA.
++ *
++ * The ITE8212 isn't exactly a standard IDE controller. It has two
++ * modes. In pass through mode then it is an IDE controller. In its smart
++ * mode its actually quite a capable hardware raid controller disguised
++ * as an IDE controller. Smart mode only understands DMA read/write and
++ * identify, none of the fancier commands apply. The IT8211 is identical
++ * in other respects but lacks the raid mode.
++ *
++ * Errata:
++ * o Rev 0x10 also requires master/slave hold the same DMA timings and
++ * cannot do ATAPI MWDMA.
++ * o The identify data for raid volumes lacks CHS info (technically ok)
++ * but also fails to set the LBA28 and other bits. We fix these in
++ * the IDE probe quirk code.
++ * o If you write LBA48 sized I/O's (ie > 256 sector) in smart mode
++ * raid then the controller firmware dies
++ * o Smart mode without RAID doesn't clear all the necessary identify
++ * bits to reduce the command set to the one used
++ *
++ * This has a few impacts on the driver
++ * - In pass through mode we do all the work you would expect
++ * - In smart mode the clocking set up is done by the controller generally
++ * but we must watch the other limits and filter.
++ * - There are a few extra vendor commands that actually talk to the
++ * controller but only work PIO with no IRQ.
++ *
++ * Vendor areas of the identify block in smart mode are used for the
++ * timing and policy set up. Each HDD in raid mode also has a serial
++ * block on the disk. The hardware extra commands are get/set chip status,
++ * rebuild, get rebuild status.
++ *
++ * In Linux the driver supports pass through mode as if the device was
++ * just another IDE controller. If the smart mode is running then
++ * volumes are managed by the controller firmware and each IDE "disk"
++ * is a raid volume. Even more cute - the controller can do automated
++ * hotplug and rebuild.
++ *
++ * The pass through controller itself is a little demented. It has a
++ * flaw that it has a single set of PIO/MWDMA timings per channel so
++ * non UDMA devices restrict each others performance. It also has a
++ * single clock source per channel so mixed UDMA100/133 performance
++ * isn't perfect and we have to pick a clock. Thankfully none of this
++ * matters in smart mode. ATAPI DMA is not currently supported.
++ *
++ * It seems the smart mode is a win for RAID1/RAID10 but otherwise not.
++ *
++ * TODO
++ * - ATAPI and other speed filtering
++ * - Command filter in smart mode
++ * - RAID configuration ioctls
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++
++#define DRV_NAME "it821x"
++#define DRV_VERSION "0.2.1"
++
++struct it821x_dev
++{
++ unsigned int smart:1, /* Are we in smart raid mode */
++ timing10:1; /* Rev 0x10 */
++ u8 clock_mode; /* 0, ATA_50 or ATA_66 */
++ u8 want[2][2]; /* Mode/Pri log for master slave */
++ /* We need these for switching the clock when DMA goes on/off
++ The high byte is the 66Mhz timing */
++ u16 pio[2]; /* Cached PIO values */
++ u16 mwdma[2]; /* Cached MWDMA values */
++ u16 udma[2]; /* Cached UDMA values (per drive) */
++ u16 last_device; /* Master or slave loaded ? */
++};
++
++#define ATA_66 0
++#define ATA_50 1
++#define ATA_ANY 2
++
++#define UDMA_OFF 0
++#define MWDMA_OFF 0
++
++/*
++ * We allow users to force the card into non raid mode without
++ * flashing the alternative BIOS. This is also neccessary right now
++ * for embedded platforms that cannot run a PC BIOS but are using this
++ * device.
++ */
++
++static int it8212_noraid;
++
++
++/**
++ * it821x_phy_reset - probe/reset
++ * @ap: ATA port
++ *
++ * Set the cable type and trigger a probe
++ */
++
++static void it821x_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA80;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * it821x_program - program the PIO/MWDMA registers
++ * @ap: ATA port
++ * @adev: Device to program
++ * @timing: Timing value (66Mhz in top 8bits, 50 in the low 8)
++ *
++ * Program the PIO/MWDMA timing for this channel according to the
++ * current clock. These share the same register so are managed by
++ * the DMA start/stop sequence as with the old driver.
++ */
++
++static void it821x_program(struct ata_port *ap, struct ata_device *adev, u16 timing)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct it821x_dev *itdev = ap->private_data;
++ int channel = ap->hard_port_no;
++ u8 conf;
++
++ /* Program PIO/MWDMA timing bits */
++ if (itdev->clock_mode == ATA_66)
++ conf = timing >> 8;
++ else
++ conf = timing & 0xFF;
++ pci_write_config_byte(pdev, 0x54 + 4 * channel, conf);
++}
++
++
++/**
++ * it821x_program_udma - program the UDMA registers
++ * @ap: ATA port
++ * @adev: ATA device to update
++ * @timing: Timing bits. Top 8 are for 66Mhz bottom for 50Mhz
++ *
++ * Program the UDMA timing for this drive according to the
++ * current clock. Handles the dual clocks and also knows about
++ * the errata on the 0x10 revision. The UDMA errata is partly handled
++ * here and partly in start_dma.
++ */
++
++static void it821x_program_udma(struct ata_port *ap, struct ata_device *adev, u16 timing)
++{
++ struct it821x_dev *itdev = ap->private_data;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int channel = ap->hard_port_no;
++ int unit = adev->devno;
++ u8 conf;
++
++ /* Program UDMA timing bits */
++ if (itdev->clock_mode == ATA_66)
++ conf = timing >> 8;
++ else
++ conf = timing & 0xFF;
++ if (itdev->timing10 == 0)
++ pci_write_config_byte(pdev, 0x56 + 4 * channel + unit, conf);
++ else {
++ /* Early revision must be programmed for both together */
++ pci_write_config_byte(pdev, 0x56 + 4 * channel, conf);
++ pci_write_config_byte(pdev, 0x56 + 4 * channel + 1, conf);
++ }
++}
++
++/**
++ * it821x_clock_strategy
++ * @ap: ATA interface
++ * @adev: ATA device being updated
++ *
++ * Select between the 50 and 66Mhz base clocks to get the best
++ * results for this interface.
++ */
++
++static void it821x_clock_strategy(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct it821x_dev *itdev = ap->private_data;
++ u8 unit = adev->devno;
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++
++ int clock, altclock;
++ u8 v;
++ int sel = 0;
++
++ /* Look for the most wanted clocking */
++ if (itdev->want[0][0] > itdev->want[1][0]) {
++ clock = itdev->want[0][1];
++ altclock = itdev->want[1][1];
++ } else {
++ clock = itdev->want[1][1];
++ altclock = itdev->want[0][1];
++ }
++
++ /* Master doesn't care does the slave ? */
++ if (clock == ATA_ANY)
++ clock = altclock;
++
++ /* Nobody cares - keep the same clock */
++ if (clock == ATA_ANY)
++ return;
++ /* No change */
++ if (clock == itdev->clock_mode)
++ return;
++
++ /* Load this into the controller ? */
++ if (clock == ATA_66)
++ itdev->clock_mode = ATA_66;
++ else {
++ itdev->clock_mode = ATA_50;
++ sel = 1;
++ }
++ pci_read_config_byte(pdev, 0x50, &v);
++ v &= ~(1 << (1 + ap->hard_port_no));
++ v |= sel << (1 + ap->hard_port_no);
++ pci_write_config_byte(pdev, 0x50, v);
++
++ /*
++ * Reprogram the UDMA/PIO of the pair drive for the switch
++ * MWDMA will be dealt with by the dma switcher
++ */
++ if (pair && itdev->udma[1-unit] != UDMA_OFF) {
++ it821x_program_udma(ap, pair, itdev->udma[1-unit]);
++ it821x_program(ap, pair, itdev->pio[1-unit]);
++ }
++ /*
++ * Reprogram the UDMA/PIO of our drive for the switch.
++ * MWDMA will be dealt with by the dma switcher
++ */
++ if (itdev->udma[unit] != UDMA_OFF) {
++ it821x_program_udma(ap, adev, itdev->udma[unit]);
++ it821x_program(ap, adev, itdev->pio[unit]);
++ }
++}
++
++/**
++ * it821x_passthru_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Configure for PIO mode. This is complicated as the register is
++ * shared by PIO and MWDMA and for both channels.
++ */
++
++static void it821x_passthru_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ /* Spec says 89 ref driver uses 88 */
++ static u16 pio[] = { 0xAA88, 0xA382, 0xA181, 0x3332, 0x3121 };
++ static u8 pio_want[] = { ATA_66, ATA_66, ATA_66, ATA_66, ATA_ANY };
++
++ struct it821x_dev *itdev = ap->private_data;
++ int unit = adev->devno;
++ int mode_wanted = adev->pio_mode - XFER_PIO_0;
++
++ /* We prefer 66Mhz clock for PIO 0-3, don't care for PIO4 */
++ itdev->want[unit][1] = pio_want[mode_wanted];
++ itdev->want[unit][0] = 1; /* PIO is lowest priority */
++ itdev->pio[unit] = pio[mode_wanted];
++ it821x_clock_strategy(ap, adev);
++ it821x_program(ap, adev, itdev->pio[unit]);
++}
++
++/**
++ * it821x_passthru_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Set up the DMA modes. The actions taken depend heavily on the mode
++ * to use. If UDMA is used as is hopefully the usual case then the
++ * timing register is private and we need only consider the clock. If
++ * we are using MWDMA then we have to manage the setting ourself as
++ * we switch devices and mode.
++ */
++
++static void it821x_passthru_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u16 dma[] = { 0x8866, 0x3222, 0x3121 };
++ static u8 mwdma_want[] = { ATA_ANY, ATA_66, ATA_ANY };
++ static u16 udma[] = { 0x4433, 0x4231, 0x3121, 0x2121, 0x1111, 0x2211, 0x1111 };
++ static u8 udma_want[] = { ATA_ANY, ATA_50, ATA_ANY, ATA_66, ATA_66, ATA_50, ATA_66 };
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct it821x_dev *itdev = ap->private_data;
++ int channel = ap->hard_port_no;
++ int unit = adev->devno;
++ u8 conf;
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ int mode_wanted = adev->dma_mode - XFER_UDMA_0;
++
++ itdev->want[unit][1] = udma_want[mode_wanted];
++ itdev->want[unit][0] = 3; /* UDMA is high priority */
++ itdev->mwdma[unit] = MWDMA_OFF;
++ itdev->udma[unit] = udma[mode_wanted];
++ if (mode_wanted >= 5)
++ itdev->udma[unit] |= 0x8080; /* UDMA 5/6 select on */
++
++ /* UDMA on. Again revision 0x10 must do the pair */
++ pci_read_config_byte(pdev, 0x50, &conf);
++ if (itdev->timing10)
++ conf &= channel ? 0x9F: 0xE7;
++ else
++ conf &= ~ (1 << (3 + 2 * channel + unit));
++ pci_write_config_byte(pdev, 0x50, conf);
++ it821x_clock_strategy(ap, adev);
++ it821x_program_udma(ap, adev, itdev->udma[unit]);
++ } else {
++ int mode_wanted = adev->dma_mode - XFER_UDMA_0;
++
++ itdev->want[unit][1] = mwdma_want[mode_wanted];
++ itdev->want[unit][0] = 2; /* MWDMA is low priority */
++ itdev->mwdma[unit] = dma[mode_wanted];
++ itdev->udma[unit] = UDMA_OFF;
++
++ /* UDMA bits off - Revision 0x10 do them in pairs */
++ pci_read_config_byte(pdev, 0x50, &conf);
++ if (itdev->timing10)
++ conf |= channel ? 0x60: 0x18;
++ else
++ conf |= 1 << (3 + 2 * channel + unit);
++ pci_write_config_byte(pdev, 0x50, conf);
++ it821x_clock_strategy(ap, adev);
++ }
++}
++
++/**
++ * it821x_passthru_dma_start - DMA start callback
++ * @qc: Command in progress
++ *
++ * Usually drivers set the DMA timing at the point the set_dmamode call
++ * is made. IT821x however requires we load new timings on the
++ * transitions in some cases.
++ */
++
++static void it821x_passthru_bmdma_start(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ struct it821x_dev *itdev = ap->private_data;
++ int unit = adev->devno;
++
++ if (itdev->mwdma[unit] != MWDMA_OFF)
++ it821x_program(ap, adev, itdev->mwdma[unit]);
++ else if (itdev->udma[unit] != UDMA_OFF && itdev->timing10)
++ it821x_program_udma(ap, adev, itdev->udma[unit]);
++ ata_bmdma_start(qc);
++}
++
++/**
++ * it821x_passthru_dma_stop - DMA stop callback
++ * @qc: ATA command
++ *
++ * We loaded new timings in dma_start, as a result we need to restore
++ * the PIO timings in dma_stop so that the next command issue gets the
++ * right clock values.
++ */
++
++static void it821x_passthru_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ struct it821x_dev *itdev = ap->private_data;
++ int unit = adev->devno;
++
++ ata_bmdma_stop(qc);
++ if (itdev->mwdma[unit] != MWDMA_OFF)
++ it821x_program(ap, adev, itdev->pio[unit]);
++}
++
++
++/**
++ * it821x_passthru_dev_select - Select master/slave
++ * @ap: ATA port
++ * @device: Device number (not pointer)
++ *
++ * Device selection hook. If neccessary perform clock switching
++ */
++
++void it821x_passthru_dev_select(struct ata_port *ap, unsigned int device)
++{
++ struct it821x_dev *itdev = ap->private_data;
++ if (itdev && device != itdev->last_device) {
++ struct ata_device *adev = &ap->device[device];
++ it821x_program(ap, adev, itdev->pio[adev->devno]);
++ itdev->last_device = device;
++ }
++}
++
++/**
++ * it821x_passthru_qc_issue_prot - wrap qc issue prot
++ * @qc: command
++ *
++ * Wrap the command issue sequence for the IT821x. We need to
++ * perform out own device selection timing loads before the
++ * usual happenings kick off
++ */
++
++static int it821x_passthru_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ it821x_passthru_dev_select(qc->ap, qc->dev->devno);
++ return ata_qc_issue_prot(qc);
++}
++
++/**
++ * it821x_smart_set_mode - mode setting
++ * @ap: interface to set up
++ *
++ * Use a non standard set_mode function. We don't want to be tuned.
++ * The BIOS configured everything. Our job is not to fiddle. We
++ * read the dma enabled bits from the PCI configuration of the device
++ * and respect them.
++ */
++
++static void it821x_smart_set_mode(struct ata_port *ap)
++{
++ int dma_enabled;
++ int i;
++
++ /* Bits 5 and 6 indicate if DMA is active on master/slave */
++ dma_enabled = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
++
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *dev = &ap->device[i];
++ if (ata_dev_present(dev)) {
++ /* We don't really care */
++ dev->pio_mode = XFER_PIO_0;
++ dev->dma_mode = XFER_MW_DMA_0;
++ /* We do need the right mode information for DMA or PIO
++ and this comes from the current configuration flags */
++ if (dma_enabled & (1 << (5 + i))) {
++ dev->xfer_mode = XFER_MW_DMA_0;
++ dev->xfer_shift = ATA_SHIFT_MWDMA;
++ dev->flags &= ~ATA_DFLAG_PIO;
++ } else {
++ dev->xfer_mode = XFER_PIO_0;
++ dev->xfer_shift = ATA_SHIFT_PIO;
++ dev->flags |= ATA_DFLAG_PIO;
++ }
++ /* Keep sector count safe (LBA48 counts blow the
++ brains of the firmware) */
++
++ /* Do we need a dev_config method ? */
++ dev->flags |= ATA_DFLAG_LOCK_SECTORS;
++ }
++ }
++}
++
++/**
++ * it821x_check_atapi_dma - ATAPI DMA handler
++ * @qc: Command we are about to issue
++ *
++ * Decide if this ATAPI command can be issued by DMA on this
++ * controller. Return 0 if it can be.
++ */
++
++static int it821x_check_atapi_dma(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct it821x_dev *itdev = ap->private_data;
++
++ /* No ATAPI DMA in smart mode */
++ if (itdev->smart)
++ return -EOPNOTSUPP;
++ /* No ATAPI DMA on rev 10 */
++ if (itdev->timing10)
++ return -EOPNOTSUPP;
++ /* Cool */
++ return 0;
++}
++
++
++/**
++ * it821x_port_start - port setup
++ * @ap: ATA port being set up
++ *
++ * The it821x needs to maintain private data structures and also to
++ * use the standard PCI interface which lacks support for this
++ * functionality. We instead set up the private data on the port
++ * start hook, and tear it down on port stop
++ */
++
++static int it821x_port_start(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct it821x_dev *itdev;
++ u8 conf;
++
++ int ret = ata_port_start(ap);
++ if (ret < 0)
++ return ret;
++
++ ap->private_data = kmalloc(sizeof(struct it821x_dev), GFP_KERNEL);
++ if (ap->private_data == NULL) {
++ ata_port_stop(ap);
++ return -ENOMEM;
++ }
++
++ itdev = ap->private_data;
++ memset(itdev, 0, sizeof(struct it821x_dev));
++
++ pci_read_config_byte(pdev, 0x50, &conf);
++
++ if (conf & 1) {
++ itdev->smart = 1;
++ /* Long I/O's although allowed in LBA48 space cause the
++ onboard firmware to enter the twighlight zone */
++ /* No ATAPI DMA in this mode either */
++ }
++ /* Pull the current clocks from 0x50 */
++ if (conf & (1 << (1 + ap->hard_port_no)))
++ itdev->clock_mode = ATA_50;
++ else
++ itdev->clock_mode = ATA_66;
++
++ itdev->want[0][1] = ATA_ANY;
++ itdev->want[1][1] = ATA_ANY;
++ itdev->last_device = -1;
++
++ pci_read_config_byte(pdev, PCI_REVISION_ID, &conf);
++ if (conf == 0x10) {
++ itdev->timing10 = 1;
++ /* Need to disable ATAPI DMA for this case */
++ if (!itdev->smart)
++ printk(KERN_WARNING DRV_NAME": Revision 0x10, workarounds activated.\n");
++ }
++
++ return 0;
++}
++
++/**
++ * it821x_port_stop - port shutdown
++ * @ap: ATA port being removed
++ *
++ * Release the private objects we added in it821x_port_start
++ */
++
++static void it821x_port_stop(struct ata_port *ap) {
++ kfree(ap->private_data);
++ ap->private_data = NULL; /* We want an OOPS if we reuse this
++ too late! */
++ ata_port_stop(ap);
++}
++
++static struct scsi_host_template it821x_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ /* 255 sectors to begin with. This is locked in smart mode but not
++ in pass through */
++ .max_sectors = 255,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations it821x_smart_port_ops = {
++ .set_mode = it821x_smart_set_mode,
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .check_atapi_dma= it821x_check_atapi_dma,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = it821x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = it821x_port_start,
++ .port_stop = it821x_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations it821x_passthru_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = it821x_passthru_set_piomode,
++ .set_dmamode = it821x_passthru_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .check_atapi_dma= it821x_check_atapi_dma,
++ .dev_select = it821x_passthru_dev_select,
++
++ .phy_reset = it821x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = it821x_passthru_bmdma_start,
++ .bmdma_stop = it821x_passthru_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = it821x_passthru_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++ .irq_handler = ata_interrupt,
++ .port_start = it821x_port_start,
++ .port_stop = it821x_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static void __devinit it821x_disable_raid(struct pci_dev *pdev)
++{
++ /* Reset local CPU, and set BIOS not ready */
++ pci_write_config_byte(pdev, 0x5E, 0x01);
++
++ /* Set to bypass mode, and reset PCI bus */
++ pci_write_config_byte(pdev, 0x50, 0x00);
++ pci_write_config_word(pdev, PCI_COMMAND,
++ PCI_COMMAND_PARITY | PCI_COMMAND_IO |
++ PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
++ pci_write_config_word(pdev, 0x40, 0xA0F3);
++
++ pci_write_config_dword(pdev,0x4C, 0x02040204);
++ pci_write_config_byte(pdev, 0x42, 0x36);
++ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0);
++}
++
++
++static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ u8 conf;
++
++ static struct ata_port_info info_smart = {
++ .sht = &it821x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &it821x_smart_port_ops
++ };
++ static struct ata_port_info info_passthru = {
++ .sht = &it821x_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &it821x_passthru_port_ops
++ };
++ static struct ata_port_info *port_info[2];
++
++ static char *mode[2] = { "pass through", "smart" };
++
++ /* Force the card into bypass mode if so requested */
++ if (it8212_noraid) {
++ printk(KERN_INFO DRV_NAME ": forcing bypass mode.\n");
++ it821x_disable_raid(pdev);
++ }
++ pci_read_config_byte(pdev, 0x50, &conf);
++ conf &= 1;
++
++ printk(KERN_INFO DRV_NAME ": controller in %s mode.\n", mode[conf]);
++ if (conf == 0)
++ port_info[0] = port_info[1] = &info_passthru;
++ else
++ port_info[0] = port_info[1] = &info_smart;
++
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static struct pci_device_id it821x[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8211), },
++ { PCI_DEVICE(PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8212), },
++ { 0, },
++};
++
++static struct pci_driver it821x_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = it821x,
++ .probe = it821x_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init it821x_init(void)
++{
++ return pci_register_driver(&it821x_pci_driver);
++}
++
++
++static void __exit it821x_exit(void)
++{
++ pci_unregister_driver(&it821x_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for the IT8211/IT8212 IDE RAID controller");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, it821x);
++MODULE_VERSION(DRV_VERSION);
++
++
++module_param_named(noraid, it8212_noraid, int, S_IRUGO);
++MODULE_PARM_DESC(it8212_noraid, "Force card into bypass mode");
++
++module_init(it821x_init);
++module_exit(it821x_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_legacy.c linux-2.6.16-rc4/drivers/scsi/pata_legacy.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_legacy.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_legacy.c 2006-02-16 15:33:52.000000000 +0000
+@@ -0,0 +1,672 @@
++
++/*
++ * pata-legacy.c - Legacy port PATA/SATA controller driver.
++ * Copyright 2005/2006 Red Hat Inc <alan@redhat.com>, all rights reserved.
++ *
++ * An ATA driver for the legacy ATA ports.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/ata.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "legacy"
++#define DRV_VERSION "0.3.1"
++
++#define NR_HOST 6
++
++static int legacy_port[NR_HOST] = { 0x1f0, 0x170, 0x1e8, 0x168, 0x1e0, 0x160 };
++static int legacy_irq[NR_HOST] = { 15, 14, 11, 10, 8, 12 };
++
++static struct ata_host_set *legacy_host[NR_HOST];
++static int nr_legacy_host;
++static int legacy_all;
++static int ht6560a;
++static int ht6560b;
++static int opti82c611a;
++
++/**
++ * legacy_set_mode - mode setting
++ * @ap: IDE interface
++ *
++ * Use a non standard set_mode function. We don't want to be tuned.
++ *
++ * The BIOS configured everything. Our job is not to fiddle. Just use
++ * whatever PIO the hardware is using and leave it at that. When we
++ * get some kind of nice user driven API for control then we can
++ * expand on this as per hdparm in the base kernel.
++ */
++
++static void legacy_set_mode(struct ata_port *ap)
++{
++ int i;
++
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *dev = &ap->device[i];
++ if (ata_dev_present(dev)) {
++ dev->pio_mode = XFER_PIO_0;
++ dev->xfer_mode = XFER_PIO_0;
++ dev->xfer_shift = ATA_SHIFT_PIO;
++ dev->flags |= ATA_DFLAG_PIO;
++ }
++ }
++}
++
++static struct scsi_host_template legacy_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations legacy_port_ops = {
++ .set_mode = legacy_set_mode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer_noirq,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Promise 20230C and 20620 support
++ *
++ * This controller supports PIO0 to PIO2. We set PIO timings conservatively to
++ * allow for 50MHz Vesa Local Bus. The 20620 DMA support is weird being DMA to
++ * controller and PIO'd to the host and not supported.
++ */
++
++static void pdc20230_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ int tries = 5;
++ int pio = adev->pio_mode - XFER_PIO_0;
++ u8 rt;
++
++ do
++ {
++ inb(0x1F5);
++ outb(inb(0x1F2) | 0x80, 0x1F2);
++ inb(0x1F2);
++ inb(0x3F6);
++ inb(0x3F6);
++ inb(0x1F2);
++ inb(0x1F2);
++ }
++ while((inb(0x1F2) & 0x80) && --tries);
++
++ outb(inb(0x1F4) & 0x07, 0x1F4);
++
++ rt = inb(0x1F3);
++ rt &= 0x07 << (3 * adev->devno);
++ rt |= (3 * pio) << (3 * adev->devno);
++
++ udelay(100);
++ outb(inb(0x1F2) | 0x01, 0x1F2);
++ udelay(100);
++ inb(0x1F5);
++
++}
++
++static void pdc_data_xfer_vlb(struct ata_port *ap, struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
++{
++ int slop = buflen & 3;
++ unsigned long flags;
++
++ if (ata_id_has_dword_io(adev->id)) {
++ local_irq_save(flags);
++
++ /* Perform the 32bit I/O synchronization sequence */
++ inb(ap->ioaddr.nsect_addr);
++ inb(ap->ioaddr.nsect_addr);
++ inb(ap->ioaddr.nsect_addr);
++
++ /* Now the data */
++
++ if (write_data)
++ outsl(ap->ioaddr.data_addr, buf, buflen >> 2);
++ else
++ insl(ap->ioaddr.data_addr, buf, buflen >> 2);
++
++ if (unlikely(slop)) {
++ u32 pad;
++ if (write_data) {
++ memcpy(&pad, buf + buflen - slop, slop);
++ outl(le32_to_cpu(pad), ap->ioaddr.data_addr);
++ } else {
++ pad = cpu_to_le16(inl(ap->ioaddr.data_addr));
++ memcpy(buf + buflen - slop, &pad, slop);
++ }
++ }
++ local_irq_restore(flags);
++ }
++ else
++ ata_pio_data_xfer_noirq(ap, adev, buf, buflen, write_data);
++}
++
++static struct ata_port_operations pdc20230_port_ops = {
++ .set_piomode = pdc20230_set_piomode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = pdc_data_xfer_vlb,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Holtek 6560A support
++ *
++ * This controller supports PIO0 to PIO2 (no IORDY even though higher timings
++ * can be loaded).
++ */
++
++static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ u8 active, recover;
++ struct ata_timing t;
++
++ /* Get the timing data in cycles. For now play safe at 50Mhz */
++ ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
++
++ active = FIT(t.active, 2, 15);
++ recover = FIT(t.recover, 4, 15);
++
++ inb(0x3E6);
++ inb(0x3E6);
++ inb(0x3E6);
++ inb(0x3E6);
++
++ outb(recover << 4 | active, ap->ioaddr.device_addr);
++ inb(ap->ioaddr.status_addr);
++}
++
++static struct ata_port_operations ht6560a_port_ops = {
++ .set_piomode = ht6560a_set_piomode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer, /* Check vlb/noirq */
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Holtek 6560B support
++ *
++ * This controller supports PIO0 to PIO4. We honour the BIOS/jumper FIFO setting
++ * unless we see an ATAPI device in which case we force it off.
++ *
++ * FIXME: need to implement 2nd channel support.
++ */
++
++static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ u8 active, recover;
++ struct ata_timing t;
++
++ /* Get the timing data in cycles. For now play safe at 50Mhz */
++ ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
++
++ active = FIT(t.active, 2, 15);
++ recover = FIT(t.recover, 2, 16);
++ recover &= 0x15;
++
++ inb(0x3E6);
++ inb(0x3E6);
++ inb(0x3E6);
++ inb(0x3E6);
++
++ outb(recover << 4 | active, ap->ioaddr.device_addr);
++
++ if (adev->class != ATA_DEV_ATA) {
++ u8 rconf = inb(0x3E6);
++ if (rconf & 0x24) {
++ rconf &= ~ 0x24;
++ outb(rconf, 0x3E6);
++ }
++ }
++ inb(ap->ioaddr.status_addr);
++}
++
++static struct ata_port_operations ht6560b_port_ops = {
++ .set_piomode = ht6560b_set_piomode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer, /* FIXME: Check 32bit and noirq */
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/*
++ * Opti 82C611A
++ *
++ * This controller supports PIO0 to PIO3.
++ */
++
++static void opti82c611a_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ u8 active, recover, setup;
++ struct ata_timing t;
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++ int clock;
++ int khz[4] = { 50000, 40000, 33000, 25000 };
++ u8 rc;
++
++ /* Enter configuration mode */
++ inb(ap->ioaddr.error_addr);
++ inb(ap->ioaddr.error_addr);
++
++ /* Read VLB clock strapping */
++ clock = 1000000000 / khz[inb(ap->ioaddr.lbah_addr) & 0x03];
++
++ /* Get the timing data in cycles */
++ ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
++
++ /* Setup timing is shared */
++ if (pair) {
++ struct ata_timing tp;
++ ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);
++
++ ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
++ }
++
++ active = FIT(t.active, 2, 17) - 2;
++ recover = FIT(t.recover, 1, 16) - 1;
++ setup = FIT(t.setup, 1, 4) - 1;
++
++ /* Select the right timing bank for write timing */
++ rc = inb(ap->ioaddr.lbal_addr);
++ rc &= 0x7F;
++ rc |= (adev->devno << 7);
++ outb(rc, ap->ioaddr.lbal_addr);
++
++ /* Write the timings */
++ outb(active << 4 | recover, ap->ioaddr.error_addr);
++
++ /* Select the right bank for read timings, also
++ load the shared timings for address */
++ rc = inb(ap->ioaddr.device_addr);
++ rc &= 0xC0;
++ rc |= adev->devno; /* Index select */
++ rc |= (setup << 4) | 0x04;
++ outb(rc, ap->ioaddr.device_addr);
++
++ /* Load the read timings */
++ outb(active << 4 | recover, ap->ioaddr.data_addr);
++
++ /* Ensure the timing register mode is right */
++ rc = inb (ap->ioaddr.lbal_addr);
++ rc &= 0x73;
++ rc |= 0x84;
++ outb(rc, ap->ioaddr.lbal_addr);
++
++ /* Exit command mode */
++ outb(0x82, ap->ioaddr.nsect_addr);
++}
++
++static struct ata_port_operations opti82c611a_port_ops = {
++ .set_piomode = opti82c611a_set_piomode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * legacy_init_one - attach a legacy interface
++ * @io: I/O port start
++ * @ctrl: control port
++ * @irq: interrupt line
++ *
++ * Register an ISA bus IDE interface. Such interfaces are PIO and we
++ * assume do not support IRQ sharing.
++ */
++
++static __init int legacy_init_one(unsigned long io, unsigned long ctrl, int irq)
++{
++ struct ata_probe_ent ae;
++ int ret;
++ struct ata_port_operations *ops = &legacy_port_ops;
++ int pio_mask = 0x1F;
++
++ if (request_region(io, 8, "pata_legacy") == NULL)
++ return -EBUSY;
++ if (request_region(ctrl, 1, "pata_legacy") == NULL) {
++ release_region(io, 8);
++ return -EBUSY;
++ }
++
++ if (ht6560a == 1 && (io == 0x1F0 || io == 0x170)) {
++ ops = &ht6560a_port_ops;
++ pio_mask = 0x07;
++ }
++ if (ht6560b == 1 && (io == 0x1F0 || io == 0x170)) {
++ ops = &ht6560b_port_ops;
++ pio_mask = 0x1F;
++ }
++ if (opti82c611a == 1 && (io == 0x1F0 || io == 0x170)) {
++ ops = &opti82c611a_port_ops;
++ pio_mask = 0x0F;
++ }
++ else if (io == 0x1F0) {
++ /* Probes */
++ inb(0x1F5);
++ outb(inb(0x1F2) | 0x80, 0x1F2);
++ inb(0x1F2);
++ inb(0x3F6);
++ inb(0x3F6);
++ inb(0x1F2);
++ inb(0x1F2);
++
++ if ((inb(0x1F2) & 0x80) == 0) {
++ /* PDC20230 or 20630 ? */
++ printk(KERN_INFO "PDC20230-C/20630 VLB ATA controller detected.\n");
++ pio_mask = 0x07;
++ ops = &pdc20230_port_ops;
++ udelay(100);
++ inb(0x1F5);
++ } else {
++ outb(0x55, 0x1F2);
++ inb(0x1F2);
++ inb(0x1F2);
++ if (inb(0x1F2) == 0x00) {
++ printk(KERN_INFO "PDC20230-B VLB ATA controller detected.\n");
++ }
++ }
++ }
++ memset(&ae, 0, sizeof(struct ata_probe_ent));
++ INIT_LIST_HEAD(&ae.node);
++ ae.dev = NULL;
++ ae.port_ops = ops;
++ ae.sht = &legacy_sht;
++ ae.n_ports = 1;
++ ae.pio_mask = pio_mask;
++ ae.irq = irq;
++ ae.irq_flags = 0;
++ ae.host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_IRQ_MASK;
++ ae.port[0].cmd_addr = io;
++ ae.port[0].altstatus_addr = ctrl;
++ ae.port[0].ctl_addr = ctrl;
++ ata_std_ports(&ae.port[0]);
++
++ ret = ata_device_add(&ae);
++ if (ret == 0)
++ return -ENODEV;
++
++ legacy_host[nr_legacy_host++] = ae.host_set;
++ return 0;
++}
++
++/**
++ * legacy_check_special_cases - ATA special cases
++ * @p: PCI device to check
++ * @master: set this if we find an ATA master
++ * @master: set this if we find an ATA secondary
++ *
++ * A small number of vendors implemented early PCI ATA interfaces on bridge logic
++ * without the ATA interface being PCI visible. Where we have a matching PCI driver
++ * we must skip the relevant device here. If we don't know about it then the legacy
++ * driver is the right driver anyway.
++ */
++
++static void legacy_check_special_cases(struct pci_dev *p, int *primary, int *secondary)
++{
++ /* Cyrix CS5510 pre SFF MWDMA ATA on the bridge */
++ if (p->vendor == 0x1078 && p->device == 0x0000) {
++ *primary = *secondary = 1;
++ return;
++ }
++ /* Cyrix CS5520 pre SFF MWDMA ATA on the bridge */
++ if (p->vendor == 0x1078 && p->device == 0x0002) {
++ *primary = *secondary = 1;
++ return;
++ }
++ /* Intel MPIIX - PIO ATA on non PCI side of bridge */
++ if (p->vendor == 0x8086 && p->device == 0x1234) {
++ u16 r;
++ pci_read_config_word(p, 0x6C, &r);
++ if (r & 0x8000) { /* ATA port enabled */
++ if (r & 0x4000)
++ *secondary = 1;
++ else
++ *primary = 1;
++ }
++ return;
++ }
++}
++
++/**
++ * legacy_init - attach legacy interfaces
++ *
++ * Attach legacy IDE interfaces by scanning the usual IRQ/port suspects.
++ * Right now we do not scan the ide0 and ide1 address but should do so
++ * for non PCI systems or systems with no PCI IDE legacy mode devices.
++ * If you fix that note there are special cases to consider like VLB
++ * drivers and CS5510/20.
++ */
++
++static __init int legacy_init(void)
++{
++ int i;
++ int ct = 0;
++ int primary = 0;
++ int secondary = 0;
++ int last_port = NR_HOST;
++
++ struct pci_dev *p = NULL;
++
++ for_each_pci_dev(p) {
++ int r;
++ /* Check for any overlap of the system ATA mappings. Native mode controllers
++ stuck on these addresses or some devices in 'raid' mode won't be found by
++ the storage class test */
++ for (r = 0; r < 6; r++) {
++ if (pci_resource_start(p, r) == 0x1f0)
++ primary = 1;
++ if (pci_resource_start(p, r) == 0x170)
++ secondary = 1;
++ }
++ /* Check for special cases */
++ legacy_check_special_cases(p, &primary, &secondary);
++
++ /* If PCI bus is present then don't probe for tertiary legacy ports */
++ if (legacy_all == 0)
++ last_port = 2;
++ }
++
++
++ for (i = 0; i < last_port; i++) {
++ /* Skip primary if we have seen a PCI one */
++ if (i == 0 && primary == 1)
++ continue;
++ /* Skip secondary if we have seen a PCI one */
++ if (i == 1 && secondary == 1)
++ continue;
++ if (legacy_init_one(legacy_port[i],
++ legacy_port[i] + 0x0206,
++ legacy_irq[i]) == 0)
++ ct++;
++ }
++ if (ct != 0)
++ return 0;
++ return -ENODEV;
++}
++
++static __exit void legacy_exit(void)
++{
++ int i;
++
++ for (i = 0; i < nr_legacy_host; i++) {
++ struct ata_port *ap =legacy_host[i]->ports[0];
++ unsigned long io = ap->ioaddr.cmd_addr;
++ unsigned long ctrl = ap->ioaddr.ctl_addr;
++ ata_host_set_remove(legacy_host[i]);
++ release_region(io, 8);
++ release_region(ctrl, 1);
++ }
++}
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for legacy ATA");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++/**
++ * legacy_probe_all - setup argument handler
++ * @unused: unused
++ *
++ * Called when the probe_all argument is passed to this driver. This indicates
++ * that we should check all the legacy ATA addresses even if PCI is present. Should
++ * only ever be needed on very strange PCI/legacy combinations
++ */
++
++static int __init legacy_probe_all(char *unused)
++{
++ legacy_all = 1;
++ return 1;
++}
++
++__setup("probe-all", legacy_probe_all);
++
++/**
++ * legacy_ht6560a - setup argument handler
++ * @unused: unused
++ *
++ * Called when the ht6560a argument is passed to this driver. This indicates
++ * that we should check all the legacy ATA addresses even if PCI is present. Should
++ * only ever be needed on very strange PCI/legacy combinations
++ */
++
++static int __init legacy_ht6560a(char *unused)
++{
++ ht6560a = 1;
++ return 1;
++}
++
++__setup("ht6560a", legacy_ht6560a);
++
++/**
++ * legacy_ht6560b - setup argument handler
++ * @unused: unused
++ *
++ * Called when the ht6560b argument is passed to this driver. This indicates
++ * that we should check all the legacy ATA addresses even if PCI is present. Should
++ * only ever be needed on very strange PCI/legacy combinations
++ */
++
++static int __init legacy_ht6560b(char *unused)
++{
++ ht6560b = 1;
++ return 1;
++}
++
++__setup("ht6560b", legacy_ht6560b);
++
++/**
++ * legacy_ht6560a - setup argument handler
++ * @unused: unused
++ *
++ * Called when the ht6560a argument is passed to this driver. This indicates
++ * that we should check all the legacy ATA addresses even if PCI is present. Should
++ * only ever be needed on very strange PCI/legacy combinations
++ */
++
++static int __init legacy_opti82c611a(char *unused)
++{
++ opti82c611a = 1;
++ return 1;
++}
++
++__setup("opti82c611a", legacy_opti82c611a);
++
++module_init(legacy_init);
++module_exit(legacy_exit);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_mpiix.c linux-2.6.16-rc4/drivers/scsi/pata_mpiix.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_mpiix.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_mpiix.c 2006-02-16 15:38:41.000000000 +0000
+@@ -0,0 +1,303 @@
++/*
++ * pata_mpiix.c - Intel MPIIX PATA for new ATA layer
++ * (C) 2005-2006 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * The MPIIX is different enough to the PIIX4 and friends that we give it
++ * a separate driver. The old ide/pci code handles this by just not tuning
++ * MPIIX at all.
++ *
++ * The MPIIX also differs in another important way from the majority of PIIX
++ * devices. The chip is a bridge (pardon the pun) between the old world of
++ * ISA IDE and PCI IDE. Although the ATA timings are PCI configured the actual
++ * IDE controller is not decoded in PCI space and the chip does not claim to
++ * be IDE class PCI. This requires slightly non-standard probe logic compared
++ * with PCI IDE and also that we do not disable the device when our driver is
++ * unloaded (as it has many other functions).
++ *
++ * The driver conciously keeps this logic internally to avoid pushing quirky
++ * PATA history into the clean libata layer.
++ *
++ * Thinkpad specific note: If you boot an MPIIX using thinkpad with a PCMCIA
++ * hard disk present this driver will not detect it. This is not a bug. In this
++ * configuration the secondary port of the MPIIX is disabled and the addresses
++ * are decoded by the PCMCIA bridge and therefore are for a generic IDE driver
++ * to operate.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_mpiix"
++#define DRV_VERSION "0.4"
++
++/**
++ * mpiix_phy_reset - probe reset
++ * @ap: ATA port
++ *
++ * Perform the ATA probe and bus reset sequence plus specific handling
++ * for this hardware. The MPIIX has the enable bits in a different place
++ * to PIIX4 and friends. As a pure PIO device it has no cable detect
++ */
++
++static void mpiix_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static const struct pci_bits mpiix_enable_bits[] = {
++ { 0x6D, 1, 0x80, 0x80 },
++ { 0x6F, 1, 0x80, 0x80 }
++ };
++
++ if (!pci_test_config_bits(pdev, &mpiix_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * mpiix_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup. The MPIIX allows us to program the
++ * IORDY sample point (2-5 clocks), recovery 1-4 clocks and whether
++ * prefetching or iordy are used.
++ *
++ * This would get very ugly because we can only program timing for one
++ * device at a time, the other gets PIO0. Fortunately libata calls
++ * our qc_issue_prot command before a command is issued so we can
++ * flip the timings back and forth to reduce the pain.
++ */
++
++static void mpiix_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ int control = 0;
++ int pio = adev->pio_mode - XFER_PIO_0;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u16 idetim;
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 0 },
++ { 2, 1 },
++ { 2, 3 }, };
++
++ pci_read_config_word(pdev, 0x6C, &idetim);
++ /* Mask the IORDY/TIME/PPE0 bank for this device */
++ if (adev->class == ATA_DEV_ATA)
++ control |= 4; /* PPE enable for disk */
++ if (ata_pio_need_iordy(adev))
++ control |= 2; /* IORDY */
++ if (pio > 0)
++ control |= 1; /* This drive is on the fast timing bank */
++
++ /* Mask out timing and clear both TIME bank selects */
++ idetim &= 0xCCEE;
++ idetim &= ~(0x07 << (2 * adev->devno));
++ idetim |= (control << (2 * adev->devno));
++
++ idetim |= (timings[pio][0] << 12) | (timings[pio][1] << 8);
++ pci_write_config_word(pdev, 0x6C, idetim);
++
++ /* We use ap->private_data as a pointer to the device currently
++ loaded for timing */
++ ap->private_data = adev;
++}
++
++/**
++ * mpiix_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings if
++ * neccessary. Our logic also clears TIME0/TIME1 for the other device so
++ * that, even if we get this wrong, cycles to the other device will
++ * be made PIO0.
++ */
++
++static int mpiix_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++
++ /* If modes have been configured and the channel data is not loaded
++ then load it. We have to check if pio_mode is set as the core code
++ does not set adev->pio_mode to XFER_PIO_0 while probing as would be
++ logical */
++
++ if (adev->pio_mode && adev != ap->private_data)
++ mpiix_set_piomode(ap, adev);
++
++ return ata_qc_issue_prot(qc);
++}
++
++static struct scsi_host_template mpiix_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations mpiix_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = mpiix_set_piomode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = mpiix_phy_reset,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = mpiix_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int mpiix_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ /* Single threaded by the PCI probe logic */
++ static struct ata_probe_ent probe[2];
++ static int printed_version;
++ u16 idetim;
++ int enabled;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n");
++
++ /* MPIIX has many functions which can be turned on or off according
++ to other devices present. Make sure IDE is enabled before we try
++ and use it */
++
++ pci_read_config_word(dev, 0x6C, &idetim);
++ if (!(idetim & 0x8000))
++ return -ENODEV;
++
++ /* We do our own plumbing to avoid leaking special cases for whacko
++ ancient hardware into the core code. There are two issues to
++ worry about. #1 The chip is a bridge so if in legacy mode and
++ without BARs set fools the setup. #2 If you pci_disable_device
++ the MPIIX your box goes castors up */
++
++ INIT_LIST_HEAD(&probe[0].node);
++ probe[0].dev = pci_dev_to_dev(dev);
++ probe[0].port_ops = &mpiix_port_ops;
++ probe[0].sht = &mpiix_sht;
++ probe[0].pio_mask = 0x1F;
++ probe[0].irq = 14;
++ probe[0].irq_flags = SA_SHIRQ;
++ probe[0].host_flags = ATA_FLAG_SLAVE_POSS;
++ probe[0].legacy_mode = 1;
++ probe[0].hard_port_no = 0;
++ probe[0].n_ports = 1;
++ probe[0].port[0].cmd_addr = 0x1F0;
++ probe[0].port[0].ctl_addr = 0x3F6;
++ probe[0].port[0].altstatus_addr = 0x3F6;
++
++ /* The secondary lurks at different addresses but is otherwise
++ the same beastie */
++
++ INIT_LIST_HEAD(&probe[1].node);
++ probe[1] = probe[0];
++ probe[1].irq = 15;
++ probe[1].hard_port_no = 1;
++ probe[1].port[0].cmd_addr = 0x170;
++ probe[1].port[0].ctl_addr = 0x376;
++ probe[1].port[0].altstatus_addr = 0x376;
++
++ /* Let libata fill in the port details */
++ ata_std_ports(&probe[0].port[0]);
++ ata_std_ports(&probe[1].port[0]);
++
++ /* Now add the port that is active */
++ enabled = (idetim & 0x4000) ? 1 : 0;
++
++ if (ata_device_add(&probe[enabled]))
++ return 0;
++ return -ENODEV;
++}
++
++/**
++ * mpiix_remove_one - device unload
++ * @pdev: PCI device being removed
++ *
++ * Handle an unplug/unload event for a PCI device. Unload the
++ * PCI driver but do not use the default handler as we *MUST NOT*
++ * disable the device as it has other functions.
++ */
++
++static void __devexit mpiix_remove_one(struct pci_dev *pdev)
++{
++ struct device *dev = pci_dev_to_dev(pdev);
++ struct ata_host_set *host_set = dev_get_drvdata(dev);
++
++ ata_host_set_remove(host_set);
++ dev_set_drvdata(dev, NULL);
++}
++
++
++
++static const struct pci_device_id mpiix[] = {
++ { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371MX, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
++ { 0, },
++};
++
++static struct pci_driver mpiix_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = mpiix,
++ .probe = mpiix_init_one,
++ .remove = mpiix_remove_one
++};
++
++static int __init mpiix_init(void)
++{
++ return pci_register_driver(&mpiix_pci_driver);
++}
++
++
++static void __exit mpiix_exit(void)
++{
++ pci_unregister_driver(&mpiix_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Intel MPIIX");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, mpiix);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(mpiix_init);
++module_exit(mpiix_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_netcell.c linux-2.6.16-rc4/drivers/scsi/pata_netcell.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_netcell.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_netcell.c 2006-02-08 14:05:57.000000000 +0000
+@@ -0,0 +1,176 @@
++/*
++ * pata_netcell.c - Netcell PATA driver
++ *
++ * (c) 2006 Red Hat <alan@redhat.com>
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <linux/ata.h>
++
++#define DRV_NAME "pata_netcell"
++#define DRV_VERSION "0.1"
++
++/**
++ * netcell_cable_detect - check for 40/80 pin
++ * @ap: Port
++ *
++ * Cables are handled by the RAID controller. Report 80 pin.
++ */
++
++static int netcell_cable_detect(struct ata_port *ap)
++{
++ return ATA_CBL_PATA80;
++}
++
++/**
++ * netcell_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void netcell_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = netcell_cable_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/* No PIO or DMA methods needed for this device */
++
++static struct scsi_host_template netcell_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ /* Special handling needed if you have sector or LBA48 limits */
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ /* Use standard CHS mapping rules */
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static const struct ata_port_operations netcell_ops = {
++ .port_disable = ata_port_disable,
++
++ /* Task file is PCI ATA format, use helpers */
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = netcell_phy_reset,
++
++ /* BMDMA handling is PCI ATA format, use helpers */
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer, /* In -ac only right now */
++
++ /* Timeout handling. Special recovery hooks here */
++ .eng_timeout = ata_eng_timeout,
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ /* Generic PATA PCI ATA helpers */
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++
++/**
++ * netcell_init_one - Register Netcell ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in netcell_pci_tbl matching with @pdev
++ *
++ * Called from kernel PCI layer.
++ *
++ * LOCKING:
++ * Inherited from PCI layer (may sleep).
++ *
++ * RETURNS:
++ * Zero on success, or -ERRNO value.
++ */
++
++static int netcell_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ static struct ata_port_info info = {
++ .sht = &netcell_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ /* Actually we don't really care about these as the
++ firmware deals with it */
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma0-2 */
++ .udma_mask = 0x3f, /* UDMA 133 */
++ .port_ops = &netcell_ops,
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev,
++ "version " DRV_VERSION "\n");
++
++ /* Any chip specific setup/optimisation/messages here */
++ ata_pci_clear_simplex(pdev);
++
++ /* And let the library code do the work */
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id netcell_pci_tbl[] = {
++ { 0x169C, 0x0044, PCI_ANY_ID, PCI_ANY_ID, },
++ { } /* terminate list */
++};
++
++static struct pci_driver netcell_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = netcell_pci_tbl,
++ .probe = netcell_init_one,
++ .remove = ata_pci_remove_one,
++};
++
++static int __init netcell_init(void)
++{
++ return pci_register_driver(&netcell_pci_driver);
++}
++
++static void __exit netcell_exit(void)
++{
++ pci_unregister_driver(&netcell_pci_driver);
++}
++
++
++module_init(netcell_init);
++module_exit(netcell_exit);
++
++MODULE_AUTHOR("");
++MODULE_DESCRIPTION("SCSI low-level driver for Netcell PATA RAID");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, netcell_pci_tbl);
++MODULE_VERSION(DRV_VERSION);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_ns87410.c linux-2.6.16-rc4/drivers/scsi/pata_ns87410.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_ns87410.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_ns87410.c 2006-02-15 15:05:43.000000000 +0000
+@@ -0,0 +1,213 @@
++/*
++ * pata_ns87410.c - National Semiconductor 87410 PATA for new ATA layer
++ * (C) 2006 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_ns87410"
++#define DRV_VERSION "0.1"
++
++/**
++ * ns87410_phy_reset - probe reset
++ * @ap: ATA port
++ *
++ * Perform the ATA probe and bus reset sequence plus specific handling
++ * for this hardware. The MPIIX has the enable bits in a different place
++ * to PIIX4 and friends. As a pure PIO device it has no cable detect
++ */
++
++static void ns87410_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static const struct pci_bits ns87410_enable_bits[] = {
++ { 0x43, 1, 0x08, 0x08 },
++ { 0x47, 1, 0x08, 0x08 }
++ };
++
++ if (!pci_test_config_bits(pdev, &ns87410_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * ns87410_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program timing data. This is kept per channel not per device,
++ * and only affects the data port.
++ */
++
++static void ns87410_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int port = 0x40 + 4 * ap->hard_port_no;
++ u8 idetcr, idefr;
++ struct ata_timing at;
++
++ static const u8 activebits[15] = {
++ 0, 1, 2, 3, 4,
++ 5, 5, 6, 6, 6,
++ 6, 7, 7, 7, 7
++ };
++
++ static const u8 recoverbits[12] = {
++ 0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 7, 7
++ };
++
++ pci_read_config_byte(pdev, port + 3, &idefr);
++
++ if (ata_pio_need_iordy(adev))
++ idefr |= 0x04; /* IORDY enable */
++ else
++ idefr &= ~0x04;
++
++ if (ata_timing_compute(adev, adev->pio_mode, &at, 30303, 1) < 0) {
++ dev_printk(KERN_ERR, &pdev->dev, "unknown mode %d.\n", adev->pio_mode);
++ return;
++ }
++
++ at.active = FIT(at.active, 2, 16) - 2;
++ at.setup = FIT(at.setup, 1, 4) - 1;
++ at.recover = FIT(at.recover, 1, 12) - 1;
++
++ idetcr = (at.setup << 6) | (recoverbits[at.recover] << 3) | activebits[at.active];
++
++ pci_write_config_byte(pdev, port, idetcr);
++ pci_write_config_byte(pdev, port + 3, idefr);
++ /* We use ap->private_data as a pointer to the device currently
++ loaded for timing */
++ ap->private_data = adev;
++}
++
++/**
++ * ns87410_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings if
++ * neccessary. Our logic also clears TIME0/TIME1 for the other device so
++ * that, even if we get this wrong, cycles to the other device will
++ * be made PIO0.
++ */
++
++static int ns87410_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++
++ /* If modes have been configured and the channel data is not loaded
++ then load it. We have to check if pio_mode is set as the core code
++ does not set adev->pio_mode to XFER_PIO_0 while probing as would be
++ logical */
++
++ if (adev->pio_mode && adev != ap->private_data)
++ ns87410_set_piomode(ap, adev);
++
++ return ata_qc_issue_prot(qc);
++}
++
++static struct scsi_host_template ns87410_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations ns87410_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = ns87410_set_piomode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = ns87410_phy_reset,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ns87410_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int ns87410_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &ns87410_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x0F,
++ .port_ops = &ns87410_port_ops
++ };
++ static struct ata_port_info *port_info[2] = {&info, &info};
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static const struct pci_device_id ns87410[] = {
++ { PCI_DEVICE(0x100B, 0xD001), },
++ { 0, },
++};
++
++static struct pci_driver ns87410_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = ns87410,
++ .probe = ns87410_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init ns87410_init(void)
++{
++ return pci_register_driver(&ns87410_pci_driver);
++}
++
++
++static void __exit ns87410_exit(void)
++{
++ pci_unregister_driver(&ns87410_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Nat Semi 87410");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, ns87410);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(ns87410_init);
++module_exit(ns87410_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_oldpiix.c linux-2.6.16-rc4/drivers/scsi/pata_oldpiix.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_oldpiix.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_oldpiix.c 2006-01-21 16:55:29.000000000 +0000
+@@ -0,0 +1,327 @@
++/*
++ * pata_oldpiix.c - Intel PATA/SATA controllers
++ *
++ * (C) 2005 Red Hat <alan@redhat.com>
++ *
++ * Some parts based on ata_piix.c by Jeff Garzik and others.
++ *
++ * Early PIIX differs significantly from the later PIIX as it lacks
++ * SITRE and the slave timing registers. This means that you have to
++ * set timing per channel, or be clever. Libata tells us whenever it
++ * does drive selection and we use this to reload the timings.
++ *
++ * Because of these behaviour differences PIIX gets its own driver module.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <linux/ata.h>
++
++#define DRV_NAME "pata_oldpiix"
++#define DRV_VERSION "0.3"
++
++/**
++ * oldpiix_pata_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void oldpiix_pata_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static const struct pci_bits oldpiix_enable_bits[] = {
++ { 0x41U, 1U, 0x80UL, 0x80UL }, /* port 0 */
++ { 0x43U, 1U, 0x80UL, 0x80UL }, /* port 1 */
++ };
++
++ if (!pci_test_config_bits(pdev, &oldpiix_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * oldpiix_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: um
++ *
++ * Set PIO mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void oldpiix_set_piomode (struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int pio = adev->pio_mode - XFER_PIO_0;
++ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
++ unsigned int idetm_port= ap->hard_port_no ? 0x42 : 0x40;
++ u16 idetm_data;
++ int control = 0;
++
++ /*
++ * See Intel Document 298600-004 for the timing programing rules
++ * for PIIX/ICH. Note that the early PIIX does not have the slave
++ * timing port at 0x44.
++ */
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 0 },
++ { 2, 1 },
++ { 2, 3 }, };
++
++ if (pio > 2)
++ control |= 1; /* TIME1 enable */
++ if (ata_pio_need_iordy(adev))
++ control |= 2; /* IE IORDY */
++
++ /* Intel specifies that the PPE functionality is for disk only */
++ if (adev->class == ATA_DEV_ATA)
++ control |= 4; /* PPE enable */
++
++ pci_read_config_word(dev, idetm_port, &idetm_data);
++
++ /* Enable PPE, IE and TIME as appropriate. Clear the other
++ drive timing bits */
++ if (adev->devno == 0) {
++ idetm_data &= 0xCCE0;
++ idetm_data |= control;
++ } else {
++ idetm_data &= 0xCC0E;
++ idetm_data |= (control << 4);
++ }
++ idetm_data |= (timings[pio][0] << 12) |
++ (timings[pio][1] << 8);
++ pci_write_config_word(dev, idetm_port, idetm_data);
++
++ /* Track which port is configured */
++ ap->private_data = adev;
++}
++
++/**
++ * oldpiix_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ * @isich: True if the device is an ICH and has IOCFG registers
++ *
++ * Set MWDMA mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void oldpiix_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
++ u8 idetm_port = ap->hard_port_no ? 0x42 : 0x40;
++ u16 idetm_data;
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 0 },
++ { 2, 1 },
++ { 2, 3 }, };
++
++ /*
++ * MWDMA is driven by the PIO timings. We must also enable
++ * IORDY unconditionally along with TIME1. PPE has already
++ * been set when the PIO timing was set.
++ */
++
++ unsigned int mwdma = adev->dma_mode - XFER_MW_DMA_0;
++ unsigned int control;
++ const unsigned int needed_pio[3] = {
++ XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
++ };
++ int pio = needed_pio[mwdma] - XFER_PIO_0;
++
++ pci_read_config_word(dev, idetm_port, &idetm_data);
++
++ control = 3; /* IORDY|TIME0 */
++ /* Intel specifies that the PPE functionality is for disk only */
++ if (adev->class == ATA_DEV_ATA)
++ control |= 4; /* PPE enable */
++
++ /* If the drive MWDMA is faster than it can do PIO then
++ we must force PIO into PIO0 */
++
++ if (adev->pio_mode < needed_pio[mwdma])
++ /* Enable DMA timing only */
++ control |= 8; /* PIO cycles in PIO0 */
++
++ /* Mask out the relevant control and timing bits we will load. Also
++ clear the other drive TIME register as a precaution */
++ if (adev->devno == 0) {
++ idetm_data &= 0xCCE0;
++ idetm_data |= control;
++ } else {
++ idetm_data &= 0xCC0E;
++ idetm_data |= (control << 4);
++ }
++ idetm_data |= (timings[pio][0] << 12) | (timings[pio][1] << 8);
++ pci_write_config_word(dev, idetm_port, idetm_data);
++
++ /* Track which port is configured */
++ ap->private_data = adev;
++}
++
++/**
++ * oldpiix_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings if
++ * neccessary. Our logic also clears TIME0/TIME1 for the other device so
++ * that, even if we get this wrong, cycles to the other device will
++ * be made PIO0.
++ */
++
++static int oldpiix_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++
++ if (adev != ap->private_data) {
++ if (adev->dma_mode)
++ oldpiix_set_dmamode(ap, adev);
++ else if (adev->pio_mode)
++ oldpiix_set_piomode(ap, adev);
++ }
++ return ata_qc_issue_prot(qc);
++}
++
++
++static struct scsi_host_template oldpiix_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static const struct ata_port_operations oldpiix_pata_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = oldpiix_set_piomode,
++ .set_dmamode = oldpiix_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = oldpiix_pata_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = oldpiix_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++
++/**
++ * oldpiix_init_one - Register PIIX ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in oldpiix_pci_tbl matching with @pdev
++ *
++ * Called from kernel PCI layer. We probe for combined mode (sigh),
++ * and then hand over control to libata, for it to do the rest.
++ *
++ * LOCKING:
++ * Inherited from PCI layer (may sleep).
++ *
++ * RETURNS:
++ * Zero on success, or -ERRNO value.
++ */
++
++static int oldpiix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ static struct ata_port_info info = {
++ .sht = &oldpiix_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma1-2 */
++ .port_ops = &oldpiix_pata_ops,
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev,
++ "version " DRV_VERSION "\n");
++
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id oldpiix_pci_tbl[] = {
++ { 0x8086, 0x1230, PCI_ANY_ID, PCI_ANY_ID, },
++ { } /* terminate list */
++};
++
++static struct pci_driver oldpiix_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = oldpiix_pci_tbl,
++ .probe = oldpiix_init_one,
++ .remove = ata_pci_remove_one,
++};
++
++static int __init oldpiix_init(void)
++{
++ return pci_register_driver(&oldpiix_pci_driver);
++}
++
++static void __exit oldpiix_exit(void)
++{
++ pci_unregister_driver(&oldpiix_pci_driver);
++}
++
++
++module_init(oldpiix_init);
++module_exit(oldpiix_exit);
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("SCSI low-level driver for early PIIX series controllers");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, oldpiix_pci_tbl);
++MODULE_VERSION(DRV_VERSION);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_opti.c linux-2.6.16-rc4/drivers/scsi/pata_opti.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_opti.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_opti.c 2006-02-16 15:38:28.000000000 +0000
+@@ -0,0 +1,268 @@
++/*
++ * pata_opti.c - ATI PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based on
++ * linux/drivers/ide/pci/opti621.c Version 0.7 Sept 10, 2002
++ *
++ * Copyright (C) 1996-1998 Linus Torvalds & authors (see below)
++ *
++ * Authors:
++ * Jaromir Koutek <miri@punknet.cz>,
++ * Jan Harkes <jaharkes@cwi.nl>,
++ * Mark Lord <mlord@pobox.com>
++ * Some parts of code are from ali14xx.c and from rz1000.c.
++ *
++ * Also consulted the FreeBSD prototype driver by Kevin Day to try
++ * and resolve some confusions.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_opti"
++#define DRV_VERSION "0.1.2"
++
++enum {
++ READ_REG = 0, /* index of Read cycle timing register */
++ WRITE_REG = 1, /* index of Write cycle timing register */
++ CNTRL_REG = 3, /* index of Control register */
++ STRAP_REG = 5, /* index of Strap register */
++ MISC_REG = 6 /* index of Miscellaneous register */
++};
++
++/**
++ * opti_phy_reset - probe reset
++ * @ap: ATA port
++ *
++ * Perform the ATA probe and bus reset sequence plus specific handling
++ * for this hardware. The Opti needs little handling - we have no UDMA66
++ * capability that needs cable detection. All we must do is check the port
++ * is enabled.
++ */
++
++static void opti_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static const struct pci_bits opti_enable_bits[] = {
++ { 0x45, 1, 0x80, 0x00 },
++ { 0x45, 1, 0x08, 0x00 }
++ };
++
++ if (!pci_test_config_bits(pdev, &opti_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * opti_write_reg - control register setup
++ * @ap: ATA port
++ * @value: value
++ * @reg: control register number
++ *
++ * The Opti uses magic 'trapdoor' register accesses to do configuration
++ * rather than using PCI space as other controllers do. The double inw
++ * on the error register activates configuration mode. We can then write
++ * the control register
++ */
++
++static void opti_write_reg(struct ata_port *ap, u8 val, int reg)
++{
++ unsigned long regio = ap->ioaddr.cmd_addr;
++ inw(regio + 1);
++ inw(regio + 1);
++ outb(3, regio + 2);
++ outb(val, regio + reg);
++ outb(0x83, regio + 2);
++}
++
++#if 0
++/**
++ * opti_read_reg - control register read
++ * @ap: ATA port
++ * @reg: control register number
++ *
++ * The Opti uses magic 'trapdoor' register accesses to do configuration
++ * rather than using PCI space as other controllers do. The double inw
++ * on the error register activates configuration mode. We can then read
++ * the control register
++ */
++
++static u8 opti_read_reg(struct ata_port *ap, int reg)
++{
++ unsigned long regio = ap->ioaddr.cmd_addr;
++ u8 ret;
++ inw(regio + 1);
++ inw(regio + 1);
++ outb(3, regio + 2);
++ ret = inb(regio + reg);
++ outb(0x83, regio + 2);
++}
++#endif
++
++/**
++ * opti_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup. Timing numbers are taken from
++ * the FreeBSD driver then pre computed to keep the code clean. There
++ * are two tables depending on the hardware clock speed.
++ */
++
++static void opti_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++ int clock;
++ int pio = adev->pio_mode - XFER_PIO_0;
++ unsigned long regio = ap->ioaddr.cmd_addr;
++ u8 addr;
++
++ /* Address table precomputed with prefetch off and a DCLK of 2 */
++ static const u8 addr_timing[2][5] = {
++ { 0x30, 0x20, 0x20, 0x10, 0x10 },
++ { 0x20, 0x20, 0x10, 0x10, 0x10 }
++ };
++ static const u8 data_rec_timing[2][5] = {
++ { 0x6B, 0x56, 0x42, 0x32, 0x31 },
++ { 0x58, 0x44, 0x32, 0x22, 0x21 }
++ };
++
++ outb(0xff, regio + 5);
++ clock = inw(regio + 5) & 1;
++
++ /*
++ * As with many controllers the address setup time is shared
++ * and must suit both devices if present.
++ */
++
++ addr = addr_timing[clock][pio];
++ if (pair) {
++ /* Hardware constraint */
++ u8 pair_addr = addr_timing[clock][pair->pio_mode - XFER_PIO_0];
++ if (pair_addr > addr)
++ addr = pair_addr;
++ }
++
++ /* Commence primary programming sequence */
++ opti_write_reg(ap, adev->devno, MISC_REG);
++ opti_write_reg(ap, data_rec_timing[clock][pio], READ_REG);
++ opti_write_reg(ap, data_rec_timing[clock][pio], WRITE_REG);
++ opti_write_reg(ap, addr, MISC_REG);
++
++ /* Programming sequence complete, override strapping */
++ opti_write_reg(ap, 0x85, CNTRL_REG);
++}
++
++static struct scsi_host_template opti_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations opti_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = opti_set_piomode,
++/* .set_dmamode = opti_set_dmamode, */
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = opti_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int opti_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &opti_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .port_ops = &opti_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++ static int printed_version;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n");
++
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static const struct pci_device_id opti[] = {
++ { PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C621, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C825, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
++ { 0, },
++};
++
++static struct pci_driver opti_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = opti,
++ .probe = opti_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init opti_init(void)
++{
++ return pci_register_driver(&opti_pci_driver);
++}
++
++
++static void __exit opti_exit(void)
++{
++ pci_unregister_driver(&opti_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Opti 621/621X");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, opti);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(opti_init);
++module_exit(opti_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_pcmcia.c linux-2.6.16-rc4/drivers/scsi/pata_pcmcia.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_pcmcia.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_pcmcia.c 2006-01-21 16:55:56.000000000 +0000
+@@ -0,0 +1,406 @@
++/*
++ * pata-pcmcia.c - PCMCIA PATA controller driver.
++ * Copyright 2005/2006 Red Hat Inc <alan@redhat.com>, all rights reserved.
++ *
++ * Heavily based upon ide-cs.c
++ * The initial developer of the original code is David A. Hinds
++ * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
++ * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/ata.h>
++#include <linux/libata.h>
++
++#include <pcmcia/cs_types.h>
++#include <pcmcia/cs.h>
++#include <pcmcia/cistpl.h>
++#include <pcmcia/ds.h>
++#include <pcmcia/cisreg.h>
++#include <pcmcia/ciscode.h>
++
++
++#define DRV_NAME "pata_pcmcia"
++#define DRV_VERSION "0.1"
++
++/*
++ * Private data structure to glue stuff together
++ */
++
++struct ata_pcmcia_info {
++ dev_link_t link;
++ int ndev;
++ dev_node_t node;
++};
++
++static struct scsi_host_template pcmcia_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations pcmcia_port_ops = {
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++#define CS_CHECK(fn, ret) \
++do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
++
++/**
++ * pcmcia_init_one - attach an pcmcia interface
++ * @pdev: pcmcia device
++ *
++ * Register a PCMCIA IDE interface. Such interfaces are PIO 0 and
++ * non shared IRQ.
++ */
++
++static int pcmcia_init_one(struct pcmcia_device *pdev)
++{
++ struct ata_probe_ent ae;
++ dev_link_t *link;
++ struct ata_pcmcia_info *info;
++ client_handle_t handle;
++ tuple_t tuple;
++ struct {
++ unsigned short buf[128];
++ cisparse_t parse;
++ config_info_t conf;
++ cistpl_cftable_entry_t dflt;
++ } *stk = NULL;
++ cistpl_cftable_entry_t *cfg;
++ int pass, last_ret = 0, last_fn = 0, is_kme = 0, ret = -ENOMEM;
++ unsigned long io_base, ctl_base;
++
++ info = kzalloc(sizeof(*info), GFP_KERNEL);
++ if (info == NULL)
++ return -ENOMEM;
++
++ link = &info->link;
++ link->priv = info;
++
++ link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
++ link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
++ link->io.IOAddrLines = 3;
++ link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
++ link->irq.IRQInfo1 = IRQ_LEVEL_ID;
++ link->conf.Attributes = CONF_ENABLE_IRQ;
++ link->conf.Vcc = 50;
++ link->conf.IntType = INT_MEMORY_AND_IO;
++
++ link->handle = pdev;
++ pdev->instance = link;
++
++ handle = link->handle;
++
++ link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
++
++ stk = kzalloc(sizeof(*stk), GFP_KERNEL);
++ if (!stk)
++ goto out1;
++
++ cfg = &stk->parse.cftable_entry;
++
++ tuple.TupleData = (cisdata_t *)&stk->buf;
++ tuple.TupleOffset = 0;
++ tuple.TupleDataMax = 255;
++ tuple.Attributes = 0;
++ tuple.DesiredTuple = CISTPL_CONFIG;
++
++ CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
++ CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
++ CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &stk->parse));
++ link->conf.ConfigBase = stk->parse.config.base;
++ link->conf.Present = stk->parse.config.rmask[0];
++
++ tuple.DesiredTuple = CISTPL_MANFID;
++ if (!pcmcia_get_first_tuple(handle, &tuple) && !pcmcia_get_tuple_data(handle, &tuple) && !pcmcia_parse_tuple(handle, &tuple, &stk->parse))
++ is_kme = ((stk->parse.manfid.manf == MANFID_KME) && ((stk->parse.manfid.card == PRODID_KME_KXLC005_A) || (stk->parse.manfid.card == PRODID_KME_KXLC005_B)));
++
++ /* Configure card */
++ link->state |= DEV_CONFIG;
++
++ /* Not sure if this is right... look up the current Vcc */
++ CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &stk->conf));
++ link->conf.Vcc = stk->conf.Vcc;
++
++ pass = io_base = ctl_base = 0;
++ tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
++ tuple.Attributes = 0;
++ CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
++
++ while (1) {
++ if (pcmcia_get_tuple_data(handle, &tuple) != 0)
++ goto next_entry;
++ if (pcmcia_parse_tuple(handle, &tuple, &stk->parse) != 0)
++ goto next_entry;
++ /* Check for matching Vcc, unless we're desperate */
++ if (!pass) {
++ if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
++ if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
++ goto next_entry;
++ } else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
++ if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
++ goto next_entry;
++ }
++ }
++
++ if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
++ link->conf.Vpp1 = link->conf.Vpp2 = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
++ else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
++ link->conf.Vpp1 = link->conf.Vpp2 = stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
++
++ if ((cfg->io.nwin > 0) || (stk->dflt.io.nwin > 0)) {
++ cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
++ link->conf.ConfigIndex = cfg->index;
++ link->io.BasePort1 = io->win[0].base;
++ link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
++ if (!(io->flags & CISTPL_IO_16BIT))
++ link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
++ if (io->nwin == 2) {
++ link->io.NumPorts1 = 8;
++ link->io.BasePort2 = io->win[1].base;
++ link->io.NumPorts2 = (is_kme) ? 2 : 1;
++ if (pcmcia_request_io(link->handle, &link->io) != 0)
++ goto next_entry;
++ io_base = link->io.BasePort1;
++ ctl_base = link->io.BasePort2;
++ } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
++ link->io.NumPorts1 = io->win[0].len;
++ link->io.NumPorts2 = 0;
++ if (pcmcia_request_io(link->handle, &link->io) != 0)
++ goto next_entry;
++ io_base = link->io.BasePort1;
++ ctl_base = link->io.BasePort1 + 0x0e;
++ } else goto next_entry;
++ /* If we've got this far, we're done */
++ break;
++ }
++next_entry:
++ if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
++ memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
++ if (pass) {
++ CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
++ } else if (pcmcia_get_next_tuple(handle, &tuple) != 0) {
++ CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
++ memset(&stk->dflt, 0, sizeof(stk->dflt));
++ pass++;
++ }
++ }
++
++ if (is_kme)
++ outb(0x81, ctl_base + 0x01);
++
++ /* FIXME: Could be more ports at base + 0x10 but we only deal with
++ one right now */
++
++ if (link->io.NumPorts1 >= 0x20)
++ printk(KERN_WARNING DRV_NAME ": second channel not yet supported.\n");
++
++ /*
++ * Having done the PCMCIA plumbing the ATA side is relatively
++ * sane.
++ */
++
++ memset(&ae, 0, sizeof(struct ata_probe_ent));
++ INIT_LIST_HEAD(&ae.node);
++ ae.dev = &pdev->dev;
++ ae.port_ops = &pcmcia_port_ops;
++ ae.sht = &pcmcia_sht;
++ ae.n_ports = 1;
++ ae.pio_mask = 1; /* ISA so PIO 0 cycles */
++ ae.irq = link->irq.AssignedIRQ;
++ ae.irq_flags = 0;
++ ae.host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_IRQ_MASK;
++ ae.port[0].cmd_addr = io_base;
++ ae.port[0].altstatus_addr = ctl_base;
++ ae.port[0].ctl_addr = ctl_base;
++ ata_std_ports(&ae.port[0]);
++
++ if (ata_device_add(&ae) == 0)
++ goto failed;
++
++ info->ndev = 1;
++ link->dev = &info->node;
++ link->state &= ~DEV_CONFIG_PENDING;
++ kfree(stk);
++ return 0;
++
++cs_failed:
++ cs_error(link->handle, last_fn, last_ret);
++failed:
++ kfree(stk);
++ info->ndev = 0;
++ link->dev = NULL;
++
++ pcmcia_release_configuration(link->handle);
++ pcmcia_release_io(link->handle, &link->io);
++ pcmcia_release_irq(link->handle, &link->irq);
++
++ link->state &= ~DEV_CONFIG;
++out1:
++ kfree(info);
++ return ret;
++}
++
++/**
++ * pcmcia_remove_one - unplug an pcmcia interface
++ * @pdev: pcmcia device
++ *
++ * A PCMCIA ATA device has been unplugged. Perform the needed
++ * cleanup. Also called on module unload for any active devices.
++ */
++
++void pcmcia_remove_one(struct pcmcia_device *pdev)
++{
++ dev_link_t *link = dev_to_instance(pdev);
++ struct ata_pcmcia_info *info = link->priv;
++ struct device *dev = &pdev->dev;
++
++ if (link->state & DEV_CONFIG) {
++ if (info->ndev) {
++ struct ata_host_set *host_set = dev_get_drvdata(dev);
++ ata_host_set_remove(host_set);
++ dev_set_drvdata(dev, NULL);
++ }
++ info->ndev = 0;
++ link->dev = NULL;
++
++ pcmcia_release_configuration(link->handle);
++ pcmcia_release_io(link->handle, &link->io);
++ pcmcia_release_irq(link->handle, &link->irq);
++ link->state &= ~DEV_CONFIG;
++ }
++ kfree(link->priv);
++}
++
++static int pcmcia_suspend(struct pcmcia_device *dev)
++{
++ dev_link_t *link = dev_to_instance(dev);
++
++ link->state |= DEV_SUSPEND;
++ if (link->state & DEV_CONFIG)
++ pcmcia_release_configuration(link->handle);
++
++ return 0;
++}
++
++static int pcmcia_resume(struct pcmcia_device *dev)
++{
++ dev_link_t *link = dev_to_instance(dev);
++
++ link->state &= ~DEV_SUSPEND;
++ if (DEV_OK(link))
++ pcmcia_request_configuration(link->handle, &link->conf);
++
++ return 0;
++}
++
++static struct pcmcia_device_id pcmcia_devices[] = {
++ PCMCIA_DEVICE_FUNC_ID(4),
++ PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000), /* Hitachi */
++ PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
++ PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),
++ PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000), /* Toshiba */
++ PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
++ PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000), /* Samsung */
++ PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000), /* Hitachi */
++ PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
++ PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200), /* Lexar */
++ PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
++ PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
++ PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
++ PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
++ PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
++ PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
++ PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
++ PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
++ PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
++ PCMCIA_DEVICE_PROD_ID12("EXP ", "CD-ROM", 0x0a5c52fd, 0x66536591),
++ PCMCIA_DEVICE_PROD_ID12("EXP ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
++ PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
++ PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
++ PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
++ PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
++ PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2 ", 0x547e66dc, 0x8671043b),
++ PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
++ PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
++ PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2 ", 0xe37be2b5, 0x8671043b),
++ PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
++ PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
++ PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
++ PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
++ PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
++ PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
++ PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
++ PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
++ PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
++ PCMCIA_DEVICE_NULL,
++};
++
++MODULE_DEVICE_TABLE(pcmcia, pcmcia_devices);
++
++static struct pcmcia_driver pcmcia_driver = {
++ .owner = THIS_MODULE,
++ .drv {
++ .name = DRV_NAME,
++ },
++ .id_table = pcmcia_devices,
++ .probe = pcmcia_init_one,
++ .remove = pcmcia_remove_one,
++ .suspend = pcmcia_suspend,
++ .resume = pcmcia_resume,
++};
++
++static int __init pcmcia_init(void)
++{
++ return pcmcia_register_driver(&pcmcia_driver);
++}
++
++static void __exit pcmcia_exit(void)
++{
++ pcmcia_unregister_driver(&pcmcia_driver);
++}
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for PCMCIA ATA");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(pcmcia_init);
++module_exit(pcmcia_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_pdc2027x.c linux-2.6.16-rc4/drivers/scsi/pata_pdc2027x.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_pdc2027x.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_pdc2027x.c 2006-01-21 16:56:47.000000000 +0000
+@@ -0,0 +1,857 @@
++/*
++ * Promise PATA TX2/TX4/TX2000/133 IDE driver for pdc20268 to pdc20277.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version
++ * 2 of the License, or (at your option) any later version.
++ *
++ * Ported to libata by:
++ * Albert Lee <albertcc@tw.ibm.com> IBM Corporation
++ *
++ * Copyright (C) 1998-2002 Andre Hedrick <andre@linux-ide.org>
++ * Portions Copyright (C) 1999 Promise Technology, Inc.
++ *
++ * Author: Frank Tiernan (frankt@promise.com)
++ * Released under terms of General Public License
++ *
++ *
++ * libata documentation is available via 'make {ps|pdf}docs',
++ * as Documentation/DocBook/libata.*
++ *
++ * Hardware information only available under NDA.
++ *
++ */
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi.h>
++#include <scsi/scsi_host.h>
++#include <scsi/scsi_cmnd.h>
++#include <linux/libata.h>
++#include <asm/io.h>
++
++#define DRV_NAME "pata_pdc2027x"
++#define DRV_VERSION "0.73"
++#undef PDC_DEBUG
++
++#ifdef PDC_DEBUG
++#define PDPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
++#else
++#define PDPRINTK(fmt, args...)
++#endif
++
++enum {
++ PDC_UDMA_100 = 0,
++ PDC_UDMA_133 = 1,
++
++ PDC_100_MHZ = 100000000,
++ PDC_133_MHZ = 133333333,
++
++ PDC_SYS_CTL = 0x1100,
++ PDC_ATA_CTL = 0x1104,
++ PDC_GLOBAL_CTL = 0x1108,
++ PDC_CTCR0 = 0x110C,
++ PDC_CTCR1 = 0x1110,
++ PDC_BYTE_COUNT = 0x1120,
++ PDC_PLL_CTL = 0x1202,
++};
++
++static int pdc2027x_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
++static void pdc2027x_remove_one(struct pci_dev *pdev);
++static void pdc2027x_phy_reset(struct ata_port *ap);
++static void pdc2027x_set_piomode(struct ata_port *ap, struct ata_device *adev);
++static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev);
++static void pdc2027x_post_set_mode(struct ata_port *ap);
++static int pdc2027x_check_atapi_dma(struct ata_queued_cmd *qc);
++
++/*
++ * ATA Timing Tables based on 133MHz controller clock.
++ * These tables are only used when the controller is in 133MHz clock.
++ * If the controller is in 100MHz clock, the ASIC hardware will
++ * set the timing registers automatically when "set feature" command
++ * is issued to the device. However, if the controller clock is 133MHz,
++ * the following tables must be used.
++ */
++static struct pdc2027x_pio_timing {
++ u8 value0, value1, value2;
++} pdc2027x_pio_timing_tbl [] = {
++ { 0xfb, 0x2b, 0xac }, /* PIO mode 0 */
++ { 0x46, 0x29, 0xa4 }, /* PIO mode 1 */
++ { 0x23, 0x26, 0x64 }, /* PIO mode 2 */
++ { 0x27, 0x0d, 0x35 }, /* PIO mode 3, IORDY on, Prefetch off */
++ { 0x23, 0x09, 0x25 }, /* PIO mode 4, IORDY on, Prefetch off */
++};
++
++static struct pdc2027x_mdma_timing {
++ u8 value0, value1;
++} pdc2027x_mdma_timing_tbl [] = {
++ { 0xdf, 0x5f }, /* MDMA mode 0 */
++ { 0x6b, 0x27 }, /* MDMA mode 1 */
++ { 0x69, 0x25 }, /* MDMA mode 2 */
++};
++
++static struct pdc2027x_udma_timing {
++ u8 value0, value1, value2;
++} pdc2027x_udma_timing_tbl [] = {
++ { 0x4a, 0x0f, 0xd5 }, /* UDMA mode 0 */
++ { 0x3a, 0x0a, 0xd0 }, /* UDMA mode 1 */
++ { 0x2a, 0x07, 0xcd }, /* UDMA mode 2 */
++ { 0x1a, 0x05, 0xcd }, /* UDMA mode 3 */
++ { 0x1a, 0x03, 0xcd }, /* UDMA mode 4 */
++ { 0x1a, 0x02, 0xcb }, /* UDMA mode 5 */
++ { 0x1a, 0x01, 0xcb }, /* UDMA mode 6 */
++};
++
++static const struct pci_device_id pdc2027x_pci_tbl[] = {
++#ifdef ATA_ENABLE_PATA
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20268, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_100 },
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20269, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20270, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_100 },
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20271, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20275, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20276, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20277, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
++#endif
++ { } /* terminate list */
++};
++
++static struct pci_driver pdc2027x_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = pdc2027x_pci_tbl,
++ .probe = pdc2027x_init_one,
++ .remove = __devexit_p(pdc2027x_remove_one),
++};
++
++static struct scsi_host_template pdc2027x_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++};
++
++static struct ata_port_operations pdc2027x_pata100_ops = {
++ .port_disable = ata_port_disable,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = pdc2027x_phy_reset,
++
++ .check_atapi_dma = pdc2027x_check_atapi_dma,
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_mmio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static struct ata_port_operations pdc2027x_pata133_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = pdc2027x_set_piomode,
++ .set_dmamode = pdc2027x_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = pdc2027x_phy_reset,
++ .post_set_mode = pdc2027x_post_set_mode,
++
++ .check_atapi_dma = pdc2027x_check_atapi_dma,
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_mmio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static struct ata_port_info pdc2027x_port_info[] = {
++ /* PDC_UDMA_100 */
++ {
++ .sht = &pdc2027x_sht,
++ .host_flags = ATA_FLAG_NO_LEGACY | ATA_FLAG_SLAVE_POSS |
++ ATA_FLAG_SRST | ATA_FLAG_MMIO,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma0-2 */
++ .udma_mask = ATA_UDMA5, /* udma0-5 */
++ .port_ops = &pdc2027x_pata100_ops,
++ },
++ /* PDC_UDMA_133 */
++ {
++ .sht = &pdc2027x_sht,
++ .host_flags = ATA_FLAG_NO_LEGACY | ATA_FLAG_SLAVE_POSS |
++ ATA_FLAG_SRST | ATA_FLAG_MMIO,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma0-2 */
++ .udma_mask = ATA_UDMA6, /* udma0-6 */
++ .port_ops = &pdc2027x_pata133_ops,
++ },
++};
++
++MODULE_AUTHOR("Andre Hedrick, Frank Tiernan, Albert Lee");
++MODULE_DESCRIPTION("libata driver module for Promise PDC20268 to PDC20277");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++MODULE_DEVICE_TABLE(pci, pdc2027x_pci_tbl);
++
++/**
++ * port_mmio - Get the MMIO address of PDC2027x extended registers
++ * @ap: Port
++ * @offset: offset from mmio base
++ */
++static inline void* port_mmio(struct ata_port *ap, unsigned int offset)
++{
++ return ap->host_set->mmio_base + ap->port_no * 0x100 + offset;
++}
++
++/**
++ * dev_mmio - Get the MMIO address of PDC2027x extended registers
++ * @ap: Port
++ * @adev: device
++ * @offset: offset from mmio base
++ */
++static inline void* dev_mmio(struct ata_port *ap, struct ata_device *adev, unsigned int offset)
++{
++ u8 adj = (adev->devno) ? 0x08 : 0x00;
++ return port_mmio(ap, offset) + adj;
++}
++
++/**
++ * pdc2027x_pata_cbl_detect - Probe host controller cable detect info
++ * @ap: Port for which cable detect info is desired
++ *
++ * Read 80c cable indicator from Promise extended register.
++ * This register is latched when the system is reset.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++static void pdc2027x_cbl_detect(struct ata_port *ap)
++{
++ u32 cgcr;
++
++ /* check cable detect results */
++ cgcr = readl(port_mmio(ap, PDC_GLOBAL_CTL));
++ if (cgcr & (1 << 26))
++ goto cbl40;
++
++ PDPRINTK("No cable or 80-conductor cable on port %d\n", ap->port_no);
++
++ ap->cbl = ATA_CBL_PATA80;
++ return;
++
++cbl40:
++ printk(KERN_INFO DRV_NAME ": 40-conductor cable detected on port %d\n", ap->port_no);
++ ap->cbl = ATA_CBL_PATA40;
++ ap->udma_mask &= ATA_UDMA_MASK_40C;
++}
++
++/**
++ * pdc2027x_port_enabled - Check PDC ATA control register to see whether the port is enabled.
++ * @ap: Port to check
++ */
++static inline int pdc2027x_port_enabled(struct ata_port *ap)
++{
++ return readb(port_mmio(ap, PDC_ATA_CTL)) & 0x02;
++}
++
++/**
++ * pdc2027x_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * Probe PATA phy.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++static void pdc2027x_phy_reset(struct ata_port *ap)
++{
++ /* Check whether port enabled */
++ if (!pdc2027x_port_enabled(ap)) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++
++ pdc2027x_cbl_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * pdc2027x_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port to configure
++ * @adev: um
++ * @pio: PIO mode, 0 - 4
++ *
++ * Set PIO mode for device.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++static void pdc2027x_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int pio = adev->pio_mode - XFER_PIO_0;
++ u32 ctcr0, ctcr1;
++
++ PDPRINTK("adev->pio_mode[%X]\n", adev->pio_mode);
++
++ /* Sanity check */
++ if (pio > 4) {
++ printk(KERN_ERR DRV_NAME ": Unknown pio mode [%d] ignored\n", pio);
++ return;
++
++ }
++
++ /* Set the PIO timing registers using value table for 133MHz */
++ PDPRINTK("Set pio regs... \n");
++
++ ctcr0 = readl(dev_mmio(ap, adev, PDC_CTCR0));
++ ctcr0 &= 0xffff0000;
++ ctcr0 |= pdc2027x_pio_timing_tbl[pio].value0 |
++ (pdc2027x_pio_timing_tbl[pio].value1 << 8);
++ writel(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
++
++ ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
++ ctcr1 &= 0x00ffffff;
++ ctcr1 |= (pdc2027x_pio_timing_tbl[pio].value2 << 24);
++ writel(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
++
++ PDPRINTK("Set pio regs done\n");
++
++ PDPRINTK("Set to pio mode[%u] \n", pio);
++}
++
++/**
++ * pdc2027x_set_dmamode - Initialize host controller PATA UDMA timings
++ * @ap: Port to configure
++ * @adev: um
++ * @udma: udma mode, XFER_UDMA_0 to XFER_UDMA_6
++ *
++ * Set UDMA mode for device.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++static void pdc2027x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int dma_mode = adev->dma_mode;
++ u32 ctcr0, ctcr1;
++
++ if ((dma_mode >= XFER_UDMA_0) &&
++ (dma_mode <= XFER_UDMA_6)) {
++ /* Set the UDMA timing registers with value table for 133MHz */
++ unsigned int udma_mode = dma_mode & 0x07;
++
++ if (dma_mode == XFER_UDMA_2) {
++ /*
++ * Turn off tHOLD.
++ * If tHOLD is '1', the hardware will add half clock for data hold time.
++ * This code segment seems to be no effect. tHOLD will be overwritten below.
++ */
++ ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
++ writel(ctcr1 & ~(1 << 7), dev_mmio(ap, adev, PDC_CTCR1));
++ }
++
++ PDPRINTK("Set udma regs... \n");
++
++ ctcr1 = readl(dev_mmio(ap, adev, PDC_CTCR1));
++ ctcr1 &= 0xff000000;
++ ctcr1 |= pdc2027x_udma_timing_tbl[udma_mode].value0 |
++ (pdc2027x_udma_timing_tbl[udma_mode].value1 << 8) |
++ (pdc2027x_udma_timing_tbl[udma_mode].value2 << 16);
++ writel(ctcr1, dev_mmio(ap, adev, PDC_CTCR1));
++
++ PDPRINTK("Set udma regs done\n");
++
++ PDPRINTK("Set to udma mode[%u] \n", udma_mode);
++
++ } else if ((dma_mode >= XFER_MW_DMA_0) &&
++ (dma_mode <= XFER_MW_DMA_2)) {
++ /* Set the MDMA timing registers with value table for 133MHz */
++ unsigned int mdma_mode = dma_mode & 0x07;
++
++ PDPRINTK("Set mdma regs... \n");
++ ctcr0 = readl(dev_mmio(ap, adev, PDC_CTCR0));
++
++ ctcr0 &= 0x0000ffff;
++ ctcr0 |= (pdc2027x_mdma_timing_tbl[mdma_mode].value0 << 16) |
++ (pdc2027x_mdma_timing_tbl[mdma_mode].value1 << 24);
++
++ writel(ctcr0, dev_mmio(ap, adev, PDC_CTCR0));
++ PDPRINTK("Set mdma regs done\n");
++
++ PDPRINTK("Set to mdma mode[%u] \n", mdma_mode);
++ } else {
++ printk(KERN_ERR DRV_NAME ": Unknown dma mode [%u] ignored\n", dma_mode);
++ }
++}
++
++/**
++ * pdc2027x_post_set_mode - Set the timing registers back to correct values.
++ * @ap: Port to configure
++ *
++ * The pdc2027x hardware will look at "SET FEATURES" and change the timing registers
++ * automatically. The values set by the hardware might be incorrect, under 133Mhz PLL.
++ * This function overwrites the possibly incorrect values set by the hardware to be correct.
++ */
++static void pdc2027x_post_set_mode(struct ata_port *ap)
++{
++ int i;
++
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *dev = &ap->device[i];
++
++ if (ata_dev_present(dev)) {
++
++ pdc2027x_set_piomode(ap, dev);
++
++ /*
++ * Enable prefetch if the device support PIO only.
++ */
++ if (dev->xfer_shift == ATA_SHIFT_PIO) {
++ u32 ctcr1 = readl(dev_mmio(ap, dev, PDC_CTCR1));
++ ctcr1 |= (1 << 25);
++ writel(ctcr1, dev_mmio(ap, dev, PDC_CTCR1));
++
++ PDPRINTK("Turn on prefetch\n");
++ } else {
++ pdc2027x_set_dmamode(ap, dev);
++ }
++ }
++ }
++}
++
++/**
++ * pdc2027x_check_atapi_dma - Check whether ATAPI DMA can be supported for this command
++ * @qc: Metadata associated with taskfile to check
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ *
++ * RETURNS: 0 when ATAPI DMA can be used
++ * 1 otherwise
++ */
++static int pdc2027x_check_atapi_dma(struct ata_queued_cmd *qc)
++{
++ struct scsi_cmnd *cmd = qc->scsicmd;
++ u8 *scsicmd = cmd->cmnd;
++ int rc = 1; /* atapi dma off by default */
++
++ /*
++ * This workaround is from Promise's GPL driver.
++ * If ATAPI DMA is used for commands not in the
++ * following white list, say MODE_SENSE and REQUEST_SENSE,
++ * pdc2027x might hit the irq lost problem.
++ */
++ switch (scsicmd[0]) {
++ case READ_10:
++ case WRITE_10:
++ case READ_12:
++ case WRITE_12:
++ case READ_6:
++ case WRITE_6:
++ case 0xad: /* READ_DVD_STRUCTURE */
++ case 0xbe: /* READ_CD */
++ /* ATAPI DMA is ok */
++ rc = 0;
++ break;
++ default:
++ ;
++ }
++
++ return rc;
++}
++
++/**
++ * pdc_read_counter - Read the ctr counter
++ * @probe_ent: for the port address
++ */
++
++static long pdc_read_counter(struct ata_probe_ent *probe_ent)
++{
++ long counter;
++ int retry = 1;
++ u32 bccrl, bccrh, bccrlv, bccrhv;
++
++retry:
++ bccrl = readl(probe_ent->mmio_base + PDC_BYTE_COUNT) & 0xffff;
++ bccrh = readl(probe_ent->mmio_base + PDC_BYTE_COUNT + 0x100) & 0xffff;
++ rmb();
++
++ /* Read the counter values again for verification */
++ bccrlv = readl(probe_ent->mmio_base + PDC_BYTE_COUNT) & 0xffff;
++ bccrhv = readl(probe_ent->mmio_base + PDC_BYTE_COUNT + 0x100) & 0xffff;
++ rmb();
++
++ counter = (bccrh << 15) | bccrl;
++
++ PDPRINTK("bccrh [%X] bccrl [%X]\n", bccrh, bccrl);
++ PDPRINTK("bccrhv[%X] bccrlv[%X]\n", bccrhv, bccrlv);
++
++ /*
++ * The 30-bit decreasing counter are read by 2 pieces.
++ * Incorrect value may be read when both bccrh and bccrl are changing.
++ * Ex. When 7900 decrease to 78FF, wrong value 7800 might be read.
++ */
++ if (retry && !(bccrh == bccrhv && bccrl >= bccrlv)) {
++ retry--;
++ PDPRINTK("rereading counter\n");
++ goto retry;
++ }
++
++ return counter;
++}
++
++/**
++ * adjust_pll - Adjust the PLL input clock in Hz.
++ *
++ * @pdc_controller: controller specific information
++ * @probe_ent: For the port address
++ * @pll_clock: The input of PLL in HZ
++ */
++static void pdc_adjust_pll(struct ata_probe_ent *probe_ent, long pll_clock, unsigned int board_idx)
++{
++
++ u16 pll_ctl;
++ long pll_clock_khz = pll_clock / 1000;
++ long pout_required = board_idx? PDC_133_MHZ:PDC_100_MHZ;
++ long ratio = pout_required / pll_clock_khz;
++ int F, R;
++
++ /* Sanity check */
++ if (unlikely(pll_clock_khz < 5000L || pll_clock_khz > 70000L)) {
++ printk(KERN_ERR DRV_NAME ": Invalid PLL input clock %ldkHz, give up!\n", pll_clock_khz);
++ return;
++ }
++
++#ifdef PDC_DEBUG
++ PDPRINTK("pout_required is %ld\n", pout_required);
++
++ /* Show the current clock value of PLL control register
++ * (maybe already configured by the firmware)
++ */
++ pll_ctl = readw(probe_ent->mmio_base + PDC_PLL_CTL);
++
++ PDPRINTK("pll_ctl[%X]\n", pll_ctl);
++#endif
++
++ /*
++ * Calculate the ratio of F, R and OD
++ * POUT = (F + 2) / (( R + 2) * NO)
++ */
++ if (ratio < 8600L) { /* 8.6x */
++ /* Using NO = 0x01, R = 0x0D */
++ R = 0x0d;
++ } else if (ratio < 12900L) { /* 12.9x */
++ /* Using NO = 0x01, R = 0x08 */
++ R = 0x08;
++ } else if (ratio < 16100L) { /* 16.1x */
++ /* Using NO = 0x01, R = 0x06 */
++ R = 0x06;
++ } else if (ratio < 64000L) { /* 64x */
++ R = 0x00;
++ } else {
++ /* Invalid ratio */
++ printk(KERN_ERR DRV_NAME ": Invalid ratio %ld, give up!\n", ratio);
++ return;
++ }
++
++ F = (ratio * (R+2)) / 1000 - 2;
++
++ if (unlikely(F < 0 || F > 127)) {
++ /* Invalid F */
++ printk(KERN_ERR DRV_NAME ": F[%d] invalid!\n", F);
++ return;
++ }
++
++ PDPRINTK("F[%d] R[%d] ratio*1000[%ld]\n", F, R, ratio);
++
++ pll_ctl = (R << 8) | F;
++
++ PDPRINTK("Writing pll_ctl[%X]\n", pll_ctl);
++
++ writew(pll_ctl, probe_ent->mmio_base + PDC_PLL_CTL);
++ readw(probe_ent->mmio_base + PDC_PLL_CTL); /* flush */
++
++ /* Wait the PLL circuit to be stable */
++ mdelay(30);
++
++#ifdef PDC_DEBUG
++ /*
++ * Show the current clock value of PLL control register
++ * (maybe configured by the firmware)
++ */
++ pll_ctl = readw(probe_ent->mmio_base + PDC_PLL_CTL);
++
++ PDPRINTK("pll_ctl[%X]\n", pll_ctl);
++#endif
++
++ return;
++}
++
++/**
++ * detect_pll_input_clock - Detect the PLL input clock in Hz.
++ * @probe_ent: for the port address
++ * Ex. 16949000 on 33MHz PCI bus for pdc20275.
++ * Half of the PCI clock.
++ */
++static long pdc_detect_pll_input_clock(struct ata_probe_ent *probe_ent)
++{
++ u32 scr;
++ long start_count, end_count;
++ long pll_clock;
++
++ /* Read current counter value */
++ start_count = pdc_read_counter(probe_ent);
++
++ /* Start the test mode */
++ scr = readl(probe_ent->mmio_base + PDC_SYS_CTL);
++ PDPRINTK("scr[%X]\n", scr);
++ writel(scr | (0x01 << 14), probe_ent->mmio_base + PDC_SYS_CTL);
++ readl(probe_ent->mmio_base + PDC_SYS_CTL); /* flush */
++
++ /* Let the counter run for 100 ms. */
++ mdelay(100);
++
++ /* Read the counter values again */
++ end_count = pdc_read_counter(probe_ent);
++
++ /* Stop the test mode */
++ scr = readl(probe_ent->mmio_base + PDC_SYS_CTL);
++ PDPRINTK("scr[%X]\n", scr);
++ writel(scr & ~(0x01 << 14), probe_ent->mmio_base + PDC_SYS_CTL);
++ readl(probe_ent->mmio_base + PDC_SYS_CTL); /* flush */
++
++ /* calculate the input clock in Hz */
++ pll_clock = (start_count - end_count) * 10;
++
++ PDPRINTK("start[%ld] end[%ld] \n", start_count, end_count);
++ PDPRINTK("PLL input clock[%ld]Hz\n", pll_clock);
++
++ return pll_clock;
++}
++
++/**
++ * pdc_hardware_init - Initialize the hardware.
++ * @pdev: instance of pci_dev found
++ * @pdc_controller: controller specific information
++ * @pe: for the port address
++ */
++static int pdc_hardware_init(struct pci_dev *pdev, struct ata_probe_ent *pe, unsigned int board_idx)
++{
++ long pll_clock;
++
++ /*
++ * Detect PLL input clock rate.
++ * On some system, where PCI bus is running at non-standard clock rate.
++ * Ex. 25MHz or 40MHz, we have to adjust the cycle_time.
++ * The pdc20275 controller employs PLL circuit to help correct timing registers setting.
++ */
++ pll_clock = pdc_detect_pll_input_clock(pe);
++
++ if (pll_clock < 0) /* counter overflow? Try again. */
++ pll_clock = pdc_detect_pll_input_clock(pe);
++
++ dev_printk(KERN_INFO, &pdev->dev, "PLL input clock %ld kHz\n", pll_clock/1000);
++
++ /* Adjust PLL control register */
++ pdc_adjust_pll(pe, pll_clock, board_idx);
++
++ return 0;
++}
++
++/**
++ * pdc_ata_setup_port - setup the mmio address
++ * @port: ata ioports to setup
++ * @base: base address
++ */
++static void pdc_ata_setup_port(struct ata_ioports *port, unsigned long base)
++{
++ port->cmd_addr =
++ port->data_addr = base;
++ port->feature_addr =
++ port->error_addr = base + 0x05;
++ port->nsect_addr = base + 0x0a;
++ port->lbal_addr = base + 0x0f;
++ port->lbam_addr = base + 0x10;
++ port->lbah_addr = base + 0x15;
++ port->device_addr = base + 0x1a;
++ port->command_addr =
++ port->status_addr = base + 0x1f;
++ port->altstatus_addr =
++ port->ctl_addr = base + 0x81a;
++}
++
++/**
++ * pdc2027x_init_one - PCI probe function
++ * Called when an instance of PCI adapter is inserted.
++ * This function checks whether the hardware is supported,
++ * initialize hardware and register an instance of ata_host_set to
++ * libata by providing struct ata_probe_ent and ata_device_add().
++ * (implements struct pci_driver.probe() )
++ *
++ * @pdev: instance of pci_dev found
++ * @ent: matching entry in the id_tbl[]
++ */
++static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ unsigned int board_idx = (unsigned int) ent->driver_data;
++
++ struct ata_probe_ent *probe_ent = NULL;
++ unsigned long base;
++ void *mmio_base;
++ int rc;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
++
++ rc = pci_enable_device(pdev);
++ if (rc)
++ return rc;
++
++ rc = pci_request_regions(pdev, DRV_NAME);
++ if (rc)
++ goto err_out;
++
++ rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
++ if (rc)
++ goto err_out_regions;
++
++ rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
++ if (rc)
++ goto err_out_regions;
++
++ /* Prepare the probe entry */
++ probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
++ if (probe_ent == NULL) {
++ rc = -ENOMEM;
++ goto err_out_regions;
++ }
++
++ memset(probe_ent, 0, sizeof(*probe_ent));
++ probe_ent->dev = pci_dev_to_dev(pdev);
++ INIT_LIST_HEAD(&probe_ent->node);
++
++ mmio_base = ioremap(pci_resource_start(pdev, 5),
++ pci_resource_len(pdev, 5));
++
++ if (mmio_base == NULL) {
++ rc = -ENOMEM;
++ goto err_out_free_ent;
++ }
++
++ base = (unsigned long) mmio_base;
++
++ probe_ent->sht = pdc2027x_port_info[board_idx].sht;
++ probe_ent->host_flags = pdc2027x_port_info[board_idx].host_flags;
++ probe_ent->pio_mask = pdc2027x_port_info[board_idx].pio_mask;
++ probe_ent->mwdma_mask = pdc2027x_port_info[board_idx].mwdma_mask;
++ probe_ent->udma_mask = pdc2027x_port_info[board_idx].udma_mask;
++ probe_ent->port_ops = pdc2027x_port_info[board_idx].port_ops;
++
++ probe_ent->irq = pdev->irq;
++ probe_ent->irq_flags = SA_SHIRQ;
++ probe_ent->mmio_base = mmio_base;
++
++ pdc_ata_setup_port(&probe_ent->port[0], base + 0x17c0);
++ probe_ent->port[0].bmdma_addr = base + 0x1000;
++ pdc_ata_setup_port(&probe_ent->port[1], base + 0x15c0);
++ probe_ent->port[1].bmdma_addr = base + 0x1008;
++
++ probe_ent->n_ports = 2;
++
++ pci_set_master(pdev);
++ //pci_enable_intx(pdev);
++
++ /* initialize adapter */
++ if (pdc_hardware_init(pdev, probe_ent, board_idx) != 0)
++ goto err_out_free_ent;
++
++ ata_device_add(probe_ent);
++ kfree(probe_ent);
++
++ return 0;
++
++err_out_free_ent:
++ kfree(probe_ent);
++err_out_regions:
++ pci_release_regions(pdev);
++err_out:
++ pci_disable_device(pdev);
++ return rc;
++}
++
++/**
++ * pdc2027x_remove_one - Called to remove a single instance of the
++ * adapter.
++ *
++ * @dev: The PCI device to remove.
++ * FIXME: module load/unload not working yet
++ */
++static void __devexit pdc2027x_remove_one(struct pci_dev *pdev)
++{
++ ata_pci_remove_one(pdev);
++}
++
++/**
++ * pdc2027x_init - Called after this module is loaded into the kernel.
++ */
++static int __init pdc2027x_init(void)
++{
++ return pci_register_driver(&pdc2027x_pci_driver);
++}
++
++/**
++ * pdc2027x_exit - Called before this module unloaded from the kernel
++ */
++static void __exit pdc2027x_exit(void)
++{
++ pci_unregister_driver(&pdc2027x_pci_driver);
++}
++
++module_init(pdc2027x_init);
++module_exit(pdc2027x_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_pdc202xx_old.c linux-2.6.16-rc4/drivers/scsi/pata_pdc202xx_old.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_pdc202xx_old.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_pdc202xx_old.c 2006-02-20 13:19:57.000000000 +0000
+@@ -0,0 +1,428 @@
++/*
++ * pata_pdc202xx_old.c - SL82C105 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based in part on linux/drivers/ide/pci/pdc202xx_old.c
++ *
++ * Initial revision
++ *
++ * TODO:
++ * Channel interlock/reset on both required ?
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_pdc202xx_old"
++#define DRV_VERSION "0.1.2"
++
++static void pdc2024x_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++
++static void pdc2026x_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u16 cis;
++
++ pci_read_config_word(pdev, 0x50, &cis);
++ if (cis & (1 << (10 + ap->hard_port_no)))
++ ap->cbl = ATA_CBL_PATA80;
++ else
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++
++/**
++ * pdc_configure_piomode - set chip PIO timing
++ * @ap: ATA interface
++ * @adev: ATA device
++ * @pio: PIO mode
++ *
++ * Called to do the PIO mode setup. Our timing registers are shared
++ * so a configure_dmamode call will undo any work we do here and vice
++ * versa
++ */
++
++static void pdc_configure_piomode(struct ata_port *ap, struct ata_device *adev, int pio)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int port = 0x60 + 4 * ap->hard_port_no + 2 * adev->devno;
++ static u16 pio_timing[5] = {
++ 0x0913, 0x050C , 0x0308, 0x0206, 0x0104
++ };
++ u8 r_ap, r_bp;
++
++ /* FIFO, IORDY ? */
++ pci_read_config_byte(pdev, port, &r_ap);
++ pci_read_config_byte(pdev, port + 1, &r_bp);
++ r_ap &= ~0x0F;
++ r_bp &= ~0x07;
++ r_ap |= (pio_timing[pio] >> 8);
++ r_bp |= (pio_timing[pio] & 0xFF);
++ pci_write_config_byte(pdev, port, r_ap);
++ pci_write_config_byte(pdev, port + 1, r_bp);
++}
++
++/**
++ * pdc_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup. Our timing registers are shared
++ * but we want to set the PIO timing by default.
++ */
++
++static void pdc_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ pdc_configure_piomode(ap, adev, adev->pio_mode - XFER_PIO_0);
++}
++
++/**
++ * pdc_configure_dmamode - set DMA mode in chip
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Load DMA cycle times into the chip ready for a DMA transfer
++ * to occur.
++ */
++
++static void pdc_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int port = 0x60 + 4 * ap->hard_port_no + 2 * adev->devno;
++ static u8 udma_timing[6][2] = {
++ { 0x60, 0x03 }, /* 33 Mhz Clock */
++ { 0x40, 0x02 },
++ { 0x20, 0x01 },
++ { 0x40, 0x02 }, /* 66 Mhz Clock */
++ { 0x20, 0x01 },
++ { 0x20, 0x01 }
++ };
++ u8 r_bp, r_cp;
++
++ pci_read_config_byte(pdev, port + 1, &r_bp);
++ pci_read_config_byte(pdev, port + 2, &r_cp);
++
++ r_bp &= ~0xF0;
++ r_cp &= ~0x0F;
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ int speed = adev->dma_mode - XFER_UDMA_0;
++ r_bp |= udma_timing[speed][0];
++ r_cp |= udma_timing[speed][1];
++
++ } else {
++ int speed = adev->dma_mode - XFER_MW_DMA_0;
++ r_bp |= 0x60;
++ r_cp |= (5 - speed);
++ }
++ pci_write_config_byte(pdev, port + 1, r_bp);
++ pci_write_config_byte(pdev, port + 2, r_cp);
++
++}
++
++/**
++ * pdc2026x_reset_engine - Reset the DMA engine
++ * @ap: ATA interface
++ *
++ * Reset the 2026x DMA engine. This is not something we want to do,
++ * and we need to figure out how to serialize this across dual channel
++ * devices if it is neccessary.
++ *
++ * FIXME: Do we need to reset the other interface too ?
++ */
++
++static void pdc2026x_reset_engine(struct ata_port *ap)
++{
++ unsigned long ctrl = ap->host_set->ports[0]->ioaddr.bmdma_addr + 0x1F;
++
++ u8 val = inb(ctrl);
++ outb(val | 0x10, ctrl);
++ mdelay(100);
++ outb(val & ~0x10, ctrl);
++ mdelay(2000); /* Check - seems to be overkill, plus if needed
++ redo locking */
++ /* Need to fix up speed info at this point */
++}
++
++/**
++ * pdc2026x_bmdma_start - DMA engine begin
++ * @qc: ATA command
++ *
++ * In UDMA3 or higher we have to clock switch for the duration of the
++ * DMA transfer sequence.
++ */
++
++static void pdc2026x_bmdma_start(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ int sel66 = ap->hard_port_no ? 0x08: 0x02;
++ /* The clock bits are in the same register for both channels */
++ unsigned long clock = ap->host_set->ports[0]->ioaddr.bmdma_addr + 0x11;
++
++ /* Check we keep host_set level locking here */
++ if (adev->dma_mode >= XFER_UDMA_2)
++ outb(inb(clock) | sel66, clock);
++ else
++ outb(inb(clock) & ~sel66, clock);
++ /* The DMA clocks may have been trashed by a reset. FIXME: make conditional
++ and move to qc_issue ? */
++ pdc_set_dmamode(ap, qc->dev);
++ /* Activate DMA */
++ ata_bmdma_start(qc);
++}
++
++/**
++ * pdc2026x_bmdma_end - DMA engine stop
++ * @qc: ATA command
++ *
++ * After a DMA completes we need to put the clock back to 33MHz for
++ * PIO timings.
++ */
++
++static void pdc2026x_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ int sel66 = ap->hard_port_no ? 0x08: 0x02;
++ /* The clock bits are in the same register for both channels */
++ unsigned long clock = ap->host_set->ports[0]->ioaddr.bmdma_addr + 0x11;
++
++ /* FIXME: Review LBA48 code in ide/pci driver */
++ ata_bmdma_stop(qc);
++ /* Check we keep host_set level locking here */
++ /* Flip back to 33Mhz for PIO */
++ if (adev->dma_mode >= XFER_UDMA_2)
++ outb(inb(clock) & ~sel66, clock);
++}
++
++/**
++ * pdc2026x_eng_timeout - command timeout
++ * @qc: command that timed out
++ *
++ * When the PDC2026x times out hit the controller over the head
++ * with a hammer before continuing. The reset unfortunately also
++ * resets the timing registers so we must reprogram these.
++ */
++
++static void pdc2026x_eng_timeout(struct ata_port *ap)
++{
++ int i;
++
++ /* Perform libata side housekeeping */
++ ata_eng_timeout(ap);
++
++ /* Reset the controller */
++ pdc2026x_reset_engine(ap);
++
++ /* Reprogram the device timings */
++ for (i = 0; i < 2; i++) {
++ struct ata_device *adev = &ap->device[i];
++ if (ata_dev_present(adev)) {
++ pdc_set_piomode(ap, adev);
++ if (adev->dma_mode)
++ pdc_set_dmamode(ap, adev);
++ }
++ }
++}
++
++/**
++ * pdc2026x_dev_config - device setup hook
++ * @ap: ATA port
++ * @adev: newly found device
++ *
++ * Perform chip specific early setup. We need to lock the transfer
++ * sizes to 8bit to avoid making the state engine on the 2026x cards
++ * barf.
++ */
++
++static void pdc2026x_dev_config(struct ata_port *ap, struct ata_device *adev)
++{
++ /* We cannot blindly set 256 as the core code may already
++ have picked a lower limit */
++
++ if(ap->host->max_sectors > 256) {
++ ap->host->max_sectors = 256;
++ ap->host->hostt->max_sectors = 256;
++ }
++ adev->flags |= ATA_DFLAG_LOCK_SECTORS;
++}
++
++static struct scsi_host_template pdc_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations pdc2024x_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = pdc_set_piomode,
++ .set_dmamode = pdc_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = pdc2024x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations pdc2026x_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = pdc_set_piomode,
++ .set_dmamode = pdc_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++ .dev_config = pdc2026x_dev_config,
++
++ .phy_reset = pdc2026x_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = pdc2026x_bmdma_start,
++ .bmdma_stop = pdc2026x_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = pdc2026x_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int pdc_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info[3] = {
++ {
++ .sht = &pdc_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA2,
++ .port_ops = &pdc2024x_port_ops
++ },
++ {
++ .sht = &pdc_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA4,
++ .port_ops = &pdc2026x_port_ops
++ },
++ {
++ .sht = &pdc_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA5,
++ .port_ops = &pdc2026x_port_ops
++ }
++
++ };
++ static struct ata_port_info *port_info[2];
++
++ port_info[0] = port_info[1] = &info[id->driver_data];
++
++ if (dev->device == PCI_DEVICE_ID_PROMISE_20265) {
++ struct pci_dev *bridge = dev->bus->self;
++ /* Don't grab anything behind a Promise I2O RAID */
++ if (bridge && bridge->vendor == PCI_VENDOR_ID_INTEL) {
++ if( bridge->device == PCI_DEVICE_ID_INTEL_I960)
++ return -ENODEV;
++ if( bridge->device == PCI_DEVICE_ID_INTEL_I960RM)
++ return -ENODEV;
++ }
++ }
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static struct pci_device_id pdc[] = {
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20246, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20262, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20263, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20265, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20267, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { 0, },
++};
++
++static struct pci_driver pdc_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = pdc,
++ .probe = pdc_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init pdc_init(void)
++{
++ return pci_register_driver(&pdc_pci_driver);
++}
++
++
++static void __exit pdc_exit(void)
++{
++ pci_unregister_driver(&pdc_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Promise 2024x and 20262-20267");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, pdc);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(pdc_init);
++module_exit(pdc_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_qdi.c linux-2.6.16-rc4/drivers/scsi/pata_qdi.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_qdi.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_qdi.c 2006-02-15 15:08:22.000000000 +0000
+@@ -0,0 +1,370 @@
++/*
++ * pata_qdi.c - QDI VLB ATA controllers
++ * (C) 2006 Red Hat <alan@redhat.com>
++ *
++ * This driver mostly exists as a proof of concept for non PCI devices under libata.
++ * While the QDI6580 was 'neat' in 1993 it is no longer terribly useful.
++ *
++ * Tuning code written from the documentation at
++ * http://www.ryston.cz/petr/vlb/qd6500.html
++ * http://www.ryston.cz/petr/vlb/qd6580.html
++ *
++ * Probe code based on drivers/ide/legacy/qd65xx.c
++ * Rewritten from the work of Colten Edwards <pje120@cs.usask.ca> by
++ * Samuel Thibault <samuel.thibault@fnac.net>
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_qdi"
++#define DRV_VERSION "0.2"
++
++#define NR_HOST 4 /* Two 6580s */
++
++struct qdi_data {
++ unsigned long timing;
++ u8 clock[2];
++ u8 last;
++ int fast;
++
++};
++
++static struct ata_host_set *qdi_host[NR_HOST];
++static struct qdi_data qdi_data[NR_HOST];
++static int nr_qdi_host = 0;
++
++static void qdi6500_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct ata_timing t;
++ struct qdi_data *qdi = ap->host_set->private_data;
++ int active, recovery;
++ u8 timing;
++
++ /* Get the timing data in cycles */
++ ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
++
++ if (qdi->fast) {
++ active = 8 - FIT(t.active, 1, 8);
++ recovery = 18 - FIT(t.recover, 3, 18);
++ } else {
++ active = 9 - FIT(t.active, 2, 9);
++ recovery = 15 - FIT(t.recover, 0, 15);
++ }
++ timing = (recovery << 4) | active | 0x08;
++
++ qdi->clock[adev->devno] = timing;
++
++ outb(timing, qdi->timing);
++}
++
++static void qdi6580_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct ata_timing t;
++ struct qdi_data *qdi = ap->host_set->private_data;
++ int active, recovery;
++ u8 timing;
++
++ /* Get the timing data in cycles */
++ ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
++
++ if (qdi->fast) {
++ active = 8 - FIT(t.active, 1, 8);
++ recovery = 18 - FIT(t.recover, 3, 18);
++ } else {
++ active = 9 - FIT(t.active, 2, 9);
++ recovery = 15 - FIT(t.recover, 0, 15);
++ }
++ timing = (recovery << 4) | active | 0x08;
++
++ qdi->clock[adev->devno] = timing;
++
++ outb(timing, qdi->timing);
++
++ /* Clear the FIFO */
++ if (adev->class != ATA_DEV_ATA)
++ outb(0x5F, (qdi->timing & 0xFFF0) + 3);
++}
++
++/**
++ * qdi_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings.
++ */
++
++static int qdi_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ struct qdi_data *qdi = ap->host_set->private_data;
++
++ if (qdi->clock[adev->devno] != qdi->last) {
++ if (adev->pio_mode) {
++ qdi->last = qdi->clock[adev->devno];
++ outb(qdi->clock[adev->devno], qdi->timing);
++ }
++ }
++ return ata_qc_issue_prot(qc);
++}
++
++static void qdi_data_xfer(struct ata_port *ap, struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
++{
++ int slop = buflen & 3;
++
++ if (ata_id_has_dword_io(adev->id)) {
++ if (write_data)
++ outsl(ap->ioaddr.data_addr, buf, buflen >> 2);
++ else
++ insl(ap->ioaddr.data_addr, buf, buflen >> 2);
++
++ if (unlikely(slop)) {
++ u32 pad;
++ if (write_data) {
++ memcpy(&pad, buf + buflen - slop, slop);
++ outl(le32_to_cpu(pad), ap->ioaddr.data_addr);
++ } else {
++ pad = cpu_to_le16(inl(ap->ioaddr.data_addr));
++ memcpy(buf + buflen - slop, &pad, slop);
++ }
++ }
++ } else
++ ata_pio_data_xfer(ap, adev, buf, buflen, write_data);
++}
++
++static struct scsi_host_template qdi_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations qdi6500_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = qdi6500_set_piomode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = qdi_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = qdi_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations qdi6580_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = qdi6580_set_piomode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = qdi_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = qdi_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * qdi_init_one - attach a qdi interface
++ * @type: Type to display
++ * @io: I/O port start
++ * @irq: interrupt line
++ * @fast: True if on a > 33Mhz VLB
++ *
++ * Register an ISA bus IDE interface. Such interfaces are PIO and we
++ * assume do not support IRQ sharing.
++ */
++
++static __init int qdi_init_one(unsigned long port, int type, unsigned long io, int irq, int fast)
++{
++ struct ata_probe_ent ae;
++ int ret;
++
++ unsigned long ctrl = io + 0x206;
++
++ /*
++ * Fill in a probe structure first of all
++ */
++
++ memset(&ae, 0, sizeof(struct ata_probe_ent));
++ INIT_LIST_HEAD(&ae.node);
++ ae.dev = NULL;
++
++ if (type == 6580) {
++ ae.port_ops = &qdi6580_port_ops;
++ ae.pio_mask = 0x1F;
++ } else {
++ ae.port_ops = &qdi6500_port_ops;
++ ae.pio_mask = 0x07; /* Actually PIO3 !IORDY is possible */
++ }
++
++ ae.sht = &qdi_sht;
++ ae.n_ports = 1;
++ ae.irq = irq;
++ ae.irq_flags = 0;
++ ae.host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_IRQ_MASK;
++ ae.port[0].cmd_addr = io;
++ ae.port[0].altstatus_addr = ctrl;
++ ae.port[0].ctl_addr = ctrl;
++ ata_std_ports(&ae.port[0]);
++
++ /*
++ * Hook in a private data structure per channel
++ */
++ ae.private_data = &qdi_data[nr_qdi_host];
++
++ qdi_data[nr_qdi_host].timing = port;
++ qdi_data[nr_qdi_host].fast = fast;
++
++ printk(KERN_INFO DRV_NAME": qd%d at 0x%lx.\n", type, io);
++ ret = ata_device_add(&ae);
++ if (ret == 0)
++ return -ENODEV;
++
++ qdi_host[nr_qdi_host++] = ae.host_set;
++ return 0;
++}
++
++/**
++ * qdi_init - attach qdi interfaces
++ *
++ * Attach qdi IDE interfaces by scanning the ports it may occupy.
++ */
++
++static __init int qdi_init(void)
++{
++ unsigned long flags;
++ unsigned long qd_port[2] = { 0x30, 0xB0 };
++ unsigned long ide_port[2] = { 0x170, 0x1F0 };
++ int ide_irq[2] = { 14, 15 };
++ int ct = 0;
++ int i;
++
++ /*
++ * Check each possible QD65xx base address
++ */
++
++ for (i = 0; i < 2; i++) {
++ unsigned long port = qd_port[i];
++ u8 r, res;
++
++
++ if (request_region(port, 2, "pata_qdi")) {
++ /* Check for a card */
++ local_irq_save(flags);
++ r = inb_p(port);
++ outb_p(0x19, port);
++ res = inb_p(port);
++ outb_p(r, port);
++ local_irq_restore(flags);
++
++ /* Fail */
++ if (res == 0x19)
++ {
++ release_region(port, 2);
++ continue;
++ }
++
++ /* Passes the presence test */
++ r = inb_p(port + 1); /* Check port agrees with port set */
++ if ((r & 2) >> 1 != i) {
++ release_region(port, 2);
++ continue;
++ }
++
++ /* Check card type */
++ if ((r & 0xF0) == 0xC0) {
++ /* QD6500: single channel */
++ if (r & 8) {
++ /* Disabled ? */
++ release_region(port, 2);
++ continue;
++ }
++ ct += qdi_init_one(port, 6500, ide_port[r & 0x01], ide_irq[r & 0x01], r & 0x04);
++ }
++ if (((r & 0xF0) == 0xA0) || (r & 0xF0) == 0x50) {
++ /* QD6580: dual channel */
++ if (!request_region(port + 2 , 2, "pata_qdi"))
++ {
++ release_region(port, 2);
++ continue;
++ }
++ res = inb(port + 3);
++ if (res & 1) {
++ /* Single channel mode */
++ ct += qdi_init_one(port, 6580, ide_port[r & 0x01], ide_irq[r & 0x01], r & 0x04);
++ } else {
++ /* Dual channel mode */
++ ct += qdi_init_one(port, 6580, 0x1F0, 14, r & 0x04);
++ ct += qdi_init_one(port + 2, 6580, 0x170, 15, r & 0x04);
++ }
++ }
++ }
++ }
++ if (ct != 0)
++ return 0;
++ return -ENODEV;
++}
++
++static __exit void qdi_exit(void)
++{
++ int i;
++
++ for (i = 0; i < nr_qdi_host; i++) {
++ ata_host_set_remove(qdi_host[i]);
++ /* Free the control resource. The 6580 dual channel has the resources
++ * claimed as a pair of 2 byte resources so we need no special cases...
++ */
++ release_region(qdi_data[i].timing, 2);
++ }
++}
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for qdi ATA");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(qdi_init);
++module_exit(qdi_exit);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_radisys.c linux-2.6.16-rc4/drivers/scsi/pata_radisys.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_radisys.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_radisys.c 2006-02-17 15:31:12.000000000 +0000
+@@ -0,0 +1,321 @@
++/*
++ * pata_radisys.c - Intel PATA/SATA controllers
++ *
++ * (C) 2006 Red Hat <alan@redhat.com>
++ *
++ * Some parts based on ata_piix.c by Jeff Garzik and others.
++ *
++ * A PIIX relative, this device has a single ATA channel and no
++ * slave timings, SITRE or PPE. In that sense it is a close relative
++ * of the original PIIX. It does however support UDMA 33/66 per channel
++ * although no other modes/timings. Also lacking is 32bit I/O on the ATA
++ * port.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <linux/ata.h>
++
++#define DRV_NAME "pata_radisys"
++#define DRV_VERSION "0.2"
++
++/**
++ * radisys_pata_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void radisys_pata_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA80;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * radisys_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: um
++ *
++ * Set PIO mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void radisys_set_piomode (struct ata_port *ap, struct ata_device *adev)
++{
++ unsigned int pio = adev->pio_mode - XFER_PIO_0;
++ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
++ u16 idetm_data;
++ int control = 0;
++
++ /*
++ * See Intel Document 298600-004 for the timing programing rules
++ * for PIIX/ICH. Note that the early PIIX does not have the slave
++ * timing port at 0x44. The Radisys is a relative of the PIIX
++ * but not the same so be careful.
++ */
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 }, /* Check me */
++ { 0, 0 },
++ { 1, 1 },
++ { 2, 2 },
++ { 3, 3 }, };
++
++ if (pio > 0)
++ control |= 1; /* TIME1 enable */
++ if (ata_pio_need_iordy(adev))
++ control |= 2; /* IE IORDY */
++
++ pci_read_config_word(dev, 0x40, &idetm_data);
++
++ /* Enable IE and TIME as appropriate. Clear the other
++ drive timing bits */
++ idetm_data &= 0xCCCC;
++ idetm_data |= (control << (4 * adev->devno));
++ idetm_data |= (timings[pio][0] << 12) |
++ (timings[pio][1] << 8);
++ pci_write_config_word(dev, 0x40, idetm_data);
++
++ /* Track which port is configured */
++ ap->private_data = adev;
++}
++
++/**
++ * radisys_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ * @isich: True if the device is an ICH and has IOCFG registers
++ *
++ * Set MWDMA mode for device, in host controller PCI config space.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void radisys_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *dev = to_pci_dev(ap->host_set->dev);
++ u16 idetm_data;
++ u8 udma_enable;
++
++ static const /* ISP RTC */
++ u8 timings[][2] = { { 0, 0 },
++ { 0, 0 },
++ { 1, 1 },
++ { 2, 2 },
++ { 3, 3 }, };
++
++ /*
++ * MWDMA is driven by the PIO timings. We must also enable
++ * IORDY unconditionally.
++ */
++
++ pci_read_config_word(dev, 0x40, &idetm_data);
++ pci_read_config_byte(dev, 0x48, &udma_enable);
++
++ if (adev->dma_mode < XFER_UDMA_0) {
++ unsigned int mwdma = adev->dma_mode - XFER_MW_DMA_0;
++ const unsigned int needed_pio[3] = {
++ XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
++ };
++ int pio = needed_pio[mwdma] - XFER_PIO_0;
++ int control = 3; /* IORDY|TIME0 */
++
++ /* If the drive MWDMA is faster than it can do PIO then
++ we must force PIO0 for PIO cycles. */
++
++ if (adev->pio_mode < needed_pio[mwdma])
++ control = 1;
++
++ /* Mask out the relevant control and timing bits we will load. Also
++ clear the other drive TIME register as a precaution */
++
++ idetm_data &= 0xCCCC;
++ idetm_data |= control << (4 * adev->devno);
++ idetm_data |= (timings[pio][0] << 12) | (timings[pio][1] << 8);
++
++ udma_enable &= ~(1 << adev->devno);
++ } else {
++ u8 udma_mode;
++
++ /* UDMA66 on. It isn't clear from the documentation whether
++ UDMA 33 and 66 are switchable via register 0x4A */
++
++ pci_read_config_byte(dev, 0x4A, &udma_mode);
++
++ if (adev->xfer_mode == XFER_UDMA_2)
++ udma_mode &= ~ (1 << adev->devno);
++ else /* UDMA 4 */
++ udma_mode |= (1 << adev->devno);
++
++ pci_write_config_byte(dev, 0x4A, udma_mode);
++
++ udma_enable |= (1 << adev->devno);
++ }
++ pci_write_config_word(dev, 0x40, idetm_data);
++ pci_write_config_byte(dev, 0x48, udma_enable);
++
++ /* Track which port is configured */
++ ap->private_data = adev;
++}
++
++/**
++ * radisys_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings if
++ * neccessary. Our logic also clears TIME0/TIME1 for the other device so
++ * that, even if we get this wrong, cycles to the other device will
++ * be made PIO0.
++ */
++
++static int radisys_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++
++ if (adev != ap->private_data) {
++ /* UDMA timing is not shared */
++ if (adev->dma_mode < XFER_UDMA_0) {
++ if (adev->dma_mode)
++ radisys_set_dmamode(ap, adev);
++ else if (adev->pio_mode)
++ radisys_set_piomode(ap, adev);
++ }
++ }
++ return ata_qc_issue_prot(qc);
++}
++
++
++static struct scsi_host_template radisys_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static const struct ata_port_operations radisys_pata_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = radisys_set_piomode,
++ .set_dmamode = radisys_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = radisys_pata_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = radisys_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++
++/**
++ * radisys_init_one - Register PIIX ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in radisys_pci_tbl matching with @pdev
++ *
++ * Called from kernel PCI layer. We probe for combined mode (sigh),
++ * and then hand over control to libata, for it to do the rest.
++ *
++ * LOCKING:
++ * Inherited from PCI layer (may sleep).
++ *
++ * RETURNS:
++ * Zero on success, or -ERRNO value.
++ */
++
++static int radisys_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ static struct ata_port_info info = {
++ .sht = &radisys_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07, /* mwdma1-2 */
++ .udma_mask = 0x14, /* UDMA33/66 only */
++ .port_ops = &radisys_pata_ops,
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev,
++ "version " DRV_VERSION "\n");
++
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id radisys_pci_tbl[] = {
++ { 0x1331, 0x8201, PCI_ANY_ID, PCI_ANY_ID, },
++ { } /* terminate list */
++};
++
++static struct pci_driver radisys_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = radisys_pci_tbl,
++ .probe = radisys_init_one,
++ .remove = ata_pci_remove_one,
++};
++
++static int __init radisys_init(void)
++{
++ return pci_register_driver(&radisys_pci_driver);
++}
++
++static void __exit radisys_exit(void)
++{
++ pci_unregister_driver(&radisys_pci_driver);
++}
++
++
++module_init(radisys_init);
++module_exit(radisys_exit);
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("SCSI low-level driver for Radisys R82600 controllers");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, radisys_pci_tbl);
++MODULE_VERSION(DRV_VERSION);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_rz1000.c linux-2.6.16-rc4/drivers/scsi/pata_rz1000.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_rz1000.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_rz1000.c 2006-02-16 15:38:18.000000000 +0000
+@@ -0,0 +1,183 @@
++/*
++ * RZ1000/1001 driver based upon
++ *
++ * linux/drivers/ide/pci/rz1000.c Version 0.06 January 12, 2003
++ * Copyright (C) 1995-1998 Linus Torvalds & author (see below)
++ * Principal Author: mlord@pobox.com (Mark Lord)
++ *
++ * See linux/MAINTAINERS for address of current maintainer.
++ *
++ * This file provides support for disabling the buggy read-ahead
++ * mode of the RZ1000 IDE chipset, commonly used on Intel motherboards.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "rz1000"
++#define DRV_VERSION "0.01"
++
++static void rz1000_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * rz1000_set_mode - mode setting function
++ * @ap: ATA interface
++ *
++ * Use a non standard set_mode function. We don't want to be tuned. We
++ * would prefer to be BIOS generic but for the fact our hardware is
++ * whacked out.
++ */
++
++static void rz1000_set_mode(struct ata_port *ap)
++{
++ int i;
++
++ for (i = 0; i < ATA_MAX_DEVICES; i++) {
++ struct ata_device *dev = &ap->device[i];
++ if (ata_dev_present(dev)) {
++ /* We don't really care */
++ dev->pio_mode = XFER_PIO_0;
++ dev->xfer_mode = XFER_PIO_0;
++ dev->xfer_shift = ATA_SHIFT_PIO;
++ dev->flags |= ATA_DFLAG_PIO;
++ }
++ }
++}
++
++
++static struct scsi_host_template rz1000_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations rz1000_port_ops = {
++ .set_mode = rz1000_set_mode,
++
++ .port_disable = ata_port_disable,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = rz1000_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * rz1000_init_one - Register RZ1000 ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in rz1000_pci_tbl matching with @pdev
++ *
++ * Configure an RZ1000 interface. This doesn't require much special
++ * handling except that we *MUST* kill the chipset readahead or the
++ * user may experience data corruption.
++ */
++
++static int rz1000_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ struct ata_port_info *port_info[2];
++ u16 reg;
++ static struct ata_port_info info = {
++ .sht = &rz1000_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .port_ops = &rz1000_port_ops
++ };
++
++ if (!printed_version++)
++ printk(KERN_DEBUG DRV_NAME " version " DRV_VERSION "\n");
++
++ /* Be exceptionally paranoid as we must be sure to apply the fix */
++ if (pci_read_config_word(pdev, 0x40, &reg) != 0)
++ goto fail;
++ reg &= 0xDFFF;
++ if (pci_write_config_word(pdev, 0x40, reg) != 0)
++ goto fail;
++ printk(KERN_INFO DRV_NAME ": disabled chipset readahead.\n");
++
++ port_info[0] = &info;
++ port_info[1] = &info;
++ return ata_pci_init_one(pdev, port_info, 2);
++fail:
++ printk(KERN_ERR DRV_NAME ": failed to disable read-ahead on chipset..\n");
++ /* Not safe to use so skip */
++ return -ENODEV;
++}
++
++static struct pci_device_id pata_rz1000[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_RZ1000), },
++ { PCI_DEVICE(PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_RZ1001), },
++ { 0, },
++};
++
++static struct pci_driver rz1000_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = pata_rz1000,
++ .probe = rz1000_init_one,
++ .remove = ata_pci_remove_one
++};
++
++
++static int __init rz1000_init(void)
++{
++ return pci_register_driver(&rz1000_pci_driver);
++}
++
++static void __exit rz1000_exit(void)
++{
++ pci_unregister_driver(&rz1000_pci_driver);
++}
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for RZ1000 PCI ATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, pata_rz1000);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(rz1000_init);
++module_exit(rz1000_exit);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sc1200.c linux-2.6.16-rc4/drivers/scsi/pata_sc1200.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sc1200.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_sc1200.c 2006-02-16 15:46:11.000000000 +0000
+@@ -0,0 +1,286 @@
++/*
++ * New ATA layer SC1200 driver Alan Cox <alan@redhat.com>
++ *
++ * TODO: Mode selection filtering
++ * TODO: Can't enable second channel until ATA core has serialize
++ * TODO: Needs custom DMA cleanup code
++ *
++ * Based very heavily on
++ *
++ * linux/drivers/ide/pci/sc1200.c Version 0.91 28-Jan-2003
++ *
++ * Copyright (C) 2000-2002 Mark Lord <mlord@pobox.com>
++ * May be copied or modified under the terms of the GNU General Public License
++ *
++ * Development of this chipset driver was funded
++ * by the nice folks at National Semiconductor.
++ *
++ * 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.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "sc1200"
++#define DRV_VERSION "0.2"
++
++#define SC1200_REV_A 0x00
++#define SC1200_REV_B1 0x01
++#define SC1200_REV_B3 0x02
++#define SC1200_REV_C1 0x03
++#define SC1200_REV_D1 0x04
++
++/**
++ * sc1200_clock - PCI clock
++ *
++ * Return the PCI bus clocking for the SC1200 chipset configuration
++ * in use. We return 0 for 33MHz 1 for 48MHz and 2 for 66Mhz
++ */
++
++static int sc1200_clock(void)
++{
++ /* Magic registers that give us the chipset data */
++ u8 chip_id = inb(0x903C);
++ u8 silicon_rev = inb(0x903D);
++ u16 pci_clock;
++
++ if (chip_id == 0x04 && silicon_rev < SC1200_REV_B1)
++ return 0; /* 33 MHz mode */
++
++ /* Clock generator configuration 0x901E its 8/9 are the PCI clocking
++ 0/3 is 33Mhz 1 is 48 2 is 66 */
++
++ pci_clock = inw(0x901E);
++ pci_clock >>= 8;
++ pci_clock &= 0x03;
++ if (pci_clock == 3)
++ pci_clock = 0;
++ return pci_clock;
++}
++
++/**
++ * sc1200_set_piomode - PIO setup
++ * @ap: ATA interface
++ * @adev: device on the interface
++ *
++ * Set our PIO requirements. This is fairly simple on the SC1200
++ */
++
++static void sc1200_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u32 pio_timings[4][5] = {
++ {0x00009172, 0x00012171, 0x00020080, 0x00032010, 0x00040010}, // format0 33Mhz
++ {0xd1329172, 0x71212171, 0x30200080, 0x20102010, 0x00100010}, // format1, 33Mhz
++ {0xfaa3f4f3, 0xc23232b2, 0x513101c1, 0x31213121, 0x10211021}, // format1, 48Mhz
++ {0xfff4fff4, 0xf35353d3, 0x814102f1, 0x42314231, 0x11311131} // format1, 66Mhz
++ };
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 format;
++ unsigned int reg = 0x40 + 0x10 * ap->hard_port_no;
++ int mode = adev->pio_mode - XFER_PIO_0;
++
++ pci_read_config_dword(pdev, reg + 4, &format);
++ format >>= 31;
++ format += sc1200_clock();
++ pci_write_config_dword(pdev, reg + 8 * adev->devno,
++ pio_timings[format][mode]);
++}
++
++/**
++ * sc1200_set_dmamode - DMA timing setup
++ * @ap: ATA interface
++ * @adev: Device being configured
++ *
++ * We cannot mix MWDMA and UDMA without reloading timings each switch
++ * master to slave.
++ */
++
++static void sc1200_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u32 udma_timing[3][3] = {
++ { 0x00921250, 0x00911140, 0x00911030 },
++ { 0x00932470, 0x00922260, 0x00922140 },
++ { 0x009436A1, 0x00933481, 0x00923261 }
++ };
++
++ static u32 mwdma_timing[3][3] = {
++ { 0x00077771, 0x00012121, 0x00002020 },
++ { 0x000BBBB2, 0x00024241, 0x00013131 },
++ { 0x000FFFF3, 0x00035352, 0x00015151 }
++ };
++
++ int clock = sc1200_clock();
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ unsigned int reg = 0x40 + 0x10 * ap->hard_port_no;
++ int mode = adev->dma_mode;
++ u32 format;
++
++ if (mode >= XFER_UDMA_0)
++ format = udma_timing[clock][mode - XFER_UDMA_0];
++ else
++ format = mwdma_timing[clock][mode - XFER_MW_DMA_0];
++
++ if (adev->devno == 0) {
++ u32 timings;
++
++ pci_read_config_dword(pdev, reg + 4, &timings);
++ timings &= 0x80000000UL;
++ timings |= format;
++ pci_write_config_dword(pdev, reg + 4, timings);
++ } else
++ pci_write_config_dword(pdev, reg + 12, format);
++}
++
++/**
++ * sc1200_qc_issue_prot - command issue
++ * @qc: command pending
++ *
++ * Called when the libata layer is about to issue a command. We wrap
++ * this interface so that we can load the correct ATA timings if
++ * neccessary. Specifically we have a problem that there is only
++ * one MWDMA/UDMA bit.
++ */
++
++static int sc1200_qc_issue_prot(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++ struct ata_device *adev = qc->dev;
++ struct ata_device *prev = ap->private_data;
++
++ /* See if the DMA settings could be wrong */
++ if (adev->dma_mode != 0 && adev != prev && prev != NULL) {
++ /* Maybe, but do the channels match MWDMA/UDMA ? */
++ if ((adev->dma_mode >= XFER_UDMA_0 && prev->dma_mode < XFER_UDMA_0) ||
++ (adev->dma_mode < XFER_UDMA_0 && prev->dma_mode >= XFER_UDMA_0))
++ /* Switch the mode bits */
++ sc1200_set_dmamode(ap, adev);
++ }
++
++ return ata_qc_issue_prot(qc);
++}
++
++static struct scsi_host_template sc1200_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations sc1200_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sc1200_set_piomode,
++ .set_dmamode = sc1200_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = sc1200_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * sc1200_init_one - Initialise an SC1200
++ * @dev: PCI device
++ * @id: Entry in match table
++ *
++ * Just throw the needed data at the libata helper and it does all
++ * our work.
++ */
++
++static int sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &sc1200_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x07,
++ .port_ops = &sc1200_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++
++ /* Can't enable port 2 yet, see top comments */
++ return ata_pci_init_one(dev, port_info, 1);
++}
++
++static struct pci_device_id sc1200[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_IDE), },
++ { 0, },
++};
++
++static struct pci_driver sc1200_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = sc1200,
++ .probe = sc1200_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init sc1200_init(void)
++{
++ return pci_register_driver(&sc1200_pci_driver);
++}
++
++
++static void __exit sc1200_exit(void)
++{
++ pci_unregister_driver(&sc1200_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox, Mark Lord");
++MODULE_DESCRIPTION("low-level driver for the NS/AMD SC1200");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, sc1200);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(sc1200_init);
++module_exit(sc1200_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_serverworks.c linux-2.6.16-rc4/drivers/scsi/pata_serverworks.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_serverworks.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_serverworks.c 2006-02-16 15:37:31.000000000 +0000
+@@ -0,0 +1,586 @@
++/*
++ * ata-serverworks.c - Serverworks PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * based upon
++ *
++ * serverworks.c
++ *
++ * Copyright (C) 1998-2000 Michel Aubry
++ * Copyright (C) 1998-2000 Andrzej Krzysztofowicz
++ * Copyright (C) 1998-2000 Andre Hedrick <andre@linux-ide.org>
++ * Portions copyright (c) 2001 Sun Microsystems
++ *
++ *
++ * RCC/ServerWorks IDE driver for Linux
++ *
++ * OSB4: `Open South Bridge' IDE Interface (fn 1)
++ * supports UDMA mode 2 (33 MB/s)
++ *
++ * CSB5: `Champion South Bridge' IDE Interface (fn 1)
++ * all revisions support UDMA mode 4 (66 MB/s)
++ * revision A2.0 and up support UDMA mode 5 (100 MB/s)
++ *
++ * *** The CSB5 does not provide ANY register ***
++ * *** to detect 80-conductor cable presence. ***
++ *
++ * CSB6: `Champion South Bridge' IDE Interface (optional: third channel)
++ *
++ * Documentation:
++ * Available under NDA only. Errata info very hard to get.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "serverworks"
++#define DRV_VERSION "0.1.1"
++
++#define SVWKS_CSB5_REVISION_NEW 0x92 /* min PCI_REVISION_ID for UDMA5 (A2.0) */
++#define SVWKS_CSB6_REVISION 0xa0 /* min PCI_REVISION_ID for UDMA4 (A1.0) */
++
++/* Seagate Barracuda ATA IV Family drives in UDMA mode 5
++ * can overrun their FIFOs when used with the CSB5 */
++
++static const char *csb_bad_ata100[] = {
++ "ST320011A",
++ "ST340016A",
++ "ST360021A",
++ "ST380021A",
++ NULL
++};
++
++/**
++ * dell_cable - Dell serverworks cable detection
++ * @ap: ATA port to do cable detect
++ *
++ * Dell hide the 40/80 pin select for their interfaces in the top two
++ * bits of the subsystem ID.
++ */
++
++static int dell_cable(struct ata_port *ap) {
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ if (pdev->subsystem_device & (1 << (ap->hard_port_no + 14)))
++ return ATA_CBL_PATA80;
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * sun_cable - Sun Cobalt 'Alpine' cable detection
++ * @ap: ATA port to do cable select
++ *
++ * Cobalt CSB5 IDE hides the 40/80pin in the top two bits of the
++ * subsystem ID the same as dell. We could use one function but we may
++ * need to extend the Dell one in future
++ */
++
++static int sun_cable(struct ata_port *ap) {
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ if (pdev->subsystem_device & (1 << (ap->hard_port_no + 14)))
++ return ATA_CBL_PATA80;
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * osb4_cable - OSB4 cable detect
++ * @ap: ATA port to check
++ *
++ * The OSB4 isn't UDMA66 capable so this is easy
++ */
++
++static int osb4_cable(struct ata_port *ap) {
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * csb4_cable - CSB5/6 cable detect
++ * @ap: ATA port to check
++ *
++ * Serverworks default arrangement is to use the drive side detection
++ * only.
++ */
++
++static int csb_cable(struct ata_port *ap) {
++ return ATA_CBL_PATA80;
++}
++
++struct sv_cable_table {
++ int device;
++ int subvendor;
++ int (*cable_detect)(struct ata_port *ap);
++};
++
++/*
++ * Note that we don't copy the old serverworks code because the old
++ * code contains obvious mistakes
++ */
++
++static struct sv_cable_table cable_detect[] = {
++ { PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_VENDOR_ID_DELL, dell_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_CSB6IDE, PCI_VENDOR_ID_DELL, dell_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_VENDOR_ID_SUN, sun_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_OSB4, PCI_ANY_ID, osb4_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_ANY_ID, csb_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_CSB6IDE, PCI_ANY_ID, csb_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2, PCI_ANY_ID, csb_cable },
++ { PCI_DEVICE_ID_SERVERWORKS_HT1000IDE, PCI_ANY_ID, csb_cable },
++ { }
++};
++
++/**
++ * serverworks_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection according to the device and subvendor
++ * identifications
++ */
++
++static int serverworks_cable_detect(struct ata_port *ap) {
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct sv_cable_table *cb = cable_detect;
++
++ while(cb->device) {
++ if (cb->device == pdev->device &&
++ (cb->subvendor == pdev->subsystem_vendor ||
++ cb->subvendor == PCI_ANY_ID)) {
++ return cb->cable_detect(ap);
++ }
++ cb++;
++ }
++ BUG();
++}
++
++static void serverworks_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = serverworks_cable_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * serverworks_is_csb - Check for CSB or OSB
++ * @pdev: PCI device to check
++ *
++ * Returns true if the device being checked is known to be a CSB
++ * series device.
++ */
++
++static u8 serverworks_is_csb(struct pci_dev *pdev)
++{
++ switch (pdev->device) {
++ case PCI_DEVICE_ID_SERVERWORKS_CSB5IDE:
++ case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE:
++ case PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2:
++ case PCI_DEVICE_ID_SERVERWORKS_HT1000IDE:
++ return 1;
++ default:
++ break;
++ }
++ return 0;
++}
++
++/**
++ * serverworks_osb4_filter - mode selection filter
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Filter the offered modes for the device to apply controller
++ * specific rules. OSB4 requires no UDMA for disks due to a FIFO
++ * bug we hit.
++ */
++
++static unsigned int serverworks_osb4_filter(const struct ata_port *ap, struct ata_device *adev, unsigned int mask, int shift)
++{
++ if (shift != ATA_SHIFT_UDMA)
++ return mask;
++ if (adev->class == ATA_DEV_ATA)
++ return 0;
++ return mask;
++}
++
++
++/**
++ * serverworks_csb_filter - mode selection filter
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Check the blacklist and disable UDMA5 if matched
++ */
++
++static unsigned int serverworks_csb_filter(const struct ata_port *ap, struct ata_device *adev, unsigned int mask, int shift)
++{
++ const char *p;
++ char model_num[40];
++ int len, i;
++
++ /* Disk, UDMA */
++ if (shift != ATA_SHIFT_UDMA)
++ return mask;
++ if (adev->class != ATA_DEV_ATA)
++ return mask;
++
++ /* Actually do need to check */
++ ata_dev_id_string(adev->id, model_num, ATA_ID_PROD_OFS, sizeof(model_num));
++ /* Precuationary - why not do this in the libata core ?? */
++
++ len = strlen(model_num);
++ while ((len > 0) && (model_num[len - 1] == ' ')) {
++ len--;
++ model_num[len] = 0;
++ }
++
++ for(i = 0; (p = csb_bad_ata100[i]) != NULL; i++) {
++ if (!strncmp(p, model_num, len))
++ return mask & 0x1F;
++ }
++ return mask;
++}
++
++
++/**
++ * serverworks_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the OSB4/CSB5 timing registers for PIO. The PIO register
++ * load is done as a simple lookup.
++ */
++static void serverworks_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u8 pio_mode[] = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
++ int offset = 1 + 2 * ap->hard_port_no - adev->devno;
++ int devbits = (2 * ap->hard_port_no + adev->devno) * 4;
++ u16 csb5_pio;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int pio = adev->pio_mode - XFER_PIO_0;
++
++ pci_write_config_byte(pdev, 0x40 + offset, pio_mode[pio]);
++
++ /* The OSB4 just requires the timing but the CSB series want the
++ mode number as well */
++ if (serverworks_is_csb(pdev)) {
++ pci_read_config_word(pdev, 0x4A, &csb5_pio);
++ csb5_pio &= ~(0x0F << devbits);
++ pci_write_config_byte(pdev, 0x4A, csb5_pio | (pio << devbits));
++ }
++}
++
++/**
++ * serverworks_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the MWDMA/UDMA modes for the serverworks OSB4/CSB5
++ * chipset. The MWDMA mode values are pulled from a lookup table
++ * while the chipset uses mode number for UDMA.
++ */
++
++static void serverworks_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u8 dma_mode[] = { 0x77, 0x21, 0x20 };
++ int offset = 1 + 2 * ap->hard_port_no - adev->devno;
++ int devbits = (2 * ap->hard_port_no + adev->devno);
++ u8 ultra;
++ u8 ultra_cfg;
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ pci_read_config_byte(pdev, 0x54, &ultra_cfg);
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ pci_write_config_byte(pdev, 0x44 + offset, 0x20);
++
++ pci_read_config_byte(pdev, 0x56 + ap->hard_port_no, &ultra);
++ ultra &= ~(0x0F << (ap->hard_port_no * 4));
++ ultra |= (adev->dma_mode - XFER_UDMA_0)
++ << (ap->hard_port_no * 4);
++ pci_write_config_byte(pdev, 0x56 + ap->hard_port_no, ultra);
++
++ ultra_cfg |= (1 << devbits);
++ } else {
++ pci_write_config_byte(pdev, 0x44 + offset,
++ dma_mode[adev->dma_mode - XFER_MW_DMA_0]);
++ ultra_cfg &= ~(1 << devbits);
++ }
++ pci_write_config_byte(pdev, 0x54, ultra_cfg);
++}
++
++static struct scsi_host_template serverworks_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations serverworks_osb4_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = serverworks_set_piomode,
++ .set_dmamode = serverworks_set_dmamode,
++ .mode_filter = serverworks_osb4_filter,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = serverworks_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations serverworks_csb_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = serverworks_set_piomode,
++ .set_dmamode = serverworks_set_dmamode,
++ .mode_filter = serverworks_csb_filter,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = serverworks_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int serverworks_fixup_osb4(struct pci_dev *pdev)
++{
++ u32 reg;
++ struct pci_dev *isa_dev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
++ PCI_DEVICE_ID_SERVERWORKS_OSB4, NULL);
++ if (isa_dev) {
++ pci_read_config_dword(isa_dev, 0x64, &reg);
++ reg &= ~0x00002000; /* disable 600ns interrupt mask */
++ if (!(reg & 0x00004000))
++ printk(KERN_DEBUG DRV_NAME ": UDMA not BIOS enabled.\n");
++ reg |= 0x00004000; /* enable UDMA/33 support */
++ pci_write_config_dword(isa_dev, 0x64, reg);
++ pci_dev_put(isa_dev);
++ return 0;
++ }
++ printk(KERN_WARNING "ata_serverworks: Unable to find bridge.\n");
++ return -ENODEV;
++}
++
++static int serverworks_fixup_csb(struct pci_dev *pdev)
++{
++ u8 rev;
++ u8 btr;
++
++ pci_read_config_byte(pdev, PCI_REVISION_ID, &rev);
++
++ /* Third Channel Test */
++ if (!(PCI_FUNC(pdev->devfn) & 1)) {
++ struct pci_dev * findev = NULL;
++ u32 reg4c = 0;
++ findev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
++ PCI_DEVICE_ID_SERVERWORKS_CSB5, NULL);
++ if (findev) {
++ pci_read_config_dword(findev, 0x4C, &reg4c);
++ reg4c &= ~0x000007FF;
++ reg4c |= 0x00000040;
++ reg4c |= 0x00000020;
++ pci_write_config_dword(findev, 0x4C, reg4c);
++ pci_dev_put(findev);
++ }
++ } else {
++ struct pci_dev * findev = NULL;
++ u8 reg41 = 0;
++
++ findev = pci_get_device(PCI_VENDOR_ID_SERVERWORKS,
++ PCI_DEVICE_ID_SERVERWORKS_CSB6, NULL);
++ if (findev) {
++ pci_read_config_byte(findev, 0x41, &reg41);
++ reg41 &= ~0x40;
++ pci_write_config_byte(findev, 0x41, reg41);
++ pci_dev_put(findev);
++ }
++ }
++ /* setup the UDMA Control register
++ *
++ * 1. clear bit 6 to enable DMA
++ * 2. enable DMA modes with bits 0-1
++ * 00 : legacy
++ * 01 : udma2
++ * 10 : udma2/udma4
++ * 11 : udma2/udma4/udma5
++ */
++ pci_read_config_byte(pdev, 0x5A, &btr);
++ btr &= ~0x40;
++ if (!(PCI_FUNC(pdev->devfn) & 1))
++ btr |= 0x2;
++ else
++ btr |= (rev >= SVWKS_CSB5_REVISION_NEW) ? 0x3 : 0x2;
++ pci_write_config_byte(pdev, 0x5A, btr);
++
++ return btr;
++}
++
++static void serverworks_fixup_ht1000(struct pci_dev *pdev)
++{
++ u8 btr;
++ /* Setup HT1000 SouthBridge Controller - Single Channel Only */
++ pci_read_config_byte(pdev, 0x5A, &btr);
++ btr &= ~0x40;
++ btr |= 0x3;
++ pci_write_config_byte(pdev, 0x5A, btr);
++}
++
++
++static int serverworks_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ int ports = 2;
++ static struct ata_port_info info[4] = {
++ { /* OSB4 */
++ .sht = &serverworks_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x07,
++ .port_ops = &serverworks_osb4_port_ops
++ }, { /* OSB4 no UDMA */
++ .sht = &serverworks_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x00,
++ .port_ops = &serverworks_osb4_port_ops
++ }, { /* CSB5 */
++ .sht = &serverworks_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f,
++ .port_ops = &serverworks_csb_port_ops
++ }, { /* CSB5 - later revisions*/
++ .sht = &serverworks_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &serverworks_csb_port_ops
++ }
++ };
++ static struct ata_port_info *port_info[2];
++ struct ata_port_info *devinfo = &info[id->driver_data];
++
++ /* Force master latency timer to 64 PCI clocks */
++ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x40);
++
++ /* OSB4 : South Bridge and IDE */
++ if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_OSB4IDE) {
++ /* Select non UDMA capable OSB4 if we can't do fixups */
++ if ( serverworks_fixup_osb4(pdev) < 0)
++ devinfo = &info[1];
++ }
++ /* setup CSB5/CSB6 : South Bridge and IDE option RAID */
++ else if ((pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE) ||
++ (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) ||
++ (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2)) {
++
++ /* If the returned btr is the newer revision then
++ select the right info block */
++ if (serverworks_fixup_csb(pdev) == 3)
++ devinfo = &info[3];
++
++ /* Is this the 3rd channel CSB6 IDE ? */
++ if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2)
++ ports = 1;
++ }
++ /* setup HT1000E */
++ else if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_HT1000IDE)
++ serverworks_fixup_ht1000(pdev);
++
++ if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE)
++ ata_pci_clear_simplex(pdev);
++
++ port_info[0] = port_info[1] = devinfo;
++ return ata_pci_init_one(pdev, port_info, ports);
++}
++
++static struct pci_device_id serverworks[] = {
++ { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
++ { 0, },
++};
++
++static struct pci_driver serverworks_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = serverworks,
++ .probe = serverworks_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init serverworks_init(void)
++{
++ return pci_register_driver(&serverworks_pci_driver);
++}
++
++
++static void __exit serverworks_exit(void)
++{
++ pci_unregister_driver(&serverworks_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Serverworks OSB4/CSB5/CSB6");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, serverworks);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(serverworks_init);
++module_exit(serverworks_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sil680.c linux-2.6.16-rc4/drivers/scsi/pata_sil680.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sil680.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_sil680.c 2006-02-16 15:28:00.000000000 +0000
+@@ -0,0 +1,368 @@
++/*
++ * pata_sil680.c - SIL680 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * based upon
++ *
++ * linux/drivers/ide/pci/siimage.c Version 1.07 Nov 30, 2003
++ *
++ * Copyright (C) 2001-2002 Andre Hedrick <andre@linux-ide.org>
++ * Copyright (C) 2003 Red Hat <alan@redhat.com>
++ *
++ * May be copied or modified under the terms of the GNU General Public License
++ *
++ * Documentation publically available.
++ *
++ * If you have strange problems with nVidia chipset systems please
++ * see the SI support documentation and update your system BIOS
++ * if neccessary
++ *
++ * TODO
++ * If we know all our devices are LBA28 (or LBA28 sized) we could use
++ * the command fifo mode.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_sil680"
++#define DRV_VERSION "0.2.1"
++
++/**
++ * sil680_selreg - return register base
++ * @hwif: interface
++ * @r: config offset
++ *
++ * Turn a config register offset into the right address in either
++ * PCI space or MMIO space to access the control register in question
++ * Thankfully this is a configuration operation so isnt performance
++ * criticial.
++ */
++
++static unsigned long sil680_selreg(struct ata_port *ap, int r)
++{
++ unsigned long base = 0xA0 + r;
++ base += (ap->hard_port_no << 4);
++ return base;
++}
++
++/**
++ * sil680_seldev - return register base
++ * @hwif: interface
++ * @r: config offset
++ *
++ * Turn a config register offset into the right address in either
++ * PCI space or MMIO space to access the control register in question
++ * including accounting for the unit shift.
++ */
++
++static unsigned long sil680_seldev(struct ata_port *ap, struct ata_device *adev, int r)
++{
++ unsigned long base = 0xA0 + r;
++ base += (ap->hard_port_no << 4);
++ base |= adev->devno ? 2 : 0;
++ return base;
++}
++
++
++/**
++ * sil680_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection. The SIL680 stores this in PCI config
++ * space for us.
++ */
++
++static int sil680_cable_detect(struct ata_port *ap) {
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ unsigned long addr = sil680_selreg(ap, 0);
++ u8 ata66;
++ pci_read_config_byte(pdev, addr, &ata66);
++ if (ata66 & 1)
++ return ATA_CBL_PATA80;
++ else
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * sil680_bus_reset - reset the SIL680 bus
++ * @ap: ATA port to reset
++ *
++ * Perform the SIL680 housekeeping when doing an ATA bus reset
++ */
++
++static void sil680_bus_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ unsigned long addr = sil680_selreg(ap, 0);
++ u8 reset;
++
++ pci_read_config_byte(pdev, addr, &reset);
++ pci_write_config_byte(pdev, addr, reset | 0x03);
++ udelay(25);
++ pci_write_config_byte(pdev, addr, reset);
++ ata_bus_reset(ap);
++}
++
++static void sil680_phy_reset(struct ata_port *ap)
++{
++ ap->cbl = sil680_cable_detect(ap);
++ sil680_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * sil680_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the SIL680 registers for PIO mode. Note that the task speed
++ * registers are shared between the devices so we must pick the lowest
++ * mode for command work.
++ */
++
++static void sil680_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u16 speed_p[5] = { 0x328A, 0x2283, 0x1104, 0x10C3, 0x10C1 };
++ static u16 speed_t[5] = { 0x328A, 0x1281, 0x1281, 0x10C3, 0x10C1 };
++
++ unsigned long tfaddr = sil680_selreg(ap, 0x02);
++ unsigned long addr = sil680_seldev(ap, adev, 0x04);
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int pio = adev->pio_mode - XFER_PIO_0;
++ int lowest_pio = pio;
++ u16 reg;
++
++ struct ata_device *pair = ata_dev_pair(ap, adev);
++
++ if (pair != NULL) {
++ if (adev->pio_mode > pair->pio_mode)
++ lowest_pio = pair->pio_mode - XFER_PIO_0;
++ }
++
++ pci_write_config_word(pdev, addr, speed_p[pio]);
++ pci_write_config_word(pdev, tfaddr, speed_t[lowest_pio]);
++
++ pci_read_config_word(pdev, tfaddr-2, &reg);
++ reg &= ~0x0200; /* Clear IORDY */
++ if (ata_pio_need_iordy(adev))
++ reg |= 0x0200; /* Enable IORDY */
++ pci_write_config_word(pdev, tfaddr-2, reg);
++}
++
++/**
++ * sil680_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Program the MWDMA/UDMA modes for the sil680 k
++ * chipset. The MWDMA mode values are pulled from a lookup table
++ * while the chipset uses mode number for UDMA.
++ */
++
++static void sil680_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ static u8 ultra_table[2][7] = {
++ { 0x0C, 0x07, 0x05, 0x04, 0x02, 0x01, 0xFF }, /* 100MHz */
++ { 0x0F, 0x0B, 0x07, 0x05, 0x03, 0x02, 0x01 }, /* 133Mhz */
++ };
++ static u16 dma_table[3] = { 0x2208, 0x10C2, 0x10C1 };
++
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ unsigned long ma = sil680_seldev(ap, adev, 0x08);
++ unsigned long ua = sil680_seldev(ap, adev, 0x0C);
++ unsigned long addr_mask = 0x80 + 4 * ap->hard_port_no;
++ int port_shift = adev->devno * 4;
++ u8 scsc, mode;
++ u16 multi, ultra;
++
++ pci_read_config_byte(pdev, 0x8A, &scsc);
++ pci_read_config_byte(pdev, addr_mask, &mode);
++ pci_read_config_word(pdev, ma, &multi);
++ pci_read_config_word(pdev, ua, &ultra);
++
++ /* Mask timing bits */
++ ultra &= ~0x3F;
++ mode &= ~(0x03 << port_shift);
++
++ /* Extract scsc */
++ scsc = (scsc & 0x30) ? 1: 0;
++
++ if (adev->dma_mode >= XFER_UDMA_0) {
++ multi = 0x10C1;
++ ultra |= ultra_table[scsc][adev->dma_mode - XFER_UDMA_0];
++ mode |= (0x03 << port_shift);
++ } else {
++ multi = dma_table[adev->dma_mode - XFER_MW_DMA_0];
++ mode |= (0x02 << port_shift);
++ }
++ pci_write_config_byte(pdev, addr_mask, mode);
++ pci_write_config_word(pdev, ma, multi);
++ pci_write_config_word(pdev, ua, ultra);
++}
++
++static struct scsi_host_template sil680_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations sil680_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sil680_set_piomode,
++ .set_dmamode = sil680_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sil680_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int sil680_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &sil680_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7f,
++ .port_ops = &sil680_port_ops
++ };
++ static struct ata_port_info info_slow = {
++ .sht = &sil680_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &sil680_port_ops
++ };
++ static struct ata_port_info *port_info[2] = {&info, &info};
++ static int printed_version;
++ u32 class_rev = 0;
++ u8 tmpbyte = 0;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
++
++ pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
++ class_rev &= 0xff;
++ /* FIXME: double check */
++ pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE, (class_rev) ? 1 : 255);
++
++ pci_write_config_byte(pdev, 0x80, 0x00);
++ pci_write_config_byte(pdev, 0x84, 0x00);
++ pci_read_config_byte(pdev, 0x8A, &tmpbyte);
++ switch(tmpbyte & 0x30) {
++ case 0x00:
++ /* 133 clock attempt to force it on */
++ pci_write_config_byte(pdev, 0x8A, tmpbyte|0x10);
++ case 0x30:
++ /* if clocking is disabled */
++ /* 133 clock attempt to force it on */
++ pci_write_config_byte(pdev, 0x8A, tmpbyte & ~0x20);
++ case 0x10:
++ /* 133 already */
++ break;
++ case 0x20:
++ /* BIOS set PCI x2 clocking */
++ break;
++ }
++
++ pci_read_config_byte(pdev, 0x8A, &tmpbyte);
++ if ((tmpbyte & 0x30) == 0)
++ port_info[0] = port_info[1] = &info_slow;
++
++ pci_write_config_byte(pdev, 0xA1, 0x72);
++ pci_write_config_word(pdev, 0xA2, 0x328A);
++ pci_write_config_dword(pdev, 0xA4, 0x62DD62DD);
++ pci_write_config_dword(pdev, 0xA8, 0x43924392);
++ pci_write_config_dword(pdev, 0xAC, 0x40094009);
++ pci_write_config_byte(pdev, 0xB1, 0x72);
++ pci_write_config_word(pdev, 0xB2, 0x328A);
++ pci_write_config_dword(pdev, 0xB4, 0x62DD62DD);
++ pci_write_config_dword(pdev, 0xB8, 0x43924392);
++ pci_write_config_dword(pdev, 0xBC, 0x40094009);
++
++ switch(tmpbyte & 0x30) {
++ case 0x00: printk(KERN_INFO "sil680: 100MHz clock.\n");break;
++ case 0x10: printk(KERN_INFO "sil680: 133MHz clock.\n");break;
++ case 0x20: printk(KERN_INFO "sil680: Using PCI clock.\n");break;
++ /* This last case is _NOT_ ok */
++ case 0x30: printk(KERN_ERR "sil680: Clock disabled ?\n");
++ return -EIO;
++ }
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id sil680[] = {
++ { PCI_DEVICE(PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_680), },
++ { 0, },
++};
++
++static struct pci_driver sil680_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = sil680,
++ .probe = sil680_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init sil680_init(void)
++{
++ return pci_register_driver(&sil680_pci_driver);
++}
++
++
++static void __exit sil680_exit(void)
++{
++ pci_unregister_driver(&sil680_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for SI680 PATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, sil680);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(sil680_init);
++module_exit(sil680_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sis.c linux-2.6.16-rc4/drivers/scsi/pata_sis.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sis.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_sis.c 2006-02-16 15:36:13.000000000 +0000
+@@ -0,0 +1,982 @@
++/*
++ * pata_sis.c - SiS ATA driver
++ *
++ * (C) 2005 Red Hat <alan@redhat.com>
++ *
++ * Based upon linux/drivers/ide/pci/sis5513.c
++ * Copyright (C) 1999-2000 Andre Hedrick <andre@linux-ide.org>
++ * Copyright (C) 2002 Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer
++ * Copyright (C) 2003 Vojtech Pavlik <vojtech@suse.cz>
++ * SiS Taiwan : for direct support and hardware.
++ * Daniela Engert : for initial ATA100 advices and numerous others.
++ * John Fremlin, Manfred Spraul, Dave Morgan, Peter Kjellerstedt :
++ * for checking code correctness, providing patches.
++ * Original tests and design on the SiS620 chipset.
++ * ATA100 tests and design on the SiS735 chipset.
++ * ATA16/33 support from specs
++ * ATA133 support for SiS961/962 by L.C. Chang <lcchang@sis.com.tw>
++ *
++ *
++ * TODO
++ * Check MWDMA on drives that don't support MWDMA speed pio cycles ?
++ * More Testing
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++#include <linux/ata.h>
++
++#define DRV_NAME "pata_sis"
++#define DRV_VERSION "0.1"
++
++struct sis_chipset {
++ u16 device; /* PCI host ID */
++ struct ata_port_info *info; /* Info block */
++ /* Probably add family, cable detect type etc here to clean
++ up code later */
++};
++
++/**
++ * sis_133_cable_detect - check for 40/80 pin
++ * @ap: Port
++ *
++ * Perform cable detection for the later UDMA133 capable
++ * SiS chipset.
++ */
++
++static int sis_133_cable_detect(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u16 tmp;
++
++ pci_read_config_word(pdev, 0x50 + 2 * ap->hard_port_no, &tmp);
++ if (tmp & 0x8000)
++ return ATA_CBL_PATA40;
++ return ATA_CBL_PATA80;
++}
++
++/**
++ * sis_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_133_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits sis_enable_bits[] = {
++ { 0x4aU, 1U, 0x02UL, 0x02UL }, /* port 0 */
++ { 0x4aU, 1U, 0x04UL, 0x04UL }, /* port 1 */
++ };
++
++ if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = sis_133_cable_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++
++/**
++ * sis_66_cable_detect - check for 40/80 pin
++ * @ap: Port
++ *
++ * Perform cable detection on the UDMA66, UDMA100 and early UDMA133
++ * SiS IDE controllers.
++ */
++
++static int sis_66_cable_detect(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 tmp;
++
++ pci_read_config_byte(pdev, 0x48, &tmp);
++ tmp >>= ap->hard_port_no;
++ if (tmp & 0x10)
++ return ATA_CBL_PATA40;
++ return ATA_CBL_PATA80;
++}
++
++/**
++ * sis_66_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_66_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits sis_enable_bits[] = {
++ { 0x4aU, 1U, 0x02UL, 0x02UL }, /* port 0 */
++ { 0x4aU, 1U, 0x04UL, 0x04UL }, /* port 1 */
++ };
++
++ if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = sis_66_cable_detect(ap);
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++
++/**
++ * sis_old_phy_reset - Probe specified port on PATA host controller
++ * @ap: Port to probe
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_old_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits sis_enable_bits[] = {
++ { 0x4aU, 1U, 0x02UL, 0x02UL }, /* port 0 */
++ { 0x4aU, 1U, 0x04UL, 0x04UL }, /* port 1 */
++ };
++
++ if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * sis_set_fifo - Set RWP fifo bits for this device
++ * @ap: Port
++ * @adev: Device
++ *
++ * SIS chipsets implement prefetch/postwrite bits for each device
++ * on both channels. This functionality is not ATAPI compatible and
++ * must be configured according to the class of device present
++ */
++
++static void sis_set_fifo(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u8 reg4b;
++ u8 mask = 0x11;
++
++ mask <<= (2 * ap->hard_port_no);
++ mask <<= adev->devno;
++
++ pci_read_config_byte(pdev, 0x4B, &reg4b);
++ reg4b &= ~mask;
++
++ /* Enable for ATA (disk) only */
++ if (adev->class == ATA_DEV_ATA)
++ reg4b |= mask;
++ pci_write_config_byte(pdev, 0x4B, reg4b);
++}
++
++/**
++ * sis_old_set_piomode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring for.
++ *
++ * Set PIO mode for device, in host controller PCI config space. This
++ * function handles PIO set up for all chips that are pre ATA100 and
++ * also early ATA100 devices.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_old_set_piomode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int port = 0x40 + 4 * ap->hard_port_no + 2 * adev->devno;
++ u8 t1, t2;
++ int speed = adev->pio_mode - XFER_PIO_0;
++
++ const u8 active[] = { 0x00, 0x07, 0x04, 0x03, 0x01 };
++ const u8 recovery[] = { 0x00, 0x06, 0x04, 0x03, 0x03 };
++
++ sis_set_fifo(ap, adev);
++
++ pci_read_config_byte(pdev, port, &t1);
++ pci_read_config_byte(pdev, port + 1, &t2);
++
++ t1 &= ~0x0F; /* Clear active/recovery timings */
++ t2 &= ~0x07;
++
++ t1 |= active[speed];
++ t2 |= recovery[speed];
++
++ pci_write_config_byte(pdev, port, t1);
++ pci_write_config_byte(pdev, port + 1, t2);
++}
++
++/**
++ * sis_100_set_pioode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring for.
++ *
++ * Set PIO mode for device, in host controller PCI config space. This
++ * function handles PIO set up for ATA100 devices and early ATA133.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_100_set_piomode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int port = 0x40 + 4 * ap->hard_port_no + 2 * adev->devno;
++ int speed = adev->pio_mode - XFER_PIO_0;
++
++ const u8 actrec[] = { 0x00, 0x67, 0x44, 0x33, 0x31 };
++
++ sis_set_fifo(ap, adev);
++
++ pci_write_config_byte(pdev, port, actrec[speed]);
++}
++
++/**
++ * sis_133_set_pioode - Initialize host controller PATA PIO timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device we are configuring for.
++ *
++ * Set PIO mode for device, in host controller PCI config space. This
++ * function handles PIO set up for the later ATA133 devices.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_133_set_piomode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int port = 0x40;
++ u32 t1;
++ u32 reg54;
++ int speed = adev->pio_mode - XFER_PIO_0;
++
++ const u32 timing100[] = {
++ 0x28269000, /* Recovery << 24 | Act << 16 | Ini << 12 */
++ 0x0C266000,
++ 0x04263000,
++ 0x0C0A3000,
++ 0x05093000
++ };
++ const u32 timing133[] = {
++ 0x1E1C6000, /* Recovery << 24 | Act << 16 | Ini << 12 */
++ 0x091C4000,
++ 0x031C2000,
++ 0x09072000,
++ 0x04062000
++ };
++
++ sis_set_fifo(ap, adev);
++
++ pci_read_config_dword(pdev, 0x54, &reg54);
++ if (reg54 & 0x40000000)
++ port = 0x70;
++ port += 8 * ap->hard_port_no + 4 * adev->devno;
++
++ pci_read_config_dword(pdev, port, &t1);
++ t1 &= 0xC0C00FFF; /* Mask out timing */
++
++ if (t1 & 0x08) /* 100 or 133 ? */
++ t1 |= timing133[speed];
++ else
++ t1 |= timing100[speed];
++ pci_write_config_byte(pdev, port, t1);
++}
++
++/**
++ * sis_old_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ *
++ * Set UDMA/MWDMA mode for device, in host controller PCI config space.
++ * Handles pre UDMA and UDMA33 devices. Supports MWDMA as well unlike
++ * the old ide/pci driver.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_old_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int speed = adev->dma_mode - XFER_MW_DMA_0;
++ int drive_pci = 0x40 + 4 * ap->hard_port_no + 2 * adev->devno;
++ u16 timing;
++
++ const u16 mwdma_bits[] = { 0x707, 0x202, 0x202 };
++ const u16 udma_bits[] = {
++ 0xE000, 0xC000, 0xA000
++ };
++
++ pci_read_config_word(pdev, drive_pci, &timing);
++
++ if (adev->dma_mode < XFER_UDMA_0) {
++ /* bits 3-0 hold recovery timing bits 8-10 active timing and
++ the higer bits are dependant on the device */
++ timing &= ~ 0x870F;
++ timing |= mwdma_bits[speed];
++ pci_write_config_word(pdev, drive_pci, timing);
++ } else {
++ /* Bit 15 is UDMA on/off, bit 13-14 are cycle time */
++ speed = adev->dma_mode - XFER_UDMA_0;
++ timing &= ~0x6000;
++ timing |= udma_bits[speed];
++ }
++}
++
++/**
++ * sis_66_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ *
++ * Set UDMA/MWDMA mode for device, in host controller PCI config space.
++ * Handles UDMA66 and early UDMA100 devices. Supports MWDMA as well unlike
++ * the old ide/pci driver.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_66_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int speed = adev->dma_mode - XFER_MW_DMA_0;
++ int drive_pci = 0x40 + 4 * ap->hard_port_no + 2 * adev->devno;
++ u16 timing;
++
++ const u16 mwdma_bits[] = { 0x707, 0x202, 0x202 };
++ const u16 udma_bits[] = { 0xF000, 0xD000, 0xB000, 0xA000, 0x9000};
++
++ pci_read_config_word(pdev, drive_pci, &timing);
++
++ if (adev->dma_mode < XFER_UDMA_0) {
++ /* bits 3-0 hold recovery timing bits 8-10 active timing and
++ the higer bits are dependant on the device, bit 15 udma */
++ timing &= ~ 0x870F;
++ timing |= mwdma_bits[speed];
++ } else {
++ /* Bit 15 is UDMA on/off, bit 12-14 are cycle time */
++ speed = adev->dma_mode - XFER_UDMA_0;
++ timing &= ~0x6000;
++ timing |= udma_bits[speed];
++ }
++ pci_write_config_word(pdev, drive_pci, timing);
++}
++
++/**
++ * sis_100_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ *
++ * Set UDMA/MWDMA mode for device, in host controller PCI config space.
++ * Handles UDMA66 and early UDMA100 devices.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_100_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int speed = adev->dma_mode - XFER_MW_DMA_0;
++ int drive_pci = 0x40 + 4 * ap->hard_port_no + 2 * adev->devno;
++ u16 timing;
++
++ const u16 udma_bits[] = { 0x8B00, 0x8700, 0x8500, 0x8300, 0x8200, 0x8100};
++
++ pci_read_config_word(pdev, drive_pci, &timing);
++
++ if (adev->dma_mode < XFER_UDMA_0) {
++ /* NOT SUPPORTED YET: NEED DATA SHEET. DITTO IN OLD DRIVER */
++ } else {
++ /* Bit 15 is UDMA on/off, bit 12-14 are cycle time */
++ speed = adev->dma_mode - XFER_UDMA_0;
++ timing &= ~0x0F00;
++ timing |= udma_bits[speed];
++ }
++ pci_write_config_word(pdev, drive_pci, timing);
++}
++
++/**
++ * sis_133_early_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ *
++ * Set UDMA/MWDMA mode for device, in host controller PCI config space.
++ * Handles early SiS 961 bridges. Supports MWDMA as well unlike
++ * the old ide/pci driver.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_133_early_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int speed = adev->dma_mode - XFER_MW_DMA_0;
++ int drive_pci = 0x40 + 4 * ap->hard_port_no + 2 * adev->devno;
++ u16 timing;
++
++ const u16 udma_bits[] = { 0x8F00, 0x8A00, 0x8700, 0x8500, 0x8300, 0x8200, 0x8100};
++
++ pci_read_config_word(pdev, drive_pci, &timing);
++
++ if (adev->dma_mode < XFER_UDMA_0) {
++ /* NOT SUPPORTED YET: NEED DATA SHEET. DITTO IN OLD DRIVER */
++ } else {
++ /* Bit 15 is UDMA on/off, bit 12-14 are cycle time */
++ speed = adev->dma_mode - XFER_UDMA_0;
++ timing &= ~0x0F00;
++ timing |= udma_bits[speed];
++ }
++ pci_write_config_word(pdev, drive_pci, timing);
++}
++
++/**
++ * sis_133_set_dmamode - Initialize host controller PATA DMA timings
++ * @ap: Port whose timings we are configuring
++ * @adev: Device to program
++ *
++ * Set UDMA/MWDMA mode for device, in host controller PCI config space.
++ * Handles early SiS 961 bridges. Supports MWDMA as well unlike
++ * the old ide/pci driver.
++ *
++ * LOCKING:
++ * None (inherited from caller).
++ */
++
++static void sis_133_set_dmamode (struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ int speed = adev->dma_mode - XFER_MW_DMA_0;
++ int port = 0x40;
++ u32 t1;
++ u32 reg54;
++
++ /* bits 4- cycle time 8 - cvs time */
++ const u32 timing_u100[] = { 0x6B0, 0x470, 0x350, 0x140, 0x120, 0x110, 0x000 };
++ const u32 timing_u133[] = { 0x9F0, 0x6A0, 0x470, 0x250, 0x230, 0x220, 0x210 };
++
++ pci_read_config_dword(pdev, 0x54, &reg54);
++ if (reg54 & 0x40000000)
++ port = 0x70;
++ port += 8 * ap->hard_port_no + 4 * adev->devno;
++
++ pci_read_config_dword(pdev, port, &t1);
++
++ if (adev->dma_mode < XFER_UDMA_0) {
++ t1 &= ~0x00000004;
++ /* FIXME: need data sheet to add MWDMA here. Also lacking on
++ ide/pci driver */
++ } else {
++ speed = adev->dma_mode - XFER_UDMA_0;
++ /* if & 8 no UDMA133 - need info for ... */
++ t1 &= ~0x00000FF0;
++ t1 |= 0x00000004;
++ if (t1 & 0x08)
++ t1 |= timing_u133[speed];
++ else
++ t1 |= timing_u100[speed];
++ }
++ pci_write_config_dword(pdev, port, t1);
++}
++
++static struct scsi_host_template sis_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static const struct ata_port_operations sis_133_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sis_133_set_piomode,
++ .set_dmamode = sis_133_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sis_133_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static const struct ata_port_operations sis_133_early_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sis_100_set_piomode,
++ .set_dmamode = sis_133_early_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sis_66_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static const struct ata_port_operations sis_100_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sis_100_set_piomode,
++ .set_dmamode = sis_100_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sis_66_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static const struct ata_port_operations sis_66_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sis_old_set_piomode,
++ .set_dmamode = sis_66_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sis_66_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static const struct ata_port_operations sis_old_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sis_old_set_piomode,
++ .set_dmamode = sis_old_set_dmamode,
++
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sis_old_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
++
++ .eng_timeout = ata_eng_timeout,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop,
++};
++
++static struct ata_port_info sis_info = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07,
++ .udma_mask = 0,
++ .port_ops = &sis_old_ops,
++};
++static struct ata_port_info sis_info33 = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .mwdma_mask = 0x07,
++ .udma_mask = ATA_UDMA2, /* UDMA 33 */
++ .port_ops = &sis_old_ops,
++};
++static struct ata_port_info sis_info66 = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .udma_mask = ATA_UDMA4, /* UDMA 66 */
++ .port_ops = &sis_66_ops,
++};
++static struct ata_port_info sis_info100 = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .udma_mask = ATA_UDMA5,
++ .port_ops = &sis_100_ops,
++};
++static struct ata_port_info sis_info100_early = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .udma_mask = ATA_UDMA5,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .port_ops = &sis_66_ops,
++};
++static struct ata_port_info sis_info133 = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .udma_mask = ATA_UDMA6,
++ .port_ops = &sis_133_ops,
++};
++static struct ata_port_info sis_info133_early = {
++ .sht = &sis_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .udma_mask = ATA_UDMA6,
++ .port_ops = &sis_133_early_ops,
++};
++
++
++static void sis_fixup(struct pci_dev *pdev, struct sis_chipset *sis)
++{
++ u16 regw;
++ u8 reg;
++
++ if (sis->info == &sis_info133) {
++ pci_read_config_word(pdev, 0x50, &regw);
++ if (regw & 0x08)
++ pci_write_config_word(pdev, 0x50, regw & ~0x08);
++ pci_read_config_word(pdev, 0x52, &regw);
++ if (regw & 0x08)
++ pci_write_config_word(pdev, 0x52, regw & ~0x08);
++ return;
++ }
++
++ if (sis->info == &sis_info133_early || sis->info == &sis_info100) {
++ /* Fix up latency */
++ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
++ /* Set compatibility bit */
++ pci_read_config_byte(pdev, 0x49, &reg);
++ if (!(reg & 0x01))
++ pci_write_config_byte(pdev, 0x49, reg | 0x01);
++ return;
++ }
++
++ if (sis->info == &sis_info66 || sis->info == &sis_info100_early) {
++ /* Fix up latency */
++ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
++ /* Set compatibility bit */
++ pci_read_config_byte(pdev, 0x52, &reg);
++ if (!(reg & 0x04))
++ pci_write_config_byte(pdev, 0x52, reg | 0x04);
++ return;
++ }
++
++ if (sis->info == &sis_info33) {
++ pci_read_config_byte(pdev, PCI_CLASS_PROG, &reg);
++ if (( reg & 0x0F ) != 0x00)
++ pci_write_config_byte(pdev, PCI_CLASS_PROG, reg & 0xF0);
++ /* Fall through to ATA16 fixup below */
++ }
++
++ if (sis->info == &sis_info || sis->info == &sis_info33) {
++ /* force per drive recovery and active timings
++ needed on ATA_33 and below chips */
++ pci_read_config_byte(pdev, 0x52, &reg);
++ if (!(reg & 0x08))
++ pci_write_config_byte(pdev, 0x52, reg|0x08);
++ return;
++ }
++
++ BUG();
++}
++
++/**
++ * sis_init_one - Register SiS ATA PCI device with kernel services
++ * @pdev: PCI device to register
++ * @ent: Entry in sis_pci_tbl matching with @pdev
++ *
++ * Called from kernel PCI layer. We probe for combined mode (sigh),
++ * and then hand over control to libata, for it to do the rest.
++ *
++ * LOCKING:
++ * Inherited from PCI layer (may sleep).
++ *
++ * RETURNS:
++ * Zero on success, or -ERRNO value.
++ */
++
++static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
++{
++ static int printed_version;
++ static struct ata_port_info *port_info[2];
++ struct ata_port_info *port;
++ struct pci_dev *host;
++ struct sis_chipset *chipset = NULL;
++
++ static struct sis_chipset sis_chipsets[] = {
++ { 0x0745, &sis_info100 },
++ { 0x0735, &sis_info100 },
++ { 0x0733, &sis_info100 },
++ { 0x0635, &sis_info100 },
++ { 0x0633, &sis_info100 },
++
++ { 0x0730, &sis_info100_early }, /* 100 with ATA 66 layout */
++ { 0x0550, &sis_info100_early }, /* 100 with ATA 66 layout */
++
++ { 0x0640, &sis_info66 },
++ { 0x0630, &sis_info66 },
++ { 0x0620, &sis_info66 },
++ { 0x0540, &sis_info66 },
++ { 0x0530, &sis_info66 },
++
++ { 0x5600, &sis_info33 },
++ { 0x5598, &sis_info33 },
++ { 0x5597, &sis_info33 },
++ { 0x5591, &sis_info33 },
++ { 0x5582, &sis_info33 },
++ { 0x5581, &sis_info33 },
++
++ { 0x5596, &sis_info },
++ { 0x5571, &sis_info },
++ { 0x5517, &sis_info },
++ { 0x5511, &sis_info },
++
++ {0}
++ };
++ static struct sis_chipset sis133_early = {
++ 0x0, &sis_info133_early
++ };
++ static struct sis_chipset sis133 = {
++ 0x0, &sis_info133
++ };
++ static struct sis_chipset sis100_early = {
++ 0x0, &sis_info100_early
++ };
++ static struct sis_chipset sis100 = {
++ 0x0, &sis_info100
++ };
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev,
++ "version " DRV_VERSION "\n");
++
++ /* We have to find the bridge first */
++
++ for (chipset = &sis_chipsets[0]; chipset->device; chipset++) {
++ host = pci_get_device(0x1039, chipset->device, NULL);
++ if (host != NULL) {
++ if (chipset->device == 0x630) { /* SIS630 */
++ u8 host_rev;
++ pci_read_config_byte(host, PCI_REVISION_ID, &host_rev);
++ if (host_rev >= 0x30) /* 630 ET */
++ chipset = &sis100_early;
++ }
++ break;
++ }
++ }
++
++ /* Look for concealed bridges */
++ if (host == NULL) {
++ /* Second check */
++ u32 idemisc;
++ u16 trueid;
++
++ /* Disable ID masking and register remapping then
++ see what the real ID is */
++
++ pci_read_config_dword(pdev, 0x54, &idemisc);
++ pci_write_config_dword(pdev, 0x54, idemisc & 0x7fffffff);
++ pci_read_config_word(pdev, PCI_DEVICE_ID, &trueid);
++ pci_write_config_dword(pdev, 0x54, idemisc);
++
++ switch(trueid) {
++ case 0x5518: /* SIS 962/963 */
++ chipset = &sis133;
++ if ((idemisc & 0x40000000) == 0) {
++ pci_write_config_dword(pdev, 0x54, idemisc | 0x40000000);
++ printk(KERN_INFO "SIS5513: Switching to 5513 register mapping\n");
++ }
++ break;
++ case 0x0180: /* SIS 965/965L */
++ chipset = &sis133;
++ break;
++ case 0x1180: /* SIS 966/966L */
++ chipset = &sis133;
++ break;
++ }
++ }
++
++ /* Further check */
++ if (chipset == NULL) {
++ struct pci_dev *lpc_bridge;
++ u16 trueid;
++ u8 prefctl;
++ u8 idecfg;
++ u8 sbrev;
++
++ /* Try the second unmasking technique */
++ pci_read_config_byte(pdev, 0x4a, &idecfg);
++ pci_write_config_byte(pdev, 0x4a, idecfg | 0x10);
++ pci_read_config_word(pdev, PCI_DEVICE_ID, &trueid);
++ pci_write_config_byte(pdev, 0x4a, idecfg);
++
++ switch(trueid) {
++ case 0x5517:
++ lpc_bridge = pci_get_slot(0x00, 0x10); /* Bus 0 Dev 2 Fn 0 */
++ if (lpc_bridge == NULL)
++ break;
++ pci_read_config_byte(lpc_bridge, PCI_REVISION_ID, &sbrev);
++ pci_read_config_byte(pdev, 0x49, &prefctl);
++ pci_dev_put(lpc_bridge);
++
++ if (sbrev == 0x10 && (prefctl & 0x80)) {
++ chipset = &sis133_early;
++ break;
++ }
++ chipset = &sis100;
++ break;
++ }
++ }
++ pci_dev_put(host);
++
++ /* No chipset info, no support */
++ if (chipset == NULL)
++ return -ENODEV;
++
++ port = chipset->info;
++ port->private_data = chipset;
++
++ sis_fixup(pdev, chipset);
++
++ port_info[0] = port_info[1] = port;
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id sis_pci_tbl[] = {
++ { 0x1039, 0x5513, PCI_ANY_ID, PCI_ANY_ID, },
++ { 0x1039, 0x5518, PCI_ANY_ID, PCI_ANY_ID, },
++ { } /* terminate list */
++};
++
++static struct pci_driver sis_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = sis_pci_tbl,
++ .probe = sis_init_one,
++ .remove = ata_pci_remove_one,
++};
++
++static int __init sis_init(void)
++{
++ return pci_register_driver(&sis_pci_driver);
++}
++
++static void __exit sis_exit(void)
++{
++ pci_unregister_driver(&sis_pci_driver);
++}
++
++
++module_init(sis_init);
++module_exit(sis_exit);
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("SCSI low-level driver for SiS ATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, sis_pci_tbl);
++MODULE_VERSION(DRV_VERSION);
++
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sl82c105.c linux-2.6.16-rc4/drivers/scsi/pata_sl82c105.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_sl82c105.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_sl82c105.c 2006-02-16 15:36:32.000000000 +0000
+@@ -0,0 +1,376 @@
++/*
++ * pata_sl82c105.c - SL82C105 PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Based in part on linux/drivers/ide/pci/sl82c105.c
++ * SL82C105/Winbond 553 IDE driver
++ *
++ * and in part on the documentation and errata sheet
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_sl82c105"
++#define DRV_VERSION "0.1.1"
++
++enum {
++ /*
++ * SL82C105 PCI config register 0x40 bits.
++ */
++ CTRL_IDE_IRQB = (1 << 30),
++ CTRL_IDE_IRQA = (1 << 28),
++ CTRL_LEGIRQ = (1 << 11),
++ CTRL_P1F16 = (1 << 5),
++ CTRL_P1EN = (1 << 4),
++ CTRL_P0F16 = (1 << 1),
++ CTRL_P0EN = (1 << 0)
++};
++
++static void sl82c105_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits sl82c105_enable_bits[] = {
++ { 0x40, 1, 0x01, 0x01 },
++ { 0x40, 1, 0x10, 0x10 }
++ };
++
++ if (ap->hard_port_no && !pci_test_config_bits(pdev, &sl82c105_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ dev_printk(KERN_INFO, &pdev->dev, "port disabled. ignoring.\n");
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++
++/**
++ * sl82c105_configure_piomode - set chip PIO timing
++ * @ap: ATA interface
++ * @adev: ATA device
++ * @pio: PIO mode
++ *
++ * Called to do the PIO mode setup. Our timing registers are shared
++ * so a configure_dmamode call will undo any work we do here and vice
++ * versa
++ */
++
++static void sl82c105_configure_piomode(struct ata_port *ap, struct ata_device *adev, int pio)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static u16 pio_timing[5] = {
++ 0x50D, 0x407, 0x304, 0x242, 0x240
++ };
++ u16 dummy;
++ int timing = 0x44 + 8 * ap->hard_port_no + 4 * adev->devno;
++
++ pci_write_config_word(pdev, timing, pio_timing[pio]);
++ /* Can we lose this oddity of the old driver */
++ pci_read_config_word(pdev, timing, &dummy);
++}
++
++/**
++ * sl82c105_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the PIO mode setup. Our timing registers are shared
++ * but we want to set the PIO timing by default.
++ */
++
++static void sl82c105_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ sl82c105_configure_piomode(ap, adev, adev->pio_mode - XFER_PIO_0);
++}
++
++/**
++ * sl82c105_configure_dmamode - set DMA mode in chip
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Load DMA cycle times into the chip ready for a DMA transfer
++ * to occur.
++ */
++
++static void sl82c105_configure_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static u16 dma_timing[3] = {
++ 0x707, 0x201, 0x200
++ };
++ u16 dummy;
++ int timing = 0x44 + 8 * ap->hard_port_no + 4 * adev->devno;
++ int dma = adev->dma_mode - XFER_MW_DMA_0;
++
++ pci_write_config_word(pdev, timing, dma_timing[dma]);
++ /* Can we lose this oddity of the old driver */
++ pci_read_config_word(pdev, timing, &dummy);
++}
++
++/**
++ * sl82c105_set_dmamode - set initial DMA mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Called to do the DMA mode setup. This replaces the PIO timings
++ * for the device in question. Set appropriate PIO timings not DMA
++ * timings at this point.
++ */
++
++static void sl82c105_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ switch(adev->dma_mode) {
++ case XFER_MW_DMA_0:
++ sl82c105_configure_piomode(ap, adev, 1);
++ break;
++ case XFER_MW_DMA_1:
++ sl82c105_configure_piomode(ap, adev, 3);
++ break;
++ case XFER_MW_DMA_2:
++ sl82c105_configure_piomode(ap, adev, 3);
++ break;
++ default:
++ BUG();
++ }
++}
++
++/**
++ * sl82c105_reset_engine - Reset the DMA engine
++ * @ap: ATA interface
++ *
++ * The sl82c105 has some serious problems with the DMA engine
++ * when transfers don't run as expected or ATAPI is used. The
++ * recommended fix is to reset the engine each use using a chip
++ * test register.
++ */
++
++static void sl82c105_reset_engine(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u16 val;
++
++ pci_read_config_word(pdev, 0x7E, &val);
++ pci_write_config_word(pdev, 0x7E, val | 4);
++ pci_write_config_word(pdev, 0x7E, val & ~4);
++}
++
++/**
++ * sl82c105_bmdma_start - DMA engine begin
++ * @qc: ATA command
++ *
++ * Reset the DMA engine each use as recommended by the errata
++ * document.
++ *
++ * FIXME: if we switch clock at BMDMA start/end we might get better
++ * PIO performance on DMA capable devices.
++ */
++
++static void sl82c105_bmdma_start(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++
++ sl82c105_reset_engine(ap);
++
++ /* Set the clocks for DMA */
++ sl82c105_configure_dmamode(ap, qc->dev);
++ /* Activate DMA */
++ ata_bmdma_start(qc);
++}
++
++/**
++ * sl82c105_bmdma_end - DMA engine stop
++ * @qc: ATA command
++ *
++ * Reset the DMA engine each use as recommended by the errata
++ * document.
++ *
++ * This function is also called to turn off DMA when a timeout occurs
++ * during DMA operation. In both cases we need to reset the engine,
++ * so no actual eng_timeout handler is required.
++ *
++ * We assume bmdma_stop is always called if bmdma_start as called. If
++ * not then we may need to wrap qc_issue.
++ */
++
++static void sl82c105_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ struct ata_port *ap = qc->ap;
++
++ ata_bmdma_stop(qc);
++ sl82c105_reset_engine(ap);
++
++ /* This will redo the initial setup of the DMA device to matching
++ PIO timings */
++ sl82c105_set_dmamode(ap, qc->dev);
++}
++
++static struct scsi_host_template sl82c105_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations sl82c105_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = sl82c105_set_piomode,
++ .set_dmamode = sl82c105_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = sl82c105_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = sl82c105_bmdma_start,
++ .bmdma_stop = sl82c105_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * sl82c105_bridge_revision - find bridge version
++ * @pdev: PCI device for the ATA function
++ *
++ * Locates the PCI bridge associated with the ATA function and
++ * providing it is a Winbond 553 reports the revision. If it cannot
++ * find a revision or the right device it returns -1
++ */
++
++static int sl82c105_bridge_revision(struct pci_dev *pdev)
++{
++ struct pci_dev *bridge;
++ u8 rev;
++
++ /*
++ * The bridge should be part of the same device, but function 0.
++ */
++ bridge = pci_get_slot(pdev->bus,
++ PCI_DEVFN(PCI_SLOT(pdev->devfn), 0));
++ if (!bridge)
++ return -1;
++
++ /*
++ * 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) {
++ pci_dev_put(bridge);
++ return -1;
++ }
++ /*
++ * We need to find function 0's revision, not function 1
++ */
++ pci_read_config_byte(bridge, PCI_REVISION_ID, &rev);
++
++ pci_dev_put(bridge);
++ return rev;
++}
++
++
++static int sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info_dma = {
++ .sht = &sl82c105_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &sl82c105_port_ops
++ };
++ static struct ata_port_info info_early = {
++ .sht = &sl82c105_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .port_ops = &sl82c105_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info_early, &info_early };
++ u32 val;
++ int rev;
++
++ rev = sl82c105_bridge_revision(dev);
++
++ if (rev == -1)
++ dev_printk(KERN_WARNING, &dev->dev, "pata_sl82c105: Unable to find bridge, disabling DMA.\n");
++ else if (rev <= 5)
++ dev_printk(KERN_WARNING, &dev->dev, "pata_sl82c105: Early bridge revision, no DMA available.\n");
++ else {
++ port_info[0] = &info_dma;
++ port_info[1] = &info_dma;
++ }
++
++ pci_read_config_dword(dev, 0x40, &val);
++ val |= CTRL_P0EN | CTRL_P0F16 | CTRL_P1F16;
++ pci_write_config_dword(dev, 0x40, val);
++
++
++ return ata_pci_init_one(dev, port_info, 1); /* For now */
++}
++
++static struct pci_device_id sl82c105[] = {
++ { PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_82C105, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { 0, },
++};
++
++static struct pci_driver sl82c105_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = sl82c105,
++ .probe = sl82c105_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init sl82c105_init(void)
++{
++ return pci_register_driver(&sl82c105_pci_driver);
++}
++
++
++static void __exit sl82c105_exit(void)
++{
++ pci_unregister_driver(&sl82c105_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Sl82c105");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, sl82c105);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(sl82c105_init);
++module_exit(sl82c105_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_triflex.c linux-2.6.16-rc4/drivers/scsi/pata_triflex.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_triflex.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_triflex.c 2006-02-16 15:36:23.000000000 +0000
+@@ -0,0 +1,268 @@
++/*
++ * pata_triflex.c - Compaq PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * based upon
++ *
++ * triflex.c
++ *
++ * IDE Chipset driver for the Compaq TriFlex IDE controller.
++ *
++ * Known to work with the Compaq Workstation 5x00 series.
++ *
++ * Copyright (C) 2002 Hewlett-Packard Development Group, L.P.
++ * Author: Torben Mathiasen <torben.mathiasen@hp.com>
++ *
++ * 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.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ * Loosely based on the piix & svwks drivers.
++ *
++ * Documentation:
++ * Not publically available.
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_triflex"
++#define DRV_VERSION "0.2.1"
++
++static void triflex_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ static struct pci_bits triflex_enable_bits[] = {
++ { 0x80, 1, 0x01, 0x01 },
++ { 0x80, 1, 0x02, 0x02 }
++ };
++
++ if (!pci_test_config_bits(pdev, &triflex_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = ATA_CBL_PATA40;
++ ata_port_probe(ap);
++ ata_bus_reset(ap);
++}
++
++/**
++ * triflex_load_timing - timing configuration
++ * @ap: ATA interface
++ * @adev: Device on the bus
++ * @speed: speed to configure
++ *
++ * The Triflex has one set of timings per device per channel. This
++ * means we must do some switching. As the PIO and DMA timings don't
++ * match we have to do some reloading unlike PIIX devices where tuning
++ * tricks can avoid it.
++ */
++
++static void triflex_load_timing(struct ata_port *ap, struct ata_device *adev, int speed)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 timing = 0;
++ u32 triflex_timing, old_triflex_timing;
++ int channel_offset = ap->hard_port_no ? 0x74: 0x70;
++ unsigned int is_slave = (adev->devno != 0);
++
++
++ pci_read_config_dword(pdev, channel_offset, &old_triflex_timing);
++ triflex_timing = old_triflex_timing;
++
++ switch(speed)
++ {
++ case XFER_MW_DMA_2:
++ timing = 0x0103;break;
++ case XFER_MW_DMA_1:
++ timing = 0x0203;break;
++ case XFER_MW_DMA_0:
++ timing = 0x0808;break;
++ case XFER_SW_DMA_2:
++ case XFER_SW_DMA_1:
++ case XFER_SW_DMA_0:
++ timing = 0x0F0F;break;
++ case XFER_PIO_4:
++ timing = 0x0202;break;
++ case XFER_PIO_3:
++ timing = 0x0204;break;
++ case XFER_PIO_2:
++ timing = 0x0404;break;
++ case XFER_PIO_1:
++ timing = 0x0508;break;
++ case XFER_PIO_0:
++ timing = 0x0808;break;
++ default:
++ BUG();
++ }
++ triflex_timing &= ~ (0xFFFF << (16 * is_slave));
++ triflex_timing |= (timing << (16 * is_slave));
++
++ if (triflex_timing != old_triflex_timing)
++ pci_write_config_dword(pdev, channel_offset, triflex_timing);
++}
++
++/**
++ * triflex_set_piomode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * Use the timing loader to set up the PIO mode. We have to do this
++ * because DMA start/stop will only be called once DMA occurs. If there
++ * has been no DMA then the PIO timings are still needed.
++ */
++static void triflex_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ triflex_load_timing(ap, adev, adev->pio_mode);
++}
++
++/**
++ * triflex_dma_start - DMA start callback
++ * @qc: Command in progress
++ *
++ * Usually drivers set the DMA timing at the point the set_dmamode call
++ * is made. Triflex however requires we load new timings on the
++ * transition or keep matching PIO/DMA pairs (ie MWDMA2/PIO4 etc).
++ * We load the DMA timings just before starting DMA and then restore
++ * the PIO timing when the DMA is finished.
++ */
++
++static void triflex_bmdma_start(struct ata_queued_cmd *qc)
++{
++ triflex_load_timing(qc->ap, qc->dev, qc->dev->dma_mode);
++ ata_bmdma_start(qc);
++}
++
++/**
++ * triflex_dma_stop - DMA stop callback
++ * @ap: ATA interface
++ * @adev: ATA device
++ *
++ * We loaded new timings in dma_start, as a result we need to restore
++ * the PIO timings in dma_stop so that the next command issue gets the
++ * right clock values.
++ */
++
++static void triflex_bmdma_stop(struct ata_queued_cmd *qc)
++{
++ ata_bmdma_stop(qc);
++ triflex_load_timing(qc->ap, qc->dev, qc->dev->pio_mode);
++}
++
++static struct scsi_host_template triflex_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations triflex_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = triflex_set_piomode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = triflex_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = triflex_bmdma_start,
++ .bmdma_stop = triflex_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id)
++{
++ static struct ata_port_info info = {
++ .sht = &triflex_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &triflex_port_ops
++ };
++ static struct ata_port_info *port_info[2] = { &info, &info };
++ static int printed_version;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n");
++
++ return ata_pci_init_one(dev, port_info, 2);
++}
++
++static const struct pci_device_id triflex[] = {
++ { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE,
++ PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
++ { 0, },
++};
++
++static struct pci_driver triflex_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = triflex,
++ .probe = triflex_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init triflex_init(void)
++{
++ return pci_register_driver(&triflex_pci_driver);
++}
++
++
++static void __exit triflex_exit(void)
++{
++ pci_unregister_driver(&triflex_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for Compaq Triflex");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, triflex);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(triflex_init);
++module_exit(triflex_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/pata_via.c linux-2.6.16-rc4/drivers/scsi/pata_via.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/pata_via.c 1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.16-rc4/drivers/scsi/pata_via.c 2006-02-16 15:28:17.000000000 +0000
+@@ -0,0 +1,547 @@
++/*
++ * pata_via.c - VIA PATA for new ATA layer
++ * (C) 2005 Red Hat Inc
++ * Alan Cox <alan@redhat.com>
++ *
++ * Documentation
++ * Most chipset documentation available under NDA only
++ *
++ * VIA version guide
++ * VIA VT82C561 - early design, uses ata_generic currently
++ * VIA VT82C576 - MWDMA, 33Mhz
++ * VIA VT82C586 - MWDMA, 33Mhz
++ * VIA VT82C586a - Added UDMA to 33Mhz
++ * VIA VT82C586b - UDMA33
++ * VIA VT82C596a - Nonfunctional UDMA66
++ * VIA VT82C596b - Working UDMA66
++ * VIA VT82C686 - Nonfunctional UDMA66
++ * VIA VT82C686a - Working UDMA66
++ * VIA VT82C686b - Updated to UDMA100
++ * VIA VT8231 - UDMA100
++ * VIA VT8233 - UDMA100
++ * VIA VT8233a - UDMA133
++ * VIA VT8233c - UDMA100
++ * VIA VT8235 - UDMA133
++ * VIA VT8237 - UDMA133
++ *
++ * Most registers remain compatible across chips. Others start reserved
++ * and acquire sensible semantics if set to 1 (eg cable detect). A few
++ * exceptions exist, notably around the FIFO settings.
++ *
++ * One additional quirk of the VIA design is that like ALi they use few
++ * PCI IDs for a lot of chips.
++ *
++ * Based heavily on:
++ *
++ * Version 3.38
++ *
++ * VIA IDE driver for Linux. Supported southbridges:
++ *
++ * vt82c576, vt82c586, vt82c586a, vt82c586b, vt82c596a, vt82c596b,
++ * vt82c686, vt82c686a, vt82c686b, vt8231, vt8233, vt8233c, vt8233a,
++ * vt8235, vt8237
++ *
++ * Copyright (c) 2000-2002 Vojtech Pavlik
++ *
++ * Based on the work of:
++ * Michel Aubry
++ * Jeff Garzik
++ * Andre Hedrick
++
++ */
++
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++#include <linux/blkdev.h>
++#include <linux/delay.h>
++#include <scsi/scsi_host.h>
++#include <linux/libata.h>
++
++#define DRV_NAME "pata_via"
++#define DRV_VERSION "0.1.4"
++
++/*
++ * The following comes directly from Vojtech Pavlik's ide/pci/via82cxxx
++ * driver.
++ */
++
++enum {
++ VIA_UDMA = 0x007,
++ VIA_UDMA_NONE = 0x000,
++ VIA_UDMA_33 = 0x001,
++ VIA_UDMA_66 = 0x002,
++ VIA_UDMA_100 = 0x003,
++ VIA_UDMA_133 = 0x004,
++ VIA_BAD_PREQ = 0x010, /* Crashes if PREQ# till DDACK# set */
++ VIA_BAD_CLK66 = 0x020, /* 66 MHz clock doesn't work correctly */
++ VIA_SET_FIFO = 0x040, /* Needs to have FIFO split set */
++ VIA_NO_UNMASK = 0x080, /* Doesn't work with IRQ unmasking on */
++ VIA_BAD_ID = 0x100, /* Has wrong vendor ID (0x1107) */
++ VIA_BAD_AST = 0x200, /* Don't touch Address Setup Timing */
++};
++
++/*
++ * VIA SouthBridge chips.
++ */
++
++static const struct via_isa_bridge {
++ const char *name;
++ u16 id;
++ u8 rev_min;
++ u8 rev_max;
++ u16 flags;
++} via_isa_bridges[] = {
++ { "vt8237", PCI_DEVICE_ID_VIA_8237, 0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
++ { "vt8235", PCI_DEVICE_ID_VIA_8235, 0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
++ { "vt8233a", PCI_DEVICE_ID_VIA_8233A, 0x00, 0x2f, VIA_UDMA_133 | VIA_BAD_AST },
++ { "vt8233c", PCI_DEVICE_ID_VIA_8233C_0, 0x00, 0x2f, VIA_UDMA_100 },
++ { "vt8233", PCI_DEVICE_ID_VIA_8233_0, 0x00, 0x2f, VIA_UDMA_100 },
++ { "vt8231", PCI_DEVICE_ID_VIA_8231, 0x00, 0x2f, VIA_UDMA_100 },
++ { "vt82c686b", PCI_DEVICE_ID_VIA_82C686, 0x40, 0x4f, VIA_UDMA_100 },
++ { "vt82c686a", PCI_DEVICE_ID_VIA_82C686, 0x10, 0x2f, VIA_UDMA_66 },
++ { "vt82c686", PCI_DEVICE_ID_VIA_82C686, 0x00, 0x0f, VIA_UDMA_33 | VIA_BAD_CLK66 },
++ { "vt82c596b", PCI_DEVICE_ID_VIA_82C596, 0x10, 0x2f, VIA_UDMA_66 },
++ { "vt82c596a", PCI_DEVICE_ID_VIA_82C596, 0x00, 0x0f, VIA_UDMA_33 | VIA_BAD_CLK66 },
++ { "vt82c586b", PCI_DEVICE_ID_VIA_82C586_0, 0x47, 0x4f, VIA_UDMA_33 | VIA_SET_FIFO },
++ { "vt82c586b", PCI_DEVICE_ID_VIA_82C586_0, 0x40, 0x46, VIA_UDMA_33 | VIA_SET_FIFO | VIA_BAD_PREQ },
++ { "vt82c586b", PCI_DEVICE_ID_VIA_82C586_0, 0x30, 0x3f, VIA_UDMA_33 | VIA_SET_FIFO },
++ { "vt82c586a", PCI_DEVICE_ID_VIA_82C586_0, 0x20, 0x2f, VIA_UDMA_33 | VIA_SET_FIFO },
++ { "vt82c586", PCI_DEVICE_ID_VIA_82C586_0, 0x00, 0x0f, VIA_UDMA_NONE | VIA_SET_FIFO },
++ { "vt82c576", PCI_DEVICE_ID_VIA_82C576, 0x00, 0x2f, VIA_UDMA_NONE | VIA_SET_FIFO | VIA_NO_UNMASK },
++ { "vt82c576", PCI_DEVICE_ID_VIA_82C576, 0x00, 0x2f, VIA_UDMA_NONE | VIA_SET_FIFO | VIA_NO_UNMASK | VIA_BAD_ID },
++ { NULL }
++};
++
++/**
++ * via_cable_detect - cable detection
++ * @ap: ATA port
++ *
++ * Perform cable detection. Actually for the VIA case the BIOS
++ * already did this for us. We read the values provided by the
++ * BIOS. If you are using an 8235 in a non-PC configuration you
++ * may need to update this code.
++ *
++ * Hotplug also impacts on this.
++ */
++
++static int via_cable_detect(struct ata_port *ap) {
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ u32 ata66;
++ pci_read_config_dword(pdev, 0x50, &ata66);
++ /* Check both the drive cable reporting bits, we might not have
++ two drives */
++ if (ata66 & (0x1010 << (16 * ap->hard_port_no)))
++ return ATA_CBL_PATA80;
++ else
++ return ATA_CBL_PATA40;
++}
++
++/**
++ * via_phy_reset - reset for eary chip
++ * @ap: ATA port
++ *
++ * Handle the reset callback for the later chips with cable detect
++ */
++
++static void via_phy_reset(struct ata_port *ap)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++
++ /* Note: When we add VIA 6410 remember it doesn't have enable bits */
++ static struct pci_bits via_enable_bits[] = {
++ { 0x40, 1, 0x02, 0x02 },
++ { 0x40, 1, 0x01, 0x01 }
++ };
++
++ if (!pci_test_config_bits(pdev, &via_enable_bits[ap->hard_port_no])) {
++ ata_port_disable(ap);
++ printk(KERN_INFO "ata%u: port disabled. ignoring.\n", ap->id);
++ return;
++ }
++ ap->cbl = via_cable_detect(ap);
++ ata_bus_reset(ap);
++ ata_port_probe(ap);
++}
++
++/**
++ * via_do_set_mode - set initial PIO mode data
++ * @ap: ATA interface
++ * @adev: ATA device
++ * @mode: ATA mode being programmed
++ * @tdiv: Clocks per PCI clock
++ * @set_ast: Set to program address setup
++ * @udma_type: UDMA mode/format of registers
++ *
++ * Program the VIA registers for DMA and PIO modes. Uses the ata timing
++ * support in order to compute modes.
++ *
++ * FIXME: Hotplug will require we serialize multiple mode changes
++ * on the two channels.
++ */
++
++static void via_do_set_mode(struct ata_port *ap, struct ata_device *adev, int mode, int tdiv, int set_ast, int udma_type)
++{
++ struct pci_dev *pdev = to_pci_dev(ap->host_set->dev);
++ struct ata_device *peer = ata_dev_pair(ap, adev);
++ struct ata_timing t, p;
++ static int via_clock = 33000; /* Bus clock in kHZ - ought to be tunable one day */
++ unsigned long T = 1000000000 / via_clock;
++ unsigned long UT = T/tdiv;
++ int ut;
++ int offset = 3 - (2*ap->hard_port_no) - adev->devno;
++
++ printk("via_do_set_mode: Mode=%d ast broken=%c udma=%d mul=%d\n",
++ mode, "YN"[set_ast], udma_type, tdiv);
++ /* Calculate the timing values we require */
++ ata_timing_compute(adev, adev->pio_mode, &t, T, UT);
++
++ /* We share 8bit timing so we must merge the constraints */
++ if (peer) {
++ if (peer->pio_mode) {
++ ata_timing_compute(peer, peer->pio_mode, &p, T, UT);
++ ata_timing_merge(&p, &t, &t, ATA_TIMING_8BIT);
++ }
++ if (peer->dma_mode) {
++ ata_timing_compute(peer, peer->dma_mode, &p, T, UT);
++ ata_timing_merge(&p, &t, &t, ATA_TIMING_8BIT);
++ }
++ }
++
++ /* Address setup is programmable but breaks on UDMA133 setups */
++ if (set_ast) {
++ u8 setup; /* 2 bits per drive */
++ int shift = 2 * offset;
++
++ pci_read_config_byte(pdev, 0x4C, &setup);
++ setup &= ~(3 << shift);
++ setup |= FIT(t.setup, 1, 4) << shift;
++ pci_write_config_byte(pdev, 0x4C, setup);
++ }
++
++ /* Load the PIO mode bits */
++ pci_write_config_byte(pdev, 0x4F - ap->hard_port_no,
++ ((FIT(t.act8b, 1, 16) - 1) << 4) | (FIT(t.rec8b, 1, 16) - 1));
++ pci_write_config_byte(pdev, 0x48 + offset,
++ ((FIT(t.active, 1, 16) - 1) << 4) | (FIT(t.recover, 1, 16) - 1));
++
++ /* Load the UDMA bits according to type */
++ switch(udma_type) {
++ default:
++ /* BUG() ? */
++ /* fall through */
++ case 33:
++ ut = t.udma ? (0xe0 | (FIT(t.udma, 2, 5) - 2)) : 0x03;
++ break;
++ case 66:
++ ut = t.udma ? (0xe8 | (FIT(t.udma, 2, 9) - 2)) : 0x0f;
++ break;
++ case 100:
++ ut = t.udma ? (0xe0 | (FIT(t.udma, 2, 9) - 2)) : 0x07;
++ break;
++ case 133:
++ ut = t.udma ? (0xe0 | (FIT(t.udma, 2, 9) - 2)) : 0x07;
++ break;
++ }
++ /* Set UDMA unless device is not UDMA capable */
++ if (udma_type)
++ pci_write_config_byte(pdev, 0x50 + offset, ut);
++}
++
++static void via_set_piomode(struct ata_port *ap, struct ata_device *adev)
++{
++ const struct via_isa_bridge *config = ap->host_set->private_data;
++ int set_ast = (config->flags & VIA_BAD_AST) ? 0 : 1;
++ int mode = config->flags & VIA_UDMA;
++ static u8 tclock[5] = { 1, 1, 2, 3, 4 };
++ static u8 udma[5] = { 0, 33, 66, 100, 133 };
++
++ via_do_set_mode(ap, adev, adev->pio_mode, tclock[mode], set_ast, udma[mode]);
++}
++
++static void via_set_dmamode(struct ata_port *ap, struct ata_device *adev)
++{
++ const struct via_isa_bridge *config = ap->host_set->private_data;
++ int set_ast = (config->flags & VIA_BAD_AST) ? 0 : 1;
++ int mode = config->flags & VIA_UDMA;
++ static u8 tclock[5] = { 1, 1, 2, 3, 4 };
++ static u8 udma[5] = { 0, 33, 66, 100, 133 };
++
++ via_do_set_mode(ap, adev, adev->dma_mode, tclock[mode], set_ast, udma[mode]);
++}
++
++static struct scsi_host_template via_sht = {
++ .module = THIS_MODULE,
++ .name = DRV_NAME,
++ .ioctl = ata_scsi_ioctl,
++ .queuecommand = ata_scsi_queuecmd,
++ .eh_strategy_handler = ata_scsi_error,
++ .can_queue = ATA_DEF_QUEUE,
++ .this_id = ATA_SHT_THIS_ID,
++ .sg_tablesize = LIBATA_MAX_PRD,
++ .max_sectors = ATA_MAX_SECTORS,
++ .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
++ .emulated = ATA_SHT_EMULATED,
++ .use_clustering = ATA_SHT_USE_CLUSTERING,
++ .proc_name = DRV_NAME,
++ .dma_boundary = ATA_DMA_BOUNDARY,
++ .slave_configure = ata_scsi_slave_config,
++ .bios_param = ata_std_bios_param,
++// .ordered_flush = 1,
++};
++
++static struct ata_port_operations via_port_ops = {
++ .port_disable = ata_port_disable,
++ .set_piomode = via_set_piomode,
++ .set_dmamode = via_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = via_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++static struct ata_port_operations via_port_ops_noirq = {
++ .port_disable = ata_port_disable,
++ .set_piomode = via_set_piomode,
++ .set_dmamode = via_set_dmamode,
++ .tf_load = ata_tf_load,
++ .tf_read = ata_tf_read,
++ .check_status = ata_check_status,
++ .exec_command = ata_exec_command,
++ .dev_select = ata_std_dev_select,
++
++ .phy_reset = via_phy_reset,
++
++ .bmdma_setup = ata_bmdma_setup,
++ .bmdma_start = ata_bmdma_start,
++ .bmdma_stop = ata_bmdma_stop,
++ .bmdma_status = ata_bmdma_status,
++
++ .qc_prep = ata_qc_prep,
++ .qc_issue = ata_qc_issue_prot,
++ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer_noirq,
++
++ .irq_handler = ata_interrupt,
++ .irq_clear = ata_bmdma_irq_clear,
++
++ .port_start = ata_port_start,
++ .port_stop = ata_port_stop,
++ .host_stop = ata_host_stop
++};
++
++/**
++ * via_init_one - discovery callback
++ * @pdev: PCI device ID
++ * @id: PCI table info
++ *
++ * A VIA IDE interface has been discovered. Figure out what revision
++ * and perform configuration work before handing it to the ATA layer
++ */
++
++static int via_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
++{
++ /* Early VIA without UDMA support */
++ static struct ata_port_info via_mwdma_info = {
++ .sht = &via_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &via_port_ops
++ };
++ /* Ditto with IRQ masking required */
++ static struct ata_port_info via_mwdma_info_borked = {
++ .sht = &via_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST | ATA_FLAG_IRQ_MASK,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .port_ops = &via_port_ops_noirq,
++ };
++ /* VIA UDMA 33 devices (and borked 66) */
++ static struct ata_port_info via_udma33_info = {
++ .sht = &via_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x7,
++ .port_ops = &via_port_ops
++ };
++ /* VIA UDMA 66 devices */
++ static struct ata_port_info via_udma66_info = {
++ .sht = &via_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x1f,
++ .port_ops = &via_port_ops
++ };
++ /* VIA UDMA 100 devices */
++ static struct ata_port_info via_udma100_info = {
++ .sht = &via_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f,
++ .port_ops = &via_port_ops
++ };
++ /* UDMA133 with bad AST (All current 133) */
++ static struct ata_port_info via_udma133_info = {
++ .sht = &via_sht,
++ .host_flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_SRST,
++ .pio_mask = 0x1f,
++ .mwdma_mask = 0x07,
++ .udma_mask = 0x3f, /* 0x7F but need to fix north bridge */
++ .port_ops = &via_port_ops
++ };
++ struct ata_port_info *port_info[2], *type;
++ struct pci_dev *isa = NULL;
++ const struct via_isa_bridge *config;
++ static int printed_version;
++ u8 t;
++ u8 enable;
++ u32 timing;
++
++ if (!printed_version++)
++ dev_printk(KERN_DEBUG, &pdev->dev, "version " DRV_VERSION "\n");
++
++ /* To find out how the IDE will behave and what features we
++ actually have to look at the bridge not the IDE controller */
++ for (config = via_isa_bridges; config->id; config++)
++ if ((isa = pci_get_device(PCI_VENDOR_ID_VIA +
++ !!(config->flags & VIA_BAD_ID),
++ config->id, NULL))) {
++
++ pci_read_config_byte(isa, PCI_REVISION_ID, &t);
++ if (t >= config->rev_min &&
++ t <= config->rev_max)
++ break;
++ pci_dev_put(isa);
++ }
++
++ if (!config->id) {
++ printk(KERN_WARNING "via: Unknown VIA SouthBridge, disabling.\n");
++ return -ENODEV;
++ }
++
++ /* 0x40 low bits indicate enabled channels */
++ pci_read_config_byte(pdev, 0x40 , &enable);
++ enable &= 3;
++ if (enable == 0) {
++ pci_dev_put(isa);
++ return -ENODEV;
++ }
++
++ /* Initialise the FIFO for the enabled channels. */
++ if (config->flags & VIA_SET_FIFO) {
++ u8 fifo_setting[4] = {0x00, 0x60, 0x00, 0x20};
++ u8 fifo;
++
++ pci_read_config_byte(pdev, 0x43, &fifo);
++
++ /* Clear PREQ# until DDACK# for errata */
++ if (config->flags & VIA_BAD_PREQ)
++ fifo &= 0x7F;
++ else
++ fifo &= 0x9f;
++ /* Turn on FIFO for enabled channels */
++ fifo |= fifo_setting[enable];
++ pci_write_config_byte(pdev, 0x43, fifo);
++ }
++ /* Clock set up */
++ switch(config->flags & VIA_UDMA) {
++ case VIA_UDMA_NONE:
++ if (config->flags & VIA_NO_UNMASK)
++ type = &via_mwdma_info_borked;
++ else
++ type = &via_mwdma_info;
++ break;
++ case VIA_UDMA_33:
++ type = &via_udma33_info;
++ break;
++ case VIA_UDMA_66:
++ type = &via_udma66_info;
++ /* The 66 MHz devices require we enable the clock */
++ pci_read_config_dword(pdev, 0x50, &timing);
++ timing |= 0x80008;
++ pci_write_config_dword(pdev, 0x50, timing);
++ break;
++ case VIA_UDMA_100:
++ type = &via_udma100_info;
++ break;
++ case VIA_UDMA_133:
++ type = &via_udma133_info;
++ break;
++ default:
++ type = NULL;
++ BUG();
++ break;
++ }
++
++ if (config->flags & VIA_BAD_CLK66) {
++ /* Disable the 66MHz clock on problem devices */
++ pci_read_config_dword(pdev, 0x50, &timing);
++ timing &= ~0x80008;
++ pci_write_config_dword(pdev, 0x50, timing);
++ }
++
++ /* We have established the device type, now fire it up */
++ type->private_data = (void *)config;
++
++ port_info[0] = port_info[1] = type;
++ return ata_pci_init_one(pdev, port_info, 2);
++}
++
++static const struct pci_device_id via[] = {
++ { PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C576_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
++ { 0, },
++};
++
++static struct pci_driver via_pci_driver = {
++ .name = DRV_NAME,
++ .id_table = via,
++ .probe = via_init_one,
++ .remove = ata_pci_remove_one
++};
++
++static int __init via_init(void)
++{
++ return pci_register_driver(&via_pci_driver);
++}
++
++
++static void __exit via_exit(void)
++{
++ pci_unregister_driver(&via_pci_driver);
++}
++
++
++MODULE_AUTHOR("Alan Cox");
++MODULE_DESCRIPTION("low-level driver for VIA PATA");
++MODULE_LICENSE("GPL");
++MODULE_DEVICE_TABLE(pci, via);
++MODULE_VERSION(DRV_VERSION);
++
++module_init(via_init);
++module_exit(via_exit);
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_mv.c linux-2.6.16-rc4/drivers/scsi/sata_mv.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_mv.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_mv.c 2006-02-20 11:28:03.000000000 +0000
+@@ -389,6 +389,7 @@
+
+ .qc_prep = mv_qc_prep,
+ .qc_issue = mv_qc_issue,
++ .data_xfer = ata_mmio_data_xfer,
+
+ .eng_timeout = mv_eng_timeout,
+
+@@ -416,6 +417,7 @@
+
+ .qc_prep = mv_qc_prep,
+ .qc_issue = mv_qc_issue,
++ .data_xfer = ata_mmio_data_xfer,
+
+ .eng_timeout = mv_eng_timeout,
+
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_nv.c linux-2.6.16-rc4/drivers/scsi/sata_nv.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_nv.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_nv.c 2006-01-21 17:08:58.000000000 +0000
+@@ -258,6 +258,7 @@
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
+ .eng_timeout = ata_eng_timeout,
++ .data_xfer = ata_pio_data_xfer,
+ .irq_handler = nv_interrupt,
+ .irq_clear = ata_bmdma_irq_clear,
+ .scr_read = nv_scr_read,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_promise.c linux-2.6.16-rc4/drivers/scsi/sata_promise.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_promise.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_promise.c 2006-02-06 12:36:12.000000000 +0000
+@@ -130,6 +130,7 @@
+ .qc_prep = pdc_qc_prep,
+ .qc_issue = pdc_qc_issue_prot,
+ .eng_timeout = pdc_eng_timeout,
++ .data_xfer = ata_mmio_data_xfer,
+ .irq_handler = pdc_interrupt,
+ .irq_clear = pdc_irq_clear,
+
+@@ -152,6 +153,7 @@
+
+ .qc_prep = pdc_qc_prep,
+ .qc_issue = pdc_qc_issue_prot,
++ .data_xfer = ata_mmio_data_xfer,
+ .eng_timeout = pdc_eng_timeout,
+ .irq_handler = pdc_interrupt,
+ .irq_clear = pdc_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_qstor.c linux-2.6.16-rc4/drivers/scsi/sata_qstor.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_qstor.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_qstor.c 2006-01-21 17:09:57.000000000 +0000
+@@ -158,6 +158,7 @@
+ .phy_reset = qs_phy_reset,
+ .qc_prep = qs_qc_prep,
+ .qc_issue = qs_qc_issue,
++ .data_xfer = ata_mmio_data_xfer,
+ .eng_timeout = qs_eng_timeout,
+ .irq_handler = qs_intr,
+ .irq_clear = qs_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sil24.c linux-2.6.16-rc4/drivers/scsi/sata_sil24.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sil24.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_sil24.c 2006-01-21 17:10:52.000000000 +0000
+@@ -309,6 +309,7 @@
+
+ .qc_prep = sil24_qc_prep,
+ .qc_issue = sil24_qc_issue,
++ .data_xfer = ata_mmio_data_xfer,
+
+ .eng_timeout = sil24_eng_timeout,
+
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sil.c linux-2.6.16-rc4/drivers/scsi/sata_sil.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sil.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_sil.c 2006-02-14 17:23:28.000000000 +0000
+@@ -165,6 +165,7 @@
+ .bmdma_status = ata_bmdma_status,
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_mmio_data_xfer,
+ .eng_timeout = ata_eng_timeout,
+ .irq_handler = ata_interrupt,
+ .irq_clear = ata_bmdma_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sis.c linux-2.6.16-rc4/drivers/scsi/sata_sis.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sis.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_sis.c 2006-01-21 17:11:23.000000000 +0000
+@@ -115,6 +115,7 @@
+ .bmdma_status = ata_bmdma_status,
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
+ .eng_timeout = ata_eng_timeout,
+ .irq_handler = ata_interrupt,
+ .irq_clear = ata_bmdma_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_svw.c linux-2.6.16-rc4/drivers/scsi/sata_svw.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_svw.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_svw.c 2006-02-06 12:30:23.000000000 +0000
+@@ -320,6 +320,7 @@
+ .bmdma_status = ata_bmdma_status,
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_mmio_data_xfer,
+ .eng_timeout = ata_eng_timeout,
+ .irq_handler = ata_interrupt,
+ .irq_clear = ata_bmdma_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sx4.c linux-2.6.16-rc4/drivers/scsi/sata_sx4.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_sx4.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_sx4.c 2006-01-21 17:12:01.000000000 +0000
+@@ -206,6 +206,7 @@
+ .phy_reset = pdc_20621_phy_reset,
+ .qc_prep = pdc20621_qc_prep,
+ .qc_issue = pdc20621_qc_issue_prot,
++ .data_xfer = ata_mmio_data_xfer,
+ .eng_timeout = pdc_eng_timeout,
+ .irq_handler = pdc20621_interrupt,
+ .irq_clear = pdc20621_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_uli.c linux-2.6.16-rc4/drivers/scsi/sata_uli.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_uli.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_uli.c 2006-01-21 17:12:24.000000000 +0000
+@@ -106,6 +106,7 @@
+ .bmdma_status = ata_bmdma_status,
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
+
+ .eng_timeout = ata_eng_timeout,
+
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_via.c linux-2.6.16-rc4/drivers/scsi/sata_via.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_via.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_via.c 2006-01-21 17:12:51.000000000 +0000
+@@ -126,6 +126,7 @@
+
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
+
+ .eng_timeout = ata_eng_timeout,
+
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/drivers/scsi/sata_vsc.c linux-2.6.16-rc4/drivers/scsi/sata_vsc.c
+--- linux.vanilla-2.6.16-rc4/drivers/scsi/sata_vsc.c 2006-02-20 11:22:25.000000000 +0000
++++ linux-2.6.16-rc4/drivers/scsi/sata_vsc.c 2006-02-20 11:28:11.000000000 +0000
+@@ -280,6 +280,7 @@
+ .bmdma_status = ata_bmdma_status,
+ .qc_prep = ata_qc_prep,
+ .qc_issue = ata_qc_issue_prot,
++ .data_xfer = ata_pio_data_xfer,
+ .eng_timeout = ata_eng_timeout,
+ .irq_handler = vsc_sata_interrupt,
+ .irq_clear = ata_bmdma_irq_clear,
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/include/linux/ata.h linux-2.6.16-rc4/include/linux/ata.h
+--- linux.vanilla-2.6.16-rc4/include/linux/ata.h 2006-02-20 11:22:26.000000000 +0000
++++ linux-2.6.16-rc4/include/linux/ata.h 2006-02-15 14:39:41.000000000 +0000
+@@ -134,6 +134,8 @@
+ ATA_CMD_PIO_READ_EXT = 0x24,
+ ATA_CMD_PIO_WRITE = 0x30,
+ ATA_CMD_PIO_WRITE_EXT = 0x34,
++ ATA_CMD_READ_NATIVE_MAX = 0xF8,
++ ATA_CMD_READ_NATIVE_MAX_EXT = 0x27,
+ ATA_CMD_READ_MULTI = 0xC4,
+ ATA_CMD_READ_MULTI_EXT = 0x29,
+ ATA_CMD_WRITE_MULTI = 0xC5,
+@@ -247,18 +249,22 @@
+ };
+
+ #define ata_id_is_ata(id) (((id)[0] & (1 << 15)) == 0)
++#define ata_id_is_cfa(id) ((id)[0] == 0x848A)
+ #define ata_id_is_sata(id) ((id)[93] == 0)
+ #define ata_id_rahead_enabled(id) ((id)[85] & (1 << 6))
+ #define ata_id_wcache_enabled(id) ((id)[85] & (1 << 5))
++#define ata_id_hpa_enabled(id) ((id)[85] & (1 << 10))
+ #define ata_id_has_fua(id) ((id)[84] & (1 << 6))
+ #define ata_id_has_flush(id) ((id)[83] & (1 << 12))
+ #define ata_id_has_flush_ext(id) ((id)[83] & (1 << 13))
+ #define ata_id_has_lba48(id) ((id)[83] & (1 << 10))
++#define ata_id_has_hpa(id) ((id)[82] & (1 << 10))
+ #define ata_id_has_wcache(id) ((id)[82] & (1 << 5))
+ #define ata_id_has_pm(id) ((id)[82] & (1 << 3))
+ #define ata_id_has_lba(id) ((id)[49] & (1 << 9))
+ #define ata_id_has_dma(id) ((id)[49] & (1 << 8))
+ #define ata_id_removeable(id) ((id)[0] & (1 << 7))
++#define ata_id_has_dword_io(id) ((id)[50] & (1 << 0))
+ #define ata_id_u32(id,n) \
+ (((u32) (id)[(n) + 1] << 16) | ((u32) (id)[(n)]))
+ #define ata_id_u64(id,n) \
+diff -u --new-file --recursive --exclude-from /usr/src/exclude linux.vanilla-2.6.16-rc4/include/linux/libata.h linux-2.6.16-rc4/include/linux/libata.h
+--- linux.vanilla-2.6.16-rc4/include/linux/libata.h 2006-02-20 11:22:26.000000000 +0000
++++ linux-2.6.16-rc4/include/linux/libata.h 2006-02-16 15:41:24.000000000 +0000
+@@ -41,7 +41,7 @@
+ #undef ATA_VERBOSE_DEBUG /* yet more debugging output */
+ #undef ATA_IRQ_TRAP /* define to ack screaming irqs */
+ #undef ATA_NDEBUG /* define to disable quick runtime checks */
+-#undef ATA_ENABLE_PATA /* define to enable PATA support in some
++#define ATA_ENABLE_PATA /* define to enable PATA support in some
+ * low-level drivers */
+ #undef ATAPI_ENABLE_DMADIR /* enables ATAPI DMADIR bridge support */
+
+@@ -101,6 +101,7 @@
+ ATA_DFLAG_PIO = (1 << 1), /* device currently in PIO mode */
+ ATA_DFLAG_LOCK_SECTORS = (1 << 2), /* don't adjust max_sectors */
+ ATA_DFLAG_LBA = (1 << 3), /* device supports LBA */
++ ATA_DFLAG_HPA = (1 << 4), /* device has an HPA */
+
+ ATA_DEV_UNKNOWN = 0, /* unknown device */
+ ATA_DEV_ATA = 1, /* ATA device */
+@@ -133,6 +134,8 @@
+ ATA_QCFLAG_SG = (1 << 3), /* have s/g table? */
+ ATA_QCFLAG_SINGLE = (1 << 4), /* no s/g, just a single buffer */
+ ATA_QCFLAG_DMAMAP = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
++
++ ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host_set only */
+
+ /* various lengths of time */
+ ATA_TMOUT_EDD = 5 * HZ, /* heuristic */
+@@ -197,6 +200,7 @@
+
+ /* forward declarations */
+ struct scsi_device;
++struct ata_host_set;
+ struct ata_port_operations;
+ struct ata_port;
+ struct ata_queued_cmd;
+@@ -237,8 +241,10 @@
+ unsigned long irq;
+ unsigned int irq_flags;
+ unsigned long host_flags;
++ unsigned long host_set_flags;
+ void __iomem *mmio_base;
+ void *private_data;
++ struct ata_host_set *host_set; /* Return not input value */
+ };
+
+ struct ata_host_set {
+@@ -250,6 +256,9 @@
+ void *private_data;
+ const struct ata_port_operations *ops;
+ struct ata_port * ports[0];
++ unsigned long host_set_flags;
++ int simplex_claimed; /* Keep seperate in case we
++ ever need to do this locked */
+ };
+
+ struct ata_queued_cmd {
+@@ -369,6 +378,7 @@
+
+ void (*set_piomode) (struct ata_port *, struct ata_device *);
+ void (*set_dmamode) (struct ata_port *, struct ata_device *);
++ unsigned int (*mode_filter) (const struct ata_port *, struct ata_device *, unsigned int, int);
+
+ void (*tf_load) (struct ata_port *ap, const struct ata_taskfile *tf);
+ void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
+@@ -379,12 +389,15 @@
+ void (*dev_select)(struct ata_port *ap, unsigned int device);
+
+ void (*phy_reset) (struct ata_port *ap);
++ void (*set_mode) (struct ata_port *ap);
+ void (*post_set_mode) (struct ata_port *ap);
+
+ int (*check_atapi_dma) (struct ata_queued_cmd *qc);
+
+ void (*bmdma_setup) (struct ata_queued_cmd *qc);
+ void (*bmdma_start) (struct ata_queued_cmd *qc);
++
++ void (*data_xfer) (struct ata_port *, struct ata_device *, unsigned char *, unsigned int, int);
+
+ void (*qc_prep) (struct ata_queued_cmd *qc);
+ int (*qc_issue) (struct ata_queued_cmd *qc);
+@@ -443,8 +456,9 @@
+ extern void ata_pci_remove_one (struct pci_dev *pdev);
+ extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state);
+ extern int ata_pci_device_resume(struct pci_dev *pdev);
++extern int ata_pci_clear_simplex(struct pci_dev *pdev);
+ #endif /* CONFIG_PCI */
+-extern int ata_device_add(const struct ata_probe_ent *ent);
++extern int ata_device_add(struct ata_probe_ent *ent);
+ extern void ata_host_set_remove(struct ata_host_set *host_set);
+ extern int ata_scsi_detect(struct scsi_host_template *sht);
+ extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
+@@ -491,6 +505,15 @@
+ extern void ata_bmdma_irq_clear(struct ata_port *ap);
+ extern void ata_qc_complete(struct ata_queued_cmd *qc);
+ extern void ata_eng_timeout(struct ata_port *ap);
++extern void ata_mmio_data_xfer(struct ata_port *ap, struct ata_device *adev, unsigned char *buf,
++ unsigned int buflen, int write_data);
++extern void ata_pio_data_xfer(struct ata_port *ap, struct ata_device *adev, unsigned char *buf,
++ unsigned int buflen, int write_data);
++extern void ata_mmio_data_xfer_noirq(struct ata_port *ap, struct ata_device *adev, unsigned char *buf,
++ unsigned int buflen, int do_write);
++extern void ata_pio_data_xfer_noirq(struct ata_port *ap, struct ata_device *adev, unsigned char *buf,
++ unsigned int buflen, int do_write);
++
+ extern void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
+ struct scsi_cmnd *cmd,
+ void (*done)(struct scsi_cmnd *));
+@@ -498,6 +521,8 @@
+ struct block_device *bdev,
+ sector_t capacity, int geom[]);
+ extern int ata_scsi_slave_config(struct scsi_device *sdev);
++extern struct ata_device *ata_dev_pair(struct ata_port *ap,
++ struct ata_device *adev);
+
+ /*
+ * Timing helpers