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

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

441
	if (id->driver_data == 0)	/* 643 */
T
Tejun Heo 已提交
442
		ata_pci_bmdma_clear_simplex(pdev);
443

444 445
	if (pdev->device == PCI_DEVICE_ID_CMD_646) {
		/* Does UDMA work ? */
S
Sergei Shtylyov 已提交
446
		if (pdev->revision > 4)
T
Tejun Heo 已提交
447
			ppi[0] = &cmd_info[2];
448
		/* Early rev with other problems ? */
S
Sergei Shtylyov 已提交
449
		else if (pdev->revision == 1)
T
Tejun Heo 已提交
450
			ppi[0] = &cmd_info[3];
451 452
	}

453

454 455 456 457 458
	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);
459

460 461 462 463
	/* PPC specific fixup copied from old driver */
#ifdef CONFIG_PPC
	pci_write_config_byte(pdev, UDIDETCR0, 0xF0);
#endif
464 465 466 467 468
	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;
469

470 471
	pci_set_master(pdev);
	return ata_pci_sff_activate_host(host, cmd64x_interrupt, &cmd64x_sht);
472 473
}

474
#ifdef CONFIG_PM
A
Alan 已提交
475 476
static int cmd64x_reinit_one(struct pci_dev *pdev)
{
477
	struct ata_host *host = dev_get_drvdata(&pdev->dev);
A
Alan 已提交
478
	u8 mrdmode;
479 480 481 482 483 484
	int rc;

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

A
Alan 已提交
485 486 487 488 489 490 491 492
	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
493 494
	ata_host_resume(host);
	return 0;
A
Alan 已提交
495
}
496
#endif
A
Alan 已提交
497

498 499 500 501 502 503 504
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 },

	{ },
505 506 507
};

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

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