ide-probe.c 40.7 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
3
 *  Copyright (C) 1994-1998   Linus Torvalds & authors (see below)
 *  Copyright (C) 2005, 2007  Bartlomiej Zolnierkiewicz
Linus Torvalds's avatar
Linus Torvalds committed
4
5
6
7
8
9
10
11
12
13
14
 */

/*
 *  Mostly written by Mark Lord <mlord@pobox.com>
 *                and Gadi Oxman <gadio@netvision.net.il>
 *                and Andre Hedrick <andre@linux-ide.org>
 *
 *  See linux/MAINTAINERS for address of current maintainer.
 *
 * This is the IDE probe module, as evolved from hd.c and ide.c.
 *
15
16
 * -- increase WAIT_PIDENTIFY to avoid CD-ROM locking at boot
 *	 by Andrea Arcangeli
Linus Torvalds's avatar
Linus Torvalds committed
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/genhd.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/spinlock.h>
#include <linux/kmod.h>
#include <linux/pci.h>
FUJITA Tomonori's avatar
FUJITA Tomonori committed
35
#include <linux/scatterlist.h>
Linus Torvalds's avatar
Linus Torvalds committed
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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

/**
 *	generic_id		-	add a generic drive id
 *	@drive:	drive to make an ID block for
 *	
 *	Add a fake id field to the drive we are passed. This allows
 *	use to skip a ton of NULL checks (which people always miss) 
 *	and make drive properties unconditional outside of this file
 */
 
static void generic_id(ide_drive_t *drive)
{
53
54
55
56
57
	u16 *id = drive->id;

	id[ATA_ID_CUR_CYLS]	= id[ATA_ID_CYLS]	= drive->cyl;
	id[ATA_ID_CUR_HEADS]	= id[ATA_ID_HEADS]	= drive->head;
	id[ATA_ID_CUR_SECTORS]	= id[ATA_ID_SECTORS]	= drive->sect;
Linus Torvalds's avatar
Linus Torvalds committed
58
59
60
61
}

static void ide_disk_init_chs(ide_drive_t *drive)
{
62
	u16 *id = drive->id;
Linus Torvalds's avatar
Linus Torvalds committed
63
64
65

	/* Extract geometry if we did not already have one for the drive */
	if (!drive->cyl || !drive->head || !drive->sect) {
66
67
68
		drive->cyl  = drive->bios_cyl  = id[ATA_ID_CYLS];
		drive->head = drive->bios_head = id[ATA_ID_HEADS];
		drive->sect = drive->bios_sect = id[ATA_ID_SECTORS];
Linus Torvalds's avatar
Linus Torvalds committed
69
70
71
	}

	/* Handle logical geometry translation by the drive */
72
	if (ata_id_current_chs_valid(id)) {
73
74
75
		drive->cyl  = id[ATA_ID_CUR_CYLS];
		drive->head = id[ATA_ID_CUR_HEADS];
		drive->sect = id[ATA_ID_CUR_SECTORS];
Linus Torvalds's avatar
Linus Torvalds committed
76
77
78
	}

	/* Use physical geometry if what we have still makes no sense */
79
80
81
82
	if (drive->head > 16 && id[ATA_ID_HEADS] && id[ATA_ID_HEADS] <= 16) {
		drive->cyl  = id[ATA_ID_CYLS];
		drive->head = id[ATA_ID_HEADS];
		drive->sect = id[ATA_ID_SECTORS];
Linus Torvalds's avatar
Linus Torvalds committed
83
84
85
86
87
	}
}

static void ide_disk_init_mult_count(ide_drive_t *drive)
{
88
89
	u16 *id = drive->id;
	u8 max_multsect = id[ATA_ID_MAX_MULTSECT] & 0xff;
Linus Torvalds's avatar
Linus Torvalds committed
90

91
92
93
94
95
96
97
	if (max_multsect) {
		if ((max_multsect / 2) > 1)
			id[ATA_ID_MULTSECT] = max_multsect | 0x100;
		else
			id[ATA_ID_MULTSECT] &= ~0x1ff;

		drive->mult_req = id[ATA_ID_MULTSECT] & 0xff;
98
99

		if (drive->mult_req)
100
			drive->special.b.set_multmode = 1;
Linus Torvalds's avatar
Linus Torvalds committed
101
102
103
104
105
106
107
108
109
110
111
112
	}
}

