ide.c 19.7 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  Copyright (C) 1994-1998	    Linus Torvalds & authors (see below)
3
 *  Copyright (C) 2003-2005, 2007   Bartlomiej Zolnierkiewicz
L
Linus Torvalds 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 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
 */

/*
 *  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.
 * It supports up to MAX_HWIFS IDE interfaces, on one or more IRQs
 *   (usually 14 & 15).
 * There can be up to two drives per interface, as per the ATA-2 spec.
 *
 * ...
 *
 *  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
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/ide.h>
59
#include <linux/hdreg.h>
L
Linus Torvalds 已提交
60 61 62 63 64 65 66
#include <linux/completion.h>
#include <linux/device.h>


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

67 68
struct class *ide_port_class;

L
Linus Torvalds 已提交
69 70 71 72 73 74
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 };

75
DEFINE_MUTEX(ide_cfg_mtx);
L
Linus Torvalds 已提交
76

77 78
__cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock);
EXPORT_SYMBOL(ide_lock);
L
Linus Torvalds 已提交
79

80 81
static void ide_port_init_devices_data(ide_hwif_t *);

L
Linus Torvalds 已提交
82 83 84
/*
 * Do not even *think* about calling this!
 */
85
void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
L
Linus Torvalds 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98
{
	/* bulk initialize hwif & drive info with zeros */
	memset(hwif, 0, sizeof(ide_hwif_t));

	/* fill in any non-zero initial values */
	hwif->index	= index;
	hwif->major	= ide_hwif_to_major[index];

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

99
	init_completion(&hwif->gendev_rel_comp);
L
Linus Torvalds 已提交
100

101
	hwif->tp_ops = &default_tp_ops;
102 103 104 105 106 107 108 109

	ide_port_init_devices_data(hwif);
}

static void ide_port_init_devices_data(ide_hwif_t *hwif)
{
	int unit;

L
Linus Torvalds 已提交
110 111
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		ide_drive_t *drive = &hwif->drives[unit];
112 113 114
		u8 j = (hwif->index * MAX_DRIVES) + unit;

		memset(drive, 0, sizeof(*drive));
L
Linus Torvalds 已提交
115 116 117 118

		drive->media			= ide_disk;
		drive->select.all		= (unit<<4)|0xa0;
		drive->hwif			= hwif;
119
		drive->ready_stat		= ATA_DRDY;
L
Linus Torvalds 已提交
120 121 122 123 124
		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';
125
		drive->name[2]			= 'a' + j;
L
Linus Torvalds 已提交
126
		drive->max_failures		= IDE_DEFAULT_MAX_FAILURES;
127

L
Linus Torvalds 已提交
128
		INIT_LIST_HEAD(&drive->list);
129
		init_completion(&drive->gendev_rel_comp);
L
Linus Torvalds 已提交
130 131
	}
}
132

133
/* Called with ide_lock held. */
134
static void __ide_port_unregister_devices(ide_hwif_t *hwif)
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
{
	int i;

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

		if (drive->present) {
			spin_unlock_irq(&ide_lock);
			device_unregister(&drive->gendev);
			wait_for_completion(&drive->gendev_rel_comp);
			spin_lock_irq(&ide_lock);
		}
	}
}

150 151 152 153 154 155 156 157 158 159 160 161
void ide_port_unregister_devices(ide_hwif_t *hwif)
{
	mutex_lock(&ide_cfg_mtx);
	spin_lock_irq(&ide_lock);
	__ide_port_unregister_devices(hwif);
	hwif->present = 0;
	ide_port_init_devices_data(hwif);
	spin_unlock_irq(&ide_lock);
	mutex_unlock(&ide_cfg_mtx);
}
EXPORT_SYMBOL_GPL(ide_port_unregister_devices);

L
Linus Torvalds 已提交
162
/**
163
 *	ide_unregister		-	free an IDE interface
164
 *	@hwif: IDE interface
L
Linus Torvalds 已提交
165 166 167 168 169 170 171 172 173 174 175
 *
 *	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
176 177
 *	the interface will not be reopened (present/vanishing locking
 *	isn't yet done BTW). After we commit to the final kill we
L
Linus Torvalds 已提交
178 179 180 181 182 183
 *	call the cleanup callback with the ide locks held.
 *
 *	Unregister restores the hwif structures to the default state.
 *	This is raving bonkers.
 */

