ide-probe.c 42.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
	}
}

/**
 *	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. 
 */
 
static inline void do_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
117
118
	u16 *id = drive->id;
	char *m = (char *)&id[ATA_ID_PROD];
119
	int bswap = 1, is_cfa;
Linus Torvalds's avatar
Linus Torvalds committed
120
121

	/* read 512 bytes of id info */
122
	hwif->tp_ops->input_data(drive, NULL, id, SECTOR_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
123
124
125

	drive->id_read = 1;
	local_irq_enable();
126
127
128
129
#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
130
131
132
	ide_fix_driveid(id);

	/*
133
134
	 *  ATA_CMD_ID_ATA returns little-endian info,
	 *  ATA_CMD_ID_ATAPI *usually* returns little-endian info.
Linus Torvalds's avatar
Linus Torvalds committed
135
	 */
136
	if (cmd == ATA_CMD_ID_ATAPI) {
137
138
139
		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
140
			/* Vertos drives may still be weird */
141
			bswap ^= 1;
Linus Torvalds's avatar
Linus Torvalds committed
142
	}
143
144
145
146

	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
147

148
	/* we depend on this a lot! */
149
	m[ATA_ID_PROD_LEN - 1] = '\0';
150

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

154
	printk(KERN_INFO "%s: %s, ", drive->name, m);
155

Linus Torvalds's avatar
Linus Torvalds committed
156
157
158
159
160
161
	drive->present = 1;
	drive->dead = 0;

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

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

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

215
216
217
218
	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)))
Linus Torvalds's avatar
Linus Torvalds committed
219
220
221
		drive->removable = 1;

	drive->media = ide_disk;
222

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

Linus Torvalds's avatar
Linus Torvalds committed
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
	return;

err_misc:
	kfree(id);
	drive->present = 0;
	return;
}

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

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

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

260
	if (io_ports->ctl_addr) {
261
262
		a = tp_ops->read_altstatus(hwif);
		s = tp_ops->read_status(hwif);
263
		if ((a ^ s) & ~ATA_IDX)
Linus Torvalds's avatar
Linus Torvalds committed
264
			/* ancient Seagate drives, broken interfaces */
265
266
267
268
			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
269
			/* use non-intrusive polling */
270
271
			use_altstatus = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
272
273
274
275

	/* set features register for atapi
	 * identify command to be sure of reply
	 */
276
	if (cmd == ATA_CMD_ID_ATAPI) {
277
278
279
280
281
282
		ide_task_t task;

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

283
		tp_ops->tf_load(drive, &task);
284
	}
Linus Torvalds's avatar
Linus Torvalds committed
285
286

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

289
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
290
291
292

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

294
	/* wait for IRQ and ATA_DRQ */
Linus Torvalds's avatar
Linus Torvalds committed
295
	msleep(50);
296
	s = tp_ops->read_status(hwif);
297

298
	if (OK_STAT(s, ATA_DRQ, BAD_R_STAT)) {
Linus Torvalds's avatar
Linus Torvalds committed
299
300
301
302
303
304
305
306
307
		unsigned long flags;

		/* local CPU only; some systems need this */
		local_irq_save(flags);
		/* drive returned ID */
		do_identify(drive, cmd);
		/* drive responded with ID */
		rc = 0;
		/* clear drive IRQ */
308
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
		local_irq_restore(flags);
	} else {
		/* drive refused ID */
		rc = 2;
	}
	return rc;
}

/**
 *	try_to_identify	-	try to identify a drive
 *	@drive: drive to probe
 *	@cmd: command to use
 *
 *	Issue the identify command and then do IRQ probing to
 *	complete the identification when needed by finding the
 *	IRQ the drive is attached to
 */
 
static int try_to_identify (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
330
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
Linus Torvalds's avatar
Linus Torvalds committed
331
332
333
334
335
336
337
338
339
340
	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.
	 */
341
	if (hwif->io_ports.ctl_addr) {
Linus Torvalds's avatar
Linus Torvalds committed
342
343
344
345
		if (!hwif->irq) {
			autoprobe = 1;
			cookie = probe_irq_on();
		}
346
		tp_ops->set_irq(hwif, autoprobe);
Linus Torvalds's avatar
Linus Torvalds committed
347
348
349
350
351
352
	}

	retval = actual_try_to_identify(drive, cmd);

	if (autoprobe) {
		int irq;
353

354
		tp_ops->set_irq(hwif, 0);
Linus Torvalds's avatar
Linus Torvalds committed
355
		/* clear drive IRQ */
356
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
361
362
363
364
365
		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
				 */
366
				printk(KERN_ERR "%s: IRQ probe failed (0x%lx)\n",
Linus Torvalds's avatar
Linus Torvalds committed
367
368
369
370
371
372
373
					drive->name, cookie);
			}
		}
	}
	return retval;
}