/**
 *	do_identify	-	identify a drive
 *	@drive: drive to identify 
 *	@cmd: command used
 *
 *	Called when we have issued a drive identify command to
 *	read and parse the results. This function is run with
 *	interrupts disabled. 
 */
113
114

static void do_identify(ide_drive_t *drive, u8 cmd)
Linus Torvalds's avatar
Linus Torvalds committed
115
116
{
	ide_hwif_t *hwif = HWIF(drive);
117
118
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
119
	unsigned long flags;
120
	int bswap = 1, is_cfa;
Linus Torvalds's avatar
Linus Torvalds committed
121

122
123
	/* local CPU only; some systems need this */
	local_irq_save(flags);
Linus Torvalds's avatar
Linus Torvalds committed
124
	/* read 512 bytes of id info */
125
	hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
126
	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
127

128
	drive->dev_flags |= IDE_DFLAG_ID_READ;
129
130
131
132
#ifdef DEBUG
	printk(KERN_INFO "%s: dumping identify data\n", drive->name);
	ide_dump_identify((u8 *)id);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
133
134
135
	ide_fix_driveid(id);

	/*
136
137
	 *  ATA_CMD_ID_ATA returns little-endian info,
	 *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
Linus Torvalds's avatar
Linus Torvalds committed
138
	 */
139
	if (cmd == ATA_CMD_ID_ATAPI) {
140
141
142
		if ((m[0] == 'N' && m[1] == 'E') ||  /* NEC */
		    (m[0] == 'F' && m[1] == 'X') ||  /* Mitsumi */
		    (m[0] == 'P' && m[1] == 'i'))    /* Pioneer */
Linus Torvalds's avatar
Linus Torvalds committed
143
			/* Vertos drives may still be weird */
144
			bswap ^= 1;
Linus Torvalds's avatar
Linus Torvalds committed
145
	}
146
147
148
149

	ide_fixstring(m, ATA_ID_PROD_LEN, bswap);
	ide_fixstring((char *)&id[ATA_ID_FW_REV], ATA_ID_FW_REV_LEN, bswap);
	ide_fixstring((char *)&id[ATA_ID_SERNO], ATA_ID_SERNO_LEN, bswap);
Linus Torvalds's avatar
Linus Torvalds committed
150

151
	/* we depend on this a lot! */
152
	m[ATA_ID_PROD_LEN - 1] = '\0';
153

154
	if (strstr(m, "E X A B Y T E N E S T"))
Linus Torvalds's avatar
Linus Torvalds committed
155
156
		goto err_misc;

157
	printk(KERN_INFO "%s: %s, ", drive->name, m);
158

159
160
	drive->dev_flags |= IDE_DFLAG_PRESENT;
	drive->dev_flags &= ~IDE_DFLAG_DEAD;
Linus Torvalds's avatar
Linus Torvalds committed
161
162
163
164

	/*
	 * Check for an ATAPI device
	 */
165
	if (cmd == ATA_CMD_ID_ATAPI) {
166
		u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;
167
168

		printk(KERN_CONT "ATAPI ");
Linus Torvalds's avatar
Linus Torvalds committed
169
170
		switch (type) {
			case ide_floppy:
171
172
173
174
				if (!strstr(m, "CD-ROM")) {
					if (!strstr(m, "oppy") &&
					    !strstr(m, "poyp") &&
					    !strstr(m, "ZIP"))
175
						printk(KERN_CONT "cdrom or floppy?, assuming ");
Linus Torvalds's avatar
Linus Torvalds committed
176
					if (drive->media != ide_cdrom) {
177
						printk(KERN_CONT "FLOPPY");
178
						drive->dev_flags |= IDE_DFLAG_REMOVABLE;
Linus Torvalds's avatar
Linus Torvalds committed
179
180
181
182
183
184
						break;
					}
				}
				/* Early cdrom models used zero */
				type = ide_cdrom;
			case ide_cdrom:
185
				drive->dev_flags |= IDE_DFLAG_REMOVABLE;
Linus Torvalds's avatar
Linus Torvalds committed
186
187
#ifdef CONFIG_PPC
				/* kludge for Apple PowerBook internal zip */
188
				if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
189
					printk(KERN_CONT "FLOPPY");
Linus Torvalds's avatar
Linus Torvalds committed
190
191
192
193
					type = ide_floppy;
					break;
				}
#endif
194
				printk(KERN_CONT "CD/DVD-ROM");
Linus Torvalds's avatar
Linus Torvalds committed
195
196
				break;
			case ide_tape:
197
				printk(KERN_CONT "TAPE");
Linus Torvalds's avatar
Linus Torvalds committed
198
199
				break;
			case ide_optical:
200
				printk(KERN_CONT "OPTICAL");
201
				drive->dev_flags |= IDE_DFLAG_REMOVABLE;
Linus Torvalds's avatar
Linus Torvalds committed
202
203
				break;
			default:
204
				printk(KERN_CONT "UNKNOWN (type %d)", type);
Linus Torvalds's avatar
Linus Torvalds committed
205
206
				break;
		}
207
		printk(KERN_CONT " drive\n");
Linus Torvalds's avatar
Linus Torvalds committed
208
209
210
		drive->media = type;
		/* an ATAPI device ignores DRDY */
		drive->ready_stat = 0;
211
212
		if (ata_id_cdb_intr(id))
			drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
213
		drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
214
215
		/* we don't do head unloading on ATAPI devices */
		drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
Linus Torvalds's avatar
Linus Torvalds committed
216
217
218
219
220
221
		return;
	}

	/*
	 * Not an ATAPI device: looks like a "regular" hard disk
	 */
