pata_efar.c 7.99 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 25
 *
 *    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/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_efar"
26
#define DRV_VERSION	"0.4.5"
27 28

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

Tejun Heo's avatar
Tejun Heo committed
37
static int efar_pre_reset(struct ata_link *link, unsigned long deadline)
38 39 40 41 42
{
	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
43
	struct ata_port *ap = link->ap;
44 45
	struct pci_dev *pdev = to_pci_dev(ap->host->dev);

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

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

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
/**
 *	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;
}

71 72
static DEFINE_SPINLOCK(efar_lock);

73 74 75
/**
 *	efar_set_piomode - Initialize host controller PATA PIO timings
 *	@ap: Port whose timings we are configuring
76
 *	@adev: Device to program
77 78 79 80 81 82 83 84 85 86 87
 *
 *	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);
88
	unsigned int master_port = ap->port_no ? 0x42 : 0x40;
89
	unsigned long flags;
90
	u16 master_data;
91
	u8 udma_enable;
92 93 94 95 96 97 98 99 100 101 102 103 104 105
	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 }, };

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

114 115
	spin_lock_irqsave(&efar_lock, flags);

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

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

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

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

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

	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);
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
}

/**
 *	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;
165
	unsigned long flags;
166 167 168 169 170 171 172 173 174
	u8 udma_enable;

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

175 176
	spin_lock_irqsave(&efar_lock, flags);

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 217
	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);
218
			slave_data &= ap->port_no ? 0x0F : 0xF0;
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
			/* 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);
234
	spin_unlock_irqrestore(&efar_lock, flags);
235 236 237
}

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

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


/**
 *	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)
{
266
	static const struct ata_port_info info = {
267
		.flags		= ATA_FLAG_SLAVE_POSS,
268
		.pio_mask	= ATA_PIO4,
269
		.mwdma_mask	= ATA_MWDMA12_ONLY,
270
		.udma_mask 	= ATA_UDMA4,
271 272
		.port_ops	= &efar_ops,
	};
273
	const struct ata_port_info *ppi[] = { &info, &info };
274

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

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

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

284 285 286 287 288 289 290 291
	{ }	/* 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,
292
#ifdef CONFIG_PM
293 294
	.suspend		= ata_pci_device_suspend,
	.resume			= ata_pci_device_resume,
295
#endif
296 297
};

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

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