pata_sis.c 23.5 KB
Newer Older
1 2 3
/*
 *    pata_sis.c - SiS ATA driver
 *
4
 *	(C) 2005 Red Hat
5
 *	(C) 2007,2009 Bartlomiej Zolnierkiewicz
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 *    Based upon linux/drivers/ide/pci/sis5513.c
 * Copyright (C) 1999-2000	Andre Hedrick <andre@linux-ide.org>
 * Copyright (C) 2002		Lionel Bouton <Lionel.Bouton@inet6.fr>, Maintainer
 * Copyright (C) 2003		Vojtech Pavlik <vojtech@suse.cz>
 * SiS Taiwan		: for direct support and hardware.
 * Daniela Engert	: for initial ATA100 advices and numerous others.
 * John Fremlin, Manfred Spraul, Dave Morgan, Peter Kjellerstedt	:
 *			  for checking code correctness, providing patches.
 * Original tests and design on the SiS620 chipset.
 * ATA100 tests and design on the SiS735 chipset.
 * ATA16/33 support from specs
 * ATA133 support for SiS961/962 by L.C. Chang <lcchang@sis.com.tw>
 *
 *
 *	TODO
 *	Check MWDMA on drives that don't support MWDMA speed pio cycles ?
 *	More Testing
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <scsi/scsi_host.h>
#include <linux/libata.h>
#include <linux/ata.h>
Alan's avatar
Alan committed
36
#include "sis.h"
37 38

#define DRV_NAME	"pata_sis"
39
#define DRV_VERSION	"0.5.2"
40 41

struct sis_chipset {
42 43
	u16 device;				/* PCI host ID */
	const struct ata_port_info *info;	/* Info block */
44 45 46 47
	/* Probably add family, cable detect type etc here to clean
	   up code later */
};

48 49 50 51 52 53 54 55 56
struct sis_laptop {
	u16 device;
	u16 subvendor;
	u16 subdevice;
};

static const struct sis_laptop sis_laptop[] = {
	/* devid, subvendor, subdev */
	{ 0x5513, 0x1043, 0x1107 },	/* ASUS A6K */
57
	{ 0x5513, 0x1734, 0x105F },	/* FSC Amilo A1630 */
58
	{ 0x5513, 0x1071, 0x8640 },	/* EasyNote K5305 */
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
	/* 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;
}

78
/**
79
 *	sis_old_port_base - return PCI configuration base for dev
80 81 82 83 84 85
 *	@adev: device
 *
 *	Returns the base of the PCI configuration registers for this port
 *	number.
 */

86
static int sis_old_port_base(struct ata_device *adev)
87
{
88
	return 0x40 + (4 * adev->link->ap->port_no) + (2 * adev->devno);
89 90
}

91
/**
92
 *	sis_port_base - return PCI configuration base for dev
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
 *	@adev: device
 *
 *	Returns the base of the PCI configuration registers for this port
 *	number.
 */

static int sis_port_base(struct ata_device *adev)
{
	struct ata_port *ap = adev->link->ap;
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	int port = 0x40;
	u32 reg54;

	/* If bit 30 is set then the registers are mapped at 0x70 not 0x40 */
	pci_read_config_dword(pdev, 0x54, &reg54);
	if (reg54 & 0x40000000)
		port = 0x70;

	return port + (8 * ap->port_no) + (4 * adev->devno);
}

114
/**
115
 *	sis_133_cable_detect - check for 40/80 pin
116
 *	@ap: Port
117
 *	@deadline: deadline jiffies for the operation
118 119 120 121 122
 *
 *	Perform cable detection for the later UDMA133 capable
 *	SiS chipset.
 */

123
static int sis_133_cable_detect(struct ata_port *ap)
124 125 126 127 128 129
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u16 tmp;

	/* The top bit of this register is the cable detect bit */
	pci_read_config_word(pdev, 0x50 + 2 * ap->port_no, &tmp);
130
	if ((tmp & 0x8000) && !sis_short_ata40(pdev))
131 132
		return ATA_CBL_PATA40;
	return ATA_CBL_PATA80;
133 134 135
}