222

223
224
225
226
	is_cfa = ata_id_is_cfa(id);

	/* CF devices are *not* removable in Linux definition of the term */
	if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
227
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
Linus Torvalds's avatar
Linus Torvalds committed
228
229

	drive->media = ide_disk;
230

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

234
	printk(KERN_CONT "%s DISK drive\n", is_cfa ? "CFA" : "ATA");
235

Linus Torvalds's avatar
Linus Torvalds committed
236
237
238
239
	return;

err_misc:
	kfree(id);
240
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
	return;
}

/**
 *	actual_try_to_identify	-	send ata/atapi identify
 *	@drive: drive to identify
 *	@cmd: command to use
 *
 *	try_to_identify() sends an ATA(PI) IDENTIFY request to a drive
 *	and waits for a response.  It also monitors irqs while this is
 *	happening, in hope of automatically determining which one is
 *	being used by the interface.
 *
 *	Returns:	0  device was identified
 *			1  device timed-out (no response to identify request)
 *			2  device aborted the command (refused to identify itself)
 */

static int actual_try_to_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
262
	struct ide_io_ports *io_ports = &hwif->io_ports;
263
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
264
	int use_altstatus = 0, rc;
Linus Torvalds's avatar
Linus Torvalds committed
265
266
267
268
269
270
	unsigned long timeout;
	u8 s = 0, a = 0;

	/* take a deep breath */
	msleep(50);

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

	/* set features register for atapi
	 * identify command to be sure of reply
	 */
288
	if (cmd == ATA_CMD_ID_ATAPI) {
289
290
291
292
293
294
		ide_task_t task;

		memset(&task, 0, sizeof(task));
		/* disable DMA & overlap */
		task.tf_flags = IDE_TFLAG_OUT_FEATURE;

295
		tp_ops->tf_load(drive, &task);
296
	}
Linus Torvalds's avatar
Linus Torvalds committed
297
298

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

301
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
302
303
304

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

306
	/* wait for IRQ and ATA_DRQ */
Linus Torvalds's avatar
Linus Torvalds committed
307
	msleep(50);
308
	s = tp_ops->read_status(hwif);
309

310
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
314
315
		/* drive returned ID */
		do_identify(drive, cmd);
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
316
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
	} else {
		/* drive refused ID */
		rc = 2;
	}
	return rc;
}

