ide-probe.c 38.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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
static void ide_classify_ata_dev(ide_drive_t *drive)
{
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
	int is_cfa = ata_id_is_cfa(id);

	/* CF devices are *not* removable in Linux definition of the term */
	if (is_cfa == 0 && (id[ATA_ID_CONFIG] & (1 << 7)))
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;

	drive->media = ide_disk;

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

	printk(KERN_INFO "%s: %s, %s DISK drive\n", drive->name, m,
		is_cfa ? "CFA" : "ATA");
}

static void ide_classify_atapi_dev(ide_drive_t *drive)
{
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
	u8 type = (id[ATA_ID_CONFIG] >> 8) & 0x1f;

	printk(KERN_INFO "%s: %s, ATAPI ", drive->name, m);
	switch (type) {
	case ide_floppy:
		if (!strstr(m, "CD-ROM")) {
			if (!strstr(m, "oppy") &&
			    !strstr(m, "poyp") &&
			    !strstr(m, "ZIP"))
				printk(KERN_CONT "cdrom or floppy?, assuming ");
			if (drive->media != ide_cdrom) {
				printk(KERN_CONT "FLOPPY");
				drive->dev_flags |= IDE_DFLAG_REMOVABLE;
				break;
			}
		}
		/* Early cdrom models used zero */
		type = ide_cdrom;
	case ide_cdrom:
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
#ifdef CONFIG_PPC
		/* kludge for Apple PowerBook internal zip */
		if (!strstr(m, "CD-ROM") && strstr(m, "ZIP")) {
			printk(KERN_CONT "FLOPPY");
			type = ide_floppy;
			break;
		}
#endif
		printk(KERN_CONT "CD/DVD-ROM");
		break;
	case ide_tape:
		printk(KERN_CONT "TAPE");
		break;
	case ide_optical:
		printk(KERN_CONT "OPTICAL");
		drive->dev_flags |= IDE_DFLAG_REMOVABLE;
		break;
	default:
		printk(KERN_CONT "UNKNOWN (type %d)", type);
		break;
	}

	printk(KERN_CONT " drive\n");
	drive->media = type;
	/* an ATAPI device ignores DRDY */
	drive->ready_stat = 0;
	if (ata_id_cdb_intr(id))
		drive->atapi_flags |= IDE_AFLAG_DRQ_INTERRUPT;
	drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
	/* we don't do head unloading on ATAPI devices */
	drive->dev_flags |= IDE_DFLAG_NO_UNLOAD;
}

Linus Torvalds's avatar
Linus Torvalds committed
180
181
182
183
184
185
186
187
188
/**
 *	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. 
 */
189
190

static void do_identify(ide_drive_t *drive, u8 cmd)
Linus Torvalds's avatar
Linus Torvalds committed
191
{
192
	ide_hwif_t *hwif = drive->hwif;
193
194
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
195
	unsigned long flags;
196
	int bswap = 1;
Linus Torvalds's avatar
Linus Torvalds committed
197

198
199
	/* local CPU only; some systems need this */
	local_irq_save(flags);
Linus Torvalds's avatar
Linus Torvalds committed
200
	/* read 512 bytes of id info */
201
	hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
202
	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
203

204
	drive->dev_flags |= IDE_DFLAG_ID_READ;
205
206
207
208
#ifdef DEBUG
	printk(KERN_INFO "%s: dumping identify data\n", drive->name);
	ide_dump_identify((u8 *)id);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
209
210
211
	ide_fix_driveid(id);

	/*
212
213
	 *  ATA_CMD_ID_ATA returns little-endian info,
	 *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
Linus Torvalds's avatar
Linus Torvalds committed
214
	 */
215
	if (cmd == ATA_CMD_ID_ATAPI) {
216
217
218
		if ((m[0] == 'N' && m[1] == 'E') ||  /* NEC */
		    (m[0] == 'F' && m[1] == 'X') ||  /* Mitsumi */
		    (m[0] == 'P' && m[1] == 'i'))    /* Pioneer */
Linus Torvalds's avatar
Linus Torvalds committed
219
			/* Vertos drives may still be weird */
220
			bswap ^= 1;
Linus Torvalds's avatar
Linus Torvalds committed
221
	}
222
223
224
225

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

227
	/* we depend on this a lot! */
228
	m[ATA_ID_PROD_LEN - 1] = '\0';
229

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

233
234
	drive->dev_flags |= IDE_DFLAG_PRESENT;
	drive->dev_flags &= ~IDE_DFLAG_DEAD;
Linus Torvalds's avatar
Linus Torvalds committed
235
236
237
238

	/*
	 * Check for an ATAPI device
	 */
239
240
241
	if (cmd == ATA_CMD_ID_ATAPI)
		ide_classify_atapi_dev(drive);
	else
Linus Torvalds's avatar
Linus Torvalds committed
242
243
244
	/*
	 * Not an ATAPI device: looks like a "regular" hard disk
	 */
245
		ide_classify_ata_dev(drive);
Linus Torvalds's avatar
Linus Torvalds committed
246
247
248
	return;
err_misc:
	kfree(id);
249
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
}

