pata_cmd64x.c 13.0 KB
Newer Older
1
/*
2
 * pata_cmd64x.c 	- CMD64x PATA for new ATA layer
3
 *			  (C) 2005 Red Hat Inc
4
 *			  Alan Cox <alan@lxorguk.ukuu.org.uk>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 * Based upon
 * linux/drivers/ide/pci/cmd64x.c		Version 1.30	Sept 10, 2002
 *
 * cmd64x.c: Enable interrupts at initialization time on Ultra/PCI machines.
 *           Note, this driver is not used at all on other systems because
 *           there the "BIOS" has done all of the following already.
 *           Due to massive hardware bugs, UltraDMA is only supported
 *           on the 646U2 and not on the 646U.
 *
 * Copyright (C) 1998		Eddie C. Dost  (ecd@skynet.be)
 * Copyright (C) 1998		David S. Miller (davem@redhat.com)
 *
 * Copyright (C) 1999-2002	Andre Hedrick <andre@linux-ide.org>
 *
 * TODO
 *	Testing work
 */
23

24 25 26 27 28 29 30 31 32 33
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <scsi/scsi_host.h>
#include <linux/libata.h>

#define DRV_NAME "pata_cmd64x"
34
#define DRV_VERSION "0.3.1"
35 36 37 38

/*
 * CMD64x specific registers definition.
 */
39

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
enum {
	CFR 		= 0x50,
		CFR_INTR_CH0  = 0x02,
	CNTRL 		= 0x51,
		CNTRL_DIS_RA0 = 0x40,
		CNTRL_DIS_RA1 = 0x80,
		CNTRL_ENA_2ND = 0x08,
	CMDTIM 		= 0x52,
	ARTTIM0 	= 0x53,
	DRWTIM0 	= 0x54,
	ARTTIM1 	= 0x55,
	DRWTIM1 	= 0x56,
	ARTTIM23 	= 0x57,
		ARTTIM23_DIS_RA2  = 0x04,
		ARTTIM23_DIS_RA3  = 0x08,
		ARTTIM23_INTR_CH1 = 0x10,
	ARTTIM2 	= 0x57,
	ARTTIM3 	= 0x57,
	DRWTIM23	= 0x58,
	DRWTIM2 	= 0x58,
	BRST 		= 0x59,
	DRWTIM3 	= 0x5b,
	BMIDECR0	= 0x70,
	MRDMODE		= 0x71,
		MRDMODE_INTR_CH0 = 0x04,
		MRDMODE_INTR_CH1 = 0x08,
		MRDMODE_BLK_CH0  = 0x10,
		MRDMODE_BLK_CH1	 = 0x20,
	BMIDESR0	= 0x72,
	UDIDETCR0	= 0x73,
	DTPR0		= 0x74,
	BMIDECR1	= 0x78,
	BMIDECSR	= 0x79,
	BMIDESR1	= 0x7A,
	UDIDETCR1	= 0x7B,
	DTPR1		= 0x7C
};

78
static int cmd648_cable_detect(struct ata_port *ap)
79 80 81 82 83 84 85
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 r;

	/* Check cable detect bits */
	pci_read_config_byte(pdev, BMIDECSR, &r);
	if (r & (1 << ap->port_no))
86 87
		return ATA_CBL_PATA80;
	return ATA_CBL_PATA40;
88 89 90
}

/**
91
 *	cmd64x_set_piomode	-	set PIO and MWDMA timing
92 93
 *	@ap: ATA interface
 *	@adev: ATA device
94
 *	@mode: mode
95
 *
96
 *	Called to do the PIO and MWDMA mode setup.
97
 */
98

99
static void cmd64x_set_timing(struct ata_port *ap, struct ata_device *adev, u8 mode)
100 101 102 103 104
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	struct ata_timing t;
	const unsigned long T = 1000000 / 33;
	const u8 setup_data[] = { 0x40, 0x40, 0x40, 0x80, 0x00 };
105

106
	u8 reg;
107

108
	/* Port layout is not logical so use a table */
