ide-probe.c 42.4 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 *  Copyright (C) 1994-1998   Linus Torvalds & authors (see below)
 *  Copyright (C) 2005, 2007  Bartlomiej Zolnierkiewicz
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14
 */

/*
 *  Mostly written by Mark Lord <mlord@pobox.com>
 *                and Gadi Oxman <gadio@netvision.net.il>
 *                and Andre Hedrick <andre@linux-ide.org>
 *
 *  See linux/MAINTAINERS for address of current maintainer.
 *
 * This is the IDE probe module, as evolved from hd.c and ide.c.
 *
15 16
 * -- increase WAIT_PIDENTIFY to avoid CD-ROM locking at boot
 *	 by Andrea Arcangeli
L
Linus Torvalds 已提交
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/spinlock.h>
#include <linux/kmod.h>
#include <linux/pci.h>
F
FUJITA Tomonori 已提交
35
#include <linux/scatterlist.h>
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

#include <asm/byteorder.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>

/**
 *	generic_id		-	add a generic drive id
 *	@drive:	drive to make an ID block for
 *	
 *	Add a fake id field to the drive we are passed. This allows
 *	use to skip a ton of NULL checks (which people always miss) 
 *	and make drive properties unconditional outside of this file
 */
 
static void generic_id(ide_drive_t *drive)
{
53 54 55 56 57
	u16 *id = drive->id;

	id[ATA_ID_CUR_CYLS]	= id[ATA_ID_CYLS]	= drive->cyl;
	id[ATA_ID_CUR_HEADS]	= id[ATA_ID_HEADS]	= drive->head;
	id[ATA_ID_CUR_SECTORS]	= id[ATA_ID_SECTORS]	= drive->sect;
L
Linus Torvalds 已提交
58 59 60 61
}

static void ide_disk_init_chs(ide_drive_t *drive)
{
62
	u16 *id = drive->id;
L
Linus Torvalds 已提交
63 64 65

	/* Extract geometry if we did not already have one for the drive */
	if (!drive->cyl || !drive->head || !drive->sect) {
66 67 68
		drive->cyl  = drive->bios_cyl  = id[ATA_ID_CYLS];
		drive->head = drive->bios_head = id[ATA_ID_HEADS];
		drive->sect = drive->bios_sect = id[ATA_ID_SECTORS];
L
Linus Torvalds 已提交
69 70 71
	}

	/* Handle logical geometry translation by the drive */
72
	if (ata_id_current_chs_valid(id)) {
73 74 75
		drive->cyl  = id[ATA_ID_CUR_CYLS];
		drive->head = id[ATA_ID_CUR_HEADS];
		drive->sect = id[ATA_ID_CUR_SECTORS];
L
Linus Torvalds 已提交
76 77 78
	}

	/* Use physical geometry if what we have still makes no sense */
79 80 81 82
	if (drive->head > 16 && id[ATA_ID_HEADS] && id[ATA_ID_HEADS] <= 16) {
		drive->cyl  = id[ATA_ID_CYLS];
		drive->head = id[ATA_ID_HEADS];
		drive->sect = id[ATA_ID_SECTORS];
L
Linus Torvalds 已提交
83 84 85 86 87
	}
}

static void ide_disk_init_mult_count(ide_drive_t *drive)
{
88 89
	u16 *id = drive->id;
	u8 max_multsect = id[ATA_ID_MAX_MULTSECT] & 0xff;
L
Linus Torvalds 已提交
90

91
	if (max_multsect) {
L
Linus Torvalds 已提交
92
#ifdef CONFIG_IDEDISK_MULTI_MODE
93 94 95 96 97 98
		if ((max_multsect / 2) > 1)
			id[ATA_ID_MULTSECT] = max_multsect | 0x100;
		else
			id[ATA_ID_MULTSECT] &= ~0x1ff;

		drive->mult_req = id[ATA_ID_MULTSECT] & 0xff;
L
Linus Torvalds 已提交
99
#endif
100 101
		if ((id[ATA_ID_MULTSECT] & 0x100) &&
		    (id[ATA_ID_MULTSECT] & 0xff))
102
			drive->special.b.set_multmode = 1;
L
Linus Torvalds 已提交
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
	}
}

/**
 *	do_identify	-	identify a drive
 *	@drive: drive to identify 
 *	@cmd: command used
 *
 *	Called when we have issued a drive identify command to
 *	read and parse the results. This function is run with
 *	interrupts disabled. 
 */
 
static inline void do_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
119 120
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
L
Linus Torvalds 已提交
121 122 123
	int bswap = 1;

	/* read 512 bytes of id info */
124
	hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
L
Linus Torvalds 已提交
125 126 127

	drive->id_read = 1;
	local_irq_enable();
128 129 130 131
#ifdef DEBUG
	printk(KERN_INFO "%s: dumping identify data\n", drive->name);
	ide_dump_identify((u8 *)id);
#endif
L
Linus Torvalds 已提交
132 133 134
	ide_fix_driveid(id);

	/*
135 136
	 *  ATA_CMD_ID_ATA returns little-endian info,
	 *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
L
Linus Torvalds 已提交
137
	 */
138
	if (cmd == ATA_CMD_ID_ATAPI) {
139 140 141
		if ((m[0] == 'N' && m[1] == 'E') ||  /* NEC */
		    (m[0] == 'F' && m[1] == 'X') ||  /* Mitsumi */
		    (m[0] == 'P' && m[1] == 'i'))    /* Pioneer */
L
Linus Torvalds 已提交
142
			/* Vertos drives may still be weird */
143
			bswap ^= 1;
L
Linus Torvalds 已提交
144
	}
145 146 147 148

	ide_fixstring(m, ATA_ID_PROD_LEN, bswap);
	ide_fixstring((char *)&id[ATA_ID_FW_REV], ATA_ID_FW_REV_LEN, bswap);
	ide_fixstring((char *)&id[ATA_ID_SERNO], ATA_ID_SERNO_LEN, bswap);
L
Linus Torvalds 已提交
149

150
	/* we depend on this a lot! */
151
	m[ATA_ID_PROD_LEN - 1] = '\0';
152

153
	if (strstr(m, "E X A B Y T E N E S T"))
L
Linus Torvalds 已提交
154 155
		goto err_misc;

156
	printk(KERN_INFO "%s: %s, ", drive->name, m);
157

L
Linus Torvalds 已提交
158 159 160 161 162 163
	drive->present = 1;
	drive->dead = 0;

	/*
	 * Check for an ATAPI device
	 */
164
	if (cmd == ATA_CMD_ID_ATAPI) {
165
		u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
166 167

		printk(KERN_CONT "ATAPI ");
L
Linus Torvalds 已提交
168 169
		switch (type) {
			case ide_floppy:
170 171 172 173
				if (!strstr(m, "CD-ROM")) {
					if (!strstr(m, "oppy") &&
					    !strstr(m, "poyp") &&
					    !strstr(m, "ZIP"))
174
						printk(KERN_CONT "cdrom or floppy?, assuming ");
L
Linus Torvalds 已提交
175
					if (drive->media != ide_cdrom) {
176
						printk(KERN_CONT "FLOPPY");
L
Linus Torvalds 已提交
177 178 179 180 181 182 183 184 185 186
						drive->removable = 1;
						break;
					}
				}
				/* Early cdrom models used zero */
				type = ide_cdrom;
			case ide_cdrom:
				drive->removable = 1;
#ifdef CONFIG_PPC
				/* kludge for Apple PowerBook internal zip */
187
				if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
188
					printk(KERN_CONT "FLOPPY");
L
Linus Torvalds 已提交
189 190 191 192
					type = ide_floppy;
					break;
				}
#endif
193
				printk(KERN_CONT "CD/DVD-ROM");
L
Linus Torvalds 已提交
194 195
				break;
			case ide_tape:
196
				printk(KERN_CONT "TAPE");
L
Linus Torvalds 已提交
197 198
				break;
			case ide_optical:
199
				printk(KERN_CONT "OPTICAL");
L
Linus Torvalds 已提交
200 201 202
				drive->removable = 1;
				break;
			default:
203
				printk(KERN_CONT "UNKNOWN (type %d)", type);
L
Linus Torvalds 已提交
204 205
				break;
		}