/**
 *	try_to_identify	-	try to identify a drive
 *	@drive: drive to probe
 *	@cmd: command to use
 *
 *	Issue the identify command and then do IRQ probing to
 *	complete the identification when needed by finding the
 *	IRQ the drive is attached to
 */
 
static int try_to_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
337
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
Linus Torvalds's avatar
Linus Torvalds committed
338
339
340
341
342
343
344
345
346
347
	int retval;
	int autoprobe = 0;
	unsigned long cookie = 0;

	/*
	 * Disable device irq unless we need to
	 * probe for it. Otherwise we'll get spurious
	 * interrupts during the identify-phase that
	 * the irq handler isn't expecting.
	 */
348
	if (hwif->io_ports.ctl_addr) {
Linus Torvalds's avatar
Linus Torvalds committed
349
350
351
352
		if (!hwif->irq) {
			autoprobe = 1;
			cookie = probe_irq_on();
		}
353
		tp_ops->set_irq(hwif, autoprobe);
Linus Torvalds's avatar
Linus Torvalds committed
354
355
356
357
358
359
	}

	retval = actual_try_to_identify(drive, cmd);

	if (autoprobe) {
		int irq;
360

361
		tp_ops->set_irq(hwif, 0);
Linus Torvalds's avatar
Linus Torvalds committed
362
		/* clear drive IRQ */
363
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
364
365
366
367
368
369
370
371
372
		udelay(5);
		irq = probe_irq_off(cookie);
		if (!hwif->irq) {
			if (irq > 0) {
				hwif->irq = irq;
			} else {
				/* Mmmm.. multiple IRQs..
				 * don't know which was ours
				 */
373
				printk(KERN_ERR "%s: IRQ probe failed (0x%lx)\n",
Linus Torvalds's avatar
Linus Torvalds committed
374
375
376
377
378
379
380
					drive->name, cookie);
			}
		}
	}
	return retval;
}

381
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
382
383
384
{
	u8 stat;

385
386
	timeout += jiffies;

387
	do {
388
389
390
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
391
		if ((stat & ATA_BUSY) == 0)
392
393
394
			return 0;
	} while (time_before(jiffies, timeout));

395
	return 1;	/* drive timed-out */
396
}
Linus Torvalds's avatar
Linus Torvalds committed
397

398
399
400
401
402
403
404
static u8 ide_read_device(ide_drive_t *drive)
{
	ide_task_t task;

	memset(&task, 0, sizeof(task));
	task.tf_flags = IDE_TFLAG_IN_DEVICE;

405
	drive->hwif->tp_ops->tf_read(drive, &task);
406
407
408
409

	return task.tf.device;
}

Linus Torvalds's avatar
Linus Torvalds committed
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
/**
 *	do_probe		-	probe an IDE device
 *	@drive: drive to probe
 *	@cmd: command to use
 *
 *	do_probe() has the difficult job of finding a drive if it exists,
 *	without getting hung up if it doesn't exist, without trampling on
 *	ethernet cards, and without leaving any IRQs dangling to haunt us later.
 *
 *	If a drive is "known" to exist (from CMOS or kernel parameters),
 *	but does not respond right away, the probe will "hang in there"
 *	for the maximum wait time (about 30 seconds), otherwise it will
 *	exit much more quickly.
 *
 * Returns:	0  device was identified
 *		1  device timed-out (no response to identify request)
 *		2  device aborted the command (refused to identify itself)
 *		3  bad status from device (possible for ATAPI drives)
 *		4  probe was not attempted because failure was obvious
 */