/**
 *	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)
{
269
	ide_hwif_t *hwif = drive->hwif;
270
	struct ide_io_ports *io_ports = &hwif->io_ports;
271
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
272
	int use_altstatus = 0, rc;
Linus Torvalds's avatar
Linus Torvalds committed
273
274
275
276
277
278
	unsigned long timeout;
	u8 s = 0, a = 0;

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

279
280
	if (io_ports->ctl_addr &&
	    (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) {
281
282
		a = tp_ops->read_altstatus(hwif);
		s = tp_ops->read_status(hwif);
283
		if ((a ^ s) & ~ATA_IDX)
Linus Torvalds's avatar
Linus Torvalds committed
284
			/* ancient Seagate drives, broken interfaces */
285
286
287
288
			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
289
			/* use non-intrusive polling */
290
291
			use_altstatus = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
292
293
294
295

	/* set features register for atapi
	 * identify command to be sure of reply
	 */
296
	if (cmd == ATA_CMD_ID_ATAPI) {
297
298
299
300
301
302
		ide_task_t task;

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

303
		tp_ops->tf_load(drive, &task);
304
	}
Linus Torvalds's avatar
Linus Torvalds committed
305
306

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

309
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
310
311
312

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

314
	/* wait for IRQ and ATA_DRQ */
Linus Torvalds's avatar
Linus Torvalds committed
315
	msleep(50);
316
	s = tp_ops->read_status(hwif);
317

318
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
Linus Torvalds's avatar
Linus Torvalds committed
319
320
321
322
323
		/* drive returned ID */
		do_identify(drive, cmd);
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
324
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
	} 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)
{
344
	ide_hwif_t *hwif = drive->hwif;
345
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
Linus Torvalds's avatar
Linus Torvalds committed
346
347
348
349
350
351
352
353
354
355
	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.
	 */
356
	if (hwif->io_ports.ctl_addr) {
Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
		if (!hwif->irq) {
			autoprobe = 1;
			cookie = probe_irq_on();
		}
361
		tp_ops->set_irq(hwif, autoprobe);
Linus Torvalds's avatar
Linus Torvalds committed
362
363
364
365
366
367
	}

	retval = actual_try_to_identify(drive, cmd);

	if (autoprobe) {
		int irq;
368

369
		tp_ops->set_irq(hwif, 0);
Linus Torvalds's avatar
Linus Torvalds committed
370
		/* clear drive IRQ */
371
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
372
373
374
375
376
377
378
379
380
		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
				 */
381
				printk(KERN_ERR "%s: IRQ probe failed (0x%lx)\n",
Linus Torvalds's avatar
Linus Torvalds committed
382
383
384
385
386
387
388
					drive->name, cookie);
			}
		}
	}
	return retval;
}

389
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
390
391
392
{
	u8 stat;

393
394
	timeout += jiffies;

395
	do {
396
397
398
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
399
		if ((stat & ATA_BUSY) == 0)
400
401
402
			return 0;
	} while (time_before(jiffies, timeout));

403
	return 1;	/* drive timed-out */
404
}
Linus Torvalds's avatar
Linus Torvalds committed
405

406
407
408
409
410
411
412
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;

413
	drive->hwif->tp_ops->tf_read(drive, &task);
414
415
416
417

	return task.tf.device;
}

Linus Torvalds's avatar
Linus Torvalds committed
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
/**
 *	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)
{
441
	ide_hwif_t *hwif = drive->hwif;
442
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
443
	int rc;
444
445
446
447
448
	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
449
450

#ifdef DEBUG
451
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
452
		drive->name, present, drive->media,
453
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
454
455
456
457
458
459
460
461
#endif

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

463
	if (ide_read_device(drive) != drive->select && present == 0) {
464
		if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
465
			/* exit with drive0 selected */
466
			SELECT_DRIVE(hwif->devices[0]);
467
			/* allow ATA_BUSY to assert & clear */
Linus Torvalds's avatar
Linus Torvalds committed
468
469
470
471
472
473
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

474
	stat = tp_ops->read_status(hwif);
475