/**
136
 *	sis_66_cable_detect - check for 40/80 pin
137 138 139 140 141 142
 *	@ap: Port
 *
 *	Perform cable detection on the UDMA66, UDMA100 and early UDMA133
 *	SiS IDE controllers.
 */

143
static int sis_66_cable_detect(struct ata_port *ap)
144 145 146 147 148 149 150
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 tmp;

	/* Older chips keep cable detect in bits 4/5 of reg 0x48 */
	pci_read_config_byte(pdev, 0x48, &tmp);
	tmp >>= ap->port_no;
151
	if ((tmp & 0x10) && !sis_short_ata40(pdev))
152 153
		return ATA_CBL_PATA40;
	return ATA_CBL_PATA80;
154 155 156 157
}


/**
158
 *	sis_pre_reset - probe begin
Tejun Heo's avatar
Tejun Heo committed
159
 *	@link: ATA link
160
 *	@deadline: deadline jiffies for the operation
161 162 163 164
 *
 *	Set up cable type and use generic probe init
 */

Tejun Heo's avatar
Tejun Heo committed
165
static int sis_pre_reset(struct ata_link *link, unsigned long deadline)
166 167 168 169 170
{
	static const struct pci_bits sis_enable_bits[] = {
		{ 0x4aU, 1U, 0x02UL, 0x02UL },	/* port 0 */
		{ 0x4aU, 1U, 0x04UL, 0x04UL },	/* port 1 */
	};
171

Tejun Heo's avatar
Tejun Heo committed
172
	struct ata_port *ap = link->ap;
173 174
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);

175 176
	if (!pci_test_config_bits(pdev, &sis_enable_bits[ap->port_no]))
		return -ENOENT;
177

Alan Cox's avatar
Alan Cox committed
178 179 180
	/* Clear the FIFO settings. We can't enable the FIFO until
	   we know we are poking at a disk */
	pci_write_config_byte(pdev, 0x4B, 0);
Tejun Heo's avatar
Tejun Heo committed
181
	return ata_sff_prereset(link, deadline);
182 183 184 185
}


/**
186
 *	sis_set_fifo - Set RWP fifo bits for this device
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
 *	@ap: Port
 *	@adev: Device
 *
 *	SIS chipsets implement prefetch/postwrite bits for each device
 *	on both channels. This functionality is not ATAPI compatible and
 *	must be configured according to the class of device present
 */

static void sis_set_fifo(struct ata_port *ap, struct ata_device *adev)
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 fifoctrl;
	u8 mask = 0x11;

	mask <<= (2 * ap->port_no);
	mask <<= adev->devno;

	/* This holds various bits including the FIFO control */
	pci_read_config_byte(pdev, 0x4B, &fifoctrl);
	fifoctrl &= ~mask;

	/* Enable for ATA (disk) only */
	if (adev->class == ATA_DEV_ATA)
		fifoctrl |= mask;
	pci_write_config_byte(pdev, 0x4B, fifoctrl);
}

/**
 *	sis_old_set_piomode - Initialize host controller PATA PIO timings
 *	@ap: Port whose timings we are configuring
 *	@adev: Device we are configuring for.
 *
 *	Set PIO mode for device, in host controller PCI config space. This
 *	function handles PIO set up for all chips that are pre ATA100 and
 *	also early ATA100 devices.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_old_set_piomode (struct ata_port *ap, struct ata_device *adev)
{
229
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
230
	int port = sis_old_port_base(adev);
231 232 233
	u8 t1, t2;
	int speed = adev->pio_mode - XFER_PIO_0;

234 235
	static const u8 active[]   = { 0x00, 0x07, 0x04, 0x03, 0x01 };
	static const u8 recovery[] = { 0x00, 0x06, 0x04, 0x03, 0x03 };
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252

	sis_set_fifo(ap, adev);

	pci_read_config_byte(pdev, port, &t1);
	pci_read_config_byte(pdev, port + 1, &t2);

	t1 &= ~0x0F;	/* Clear active/recovery timings */
	t2 &= ~0x07;

	t1 |= active[speed];
	t2 |= recovery[speed];

	pci_write_config_byte(pdev, port, t1);
	pci_write_config_byte(pdev, port + 1, t2);
}

