ide-probe.c 37.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2 3
 *  Copyright (C) 1994-1998   Linus Torvalds & authors (see below)
 *  Copyright (C) 2005, 2007  Bartlomiej Zolnierkiewicz
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
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>
FUJITA Tomonori's avatar
FUJITA Tomonori committed
35
#include <linux/scatterlist.h>
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
58 59 60 61
}

static void ide_disk_init_chs(ide_drive_t *drive)
{
62
	u16 *id = drive->id;
Linus Torvalds's avatar
Linus Torvalds committed
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];
Linus Torvalds's avatar
Linus Torvalds committed
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];
Linus Torvalds's avatar
Linus Torvalds committed
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];
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
90

91 92 93 94 95 96 97
	if (max_multsect) {
		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;
98 99

		if (drive->mult_req)
100
			drive->special_flags |= IDE_SFLAG_SET_MULTMODE;
Linus Torvalds's avatar
Linus Torvalds committed
101 102 103
	}
}

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
static void ide_classify_ata_dev(ide_drive_t *drive)
{
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
	int is_cfa = ata_id_is_cfa(id);

	/* CF devices are *not* removable in Linux definition of the term */
	if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;

	drive->media = ide_disk;

	if (!ata_id_has_unload(drive->id))
		drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;

	printk(KERN_INFO "%s: %s, %s DISK drive\n", drive->name, m,
		is_cfa ? "CFA" : "ATA");
}

static void ide_classify_atapi_dev(ide_drive_t *drive)
{
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
	u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;

	printk(KERN_INFO "%s: %s, ATAPI ", drive->name, m);
	switch (type) {
	case ide_floppy:
		if (!strstr(m, "CD-ROM")) {
			if (!strstr(m, "oppy") &&
			    !strstr(m, "poyp") &&
			    !strstr(m, "ZIP"))
				printk(KERN_CONT "cdrom or floppy?, assuming ");
			if (drive->media != ide_cdrom) {
				printk(KERN_CONT "FLOPPY");
				drive->dev_flags |= IDE_DFLAG_REMOVABLE;
				break;
			}
		}
		/* Early cdrom models used zero */
		type = ide_cdrom;
	case ide_cdrom:
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
#ifdef CONFIG_PPC
		/* kludge for Apple PowerBook internal zip */
		if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
			printk(KERN_CONT "FLOPPY");
			type = ide_floppy;
			break;
		}
#endif
		printk(KERN_CONT "CD/DVD-ROM");
		break;
	case ide_tape:
		printk(KERN_CONT "TAPE");
		break;
	case ide_optical:
		printk(KERN_CONT "OPTICAL");
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
		break;
	default:
		printk(KERN_CONT "UNKNOWN (type %d)", type);
		break;
	}

	printk(KERN_CONT " drive\n");
	drive->media = type;
	/* an ATAPI device ignores DRDY */
	drive->ready_stat = 0;
	if (ata_id_cdb_intr(id))
		drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
	drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
	/* we don't do head unloading on ATAPI devices */
	drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
}

Linus Torvalds's avatar
Linus Torvalds committed
180 181 182 183
/**
 *	do_identify	-	identify a drive
 *	@drive: drive to identify 
 *	@cmd: command used
184
 *	@id: buffer for IDENTIFY data
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188 189
 *
 *	Called when we have issued a drive identify command to
 *	read and parse the results. This function is run with
 *	interrupts disabled. 
 */
190

