pata_legacy.c 33.2 KB
Newer Older
1 2
/*
 *   pata-legacy.c - Legacy port PATA/SATA controller driver.
3
 *   Copyright 2005/2006 Red Hat, all rights reserved.
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *   An ATA driver for the legacy ATA ports.
 *
 *   Data Sources:
 *	Opti 82C465/82C611 support: Data sheets at opti-inc.com
 *	HT6560 series:
 *	Promise 20230/20620:
 *		http://www.ryston.cz/petr/vlb/pdc20230b.html
 *		http://www.ryston.cz/petr/vlb/pdc20230c.html
 *		http://www.ryston.cz/petr/vlb/pdc20630.html
28 29 30 31 32 33 34
 *	QDI65x0:
 *		http://www.ryston.cz/petr/vlb/qd6500.html
 *		http://www.ryston.cz/petr/vlb/qd6580.html
 *
 *	QDI65x0 probe code based on drivers/ide/legacy/qd65xx.c
 *	Rewritten from the work of Colten Edwards <pje120@cs.usask.ca> by
 *	Samuel Thibault <samuel.thibault@ens-lyon.org>
35 36 37 38 39 40 41 42 43 44
 *
 *  Unsupported but docs exist:
 *	Appian/Adaptec AIC25VL01/Cirrus Logic PD7220
 *
 *  This driver handles legacy (that is "ISA/VLB side") IDE ports found
 *  on PC class systems. There are three hybrid devices that are exceptions
 *  The Cyrix 5510/5520 where a pre SFF ATA device is on the bridge and
 *  the MPIIX where the tuning is PCI side but the IDE is "ISA side".
 *
 *  Specific support is included for the ht6560a/ht6560b/opti82c611a/
45
 *  opti82c465mv/promise 20230c/20630/qdi65x0/winbond83759A
46
 *
47 48 49
 *  Support for the Winbond 83759A when operating in advanced mode.
 *  Multichip mode is not currently supported.
 *
50 51 52 53 54 55 56 57 58 59 60
 *  Use the autospeed and pio_mask options with:
 *	Appian ADI/2 aka CLPD7220 or AIC25VL01.
 *  Use the jumpers, autospeed and set pio_mask to the mode on the jumpers with
 *	Goldstar GM82C711, PIC-1288A-125, UMC 82C871F, Winbond W83759,
 *	Winbond W83759A, Promise PDC20230-B
 *
 *  For now use autospeed and pio_mask as above with the W83759A. This may
 *  change.
 *
 */

61
#include <linux/async.h>
62 63 64 65 66 67 68 69 70 71 72 73
#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 <scsi/scsi_host.h>
#include <linux/ata.h>
#include <linux/libata.h>
#include <linux/platform_device.h>

#define DRV_NAME "pata_legacy"
74
#define DRV_VERSION "0.6.5"
75 76 77

#define NR_HOST 6

78 79 80
static int all;
module_param(all, int, 0444);
MODULE_PARM_DESC(all, "Grab all legacy port devices, even if PCI(0=off, 1=on)");
81

82 83 84 85 86 87 88 89 90 91 92
enum controller {
	BIOS = 0,
	SNOOP = 1,
	PDC20230 = 2,
	HT6560A = 3,
	HT6560B = 4,
	OPTI611A = 5,
	OPTI46X = 6,
	QDI6500 = 7,
	QDI6580 = 8,
	QDI6580DP = 9,		/* Dual channel mode is different */
93
	W83759A = 10,
94 95 96 97

	UNKNOWN = -1
};

98 99 100 101 102 103 104 105
struct legacy_data {
	unsigned long timing;
	u8 clock[2];
	u8 last;
	int fast;
	enum controller type;
	struct platform_device *platform_dev;
};
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

struct legacy_probe {
	unsigned char *name;
	unsigned long port;
	unsigned int irq;
	unsigned int slot;
	enum controller type;
	unsigned long private;
};

struct legacy_controller {
	const char *name;
	struct ata_port_operations *ops;
	unsigned int pio_mask;
	unsigned int flags;
121
	unsigned int pflags;
122 123
	int (*setup)(struct platform_device *, struct legacy_probe *probe,
		struct legacy_data *data);
124 125 126 127 128
};

static int legacy_port[NR_HOST] = { 0x1f0, 0x170, 0x1e8, 0x168, 0x1e0, 0x160 };

static struct legacy_probe probe_list[NR_HOST];
129 130 131 132 133
static struct legacy_data legacy_data[NR_HOST];
static struct ata_host *legacy_host[NR_HOST];
static int nr_legacy_host;


134 135 136 137 138 139
static int probe_all;		/* Set to check all ISA port ranges */
static int ht6560a;		/* HT 6560A on primary 1, second 2, both 3 */
static int ht6560b;		/* HT 6560A on primary 1, second 2, both 3 */
static int opti82c611a;		/* Opti82c611A on primary 1, sec 2, both 3 */
static int opti82c46x;		/* Opti 82c465MV present(pri/sec autodetect) */
static int autospeed;		/* Chip present which snoops speed changes */
140
static int pio_mask = ATA_PIO4;	/* PIO range for autospeed devices */
141
static int iordy_mask = 0xFFFFFFFF;	/* Use iordy if available */
142

143 144 145 146 147 148 149
/* Set to probe QDI controllers */
#ifdef CONFIG_PATA_QDI_MODULE
static int qdi = 1;
#else
static int qdi;
#endif

150
#ifdef CONFIG_PATA_WINBOND_VLB_MODULE
151 152 153 154 155 156 157
static int winbond = 1;		/* Set to probe Winbond controllers,
					give I/O port if non standard */
#else
static int winbond;		/* Set to probe Winbond controllers,
					give I/O port if non standard */
#endif

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 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
/**
 *	legacy_probe_add	-	Add interface to probe list
 *	@port: Controller port
 *	@irq: IRQ number
 *	@type: Controller type
 *	@private: Controller specific info
 *
 *	Add an entry into the probe list for ATA controllers. This is used
 *	to add the default ISA slots and then to build up the table
 *	further according to other ISA/VLB/Weird device scans
 *
 *	An I/O port list is used to keep ordering stable and sane, as we
 *	don't have any good way to talk about ordering otherwise
 */