/**
253
 *	sis_100_set_piomode - Initialize host controller PATA PIO timings
254 255 256 257 258 259 260 261 262 263 264 265
 *	@ap: Port whose timings we are configuring
 *	@adev: Device we are configuring for.
 *
 *	Set PIO mode for device, in host controller PCI config space. This
 *	function handles PIO set up for ATA100 devices and early ATA133.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_100_set_piomode (struct ata_port *ap, struct ata_device *adev)
{
266
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
267
	int port = sis_old_port_base(adev);
268 269
	int speed = adev->pio_mode - XFER_PIO_0;

270
	static const u8 actrec[] = { 0x00, 0x67, 0x44, 0x33, 0x31 };
271 272 273 274 275 276 277

	sis_set_fifo(ap, adev);

	pci_write_config_byte(pdev, port, actrec[speed]);
}

/**
278
 *	sis_133_set_piomode - Initialize host controller PATA PIO timings
279 280 281 282
 *	@ap: Port whose timings we are configuring
 *	@adev: Device we are configuring for.
 *
 *	Set PIO mode for device, in host controller PCI config space. This
283
 *	function handles PIO set up for the later ATA133 devices.
284 285 286 287 288
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

289
static void sis_133_set_piomode (struct ata_port *ap, struct ata_device *adev)
290
{
291
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
292
	int port;
293
	u32 t1;
294
	int speed = adev->pio_mode - XFER_PIO_0;
295

296
	static const u32 timing133[] = {
297 298 299 300 301 302
		0x28269000,	/* Recovery << 24 | Act << 16 | Ini << 12 */
		0x0C266000,
		0x04263000,
		0x0C0A3000,
		0x05093000
	};
303
	static const u32 timing100[] = {
304 305 306 307 308 309 310 311 312
		0x1E1C6000,	/* Recovery << 24 | Act << 16 | Ini << 12 */
		0x091C4000,
		0x031C2000,
		0x09072000,
		0x04062000
	};

	sis_set_fifo(ap, adev);

313
	port = sis_port_base(adev);
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
	pci_read_config_dword(pdev, port, &t1);
	t1 &= 0xC0C00FFF;	/* Mask out timing */

	if (t1 & 0x08)		/* 100 or 133 ? */
		t1 |= timing133[speed];
	else
		t1 |= timing100[speed];
	pci_write_config_byte(pdev, port, t1);
}

/**
 *	sis_old_set_dmamode - Initialize host controller PATA DMA timings
 *	@ap: Port whose timings we are configuring
 *	@adev: Device to program
 *
 *	Set UDMA/MWDMA mode for device, in host controller PCI config space.
 *	Handles pre UDMA and UDMA33 devices. Supports MWDMA as well unlike
 *	the old ide/pci driver.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_old_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
339
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
340
	int speed = adev->dma_mode - XFER_MW_DMA_0;
341
	int drive_pci = sis_old_port_base(adev);
342 343
	u16 timing;

344 345
	static const u16 mwdma_bits[] = { 0x008, 0x302, 0x301 };
	static const u16 udma_bits[]  = { 0xE000, 0xC000, 0xA000 };
346 347 348 349 350

	pci_read_config_word(pdev, drive_pci, &timing);

	if (adev->dma_mode < XFER_UDMA_0) {
		/* bits 3-0 hold recovery timing bits 8-10 active timing and
351
		   the higher bits are dependent on the device */
352
		timing &= ~0x870F;
353 354 355 356 357 358 359
		timing |= mwdma_bits[speed];
	} else {
		/* Bit 15 is UDMA on/off, bit 13-14 are cycle time */
		speed = adev->dma_mode - XFER_UDMA_0;
		timing &= ~0x6000;
		timing |= udma_bits[speed];
	}
360
	pci_write_config_word(pdev, drive_pci, timing);
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
}

