ide-probe.c 36.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
/**
 *	do_identify	-	identify a drive
 *	@drive: drive to identify 
 *	@cmd: command used
184
 *	@id: buffer for IDENTIFY data
Linus Torvalds's avatar
Linus Torvalds committed
185
186
187
188
189
 *
 *	Called when we have issued a drive identify command to
 *	read and parse the results. This function is run with
 *	interrupts disabled. 
 */
190

191
static void do_identify(ide_drive_t *drive, u8 cmd, u16 *id)
Linus Torvalds's avatar
Linus Torvalds committed
192
{
193
	ide_hwif_t *hwif = drive->hwif;
194
	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"))
231
232
233
		drive->dev_flags &= ~IDE_DFLAG_PRESENT;
	else
		drive->dev_flags |= IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
234
235
236
}

/**
237
 *	ide_dev_read_id	-	send ATA/ATAPI IDENTIFY command
Linus Torvalds's avatar
Linus Torvalds committed
238
239
 *	@drive: drive to identify
 *	@cmd: command to use
240
 *	@id: buffer for IDENTIFY data
Linus Torvalds's avatar
Linus Torvalds committed
241
 *
242
 *	Sends an ATA(PI) IDENTIFY request to a drive and waits for a response.
Linus Torvalds's avatar
Linus Torvalds committed
243
244
245
246
247
248
 *
 *	Returns:	0  device was identified
 *			1  device timed-out (no response to identify request)
 *			2  device aborted the command (refused to identify itself)
 */

249
int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id)
Linus Torvalds's avatar
Linus Torvalds committed
250
{
251
	ide_hwif_t *hwif = drive->hwif;
252
	struct ide_io_ports *io_ports = &hwif->io_ports;
253
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
254
	int use_altstatus = 0, rc;
Linus Torvalds's avatar
Linus Torvalds committed
255
256
257
	unsigned long timeout;
	u8 s = 0, a = 0;

258
259
260
261
262
263
264
	/*
	 * Disable device IRQ.  Otherwise we'll get spurious interrupts
	 * during the identify phase that the IRQ handler isn't expecting.
	 */
	if (io_ports->ctl_addr)
		tp_ops->set_irq(hwif, 0);

Linus Torvalds's avatar
Linus Torvalds committed
265
266
267
	/* take a deep breath */
	msleep(50);

268
269
	if (io_ports->ctl_addr &&
	    (hwif->host_flags & IDE_HFLAG_BROKEN_ALTSTATUS) == 0) {
270
271
		a = tp_ops->read_altstatus(hwif);
		s = tp_ops->read_status(hwif);
272
		if ((a ^ s) & ~ATA_IDX)
Linus Torvalds's avatar
Linus Torvalds committed
273
			/* ancient Seagate drives, broken interfaces */
274
275
276
277
			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
278
			/* use non-intrusive polling */
279
280
			use_altstatus = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
281
282
283
284

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

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

292
		tp_ops->tf_load(drive, &task);
293
	}
Linus Torvalds's avatar
Linus Torvalds committed
294
295

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

298
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
299
300
301

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

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

307
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
Linus Torvalds's avatar
Linus Torvalds committed
308
		/* drive returned ID */
309
		do_identify(drive, cmd, id);
Linus Torvalds's avatar
Linus Torvalds committed
310
311
312
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
313
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
314
315
316
317
318
319
320
	} else {
		/* drive refused ID */
		rc = 2;
	}
	return rc;
}

321
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
322
323
324
{
	u8 stat;

325
326
	timeout += jiffies;

327
	do {
328
329
330
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
331
		if ((stat & ATA_BUSY) == 0)
332
333
334
			return 0;
	} while (time_before(jiffies, timeout));

335
	return 1;	/* drive timed-out */
336
}
Linus Torvalds's avatar
Linus Torvalds committed
337

338
339
340
341
342
343
344
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;

345
	drive->hwif->tp_ops->tf_read(drive, &task);
346
347
348
349

	return task.tf.device;
}

Linus Torvalds's avatar
Linus Torvalds committed
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
/**
 *	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)
{
373
	ide_hwif_t *hwif = drive->hwif;
374
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
375
	u16 *id = drive->id;
376
	int rc;
377
378
379
380
381
	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
382
383

#ifdef DEBUG
384
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
385
		drive->name, present, drive->media,
386
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
387
388
389
390
391
392
393
394
#endif

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

396
	if (ide_read_device(drive) != drive->select && present == 0) {
397
		if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
398
			/* exit with drive0 selected */
