pata_efar.c 7.97 KB
Newer Older
1 2 3
/*
 *    pata_efar.c - EFAR PIIX clone controller driver
 *
4
 *	(C) 2005 Red Hat
5
 *	(C) 2009-2010 Bartlomiej Zolnierkiewicz
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 *    Some parts based on ata_piix.c by Jeff Garzik and others.
 *
 *    The EFAR is a PIIX4 clone with UDMA66 support. Unlike the later
 *    Intel ICH controllers the EFAR widened the UDMA mode register bits
 *    and doesn't require the funky clock selection.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.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_efar"
25
#define DRV_VERSION	"0.4.5"
26 27

/**
28
 *	efar_pre_reset	-	Enable bits
Tejun Heo's avatar
Tejun Heo committed
29
 *	@link: ATA link
30
 *	@deadline: deadline jiffies for the operation
31 32 33 34 35
 *
 *	Perform cable detection for the EFAR ATA interface. This is
 *	different to the PIIX arrangement
 */

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

45 46 47
	if (!pci_test_config_bits(pdev, &efar_enable_bits[ap->port_no]))
		return -ENOENT;

Tejun Heo's avatar
Tejun Heo committed
48
	return ata_sff_prereset(link, deadline);
49 50
}

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
/**
 *	efar_cable_detect	-	check for 40/80 pin
 *	@ap: Port
 *
 *	Perform cable detection for the EFAR ATA interface. This is
 *	different to the PIIX arrangement
 */

static int efar_cable_detect(struct ata_port *ap)
{
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);
	u8 tmp;

	pci_read_config_byte(pdev, 0x47, &tmp);
	if (tmp & (2 >> ap->port_no))
		return ATA_CBL_PATA40;
	return ATA_CBL_PATA80;
}

70 71
static DEFINE_SPINLOCK(efar_lock);

72 73 74
/**
 *	efar_set_piomode - Initialize host controller PATA PIO timings
 *	@ap: Port whose timings we are configuring
75
 *	@adev: Device to program
76 77 78 79 80 81 82 83 84 85 86
 *
 *	Set PIO mode for device, in host controller PCI config space.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void efar_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);
87
	unsigned int master_port = ap->port_no ? 0x42 : 0x40;
88
	unsigned long flags;
89
	u16 master_data;
90
	u8 udma_enable;
91 92 93 94 95 96 97 98 99 100 101 102 103 104
	int control = 0;

	/*
	 *	See Intel Document 298600-004 for the timing programing rules
	 *	for PIIX/ICH. The EFAR is a clone so very similar
	 */

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

105 106
	if (pio > 1)
		control |= 1;	/* TIME */
107
	if (ata_pio_need_iordy(adev))	/* PIO 3/4 require IORDY */
108 109
		control |= 2;	/* IE */
	/* Intel specifies that the prefetch/posting is for disk only */
110
	if (adev->class == ATA_DEV_ATA)
111
		control |= 4;	/* PPE */
112

113 114
	spin_lock_irqsave(&efar_lock, flags);

115
	pci_read_config_word(dev, master_port, &master_data);
116

117
	/* Set PPE, IE, and TIME as appropriate */
118
	if (adev->devno == 0) {
119 120 121
		master_data &= 0xCCF0;
		master_data |= control;
		master_data |= (timings[pio][0] << 12) |
122 123 124 125 126
			(timings[pio][1] << 8);
	} else {
		int shift = 4 * ap->port_no;
		u8 slave_data;

127 128
		master_data &= 0xFF0F;
		master_data |= (control << 4);
129

130
		/* Slave timing in separate register */
131
		pci_read_config_byte(dev, 0x44, &slave_data);
132
		slave_data &= ap->port_no ? 0x0F : 0xF0;
133 134 135 136
		slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << shift;
		pci_write_config_byte(dev, 0x44, slave_data);
	}

137 138
	master_data |= 0x4000;	/* Ensure SITRE is set */
	pci_write_config_word(dev, master_port, master_data);
139 140 141 142 143

	pci_read_config_byte(dev, 0x48, &udma_enable);
	udma_enable &= ~(1 << (2 * ap->port_no + adev->devno));
	pci_write_config_byte(dev, 0x48, udma_enable);
	spin_unlock_irqrestore(&efar_lock, flags);
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
}