/**
 *	sis_66_set_dmamode - Initialize host controller PATA DMA timings
 *	@ap: Port whose timings we are configuring
 *	@adev: Device to program
 *
 *	Set UDMA/MWDMA mode for device, in host controller PCI config space.
 *	Handles UDMA66 and early UDMA100 devices. Supports MWDMA as well unlike
 *	the old ide/pci driver.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_66_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
378
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
379
	int speed = adev->dma_mode - XFER_MW_DMA_0;
380
	int drive_pci = sis_old_port_base(adev);
381 382
	u16 timing;

383
	/* MWDMA 0-2 and UDMA 0-5 */
384 385
	static const u16 mwdma_bits[] = { 0x008, 0x302, 0x301 };
	static const u16 udma_bits[]  = { 0xF000, 0xD000, 0xB000, 0xA000, 0x9000, 0x8000 };
386 387 388 389 390

	pci_read_config_word(pdev, drive_pci, &timing);

	if (adev->dma_mode < XFER_UDMA_0) {
		/* bits 3-0 hold recovery timing bits 8-10 active timing and
391
		   the higher bits are dependent on the device, bit 15 udma */
392
		timing &= ~0x870F;
393 394 395 396
		timing |= mwdma_bits[speed];
	} else {
		/* Bit 15 is UDMA on/off, bit 12-14 are cycle time */
		speed = adev->dma_mode - XFER_UDMA_0;
397
		timing &= ~0xF000;
398 399 400 401 402 403 404 405 406 407 408
		timing |= udma_bits[speed];
	}
	pci_write_config_word(pdev, drive_pci, timing);
}

/**
 *	sis_100_set_dmamode - Initialize host controller PATA DMA timings
 *	@ap: Port whose timings we are configuring
 *	@adev: Device to program
 *
 *	Set UDMA/MWDMA mode for device, in host controller PCI config space.
409
 *	Handles UDMA66 and early UDMA100 devices.
410 411 412 413 414 415 416
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_100_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
417
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
418
	int speed = adev->dma_mode - XFER_MW_DMA_0;
419
	int drive_pci = sis_old_port_base(adev);
420
	u8 timing;
421

422
	static const u8 udma_bits[]  = { 0x8B, 0x87, 0x85, 0x83, 0x82, 0x81};
423

424
	pci_read_config_byte(pdev, drive_pci + 1, &timing);
425 426

	if (adev->dma_mode < XFER_UDMA_0) {
427
		/* NOT SUPPORTED YET: NEED DATA SHEET. DITTO IN OLD DRIVER */
428
	} else {
429
		/* Bit 7 is UDMA on/off, bit 0-3 are cycle time */
430
		speed = adev->dma_mode - XFER_UDMA_0;
431
		timing &= ~0x8F;
432 433
		timing |= udma_bits[speed];
	}
434
	pci_write_config_byte(pdev, drive_pci + 1, timing);
435 436 437 438 439 440 441 442
}

/**
 *	sis_133_early_set_dmamode - Initialize host controller PATA DMA timings
 *	@ap: Port whose timings we are configuring
 *	@adev: Device to program
 *
 *	Set UDMA/MWDMA mode for device, in host controller PCI config space.
443
 *	Handles early SiS 961 bridges.
444 445 446 447 448 449 450
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_133_early_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
451
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
452
	int speed = adev->dma_mode - XFER_MW_DMA_0;
453
	int drive_pci = sis_old_port_base(adev);
454 455 456
	u8 timing;
	/* Low 4 bits are timing */
	static const u8 udma_bits[]  = { 0x8F, 0x8A, 0x87, 0x85, 0x83, 0x82, 0x81};
457

458
	pci_read_config_byte(pdev, drive_pci + 1, &timing);
459 460

	if (adev->dma_mode < XFER_UDMA_0) {
461
		/* NOT SUPPORTED YET: NEED DATA SHEET. DITTO IN OLD DRIVER */
462
	} else {
463
		/* Bit 7 is UDMA on/off, bit 0-3 are cycle time */
464
		speed = adev->dma_mode - XFER_UDMA_0;
465
		timing &= ~0x8F;
466 467
		timing |= udma_bits[speed];
	}
468
	pci_write_config_byte(pdev, drive_pci + 1, timing);
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
}