206
		printk(KERN_CONT " drive\n");
L
Linus Torvalds 已提交
207 208 209 210 211 212 213 214 215
		drive->media = type;
		/* an ATAPI device ignores DRDY */
		drive->ready_stat = 0;
		return;
	}

	/*
	 * Not an ATAPI device: looks like a "regular" hard disk
	 */
216 217 218 219 220

	/*
	 * 0x848a = CompactFlash device
	 * These are *not* removable in Linux definition of the term
	 */
221
	if (id[ATA_ID_CONFIG] != 0x848a && (id[ATA_ID_CONFIG] & (1 << 7)))
L
Linus Torvalds 已提交
222 223 224
		drive->removable = 1;

	drive->media = ide_disk;
225 226

	printk(KERN_CONT "%s DISK drive\n",
227
		(id[ATA_ID_CONFIG] == 0x848a) ? "CFA" : "ATA");
228

L
Linus Torvalds 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
	return;

err_misc:
	kfree(id);
	drive->present = 0;
	return;
}

/**
 *	actual_try_to_identify	-	send ata/atapi identify
 *	@drive: drive to identify
 *	@cmd: command to use
 *
 *	try_to_identify() sends an ATA(PI) IDENTIFY request to a drive
 *	and waits for a response.  It also monitors irqs while this is
 *	happening, in hope of automatically determining which one is
 *	being used by the interface.
 *
 *	Returns:	0  device was identified
 *			1  device timed-out (no response to identify request)
 *			2  device aborted the command (refused to identify itself)
 */

static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
255
	struct ide_io_ports *io_ports = &hwif->io_ports;
256
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
257
	int use_altstatus = 0, rc;
L
Linus Torvalds 已提交
258 259 260 261 262 263
	unsigned long timeout;
	u8 s = 0, a = 0;

	/* take a deep breath */
	msleep(50);

264
	if (io_ports->ctl_addr) {
265 266
		a = tp_ops->read_altstatus(hwif);
		s = tp_ops->read_status(hwif);
267
		if ((a ^ s) & ~ATA_IDX)
L
Linus Torvalds 已提交
268
			/* ancient Seagate drives, broken interfaces */
269 270 271 272
			printk(KERN_INFO "%s: probing with STATUS(0x%02x) "
					 "instead of ALTSTATUS(0x%02x)\n",
					 drive->name, s, a);
		else
L
Linus Torvalds 已提交
273
			/* use non-intrusive polling */
274 275
			use_altstatus = 1;
	}
L
Linus Torvalds 已提交
276 277 278 279

	/* set features register for atapi
	 * identify command to be sure of reply
	 */
280
	if (cmd == ATA_CMD_ID_ATAPI) {
281 282 283 284 285 286
		ide_task_t task;

		memset(&task, 0, sizeof(task));
		/* disable DMA & overlap */
		task.tf_flags = IDE_TFLAG_OUT_FEATURE;

287
		tp_ops->tf_load(drive, &task);
288
	}
L
Linus Torvalds 已提交
289 290

	/* ask drive for ID */
291
	tp_ops->exec_command(hwif, cmd);
L
Linus Torvalds 已提交
292

293
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
294 295 296

	if (ide_busy_sleep(hwif, timeout, use_altstatus))
		return 1;
L
Linus Torvalds 已提交
297

298
	/* wait for IRQ and ATA_DRQ */
L
Linus Torvalds 已提交
299
	msleep(50);
300
	s = tp_ops->read_status(hwif);
301

302
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
L
Linus Torvalds 已提交
303 304 305 306 307 308 309 310 311
		unsigned long flags;

		/* local CPU only; some systems need this */
		local_irq_save(flags);
		/* drive returned ID */
		do_identify(drive, cmd);
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
312
		(void)tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
		local_irq_restore(flags);
	} else {
		/* drive refused ID */
		rc = 2;
	}
	return rc;
}

/**
 *	try_to_identify	-	try to identify a drive
 *	@drive: drive to probe
 *	@cmd: command to use
 *
 *	Issue the identify command and then do IRQ probing to
 *	complete the identification when needed by finding the
 *	IRQ the drive is attached to
 */
 
static int try_to_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
334
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
L
Linus Torvalds 已提交
335 336 337 338 339 340 341 342 343 344
	int retval;
	int autoprobe = 0;
	unsigned long cookie = 0;

	/*
	 * Disable device irq unless we need to
	 * probe for it. Otherwise we'll get spurious
	 * interrupts during the identify-phase that
	 * the irq handler isn't expecting.
	 */
345
	if (hwif->io_ports.ctl_addr) {
L
Linus Torvalds 已提交
346 347 348 349
		if (!hwif->irq) {
			autoprobe = 1;
			cookie = probe_irq_on();
		}
350
		tp_ops->set_irq(hwif, autoprobe);
L
Linus Torvalds 已提交
351 352 353 354 355 356
	}

	retval = actual_try_to_identify(drive, cmd);

	if (autoprobe) {
		int irq;
357

358
		tp_ops->set_irq(hwif, 0);
L
Linus Torvalds 已提交
359
		/* clear drive IRQ */
360
		(void)tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
361 362 363 364 365 366 367 368 369
		udelay(5);
		irq = probe_irq_off(cookie);
		if (!hwif->irq) {
			if (irq > 0) {
				hwif->irq = irq;
			} else {
				/* Mmmm.. multiple IRQs..
				 * don't know which was ours
				 */
370
				printk(KERN_ERR "%s: IRQ probe failed (0x%lx)\n",
L
Linus Torvalds 已提交
371 372 373 374 375 376 377
					drive->name, cookie);
			}
		}
	}
	return retval;
}

378
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
379 380 381
{
	u8 stat;

382 383
	timeout += jiffies;

384
	do {
385 386 387
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
388
		if ((stat & ATA_BUSY) == 0)
389 390 391
			return 0;
	} while (time_before(jiffies, timeout));

392
	return 1;	/* drive timed-out */
393
}
L
Linus Torvalds 已提交
394

395 396 397 398 399 400 401
static u8 ide_read_device(ide_drive_t *drive)
{
	ide_task_t task;

	memset(&task, 0, sizeof(task));
	task.tf_flags = IDE_TFLAG_IN_DEVICE;

402
	drive->hwif->tp_ops->tf_read(drive, &task);
403 404 405 406

	return task.tf.device;
}

L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
/**
 *	do_probe		-	probe an IDE device
 *	@drive: drive to probe
 *	@cmd: command to use
 *
 *	do_probe() has the difficult job of finding a drive if it exists,
 *	without getting hung up if it doesn't exist, without trampling on
 *	ethernet cards, and without leaving any IRQs dangling to haunt us later.
 *
 *	If a drive is "known" to exist (from CMOS or kernel parameters),
 *	but does not respond right away, the probe will "hang in there"
 *	for the maximum wait time (about 30 seconds), otherwise it will
 *	exit much more quickly.
 *
 * Returns:	0  device was identified
 *		1  device timed-out (no response to identify request)
 *		2  device aborted the command (refused to identify itself)
 *		3  bad status from device (possible for ATAPI drives)
 *		4  probe was not attempted because failure was obvious
 */

