ide-probe.c 39.3 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;
652
	hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
653
	hwif->gendev.release = hwif_release_dev;
654

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

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

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

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

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

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

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

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

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

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

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

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

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

778
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
779
{
780
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
781
782
	unsigned long flags;
	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
800
	local_irq_save(flags);
	local_irq_enable_in_hardirq();
Linus Torvalds's avatar
Linus Torvalds committed
801

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

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

Linus Torvalds's avatar
Linus Torvalds committed
815
	local_irq_restore(flags);
816

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

824
	return rc;
825
826
827
828
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
829
	const struct ide_port_ops *port_ops = hwif->port_ops;
830
831
	ide_drive_t *drive;
	int i;
832

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

840
	ide_port_for_each_dev(i, drive, hwif) {
841
		if (drive->dev_flags & IDE_DFLAG_PRESENT) {
842
			ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
843

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

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

851
	ide_port_for_each_dev(i, drive, hwif) {
852
		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
853
			drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
854
		else
855
			drive->dev_flags &= ~IDE_DFLAG_NO_IO_32BIT;
856
	}
Linus Torvalds's avatar
Linus Torvalds committed
857
858
859
860
861
862
863
}

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
864
	struct request_queue *q;
865
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
866
867
868
869
870
871
872
873
874
875
	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.
	 */
876

877
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
878
879
880
881
882
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
	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;
}

914
915
static DEFINE_MUTEX(ide_cfg_mtx);

916
917
918
919
/*
 * For any present drive:
 * - allocate the block device queue
 */
920
static int ide_port_setup_devices(ide_hwif_t *hwif)
921
{
922
	ide_drive_t *drive;
923
	int i, j = 0;
924

925
	mutex_lock(&ide_cfg_mtx);
926
	ide_port_for_each_dev(i, drive, hwif) {
927
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
928
929
930
931
932
			continue;

		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
933
934
935
			kfree(drive->id);
			drive->id = NULL;
			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
936
937
938
			continue;
		}

939
		j++;
940
	}
941
	mutex_unlock(&ide_cfg_mtx);
942
943

	return j;
944
945
}

Linus Torvalds's avatar
Linus Torvalds committed
946
/*
947
 * This routine sets up the IRQ for an IDE interface.
Linus Torvalds's avatar
Linus Torvalds committed
948
949
950
 */
static int init_irq (ide_hwif_t *hwif)
{
951
	struct ide_io_ports *io_ports = &hwif->io_ports;
952
	int sa = 0;
Linus Torvalds's avatar
Linus Torvalds committed
953

954
	mutex_lock(&ide_cfg_mtx);
955
	spin_lock_init(&hwif->lock);
956

957
958
959
	init_timer(&hwif->timer);
	hwif->timer.function = &ide_timer_expiry;
	hwif->timer.data = (unsigned long)hwif;
960

Adrian Bunk's avatar
Adrian Bunk committed
961
#if defined(__mc68000__)
962
	sa = IRQF_SHARED;
963
#endif /* __mc68000__ */
Linus Torvalds's avatar
Linus Torvalds committed
964

965
966
	if (hwif->chipset == ide_pci)
		sa = IRQF_SHARED;
Linus Torvalds's avatar
Linus Torvalds committed
967

968
969
	if (io_ports->ctl_addr)
		hwif->tp_ops->set_irq(hwif, 1);
Linus Torvalds's avatar
Linus Torvalds committed
970

971
	if (request_irq(hwif->irq, &ide_intr, sa, hwif->name, hwif))
972
		goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
973

974
975
976
977
978
979
980
981
	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
982
#if !defined(__mc68000__)
983
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
984
985
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
986
#else
987
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
988
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
989
#endif /* __mc68000__ */
990
991
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
		printk(KERN_CONT " (serialized)");
992
	printk(KERN_CONT "\n");
993

994
	mutex_unlock(&ide_cfg_mtx);
Linus Torvalds's avatar
Linus Torvalds committed
995
996
	return 0;
out_up:
997
	mutex_unlock(&ide_cfg_mtx);
Linus Torvalds's avatar
Linus Torvalds committed
998
999
1000
	return 1;
}