static int do_probe (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
434
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
435
	int rc;
436
437
438
439
440
	u8 present = !!(drive->dev_flags & IDE_DFLAG_PRESENT), stat;

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

#ifdef DEBUG
443
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
444
		drive->name, present, drive->media,
445
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
446
447
448
449
450
451
452
453
#endif

	/* needed for some systems
	 * (e.g. crw9624 as drive0 with disk as slave)
	 */
	msleep(50);
	SELECT_DRIVE(drive);
	msleep(50);
454

455
	if (ide_read_device(drive) != drive->select && present == 0) {
456
		if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
457
458
			/* exit with drive0 selected */
			SELECT_DRIVE(&hwif->drives[0]);
459
			/* allow ATA_BUSY to assert & clear */
Linus Torvalds's avatar
Linus Torvalds committed
460
461
462
463
464
465
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

466
	stat = tp_ops->read_status(hwif);
467

468
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
469
	    present || cmd == ATA_CMD_ID_ATAPI) {
Linus Torvalds's avatar
Linus Torvalds committed
470
471
472
473
474
		/* send cmd and wait */
		if ((rc = try_to_identify(drive, cmd))) {
			/* failed: try again */
			rc = try_to_identify(drive,cmd);
		}
475

476
		stat = tp_ops->read_status(hwif);
477

478
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
479
480
			return 4;

481
		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
482
483
			printk(KERN_ERR "%s: no response (status = 0x%02x), "
					"resetting drive\n", drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
484
			msleep(50);
485
			SELECT_DRIVE(drive);
Linus Torvalds's avatar
Linus Torvalds committed
486
			msleep(50);
487
			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
488
			(void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
Linus Torvalds's avatar
Linus Torvalds committed
489
490
			rc = try_to_identify(drive, cmd);
		}
491
492

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

Linus Torvalds's avatar
Linus Torvalds committed
495
		if (rc == 1)
496
497
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
498
499
500
501
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
502
	if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
503
504
505
506
		/* exit with drive0 selected */
		SELECT_DRIVE(&hwif->drives[0]);
		msleep(50);
		/* ensure drive irq is clear */
507
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
508
509
510
511
512
513
514
515
516
517
	}
	return rc;
}

/*
 *
 */
static void enable_nest (ide_drive_t *drive)
{
	ide_hwif_t *hwif = HWIF(drive);
518
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
519
	u8 stat;
Linus Torvalds's avatar
Linus Torvalds committed
520

521
522
	printk(KERN_INFO "%s: enabling %s -- ",
		hwif->name, (char *)&drive->id[ATA_ID_PROD]);
523

Linus Torvalds's avatar
Linus Torvalds committed
524
525
	SELECT_DRIVE(drive);
	msleep(50);
526
	tp_ops->exec_command(hwif, ATA_EXABYTE_ENABLE_NEST);
527

528
	if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 0)) {
529
530
531
		printk(KERN_CONT "failed (timeout)\n");
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
532
533
534

	msleep(50);

535
	stat = tp_ops->read_status(hwif);
536
537
538
539
540

	if (!OK_STAT(stat, 0, BAD_STAT))
		printk(KERN_CONT "failed (status = 0x%02x)\n", stat);
	else
		printk(KERN_CONT "success\n");
Linus Torvalds's avatar
Linus Torvalds committed
541
542
543
544
545
546
547
548
549
550
}

/**
 *	probe_for_drives	-	upper level drive probe
 *	@drive: drive to probe for
 *
 *	probe_for_drive() tests for existence of a given drive using do_probe()
 *	and presents things to the user as needed.
 *
 *	Returns:	0  no device was found
551
552
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
553
 */
554
555

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
556
{
557
558
	char *m;

Linus Torvalds's avatar
Linus Torvalds committed
559
560
561
562
563
564
565
566
567
	/*
	 *	In order to keep things simple we have an id
	 *	block for all drives at all times. If the device
	 *	is pre ATA or refuses ATA/ATAPI identify we
	 *	will add faked data to this.
	 *
	 *	Also note that 0 everywhere means "can't do X"
	 */
 
568
569
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

570
	drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
571
	if (drive->id == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
572
573
574
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
575
576
577
578

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

Linus Torvalds's avatar
Linus Torvalds committed
579
	/* skip probing? */
580
	if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
581
retry:
Linus Torvalds's avatar
Linus Torvalds committed
582
		/* if !(success||timed-out) */
583
		if (do_probe(drive, ATA_CMD_ID_ATA) >= 2)
Linus Torvalds's avatar
Linus Torvalds committed
584
			/* look for ATAPI device */
585
			(void)do_probe(drive, ATA_CMD_ID_ATAPI);
586

587
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
588
589
			/* drive not found */
			return 0;
590

591
		if (strstr(m, "E X A B Y T E N E S T")) {
Alan Cox's avatar
Alan Cox committed
592
			enable_nest(drive);
593
594
595
			goto retry;
		}

Linus Torvalds's avatar
Linus Torvalds committed
596
		/* identification failed? */
597
		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
598
599
600
601
602
603
604
605
606
			if (drive->media == ide_disk) {
				printk(KERN_INFO "%s: non-IDE drive, CHS=%d/%d/%d\n",
					drive->name, drive->cyl,
					drive->head, drive->sect);
			} else if (drive->media == ide_cdrom) {
				printk(KERN_INFO "%s: ATAPI cdrom (?)\n", drive->name);
			} else {
				/* nuke it */
				printk(KERN_WARNING "%s: Unknown device on bus refused identification. Ignoring.\n", drive->name);
607
				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
608
609
610
611
			}
		}
		/* drive was found */
	}