184
void ide_unregister(ide_hwif_t *hwif)
L
Linus Torvalds 已提交
185
{
186
	ide_hwif_t *g;
L
Linus Torvalds 已提交
187
	ide_hwgroup_t *hwgroup;
188
	int irq_count = 0;
L
Linus Torvalds 已提交
189 190 191

	BUG_ON(in_interrupt());
	BUG_ON(irqs_disabled());
192

193
	mutex_lock(&ide_cfg_mtx);
L
Linus Torvalds 已提交
194

195 196 197 198 199
	spin_lock_irq(&ide_lock);
	if (hwif->present) {
		__ide_port_unregister_devices(hwif);
		hwif->present = 0;
	}
L
Linus Torvalds 已提交
200 201
	spin_unlock_irq(&ide_lock);

202
	ide_proc_unregister_port(hwif);
L
Linus Torvalds 已提交
203 204 205 206 207 208 209 210 211 212 213 214 215 216

	hwgroup = hwif->hwgroup;
	/*
	 * 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)
		free_irq(hwif->irq, hwgroup);

217
	ide_remove_port_from_hwgroup(hwif);
L
Linus Torvalds 已提交
218

219
	device_unregister(hwif->portdev);
L
Linus Torvalds 已提交
220
	device_unregister(&hwif->gendev);
221
	wait_for_completion(&hwif->gendev_rel_comp);
L
Linus Torvalds 已提交
222 223 224 225 226 227 228 229

	/*
	 * Remove us from the kernel's knowledge
	 */
	blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS);
	kfree(hwif->sg_table);
	unregister_blkdev(hwif->major, hwif->name);

230
	if (hwif->dma_base)
231
		ide_release_dma_engine(hwif);
L
Linus Torvalds 已提交
232

233
	mutex_unlock(&ide_cfg_mtx);
L
Linus Torvalds 已提交
234 235
}

236 237
void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
{
238
	memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
239 240
	hwif->irq = hw->irq;
	hwif->chipset = hw->chipset;
241 242
	hwif->dev = hw->dev;
	hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
243
	hwif->ack_intr = hw->ack_intr;
244
	hwif->config_data = hw->config;
245 246
}

L
Linus Torvalds 已提交
247 248 249 250
/*
 *	Locks for IDE setting functionality
 */

251
DEFINE_MUTEX(ide_setting_mtx);
L
Linus Torvalds 已提交
252

253 254
ide_devset_get(io_32bit, io_32bit);

255
static int set_io_32bit(ide_drive_t *drive, int arg)
L
Linus Torvalds 已提交
256
{
257 258 259 260 261 262
	if (drive->no_io_32bit)
		return -EPERM;

	if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
		return -EINVAL;

L
Linus Torvalds 已提交
263
	drive->io_32bit = arg;
264

L
Linus Torvalds 已提交
265 266 267
	return 0;
}

268 269
ide_devset_get(ksettings, keep_settings);

270
static int set_ksettings(ide_drive_t *drive, int arg)
271 272 273 274 275 276 277 278 279
{
	if (arg < 0 || arg > 1)
		return -EINVAL;

	drive->keep_settings = arg;

	return 0;
}

280 281
ide_devset_get(using_dma, using_dma);

282
static int set_using_dma(ide_drive_t *drive, int arg)
L
Linus Torvalds 已提交
283 284
{
#ifdef CONFIG_BLK_DEV_IDEDMA
285 286
	int err = -EPERM;

287 288 289
	if (arg < 0 || arg > 1)
		return -EINVAL;

290
	if (ata_id_has_dma(drive->id) == 0)
291 292
		goto out;

293
	if (drive->hwif->dma_ops == NULL)
294 295 296 297
		goto out;

	err = 0;

L
Linus Torvalds 已提交
298
	if (arg) {
299
		if (ide_set_dma(drive))
300
			err = -EIO;
301 302
	} else
		ide_dma_off(drive);
303 304 305

out:
	return err;
L
Linus Torvalds 已提交
306
#else
307 308 309
	if (arg < 0 || arg > 1)
		return -EINVAL;

L
Linus Torvalds 已提交
310 311 312 313
	return -EPERM;
#endif
}