static int do_probe (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
431
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
432 433
	int rc;
	u8 stat;
L
Linus Torvalds 已提交
434 435 436

	if (drive->present) {
		/* avoid waiting for inappropriate probes */
437
		if (drive->media != ide_disk && cmd == ATA_CMD_ID_ATA)
L
Linus Torvalds 已提交
438 439 440
			return 4;
	}
#ifdef DEBUG
441
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
L
Linus Torvalds 已提交
442
		drive->name, drive->present, drive->media,
443
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
L
Linus Torvalds 已提交
444 445 446 447 448 449 450 451
#endif

	/* needed for some systems
	 * (e.g. crw9624 as drive0 with disk as slave)
	 */
	msleep(50);
	SELECT_DRIVE(drive);
	msleep(50);
452 453

	if (ide_read_device(drive) != drive->select.all && !drive->present) {
L
Linus Torvalds 已提交
454 455 456
		if (drive->select.b.unit != 0) {
			/* exit with drive0 selected */
			SELECT_DRIVE(&hwif->drives[0]);
457
			/* allow ATA_BUSY to assert & clear */
L
Linus Torvalds 已提交
458 459 460 461 462 463
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

464
	stat = tp_ops->read_status(hwif);
465

466
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
467
	    drive->present || cmd == ATA_CMD_ID_ATAPI) {
L
Linus Torvalds 已提交
468 469 470 471 472
		/* send cmd and wait */
		if ((rc = try_to_identify(drive, cmd))) {
			/* failed: try again */
			rc = try_to_identify(drive,cmd);
		}
473

474
		stat = tp_ops->read_status(hwif);
475

476
		if (stat == (ATA_BUSY | ATA_DRDY))
L
Linus Torvalds 已提交
477 478
			return 4;

479
		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
480 481
			printk(KERN_ERR "%s: no response (status = 0x%02x), "
					"resetting drive\n", drive->name, stat);
L
Linus Torvalds 已提交
482
			msleep(50);
483
			SELECT_DRIVE(drive);
L
Linus Torvalds 已提交
484
			msleep(50);
485
			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
486
			(void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
L
Linus Torvalds 已提交
487 488
			rc = try_to_identify(drive, cmd);
		}
489 490

		/* ensure drive IRQ is clear */
491
		stat = tp_ops->read_status(hwif);
492

L
Linus Torvalds 已提交
493
		if (rc == 1)
494 495
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
L
Linus Torvalds 已提交
496 497 498 499 500 501 502 503 504
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
	if (drive->select.b.unit != 0) {
		/* exit with drive0 selected */
		SELECT_DRIVE(&hwif->drives[0]);
		msleep(50);
		/* ensure drive irq is clear */
505
		(void)tp_ops->read_status(hwif);
L
Linus Torvalds 已提交
506 507 508 509 510 511 512 513 514 515
	}
	return rc;
}

/*
 *
 */
static void enable_nest (ide_drive_t *drive)
{
	ide_hwif_t *hwif = HWIF(drive);
516
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
517
	u8 stat;
L
Linus Torvalds 已提交
518

519 520
	printk(KERN_INFO "%s: enabling %s -- ",
		hwif->name, (char *)&drive->id[ATA_ID_PROD]);
521

L
Linus Torvalds 已提交
522 523
	SELECT_DRIVE(drive);
	msleep(50);
524
	tp_ops->exec_command(hwif, ATA_EXABYTE_ENABLE_NEST);
525

526
	if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 0)) {
527 528 529
		printk(KERN_CONT "failed (timeout)\n");
		return;
	}
L
Linus Torvalds 已提交
530 531 532

	msleep(50);

533
	stat = tp_ops->read_status(hwif);
534 535 536 537 538

	if (!OK_STAT(stat, 0, BAD_STAT))
		printk(KERN_CONT "failed (status = 0x%02x)\n", stat);
	else
		printk(KERN_CONT "success\n");
L
Linus Torvalds 已提交
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
}

/**
 *	probe_for_drives	-	upper level drive probe
 *	@drive: drive to probe for
 *
 *	probe_for_drive() tests for existence of a given drive using do_probe()
 *	and presents things to the user as needed.
 *
 *	Returns:	0  no device was found
 *			1  device was found (note: drive->present might
 *			   still be 0)
 */
 
static inline u8 probe_for_drive (ide_drive_t *drive)
{
555 556
	char *m;

L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564 565
	/*
	 *	In order to keep things simple we have an id
	 *	block for all drives at all times. If the device
	 *	is pre ATA or refuses ATA/ATAPI identify we
	 *	will add faked data to this.
	 *
	 *	Also note that 0 everywhere means "can't do X"
	 */
 
566
	drive->id = kzalloc(SECTOR_WORDS *4, GFP_KERNEL);
L
Linus Torvalds 已提交
567 568 569 570 571 572
	drive->id_read = 0;
	if(drive->id == NULL)
	{
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
573 574 575 576

	m = (char *)&drive->id[ATA_ID_PROD];
	strcpy(m, "UNKNOWN");

L
Linus Torvalds 已提交
577
	/* skip probing? */
578 579
	if (!drive->noprobe) {
retry:
L
Linus Torvalds 已提交
580
		/* if !(success||timed-out) */
581
		if (do_probe(drive, ATA_CMD_ID_ATA) >= 2)
L
Linus Torvalds 已提交
582
			/* look for ATAPI device */
583
			(void)do_probe(drive, ATA_CMD_ID_ATAPI);
584

L
Linus Torvalds 已提交
585 586 587
		if (!drive->present)
			/* drive not found */
			return 0;
588

589
		if (strstr(m, "E X A B Y T E N E S T")) {
A
Alan Cox 已提交
590
			enable_nest(drive);
591 592 593
			goto retry;
		}

L
Linus Torvalds 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
		/* identification failed? */
		if (!drive->id_read) {
			if (drive->media == ide_disk) {
				printk(KERN_INFO "%s: non-IDE drive, CHS=%d/%d/%d\n",
					drive->name, drive->cyl,
					drive->head, drive->sect);
			} else if (drive->media == ide_cdrom) {
				printk(KERN_INFO "%s: ATAPI cdrom (?)\n", drive->name);
			} else {
				/* nuke it */
				printk(KERN_WARNING "%s: Unknown device on bus refused identification. Ignoring.\n", drive->name);
				drive->present = 0;
			}
		}
		/* drive was found */
	}
	if(!drive->present)
		return 0;
	/* The drive wasn't being helpful. Add generic info only */
	if (drive->id_read == 0) {
		generic_id(drive);
		return 1;
	}

	if (drive->media == ide_disk) {
		ide_disk_init_chs(drive);
		ide_disk_init_mult_count(drive);
	}

	return drive->present;
}

P
Pavel Machek 已提交
626
static void hwif_release_dev(struct device *dev)
L
Linus Torvalds 已提交
627 628 629
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

630
	complete(&hwif->gendev_rel_comp);
L
Linus Torvalds 已提交
631 632
}

633
static int ide_register_port(ide_hwif_t *hwif)
L
Linus Torvalds 已提交
634
{
635 636
	int ret;

L
Linus Torvalds 已提交
637 638 639 640
	/* register with global device tree */
	strlcpy(hwif->gendev.bus_id,hwif->name,BUS_ID_SIZE);
	hwif->gendev.driver_data = hwif;
	if (hwif->gendev.parent == NULL) {
641 642
		if (hwif->dev)
			hwif->gendev.parent = hwif->dev;
L
Linus Torvalds 已提交
643 644 645 646 647
		else
			/* Would like to do = &device_legacy */
			hwif->gendev.parent = NULL;
	}
	hwif->gendev.release = hwif_release_dev;
648
	ret = device_register(&hwif->gendev);
649
	if (ret < 0) {
650
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
651
			__func__, ret);
652 653 654
		goto out;
	}

655 656
	hwif->portdev = device_create_drvdata(ide_port_class, &hwif->gendev,
					      MKDEV(0, 0), hwif, hwif->name);
657 658 659 660 661 662
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
L
Linus Torvalds 已提交
663 664
}

