pata_ali.c 17.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * pata_ali.c 	- ALI 15x3 PATA for new ATA layer
 *			  (C) 2005 Red Hat Inc
 *
 * 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/CHECK
 *	Cannot have ATAPI on both master & slave for rev < c2 (???) but
22 23 24
 *	otherwise should do atapi DMA (For now for old we do PIO only for
 *	ATAPI)
 *	Review Sunblade workaround.
25 26 27 28 29 30 31 32 33 34 35 36 37
 */

#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 <linux/dmi.h>

#define DRV_NAME "pata_ali"
38
#define DRV_VERSION "0.7.8"
39

40
static int ali_atapi_dma = 0;
Tejun Heo's avatar
Tejun Heo committed
41 42 43
module_param_named(atapi_dma, ali_atapi_dma, int, 0644);
MODULE_PARM_DESC(atapi_dma, "Enable ATAPI DMA (0=disable, 1=enable)");

44
static struct pci_dev *ali_isa_bridge;
45

46 47 48 49
/*
 *	Cable special cases
 */

50
static const struct dmi_system_id cable_dmi_table[] = {
51 52 53 54
	{
		.ident = "HP Pavilion N5430",
		.matches = {
			DMI_MATCH(DMI_BOARD_VENDOR, "Hewlett-Packard"),
Alan Cox's avatar
Alan Cox committed
55
			DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
56 57
		},
	},
58
	{
59
		.ident = "Toshiba Satellite S1800-814",
60 61 62 63 64
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
			DMI_MATCH(DMI_PRODUCT_NAME, "S1800-814"),
		},
	},
65 66 67 68 69 70 71 72
	{ }
};

static int ali_cable_override(struct pci_dev *pdev)
{
	/* Fujitsu P2000 */
	if (pdev->subsystem_vendor == 0x10CF && pdev->subsystem_device == 0x10AF)
	   	return 1;
73
	/* Mitac 8317 (Winbook-A) and relatives */
Jeff Garzik's avatar
Jeff Garzik committed
74
	if (pdev->subsystem_vendor == 0x1071 && pdev->subsystem_device == 0x8317)
75
		return 1;
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
	/* Systems by DMI */
	if (dmi_check_system(cable_dmi_table))
		return 1;
	return 0;
}

/**
 *	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->dev);
	u8 ata66;

	/* Certain laptops use short but suitable cables and don't
	   implement the detect logic */

	if (ali_cable_override(pdev))
98
		return ATA_CBL_PATA40_SHORT;
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

	/* 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->port_no))
		return ATA_CBL_PATA40;
	else
		return ATA_CBL_PATA80;
}

/**
 *	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
 */

118
static unsigned long ali_20_filter(struct ata_device *adev, unsigned long mask)
119
{
120
	char model_num[ATA_ID_PROD_LEN + 1];
121 122 123
	/* No DMA on anything but a disk for now */
	if (adev->class != ATA_DEV_ATA)
		mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
124
	ata_id_c_string(adev->id, model_num, ATA_ID_PROD, sizeof(model_num));
125 126
	if (strstr(model_num, "WDC"))
		return mask &= ~ATA_MASK_UDMA;
127
	return mask;
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
}

/**
 *	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->dev);
	int pio_fifo = 0x54 + ap->port_no;
	u8 fifo;
	int shift = 4 * adev->devno;

	/* ATA - FIFO on set nibble to 0x05, ATAPI - FIFO off, set nibble to
	   0x00. Not all the docs agree but the behaviour we now use is the
	   one stated in the BIOS Programming Guide */
151

152 153
	pci_read_config_byte(pdev, pio_fifo, &fifo);
	fifo &= ~(0x0F << shift);
Alan Cox's avatar
Alan Cox committed
154
	fifo |= (on << shift);
155 156 157 158 159 160 161
	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