476
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
477
	    present || cmd == ATA_CMD_ID_ATAPI) {
Linus Torvalds's avatar
Linus Torvalds committed
478
479
480
481
482
		/* send cmd and wait */
		if ((rc = try_to_identify(drive, cmd))) {
			/* failed: try again */
			rc = try_to_identify(drive,cmd);
		}
483

484
		stat = tp_ops->read_status(hwif);
485

486
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
487
488
			return 4;

489
		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
490
491
			printk(KERN_ERR "%s: no response (status = 0x%02x), "
					"resetting drive\n", drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
492
			msleep(50);
493
			SELECT_DRIVE(drive);
Linus Torvalds's avatar
Linus Torvalds committed
494
			msleep(50);
495
			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
496
			(void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
Linus Torvalds's avatar
Linus Torvalds committed
497
498
			rc = try_to_identify(drive, cmd);
		}
499
500

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

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

/*
 *
 */
static void enable_nest (ide_drive_t *drive)
{
525
	ide_hwif_t *hwif = drive->hwif;
526
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
527
	u8 stat;
Linus Torvalds's avatar
Linus Torvalds committed
528

529
530
	printk(KERN_INFO "%s: enabling %s -- ",
		hwif->name, (char *)&drive->id[ATA_ID_PROD]);
531

Linus Torvalds's avatar
Linus Torvalds committed
532
533
	SELECT_DRIVE(drive);
	msleep(50);
534
	tp_ops->exec_command(hwif, ATA_EXABYTE_ENABLE_NEST);
535

536
	if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 0)) {
537
538
539
		printk(KERN_CONT "failed (timeout)\n");
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
540
541
542

	msleep(50);

543
	stat = tp_ops->read_status(hwif);
544
545
546
547
548

	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
549
550
551
552
553
554
555
556
557
558
}

/**
 *	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
559
560
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
561
 */
562
563

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
564
{
565
566
	char *m;

Linus Torvalds's avatar
Linus Torvalds committed
567
568
569
570
571
572
573
574
575
	/*
	 *	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"
	 */
 
576
577
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

578
	drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
579
	if (drive->id == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
580
581
582
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
583
584
585
586

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

Linus Torvalds's avatar
Linus Torvalds committed
587
	/* skip probing? */
588
	if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
589
retry:
Linus Torvalds's avatar
Linus Torvalds committed
590
		/* if !(success||timed-out) */
591
		if (do_probe(drive, ATA_CMD_ID_ATA) >= 2)
Linus Torvalds's avatar
Linus Torvalds committed
592
			/* look for ATAPI device */
593
			(void)do_probe(drive, ATA_CMD_ID_ATAPI);
594

595
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
596
597
			/* drive not found */
			return 0;
598

599
		if (strstr(m, "E X A B Y T E N E S T")) {
Alan Cox's avatar
Alan Cox committed
600
			enable_nest(drive);
601
602
603
			goto retry;
		}

Linus Torvalds's avatar
Linus Torvalds committed
604
		/* identification failed? */
605
		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
606
607
608
609
610
611
612
613
614
			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);
615
				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
616
617
618
619
			}
		}
		/* drive was found */
	}
620
621

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

Linus Torvalds's avatar
Linus Torvalds committed
624
	/* The drive wasn't being helpful. Add generic info only */
625
	if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
626
627
628
629
630
631
632
633
634
		generic_id(drive);
		return 1;
	}

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

635
	return !!(drive->dev_flags & IDE_DFLAG_PRESENT);
Linus Torvalds's avatar
Linus Torvalds committed
636
637
}

Pavel Machek's avatar
Pavel Machek committed
638
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
639
640
641
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

642
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
643
644
}

645
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
646
{
647
648
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
649
	/* register with global device tree */
650
	dev_set_name(&hwif->gendev, hwif->name);
Linus Torvalds's avatar
Linus Torvalds committed
651
	hwif->gendev.driver_data = hwif;
Andreas Schwab's avatar
Andreas Schwab committed
652
653
	if (hwif->gendev.parent == NULL)
		hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
654
	hwif->gendev.release = hwif_release_dev;
655

656
	ret = device_register(&hwif->gendev);
657
	if (ret < 0) {
658
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
659
			__func__, ret);
660
661
662
		goto out;
	}

663
664
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
				      MKDEV(0, 0), hwif, hwif->name);
665
666
667
668
669
670
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
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
/**
 *	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
700
{
701
702
	ide_drive_t *drive;
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718

	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 */