109
	const u8 arttim_port[2][2] = {
110 111 112 113 114 115 116
		{ ARTTIM0, ARTTIM1 },
		{ ARTTIM23, ARTTIM23 }
	};
	const u8 drwtim_port[2][2] = {
		{ DRWTIM0, DRWTIM1 },
		{ DRWTIM2, DRWTIM3 }
	};
117

118 119
	int arttim = arttim_port[ap->port_no][adev->devno];
	int drwtim = drwtim_port[ap->port_no][adev->devno];
120

121 122 123
	/* 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) {
124 125 126 127 128 129
		printk(KERN_ERR DRV_NAME ": mode computation failed.\n");
		return;
	}
	if (ap->port_no) {
		/* Slave has shared address setup */
		struct ata_device *pair = ata_dev_pair(adev);
130

131 132 133 134 135 136
		if (pair) {
			struct ata_timing tp;
			ata_timing_compute(pair, pair->pio_mode, &tp, T, 0);
			ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
		}
	}
137

138 139 140 141 142 143 144 145
	printk(KERN_DEBUG DRV_NAME ": active %d recovery %d setup %d.\n",
		t.active, t.recover, t.setup);
	if (t.recover > 16) {
		t.active += t.recover - 16;
		t.recover = 16;
	}
	if (t.active > 16)
		t.active = 16;
146

147 148
	/* Now convert the clocks into values we can actually stuff into
	   the chip */
149

150 151 152 153
	if (t.recover > 1)
		t.recover--;
	else
		t.recover = 15;
154

155 156 157 158
	if (t.setup > 4)
		t.setup = 0xC0;
	else
		t.setup = setup_data[t.setup];
159

160
	t.active &= 0x0F;	/* 0 = 16 */
161

162 163 164 165 166
	/* Load setup timing */
	pci_read_config_byte(pdev, arttim, &reg);
	reg &= 0x3F;
	reg |= t.setup;
	pci_write_config_byte(pdev, arttim, reg);
167

168
	/* Load active/recovery */
169
	pci_write_config_byte(pdev, drwtim, (t.active << 4) | t.recover);
170 171
}

172 173 174 175 176 177 178 179 180 181 182 183 184 185
/**
 *	cmd64x_set_piomode	-	set initial PIO mode data
 *	@ap: ATA interface
 *	@adev: ATA device
 *
 *	Used when configuring the devices ot set the PIO timings. All the
 *	actual work is done by the PIO/MWDMA setting helper
 */

static void cmd64x_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	cmd64x_set_timing(ap, adev, adev->pio_mode);
}

186 187 188 189 190 191 192
/**
 *	cmd64x_set_dmamode	-	set initial DMA mode data
 *	@ap: ATA interface
 *	@adev: ATA device
 *
 *	Called to do the DMA mode setup.
 */
193

194 195 196
static void cmd64x_set_dmamode(struct ata_port *ap, struct ata_device *adev)
{
	static const u8 udma_data[] = {
197
		0x30, 0x20, 0x10, 0x20, 0x10, 0x00
198
	};
199

200 201 202 203 204 205
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 regU, regD;

	int pciU = UDIDETCR0 + 8 * ap->port_no;
	int pciD = BMIDESR0 + 8 * ap->port_no;
	int shift = 2 * adev->devno;
206

207 208 209
	pci_read_config_byte(pdev, pciD, &regD);
	pci_read_config_byte(pdev, pciU, &regU);

210 211 212 213 214 215
	/* DMA bits off */
	regD &= ~(0x20 << adev->devno);
	/* DMA control bits */
	regU &= ~(0x30 << shift);
	/* DMA timing bits */
	regU &= ~(0x05 << adev->devno);
216

217
	if (adev->dma_mode >= XFER_UDMA_0) {
A
Adrian Bunk 已提交
218
		/* Merge the timing value */
219
		regU |= udma_data[adev->dma_mode - XFER_UDMA_0] << shift;
220 221 222 223
		/* Merge the control bits */
		regU |= 1 << adev->devno; /* UDMA on */
		if (adev->dma_mode > 2)	/* 15nS timing */
			regU |= 4 << adev->devno;
224 225 226 227
	} else {
		regU &= ~ (1 << adev->devno);	/* UDMA off */
		cmd64x_set_timing(ap, adev, adev->dma_mode);
	}
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246

	regD |= 0x20 << adev->devno;

	pci_write_config_byte(pdev, pciU, regU);
	pci_write_config_byte(pdev, pciD, regD);
}

