ide-probe.c 36.9 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"))
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

	return;
err_misc:
	kfree(id);
239
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
240
241
242
}

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

255
int ide_dev_read_id(ide_drive_t *drive, u8 cmd, u16 *id)
Linus Torvalds's avatar
Linus Torvalds committed
256
{
257
	ide_hwif_t *hwif = drive->hwif;
258
	struct ide_io_ports *io_ports = &hwif->io_ports;
259
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
260
	int use_altstatus = 0, rc;
Linus Torvalds's avatar
Linus Torvalds committed
261
262
263
	unsigned long timeout;
	u8 s = 0, a = 0;

264
265
266
267
268
269
270
	/*
	 * 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
271
272
273
	/* take a deep breath */
	msleep(50);

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

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

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

298
		tp_ops->tf_load(drive, &task);
299
	}
Linus Torvalds's avatar
Linus Torvalds committed
300
301

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

304
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
305
306
307

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

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

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

327
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
328
329
330
{
	u8 stat;

331
332
	timeout += jiffies;

333
	do {
334
335
336
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
337
		if ((stat & ATA_BUSY) == 0)
338
339
340
			return 0;
	} while (time_before(jiffies, timeout));

341
	return 1;	/* drive timed-out */
342
}
Linus Torvalds's avatar
Linus Torvalds committed
343

344
345
346
347
348
349
350
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;

351
	drive->hwif->tp_ops->tf_read(drive, &task);
352
353
354
355

	return task.tf.device;
}

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

#ifdef DEBUG
390
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
391
		drive->name, present, drive->media,
392
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
393
394
395
396
397
398
399
400
#endif

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

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

413
	stat = tp_ops->read_status(hwif);
414

415
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
416
	    present || cmd == ATA_CMD_ID_ATAPI) {
417
418
		rc = ide_dev_read_id(drive, cmd, id);
		if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
419
			/* failed: try again */
420
			rc = ide_dev_read_id(drive, cmd, id);
421

422
		stat = tp_ops->read_status(hwif);
423

424
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
425
426
			return 4;

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

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

Linus Torvalds's avatar
Linus Torvalds committed
441
		if (rc == 1)
442
443
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
444
445
446
447
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
448
	if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
449
		/* exit with drive0 selected */
450
		SELECT_DRIVE(hwif->devices[0]);
Linus Torvalds's avatar
Linus Torvalds committed
451
452
		msleep(50);
		/* ensure drive irq is clear */
453
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
454
455
456
457
458
459
460
461
462
463
464
465
	}
	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
466
467
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
468
 */
469
470

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
471
{
472
	char *m;
473
474
	int rc;
	u8 cmd;
475

Linus Torvalds's avatar
Linus Torvalds committed
476
477
478
479
480
481
482
483
484
	/*
	 *	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"
	 */
 
485
486
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

487
	drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
488
	if (drive->id == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
489
490
491
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
492
493
494
495

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

Linus Torvalds's avatar
Linus Torvalds committed
496
	/* skip probing? */
497
	if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
498
		/* if !(success||timed-out) */
499
500
501
		cmd = ATA_CMD_ID_ATA;
		rc = do_probe(drive, cmd);
		if (rc >= 2) {
Linus Torvalds's avatar
Linus Torvalds committed
502
			/* look for ATAPI device */
503
504
505
			cmd = ATA_CMD_ID_ATAPI;
			rc = do_probe(drive, cmd);
		}
506

507
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
508
509
			/* drive not found */
			return 0;
510

Linus Torvalds's avatar
Linus Torvalds committed
511
		/* identification failed? */
512
		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
513
514
515
516
517
518
519
520
521
			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);
522
				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
523
			}
524
525
526
527
528
		} 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
529
530
		}
	}
531
532

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

Linus Torvalds's avatar
Linus Torvalds committed
535
	/* The drive wasn't being helpful. Add generic info only */
536
	if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
537
538
539
540
541
542
543
544
545
		generic_id(drive);
		return 1;
	}

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

546
	return !!(drive->dev_flags & IDE_DFLAG_PRESENT);
Linus Torvalds's avatar
Linus Torvalds committed
547
548
}

Pavel Machek's avatar
Pavel Machek committed
549
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
550
551
552
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