314
static int set_pio_mode(ide_drive_t *drive, int arg)
L
Linus Torvalds 已提交
315
{
316
	struct request *rq;
317
	ide_hwif_t *hwif = drive->hwif;
318
	const struct ide_port_ops *port_ops = hwif->port_ops;
L
Linus Torvalds 已提交
319

320 321 322
	if (arg < 0 || arg > 255)
		return -EINVAL;

323
	if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
324
	    (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
L
Linus Torvalds 已提交
325
		return -ENOSYS;
326

L
Linus Torvalds 已提交
327 328
	if (drive->special.b.set_tune)
		return -EBUSY;
329

330 331
	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
332

L
Linus Torvalds 已提交
333 334
	drive->tune_req = (u8) arg;
	drive->special.b.set_tune = 1;
335 336 337 338

	blk_execute_rq(drive->queue, NULL, rq, 0);
	blk_put_request(rq);

L
Linus Torvalds 已提交
339 340 341
	return 0;
}

342 343
ide_devset_get(unmaskirq, unmask);

344
static int set_unmaskirq(ide_drive_t *drive, int arg)
345 346 347 348 349 350 351 352 353 354 355 356
{
	if (drive->no_unmask)
		return -EPERM;

	if (arg < 0 || arg > 1)
		return -EINVAL;

	drive->unmask = arg;

	return 0;
}

357 358 359 360 361 362 363 364 365
#define ide_gen_devset_rw(_name, _func) \
__IDE_DEVSET(_name, DS_SYNC, get_##_func, set_##_func)

ide_gen_devset_rw(io_32bit, io_32bit);
ide_gen_devset_rw(keepsettings, ksettings);
ide_gen_devset_rw(unmaskirq, unmaskirq);
ide_gen_devset_rw(using_dma, using_dma);
__IDE_DEVSET(pio_mode, 0, NULL, set_pio_mode);

366
static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
L
Linus Torvalds 已提交
367
{
368
	ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
369
	ide_hwif_t *hwif = HWIF(drive);
370
	struct request *rq;
L
Linus Torvalds 已提交
371 372
	struct request_pm_state rqpm;
	ide_task_t args;
373
	int ret;
L
Linus Torvalds 已提交
374

375 376
	/* call ACPI _GTM only once */
	if ((drive->dn & 1) == 0 || pair == NULL)
377 378
		ide_acpi_get_timing(hwif);

L
Linus Torvalds 已提交
379 380
	memset(&rqpm, 0, sizeof(rqpm));
	memset(&args, 0, sizeof(args));
381 382 383 384
	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->cmd_type = REQ_TYPE_PM_SUSPEND;
	rq->special = &args;
	rq->data = &rqpm;
L
Linus Torvalds 已提交
385
	rqpm.pm_step = ide_pm_state_start_suspend;
386 387 388
	if (mesg.event == PM_EVENT_PRETHAW)
		mesg.event = PM_EVENT_FREEZE;
	rqpm.pm_state = mesg.event;
L
Linus Torvalds 已提交
389

390 391
	ret = blk_execute_rq(drive->queue, NULL, rq, 0);
	blk_put_request(rq);
392 393 394

	/* call ACPI _PS3 only after both devices are suspended */
	if (ret == 0 && ((drive->dn & 1) || pair == NULL))
395
		ide_acpi_set_state(hwif, 0);
396

397
	return ret;
L
Linus Torvalds 已提交
398 399 400 401
}

static int generic_ide_resume(struct device *dev)
{
402
	ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
403
	ide_hwif_t *hwif = HWIF(drive);
404
	struct request *rq;
L
Linus Torvalds 已提交
405 406
	struct request_pm_state rqpm;
	ide_task_t args;
L
Lee Trager 已提交
407
	int err;
L
Linus Torvalds 已提交
408

409 410
	/* call ACPI _PS0 / _STM only once */
	if ((drive->dn & 1) == 0 || pair == NULL) {
411
		ide_acpi_set_state(hwif, 1);
412
		ide_acpi_push_timing(hwif);
413
	}
414 415 416

	ide_acpi_exec_tfs(drive);

L
Linus Torvalds 已提交
417 418
	memset(&rqpm, 0, sizeof(rqpm));
	memset(&args, 0, sizeof(args));
419 420 421 422 423
	rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
	rq->cmd_type = REQ_TYPE_PM_RESUME;
	rq->cmd_flags |= REQ_PREEMPT;
	rq->special = &args;
	rq->data = &rqpm;
L
Linus Torvalds 已提交
424
	rqpm.pm_step = ide_pm_state_start_resume;
425
	rqpm.pm_state = PM_EVENT_ON;
L
Linus Torvalds 已提交
426

427 428
	err = blk_execute_rq(drive->queue, NULL, rq, 1);
	blk_put_request(rq);
L
Lee Trager 已提交
429

430 431 432 433 434 435
	if (err == 0 && dev->driver) {
		ide_driver_t *drv = to_ide_driver(dev->driver);

		if (drv->resume)
			drv->resume(drive);
	}
L
Lee Trager 已提交
436 437

	return err;
L
Linus Torvalds 已提交
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 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
/**
 * ide_device_get	-	get an additional reference to a ide_drive_t
 * @drive:	device to get a reference to
 *
 * Gets a reference to the ide_drive_t and increments the use count of the
 * underlying LLDD module.
 */
int ide_device_get(ide_drive_t *drive)
{
	struct device *host_dev;
	struct module *module;

	if (!get_device(&drive->gendev))
		return -ENXIO;

	host_dev = drive->hwif->host->dev[0];
	module = host_dev ? host_dev->driver->owner : NULL;

	if (module && !try_module_get(module)) {
		put_device(&drive->gendev);
		return -ENXIO;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(ide_device_get);

/**
 * ide_device_put	-	release a reference to a ide_drive_t
 * @drive:	device to release a reference on
 *
 * Release a reference to the ide_drive_t and decrements the use count of
 * the underlying LLDD module.
 */
void ide_device_put(ide_drive_t *drive)
{
#ifdef CONFIG_MODULE_UNLOAD
	struct device *host_dev = drive->hwif->host->dev[0];
	struct module *module = host_dev ? host_dev->driver->owner : NULL;

	if (module)
		module_put(module);
#endif
	put_device(&drive->gendev);
}
EXPORT_SYMBOL_GPL(ide_device_put);

487 488 489 490 491
static int ide_bus_match(struct device *dev, struct device_driver *drv)
{
	return 1;
}

492 493 494 495 496 497 498 499 500 501 502
static char *media_string(ide_drive_t *drive)
{
	switch (drive->media) {
	case ide_disk:
		return "disk";
	case ide_cdrom:
		return "cdrom";
	case ide_tape:
		return "tape";
	case ide_floppy:
		return "floppy";
503 504
	case ide_optical:
		return "optical";
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
	default:
		return "UNKNOWN";
	}
}

static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	ide_drive_t *drive = to_ide_device(dev);
	return sprintf(buf, "%s\n", media_string(drive));
}

static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	ide_drive_t *drive = to_ide_device(dev);
	return sprintf(buf, "%s\n", drive->name);
}

static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	ide_drive_t *drive = to_ide_device(dev);
	return sprintf(buf, "ide:m-%s\n", media_string(drive));
}

528 529 530 531
static ssize_t model_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	ide_drive_t *drive = to_ide_device(dev);
532
	return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]);