/**
 *	cmd648_dma_stop	-	DMA stop callback
 *	@qc: Command in progress
 *
 *	DMA has completed.
 */

static void cmd648_bmdma_stop(struct ata_queued_cmd *qc)
{
	struct ata_port *ap = qc->ap;
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 dma_intr;
247 248
	int dma_mask = ap->port_no ? ARTTIM23_INTR_CH1 : CFR_INTR_CH0;
	int dma_reg = ap->port_no ? ARTTIM2 : CFR;
249

250
	ata_bmdma_stop(qc);
251

252 253 254
	pci_read_config_byte(pdev, dma_reg, &dma_intr);
	pci_write_config_byte(pdev, dma_reg, dma_intr | dma_mask);
}
255

256
/**
257
 *	cmd64x_bmdma_stop	-	DMA stop callback
258 259
 *	@qc: Command in progress
 *
260 261
 *	Track the completion of live DMA commands and clear the
 *	host->private_data DMA tracking flag as we do.
262 263
 */

264
static void cmd64x_bmdma_stop(struct ata_queued_cmd *qc)
265
{
266
	struct ata_port *ap = qc->ap;
267
	ata_bmdma_stop(qc);
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
	WARN_ON(ap->host->private_data != ap);
	ap->host->private_data = NULL;
}

/**
 *	cmd64x_qc_defer		-	Defer logic for chip limits
 *	@qc: queued command
 *
 *	Decide whether we can issue the command. Called under the host lock.
 */

static int cmd64x_qc_defer(struct ata_queued_cmd *qc)
{
	struct ata_host *host = qc->ap->host;
	struct ata_port *alt = host->ports[1 ^ qc->ap->port_no];
	int rc;
	int dma = 0;

	/* Apply the ATA rules first */
	rc = ata_std_qc_defer(qc);
	if (rc)
		return rc;

	if (qc->tf.protocol == ATAPI_PROT_DMA ||
			qc->tf.protocol == ATA_PROT_DMA)
		dma = 1;

	/* If the other port is not live then issue the command */
	if (alt == NULL || !alt->qc_active) {
		if (dma)
			host->private_data = qc->ap;
		return 0;
	}
	/* If there is a live DMA command then wait */
	if (host->private_data != NULL)
		return 	ATA_DEFER_PORT;
	if (dma)
		/* Cannot overlap our DMA command */
		return ATA_DEFER_PORT;
	return 0;
308
}
309

310 311 312 313 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 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
/**
 *	cmd64x_interrupt - ATA host interrupt handler
 *	@irq: irq line (unused)
 *	@dev_instance: pointer to our ata_host information structure
 *
 *	Our interrupt handler for PCI IDE devices.  Calls
 *	ata_sff_host_intr() for each port that is flagging an IRQ. We cannot
 *	use the defaults as we need to avoid touching status/altstatus during
 *	a DMA.
 *
 *	LOCKING:
 *	Obtains host lock during operation.
 *
 *	RETURNS:
 *	IRQ_NONE or IRQ_HANDLED.
 */
