sc1200.c 9.22 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
 * 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>
17
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
18 19 20 21
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/ide.h>
#include <linux/pm.h>
22

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

25 26
#define DRV_NAME "sc1200"

Linus Torvalds's avatar
Linus Torvalds committed
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 80
#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)

81 82 83
static void sc1200_tunepio(ide_drive_t *drive, u8 pio)
{
	ide_hwif_t *hwif = drive->hwif;
84
	struct pci_dev *pdev = to_pci_dev(hwif->dev);
85 86 87 88 89 90 91 92 93 94
	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]);
}

95 96 97 98 99 100 101 102 103 104
/*
 *	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
105
{
106
	ide_hwif_t *hwif = drive->hwif;
107
	ide_drive_t *mate = ide_get_pair_dev(drive);
108
	u16 *mateid;
109 110
	u8 mask = hwif->ultra_mask;

111
	if (mate == NULL)
112
		goto out;
113
	mateid = mate->id;
114

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

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

134 135 136 137 138 139 140 141 142 143 144 145
	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
146 147 148 149 150 151
	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.
	 */
152 153 154 155 156

	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
157

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

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

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

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

/*
190
 * sc1200_set_pio_mode() handles setting of PIO modes
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194 195
 * 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.
 */
196

197
static void sc1200_set_pio_mode(ide_hwif_t *hwif, ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
198 199
{
	int		mode = -1;
200
	const u8	pio = drive->pio_mode - XFER_PIO_0;
Linus Torvalds's avatar
Linus Torvalds committed
201

202
	/*
203
	 * bad abuse of ->set_pio_mode interface
204
	 */
Linus Torvalds's avatar
Linus Torvalds committed
205 206 207 208 209 210 211 212 213 214
	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);
215
		ide_dma_off_quietly(drive);
216 217
		if (ide_set_dma_mode(drive, mode) == 0 &&
		    (drive->dev_flags & IDE_DFLAG_USING_DMA))
218
			hwif->dma_ops->dma_host_set(drive, 1);
Linus Torvalds's avatar
Linus Torvalds committed
219 220 221
		return;
	}

222
	sc1200_tunepio(drive, pio);
Linus Torvalds's avatar
Linus Torvalds committed
223 224
}

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

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

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

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

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

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

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

Linus Torvalds's avatar
Linus Torvalds committed
273 274
	return 0;
}
275
#endif
Linus Torvalds's avatar
Linus Torvalds committed
276

277 278 279 280 281 282
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,
};

283 284 285 286
static const struct ide_dma_ops sc1200_dma_ops = {
	.dma_host_set		= ide_dma_host_set,
	.dma_setup		= ide_dma_setup,
	.dma_start		= ide_dma_start,
287
	.dma_end		= sc1200_dma_end,
288 289
	.dma_test_irq		= ide_dma_test_irq,
	.dma_lost_irq		= ide_dma_lost_irq,
290
	.dma_timer_expiry	= ide_dma_sff_timer_expiry,
291
	.dma_sff_read_status	= ide_dma_sff_read_status,
292 293
};

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

306
static int sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
307
{
308 309 310 311 312 313 314 315 316 317 318 319 320
	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
321 322
}

323 324
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
325 326 327 328
	{ 0, },
};
MODULE_DEVICE_TABLE(pci, sc1200_pci_tbl);

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

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

345 346
static void __exit sc1200_ide_exit(void)
{
347
	pci_unregister_driver(&sc1200_pci_driver);
348 349
}

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

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