162
 *	@t: timing data
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
 *	@ultra: UDMA timing or zero for off
 *
 *	Loads the timing registers for cmd/data and disable UDMA if
 *	ultra is zero. If ultra 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, struct ata_timing *t, u8 ultra)
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	int cas = 0x58 + 4 * ap->port_no;	/* Command timing */
	int cbt = 0x59 + 4 * ap->port_no;	/* Command timing */
	int drwt = 0x5A + 4 * ap->port_no + adev->devno; /* R/W timing */
	int udmat = 0x56 + ap->port_no;	/* UDMA timing */
	int shift = 4 * adev->devno;
	u8 udma;

	if (t != NULL) {
181 182 183 184 185
		t->setup = clamp_val(t->setup, 1, 8) & 7;
		t->act8b = clamp_val(t->act8b, 1, 8) & 7;
		t->rec8b = clamp_val(t->rec8b, 1, 16) & 15;
		t->active = clamp_val(t->active, 1, 8) & 7;
		t->recover = clamp_val(t->recover, 1, 16) & 15;
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203

		pci_write_config_byte(pdev, cas, t->setup);
		pci_write_config_byte(pdev, cbt, (t->act8b << 4) | t->rec8b);
		pci_write_config_byte(pdev, drwt, (t->active << 4) | t->recover);
	}

	/* 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
 *
204
 *	Program the ALi registers for PIO mode.
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
 */

static void ali_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	struct ata_device *pair = ata_dev_pair(adev);
	struct ata_timing t;
	unsigned long T =  1000000000 / 33333;	/* PCI clock based */

	ata_timing_compute(adev, adev->pio_mode, &t, T, 1);
	if (pair) {
		struct ata_timing p;
		ata_timing_compute(pair, 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_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
		}
	}

	/* PIO FIFO is only permitted on ATA disk */
	if (adev->class != ATA_DEV_ATA)
		ali_fifo_control(ap, adev, 0x00);
	ali_program_modes(ap, adev, &t, 0);
	if (adev->class == ATA_DEV_ATA)
		ali_fifo_control(ap, adev, 0x05);

}

/**
 *	ali_set_dmamode	-	set initial DMA mode data
 *	@ap: ATA interface
 *	@adev: ATA device
 *
238
 *	Program the ALi registers for DMA mode.
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
 */

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 };
	struct ata_device *pair = ata_dev_pair(adev);
	struct ata_timing t;
	unsigned long T =  1000000000 / 33333;	/* PCI clock based */
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);


	if (adev->class == ATA_DEV_ATA)
		ali_fifo_control(ap, adev, 0x08);

	if (adev->dma_mode >= XFER_UDMA_0) {
		ali_program_modes(ap, adev, NULL, udma_timing[adev->dma_mode - XFER_UDMA_0]);
		if (adev->dma_mode >= XFER_UDMA_3) {
			u8 reg4b;
			pci_read_config_byte(pdev, 0x4B, &reg4b);
			reg4b |= 1;
			pci_write_config_byte(pdev, 0x4B, reg4b);
		}
	} else {
		ata_timing_compute(adev, adev->dma_mode, &t, T, 1);
		if (pair) {
			struct ata_timing p;
			ata_timing_compute(pair, 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_merge(&p, &t, &t, ATA_TIMING_SETUP|ATA_TIMING_8BIT);
			}
		}
		ali_program_modes(ap, adev, &t, 0);
	}
}

Tejun Heo's avatar
Tejun Heo committed
276 277 278 279 280 281 282 283 284 285 286 287 288 289
/**
 *	ali_warn_atapi_dma	-	Warn about ATAPI DMA disablement
 *	@adev: Device
 *
 *	Whine about ATAPI DMA disablement if @adev is an ATAPI device.
 *	Can be used as ->dev_config.
 */

static void ali_warn_atapi_dma(struct ata_device *adev)
{
	struct ata_eh_context *ehc = &adev->link->eh_context;
	int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;

	if (print_info && adev->class == ATA_DEV_ATAPI && !ali_atapi_dma) {
290 291 292 293
		ata_dev_warn(adev,
			     "WARNING: ATAPI DMA disabled for reliability issues.  It can be enabled\n");
		ata_dev_warn(adev,
			     "WARNING: via pata_ali.atapi_dma modparam or corresponding sysfs node.\n");
Tejun Heo's avatar
Tejun Heo committed
294 295 296
	}
}

297 298 299 300 301 302 303 304 305 306 307
/**
 *	ali_lock_sectors	-	Keep older devices to 255 sector mode
 *	@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
 */

308
static void ali_lock_sectors(struct ata_device *adev)
309 310
{
	adev->max_sectors = 255;
Tejun Heo's avatar
Tejun Heo committed
311
	ali_warn_atapi_dma(adev);
312 313
}