399
			SELECT_DRIVE(hwif->devices[0]);
400
			/* allow ATA_BUSY to assert & clear */
Linus Torvalds's avatar
Linus Torvalds committed
401
402
403
404
405
406
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

407
	stat = tp_ops->read_status(hwif);
408

409
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
410
	    present || cmd == ATA_CMD_ID_ATAPI) {
411
412
		rc = ide_dev_read_id(drive, cmd, id);
		if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
413
			/* failed: try again */
414
			rc = ide_dev_read_id(drive, cmd, id);
415

416
		stat = tp_ops->read_status(hwif);
417

418
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
419
420
			return 4;

421
		if (rc == 1 && cmd == ATA_CMD_ID_ATAPI) {
422
423
			printk(KERN_ERR "%s: no response (status = 0x%02x), "
					"resetting drive\n", drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
424
			msleep(50);
425
			SELECT_DRIVE(drive);
Linus Torvalds's avatar
Linus Torvalds committed
426
			msleep(50);
427
			tp_ops->exec_command(hwif, ATA_CMD_DEV_RESET);
428
			(void)ide_busy_sleep(hwif, WAIT_WORSTCASE, 0);
429
			rc = ide_dev_read_id(drive, cmd, id);
Linus Torvalds's avatar
Linus Torvalds committed
430
		}
431
432

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

Linus Torvalds's avatar
Linus Torvalds committed
435
		if (rc == 1)
436
437
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
438
439
440
441
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
442
	if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
443
		/* exit with drive0 selected */
444
		SELECT_DRIVE(hwif->devices[0]);
Linus Torvalds's avatar
Linus Torvalds committed
445
446
		msleep(50);
		/* ensure drive irq is clear */
447
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
448
449
450
451
452
453
454
455
456
457
458
459
	}
	return rc;
}

/**
 *	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
460
461
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
462
 */
463
464

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
465
{
466
	char *m;
467
468
	int rc;
	u8 cmd;
469

Linus Torvalds's avatar
Linus Torvalds committed
470
471
472
473
474
475
476
477
478
	/*
	 *	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"
	 */
 
479
480
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

481
	drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
482
	if (drive->id == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
483
484
485
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
486
487
488
489

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

Linus Torvalds's avatar
Linus Torvalds committed
490
	/* skip probing? */
491
	if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
492
		/* if !(success||timed-out) */
493
494
495
		cmd = ATA_CMD_ID_ATA;
		rc = do_probe(drive, cmd);
		if (rc >= 2) {
Linus Torvalds's avatar
Linus Torvalds committed
496
			/* look for ATAPI device */
497
498
499
			cmd = ATA_CMD_ID_ATAPI;
			rc = do_probe(drive, cmd);
		}
500

501
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
502
			goto out_free;
503

Linus Torvalds's avatar
Linus Torvalds committed
504
		/* identification failed? */
505
		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
506
507
508
509
510
511
512
513
514
			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);
515
				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
516
			}
517
518
519
520
521
		} else {
			if (cmd == ATA_CMD_ID_ATAPI)
				ide_classify_atapi_dev(drive);
			else
				ide_classify_ata_dev(drive);
Linus Torvalds's avatar
Linus Torvalds committed
522
523
		}
	}
524
525

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
526
		goto out_free;
527

Linus Torvalds's avatar
Linus Torvalds committed
528
	/* The drive wasn't being helpful. Add generic info only */
529
	if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
530
531
532
533
534
535
536
537
538
		generic_id(drive);
		return 1;
	}

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

539
540
541
542
	return 1;
out_free:
	kfree(drive->id);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
543
544
}

Pavel Machek's avatar
Pavel Machek committed
545
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
546
547
548
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

549
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
550
551
}

552
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
553
{
554
555
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
556
	/* register with global device tree */
557
	dev_set_name(&hwif->gendev, hwif->name);
Linus Torvalds's avatar
Linus Torvalds committed
558
	hwif->gendev.driver_data = hwif;
Andreas Schwab's avatar
Andreas Schwab committed
559
560
	if (hwif->gendev.parent == NULL)
		hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
561
	hwif->gendev.release = hwif_release_dev;
562

563
	ret = device_register(&hwif->gendev);
564
	if (ret < 0) {
565
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
566
			__func__, ret);
567
568
569
		goto out;
	}