665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
/**
 *	ide_port_wait_ready	-	wait for port to become ready
 *	@hwif: IDE port
 *
 *	This is needed on some PPCs and a bunch of BIOS-less embedded
 *	platforms.  Typical cases are:
 *
 *	- The firmware hard reset the disk before booting the kernel,
 *	  the drive is still doing it's poweron-reset sequence, that
 *	  can take up to 30 seconds.
 *
 *	- The firmware does nothing (or no firmware), the device is
 *	  still in POST state (same as above actually).
 *
 *	- Some CD/DVD/Writer combo drives tend to drive the bus during
 *	  their reset sequence even when they are non-selected slave
 *	  devices, thus preventing discovery of the main HD.
 *
 *	Doing this wait-for-non-busy should not harm any existing
 *	configuration and fix some issues like the above.
 *
 *	BenH.
 *
 *	Returns 0 on success, error code (< 0) otherwise.
 */

static int ide_port_wait_ready(ide_hwif_t *hwif)
L
Linus Torvalds 已提交
692
{
693
	int unit, rc;
L
Linus Torvalds 已提交
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709

	printk(KERN_DEBUG "Probing IDE interface %s...\n", hwif->name);

	/* Let HW settle down a bit from whatever init state we
	 * come from */
	mdelay(2);

	/* Wait for BSY bit to go away, spec timeout is 30 seconds,
	 * I know of at least one disk who takes 31 seconds, I use 35
	 * here to be safe
	 */
	rc = ide_wait_not_busy(hwif, 35000);
	if (rc)
		return rc;

	/* Now make sure both master & slave are ready */
710 711 712 713 714 715
	for (unit = 0; unit < MAX_DRIVES; unit++) {
		ide_drive_t *drive = &hwif->drives[unit];

		/* Ignore disks that we will not probe for later. */
		if (!drive->noprobe || drive->present) {
			SELECT_DRIVE(drive);
716
			hwif->tp_ops->set_irq(hwif, 1);
717 718 719 720 721 722 723 724 725
			mdelay(2);
			rc = ide_wait_not_busy(hwif, 35000);
			if (rc)
				goto out;
		} else
			printk(KERN_DEBUG "%s: ide_wait_not_busy() skipped\n",
					  drive->name);
	}
out:
L
Linus Torvalds 已提交
726
	/* Exit function with master reselected (let's be sane) */
727 728 729
	if (unit)
		SELECT_DRIVE(&hwif->drives[0]);

L
Linus Torvalds 已提交
730 731 732 733 734
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
735
 *	@dev1: slave device
L
Linus Torvalds 已提交
736 737 738 739 740 741
 *
 *	Analyse the drives on the interface and attempt to decide if we
 *	have the same drive viewed twice. This occurs with crap CF adapters
 *	and PCMCIA sometimes.
 */

742
void ide_undecoded_slave(ide_drive_t *dev1)
L
Linus Torvalds 已提交
743
{
744
	ide_drive_t *dev0 = &dev1->hwif->drives[0];
L
Linus Torvalds 已提交
745

746
	if ((dev1->dn & 1) == 0 || dev0->present == 0)
L
Linus Torvalds 已提交
747 748 749
		return;

	/* If the models don't match they are not the same product */
750 751
	if (strcmp((char *)&dev0->id[ATA_ID_PROD],
		   (char *)&dev1->id[ATA_ID_PROD]))
L
Linus Torvalds 已提交
752 753 754
		return;

	/* Serial numbers do not match */
755 756
	if (strncmp((char *)&dev0->id[ATA_ID_SERNO],
		    (char *)&dev1->id[ATA_ID_SERNO], ATA_ID_SERNO_LEN))
L
Linus Torvalds 已提交
757 758 759
		return;

	/* No serial number, thankfully very rare for CF */
760
	if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
L
Linus Torvalds 已提交
761 762 763 764 765
		return;

	/* Appears to be an IDE flash adapter with decode bugs */
	printk(KERN_WARNING "ide-probe: ignoring undecoded slave\n");

766
	dev1->present = 0;
L
Linus Torvalds 已提交
767 768 769 770
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

771
static int ide_probe_port(ide_hwif_t *hwif)
L
Linus Torvalds 已提交
772 773 774
{
	unsigned long flags;
	unsigned int irqd;
775 776 777
	int unit, rc = -ENODEV;

	BUG_ON(hwif->present);
L
Linus Torvalds 已提交
778

779
	if (hwif->drives[0].noprobe && hwif->drives[1].noprobe)
780
		return -EACCES;
L
Linus Torvalds 已提交
781 782 783 784 785 786 787 788 789 790 791

	/*
	 * We must always disable IRQ, as probe_for_drive will assert IRQ, but
	 * we'll install our IRQ driver much later...
	 */
	irqd = hwif->irq;
	if (irqd)
		disable_irq(hwif->irq);

	local_irq_set(flags);

792
	if (ide_port_wait_ready(hwif) == -EBUSY)
L
Linus Torvalds 已提交
793 794 795
		printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);

	/*
796 797
	 * Second drive should only exist if first drive was found,
	 * but a lot of cdrom drives are configured as single slaves.
L
Linus Torvalds 已提交
798
	 */
799
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
L
Linus Torvalds 已提交
800 801 802
		ide_drive_t *drive = &hwif->drives[unit];
		drive->dn = (hwif->channel ? 2 : 0) + unit;
		(void) probe_for_drive(drive);
803 804
		if (drive->present)
			rc = 0;
L
Linus Torvalds 已提交
805
	}
806

L
Linus Torvalds 已提交
807
	local_irq_restore(flags);
808

L
Linus Torvalds 已提交
809 810 811 812 813 814 815
	/*
	 * Use cached IRQ number. It might be (and is...) changed by probe
	 * code above
	 */
	if (irqd)
		enable_irq(irqd);

816
	return rc;
817 818 819 820
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
821
	const struct ide_port_ops *port_ops = hwif->port_ops;
822 823
	int unit;

824 825 826
	for (unit = 0; unit < MAX_DRIVES; unit++) {
		ide_drive_t *drive = &hwif->drives[unit];

827 828
		if (drive->present && port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
829
	}
830

L
Linus Torvalds 已提交
831 832 833 834
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		ide_drive_t *drive = &hwif->drives[unit];

		if (drive->present) {
835
			ide_set_max_pio(drive);
L
Linus Torvalds 已提交
836 837 838

			drive->nice1 = 1;

839
			if (hwif->dma_ops)
840
				ide_set_dma(drive);
L
Linus Torvalds 已提交
841 842
		}
	}
843 844 845 846

	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		ide_drive_t *drive = &hwif->drives[unit];

847
		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
848 849
			drive->no_io_32bit = 1;
		else
850
			drive->no_io_32bit = drive->id[ATA_ID_DWORD_IO] ? 1 : 0;
851
	}
L
Linus Torvalds 已提交
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
}

#if MAX_HWIFS > 1
/*
 * save_match() is used to simplify logic in init_irq() below.
 *
 * A loophole here is that we may not know about a particular
 * hwif's irq until after that hwif is actually probed/initialized..
 * This could be a problem for the case where an hwif is on a
 * dual interface that requires serialization (eg. cmd640) and another
 * hwif using one of the same irqs is initialized beforehand.
 *
 * This routine detects and reports such situations, but does not fix them.
 */
static void save_match(ide_hwif_t *hwif, ide_hwif_t *new, ide_hwif_t **match)
{
	ide_hwif_t *m = *match;

	if (m && m->hwgroup && m->hwgroup != new->hwgroup) {
		if (!new->hwgroup)
			return;
873
		printk(KERN_WARNING "%s: potential IRQ problem with %s and %s\n",
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881 882 883 884 885
			hwif->name, new->name, m->name);
	}
	if (!m || m->irq != hwif->irq) /* don't undo a prior perfect match */
		*match = new;
}
#endif /* MAX_HWIFS > 1 */

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
886
	struct request_queue *q;