static int legacy_probe_add(unsigned long port, unsigned int irq,
				enum controller type, unsigned long private)
{
	struct legacy_probe *lp = &probe_list[0];
	int i;
	struct legacy_probe *free = NULL;

	for (i = 0; i < NR_HOST; i++) {
		if (lp->port == 0 && free == NULL)
			free = lp;
		/* Matching port, or the correct slot for ordering */
		if (lp->port == port || legacy_port[i] == port) {
			free = lp;
			break;
		}
		lp++;
	}
	if (free == NULL) {
		printk(KERN_ERR "pata_legacy: Too many interfaces.\n");
		return -1;
	}
	/* Fill in the entry for later probing */
	free->port = port;
	free->irq = irq;
	free->type = type;
	free->private = private;
	return 0;
}


203 204
/**
 *	legacy_set_mode		-	mode setting
205
 *	@link: IDE link
Alan's avatar
Alan committed
206
 *	@unused: Device that failed when error is returned
207 208 209 210 211 212 213 214 215
 *
 *	Use a non standard set_mode function. We don't want to be tuned.
 *
 *	The BIOS configured everything. Our job is not to fiddle. Just use
 *	whatever PIO the hardware is using and leave it at that. When we
 *	get some kind of nice user driven API for control then we can
 *	expand on this as per hdparm in the base kernel.
 */

216
static int legacy_set_mode(struct ata_link *link, struct ata_device **unused)
217
{
218
	struct ata_device *dev;
219

Tejun Heo's avatar
Tejun Heo committed
220
	ata_for_each_dev(dev, link, ENABLED) {
221
		ata_dev_info(dev, "configured for PIO\n");
Tejun Heo's avatar
Tejun Heo committed
222 223 224 225
		dev->pio_mode = XFER_PIO_0;
		dev->xfer_mode = XFER_PIO_0;
		dev->xfer_shift = ATA_SHIFT_PIO;
		dev->flags |= ATA_DFLAG_PIO;
226
	}
Alan's avatar
Alan committed
227
	return 0;
228 229 230
}

static struct scsi_host_template legacy_sht = {
231
	ATA_PIO_SHT(DRV_NAME),
232 233
};

234 235 236 237 238
static const struct ata_port_operations legacy_base_port_ops = {
	.inherits	= &ata_sff_port_ops,
	.cable_detect	= ata_cable_40wire,
};

239 240 241 242 243 244 245 246 247
/*
 *	These ops are used if the user indicates the hardware
 *	snoops the commands to decide on the mode and handles the
 *	mode selection "magically" itself. Several legacy controllers
 *	do this. The mode range can be set if it is not 0x1F by setting
 *	pio_mask as well.
 */

static struct ata_port_operations simple_port_ops = {
248
	.inherits	= &legacy_base_port_ops,
Tejun Heo's avatar
Tejun Heo committed
249
	.sff_data_xfer	= ata_sff_data_xfer_noirq,
250 251 252
};

static struct ata_port_operations legacy_port_ops = {
253
	.inherits	= &legacy_base_port_ops,
Tejun Heo's avatar
Tejun Heo committed
254
	.sff_data_xfer	= ata_sff_data_xfer_noirq,
255
	.set_mode	= legacy_set_mode,
256 257 258 259 260
};

/*
 *	Promise 20230C and 20620 support
 *
261 262 263 264
 *	This controller supports PIO0 to PIO2. We set PIO timings
 *	conservatively to allow for 50MHz Vesa Local Bus. The 20620 DMA
 *	support is weird being DMA to controller and PIO'd to the host
 *	and not supported.
265 266 267 268 269 270 271 272
 */

static void pdc20230_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	int tries = 5;
	int pio = adev->pio_mode - XFER_PIO_0;
	u8 rt;
	unsigned long flags;
273

274
	/* Safe as UP only. Force I/Os to occur together */
275

276
	local_irq_save(flags);
277

278
	/* Unlock the control interface */
279
	do {
280 281 282 283 284 285 286 287
		inb(0x1F5);
		outb(inb(0x1F2) | 0x80, 0x1F2);
		inb(0x1F2);
		inb(0x3F6);
		inb(0x3F6);
		inb(0x1F2);
		inb(0x1F2);
	}
288
	while ((inb(0x1F2) & 0x80) && --tries);
289 290

	local_irq_restore(flags);
291

292 293 294 295 296 297 298 299 300 301 302 303 304 305
	outb(inb(0x1F4) & 0x07, 0x1F4);

	rt = inb(0x1F3);
	rt &= 0x07 << (3 * adev->devno);
	if (pio)
		rt |= (1 + 3 * pio) << (3 * adev->devno);

	udelay(100);
	outb(inb(0x1F2) | 0x01, 0x1F2);
	udelay(100);
	inb(0x1F5);

}

306
static unsigned int pdc_data_xfer_vlb(struct ata_device *dev,
307
			unsigned char *buf, unsigned int buflen, int rw)
308
{
309
	int slop = buflen & 3;
310 311
	struct ata_port *ap = dev->link->ap;

312
	/* 32bit I/O capable *and* we need to write a whole number of dwords */
313 314
	if (ata_id_has_dword_io(dev->id) && (slop == 0 || slop == 3)
					&& (ap->pflags & ATA_PFLAG_PIO32)) {
315 316
		unsigned long flags;

317 318 319
		local_irq_save(flags);

		/* Perform the 32bit I/O synchronization sequence */
Tejun Heo's avatar
Tejun Heo committed
320 321 322
		ioread8(ap->ioaddr.nsect_addr);
		ioread8(ap->ioaddr.nsect_addr);
		ioread8(ap->ioaddr.nsect_addr);
323 324

		/* Now the data */
325
		if (rw == READ)
Tejun Heo's avatar
Tejun Heo committed
326
			ioread32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
327 328
		else
			iowrite32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
329 330

		if (unlikely(slop)) {
331
			__le32 pad;
332
			if (rw == READ) {
333
				pad = cpu_to_le32(ioread32(ap->ioaddr.data_addr));
334
				memcpy(buf + buflen - slop, &pad, slop);
335 336 337
			} else {
				memcpy(&pad, buf + buflen - slop, slop);
				iowrite32(le32_to_cpu(pad), ap->ioaddr.data_addr);
338
			}
339
			buflen += 4 - slop;
340 341
		}
		local_irq_restore(flags);
342
	} else
Tejun Heo's avatar
Tejun Heo committed
343
		buflen = ata_sff_data_xfer_noirq(dev, buf, buflen, rw);
344 345

	return buflen;
346 347 348
}

