ide.c 65.3 KB
Newer Older
1
/*
Alan Cox's avatar
Alan Cox committed
2
 *  linux/drivers/ide/ide.c		Version 7.00beta2	Mar 05 2003
3 4 5 6 7 8 9 10 11 12 13 14
 *
 *  Copyright (C) 1994-1998  Linus Torvalds & authors (see below)
 */

/*
 *  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 multiple IDE interface driver, as evolved from hd.c.
15 16
 * It supports up to MAX_HWIFS IDE interfaces, on one or more IRQs
 *   (usually 14 & 15).
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
 * There can be up to two drives per interface, as per the ATA-2 spec.
 *
 * Primary:    ide0, port 0x1f0; major=3;  hda is minor=0; hdb is minor=64
 * Secondary:  ide1, port 0x170; major=22; hdc is minor=0; hdd is minor=64
 * Tertiary:   ide2, port 0x???; major=33; hde is minor=0; hdf is minor=64
 * Quaternary: ide3, port 0x???; major=34; hdg is minor=0; hdh is minor=64
 * ...
 *
 *  From hd.c:
 *  |
 *  | It traverses the request-list, using interrupts to jump between functions.
 *  | As nearly all functions can be called within interrupts, we may not sleep.
 *  | Special care is recommended.  Have Fun!
 *  |
 *  | modified by Drew Eckhardt to check nr of hd's from the CMOS.
 *  |
 *  | Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
 *  | in the early extended-partition checks and added DM partitions.
 *  |
 *  | Early work on error handling by Mika Liljeberg (liljeber@cs.Helsinki.FI).
 *  |
 *  | IRQ-unmask, drive-id, multiple-mode, support for ">16 heads",
 *  | and general streamlining by Mark Lord (mlord@pobox.com).
 *
 *  October, 1994 -- Complete line-by-line overhaul for linux 1.1.x, by:
 *
 *	Mark Lord	(mlord@pobox.com)		(IDE Perf.Pkg)
 *	Delman Lee	(delman@ieee.org)		("Mr. atdisk2")
 *	Scott Snyder	(snyder@fnald0.fnal.gov)	(ATAPI IDE cd-rom)
 *
 *  This was a rewrite of just about everything from hd.c, though some original
 *  code is still sprinkled about.  Think of it as a major evolution, with
 *  inspiration from lots of linux users, esp.  hamish@zot.apana.org.au
 *
 *  Version 1.0 ALPHA	initial code, primary i/f working okay
 *  Version 1.3 BETA	dual i/f on shared irq tested & working!
 *  Version 1.4 BETA	added auto probing for irq(s)
 *  Version 1.5 BETA	added ALPHA (untested) support for IDE cd-roms,
 *  ...
 * Version 5.50		allow values as small as 20 for idebus=
 * Version 5.51		force non io_32bit in drive_cmd_intr()
 *			change delay_10ms() to delay_50ms() to fix problems
 * Version 5.52		fix incorrect invalidation of removable devices
 *			add "hdx=slow" command line option
 * Version 5.60		start to modularize the driver; the disk and ATAPI
 *			 drivers can be compiled as loadable modules.
 *			move IDE probe code to ide-probe.c
 *			move IDE disk code to ide-disk.c
 *			add support for generic IDE device subdrivers
 *			add m68k code from Geert Uytterhoeven
 *			probe all interfaces by default
 *			add ioctl to (re)probe an interface
 * Version 6.00		use per device request queues
 *			attempt to optimize shared hwgroup performance
 *			add ioctl to manually adjust bandwidth algorithms
 *			add kerneld support for the probe module
 *			fix bug in ide_error()
 *			fix bug in the first ide_get_lock() call for Atari
 *			don't flush leftover data for ATAPI devices
 * Version 6.01		clear hwgroup->active while the hwgroup sleeps
 *			support HDIO_GETGEO for floppies
 * Version 6.02		fix ide_ack_intr() call
 *			check partition table on floppies
 * Version 6.03		handle bad status bit sequencing in ide_wait_stat()
 * Version 6.10		deleted old entries from this list of updates
 *			replaced triton.c with ide-dma.c generic PCI DMA
 *			added support for BIOS-enabled UltraDMA
 *			rename all "promise" things to "pdc4030"
 *			fix EZ-DRIVE handling on small disks
 * Version 6.11		fix probe error in ide_scan_devices()
 *			fix ancient "jiffies" polling bugs
 *			mask all hwgroup interrupts on each irq entry
 * Version 6.12		integrate ioctl and proc interfaces
 *			fix parsing of "idex=" command line parameter
 * Version 6.13		add support for ide4/ide5 courtesy rjones@orchestream.com
 * Version 6.14		fixed IRQ sharing among PCI devices
 * Version 6.15		added SMP awareness to IDE drivers
 * Version 6.16		fixed various bugs; even more SMP friendly
 * Version 6.17		fix for newest EZ-Drive problem
 * Version 6.18		default unpartitioned-disk translation now "BIOS LBA"
 * Version 6.19		Re-design for a UNIFORM driver for all platforms,
 *			  model based on suggestions from Russell King and
 *			  Geert Uytterhoeven
 *			Promise DC4030VL now supported.
 *			add support for ide6/ide7
 *			delay_50ms() changed to ide_delay_50ms() and exported.
 * Version 6.20		Added/Fixed Generic ATA-66 support and hwif detection.
 *			Added hdx=flash to allow for second flash disk
 *			  detection w/o the hang loop.
 *			Added support for ide8/ide9
 *			Added idex=ata66 for the quirky chipsets that are
 *			  ATA-66 compliant, but have yet to determine a method
 *			  of verification of the 80c cable presence.
 *			  Specifically Promise's PDC20262 chipset.
 * Version 6.21		Fixing/Fixed SMP spinlock issue with insight from an old
 *			  hat that clarified original low level driver design.
 * Version 6.30		Added SMP support; fixed multmode issues.  -ml
 * Version 6.31		Debug Share INTR's and request queue streaming
 *			Native ATA-100 support
 *			Prep for Cascades Project
117
 * Version 7.00alpha	First named revision of ide rearrange
118 119 120 121 122 123 124 125
 *
 *  Some additional driver compile-time options are in ./include/linux/ide.h
 *
 *  To do, in likely order of completion:
 *	- modify kernel to obtain BIOS geometry for drives on 2nd/3rd/4th i/f
 *
 */

126 127
#define	REVISION	"Revision: 7.00alpha2"
#define	VERSION		"Id: ide.c 7.00a2 20020906"
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

#undef REALLY_SLOW_IO		/* most systems can safely undef this */

#define _IDE_C			/* Tell ide.h it's really us */

#include <linux/config.h>
#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/blkpg.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/completion.h>
#include <linux/reboot.h>
#include <linux/cdrom.h>
154
#include <linux/seq_file.h>
155
#include <linux/device.h>
156 157 158 159 160 161 162 163 164 165 166

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


/* default maximum number of failures */
#define IDE_DEFAULT_MAX_FAILURES 	1

167 168 169 170 171
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 };
172

173 174 175
static int idebus_parameter;	/* holds the "idebus=" parameter */
static int system_bus_speed;	/* holds what we think is VESA/PCI bus speed */
static int initializing;	/* set while initializing built-in drivers */
176

Alan Cox's avatar
Alan Cox committed
177
DECLARE_MUTEX(ide_cfg_sem);
178 179
spinlock_t ide_lock __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;

180
#ifdef CONFIG_BLK_DEV_IDEPCI
181
static int ide_scan_direction; /* THIS was formerly 2.2.x pci=reverse */
182
#endif
183

184
#ifdef CONFIG_IDEDMA_AUTO
185
int noautodma = 0;
186 187 188
#else
int noautodma = 1;
#endif
189

Jens Axboe's avatar
Jens Axboe committed
190
EXPORT_SYMBOL(noautodma);
191
EXPORT_SYMBOL(ide_bus_type);
Jens Axboe's avatar
Jens Axboe committed
192

193 194 195
/*
 * This is declared extern in ide.h, for access by other IDE modules:
 */
196 197 198 199
ide_hwif_t ide_hwifs[MAX_HWIFS];	/* master data repository */

EXPORT_SYMBOL(ide_hwifs);

Alan Cox's avatar
Alan Cox committed
200
extern ide_driver_t idedefault_driver;
201
static void setup_driver_defaults(ide_driver_t *driver);
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231

/*
 * Do not even *think* about calling this!
 */
static void init_hwif_data (unsigned int index)
{
	unsigned int unit;
	hw_regs_t hw;
	ide_hwif_t *hwif = &ide_hwifs[index];

	/* bulk initialize hwif & drive info with zeros */
	memset(hwif, 0, sizeof(ide_hwif_t));
	memset(&hw, 0, sizeof(hw_regs_t));

	/* fill in any non-zero initial values */
	hwif->index     = index;
	ide_init_hwif_ports(&hw, ide_default_io_base(index), 0, &hwif->irq);
	memcpy(&hwif->hw, &hw, sizeof(hw));
	memcpy(hwif->io_ports, hw.io_ports, sizeof(hw.io_ports));
	hwif->noprobe	= !hwif->io_ports[IDE_DATA_OFFSET];
#ifdef CONFIG_BLK_DEV_HD
	if (hwif->io_ports[IDE_DATA_OFFSET] == HD_DATA)
		hwif->noprobe = 1; /* may be overridden by ide_setup() */
#endif /* CONFIG_BLK_DEV_HD */
	hwif->major	= ide_hwif_to_major[index];
	hwif->name[0]	= 'i';
	hwif->name[1]	= 'd';
	hwif->name[2]	= 'e';
	hwif->name[3]	= '0' + index;
	hwif->bus_state = BUSSTATE_ON;
232 233 234 235 236 237 238 239
	hwif->reset_poll= NULL;
	hwif->pre_reset = NULL;

	hwif->atapi_dma = 0;		/* disable all atapi dma */ 
	hwif->ultra_mask = 0x80;	/* disable all ultra */
	hwif->mwdma_mask = 0x80;	/* disable all mwdma */
	hwif->swdma_mask = 0x80;	/* disable all swdma */

240 241
	sema_init(&hwif->gendev_rel_sem, 0);

242 243
	default_hwif_iops(hwif);
	default_hwif_transport(hwif);
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		ide_drive_t *drive = &hwif->drives[unit];

		drive->media			= ide_disk;
		drive->select.all		= (unit<<4)|0xa0;
		drive->hwif			= hwif;
		drive->ctl			= 0x08;
		drive->ready_stat		= READY_STAT;
		drive->bad_wstat		= BAD_W_STAT;
		drive->special.b.recalibrate	= 1;
		drive->special.b.set_geometry	= 1;
		drive->name[0]			= 'h';
		drive->name[1]			= 'd';
		drive->name[2]			= 'a' + (index * MAX_DRIVES) + unit;
		drive->max_failures		= IDE_DEFAULT_MAX_FAILURES;
259 260
		drive->using_dma		= 0;
		drive->is_flash			= 0;
Alan Cox's avatar
Alan Cox committed
261
		drive->driver			= &idedefault_driver;
262
		drive->vdma			= 0;
263
		INIT_LIST_HEAD(&drive->list);
264
		sema_init(&drive->gendev_rel_sem, 0);
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
	}
}

/*
 * init_ide_data() sets reasonable default values into all fields
 * of all instances of the hwifs and drives, but only on the first call.
 * Subsequent calls have no effect (they don't wipe out anything).
 *
 * This routine is normally called at driver initialization time,
 * but may also be called MUCH earlier during kernel "command-line"
 * parameter processing.  As such, we cannot depend on any other parts
 * of the kernel (such as memory allocation) to be functioning yet.
 *
 * This is too bad, as otherwise we could dynamically allocate the
 * ide_drive_t structs as needed, rather than always consuming memory
 * for the max possible number (MAX_HWIFS * MAX_DRIVES) of them.
281 282 283
 *
 * FIXME: We should stuff the setup data into __init and copy the
 * relevant hwifs/allocate them properly during boot.
284 285 286 287 288 289 290 291 292 293 294
 */