L
Linus Torvalds 已提交
887 888 889 890 891 892 893 894 895 896 897
	ide_hwif_t *hwif = HWIF(drive);
	int max_sectors = 256;
	int max_sg_entries = PRD_ENTRIES;

	/*
	 *	Our default set up assumes the normal IDE case,
	 *	that is 64K segmenting, standard PRD setup
	 *	and LBA28. Some drivers then impose their own
	 *	limits and LBA48 we could raise it but as yet
	 *	do not.
	 */
898

899
	q = blk_init_queue_node(do_ide_request, &ide_lock, hwif_to_node(hwif));
L
Linus Torvalds 已提交
900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
	if (!q)
		return 1;

	q->queuedata = drive;
	blk_queue_segment_boundary(q, 0xffff);

	if (hwif->rqsize < max_sectors)
		max_sectors = hwif->rqsize;
	blk_queue_max_sectors(q, max_sectors);

#ifdef CONFIG_PCI
	/* When we have an IOMMU, we may have a problem where pci_map_sg()
	 * creates segments that don't completely match our boundary
	 * requirements and thus need to be broken up again. Because it
	 * doesn't align properly either, we may actually have to break up
	 * to more segments than what was we got in the first place, a max
	 * worst case is twice as many.
	 * This will be fixed once we teach pci_map_sg() about our boundary
	 * requirements, hopefully soon. *FIXME*
	 */
	if (!PCI_DMA_BUS_IS_PHYS)
		max_sg_entries >>= 1;
#endif /* CONFIG_PCI */

	blk_queue_max_hw_segments(q, max_sg_entries);
	blk_queue_max_phys_segments(q, max_sg_entries);

	/* assign drive queue */
	drive->queue = q;

	/* needs drive->queue to be set */
	ide_toggle_bounce(drive, 1);

	return 0;
}

936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
static void ide_add_drive_to_hwgroup(ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;

	spin_lock_irq(&ide_lock);
	if (!hwgroup->drive) {
		/* first drive for hwgroup. */
		drive->next = drive;
		hwgroup->drive = drive;
		hwgroup->hwif = HWIF(hwgroup->drive);
	} else {
		drive->next = hwgroup->drive->next;
		hwgroup->drive->next = drive;
	}
	spin_unlock_irq(&ide_lock);
}

953 954 955 956 957 958 959 960 961
/*
 * For any present drive:
 * - allocate the block device queue
 * - link drive into the hwgroup
 */
static void ide_port_setup_devices(ide_hwif_t *hwif)
{
	int i;

962
	mutex_lock(&ide_cfg_mtx);
963 964 965 966 967 968 969 970 971 972 973 974 975 976
	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive = &hwif->drives[i];

		if (!drive->present)
			continue;

		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
			continue;
		}

		ide_add_drive_to_hwgroup(drive);
	}
977
	mutex_unlock(&ide_cfg_mtx);
978 979
}

B
Bartlomiej Zolnierkiewicz 已提交
980 981
static ide_hwif_t *ide_ports[MAX_HWIFS];

982 983 984 985
void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
{
	ide_hwgroup_t *hwgroup = hwif->hwgroup;

B
Bartlomiej Zolnierkiewicz 已提交
986 987
	ide_ports[hwif->index] = NULL;

988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
	spin_lock_irq(&ide_lock);
	/*
	 * Remove us from the hwgroup, and free
	 * the hwgroup if we were the only member
	 */
	if (hwif->next == hwif) {
		BUG_ON(hwgroup->hwif != hwif);
		kfree(hwgroup);
	} else {
		/* There is another interface in hwgroup.
		 * Unlink us, and set hwgroup->drive and ->hwif to
		 * something sane.
		 */
		ide_hwif_t *g = hwgroup->hwif;

		while (g->next != hwif)
			g = g->next;
		g->next = hwif->next;
		if (hwgroup->hwif == hwif) {
			/* Chose a random hwif for hwgroup->hwif.
			 * It's guaranteed that there are no drives
			 * left in the hwgroup.
			 */
			BUG_ON(hwgroup->drive != NULL);
			hwgroup->hwif = g;
		}
		BUG_ON(hwgroup->hwif == hwif);
	}
	spin_unlock_irq(&ide_lock);
}

L
Linus Torvalds 已提交
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
/*
 * This routine sets up the irq for an ide interface, and creates a new
 * hwgroup for the irq/hwif if none was previously assigned.
 *
 * Much of the code is for correctly detecting/handling irq sharing
 * and irq serialization situations.  This is somewhat complex because
 * it handles static as well as dynamic (PCMCIA) IDE interfaces.
 */
static int init_irq (ide_hwif_t *hwif)
{
1029
	struct ide_io_ports *io_ports = &hwif->io_ports;
L
Linus Torvalds 已提交
1030 1031 1032 1033
	unsigned int index;
	ide_hwgroup_t *hwgroup;
	ide_hwif_t *match = NULL;

1034
	mutex_lock(&ide_cfg_mtx);
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039 1040
	hwif->hwgroup = NULL;
#if MAX_HWIFS > 1
	/*
	 * Group up with any other hwifs that share our irq(s).
	 */
	for (index = 0; index < MAX_HWIFS; index++) {
B
Bartlomiej Zolnierkiewicz 已提交
1041 1042 1043
		ide_hwif_t *h = ide_ports[index];

		if (h && h->hwgroup) {  /* scan only initialized ports */
L
Linus Torvalds 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
			if (hwif->irq == h->irq) {
				hwif->sharing_irq = h->sharing_irq = 1;
				if (hwif->chipset != ide_pci ||
				    h->chipset != ide_pci) {
					save_match(hwif, h, &match);
				}
			}
			if (hwif->serialized) {
				if (hwif->mate && hwif->mate->irq == h->irq)
					save_match(hwif, h, &match);
			}
			if (h->serialized) {
				if (h->mate && hwif->irq == h->mate->irq)
					save_match(hwif, h, &match);
			}
		}
	}
#endif /* MAX_HWIFS > 1 */
	/*
	 * If we are still without a hwgroup, then form a new one
	 */
	if (match) {
		hwgroup = match->hwgroup;
		hwif->hwgroup = hwgroup;
		/*
		 * Link us into the hwgroup.
		 * This must be done early, do ensure that unexpected_intr
		 * can find the hwif and prevent irq storms.
		 * No drives are attached to the new hwif, choose_drive
		 * can't do anything stupid (yet).
		 * Add ourself as the 2nd entry to the hwgroup->hwif
		 * linked list, the first entry is the hwif that owns
		 * hwgroup->handler - do not change that.
		 */
		spin_lock_irq(&ide_lock);
		hwif->next = hwgroup->hwif->next;
		hwgroup->hwif->next = hwif;
1081
		BUG_ON(hwif->next == hwif);
L
Linus Torvalds 已提交
1082 1083
		spin_unlock_irq(&ide_lock);
	} else {
1084 1085 1086 1087
		hwgroup = kmalloc_node(sizeof(*hwgroup), GFP_KERNEL|__GFP_ZERO,
				       hwif_to_node(hwif));
		if (hwgroup == NULL)
			goto out_up;
L
Linus Torvalds 已提交
1088 1089

		hwif->hwgroup = hwgroup;
1090
		hwgroup->hwif = hwif->next = hwif;
L
Linus Torvalds 已提交
1091 1092 1093 1094 1095 1096

		init_timer(&hwgroup->timer);
		hwgroup->timer.function = &ide_timer_expiry;
		hwgroup->timer.data = (unsigned long) hwgroup;
	}

B
Bartlomiej Zolnierkiewicz 已提交
1097 1098
	ide_ports[hwif->index] = hwif;

L
Linus Torvalds 已提交
1099 1100 1101 1102
	/*
	 * Allocate the irq, if not already obtained for another hwif
	 */
	if (!match || match->irq != hwif->irq) {
1103
		int sa = 0;
A
Adrian Bunk 已提交
1104
#if defined(__mc68000__)
1105
		sa = IRQF_SHARED;
1106
#endif /* __mc68000__ */
L
Linus Torvalds 已提交
1107

1108
		if (IDE_CHIPSET_IS_PCI(hwif->chipset))
1109
			sa = IRQF_SHARED;
L
Linus Torvalds 已提交
1110

1111
		if (io_ports->ctl_addr)
1112
			hwif->tp_ops->set_irq(hwif, 1);
L
Linus Torvalds 已提交
1113 1114 1115 1116 1117

		if (request_irq(hwif->irq,&ide_intr,sa,hwif->name,hwgroup))
	       		goto out_unlink;
	}

1118 1119 1120 1121 1122 1123 1124 1125
	if (!hwif->rqsize) {
		if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
		    (hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA))
			hwif->rqsize = 256;
		else
			hwif->rqsize = 65536;
	}