374
int ide_busy_sleep(ide_hwif_t *hwif, unsigned long timeout, int altstatus)
375
376
377
{
	u8 stat;

378
379
	timeout += jiffies;

380
	do {
381
382
383
		msleep(50);	/* give drive a breather */
		stat = altstatus ? hwif->tp_ops->read_altstatus(hwif)
				 : hwif->tp_ops->read_status(hwif);
384
		if ((stat & ATA_BUSY) == 0)
385
386
387
			return 0;
	} while (time_before(jiffies, timeout));

388
	return 1;	/* drive timed-out */
389
}
Linus Torvalds's avatar
Linus Torvalds committed
390

391
392
393
394
395
396
397
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;

398
	drive->hwif->tp_ops->tf_read(drive, &task);
399
400
401
402

	return task.tf.device;
}

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

static int do_probe (ide_drive_t *drive, u8 cmd)
{
	ide_hwif_t *hwif = HWIF(drive);
427
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
428
429
	int rc;
	u8 stat;
Linus Torvalds's avatar
Linus Torvalds committed
430
431
432

	if (drive->present) {
		/* avoid waiting for inappropriate probes */
433
		if (drive->media != ide_disk && cmd == ATA_CMD_ID_ATA)
Linus Torvalds's avatar
Linus Torvalds committed
434
435
436
			return 4;
	}
#ifdef DEBUG
437
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
Linus Torvalds's avatar
Linus Torvalds committed
438
		drive->name, drive->present, drive->media,
439
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
440
441
442
443
444
445
446
447
#endif

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

	if (ide_read_device(drive) != drive->select.all && !drive->present) {
Linus Torvalds's avatar
Linus Torvalds committed
450
451
452
		if (drive->select.b.unit != 0) {
			/* exit with drive0 selected */
			SELECT_DRIVE(&hwif->drives[0]);
453
			/* allow ATA_BUSY to assert & clear */
Linus Torvalds's avatar
Linus Torvalds committed
454
455
456
457
458
459
			msleep(50);
		}
		/* no i/f present: mmm.. this should be a 4 -ml */
		return 3;
	}

460
	stat = tp_ops->read_status(hwif);
461

462
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
463
	    drive->present || cmd == ATA_CMD_ID_ATAPI) {
Linus Torvalds's avatar
Linus Torvalds committed
464
465
466
467
468
		/* send cmd and wait */
		if ((rc = try_to_identify(drive, cmd))) {
			/* failed: try again */
			rc = try_to_identify(drive,cmd);
		}
469

470
		stat = tp_ops->read_status(hwif);
471

472
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
473
474
			return 4;

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

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

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

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

515
516
	printk(KERN_INFO "%s: enabling %s -- ",
		hwif->name, (char *)&drive->id[ATA_ID_PROD]);
517

Linus Torvalds's avatar
Linus Torvalds committed
518
519
	SELECT_DRIVE(drive);
	msleep(50);
520
	tp_ops->exec_command(hwif, ATA_EXABYTE_ENABLE_NEST);
521

522
	if (ide_busy_sleep(hwif, WAIT_WORSTCASE, 0)) {
523
524
525
		printk(KERN_CONT "failed (timeout)\n");
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
526
527
528

	msleep(50);

529
	stat = tp_ops->read_status(hwif);
530
531
532
533
534

	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
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
}

/**
 *	probe_for_drives	-	upper level drive probe
 *	@drive: drive to probe for
 *
 *	probe_for_drive() tests for existence of a given drive using do_probe()
 *	and presents things to the user as needed.
 *
 *	Returns:	0  no device was found
 *			1  device was found (note: drive->present might
 *			   still be 0)
 */
 
static inline u8 probe_for_drive (ide_drive_t *drive)
{
551
552
	char *m;

Linus Torvalds's avatar
Linus Torvalds committed
553
554
555
556
557
558
559
560
561
	/*
	 *	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"
	 */
 
562
	drive->id = kzalloc(SECTOR_SIZE, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
563
564
565
566
567
568
	drive->id_read = 0;
	if(drive->id == NULL)
	{
		printk(KERN_ERR "ide: out of memory for id data.\n");
		return 0;
	}
569
570
571
572

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

Linus Torvalds's avatar
Linus Torvalds committed
573
	/* skip probing? */
574
575
	if (!drive->noprobe) {
retry:
Linus Torvalds's avatar
Linus Torvalds committed
576
		/* if !(success||timed-out) */
577
		if (do_probe(drive, ATA_CMD_ID_ATA) >= 2)
Linus Torvalds's avatar
Linus Torvalds committed
578
			/* look for ATAPI device */
579
			(void)do_probe(drive, ATA_CMD_ID_ATAPI);
580

Linus Torvalds's avatar
Linus Torvalds committed
581
582
583
		if (!drive->present)
			/* drive not found */
			return 0;
584

585
		if (strstr(m, "E X A B Y T E N E S T")) {
Alan Cox's avatar
Alan Cox committed
586
			enable_nest(drive);
587
588
589
			goto retry;
		}

Linus Torvalds's avatar
Linus Torvalds committed
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
		/* identification failed? */
		if (!drive->id_read) {
			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);
				drive->present = 0;
			}
		}
		/* drive was found */
	}
	if(!drive->present)
		return 0;
	/* The drive wasn't being helpful. Add generic info only */
	if (drive->id_read == 0) {
		generic_id(drive);
		return 1;
	}

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

	return drive->present;
}