#define MAGIC_COOKIE 0x12345678
static void __init init_ide_data (void)
{
	unsigned int index;
	static unsigned long magic_cookie = MAGIC_COOKIE;

	if (magic_cookie != MAGIC_COOKIE)
		return;		/* already initialized */
	magic_cookie = 0;

295 296
	setup_driver_defaults(&idedefault_driver);

297 298 299 300 301
	/* Initialise all interface structures */
	for (index = 0; index < MAX_HWIFS; ++index)
		init_hwif_data(index);

	/* Add default hw interfaces */
302
	initializing = 1;
303
	ide_init_default_hwifs();
304
	initializing = 0;
305 306 307 308 309 310 311 312 313 314 315 316
}

/*
 * ide_system_bus_speed() returns what we think is the system VESA/PCI
 * bus speed (in MHz).  This is used for calculating interface PIO timings.
 * The default is 40 for known PCI systems, 50 otherwise.
 * The "idebus=xx" parameter can be used to override this value.
 * The actual value to be used is computed/displayed the first time through.
 */
int ide_system_bus_speed (void)
{
	if (!system_bus_speed) {
317 318 319
		if (idebus_parameter) {
			/* user supplied value */
			system_bus_speed = idebus_parameter;
320
		} else if (pci_find_device(PCI_ANY_ID, PCI_ANY_ID, NULL) != NULL) {
321 322 323 324 325 326
			/* safe default value for PCI */
			system_bus_speed = 33;
		} else {
			/* safe default value for VESA and PCI */
			system_bus_speed = 50;
		}
327
		printk(KERN_INFO "ide: Assuming %dMHz system bus speed "
328
			"for PIO modes%s\n", system_bus_speed,
329 330 331 332 333 334 335 336 337
			idebus_parameter ? "" : "; override with idebus=xx");
	}
	return system_bus_speed;
}

/*
 * current_capacity() returns the capacity (in sectors) of a drive
 * according to its current geometry/LBA settings.
 */
338
sector_t current_capacity (ide_drive_t *drive)
339 340 341
{
	if (!drive->present)
		return 0;
Alan Cox's avatar
Alan Cox committed
342
	return DRIVER(drive)->capacity(drive);
343 344
}

345
EXPORT_SYMBOL(current_capacity);
346 347 348 349

/*
 * Error reporting, in human readable form (luxurious, but a memory hog).
 */
350
u8 ide_dump_status (ide_drive_t *drive, const char *msg, u8 stat)
351
{
352
	ide_hwif_t *hwif = HWIF(drive);
353
	unsigned long flags;
354
	u8 err = 0;
355 356

	local_irq_set(flags);
357
	printk(KERN_WARNING "%s: %s: status=0x%02x", drive->name, msg, stat);
358 359
#if FANCY_STATUS_DUMPS
	printk(" { ");
360
	if (stat & BUSY_STAT) {
361
		printk("Busy ");
362
	} else {
363 364 365 366 367 368 369 370 371 372 373 374
		if (stat & READY_STAT)	printk("DriveReady ");
		if (stat & WRERR_STAT)	printk("DeviceFault ");
		if (stat & SEEK_STAT)	printk("SeekComplete ");
		if (stat & DRQ_STAT)	printk("DataRequest ");
		if (stat & ECC_STAT)	printk("CorrectedError ");
		if (stat & INDEX_STAT)	printk("Index ");
		if (stat & ERR_STAT)	printk("Error ");
	}
	printk("}");
#endif	/* FANCY_STATUS_DUMPS */
	printk("\n");
	if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
375
		err = hwif->INB(IDE_ERROR_REG);
376 377 378 379 380
		printk("%s: %s: error=0x%02x", drive->name, msg, err);
#if FANCY_STATUS_DUMPS
		if (drive->media == ide_disk) {
			printk(" { ");
			if (err & ABRT_ERR)	printk("DriveStatusError ");
381
			if (err & ICRC_ERR)	printk("Bad%s ", (err & ABRT_ERR) ? "CRC" : "Sector");
382 383 384 385 386 387 388 389 390
			if (err & ECC_ERR)	printk("UncorrectableError ");
			if (err & ID_ERR)	printk("SectorIdNotFound ");
			if (err & TRK0_ERR)	printk("TrackZeroNotFound ");
			if (err & MARK_ERR)	printk("AddrMarkNotFound ");
			printk("}");
			if ((err & (BBD_ERR | ABRT_ERR)) == BBD_ERR || (err & (ECC_ERR|ID_ERR|MARK_ERR))) {
				if ((drive->id->command_set_2 & 0x0400) &&
				    (drive->id->cfs_enable_2 & 0x0400) &&
				    (drive->addressing == 1)) {
391 392
					u64 sectors = 0;
					u32 high = 0;
393
					u32 low = ide_read_24(drive);
394
					hwif->OUTB(drive->ctl|0x80, IDE_CONTROL_REG);
395
					high = ide_read_24(drive);
396

397
					sectors = ((u64)high << 24) | low;
398
					printk(", LBAsect=%llu, high=%d, low=%d",
399
					       (long long) sectors,
400 401
					       high, low);
				} else {
402
					u8 cur = hwif->INB(IDE_SELECT_REG);
403 404 405
					if (cur & 0x40) {	/* using LBA? */
						printk(", LBAsect=%ld", (unsigned long)
						 ((cur&0xf)<<24)
406 407 408
						 |(hwif->INB(IDE_HCYL_REG)<<16)
						 |(hwif->INB(IDE_LCYL_REG)<<8)
						 | hwif->INB(IDE_SECTOR_REG));
409 410
					} else {
						printk(", CHS=%d/%d/%d",
411 412
						 (hwif->INB(IDE_HCYL_REG)<<8) +
						  hwif->INB(IDE_LCYL_REG),
413
						  cur & 0xf,
414
						  hwif->INB(IDE_SECTOR_REG));
415 416 417
					}
				}
				if (HWGROUP(drive) && HWGROUP(drive)->rq)
418
					printk(", sector=%llu", (unsigned long long)HWGROUP(drive)->rq->sector);
419 420 421 422 423 424 425 426 427
			}
		}
#endif	/* FANCY_STATUS_DUMPS */
		printk("\n");
	}
	local_irq_restore(flags);
	return err;
}

428 429
EXPORT_SYMBOL(ide_dump_status);

430 431
static int ide_open (struct inode * inode, struct file * filp)
{
432
	return -ENXIO;
433 434
}

435 436
static spinlock_t drives_lock = SPIN_LOCK_UNLOCKED;
static spinlock_t drivers_lock = SPIN_LOCK_UNLOCKED;
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
static LIST_HEAD(drivers);

/* Iterator */
static void *m_start(struct seq_file *m, loff_t *pos)
{
	struct list_head *p;
	loff_t l = *pos;
	spin_lock(&drivers_lock);
	list_for_each(p, &drivers)
		if (!l--)
			return list_entry(p, ide_driver_t, drivers);
	return NULL;
}
static void *m_next(struct seq_file *m, void *v, loff_t *pos)
{
	struct list_head *p = ((ide_driver_t *)v)->drivers.next;
	(*pos)++;
	return p==&drivers ? NULL : list_entry(p, ide_driver_t, drivers);
}
static void m_stop(struct seq_file *m, void *v)
{
	spin_unlock(&drivers_lock);
}
static int show_driver(struct seq_file *m, void *v)
{
	ide_driver_t *driver = v;
	seq_printf(m, "%s version %s\n", driver->name, driver->version);
	return 0;
}
struct seq_operations ide_drivers_op = {
467 468 469 470
	.start	= m_start,
	.next	= m_next,
	.stop	= m_stop,
	.show	= show_driver
471
};
472

473
#ifdef CONFIG_PROC_FS
474 475
struct proc_dir_entry *proc_ide_root;

476 477 478 479 480 481
ide_proc_entry_t generic_subdriver_entries[] = {
	{ "capacity",	S_IFREG|S_IRUGO,	proc_ide_read_capacity,	NULL },
	{ NULL, 0, NULL, NULL }
};
#endif

482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
static struct resource* hwif_request_region(ide_hwif_t *hwif,
					    unsigned long addr, int num)
{
	struct resource *res;

	if (hwif->mmio)
		res = request_mem_region(addr, num, hwif->name);
	else
		res = request_region(addr, num, hwif->name);

	if (!res)
		printk(KERN_ERR "%s: %s resource 0x%lX-0x%lX not free.\n",
				hwif->name, hwif->mmio ? "MMIO" : "I/O",
				addr, addr+num-1);
	return res;
}
498 499 500 501

#define hwif_release_region(addr, num) \
	((hwif->mmio) ? release_mem_region((addr),(num)) : release_region((addr),(num)))

502
/**
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
 *	ide_hwif_request_regions - request resources for IDE
 *	@hwif: interface to use
 *
 *	Requests all the needed resources for an interface.
 *	Right now core IDE code does this work which is deeply wrong.
 *	MMIO leaves it to the controller driver,
 *	PIO will migrate this way over time.
 */
int ide_hwif_request_regions(ide_hwif_t *hwif)
{
	unsigned long addr;
	unsigned int i;

	if (hwif->mmio == 2)
		return 0;
	addr = hwif->io_ports[IDE_CONTROL_OFFSET];
	if (addr && !hwif_request_region(hwif, addr, 1))
		goto control_region_busy;
	hwif->straight8 = 0;
	addr = hwif->io_ports[IDE_DATA_OFFSET];
	if ((addr | 7) == hwif->io_ports[IDE_STATUS_OFFSET]) {
		if (!hwif_request_region(hwif, addr, 8))
			goto data_region_busy;
		hwif->straight8 = 1;
		return 0;
	}
	for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
		addr = hwif->io_ports[i];
		if (!hwif_request_region(hwif, addr, 1)) {
			while (--i)
				hwif_release_region(addr, 1);
			goto data_region_busy;
		}
	}
	return 0;

data_region_busy:
	addr = hwif->io_ports[IDE_CONTROL_OFFSET];
	if (addr)
		hwif_release_region(addr, 1);
control_region_busy:
	/* If any errors are return, we drop the hwif interface. */
	return -EBUSY;
}

EXPORT_SYMBOL(ide_hwif_request_regions);

/**
 *	ide_hwif_release_regions - free IDE resources
552 553 554 555 556 557 558 559
 *
 *	Note that we only release the standard ports,
 *	and do not even try to handle any extra ports
 *	allocated for weird IDE interface chipsets.
 *
 *	Note also that we don't yet handle mmio resources here. More
 *	importantly our caller should be doing this so we need to 
 *	restructure this as a helper function for drivers.
560
 */
561
void ide_hwif_release_regions(ide_hwif_t *hwif)
562
{
563 564 565 566
	u32 i = 0;

	if (hwif->mmio == 2)
		return;
567
	if (hwif->io_ports[IDE_CONTROL_OFFSET])
568 569 570 571 572
		hwif_release_region(hwif->io_ports[IDE_CONTROL_OFFSET], 1);
	if (hwif->straight8) {
		hwif_release_region(hwif->io_ports[IDE_DATA_OFFSET], 8);
		return;
	}
573 574
	for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++)
		if (hwif->io_ports[i])
575
			hwif_release_region(hwif->io_ports[i], 1);
576 577
}

578
EXPORT_SYMBOL(ide_hwif_release_regions);
579 580 581

extern void init_hwif_data(unsigned int index);

582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
/**
 *	ide_unregister		-	free an ide interface
 *	@index: index of interface (will change soon to a pointer)
 *
 *	Perform the final unregister of an IDE interface. At the moment
 *	we don't refcount interfaces so this will also get split up.
 *
 *	Locking:
 *	The caller must not hold the IDE locks
 *	The drive present/vanishing is not yet properly locked
 *	Take care with the callbacks. These have been split to avoid
 *	deadlocking the IDE layer. The shutdown callback is called
 *	before we take the lock and free resources. It is up to the
 *	caller to be sure there is no pending I/O here, and that
 *	the interfce will not be reopened (present/vanishing locking
 *	isnt yet done btw). After we commit to the final kill we
 *	call the cleanup callback with the ide locks held.
 *
 *	Unregister restores the hwif structures to the default state.
 *	This is raving bonkers.
 */
 
