sc1200.c 9.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * Copyright (C) 2000-2002		Mark Lord <mlord@pobox.com>
3 4
 * Copyright (C)      2007		Bartlomiej Zolnierkiewicz
 *
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * May be copied or modified under the terms of the GNU General Public License
 *
 * Development of this chipset driver was funded
 * by the nice folks at National Semiconductor.
 *
 * Documentation:
 *	Available from National Semiconductor
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/ide.h>
#include <linux/pm.h>
21

Linus Torvalds's avatar
Linus Torvalds committed
22 23
#include <asm/io.h>

24 25
#define DRV_NAME "sc1200"

Linus Torvalds's avatar
Linus Torvalds committed
26 27 28 29 30 31 32 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
#define SC1200_REV_A	0x00
#define SC1200_REV_B1	0x01
#define SC1200_REV_B3	0x02
#define SC1200_REV_C1	0x03
#define SC1200_REV_D1	0x04

#define PCI_CLK_33	0x00
#define PCI_CLK_48	0x01
#define PCI_CLK_66	0x02
#define PCI_CLK_33A	0x03

static unsigned short sc1200_get_pci_clock (void)
{
	unsigned char chip_id, silicon_revision;
	unsigned int pci_clock;
	/*
	 * Check the silicon revision, as not all versions of the chip
	 * have the register with the fast PCI bus timings.
	 */
	chip_id = inb (0x903c);
	silicon_revision = inb (0x903d);

	// Read the fast pci clock frequency
	if (chip_id == 0x04 && silicon_revision < SC1200_REV_B1) {
		pci_clock = PCI_CLK_33;
	} else {
		// check clock generator configuration (cfcc)
		// the clock is in bits 8 and 9 of this word

		pci_clock = inw (0x901e);
		pci_clock >>= 8;
		pci_clock &= 0x03;
		if (pci_clock == PCI_CLK_33A)
			pci_clock = PCI_CLK_33;
	}
	return pci_clock;
}

/*
 * Here are the standard PIO mode 0-4 timings for each "format".
 * Format-0 uses fast data reg timings, with slower command reg timings.
 * Format-1 uses fast timings for all registers, but won't work with all drives.
 */
static const unsigned int sc1200_pio_timings[4][5] =
	{{0x00009172, 0x00012171, 0x00020080, 0x00032010, 0x00040010},	// format0  33Mhz
	 {0xd1329172, 0x71212171, 0x30200080, 0x20102010, 0x00100010},	// format1, 33Mhz
	 {0xfaa3f4f3, 0xc23232b2, 0x513101c1, 0x31213121, 0x10211021},	// format1, 48Mhz
	 {0xfff4fff4, 0xf35353d3, 0x814102f1, 0x42314231, 0x11311131}};	// format1, 66Mhz

/*
 * After chip reset, the PIO timings are set to 0x00009172, which is not valid.
 */
//#define SC1200_BAD_PIO(timings) (((timings)&~0x80000000)==0x00009172)

80 81 82
static void sc1200_tunepio(ide_drive_t *drive, u8 pio)
{
	ide_hwif_t *hwif = drive->hwif;
83
	struct pci_dev *pdev = to_pci_dev(hwif->dev);
84 85 86 87 88 89 90 91 92 93
	unsigned int basereg = hwif->channel ? 0x50 : 0x40, format = 0;

	pci_read_config_dword(pdev, basereg + 4, &format);
	format = (format >> 31) & 1;
	if (format)
		format += sc1200_get_pci_clock();
	pci_write_config_dword(pdev, basereg + ((drive->dn & 1) << 3),
			       sc1200_pio_timings[format][pio]);
}

94 95 96 97 98 99 100 101 102 103
/*
 *	The SC1200 specifies that two drives sharing a cable cannot mix
 *	UDMA/MDMA.  It has to be one or the other, for the pair, though
 *	different timings can still be chosen for each drive.  We could
 *	set the appropriate timing bits on the fly, but that might be
 *	a bit confusing.  So, for now we statically handle this requirement
 *	by looking at our mate drive to see what it is capable of, before
 *	choosing a mode for our own drive.
 */