/**
 *	sis_133_set_dmamode - Initialize host controller PATA DMA timings
 *	@ap: Port whose timings we are configuring
 *	@adev: Device to program
 *
 *	Set UDMA/MWDMA mode for device, in host controller PCI config space.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void sis_133_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
484
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
485
	int port;
486 487
	u32 t1;

488
	port = sis_port_base(adev);
489 490 491
	pci_read_config_dword(pdev, port, &t1);

	if (adev->dma_mode < XFER_UDMA_0) {
492 493 494 495 496 497 498
		/* Recovery << 24 | Act << 16 | Ini << 12, like PIO modes */
		static const u32 timing_u100[] = { 0x19154000, 0x06072000, 0x04062000 };
		static const u32 timing_u133[] = { 0x221C6000, 0x0C0A3000, 0x05093000 };
		int speed = adev->dma_mode - XFER_MW_DMA_0;

		t1 &= 0xC0C00FFF;
		/* disable UDMA */
499
		t1 &= ~0x00000004;
500 501 502 503
		if (t1 & 0x08)
			t1 |= timing_u133[speed];
		else
			t1 |= timing_u100[speed];
504
	} else {
505 506 507
		/* bits 4- cycle time 8 - cvs time */
		static const u32 timing_u100[] = { 0x6B0, 0x470, 0x350, 0x140, 0x120, 0x110, 0x000 };
		static const u32 timing_u133[] = { 0x9F0, 0x6A0, 0x470, 0x250, 0x230, 0x220, 0x210 };
508
		int speed = adev->dma_mode - XFER_UDMA_0;
509

510
		t1 &= ~0x00000FF0;
511
		/* enable UDMA */
512 513 514 515 516 517 518 519 520
		t1 |= 0x00000004;
		if (t1 & 0x08)
			t1 |= timing_u133[speed];
		else
			t1 |= timing_u100[speed];
	}
	pci_write_config_dword(pdev, port, t1);
}

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
/**
 *	sis_133_mode_filter - mode selection filter
 *	@adev: ATA device
 *
 *	Block UDMA6 on devices that do not support it.
 */

static unsigned long sis_133_mode_filter(struct ata_device *adev, unsigned long mask)
{
	struct ata_port *ap = adev->link->ap;
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	int port = sis_port_base(adev);
	u32 t1;

	pci_read_config_dword(pdev, port, &t1);
	/* if ATA133 is disabled, mask it out */
	if (!(t1 & 0x08))
		mask &= ~(0xC0 << ATA_SHIFT_UDMA);
	return mask;
}

542
static struct scsi_host_template sis_sht = {
543
	ATA_BMDMA_SHT(DRV_NAME),
544 545
};

546 547
static struct ata_port_operations sis_133_for_sata_ops = {
	.inherits		= &ata_bmdma_port_ops,
548 549
	.set_piomode		= sis_133_set_piomode,
	.set_dmamode		= sis_133_set_dmamode,
550
	.cable_detect		= sis_133_cable_detect,
551
};
552

553 554
static struct ata_port_operations sis_base_ops = {
	.inherits		= &ata_bmdma_port_ops,
555
	.prereset		= sis_pre_reset,
556 557
};

558 559
static struct ata_port_operations sis_133_ops = {
	.inherits		= &sis_base_ops,
560 561 562
	.set_piomode		= sis_133_set_piomode,
	.set_dmamode		= sis_133_set_dmamode,
	.cable_detect		= sis_133_cable_detect,
563
	.mode_filter		= sis_133_mode_filter,
564 565
};

566 567
static struct ata_port_operations sis_133_early_ops = {
	.inherits		= &sis_base_ops,
568 569
	.set_piomode		= sis_100_set_piomode,
	.set_dmamode		= sis_133_early_set_dmamode,
570
	.cable_detect		= sis_66_cable_detect,
571 572
};

573 574
static struct ata_port_operations sis_100_ops = {
	.inherits		= &sis_base_ops,
575 576
	.set_piomode		= sis_100_set_piomode,
	.set_dmamode		= sis_100_set_dmamode,
577
	.cable_detect		= sis_66_cable_detect,
578 579
};