314 315 316 317 318 319
/**
 *	ali_check_atapi_dma	-	DMA check for most ALi controllers
 *	@adev: Device
 *
 *	Called to decide whether commands should be sent by DMA or PIO
 */
320

321 322
static int ali_check_atapi_dma(struct ata_queued_cmd *qc)
{
Tejun Heo's avatar
Tejun Heo committed
323 324 325 326 327 328 329 330 331 332 333 334
	if (!ali_atapi_dma) {
		/* FIXME: pata_ali can't do ATAPI DMA reliably but the
		 * IDE alim15x3 driver can.  I tried lots of things
		 * but couldn't find what the actual difference was.
		 * If you got an idea, please write it to
		 * linux-ide@vger.kernel.org and cc htejun@gmail.com.
		 *
		 * Disable ATAPI DMA for now.
		 */
		return -EOPNOTSUPP;
	}

335
	/* If its not a media command, its not worth it */
336
	if (atapi_cmd_type(qc->cdb[0]) == ATAPI_MISC)
337 338 339 340
		return -EOPNOTSUPP;
	return 0;
}

341 342 343 344 345 346
static void ali_c2_c3_postreset(struct ata_link *link, unsigned int *classes)
{
	u8 r;
	int port_bit = 4 << link->ap->port_no;

	/* If our bridge is an ALI 1533 then do the extra work */
347
	if (ali_isa_bridge) {
348
		/* Tristate and re-enable the bus signals */
349
		pci_read_config_byte(ali_isa_bridge, 0x58, &r);
350
		r &= ~port_bit;
351
		pci_write_config_byte(ali_isa_bridge, 0x58, r);
352
		r |= port_bit;
353
		pci_write_config_byte(ali_isa_bridge, 0x58, r);
354 355 356 357
	}
	ata_sff_postreset(link, classes);
}

358
static struct scsi_host_template ali_sht = {
359
	ATA_BMDMA_SHT(DRV_NAME),
360 361 362 363 364 365 366
};

/*
 *	Port operations for PIO only ALi
 */

static struct ata_port_operations ali_early_port_ops = {
367
	.inherits	= &ata_sff_port_ops,
368
	.cable_detect	= ata_cable_40wire,
369
	.set_piomode	= ali_set_piomode,
Alan Cox's avatar
Alan Cox committed
370
	.sff_data_xfer  = ata_sff_data_xfer32,
371
};
372

373
static const struct ata_port_operations ali_dma_base_ops = {
Alan Cox's avatar
Alan Cox committed
374
	.inherits	= &ata_bmdma32_port_ops,
375 376
	.set_piomode	= ali_set_piomode,
	.set_dmamode	= ali_set_dmamode,
377 378 379 380 381 382 383
};

/*
 *	Port operations for DMA capable ALi without cable
 *	detect
 */
static struct ata_port_operations ali_20_port_ops = {
384 385
	.inherits	= &ali_dma_base_ops,
	.cable_detect	= ata_cable_40wire,
386
	.mode_filter	= ali_20_filter,
Tejun Heo's avatar
Tejun Heo committed
387
	.check_atapi_dma = ali_check_atapi_dma,
388 389 390 391 392 393 394
	.dev_config	= ali_lock_sectors,
};

/*
 *	Port operations for DMA capable ALi with cable detect
 */
static struct ata_port_operations ali_c2_port_ops = {
395
	.inherits	= &ali_dma_base_ops,
396
	.check_atapi_dma = ali_check_atapi_dma,
397
	.cable_detect	= ali_c2_cable_detect,
398
	.dev_config	= ali_lock_sectors,
399 400 401 402 403 404 405 406 407 408 409
	.postreset	= ali_c2_c3_postreset,
};

/*
 *	Port operations for DMA capable ALi with cable detect
 */
static struct ata_port_operations ali_c4_port_ops = {
	.inherits	= &ali_dma_base_ops,
	.check_atapi_dma = ali_check_atapi_dma,
	.cable_detect	= ali_c2_cable_detect,
	.dev_config	= ali_lock_sectors,
410 411 412 413 414 415
};

/*
 *	Port operations for DMA capable ALi with cable detect and LBA48
 */