719
	ide_port_for_each_dev(i, drive, hwif) {
720
		/* Ignore disks that we will not probe for later. */
721
722
		if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
		    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
723
			SELECT_DRIVE(drive);
724
			hwif->tp_ops->set_irq(hwif, 1);
725
726
727
728
729
730
731
732
733
			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
734
	/* Exit function with master reselected (let's be sane) */
735
	if (i)
736
		SELECT_DRIVE(hwif->devices[0]);
737

Linus Torvalds's avatar
Linus Torvalds committed
738
739
740
741
742
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
743
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
744
745
746
747
748
749
 *
 *	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.
 */

750
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
751
{
752
	ide_drive_t *dev0 = dev1->hwif->devices[0];
Linus Torvalds's avatar
Linus Torvalds committed
753

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

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

	/* Serial numbers do not match */
763
764
	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
765
766
767
		return;

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

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

774
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
775
776
777
778
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

779
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
780
{
781
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
782
	unsigned int irqd;
783
	int i, rc = -ENODEV;
784
785

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

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

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

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

	/*
803
804
	 * 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
805
	 */
806
	ide_port_for_each_dev(i, drive, hwif) {
Linus Torvalds's avatar
Linus Torvalds committed
807
		(void) probe_for_drive(drive);
808
		if (drive->dev_flags & IDE_DFLAG_PRESENT)
809
			rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
810
	}
811

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

819
	return rc;
820
821
822
823
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
824
	const struct ide_port_ops *port_ops = hwif->port_ops;
825
826
	ide_drive_t *drive;
	int i;
827

828
829
830
	ide_port_for_each_present_dev(i, drive, hwif) {
		if (port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
831
	}
832

833
834
	ide_port_for_each_present_dev(i, drive, hwif) {
		ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
835

836
		drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
837

838
839
		if (hwif->dma_ops)
			ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
840
841
842
843
844
845
846
847
	}
}

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
848
	struct request_queue *q;
849
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
850
851
852
853
854
855
856
857
858
859
	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.
	 */
860

861
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
	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;
}

898
899
static DEFINE_MUTEX(ide_cfg_mtx);

900
901
902
903
/*
 * For any present drive:
 * - allocate the block device queue
 */
904
static int ide_port_setup_devices(ide_hwif_t *hwif)
905
{
906
	ide_drive_t *drive;
907
	int i, j = 0;
908

909
	mutex_lock(&ide_cfg_mtx);
910
	ide_port_for_each_present_dev(i, drive, hwif) {
911
912
913
		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
914
915
916
			kfree(drive->id);
			drive->id = NULL;
			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
917
918
919
			continue;
		}

920
		j++;
921
	}
922
	mutex_unlock(&ide_cfg_mtx);
923
924

	return j;
925
926
}

Linus Torvalds's avatar
Linus Torvalds committed
927
/*
928
 * This routine sets up the IRQ for an IDE interface.
Linus Torvalds's avatar
Linus Torvalds committed
929
930
931
 */
static int init_irq (ide_hwif_t *hwif)
{
932
	struct ide_io_ports *io_ports = &hwif->io_ports;
933
	irq_handler_t irq_handler;
934
	int sa = 0;
Linus Torvalds's avatar
Linus Torvalds committed
935

936
937
938
939
	irq_handler = hwif->host->irq_handler;
	if (irq_handler == NULL)
		irq_handler = ide_intr;

Adrian Bunk's avatar
Adrian Bunk committed
940
#if defined(__mc68000__)
941
	sa = IRQF_SHARED;
942
#endif /* __mc68000__ */
Linus Torvalds's avatar
Linus Torvalds committed
943

944
945
	if (hwif->chipset == ide_pci)
		sa = IRQF_SHARED;
Linus Torvalds's avatar
Linus Torvalds committed
946

947
948
	if (io_ports->ctl_addr)
		hwif->tp_ops->set_irq(hwif, 1);
Linus Torvalds's avatar
Linus Torvalds committed
949

950
	if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
951
		goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
952

953
954
955
956
957
958
959
960
	if (!hwif->rqsize) {
		if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
		    (hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA))
			hwif->rqsize = 256;
		else
			hwif->rqsize = 65536;
	}

Adrian Bunk's avatar
Adrian Bunk committed
961
#if !defined(__mc68000__)
962
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
963
964
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
965
#else
966
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
967
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
968
#endif /* __mc68000__ */
969
970
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
		printk(KERN_CONT " (serialized)");
971
	printk(KERN_CONT "\n");
972

Linus Torvalds's avatar
Linus Torvalds committed
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
	return 0;
out_up:
	return 1;
}

static int ata_lock(dev_t dev, void *data)
{
	/* FIXME: we want to pin hwif down */
	return 0;
}

static struct kobject *ata_probe(dev_t dev, int *part, void *data)
{
	ide_hwif_t *hwif = data;
	int unit = *part >> PARTN_BITS;
988
	ide_drive_t *drive = hwif->devices[unit];
989
990

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
991
992
993
994
995
996
997
998
999
1000
		return NULL;

	if (drive->media == ide_disk)
		request_module("ide-disk");
	if (drive->media == ide_cdrom || drive->media == ide_optical)
		request_module("ide-cd");
	if (drive->media == ide_tape)
		request_module("ide-tape");
	if (drive->media == ide_floppy)
		request_module("ide-floppy");