580 581
static struct ata_port_operations sis_66_ops = {
	.inherits		= &sis_base_ops,
582 583
	.set_piomode		= sis_old_set_piomode,
	.set_dmamode		= sis_66_set_dmamode,
584
	.cable_detect		= sis_66_cable_detect,
585 586
};

587 588
static struct ata_port_operations sis_old_ops = {
	.inherits		= &sis_base_ops,
589 590
	.set_piomode		= sis_old_set_piomode,
	.set_dmamode		= sis_old_set_dmamode,
591
	.cable_detect		= ata_cable_40wire,
592 593
};

594
static const struct ata_port_info sis_info = {
595
	.flags		= ATA_FLAG_SLAVE_POSS,
596 597 598
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
	/* No UDMA */
599 600
	.port_ops	= &sis_old_ops,
};
601
static const struct ata_port_info sis_info33 = {
602
	.flags		= ATA_FLAG_SLAVE_POSS,
603 604 605
	.pio_mask	= ATA_PIO4,
	.mwdma_mask	= ATA_MWDMA2,
	.udma_mask	= ATA_UDMA2,
606 607
	.port_ops	= &sis_old_ops,
};
608
static const struct ata_port_info sis_info66 = {
609
	.flags		= ATA_FLAG_SLAVE_POSS,
610 611 612
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
	.udma_mask	= ATA_UDMA4,
613 614
	.port_ops	= &sis_66_ops,
};
615
static const struct ata_port_info sis_info100 = {
616
	.flags		= ATA_FLAG_SLAVE_POSS,
617 618
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
619 620 621
	.udma_mask	= ATA_UDMA5,
	.port_ops	= &sis_100_ops,
};
622
static const struct ata_port_info sis_info100_early = {
623
	.flags		= ATA_FLAG_SLAVE_POSS,
624 625
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
626 627 628
	.udma_mask	= ATA_UDMA5,
	.port_ops	= &sis_66_ops,
};
629
static const struct ata_port_info sis_info133 = {
630
	.flags		= ATA_FLAG_SLAVE_POSS,
631
	.pio_mask	= ATA_PIO4,
632
	.mwdma_mask	= ATA_MWDMA2,
633 634 635
	.udma_mask	= ATA_UDMA6,
	.port_ops	= &sis_133_ops,
};
636
const struct ata_port_info sis_info133_for_sata = {
637
	.flags		= ATA_FLAG_SLAVE_POSS,
638 639
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
640 641 642
	.udma_mask	= ATA_UDMA6,
	.port_ops	= &sis_133_for_sata_ops,
};
643
static const struct ata_port_info sis_info133_early = {
644
	.flags		= ATA_FLAG_SLAVE_POSS,
645 646
	.pio_mask	= ATA_PIO4,
	/* No MWDMA */
647 648 649 650
	.udma_mask	= ATA_UDMA6,
	.port_ops	= &sis_133_early_ops,
};

651
/* Privately shared with the SiS180 SATA driver, not for use elsewhere */
652
EXPORT_SYMBOL_GPL(sis_info133_for_sata);
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712

static void sis_fixup(struct pci_dev *pdev, struct sis_chipset *sis)
{
	u16 regw;
	u8 reg;

	if (sis->info == &sis_info133) {
		pci_read_config_word(pdev, 0x50, &regw);
		if (regw & 0x08)
			pci_write_config_word(pdev, 0x50, regw & ~0x08);
		pci_read_config_word(pdev, 0x52, &regw);
		if (regw & 0x08)
			pci_write_config_word(pdev, 0x52, regw & ~0x08);
		return;
	}

	if (sis->info == &sis_info133_early || sis->info == &sis_info100) {
		/* Fix up latency */
		pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
		/* Set compatibility bit */
		pci_read_config_byte(pdev, 0x49, &reg);
		if (!(reg & 0x01))
			pci_write_config_byte(pdev, 0x49, reg | 0x01);
		return;
	}

	if (sis->info == &sis_info66 || sis->info == &sis_info100_early) {
		/* Fix up latency */
		pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
		/* Set compatibility bit */
		pci_read_config_byte(pdev, 0x52, &reg);
		if (!(reg & 0x04))
			pci_write_config_byte(pdev, 0x52, reg | 0x04);
		return;
	}

	if (sis->info == &sis_info33) {
		pci_read_config_byte(pdev, PCI_CLASS_PROG, &reg);
		if (( reg & 0x0F ) != 0x00)
			pci_write_config_byte(pdev, PCI_CLASS_PROG, reg & 0xF0);
		/* Fall through to ATA16 fixup below */
	}

	if (sis->info == &sis_info || sis->info == &sis_info33) {
		/* force per drive recovery and active timings
		   needed on ATA_33 and below chips */
		pci_read_config_byte(pdev, 0x52, &reg);
		if (!(reg & 0x08))
			pci_write_config_byte(pdev, 0x52, reg|0x08);
		return;
	}

	BUG();
}