A
Adrian Bunk 已提交
1126
#if !defined(__mc68000__)
1127
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
1128 1129
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
L
Linus Torvalds 已提交
1130
#else
1131
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
1132
		io_ports->data_addr, hwif->irq);
A
Adrian Bunk 已提交
1133
#endif /* __mc68000__ */
L
Linus Torvalds 已提交
1134
	if (match)
1135
		printk(KERN_CONT " (%sed with %s)",
L
Linus Torvalds 已提交
1136
			hwif->sharing_irq ? "shar" : "serializ", match->name);
1137
	printk(KERN_CONT "\n");
1138

1139
	mutex_unlock(&ide_cfg_mtx);
L
Linus Torvalds 已提交
1140 1141
	return 0;
out_unlink:
1142
	ide_remove_port_from_hwgroup(hwif);
L
Linus Torvalds 已提交
1143
out_up:
1144
	mutex_unlock(&ide_cfg_mtx);
L
Linus Torvalds 已提交
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
	return 1;
}

static int ata_lock(dev_t dev, void *data)
{
	/* FIXME: we want to pin hwif down */
	return 0;
}

static struct kobject *ata_probe(dev_t dev, int *part, void *data)
{
	ide_hwif_t *hwif = data;
	int unit = *part >> PARTN_BITS;
	ide_drive_t *drive = &hwif->drives[unit];
	if (!drive->present)
		return NULL;

	if (drive->media == ide_disk)
		request_module("ide-disk");
	if (drive->scsi)
		request_module("ide-scsi");
	if (drive->media == ide_cdrom || drive->media == ide_optical)
		request_module("ide-cd");
	if (drive->media == ide_tape)
		request_module("ide-tape");
	if (drive->media == ide_floppy)
		request_module("ide-floppy");

	return NULL;
}

static struct kobject *exact_match(dev_t dev, int *part, void *data)
{
	struct gendisk *p = data;
	*part &= (1 << PARTN_BITS) - 1;
1180
	return &disk_to_dev(p)->kobj;
L
Linus Torvalds 已提交
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
}

static int exact_lock(dev_t dev, void *data)
{
	struct gendisk *p = data;

	if (!get_disk(p))
		return -1;
	return 0;
}

void ide_register_region(struct gendisk *disk)
{
	blk_register_region(MKDEV(disk->major, disk->first_minor),
			    disk->minors, NULL, exact_match, exact_lock, disk);
}

EXPORT_SYMBOL_GPL(ide_register_region);

void ide_unregister_region(struct gendisk *disk)
{
	blk_unregister_region(MKDEV(disk->major, disk->first_minor),
			      disk->minors);
}

EXPORT_SYMBOL_GPL(ide_unregister_region);

void ide_init_disk(struct gendisk *disk, ide_drive_t *drive)
{
	ide_hwif_t *hwif = drive->hwif;
	unsigned int unit = (drive->select.all >> 4) & 1;

	disk->major = hwif->major;
	disk->first_minor = unit << PARTN_BITS;
	sprintf(disk->disk_name, "hd%c", 'a' + hwif->index * MAX_DRIVES + unit);
	disk->queue = drive->queue;
}

EXPORT_SYMBOL_GPL(ide_init_disk);

1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
static void ide_remove_drive_from_hwgroup(ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;

	if (drive == drive->next) {
		/* special case: last drive from hwgroup. */
		BUG_ON(hwgroup->drive != drive);
		hwgroup->drive = NULL;
	} else {
		ide_drive_t *walk;

		walk = hwgroup->drive;
		while (walk->next != drive)
			walk = walk->next;
		walk->next = drive->next;
		if (hwgroup->drive == drive) {
			hwgroup->drive = drive->next;
			hwgroup->hwif = hwgroup->drive->hwif;
		}
	}
	BUG_ON(hwgroup->drive == drive);
}

L
Linus Torvalds 已提交
1244 1245 1246 1247
static void drive_release_dev (struct device *dev)
{
	ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);

1248 1249
	ide_proc_unregister_device(drive);

1250 1251
	spin_lock_irq(&ide_lock);
	ide_remove_drive_from_hwgroup(drive);
1252 1253
	kfree(drive->id);
	drive->id = NULL;
1254 1255 1256 1257 1258 1259 1260 1261
	drive->present = 0;
	/* Messed up locking ... */
	spin_unlock_irq(&ide_lock);
	blk_cleanup_queue(drive->queue);
	spin_lock_irq(&ide_lock);
	drive->queue = NULL;
	spin_unlock_irq(&ide_lock);

1262
	complete(&drive->gendev_rel_comp);
L
Linus Torvalds 已提交
1263 1264 1265 1266 1267 1268 1269
}

static int hwif_init(ide_hwif_t *hwif)
{
	int old_irq;

	if (!hwif->irq) {
1270
		hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
1271
		if (!hwif->irq) {
1272
			printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
1273
			return 0;
L
Linus Torvalds 已提交
1274 1275 1276 1277 1278 1279 1280 1281 1282
		}
	}

	if (register_blkdev(hwif->major, hwif->name))
		return 0;

	if (!hwif->sg_max_nents)
		hwif->sg_max_nents = PRD_ENTRIES;

J
Jens Axboe 已提交
1283
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}
J
Jens Axboe 已提交
1289 1290

	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
L
Linus Torvalds 已提交
1291 1292 1293 1294 1295 1296 1297 1298 1299
	
	if (init_irq(hwif) == 0)
		goto done;

	old_irq = hwif->irq;
	/*
	 *	It failed to initialise. Find the default IRQ for 
	 *	this port and try that.
	 */
1300
	hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
1301
	if (!hwif->irq) {
1302
		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
L
Linus Torvalds 已提交
1303 1304 1305 1306
			hwif->name, old_irq);
		goto out;
	}
	if (init_irq(hwif)) {
1307
		printk(KERN_ERR "%s: probed IRQ %d and default IRQ %d failed\n",
L
Linus Torvalds 已提交
1308 1309 1310
			hwif->name, old_irq, hwif->irq);
		goto out;
	}
1311
	printk(KERN_WARNING "%s: probed IRQ %d failed, using default\n",
L
Linus Torvalds 已提交
1312 1313 1314
		hwif->name, hwif->irq);

done:
1315 1316
	blk_register_region(MKDEV(hwif->major, 0), MAX_DRIVES << PARTN_BITS,
			    THIS_MODULE, ata_probe, ata_lock, hwif);
L
Linus Torvalds 已提交
1317 1318 1319 1320 1321 1322 1323
	return 1;

out:
	unregister_blkdev(hwif->major, hwif->name);
	return 0;
}

1324 1325 1326 1327 1328 1329
static void hwif_register_devices(ide_hwif_t *hwif)
{
	unsigned int i;

	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive = &hwif->drives[i];
1330 1331
		struct device *dev = &drive->gendev;
		int ret;
1332

1333 1334
		if (!drive->present)
			continue;
1335

1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
		ide_add_generic_settings(drive);

		snprintf(dev->bus_id, BUS_ID_SIZE, "%u.%u", hwif->index, i);
		dev->parent = &hwif->gendev;
		dev->bus = &ide_bus_type;
		dev->driver_data = drive;
		dev->release = drive_release_dev;

		ret = device_register(dev);
		if (ret < 0)
			printk(KERN_WARNING "IDE: %s: device_register error: "
					    "%d\n", __func__, ret);
1348 1349 1350
	}
}