533 534 535 536 537 538
}

static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
{
	ide_drive_t *drive = to_ide_device(dev);
539
	return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]);
540 541 542 543 544 545
}

static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	ide_drive_t *drive = to_ide_device(dev);
546
	return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]);
547 548
}

549 550 551 552
static struct device_attribute ide_dev_attrs[] = {
	__ATTR_RO(media),
	__ATTR_RO(drivename),
	__ATTR_RO(modalias),
553 554 555
	__ATTR_RO(model),
	__ATTR_RO(firmware),
	__ATTR(serial, 0400, serial_show, NULL),
556 557 558
	__ATTR_NULL
};

559
static int ide_uevent(struct device *dev, struct kobj_uevent_env *env)
560 561
{
	ide_drive_t *drive = to_ide_device(dev);
562 563 564 565

	add_uevent_var(env, "MEDIA=%s", media_string(drive));
	add_uevent_var(env, "DRIVENAME=%s", drive->name);
	add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive));
566 567 568
	return 0;
}

569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
static int generic_ide_probe(struct device *dev)
{
	ide_drive_t *drive = to_ide_device(dev);
	ide_driver_t *drv = to_ide_driver(dev->driver);

	return drv->probe ? drv->probe(drive) : -ENODEV;
}

static int generic_ide_remove(struct device *dev)
{
	ide_drive_t *drive = to_ide_device(dev);
	ide_driver_t *drv = to_ide_driver(dev->driver);

	if (drv->remove)
		drv->remove(drive);

	return 0;
}

