ide-probe.c 37 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
Linus Torvalds's avatar
Linus Torvalds committed
241
 *
242
 *	Sends an ATA(PI) IDENTIFY request to a drive and waits for a response.
Linus Torvalds's avatar
Linus Torvalds committed
243 244 245 246 247 248
 *
 *	Returns:	0  device was identified
 *			1  device timed-out (no response to identify request)
 *			2  device aborted the command (refused to identify itself)
 */

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

258 259 260 261 262
	/*
	 * 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)
263
		tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
264

Linus Torvalds's avatar
Linus Torvalds committed
265 266 267
	/* take a deep breath */
	msleep(50);

268 269
	if (io_ports->ctl_addr &&
	    (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) {
270 271
		a = tp_ops->read_altstatus(hwif);
		s = tp_ops->read_status(hwif);
272
		if ((a ^ s) & ~ATA_IDX)
Linus Torvalds's avatar
Linus Torvalds committed
273
			/* ancient Seagate drives, broken interfaces */
274 275 276 277
			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
278
			/* use non-intrusive polling */
279 280
			use_altstatus = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
281 282 283 284

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

288
		memset(&tf, 0, sizeof(tf));
289
		/* disable DMA & overlap */
290
		tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE);
291
	}
Linus Torvalds's avatar
Linus Torvalds committed
292 293

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

296
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
297 298 299

	if (ide_busy_sleep(hwif, timeout, use_altstatus))
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
300

301
	/* wait for IRQ and ATA_DRQ */
Linus Torvalds's avatar
Linus Torvalds committed
302
	msleep(50);
303
	s = tp_ops->read_status(hwif);
304

305
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
Linus Torvalds's avatar
Linus Torvalds committed
306
		/* drive returned ID */
307
		do_identify(drive, cmd, id);
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
311
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317 318
	} else {
		/* drive refused ID */
		rc = 2;
	}
	return rc;
}

319
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
320 321 322
{
	u8 stat;

323 324
	timeout += jiffies;

325
	do {
326 327 328
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
329
		if ((stat & ATA_BUSY) == 0)
330 331 332
			return 0;
	} while (time_before(jiffies, timeout));

333
	return 1;	/* drive timed-out */
334
}
Linus Torvalds's avatar
Linus Torvalds committed
335

336 337
static u8 ide_read_device(ide_drive_t *drive)
{
338
	struct ide_taskfile tf;
339

340
	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_DEVICE);
341

342
	return tf.device;
343 344
}

Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
/**
 *	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)
{
368
	ide_hwif_t *hwif = drive->hwif;
369
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
370
	u16 *id = drive->id;
371
	int rc;
372 373 374 375 376
	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
377 378

#ifdef DEBUG
379
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
380
		drive->name, present, drive->media,
381
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
382 383 384 385 386 387
#endif

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

391
	if (ide_read_device(drive) != drive->select && present == 0) {
392
		if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
393
			/* exit with drive0 selected */
394
			tp_ops->dev_select(hwif->devices[0]);
395
			/* allow ATA_BUSY to assert & clear */
Linus Torvalds's avatar
Linus Torvalds committed
396 397 398 399 400 401
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

402
	stat = tp_ops->read_status(hwif);
403