191
static void do_identify(ide_drive_t *drive, u8 cmd, u16 *id)
Linus Torvalds's avatar
Linus Torvalds committed
192
{
193
	ide_hwif_t *hwif = drive->hwif;
194
	char *m = (char *)&id[ATA_ID_PROD];
195
	unsigned long flags;
196
	int bswap = 1;
Linus Torvalds's avatar
Linus Torvalds committed
197

198 199
	/* local CPU only; some systems need this */
	local_irq_save(flags);
Linus Torvalds's avatar
Linus Torvalds committed
200
	/* read 512 bytes of id info */
201
	hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
202
	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
203

204
	drive->dev_flags |= IDE_DFLAG_ID_READ;
205 206 207 208
#ifdef DEBUG
	printk(KERN_INFO "%s: dumping identify data\n", drive->name);
	ide_dump_identify((u8 *)id);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
209 210 211
	ide_fix_driveid(id);

	/*
212 213
	 *  ATA_CMD_ID_ATA returns little-endian info,
	 *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
Linus Torvalds's avatar
Linus Torvalds committed
214
	 */
215
	if (cmd == ATA_CMD_ID_ATAPI) {
216 217 218
		if ((m[0] == 'N' && m[1] == 'E') ||  /* NEC */
		    (m[0] == 'F' && m[1] == 'X') ||  /* Mitsumi */
		    (m[0] == 'P' && m[1] == 'i'))    /* Pioneer */
Linus Torvalds's avatar
Linus Torvalds committed
219
			/* Vertos drives may still be weird */
220
			bswap ^= 1;
Linus Torvalds's avatar
Linus Torvalds committed
221
	}
222 223 224 225

	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);
Linus Torvalds's avatar
Linus Torvalds committed
226

227
	/* we depend on this a lot! */
228
	m[ATA_ID_PROD_LEN - 1] = '\0';
229

230
	if (strstr(m, "E X A B Y T E N E S T"))
231 232 233
		drive->dev_flags &= ~IDE_DFLAG_PRESENT;
	else
		drive->dev_flags |= IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
234 235 236
}

/**
237
 *	ide_dev_read_id	-	send ATA/ATAPI IDENTIFY command
Linus Torvalds's avatar
Linus Torvalds committed
238 239
 *	@drive: drive to identify
 *	@cmd: command to use
240
 *	@id: buffer for IDENTIFY data
241
 *	@irq_ctx: flag set when called from the IRQ context
Linus Torvalds's avatar
Linus Torvalds committed
242
 *
243
 *	Sends an ATA(PI) IDENTIFY request to a drive and waits for a response.
Linus Torvalds's avatar
Linus Torvalds committed
244 245 246 247 248 249
 *
 *	Returns:	0  device was identified
 *			1  device timed-out (no response to identify request)
 *			2  device aborted the command (refused to identify itself)
 */

250
int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id, int irq_ctx)
Linus Torvalds's avatar
Linus Torvalds committed
251
{
252
	ide_hwif_t *hwif = drive->hwif;
253
	struct ide_io_ports *io_ports = &hwif->io_ports;
254
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
255
	int use_altstatus = 0, rc;
Linus Torvalds's avatar
Linus Torvalds committed
256 257 258
	unsigned long timeout;
	u8 s = 0, a = 0;

259 260 261 262 263
	/*
	 * Disable device IRQ.  Otherwise we'll get spurious interrupts
	 * during the identify phase that the IRQ handler isn't expecting.
	 */
	if (io_ports->ctl_addr)
264
		tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
265

Linus Torvalds's avatar
Linus Torvalds committed
266
	/* take a deep breath */
267 268 269 270
	if (irq_ctx)
		mdelay(50);
	else
		msleep(50);
Linus Torvalds's avatar
Linus Torvalds committed
271

272 273
	if (io_ports->ctl_addr &&
	    (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) {
274 275
		a = tp_ops->read_altstatus(hwif);
		s = tp_ops->read_status(hwif);
276
		if ((a ^ s) & ~ATA_SENSE)
Linus Torvalds's avatar
Linus Torvalds committed
277
			/* ancient Seagate drives, broken interfaces */
278 279 280 281
			printk(KERN_INFO "%s: probing with STATUS(0x%02x) "
					 "instead of ALTSTATUS(0x%02x)\n",
					 drive->name, s, a);
		else
Linus Torvalds's avatar
Linus Torvalds committed
282
			/* use non-intrusive polling */
283 284
			use_altstatus = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
285 286 287 288

	/* set features register for atapi
	 * identify command to be sure of reply
	 */
289
	if (cmd == ATA_CMD_ID_ATAPI) {
290
		struct ide_taskfile tf;
291

292
		memset(&tf, 0, sizeof(tf));
293
		/* disable DMA & overlap */
294
		tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE);
295
	}
Linus Torvalds's avatar
Linus Torvalds committed
296 297

	/* ask drive for ID */
298
	tp_ops->exec_command(hwif, cmd);
Linus Torvalds's avatar
Linus Torvalds committed
299

300
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
301

302
	/* wait for IRQ and ATA_DRQ */
303 304 305 306 307 308 309 310 311 312 313 314
	if (irq_ctx) {
		rc = __ide_wait_stat(drive, ATA_DRQ, BAD_R_STAT, timeout, &s);
		if (rc)
			return 1;
	} else {
		rc = ide_busy_sleep(drive, timeout, use_altstatus);
		if (rc)
			return 1;

		msleep(50);
		s = tp_ops->read_status(hwif);
	}
315

316
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
Linus Torvalds's avatar
Linus Torvalds committed
317
		/* drive returned ID */
318
		do_identify(drive, cmd, id);
Linus Torvalds's avatar
Linus Torvalds committed
319 320 321
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
322
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
323 324 325 326 327 328 329
	} else {
		/* drive refused ID */
		rc = 2;
	}
	return rc;
}