static struct ata_port_operations ali_c5_port_ops = {
416
	.inherits	= &ali_dma_base_ops,
417
	.check_atapi_dma = ali_check_atapi_dma,
Tejun Heo's avatar
Tejun Heo committed
418
	.dev_config	= ali_warn_atapi_dma,
419
	.cable_detect	= ali_c2_cable_detect,
420 421
};

422 423 424 425 426 427 428 429

/**
 *	ali_init_chipset	-	chip setup function
 *	@pdev: PCI device of ATA controller
 *
 *	Perform the setup on the device that must be done both at boot
 *	and at resume time.
 */
430

431 432
static void ali_init_chipset(struct pci_dev *pdev)
{
433
	u8 tmp;
434
	struct pci_dev *north;
435 436 437 438 439 440

	/*
	 * The chipset revision selects the driver operations and
	 * mode data.
	 */

441 442 443 444 445 446 447
	if (pdev->revision <= 0x20) {
		pci_read_config_byte(pdev, 0x53, &tmp);
		tmp |= 0x03;
		pci_write_config_byte(pdev, 0x53, tmp);
	} else {
		pci_read_config_byte(pdev, 0x4a, &tmp);
		pci_write_config_byte(pdev, 0x4a, tmp | 0x20);
448
		pci_read_config_byte(pdev, 0x4B, &tmp);
449 450 451 452 453
		if (pdev->revision < 0xC2)
			/* 1543-E/F, 1543C-C, 1543C-D, 1543C-E */
			/* Clear CD-ROM DMA write bit */
			tmp &= 0x7F;
		/* Cable and UDMA */
454 455 456
		if (pdev->revision >= 0xc2)
			tmp |= 0x01;
		pci_write_config_byte(pdev, 0x4B, tmp | 0x08);
457 458 459 460 461 462
		/*
		 * 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);
463
		if (pdev->revision >= 0xc7)
464 465 466 467 468
			tmp |= 0x03;
		else
			tmp |= 0x01;	/* CD_ROM enable for DMA */
		pci_write_config_byte(pdev, 0x53, tmp);
	}
469
	north = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
470
	if (north && north->vendor == PCI_VENDOR_ID_AL && ali_isa_bridge) {
471 472
		/* Configure the ALi bridge logic. For non ALi rely on BIOS.
		   Set the south bridge enable bit */
473
		pci_read_config_byte(ali_isa_bridge, 0x79, &tmp);
474
		if (pdev->revision == 0xC2)
475
			pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x04);
476
		else if (pdev->revision > 0xC2 && pdev->revision < 0xC5)
477
			pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x02);
478
	}
479
	pci_dev_put(north);
Tejun Heo's avatar
Tejun Heo committed
480
	ata_pci_bmdma_clear_simplex(pdev);
481
}
482 483 484 485 486 487 488 489 490 491 492
/**
 *	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)
{
493
	static const struct ata_port_info info_early = {
494
		.flags = ATA_FLAG_SLAVE_POSS,
495
		.pio_mask = ATA_PIO4,
496 497 498
		.port_ops = &ali_early_port_ops
	};
	/* Revision 0x20 added DMA */
499
	static const struct ata_port_info info_20 = {
500 501
		.flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
							ATA_FLAG_IGN_SIMPLEX,
502 503
		.pio_mask = ATA_PIO4,
		.mwdma_mask = ATA_MWDMA2,
504 505 506
		.port_ops = &ali_20_port_ops
	};
	/* Revision 0x20 with support logic added UDMA */
507
	static const struct ata_port_info info_20_udma = {
508 509
		.flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
							ATA_FLAG_IGN_SIMPLEX,
510 511 512
		.pio_mask = ATA_PIO4,
		.mwdma_mask = ATA_MWDMA2,
		.udma_mask = ATA_UDMA2,
513 514 515
		.port_ops = &ali_20_port_ops
	};
	/* Revision 0xC2 adds UDMA66 */
516
	static const struct ata_port_info info_c2 = {
517 518
		.flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
							ATA_FLAG_IGN_SIMPLEX,
519 520
		.pio_mask = ATA_PIO4,
		.mwdma_mask = ATA_MWDMA2,
521
		.udma_mask = ATA_UDMA4,
522 523
		.port_ops = &ali_c2_port_ops
	};
524
	/* Revision 0xC3 is UDMA66 for now */