604 605
void ide_unregister (unsigned int index)
{
Alan Cox's avatar
Alan Cox committed
606
	ide_drive_t *drive;
607 608 609 610 611 612
	ide_hwif_t *hwif, *g;
	ide_hwgroup_t *hwgroup;
	int irq_count = 0, unit, i;
	ide_hwif_t old_hwif;

	if (index >= MAX_HWIFS)
613 614
		BUG();
		
Alan Cox's avatar
Alan Cox committed
615 616 617 618
	BUG_ON(in_interrupt());
	BUG_ON(irqs_disabled());
	down(&ide_cfg_sem);
	spin_lock_irq(&ide_lock);
619 620 621 622 623 624 625
	hwif = &ide_hwifs[index];
	if (!hwif->present)
		goto abort;
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		drive = &hwif->drives[unit];
		if (!drive->present)
			continue;
626
		if (drive->usage || DRIVER(drive)->busy)
627
			goto abort;
628
		drive->dead = 1;
629 630 631
	}
	hwif->present = 0;
	
Alan Cox's avatar
Alan Cox committed
632
	spin_unlock_irq(&ide_lock);
633 634 635 636 637

	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		drive = &hwif->drives[unit];
		if (!drive->present)
			continue;
Alan Cox's avatar
Alan Cox committed
638
		DRIVER(drive)->cleanup(drive);
639 640
	}
	
641
#ifdef CONFIG_PROC_FS
Alexander Viro's avatar
Alexander Viro committed
642
	destroy_proc_ide_drives(hwif);
643 644
#endif

645
	hwgroup = hwif->hwgroup;
646 647 648 649 650 651 652 653 654 655
	/*
	 * free the irq if we were the only hwif using it
	 */
	g = hwgroup->hwif;
	do {
		if (g->irq == hwif->irq)
			++irq_count;
		g = g->next;
	} while (g != hwgroup->hwif);
	if (irq_count == 1)
656
		free_irq(hwif->irq, hwgroup);
657

Alan Cox's avatar
Alan Cox committed
658
	spin_lock_irq(&ide_lock);
659 660 661 662 663
	/*
	 * Note that we only release the standard ports,
	 * and do not even try to handle any extra ports
	 * allocated for weird IDE interface chipsets.
	 */
664
	ide_hwif_release_regions(hwif);
665 666 667 668 669 670 671

	/*
	 * Remove us from the hwgroup, and free
	 * the hwgroup if we were the only member
	 */
	for (i = 0; i < MAX_DRIVES; ++i) {
		drive = &hwif->drives[i];
672 673 674
		if (drive->devfs_name[0] != '\0') {
			devfs_remove(drive->devfs_name);
			drive->devfs_name[0] = '\0';
675 676 677
		}
		if (!drive->present)
			continue;
Alan Cox's avatar
Alan Cox committed
678 679 680
		if (drive == drive->next) {
			/* special case: last drive from hwgroup. */
			BUG_ON(hwgroup->drive != drive);
681
			hwgroup->drive = NULL;
Alan Cox's avatar
Alan Cox committed
682 683 684 685 686 687 688 689 690 691 692 693 694
		} else {
			ide_drive_t *walk;

			walk = hwgroup->drive;
			while (walk->next != drive)
				walk = walk->next;
			walk->next = drive->next;
			if (hwgroup->drive == drive) {
				hwgroup->drive = drive->next;
				hwgroup->hwif = HWIF(hwgroup->drive);
			}
		}
		BUG_ON(hwgroup->drive == drive);
695 696 697 698 699
		if (drive->id != NULL) {
			kfree(drive->id);
			drive->id = NULL;
		}
		drive->present = 0;
700 701
		/* Messed up locking ... */
		spin_unlock_irq(&ide_lock);
702
		blk_cleanup_queue(drive->queue);
703
		device_unregister(&drive->gendev);
704
		down(&drive->gendev_rel_sem);
705
		spin_lock_irq(&ide_lock);
706
		drive->queue = NULL;
707
	}
Alan Cox's avatar
Alan Cox committed
708 709
	if (hwif->next == hwif) {
		BUG_ON(hwgroup->hwif != hwif);
710
		kfree(hwgroup);
Alan Cox's avatar
Alan Cox committed
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
	} else {
		/* There is another interface in hwgroup.
		 * Unlink us, and set hwgroup->drive and ->hwif to
		 * something sane.
		 */
		g = hwgroup->hwif;
		while (g->next != hwif)
			g = g->next;
		g->next = hwif->next;
		if (hwgroup->hwif == hwif) {
			/* Chose a random hwif for hwgroup->hwif.
			 * It's guaranteed that there are no drives
			 * left in the hwgroup.
			 */
			BUG_ON(hwgroup->drive != NULL);
			hwgroup->hwif = g;
		}
		BUG_ON(hwgroup->hwif == hwif);
	}
730

731 732 733
	/* More messed up locking ... */
	spin_unlock_irq(&ide_lock);
	device_unregister(&hwif->gendev);
734
	down(&hwif->gendev_rel_sem);
735 736 737 738 739 740 741 742 743 744 745

	/*
	 * Remove us from the kernel's knowledge
	 */
	blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS);
	for (i = 0; i < MAX_DRIVES; i++) {
		struct gendisk *disk = hwif->drives[i].disk;
		hwif->drives[i].disk = NULL;
		put_disk(disk);
	}
	unregister_blkdev(hwif->major, hwif->name);
746 747
	spin_lock_irq(&ide_lock);

748
#if !defined(CONFIG_DMA_NONPCI)
749 750
	if (hwif->dma_base) {
		(void) ide_release_dma(hwif);
751

752
		hwif->dma_base = 0;
753 754 755 756 757 758
		hwif->dma_master = 0;
		hwif->dma_command = 0;
		hwif->dma_vendor1 = 0;
		hwif->dma_status = 0;
		hwif->dma_vendor3 = 0;
		hwif->dma_prdtable = 0;
759
	}
760
#endif /* !(CONFIG_DMA_NONPCI) */
761 762 763 764
	old_hwif			= *hwif;
	init_hwif_data(index);	/* restore hwif data to pristine status */
	hwif->hwgroup			= old_hwif.hwgroup;

765 766
	hwif->gendev.parent		= old_hwif.gendev.parent;

767 768 769 770 771 772 773 774 775 776 777 778 779 780
	hwif->proc			= old_hwif.proc;

	hwif->major			= old_hwif.major;
//	hwif->index			= old_hwif.index;
//	hwif->channel			= old_hwif.channel;
	hwif->straight8			= old_hwif.straight8;
	hwif->bus_state			= old_hwif.bus_state;

	hwif->atapi_dma			= old_hwif.atapi_dma;
	hwif->ultra_mask		= old_hwif.ultra_mask;
	hwif->mwdma_mask		= old_hwif.mwdma_mask;
	hwif->swdma_mask		= old_hwif.swdma_mask;

	hwif->chipset			= old_hwif.chipset;
781
	hwif->hold			= old_hwif.hold;
782

783
#ifdef CONFIG_BLK_DEV_IDEPCI
784 785
	hwif->pci_dev			= old_hwif.pci_dev;
	hwif->cds			= old_hwif.cds;
786
#endif /* CONFIG_BLK_DEV_IDEPCI */
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834

#if 0
	hwif->hwifops			= old_hwif.hwifops;
#else
	hwif->identify			= old_hwif.identify;
	hwif->tuneproc			= old_hwif.tuneproc;
	hwif->speedproc			= old_hwif.speedproc;
	hwif->selectproc		= old_hwif.selectproc;
	hwif->reset_poll		= old_hwif.reset_poll;
	hwif->pre_reset			= old_hwif.pre_reset;
	hwif->resetproc			= old_hwif.resetproc;
	hwif->intrproc			= old_hwif.intrproc;
	hwif->maskproc			= old_hwif.maskproc;
	hwif->quirkproc			= old_hwif.quirkproc;
	hwif->busproc			= old_hwif.busproc;
#endif

#if 0
	hwif->pioops			= old_hwif.pioops;
#else
	hwif->ata_input_data		= old_hwif.ata_input_data;
	hwif->ata_output_data		= old_hwif.ata_output_data;
	hwif->atapi_input_bytes		= old_hwif.atapi_input_bytes;
	hwif->atapi_output_bytes	= old_hwif.atapi_output_bytes;
#endif

#if 0
	hwif->dmaops			= old_hwif.dmaops;
#else
	hwif->ide_dma_read		= old_hwif.ide_dma_read;
	hwif->ide_dma_write		= old_hwif.ide_dma_write;
	hwif->ide_dma_begin		= old_hwif.ide_dma_begin;
	hwif->ide_dma_end		= old_hwif.ide_dma_end;
	hwif->ide_dma_check		= old_hwif.ide_dma_check;
	hwif->ide_dma_on		= old_hwif.ide_dma_on;
	hwif->ide_dma_off_quietly	= old_hwif.ide_dma_off_quietly;
	hwif->ide_dma_test_irq		= old_hwif.ide_dma_test_irq;
	hwif->ide_dma_host_on		= old_hwif.ide_dma_host_on;
	hwif->ide_dma_host_off		= old_hwif.ide_dma_host_off;
	hwif->ide_dma_verbose		= old_hwif.ide_dma_verbose;
	hwif->ide_dma_lostirq		= old_hwif.ide_dma_lostirq;
	hwif->ide_dma_timeout		= old_hwif.ide_dma_timeout;
#endif

#if 0
	hwif->iops			= old_hwif.iops;
#else
	hwif->OUTB		= old_hwif.OUTB;
Alan Cox's avatar
Alan Cox committed
835
	hwif->OUTBSYNC		= old_hwif.OUTBSYNC;
836 837 838 839 840 841 842 843 844 845 846 847 848 849
	hwif->OUTW		= old_hwif.OUTW;
	hwif->OUTL		= old_hwif.OUTL;
	hwif->OUTSW		= old_hwif.OUTSW;
	hwif->OUTSL		= old_hwif.OUTSL;

	hwif->INB		= old_hwif.INB;
	hwif->INW		= old_hwif.INW;
	hwif->INL		= old_hwif.INL;
	hwif->INSW		= old_hwif.INSW;
	hwif->INSL		= old_hwif.INSL;
#endif

	hwif->mmio			= old_hwif.mmio;
	hwif->rqsize			= old_hwif.rqsize;
850
	hwif->no_lba48			= old_hwif.no_lba48;
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
#ifndef CONFIG_BLK_DEV_IDECS
	hwif->irq			= old_hwif.irq;
#endif /* CONFIG_BLK_DEV_IDECS */

	hwif->dma_base			= old_hwif.dma_base;
	hwif->dma_master		= old_hwif.dma_master;
	hwif->dma_command		= old_hwif.dma_command;
	hwif->dma_vendor1		= old_hwif.dma_vendor1;
	hwif->dma_status		= old_hwif.dma_status;
	hwif->dma_vendor3		= old_hwif.dma_vendor3;
	hwif->dma_prdtable		= old_hwif.dma_prdtable;

	hwif->dma_extra			= old_hwif.dma_extra;
	hwif->config_data		= old_hwif.config_data;
	hwif->select_data		= old_hwif.select_data;
	hwif->autodma			= old_hwif.autodma;
	hwif->udma_four			= old_hwif.udma_four;
	hwif->no_dsc			= old_hwif.no_dsc;

	hwif->hwif_data			= old_hwif.hwif_data;
871
abort:
Alan Cox's avatar
Alan Cox committed
872 873
	spin_unlock_irq(&ide_lock);
	up(&ide_cfg_sem);
874 875
}

876 877
EXPORT_SYMBOL(ide_unregister);

Adam Belay's avatar
Adam Belay committed
878

879 880 881 882 883 884 885 886 887 888 889 890 891
/**
 *	ide_setup_ports 	-	set up IDE interface ports
 *	@hw: register descriptions
 *	@base: base register
 *	@offsets: table of register offsets
 *	@ctrl: control register
 *	@ack_irq: IRQ ack
 *	@irq: interrupt lie
 *
 *	Setup hw_regs_t structure described by parameters.  You
 *	may set up the hw structure yourself OR use this routine to
 *	do it for you. This is basically a helper
 *
892
 */