570
571
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
				      MKDEV(0, 0), hwif, hwif->name);
572
573
574
575
576
577
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
578
579
}

580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
/**
 *	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
607
{
608
609
	ide_drive_t *drive;
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625

	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 */
626
	ide_port_for_each_dev(i, drive, hwif) {
627
		/* Ignore disks that we will not probe for later. */
628
629
		if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
		    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
630
			SELECT_DRIVE(drive);
631
			hwif->tp_ops->set_irq(hwif, 1);
632
633
634
635
636
637
638
639
640
			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
641
	/* Exit function with master reselected (let's be sane) */
642
	if (i)
643
		SELECT_DRIVE(hwif->devices[0]);
644

Linus Torvalds's avatar
Linus Torvalds committed
645
646
647
648
649
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
650
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
654
655
656
 *
 *	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.
 */

657
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
658
{
659
	ide_drive_t *dev0 = dev1->hwif->devices[0];
Linus Torvalds's avatar
Linus Torvalds committed
660

661
	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
		return;

	/* If the models don't match they are not the same product */
665
666
	if (strcmp((char *)&dev0->id[ATA_ID_PROD],
		   (char *)&dev1->id[ATA_ID_PROD]))
Linus Torvalds's avatar
Linus Torvalds committed
667
668
669
		return;

	/* Serial numbers do not match */
670
671
	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
672
673
674
		return;

	/* No serial number, thankfully very rare for CF */
675
	if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
Linus Torvalds's avatar
Linus Torvalds committed
676
677
678
679
680
		return;

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

681
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
682
683
684
685
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

686
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
687
{
688
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
689
	unsigned int irqd;
690
	int i, rc = -ENODEV;
691
692

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

694
695
	if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
	    (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
696
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
697
698
699
700
701
702
703
704
705

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

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

	/*
710
711
	 * 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
712
	 */
713
	ide_port_for_each_dev(i, drive, hwif) {
Linus Torvalds's avatar
Linus Torvalds committed
714
		(void) probe_for_drive(drive);
715
		if (drive->dev_flags & IDE_DFLAG_PRESENT)
716
			rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
717
	}
718

Linus Torvalds's avatar
Linus Torvalds committed
719
720
721
722
723
724
725
	/*
	 * Use cached IRQ number. It might be (and is...) changed by probe
	 * code above
	 */
	if (irqd)
		enable_irq(irqd);

726
	return rc;
727
728
729
730
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
731
	const struct ide_port_ops *port_ops = hwif->port_ops;
732
733
	ide_drive_t *drive;
	int i;
734

735
736
737
	ide_port_for_each_present_dev(i, drive, hwif) {
		if (port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
738
	}
739

740
741
	ide_port_for_each_present_dev(i, drive, hwif) {
		ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
742

743
		drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
744

745
746
		if (hwif->dma_ops)
			ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
747
748
749
750
751
752
753
754
	}
}

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
755
	struct request_queue *q;
756
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
757
758
759
760
761
762
763
764
765
766
	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.
	 */
767

768
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
	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;
}

805
806
static DEFINE_MUTEX(ide_cfg_mtx);

807
808
809
810
/*
 * For any present drive:
 * - allocate the block device queue
 */
811
static int ide_port_setup_devices(ide_hwif_t *hwif)
812
{
813
	ide_drive_t *drive;
814
	int i, j = 0;
815

816
	mutex_lock(&ide_cfg_mtx);
817
	ide_port_for_each_present_dev(i, drive, hwif) {
818
819
820
		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
821
822
823
			kfree(drive->id);
			drive->id = NULL;
			drive->dev_flags &= ~IDE_DFLAG_PRESENT;
824
825
826
			continue;
		}

827
		j++;
828
	}
829
	mutex_unlock(&ide_cfg_mtx);
830
831

	return j;
832
833
}

Linus Torvalds's avatar
Linus Torvalds committed
834
/*
835
 * This routine sets up the IRQ for an IDE interface.
Linus Torvalds's avatar
Linus Torvalds committed
836
837
838
 */
static int init_irq (ide_hwif_t *hwif)
{
839
	struct ide_io_ports *io_ports = &hwif->io_ports;
840
841
842
	struct ide_host *host = hwif->host;
	irq_handler_t irq_handler = host->irq_handler;
	int sa = host->irq_flags;
Linus Torvalds's avatar
Linus Torvalds committed
843

844
845
846
	if (irq_handler == NULL)
		irq_handler = ide_intr;

847
848
	if (io_ports->ctl_addr)
		hwif->tp_ops->set_irq(hwif, 1);
Linus Torvalds's avatar
Linus Torvalds committed
849

850
	if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
851
		goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
852

Adrian Bunk's avatar
Adrian Bunk committed
853
#if !defined(__mc68000__)
854
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
855
856
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
857
#else
858
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
859
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
860
#endif /* __mc68000__ */
861
862
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
		printk(KERN_CONT " (serialized)");
863
	printk(KERN_CONT "\n");
864

Linus Torvalds's avatar
Linus Torvalds committed
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
	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;
880
	ide_drive_t *drive = hwif->devices[unit];
881
882

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
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
		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");

	return NULL;
}

static struct kobject *exact_match(dev_t dev, int *part, void *data)
{
	struct gendisk *p = data;
	*part &= (1 << PARTN_BITS) - 1;
901
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
}

static int exact_lock(dev_t dev, void *data)
{
	struct gendisk *p = data;

	if (!get_disk(p))
		return -1;
	return 0;
}

void ide_register_region(struct gendisk *disk)
{
	blk_register_region(MKDEV(disk->major, disk->first_minor),
			    disk->minors, NULL, exact_match, exact_lock, disk);
}

EXPORT_SYMBOL_GPL(ide_register_region);

void ide_unregister_region(struct gendisk *disk)
{
	blk_unregister_region(MKDEV(disk->major, disk->first_minor),
			      disk->minors);
}

EXPORT_SYMBOL_GPL(ide_unregister_region);

void ide_init_disk(struct gendisk *disk, ide_drive_t *drive)
{
	ide_hwif_t *hwif = drive->hwif;
932
	unsigned int unit = drive->dn & 1;
Linus Torvalds's avatar
Linus Torvalds committed
933
934
935
936
937
938
939
940
941
942
943
944

	disk->major = hwif->major;
	disk->first_minor = unit << PARTN_BITS;
	sprintf(disk->disk_name, "hd%c", 'a' + hwif->index * MAX_DRIVES + unit);
	disk->queue = drive->queue;
}

EXPORT_SYMBOL_GPL(ide_init_disk);

static void drive_release_dev (struct device *dev)
{
	ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);
945
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
946

947
948
	ide_proc_unregister_device(drive);

949
	spin_lock_irq(&hwif->lock);
950
951
	kfree(drive->id);
	drive->id = NULL;
952
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
953
	/* Messed up locking ... */
954
	spin_unlock_irq(&hwif->lock);
955
	blk_cleanup_queue(drive->queue);
956
	spin_lock_irq(&hwif->lock);
957
	drive->queue = NULL;
958
	spin_unlock_irq(&hwif->lock);
959

960
	complete(&drive->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
961
962
963
964
965
}

static int hwif_init(ide_hwif_t *hwif)
{
	if (!hwif->irq) {
966
967
		printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
968
969
970
971
972
973
974
975
	}

	if (register_blkdev(hwif->major, hwif->name))
		return 0;

	if (!hwif->sg_max_nents)
		hwif->sg_max_nents = PRD_ENTRIES;

976
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
Linus Torvalds's avatar
Linus Torvalds committed
977
978
979
980
981
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}
982
983

	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
Linus Torvalds's avatar
Linus Torvalds committed
984
985
	
	if (init_irq(hwif)) {
986
987
		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
			hwif->name, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
988
989
990
		goto out;
	}

991
992
	blk_register_region(MKDEV(hwif->major, 0), MAX_DRIVES << PARTN_BITS,
			    THIS_MODULE, ata_probe, ata_lock, hwif);
Linus Torvalds's avatar
Linus Torvalds committed
993
994
995
996
997
998
999
	return 1;

out:
	unregister_blkdev(hwif->major, hwif->name);
	return 0;
}

1000
static void hwif_register_devices(ide_hwif_t *hwif)