static u8 sc1200_udma_filter(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
104
{
105
	ide_hwif_t *hwif = drive->hwif;
106
	ide_drive_t *mate = ide_get_pair_dev(drive);
107
	u16 *mateid = mate->id;
108 109
	u8 mask = hwif->ultra_mask;

110
	if (mate == NULL)
111 112
		goto out;

113
	if (ata_id_has_dma(mateid) && __ide_dma_bad_drive(mate) == 0) {
114 115
		if ((mateid[ATA_ID_FIELD_VALID] & 4) &&
		    (mateid[ATA_ID_UDMA_MODES] & 7))
116
			goto out;
117 118
		if ((mateid[ATA_ID_FIELD_VALID] & 2) &&
		    (mateid[ATA_ID_MWDMA_MODES] & 7))
119
			mask = 0;
Linus Torvalds's avatar
Linus Torvalds committed
120
	}
121 122
out:
	return mask;
Linus Torvalds's avatar
Linus Torvalds committed
123 124
}

125
static void sc1200_set_dma_mode(ide_drive_t *drive, const u8 mode)
Linus Torvalds's avatar
Linus Torvalds committed
126 127
{
	ide_hwif_t		*hwif = HWIF(drive);
128
	struct pci_dev		*dev = to_pci_dev(hwif->dev);
Linus Torvalds's avatar
Linus Torvalds committed
129 130 131 132
	unsigned int		reg, timings;
	unsigned short		pci_clock;
	unsigned int		basereg = hwif->channel ? 0x50 : 0x40;

133 134 135 136 137 138 139 140 141 142 143 144
	static const u32 udma_timing[3][3] = {
		{ 0x00921250, 0x00911140, 0x00911030 },
		{ 0x00932470, 0x00922260, 0x00922140 },
		{ 0x009436a1, 0x00933481, 0x00923261 },
	};

	static const u32 mwdma_timing[3][3] = {
		{ 0x00077771, 0x00012121, 0x00002020 },
		{ 0x000bbbb2, 0x00024241, 0x00013131 },
		{ 0x000ffff3, 0x00035352, 0x00015151 },
	};

Linus Torvalds's avatar
Linus Torvalds committed
145 146 147 148 149 150
	pci_clock = sc1200_get_pci_clock();

	/*
	 * Note that each DMA mode has several timings associated with it.
	 * The correct timing depends on the fast PCI clock freq.
	 */
151 152 153 154 155

	if (mode >= XFER_UDMA_0)
		timings =  udma_timing[pci_clock][mode - XFER_UDMA_0];
	else
		timings = mwdma_timing[pci_clock][mode - XFER_MW_DMA_0];
Linus Torvalds's avatar
Linus Torvalds committed
156

157
	if ((drive->dn & 1) == 0) {
158
		pci_read_config_dword(dev, basereg + 4, &reg);
Linus Torvalds's avatar
Linus Torvalds committed
159
		timings |= reg & 0x80000000;	/* preserve PIO format bit */
160 161 162
		pci_write_config_dword(dev, basereg + 4, timings);
	} else
		pci_write_config_dword(dev, basereg + 12, timings);
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165 166 167 168 169
}

/*  Replacement for the standard ide_dma_end action in
 *  dma_proc.
 *
 *  returns 1 on error, 0 otherwise
 */
170
static int sc1200_dma_end(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
{
	ide_hwif_t *hwif = HWIF(drive);
	unsigned long dma_base = hwif->dma_base;
	byte dma_stat;

	dma_stat = inb(dma_base+2);		/* get DMA status */

	if (!(dma_stat & 4))
		printk(" ide_dma_end dma_stat=%0x err=%x newerr=%x\n",
		  dma_stat, ((dma_stat&7)!=4), ((dma_stat&2)==2));

	outb(dma_stat|0x1b, dma_base+2);	/* clear the INTR & ERROR bits */
	outb(inb(dma_base)&~1, dma_base);	/* !! DO THIS HERE !! stop DMA */

	drive->waiting_for_dma = 0;
	ide_destroy_dmatable(drive);		/* purge DMA mappings */

	return (dma_stat & 7) != 4;		/* verify good DMA status */
}

/*
192
 * sc1200_set_pio_mode() handles setting of PIO modes
Linus Torvalds's avatar
Linus Torvalds committed
193 194 195 196 197
 * for both the chipset and drive.
 *
 * All existing BIOSs for this chipset guarantee that all drives
 * will have valid default PIO timings set up before we get here.
 */
198 199

static void sc1200_set_pio_mode(ide_drive_t *drive, const u8 pio)
Linus Torvalds's avatar
Linus Torvalds committed
200 201 202 203
{
	ide_hwif_t	*hwif = HWIF(drive);
	int		mode = -1;

204
	/*
205
	 * bad abuse of ->set_pio_mode interface
206
	 */
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209 210 211 212 213 214 215 216
	switch (pio) {
		case 200: mode = XFER_UDMA_0;	break;
		case 201: mode = XFER_UDMA_1;	break;
		case 202: mode = XFER_UDMA_2;	break;
		case 100: mode = XFER_MW_DMA_0;	break;
		case 101: mode = XFER_MW_DMA_1;	break;
		case 102: mode = XFER_MW_DMA_2;	break;
	}
	if (mode != -1) {
		printk("SC1200: %s: changing (U)DMA mode\n", drive->name);
217
		ide_dma_off_quietly(drive);
218 219
		if (ide_set_dma_mode(drive, mode) == 0 &&
		    (drive->dev_flags & IDE_DFLAG_USING_DMA))
220
			hwif->dma_ops->dma_host_set(drive, 1);
Linus Torvalds's avatar
Linus Torvalds committed
221 222 223
		return;
	}

224
	sc1200_tunepio(drive, pio);
Linus Torvalds's avatar
Linus Torvalds committed
225 226
}

227
#ifdef CONFIG_PM
228 229 230
struct sc1200_saved_state {
	u32 regs[8];
};
Linus Torvalds's avatar
Linus Torvalds committed
231

232
static int sc1200_suspend (struct pci_dev *dev, pm_message_t state)
Linus Torvalds's avatar
Linus Torvalds committed
233
{
234
	printk("SC1200: suspend(%u)\n", state.event);
Linus Torvalds's avatar
Linus Torvalds committed
235

236 237 238
	/*
	 * we only save state when going from full power to less
	 */
239
	if (state.event == PM_EVENT_ON) {
240 241
		struct ide_host *host = pci_get_drvdata(dev);
		struct sc1200_saved_state *ss = host->host_priv;
242 243 244 245 246 247 248 249 250
		unsigned int r;

		/*
		 * save timing registers
		 * (this may be unnecessary if BIOS also does it)
		 */
		for (r = 0; r < 8; r++)
			pci_read_config_dword(dev, 0x40 + r * 4, &ss->regs[r]);
	}
Linus Torvalds's avatar
Linus Torvalds committed
251 252

	pci_disable_device(dev);
253
	pci_set_power_state(dev, pci_choose_state(dev, state));
Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258
	return 0;
}

static int sc1200_resume (struct pci_dev *dev)
{
259 260
	struct ide_host *host = pci_get_drvdata(dev);
	struct sc1200_saved_state *ss = host->host_priv;
261 262
	unsigned int r;
	int i;
263 264 265 266

	i = pci_enable_device(dev);
	if (i)
		return i;
Linus Torvalds's avatar
Linus Torvalds committed
267

268 269 270 271
	/*
	 * restore timing registers
	 * (this may be unnecessary if BIOS also does it)
	 */
272 273
	for (r = 0; r < 8; r++)
		pci_write_config_dword(dev, 0x40 + r * 4, ss->regs[r]);
274

Linus Torvalds's avatar
Linus Torvalds committed
275 276
	return 0;
}
277
#endif
Linus Torvalds's avatar
Linus Torvalds committed
278

279 280 281 282 283 284
static const struct ide_port_ops sc1200_port_ops = {
	.set_pio_mode		= sc1200_set_pio_mode,
	.set_dma_mode		= sc1200_set_dma_mode,
	.udma_filter		= sc1200_udma_filter,
};

285 286 287 288 289
static const struct ide_dma_ops sc1200_dma_ops = {
	.dma_host_set		= ide_dma_host_set,
	.dma_setup		= ide_dma_setup,
	.dma_exec_cmd		= ide_dma_exec_cmd,
	.dma_start		= ide_dma_start,
290
	.dma_end		= sc1200_dma_end,
291 292 293
	.dma_test_irq		= ide_dma_test_irq,
	.dma_lost_irq		= ide_dma_lost_irq,
	.dma_timeout		= ide_dma_timeout,
294 295
};

296
static const struct ide_port_info sc1200_chipset __devinitdata = {
297
	.name		= DRV_NAME,
298
	.port_ops	= &sc1200_port_ops,
299
	.dma_ops	= &sc1200_dma_ops,
300 301
	.host_flags	= IDE_HFLAG_SERIALIZE |
			  IDE_HFLAG_POST_SET_MODE |
302
			  IDE_HFLAG_ABUSE_DMA_MODES,
303
	.pio_mask	= ATA_PIO4,
304 305
	.mwdma_mask	= ATA_MWDMA2,
	.udma_mask	= ATA_UDMA2,
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309
};

static int __devinit sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
{
310 311 312 313 314 315 316 317 318 319 320 321 322
	struct sc1200_saved_state *ss = NULL;
	int rc;

#ifdef CONFIG_PM
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
	if (ss == NULL)
		return -ENOMEM;
#endif
	rc = ide_pci_init_one(dev, &sc1200_chipset, ss);
	if (rc)
		kfree(ss);

	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
323 324
}

325 326
static const struct pci_device_id sc1200_pci_tbl[] = {
	{ PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_SCx200_IDE), 0},
Linus Torvalds's avatar
Linus Torvalds committed
327 328 329 330
	{ 0, },
};
MODULE_DEVICE_TABLE(pci, sc1200_pci_tbl);

331
static struct pci_driver sc1200_pci_driver = {
Linus Torvalds's avatar
Linus Torvalds committed
332 333 334
	.name		= "SC1200_IDE",
	.id_table	= sc1200_pci_tbl,
	.probe		= sc1200_init_one,
335
	.remove		= ide_pci_remove,
336
#ifdef CONFIG_PM
Linus Torvalds's avatar
Linus Torvalds committed
337 338
	.suspend	= sc1200_suspend,
	.resume		= sc1200_resume,
339
#endif
Linus Torvalds's avatar
Linus Torvalds committed
340 341
};

342
static int __init sc1200_ide_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
343
{
344
	return ide_pci_register_driver(&sc1200_pci_driver);
Linus Torvalds's avatar
Linus Torvalds committed
345 346
}

347 348
static void __exit sc1200_ide_exit(void)
{
349
	pci_unregister_driver(&sc1200_pci_driver);
350 351
}

Linus Torvalds's avatar
Linus Torvalds committed
352
module_init(sc1200_ide_init);
353
module_exit(sc1200_ide_exit);
Linus Torvalds's avatar
Linus Torvalds committed
354 355 356 357

MODULE_AUTHOR("Mark Lord");
MODULE_DESCRIPTION("PCI driver module for NS SC1200 IDE");
MODULE_LICENSE("GPL");