static struct ata_port_operations pdc20230_port_ops = {
349
	.inherits	= &legacy_base_port_ops,
350
	.set_piomode	= pdc20230_set_piomode,
Tejun Heo's avatar
Tejun Heo committed
351
	.sff_data_xfer	= pdc_data_xfer_vlb,
352 353 354 355 356
};

/*
 *	Holtek 6560A support
 *
357 358
 *	This controller supports PIO0 to PIO2 (no IORDY even though higher
 *	timings can be loaded).
359 360 361 362 363 364 365 366 367 368
 */

static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	u8 active, recover;
	struct ata_timing t;

	/* Get the timing data in cycles. For now play safe at 50Mhz */
	ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);

369 370
	active = clamp_val(t.active, 2, 15);
	recover = clamp_val(t.recover, 4, 15);
371 372 373 374 375 376

	inb(0x3E6);
	inb(0x3E6);
	inb(0x3E6);
	inb(0x3E6);

Tejun Heo's avatar
Tejun Heo committed
377 378
	iowrite8(recover << 4 | active, ap->ioaddr.device_addr);
	ioread8(ap->ioaddr.status_addr);
379 380 381
}

static struct ata_port_operations ht6560a_port_ops = {
382
	.inherits	= &legacy_base_port_ops,
383 384 385 386 387 388
	.set_piomode	= ht6560a_set_piomode,
};

/*
 *	Holtek 6560B support
 *
389 390
 *	This controller supports PIO0 to PIO4. We honour the BIOS/jumper FIFO
 *	setting unless we see an ATAPI device in which case we force it off.
391 392 393 394 395 396 397 398 399 400 401 402
 *
 *	FIXME: need to implement 2nd channel support.
 */

static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	u8 active, recover;
	struct ata_timing t;

	/* Get the timing data in cycles. For now play safe at 50Mhz */
	ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);

403
	active = clamp_val(t.active, 2, 15);
404
	recover = clamp_val(t.recover, 2, 16) & 0x0F;
405 406 407 408 409 410

	inb(0x3E6);
	inb(0x3E6);
	inb(0x3E6);
	inb(0x3E6);

Tejun Heo's avatar
Tejun Heo committed
411
	iowrite8(recover << 4 | active, ap->ioaddr.device_addr);
412 413 414 415

	if (adev->class != ATA_DEV_ATA) {
		u8 rconf = inb(0x3E6);
		if (rconf & 0x24) {
416
			rconf &= ~0x24;
417 418 419
			outb(rconf, 0x3E6);
		}
	}
Tejun Heo's avatar
Tejun Heo committed
420
	ioread8(ap->ioaddr.status_addr);
421 422 423
}

static struct ata_port_operations ht6560b_port_ops = {
424
	.inherits	= &legacy_base_port_ops,
425 426 427 428 429 430
	.set_piomode	= ht6560b_set_piomode,
};

/*
 *	Opti core chipset helpers
 */
431

432 433 434 435 436 437 438 439 440 441 442
/**
 *	opti_syscfg	-	read OPTI chipset configuration
 *	@reg: Configuration register to read
 *
 *	Returns the value of an OPTI system board configuration register.
 */

static u8 opti_syscfg(u8 reg)
{
	unsigned long flags;
	u8 r;
443

444 445 446 447 448 449 450 451 452 453 454 455 456 457
	/* Uniprocessor chipset and must force cycles adjancent */
	local_irq_save(flags);
	outb(reg, 0x22);
	r = inb(0x24);
	local_irq_restore(flags);
	return r;
}

/*
 *	Opti 82C611A
 *
 *	This controller supports PIO0 to PIO3.
 */

458 459
static void opti82c611a_set_piomode(struct ata_port *ap,
						struct ata_device *adev)
460 461 462 463 464 465 466 467 468
{
	u8 active, recover, setup;
	struct ata_timing t;
	struct ata_device *pair = ata_dev_pair(adev);
	int clock;
	int khz[4] = { 50000, 40000, 33000, 25000 };
	u8 rc;

	/* Enter configuration mode */
Tejun Heo's avatar
Tejun Heo committed
469 470 471
	ioread16(ap->ioaddr.error_addr);
	ioread16(ap->ioaddr.error_addr);
	iowrite8(3, ap->ioaddr.nsect_addr);
472 473

	/* Read VLB clock strapping */
Tejun Heo's avatar
Tejun Heo committed
474
	clock = 1000000000 / khz[ioread8(ap->ioaddr.lbah_addr) & 0x03];
475 476 477 478 479 480 481 482 483 484 485 486

	/* Get the timing data in cycles */
	ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);

	/* Setup timing is shared */
	if (pair) {
		struct ata_timing tp;
		ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);

		ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
	}

487 488 489
	active = clamp_val(t.active, 2, 17) - 2;
	recover = clamp_val(t.recover, 1, 16) - 1;
	setup = clamp_val(t.setup, 1, 4) - 1;
490 491

	/* Select the right timing bank for write timing */
Tejun Heo's avatar
Tejun Heo committed
492
	rc = ioread8(ap->ioaddr.lbal_addr);
493 494
	rc &= 0x7F;
	rc |= (adev->devno << 7);
Tejun Heo's avatar
Tejun Heo committed
495
	iowrite8(rc, ap->ioaddr.lbal_addr);
496 497

	/* Write the timings */
Tejun Heo's avatar
Tejun Heo committed
498
	iowrite8(active << 4 | recover, ap->ioaddr.error_addr);
499 500 501

	/* Select the right bank for read timings, also
	   load the shared timings for address */
Tejun Heo's avatar
Tejun Heo committed
502
	rc = ioread8(ap->ioaddr.device_addr);