893
 
894
void ide_setup_ports (	hw_regs_t *hw,
Alan Cox's avatar
Alan Cox committed
895 896
			unsigned long base, int *offsets,
			unsigned long ctrl, unsigned long intr,
897 898 899 900 901
			ide_ack_intr_t *ack_intr,
/*
 *			ide_io_ops_t *iops,
 */
			int irq)
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
{
	int i;

	for (i = 0; i < IDE_NR_PORTS; i++) {
		if (offsets[i] == -1) {
			switch(i) {
				case IDE_CONTROL_OFFSET:
					hw->io_ports[i] = ctrl;
					break;
#if defined(CONFIG_AMIGA) || defined(CONFIG_MAC)
				case IDE_IRQ_OFFSET:
					hw->io_ports[i] = intr;
					break;
#endif /* (CONFIG_AMIGA) || (CONFIG_MAC) */
				default:
					hw->io_ports[i] = 0;
					break;
			}
		} else {
			hw->io_ports[i] = base + offsets[i];
		}
	}
	hw->irq = irq;
	hw->dma = NO_DMA;
	hw->ack_intr = ack_intr;
927 928 929
/*
 *	hw->iops = iops;
 */
930 931
}

932 933
EXPORT_SYMBOL(ide_setup_ports);

934
/*
Alan Cox's avatar
Alan Cox committed
935
 * Register an IDE interface, specifying exactly the registers etc
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
 * Set init=1 iff calling before probes have taken place.
 */
int ide_register_hw (hw_regs_t *hw, ide_hwif_t **hwifp)
{
	int index, retry = 1;
	ide_hwif_t *hwif;

	do {
		for (index = 0; index < MAX_HWIFS; ++index) {
			hwif = &ide_hwifs[index];
			if (hwif->hw.io_ports[IDE_DATA_OFFSET] == hw->io_ports[IDE_DATA_OFFSET])
				goto found;
		}
		for (index = 0; index < MAX_HWIFS; ++index) {
			hwif = &ide_hwifs[index];
951 952
			if (hwif->hold)
				continue;
953 954 955 956 957 958 959 960 961 962 963
			if ((!hwif->present && !hwif->mate && !initializing) ||
			    (!hwif->hw.io_ports[IDE_DATA_OFFSET] && initializing))
				goto found;
		}
		for (index = 0; index < MAX_HWIFS; index++)
			ide_unregister(index);
	} while (retry--);
	return -1;
found:
	if (hwif->present)
		ide_unregister(index);
964 965
	else if (!hwif->hold)
		init_hwif_data(index);
966 967 968 969 970 971 972 973 974
	if (hwif->present)
		return -1;
	memcpy(&hwif->hw, hw, sizeof(*hw));
	memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->hw.io_ports));
	hwif->irq = hw->irq;
	hwif->noprobe = 0;
	hwif->chipset = hw->chipset;

	if (!initializing) {
975
		probe_hwif_init(hwif);
976 977 978 979 980 981 982 983 984
		create_proc_ide_interfaces();
	}

	if (hwifp)
		*hwifp = hwif;

	return (initializing || hwif->present) ? index : -1;
}

985 986
EXPORT_SYMBOL(ide_register_hw);

Alan Cox's avatar
Alan Cox committed
987 988 989 990 991 992 993
/*
 *	Locks for IDE setting functionality
 */

DECLARE_MUTEX(ide_setting_sem);
EXPORT_SYMBOL(ide_setting_sem);

994
/**
Alan Cox's avatar
Alan Cox committed
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
 *	ide_add_setting	-	add an ide setting option
 *	@drive: drive to use
 *	@name: setting name
 *	@rw: true if the function is read write
 *	@read_ioctl: function to call on read
 *	@write_ioctl: function to call on write
 *	@data_type: type of data
 *	@min: range minimum
 *	@max: range maximum
 *	@mul_factor: multiplication scale
 *	@div_factor: divison scale
 *	@data: private data field
 *	@set: setting
1008
 *
Alan Cox's avatar
Alan Cox committed
1009 1010 1011 1012 1013 1014 1015 1016 1017
 *	Removes the setting named from the device if it is present.
 *	The function takes the settings_lock to protect against 
 *	parallel changes. This function must not be called from IRQ
 *	context. Returns 0 on success or -1 on failure.
 *
 *	BUGS: This code is seriously over-engineered. There is also
 *	magic about how the driver specific features are setup. If
 *	a driver is attached we assume the driver settings are auto
 *	remove.
1018 1019
 */
 
Alan Cox's avatar
Alan Cox committed
1020
int ide_add_setting (ide_drive_t *drive, const char *name, int rw, int read_ioctl, int write_ioctl, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set)
1021 1022 1023
{
	ide_settings_t **p = (ide_settings_t **) &drive->settings, *setting = NULL;

Alan Cox's avatar
Alan Cox committed
1024
	down(&ide_setting_sem);
1025 1026 1027 1028 1029 1030 1031
	while ((*p) && strcmp((*p)->name, name) < 0)
		p = &((*p)->next);
	if ((setting = kmalloc(sizeof(*setting), GFP_KERNEL)) == NULL)
		goto abort;
	memset(setting, 0, sizeof(*setting));
	if ((setting->name = kmalloc(strlen(name) + 1, GFP_KERNEL)) == NULL)
		goto abort;
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
	strcpy(setting->name, name);
	setting->rw = rw;
	setting->read_ioctl = read_ioctl;
	setting->write_ioctl = write_ioctl;
	setting->data_type = data_type;
	setting->min = min;
	setting->max = max;
	setting->mul_factor = mul_factor;
	setting->div_factor = div_factor;
	setting->data = data;
	setting->set = set;
Alan Cox's avatar
Alan Cox committed
1043
	
1044
	setting->next = *p;
Alan Cox's avatar
Alan Cox committed
1045
	if (drive->driver != &idedefault_driver)
1046 1047
		setting->auto_remove = 1;
	*p = setting;
Alan Cox's avatar
Alan Cox committed
1048 1049
	up(&ide_setting_sem);
	return 0;
1050
abort:
Alan Cox's avatar
Alan Cox committed
1051
	up(&ide_setting_sem);
1052 1053
	if (setting)
		kfree(setting);
Alan Cox's avatar
Alan Cox committed
1054
	return -1;
1055 1056
}

1057 1058
EXPORT_SYMBOL(ide_add_setting);

1059
/**
Alan Cox's avatar
Alan Cox committed
1060 1061 1062
 *	__ide_remove_setting	-	remove an ide setting option
 *	@drive: drive to use
 *	@name: setting name
1063
 *
Alan Cox's avatar
Alan Cox committed
1064 1065
 *	Removes the setting named from the device if it is present.
 *	The caller must hold the setting semaphore.
1066 1067
 */
 
Alan Cox's avatar
Alan Cox committed
1068
static void __ide_remove_setting (ide_drive_t *drive, char *name)
1069
{
Alan Cox's avatar
Alan Cox committed
1070 1071 1072
	ide_settings_t **p, *setting;

	p = (ide_settings_t **) &drive->settings;
1073 1074 1075 1076 1077

	while ((*p) && strcmp((*p)->name, name))
		p = &((*p)->next);
	if ((setting = (*p)) == NULL)
		return;
Alan Cox's avatar
Alan Cox committed
1078

1079
	(*p) = setting->next;
Alan Cox's avatar
Alan Cox committed
1080
	
1081 1082 1083 1084
	kfree(setting->name);
	kfree(setting);
}

Alan Cox's avatar
Alan Cox committed
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
/**
 *	ide_remove_setting	-	remove an ide setting option
 *	@drive: drive to use
 *	@name: setting name
 *
 *	Removes the setting named from the device if it is present.
 *	The function takes the settings_lock to protect against 
 *	parallel changes. This function must not be called from IRQ
 *	context.
 */
 
void ide_remove_setting (ide_drive_t *drive, char *name)
{
	down(&ide_setting_sem);
	__ide_remove_setting(drive, name);
	up(&ide_setting_sem);
}

1103 1104
EXPORT_SYMBOL(ide_remove_setting);

1105
/**
Alan Cox's avatar
Alan Cox committed
1106 1107 1108
 *	ide_find_setting_by_ioctl	-	find a drive specific ioctl
 *	@drive: drive to scan
 *	@cmd: ioctl command to handle
1109
 *
Alan Cox's avatar
Alan Cox committed
1110 1111 1112
 *	Scan's the device setting table for a matching entry and returns
 *	this or NULL if no entry is found. The caller must hold the
 *	setting semaphore
1113 1114
 */
 
1115 1116 1117 1118 1119 1120 1121 1122 1123
static ide_settings_t *ide_find_setting_by_ioctl (ide_drive_t *drive, int cmd)
{
	ide_settings_t *setting = drive->settings;

	while (setting) {
		if (setting->read_ioctl == cmd || setting->write_ioctl == cmd)
			break;
		setting = setting->next;
	}
Alan Cox's avatar
Alan Cox committed
1124
	
1125 1126 1127
	return setting;
}

1128
/**
Alan Cox's avatar
Alan Cox committed
1129 1130 1131
 *	ide_find_setting_by_name	-	find a drive specific setting
 *	@drive: drive to scan
 *	@name: setting name
1132
 *
Alan Cox's avatar
Alan Cox committed
1133 1134 1135
 *	Scan's the device setting table for a matching entry and returns
 *	this or NULL if no entry is found. The caller must hold the
 *	setting semaphore
1136 1137
 */
 
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
ide_settings_t *ide_find_setting_by_name (ide_drive_t *drive, char *name)
{
	ide_settings_t *setting = drive->settings;

	while (setting) {
		if (strcmp(setting->name, name) == 0)
			break;
		setting = setting->next;
	}
	return setting;
}

1150
/**
Alan Cox's avatar
Alan Cox committed
1151 1152
 *	auto_remove_settings	-	remove driver specific settings
 *	@drive: drive
1153
 *
Alan Cox's avatar
Alan Cox committed
1154 1155
 *	Automatically remove all the driver specific settings for this
 *	drive. This function may sleep and must not be called from IRQ
1156
 *	context. The caller must hold ide_setting_sem.
1157 1158
 */
 
1159 1160 1161 1162 1163 1164 1165
static void auto_remove_settings (ide_drive_t *drive)
{
	ide_settings_t *setting;
repeat:
	setting = drive->settings;
	while (setting) {
		if (setting->auto_remove) {
Alan Cox's avatar
Alan Cox committed
1166
			__ide_remove_setting(drive, setting->name);
1167 1168 1169 1170 1171 1172
			goto repeat;
		}
		setting = setting->next;
	}
}

Alan Cox's avatar
Alan Cox committed
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
/**
 *	ide_read_setting	-	read an IDE setting
 *	@drive: drive to read from
 *	@setting: drive setting
 *
 *	Read a drive setting and return the value. The caller
 *	must hold the ide_setting_sem when making this call.
 *
 *	BUGS: the data return and error are the same return value
 *	so an error -EINVAL and true return of the same value cannot
 *	be told apart
 */
 
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
int ide_read_setting (ide_drive_t *drive, ide_settings_t *setting)
{
	int		val = -EINVAL;
	unsigned long	flags;

	if ((setting->rw & SETTING_READ)) {
		spin_lock_irqsave(&ide_lock, flags);
		switch(setting->data_type) {
			case TYPE_BYTE:
				val = *((u8 *) setting->data);
				break;
			case TYPE_SHORT:
				val = *((u16 *) setting->data);
				break;
			case TYPE_INT:
			case TYPE_INTA:
				val = *((u32 *) setting->data);
				break;
		}
		spin_unlock_irqrestore(&ide_lock, flags);
	}
	return val;
}

