pata_oldpiix.c 7.17 KB
Newer Older
1 2 3
/*
 *    pata_oldpiix.c - Intel PATA/SATA controllers
 *
4
 *	(C) 2005 Red Hat
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 *    Some parts based on ata_piix.c by Jeff Garzik and others.
 *
 *    Early PIIX differs significantly from the later PIIX as it lacks
 *    SITRE and the slave timing registers. This means that you have to
 *    set timing per channel, or be clever. Libata tells us whenever it
 *    does drive selection and we use this to reload the timings.
 *
 *    Because of these behaviour differences PIIX gets its own driver module.
 */

#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>

#define DRV_NAME	"pata_oldpiix"
28
#define DRV_VERSION	"0.5.5"
29 30 31

/**
 *	oldpiix_pre_reset		-	probe begin
Tejun Heo's avatar
Tejun Heo committed
32
 *	@link: ATA link
33
 *	@deadline: deadline jiffies for the operation
34 35 36 37
 *
 *	Set up cable type and use generic probe init
 */

Tejun Heo's avatar
Tejun Heo committed
38
static int oldpiix_pre_reset(struct ata_link *link, unsigned long deadline)
39
{
Tejun Heo's avatar
Tejun Heo committed
40
	struct ata_port *ap = link->ap;
41 42 43 44 45 46
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	static const struct pci_bits oldpiix_enable_bits[] = {
		{ 0x41U, 1U, 0x80UL, 0x80UL },	/* port 0 */
		{ 0x43U, 1U, 0x80UL, 0x80UL },	/* port 1 */
	};

47 48
	if (!pci_test_config_bits(pdev, &oldpiix_enable_bits[ap->port_no]))
		return -ENOENT;
49

Tejun Heo's avatar
Tejun Heo committed
50
	return ata_sff_prereset(link, deadline);
51 52 53 54 55
}

/**
 *	oldpiix_set_piomode - Initialize host controller PATA PIO timings
 *	@ap: Port whose timings we are configuring
56
 *	@adev: Device whose timings we are configuring
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
 *
 *	Set PIO mode for device, in host controller PCI config space.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void oldpiix_set_piomode (struct ata_port *ap, struct ata_device *adev)
{
	unsigned int pio	= adev->pio_mode - XFER_PIO_0;
	struct pci_dev *dev	= to_pci_dev(ap->host->dev);
	unsigned int idetm_port= ap->port_no ? 0x42 : 0x40;
	u16 idetm_data;
	int control = 0;

	/*
	 *	See Intel Document 298600-004 for the timing programing rules
	 *	for PIIX/ICH. Note that the early PIIX does not have the slave
	 *	timing port at 0x44.
	 */

	static const	 /* ISP  RTC */
	u8 timings[][2]	= { { 0, 0 },
			    { 0, 0 },
			    { 1, 0 },
			    { 2, 1 },
			    { 2, 3 }, };

85 86
	if (pio > 1)
		control |= 1;	/* TIME */
87
	if (ata_pio_need_iordy(adev))
88
		control |= 2;	/* IE */
89

90
	/* Intel specifies that the prefetch/posting is for disk only */
91
	if (adev->class == ATA_DEV_ATA)
92
		control |= 4;	/* PPE */
93 94 95

	pci_read_config_word(dev, idetm_port, &idetm_data);

96 97 98 99
	/*
	 * Set PPE, IE and TIME as appropriate.
	 * Clear the other drive's timing bits.
	 */
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
	if (adev->devno == 0) {
		idetm_data &= 0xCCE0;
		idetm_data |= control;
	} else {
		idetm_data &= 0xCC0E;
		idetm_data |= (control << 4);
	}
	idetm_data |= (timings[pio][0] << 12) |
			(timings[pio][1] << 8);
	pci_write_config_word(dev, idetm_port, idetm_data);

	/* Track which port is configured */
	ap->private_data = adev;
}

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