330
int ide_busy_sleep(ide_drive_t *drive, unsigned long timeout, int altstatus)
331
{
332
	ide_hwif_t *hwif = drive->hwif;
333 334
	u8 stat;

335 336
	timeout += jiffies;

337
	do {
338 339 340
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
341
		if ((stat & ATA_BUSY) == 0)
342 343 344
			return 0;
	} while (time_before(jiffies, timeout));

345 346
	printk(KERN_ERR "%s: timeout in %s\n", drive->name, __func__);

347
	return 1;	/* drive timed-out */
348
}
Linus Torvalds's avatar
Linus Torvalds committed
349

350 351
static u8 ide_read_device(ide_drive_t *drive)
{
352
	struct ide_taskfile tf;
353

354
	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_DEVICE);
355

356
	return tf.device;
357 358
}

Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
/**
 *	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)
{
382
	ide_hwif_t *hwif = drive->hwif;
383
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
384
	u16 *id = drive->id;
385
	int rc;
386 387 388 389 390
	u8 present = !!(drive->dev_flags & IDE_DFLAG_PRESENT), stat;

	/* avoid waiting for inappropriate probes */
	if (present && drive->media != ide_disk && cmd == ATA_CMD_ID_ATA)
		return 4;
Linus Torvalds's avatar
Linus Torvalds committed
391 392

#ifdef DEBUG
393
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
394
		drive->name, present, drive->media,
395
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
396 397 398 399 400 401
#endif

	/* needed for some systems
	 * (e.g. crw9624 as drive0 with disk as slave)
	 */
	msleep(50);
402
	tp_ops->dev_select(drive);
Linus Torvalds's avatar
Linus Torvalds committed
403
	msleep(50);
404

405
	if (ide_read_device(drive) != drive->select && present == 0) {
406
		if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
407
			/* exit with drive0 selected */
408
			tp_ops->dev_select(hwif->devices[0]);
409
			/* allow ATA_BUSY to assert & clear */
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

416
	stat = tp_ops->read_status(hwif);
417

418
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
419
	    present || cmd == ATA_CMD_ID_ATAPI) {
420
		rc = ide_dev_read_id(drive, cmd, id, 0);
421
		if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
422
			/* failed: try again */
423
			rc = ide_dev_read_id(drive, cmd, id, 0);
424

425
		stat = tp_ops->read_status(hwif);
426

427
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
428 429
			return 4;

430
		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
431 432
			printk(KERN_ERR "%s: no response (status = 0x%02x), "
					"resetting drive\n", drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
433
			msleep(50);
434
			tp_ops->dev_select(drive);
Linus Torvalds's avatar
Linus Torvalds committed
435
			msleep(50);
436
			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
437
			(void)ide_busy_sleep(drive, WAIT_WORSTCASE, 0);
438
			rc = ide_dev_read_id(drive, cmd, id, 0);
Linus Torvalds's avatar
Linus Torvalds committed
439
		}
440 441

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

Linus Torvalds's avatar
Linus Torvalds committed
444
		if (rc == 1)
445 446
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449 450
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
451
	if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
452
		/* exit with drive0 selected */
453
		tp_ops->dev_select(hwif->devices[0]);
Linus Torvalds's avatar
Linus Torvalds committed
454 455
		msleep(50);
		/* ensure drive irq is clear */
456
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459 460 461 462 463 464 465 466 467 468
	}
	return rc;
}