static void generic_ide_shutdown(struct device *dev)
{
	ide_drive_t *drive = to_ide_device(dev);
	ide_driver_t *drv = to_ide_driver(dev->driver);

	if (dev->driver && drv->shutdown)
		drv->shutdown(drive);
}

L
Linus Torvalds 已提交
597 598
struct bus_type ide_bus_type = {
	.name		= "ide",
599
	.match		= ide_bus_match,
600
	.uevent		= ide_uevent,
601 602 603
	.probe		= generic_ide_probe,
	.remove		= generic_ide_remove,
	.shutdown	= generic_ide_shutdown,
604
	.dev_attrs	= ide_dev_attrs,
L
Linus Torvalds 已提交
605 606 607 608
	.suspend	= generic_ide_suspend,
	.resume		= generic_ide_resume,
};

609 610
EXPORT_SYMBOL_GPL(ide_bus_type);

611 612 613 614 615 616 617 618 619 620 621 622
int ide_vlb_clk;
EXPORT_SYMBOL_GPL(ide_vlb_clk);

module_param_named(vlb_clock, ide_vlb_clk, int, 0);
MODULE_PARM_DESC(vlb_clock, "VLB clock frequency (in MHz)");

int ide_pci_clk;
EXPORT_SYMBOL_GPL(ide_pci_clk);

module_param_named(pci_clock, ide_pci_clk, int, 0);
MODULE_PARM_DESC(pci_clock, "PCI bus clock frequency (in MHz)");

623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
static int ide_set_dev_param_mask(const char *s, struct kernel_param *kp)
{
	int a, b, i, j = 1;
	unsigned int *dev_param_mask = (unsigned int *)kp->arg;

	if (sscanf(s, "%d.%d:%d", &a, &b, &j) != 3 &&
	    sscanf(s, "%d.%d", &a, &b) != 2)
		return -EINVAL;

	i = a * MAX_DRIVES + b;

	if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
		return -EINVAL;

	if (j)
		*dev_param_mask |= (1 << i);
	else
		*dev_param_mask &= (1 << i);

	return 0;
}

static unsigned int ide_nodma;

module_param_call(nodma, ide_set_dev_param_mask, NULL, &ide_nodma, 0);
MODULE_PARM_DESC(nodma, "disallow DMA for a device");

static unsigned int ide_noflush;

module_param_call(noflush, ide_set_dev_param_mask, NULL, &ide_noflush, 0);
MODULE_PARM_DESC(noflush, "disable flush requests for a device");

static unsigned int ide_noprobe;

module_param_call(noprobe, ide_set_dev_param_mask, NULL, &ide_noprobe, 0);
MODULE_PARM_DESC(noprobe, "skip probing for a device");

static unsigned int ide_nowerr;

module_param_call(nowerr, ide_set_dev_param_mask, NULL, &ide_nowerr, 0);
663
MODULE_PARM_DESC(nowerr, "ignore the ATA_DF bit for a device");
664

665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
static unsigned int ide_cdroms;

module_param_call(cdrom, ide_set_dev_param_mask, NULL, &ide_cdroms, 0);
MODULE_PARM_DESC(cdrom, "force device as a CD-ROM");

struct chs_geom {
	unsigned int	cyl;
	u8		head;
	u8		sect;
};

static unsigned int ide_disks;
static struct chs_geom ide_disks_chs[MAX_HWIFS * MAX_DRIVES];

static int ide_set_disk_chs(const char *str, struct kernel_param *kp)
{
	int a, b, c = 0, h = 0, s = 0, i, j = 1;

	if (sscanf(str, "%d.%d:%d,%d,%d", &a, &b, &c, &h, &s) != 5 &&
	    sscanf(str, "%d.%d:%d", &a, &b, &j) != 3)
		return -EINVAL;

	i = a * MAX_DRIVES + b;

	if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
		return -EINVAL;

	if (c > INT_MAX || h > 255 || s > 255)
		return -EINVAL;

	if (j)
		ide_disks |= (1 << i);
	else
		ide_disks &= (1 << i);

	ide_disks_chs[i].cyl  = c;
	ide_disks_chs[i].head = h;
	ide_disks_chs[i].sect = s;

	return 0;
}

module_param_call(chs, ide_set_disk_chs, NULL, NULL, 0);
MODULE_PARM_DESC(chs, "force device as a disk (using CHS)");