612
613

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
614
		return 0;
615

Linus Torvalds's avatar
Linus Torvalds committed
616
	/* The drive wasn't being helpful. Add generic info only */
617
	if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
618
619
620
621
622
623
624
625
626
		generic_id(drive);
		return 1;
	}

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

627
	return !!(drive->dev_flags & IDE_DFLAG_PRESENT);
Linus Torvalds's avatar
Linus Torvalds committed
628
629
}

Pavel Machek's avatar
Pavel Machek committed
630
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
631
632
633
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

634
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
635
636
}

637
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
638
{
639
640
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
641
	/* register with global device tree */
642
	dev_set_name(&hwif->gendev, hwif->name);
Linus Torvalds's avatar
Linus Torvalds committed
643
644
	hwif->gendev.driver_data = hwif;
	if (hwif->gendev.parent == NULL) {
645
646
		if (hwif->dev)
			hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
647
648
649
650
651
		else
			/* Would like to do = &device_legacy */
			hwif->gendev.parent = NULL;
	}
	hwif->gendev.release = hwif_release_dev;
652
	ret = device_register(&hwif->gendev);
653
	if (ret < 0) {
654
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
655
			__func__, ret);
656
657
658
		goto out;
	}

659
660
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
				      MKDEV(0, 0), hwif, hwif->name);
661
662
663
664
665
666
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
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
/**
 *	ide_port_wait_ready	-	wait for port to become ready
 *	@hwif: IDE port
 *
 *	This is needed on some PPCs and a bunch of BIOS-less embedded
 *	platforms.  Typical cases are:
 *
 *	- The firmware hard reset the disk before booting the kernel,
 *	  the drive is still doing it's poweron-reset sequence, that
 *	  can take up to 30 seconds.
 *
 *	- The firmware does nothing (or no firmware), the device is
 *	  still in POST state (same as above actually).
 *
 *	- Some CD/DVD/Writer combo drives tend to drive the bus during
 *	  their reset sequence even when they are non-selected slave
 *	  devices, thus preventing discovery of the main HD.
 *
 *	Doing this wait-for-non-busy should not harm any existing
 *	configuration and fix some issues like the above.
 *
 *	BenH.
 *
 *	Returns 0 on success, error code (< 0) otherwise.
 */