int ide_spin_wait_hwgroup (ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup = HWGROUP(drive);
	unsigned long timeout = jiffies + (3 * HZ);

	spin_lock_irq(&ide_lock);

	while (hwgroup->busy) {
		unsigned long lflags;
		spin_unlock_irq(&ide_lock);
		local_irq_set(lflags);
		if (time_after(jiffies, timeout)) {
			local_irq_restore(lflags);
1223
			printk(KERN_ERR "%s: channel busy\n", drive->name);
1224 1225 1226 1227 1228 1229 1230 1231
			return -EBUSY;
		}
		local_irq_restore(lflags);
		spin_lock_irq(&ide_lock);
	}
	return 0;
}

1232 1233
EXPORT_SYMBOL(ide_spin_wait_hwgroup);

Alan Cox's avatar
Alan Cox committed
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
/**
 *	ide_write_setting	-	read an IDE setting
 *	@drive: drive to read from
 *	@setting: drive setting
 *	@val: value
 *
 *	Write a drive setting if it is possible. The caller
 *	must hold the ide_setting_sem when making this call.
 *
 *	BUGS: the data return and error are the same return value
 *	so an error -EINVAL and true return of the same value cannot
 *	be told apart
 *
 *	FIXME:  This should be changed to enqueue a special request
 *	to the driver to change settings, and then wait on a sema for completion.
 *	The current scheme of polling is kludgy, though safe enough.
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
 */
int ide_write_setting (ide_drive_t *drive, ide_settings_t *setting, int val)
{
	int i;
	u32 *p;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;
	if (!(setting->rw & SETTING_WRITE))
		return -EPERM;
	if (val < setting->min || val > setting->max)
		return -EINVAL;
	if (setting->set)
		return setting->set(drive, val);
	if (ide_spin_wait_hwgroup(drive))
		return -EBUSY;
	switch (setting->data_type) {
		case TYPE_BYTE:
			*((u8 *) setting->data) = val;
			break;
		case TYPE_SHORT:
			*((u16 *) setting->data) = val;
			break;
		case TYPE_INT:
			*((u32 *) setting->data) = val;
			break;
		case TYPE_INTA:
			p = (u32 *) setting->data;
			for (i = 0; i < 1 << PARTN_BITS; i++, p++)
				*p = val;
			break;
	}
	spin_unlock_irq(&ide_lock);
	return 0;
}

1286 1287
EXPORT_SYMBOL(ide_write_setting);

1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
static int set_io_32bit(ide_drive_t *drive, int arg)
{
	drive->io_32bit = arg;
#ifdef CONFIG_BLK_DEV_DTC2278
	if (HWIF(drive)->chipset == ide_dtc2278)
		HWIF(drive)->drives[!drive->select.b.unit].io_32bit = arg;
#endif /* CONFIG_BLK_DEV_DTC2278 */
	return 0;
}

static int set_using_dma (ide_drive_t *drive, int arg)
{
1300
#ifdef CONFIG_BLK_DEV_IDEDMA
1301 1302 1303
	if (!drive->id || !(drive->id->capability & 1))
		return -EPERM;
	if (HWIF(drive)->ide_dma_check == NULL)
1304
		return -EPERM;
1305
	if (arg) {
Alan Cox's avatar
Alan Cox committed
1306
		if (HWIF(drive)->ide_dma_check(drive)) return -EIO;
1307 1308
		if (HWIF(drive)->ide_dma_on(drive)) return -EIO;
	} else {
1309 1310
		if (__ide_dma_off(drive))
			return -EIO;
1311
	}
1312
	return 0;
1313 1314 1315
#else
	return -EPERM;
#endif
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
}

static int set_pio_mode (ide_drive_t *drive, int arg)
{
	struct request rq;

	if (!HWIF(drive)->tuneproc)
		return -ENOSYS;
	if (drive->special.b.set_tune)
		return -EBUSY;
	ide_init_drive_cmd(&rq);
1327
	drive->tune_req = (u8) arg;
1328
	drive->special.b.set_tune = 1;
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
	(void) ide_do_drive_cmd(drive, &rq, ide_wait);
	return 0;
}

static int set_xfer_rate (ide_drive_t *drive, int arg)
{
	int err = ide_wait_cmd(drive,
			WIN_SETFEATURES, (u8) arg,
			SETFEATURES_XFER, 0, NULL);

	if (!err && arg) {
1340
		ide_set_xfer_rate(drive, (u8) arg);
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
		ide_driveid_update(drive);
	}
	return err;
}

int ide_atapi_to_scsi (ide_drive_t *drive, int arg)
{
	if (drive->media == ide_disk) {
		drive->scsi = 0;
		return 0;
	}

Alan Cox's avatar
Alan Cox committed
1353 1354 1355
	if (DRIVER(drive)->cleanup(drive)) {
		drive->scsi = 0;
		return 0;
1356 1357 1358 1359
	}

	drive->scsi = (u8) arg;
	ata_attach(drive);
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
	return 0;
}

void ide_add_generic_settings (ide_drive_t *drive)
{
/*
 *			drive	setting name		read/write access				read ioctl		write ioctl		data type	min	max				mul_factor	div_factor	data pointer			set function
 */
	ide_add_setting(drive,	"io_32bit",		drive->no_io_32bit ? SETTING_READ : SETTING_RW,	HDIO_GET_32BIT,		HDIO_SET_32BIT,		TYPE_BYTE,	0,	1 + (SUPPORT_VLB_SYNC << 1),	1,		1,		&drive->io_32bit,		set_io_32bit);
	ide_add_setting(drive,	"keepsettings",		SETTING_RW,					HDIO_GET_KEEPSETTINGS,	HDIO_SET_KEEPSETTINGS,	TYPE_BYTE,	0,	1,				1,		1,		&drive->keep_settings,		NULL);
	ide_add_setting(drive,	"nice1",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	1,				1,		1,		&drive->nice1,			NULL);
	ide_add_setting(drive,	"pio_mode",		SETTING_WRITE,					-1,			HDIO_SET_PIO_MODE,	TYPE_BYTE,	0,	255,				1,		1,		NULL,				set_pio_mode);
	ide_add_setting(drive,	"unmaskirq",		drive->no_unmask ? SETTING_READ : SETTING_RW,	HDIO_GET_UNMASKINTR,	HDIO_SET_UNMASKINTR,	TYPE_BYTE,	0,	1,				1,		1,		&drive->unmask,			NULL);
	ide_add_setting(drive,	"using_dma",		SETTING_RW,					HDIO_GET_DMA,		HDIO_SET_DMA,		TYPE_BYTE,	0,	1,				1,		1,		&drive->using_dma,		set_using_dma);
	ide_add_setting(drive,	"init_speed",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	70,				1,		1,		&drive->init_speed,		NULL);
1375
	ide_add_setting(drive,	"current_speed",	SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	70,				1,		1,		&drive->current_speed,		set_xfer_rate);
1376
	ide_add_setting(drive,	"number",		SETTING_RW,					-1,			-1,			TYPE_BYTE,	0,	3,				1,		1,		&drive->dn,			NULL);
1377 1378
	if (drive->media != ide_disk)
		ide_add_setting(drive,	"ide-scsi",		SETTING_RW,					-1,		HDIO_SET_IDE_SCSI,		TYPE_BYTE,	0,	1,				1,		1,		&drive->scsi,			ide_atapi_to_scsi);
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
}

/*
 * Delay for *at least* 50ms.  As we don't know how much time is left
 * until the next tick occurs, we wait an extra tick to be safe.
 * This is used only during the probing/polling for drives at boot time.
 *
 * However, its usefullness may be needed in other places, thus we export it now.
 * The future may change this to a millisecond setable delay.
 */
void ide_delay_50ms (void)
{
#ifndef CONFIG_BLK_DEV_IDECS
	mdelay(50);
#else
	__set_current_state(TASK_UNINTERRUPTIBLE);
Alan Cox's avatar
Alan Cox committed
1395
	schedule_timeout(1+HZ/20);
1396 1397 1398
#endif /* CONFIG_BLK_DEV_IDECS */
}

1399 1400
EXPORT_SYMBOL(ide_delay_50ms);

1401 1402 1403 1404 1405
int system_bus_clock (void)
{
	return((int) ((!system_bus_speed) ? ide_system_bus_speed() : system_bus_speed ));
}

1406 1407 1408 1409 1410 1411 1412 1413 1414
EXPORT_SYMBOL(system_bus_clock);

/*
 *	Locking is badly broken here - since way back.  That sucker is
 * root-only, but that's not an excuse...  The real question is what
 * exclusion rules do we want here.
 */
int ide_replace_subdriver (ide_drive_t *drive, const char *driver)
{
1415
	if (!drive->present || drive->usage || drive->dead)
1416
		goto abort;
Alan Cox's avatar
Alan Cox committed
1417
	if (DRIVER(drive)->cleanup(drive))
1418
		goto abort;
1419
	strlcpy(drive->driver_req, driver, sizeof(drive->driver_req));
1420 1421 1422 1423 1424 1425 1426 1427 1428
	if (ata_attach(drive)) {
		spin_lock(&drives_lock);
		list_del_init(&drive->list);
		spin_unlock(&drives_lock);
		drive->driver_req[0] = 0;
		ata_attach(drive);
	} else {
		drive->driver_req[0] = 0;
	}
Alan Cox's avatar
Alan Cox committed
1429
	if (DRIVER(drive)!= &idedefault_driver && !strcmp(DRIVER(drive)->name, driver))
1430 1431 1432 1433 1434 1435 1436
		return 0;
abort:
	return 1;
}

EXPORT_SYMBOL(ide_replace_subdriver);

1437
int ata_attach(ide_drive_t *drive)
1438
{
1439
	struct list_head *p;
1440
	spin_lock(&drivers_lock);
1441 1442
	list_for_each(p, &drivers) {
		ide_driver_t *driver = list_entry(p, ide_driver_t, drivers);
1443
		if (!try_module_get(driver->owner))
1444 1445
			continue;
		spin_unlock(&drivers_lock);
1446
		if (driver->attach(drive) == 0) {
1447
			module_put(driver->owner);
1448
			drive->gendev.driver = &driver->gen_driver;
1449
			return 0;
1450
		}
1451
		spin_lock(&drivers_lock);
1452
		module_put(driver->owner);
1453
	}
Alan Cox's avatar
Alan Cox committed
1454
	drive->gendev.driver = &idedefault_driver.gen_driver;
1455
	spin_unlock(&drivers_lock);
Alan Cox's avatar
Alan Cox committed
1456 1457
	if(idedefault_driver.attach(drive) != 0)
		panic("ide: default attach failed");
1458
	return 1;
1459 1460
}

1461 1462
EXPORT_SYMBOL(ata_attach);

1463
static int generic_ide_suspend(struct device *dev, u32 state)
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
{
	ide_drive_t *drive = dev->driver_data;
	struct request rq;
	struct request_pm_state rqpm;
	ide_task_t args;

	memset(&rq, 0, sizeof(rq));
	memset(&rqpm, 0, sizeof(rqpm));
	memset(&args, 0, sizeof(args));
	rq.flags = REQ_PM_SUSPEND;
	rq.special = &args;
	rq.pm = &rqpm;
	rqpm.pm_step = ide_pm_state_start_suspend;
	rqpm.pm_state = state;

	return ide_do_drive_cmd(drive, &rq, ide_wait);
}

1482
static int generic_ide_resume(struct device *dev)
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
{
	ide_drive_t *drive = dev->driver_data;
	struct request rq;
	struct request_pm_state rqpm;
	ide_task_t args;

	memset(&rq, 0, sizeof(rq));
	memset(&rqpm, 0, sizeof(rqpm));
	memset(&args, 0, sizeof(args));
	rq.flags = REQ_PM_RESUME;
	rq.special = &args;
	rq.pm = &rqpm;
	rqpm.pm_step = ide_pm_state_start_resume;
	rqpm.pm_state = 0;

	return ide_do_drive_cmd(drive, &rq, ide_head_wait);
}

1501 1502
int generic_ide_ioctl(struct block_device *bdev, unsigned int cmd,
			unsigned long arg)