710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
static void ide_dev_apply_params(ide_drive_t *drive)
{
	int i = drive->hwif->index * MAX_DRIVES + drive->select.b.unit;

	if (ide_nodma & (1 << i)) {
		printk(KERN_INFO "ide: disallowing DMA for %s\n", drive->name);
		drive->nodma = 1;
	}
	if (ide_noflush & (1 << i)) {
		printk(KERN_INFO "ide: disabling flush requests for %s\n",
				 drive->name);
		drive->noflush = 1;
	}
	if (ide_noprobe & (1 << i)) {
		printk(KERN_INFO "ide: skipping probe for %s\n", drive->name);
		drive->noprobe = 1;
	}
	if (ide_nowerr & (1 << i)) {
728
		printk(KERN_INFO "ide: ignoring the ATA_DF bit for %s\n",
729 730 731
				 drive->name);
		drive->bad_wstat = BAD_R_STAT;
	}
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
	if (ide_cdroms & (1 << i)) {
		printk(KERN_INFO "ide: forcing %s as a CD-ROM\n", drive->name);
		drive->present = 1;
		drive->media = ide_cdrom;
		/* an ATAPI device ignores DRDY */
		drive->ready_stat = 0;
	}
	if (ide_disks & (1 << i)) {
		drive->cyl  = drive->bios_cyl  = ide_disks_chs[i].cyl;
		drive->head = drive->bios_head = ide_disks_chs[i].head;
		drive->sect = drive->bios_sect = ide_disks_chs[i].sect;
		drive->forced_geom = 1;
		printk(KERN_INFO "ide: forcing %s as a disk (%d/%d/%d)\n",
				 drive->name,
				 drive->cyl, drive->head, drive->sect);
		drive->present = 1;
		drive->media = ide_disk;
749
		drive->ready_stat = ATA_DRDY;
750
	}
751 752
}

753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
static unsigned int ide_ignore_cable;

static int ide_set_ignore_cable(const char *s, struct kernel_param *kp)
{
	int i, j = 1;

	if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1)
		return -EINVAL;

	if (i >= MAX_HWIFS || j < 0 || j > 1)
		return -EINVAL;

	if (j)
		ide_ignore_cable |= (1 << i);
	else
		ide_ignore_cable &= (1 << i);

	return 0;
}

module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0);
MODULE_PARM_DESC(ignore_cable, "ignore cable detection");

void ide_port_apply_params(ide_hwif_t *hwif)
{
778 779
	int i;

780 781 782 783 784
	if (ide_ignore_cable & (1 << hwif->index)) {
		printk(KERN_INFO "ide: ignoring cable detection for %s\n",
				 hwif->name);
		hwif->cbl = ATA_CBL_PATA40_SHORT;
	}
785 786 787

	for (i = 0; i < MAX_DRIVES; i++)
		ide_dev_apply_params(&hwif->drives[i]);
788 789
}

L
Linus Torvalds 已提交
790 791 792 793 794
/*
 * This is gets invoked once during initialization, to set *everything* up
 */
static int __init ide_init(void)
{
795 796
	int ret;

797
	printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n");
798

799 800 801 802 803
	ret = bus_register(&ide_bus_type);
	if (ret < 0) {
		printk(KERN_WARNING "IDE: bus_register error: %d\n", ret);
		return ret;
	}
L
Linus Torvalds 已提交
804

805 806 807 808 809 810
	ide_port_class = class_create(THIS_MODULE, "ide_port");
	if (IS_ERR(ide_port_class)) {
		ret = PTR_ERR(ide_port_class);
		goto out_port_class;
	}

811
	proc_ide_create();
L
Linus Torvalds 已提交
812 813

	return 0;
814 815 816 817 818

out_port_class:
	bus_unregister(&ide_bus_type);

	return ret;
L
Linus Torvalds 已提交
819 820
}

821
static void __exit ide_exit(void)
L
Linus Torvalds 已提交
822 823 824
{
	proc_ide_destroy();

825 826
	class_destroy(ide_port_class);

L
Linus Torvalds 已提交
827 828 829 830
	bus_unregister(&ide_bus_type);
}

module_init(ide_init);
831
module_exit(ide_exit);
L
Linus Torvalds 已提交
832

833
MODULE_LICENSE("GPL");
新手
引导
客服 返回
顶部