irqreturn_t cmd64x_interrupt(int irq, void *dev_instance)
{
	struct ata_host *host = dev_instance;
	struct pci_dev *pdev = to_pci_dev(host->dev);
	unsigned int i;
	unsigned int handled = 0;
	unsigned long flags;
	static const u8 irq_reg[2] = { CFR, ARTTIM23 };
	static const u8 irq_mask[2] = { 1 << 2, 1 << 4 };

	/* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
	spin_lock_irqsave(&host->lock, flags);

	for (i = 0; i < host->n_ports; i++) {
		struct ata_port *ap;
		u8 reg;

		pci_read_config_byte(pdev, irq_reg[i], &reg);
		ap = host->ports[i];
		if (ap && (reg & irq_mask[i]) &&
		    !(ap->flags & ATA_FLAG_DISABLED)) {
			struct ata_queued_cmd *qc;

			qc = ata_qc_from_tag(ap, ap->link.active_tag);
			if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
			    (qc->flags & ATA_QCFLAG_ACTIVE))
				handled |= ata_sff_host_intr(ap, qc);
		}
	}

	spin_unlock_irqrestore(&host->lock, flags);

	return IRQ_RETVAL(handled);
}
360
static struct scsi_host_template cmd64x_sht = {
361
	ATA_BMDMA_SHT(DRV_NAME),
362 363
};

364 365
static const struct ata_port_operations cmd64x_base_ops = {
	.inherits	= &ata_bmdma_port_ops,
366 367
	.set_piomode	= cmd64x_set_piomode,
	.set_dmamode	= cmd64x_set_dmamode,
368 369
	.bmdma_stop	= cmd64x_bmdma_stop,
	.qc_defer	= cmd64x_qc_defer,
370
};
371

372 373
static struct ata_port_operations cmd64x_port_ops = {
	.inherits	= &cmd64x_base_ops,
374
	.cable_detect	= ata_cable_40wire,
375
};
376

377 378 379
static struct ata_port_operations cmd646r1_port_ops = {
	.inherits	= &cmd64x_base_ops,
	.cable_detect	= ata_cable_40wire,
380
};
381 382

static struct ata_port_operations cmd648_port_ops = {
383
	.inherits	= &cmd64x_base_ops,
384
	.bmdma_stop	= cmd648_bmdma_stop,
385
	.cable_detect	= cmd648_cable_detect,
386
	.qc_defer	= ata_std_qc_defer
387 388
};

389 390 391
static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
{
	u32 class_rev;
392

T
Tejun Heo 已提交
393
	static const struct ata_port_info cmd_info[6] = {
394
		{	/* CMD 643 - no UDMA */
395
			.flags = ATA_FLAG_SLAVE_POSS,
396 397
			.pio_mask = ATA_PIO4,
			.mwdma_mask = ATA_MWDMA2,
398 399 400
			.port_ops = &cmd64x_port_ops
		},
		{	/* CMD 646 with broken UDMA */
401
			.flags = ATA_FLAG_SLAVE_POSS,
402 403
			.pio_mask = ATA_PIO4,
			.mwdma_mask = ATA_MWDMA2,
404 405 406
			.port_ops = &cmd64x_port_ops
		},
		{	/* CMD 646 with working UDMA */
407
			.flags = ATA_FLAG_SLAVE_POSS,
408 409
			.pio_mask = ATA_PIO4,
			.mwdma_mask = ATA_MWDMA2,
A
Alan Cox 已提交
410
			.udma_mask = ATA_UDMA2,
411 412 413
			.port_ops = &cmd64x_port_ops
		},
		{	/* CMD 646 rev 1  */
414
			.flags = ATA_FLAG_SLAVE_POSS,
415 416
			.pio_mask = ATA_PIO4,
			.mwdma_mask = ATA_MWDMA2,
417 418 419
			.port_ops = &cmd646r1_port_ops
		},
		{	/* CMD 648 */
420
			.flags = ATA_FLAG_SLAVE_POSS,
421 422
			.pio_mask = ATA_PIO4,
			.mwdma_mask = ATA_MWDMA2,
A
Alan Cox 已提交
423
			.udma_mask = ATA_UDMA4,
424 425 426
			.port_ops = &cmd648_port_ops
		},
		{	/* CMD 649 */
427
			.flags = ATA_FLAG_SLAVE_POSS,
428 429
			.pio_mask = ATA_PIO4,
			.mwdma_mask = ATA_MWDMA2,
A
Alan Cox 已提交
430
			.udma_mask = ATA_UDMA5,
431 432 433
			.port_ops = &cmd648_port_ops
		}
	};