1503
{
1504
	ide_drive_t *drive = bdev->bd_disk->private_data;
1505
	ide_settings_t *setting;
Alexander Viro's avatar
Alexander Viro committed
1506
	int err = 0;
1507

Alan Cox's avatar
Alan Cox committed
1508
	down(&ide_setting_sem);
1509 1510 1511
	if ((setting = ide_find_setting_by_ioctl(drive, cmd)) != NULL) {
		if (cmd == setting->read_ioctl) {
			err = ide_read_setting(drive, setting);
Alan Cox's avatar
Alan Cox committed
1512
			up(&ide_setting_sem);
1513 1514
			return err >= 0 ? put_user(err, (long *) arg) : err;
		} else {
1515
			if (bdev != bdev->bd_contains)
Alan Cox's avatar
Alan Cox committed
1516 1517 1518 1519 1520
				err = -EINVAL;
			else
				err = ide_write_setting(drive, setting, arg);
			up(&ide_setting_sem);
			return err;
1521 1522
		}
	}
Alan Cox's avatar
Alan Cox committed
1523
	up(&ide_setting_sem);
1524 1525 1526 1527 1528

	switch (cmd) {
		case HDIO_GETGEO:
		{
			struct hd_geometry *loc = (struct hd_geometry *) arg;
1529
			u16 bios_cyl = drive->bios_cyl; /* truncate */
1530
			if (!loc || (drive->media != ide_disk && drive->media != ide_floppy)) return -EINVAL;
1531 1532 1533
			if (put_user(drive->bios_head, (u8 *) &loc->heads)) return -EFAULT;
			if (put_user(drive->bios_sect, (u8 *) &loc->sectors)) return -EFAULT;
			if (put_user(bios_cyl, (u16 *) &loc->cylinders)) return -EFAULT;
1534
			if (put_user((unsigned)get_start_sect(bdev),
1535 1536 1537 1538 1539 1540
				(unsigned long *) &loc->start)) return -EFAULT;
			return 0;
		}

		case HDIO_OBSOLETE_IDENTITY:
		case HDIO_GET_IDENTITY:
1541
			if (bdev != bdev->bd_contains)
1542
				return -EINVAL;
Alan Cox's avatar
Alan Cox committed
1543
			if (drive->id_read == 0)
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
				return -ENOMSG;
			if (copy_to_user((char *)arg, (char *)drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142))
				return -EFAULT;
			return 0;

		case HDIO_GET_NICE:
			return put_user(drive->dsc_overlap	<<	IDE_NICE_DSC_OVERLAP	|
					drive->atapi_overlap	<<	IDE_NICE_ATAPI_OVERLAP	|
					drive->nice0		<< 	IDE_NICE_0		|
					drive->nice1		<<	IDE_NICE_1		|
					drive->nice2		<<	IDE_NICE_2,
					(long *) arg);

#ifdef CONFIG_IDE_TASK_IOCTL
		case HDIO_DRIVE_TASKFILE:
		        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
				return -EACCES;
			switch(drive->media) {
				case ide_disk:
1563
					return ide_taskfile_ioctl(drive, cmd, arg);
1564 1565 1566 1567 1568 1569
				default:
					return -ENOMSG;
			}
#endif /* CONFIG_IDE_TASK_IOCTL */

		case HDIO_DRIVE_CMD:
1570
			if (!capable(CAP_SYS_RAWIO))
1571
				return -EACCES;
1572
			return ide_cmd_ioctl(drive, cmd, arg);
1573 1574

		case HDIO_DRIVE_TASK:
1575
			if (!capable(CAP_SYS_RAWIO))
1576
				return -EACCES;
1577
			return ide_task_ioctl(drive, cmd, arg);
1578 1579 1580

		case HDIO_SCAN_HWIF:
		{
1581
			hw_regs_t hw;
1582
			int args[3];
Alan Cox's avatar
Alan Cox committed
1583
			if (!capable(CAP_SYS_RAWIO)) return -EACCES;
1584 1585
			if (copy_from_user(args, (void *)arg, 3 * sizeof(int)))
				return -EFAULT;
1586 1587 1588 1589
			ide_init_hwif_ports(&hw, (unsigned long) args[0],
					    (unsigned long) args[1], NULL);
			hw.irq = args[2];
			if (ide_register_hw(&hw, NULL) == -1)
1590 1591 1592 1593
				return -EIO;
			return 0;
		}
	        case HDIO_UNREGISTER_HWIF:
Alan Cox's avatar
Alan Cox committed
1594
			if (!capable(CAP_SYS_RAWIO)) return -EACCES;
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
			/* (arg > MAX_HWIFS) checked in function */
			ide_unregister(arg);
			return 0;
		case HDIO_SET_NICE:
			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
			if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP) | (1 << IDE_NICE_1))))
				return -EPERM;
			drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
			if (drive->dsc_overlap && !DRIVER(drive)->supports_dsc_overlap) {
				drive->dsc_overlap = 0;
				return -EPERM;
			}
			drive->nice1 = (arg >> IDE_NICE_1) & 1;
			return 0;
		case HDIO_DRIVE_RESET:
		{
			unsigned long flags;
			if (!capable(CAP_SYS_ADMIN)) return -EACCES;
Alan Cox's avatar
Alan Cox committed
1613 1614 1615 1616 1617 1618 1619 1620 1621
			
			/*
			 *	Abort the current command on the
			 *	group if there is one, taking
			 *	care not to allow anything else
			 *	to be queued and to die on the
			 *	spot if we miss one somehow
			 */

1622
			spin_lock_irqsave(&ide_lock, flags);
Alan Cox's avatar
Alan Cox committed
1623 1624 1625 1626 1627 1628 1629 1630 1631
			
			DRIVER(drive)->abort(drive, "drive reset");
			if(HWGROUP(drive)->handler)
				BUG();
				
			/* Ensure nothing gets queued after we
			   drop the lock. Reset will clear the busy */
		   
			HWGROUP(drive)->busy = 1;
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
			spin_unlock_irqrestore(&ide_lock, flags);
			(void) ide_do_reset(drive);
			if (drive->suspend_reset) {
/*
 *				APM WAKE UP todo !!
 *				int nogoodpower = 1;
 *				while(nogoodpower) {
 *					check_power1() or check_power2()
 *					nogoodpower = 0;
 *				} 
 *				HWIF(drive)->multiproc(drive);
 */
1644
				return ioctl_by_bdev(bdev, BLKRRPART, 0);
1645 1646 1647 1648 1649 1650
			}
			return 0;
		}

		case CDROMEJECT:
		case CDROMCLOSETRAY:
1651
			return scsi_cmd_ioctl(bdev->bd_disk, cmd, arg);
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663

		case HDIO_GET_BUSSTATE:
			if (!capable(CAP_SYS_ADMIN))
				return -EACCES;
			if (put_user(HWIF(drive)->bus_state, (long *)arg))
				return -EFAULT;
			return 0;

		case HDIO_SET_BUSSTATE:
			if (!capable(CAP_SYS_ADMIN))
				return -EACCES;
			if (HWIF(drive)->busproc)
Alan Cox's avatar
Alan Cox committed
1664 1665
				return HWIF(drive)->busproc(drive, (int)arg);
			return -EOPNOTSUPP;
1666
		default:
1667
			return -EINVAL;
1668 1669 1670
	}
}

1671 1672
EXPORT_SYMBOL(generic_ide_ioctl);

1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
/*
 * stridx() returns the offset of c within s,
 * or -1 if c is '\0' or not found within s.
 */
static int __init stridx (const char *s, char c)
{
	char *i = strchr(s, c);
	return (i && c) ? i - s : -1;
}

/*
 * match_parm() does parsing for ide_setup():
 *
 * 1. the first char of s must be '='.
 * 2. if the remainder matches one of the supplied keywords,
 *     the index (1 based) of the keyword is negated and returned.
 * 3. if the remainder is a series of no more than max_vals numbers
 *     separated by commas, the numbers are saved in vals[] and a
 *     count of how many were saved is returned.  Base10 is assumed,
 *     and base16 is allowed when prefixed with "0x".
 * 4. otherwise, zero is returned.
 */
static int __init match_parm (char *s, const char *keywords[], int vals[], int max_vals)
{
	static const char *decimal = "0123456789";
	static const char *hex = "0123456789abcdef";
	int i, n;

	if (*s++ == '=') {
		/*
		 * Try matching against the supplied keywords,
		 * and return -(index+1) if we match one
		 */
		if (keywords != NULL) {
			for (i = 0; *keywords != NULL; ++i) {
				if (!strcmp(s, *keywords++))
					return -(i+1);
			}
		}
		/*
		 * Look for a series of no more than "max_vals"
		 * numeric values separated by commas, in base10,
		 * or base16 when prefixed with "0x".
		 * Return a count of how many were found.
		 */
		for (n = 0; (i = stridx(decimal, *s)) >= 0;) {
			vals[n] = i;
			while ((i = stridx(decimal, *++s)) >= 0)
				vals[n] = (vals[n] * 10) + i;
			if (*s == 'x' && !vals[n]) {
				while ((i = stridx(hex, *++s)) >= 0)
					vals[n] = (vals[n] * 0x10) + i;
			}
			if (++n == max_vals)
				break;
			if (*s == ',' || *s == ';')
				++s;
		}
		if (!*s)
			return n;
	}
	return 0;	/* zero = nothing matched */
}

1737 1738 1739 1740 1741
#ifdef CONFIG_BLK_DEV_PDC4030
static int __initdata probe_pdc4030;
#endif
#ifdef CONFIG_BLK_DEV_ALI14XX
static int __initdata probe_ali14xx;
1742
extern int ali14xx_init(void);
1743 1744 1745
#endif
#ifdef CONFIG_BLK_DEV_UMC8672
static int __initdata probe_umc8672;
1746
extern int umc8672_init(void);
1747 1748 1749
#endif
#ifdef CONFIG_BLK_DEV_DTC2278
static int __initdata probe_dtc2278;
1750
extern int dtc2278_init(void);
1751 1752 1753
#endif
#ifdef CONFIG_BLK_DEV_HT6560B
static int __initdata probe_ht6560b;
1754
extern int ht6560b_init(void);
1755 1756 1757
#endif
#ifdef CONFIG_BLK_DEV_QD65XX
static int __initdata probe_qd65xx;
1758
extern int qd65xx_init(void);
1759 1760 1761 1762
#endif

static int __initdata is_chipset_set[MAX_HWIFS];

1763 1764
/*
 * ide_setup() gets called VERY EARLY during initialization,
1765
 * to handle kernel "command line" strings beginning with "hdx=" or "ide".
1766
 *
1767
 * Remember to update Documentation/ide.txt if you change something here.
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
 */