/**
 *	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
469 470
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
471
 */
472 473

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
474
{
475
	char *m;
476 477
	int rc;
	u8 cmd;
478

479 480
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

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

Linus Torvalds's avatar
Linus Torvalds committed
484
	/* skip probing? */
485
	if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
486
		/* if !(success||timed-out) */
487 488 489
		cmd = ATA_CMD_ID_ATA;
		rc = do_probe(drive, cmd);
		if (rc >= 2) {
Linus Torvalds's avatar
Linus Torvalds committed
490
			/* look for ATAPI device */
491 492 493
			cmd = ATA_CMD_ID_ATAPI;
			rc = do_probe(drive, cmd);
		}
494

495
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
496
			return 0;
497

Linus Torvalds's avatar
Linus Torvalds committed
498
		/* identification failed? */
499
		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
500 501 502 503 504 505 506 507 508
			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);
509
				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
510
			}
511 512 513 514 515
		} else {
			if (cmd == ATA_CMD_ID_ATAPI)
				ide_classify_atapi_dev(drive);
			else
				ide_classify_ata_dev(drive);
Linus Torvalds's avatar
Linus Torvalds committed
516 517
		}
	}
518 519

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
520
		return 0;
521

Linus Torvalds's avatar
Linus Torvalds committed
522
	/* The drive wasn't being helpful. Add generic info only */
523
	if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
524 525 526 527 528 529 530 531 532
		generic_id(drive);
		return 1;
	}

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

533
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
534 535
}

536
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
537 538 539
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

540
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
541 542
}

543
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
544
{
545 546
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
547
	/* register with global device tree */
548
	dev_set_name(&hwif->gendev, "%s", hwif->name);
549
	dev_set_drvdata(&hwif->gendev, hwif);
550 551
	if (hwif->gendev.parent == NULL)
		hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
552
	hwif->gendev.release = hwif_release_dev;
553

554
	ret = device_register(&hwif->gendev);
555
	if (ret < 0) {
556
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
557
			__func__, ret);
558 559 560
		goto out;
	}

561
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
562
				      MKDEV(0, 0), hwif, "%s", hwif->name);
563 564 565 566 567 568
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
569 570
}

571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
/**
 *	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)
Linus Torvalds's avatar
Linus Torvalds committed
598
{
599
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
600 601
	ide_drive_t *drive;
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617

	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 */