1351 1352
static void ide_port_init_devices(ide_hwif_t *hwif)
{
1353
	const struct ide_port_ops *port_ops = hwif->port_ops;
1354 1355 1356 1357 1358 1359 1360 1361 1362
	int i;

	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive = &hwif->drives[i];

		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
			drive->io_32bit = 1;
		if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
			drive->unmask = 1;
1363 1364
		if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
			drive->no_unmask = 1;
1365

1366 1367 1368
		if (port_ops && port_ops->init_dev)
			port_ops->init_dev(drive);
	}
1369 1370
}

1371 1372
static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
			  const struct ide_port_info *d)
1373
{
1374
	hwif->channel = port;
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385

	if (d->chipset)
		hwif->chipset = d->chipset;

	if (d->init_iops)
		d->init_iops(hwif);

	if ((!hwif->irq && (d->host_flags & IDE_HFLAG_LEGACY_IRQS)) ||
	    (d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS))
		hwif->irq = port ? 15 : 14;

1386 1387
	/* ->host_flags may be set by ->init_iops (or even earlier...) */
	hwif->host_flags |= d->host_flags;
1388 1389
	hwif->pio_mask = d->pio_mask;

1390 1391 1392
	if (d->tp_ops)
		hwif->tp_ops = d->tp_ops;

1393 1394 1395 1396
	/* ->set_pio_mode for DTC2278 is currently limited to port 0 */
	if (hwif->chipset != ide_dtc2278 || hwif->channel == 0)
		hwif->port_ops = d->port_ops;

1397 1398 1399 1400
	hwif->swdma_mask = d->swdma_mask;
	hwif->mwdma_mask = d->mwdma_mask;
	hwif->ultra_mask = d->udma_mask;

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
		int rc;

		if (d->init_dma)
			rc = d->init_dma(hwif, d);
		else
			rc = ide_hwif_setup_dma(hwif, d);

		if (rc < 0) {
			printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
1411
			hwif->dma_base = 0;
1412 1413 1414
			hwif->swdma_mask = 0;
			hwif->mwdma_mask = 0;
			hwif->ultra_mask = 0;
1415 1416
		} else if (d->dma_ops)
			hwif->dma_ops = d->dma_ops;
1417
	}
1418

1419 1420 1421 1422 1423 1424
	if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
	    ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base)) {
		if (hwif->mate)
			hwif->mate->serialized = hwif->serialized = 1;
	}

1425 1426 1427 1428 1429 1430
	if (d->host_flags & IDE_HFLAG_RQSIZE_256)
		hwif->rqsize = 256;

	/* call chipset specific routine for each enabled port */
	if (d->init_hwif)
		d->init_hwif(hwif);
1431
}
1432

1433 1434
static void ide_port_cable_detect(ide_hwif_t *hwif)
{
1435 1436 1437
	const struct ide_port_ops *port_ops = hwif->port_ops;

	if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
1438
		if (hwif->cbl != ATA_CBL_PATA40_SHORT)
1439
			hwif->cbl = port_ops->cable_detect(hwif);
1440
	}
1441 1442
}

1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
static ssize_t store_delete_devices(struct device *portdev,
				    struct device_attribute *attr,
				    const char *buf, size_t n)
{
	ide_hwif_t *hwif = dev_get_drvdata(portdev);

	if (strncmp(buf, "1", n))
		return -EINVAL;

	ide_port_unregister_devices(hwif);

	return n;
};

static DEVICE_ATTR(delete_devices, S_IWUSR, NULL, store_delete_devices);

static ssize_t store_scan(struct device *portdev,
			  struct device_attribute *attr,
			  const char *buf, size_t n)
{
	ide_hwif_t *hwif = dev_get_drvdata(portdev);

	if (strncmp(buf, "1", n))
		return -EINVAL;

	ide_port_unregister_devices(hwif);
	ide_port_scan(hwif);

	return n;
};

static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);

static struct device_attribute *ide_port_attrs[] = {
	&dev_attr_delete_devices,
	&dev_attr_scan,
	NULL
};

static int ide_sysfs_register_port(ide_hwif_t *hwif)
{
1484
	int i, uninitialized_var(rc);
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494

	for (i = 0; ide_port_attrs[i]; i++) {
		rc = device_create_file(hwif->portdev, ide_port_attrs[i]);
		if (rc)
			break;
	}

	return rc;
}

1495 1496
static unsigned int ide_indexes;

1497
/**
1498
 *	ide_find_port_slot	-	find free port slot
1499 1500
 *	@d: IDE port info
 *
1501
 *	Return the new port slot index or -ENOENT if we are out of free slots.
1502 1503
 */

1504
static int ide_find_port_slot(const struct ide_port_info *d)
1505
{
1506
	int idx = -ENOENT;
1507
	u8 bootable = (d && (d->host_flags & IDE_HFLAG_NON_BOOTABLE)) ? 0 : 1;
1508
	u8 i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;;
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519

	/*
	 * Claim an unassigned slot.
	 *
	 * Give preference to claiming other slots before claiming ide0/ide1,
	 * just in case there's another interface yet-to-be-scanned
	 * which uses ports 0x1f0/0x170 (the ide0/ide1 defaults).
	 *
	 * Unless there is a bootable card that does not use the standard
	 * ports 0x1f0/0x170 (the ide0/ide1 defaults).
	 */
1520 1521 1522 1523
	mutex_lock(&ide_cfg_mtx);
	if (MAX_HWIFS == 1) {
		if (ide_indexes == 0 && i == 0)
			idx = 1;
1524
	} else {
1525 1526 1527 1528 1529 1530 1531 1532
		if (bootable) {
			if ((ide_indexes | i) != (1 << MAX_HWIFS) - 1)
				idx = ffz(ide_indexes | i);
		} else {
			if ((ide_indexes | 3) != (1 << MAX_HWIFS) - 1)
				idx = ffz(ide_indexes | 3);
			else if ((ide_indexes & 3) != 3)
				idx = ffz(ide_indexes);
1533 1534
		}
	}
1535 1536 1537
	if (idx >= 0)
		ide_indexes |= (1 << idx);
	mutex_unlock(&ide_cfg_mtx);
1538

1539 1540
	return idx;
}
1541

1542 1543 1544 1545 1546
static void ide_free_port_slot(int idx)
{
	mutex_lock(&ide_cfg_mtx);
	ide_indexes &= ~(1 << idx);
	mutex_unlock(&ide_cfg_mtx);
1547 1548
}

1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
struct ide_host *ide_host_alloc_all(const struct ide_port_info *d,
				    hw_regs_t **hws)
{
	struct ide_host *host;
	int i;

	host = kzalloc(sizeof(*host), GFP_KERNEL);
	if (host == NULL)
		return NULL;

	for (i = 0; i < MAX_HWIFS; i++) {
		ide_hwif_t *hwif;
1561
		int idx;
1562 1563 1564 1565

		if (hws[i] == NULL)
			continue;

1566 1567 1568 1569
		hwif = kzalloc(sizeof(*hwif), GFP_KERNEL);
		if (hwif == NULL)
			continue;

1570 1571 1572 1573
		idx = ide_find_port_slot(d);
		if (idx < 0) {
			printk(KERN_ERR "%s: no free slot for interface\n",
					d ? d->name : "ide");
1574
			kfree(hwif);
1575
			continue;
1576
		}
1577 1578 1579

		ide_init_port_data(hwif, idx);

1580 1581
		hwif->host = host;

1582 1583
		host->ports[i] = hwif;
		host->n_ports++;
1584 1585 1586 1587 1588 1589 1590
	}

	if (host->n_ports == 0) {
		kfree(host);
		return NULL;
	}

1591 1592 1593
	if (hws[0])
		host->dev[0] = hws[0]->dev;

1594 1595 1596
	if (d)
		host->host_flags = d->host_flags;

1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
	return host;
}
EXPORT_SYMBOL_GPL(ide_host_alloc_all);