/**
 *	sis_init_one - Register SiS ATA PCI device with kernel services
 *	@pdev: PCI device to register
 *	@ent: Entry in sis_pci_tbl matching with @pdev
 *
713
 *	Called from kernel PCI layer. We probe for combined mode (sigh),
714 715 716 717 718 719 720 721 722 723 724
 *	and then hand over control to libata, for it to do the rest.
 *
 *	LOCKING:
 *	Inherited from PCI layer (may sleep).
 *
 *	RETURNS:
 *	Zero on success, or -ERRNO value.
 */

static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
725
	const struct ata_port_info *ppi[] = { NULL, NULL };
726 727
	struct pci_dev *host = NULL;
	struct sis_chipset *chipset = NULL;
Alan Cox's avatar
Alan Cox committed
728
	struct sis_chipset *sets;
729
	int rc;
730 731

	static struct sis_chipset sis_chipsets[] = {
732

Alan Cox's avatar
Alan Cox committed
733 734 735
		{ 0x0968, &sis_info133 },
		{ 0x0966, &sis_info133 },
		{ 0x0965, &sis_info133 },
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
		{ 0x0745, &sis_info100 },
		{ 0x0735, &sis_info100 },
		{ 0x0733, &sis_info100 },
		{ 0x0635, &sis_info100 },
		{ 0x0633, &sis_info100 },

		{ 0x0730, &sis_info100_early },	/* 100 with ATA 66 layout */
		{ 0x0550, &sis_info100_early },	/* 100 with ATA 66 layout */

		{ 0x0640, &sis_info66 },
		{ 0x0630, &sis_info66 },
		{ 0x0620, &sis_info66 },
		{ 0x0540, &sis_info66 },
		{ 0x0530, &sis_info66 },

		{ 0x5600, &sis_info33 },
		{ 0x5598, &sis_info33 },
		{ 0x5597, &sis_info33 },
		{ 0x5591, &sis_info33 },
		{ 0x5582, &sis_info33 },
		{ 0x5581, &sis_info33 },

		{ 0x5596, &sis_info },
		{ 0x5571, &sis_info },
		{ 0x5517, &sis_info },
		{ 0x5511, &sis_info },

		{0}
	};
	static struct sis_chipset sis133_early = {
		0x0, &sis_info133_early
	};
	static struct sis_chipset sis133 = {
		0x0, &sis_info133
	};
	static struct sis_chipset sis100_early = {
		0x0, &sis_info100_early
	};
	static struct sis_chipset sis100 = {
		0x0, &sis_info100
	};

778
	ata_print_version_once(&pdev->dev, DRV_VERSION);
779

780 781 782
	rc = pcim_enable_device(pdev);
	if (rc)
		return rc;
783

784
	/* We have to find the bridge first */
Alan Cox's avatar
Alan Cox committed
785 786
	for (sets = &sis_chipsets[0]; sets->device; sets++) {
		host = pci_get_device(PCI_VENDOR_ID_SI, sets->device, NULL);
787
		if (host != NULL) {
Alan Cox's avatar
Alan Cox committed
788 789
			chipset = sets;			/* Match found */
			if (sets->device == 0x630) {	/* SIS630 */
790
				if (host->revision >= 0x30)	/* 630 ET */
791 792 793 794 795 796 797
					chipset = &sis100_early;
			}
			break;
		}
	}

	/* Look for concealed bridges */