618
	ide_port_for_each_dev(i, drive, hwif) {
619
		/* Ignore disks that we will not probe for later. */
620 621
		if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
		    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
622 623
			tp_ops->dev_select(drive);
			tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
624 625 626 627 628 629 630 631 632
			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:
Linus Torvalds's avatar
Linus Torvalds committed
633
	/* Exit function with master reselected (let's be sane) */
634
	if (i)
635
		tp_ops->dev_select(hwif->devices[0]);
636

Linus Torvalds's avatar
Linus Torvalds committed
637 638 639 640 641
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
642
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646 647 648
 *
 *	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.
 */

649
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
650
{
651
	ide_drive_t *dev0 = dev1->hwif->devices[0];
Linus Torvalds's avatar
Linus Torvalds committed
652

653
	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656
		return;

	/* If the models don't match they are not the same product */
657 658
	if (strcmp((char *)&dev0->id[ATA_ID_PROD],
		   (char *)&dev1->id[ATA_ID_PROD]))
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661
		return;

	/* Serial numbers do not match */
662 663
	if (strncmp((char *)&dev0->id[ATA_ID_SERNO],
		    (char *)&dev1->id[ATA_ID_SERNO], ATA_ID_SERNO_LEN))
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666
		return;

	/* No serial number, thankfully very rare for CF */
667
	if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
Linus Torvalds's avatar
Linus Torvalds committed
668 669 670 671 672
		return;

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

673
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
674 675 676 677
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

678
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
679
{
680
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
681
	unsigned int irqd;
682
	int i, rc = -ENODEV;
683 684

	BUG_ON(hwif->present);
Linus Torvalds's avatar
Linus Torvalds committed
685

686 687
	if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
	    (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
688
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
689 690 691 692 693 694 695 696 697

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

698 699
	if (ide_port_wait_ready(hwif) == -EBUSY)
		printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);
Linus Torvalds's avatar
Linus Torvalds committed
700 701

	/*
702 703
	 * Second drive should only exist if first drive was found,
	 * but a lot of cdrom drives are configured as single slaves.
Linus Torvalds's avatar
Linus Torvalds committed
704
	 */
705
	ide_port_for_each_dev(i, drive, hwif) {
Linus Torvalds's avatar
Linus Torvalds committed
706
		(void) probe_for_drive(drive);
707
		if (drive->dev_flags & IDE_DFLAG_PRESENT)
708
			rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
709
	}
710

Linus Torvalds's avatar
Linus Torvalds committed
711 712 713 714 715 716 717
	/*
	 * Use cached IRQ number. It might be (and is...) changed by probe
	 * code above
	 */
	if (irqd)
		enable_irq(irqd);

718
	return rc;
719 720 721 722
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
723
	const struct ide_port_ops *port_ops = hwif->port_ops;
724 725
	ide_drive_t *drive;
	int i;
726

727
	ide_port_for_each_present_dev(i, drive, hwif) {
728 729
		ide_check_nien_quirk_list(drive);

730 731
		if (port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
732
	}
733

734 735
	ide_port_for_each_present_dev(i, drive, hwif) {
		ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
736

737
		drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
738

739 740
		if (hwif->dma_ops)
			ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
741 742 743 744 745 746 747 748
	}
}

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
749
	struct request_queue *q;
750
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
751 752 753 754 755 756 757 758 759 760
	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.
	 */
761

762
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
763 764 765 766 767 768 769 770
	if (!q)
		return 1;

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

	if (hwif->rqsize < max_sectors)
		max_sectors = hwif->rqsize;
771
	blk_queue_max_hw_sectors(q, max_sectors);
Linus Torvalds's avatar
Linus Torvalds committed
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786

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

787
	blk_queue_max_segments(q, max_sg_entries);
Linus Torvalds's avatar
Linus Torvalds committed
788 789 790 791 792 793 794 795 796 797

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

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

	return 0;
}

798 799
static DEFINE_MUTEX(ide_cfg_mtx);

800 801 802 803
/*
 * For any present drive:
 * - allocate the block device queue
 */
804
static int ide_port_setup_devices(ide_hwif_t *hwif)
805
{
806
	ide_drive_t *drive;
807
	int i, j = 0;
808

809
	mutex_lock(&ide_cfg_mtx);
810
	ide_port_for_each_present_dev(i, drive, hwif) {
811 812 813
		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
814
			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
815 816 817
			continue;
		}

818
		j++;
819
	}
820
	mutex_unlock(&ide_cfg_mtx);
821 822

	return j;
823 824
}

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
static void ide_host_enable_irqs(struct ide_host *host)
{
	ide_hwif_t *hwif;
	int i;

	ide_host_for_each_port(i, hwif, host) {
		if (hwif == NULL)
			continue;

		/* clear any pending IRQs */
		hwif->tp_ops->read_status(hwif);

		/* unmask IRQs */
		if (hwif->io_ports.ctl_addr)
			hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
843
/*
844
 * This routine sets up the IRQ for an IDE interface.
Linus Torvalds's avatar
Linus Torvalds committed
845 846 847
 */
static int init_irq (ide_hwif_t *hwif)
{
848
	struct ide_io_ports *io_ports = &hwif->io_ports;
849 850 851
	struct ide_host *host = hwif->host;
	irq_handler_t irq_handler = host->irq_handler;
	int sa = host->irq_flags;
Linus Torvalds's avatar
Linus Torvalds committed
852

853 854 855
	if (irq_handler == NULL)
		irq_handler = ide_intr;

856 857 858
	if (!host->get_lock)
		if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
			goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
859

Adrian Bunk's avatar
Adrian Bunk committed
860
#if !defined(__mc68000__)
861
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
862 863
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
864
#else
865
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
866
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
867
#endif /* __mc68000__ */
868 869
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
		printk(KERN_CONT " (serialized)");
870
	printk(KERN_CONT "\n");
871

Linus Torvalds's avatar
Linus Torvalds committed
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
	return 0;
out_up:
	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;
887
	ide_drive_t *drive = hwif->devices[unit];
888 889

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
		return NULL;

	if (drive->media == ide_disk)
		request_module("ide-disk");
	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;
908
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
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 936 937 938
}

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;
939
	unsigned int unit = drive->dn & 1;
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942 943 944 945 946 947 948 949 950 951 952

	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);

static void drive_release_dev (struct device *dev)
{
	ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);

953 954
	ide_proc_unregister_device(drive);

955 956 957
	blk_cleanup_queue(drive->queue);
	drive->queue = NULL;

958
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
959

960
	complete(&drive->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
961 962 963 964 965
}

static int hwif_init(ide_hwif_t *hwif)
{
	if (!hwif->irq) {
966 967
		printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
968 969 970 971 972 973 974 975
	}

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

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

976
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
Linus Torvalds's avatar
Linus Torvalds committed
977 978 979 980 981
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}
982 983

	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
Linus Torvalds's avatar
Linus Torvalds committed
984 985
	
	if (init_irq(hwif)) {
986 987
		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
			hwif->name, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
988 989 990
		goto out;
	}

991 992
	blk_register_region(MKDEV(hwif->major, 0), MAX_DRIVES << PARTN_BITS,
			    THIS_MODULE, ata_probe, ata_lock, hwif);
Linus Torvalds's avatar
Linus Torvalds committed
993 994 995 996 997 998 999
	return 1;

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

1000 1001
static void hwif_register_devices(ide_hwif_t *hwif)
{
1002
	ide_drive_t *drive;
1003 1004
	unsigned int i;

1005
	ide_port_for_each_present_dev(i, drive, hwif) {
1006 1007
		struct device *dev = &drive->gendev;
		int ret;
1008

1009
		dev_set_name(dev, "%u.%u", hwif->index, i);
1010
		dev_set_drvdata(dev, drive);
1011 1012 1013 1014 1015 1016 1017 1018
		dev->parent = &hwif->gendev;
		dev->bus = &ide_bus_type;
		dev->release = drive_release_dev;

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

1022 1023
static void ide_port_init_devices(ide_hwif_t *hwif)
{
1024
	const struct ide_port_ops *port_ops = hwif->port_ops;
1025
	ide_drive_t *drive;
1026 1027
	int i;

1028
	ide_port_for_each_dev(i, drive, hwif) {
1029 1030
		drive->dn = i + hwif->channel * 2;

1031 1032
		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
			drive->io_32bit = 1;
1033 1034
		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
			drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
1035
		if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
1036
			drive->dev_flags |= IDE_DFLAG_UNMASK;
1037
		if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
1038
			drive->dev_flags |= IDE_DFLAG_NO_UNMASK;
1039

1040 1041
		drive->pio_mode = XFER_PIO_0;

1042 1043 1044
		if (port_ops && port_ops->init_dev)
			port_ops->init_dev(drive);
	}
1045 1046
}

1047 1048
static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
			  const struct ide_port_info *d)
1049
{
1050
	hwif->channel = port;
1051

1052
	hwif->chipset = d->chipset ? d->chipset : ide_pci;
1053 1054 1055 1056

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

1057 1058
	/* ->host_flags may be set by ->init_iops (or even earlier...) */
	hwif->host_flags |= d->host_flags;
1059 1060
	hwif->pio_mask = d->pio_mask;

1061 1062 1063
	if (d->tp_ops)
		hwif->tp_ops = d->tp_ops;

1064
	/* ->set_pio_mode for DTC2278 is currently limited to port 0 */
1065
	if ((hwif->host_flags & IDE_HFLAG_DTC2278) == 0 || hwif->channel == 0)
1066 1067
		hwif->port_ops = d->port_ops;

1068 1069 1070 1071
	hwif->swdma_mask = d->swdma_mask;
	hwif->mwdma_mask = d->mwdma_mask;
	hwif->ultra_mask = d->udma_mask;

1072 1073 1074
	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
		int rc;

1075 1076
		hwif->dma_ops = d->dma_ops;

1077 1078 1079 1080 1081 1082 1083
		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);
1084 1085

			hwif->dma_ops = NULL;
1086
			hwif->dma_base = 0;
1087 1088 1089
			hwif->swdma_mask = 0;
			hwif->mwdma_mask = 0;
			hwif->ultra_mask = 0;
1090
		}
1091
	}
1092

1093
	if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
1094 1095
	    ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base))
		hwif->host->host_flags |= IDE_HFLAG_SERIALIZE;
