ide2libata

Index: b/drivers/ide/piix.c
===================================================================
@@ -256,9 +256,12 @@ static const struct ich_laptop ich_lapto
 	{ 0x27DF, 0x1025, 0x0102 },	/* ICH7 on Acer 5602aWLMi */
 	{ 0x27DF, 0x0005, 0x0280 },	/* ICH7 on Acer 5602WLMi */
 	{ 0x27DF, 0x1025, 0x0110 },	/* ICH7 on Acer 3682WLMi */
+	{ 0x27DF, 0x1028, 0x02b0 },	/* ICH7 on unknown Dell */
 	{ 0x27DF, 0x1043, 0x1267 },	/* ICH7 on Asus W5F */
 	{ 0x27DF, 0x103C, 0x30A1 },	/* ICH7 on HP Compaq nc2400 */
+	{ 0x27DF, 0x103C, 0x361a },	/* ICH7 on unkown HP  */
 	{ 0x27DF, 0x1071, 0xD221 },	/* ICH7 on Hercules EC-900 */
+	{ 0x27DF, 0x152D, 0x0778 },	/* ICH7 on unknown Intel */
 	{ 0x24CA, 0x1025, 0x0061 },	/* ICH4 on Acer Aspire 2023WLMi */
 	{ 0x24CA, 0x1025, 0x003d },	/* ICH4 on ACER TM290 */
 	{ 0x266F, 0x1025, 0x0066 },	/* ICH6 on ACER Aspire 1694WLMi */

Index: b/drivers/ata/libata-core.c
===================================================================
@@ -3076,10 +3076,11 @@ static const struct ata_timing ata_timin
 	{ 0xFF }
 };
 
-#define ENOUGH(v, unit)		(((v)-1)/(unit)+1)
-#define EZ(v, unit)		((v)?ENOUGH(v, unit):0)
+#define ENOUGH(v, unit)		(((v) - 1) / (unit) + 1)
+#define EZ(v, unit)		((v) ? ENOUGH(v, unit) : 0)
 