static int ide_port_wait_ready(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
696
{
697
	int unit, rc;
Linus Torvalds's avatar
Linus Torvalds committed
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713

	printk(KERN_DEBUG "Probing IDE interface %s...\n", hwif->name);

	/* Let HW settle down a bit from whatever init state we
	 * come from */
	mdelay(2);

	/* Wait for BSY bit to go away, spec timeout is 30 seconds,
	 * I know of at least one disk who takes 31 seconds, I use 35
	 * here to be safe
	 */
	rc = ide_wait_not_busy(hwif, 35000);
	if (rc)
		return rc;

	/* Now make sure both master & slave are ready */
714
715
716
717
	for (unit = 0; unit < MAX_DRIVES; unit++) {
		ide_drive_t *drive = &hwif->drives[unit];

		/* Ignore disks that we will not probe for later. */
718
719
		if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
		    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
720
			SELECT_DRIVE(drive);
721
			hwif->tp_ops->set_irq(hwif, 1);
722
723
724
725
726
727
728
729
730
			mdelay(2);
			rc = ide_wait_not_busy(hwif, 35000);
			if (rc)
				goto out;
		} else
			printk(KERN_DEBUG "%s: ide_wait_not_busy() skipped\n",
					  drive->name);
	}
out:
Linus Torvalds's avatar
Linus Torvalds committed
731
	/* Exit function with master reselected (let's be sane) */
732
733
734
	if (unit)
		SELECT_DRIVE(&hwif->drives[0]);

Linus Torvalds's avatar
Linus Torvalds committed
735
736
737
738
739
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
740
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
741
742
743
744
745
746
 *
 *	Analyse the drives on the interface and attempt to decide if we
 *	have the same drive viewed twice. This occurs with crap CF adapters
 *	and PCMCIA sometimes.
 */

747
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
748
{
749
	ide_drive_t *dev0 = &dev1->hwif->drives[0];
Linus Torvalds's avatar
Linus Torvalds committed
750

751
	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
752
753
754
		return;

	/* If the models don't match they are not the same product */
755
756
	if (strcmp((char *)&dev0->id[ATA_ID_PROD],
		   (char *)&dev1->id[ATA_ID_PROD]))
Linus Torvalds's avatar
Linus Torvalds committed
757
758
759
		return;

	/* Serial numbers do not match */
760
761
	if (strncmp((char *)&dev0->id[ATA_ID_SERNO],
		    (char *)&dev1->id[ATA_ID_SERNO], ATA_ID_SERNO_LEN))
Linus Torvalds's avatar
Linus Torvalds committed
762
763
764
		return;

	/* No serial number, thankfully very rare for CF */
765
	if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
Linus Torvalds's avatar
Linus Torvalds committed
766
767
768
769
770
		return;

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

771
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
772
773
774
775
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

776
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
777
778
779
{
	unsigned long flags;
	unsigned int irqd;
780
781
782
	int unit, rc = -ENODEV;

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

784
785
	if ((hwif->drives[0].dev_flags & IDE_DFLAG_NOPROBE) &&
	    (hwif->drives[1].dev_flags & IDE_DFLAG_NOPROBE))
786
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
787
788
789
790
791
792
793
794
795
796
797

	/*
	 * We must always disable IRQ, as probe_for_drive will assert IRQ, but
	 * we'll install our IRQ driver much later...
	 */
	irqd = hwif->irq;
	if (irqd)
		disable_irq(hwif->irq);

	local_irq_set(flags);

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

	/*
802
803
	 * Second drive should only exist if first drive was found,
	 * but a lot of cdrom drives are configured as single slaves.
Linus Torvalds's avatar
Linus Torvalds committed
804
	 */
805
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
Linus Torvalds's avatar
Linus Torvalds committed
806
		ide_drive_t *drive = &hwif->drives[unit];
807

Linus Torvalds's avatar
Linus Torvalds committed
808
		(void) probe_for_drive(drive);
809
		if (drive->dev_flags & IDE_DFLAG_PRESENT)
810
			rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
811
	}
812

Linus Torvalds's avatar
Linus Torvalds committed
813
	local_irq_restore(flags);
814

Linus Torvalds's avatar
Linus Torvalds committed
815
816
817
818
819
820
821
	/*
	 * Use cached IRQ number. It might be (and is...) changed by probe
	 * code above
	 */
	if (irqd)
		enable_irq(irqd);

822
	return rc;
823
824
825
826
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
827
	const struct ide_port_ops *port_ops = hwif->port_ops;
828
829
	int unit;

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

833
834
835
836
		if (drive->dev_flags & IDE_DFLAG_PRESENT) {
			if (port_ops && port_ops->quirkproc)
				port_ops->quirkproc(drive);
		}
837
	}
838

Linus Torvalds's avatar
Linus Torvalds committed
839
840
841
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		ide_drive_t *drive = &hwif->drives[unit];

842
		if (drive->dev_flags & IDE_DFLAG_PRESENT) {
843
			ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
844

845
			drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
846

847
			if (hwif->dma_ops)
848
				ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
849
850
		}
	}