525
	static const struct ata_port_info info_c3 = {
526 527
		.flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
							ATA_FLAG_IGN_SIMPLEX,
528 529
		.pio_mask = ATA_PIO4,
		.mwdma_mask = ATA_MWDMA2,
530
		.udma_mask = ATA_UDMA4,
531 532
		.port_ops = &ali_c2_port_ops
	};
533
	/* Revision 0xC4 is UDMA100 */
534
	static const struct ata_port_info info_c4 = {
535 536
		.flags = ATA_FLAG_SLAVE_POSS | ATA_FLAG_PIO_LBA48 |
							ATA_FLAG_IGN_SIMPLEX,
537 538
		.pio_mask = ATA_PIO4,
		.mwdma_mask = ATA_MWDMA2,
539
		.udma_mask = ATA_UDMA5,
540
		.port_ops = &ali_c4_port_ops
541 542
	};
	/* Revision 0xC5 is UDMA133 with LBA48 DMA */
543
	static const struct ata_port_info info_c5 = {
544
		.flags = ATA_FLAG_SLAVE_POSS | 	ATA_FLAG_IGN_SIMPLEX,
545 546
		.pio_mask = ATA_PIO4,
		.mwdma_mask = ATA_MWDMA2,
547
		.udma_mask = ATA_UDMA6,
548 549 550
		.port_ops = &ali_c5_port_ops
	};

551
	const struct ata_port_info *ppi[] = { NULL, NULL };
552
	u8 tmp;
553 554 555 556 557
	int rc;

	rc = pcim_enable_device(pdev);
	if (rc)
		return rc;
558 559 560 561 562 563

	/*
	 * The chipset revision selects the driver operations and
	 * mode data.
	 */

564
	if (pdev->revision < 0x20) {
565
		ppi[0] = &info_early;
566
	} else if (pdev->revision < 0xC2) {
567
        	ppi[0] = &info_20;
568
	} else if (pdev->revision == 0xC2) {
569
        	ppi[0] = &info_c2;
570
	} else if (pdev->revision == 0xC3) {
571
        	ppi[0] = &info_c3;
572
	} else if (pdev->revision == 0xC4) {
573
        	ppi[0] = &info_c4;
574
	} else
575
        	ppi[0] = &info_c5;
576

577
	ali_init_chipset(pdev);
578

579
	if (ali_isa_bridge && pdev->revision >= 0x20 && pdev->revision < 0xC2) {
580
		/* Are we paired with a UDMA capable chip */
581
		pci_read_config_byte(ali_isa_bridge, 0x5E, &tmp);
582
		if ((tmp & 0x1E) == 0x12)
583
	        	ppi[0] = &info_20_udma;
584
	}
585

586 587 588 589
	if (!ppi[0]->mwdma_mask && !ppi[0]->udma_mask)
		return ata_pci_sff_init_one(pdev, ppi, &ali_sht, NULL, 0);
	else
		return ata_pci_bmdma_init_one(pdev, ppi, &ali_sht, NULL, 0);
590 591
}

592
#ifdef CONFIG_PM
593 594
static int ali_reinit_one(struct pci_dev *pdev)
{
595 596 597 598 599 600
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
	int rc;

	rc = ata_pci_device_do_resume(pdev);
	if (rc)
		return rc;
601
	ali_init_chipset(pdev);
602 603
	ata_host_resume(host);
	return 0;
604
}
605
#endif
606

607 608 609 610 611
static const struct pci_device_id ali[] = {
	{ PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5228), },
	{ PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5229), },

	{ },
612 613 614 615 616 617
};

static struct pci_driver ali_pci_driver = {
	.name 		= DRV_NAME,
	.id_table	= ali,
	.probe 		= ali_init_one,
618
	.remove		= ata_pci_remove_one,
619
#ifdef CONFIG_PM
620 621
	.suspend	= ata_pci_device_suspend,
	.resume		= ali_reinit_one,
622
#endif
623 624 625 626
};

static int __init ali_init(void)
{
627
	int ret;
628
	ali_isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
629 630 631

	ret = pci_register_driver(&ali_pci_driver);
	if (ret < 0)
632
		pci_dev_put(ali_isa_bridge);
633
	return ret;
634 635 636 637 638 639
}


static void __exit ali_exit(void)
{
	pci_unregister_driver(&ali_pci_driver);
640
	pci_dev_put(ali_isa_bridge);
641 642 643 644 645 646 647 648 649 650 651
}


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);