PageRenderTime 96ms CodeModel.GetById 12ms app.highlight 72ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/ide/ide-probe.c

http://github.com/mirrors/linux
C | 1680 lines | 1109 code | 304 blank | 267 comment | 256 complexity | a4b42a7893cb58e952b47521d354a4ff MD5 | raw file
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *  Copyright (C) 1994-1998   Linus Torvalds & authors (see below)
   4 *  Copyright (C) 2005, 2007  Bartlomiej Zolnierkiewicz
   5 */
   6
   7/*
   8 *  Mostly written by Mark Lord <mlord@pobox.com>
   9 *                and Gadi Oxman <gadio@netvision.net.il>
  10 *                and Andre Hedrick <andre@linux-ide.org>
  11 *
  12 *  See linux/MAINTAINERS for address of current maintainer.
  13 *
  14 * 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
  17 *	 by Andrea Arcangeli
  18 */
  19
  20#include <linux/module.h>
  21#include <linux/types.h>
  22#include <linux/string.h>
  23#include <linux/kernel.h>
  24#include <linux/timer.h>
  25#include <linux/mm.h>
  26#include <linux/interrupt.h>
  27#include <linux/major.h>
  28#include <linux/errno.h>
  29#include <linux/genhd.h>
  30#include <linux/slab.h>
  31#include <linux/delay.h>
  32#include <linux/ide.h>
  33#include <linux/spinlock.h>
  34#include <linux/kmod.h>
  35#include <linux/pci.h>
  36#include <linux/scatterlist.h>
  37
  38#include <asm/byteorder.h>
  39#include <asm/irq.h>
  40#include <linux/uaccess.h>
  41#include <asm/io.h>
  42
  43/**
  44 *	generic_id		-	add a generic drive id
  45 *	@drive:	drive to make an ID block for
  46 *	
  47 *	Add a fake id field to the drive we are passed. This allows
  48 *	use to skip a ton of NULL checks (which people always miss) 
  49 *	and make drive properties unconditional outside of this file
  50 */
  51 
  52static void generic_id(ide_drive_t *drive)
  53{
  54	u16 *id = drive->id;
  55
  56	id[ATA_ID_CUR_CYLS]	= id[ATA_ID_CYLS]	= drive->cyl;
  57	id[ATA_ID_CUR_HEADS]	= id[ATA_ID_HEADS]	= drive->head;
  58	id[ATA_ID_CUR_SECTORS]	= id[ATA_ID_SECTORS]	= drive->sect;
  59}
  60
  61static void ide_disk_init_chs(ide_drive_t *drive)
  62{
  63	u16 *id = drive->id;
  64
  65	/* Extract geometry if we did not already have one for the drive */
  66	if (!drive->cyl || !drive->head || !drive->sect) {
  67		drive->cyl  = drive->bios_cyl  = id[ATA_ID_CYLS];
  68		drive->head = drive->bios_head = id[ATA_ID_HEADS];
  69		drive->sect = drive->bios_sect = id[ATA_ID_SECTORS];
  70	}
  71
  72	/* Handle logical geometry translation by the drive */
  73	if (ata_id_current_chs_valid(id)) {
  74		drive->cyl  = id[ATA_ID_CUR_CYLS];
  75		drive->head = id[ATA_ID_CUR_HEADS];
  76		drive->sect = id[ATA_ID_CUR_SECTORS];
  77	}
  78
  79	/* Use physical geometry if what we have still makes no sense */
  80	if (drive->head > 16 && id[ATA_ID_HEADS] && id[ATA_ID_HEADS] <= 16) {
  81		drive->cyl  = id[ATA_ID_CYLS];
  82		drive->head = id[ATA_ID_HEADS];
  83		drive->sect = id[ATA_ID_SECTORS];
  84	}
  85}
  86
  87static void ide_disk_init_mult_count(ide_drive_t *drive)
  88{
  89	u16 *id = drive->id;
  90	u8 max_multsect = id[ATA_ID_MAX_MULTSECT] & 0xff;
  91
  92	if (max_multsect) {
  93		if ((max_multsect / 2) > 1)
  94			id[ATA_ID_MULTSECT] = max_multsect | 0x100;
  95		else
  96			id[ATA_ID_MULTSECT] &= ~0x1ff;
  97
  98		drive->mult_req = id[ATA_ID_MULTSECT] & 0xff;
  99
 100		if (drive->mult_req)
 101			drive->special_flags |= IDE_SFLAG_SET_MULTMODE;
 102	}
 103}
 104
 105static void ide_classify_ata_dev(ide_drive_t *drive)
 106{
 107	u16 *id = drive->id;
 108	char *m = (char *)&id[ATA_ID_PROD];
 109	int is_cfa = ata_id_is_cfa(id);
 110
 111	/* CF devices are *not* removable in Linux definition of the term */
 112	if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
 113		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
 114
 115	drive->media = ide_disk;
 116
 117	if (!ata_id_has_unload(drive->id))
 118		drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
 119
 120	printk(KERN_INFO "%s: %s, %s DISK drive\n", drive->name, m,
 121		is_cfa ? "CFA" : "ATA");
 122}
 123
 124static void ide_classify_atapi_dev(ide_drive_t *drive)
 125{
 126	u16 *id = drive->id;
 127	char *m = (char *)&id[ATA_ID_PROD];
 128	u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
 129
 130	printk(KERN_INFO "%s: %s, ATAPI ", drive->name, m);
 131	switch (type) {
 132	case ide_floppy:
 133		if (!strstr(m, "CD-ROM")) {
 134			if (!strstr(m, "oppy") &&
 135			    !strstr(m, "poyp") &&
 136			    !strstr(m, "ZIP"))
 137				printk(KERN_CONT "cdrom or floppy?, assuming ");
 138			if (drive->media != ide_cdrom) {
 139				printk(KERN_CONT "FLOPPY");
 140				drive->dev_flags |= IDE_DFLAG_REMOVABLE;
 141				break;
 142			}
 143		}
 144		/* Early cdrom models used zero */
 145		type = ide_cdrom;
 146		/* fall through */
 147	case ide_cdrom:
 148		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
 149#ifdef CONFIG_PPC
 150		/* kludge for Apple PowerBook internal zip */
 151		if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
 152			printk(KERN_CONT "FLOPPY");
 153			type = ide_floppy;
 154			break;
 155		}
 156#endif
 157		printk(KERN_CONT "CD/DVD-ROM");
 158		break;
 159	case ide_tape:
 160		printk(KERN_CONT "TAPE");
 161		break;
 162	case ide_optical:
 163		printk(KERN_CONT "OPTICAL");
 164		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
 165		break;
 166	default:
 167		printk(KERN_CONT "UNKNOWN (type %d)", type);
 168		break;
 169	}
 170
 171	printk(KERN_CONT " drive\n");
 172	drive->media = type;
 173	/* an ATAPI device ignores DRDY */
 174	drive->ready_stat = 0;
 175	if (ata_id_cdb_intr(id))
 176		drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
 177	drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
 178	/* we don't do head unloading on ATAPI devices */
 179	drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
 180}
 181
 182/**
 183 *	do_identify	-	identify a drive
 184 *	@drive: drive to identify 
 185 *	@cmd: command used
 186 *	@id: buffer for IDENTIFY data
 187 *
 188 *	Called when we have issued a drive identify command to
 189 *	read and parse the results. This function is run with
 190 *	interrupts disabled. 
 191 */
 192
 193static void do_identify(ide_drive_t *drive, u8 cmd, u16 *id)
 194{
 195	ide_hwif_t *hwif = drive->hwif;
 196	char *m = (char *)&id[ATA_ID_PROD];
 197	unsigned long flags;
 198	int bswap = 1;
 199
 200	/* local CPU only; some systems need this */
 201	local_irq_save(flags);
 202	/* read 512 bytes of id info */
 203	hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
 204	local_irq_restore(flags);
 205
 206	drive->dev_flags |= IDE_DFLAG_ID_READ;
 207#ifdef DEBUG
 208	printk(KERN_INFO "%s: dumping identify data\n", drive->name);
 209	ide_dump_identify((u8 *)id);
 210#endif
 211	ide_fix_driveid(id);
 212
 213	/*
 214	 *  ATA_CMD_ID_ATA returns little-endian info,
 215	 *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
 216	 */
 217	if (cmd == ATA_CMD_ID_ATAPI) {
 218		if ((m[0] == 'N' && m[1] == 'E') ||  /* NEC */
 219		    (m[0] == 'F' && m[1] == 'X') ||  /* Mitsumi */
 220		    (m[0] == 'P' && m[1] == 'i'))    /* Pioneer */
 221			/* Vertos drives may still be weird */
 222			bswap ^= 1;
 223	}
 224
 225	ide_fixstring(m, ATA_ID_PROD_LEN, bswap);
 226	ide_fixstring((char *)&id[ATA_ID_FW_REV], ATA_ID_FW_REV_LEN, bswap);
 227	ide_fixstring((char *)&id[ATA_ID_SERNO], ATA_ID_SERNO_LEN, bswap);
 228
 229	/* we depend on this a lot! */
 230	m[ATA_ID_PROD_LEN - 1] = '\0';
 231
 232	if (strstr(m, "E X A B Y T E N E S T"))
 233		drive->dev_flags &= ~IDE_DFLAG_PRESENT;
 234	else
 235		drive->dev_flags |= IDE_DFLAG_PRESENT;
 236}
 237
 238/**
 239 *	ide_dev_read_id	-	send ATA/ATAPI IDENTIFY command
 240 *	@drive: drive to identify
 241 *	@cmd: command to use
 242 *	@id: buffer for IDENTIFY data
 243 *	@irq_ctx: flag set when called from the IRQ context
 244 *
 245 *	Sends an ATA(PI) IDENTIFY request to a drive and waits for a response.
 246 *
 247 *	Returns:	0  device was identified
 248 *			1  device timed-out (no response to identify request)
 249 *			2  device aborted the command (refused to identify itself)
 250 */
 251
 252int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id, int irq_ctx)
 253{
 254	ide_hwif_t *hwif = drive->hwif;
 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;
 258	unsigned long timeout;
 259	u8 s = 0, a = 0;
 260
 261	/*
 262	 * Disable device IRQ.  Otherwise we'll get spurious interrupts
 263	 * during the identify phase that the IRQ handler isn't expecting.
 264	 */
 265	if (io_ports->ctl_addr)
 266		tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
 267
 268	/* take a deep breath */
 269	if (irq_ctx)
 270		mdelay(50);
 271	else
 272		msleep(50);
 273
 274	if (io_ports->ctl_addr &&
 275	    (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) {
 276		a = tp_ops->read_altstatus(hwif);
 277		s = tp_ops->read_status(hwif);
 278		if ((a ^ s) & ~ATA_SENSE)
 279			/* ancient Seagate drives, broken interfaces */
 280			printk(KERN_INFO "%s: probing with STATUS(0x%02x) "
 281					 "instead of ALTSTATUS(0x%02x)\n",
 282					 drive->name, s, a);
 283		else
 284			/* use non-intrusive polling */
 285			use_altstatus = 1;
 286	}
 287
 288	/* set features register for atapi
 289	 * identify command to be sure of reply
 290	 */
 291	if (cmd == ATA_CMD_ID_ATAPI) {
 292		struct ide_taskfile tf;
 293
 294		memset(&tf, 0, sizeof(tf));
 295		/* disable DMA & overlap */
 296		tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE);
 297	}
 298
 299	/* ask drive for ID */
 300	tp_ops->exec_command(hwif, cmd);
 301
 302	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
 303
 304	/* wait for IRQ and ATA_DRQ */
 305	if (irq_ctx) {
 306		rc = __ide_wait_stat(drive, ATA_DRQ, BAD_R_STAT, timeout, &s);
 307		if (rc)
 308			return 1;
 309	} else {
 310		rc = ide_busy_sleep(drive, timeout, use_altstatus);
 311		if (rc)
 312			return 1;
 313
 314		msleep(50);
 315		s = tp_ops->read_status(hwif);
 316	}
 317
 318	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
 319		/* drive returned ID */
 320		do_identify(drive, cmd, id);
 321		/* drive responded with ID */
 322		rc = 0;
 323		/* clear drive IRQ */
 324		(void)tp_ops->read_status(hwif);
 325	} else {
 326		/* drive refused ID */
 327		rc = 2;
 328	}
 329	return rc;
 330}
 331
 332int ide_busy_sleep(ide_drive_t *drive, unsigned long timeout, int altstatus)
 333{
 334	ide_hwif_t *hwif = drive->hwif;
 335	u8 stat;
 336
 337	timeout += jiffies;
 338
 339	do {
 340		msleep(50);	/* give drive a breather */
 341		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
 342				 : hwif->tp_ops->read_status(hwif);
 343		if ((stat & ATA_BUSY) == 0)
 344			return 0;
 345	} while (time_before(jiffies, timeout));
 346
 347	printk(KERN_ERR "%s: timeout in %s\n", drive->name, __func__);
 348
 349	return 1;	/* drive timed-out */
 350}
 351
 352static u8 ide_read_device(ide_drive_t *drive)
 353{
 354	struct ide_taskfile tf;
 355
 356	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_DEVICE);
 357
 358	return tf.device;
 359}
 360
 361/**
 362 *	do_probe		-	probe an IDE device
 363 *	@drive: drive to probe
 364 *	@cmd: command to use
 365 *
 366 *	do_probe() has the difficult job of finding a drive if it exists,
 367 *	without getting hung up if it doesn't exist, without trampling on
 368 *	ethernet cards, and without leaving any IRQs dangling to haunt us later.
 369 *
 370 *	If a drive is "known" to exist (from CMOS or kernel parameters),
 371 *	but does not respond right away, the probe will "hang in there"
 372 *	for the maximum wait time (about 30 seconds), otherwise it will
 373 *	exit much more quickly.
 374 *
 375 * Returns:	0  device was identified
 376 *		1  device timed-out (no response to identify request)
 377 *		2  device aborted the command (refused to identify itself)
 378 *		3  bad status from device (possible for ATAPI drives)
 379 *		4  probe was not attempted because failure was obvious
 380 */
 381
 382static int do_probe (ide_drive_t *drive, u8 cmd)
 383{
 384	ide_hwif_t *hwif = drive->hwif;
 385	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
 386	u16 *id = drive->id;
 387	int rc;
 388	u8 present = !!(drive->dev_flags & IDE_DFLAG_PRESENT), stat;
 389
 390	/* avoid waiting for inappropriate probes */
 391	if (present && drive->media != ide_disk && cmd == ATA_CMD_ID_ATA)
 392		return 4;
 393
 394#ifdef DEBUG
 395	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
 396		drive->name, present, drive->media,
 397		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
 398#endif
 399
 400	/* needed for some systems
 401	 * (e.g. crw9624 as drive0 with disk as slave)
 402	 */
 403	msleep(50);
 404	tp_ops->dev_select(drive);
 405	msleep(50);
 406
 407	if (ide_read_device(drive) != drive->select && present == 0) {
 408		if (drive->dn & 1) {
 409			/* exit with drive0 selected */
 410			tp_ops->dev_select(hwif->devices[0]);
 411			/* allow ATA_BUSY to assert & clear */
 412			msleep(50);
 413		}
 414		/* no i/f present: mmm.. this should be a 4 -ml */
 415		return 3;
 416	}
 417
 418	stat = tp_ops->read_status(hwif);
 419
 420	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
 421	    present || cmd == ATA_CMD_ID_ATAPI) {
 422		rc = ide_dev_read_id(drive, cmd, id, 0);
 423		if (rc)
 424			/* failed: try again */
 425			rc = ide_dev_read_id(drive, cmd, id, 0);
 426
 427		stat = tp_ops->read_status(hwif);
 428
 429		if (stat == (ATA_BUSY | ATA_DRDY))
 430			return 4;
 431
 432		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
 433			printk(KERN_ERR "%s: no response (status = 0x%02x), "
 434					"resetting drive\n", drive->name, stat);
 435			msleep(50);
 436			tp_ops->dev_select(drive);
 437			msleep(50);
 438			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
 439			(void)ide_busy_sleep(drive, WAIT_WORSTCASE, 0);
 440			rc = ide_dev_read_id(drive, cmd, id, 0);
 441		}
 442
 443		/* ensure drive IRQ is clear */
 444		stat = tp_ops->read_status(hwif);
 445
 446		if (rc == 1)
 447			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
 448					drive->name, stat);
 449	} else {
 450		/* not present or maybe ATAPI */
 451		rc = 3;
 452	}
 453	if (drive->dn & 1) {
 454		/* exit with drive0 selected */
 455		tp_ops->dev_select(hwif->devices[0]);
 456		msleep(50);
 457		/* ensure drive irq is clear */
 458		(void)tp_ops->read_status(hwif);
 459	}
 460	return rc;
 461}
 462
 463/**
 464 *	probe_for_drives	-	upper level drive probe
 465 *	@drive: drive to probe for
 466 *
 467 *	probe_for_drive() tests for existence of a given drive using do_probe()
 468 *	and presents things to the user as needed.
 469 *
 470 *	Returns:	0  no device was found
 471 *			1  device was found
 472 *			   (note: IDE_DFLAG_PRESENT might still be not set)
 473 */
 474
 475static u8 probe_for_drive(ide_drive_t *drive)
 476{
 477	char *m;
 478	int rc;
 479	u8 cmd;
 480
 481	drive->dev_flags &= ~IDE_DFLAG_ID_READ;
 482
 483	m = (char *)&drive->id[ATA_ID_PROD];
 484	strcpy(m, "UNKNOWN");
 485
 486	/* skip probing? */
 487	if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
 488		/* if !(success||timed-out) */
 489		cmd = ATA_CMD_ID_ATA;
 490		rc = do_probe(drive, cmd);
 491		if (rc >= 2) {
 492			/* look for ATAPI device */
 493			cmd = ATA_CMD_ID_ATAPI;
 494			rc = do_probe(drive, cmd);
 495		}
 496
 497		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
 498			return 0;
 499
 500		/* identification failed? */
 501		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
 502			if (drive->media == ide_disk) {
 503				printk(KERN_INFO "%s: non-IDE drive, CHS=%d/%d/%d\n",
 504					drive->name, drive->cyl,
 505					drive->head, drive->sect);
 506			} else if (drive->media == ide_cdrom) {
 507				printk(KERN_INFO "%s: ATAPI cdrom (?)\n", drive->name);
 508			} else {
 509				/* nuke it */
 510				printk(KERN_WARNING "%s: Unknown device on bus refused identification. Ignoring.\n", drive->name);
 511				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
 512			}
 513		} else {
 514			if (cmd == ATA_CMD_ID_ATAPI)
 515				ide_classify_atapi_dev(drive);
 516			else
 517				ide_classify_ata_dev(drive);
 518		}
 519	}
 520
 521	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
 522		return 0;
 523
 524	/* The drive wasn't being helpful. Add generic info only */
 525	if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
 526		generic_id(drive);
 527		return 1;
 528	}
 529
 530	if (drive->media == ide_disk) {
 531		ide_disk_init_chs(drive);
 532		ide_disk_init_mult_count(drive);
 533	}
 534
 535	return 1;
 536}
 537
 538static void hwif_release_dev(struct device *dev)
 539{
 540	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);
 541
 542	complete(&hwif->gendev_rel_comp);
 543}
 544
 545static int ide_register_port(ide_hwif_t *hwif)
 546{
 547	int ret;
 548
 549	/* register with global device tree */
 550	dev_set_name(&hwif->gendev, "%s", hwif->name);
 551	dev_set_drvdata(&hwif->gendev, hwif);
 552	if (hwif->gendev.parent == NULL)
 553		hwif->gendev.parent = hwif->dev;
 554	hwif->gendev.release = hwif_release_dev;
 555
 556	ret = device_register(&hwif->gendev);
 557	if (ret < 0) {
 558		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
 559			__func__, ret);
 560		goto out;
 561	}
 562
 563	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
 564				      MKDEV(0, 0), hwif, "%s", hwif->name);
 565	if (IS_ERR(hwif->portdev)) {
 566		ret = PTR_ERR(hwif->portdev);
 567		device_unregister(&hwif->gendev);
 568	}
 569out:
 570	return ret;
 571}
 572
 573/**
 574 *	ide_port_wait_ready	-	wait for port to become ready
 575 *	@hwif: IDE port
 576 *
 577 *	This is needed on some PPCs and a bunch of BIOS-less embedded
 578 *	platforms.  Typical cases are:
 579 *
 580 *	- The firmware hard reset the disk before booting the kernel,
 581 *	  the drive is still doing it's poweron-reset sequence, that
 582 *	  can take up to 30 seconds.
 583 *
 584 *	- The firmware does nothing (or no firmware), the device is
 585 *	  still in POST state (same as above actually).
 586 *
 587 *	- Some CD/DVD/Writer combo drives tend to drive the bus during
 588 *	  their reset sequence even when they are non-selected slave
 589 *	  devices, thus preventing discovery of the main HD.
 590 *
 591 *	Doing this wait-for-non-busy should not harm any existing
 592 *	configuration and fix some issues like the above.
 593 *
 594 *	BenH.
 595 *
 596 *	Returns 0 on success, error code (< 0) otherwise.
 597 */
 598
 599static int ide_port_wait_ready(ide_hwif_t *hwif)
 600{
 601	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
 602	ide_drive_t *drive;
 603	int i, rc;
 604
 605	printk(KERN_DEBUG "Probing IDE interface %s...\n", hwif->name);
 606
 607	/* Let HW settle down a bit from whatever init state we
 608	 * come from */
 609	mdelay(2);
 610
 611	/* Wait for BSY bit to go away, spec timeout is 30 seconds,
 612	 * I know of at least one disk who takes 31 seconds, I use 35
 613	 * here to be safe
 614	 */
 615	rc = ide_wait_not_busy(hwif, 35000);
 616	if (rc)
 617		return rc;
 618
 619	/* Now make sure both master & slave are ready */
 620	ide_port_for_each_dev(i, drive, hwif) {
 621		/* Ignore disks that we will not probe for later. */
 622		if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
 623		    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
 624			tp_ops->dev_select(drive);
 625			tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
 626			mdelay(2);
 627			rc = ide_wait_not_busy(hwif, 35000);
 628			if (rc)
 629				goto out;
 630		} else
 631			printk(KERN_DEBUG "%s: ide_wait_not_busy() skipped\n",
 632					  drive->name);
 633	}
 634out:
 635	/* Exit function with master reselected (let's be sane) */
 636	if (i)
 637		tp_ops->dev_select(hwif->devices[0]);
 638
 639	return rc;
 640}
 641
 642/**
 643 *	ide_undecoded_slave	-	look for bad CF adapters
 644 *	@dev1: slave device
 645 *
 646 *	Analyse the drives on the interface and attempt to decide if we
 647 *	have the same drive viewed twice. This occurs with crap CF adapters
 648 *	and PCMCIA sometimes.
 649 */
 650
 651void ide_undecoded_slave(ide_drive_t *dev1)
 652{
 653	ide_drive_t *dev0 = dev1->hwif->devices[0];
 654
 655	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
 656		return;
 657
 658	/* If the models don't match they are not the same product */
 659	if (strcmp((char *)&dev0->id[ATA_ID_PROD],
 660		   (char *)&dev1->id[ATA_ID_PROD]))
 661		return;
 662
 663	/* Serial numbers do not match */
 664	if (strncmp((char *)&dev0->id[ATA_ID_SERNO],
 665		    (char *)&dev1->id[ATA_ID_SERNO], ATA_ID_SERNO_LEN))
 666		return;
 667
 668	/* No serial number, thankfully very rare for CF */
 669	if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
 670		return;
 671
 672	/* Appears to be an IDE flash adapter with decode bugs */
 673	printk(KERN_WARNING "ide-probe: ignoring undecoded slave\n");
 674
 675	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
 676}
 677
 678EXPORT_SYMBOL_GPL(ide_undecoded_slave);
 679
 680static int ide_probe_port(ide_hwif_t *hwif)
 681{
 682	ide_drive_t *drive;
 683	unsigned int irqd;
 684	int i, rc = -ENODEV;
 685
 686	BUG_ON(hwif->present);
 687
 688	if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
 689	    (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
 690		return -EACCES;
 691
 692	/*
 693	 * We must always disable IRQ, as probe_for_drive will assert IRQ, but
 694	 * we'll install our IRQ driver much later...
 695	 */
 696	irqd = hwif->irq;
 697	if (irqd)
 698		disable_irq(hwif->irq);
 699
 700	if (ide_port_wait_ready(hwif) == -EBUSY)
 701		printk(KERN_DEBUG "%s: Wait for ready failed before probe !\n", hwif->name);
 702
 703	/*
 704	 * Second drive should only exist if first drive was found,
 705	 * but a lot of cdrom drives are configured as single slaves.
 706	 */
 707	ide_port_for_each_dev(i, drive, hwif) {
 708		(void) probe_for_drive(drive);
 709		if (drive->dev_flags & IDE_DFLAG_PRESENT)
 710			rc = 0;
 711	}
 712
 713	/*
 714	 * Use cached IRQ number. It might be (and is...) changed by probe
 715	 * code above
 716	 */
 717	if (irqd)
 718		enable_irq(irqd);
 719
 720	return rc;
 721}
 722
 723static void ide_port_tune_devices(ide_hwif_t *hwif)
 724{
 725	const struct ide_port_ops *port_ops = hwif->port_ops;
 726	ide_drive_t *drive;
 727	int i;
 728
 729	ide_port_for_each_present_dev(i, drive, hwif) {
 730		ide_check_nien_quirk_list(drive);
 731
 732		if (port_ops && port_ops->quirkproc)
 733			port_ops->quirkproc(drive);
 734	}
 735
 736	ide_port_for_each_present_dev(i, drive, hwif) {
 737		ide_set_max_pio(drive);
 738
 739		drive->dev_flags |= IDE_DFLAG_NICE1;
 740
 741		if (hwif->dma_ops)
 742			ide_set_dma(drive);
 743	}
 744}
 745
 746static void ide_initialize_rq(struct request *rq)
 747{
 748	struct ide_request *req = blk_mq_rq_to_pdu(rq);
 749
 750	req->special = NULL;
 751	scsi_req_init(&req->sreq);
 752	req->sreq.sense = req->sense;
 753}
 754
 755static const struct blk_mq_ops ide_mq_ops = {
 756	.queue_rq		= ide_queue_rq,
 757	.initialize_rq_fn	= ide_initialize_rq,
 758};
 759
 760/*
 761 * init request queue
 762 */
 763static int ide_init_queue(ide_drive_t *drive)
 764{
 765	struct request_queue *q;
 766	ide_hwif_t *hwif = drive->hwif;
 767	int max_sectors = 256;
 768	int max_sg_entries = PRD_ENTRIES;
 769	struct blk_mq_tag_set *set;
 770
 771	/*
 772	 *	Our default set up assumes the normal IDE case,
 773	 *	that is 64K segmenting, standard PRD setup
 774	 *	and LBA28. Some drivers then impose their own
 775	 *	limits and LBA48 we could raise it but as yet
 776	 *	do not.
 777	 */
 778
 779	set = &drive->tag_set;
 780	set->ops = &ide_mq_ops;
 781	set->nr_hw_queues = 1;
 782	set->queue_depth = 32;
 783	set->reserved_tags = 1;
 784	set->cmd_size = sizeof(struct ide_request);
 785	set->numa_node = hwif_to_node(hwif);
 786	set->flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_BLOCKING;
 787	if (blk_mq_alloc_tag_set(set))
 788		return 1;
 789
 790	q = blk_mq_init_queue(set);
 791	if (IS_ERR(q)) {
 792		blk_mq_free_tag_set(set);
 793		return 1;
 794	}
 795
 796	blk_queue_flag_set(QUEUE_FLAG_SCSI_PASSTHROUGH, q);
 797
 798	q->queuedata = drive;
 799	blk_queue_segment_boundary(q, 0xffff);
 800
 801	if (hwif->rqsize < max_sectors)
 802		max_sectors = hwif->rqsize;
 803	blk_queue_max_hw_sectors(q, max_sectors);
 804
 805#ifdef CONFIG_PCI
 806	/* When we have an IOMMU, we may have a problem where pci_map_sg()
 807	 * creates segments that don't completely match our boundary
 808	 * requirements and thus need to be broken up again. Because it
 809	 * doesn't align properly either, we may actually have to break up
 810	 * to more segments than what was we got in the first place, a max
 811	 * worst case is twice as many.
 812	 * This will be fixed once we teach pci_map_sg() about our boundary
 813	 * requirements, hopefully soon. *FIXME*
 814	 */
 815	max_sg_entries >>= 1;
 816#endif /* CONFIG_PCI */
 817
 818	blk_queue_max_segments(q, max_sg_entries);
 819
 820	/* assign drive queue */
 821	drive->queue = q;
 822
 823	return 0;
 824}
 825
 826static DEFINE_MUTEX(ide_cfg_mtx);
 827
 828/*
 829 * For any present drive:
 830 * - allocate the block device queue
 831 */
 832static int ide_port_setup_devices(ide_hwif_t *hwif)
 833{
 834	ide_drive_t *drive;
 835	int i, j = 0;
 836
 837	mutex_lock(&ide_cfg_mtx);
 838	ide_port_for_each_present_dev(i, drive, hwif) {
 839		if (ide_init_queue(drive)) {
 840			printk(KERN_ERR "ide: failed to init %s\n",
 841					drive->name);
 842			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
 843			continue;
 844		}
 845
 846		j++;
 847	}
 848	mutex_unlock(&ide_cfg_mtx);
 849
 850	return j;
 851}
 852
 853static void ide_host_enable_irqs(struct ide_host *host)
 854{
 855	ide_hwif_t *hwif;
 856	int i;
 857
 858	ide_host_for_each_port(i, hwif, host) {
 859		if (hwif == NULL)
 860			continue;
 861
 862		/* clear any pending IRQs */
 863		hwif->tp_ops->read_status(hwif);
 864
 865		/* unmask IRQs */
 866		if (hwif->io_ports.ctl_addr)
 867			hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
 868	}
 869}
 870
 871/*
 872 * This routine sets up the IRQ for an IDE interface.
 873 */
 874static int init_irq (ide_hwif_t *hwif)
 875{
 876	struct ide_io_ports *io_ports = &hwif->io_ports;
 877	struct ide_host *host = hwif->host;
 878	irq_handler_t irq_handler = host->irq_handler;
 879	int sa = host->irq_flags;
 880
 881	if (irq_handler == NULL)
 882		irq_handler = ide_intr;
 883
 884	if (!host->get_lock)
 885		if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
 886			goto out_up;
 887
 888#if !defined(__mc68000__)
 889	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
 890		io_ports->data_addr, io_ports->status_addr,
 891		io_ports->ctl_addr, hwif->irq);
 892#else
 893	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
 894		io_ports->data_addr, hwif->irq);
 895#endif /* __mc68000__ */
 896	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
 897		printk(KERN_CONT " (serialized)");
 898	printk(KERN_CONT "\n");
 899
 900	return 0;
 901out_up:
 902	return 1;
 903}
 904
 905static int ata_lock(dev_t dev, void *data)
 906{
 907	/* FIXME: we want to pin hwif down */
 908	return 0;
 909}
 910
 911static struct kobject *ata_probe(dev_t dev, int *part, void *data)
 912{
 913	ide_hwif_t *hwif = data;
 914	int unit = *part >> PARTN_BITS;
 915	ide_drive_t *drive = hwif->devices[unit];
 916
 917	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
 918		return NULL;
 919
 920	if (drive->media == ide_disk)
 921		request_module("ide-disk");
 922	if (drive->media == ide_cdrom || drive->media == ide_optical)
 923		request_module("ide-cd");
 924	if (drive->media == ide_tape)
 925		request_module("ide-tape");
 926	if (drive->media == ide_floppy)
 927		request_module("ide-floppy");
 928
 929	return NULL;
 930}
 931
 932static struct kobject *exact_match(dev_t dev, int *part, void *data)
 933{
 934	struct gendisk *p = data;
 935	*part &= (1 << PARTN_BITS) - 1;
 936	return &disk_to_dev(p)->kobj;
 937}
 938
 939static int exact_lock(dev_t dev, void *data)
 940{
 941	struct gendisk *p = data;
 942
 943	if (!get_disk_and_module(p))
 944		return -1;
 945	return 0;
 946}
 947
 948void ide_register_region(struct gendisk *disk)
 949{
 950	blk_register_region(MKDEV(disk->major, disk->first_minor),
 951			    disk->minors, NULL, exact_match, exact_lock, disk);
 952}
 953
 954EXPORT_SYMBOL_GPL(ide_register_region);
 955
 956void ide_unregister_region(struct gendisk *disk)
 957{
 958	blk_unregister_region(MKDEV(disk->major, disk->first_minor),
 959			      disk->minors);
 960}
 961
 962EXPORT_SYMBOL_GPL(ide_unregister_region);
 963
 964void ide_init_disk(struct gendisk *disk, ide_drive_t *drive)
 965{
 966	ide_hwif_t *hwif = drive->hwif;
 967	unsigned int unit = drive->dn & 1;
 968
 969	disk->major = hwif->major;
 970	disk->first_minor = unit << PARTN_BITS;
 971	sprintf(disk->disk_name, "hd%c", 'a' + hwif->index * MAX_DRIVES + unit);
 972	disk->queue = drive->queue;
 973}
 974
 975EXPORT_SYMBOL_GPL(ide_init_disk);
 976
 977static void drive_release_dev (struct device *dev)
 978{
 979	ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
 980
 981	ide_proc_unregister_device(drive);
 982
 983	if (drive->sense_rq)
 984		blk_mq_free_request(drive->sense_rq);
 985
 986	blk_cleanup_queue(drive->queue);
 987	drive->queue = NULL;
 988	blk_mq_free_tag_set(&drive->tag_set);
 989
 990	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
 991
 992	complete(&drive->gendev_rel_comp);
 993}
 994
 995static int hwif_init(ide_hwif_t *hwif)
 996{
 997	if (!hwif->irq) {
 998		printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
 999		return 0;
1000	}
1001
1002	if (register_blkdev(hwif->major, hwif->name))
1003		return 0;
1004
1005	if (!hwif->sg_max_nents)
1006		hwif->sg_max_nents = PRD_ENTRIES;
1007
1008	hwif->sg_table = kmalloc_array(hwif->sg_max_nents,
1009				       sizeof(struct scatterlist),
1010				       GFP_KERNEL);
1011	if (!hwif->sg_table) {
1012		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
1013		goto out;
1014	}
1015
1016	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
1017	
1018	if (init_irq(hwif)) {
1019		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
1020			hwif->name, hwif->irq);
1021		goto out;
1022	}
1023
1024	blk_register_region(MKDEV(hwif->major, 0), MAX_DRIVES << PARTN_BITS,
1025			    THIS_MODULE, ata_probe, ata_lock, hwif);
1026	return 1;
1027
1028out:
1029	unregister_blkdev(hwif->major, hwif->name);
1030	return 0;
1031}
1032
1033static void hwif_register_devices(ide_hwif_t *hwif)
1034{
1035	ide_drive_t *drive;
1036	unsigned int i;
1037
1038	ide_port_for_each_present_dev(i, drive, hwif) {
1039		struct device *dev = &drive->gendev;
1040		int ret;
1041
1042		dev_set_name(dev, "%u.%u", hwif->index, i);
1043		dev_set_drvdata(dev, drive);
1044		dev->parent = &hwif->gendev;
1045		dev->bus = &ide_bus_type;
1046		dev->release = drive_release_dev;
1047
1048		ret = device_register(dev);
1049		if (ret < 0)
1050			printk(KERN_WARNING "IDE: %s: device_register error: "
1051					    "%d\n", __func__, ret);
1052	}
1053}
1054
1055static void ide_port_init_devices(ide_hwif_t *hwif)
1056{
1057	const struct ide_port_ops *port_ops = hwif->port_ops;
1058	ide_drive_t *drive;
1059	int i;
1060
1061	ide_port_for_each_dev(i, drive, hwif) {
1062		drive->dn = i + hwif->channel * 2;
1063
1064		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
1065			drive->io_32bit = 1;
1066		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
1067			drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
1068		if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
1069			drive->dev_flags |= IDE_DFLAG_UNMASK;
1070		if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
1071			drive->dev_flags |= IDE_DFLAG_NO_UNMASK;
1072
1073		drive->pio_mode = XFER_PIO_0;
1074
1075		if (port_ops && port_ops->init_dev)
1076			port_ops->init_dev(drive);
1077	}
1078}
1079
1080static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
1081			  const struct ide_port_info *d)
1082{
1083	hwif->channel = port;
1084
1085	hwif->chipset = d->chipset ? d->chipset : ide_pci;
1086
1087	if (d->init_iops)
1088		d->init_iops(hwif);
1089
1090	/* ->host_flags may be set by ->init_iops (or even earlier...) */
1091	hwif->host_flags |= d->host_flags;
1092	hwif->pio_mask = d->pio_mask;
1093
1094	if (d->tp_ops)
1095		hwif->tp_ops = d->tp_ops;
1096
1097	/* ->set_pio_mode for DTC2278 is currently limited to port 0 */
1098	if ((hwif->host_flags & IDE_HFLAG_DTC2278) == 0 || hwif->channel == 0)
1099		hwif->port_ops = d->port_ops;
1100
1101	hwif->swdma_mask = d->swdma_mask;
1102	hwif->mwdma_mask = d->mwdma_mask;
1103	hwif->ultra_mask = d->udma_mask;
1104
1105	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
1106		int rc;
1107
1108		hwif->dma_ops = d->dma_ops;
1109
1110		if (d->init_dma)
1111			rc = d->init_dma(hwif, d);
1112		else
1113			rc = ide_hwif_setup_dma(hwif, d);
1114
1115		if (rc < 0) {
1116			printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
1117
1118			hwif->dma_ops = NULL;
1119			hwif->dma_base = 0;
1120			hwif->swdma_mask = 0;
1121			hwif->mwdma_mask = 0;
1122			hwif->ultra_mask = 0;
1123		}
1124	}
1125
1126	if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
1127	    ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base))
1128		hwif->host->host_flags |= IDE_HFLAG_SERIALIZE;
1129
1130	if (d->max_sectors)
1131		hwif->rqsize = d->max_sectors;
1132	else {
1133		if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
1134		    (hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA))
1135			hwif->rqsize = 256;
1136		else
1137			hwif->rqsize = 65536;
1138	}
1139
1140	/* call chipset specific routine for each enabled port */
1141	if (d->init_hwif)
1142		d->init_hwif(hwif);
1143}
1144
1145static void ide_port_cable_detect(ide_hwif_t *hwif)
1146{
1147	const struct ide_port_ops *port_ops = hwif->port_ops;
1148
1149	if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
1150		if (hwif->cbl != ATA_CBL_PATA40_SHORT)
1151			hwif->cbl = port_ops->cable_detect(hwif);
1152	}
1153}
1154
1155/*
1156 * Deferred request list insertion handler
1157 */
1158static void drive_rq_insert_work(struct work_struct *work)
1159{
1160	ide_drive_t *drive = container_of(work, ide_drive_t, rq_work);
1161	ide_hwif_t *hwif = drive->hwif;
1162	struct request *rq;
1163	blk_status_t ret;
1164	LIST_HEAD(list);
1165
1166	blk_mq_quiesce_queue(drive->queue);
1167
1168	ret = BLK_STS_OK;
1169	spin_lock_irq(&hwif->lock);
1170	while (!list_empty(&drive->rq_list)) {
1171		rq = list_first_entry(&drive->rq_list, struct request, queuelist);
1172		list_del_init(&rq->queuelist);
1173
1174		spin_unlock_irq(&hwif->lock);
1175		ret = ide_issue_rq(drive, rq, true);
1176		spin_lock_irq(&hwif->lock);
1177	}
1178	spin_unlock_irq(&hwif->lock);
1179
1180	blk_mq_unquiesce_queue(drive->queue);
1181
1182	if (ret != BLK_STS_OK)
1183		kblockd_schedule_work(&drive->rq_work);
1184}
1185
1186static const u8 ide_hwif_to_major[] =
1187	{ IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR, IDE4_MAJOR,
1188	  IDE5_MAJOR, IDE6_MAJOR, IDE7_MAJOR, IDE8_MAJOR, IDE9_MAJOR };
1189
1190static void ide_port_init_devices_data(ide_hwif_t *hwif)
1191{
1192	ide_drive_t *drive;
1193	int i;
1194
1195	ide_port_for_each_dev(i, drive, hwif) {
1196		u8 j = (hwif->index * MAX_DRIVES) + i;
1197		u16 *saved_id = drive->id;
1198
1199		memset(drive, 0, sizeof(*drive));
1200		memset(saved_id, 0, SECTOR_SIZE);
1201		drive->id = saved_id;
1202
1203		drive->media			= ide_disk;
1204		drive->select			= (i << 4) | ATA_DEVICE_OBS;
1205		drive->hwif			= hwif;
1206		drive->ready_stat		= ATA_DRDY;
1207		drive->bad_wstat		= BAD_W_STAT;
1208		drive->special_flags		= IDE_SFLAG_RECALIBRATE |
1209						  IDE_SFLAG_SET_GEOMETRY;
1210		drive->name[0]			= 'h';
1211		drive->name[1]			= 'd';
1212		drive->name[2]			= 'a' + j;
1213		drive->max_failures		= IDE_DEFAULT_MAX_FAILURES;
1214
1215		INIT_LIST_HEAD(&drive->list);
1216		init_completion(&drive->gendev_rel_comp);
1217
1218		INIT_WORK(&drive->rq_work, drive_rq_insert_work);
1219		INIT_LIST_HEAD(&drive->rq_list);
1220	}
1221}
1222
1223static void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
1224{
1225	/* fill in any non-zero initial values */
1226	hwif->index	= index;
1227	hwif->major	= ide_hwif_to_major[index];
1228
1229	hwif->name[0]	= 'i';
1230	hwif->name[1]	= 'd';
1231	hwif->name[2]	= 'e';
1232	hwif->name[3]	= '0' + index;
1233
1234	spin_lock_init(&hwif->lock);
1235
1236	timer_setup(&hwif->timer, ide_timer_expiry, 0);
1237
1238	init_completion(&hwif->gendev_rel_comp);
1239
1240	hwif->tp_ops = &default_tp_ops;
1241
1242	ide_port_init_devices_data(hwif);
1243}
1244
1245static void ide_init_port_hw(ide_hwif_t *hwif, struct ide_hw *hw)
1246{
1247	memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
1248	hwif->irq = hw->irq;
1249	hwif->dev = hw->dev;
1250	hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
1251	hwif->config_data = hw->config;
1252}
1253
1254static unsigned int ide_indexes;
1255
1256/**
1257 *	ide_find_port_slot	-	find free port slot
1258 *	@d: IDE port info
1259 *
1260 *	Return the new port slot index or -ENOENT if we are out of free slots.
1261 */
1262
1263static int ide_find_port_slot(const struct ide_port_info *d)
1264{
1265	int idx = -ENOENT;
1266	u8 bootable = (d && (d->host_flags & IDE_HFLAG_NON_BOOTABLE)) ? 0 : 1;
1267	u8 i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;
1268
1269	/*
1270	 * Claim an unassigned slot.
1271	 *
1272	 * Give preference to claiming other slots before claiming ide0/ide1,
1273	 * just in case there's another interface yet-to-be-scanned
1274	 * which uses ports 0x1f0/0x170 (the ide0/ide1 defaults).
1275	 *
1276	 * Unless there is a bootable card that does not use the standard
1277	 * ports 0x1f0/0x170 (the ide0/ide1 defaults).
1278	 */
1279	mutex_lock(&ide_cfg_mtx);
1280	if (bootable) {
1281		if ((ide_indexes | i) != (1 << MAX_HWIFS) - 1)
1282			idx = ffz(ide_indexes | i);
1283	} else {
1284		if ((ide_indexes | 3) != (1 << MAX_HWIFS) - 1)
1285			idx = ffz(ide_indexes | 3);
1286		else if ((ide_indexes & 3) != 3)
1287			idx = ffz(ide_indexes);
1288	}
1289	if (idx >= 0)
1290		ide_indexes |= (1 << idx);
1291	mutex_unlock(&ide_cfg_mtx);
1292
1293	return idx;
1294}
1295
1296static void ide_free_port_slot(int idx)
1297{
1298	mutex_lock(&ide_cfg_mtx);
1299	ide_indexes &= ~(1 << idx);
1300	mutex_unlock(&ide_cfg_mtx);
1301}
1302
1303static void ide_port_free_devices(ide_hwif_t *hwif)
1304{
1305	ide_drive_t *drive;
1306	int i;
1307
1308	ide_port_for_each_dev(i, drive, hwif) {
1309		kfree(drive->id);
1310		kfree(drive);
1311	}
1312}
1313
1314static int ide_port_alloc_devices(ide_hwif_t *hwif, int node)
1315{
1316	ide_drive_t *drive;
1317	int i;
1318
1319	for (i = 0; i < MAX_DRIVES; i++) {
1320		drive = kzalloc_node(sizeof(*drive), GFP_KERNEL, node);
1321		if (drive == NULL)
1322			goto out_nomem;
1323
1324		/*
1325		 * In order to keep things simple we have an id
1326		 * block for all drives at all times. If the device
1327		 * is pre ATA or refuses ATA/ATAPI identify we
1328		 * will add faked data to this.
1329		 *
1330		 * Also note that 0 everywhere means "can't do X"
1331		 */
1332		drive->id = kzalloc_node(SECTOR_SIZE, GFP_KERNEL, node);
1333		if (drive->id == NULL)
1334			goto out_free_drive;
1335
1336		hwif->devices[i] = drive;
1337	}
1338	return 0;
1339
1340out_free_drive:
1341	kfree(drive);
1342out_nomem:
1343	ide_port_free_devices(hwif);
1344	return -ENOMEM;
1345}
1346
1347struct ide_host *ide_host_alloc(const struct ide_port_info *d,
1348				struct ide_hw **hws, unsigned int n_ports)
1349{
1350	struct ide_host *host;
1351	struct device *dev = hws[0] ? hws[0]->dev : NULL;
1352	int node = dev ? dev_to_node(dev) : -1;
1353	int i;
1354
1355	host = kzalloc_node(sizeof(*host), GFP_KERNEL, node);
1356	if (host == NULL)
1357		return NULL;
1358
1359	for (i = 0; i < n_ports; i++) {
1360		ide_hwif_t *hwif;
1361		int idx;
1362
1363		if (hws[i] == NULL)
1364			continue;
1365
1366		hwif = kzalloc_node(sizeof(*hwif), GFP_KERNEL, node);
1367		if (hwif == NULL)
1368			continue;
1369
1370		if (ide_port_alloc_devices(hwif, node) < 0) {
1371			kfree(hwif);
1372			continue;
1373		}
1374
1375		idx = ide_find_port_slot(d);
1376		if (idx < 0) {
1377			printk(KERN_ERR "%s: no free slot for interface\n",
1378					d ? d->name : "ide");
1379			ide_port_free_devices(hwif);
1380			kfree(hwif);
1381			continue;
1382		}
1383
1384		ide_init_port_data(hwif, idx);
1385
1386		hwif->host = host;
1387
1388		host->ports[i] = hwif;
1389		host->n_ports++;
1390	}
1391
1392	if (host->n_ports == 0) {
1393		kfree(host);
1394		return NULL;
1395	}
1396
1397	host->dev[0] = dev;
1398
1399	if (d) {
1400		host->init_chipset = d->init_chipset;
1401		host->get_lock     = d->get_lock;
1402		host->release_lock = d->release_lock;
1403		host->host_flags = d->host_flags;
1404		host->irq_flags = d->irq_flags;
1405	}
1406
1407	return host;
1408}
1409EXPORT_SYMBOL_GPL(ide_host_alloc);
1410
1411static void ide_port_free(ide_hwif_t *hwif)
1412{
1413	ide_port_free_devices(hwif);
1414	ide_free_port_slot(hwif->index);
1415	kfree(hwif);
1416}
1417
1418static void ide_disable_port(ide_hwif_t *hwif)
1419{
1420	struct ide_host *host = hwif->host;
1421	int i;
1422
1423	printk(KERN_INFO "%s: disabling port\n", hwif->name);
1424
1425	for (i = 0; i < MAX_HOST_PORTS; i++) {
1426		if (host->ports[i] == hwif) {
1427			host->ports[i] = NULL;
1428			host->n_ports--;
1429		}
1430	}
1431
1432	ide_port_free(hwif);
1433}
1434
1435int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
1436		      struct ide_hw **hws)
1437{
1438	ide_hwif_t *hwif, *mate = NULL;
1439	int i, j = 0;
1440
1441	pr_warn("legacy IDE will be removed in 2021, please switch to libata\n"
1442		"Report any missing HW support to linux-ide@vger.kernel.org\n");
1443
1444	ide_host_for_each_port(i, hwif, host) {
1445		if (hwif == NULL) {
1446			mate = NULL;
1447			continue;
1448		}
1449
1450		ide_init_port_hw(hwif, hws[i]);
1451		ide_port_apply_params(hwif);
1452
1453		if ((i & 1) && mate) {
1454			hwif->mate = mate;
1455			mate->mate = hwif;
1456		}
1457
1458		mate = (i & 1) ? NULL : hwif;
1459
1460		ide_init_port(hwif, i & 1, d);
1461		ide_port_cable_detect(hwif);
1462
1463		hwif->port_flags |= IDE_PFLAG_PROBING;
1464
1465		ide_port_init_devices(hwif);
1466	}
1467
1468	ide_host_for_each_port(i, hwif, host) {
1469		if (hwif == NULL)
1470			continue;
1471
1472		if (ide_probe_port(hwif) == 0)
1473			hwif->present = 1;
1474
1475		hwif->port_flags &= ~IDE_PFLAG_PROBING;
1476
1477		if ((hwif->host_flags & IDE_HFLAG_4DRIVES) == 0 ||
1478		    hwif->mate == NULL || hwif->mate->present == 0) {
1479			if (ide_register_port(hwif)) {
1480				ide_disable_port(hwif);
1481				continue;
1482			}
1483		}
1484
1485		if (hwif->present)
1486			ide_port_tune_devices(hwif);
1487	}
1488
1489	ide_host_enable_irqs(host);
1490
1491	ide_host_for_each_port(i, hwif, host) {
1492		if (hwif == NULL)
1493			continue;
1494
1495		if (hwif_init(hwif) == 0) {
1496			printk(KERN_INFO "%s: failed to initialize IDE "
1497					 "interface\n", hwif->name);
1498			device_unregister(hwif->portdev);
1499			device_unregister(&hwif->gendev);
1500			ide_disable_port(hwif);
1501			continue;
1502		}
1503
1504		if (hwif->present)
1505			if (ide_port_setup_devices(hwif) == 0) {
1506				hwif->present = 0;
1507				continue;
1508			}
1509
1510		j++;
1511
1512		ide_acpi_init_port(hwif);
1513
1514		if (hwif->present)
1515			ide_acpi_port_init_devices(hwif);
1516	}
1517
1518	ide_host_for_each_port(i, hwif, host) {
1519		if (hwif == NULL)
1520			continue;
1521
1522		ide_sysfs_register_port(hwif);
1523		ide_proc_register_port(hwif);
1524
1525		if (hwif->present) {
1526			ide_proc_port_register_devices(hwif);
1527			hwif_register_devices(hwif);
1528		}
1529	}
1530
1531	return j ? 0 : -1;
1532}
1533EXPORT_SYMBOL_GPL(ide_host_register);
1534
1535int ide_host_add(const struct ide_port_info *d, struct ide_hw **hws,
1536		 unsigned int n_ports, struct ide_host **hostp)
1537{
1538	struct ide_host *host;
1539	int rc;
1540
1541	host = ide_host_alloc(d, hws, n_ports);
1542	if (host == NULL)
1543		return -ENOMEM;
1544
1545	rc = ide_host_register(host, d, hws);
1546	if (rc) {
1547		ide_host_free(host);
1548		return rc;
1549	}
1550
1551	if (hostp)
1552		*hostp = host;
1553
1554	return 0;
1555}
1556EXPORT_SYMBOL_GPL(ide_host_add);
1557
1558static void __ide_port_unregister_devices(ide_hwif_t *hwif)
1559{
1560	ide_drive_t *drive;
1561	int i;
1562
1563	ide_port_for_each_present_dev(i, drive, hwif) {
1564		device_unregister(&drive->gendev);
1565		wait_for_completion(&drive->gendev_rel_comp);
1566	}
1567}
1568
1569void ide_port_unregister_devices(ide_hwif_t *hwif)
1570{
1571	mutex_lock(&ide_cfg_mtx);
1572	__ide_port_unregister_devices(hwif);
1573	hwif->present = 0;
1574	ide_port_init_devices_data(hwif);
1575	mutex_unlock(&ide_cfg_mtx);
1576}
1577EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
1578
1579/**
1580 *	ide_unregister		-	free an IDE interface
1581 *	@hwif: IDE interface
1582 *
1583 *	Perform the final unregister of an IDE interface.
1584 *
1585 *	Locking:
1586 *	The caller must not hold the IDE locks.
1587 *
1588 *	It is up to the caller to be sure there is no pending I/O here,
1589 *	and that the interface will not be reopened (present/vanishing
1590 *	locking isn't yet done BTW).
1591 */
1592
1593static void ide_unregister(ide_hwif_t *hwif)
1594{
1595	BUG_ON(in_interrupt());
1596	BUG_ON(irqs_disabled());
1597
1598	mutex_lock(&ide_cfg_mtx);
1599
1600	if (hwif->present) {
1601		__ide_port_unregister_devices(hwif);
1602		hwif->present = 0;
1603	}
1604
1605	ide_proc_unregister_port(hwif);
1606
1607	if (!hwif->host->get_lock)
1608		free_irq(hwif->irq, hwif);
1609
1610	device_unregister(hwif->portdev);
1611	device_unregister(&hwif->gendev);
1612	wait_for_completion(&hwif->gendev_rel_comp);
1613
1614	/*
1615	 * Remove us from the kernel's knowledge
1616	 */
1617	blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS);
1618	kfree(hwif->sg_table);
1619	unregister_blkdev(hwif->major, hwif->name);
1620
1621	ide_release_dma_engine(hwif);
1622
1623	mutex_unlock(&ide_cfg_mtx);
1624}
1625
1626void ide_host_free(struct ide_host *host)
1627{
1628	ide_hwif_t *hwif;
1629	int i;
1630
1631	ide_host_for_each_port(i, hwif, host) {
1632		if (hwif)
1633			ide_port_free(hwif);
1634	}
1635
1636	kfree(host);
1637}
1638EXPORT_SYMBOL_GPL(ide_host_free);
1639
1640void ide_host_remove(struct ide_host *host)
1641{
1642	ide_hwif_t *hwif;
1643	int i;
1644
1645	ide_host_for_each_port(i, hwif, host) {
1646		if (hwif)
1647			ide_unregister(hwif);
1648	}
1649
1650	ide_host_free(host);
1651}
1652EXPORT_SYMBOL_GPL(ide_host_remove);
1653
1654void ide_port_scan(ide_hwif_t *hwif)
1655{
1656	int rc;
1657
1658	ide_port_apply_params(hwif);
1659	ide_port_cable_detect(hwif);
1660
1661	hwif->port_flags |= IDE_PFLAG_PROBING;
1662
1663	ide_port_init_devices(hwif);
1664
1665	rc = ide_probe_port(hwif);
1666
1667	hwif->port_flags &= ~IDE_PFLAG_PROBING;
1668
1669	if (rc < 0)
1670		return;
1671
1672	hwif->present = 1;
1673
1674	ide_port_tune_devices(hwif);
1675	ide_port_setup_devices(hwif);
1676	ide_acpi_port_init_devices(hwif);
1677	hwif_register_devices(hwif);
1678	ide_proc_port_register_devices(hwif);
1679}
1680EXPORT_SYMBOL_GPL(ide_port_scan);