1096

1097 1098
	if (d->max_sectors)
		hwif->rqsize = d->max_sectors;
1099 1100 1101 1102 1103 1104 1105
	else {
		if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
		    (hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA))
			hwif->rqsize = 256;
		else
			hwif->rqsize = 65536;
	}
1106 1107 1108 1109

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

1112 1113
static void ide_port_cable_detect(ide_hwif_t *hwif)
{
1114 1115 1116
	const struct ide_port_ops *port_ops = hwif->port_ops;

	if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
1117
		if (hwif->cbl != ATA_CBL_PATA40_SHORT)
1118
			hwif->cbl = port_ops->cable_detect(hwif);
1119
	}
1120 1121
}

1122 1123 1124 1125 1126 1127
static const u8 ide_hwif_to_major[] =
	{ IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR, IDE4_MAJOR,
	  IDE5_MAJOR, IDE6_MAJOR, IDE7_MAJOR, IDE8_MAJOR, IDE9_MAJOR };

static void ide_port_init_devices_data(ide_hwif_t *hwif)
{
1128 1129
	ide_drive_t *drive;
	int i;
1130

1131 1132
	ide_port_for_each_dev(i, drive, hwif) {
		u8 j = (hwif->index * MAX_DRIVES) + i;
1133
		u16 *saved_id = drive->id;
1134 1135

		memset(drive, 0, sizeof(*drive));
1136 1137
		memset(saved_id, 0, SECTOR_SIZE);
		drive->id = saved_id;
1138 1139

		drive->media			= ide_disk;
1140
		drive->select			= (i << 4) | ATA_DEVICE_OBS;
1141 1142 1143
		drive->hwif			= hwif;
		drive->ready_stat		= ATA_DRDY;
		drive->bad_wstat		= BAD_W_STAT;
1144 1145
		drive->special_flags		= IDE_SFLAG_RECALIBRATE |
						  IDE_SFLAG_SET_GEOMETRY;
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
		drive->name[0]			= 'h';
		drive->name[1]			= 'd';
		drive->name[2]			= 'a' + j;
		drive->max_failures		= IDE_DEFAULT_MAX_FAILURES;

		INIT_LIST_HEAD(&drive->list);
		init_completion(&drive->gendev_rel_comp);
	}
}