404
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
405
	    present || cmd == ATA_CMD_ID_ATAPI) {
406 407
		rc = ide_dev_read_id(drive, cmd, id);
		if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
408
			/* failed: try again */
409
			rc = ide_dev_read_id(drive, cmd, id);
410

411
		stat = tp_ops->read_status(hwif);
412

413
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
414 415
			return 4;

416
		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
417 418
			printk(KERN_ERR "%s: no response (status = 0x%02x), "
					"resetting drive\n", drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
419
			msleep(50);
420
			tp_ops->dev_select(drive);
Linus Torvalds's avatar
Linus Torvalds committed
421
			msleep(50);
422
			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
423
			(void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
424
			rc = ide_dev_read_id(drive, cmd, id);
Linus Torvalds's avatar
Linus Torvalds committed
425
		}
426 427

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

Linus Torvalds's avatar
Linus Torvalds committed
430
		if (rc == 1)
431 432
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
437
	if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
438
		/* exit with drive0 selected */
439
		tp_ops->dev_select(hwif->devices[0]);
Linus Torvalds's avatar
Linus Torvalds committed
440 441
		msleep(50);
		/* ensure drive irq is clear */
442
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445 446 447 448 449 450 451 452 453 454
	}
	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
455 456
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
457
 */
458 459

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
460
{
461
	char *m;
462 463
	int rc;
	u8 cmd;
464

Linus Torvalds's avatar
Linus Torvalds committed
465 466 467 468 469 470 471 472 473
	/*
	 *	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"
	 */
 
474 475
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

476
	drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
477
	if (drive->id == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
481 482 483 484

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

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

496
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
497
			goto out_free;
498

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

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
521
		goto out_free;
522

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

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

534 535 536 537
	return 1;
out_free:
	kfree(drive->id);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
538 539
}

540
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
541 542 543
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

544
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
545 546
}

547
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
548
{
549 550
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
551
	/* register with global device tree */
552
	dev_set_name(&hwif->gendev, hwif->name);
Linus Torvalds's avatar
Linus Torvalds committed
553
	hwif->gendev.driver_data = hwif;
554 555
	if (hwif->gendev.parent == NULL)
		hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
556
	hwif->gendev.release = hwif_release_dev;
557

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

565 566
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
				      MKDEV(0, 0), hwif, hwif->name);
567 568 569 570 571 572
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
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 598 599 600 601
/**
 *	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
602
{
603
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
604 605
	ide_drive_t *drive;
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621

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

Linus Torvalds's avatar
Linus Torvalds committed
641 642 643 644 645
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
646
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
647 648 649 650 651 652
 *
 *	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.
 */

653
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
654
{
655
	ide_drive_t *dev0 = dev1->hwif->devices[0];
Linus Torvalds's avatar
Linus Torvalds committed
656

657
	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
658 659 660
		return;

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

	/* Serial numbers do not match */
666 667
	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
668 669 670
		return;

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

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

677
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
678 679 680 681
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

682
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
683
{
684
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
685
	unsigned int irqd;
686
	int i, rc = -ENODEV;
687 688

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

690 691
	if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
	    (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
692
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696 697 698 699 700 701

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

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

	/*
706 707
	 * 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
708
	 */
709
	ide_port_for_each_dev(i, drive, hwif) {
Linus Torvalds's avatar
Linus Torvalds committed
710
		(void) probe_for_drive(drive);
711
		if (drive->dev_flags & IDE_DFLAG_PRESENT)
712
			rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
713
	}
714

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

722
	return rc;
723 724 725 726
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
727
	const struct ide_port_ops *port_ops = hwif->port_ops;
728 729
	ide_drive_t *drive;
	int i;
730

731 732 733
	ide_port_for_each_present_dev(i, drive, hwif) {
		if (port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
734
	}
735

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

739
		drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
740

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

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

764
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
	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;
}

801 802
static DEFINE_MUTEX(ide_cfg_mtx);

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

812
	mutex_lock(&ide_cfg_mtx);
813
	ide_port_for_each_present_dev(i, drive, hwif) {
814 815 816
		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
817 818 819
			kfree(drive->id);
			drive->id = NULL;
			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
820 821 822
			continue;
		}

823
		j++;
824
	}
825
	mutex_unlock(&ide_cfg_mtx);
826 827

	return j;
828 829
}

Linus Torvalds's avatar
Linus Torvalds committed
830
/*
831
 * This routine sets up the IRQ for an IDE interface.
Linus Torvalds's avatar
Linus Torvalds committed
832 833 834
 */
static int init_irq (ide_hwif_t *hwif)
{
835
	struct ide_io_ports *io_ports = &hwif->io_ports;
836 837 838
	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
839

840 841 842
	if (irq_handler == NULL)
		irq_handler = ide_intr;

843
	if (io_ports->ctl_addr)
844
		hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
Linus Torvalds's avatar
Linus Torvalds committed
845

846
	if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
847
		goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
848

Adrian Bunk's avatar
Adrian Bunk committed
849
#if !defined(__mc68000__)
850
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
851 852
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
853
#else
854
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
855
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
856
#endif /* __mc68000__ */
857 858
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
		printk(KERN_CONT " (serialized)");
859
	printk(KERN_CONT "\n");
860

Linus Torvalds's avatar
Linus Torvalds committed
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
	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;
876
	ide_drive_t *drive = hwif->devices[unit];
877 878

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
		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;
897
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
898 899 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
}

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;
928
	unsigned int unit = drive->dn & 1;
Linus Torvalds's avatar
Linus Torvalds committed
929 930 931 932 933 934 935 936 937 938 939 940 941

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

942 943
	ide_proc_unregister_device(drive);

944 945 946
	blk_cleanup_queue(drive->queue);
	drive->queue = NULL;

947 948
	kfree(drive->id);
	drive->id = NULL;
949

950
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
951

952
	complete(&drive->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
953 954 955 956 957
}

static int hwif_init(ide_hwif_t *hwif)
{
	if (!hwif->irq) {
958 959
		printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
960 961 962 963 964 965 966 967
	}

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

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

968
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
Linus Torvalds's avatar
Linus Torvalds committed
969 970 971 972 973
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}
974 975

	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
Linus Torvalds's avatar
Linus Torvalds committed
976 977
	
	if (init_irq(hwif)) {
978 979
		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
			hwif->name, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
980 981 982
		goto out;
	}

983 984
	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
985 986 987 988 989 990 991
	return 1;

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

992 993
static void hwif_register_devices(ide_hwif_t *hwif)
{
994
	ide_drive_t *drive;
995 996
	unsigned int i;

997
	ide_port_for_each_present_dev(i, drive, hwif) {
998 999
		struct device *dev = &drive->gendev;
		int ret;
1000

1001
		dev_set_name(dev, "%u.%u", hwif->index, i);
1002 1003 1004 1005 1006 1007 1008 1009 1010
		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);
1011 1012 1013
	}
}

1014 1015
static void ide_port_init_devices(ide_hwif_t *hwif)
{
1016
	const struct ide_port_ops *port_ops = hwif->port_ops;
1017
	ide_drive_t *drive;
1018 1019
	int i;

1020
	ide_port_for_each_dev(i, drive, hwif) {
1021 1022
		drive->dn = i + hwif->channel * 2;

1023 1024
		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
			drive->io_32bit = 1;
1025 1026
		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
			drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
1027
		if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
1028
			drive->dev_flags |= IDE_DFLAG_UNMASK;
1029
		if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
1030
			drive->dev_flags |= IDE_DFLAG_NO_UNMASK;
1031

1032 1033 1034
		if (port_ops && port_ops->init_dev)
			port_ops->init_dev(drive);
	}
1035 1036 1037 1038 1039 1040 1041 1042 1043

	ide_port_for_each_dev(i, drive, hwif) {
		/*
		 * default to PIO Mode 0 before we figure out
		 * the most suited mode for the attached device
		 */
		if (port_ops && port_ops->set_pio_mode)
			port_ops->set_pio_mode(drive, 0);
	}
1044 1045
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1121 1122 1123 1124 1125 1126
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)
{
1127 1128
	ide_drive_t *drive;
	int i;
1129

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

		memset(drive, 0, sizeof(*drive));

		drive->media			= ide_disk;
1136
		drive->select			= (i << 4) | ATA_DEVICE_OBS;
1137 1138 1139
		drive->hwif			= hwif;
		drive->ready_stat		= ATA_DRDY;
		drive->bad_wstat		= BAD_W_STAT;
1140 1141
		drive->special_flags		= IDE_SFLAG_RECALIBRATE |
						  IDE_SFLAG_SET_GEOMETRY;
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
		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;

1163 1164 1165 1166 1167 1168
	spin_lock_init(&hwif->lock);

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

1169 1170 1171 1172 1173 1174 1175
	init_completion(&hwif->gendev_rel_comp);

	hwif->tp_ops = &default_tp_ops;

	ide_port_init_devices_data(hwif);
}

1176
static void ide_init_port_hw(ide_hwif_t *hwif, struct ide_hw *hw)
1177 1178 1179 1180 1181 1182 1183 1184 1185
{
	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->ack_intr = hw->ack_intr;
	hwif->config_data = hw->config;
}

1186 1187
static unsigned int ide_indexes;

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

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

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

1225 1226
	return idx;
}
1227