553
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
554
555
}

556
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
557
{
558
559
	int ret;

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

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

574
575
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
				      MKDEV(0, 0), hwif, hwif->name);
576
577
578
579
580
581
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
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
607
608
609
610
/**
 *	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
611
{
612
613
	ide_drive_t *drive;
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629

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

Linus Torvalds's avatar
Linus Torvalds committed
649
650
651
652
653
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
654
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
655
656
657
658
659
660
 *
 *	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.
 */

661
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
662
{
663
	ide_drive_t *dev0 = dev1->hwif->devices[0];
Linus Torvalds's avatar
Linus Torvalds committed
664

665
	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
666
667
668
		return;

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

	/* Serial numbers do not match */
674
675
	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
676
677
678
		return;

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

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

685
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
686
687
688
689
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

690
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
691
{
692
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
693
	unsigned int irqd;
694
	int i, rc = -ENODEV;
695
696

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

698
699
	if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
	    (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
700
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
701
702
703
704
705
706
707
708
709

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

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

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

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

730
	return rc;
731
732
733
734
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
735
	const struct ide_port_ops *port_ops = hwif->port_ops;
736
737
	ide_drive_t *drive;
	int i;
738

739
740
741
	ide_port_for_each_present_dev(i, drive, hwif) {
		if (port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
742
	}
743

744
745
	ide_port_for_each_present_dev(i, drive, hwif) {
		ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
746

747
		drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
748

749
750
		if (hwif->dma_ops)
			ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
751
752
753
754
755
756
757
758
	}
}

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

772
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
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
805
806
807
808
	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;
}

809
810
static DEFINE_MUTEX(ide_cfg_mtx);

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

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

831
		j++;
832
	}
833
	mutex_unlock(&ide_cfg_mtx);
834
835

	return j;
836
837
}

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

847
848
849
850
	irq_handler = hwif->host->irq_handler;
	if (irq_handler == NULL)
		irq_handler = ide_intr;

Adrian Bunk's avatar
Adrian Bunk committed
851
#if defined(__mc68000__)
852
	sa = IRQF_SHARED;
853
#endif /* __mc68000__ */
Linus Torvalds's avatar
Linus Torvalds committed
854

855
856
	if (hwif->chipset == ide_pci)
		sa = IRQF_SHARED;
Linus Torvalds's avatar
Linus Torvalds committed
857

858
859
	if (io_ports->ctl_addr)
		hwif->tp_ops->set_irq(hwif, 1);
Linus Torvalds's avatar
Linus Torvalds committed
860

861
	if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
862
		goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
863

864
865
866
867
868
869
870
871
	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
872
#if !defined(__mc68000__)
873
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
874
875
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
876
#else
877
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
878
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
879
#endif /* __mc68000__ */
880
881
	if (hwif->host->host_flags & IDE_HFLAG_SERIALIZE)
		printk(KERN_CONT " (serialized)");
882
	printk(KERN_CONT "\n");
883

Linus Torvalds's avatar
Linus Torvalds committed
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
	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;
899
	ide_drive_t *drive = hwif->devices[unit];
900
901

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
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
		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;
920
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
}

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;
951
	unsigned int unit = drive->dn & 1;
Linus Torvalds's avatar
Linus Torvalds committed
952
953
954
955
956
957
958
959
960
961
962
963

	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);
964
	ide_hwif_t *hwif = drive->hwif;
Linus Torvalds's avatar
Linus Torvalds committed
965

966
967
	ide_proc_unregister_device(drive);

968
	spin_lock_irq(&hwif->lock);
969
970
	kfree(drive->id);
	drive->id = NULL;
971
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
972
	/* Messed up locking ... */
973
	spin_unlock_irq(&hwif->lock);
974
	blk_cleanup_queue(drive->queue);
975
	spin_lock_irq(&hwif->lock);
976
	drive->queue = NULL;
977
	spin_unlock_irq(&hwif->lock);
978

979
	complete(&drive->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
980
981
982
983
984
}

static int hwif_init(ide_hwif_t *hwif)
{
	if (!hwif->irq) {
985
986
		printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
987
988
989
990
991
992
993
994
	}

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

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

995
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
Linus Torvalds's avatar
Linus Torvalds committed
996
997
998
999
1000
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}