static void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
{
	/* fill in any non-zero initial values */
	hwif->index	= index;
	hwif->major	= ide_hwif_to_major[index];

	hwif->name[0]	= 'i';
	hwif->name[1]	= 'd';
	hwif->name[2]	= 'e';
	hwif->name[3]	= '0' + index;

1167 1168 1169 1170 1171 1172
	spin_lock_init(&hwif->lock);

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

1173 1174 1175 1176 1177 1178 1179
	init_completion(&hwif->gendev_rel_comp);

	hwif->tp_ops = &default_tp_ops;

	ide_port_init_devices_data(hwif);
}

1180
static void ide_init_port_hw(ide_hwif_t *hwif, struct ide_hw *hw)
1181 1182 1183 1184 1185 1186 1187 1188
{
	memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
	hwif->irq = hw->irq;
	hwif->dev = hw->dev;
	hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
	hwif->config_data = hw->config;
}

1189 1190
static unsigned int ide_indexes;

1191
/**
1192
 *	ide_find_port_slot	-	find free port slot
1193 1194
 *	@d: IDE port info
 *
1195
 *	Return the new port slot index or -ENOENT if we are out of free slots.
1196 1197
 */

1198
static int ide_find_port_slot(const struct ide_port_info *d)
1199
{
1200
	int idx = -ENOENT;
1201
	u8 bootable = (d && (d->host_flags & IDE_HFLAG_NON_BOOTABLE)) ? 0 : 1;
1202
	u8 i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213

	/*
	 * 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).
	 */
1214
	mutex_lock(&ide_cfg_mtx);
1215 1216 1217
	if (bootable) {
		if ((ide_indexes | i) != (1 << MAX_HWIFS) - 1)
			idx = ffz(ide_indexes | i);
1218
	} else {
1219 1220 1221 1222
		if ((ide_indexes | 3) != (1 << MAX_HWIFS) - 1)
			idx = ffz(ide_indexes | 3);
		else if ((ide_indexes & 3) != 3)
			idx = ffz(ide_indexes);
1223
	}
1224 1225 1226
	if (idx >= 0)
		ide_indexes |= (1 << idx);
	mutex_unlock(&ide_cfg_mtx);
1227

1228 1229
	return idx;
}
1230

