pata_radisys.c 6.61 KB
Newer Older
1 2 3
/*
 *    pata_radisys.c - Intel PATA/SATA controllers
 *
4
 *	(C) 2006 Red Hat <alan@lxorguk.ukuu.org.uk>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 *    Some parts based on ata_piix.c by Jeff Garzik and others.
 *
 *    A PIIX relative, this device has a single ATA channel and no
 *    slave timings, SITRE or PPE. In that sense it is a close relative
 *    of the original PIIX. It does however support UDMA 33/66 per channel
 *    although no other modes/timings. Also lacking is 32bit I/O on the ATA
 *    port.
 */

#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_radisys"
27
#define DRV_VERSION	"0.4.4"
28 29 30

/**
 *	radisys_set_piomode - Initialize host controller PATA PIO timings
31 32
 *	@ap: ATA port
 *	@adev: Device whose timings we are configuring
33 34 35 36 37 38 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 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
 *
 *	Set PIO mode for device, in host controller PCI config space.
 *
 *	LOCKING:
 *	None (inherited from caller).
 */

static void radisys_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);
	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. The Radisys is a relative of the PIIX
	 *	but not the same so be careful.
	 */

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

	if (pio > 0)
		control |= 1;	/* TIME1 enable */
	if (ata_pio_need_iordy(adev))
		control |= 2;	/* IE IORDY */

	pci_read_config_word(dev, 0x40, &idetm_data);

	/* Enable IE and TIME as appropriate. Clear the other
	   drive timing bits */
	idetm_data &= 0xCCCC;
	idetm_data |= (control << (4 * adev->devno));
	idetm_data |= (timings[pio][0] << 12) |
			(timings[pio][1] << 8);
	pci_write_config_word(dev, 0x40, idetm_data);

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

/**
 *	radisys_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 radisys_set_dmamode (struct ata_port *ap, struct ata_device *adev)
{
	struct pci_dev *dev	= to_pci_dev(ap->host->dev);
	u16 idetm_data;
	u8 udma_enable;
96

97 98 99 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
	static const	 /* ISP  RTC */
	u8 timings[][2]	= { { 0, 0 },
			    { 0, 0 },
			    { 1, 1 },
			    { 2, 2 },
			    { 3, 3 }, };

	/*
	 * MWDMA is driven by the PIO timings. We must also enable
	 * IORDY unconditionally.
	 */

	pci_read_config_word(dev, 0x40, &idetm_data);
	pci_read_config_byte(dev, 0x48, &udma_enable);

	if (adev->dma_mode < XFER_UDMA_0) {
		unsigned int mwdma	= adev->dma_mode - XFER_MW_DMA_0;
		const unsigned int needed_pio[3] = {
			XFER_PIO_0, XFER_PIO_3, XFER_PIO_4
		};
		int pio = needed_pio[mwdma] - XFER_PIO_0;
		int control = 3;	/* IORDY|TIME0 */

		/* If the drive MWDMA is faster than it can do PIO then
		   we must force PIO0 for PIO cycles. */

		if (adev->pio_mode < needed_pio[mwdma])
			control = 1;

		/* Mask out the relevant control and timing bits we will load. Also
		   clear the other drive TIME register as a precaution */
128

129 130 131 132 133 134 135
		idetm_data &= 0xCCCC;
		idetm_data |= control << (4 * adev->devno);
		idetm_data |= (timings[pio][0] << 12) | (timings[pio][1] << 8);

		udma_enable &= ~(1 << adev->devno);
	} else {
		u8 udma_mode;
136

137
		/* UDMA66 on: UDMA 33 and 66 are switchable via register 0x4A */
138

139
		pci_read_config_byte(dev, 0x4A, &udma_mode);
140

141
		if (adev->xfer_mode == XFER_UDMA_2)
142
			udma_mode &= ~(2 << (adev->devno * 4));
143
		else /* UDMA 4 */
144
			udma_mode |= (2 << (adev->devno * 4));
145

146
		pci_write_config_byte(dev, 0x4A, udma_mode);
147

148 149 150 151 152 153 154 155 156 157
		udma_enable |= (1 << adev->devno);
	}
	pci_write_config_word(dev, 0x40, idetm_data);
	pci_write_config_byte(dev, 0x48, udma_enable);

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

/**
Tejun Heo's avatar
Tejun Heo committed
158
 *	radisys_qc_issue	-	command issue
159 160 161 162
 *	@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
163
 *	necessary. Our logic also clears TIME0/TIME1 for the other device so
164 165 166 167
 *	that, even if we get this wrong, cycles to the other device will
 *	be made PIO0.
 */

Tejun Heo's avatar
Tejun Heo committed
168
static unsigned int radisys_qc_issue(struct ata_queued_cmd *qc)
169 170 171 172 173 174 175 176 177 178 179 180 181
{
	struct ata_port *ap = qc->ap;
	struct ata_device *adev = qc->dev;

	if (adev != ap->private_data) {
		/* UDMA timing is not shared */
		if (adev->dma_mode < XFER_UDMA_0) {
			if (adev->dma_mode)
				radisys_set_dmamode(ap, adev);
			else if (adev->pio_mode)
				radisys_set_piomode(ap, adev);
		}
	}
182
	return ata_bmdma_qc_issue(qc);
183 184 185 186
}


static struct scsi_host_template radisys_sht = {
187
	ATA_BMDMA_SHT(DRV_NAME),
188 189
};

190 191
static struct ata_port_operations radisys_pata_ops = {
	.inherits		= &ata_bmdma_port_ops,
Tejun Heo's avatar
Tejun Heo committed
192
	.qc_issue		= radisys_qc_issue,
193
	.cable_detect		= ata_cable_unknown,
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
	.set_piomode		= radisys_set_piomode,
	.set_dmamode		= radisys_set_dmamode,
};


/**
 *	radisys_init_one - Register PIIX ATA PCI device with kernel services
 *	@pdev: PCI device to register
 *	@ent: Entry in radisys_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 radisys_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
{
216
	static const struct ata_port_info info = {
217
		.flags		= ATA_FLAG_SLAVE_POSS,
218
		.pio_mask	= ATA_PIO4,
219
		.mwdma_mask	= ATA_MWDMA12_ONLY,
220
		.udma_mask	= ATA_UDMA24_ONLY,
221 222
		.port_ops	= &radisys_pata_ops,
	};
223
	const struct ata_port_info *ppi[] = { &info, NULL };
224

225
	ata_print_version_once(&pdev->dev, DRV_VERSION);
226

227
	return ata_pci_bmdma_init_one(pdev, ppi, &radisys_sht, NULL, 0);
228 229 230
}

static const struct pci_device_id radisys_pci_tbl[] = {
231 232
	{ PCI_VDEVICE(RADISYS, 0x8201), },

233 234 235 236 237 238 239 240
	{ }	/* terminate list */
};

static struct pci_driver radisys_pci_driver = {
	.name			= DRV_NAME,
	.id_table		= radisys_pci_tbl,
	.probe			= radisys_init_one,
	.remove			= ata_pci_remove_one,
241
#ifdef CONFIG_PM
242 243
	.suspend		= ata_pci_device_suspend,
	.resume			= ata_pci_device_resume,
244
#endif
245 246
};

Axel Lin's avatar
Axel Lin committed
247
module_pci_driver(radisys_pci_driver);
248 249 250 251 252 253

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("SCSI low-level driver for Radisys R82600 controllers");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, radisys_pci_tbl);
MODULE_VERSION(DRV_VERSION);