Pavel Machek's avatar
Pavel Machek committed
622
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
623
624
625
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

626
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
627
628
}

629
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
630
{
631
632
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
633
634
635
636
	/* register with global device tree */
	strlcpy(hwif->gendev.bus_id,hwif->name,BUS_ID_SIZE);
	hwif->gendev.driver_data = hwif;
	if (hwif->gendev.parent == NULL) {
637
638
		if (hwif->dev)
			hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
639
640
641
642
643
		else
			/* Would like to do = &device_legacy */
			hwif->gendev.parent = NULL;
	}
	hwif->gendev.release = hwif_release_dev;
644
	ret = device_register(&hwif->gendev);
645
	if (ret < 0) {
646
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
647
			__func__, ret);
648
649
650
		goto out;
	}

651
652
	hwif->portdev = device_create_drvdata(ide_port_class, &hwif->gendev,
					      MKDEV(0, 0), hwif, hwif->name);
653
654
655
656
657
658
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
659
660
}

661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
/**
 *	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
688
{
689
	int unit, rc;
Linus Torvalds's avatar
Linus Torvalds committed
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705

	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 */
706
707
708
709
710
711
	for (unit = 0; unit < MAX_DRIVES; unit++) {
		ide_drive_t *drive = &hwif->drives[unit];

		/* Ignore disks that we will not probe for later. */
		if (!drive->noprobe || drive->present) {
			SELECT_DRIVE(drive);
712
			hwif->tp_ops->set_irq(hwif, 1);
713
714
715
716
717
718
719
720
721
			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
722
	/* Exit function with master reselected (let's be sane) */
723
724
725
	if (unit)
		SELECT_DRIVE(&hwif->drives[0]);

Linus Torvalds's avatar
Linus Torvalds committed
726
727
728
729
730
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
731
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
732
733
734
735
736
737
 *
 *	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.
 */

738
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
739
{
740
	ide_drive_t *dev0 = &dev1->hwif->drives[0];
Linus Torvalds's avatar
Linus Torvalds committed
741

742
	if ((dev1->dn & 1) == 0 || dev0->present == 0)
Linus Torvalds's avatar
Linus Torvalds committed
743
744
745
		return;

	/* If the models don't match they are not the same product */
746
747
	if (strcmp((char *)&dev0->id[ATA_ID_PROD],
		   (char *)&dev1->id[ATA_ID_PROD]))
Linus Torvalds's avatar
Linus Torvalds committed
748
749
750
		return;

	/* Serial numbers do not match */
751
752
	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
753
754
755
		return;

	/* No serial number, thankfully very rare for CF */
756
	if (*(char *)&dev0->id[ATA_ID_SERNO] == 0)
Linus Torvalds's avatar
Linus Torvalds committed
757
758
759
760
761
		return;

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

762
	dev1->present = 0;
Linus Torvalds's avatar
Linus Torvalds committed
763
764
765
766
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

767
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
768
769
770
{
	unsigned long flags;
	unsigned int irqd;
771
772
773
	int unit, rc = -ENODEV;

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

775
	if (hwif->drives[0].noprobe && hwif->drives[1].noprobe)
776
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
777
778
779
780
781
782
783
784
785
786
787

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

	local_irq_set(flags);

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

	/*
792
793
	 * 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
794
	 */
795
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
Linus Torvalds's avatar
Linus Torvalds committed
796
797
798
		ide_drive_t *drive = &hwif->drives[unit];
		drive->dn = (hwif->channel ? 2 : 0) + unit;
		(void) probe_for_drive(drive);
799
800
		if (drive->present)
			rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
801
	}
802

Linus Torvalds's avatar
Linus Torvalds committed
803
	local_irq_restore(flags);
804

Linus Torvalds's avatar
Linus Torvalds committed
805
806
807
808
809
810
811
	/*
	 * Use cached IRQ number. It might be (and is...) changed by probe
	 * code above
	 */
	if (irqd)
		enable_irq(irqd);

812
	return rc;
813
814
815
816
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
817
	const struct ide_port_ops *port_ops = hwif->port_ops;
818
819
	int unit;

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

823
824
		if (drive->present && port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
825
	}
826

Linus Torvalds's avatar
Linus Torvalds committed
827
828
829
830
	for (unit = 0; unit < MAX_DRIVES; ++unit) {
		ide_drive_t *drive = &hwif->drives[unit];

		if (drive->present) {
831
			ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
832
833
834

			drive->nice1 = 1;

835
			if (hwif->dma_ops)
836
				ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
837
838
		}
	}
839
840
841
842

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

843
		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
844
845
			drive->no_io_32bit = 1;
		else
846
			drive->no_io_32bit = drive->id[ATA_ID_DWORD_IO] ? 1 : 0;
847
	}
Linus Torvalds's avatar
Linus Torvalds committed
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
}

#if MAX_HWIFS > 1
/*
 * save_match() is used to simplify logic in init_irq() below.
 *
 * A loophole here is that we may not know about a particular
 * hwif's irq until after that hwif is actually probed/initialized..
 * This could be a problem for the case where an hwif is on a
 * dual interface that requires serialization (eg. cmd640) and another
 * hwif using one of the same irqs is initialized beforehand.
 *
 * This routine detects and reports such situations, but does not fix them.
 */
static void save_match(ide_hwif_t *hwif, ide_hwif_t *new, ide_hwif_t **match)
{
	ide_hwif_t *m = *match;

	if (m && m->hwgroup && m->hwgroup != new->hwgroup) {
		if (!new->hwgroup)
			return;
869
		printk(KERN_WARNING "%s: potential IRQ problem with %s and %s\n",
Linus Torvalds's avatar
Linus Torvalds committed
870
871
872
873
874
875
876
877
878
879
880
881
			hwif->name, new->name, m->name);
	}
	if (!m || m->irq != hwif->irq) /* don't undo a prior perfect match */
		*match = new;
}
#endif /* MAX_HWIFS > 1 */

/*
 * init request queue
 */
static int ide_init_queue(ide_drive_t *drive)
{
882
	struct request_queue *q;
Linus Torvalds's avatar
Linus Torvalds committed
883
884
885
886
887
888
889
890
891
892
893
	ide_hwif_t *hwif = HWIF(drive);
	int max_sectors = 256;
	int max_sg_entries = PRD_ENTRIES;

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

895
	q = blk_init_queue_node(do_ide_request, &ide_lock, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
896
897
898
899
900
901
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
	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;
}

932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
static void ide_add_drive_to_hwgroup(ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;

	spin_lock_irq(&ide_lock);
	if (!hwgroup->drive) {
		/* first drive for hwgroup. */
		drive->next = drive;
		hwgroup->drive = drive;
		hwgroup->hwif = HWIF(hwgroup->drive);
	} else {
		drive->next = hwgroup->drive->next;
		hwgroup->drive->next = drive;
	}
	spin_unlock_irq(&ide_lock);
}

949
950
951
952
953
954
955
956
957
/*
 * For any present drive:
 * - allocate the block device queue
 * - link drive into the hwgroup
 */
static void ide_port_setup_devices(ide_hwif_t *hwif)
{
	int i;

958
	mutex_lock(&ide_cfg_mtx);
959
960
961
962
963
964
965
966
967
968
969
970
971
972
	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive = &hwif->drives[i];

		if (!drive->present)
			continue;

		if (ide_init_queue(drive)) {
			printk(KERN_ERR "ide: failed to init %s\n",
					drive->name);
			continue;
		}

		ide_add_drive_to_hwgroup(drive);
	}
973
	mutex_unlock(&ide_cfg_mtx);
974
975
}

976
977
static ide_hwif_t *ide_ports[MAX_HWIFS];

978
979
980
981
void ide_remove_port_from_hwgroup(ide_hwif_t *hwif)
{
	ide_hwgroup_t *hwgroup = hwif->hwgroup;

982
983
	ide_ports[hwif->index] = NULL;

984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
	spin_lock_irq(&ide_lock);
	/*
	 * Remove us from the hwgroup, and free
	 * the hwgroup if we were the only member
	 */
	if (hwif->next == hwif) {
		BUG_ON(hwgroup->hwif != hwif);
		kfree(hwgroup);
	} else {
		/* There is another interface in hwgroup.
		 * Unlink us, and set hwgroup->drive and ->hwif to
		 * something sane.
		 */
		ide_hwif_t *g = hwgroup->hwif;

		while (g->next != hwif)
			g = g->next;
		g->next = hwif->next;
		if (hwgroup->hwif == hwif) {
			/* Chose a random hwif for hwgroup->hwif.
			 * It's guaranteed that there are no drives
			 * left in the hwgroup.
			 */
			BUG_ON(hwgroup->drive != NULL);
			hwgroup->hwif = g;
		}
		BUG_ON(hwgroup->hwif == hwif);
	}
	spin_unlock_irq(&ide_lock);
}

Linus Torvalds's avatar
Linus Torvalds committed
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
/*
 * This routine sets up the irq for an ide interface, and creates a new
 * hwgroup for the irq/hwif if none was previously assigned.
 *
 * Much of the code is for correctly detecting/handling irq sharing
 * and irq serialization situations.  This is somewhat complex because
 * it handles static as well as dynamic (PCMCIA) IDE interfaces.
 */
static int init_irq (ide_hwif_t *hwif)
{
1025
	struct ide_io_ports *io_ports = &hwif->io_ports;
Linus Torvalds's avatar
Linus Torvalds committed
1026
1027
1028
1029
	unsigned int index;
	ide_hwgroup_t *hwgroup;
	ide_hwif_t *match = NULL;

1030
	mutex_lock(&ide_cfg_mtx);
Linus Torvalds's avatar
Linus Torvalds committed
1031
1032
1033
1034
1035
1036
	hwif->hwgroup = NULL;
#if MAX_HWIFS > 1
	/*
	 * Group up with any other hwifs that share our irq(s).
	 */
	for (index = 0; index < MAX_HWIFS; index++) {
1037
1038
1039
		ide_hwif_t *h = ide_ports[index];

		if (h && h->hwgroup) {  /* scan only initialized ports */
Linus Torvalds's avatar
Linus Torvalds committed
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
			if (hwif->irq == h->irq) {
				hwif->sharing_irq = h->sharing_irq = 1;
				if (hwif->chipset != ide_pci ||
				    h->chipset != ide_pci) {
					save_match(hwif, h, &match);
				}
			}
			if (hwif->serialized) {
				if (hwif->mate && hwif->mate->irq == h->irq)
					save_match(hwif, h, &match);
			}
			if (h->serialized) {
				if (h->mate && hwif->irq == h->mate->irq)
					save_match(hwif, h, &match);
			}
		}
	}
#endif /* MAX_HWIFS > 1 */
	/*
	 * If we are still without a hwgroup, then form a new one
	 */
	if (match) {
		hwgroup = match->hwgroup;
		hwif->hwgroup = hwgroup;
		/*
		 * Link us into the hwgroup.
		 * This must be done early, do ensure that unexpected_intr
		 * can find the hwif and prevent irq storms.
		 * No drives are attached to the new hwif, choose_drive
		 * can't do anything stupid (yet).
		 * Add ourself as the 2nd entry to the hwgroup->hwif
		 * linked list, the first entry is the hwif that owns
		 * hwgroup->handler - do not change that.
		 */
		spin_lock_irq(&ide_lock);
		hwif->next = hwgroup->hwif->next;
		hwgroup->hwif->next = hwif;
1077
		BUG_ON(hwif->next == hwif);
Linus Torvalds's avatar
Linus Torvalds committed
1078
1079
		spin_unlock_irq(&ide_lock);
	} else {
1080
1081
1082
1083
		hwgroup = kmalloc_node(sizeof(*hwgroup), GFP_KERNEL|__GFP_ZERO,
				       hwif_to_node(hwif));
		if (hwgroup == NULL)
			goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
1084
1085

		hwif->hwgroup = hwgroup;
1086
		hwgroup->hwif = hwif->next = hwif;
Linus Torvalds's avatar
Linus Torvalds committed
1087
1088
1089
1090
1091
1092

		init_timer(&hwgroup->timer);
		hwgroup->timer.function = &ide_timer_expiry;
		hwgroup->timer.data = (unsigned long) hwgroup;
	}

1093
1094
	ide_ports[hwif->index] = hwif;

Linus Torvalds's avatar
Linus Torvalds committed
1095
1096
1097
1098
	/*
	 * Allocate the irq, if not already obtained for another hwif
	 */
	if (!match || match->irq != hwif->irq) {
1099
		int sa = 0;
Adrian Bunk's avatar
Adrian Bunk committed
1100
#if defined(__mc68000__)
1101
		sa = IRQF_SHARED;
1102
#endif /* __mc68000__ */
Linus Torvalds's avatar
Linus Torvalds committed
1103

1104
1105
		if (hwif->chipset == ide_pci || hwif->chipset == ide_cmd646 ||
		    hwif->chipset == ide_ali14xx)
1106
			sa = IRQF_SHARED;
Linus Torvalds's avatar
Linus Torvalds committed
1107

1108
		if (io_ports->ctl_addr)
1109
			hwif->tp_ops->set_irq(hwif, 1);
Linus Torvalds's avatar
Linus Torvalds committed
1110
1111
1112
1113
1114

		if (request_irq(hwif->irq,&ide_intr,sa,hwif->name,hwgroup))
	       		goto out_unlink;
	}

1115
1116
1117
1118
1119
1120
1121
1122
	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
1123
#if !defined(__mc68000__)
1124
	printk(KERN_INFO "%s at 0x%03lx-0x%03lx,0x%03lx on irq %d", hwif->name,
1125
1126
		io_ports->data_addr, io_ports->status_addr,
		io_ports->ctl_addr, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
1127
#else
1128
	printk(KERN_INFO "%s at 0x%08lx on irq %d", hwif->name,
1129
		io_ports->data_addr, hwif->irq);
Adrian Bunk's avatar
Adrian Bunk committed
1130
#endif /* __mc68000__ */
Linus Torvalds's avatar
Linus Torvalds committed
1131
	if (match)
1132
		printk(KERN_CONT " (%sed with %s)",
Linus Torvalds's avatar
Linus Torvalds committed
1133
			hwif->sharing_irq ? "shar" : "serializ", match->name);
1134
	printk(KERN_CONT "\n");
1135

1136
	mutex_unlock(&ide_cfg_mtx);
Linus Torvalds's avatar
Linus Torvalds committed
1137
1138
	return 0;
out_unlink:
1139
	ide_remove_port_from_hwgroup(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
1140
out_up:
1141
	mutex_unlock(&ide_cfg_mtx);
Linus Torvalds's avatar
Linus Torvalds committed
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
	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;
	ide_drive_t *drive = &hwif->drives[unit];
	if (!drive->present)
		return NULL;

	if (drive->media == ide_disk)
		request_module("ide-disk");
	if (drive->scsi)
		request_module("ide-scsi");
	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;
1177
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
}

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;
	unsigned int unit = (drive->select.all >> 4) & 1;

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

1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
static void ide_remove_drive_from_hwgroup(ide_drive_t *drive)
{
	ide_hwgroup_t *hwgroup = drive->hwif->hwgroup;

	if (drive == drive->next) {
		/* special case: last drive from hwgroup. */
		BUG_ON(hwgroup->drive != drive);
		hwgroup->drive = NULL;
	} else {
		ide_drive_t *walk;

		walk = hwgroup->drive;
		while (walk->next != drive)
			walk = walk->next;
		walk->next = drive->next;
		if (hwgroup->drive == drive) {
			hwgroup->drive = drive->next;
			hwgroup->hwif = hwgroup->drive->hwif;
		}
	}
	BUG_ON(hwgroup->drive == drive);
}

Linus Torvalds's avatar
Linus Torvalds committed
1241
1242
1243
1244
static void drive_release_dev (struct device *dev)
{
	ide_drive_t *drive = container_of(dev, ide_drive_t, gendev);

1245
1246
	ide_proc_unregister_device(drive);

1247
1248
	spin_lock_irq(&ide_lock);
	ide_remove_drive_from_hwgroup(drive);
1249
1250
	kfree(drive->id);
	drive->id = NULL;
1251
1252
1253
1254
1255
1256
1257
1258
	drive->present = 0;
	/* Messed up locking ... */
	spin_unlock_irq(&ide_lock);
	blk_cleanup_queue(drive->queue);
	spin_lock_irq(&ide_lock);
	drive->queue = NULL;
	spin_unlock_irq(&ide_lock);

1259
	complete(&drive->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
1260
1261
1262
1263
1264
1265
1266
}

static int hwif_init(ide_hwif_t *hwif)
{
	int old_irq;

	if (!hwif->irq) {
1267
		hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
1268
		if (!hwif->irq) {
1269
			printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
1270
			return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1271
1272
1273
1274
1275
1276
1277
1278
1279
		}
	}

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

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

1280
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
Linus Torvalds's avatar
Linus Torvalds committed
1281
1282
1283
1284
1285
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}
1286
1287

	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
Linus Torvalds's avatar
Linus Torvalds committed
1288
1289
1290
1291
1292
1293
1294
1295
1296
	
	if (init_irq(hwif) == 0)
		goto done;

	old_irq = hwif->irq;
	/*
	 *	It failed to initialise. Find the default IRQ for 
	 *	this port and try that.
	 */
1297
	hwif->irq = __ide_default_irq(hwif->io_ports.data_addr);
1298
	if (!hwif->irq) {
1299
		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
1300
1301
1302
1303
			hwif->name, old_irq);
		goto out;
	}
	if (init_irq(hwif)) {
1304
		printk(KERN_ERR "%s: probed IRQ %d and default IRQ %d failed\n",
Linus Torvalds's avatar
Linus Torvalds committed
1305
1306
1307
			hwif->name, old_irq, hwif->irq);
		goto out;
	}
1308
	printk(KERN_WARNING "%s: probed IRQ %d failed, using default\n",
Linus Torvalds's avatar
Linus Torvalds committed
1309
1310
1311
		hwif->name, hwif->irq);

done:
1312
1313
	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
1314
1315
1316
1317
1318
1319
1320
	return 1;

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

1321
1322
1323
1324
1325
1326
static void hwif_register_devices(ide_hwif_t *hwif)
{
	unsigned int i;

	for (i = 0; i < MAX_DRIVES; i++) {
		ide_drive_t *drive = &hwif->drives[i];
1327
1328
		struct device *dev = &drive->gendev;
		int ret;
1329

1330
1331
		if (!drive->present)
			continue;
1332

1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
		snprintf(dev->bus_id, BUS_ID_SIZE, "%u.%u", hwif->index, i);
		dev->parent = &hwif->gendev;
		dev->bus = &ide_bus_type;
		dev->driver_data = drive;
		dev->release = drive_release_dev;

		ret = device_register(dev);
		if (ret < 0)
			printk(KERN_WARNING "IDE: %s: device_register error: "
					    "%d\n", __func__, ret);
1343
1344
1345
	}
}

1346
1347
static void ide_port_init_devices(ide_hwif_t *hwif)
{
1348
	const struct ide_port_ops *port_ops = hwif->port_ops;
1349
1350
1351
1352
1353
1354
1355
1356
1357
	int i;

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

		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
			drive->io_32bit = 1;
		if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
			drive->unmask = 1;
1358
1359
		if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
			drive->no_unmask = 1;
1360

1361
1362
1363
		if (port_ops && port_ops->init_dev)
			port_ops->init_dev(drive);
	}
1364
1365
}

1366
1367
static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
			  const struct ide_port_info *d)
1368
{
1369
	hwif->channel = port;