-static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
+static void ata_timing_quantize(const struct ata_timing *t,
+				struct ata_timing *q, int T, int UT)
 {
 	q->setup	= EZ(t->setup      * 1000,  T);
 	q->act8b	= EZ(t->act8b      * 1000,  T);

@@ -3095,15 +3096,24 @@ static void ata_timing_quantize(const st
 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
 		      struct ata_timing *m, unsigned int what)
 {
-	if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
-	if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
-	if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
-	if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
-	if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
-	if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
-	if (what & ATA_TIMING_DMACK_HOLD) m->dmack_hold = max(a->dmack_hold, b->dmack_hold);
-	if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
-	if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
+	if (what & ATA_TIMING_SETUP)
+		m->setup      = max(a->setup,      b->setup);
+	if (what & ATA_TIMING_ACT8B)
+		m->act8b      = max(a->act8b,      b->act8b);
+	if (what & ATA_TIMING_REC8B)
+		m->rec8b      = max(a->rec8b,      b->rec8b);
+	if (what & ATA_TIMING_CYC8B)
+		m->cyc8b      = max(a->cyc8b,      b->cyc8b);
+	if (what & ATA_TIMING_ACTIVE)
+		m->active     = max(a->active,     b->active);
+	if (what & ATA_TIMING_RECOVER)
+		m->recover    = max(a->recover,    b->recover);
+	if (what & ATA_TIMING_DMACK_HOLD)
+		m->dmack_hold = max(a->dmack_hold, b->dmack_hold);
+	if (what & ATA_TIMING_CYCLE)
+		m->cycle      = max(a->cycle,      b->cycle);
+	if (what & ATA_TIMING_UDMA)
+		m->udma       = max(a->udma,       b->udma);
 }
 
 const struct ata_timing *ata_timing_find_mode(u8 xfer_mode)

@@ -3129,7 +3139,8 @@ int ata_timing_compute(struct ata_device
 	 * Find the mode.
 	 */
 
-	if (!(s = ata_timing_find_mode(speed)))
+	s = ata_timing_find_mode(speed);
+	if (!s)
 		return -EINVAL;
 
 	memcpy(t, s, sizeof(*s));

@@ -3162,7 +3173,7 @@ int ata_timing_compute(struct ata_device
 
 	/*
 	 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
-	 * S.M.A.R.T * and some other commands. We have to ensure that the
+	 * S.M.A.R.T and some other commands. We have to ensure that the
 	 * DMA cycle timing is slower/equal than the fastest PIO timing.
 	 */
 

179 lines not on this page · raw message

179 lines not on this page · raw message

Index: b/drivers/ata/ata-timings.c
===================================================================
@@ -100,10 +100,9 @@ const struct ata_timing *ata_timing_find
 }
 EXPORT_SYMBOL_GPL(ata_timing_find_mode);
 
-int ata_timing_compute(struct ata_device *adev, unsigned short speed,
+int ata_timing_compute(const u16 *id, u8 speed, u8 pio_speed,
 		       struct ata_timing *t, int T, int UT)
 {
-	const u16 *id = adev->id;
 	const struct ata_timing *s;
 	struct ata_timing p;
 

@@ -150,7 +149,7 @@ int ata_timing_compute(struct ata_device
 	 */
 
 	if (speed > XFER_PIO_6) {
-		ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
+		ata_timing_compute(id, pio_speed, pio_speed, &p, T, UT);
 		ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
 	}
 

Index: b/drivers/ata/pata_ali.c
===================================================================
@@ -210,13 +210,16 @@ static void ali_set_piomode(struct ata_p
 	struct ata_timing t;
 	unsigned long T =  1000000000 / 33333;	/* PCI clock based */
 
-	ata_timing_compute(adev, adev->pio_mode, &t, T, 1);
+	ata_timing_compute(adev->id, adev->pio_mode, adev->pio_mode, &t, T, 1);
 	if (pair) {
 		struct ata_timing p;
-		ata_timing_compute(pair, pair->pio_mode, &p, T, 1);
+
+		ata_timing_compute(pair->id, pair->pio_mode, pair->pio_mode,
+				   &p, T, 1);
 		ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
 		if (pair->dma_mode) {
-			ata_timing_compute(pair, pair->dma_mode, &p, T, 1);
+			ata_timing_compute(pair->id, pair->dma_mode,
+					   pair->pio_mode, &p, T, 1);
 			ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
 		}
 	}

@@ -256,13 +259,17 @@ static void ali_set_dmamode(struct ata_p
 			pci_write_config_byte(pdev, 0x4B, reg4b);
 		}
 	} else {
-		ata_timing_compute(adev, adev->dma_mode, &t, T, 1);
+		ata_timing_compute(adev->id, adev->dma_mode, adev->pio_mode,
+				   &t, T, 1);
 		if (pair) {
 			struct ata_timing p;
-			ata_timing_compute(pair, pair->pio_mode, &p, T, 1);
+
+			ata_timing_compute(pair->id, pair->pio_mode,
+					   pair->pio_mode, &p, T, 1);
 			ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
 			if (pair->dma_mode) {
-				ata_timing_compute(pair, pair->dma_mode, &p, T, 1);
+				ata_timing_compute(pair->id, pair->dma_mode,
+						   pair->pio_mode, &p, T, 1);
 				ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
 			}
 		}

Index: b/drivers/ata/pata_amd.c
===================================================================
@@ -59,13 +59,11 @@ static void timing_setup(struct ata_port
 	if (clock >= 2)
 		UT = T / 2;
 
-	if (ata_timing_compute(adev, speed, &at, T, UT) < 0) {
-		dev_printk(KERN_ERR, &pdev->dev, "unknown mode %d.\n", speed);
-		return;
-	}
+	ata_timing_compute(adev->id, speed, adev->pio_mode, &at, T, UT);
 
 	if (peer) {
-		ata_timing_compute(peer, peer->pio_mode, &apeer, T, UT);
+		ata_timing_compute(peer->id, peer->pio_mode,
+				   peer->pio_mode, &apeer, T, UT);
 		ata_timing_merge(&apeer, &at, &at, ATA_TIMING_8BIT);
 	}
 

Index: b/drivers/ata/pata_at32.c
===================================================================
@@ -150,15 +150,11 @@ static void pata_at32_set_piomode(struct
 {
 	struct ata_timing timing;
 	struct at32_ide_info *info = ap->host->private_data;
-
 	int ret;
+	u8 mode = adev->pio_mode;
 
 	/* Compute ATA timing */
-	ret = ata_timing_compute(adev, adev->pio_mode, &timing, 1000, 0);
-	if (ret) {
-		dev_warn(ap->dev, "Failed to compute ATA timing %d\n", ret);
-		return;
-	}
+	ata_timing_compute(adev->id, mode, mode, &timing, 1000, 0);
 
 	/* Setup SMC to ATA timing */
 	ret = pata_at32_setup_timing(ap->dev, info, &timing);

Index: b/drivers/ata/pata_at91.c
===================================================================
@@ -48,9 +48,6 @@ struct at91_ide_info {
 	void __iomem *alt_addr;
 };
 
-static const struct ata_timing initial_timing =
-	{XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0};
-
 static unsigned long calc_mck_cycles(unsigned long ns, unsigned long mck_hz)
 {
 	unsigned long mul;

@@ -148,22 +145,15 @@ static void pata_at91_set_piomode(struct
 {
 	struct at91_ide_info *info = ap->host->private_data;
 	struct ata_timing timing;
-	int ret;
+	u8 mode = adev->pio_mode;
 
 	/* Compute ATA timing and set it to SMC */
-	ret = ata_timing_compute(adev, adev->pio_mode, &timing, 1000, 0);
-	if (ret) {
-		dev_warn(ap->dev, "Failed to compute ATA timing %d, \
-				set PIO_0 timing\n", ret);
-		set_smc_timing(ap->dev, info, &initial_timing);
-	} else {
-		set_smc_timing(ap->dev, info, &timing);
-	}
+	ata_timing_compute(adev->id, mode, mode, &timing, 1000, 0);
+
+	set_smc_timing(ap->dev, info, &timing);
 
 	/* Setup SMC mode */
 	set_smc_mode(info);
-
-	return;
 }
 
 static unsigned int pata_at91_data_xfer_noirq(struct ata_device *dev,

Index: b/drivers/ata/pata_atp867x.c
===================================================================
@@ -223,9 +223,10 @@ static void atp867x_set_piomode(struct a
 	T = 1000000000 / 33333;
 	UT = T / 4;
 
-	ata_timing_compute(adev, speed, &t, T, UT);
+	ata_timing_compute(adev->id, speed, adev->pio_mode, &t, T, UT);
 	if (peer && peer->pio_mode) {
-		ata_timing_compute(peer, peer->pio_mode, &p, T, UT);
+		ata_timing_compute(peer->id, peer->pio_mode, peer->pio_mode,
+				   &p, T, UT);
 		ata_timing_merge(&p, &t, &t, ATA_TIMING_8BIT);
 	}
 

Index: b/drivers/ata/pata_cmd640.c
===================================================================
@@ -59,16 +59,15 @@ static void cmd640_set_piomode(struct at
 	int arttim = ARTIM0 + 2 * adev->devno;
 	struct ata_device *pair = ata_dev_pair(adev);
 
-	if (ata_timing_compute(adev, adev->pio_mode, &t, T, 0) < 0) {
-		printk(KERN_ERR DRV_NAME ": mode computation failed.\n");
-		return;
-	}
+	ata_timing_compute(adev->id, adev->pio_mode, adev->pio_mode, &t, T, 0);
 
 	/* The second channel has shared timings and the setup timing is
 	   messy to switch to merge it for worst case */
 	if (ap->port_no && pair) {
 		struct ata_timing p;
-		ata_timing_compute(pair, pair->pio_mode, &p, T, 1);
+
+		ata_timing_compute(pair->id, pair->pio_mode, pair->pio_mode,
+				   &p, T, 1);
 		ata_timing_merge(&p, &t, &t, ATA_TIMING_SETUP);
 	}
 

Index: b/drivers/ata/pata_cmd64x.c
===================================================================
@@ -145,10 +145,8 @@ static void cmd64x_set_timing(struct ata
 
 	/* ata_timing_compute is smart and will produce timings for MWDMA
 	   that don't violate the drives PIO capabilities. */
-	if (ata_timing_compute(adev, mode, &t, T, 0) < 0) {
-		printk(KERN_ERR DRV_NAME ": mode computation failed.\n");
-		return;
-	}
+	ata_timing_compute(adev->id, mode, adev->pio_mode, &t, T, 0);
+
 	if (ap->port_no) {
 		/* Slave has shared address setup */
 		struct ata_device *pair = ata_dev_pair(adev);

@@ -156,11 +154,12 @@ static void cmd64x_set_timing(struct ata
 		if (pair) {
 			struct ata_timing tp;
 
-			ata_timing_compute(pair, pair->pio_mode, &tp, T, 0);
+			ata_timing_compute(pair->id, pair->pio_mode,
+					pair->pio_mode, &tp, T, 0);
 			ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
 			if (pair->dma_mode) {
-				ata_timing_compute(pair, pair->dma_mode,
-						&tp, T, 0);
+				ata_timing_compute(pair->id, pair->dma_mode,
+						pair->pio_mode, &tp, T, 0);
 				ata_timing_merge(&tp, &t, &t, ATA_TIMING_SETUP);
 			}
 		}

Index: b/drivers/ata/pata_cypress.c
===================================================================
@@ -57,10 +57,7 @@ static void cy82c693_set_piomode(struct
 	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;
-	}
+	ata_timing_compute(adev->id, adev->pio_mode, adev->pio_mode, &t, T, 1);
 
 	time_16 = clamp_val(t.recover - 1, 0, 15) |
 		  (clamp_val(t.active - 1, 0, 15) << 4);

Index: b/drivers/ata/pata_icside.c
===================================================================
@@ -186,6 +186,7 @@ static const expansioncard_ops_t pata_ic
 static void pata_icside_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 {
 	struct pata_icside_state *state = ap->host->private_data;
+	const u16 *id = adev->id;
 	struct ata_timing t;
 	unsigned int cycle;
 	char iomd_type;

@@ -193,8 +194,7 @@ static void pata_icside_set_dmamode(stru
 	/*
 	 * DMA is based on a 16MHz clock
 	 */
-	if (ata_timing_compute(adev, adev->dma_mode, &t, 1000, 1))
-		return;
+	ata_timing_compute(id, adev->dma_mode, adev->pio_mode, &t, 1000, 1);
 
 	/*
 	 * Choose the IOMD cycle timing which ensure that the interface

Index: b/drivers/ata/pata_legacy.c
===================================================================
@@ -357,11 +357,11 @@ static struct ata_port_operations pdc202
 
 static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
 {
-	u8 active, recover;
+	u8 mode = adev->pio_mode, 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);
+	ata_timing_compute(adev->id, mode, mode, &t, 20000, 1000);
 
 	active = clamp_val(t.active, 2, 15);
 	recover = clamp_val(t.recover, 4, 15);

@@ -391,11 +391,11 @@ static struct ata_port_operations ht6560
 
 static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
 {
-	u8 active, recover;
+	u8 mode = adev->pio_mode, 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);
+	ata_timing_compute(adev->id, mode, mode, &t, 20000, 1000);
 
 	active = clamp_val(t.active, 2, 15);
 	recover = clamp_val(t.recover, 2, 16);

@@ -456,7 +456,7 @@ static u8 opti_syscfg(u8 reg)
 static void opti82c611a_set_piomode(struct ata_port *ap,
 						struct ata_device *adev)
 {
-	u8 active, recover, setup;
+	u8 mode = adev->pio_mode, active, recover, setup;
 	struct ata_timing t;
 	struct ata_device *pair = ata_dev_pair(adev);
 	int clock;

@@ -472,13 +472,14 @@ static void opti82c611a_set_piomode(stru
 	clock = 1000000000 / khz[ioread8(ap->ioaddr.lbah_addr) & 0x03];
 
 	/* Get the timing data in cycles */
-	ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
+	ata_timing_compute(adev->id, mode, 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_compute(pair->id, pair->pio_mode, pair->pio_mode,
+				   &tp, clock, 1000);
 		ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
 	}
 

@@ -531,7 +532,7 @@ static struct ata_port_operations opti82
 
 static void opti82c46x_set_piomode(struct ata_port *ap, struct ata_device *adev)
 {
-	u8 active, recover, setup;
+	u8 mode = adev->pio_mode, active, recover, setup;
 	struct ata_timing t;
 	struct ata_device *pair = ata_dev_pair(adev);
 	int clock;

@@ -551,13 +552,14 @@ static void opti82c46x_set_piomode(struc
 	clock = 1000000000 / khz[sysclk];
 
 	/* Get the timing data in cycles */
-	ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
+	ata_timing_compute(adev->id, mode, 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_compute(pair->id, pair->pio_mode, pair->pio_mode,
+				   &tp, clock, 1000);
 		ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
 	}
 

@@ -651,10 +653,10 @@ static void qdi65x0_set_piomode(struct a
 	struct ata_timing t;
 	struct legacy_data *ld_qdi = ap->host->private_data;
 	int active, recovery;
-	u8 timing;
+	u8 mode = adev->pio_mode, timing;
 
 	/* Get the timing data in cycles */
-	ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
+	ata_timing_compute(adev->id, mode, mode, &t, 30303, 1000);
 
 	if (ld_qdi->fast) {
 		active = 8 - clamp_val(t.active, 1, 8);

@@ -786,16 +788,16 @@ static void winbond_set_piomode(struct a
 	struct ata_timing t;
 	struct legacy_data *ld_winbond = ap->host->private_data;
 	int active, recovery;
-	u8 reg;
+	u8 mode = adev->pio_mode, reg;
 	int timing = 0x88 + (ap->port_no * 4) + (adev->devno * 2);
 
 	reg = winbond_readcfg(ld_winbond->timing, 0x81);
 
 	/* Get the timing data in cycles */
 	if (reg & 0x40)		/* Fast VLB bus, assume 50MHz */
-		ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
+		ata_timing_compute(adev->id, mode, mode, &t, 20000, 1000);
 	else
-		ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
+		ata_timing_compute(adev->id, mode, mode, &t, 30303, 1000);
 
 	active = (clamp_val(t.active, 3, 17) - 1) & 0x0F;
 	recovery = (clamp_val(t.recover, 1, 15) + 1) & 0x0F;

Index: b/drivers/ata/pata_ns87410.c
===================================================================
@@ -65,7 +65,7 @@ static void ns87410_set_piomode(struct a
 {
 	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 	int port = 0x40 + 4 * ap->port_no;
-	u8 idetcr, idefr;
+	u8 mode = adev->pio_mode, idetcr, idefr;
 	struct ata_timing at;
 
 	static const u8 activebits[15] = {

@@ -85,10 +85,7 @@ static void ns87410_set_piomode(struct a
 	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;
-	}
+	ata_timing_compute(adev->id, mode, mode, &at, 30303, 1);
 
 	at.active = clamp_val(at.active, 2, 16) - 2;
 	at.setup = clamp_val(at.setup, 1, 4) - 1;

Index: b/drivers/ata/pata_ns87415.c
===================================================================
@@ -64,7 +64,7 @@ static void ns87415_set_mode(struct ata_
 	/* Timing register format is 17 - low nybble read timing with
 	   the high nybble being 16 - x for recovery time in PCI clocks */
 
-	ata_timing_compute(adev, adev->pio_mode, &t, T, 0);
+	ata_timing_compute(adev->id, adev->pio_mode, adev->pio_mode, &t, T, 0);
 
 	clocking = 17 - clamp_val(t.active, 2, 17);
 	clocking |= (16 - clamp_val(t.recover, 1, 16)) << 4;

Index: b/drivers/ata/pata_octeon_cf.c
===================================================================
@@ -104,11 +104,11 @@ static void octeon_cf_set_piomode(struct
 	int t1;
 	int t2;
 	int t2i;
+	u8 mode = dev->pio_mode;
 
 	T = (int)(2000000000000LL / octeon_get_clock_rate());
 
-	if (ata_timing_compute(dev, dev->pio_mode, &timing, T, T))
-		BUG();
+	ata_timing_compute(dev->id, mode, mode, &timing, T, T);
 
 	t1 = timing.setup;
 	if (t1)

Index: b/drivers/ata/pata_via.c
===================================================================
@@ -252,12 +252,13 @@ static void via_do_set_mode(struct ata_p
 	}
 
 	/* Calculate the timing values we require */
-	ata_timing_compute(adev, mode, &t, T, UT);
+	ata_timing_compute(adev->id, mode, 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_compute(peer->id, peer->pio_mode,
+					   peer->pio_mode, &p, T, UT);
 			ata_timing_merge(&p, &t, &t, ATA_TIMING_8BIT);
 		}
 	}

47 lines not on this page · raw message

Index: b/include/linux/libata.h
===================================================================
@@ -390,24 +390,6 @@ enum {
 	ATAPI_PASS_THRU		= 3,		/* SAT pass-thru */
 	ATAPI_MISC		= 4,		/* the rest */
 
-	/* Timing constants */
-	ATA_TIMING_SETUP	= (1 << 0),
-	ATA_TIMING_ACT8B	= (1 << 1),
-	ATA_TIMING_REC8B	= (1 << 2),
-	ATA_TIMING_CYC8B	= (1 << 3),
-	ATA_TIMING_8BIT		= ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
-				  ATA_TIMING_CYC8B,
-	ATA_TIMING_ACTIVE	= (1 << 4),
-	ATA_TIMING_RECOVER	= (1 << 5),
-	ATA_TIMING_DMACK_HOLD	= (1 << 6),
-	ATA_TIMING_CYCLE	= (1 << 7),
-	ATA_TIMING_UDMA		= (1 << 8),
-	ATA_TIMING_ALL		= ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
-				  ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
-				  ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
-				  ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
-				  ATA_TIMING_UDMA,
-
 	/* ACPI constants */
 	ATA_ACPI_FILTER_SETXFER	= 1 << 0,
 	ATA_ACPI_FILTER_LOCK	= 1 << 1,

@@ -883,19 +865,6 @@ struct ata_port_info {
 	void 			*private_data;
 };
 
-struct ata_timing {
-	unsigned short mode;		/* ATA mode */
-	unsigned short setup;		/* t1 */
-	unsigned short act8b;		/* t2 for 8-bit I/O */
-	unsigned short rec8b;		/* t2i for 8-bit I/O */
-	unsigned short cyc8b;		/* t0 for 8-bit I/O */
-	unsigned short active;		/* t2 or tD */
-	unsigned short recover;		/* t2i or tK */
-	unsigned short dmack_hold;	/* tj */
-	unsigned short cycle;		/* t0 */
-	unsigned short udma;		/* t2CYCTYP/2 */
-};
-
 /*
  * Core layer - drivers/ata/libata-core.c
  */

@@ -1029,12 +998,6 @@ extern void ata_pio_queue_task(struct at
 
 /* Timing helpers */
 extern unsigned int ata_pio_need_iordy(const struct ata_device *);
-extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
-extern int ata_timing_compute(struct ata_device *, unsigned short,
-			      struct ata_timing *, int, int);
-extern void ata_timing_merge(const struct ata_timing *,
-			     const struct ata_timing *, struct ata_timing *,
-			     unsigned int);
 extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
 
 /* PCI */

Index: b/drivers/ata/ata-timings.c
===================================================================
@@ -15,7 +15,7 @@
  */
 
 static const struct ata_timing ata_timing[] = {
-/*	{ XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 0,  960,   0 }, */
+	{ XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 0,  960,   0 },
 	{ XFER_PIO_0,     70, 290, 240, 600, 165, 150, 0,  600,   0 },
 	{ XFER_PIO_1,     50, 290,  93, 383, 125, 100, 0,  383,   0 },
 	{ XFER_PIO_2,     30, 290,  40, 330, 100,  90, 0,  240,   0 },

Index: b/drivers/ide/ali14xx.c
===================================================================
@@ -117,7 +117,7 @@ static void ali14xx_set_pio_mode(ide_hwi
 	unsigned long flags;
 	int bus_speed = ide_vlb_clk ? ide_vlb_clk : 50;
 	const u8 pio = drive->pio_mode - XFER_PIO_0;
-	struct ide_timing *t = ide_timing_find_mode(XFER_PIO_0 + pio);
+	const struct ata_timing *t = ata_timing_find_mode(XFER_PIO_0 + pio);
 
 	/* calculate timing, according to PIO mode */
 	time1 = ide_pio_cycle_time(drive, pio);

72 lines not on this page · raw message

Index: b/drivers/ide/amd74xx.c
===================================================================
@@ -48,7 +48,7 @@ static inline u8 amd_offset(struct pci_d
  */
 
 static void amd_set_speed(struct pci_dev *dev, u8 dn, u8 udma_mask,
-			  struct ide_timing *timing)
+			  struct ata_timing *timing)
 {
 	u8 t = 0, offset = amd_offset(dev);
 

@@ -83,7 +83,7 @@ static void amd_set_drive(ide_hwif_t *hw
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	ide_drive_t *peer = ide_get_pair_dev(drive);
-	struct ide_timing t, p;
+	struct ata_timing t, p;
 	int T, UT;
 	u8 udma_mask = hwif->ultra_mask;
 	const u8 speed = drive->dma_mode;

@@ -91,11 +91,12 @@ static void amd_set_drive(ide_hwif_t *hw
 	T = 1000000000 / amd_clock;
 	UT = (udma_mask == ATA_UDMA2) ? T : (T / 2);
 
-	ide_timing_compute(drive, speed, &t, T, UT);
+	ata_timing_compute(drive->id, speed, drive->pio_mode, &t, T, UT);
 
 	if (peer) {
-		ide_timing_compute(peer, peer->pio_mode, &p, T, UT);
-		ide_timing_merge(&p, &t, &t, IDE_TIMING_8BIT);
+		ata_timing_compute(peer->id, peer->pio_mode,
+				   peer->pio_mode, &p, T, UT);
+		ata_timing_merge(&p, &t, &t, ATA_TIMING_8BIT);
 	}
 
 	if (speed == XFER_UDMA_5 && amd_clock <= 33333) t.udma = 1;

Index: b/drivers/ide/at91_ide.c
===================================================================
@@ -107,7 +107,7 @@ static unsigned int calc_mck_cycles(unsi
 }
 
 static void apply_timings(const u8 chipselect, const u8 pio,
-			  const struct ide_timing *timing, int use_iordy)
+			  const struct ata_timing *timing, int use_iordy)
 {
 	unsigned int t0, t1, t2, t6z;
 	unsigned int cycle, setup, pulse, data_float;

@@ -174,14 +174,14 @@ static void at91_ide_output_data(ide_dri
 
 static void at91_ide_set_pio_mode(ide_hwif_t *hwif, ide_drive_t *drive)
 {
-	struct ide_timing *timing;
+	const struct ata_timing *timing;
 	u8 chipselect = hwif->select_data;
 	int use_iordy = 0;
 	const u8 pio = drive->pio_mode - XFER_PIO_0;
 
 	pdbg("chipselect %u pio %u\n", chipselect, pio);
 
-	timing = ide_timing_find_mode(XFER_PIO_0 + pio);
+	timing = ata_timing_find_mode(XFER_PIO_0 + pio);
 	BUG_ON(!timing);
 
 	if (ide_pio_need_iordy(drive, pio))

@@ -311,7 +311,8 @@ static int __init at91_ide_probe(struct
 	}
 
 	/* setup Static Memory Controller - PIO 0 as default */
-	apply_timings(board->chipselect, 0, ide_timing_find_mode(XFER_PIO_0), 0);
+	apply_timings(board->chipselect, 0,
+		      ata_timing_find_mode(XFER_PIO_0), 0);
 
 	/* with GPIO interrupt we have to do quirks in handler */
 	if (board->irq_pin >= PIN_BASE)

Index: b/drivers/ide/cmd640.c
===================================================================
@@ -513,7 +513,7 @@ static void program_drive_counts(ide_dri
 static void cmd640_set_mode(ide_drive_t *drive, unsigned int index,
 			    u8 pio_mode, unsigned int cycle_time)
 {
-	struct ide_timing *t;
+	const struct ata_timing *t;
 	int setup_time, active_time, recovery_time, clock_time;
 	u8 setup_count, active_count, recovery_count, recovery_count2, cycle_count;
 	int bus_speed;

@@ -526,7 +526,7 @@ static void cmd640_set_mode(ide_drive_t
 	if (pio_mode > 5)
 		pio_mode = 5;
 
-	t = ide_timing_find_mode(XFER_PIO_0 + pio_mode);
+	t = ata_timing_find_mode(XFER_PIO_0 + pio_mode);
 	setup_time  = t->setup;
 	active_time = t->active;
 

Index: b/drivers/ide/cmd64x.c
===================================================================
@@ -62,10 +62,10 @@ static void cmd64x_program_timings(ide_d
 	static const u8 setup_values[] = {0x40, 0x40, 0x40, 0x80, 0, 0xc0};
 	static const u8 arttim_regs[4] = {ARTTIM0, ARTTIM1, ARTTIM23, ARTTIM23};
 	static const u8 drwtim_regs[4] = {DRWTIM0, DRWTIM1, DRWTIM2, DRWTIM3};
-	struct ide_timing t;
+	struct ata_timing t;
 	u8 arttim = 0;
 
-	ide_timing_compute(drive, mode, &t, T, 0);
+	ata_timing_compute(drive->id, mode, drive->pio_mode, &t, T, 0);
 
 	/*
 	 * In case we've got too long recovery phase, try to lengthen

@@ -98,14 +98,15 @@ static void cmd64x_program_timings(ide_d
 		ide_drive_t *pair = ide_get_pair_dev(drive);
 
 		if (pair) {
-			struct ide_timing tp;
+			struct ata_timing tp;
 
-			ide_timing_compute(pair, pair->pio_mode, &tp, T, 0);
-			ide_timing_merge(&t, &tp, &t, IDE_TIMING_SETUP);
+			ata_timing_compute(pair->id, pair->pio_mode,
+					pair->pio_mode, &tp, T, 0);
+			ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
 			if (pair->dma_mode) {
-				ide_timing_compute(pair, pair->dma_mode,
-						&tp, T, 0);
-				ide_timing_merge(&tp, &t, &t, IDE_TIMING_SETUP);
+				ata_timing_compute(pair->id, pair->dma_mode,
+						pair->pio_mode, &tp, T, 0);
+				ata_timing_merge(&tp, &t, &t, ATA_TIMING_SETUP);
 			}
 		}
 	}

Index: b/drivers/ide/cy82c693.c
===================================================================
@@ -86,8 +86,8 @@ static void cy82c693_set_pio_mode(ide_hw
 	int bus_speed = ide_pci_clk ? ide_pci_clk : 33;
 	const unsigned long T = 1000000 / bus_speed;
 	unsigned int addrCtrl;
-	struct ide_timing t;
-	u8 time_16, time_8;
+	struct ata_timing t;
+	u8 mode = drive->pio_mode, time_16, time_8;
 
 	/* select primary or secondary channel */
 	if (hwif->index > 0) {  /* drive is on the secondary channel */

@@ -100,7 +100,7 @@ static void cy82c693_set_pio_mode(ide_hw
 		}
 	}
 
-	ide_timing_compute(drive, drive->pio_mode, &t, T, 1);
+	ata_timing_compute(drive->id, mode, mode, &t, T, 1);
 
 	time_16 = clamp_val(t.recover - 1, 0, 15) |
 		  (clamp_val(t.active - 1, 0, 15) << 4);

Index: b/drivers/ide/ht6560b.c
===================================================================
@@ -205,7 +205,8 @@ static u8 ht_pio2timings(ide_drive_t *dr
 
         if (pio) {
 		unsigned int cycle_time;
-		struct ide_timing *t = ide_timing_find_mode(XFER_PIO_0 + pio);
+		const struct ata_timing *t =
+			ata_timing_find_mode(XFER_PIO_0 + pio);
 
 		cycle_time = ide_pio_cycle_time(drive, pio);
 

217 lines not on this page · raw message

Index: b/drivers/ide/ide-xfer-mode.c
===================================================================
@@ -118,6 +118,31 @@ int ide_pio_need_iordy(ide_drive_t *driv
 }
 EXPORT_SYMBOL_GPL(ide_pio_need_iordy);
 
+u16 ide_pio_cycle_time(ide_drive_t *drive, u8 pio)
+{
+	u16 *id = drive->id;
+	const struct ata_timing *t = ata_timing_find_mode(XFER_PIO_0 + pio);
+	u16 cycle = 0;
+
+	if (id[ATA_ID_FIELD_VALID] & 2) {
+		if (ata_id_has_iordy(drive->id))
+			cycle = id[ATA_ID_EIDE_PIO_IORDY];
+		else
+			cycle = id[ATA_ID_EIDE_PIO];
+
+		/* conservative "downgrade" for all pre-ATA2 drives */
+		if (pio < 3 && cycle < t->cycle)
+			cycle = 0; /* use standard timing */
+
+		/* Use the standard timing for the CF specific modes too */
+		if (pio > 4 && ata_id_is_cfa(id))
+			cycle = 0;
+	}
+
+	return cycle ? cycle : t->cycle;
+}
+EXPORT_SYMBOL_GPL(ide_pio_cycle_time);
+
 int ide_set_pio_mode(ide_drive_t *drive, const u8 mode)
 {
 	ide_hwif_t *hwif = drive->hwif;

Index: b/drivers/ide/palm_bk3710.c
===================================================================
@@ -112,13 +112,12 @@ static void palm_bk3710_setdmamode(void
 				   unsigned short min_cycle,
 				   unsigned int mode)
 {
+	const struct ata_timing *t = ata_timing_find_mode(mode);
 	u8 td, tkw, t0;
 	u32 val32;
 	u16 val16;
-	struct ide_timing *t;
 	int cycletime;
 
-	t = ide_timing_find_mode(mode);
 	cycletime = max_t(int, t->cycle, min_cycle);
 
 	/* DMA Data Setup */

@@ -144,11 +143,9 @@ static void palm_bk3710_setpiomode(void
 				   unsigned int dev, unsigned int cycletime,
 				   unsigned int mode)
 {
+	const struct ata_timing *t = ata_timing_find_mode(XFER_PIO_0 + mode);
 	u8 t2, t2i, t0;
 	u32 val32;
-	struct ide_timing *t;
-
-	t = ide_timing_find_mode(XFER_PIO_0 + mode);
 
 	/* PIO Data Setup */
 	t0 = DIV_ROUND_UP(cycletime, ideclk_period);

Index: b/drivers/ide/pmac.c
===================================================================
@@ -503,7 +503,7 @@ static void pmac_ide_set_pio_mode(ide_hw
 	pmac_ide_hwif_t *pmif =
 		(pmac_ide_hwif_t *)dev_get_drvdata(hwif->gendev.parent);
 	const u8 pio = drive->pio_mode - XFER_PIO_0;
-	struct ide_timing *tim = ide_timing_find_mode(XFER_PIO_0 + pio);
+	const struct ata_timing *tim = ata_timing_find_mode(XFER_PIO_0 + pio);
 	u32 *timings, t;
 	unsigned accessTicks, recTicks;
 	unsigned accessTime, recTime;

@@ -612,7 +612,7 @@ set_timings_udma_ata4(u32 *timings, u8 s
 static int
 set_timings_udma_ata6(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 {
-	struct ide_timing *t = ide_timing_find_mode(speed);
+	const struct ata_timing *t = ata_timing_find_mode(speed);
 	u32 tr;
 
 	if (speed > XFER_UDMA_5 || t == NULL)

@@ -630,7 +630,7 @@ set_timings_udma_ata6(u32 *pio_timings,
 static int
 set_timings_udma_shasta(u32 *pio_timings, u32 *ultra_timings, u8 speed)
 {
-	struct ide_timing *t = ide_timing_find_mode(speed);
+	const struct ata_timing *t = ata_timing_find_mode(speed);
 	u32 tr;
 
 	if (speed > XFER_UDMA_6 || t == NULL)

Index: b/drivers/ide/qd65xx.c
===================================================================
@@ -212,7 +212,7 @@ static void qd6500_set_pio_mode(ide_hwif
 static void qd6580_set_pio_mode(ide_hwif_t *hwif, ide_drive_t *drive)
 {
 	const u8 pio = drive->pio_mode - XFER_PIO_0;
-	struct ide_timing *t = ide_timing_find_mode(XFER_PIO_0 + pio);
+	const struct ata_timing *t = ata_timing_find_mode(XFER_PIO_0 + pio);
 	unsigned int cycle_time;
 	int active_time   = 175;
 	int recovery_time = 415; /* worst case values from the dos driver */

Index: b/drivers/ide/sl82c105.c
===================================================================
@@ -41,7 +41,7 @@
  */
 static unsigned int get_pio_timings(ide_drive_t *drive, u8 pio)
 {
-	struct ide_timing *t = ide_timing_find_mode(XFER_PIO_0 + pio);
+	const struct ata_timing *t = ata_timing_find_mode(XFER_PIO_0 + pio);
 	unsigned int cmd_on, cmd_off;
 	u8 iordy = 0;
 

Index: b/drivers/ide/tx4938ide.c
===================================================================
@@ -23,7 +23,7 @@ static void tx4938ide_tune_ebusc(unsigne
 				 unsigned int gbus_clock,
 				 u8 pio)
 {
-	struct ide_timing *t = ide_timing_find_mode(XFER_PIO_0 + pio);
+	const struct ata_timing *t = ata_timing_find_mode(XFER_PIO_0 + pio);
 	u64 cr = __raw_readq(&tx4938_ebuscptr->cr[ebus_ch]);
 	unsigned int sp = (cr >> 4) & 3;
 	unsigned int clock = gbus_clock / (4 - sp);

Index: b/drivers/ide/via82cxxx.c
===================================================================
@@ -122,7 +122,7 @@ struct via82cxxx_dev
  *	via_set_speed writes timing values to the chipset registers
  */
 
-static void via_set_speed(ide_hwif_t *hwif, u8 dn, struct ide_timing *timing)
+static void via_set_speed(ide_hwif_t *hwif, u8 dn, struct ata_timing *timing)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	struct ide_host *host = pci_get_drvdata(dev);

@@ -182,7 +182,7 @@ static void via_set_drive(ide_hwif_t *hw
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	struct ide_host *host = pci_get_drvdata(dev);
 	struct via82cxxx_dev *vdev = host->host_priv;
-	struct ide_timing t, p;
+	struct ata_timing t, p;
 	unsigned int T, UT;
 	const u8 speed = drive->dma_mode;
 

@@ -196,11 +196,12 @@ static void via_set_drive(ide_hwif_t *hw
 	default:	UT = T;
 	}
 
-	ide_timing_compute(drive, speed, &t, T, UT);
+	ata_timing_compute(drive->id, speed, drive->pio_mode, &t, T, UT);
 
 	if (peer) {
-		ide_timing_compute(peer, peer->pio_mode, &p, T, UT);
-		ide_timing_merge(&p, &t, &t, IDE_TIMING_8BIT);
+		ata_timing_compute(peer->id, peer->pio_mode,
+				   peer->pio_mode, &p, T, UT);
+		ata_timing_merge(&p, &t, &t, ATA_TIMING_8BIT);
 	}
 
 	via_set_speed(hwif, drive->dn, &t);

Index: b/include/linux/ide.h
===================================================================
@@ -1459,44 +1459,11 @@ extern void ide_toggle_bounce(ide_drive_
 u64 ide_get_lba_addr(struct ide_cmd *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 
-struct ide_timing {
-	u8  mode;
-	u8  setup;	/* t1 */
-	u16 act8b;	/* t2 for 8-bit io */
-	u16 rec8b;	/* t2i for 8-bit io */
-	u16 cyc8b;	/* t0 for 8-bit io */
-	u16 active;	/* t2 or tD */
-	u16 recover;	/* t2i or tK */
-	u16 cycle;	/* t0 */
-	u16 udma;	/* t2CYCTYP/2 */
-};
-
-enum {
-	IDE_TIMING_SETUP	= (1 << 0),
-	IDE_TIMING_ACT8B	= (1 << 1),
-	IDE_TIMING_REC8B	= (1 << 2),
-	IDE_TIMING_CYC8B	= (1 << 3),
-	IDE_TIMING_8BIT		= IDE_TIMING_ACT8B | IDE_TIMING_REC8B |
-				  IDE_TIMING_CYC8B,
-	IDE_TIMING_ACTIVE	= (1 << 4),
-	IDE_TIMING_RECOVER	= (1 << 5),
-	IDE_TIMING_CYCLE	= (1 << 6),
-	IDE_TIMING_UDMA		= (1 << 7),
-	IDE_TIMING_ALL		= IDE_TIMING_SETUP | IDE_TIMING_8BIT |
-				  IDE_TIMING_ACTIVE | IDE_TIMING_RECOVER |
-				  IDE_TIMING_CYCLE | IDE_TIMING_UDMA,
-};
-
-struct ide_timing *ide_timing_find_mode(u8);
-u16 ide_pio_cycle_time(ide_drive_t *, u8);
-void ide_timing_merge(struct ide_timing *, struct ide_timing *,
-		      struct ide_timing *, unsigned int);
-int ide_timing_compute(ide_drive_t *, u8, struct ide_timing *, int, int);
-
 #ifdef CONFIG_IDE_XFER_MODE
 int ide_scan_pio_blacklist(char *);
 const char *ide_xfer_verbose(u8);
 int ide_pio_need_iordy(ide_drive_t *, const u8);
+u16 ide_pio_cycle_time(ide_drive_t *, u8);
 int ide_set_pio_mode(ide_drive_t *, u8);
 int ide_set_dma_mode(ide_drive_t *, u8);
 void ide_set_pio(ide_drive_t *, u8);

Index: b/drivers/ata/pata_pcmcia.c
===================================================================
@@ -388,72 +388,7 @@ static void pcmcia_remove_one(struct pcm
 	kfree(info);
 }
 
-static struct pcmcia_device_id pcmcia_devices[] = {
-	PCMCIA_DEVICE_FUNC_ID(4),
-	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),	/* Corsair */
-	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),	/* Hitachi */
-	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),	/* I-O Data CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),	/* Mitsubishi CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
-	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904),
-	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),	/* SanDisk CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),	/* Kingston */
-	PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), 	/* TI emulated */
-	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, 0x0100),	/* Viking CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),	/* Lexar, Viking CFA */
-	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-ROM", 0x46d7db81, 0x66536591),
-	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("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
-	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
-	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
-	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
-	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_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
-	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
-	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("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
-	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
-	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
-	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
-	PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
-	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
-	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
-	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_PROD_ID2("Flash Card", 0x5a362506),
-	PCMCIA_DEVICE_NULL,
-};
-
-MODULE_DEVICE_TABLE(pcmcia, pcmcia_devices);
+#include "pata_pcmcia.h"
 
 static struct pcmcia_driver pcmcia_driver = {
 	.owner		= THIS_MODULE,

66 lines not on this page · raw message

Index: b/drivers/ide/ide-cs.c
===================================================================
@@ -385,71 +385,7 @@ static void ide_release(struct pcmcia_de
 
 ======================================================================*/
 
-static struct pcmcia_device_id ide_ids[] = {
-	PCMCIA_DEVICE_FUNC_ID(4),
-	PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),	/* Corsair */
-	PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),	/* Hitachi */
-	PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),	/* I-O Data CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),	/* Mitsubishi CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
-	PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904),
-	PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),	/* SanDisk CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),	/* Kingston */
-	PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620), 	/* TI emulated */
-	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, 0x0100),	/* Viking CFA */
-	PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),	/* Lexar, Viking CFA */
-	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-ROM", 0x46d7db81, 0x66536591),
-	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("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
-	PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
-	PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
-	PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
-	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_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
-	PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
-	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("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
-	PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
-	PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
-	PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
-	PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
-	PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
-	PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
-	PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
-	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_PROD_ID2("Flash Card", 0x5a362506),
-	PCMCIA_DEVICE_NULL,
-};
-MODULE_DEVICE_TABLE(pcmcia, ide_ids);
+#include "../ata/pata_pcmcia.h"
 
 static struct pcmcia_driver ide_cs_driver = {
 	.owner		= THIS_MODULE,

@@ -458,7 +394,7 @@ static struct pcmcia_driver ide_cs_drive
 	},
 	.probe		= ide_probe,
 	.remove		= ide_detach,
-	.id_table       = ide_ids,
+	.id_table       = pcmcia_devices,
 };
 
 static int __init init_ide_cs(void)

Index: b/drivers/ata/ata_piix.c
===================================================================
@@ -611,6 +611,21 @@ static const struct ich_laptop ich_lapto
 	{ 0, }
 };
 
+static int ich_short_ata40(struct pci_dev *pdev)
+{
+	const struct ich_laptop *lap = &ich_laptop[0];
+
+	while (lap->device) {
+		if (lap->device == pdev->device &&
+		    lap->subvendor == pdev->subsystem_vendor &&
+		    lap->subdevice == pdev->subsystem_device)
+			return 1;
+		lap++;
+	}
+
+	return 0;
+}
+
 /**
  *	ich_pata_cable_detect - Probe host controller cable detect info
  *	@ap: Port for which cable detect info is desired

@@ -626,18 +641,11 @@ static int ich_pata_cable_detect(struct
 {
 	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
 	struct piix_host_priv *hpriv = ap->host->private_data;
-	const struct ich_laptop *lap = &ich_laptop[0];
 	u8 mask;
 
-	/* Check for specials - Acer Aspire 5602WLMi */
-	while (lap->device) {
-		if (lap->device == pdev->device &&
-		    lap->subvendor == pdev->subsystem_vendor &&
-		    lap->subdevice == pdev->subsystem_device)
-			return ATA_CBL_PATA40_SHORT;
-
-		lap++;
-	}
+	/* check for specials */
+	if (ich_short_ata40(pdev))
+		return ATA_CBL_PATA40_SHORT;
 
 	/* check BIOS cable detect results */
 	mask = ap->port_no == 0 ? PIIX_80C_PRI : PIIX_80C_SEC;

Index: b/drivers/ata/ata_piix.c
===================================================================
@@ -581,50 +581,7 @@ MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, piix_pci_tbl);
 MODULE_VERSION(DRV_VERSION);
 
-struct ich_laptop {
-	u16 device;
-	u16 subvendor;
-	u16 subdevice;
-};
-
-/*
- *	List of laptops that use short cables rather than 80 wire
- */
-
-static const struct ich_laptop ich_laptop[] = {
-	/* devid, subvendor, subdev */
-	{ 0x27DF, 0x0005, 0x0280 },	/* ICH7 on Acer 5602WLMi */
-	{ 0x27DF, 0x1025, 0x0102 },	/* ICH7 on Acer 5602aWLMi */
-	{ 0x27DF, 0x1025, 0x0110 },	/* ICH7 on Acer 3682WLMi */
-	{ 0x27DF, 0x1028, 0x02b0 },	/* ICH7 on unknown Dell */
-	{ 0x27DF, 0x1043, 0x1267 },	/* ICH7 on Asus W5F */
-	{ 0x27DF, 0x103C, 0x30A1 },	/* ICH7 on HP Compaq nc2400 */
-	{ 0x27DF, 0x103C, 0x361a },	/* ICH7 on unkown HP  */
-	{ 0x27DF, 0x1071, 0xD221 },	/* ICH7 on Hercules EC-900 */
-	{ 0x27DF, 0x152D, 0x0778 },	/* ICH7 on unknown Intel */
-	{ 0x24CA, 0x1025, 0x0061 },	/* ICH4 on ACER Aspire 2023WLMi */
-	{ 0x24CA, 0x1025, 0x003d },	/* ICH4 on ACER TM290 */
-	{ 0x266F, 0x1025, 0x0066 },	/* ICH6 on ACER Aspire 1694WLMi */
-	{ 0x2653, 0x1043, 0x82D8 },	/* ICH6M on Asus Eee 701 */
-	{ 0x27df, 0x104d, 0x900e },	/* ICH7 on Sony TZ-90 */
-	/* end marker */
-	{ 0, }
-};
-
-static int ich_short_ata40(struct pci_dev *pdev)
-{
-	const struct ich_laptop *lap = &ich_laptop[0];
-
-	while (lap->device) {
-		if (lap->device == pdev->device &&
-		    lap->subvendor == pdev->subsystem_vendor &&
-		    lap->subdevice == pdev->subsystem_device)
-			return 1;
-		lap++;
-	}
-
-	return 0;
-}
+#include "ata_piix.h"
 
 /**
  *	ich_pata_cable_detect - Probe host controller cable detect info

45 lines not on this page · raw message

Index: b/drivers/ide/piix.c
===================================================================
@@ -241,51 +241,16 @@ static void ich_clear_irq(ide_drive_t *d
 	outb(dma_stat, hwif->dma_base + ATA_DMA_STATUS);
 }
 
-struct ich_laptop {
-	u16 device;
-	u16 subvendor;
-	u16 subdevice;
-};
-
-/*
- *	List of laptops that use short cables rather than 80 wire
- */
-
-static const struct ich_laptop ich_laptop[] = {
-	/* devid, subvendor, subdev */
-	{ 0x27DF, 0x1025, 0x0102 },	/* ICH7 on Acer 5602aWLMi */
-	{ 0x27DF, 0x0005, 0x0280 },	/* ICH7 on Acer 5602WLMi */
-	{ 0x27DF, 0x1025, 0x0110 },	/* ICH7 on Acer 3682WLMi */
-	{ 0x27DF, 0x1028, 0x02b0 },	/* ICH7 on unknown Dell */
-	{ 0x27DF, 0x1043, 0x1267 },	/* ICH7 on Asus W5F */
-	{ 0x27DF, 0x103C, 0x30A1 },	/* ICH7 on HP Compaq nc2400 */
-	{ 0x27DF, 0x103C, 0x361a },	/* ICH7 on unkown HP  */
-	{ 0x27DF, 0x1071, 0xD221 },	/* ICH7 on Hercules EC-900 */
-	{ 0x27DF, 0x152D, 0x0778 },	/* ICH7 on unknown Intel */
-	{ 0x24CA, 0x1025, 0x0061 },	/* ICH4 on Acer Aspire 2023WLMi */
-	{ 0x24CA, 0x1025, 0x003d },	/* ICH4 on ACER TM290 */
-	{ 0x266F, 0x1025, 0x0066 },	/* ICH6 on ACER Aspire 1694WLMi */
-	{ 0x2653, 0x1043, 0x82D8 },	/* ICH6M on Asus Eee 701 */
-	{ 0x27df, 0x104d, 0x900e },	/* ICH7 on Sony TZ-90 */
-	/* end marker */
-	{ 0, }
-};
+#include "../ata/ata_piix.h"
 
 static u8 piix_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
-	const struct ich_laptop *lap = &ich_laptop[0];
 	u8 reg54h = 0, mask = hwif->channel ? 0xc0 : 0x30;
 
 	/* check for specials */
-	while (lap->device) {
-		if (lap->device == pdev->device &&
-		    lap->subvendor == pdev->subsystem_vendor &&
-		    lap->subdevice == pdev->subsystem_device) {
-			return ATA_CBL_PATA40_SHORT;
-		}
-		lap++;
-	}
+	if (ich_short_ata40(pdev))
+		return ATA_CBL_PATA40_SHORT;
 
 	pci_read_config_byte(pdev, 0x54, &reg54h);
 

Index: b/drivers/ata/pata_ali.c
===================================================================
@@ -32,7 +32,6 @@
 #include <linux/delay.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
-#include <linux/dmi.h>
 
 #define DRV_NAME "pata_ali"
 #define DRV_VERSION "0.7.8"

@@ -43,41 +42,7 @@ MODULE_PARM_DESC(atapi_dma, "Enable ATAP
 
 static struct pci_dev *ali_isa_bridge;
 
-/*
- *	Cable special cases
- */
-
-static const struct dmi_system_id cable_dmi_table[] = {
-	{
-		.ident = "HP Pavilion N5430",
-		.matches = {
-			DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
-			DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
-		},
-	},
-	{
-		.ident = "Toshiba Satelite S1800-814",
-		.matches = {
-			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
-			DMI_MATCH(DMI_PRODUCT_NAME, "S1800-814"),
-		},
-	},
-	{ }
-};
-
-static int ali_cable_override(struct pci_dev *pdev)
-{
-	/* Fujitsu P2000 */
-	if (pdev->subsystem_vendor == 0x10CF && pdev->subsystem_device == 0x10AF)
-	   	return 1;
-	/* Mitac 8317 (Winbook-A) and relatives */
-	if (pdev->subsystem_vendor == 0x1071 && pdev->subsystem_device == 0x8317)
-		return 1;
-	/* Systems by DMI */
-	if (dmi_check_system(cable_dmi_table))
-		return 1;
-	return 0;
-}
+#include "pata_ali.h"
 
 /**
  *	ali_c2_cable_detect	-	cable detection

Index: b/drivers/ata/pata_ali.h
===================================================================
@@ -0,0 +1,40 @@
+
+#include <linux/dmi.h>
+
+/*
+ *	Cable special cases
+ */
+
+static const struct dmi_system_id cable_dmi_table[] = {
+	{
+		.ident = "HP Pavilion N5430",
+		.matches = {
+			DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
+			DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
+		},
+	},
+	{
+		.ident = "Toshiba Satellite S1800-814",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "S1800-814"),
+		},
+	},
+	{ }
+};
+
+static int ali_cable_override(struct pci_dev *pdev)
+{
+	/* Fujitsu P2000 */
+	if (pdev->subsystem_vendor == 0x10CF &&
+	    pdev->subsystem_device == 0x10AF)
+		return 1;
+	/* Mitac 8317 (Winbook-A) and relatives */
+	if (pdev->subsystem_vendor == 0x1071 &&
+	    pdev->subsystem_device == 0x8317)
+		return 1;
+	/* Systems by DMI */
+	if (dmi_check_system(cable_dmi_table))
+		return 1;
+	return 0;
+}

Index: b/drivers/ide/alim15x3.c
===================================================================
@@ -33,7 +33,6 @@
 #include <linux/pci.h>
 #include <linux/ide.h>
 #include <linux/init.h>
-#include <linux/dmi.h>
 
 #include <asm/io.h>
 

@@ -308,46 +307,7 @@ out:
 	return 0;
 }
 
-/*
- *	Cable special cases
- */
-
-static const struct dmi_system_id cable_dmi_table[] = {
-	{
-		.ident = "HP Pavilion N5430",
-		.matches = {
-			DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
-			DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
-		},
-	},
-	{
-		.ident = "Toshiba Satellite S1800-814",
-		.matches = {
-			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
-			DMI_MATCH(DMI_PRODUCT_NAME, "S1800-814"),
-		},
-	},
-	{ }
-};
-
-static int ali_cable_override(struct pci_dev *pdev)
-{
-	/* Fujitsu P2000 */
-	if (pdev->subsystem_vendor == 0x10CF &&
-	    pdev->subsystem_device == 0x10AF)
-		return 1;
-
-	/* Mitac 8317 (Winbook-A) and relatives */
-	if (pdev->subsystem_vendor == 0x1071 &&
-	    pdev->subsystem_device == 0x8317)
-		return 1;
-
-	/* Systems by DMI */
-	if (dmi_check_system(cable_dmi_table))
-		return 1;
-
-	return 0;
-}
+#include "../ata/pata_ali.h"
 
 /**
  *	ali_cable_detect	-	cable detection

Index: b/drivers/ata/pata_sis.c
===================================================================
@@ -45,35 +45,7 @@ struct sis_chipset {
 	   up code later */
 };
 
-struct sis_laptop {
-	u16 device;
-	u16 subvendor;
-	u16 subdevice;
-};
-
-static const struct sis_laptop sis_laptop[] = {
-	/* devid, subvendor, subdev */
-	{ 0x5513, 0x1043, 0x1107 },	/* ASUS A6K */
-	{ 0x5513, 0x1734, 0x105F },	/* FSC Amilo A1630 */
-	{ 0x5513, 0x1071, 0x8640 },     /* EasyNote K5305 */
-	/* end marker */
-	{ 0, }
-};
-
-static int sis_short_ata40(struct pci_dev *dev)
-{
-	const struct sis_laptop *lap = &sis_laptop[0];
-
-	while (lap->device) {
-		if (lap->device == dev->device &&
-		    lap->subvendor == dev->subsystem_vendor &&
-		    lap->subdevice == dev->subsystem_device)
-			return 1;
-		lap++;
-	}
-
-	return 0;
-}
+#include "pata_sis.h"
 
 /**
  *	sis_old_port_base		-	return PCI configuration base for dev

Index: b/drivers/ata/pata_sis.h
===================================================================
@@ -0,0 +1,30 @@
+
+struct sis_laptop {
+	u16 device;
+	u16 subvendor;
+	u16 subdevice;
+};
+
+static const struct sis_laptop sis_laptop[] = {
+	/* devid, subvendor, subdev */
+	{ 0x5513, 0x1043, 0x1107 },	/* ASUS A6K */
+	{ 0x5513, 0x1734, 0x105F },	/* FSC Amilo A1630 */
+	{ 0x5513, 0x1071, 0x8640 },     /* EasyNote K5305 */
+	/* end marker */
+	{ 0, }
+};
+
+static int sis_short_ata40(struct pci_dev *dev)
+{
+	const struct sis_laptop *lap = &sis_laptop[0];
+
+	while (lap->device) {
+		if (lap->device == dev->device &&
+		    lap->subvendor == dev->subsystem_vendor &&
+		    lap->subdevice == dev->subsystem_device)
+			return 1;
+		lap++;
+	}
+
+	return 0;
+}

Index: b/drivers/ide/sis5513.c
===================================================================
@@ -506,34 +506,15 @@ static int init_chipset_sis5513(struct p
 	return 0;
 }
 
-struct sis_laptop {
-	u16 device;
-	u16 subvendor;
-	u16 subdevice;
-};
-
-static const struct sis_laptop sis_laptop[] = {
-	/* devid, subvendor, subdev */
-	{ 0x5513, 0x1043, 0x1107 },	/* ASUS A6K */
-	{ 0x5513, 0x1734, 0x105f },	/* FSC Amilo A1630 */
-	{ 0x5513, 0x1071, 0x8640 },     /* EasyNote K5305 */
-	/* end marker */
-	{ 0, }
-};
+#include "../ata/pata_sis.h"
 
 static u8 sis_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
-	const struct sis_laptop *lap = &sis_laptop[0];
 	u8 ata66 = 0;
 
-	while (lap->device) {
-		if (lap->device == pdev->device &&
-		    lap->subvendor == pdev->subsystem_vendor &&
-		    lap->subdevice == pdev->subsystem_device)
-			return ATA_CBL_PATA40_SHORT;
-		lap++;
-	}
+	if (sis_short_ata40(pdev))
+		return ATA_CBL_PATA40_SHORT;
 
 	if (chipset_family >= ATA_133) {
 		u16 regw = 0;

Index: b/drivers/ata/pata_via.c
===================================================================
@@ -60,7 +60,6 @@
 #include <linux/delay.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
-#include <linux/dmi.h>
 
 #define DRV_NAME "pata_via"
 #define DRV_VERSION "0.3.4"

@@ -127,32 +126,7 @@ struct via_port {
 	u8 cached_device;
 };
 
-/*
- *	Cable special cases
- */
-
-static const struct dmi_system_id cable_dmi_table[] = {
-	{
-		.ident = "Acer Ferrari 3400",
-		.matches = {
-			DMI_MATCH(DMI_BOARD_VENDOR, "Acer,Inc."),
-			DMI_MATCH(DMI_BOARD_NAME, "Ferrari 3400"),
-		},
-	},
-	{ }
-};
-
-static int via_cable_override(struct pci_dev *pdev)
-{
-	/* Systems by DMI */
-	if (dmi_check_system(cable_dmi_table))
-		return 1;
-	/* Arima W730-K8/Targa Visionary 811/... */
-	if (pdev->subsystem_vendor == 0x161F && pdev->subsystem_device == 0x2032)
-		return 1;
-	return 0;
-}
-
+#include "pata_via.h"
 
 /**
  *	via_cable_detect	-	cable detection

Index: b/drivers/ata/pata_via.h
===================================================================
@@ -0,0 +1,29 @@
+
+#include <linux/dmi.h>
+
+/*
+ *	Cable special cases
+ */
+
+static const struct dmi_system_id cable_dmi_table[] = {
+	{
+		.ident = "Acer Ferrari 3400",
+		.matches = {
+			DMI_MATCH(DMI_BOARD_VENDOR, "Acer,Inc."),
+			DMI_MATCH(DMI_BOARD_NAME, "Ferrari 3400"),
+		},
+	},
+	{ }
+};
+
+static int via_cable_override(struct pci_dev *pdev)
+{
+	/* Systems by DMI */
+	if (dmi_check_system(cable_dmi_table))
+		return 1;
+	/* Arima W730-K8/Targa Visionary 811/... */
+	if (pdev->subsystem_vendor == 0x161F &&
+	    pdev->subsystem_device == 0x2032)
+		return 1;
+	return 0;
+}

Index: b/drivers/ide/via82cxxx.c
===================================================================
@@ -29,7 +29,6 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/ide.h>
-#include <linux/dmi.h>
 
 #ifdef CONFIG_PPC_CHRP
 #include <asm/processor.h>

@@ -351,34 +350,7 @@ static int init_chipset_via82cxxx(struct
 	return 0;
 }
 
-/*
- *	Cable special cases
- */
-
-static const struct dmi_system_id cable_dmi_table[] = {
-	{
-		.ident = "Acer Ferrari 3400",
-		.matches = {
-			DMI_MATCH(DMI_BOARD_VENDOR, "Acer,Inc."),
-			DMI_MATCH(DMI_BOARD_NAME, "Ferrari 3400"),
-		},
-	},
-	{ }
-};
-
-static int via_cable_override(struct pci_dev *pdev)
-{
-	/* Systems by DMI */
-	if (dmi_check_system(cable_dmi_table))
-		return 1;
-
-	/* Arima W730-K8/Targa Visionary 811/... */
-	if (pdev->subsystem_vendor == 0x161F &&
-	    pdev->subsystem_device == 0x2032)
-		return 1;
-
-	return 0;
-}
+#include "../ata/pata_via.h"
 
 static u8 via82cxxx_cable_detect(ide_hwif_t *hwif)
 {

Index: b/drivers/ide/cy82c693.c
===================================================================
@@ -179,7 +179,7 @@ static int __devinit cy82c693_init_one(s
 static void __devexit cy82c693_remove(struct pci_dev *dev)
 {
 	struct ide_host *host = pci_get_drvdata(dev);
-	struct pci_dev *dev2 = host->dev[1] ? to_pci_dev(host->dev[1]) : NULL;
+	struct pci_dev *dev2 = host->dev2 ? to_pci_dev(host->dev2) : NULL;
 
 	ide_pci_remove(dev);
 	pci_dev_put(dev2);

Index: b/drivers/ide/hpt366.c
===================================================================
@@ -610,7 +610,7 @@ static struct hpt_info *hpt3xx_get_info(
 	struct ide_host *host	= dev_get_drvdata(dev);
 	struct hpt_info *info	= (struct hpt_info *)host->host_priv;
 
-	return dev == host->dev[1] ? info + 1 : info;
+	return dev == host->dev2 ? info + 1 : info;
 }
 
 /*

@@ -943,7 +943,7 @@ static int hpt37x_calibrate_dpll(struct
 static void hpt3xx_disable_fast_irq(struct pci_dev *dev, u8 mcr_addr)
 {
 	struct ide_host *host	= pci_get_drvdata(dev);
-	struct hpt_info *info	= host->host_priv + (&dev->dev == host->dev[1]);
+	struct hpt_info *info	= host->host_priv + (&dev->dev == host->dev2);
 	u8  chip_type		= info->chip_type;
 	u8  new_mcr, old_mcr	= 0;
 

@@ -1567,7 +1567,7 @@ static void __devexit hpt366_remove(stru
 {
 	struct ide_host *host = pci_get_drvdata(dev);
 	struct ide_info *info = host->host_priv;
-	struct pci_dev *dev2 = host->dev[1] ? to_pci_dev(host->dev[1]) : NULL;
+	struct pci_dev *dev2 = host->dev2 ? to_pci_dev(host->dev2) : NULL;
 
 	ide_pci_remove(dev);
 	pci_dev_put(dev2);

Index: b/drivers/ide/ide-probe.c
===================================================================
@@ -1334,7 +1334,7 @@ struct ide_host *ide_host_alloc(const st
 		return NULL;
 	}
 
-	host->dev[0] = dev;
+	host->dev = dev;
 
 	if (d) {
 		host->init_chipset = d->init_chipset;

Index: b/drivers/ide/ide.c
===================================================================
@@ -77,7 +77,7 @@ int ide_device_get(ide_drive_t *drive)
 	if (!get_device(&drive->gendev))
 		return -ENXIO;
 
-	host_dev = drive->hwif->host->dev[0];
+	host_dev = drive->hwif->host->dev;
 	module = host_dev ? host_dev->driver->owner : NULL;
 
 	if (module && !try_module_get(module)) {

@@ -99,7 +99,7 @@ EXPORT_SYMBOL_GPL(ide_device_get);
 void ide_device_put(ide_drive_t *drive)
 {
 #ifdef CONFIG_MODULE_UNLOAD
-	struct device *host_dev = drive->hwif->host->dev[0];
+	struct device *host_dev = drive->hwif->host->dev;
 	struct module *module = host_dev ? host_dev->driver->owner : NULL;
 
 	if (module)

Index: b/drivers/ide/pdc202xx_new.c
===================================================================
@@ -517,7 +517,7 @@ static int __devinit pdc202new_init_one(
 static void __devexit pdc202new_remove(struct pci_dev *dev)
 {
 	struct ide_host *host = pci_get_drvdata(dev);
-	struct pci_dev *dev2 = host->dev[1] ? to_pci_dev(host->dev[1]) : NULL;
+	struct pci_dev *dev2 = host->dev2 ? to_pci_dev(host->dev2) : NULL;
 
 	ide_pci_remove(dev);
 	pci_dev_put(dev2);

Index: b/drivers/ide/setup-pci.c
===================================================================
@@ -556,9 +556,9 @@ int ide_pci_init_two(struct pci_dev *dev
 		goto out;
 	}
 
-	host->dev[0] = &dev1->dev;
+	host->dev = &dev1->dev;
 	if (dev2)
-		host->dev[1] = &dev2->dev;
+		host->dev2 = &dev2->dev;
 
 	host->host_priv = priv;
 	host->irq_flags = IRQF_SHARED;

@@ -603,7 +603,7 @@ EXPORT_SYMBOL_GPL(ide_pci_init_one);
 void ide_pci_remove(struct pci_dev *dev)
 {
 	struct ide_host *host = pci_get_drvdata(dev);
-	struct pci_dev *dev2 = host->dev[1] ? to_pci_dev(host->dev[1]) : NULL;
+	struct pci_dev *dev2 = host->dev2 ? to_pci_dev(host->dev2) : NULL;
 	int bars;
 
 	if (host->host_flags & IDE_HFLAG_SINGLE)

Index: b/include/linux/ide.h
===================================================================
@@ -775,7 +775,7 @@ typedef struct hwif_s {
 struct ide_host {
 	ide_hwif_t	*ports[MAX_HOST_PORTS + 1];
 	unsigned int	n_ports;
-	struct device	*dev[2];
+	struct device	*dev, *dev2;
 
 	int		(*init_chipset)(struct pci_dev *);
 

Index: b/include/linux/ide.h
===================================================================
@@ -682,7 +682,12 @@ typedef struct hwif_s {
 
 	u8 major;	/* our major number */
 	u8 index;	/* 0 for ide0; 1 for ide1; ... */
-	u8 channel;	/* for dual-port chips: 0=primary, 1=secondary */
+
+	union {
+		/* for dual-port chips: 0=primary, 1=secondary */
+		u8 channel;
+		u8 port_no;
+	};
 
 	u32 host_flags;
 

Index: b/include/linux/ide.h
===================================================================
@@ -693,7 +693,10 @@ typedef struct hwif_s {
 
 	u8 pio_mask;
 
-	u8 ultra_mask;
+	union {
+		u8 ultra_mask;
+		u8 udma_mask;
+	};
 	u8 mwdma_mask;
 	u8 swdma_mask;
 

Index: b/include/linux/ide.h
===================================================================
@@ -747,7 +747,11 @@ typedef struct hwif_s {
 
 	struct completion gendev_rel_comp; /* To deal with device release() */
 
-	void		*hwif_data;	/* extra hwif data */
+	/* extra port data */
+	union {
+		void	*hwif_data;
+		void	*private_data;
+	};
 
 #ifdef CONFIG_BLK_DEV_IDEACPI
 	struct ide_acpi_hwif_link *acpidata;

Index: b/drivers/ide/ide-probe.c
===================================================================
@@ -1033,6 +1033,7 @@ static void ide_port_init_devices(ide_hw
 
 	ide_port_for_each_dev(i, drive, hwif) {
 		drive->dn = i + hwif->channel * 2;
+		drive->devno = i;
 
 		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
 			drive->io_32bit = 1;

Index: b/include/linux/ide.h
===================================================================
@@ -518,6 +518,7 @@ struct ide_drive_s {
 	u8	pio_mode;	/* for ->set_pio_mode _only_ */
 	u8	dma_mode;	/* for ->dma_pio_mode _only_ */
         u8	dn;		/* now wide spread use */
+	u8	devno;		/* 0 or 1 */
 	u8	acoustic;	/* acoustic management */
 	u8	media;		/* disk, cdrom, tape, floppy, ... */
 	u8	ready_stat;	/* min status value for drive ready */

Index: b/include/linux/ide.h
===================================================================
@@ -520,7 +520,13 @@ struct ide_drive_s {
         u8	dn;		/* now wide spread use */
 	u8	devno;		/* 0 or 1 */
 	u8	acoustic;	/* acoustic management */
-	u8	media;		/* disk, cdrom, tape, floppy, ... */
+
+	/* disk, cdrom, tape, floppy, ... */
+	union {
+		u8	media;
+		u8	class;
+	};
+
 	u8	ready_stat;	/* min status value for drive ready */
 	u8	mult_count;	/* current multiple sector setting */
 	u8	mult_req;	/* requested multiple sector setting */

Index: b/drivers/ide/aec62xx.c
===================================================================
@@ -160,7 +160,7 @@ static int init_chipset_aec62xx(struct p
 	return 0;
 }
 
-static u8 atp86x_cable_detect(ide_hwif_t *hwif)
+static int atp86x_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	u8 ata66 = 0, mask = hwif->channel ? 0x02 : 0x01;

Index: b/drivers/ide/alim15x3.c
===================================================================
@@ -317,7 +317,7 @@ out:
  *	of UDMA66 transfers. It doesn't check the drives.
  */
 
-static u8 ali_cable_detect(ide_hwif_t *hwif)
+static int ali_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	u8 cbl = ATA_CBL_PATA40, tmpbyte;

Index: b/drivers/ide/amd74xx.c
===================================================================
@@ -178,7 +178,7 @@ static int init_chipset_amd74xx(struct p
 	return 0;
 }
 
-static u8 amd_cable_detect(ide_hwif_t *hwif)
+static int amd_cable_detect(ide_hwif_t *hwif)
 {
 	if ((amd_80w >> hwif->channel) & 1)
 		return ATA_CBL_PATA80;

Index: b/drivers/ide/atiixp.c
===================================================================
@@ -120,7 +120,7 @@ static void atiixp_set_dma_mode(ide_hwif
 	spin_unlock_irqrestore(&atiixp_lock, flags);
 }
 
-static u8 atiixp_cable_detect(ide_hwif_t *hwif)
+static int atiixp_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
 	u8 udma_mode = 0, ch = hwif->channel;

Index: b/drivers/ide/cmd64x.c
===================================================================
@@ -312,7 +312,7 @@ static int init_chipset_cmd64x(struct pc
 	return 0;
 }
 
-static u8 cmd64x_cable_detect(ide_hwif_t *hwif)
+static int cmd64x_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev  *dev	= to_pci_dev(hwif->dev);
 	u8 bmidecsr = 0, mask	= hwif->channel ? 0x02 : 0x01;

Index: b/drivers/ide/cs5535.c
===================================================================
@@ -153,7 +153,7 @@ static void cs5535_set_pio_mode(ide_hwif
 	cs5535_set_speed(drive, drive->pio_mode);
 }
 
-static u8 cs5535_cable_detect(ide_hwif_t *hwif)
+static int cs5535_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	u8 bit;

Index: b/drivers/ide/cs5536.c
===================================================================
@@ -110,7 +110,7 @@ static void cs5536_program_dtc(ide_drive
  *	Returns a cable type.
  */
 
-static u8 cs5536_cable_detect(ide_hwif_t *hwif)
+static int cs5536_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
 	u32 cfg;

Index: b/drivers/ide/hpt366.c
===================================================================
@@ -1215,7 +1215,7 @@ static int init_chipset_hpt366(struct pc
 	return 0;
 }
 
-static u8 hpt3xx_cable_detect(ide_hwif_t *hwif)
+static int hpt3xx_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev	*dev	= to_pci_dev(hwif->dev);
 	struct hpt_info *info	= hpt3xx_get_info(hwif->dev);

Index: b/drivers/ide/it8213.c
===================================================================
@@ -140,7 +140,7 @@ static void it8213_set_dma_mode(ide_hwif
 	}
 }
 
-static u8 it8213_cable_detect(ide_hwif_t *hwif)
+static int it8213_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	u8 reg42h = 0;

Index: b/drivers/ide/it821x.c
===================================================================
@@ -423,7 +423,7 @@ static void it821x_set_dma_mode(ide_hwif
  *	the needed logic onboard.
  */
 
-static u8 it821x_cable_detect(ide_hwif_t *hwif)
+static int it821x_cable_detect(ide_hwif_t *hwif)
 {
 	/* The reference driver also only does disk side */
 	return ATA_CBL_PATA80;

Index: b/drivers/ide/jmicron.c
===================================================================
@@ -26,7 +26,7 @@ typedef enum {
  *	Returns the cable type.
  */
 
-static u8 jmicron_cable_detect(ide_hwif_t *hwif)
+static int jmicron_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
 

Index: b/drivers/ide/palm_bk3710.c
===================================================================
@@ -274,7 +274,7 @@ static void __devinit palm_bk3710_chipin
 	palm_bk3710_setpiomode(base, NULL, 1, 600, 0);
 }
 
-static u8 palm_bk3710_cable_detect(ide_hwif_t *hwif)
+static int palm_bk3710_cable_detect(ide_hwif_t *hwif)
 {
 	return ATA_CBL_PATA80;
 }

Index: b/drivers/ide/pdc202xx_new.c
===================================================================
@@ -180,7 +180,7 @@ static void pdcnew_set_pio_mode(ide_hwif
 	}
 }
 
-static u8 pdcnew_cable_detect(ide_hwif_t *hwif)
+static int pdcnew_cable_detect(ide_hwif_t *hwif)
 {
 	if (get_indexed_reg(hwif, 0x0b) & 0x04)
 		return ATA_CBL_PATA40;

Index: b/drivers/ide/pdc202xx_old.c
===================================================================
@@ -103,7 +103,7 @@ static int pdc202xx_test_irq(ide_hwif_t
 	}
 }
 
-static u8 pdc2026x_cable_detect(ide_hwif_t *hwif)
+static int pdc2026x_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	u16 CIS, mask = hwif->channel ? (1 << 11) : (1 << 10);

Index: b/drivers/ide/piix.c
===================================================================
@@ -243,7 +243,7 @@ static void ich_clear_irq(ide_drive_t *d
 
 #include "../ata/ata_piix.h"
 
-static u8 piix_cable_detect(ide_hwif_t *hwif)
+static int piix_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
 	u8 reg54h = 0, mask = hwif->channel ? 0xc0 : 0x30;

Index: b/drivers/ide/pmac.c
===================================================================
@@ -912,7 +912,7 @@ static int pmac_ide_do_resume(pmac_ide_h
 	return 0;
 }
 
-static u8 pmac_ide_cable_detect(ide_hwif_t *hwif)
+static int pmac_ide_cable_detect(ide_hwif_t *hwif)
 {
 	pmac_ide_hwif_t *pmif =
 		(pmac_ide_hwif_t *)dev_get_drvdata(hwif->gendev.parent);

Index: b/drivers/ide/scc_pata.c
===================================================================
@@ -754,7 +754,7 @@ static int __devinit scc_init_dma(ide_hw
 	return ide_allocate_dma_engine(hwif);
 }
 
-static u8 scc_cable_detect(ide_hwif_t *hwif)
+static int scc_cable_detect(ide_hwif_t *hwif)
 {
 	return ATA_CBL_PATA80;
 }

Index: b/drivers/ide/serverworks.c
===================================================================
@@ -301,7 +301,7 @@ static u8 ata66_svwks_cobalt(ide_hwif_t
 	return ATA_CBL_PATA40;
 }
 
-static u8 svwks_cable_detect(ide_hwif_t *hwif)
+static int svwks_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 

Index: b/drivers/ide/siimage.c
===================================================================
@@ -667,7 +667,7 @@ static void __devinit init_iops_siimage(
  *	Check for the presence of an ATA66 capable cable on the interface.
  */
 
-static u8 sil_cable_detect(ide_hwif_t *hwif)
+static int sil_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev	= to_pci_dev(hwif->dev);
 	unsigned long addr	= siimage_selreg(hwif, 0);

Index: b/drivers/ide/sis5513.c
===================================================================
@@ -508,7 +508,7 @@ static int init_chipset_sis5513(struct p
 
 #include "../ata/pata_sis.h"
 
-static u8 sis_cable_detect(ide_hwif_t *hwif)
+static int sis_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
 	u8 ata66 = 0;

Index: b/drivers/ide/slc90e66.c
===================================================================
@@ -115,7 +115,7 @@ static void slc90e66_set_dma_mode(ide_hw
 	}
 }
 
-static u8 slc90e66_cable_detect(ide_hwif_t *hwif)
+static int slc90e66_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	u8 reg47 = 0, mask = hwif->channel ? 0x01 : 0x02;

Index: b/drivers/ide/tc86c001.c
===================================================================
@@ -130,7 +130,7 @@ static void tc86c001_dma_start(ide_drive
 	ide_dma_start(drive);
 }
 
-static u8 tc86c001_cable_detect(ide_hwif_t *hwif)
+static int tc86c001_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *dev = to_pci_dev(hwif->dev);
 	unsigned long sc_base = pci_resource_start(dev, 5);

Index: b/drivers/ide/tx4939ide.c
===================================================================
@@ -189,7 +189,7 @@ static void tx4939ide_clear_irq(ide_driv
 	tx4939ide_writew(ctl, base, TX4939IDE_Int_Ctl);
 }
 
-static u8 tx4939ide_cable_detect(ide_hwif_t *hwif)
+static int tx4939ide_cable_detect(ide_hwif_t *hwif)
 {
 	void __iomem *base = TX4939IDE_BASE(hwif);
 

Index: b/drivers/ide/via82cxxx.c
===================================================================
@@ -352,7 +352,7 @@ static int init_chipset_via82cxxx(struct
 
 #include "../ata/pata_via.h"
 
-static u8 via82cxxx_cable_detect(ide_hwif_t *hwif)
+static int via82cxxx_cable_detect(ide_hwif_t *hwif)
 {
 	struct pci_dev *pdev = to_pci_dev(hwif->dev);
 	struct ide_host *host = pci_get_drvdata(pdev);

Index: b/include/linux/ide.h
===================================================================
@@ -644,7 +644,7 @@ struct ide_port_ops {
 	u8	(*mdma_filter)(ide_drive_t *);
 	u8	(*udma_filter)(ide_drive_t *);
 
-	u8	(*cable_detect)(struct hwif_s *);
+	int	(*cable_detect)(struct hwif_s *);
 };
 
 struct ide_dma_ops {

Index: b/drivers/ide/it8213.c
===================================================================
@@ -55,15 +55,13 @@ static void it8213_set_pio_mode(ide_hwif
 	if (is_slave) {
 		master_data |=  0x4000;
 		master_data &= ~0x0070;
-		if (pio > 1)
-			master_data = master_data | (control << 4);
+		master_data = master_data | (control << 4);
 		pci_read_config_byte(dev, slave_port, &slave_data);
 		slave_data = slave_data & 0xf0;
 		slave_data = slave_data | (timings[pio][0] << 2) | timings[pio][1];
 	} else {
 		master_data &= ~0x3307;
-		if (pio > 1)
-			master_data = master_data | control;
+		master_data = master_data | control;
 		master_data = master_data | (timings[pio][0] << 12) | (timings[pio][1] << 8);
 	}
 	pci_write_config_word(dev, master_port, master_data);

Index: b/drivers/ide/piix.c
===================================================================
@@ -103,20 +103,16 @@ static void piix_set_pio_mode(ide_hwif_t
 	if (is_slave) {
 		master_data |=  0x4000;
 		master_data &= ~0x0070;
-		if (pio > 1) {
-			/* Set PPE, IE and TIME */
-			master_data |= control << 4;
-		}
+		/* Set PPE, IE and TIME */
+		master_data |= control << 4;
 		pci_read_config_byte(dev, slave_port, &slave_data);
 		slave_data &= hwif->channel ? 0x0f : 0xf0;
 		slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) <<
 			       (hwif->channel ? 4 : 0);
 	} else {
 		master_data &= ~0x3307;
-		if (pio > 1) {
-			/* enable PPE, IE and TIME */
-			master_data |= control;
-		}
+		/* enable PPE, IE and TIME */
+		master_data |= control;
 		master_data |= (timings[pio][0] << 12) | (timings[pio][1] << 8);
 	}
 	pci_write_config_word(dev, master_port, master_data);

Index: b/drivers/ide/slc90e66.c
===================================================================
@@ -50,20 +50,16 @@ static void slc90e66_set_pio_mode(ide_hw
 	if (is_slave) {
 		master_data |=  0x4000;
 		master_data &= ~0x0070;
-		if (pio > 1) {
-			/* Set PPE, IE and TIME */
-			master_data |= control << 4;
-		}
+		/* Set PPE, IE and TIME */
+		master_data |= control << 4;
 		pci_read_config_byte(dev, slave_port, &slave_data);
 		slave_data &= hwif->channel ? 0x0f : 0xf0;
 		slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) <<
 			       (hwif->channel ? 4 : 0);
 	} else {
 		master_data &= ~0x3307;
-		if (pio > 1) {
-			/* enable PPE, IE and TIME */
-			master_data |= control;
-		}
+		/* enable PPE, IE and TIME */
+		master_data |= control;
 		master_data |= (timings[pio][0] << 12) | (timings[pio][1] << 8);
 	}
 	pci_write_config_word(dev, master_port, master_data);

Index: b/include/linux/ide2libata.h
===================================================================
@@ -0,0 +1,17 @@
+#ifndef __IDE2LIBATA_H
+#define __IDE2LIBATA_H
+
+#include <linux/ide.h>
+
+#define __IDE2LIBATA		1
+
+#define ATA_DEV_ATA		ide_disk
+
+#define ata_host		ide_host
+#define ata_port		hwif_s
+#define ata_device		ide_drive_s
+
+#define ata_pio_need_iordy(d)	ide_pio_need_iordy(d, d->pio_mode - XFER_PIO_0)
+#define ata_dev_pair		ide_get_pair_dev
+
+#endif /* __IDE2LIBATA_H */

Index: b/drivers/ata/ata_piix.c
===================================================================
@@ -629,178 +629,6 @@ static int piix_pata_prereset(struct ata
 	return ata_sff_prereset(link, deadline);
 }
 
-static DEFINE_SPINLOCK(piix_lock);
-
-static void piix_set_timings(struct ata_port *ap, struct ata_device *adev,
-			     u8 pio, bool use_mwdma)
-{
-	struct pci_dev *dev	= to_pci_dev(ap->host->dev);
-	unsigned long flags;
-	unsigned int is_slave	= (adev->devno != 0);
-	unsigned int master_port= ap->port_no ? 0x42 : 0x40;
-	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 },
-			    { 0, 0 },
-			    { 1, 0 },
-			    { 2, 1 },
-			    { 2, 3 }, };
-
-	if (pio >= 2 || use_mwdma)
-		control |= 1;	/* TIME1 enable */
-	if (ata_pio_need_iordy(adev) || use_mwdma)
-		control |= 2;	/* IE enable */
-	/* 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 (use_mwdma && adev->pio_mode < (XFER_PIO_0 + pio))
-		/* Enable DMA timing only */
-		control |= 8;	/* PIO cycles in PIO0 */
-
-	spin_lock_irqsave(&piix_lock, flags);
-
-	/* PIO configuration clears DTE unconditionally.  It will be
-	 * programmed in set_dmamode which is guaranteed to be called
-	 * after set_piomode if any DMA mode is available.
-	 */
-	pci_read_config_word(dev, master_port, &master_data);
-	if (is_slave) {
-		/* clear TIME1|IE1|PPE1|DTE1 */
-		master_data &= 0xff0f;
-		/* Enable SITRE (separate slave timing register) */
-		master_data |= 0x4000;
-		/* enable PPE1, IE1 and TIME1 as needed */
-		master_data |= (control << 4);
-		pci_read_config_byte(dev, slave_port, &slave_data);
-		slave_data &= (ap->port_no ? 0x0f : 0xf0);
-		/* Load the timing nibble for this slave */
-		slave_data |= ((timings[pio][0] << 2) | timings[pio][1])
-						<< (ap->port_no ? 4 : 0);
-	} else {
-		/* clear ISP|RCT|TIME0|IE0|PPE0|DTE0 */
-		master_data &= 0xccf0;
-		/* Enable PPE, IE and TIME as appropriate */
-		master_data |= control;
-		/* load ISP and RCT */
-		master_data |=
-			(timings[pio][0] << 12) |
-			(timings[pio][1] << 8);
-	}
-	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->port_no + adev->devno));
-		pci_write_config_byte(dev, 0x48, udma_enable);
-	}
-
-	spin_unlock_irqrestore(&piix_lock, flags);
-}
-
-/**
- *	piix_set_piomode - Initialize host controller PATA PIO timings
- *	@ap: Port whose timings we are configuring
- *	@adev: Drive in question
- *
- *	Set PIO mode for device, in host controller PCI config space.
- *
- *	LOCKING:
- *	None (inherited from caller).
- */
-
-static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev)
-{
-	piix_set_timings(ap, adev, adev->pio_mode - XFER_PIO_0, 0);
-}
-
-/**
- *	do_pata_set_dmamode - Initialize host controller PATA PIO timings
- *	@ap: Port whose timings we are configuring
- *	@adev: Drive in question
- *	@isich: set if the chip is an ICH device
- *
- *	Set UDMA mode for device, in host controller PCI config space.
- *
- *	LOCKING:
- *	None (inherited from caller).
- */
-
-static void do_pata_set_dmamode(struct ata_port *ap, struct ata_device *adev, int isich)
-{
-	struct pci_dev *dev	= to_pci_dev(ap->host->dev);
-	unsigned long flags;
-	u8 speed		= adev->dma_mode;
-	int devid		= adev->devno + 2 * ap->port_no;
-	u8 udma_enable		= 0;
-
-	if (speed >= XFER_UDMA_0) {
-		unsigned int udma = speed - XFER_UDMA_0;
-		u16 udma_timing;
-		u16 ideconf;
-		int u_clock, u_speed;
-
-		spin_lock_irqsave(&piix_lock, flags);
-
-		pci_read_config_byte(dev, 0x48, &udma_enable);
-
-		/*
-		 * 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);
-		}
-
-		pci_write_config_byte(dev, 0x48, udma_enable);
-
-		spin_unlock_irqrestore(&piix_lock, flags);
-	} else
-		/* MWDMA is driven by the PIO timings. */
-		piix_set_timings(ap, adev, ata_mwdma_to_pio(speed), 1);
-}
-
 /**
  *	piix_set_dmamode - Initialize host controller PATA DMA timings
  *	@ap: Port whose timings we are configuring