int __init ide_setup (char *s)
{
	int i, vals[3];
	ide_hwif_t *hwif;
	ide_drive_t *drive;
	unsigned int hw, unit;
	const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
	const char max_hwif  = '0' + (MAX_HWIFS - 1);

	
	if (strncmp(s,"hd",2) == 0 && s[2] == '=')	/* hd= is for hd.c   */
		return 0;				/* driver and not us */

1782
	if (strncmp(s,"ide",3) && strncmp(s,"idebus",6) && strncmp(s,"hd",2))
1783 1784
		return 0;

1785
	printk(KERN_INFO "ide_setup: %s", s);
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
	init_ide_data ();

#ifdef CONFIG_BLK_DEV_IDEDOUBLER
	if (!strcmp(s, "ide=doubler")) {
		extern int ide_doubler;

		printk(" : Enabled support for IDE doublers\n");
		ide_doubler = 1;
		return 1;
	}
#endif /* CONFIG_BLK_DEV_IDEDOUBLER */

	if (!strcmp(s, "ide=nodma")) {
		printk("IDE: Prevented DMA\n");
		noautodma = 1;
		return 1;
	}

#ifdef CONFIG_BLK_DEV_IDEPCI
	if (!strcmp(s, "ide=reverse")) {
		ide_scan_direction = 1;
		printk(" : Enabled support for IDE inverse scan order.\n");
		return 1;
	}
#endif /* CONFIG_BLK_DEV_IDEPCI */

	/*
	 * Look for drive options:  "hdx="
	 */
	if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) {
1816 1817
		const char *hd_words[] = {
			"none", "noprobe", "nowerr", "cdrom", "serialize",
1818 1819
			"autotune", "noautotune", "minus8", "swapdata", "bswap",
			"minus11", "remap", "remap63", "scsi", NULL };
1820 1821 1822 1823 1824 1825
		unit = s[2] - 'a';
		hw   = unit / MAX_DRIVES;
		unit = unit % MAX_DRIVES;
		hwif = &ide_hwifs[hw];
		drive = &hwif->drives[unit];
		if (strncmp(s + 4, "ide-", 4) == 0) {
1826
			strlcpy(drive->driver_req, s + 4, sizeof(drive->driver_req));
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846
			goto done;
		}
		switch (match_parm(&s[3], hd_words, vals, 3)) {
			case -1: /* "none" */
			case -2: /* "noprobe" */
				drive->noprobe = 1;
				goto done;
			case -3: /* "nowerr" */
				drive->bad_wstat = BAD_R_STAT;
				hwif->noprobe = 0;
				goto done;
			case -4: /* "cdrom" */
				drive->present = 1;
				drive->media = ide_cdrom;
				hwif->noprobe = 0;
				goto done;
			case -5: /* "serialize" */
				printk(" -- USE \"ide%d=serialize\" INSTEAD", hw);
				goto do_serialize;
			case -6: /* "autotune" */
1847
				drive->autotune = IDE_TUNE_AUTO;
1848 1849
				goto done;
			case -7: /* "noautotune" */
1850
				drive->autotune = IDE_TUNE_NOAUTO;
1851
				goto done;
1852 1853
			case -9: /* "swapdata" */
			case -10: /* "bswap" */
1854 1855 1856 1857 1858
				drive->bswap = 1;
				goto done;
			case -12: /* "remap" */
				drive->remap_0_to_1 = 1;
				goto done;
1859 1860
			case -13: /* "remap63" */
				drive->sect0 = 63;
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
				goto done;
			case -14: /* "scsi" */
				drive->scsi = 1;
				goto done;
			case 3: /* cyl,head,sect */
				drive->media	= ide_disk;
				drive->cyl	= drive->bios_cyl  = vals[0];
				drive->head	= drive->bios_head = vals[1];
				drive->sect	= drive->bios_sect = vals[2];
				drive->present	= 1;
				drive->forced_geom = 1;
				hwif->noprobe = 0;
				goto done;
			default:
				goto bad_option;
		}
	}

	if (s[0] != 'i' || s[1] != 'd' || s[2] != 'e')
		goto bad_option;
	/*
	 * Look for bus speed option:  "idebus="
	 */
	if (s[3] == 'b' && s[4] == 'u' && s[5] == 's') {
		if (match_parm(&s[6], NULL, vals, 1) != 1)
			goto bad_option;
		if (vals[0] >= 20 && vals[0] <= 66) {
			idebus_parameter = vals[0];
		} else
			printk(" -- BAD BUS SPEED! Expected value from 20 to 66");
		goto done;
	}
	/*
	 * Look for interface options:  "idex="
	 */
	if (s[3] >= '0' && s[3] <= max_hwif) {
		/*
		 * Be VERY CAREFUL changing this: note hardcoded indexes below
1899
		 * (-8, -9, -10) are reserved to ease the hardcoding.
1900 1901
		 */
		const char *ide_words[] = {
1902
			"noprobe", "serialize", "autotune", "noautotune", 
1903
			"reset", "dma", "ata66", "minus8", "minus9",
1904 1905
			"minus10", "four", "qd65xx", "ht6560b", "cmd640_vlb",
			"dtc2278", "umc8672", "ali14xx", "dc4030", NULL };
1906 1907 1908 1909 1910
		hw = s[3] - '0';
		hwif = &ide_hwifs[hw];
		i = match_parm(&s[4], ide_words, vals, 3);

		/*
1911 1912
		 * Cryptic check to ensure chipset not already set for hwif.
		 * Note: we can't depend on hwif->chipset here.
1913
		 */
1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
		if ((i >= -18 && i <= -11) || (i > 0 && i <= 3)) {
			/* chipset already specified */
			if (is_chipset_set[hw])
				goto bad_option;
			if (i > -18 && i <= -11) {
				/* these drivers are for "ide0=" only */
				if (hw != 0)
					goto bad_hwif;
				/* chipset already specified for 2nd port */
				if (is_chipset_set[hw+1])
					goto bad_option;
			}
			is_chipset_set[hw] = 1;
1927 1928 1929 1930 1931 1932
			printk("\n");
		}

		switch (i) {
#ifdef CONFIG_BLK_DEV_PDC4030
			case -18: /* "dc4030" */
1933
				probe_pdc4030 = 1;
1934
				goto done;
1935
#endif
1936 1937
#ifdef CONFIG_BLK_DEV_ALI14XX
			case -17: /* "ali14xx" */
1938
				probe_ali14xx = 1;
1939
				goto done;
1940
#endif
1941 1942
#ifdef CONFIG_BLK_DEV_UMC8672
			case -16: /* "umc8672" */
1943
				probe_umc8672 = 1;
1944
				goto done;
1945
#endif
1946 1947
#ifdef CONFIG_BLK_DEV_DTC2278
			case -15: /* "dtc2278" */
1948
				probe_dtc2278 = 1;
1949
				goto done;
1950
#endif
1951 1952 1953 1954 1955 1956 1957
#ifdef CONFIG_BLK_DEV_CMD640
			case -14: /* "cmd640_vlb" */
			{
				extern int cmd640_vlb; /* flag for cmd640.c */
				cmd640_vlb = 1;
				goto done;
			}
1958
#endif
1959 1960
#ifdef CONFIG_BLK_DEV_HT6560B
			case -13: /* "ht6560b" */
1961
				probe_ht6560b = 1;
1962
				goto done;
1963
#endif
1964
#ifdef CONFIG_BLK_DEV_QD65XX
1965
			case -12: /* "qd65xx" */
1966
				probe_qd65xx = 1;
1967
				goto done;
1968
#endif
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
#ifdef CONFIG_BLK_DEV_4DRIVES
			case -11: /* "four" drives on one set of ports */
			{
				ide_hwif_t *mate = &ide_hwifs[hw^1];
				mate->drives[0].select.all ^= 0x20;
				mate->drives[1].select.all ^= 0x20;
				hwif->chipset = mate->chipset = ide_4drives;
				mate->irq = hwif->irq;
				memcpy(mate->io_ports, hwif->io_ports, sizeof(hwif->io_ports));
				goto do_serialize;
			}
#endif /* CONFIG_BLK_DEV_4DRIVES */
			case -10: /* minus10 */
			case -9: /* minus9 */
1983
			case -8: /* minus8 */
1984 1985 1986 1987 1988
				goto bad_option;
			case -7: /* ata66 */
#ifdef CONFIG_BLK_DEV_IDEPCI
				hwif->udma_four = 1;
				goto done;
1989
#else
1990
				goto bad_hwif;
1991
#endif
1992 1993 1994 1995 1996 1997 1998
			case -6: /* dma */
				hwif->autodma = 1;
				goto done;
			case -5: /* "reset" */
				hwif->reset = 1;
				goto done;
			case -4: /* "noautotune" */
1999 2000
				hwif->drives[0].autotune = IDE_TUNE_NOAUTO;
				hwif->drives[1].autotune = IDE_TUNE_NOAUTO;
2001 2002
				goto done;
			case -3: /* "autotune" */
2003 2004
				hwif->drives[0].autotune = IDE_TUNE_AUTO;
				hwif->drives[1].autotune = IDE_TUNE_AUTO;
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022
				goto done;
			case -2: /* "serialize" */
			do_serialize:
				hwif->mate = &ide_hwifs[hw^1];
				hwif->mate->mate = hwif;
				hwif->serialized = hwif->mate->serialized = 1;
				goto done;

			case -1: /* "noprobe" */
				hwif->noprobe = 1;
				goto done;

			case 1:	/* base */
				vals[1] = vals[0] + 0x206; /* default ctl */
			case 2: /* base,ctl */
				vals[2] = 0;	/* default irq = probe for it */
			case 3: /* base,ctl,irq */
				hwif->hw.irq = vals[2];
Alan Cox's avatar
Alan Cox committed
2023
				ide_init_hwif_ports(&hwif->hw, (unsigned long) vals[0], (unsigned long) vals[1], &hwif->irq);
2024 2025 2026
				memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->io_ports));
				hwif->irq      = vals[2];
				hwif->noprobe  = 0;
2027
				hwif->chipset  = ide_forced;
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
				goto done;

			case 0: goto bad_option;
			default:
				printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n");
				return 1;
		}
	}
bad_option:
	printk(" -- BAD OPTION\n");
	return 1;
bad_hwif:
	printk("-- NOT SUPPORTED ON ide%d", hw);
done:
	printk("\n");
	return 1;
}

/*
 * probe_for_hwifs() finds/initializes "known" IDE interfaces
 */
static void __init probe_for_hwifs (void)
{
2051
#ifdef CONFIG_BLK_DEV_IDEPCI
2052
	ide_scan_pcibus(ide_scan_direction);
2053
#endif /* CONFIG_BLK_DEV_IDEPCI */
2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068

#ifdef CONFIG_ETRAX_IDE
	{
		extern void init_e100_ide(void);
		init_e100_ide();
	}
#endif /* CONFIG_ETRAX_IDE */
#ifdef CONFIG_BLK_DEV_CMD640
	{
		extern void ide_probe_for_cmd640x(void);
		ide_probe_for_cmd640x();
	}
#endif /* CONFIG_BLK_DEV_CMD640 */
#ifdef CONFIG_BLK_DEV_PDC4030
	{
2069 2070 2071
		extern int pdc4030_init(void);
		if (probe_pdc4030)
			(void)pdc4030_init();
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115
	}
#endif /* CONFIG_BLK_DEV_PDC4030 */
#ifdef CONFIG_BLK_DEV_IDE_PMAC
	{
		extern void pmac_ide_probe(void);
		pmac_ide_probe();
	}
#endif /* CONFIG_BLK_DEV_IDE_PMAC */
#ifdef CONFIG_BLK_DEV_IDE_SWARM
	{
		extern void swarm_ide_probe(void);
		swarm_ide_probe();
	}
#endif /* CONFIG_BLK_DEV_IDE_SWARM */
#ifdef CONFIG_BLK_DEV_GAYLE
	{
		extern void gayle_init(void);
		gayle_init();
	}
#endif /* CONFIG_BLK_DEV_GAYLE */
#ifdef CONFIG_BLK_DEV_FALCON_IDE
	{
		extern void falconide_init(void);
		falconide_init();
	}
#endif /* CONFIG_BLK_DEV_FALCON_IDE */
#ifdef CONFIG_BLK_DEV_MAC_IDE
	{
		extern void macide_init(void);
		macide_init();
	}
#endif /* CONFIG_BLK_DEV_MAC_IDE */
#ifdef CONFIG_BLK_DEV_Q40IDE
	{
		extern void q40ide_init(void);
		q40ide_init();
	}
#endif /* CONFIG_BLK_DEV_Q40IDE */
#ifdef CONFIG_BLK_DEV_BUDDHA
	{
		extern void buddha_init(void);
		buddha_init();
	}
#endif /* CONFIG_BLK_DEV_BUDDHA */
Adam Belay's avatar
Adam Belay committed
2116
#if defined(CONFIG_BLK_DEV_IDEPNP) && defined(CONFIG_PNP)
2117 2118 2119 2120
	{
		extern void pnpide_init(int enable);
		pnpide_init(1);
	}
Adam Belay's avatar
Adam Belay committed
2121
#endif /* CONFIG_BLK_DEV_IDEPNP */
2122 2123
}

2124 2125 2126 2127 2128 2129
/*
 *	Actually unregister the subdriver. Called with the
 *	request lock dropped.
 */
 
static int default_cleanup (ide_drive_t *drive)
2130
{
2131
	return ide_unregister_subdriver(drive);
2132 2133
}

2134
static ide_startstop_t default_do_request (ide_drive_t *drive, struct request *rq, sector_t block)
2135
{
2136
	ide_end_request(drive, 0, 0);
2137 2138 2139
	return ide_stopped;
}