503 504 505
	rc &= 0xC0;
	rc |= adev->devno;	/* Index select */
	rc |= (setup << 4) | 0x04;
Tejun Heo's avatar
Tejun Heo committed
506
	iowrite8(rc, ap->ioaddr.device_addr);
507 508

	/* Load the read timings */
Tejun Heo's avatar
Tejun Heo committed
509
	iowrite8(active << 4 | recover, ap->ioaddr.data_addr);
510 511

	/* Ensure the timing register mode is right */
Tejun Heo's avatar
Tejun Heo committed
512
	rc = ioread8(ap->ioaddr.lbal_addr);
513 514
	rc &= 0x73;
	rc |= 0x84;
Tejun Heo's avatar
Tejun Heo committed
515
	iowrite8(rc, ap->ioaddr.lbal_addr);
516 517

	/* Exit command mode */
Tejun Heo's avatar
Tejun Heo committed
518
	iowrite8(0x83,  ap->ioaddr.nsect_addr);
519 520 521 522
}


static struct ata_port_operations opti82c611a_port_ops = {
523
	.inherits	= &legacy_base_port_ops,
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
	.set_piomode	= opti82c611a_set_piomode,
};

/*
 *	Opti 82C465MV
 *
 *	This controller supports PIO0 to PIO3. Unlike the 611A the MVB
 *	version is dual channel but doesn't have a lot of unique registers.
 */

static void opti82c46x_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	u8 active, recover, setup;
	struct ata_timing t;
	struct ata_device *pair = ata_dev_pair(adev);
	int clock;
	int khz[4] = { 50000, 40000, 33000, 25000 };
	u8 rc;
	u8 sysclk;

	/* Get the clock */
545
	sysclk = (opti_syscfg(0xAC) & 0xC0) >> 6;	/* BIOS set */
546 547

	/* Enter configuration mode */
Tejun Heo's avatar
Tejun Heo committed
548 549 550
	ioread16(ap->ioaddr.error_addr);
	ioread16(ap->ioaddr.error_addr);
	iowrite8(3, ap->ioaddr.nsect_addr);
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565

	/* Read VLB clock strapping */
	clock = 1000000000 / khz[sysclk];

	/* Get the timing data in cycles */
	ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);

	/* Setup timing is shared */
	if (pair) {
		struct ata_timing tp;
		ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);

		ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
	}

566 567 568
	active = clamp_val(t.active, 2, 17) - 2;
	recover = clamp_val(t.recover, 1, 16) - 1;
	setup = clamp_val(t.setup, 1, 4) - 1;
569 570

	/* Select the right timing bank for write timing */
Tejun Heo's avatar
Tejun Heo committed
571
	rc = ioread8(ap->ioaddr.lbal_addr);
572 573
	rc &= 0x7F;
	rc |= (adev->devno << 7);
Tejun Heo's avatar
Tejun Heo committed
574
	iowrite8(rc, ap->ioaddr.lbal_addr);
575 576

	/* Write the timings */
Tejun Heo's avatar
Tejun Heo committed
577
	iowrite8(active << 4 | recover, ap->ioaddr.error_addr);
578 579 580

	/* Select the right bank for read timings, also
	   load the shared timings for address */
Tejun Heo's avatar
Tejun Heo committed
581
	rc = ioread8(ap->ioaddr.device_addr);
582 583 584
	rc &= 0xC0;
	rc |= adev->devno;	/* Index select */
	rc |= (setup << 4) | 0x04;
Tejun Heo's avatar
Tejun Heo committed
585
	iowrite8(rc, ap->ioaddr.device_addr);
586 587

	/* Load the read timings */
Tejun Heo's avatar
Tejun Heo committed
588
	iowrite8(active << 4 | recover, ap->ioaddr.data_addr);
589 590

	/* Ensure the timing register mode is right */
Tejun Heo's avatar
Tejun Heo committed
591
	rc = ioread8(ap->ioaddr.lbal_addr);
592 593
	rc &= 0x73;
	rc |= 0x84;
Tejun Heo's avatar
Tejun Heo committed
594
	iowrite8(rc, ap->ioaddr.lbal_addr);
595 596

	/* Exit command mode */
Tejun Heo's avatar
Tejun Heo committed
597
	iowrite8(0x83,  ap->ioaddr.nsect_addr);
598 599 600 601 602 603

	/* We need to know this for quad device on the MVB */
	ap->host->private_data = ap;
}

/**
Tejun Heo's avatar
Tejun Heo committed
604
 *	opt82c465mv_qc_issue		-	command issue
605 606 607 608 609 610 611 612 613 614 615 616 617
 *	@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. The
 *	MVB has a single set of timing registers and these are shared
 *	across channels. As there are two registers we really ought to
 *	track the last two used values as a sort of register window. For
 *	now we just reload on a channel switch. On the single channel
 *	setup this condition never fires so we do nothing extra.
 *
 *	FIXME: dual channel needs ->serialize support
 */

Tejun Heo's avatar
Tejun Heo committed
618
static unsigned int opti82c46x_qc_issue(struct ata_queued_cmd *qc)
619 620 621 622 623 624 625 626 627 628
{
	struct ata_port *ap = qc->ap;
	struct ata_device *adev = qc->dev;

	/* If timings are set and for the wrong channel (2nd test is
	   due to a libata shortcoming and will eventually go I hope) */
	if (ap->host->private_data != ap->host
	    && ap->host->private_data != NULL)
		opti82c46x_set_piomode(ap, adev);

Tejun Heo's avatar
Tejun Heo committed
629
	return ata_sff_qc_issue(qc);
630 631 632
}

static struct ata_port_operations opti82c46x_port_ops = {
633
	.inherits	= &legacy_base_port_ops,
634
	.set_piomode	= opti82c46x_set_piomode,
Tejun Heo's avatar
Tejun Heo committed
635
	.qc_issue	= opti82c46x_qc_issue,
636 637 638
};

/**
639
 *	qdi65x0_set_piomode		-	PIO setup for QDI65x0
640 641
 *	@ap: Port
 *	@adev: Device
642
 *
643 644 645 646
 *	In single channel mode the 6580 has one clock per device and we can
 *	avoid the requirement to clock switch. We also have to load the timing
 *	into the right clock according to whether we are master or slave.
 *
647
 *	In dual channel mode the 6580 has one clock per channel and we have
Tejun Heo's avatar
Tejun Heo committed
648
 *	to software clockswitch in qc_issue.
649 650
 */