1228 1229 1230 1231 1232
static void ide_free_port_slot(int idx)
{
	mutex_lock(&ide_cfg_mtx);
	ide_indexes &= ~(1 << idx);
	mutex_unlock(&ide_cfg_mtx);
1233 1234
}

1235 1236
static void ide_port_free_devices(ide_hwif_t *hwif)
{
1237
	ide_drive_t *drive;
1238 1239
	int i;

1240 1241
	ide_port_for_each_dev(i, drive, hwif)
		kfree(drive);
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
}

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;

		hwif->devices[i] = drive;
	}
	return 0;

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

1264 1265
struct ide_host *ide_host_alloc(const struct ide_port_info *d,
				struct ide_hw **hws, unsigned int n_ports)
1266 1267
{
	struct ide_host *host;
1268 1269
	struct device *dev = hws[0] ? hws[0]->dev : NULL;
	int node = dev ? dev_to_node(dev) : -1;
1270 1271
	int i;

1272
	host = kzalloc_node(sizeof(*host), GFP_KERNEL, node);
1273 1274 1275
	if (host == NULL)
		return NULL;

1276
	for (i = 0; i < n_ports; i++) {
1277
		ide_hwif_t *hwif;
1278
		int idx;
1279 1280 1281 1282

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

1283
		hwif = kzalloc_node(sizeof(*hwif), GFP_KERNEL, node);
1284 1285 1286
		if (hwif == NULL)
			continue;

1287 1288 1289 1290 1291
		if (ide_port_alloc_devices(hwif, node) < 0) {
			kfree(hwif);
			continue;
		}

1292 1293 1294 1295
		idx = ide_find_port_slot(d);
		if (idx < 0) {
			printk(KERN_ERR "%s: no free slot for interface\n",
					d ? d->name : "ide");
1296
			kfree(hwif);
1297
			continue;
1298
		}
1299 1300 1301

		ide_init_port_data(hwif, idx);

1302 1303
		hwif->host = host;

1304 1305
		host->ports[i] = hwif;
		host->n_ports++;
1306 1307 1308 1309 1310 1311 1312
	}

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

1313
	host->dev[0] = dev;
1314

1315 1316
	if (d) {
		host->init_chipset = d->init_chipset;
1317 1318
		host->get_lock     = d->get_lock;
		host->release_lock = d->release_lock;
1319
		host->host_flags = d->host_flags;
1320
		host->irq_flags = d->irq_flags;
1321
	}
1322

1323 1324 1325 1326
	return host;
}
EXPORT_SYMBOL_GPL(ide_host_alloc);