T
Tejun Heo 已提交
434
	const struct ata_port_info *ppi[] = { &cmd_info[id->driver_data], NULL };
435
	u8 mrdmode;
436
	int rc;
437
	struct ata_host *host;
438 439 440 441

	rc = pcim_enable_device(pdev);
	if (rc)
		return rc;
442

443 444
	pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
	class_rev &= 0xFF;
445

446
	if (id->driver_data == 0)	/* 643 */
T
Tejun Heo 已提交
447
		ata_pci_bmdma_clear_simplex(pdev);
448

449 450 451
	if (pdev->device == PCI_DEVICE_ID_CMD_646) {
		/* Does UDMA work ? */
		if (class_rev > 4)
T
Tejun Heo 已提交
452
			ppi[0] = &cmd_info[2];
453 454
		/* Early rev with other problems ? */
		else if (class_rev == 1)
T
Tejun Heo 已提交
455
			ppi[0] = &cmd_info[3];
456 457
	}

458

459 460 461 462 463
	pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
	pci_read_config_byte(pdev, MRDMODE, &mrdmode);
	mrdmode &= ~ 0x30;	/* IRQ set up */
	mrdmode |= 0x02;	/* Memory read line enable */
	pci_write_config_byte(pdev, MRDMODE, mrdmode);
464

465 466 467 468
	/* PPC specific fixup copied from old driver */
#ifdef CONFIG_PPC
	pci_write_config_byte(pdev, UDIDETCR0, 0xF0);
#endif
469 470 471 472 473
	rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
	if (rc)
		return rc;
	/* We use this pointer to track the AP which has DMA running */
	host->private_data = NULL;
474

475 476
	pci_set_master(pdev);
	return ata_pci_sff_activate_host(host, cmd64x_interrupt, &cmd64x_sht);
477 478
}

479
#ifdef CONFIG_PM
A
Alan 已提交
480 481
static int cmd64x_reinit_one(struct pci_dev *pdev)
{
482
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
A
Alan 已提交
483
	u8 mrdmode;
484 485 486 487 488 489
	int rc;

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

A
Alan 已提交
490 491 492 493 494 495 496 497
	pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
	pci_read_config_byte(pdev, MRDMODE, &mrdmode);
	mrdmode &= ~ 0x30;	/* IRQ set up */
	mrdmode |= 0x02;	/* Memory read line enable */
	pci_write_config_byte(pdev, MRDMODE, mrdmode);
#ifdef CONFIG_PPC
	pci_write_config_byte(pdev, UDIDETCR0, 0xF0);
#endif
498 499
	ata_host_resume(host);
	return 0;
A
Alan 已提交
500
}
501
#endif
A
Alan 已提交
502

503 504 505 506 507 508 509
static const struct pci_device_id cmd64x[] = {
	{ PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_643), 0 },
	{ PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_646), 1 },
	{ PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_648), 4 },
	{ PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_649), 5 },

	{ },
510 511 512
};

static struct pci_driver cmd64x_pci_driver = {
513
	.name 		= DRV_NAME,
514 515
	.id_table	= cmd64x,
	.probe 		= cmd64x_init_one,
A
Alan 已提交
516
	.remove		= ata_pci_remove_one,
517
#ifdef CONFIG_PM
A
Alan 已提交
518 519
	.suspend	= ata_pci_device_suspend,
	.resume		= cmd64x_reinit_one,
520
#endif
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
};

static int __init cmd64x_init(void)
{
	return pci_register_driver(&cmd64x_pci_driver);
}

static void __exit cmd64x_exit(void)
{
	pci_unregister_driver(&cmd64x_pci_driver);
}

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("low-level driver for CMD64x series PATA controllers");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, cmd64x);
MODULE_VERSION(DRV_VERSION);

module_init(cmd64x_init);
module_exit(cmd64x_exit);