651
static void qdi65x0_set_piomode(struct ata_port *ap, struct ata_device *adev)
652
{
653
	struct ata_timing t;
654
	struct legacy_data *ld_qdi = ap->host->private_data;
655 656
	int active, recovery;
	u8 timing;
657

658 659 660
	/* Get the timing data in cycles */
	ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);

661
	if (ld_qdi->fast) {
662 663
		active = 8 - clamp_val(t.active, 1, 8);
		recovery = 18 - clamp_val(t.recover, 3, 18);
664
	} else {
665 666
		active = 9 - clamp_val(t.active, 2, 9);
		recovery = 15 - clamp_val(t.recover, 0, 15);
667 668
	}
	timing = (recovery << 4) | active | 0x08;
669
	ld_qdi->clock[adev->devno] = timing;
670

671 672 673 674
	if (ld_qdi->type == QDI6580)
		outb(timing, ld_qdi->timing + 2 * adev->devno);
	else
		outb(timing, ld_qdi->timing + 2 * ap->port_no);
675 676

	/* Clear the FIFO */
677
	if (ld_qdi->type != QDI6500 && adev->class != ATA_DEV_ATA)
678
		outb(0x5F, (ld_qdi->timing & 0xFFF0) + 3);
679 680 681
}

/**
Tejun Heo's avatar
Tejun Heo committed
682
 *	qdi_qc_issue		-	command issue
683 684 685 686 687 688
 *	@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.
 */

Tejun Heo's avatar
Tejun Heo committed
689
static unsigned int qdi_qc_issue(struct ata_queued_cmd *qc)
690 691 692
{
	struct ata_port *ap = qc->ap;
	struct ata_device *adev = qc->dev;
693
	struct legacy_data *ld_qdi = ap->host->private_data;
694

695
	if (ld_qdi->clock[adev->devno] != ld_qdi->last) {
696
		if (adev->pio_mode) {
697 698
			ld_qdi->last = ld_qdi->clock[adev->devno];
			outb(ld_qdi->clock[adev->devno], ld_qdi->timing +
699 700
							2 * ap->port_no);
		}
701
	}
Tejun Heo's avatar
Tejun Heo committed
702
	return ata_sff_qc_issue(qc);
703
}
704

705
static unsigned int vlb32_data_xfer(struct ata_device *adev, unsigned char *buf,
706 707 708 709
					unsigned int buflen, int rw)
{
	struct ata_port *ap = adev->link->ap;
	int slop = buflen & 3;
710

711 712
	if (ata_id_has_dword_io(adev->id) && (slop == 0 || slop == 3)
					&& (ap->pflags & ATA_PFLAG_PIO32)) {
713 714 715 716
		if (rw == WRITE)
			iowrite32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
		else
			ioread32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
717

718
		if (unlikely(slop)) {
719
			__le32 pad;
720 721
			if (rw == WRITE) {
				memcpy(&pad, buf + buflen - slop, slop);
722
				iowrite32(le32_to_cpu(pad), ap->ioaddr.data_addr);
723
			} else {
724
				pad = cpu_to_le32(ioread32(ap->ioaddr.data_addr));
725 726 727 728 729
				memcpy(buf + buflen - slop, &pad, slop);
			}
		}
		return (buflen + 3) & ~3;
	} else
Tejun Heo's avatar
Tejun Heo committed
730
		return ata_sff_data_xfer(adev, buf, buflen, rw);
731 732
}

733 734 735 736 737 738 739 740 741
static int qdi_port(struct platform_device *dev,
			struct legacy_probe *lp, struct legacy_data *ld)
{
	if (devm_request_region(&dev->dev, lp->private, 4, "qdi") == NULL)
		return -EBUSY;
	ld->timing = lp->private;
	return 0;
}

742
static struct ata_port_operations qdi6500_port_ops = {
743
	.inherits	= &legacy_base_port_ops,
744
	.set_piomode	= qdi65x0_set_piomode,
Tejun Heo's avatar
Tejun Heo committed
745
	.qc_issue	= qdi_qc_issue,
Tejun Heo's avatar
Tejun Heo committed
746
	.sff_data_xfer	= vlb32_data_xfer,
747 748 749
};

static struct ata_port_operations qdi6580_port_ops = {
750
	.inherits	= &legacy_base_port_ops,
751
	.set_piomode	= qdi65x0_set_piomode,
Tejun Heo's avatar
Tejun Heo committed
752
	.sff_data_xfer	= vlb32_data_xfer,
753 754 755
};

static struct ata_port_operations qdi6580dp_port_ops = {
756
	.inherits	= &legacy_base_port_ops,
757
	.set_piomode	= qdi65x0_set_piomode,
758
	.qc_issue	= qdi_qc_issue,
Tejun Heo's avatar
Tejun Heo committed
759
	.sff_data_xfer	= vlb32_data_xfer,
760 761
};

762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
static DEFINE_SPINLOCK(winbond_lock);

static void winbond_writecfg(unsigned long port, u8 reg, u8 val)
{
	unsigned long flags;
	spin_lock_irqsave(&winbond_lock, flags);
	outb(reg, port + 0x01);
	outb(val, port + 0x02);
	spin_unlock_irqrestore(&winbond_lock, flags);
}

static u8 winbond_readcfg(unsigned long port, u8 reg)
{
	u8 val;

	unsigned long flags;
	spin_lock_irqsave(&winbond_lock, flags);
	outb(reg, port + 0x01);
	val = inb(port + 0x02);
	spin_unlock_irqrestore(&winbond_lock, flags);

	return val;
}

static void winbond_set_piomode(struct ata_port *ap, struct ata_device *adev)
{
	struct ata_timing t;
789
	struct legacy_data *ld_winbond = ap->host->private_data;
790 791 792 793
	int active, recovery;
	u8 reg;
	int timing = 0x88 + (ap->port_no * 4) + (adev->devno * 2);

794
	reg = winbond_readcfg(ld_winbond->timing, 0x81);
795 796 797 798 799 800 801

	/* Get the timing data in cycles */
	if (reg & 0x40)		/* Fast VLB bus, assume 50MHz */
		ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
	else
		ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);