1231 1232 1233 1234 1235
static void ide_free_port_slot(int idx)
{
	mutex_lock(&ide_cfg_mtx);
	ide_indexes &= ~(1 << idx);
	mutex_unlock(&ide_cfg_mtx);
1236 1237
}

1238 1239
static void ide_port_free_devices(ide_hwif_t *hwif)
{
1240
	ide_drive_t *drive;
1241 1242
	int i;

1243 1244
	ide_port_for_each_dev(i, drive, hwif) {
		kfree(drive->id);
1245
		kfree(drive);
1246
	}
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
}

static int ide_port_alloc_devices(ide_hwif_t *hwif, int node)
{
	int i;

	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive;

		drive = kzalloc_node(sizeof(*drive), GFP_KERNEL, node);
		if (drive == NULL)
			goto out_nomem;

1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
		/*
		 * 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"
		 */
		drive->id = kzalloc_node(SECTOR_SIZE, GFP_KERNEL, node);
		if (drive->id == NULL)
			goto out_nomem;

1272 1273 1274 1275 1276 1277 1278 1279 1280
		hwif->devices[i] = drive;
	}
	return 0;

out_nomem:
	ide_port_free_devices(hwif);
	return -ENOMEM;
}

1281 1282
struct ide_host *ide_host_alloc(const struct ide_port_info *d,
				struct ide_hw **hws, unsigned int n_ports)
1283 1284
{
	struct ide_host *host;
1285 1286
	struct device *dev = hws[0] ? hws[0]->dev : NULL;
	int node = dev ? dev_to_node(dev) : -1;
1287 1288
	int i;

1289
	host = kzalloc_node(sizeof(*host), GFP_KERNEL, node);
1290 1291 1292
	if (host == NULL)
		return NULL;

1293
	for (i = 0; i < n_ports; i++) {
1294
		ide_hwif_t *hwif;
1295
		int idx;
1296 1297 1298 1299

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

1300
		hwif = kzalloc_node(sizeof(*hwif), GFP_KERNEL, node);
1301 1302 1303
		if (hwif == NULL)
			continue;

1304 1305 1306 1307 1308
		if (ide_port_alloc_devices(hwif, node) < 0) {
			kfree(hwif);
			continue;
		}

1309 1310 1311 1312
		idx = ide_find_port_slot(d);
		if (idx < 0) {
			printk(KERN_ERR "%s: no free slot for interface\n",
					d ? d->name : "ide");
1313
			ide_port_free_devices(hwif);
1314
			kfree(hwif);
1315
			continue;
1316
		}
1317 1318 1319

		ide_init_port_data(hwif, idx);

1320 1321
		hwif->host = host;