2140
static int default_end_request (ide_drive_t *drive, int uptodate, int nr_sects)
2141
{
2142
	return ide_end_request(drive, uptodate, nr_sects);
2143 2144
}

2145
static u8 default_sense (ide_drive_t *drive, const char *msg, u8 stat)
2146 2147 2148 2149
{
	return ide_dump_status(drive, msg, stat);
}

2150
static ide_startstop_t default_error (ide_drive_t *drive, const char *msg, u8 stat)
2151 2152 2153 2154 2155 2156 2157 2158
{
	return ide_error(drive, msg, stat);
}

static void default_pre_reset (ide_drive_t *drive)
{
}

2159
static sector_t default_capacity (ide_drive_t *drive)
2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
{
	return 0x7fffffff;
}

static ide_startstop_t default_special (ide_drive_t *drive)
{
	special_t *s = &drive->special;

	s->all = 0;
	drive->mult_req = 0;
	return ide_stopped;
}

2173
static int default_attach (ide_drive_t *drive)
2174
{
2175 2176
	printk(KERN_ERR "%s: does not support hotswap of device class !\n",
		drive->name);
2177 2178 2179 2180

	return 0;
}

Alan Cox's avatar
Alan Cox committed
2181 2182 2183 2184 2185
static ide_startstop_t default_abort (ide_drive_t *drive, const char *msg)
{
	return ide_abort(drive, msg);
}

2186 2187 2188 2189 2190 2191 2192
static ide_startstop_t default_start_power_step(ide_drive_t *drive,
						struct request *rq)
{
	rq->pm->pm_step = ide_pm_state_completed;
	return ide_stopped;
}

2193
static void setup_driver_defaults (ide_driver_t *d)
2194
{
2195
	if (d->cleanup == NULL)		d->cleanup = default_cleanup;
2196 2197 2198 2199
	if (d->do_request == NULL)	d->do_request = default_do_request;
	if (d->end_request == NULL)	d->end_request = default_end_request;
	if (d->sense == NULL)		d->sense = default_sense;
	if (d->error == NULL)		d->error = default_error;
Alan Cox's avatar
Alan Cox committed
2200
	if (d->abort == NULL)		d->abort = default_abort;
2201 2202 2203
	if (d->pre_reset == NULL)	d->pre_reset = default_pre_reset;
	if (d->capacity == NULL)	d->capacity = default_capacity;
	if (d->special == NULL)		d->special = default_special;
2204
	if (d->attach == NULL)		d->attach = default_attach;
2205 2206
	if (d->start_power_step == NULL)
		d->start_power_step = default_start_power_step;
2207 2208
}

2209
int ide_register_subdriver(ide_drive_t *drive, ide_driver_t *driver)
2210 2211
{
	unsigned long flags;
2212 2213 2214

	BUG_ON(!drive->driver);

2215
	spin_lock_irqsave(&ide_lock, flags);
2216 2217
	if (!drive->present || drive->driver != &idedefault_driver ||
	    drive->usage || drive->dead) {
2218 2219 2220 2221 2222
		spin_unlock_irqrestore(&ide_lock, flags);
		return 1;
	}
	drive->driver = driver;
	spin_unlock_irqrestore(&ide_lock, flags);
2223
	spin_lock(&drives_lock);
2224
	list_add_tail(&drive->list, &driver->drives);
2225
	spin_unlock(&drives_lock);
Alan Cox's avatar
Alan Cox committed
2226
//	printk(KERN_INFO "%s: attached %s driver.\n", drive->name, driver->name);
2227 2228
	if ((drive->autotune == IDE_TUNE_DEFAULT) ||
		(drive->autotune == IDE_TUNE_AUTO)) {
2229
		/* DMA timings and setup moved to ide-probe.c */
2230 2231 2232 2233 2234
		drive->dsc_overlap = (drive->next != drive && driver->supports_dsc_overlap);
		drive->nice1 = 1;
	}
	drive->suspend_reset = 0;
#ifdef CONFIG_PROC_FS
2235 2236 2237 2238
	if (drive->driver != &idedefault_driver) {
		ide_add_proc_entries(drive->proc, generic_subdriver_entries, drive);
		ide_add_proc_entries(drive->proc, driver->proc, drive);
	}
2239 2240 2241 2242
#endif
	return 0;
}

2243 2244
EXPORT_SYMBOL(ide_register_subdriver);

2245 2246 2247 2248
int ide_unregister_subdriver (ide_drive_t *drive)
{
	unsigned long flags;
	
2249
	down(&ide_setting_sem);
2250
	spin_lock_irqsave(&ide_lock, flags);
Alan Cox's avatar
Alan Cox committed
2251
	if (drive->usage || drive->driver == &idedefault_driver || DRIVER(drive)->busy) {
2252
		spin_unlock_irqrestore(&ide_lock, flags);
2253
		up(&ide_setting_sem);
2254 2255
		return 1;
	}
Adam Belay's avatar
Adam Belay committed
2256
#if defined(CONFIG_BLK_DEV_IDEPNP) && defined(CONFIG_PNP) && defined(MODULE)
2257
	pnpide_init(0);
Adam Belay's avatar
Adam Belay committed
2258
#endif /* CONFIG_BLK_DEV_IDEPNP */
2259 2260 2261 2262 2263
#ifdef CONFIG_PROC_FS
	ide_remove_proc_entries(drive->proc, DRIVER(drive)->proc);
	ide_remove_proc_entries(drive->proc, generic_subdriver_entries);
#endif
	auto_remove_settings(drive);
Alan Cox's avatar
Alan Cox committed
2264
	drive->driver = &idedefault_driver;
2265
	spin_unlock_irqrestore(&ide_lock, flags);
2266
	up(&ide_setting_sem);
2267 2268 2269
	spin_lock(&drives_lock);
	list_del_init(&drive->list);
	spin_unlock(&drives_lock);
2270
	/* drive will be added to &idedefault_driver->drives in ata_attach() */
2271 2272 2273
	return 0;
}

2274 2275
EXPORT_SYMBOL(ide_unregister_subdriver);

2276 2277 2278
static int ide_drive_remove(struct device * dev)
{
	ide_drive_t * drive = container_of(dev,ide_drive_t,gendev);
Alan Cox's avatar
Alan Cox committed
2279
	DRIVER(drive)->cleanup(drive);
2280 2281 2282
	return 0;
}

2283
int ide_register_driver(ide_driver_t *driver)
2284
{
2285
	struct list_head list;
2286 2287
	struct list_head *list_loop;
	struct list_head *tmp_storage;
2288

2289 2290
	setup_driver_defaults(driver);

2291
	spin_lock(&drivers_lock);
2292
	list_add(&driver->drivers, &drivers);
2293
	spin_unlock(&drivers_lock);
2294 2295

	INIT_LIST_HEAD(&list);
2296 2297
	spin_lock(&drives_lock);
	list_splice_init(&idedefault_driver.drives, &list);
2298 2299
	spin_unlock(&drives_lock);

2300 2301
	list_for_each_safe(list_loop, tmp_storage, &list) {
		ide_drive_t *drive = container_of(list_loop, ide_drive_t, list);
2302
		list_del_init(&drive->list);
Alan Cox's avatar
Alan Cox committed
2303 2304
		if (drive->present)
			ata_attach(drive);
2305
	}
2306
	driver->gen_driver.name = (char *) driver->name;
2307
	driver->gen_driver.bus = &ide_bus_type;
2308
	driver->gen_driver.remove = ide_drive_remove;
2309
	return driver_register(&driver->gen_driver);
2310 2311
}

2312 2313
EXPORT_SYMBOL(ide_register_driver);

2314
void ide_unregister_driver(ide_driver_t *driver)
2315
{
2316 2317
	ide_drive_t *drive;

2318
	spin_lock(&drivers_lock);
2319
	list_del(&driver->drivers);
2320 2321
	spin_unlock(&drivers_lock);

2322 2323
	driver_unregister(&driver->gen_driver);

2324 2325
	while(!list_empty(&driver->drives)) {
		drive = list_entry(driver->drives.next, ide_drive_t, list);
2326
		if (driver->cleanup(drive)) {
2327
			printk(KERN_ERR "%s: cleanup_module() called while still busy\n", drive->name);
2328
			BUG();
2329
		}
2330
		ata_attach(drive);
2331
	}
2332 2333
}

2334 2335
EXPORT_SYMBOL(ide_unregister_driver);

2336
struct block_device_operations ide_fops[] = {{
Alexander Viro's avatar
Alexander Viro committed
2337 2338
	.owner		= THIS_MODULE,
	.open		= ide_open,
2339 2340
}};

2341
EXPORT_SYMBOL(ide_fops);
2342 2343 2344 2345 2346 2347 2348

/*
 * Probe module
 */

EXPORT_SYMBOL(ide_lock);

2349 2350
struct bus_type ide_bus_type = {
	.name		= "ide",
2351 2352
	.suspend	= generic_ide_suspend,
	.resume		= generic_ide_resume,
2353 2354
};

2355 2356 2357 2358 2359
/*
 * This is gets invoked once during initialization, to set *everything* up
 */
int __init ide_init (void)
{
2360 2361 2362
	printk(KERN_INFO "Uniform Multi-Platform E-IDE driver " REVISION "\n");
	devfs_mk_dir("ide");
	system_bus_speed = ide_system_bus_speed();
2363

2364 2365
	bus_register(&ide_bus_type);

2366
	init_ide_data();
2367

2368 2369 2370 2371
#ifdef CONFIG_PROC_FS
	proc_ide_root = proc_mkdir("ide", 0);
#endif

2372 2373
#ifdef CONFIG_BLK_DEV_ALI14XX
	if (probe_ali14xx)
2374
		(void)ali14xx_init();
2375 2376 2377
#endif
#ifdef CONFIG_BLK_DEV_UMC8672
	if (probe_umc8672)
2378
		(void)umc8672_init();
2379 2380 2381
#endif
#ifdef CONFIG_BLK_DEV_DTC2278
	if (probe_dtc2278)
2382
		(void)dtc2278_init();
2383 2384 2385
#endif
#ifdef CONFIG_BLK_DEV_HT6560B
	if (probe_ht6560b)
2386
		(void)ht6560b_init();
2387 2388 2389
#endif
#ifdef CONFIG_BLK_DEV_QD65XX
	if (probe_qd65xx)
2390
		(void)qd65xx_init();
2391 2392
#endif

2393
	initializing = 1;
2394 2395
	/* Probe for special PCI and other "known" interface chipsets. */
	probe_for_hwifs();
2396 2397
	initializing = 0;

2398 2399 2400
#ifdef CONFIG_PROC_FS
	proc_ide_create();
#endif
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418
	return 0;
}

#ifdef MODULE
char *options = NULL;
MODULE_PARM(options,"s");
MODULE_LICENSE("GPL");

static void __init parse_options (char *line)
{
	char *next = line;

	if (line == NULL || !*line)
		return;
	while ((line = next) != NULL) {
 		if ((next = strchr(line,' ')) != NULL)
			*next++ = 0;
		if (!ide_setup(line))
2419
			printk (KERN_INFO "Unknown option '%s'\n", line);
2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
	}
}

int init_module (void)
{
	parse_options(options);
	return ide_init();
}

void cleanup_module (void)
{
	int index;

	for (index = 0; index < MAX_HWIFS; ++index) {
		ide_unregister(index);
2435
#if !defined(CONFIG_DMA_NONPCI)
2436 2437
		if (ide_hwifs[index].dma_base)
			(void) ide_release_dma(&ide_hwifs[index]);
2438
#endif /* !(CONFIG_DMA_NONPCI) */
2439 2440 2441 2442 2443
	}

#ifdef CONFIG_PROC_FS
	proc_ide_destroy();
#endif
Alexander Viro's avatar
Alexander Viro committed
2444
	devfs_remove("ide");
2445 2446

	bus_unregister(&ide_bus_type);
2447 2448 2449 2450 2451 2452
}

#else /* !MODULE */

__setup("", ide_setup);

Alexander Viro's avatar
Alexander Viro committed
2453 2454
module_init(ide_init);

2455
#endif /* MODULE */