802 803
	active = (clamp_val(t.active, 3, 17) - 1) & 0x0F;
	recovery = (clamp_val(t.recover, 1, 15) + 1) & 0x0F;
804
	timing = (active << 4) | recovery;
805
	winbond_writecfg(ld_winbond->timing, timing, reg);
806 807 808 809 810 811 812 813

	/* Load the setup timing */

	reg = 0x35;
	if (adev->class != ATA_DEV_ATA)
		reg |= 0x08;	/* FIFO off */
	if (!ata_pio_need_iordy(adev))
		reg |= 0x02;	/* IORDY off */
814
	reg |= (clamp_val(t.setup, 0, 3) << 6);
815
	winbond_writecfg(ld_winbond->timing, timing + 1, reg);
816 817 818 819 820 821 822 823 824 825 826 827
}

static int winbond_port(struct platform_device *dev,
			struct legacy_probe *lp, struct legacy_data *ld)
{
	if (devm_request_region(&dev->dev, lp->private, 4, "winbond") == NULL)
		return -EBUSY;
	ld->timing = lp->private;
	return 0;
}

static struct ata_port_operations winbond_port_ops = {
828
	.inherits	= &legacy_base_port_ops,
829
	.set_piomode	= winbond_set_piomode,
Tejun Heo's avatar
Tejun Heo committed
830
	.sff_data_xfer	= vlb32_data_xfer,
831 832
};

833
static struct legacy_controller controllers[] = {
834
	{"BIOS",	&legacy_port_ops, 	ATA_PIO4,
835
			ATA_FLAG_NO_IORDY,	0,			NULL },
836
	{"Snooping", 	&simple_port_ops, 	ATA_PIO4,
837
			0,			0,			NULL },
838
	{"PDC20230",	&pdc20230_port_ops,	ATA_PIO2,
839
			ATA_FLAG_NO_IORDY,
840
			ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE,	NULL },
841
	{"HT6560A",	&ht6560a_port_ops,	ATA_PIO2,
842
			ATA_FLAG_NO_IORDY,	0,			NULL },
843
	{"HT6560B",	&ht6560b_port_ops,	ATA_PIO4,
844
			ATA_FLAG_NO_IORDY,	0,			NULL },
845
	{"OPTI82C611A",	&opti82c611a_port_ops,	ATA_PIO3,
846
			0,			0,			NULL },
847
	{"OPTI82C46X",	&opti82c46x_port_ops,	ATA_PIO3,
848
			0,			0,			NULL },
849
	{"QDI6500",	&qdi6500_port_ops,	ATA_PIO2,
850
			ATA_FLAG_NO_IORDY,
851
			ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE,    qdi_port },
852
	{"QDI6580",	&qdi6580_port_ops,	ATA_PIO4,
853
			0, ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE, qdi_port },
854
	{"QDI6580DP",	&qdi6580dp_port_ops,	ATA_PIO4,
855
			0, ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE, qdi_port },
856
	{"W83759A",	&winbond_port_ops,	ATA_PIO4,
857
			0, ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE,
858
								winbond_port }
859 860 861 862 863 864 865 866 867 868
};

/**
 *	probe_chip_type		-	Discover controller
 *	@probe: Probe entry to check
 *
 *	Probe an ATA port and identify the type of controller. We don't
 *	check if the controller appears to be driveless at this point.
 */

869
static __init int probe_chip_type(struct legacy_probe *probe)
870 871 872
{
	int mask = 1 << probe->slot;

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
	if (winbond && (probe->port == 0x1F0 || probe->port == 0x170)) {
		u8 reg = winbond_readcfg(winbond, 0x81);
		reg |= 0x80;	/* jumpered mode off */
		winbond_writecfg(winbond, 0x81, reg);
		reg = winbond_readcfg(winbond, 0x83);
		reg |= 0xF0;	/* local control */
		winbond_writecfg(winbond, 0x83, reg);
		reg = winbond_readcfg(winbond, 0x85);
		reg |= 0xF0;	/* programmable timing */
		winbond_writecfg(winbond, 0x85, reg);

		reg = winbond_readcfg(winbond, 0x81);

		if (reg & mask)
			return W83759A;
	}
889 890 891
	if (probe->port == 0x1F0) {
		unsigned long flags;
		local_irq_save(flags);
892 893
		/* Probes */
		outb(inb(0x1F2) | 0x80, 0x1F2);
894
		inb(0x1F5);
895 896 897 898 899 900 901 902
		inb(0x1F2);
		inb(0x3F6);
		inb(0x3F6);
		inb(0x1F2);
		inb(0x1F2);

		if ((inb(0x1F2) & 0x80) == 0) {
			/* PDC20230c or 20630 ? */
903 904
			printk(KERN_INFO  "PDC20230-C/20630 VLB ATA controller"
							" detected.\n");
905 906
			udelay(100);
			inb(0x1F5);
907 908
			local_irq_restore(flags);
			return PDC20230;
909 910 911 912
		} else {
			outb(0x55, 0x1F2);
			inb(0x1F2);
			inb(0x1F2);
913 914 915 916 917
			if (inb(0x1F2) == 0x00)
				printk(KERN_INFO "PDC20230-B VLB ATA "
						     "controller detected.\n");
			local_irq_restore(flags);
			return BIOS;
918 919 920 921
		}
		local_irq_restore(flags);
	}

922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
	if (ht6560a & mask)
		return HT6560A;
	if (ht6560b & mask)
		return HT6560B;
	if (opti82c611a & mask)
		return OPTI611A;
	if (opti82c46x & mask)
		return OPTI46X;
	if (autospeed & mask)
		return SNOOP;
	return BIOS;
}


/**
 *	legacy_init_one		-	attach a legacy interface
 *	@pl: probe record
 *
 *	Register an ISA bus IDE interface. Such interfaces are PIO and we
 *	assume do not support IRQ sharing.
 */