851
852
853
854

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

855
856
857
		if ((hwif->host_flags & IDE_HFLAG_NO_IO_32BIT) ||
		    drive->id[ATA_ID_DWORD_IO])
			drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
858
		else
859
			drive->dev_flags &= ~IDE_DFLAG_NO_IO_32BIT;
860
	}
Linus Torvalds's avatar
Linus Torvalds committed
861
862
863
864
865
866
867
}

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
868
	struct request_queue *q;
Linus Torvalds's avatar
Linus Torvalds committed
869
870
871
872
873
874
875
876
877
878
879
	ide_hwif_t *hwif = HWIF(drive);
	int max_sectors = 256;
	int max_sg_entries = PRD_ENTRIES;

	/*
	 *	Our default set up assumes the normal IDE case,
	 *	that is 64K segmenting, standard PRD setup
	 *	and LBA28. Some drivers then impose their own
	 *	limits and LBA48 we could raise it but as yet
	 *	do not.
	 */
880

881
882
	q = blk_init_queue_node(do_ide_request, &hwif->hwgroup->lock,
				hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
	if (!q)
		return 1;

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

	if (hwif->rqsize < max_sectors)
		max_sectors = hwif->rqsize;
	blk_queue_max_sectors(q, max_sectors);

#ifdef CONFIG_PCI
	/* When we have an IOMMU, we may have a problem where pci_map_sg()
	 * creates segments that don't completely match our boundary
	 * requirements and thus need to be broken up again. Because it
	 * doesn't align properly either, we may actually have to break up
	 * to more segments than what was we got in the first place, a max
	 * worst case is twice as many.
	 * This will be fixed once we teach pci_map_sg() about our boundary
	 * requirements, hopefully soon. *FIXME*
	 */
	if (!PCI_DMA_BUS_IS_PHYS)
		max_sg_entries >>= 1;
#endif /* CONFIG_PCI */

	blk_queue_max_hw_segments(q, max_sg_entries);
	blk_queue_max_phys_segments(q, max_sg_entries);

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

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

	return 0;
}

919
920
921
922
static void ide_add_drive_to_hwgroup(ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;

923
	spin_lock_irq(&hwgroup->lock);
924
925
926
927
928
929
930
931
932
	if (!hwgroup->drive) {
		/* first drive for hwgroup. */
		drive->next = drive;
		hwgroup->drive = drive;
		hwgroup->hwif = HWIF(hwgroup->drive);
	} else {
		drive->next = hwgroup->drive->next;
		hwgroup->drive->next = drive;
	}
933
	spin_unlock_irq(&hwgroup->lock);
934
935
}

936
937
938
939
940
/*
 * For any present drive:
 * - allocate the block device queue
 * - link drive into the hwgroup
 */
941
static int ide_port_setup_devices(ide_hwif_t *hwif)
942
{
943
	int i, j = 0;
944

945
	mutex_lock(&ide_cfg_mtx);
946
947
948
	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive = &hwif->drives[i];

949
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
950
951
952
953
954
			continue;

		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
955
956
957
			kfree(drive->id);
			drive->id = NULL;
			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
958
959
960
			continue;
		}

961
962
		j++;

963
964
		ide_add_drive_to_hwgroup(drive);
	}
965
	mutex_unlock(&ide_cfg_mtx);
966
967

	return j;
968
969
}

970
971
static ide_hwif_t *ide_ports[MAX_HWIFS];

972
973
974
975
void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
{
	ide_hwgroup_t *hwgroup = hwif->hwgroup;

976
977
	ide_ports[hwif->index] = NULL;

978
	spin_lock_irq(&hwgroup->lock);
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
	/*
	 * Remove us from the hwgroup, and free
	 * the hwgroup if we were the only member
	 */
	if (hwif->next == hwif) {
		BUG_ON(hwgroup->hwif != hwif);
		kfree(hwgroup);
	} else {
		/* There is another interface in hwgroup.
		 * Unlink us, and set hwgroup->drive and ->hwif to
		 * something sane.
		 */
		ide_hwif_t *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.
			 */
For faster browsing, not all history is shown. View entire blame