Alan Cox's avatar
Alan Cox committed
798
	if (chipset == NULL) {
799 800 801 802 803 804 805 806 807 808 809 810 811 812
		/* Second check */
		u32 idemisc;
		u16 trueid;

		/* Disable ID masking and register remapping then
		   see what the real ID is */

		pci_read_config_dword(pdev, 0x54, &idemisc);
		pci_write_config_dword(pdev, 0x54, idemisc & 0x7fffffff);
		pci_read_config_word(pdev, PCI_DEVICE_ID, &trueid);
		pci_write_config_dword(pdev, 0x54, idemisc);

		switch(trueid) {
		case 0x5518:	/* SIS 962/963 */
813 814
			dev_info(&pdev->dev,
				 "SiS 962/963 MuTIOL IDE UDMA133 controller\n");
815 816 817
			chipset = &sis133;
			if ((idemisc & 0x40000000) == 0) {
				pci_write_config_dword(pdev, 0x54, idemisc | 0x40000000);
818 819
				dev_info(&pdev->dev,
					 "Switching to 5513 register mapping\n");
820 821 822
			}
			break;
		case 0x0180:	/* SIS 965/965L */
823
			chipset = &sis133;
824 825
			break;
		case 0x1180:	/* SIS 966/966L */
826
			chipset = &sis133;
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
			break;
		}
	}

	/* Further check */
	if (chipset == NULL) {
		struct pci_dev *lpc_bridge;
		u16 trueid;
		u8 prefctl;
		u8 idecfg;

		/* Try the second unmasking technique */
		pci_read_config_byte(pdev, 0x4a, &idecfg);
		pci_write_config_byte(pdev, 0x4a, idecfg | 0x10);
		pci_read_config_word(pdev, PCI_DEVICE_ID, &trueid);
		pci_write_config_byte(pdev, 0x4a, idecfg);

		switch(trueid) {
		case 0x5517:
			lpc_bridge = pci_get_slot(pdev->bus, 0x10); /* Bus 0 Dev 2 Fn 0 */
			if (lpc_bridge == NULL)
				break;
			pci_read_config_byte(pdev, 0x49, &prefctl);
			pci_dev_put(lpc_bridge);

852
			if (lpc_bridge->revision == 0x10 && (prefctl & 0x80)) {
853 854 855 856 857 858 859 860 861 862 863 864 865
				chipset = &sis133_early;
				break;
			}
			chipset = &sis100;
			break;
		}
	}
	pci_dev_put(host);

	/* No chipset info, no support */
	if (chipset == NULL)
		return -ENODEV;

866
	ppi[0] = chipset->info;
867 868 869

	sis_fixup(pdev, chipset);

870
	return ata_pci_bmdma_init_one(pdev, ppi, &sis_sht, chipset, 0);
871 872
}

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
#ifdef CONFIG_PM
static int sis_reinit_one(struct pci_dev *pdev)
{
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
	int rc;

	rc = ata_pci_device_do_resume(pdev);
	if (rc)
		return rc;

	sis_fixup(pdev, host->private_data);

	ata_host_resume(host);
	return 0;
}
#endif

890
static const struct pci_device_id sis_pci_tbl[] = {
891 892
	{ PCI_VDEVICE(SI, 0x5513), },	/* SiS 5513 */
	{ PCI_VDEVICE(SI, 0x5518), },	/* SiS 5518 */
893
	{ PCI_VDEVICE(SI, 0x1180), },	/* SiS 1180 */
894

895 896 897 898 899 900 901 902
	{ }
};

static struct pci_driver sis_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= sis_pci_tbl,
	.probe			= sis_init_one,
	.remove			= ata_pci_remove_one,
903
#ifdef CONFIG_PM
904
	.suspend		= ata_pci_device_suspend,
905
	.resume			= sis_reinit_one,
906
#endif
907 908
};

Axel Lin's avatar
Axel Lin committed
909
module_pci_driver(sis_pci_driver);
910 911 912 913 914 915

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("SCSI low-level driver for SiS ATA");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, sis_pci_tbl);
MODULE_VERSION(DRV_VERSION);