static __init int legacy_init_one(struct legacy_probe *probe)
{
	struct legacy_controller *controller = &controllers[probe->type];
	int pio_modes = controller->pio_mask;
	unsigned long io = probe->port;
	u32 mask = (1 << probe->slot);
	struct ata_port_operations *ops = controller->ops;
	struct legacy_data *ld = &legacy_data[probe->slot];
	struct ata_host *host = NULL;
	struct ata_port *ap;
	struct platform_device *pdev;
	struct ata_device *dev;
	void __iomem *io_addr, *ctrl_addr;
	u32 iordy = (iordy_mask & mask) ? 0: ATA_FLAG_NO_IORDY;
	int ret;

	iordy |= controller->flags;

	pdev = platform_device_register_simple(DRV_NAME, probe->slot, NULL, 0);
	if (IS_ERR(pdev))
		return PTR_ERR(pdev);
965

966 967 968 969 970
	ret = -EBUSY;
	if (devm_request_region(&pdev->dev, io, 8, "pata_legacy") == NULL ||
	    devm_request_region(&pdev->dev, io + 0x0206, 1,
							"pata_legacy") == NULL)
		goto fail;
971

972
	ret = -ENOMEM;
973 974 975 976
	io_addr = devm_ioport_map(&pdev->dev, io, 8);
	ctrl_addr = devm_ioport_map(&pdev->dev, io + 0x0206, 1);
	if (!io_addr || !ctrl_addr)
		goto fail;
977
	ld->type = probe->type;
978
	if (controller->setup)
979
		if (controller->setup(pdev, probe, ld) < 0)
980
			goto fail;
981 982 983 984 985 986 987 988
	host = ata_host_alloc(&pdev->dev, 1);
	if (!host)
		goto fail;
	ap = host->ports[0];

	ap->ops = ops;
	ap->pio_mask = pio_modes;
	ap->flags |= ATA_FLAG_SLAVE_POSS | iordy;
989
	ap->pflags |= controller->pflags;
990 991 992
	ap->ioaddr.cmd_addr = io_addr;
	ap->ioaddr.altstatus_addr = ctrl_addr;
	ap->ioaddr.ctl_addr = ctrl_addr;
Tejun Heo's avatar
Tejun Heo committed
993
	ata_sff_std_ports(&ap->ioaddr);
994
	ap->host->private_data = ld;
995

996
	ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io, io + 0x0206);
997

Tejun Heo's avatar
Tejun Heo committed
998 999
	ret = ata_host_activate(host, probe->irq, ata_sff_interrupt, 0,
				&legacy_sht);
1000
	if (ret)
1001
		goto fail;
1002
	async_synchronize_full();
1003 1004
	ld->platform_dev = pdev;

1005 1006 1007
	/* Nothing found means we drop the port as its probably not there */

	ret = -ENODEV;
Tejun Heo's avatar
Tejun Heo committed
1008
	ata_for_each_dev(dev, &ap->link, ALL) {
1009 1010 1011 1012 1013 1014
		if (!ata_dev_absent(dev)) {
			legacy_host[probe->slot] = host;
			ld->platform_dev = pdev;
			return 0;
		}
	}
1015
	ata_host_detach(host);
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
fail:
	platform_device_unregister(pdev);
	return ret;
}

/**
 *	legacy_check_special_cases	-	ATA special cases
 *	@p: PCI device to check
 *	@master: set this if we find an ATA master
 *	@master: set this if we find an ATA secondary
 *
1027 1028 1029 1030 1031
 *	A small number of vendors implemented early PCI ATA interfaces
 *	on bridge logic without the ATA interface being PCI visible.
 *	Where we have a matching PCI driver we must skip the relevant
 *	device here. If we don't know about it then the legacy driver
 *	is the right driver anyway.
1032 1033
 */

1034
static void __init legacy_check_special_cases(struct pci_dev *p, int *primary,
1035
								int *secondary)
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
{
	/* Cyrix CS5510 pre SFF MWDMA ATA on the bridge */
	if (p->vendor == 0x1078 && p->device == 0x0000) {
		*primary = *secondary = 1;
		return;
	}
	/* Cyrix CS5520 pre SFF MWDMA ATA on the bridge */
	if (p->vendor == 0x1078 && p->device == 0x0002) {
		*primary = *secondary = 1;
		return;
	}
	/* Intel MPIIX - PIO ATA on non PCI side of bridge */
	if (p->vendor == 0x8086 && p->device == 0x1234) {
		u16 r;
		pci_read_config_word(p, 0x6C, &r);
1051 1052
		if (r & 0x8000) {
			/* ATA port enabled */
1053 1054 1055 1056 1057 1058 1059 1060 1061
			if (r & 0x4000)
				*secondary = 1;
			else
				*primary = 1;
		}
		return;
	}
}

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
static __init void probe_opti_vlb(void)
{
	/* If an OPTI 82C46X is present find out where the channels are */
	static const char *optis[4] = {
		"3/463MV", "5MV",
		"5MVA", "5MVB"
	};
	u8 chans = 1;
	u8 ctrl = (opti_syscfg(0x30) & 0xC0) >> 6;

	opti82c46x = 3;	/* Assume master and slave first */
	printk(KERN_INFO DRV_NAME ": Opti 82C46%s chipset support.\n",
								optis[ctrl]);
	if (ctrl == 3)
		chans = (opti_syscfg(0x3F) & 0x20) ? 2 : 1;
	ctrl = opti_syscfg(0xAC);
	/* Check enabled and this port is the 465MV port. On the
	   MVB we may have two channels */
	if (ctrl & 8) {
		if (chans == 2) {
			legacy_probe_add(0x1F0, 14, OPTI46X, 0);
			legacy_probe_add(0x170, 15, OPTI46X, 0);
		}
		if (ctrl & 4)
			legacy_probe_add(0x170, 15, OPTI46X, 0);
		else
			legacy_probe_add(0x1F0, 14, OPTI46X, 0);
	} else
		legacy_probe_add(0x1F0, 14, OPTI46X, 0);
}