/**
 *	efar_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 efar_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
	struct pci_dev *dev	= to_pci_dev(ap->host->dev);
	u8 master_port		= ap->port_no ? 0x42 : 0x40;
	u16 master_data;
	u8 speed		= adev->dma_mode;
	int devid		= adev->devno + 2 * ap->port_no;
164
	unsigned long flags;
165 166 167 168 169 170 171 172 173
	u8 udma_enable;

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

174 175
	spin_lock_irqsave(&efar_lock, flags);

176 177 178 179 180 181 182 183 184 185 186 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
	pci_read_config_word(dev, master_port, &master_data);
	pci_read_config_byte(dev, 0x48, &udma_enable);

	if (speed >= XFER_UDMA_0) {
		unsigned int udma	= adev->dma_mode - XFER_UDMA_0;
		u16 udma_timing;

		udma_enable |= (1 << devid);

		/* Load the UDMA mode number */
		pci_read_config_word(dev, 0x4A, &udma_timing);
		udma_timing &= ~(7 << (4 * devid));
		udma_timing |= udma << (4 * devid);
		pci_write_config_word(dev, 0x4A, udma_timing);
	} else {
		/*
		 * 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;
		u8 slave_data;
		const unsigned int needed_pio[3] = {
			XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
		};
		int pio = needed_pio[mwdma] - XFER_PIO_0;

		control = 3;	/* IORDY|TIME1 */

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

		if (adev->devno) {	/* Slave */
			master_data &= 0xFF4F;  /* Mask out IORDY|TIME1|DMAONLY */
			master_data |= control << 4;
			pci_read_config_byte(dev, 0x44, &slave_data);
217
			slave_data &= ap->port_no ? 0x0F : 0xF0;
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
			/* Load the matching timing */
			slave_data |= ((timings[pio][0] << 2) | timings[pio][1]) << (ap->port_no ? 4 : 0);
			pci_write_config_byte(dev, 0x44, slave_data);
		} else { 	/* Master */
			master_data &= 0xCCF4;	/* Mask out IORDY|TIME1|DMAONLY
						   and master timing bits */
			master_data |= control;
			master_data |=
				(timings[pio][0] << 12) |
				(timings[pio][1] << 8);
		}
		udma_enable &= ~(1 << devid);
		pci_write_config_word(dev, master_port, master_data);
	}
	pci_write_config_byte(dev, 0x48, udma_enable);
233
	spin_unlock_irqrestore(&efar_lock, flags);
234 235 236
}

static struct scsi_host_template efar_sht = {
237
	ATA_BMDMA_SHT(DRV_NAME),
238 239
};

240 241 242
static struct ata_port_operations efar_ops = {
	.inherits		= &ata_bmdma_port_ops,
	.cable_detect		= efar_cable_detect,
243 244
	.set_piomode		= efar_set_piomode,
	.set_dmamode		= efar_set_dmamode,
245
	.prereset		= efar_pre_reset,
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
};


/**
 *	efar_init_one - Register EFAR ATA PCI device with kernel services
 *	@pdev: PCI device to register
 *	@ent: Entry in efar_pci_tbl matching with @pdev
 *
 *	Called from kernel PCI layer.
 *
 *	LOCKING:
 *	Inherited from PCI layer (may sleep).
 *
 *	RETURNS:
 *	Zero on success, or -ERRNO value.
 */

static int efar_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
265
	static const struct ata_port_info info = {
266
		.flags		= ATA_FLAG_SLAVE_POSS,
267
		.pio_mask	= ATA_PIO4,
268
		.mwdma_mask	= ATA_MWDMA12_ONLY,
269
		.udma_mask 	= ATA_UDMA4,
270 271
		.port_ops	= &efar_ops,
	};
272
	const struct ata_port_info *ppi[] = { &info, &info };
273

274
	ata_print_version_once(&pdev->dev, DRV_VERSION);
275

276 277
	return ata_pci_bmdma_init_one(pdev, ppi, &efar_sht, NULL,
				      ATA_HOST_PARALLEL_SCAN);
278 279 280
}

static const struct pci_device_id efar_pci_tbl[] = {
281 282
	{ PCI_VDEVICE(EFAR, 0x9130), },

283 284 285 286 287 288 289 290
	{ }	/* terminate list */
};

static struct pci_driver efar_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= efar_pci_tbl,
	.probe			= efar_init_one,
	.remove			= ata_pci_remove_one,
291
#ifdef CONFIG_PM_SLEEP
292 293
	.suspend		= ata_pci_device_suspend,
	.resume			= ata_pci_device_resume,
294
#endif
295 296
};

Axel Lin's avatar
Axel Lin committed
297
module_pci_driver(efar_pci_driver);
298 299 300 301 302 303

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("SCSI low-level driver for EFAR PIIX clones");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, efar_pci_tbl);
MODULE_VERSION(DRV_VERSION);