static void oldpiix_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
	struct pci_dev *dev	= to_pci_dev(ap->host->dev);
	u8 idetm_port		= ap->port_no ? 0x42 : 0x40;
	u16 idetm_data;

	static const	 /* ISP  RTC */
	u8 timings[][2]	= { { 0, 0 },
			    { 0, 0 },
			    { 1, 0 },
			    { 2, 1 },
			    { 2, 3 }, };

	/*
	 * MWDMA is driven by the PIO timings. We must also enable
	 * IORDY unconditionally along with TIME1. PPE has already
	 * been set when the PIO timing was set.
	 */

	unsigned int mwdma	= adev->dma_mode - XFER_MW_DMA_0;
	unsigned int control;
	const unsigned int needed_pio[3] = {
		XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
	};
	int pio = needed_pio[mwdma] - XFER_PIO_0;

	pci_read_config_word(dev, idetm_port, &idetm_data);

	control = 3;	/* IORDY|TIME0 */
	/* 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 (adev->pio_mode < needed_pio[mwdma])
		/* Enable DMA timing only */
		control |= 8;	/* PIO cycles in PIO0 */

	/* Mask out the relevant control and timing bits we will load. Also
	   clear the other drive TIME register as a precaution */
	if (adev->devno == 0) {
		idetm_data &= 0xCCE0;
		idetm_data |= control;
	} else {
		idetm_data &= 0xCC0E;
		idetm_data |= (control << 4);
	}
	idetm_data |= (timings[pio][0] << 12) | (timings[pio][1] << 8);
	pci_write_config_word(dev, idetm_port, idetm_data);

	/* Track which port is configured */
	ap->private_data = adev;
}

/**
Tejun Heo's avatar
Tejun Heo committed
183
 *	oldpiix_qc_issue	-	command issue
184 185 186 187
 *	@qc: command pending
 *
 *	Called when the libata layer is about to issue a command. We wrap
 *	this interface so that we can load the correct ATA timings if
188
 *	necessary. Our logic also clears TIME0/TIME1 for the other device so
189 190 191 192
 *	that, even if we get this wrong, cycles to the other device will
 *	be made PIO0.
 */

Tejun Heo's avatar
Tejun Heo committed
193
static unsigned int oldpiix_qc_issue(struct ata_queued_cmd *qc)
194 195 196 197 198
{
	struct ata_port *ap = qc->ap;
	struct ata_device *adev = qc->dev;

	if (adev != ap->private_data) {
199
		oldpiix_set_piomode(ap, adev);
200
		if (ata_dma_enabled(adev))
201 202
			oldpiix_set_dmamode(ap, adev);
	}
203
	return ata_bmdma_qc_issue(qc);
204 205 206 207
}


static struct scsi_host_template oldpiix_sht = {
208
	ATA_BMDMA_SHT(DRV_NAME),
209 210
};

211 212
static struct ata_port_operations oldpiix_pata_ops = {
	.inherits		= &ata_bmdma_port_ops,
Tejun Heo's avatar
Tejun Heo committed
213
	.qc_issue		= oldpiix_qc_issue,
214
	.cable_detect		= ata_cable_40wire,
215 216
	.set_piomode		= oldpiix_set_piomode,
	.set_dmamode		= oldpiix_set_dmamode,
217
	.prereset		= oldpiix_pre_reset,
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
};


/**
 *	oldpiix_init_one - Register PIIX ATA PCI device with kernel services
 *	@pdev: PCI device to register
 *	@ent: Entry in oldpiix_pci_tbl matching with @pdev
 *
 *	Called from kernel PCI layer.  We probe for combined mode (sigh),
 *	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 oldpiix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
238
	static const struct ata_port_info info = {
239
		.flags		= ATA_FLAG_SLAVE_POSS,
240
		.pio_mask	= ATA_PIO4,
241
		.mwdma_mask	= ATA_MWDMA12_ONLY,
242 243
		.port_ops	= &oldpiix_pata_ops,
	};
244
	const struct ata_port_info *ppi[] = { &info, NULL };
245

246
	ata_print_version_once(&pdev->dev, DRV_VERSION);
247

248
	return ata_pci_bmdma_init_one(pdev, ppi, &oldpiix_sht, NULL, 0);
249 250 251
}

static const struct pci_device_id oldpiix_pci_tbl[] = {
252 253
	{ PCI_VDEVICE(INTEL, 0x1230), },

254 255 256 257 258 259 260 261
	{ }	/* terminate list */
};

static struct pci_driver oldpiix_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= oldpiix_pci_tbl,
	.probe			= oldpiix_init_one,
	.remove			= ata_pci_remove_one,
262
#ifdef CONFIG_PM
263 264
	.suspend		= ata_pci_device_suspend,
	.resume			= ata_pci_device_resume,
265
#endif
266 267
};

Axel Lin's avatar
Axel Lin committed
268
module_pci_driver(oldpiix_pci_driver);
269 270 271 272 273 274

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("SCSI low-level driver for early PIIX series controllers");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, oldpiix_pci_tbl);
MODULE_VERSION(DRV_VERSION);