static __init void qdi65_identify_port(u8 r, u8 res, unsigned long port)
{
	static const unsigned long ide_port[2] = { 0x170, 0x1F0 };
	/* Check card type */
	if ((r & 0xF0) == 0xC0) {
		/* QD6500: single channel */
1099
		if (r & 8)
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
			/* Disabled ? */
			return;
		legacy_probe_add(ide_port[r & 0x01], 14 + (r & 0x01),
								QDI6500, port);
	}
	if (((r & 0xF0) == 0xA0) || (r & 0xF0) == 0x50) {
		/* QD6580: dual channel */
		if (!request_region(port + 2 , 2, "pata_qdi")) {
			release_region(port, 2);
			return;
		}
		res = inb(port + 3);
		/* Single channel mode ? */
		if (res & 1)
			legacy_probe_add(ide_port[r & 0x01], 14 + (r & 0x01),
								QDI6580, port);
		else { /* Dual channel mode */
			legacy_probe_add(0x1F0, 14, QDI6580DP, port);
			/* port + 0x02, r & 0x04 */
			legacy_probe_add(0x170, 15, QDI6580DP, port + 2);
		}
1121
		release_region(port + 2, 2);
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
	}
}

static __init void probe_qdi_vlb(void)
{
	unsigned long flags;
	static const unsigned long qd_port[2] = { 0x30, 0xB0 };
	int i;

	/*
	 *	Check each possible QD65xx base address
	 */

	for (i = 0; i < 2; i++) {
		unsigned long port = qd_port[i];
		u8 r, res;


		if (request_region(port, 2, "pata_qdi")) {
			/* Check for a card */
			local_irq_save(flags);
			/* I have no h/w that needs this delay but it
			   is present in the historic code */
			r = inb(port);
			udelay(1);
			outb(0x19, port);
			udelay(1);
			res = inb(port);
			udelay(1);
			outb(r, port);
			udelay(1);
			local_irq_restore(flags);

			/* Fail */
			if (res == 0x19) {
				release_region(port, 2);
				continue;
			}
			/* Passes the presence test */
			r = inb(port + 1);
			udelay(1);
			/* Check port agrees with port set */
1164 1165 1166
			if ((r & 2) >> 1 == i)
				qdi65_identify_port(r, res, port);
			release_region(port, 2);
1167 1168 1169
		}
	}
}
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186

/**
 *	legacy_init		-	attach legacy interfaces
 *
 *	Attach legacy IDE interfaces by scanning the usual IRQ/port suspects.
 *	Right now we do not scan the ide0 and ide1 address but should do so
 *	for non PCI systems or systems with no PCI IDE legacy mode devices.
 *	If you fix that note there are special cases to consider like VLB
 *	drivers and CS5510/20.
 */

static __init int legacy_init(void)
{
	int i;
	int ct = 0;
	int primary = 0;
	int secondary = 0;
1187 1188 1189
	int pci_present = 0;
	struct legacy_probe *pl = &probe_list[0];
	int slot = 0;
1190 1191 1192 1193 1194

	struct pci_dev *p = NULL;

	for_each_pci_dev(p) {
		int r;
1195 1196 1197
		/* Check for any overlap of the system ATA mappings. Native
		   mode controllers stuck on these addresses or some devices
		   in 'raid' mode won't be found by the storage class test */
1198 1199 1200 1201 1202 1203 1204 1205 1206
		for (r = 0; r < 6; r++) {
			if (pci_resource_start(p, r) == 0x1f0)
				primary = 1;
			if (pci_resource_start(p, r) == 0x170)
				secondary = 1;
		}
		/* Check for special cases */
		legacy_check_special_cases(p, &primary, &secondary);

1207 1208 1209
		/* If PCI bus is present then don't probe for tertiary
		   legacy ports */
		pci_present = 1;
1210 1211
	}

1212 1213 1214
	if (winbond == 1)
		winbond = 0x130;	/* Default port, alt is 1B0 */

1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
	if (primary == 0 || all)
		legacy_probe_add(0x1F0, 14, UNKNOWN, 0);
	if (secondary == 0 || all)
		legacy_probe_add(0x170, 15, UNKNOWN, 0);

	if (probe_all || !pci_present) {
		/* ISA/VLB extra ports */
		legacy_probe_add(0x1E8, 11, UNKNOWN, 0);
		legacy_probe_add(0x168, 10, UNKNOWN, 0);
		legacy_probe_add(0x1E0, 8, UNKNOWN, 0);
		legacy_probe_add(0x160, 12, UNKNOWN, 0);
1226 1227
	}

1228 1229 1230 1231 1232 1233 1234
	if (opti82c46x)
		probe_opti_vlb();
	if (qdi)
		probe_qdi_vlb();

	for (i = 0; i < NR_HOST; i++, pl++) {
		if (pl->port == 0)
1235
			continue;
1236 1237 1238 1239
		if (pl->type == UNKNOWN)
			pl->type = probe_chip_type(pl);
		pl->slot = slot++;
		if (legacy_init_one(pl) == 0)
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
			ct++;
	}
	if (ct != 0)
		return 0;
	return -ENODEV;
}

static __exit void legacy_exit(void)
{
	int i;

	for (i = 0; i < nr_legacy_host; i++) {
		struct legacy_data *ld = &legacy_data[i];
1253
		ata_host_detach(legacy_host[i]);
1254 1255 1256 1257 1258 1259 1260 1261
		platform_device_unregister(ld->platform_dev);
	}
}

MODULE_AUTHOR("Alan Cox");
MODULE_DESCRIPTION("low-level driver for legacy ATA");
MODULE_LICENSE("GPL");
MODULE_VERSION(DRV_VERSION);
1262
MODULE_ALIAS("pata_qdi");
1263
MODULE_ALIAS("pata_winbond");
1264 1265 1266 1267 1268 1269 1270

module_param(probe_all, int, 0);
module_param(autospeed, int, 0);
module_param(ht6560a, int, 0);
module_param(ht6560b, int, 0);
module_param(opti82c611a, int, 0);
module_param(opti82c46x, int, 0);
1271
module_param(qdi, int, 0);
1272
module_param(winbond, int, 0);
1273
module_param(pio_mask, int, 0);
1274
module_param(iordy_mask, int, 0);
1275 1276 1277

module_init(legacy_init);
module_exit(legacy_exit);