struct ide_host *ide_host_alloc(const struct ide_port_info *d, hw_regs_t **hws)
{
	hw_regs_t *hws_all[MAX_HWIFS];
	int i;

	for (i = 0; i < MAX_HWIFS; i++)
		hws_all[i] = (i < 4) ? hws[i] : NULL;

	return ide_host_alloc_all(d, hws_all);
}
EXPORT_SYMBOL_GPL(ide_host_alloc);

int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
		      hw_regs_t **hws)
1615 1616
{
	ide_hwif_t *hwif, *mate = NULL;
1617
	int i, j = 0;
1618

1619
	for (i = 0; i < MAX_HWIFS; i++) {
1620
		hwif = host->ports[i];
1621

1622
		if (hwif == NULL) {
1623 1624 1625 1626
			mate = NULL;
			continue;
		}

1627
		ide_init_port_hw(hwif, hws[i]);
1628 1629 1630 1631 1632 1633 1634
		ide_port_apply_params(hwif);

		if (d == NULL) {
			mate = NULL;
			continue;
		}

1635
		if ((i & 1) && mate) {
1636 1637 1638 1639 1640 1641 1642
			hwif->mate = mate;
			mate->mate = hwif;
		}

		mate = (i & 1) ? NULL : hwif;

		ide_init_port(hwif, i & 1, d);
1643
		ide_port_cable_detect(hwif);
1644
		ide_port_init_devices(hwif);
1645 1646
	}

1647
	for (i = 0; i < MAX_HWIFS; i++) {
1648
		hwif = host->ports[i];
1649

1650 1651
		if (hwif == NULL)
			continue;
1652

1653 1654
		if (ide_probe_port(hwif) == 0)
			hwif->present = 1;
1655 1656 1657 1658 1659

		if (hwif->chipset != ide_4drives || !hwif->mate ||
		    !hwif->mate->present)
			ide_register_port(hwif);

1660 1661
		if (hwif->present)
			ide_port_tune_devices(hwif);
1662
	}
1663

1664
	for (i = 0; i < MAX_HWIFS; i++) {
1665
		hwif = host->ports[i];
1666

1667 1668
		if (hwif == NULL)
			continue;
1669 1670 1671 1672

		if (hwif_init(hwif) == 0) {
			printk(KERN_INFO "%s: failed to initialize IDE "
					 "interface\n", hwif->name);
1673
			hwif->present = 0;
1674 1675
			continue;
		}
1676

1677 1678
		j++;

1679 1680
		if (hwif->present)
			ide_port_setup_devices(hwif);
1681

1682
		ide_acpi_init(hwif);
1683 1684 1685

		if (hwif->present)
			ide_acpi_port_init_devices(hwif);
1686 1687
	}

1688
	for (i = 0; i < MAX_HWIFS; i++) {
1689
		hwif = host->ports[i];
1690

1691 1692
		if (hwif == NULL)
			continue;
1693

1694 1695 1696 1697
		if (hwif->chipset == ide_unknown)
			hwif->chipset = ide_generic;

		if (hwif->present)
1698
			hwif_register_devices(hwif);
1699 1700
	}

1701
	for (i = 0; i < MAX_HWIFS; i++) {
1702
		hwif = host->ports[i];
1703

1704 1705
		if (hwif == NULL)
			continue;
1706

1707 1708 1709 1710
		ide_sysfs_register_port(hwif);
		ide_proc_register_port(hwif);

		if (hwif->present)
1711
			ide_proc_port_register_devices(hwif);
1712 1713
	}

1714
	return j ? 0 : -1;
1715
}
1716
EXPORT_SYMBOL_GPL(ide_host_register);
1717

1718 1719 1720 1721
int ide_host_add(const struct ide_port_info *d, hw_regs_t **hws,
		 struct ide_host **hostp)
{
	struct ide_host *host;
1722
	int rc;
1723 1724 1725 1726 1727

	host = ide_host_alloc(d, hws);
	if (host == NULL)
		return -ENOMEM;

1728 1729 1730 1731 1732
	rc = ide_host_register(host, d, hws);
	if (rc) {
		ide_host_free(host);
		return rc;
	}
1733 1734 1735 1736 1737 1738 1739 1740

	if (hostp)
		*hostp = host;

	return 0;
}
EXPORT_SYMBOL_GPL(ide_host_add);

1741
void ide_host_free(struct ide_host *host)
1742
{
1743
	ide_hwif_t *hwif;
1744
	int i;
1745

1746
	for (i = 0; i < MAX_HWIFS; i++) {
1747 1748 1749 1750 1751 1752
		hwif = host->ports[i];

		if (hwif == NULL)
			continue;

		ide_free_port_slot(hwif->index);
1753
		kfree(hwif);
1754
	}
1755

1756
	kfree(host);
1757
}
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
EXPORT_SYMBOL_GPL(ide_host_free);

void ide_host_remove(struct ide_host *host)
{
	int i;

	for (i = 0; i < MAX_HWIFS; i++) {
		if (host->ports[i])
			ide_unregister(host->ports[i]);
	}

	ide_host_free(host);
}
1771
EXPORT_SYMBOL_GPL(ide_host_remove);
1772 1773 1774

void ide_port_scan(ide_hwif_t *hwif)
{
1775
	ide_port_apply_params(hwif);
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
	ide_port_cable_detect(hwif);
	ide_port_init_devices(hwif);

	if (ide_probe_port(hwif) < 0)
		return;

	hwif->present = 1;

	ide_port_tune_devices(hwif);
	ide_acpi_port_init_devices(hwif);
	ide_port_setup_devices(hwif);
	hwif_register_devices(hwif);
	ide_proc_port_register_devices(hwif);
}
EXPORT_SYMBOL_GPL(ide_port_scan);
1791

1792
static void ide_legacy_init_one(hw_regs_t **hws, hw_regs_t *hw,
1793
				u8 port_no, const struct ide_port_info *d,
1794
				unsigned long config)
1795
{
1796 1797
	unsigned long base, ctl;
	int irq;
1798

1799 1800 1801 1802 1803 1804 1805 1806 1807
	if (port_no == 0) {
		base = 0x1f0;
		ctl  = 0x3f6;
		irq  = 14;
	} else {
		base = 0x170;
		ctl  = 0x376;
		irq  = 15;
	}
1808

1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
	if (!request_region(base, 8, d->name)) {
		printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
				d->name, base, base + 7);
		return;
	}

	if (!request_region(ctl, 1, d->name)) {
		printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
				d->name, ctl);
		release_region(base, 8);
		return;
	}

1822 1823
	ide_std_init_ports(hw, base, ctl);
	hw->irq = irq;
1824
	hw->chipset = d->chipset;
1825
	hw->config = config;
1826

1827
	hws[port_no] = hw;
1828
}
1829

1830 1831
int ide_legacy_device_add(const struct ide_port_info *d, unsigned long config)
{
1832
	hw_regs_t hw[2], *hws[] = { NULL, NULL, NULL, NULL };
1833

1834 1835 1836
	memset(&hw, 0, sizeof(hw));

	if ((d->host_flags & IDE_HFLAG_QD_2ND_PORT) == 0)
1837 1838
		ide_legacy_init_one(hws, &hw[0], 0, d, config);
	ide_legacy_init_one(hws, &hw[1], 1, d, config);
1839

1840
	if (hws[0] == NULL && hws[1] == NULL &&
1841 1842
	    (d->host_flags & IDE_HFLAG_SINGLE))
		return -ENOENT;
1843

1844
	return ide_host_add(d, hws, NULL);
1845 1846
}
EXPORT_SYMBOL_GPL(ide_legacy_device_add);