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"))
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
	/*
	 * 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)
263
		tp_ops->write_devctl(hwif, ATA_NIEN | ATA_DEVCTL_OBS);
264

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
		struct ide_taskfile tf;
287

288
		memset(&tf, 0, sizeof(tf));
289
		/* disable DMA & overlap */
290
		tp_ops->tf_load(drive, &tf, IDE_VALID_FEATURE);
291
	}
Linus Torvalds's avatar
Linus Torvalds committed
292
293

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

296
	timeout = ((cmd == ATA_CMD_ID_ATA) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
297
298
299

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

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

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

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

323
324
	timeout += jiffies;

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

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

336
337
static u8 ide_read_device(ide_drive_t *drive)
{
338
	struct ide_taskfile tf;
339

340
	drive->hwif->tp_ops->tf_read(drive, &tf, IDE_VALID_DEVICE);
341

342
	return tf.device;
343
344
}

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

#ifdef DEBUG
379
	printk(KERN_INFO "probing for %s: present=%d, media=%d, probetype=%s\n",
380
		drive->name, present, drive->media,
381
		(cmd == ATA_CMD_ID_ATA) ? "ATA" : "ATAPI");
Linus Torvalds's avatar
Linus Torvalds committed
382
383
384
385
386
387
#endif

	/* needed for some systems
	 * (e.g. crw9624 as drive0 with disk as slave)
	 */
	msleep(50);
Sergei Shtylyov's avatar
Sergei Shtylyov committed
388
	tp_ops->dev_select(drive);
Linus Torvalds's avatar
Linus Torvalds committed
389
	msleep(50);
390

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

402
	stat = tp_ops->read_status(hwif);
403

404
	if (OK_STAT(stat, ATA_DRDY, ATA_BUSY) ||
405
	    present || cmd == ATA_CMD_ID_ATAPI) {
406
407
		rc = ide_dev_read_id(drive, cmd, id);
		if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
408
			/* failed: try again */
409
			rc = ide_dev_read_id(drive, cmd, id);
410

411
		stat = tp_ops->read_status(hwif);
412

413
		if (stat == (ATA_BUSY | ATA_DRDY))
Linus Torvalds's avatar
Linus Torvalds committed
414
415
			return 4;

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

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

Linus Torvalds's avatar
Linus Torvalds committed
430
		if (rc == 1)
431
432
			printk(KERN_ERR "%s: no response (status = 0x%02x)\n",
					drive->name, stat);
Linus Torvalds's avatar
Linus Torvalds committed
433
434
435
436
	} else {
		/* not present or maybe ATAPI */
		rc = 3;
	}
437
	if (drive->dn & 1) {
Linus Torvalds's avatar
Linus Torvalds committed
438
		/* exit with drive0 selected */
Sergei Shtylyov's avatar
Sergei Shtylyov committed
439
		tp_ops->dev_select(hwif->devices[0]);
Linus Torvalds's avatar
Linus Torvalds committed
440
441
		msleep(50);
		/* ensure drive irq is clear */
442
		(void)tp_ops->read_status(hwif);
Linus Torvalds's avatar
Linus Torvalds committed
443
444
445
446
447
448
449
450
451
452
453
454
	}
	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
455
456
 *			1  device was found
 *			   (note: IDE_DFLAG_PRESENT might still be not set)
Linus Torvalds's avatar
Linus Torvalds committed
457
 */
458
459

static u8 probe_for_drive(ide_drive_t *drive)
Linus Torvalds's avatar
Linus Torvalds committed
460
{
461
	char *m;
462
463
	int rc;
	u8 cmd;
464

Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
469
470
471
472
473
	/*
	 *	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"
	 */
 
474
475
	drive->dev_flags &= ~IDE_DFLAG_ID_READ;

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

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

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

496
		if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
497
			goto out_free;
498

Linus Torvalds's avatar
Linus Torvalds committed
499
		/* identification failed? */
500
		if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
501
502
503
504
505
506
507
508
509
			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);
510
				drive->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
511
			}
512
513
514
515
516
		} 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
517
518
		}
	}
519
520

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
521
		goto out_free;
522

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

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

534
535
536
537
	return 1;
out_free:
	kfree(drive->id);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
538
539
}

Pavel Machek's avatar
Pavel Machek committed
540
static void hwif_release_dev(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
541
542
543
{
	ide_hwif_t *hwif = container_of(dev, ide_hwif_t, gendev);

544
	complete(&hwif->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
545
546
}

547
static int ide_register_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
548
{
549
550
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
551
	/* register with global device tree */
552
	dev_set_name(&hwif->gendev, hwif->name);
Linus Torvalds's avatar
Linus Torvalds committed
553
	hwif->gendev.driver_data = hwif;
Andreas Schwab's avatar
Andreas Schwab committed
554
555
	if (hwif->gendev.parent == NULL)
		hwif->gendev.parent = hwif->dev;
Linus Torvalds's avatar
Linus Torvalds committed
556
	hwif->gendev.release = hwif_release_dev;
557

558
	ret = device_register(&hwif->gendev);
559
	if (ret < 0) {
560
		printk(KERN_WARNING "IDE: %s: device_register error: %d\n",
561
			__func__, ret);
562
563
564
		goto out;
	}

565
566
	hwif->portdev = device_create(ide_port_class, &hwif->gendev,
				      MKDEV(0, 0), hwif, hwif->name);
567
568
569
570
571
572
	if (IS_ERR(hwif->portdev)) {
		ret = PTR_ERR(hwif->portdev);
		device_unregister(&hwif->gendev);
	}
out:
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
573
574
}

575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
/**
 *	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
602
{
Sergei Shtylyov's avatar
Sergei Shtylyov committed
603
	const struct ide_tp_ops *tp_ops = hwif->tp_ops;
604
605
	ide_drive_t *drive;
	int i, rc;
Linus Torvalds's avatar
Linus Torvalds committed
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621

	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 */
622
	ide_port_for_each_dev(i, drive, hwif) {
623
		/* Ignore disks that we will not probe for later. */
624
625
		if ((drive->dev_flags & IDE_DFLAG_NOPROBE) == 0 ||
		    (drive->dev_flags & IDE_DFLAG_PRESENT)) {
Sergei Shtylyov's avatar
Sergei Shtylyov committed
626
627
			tp_ops->dev_select(drive);
			tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
628
629
630
631
632
633
634
635
636
			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
637
	/* Exit function with master reselected (let's be sane) */
638
	if (i)
Sergei Shtylyov's avatar
Sergei Shtylyov committed
639
		tp_ops->dev_select(hwif->devices[0]);
640

Linus Torvalds's avatar
Linus Torvalds committed
641
642
643
644
645
	return rc;
}

/**
 *	ide_undecoded_slave	-	look for bad CF adapters
646
 *	@dev1: slave device
Linus Torvalds's avatar
Linus Torvalds committed
647
648
649
650
651
652
 *
 *	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.
 */

653
void ide_undecoded_slave(ide_drive_t *dev1)
Linus Torvalds's avatar
Linus Torvalds committed
654
{
655
	ide_drive_t *dev0 = dev1->hwif->devices[0];
Linus Torvalds's avatar
Linus Torvalds committed
656

657
	if ((dev1->dn & 1) == 0 || (dev0->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
658
659
660
		return;

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

	/* Serial numbers do not match */
666
667
	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
668
669
670
		return;

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

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

677
	dev1->dev_flags &= ~IDE_DFLAG_PRESENT;
Linus Torvalds's avatar
Linus Torvalds committed
678
679
680
681
}

EXPORT_SYMBOL_GPL(ide_undecoded_slave);

682
static int ide_probe_port(ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
683
{
684
	ide_drive_t *drive;
Linus Torvalds's avatar
Linus Torvalds committed
685
	unsigned int irqd;
686
	int i, rc = -ENODEV;
687
688

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

690
691
	if ((hwif->devices[0]->dev_flags & IDE_DFLAG_NOPROBE) &&
	    (hwif->devices[1]->dev_flags & IDE_DFLAG_NOPROBE))
692
		return -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
693
694
695
696
697
698
699
700
701

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

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

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

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

722
	return rc;
723
724
725
726
}

static void ide_port_tune_devices(ide_hwif_t *hwif)
{
727
	const struct ide_port_ops *port_ops = hwif->port_ops;
728
729
	ide_drive_t *drive;
	int i;
730

731
732
733
	ide_port_for_each_present_dev(i, drive, hwif) {
		if (port_ops && port_ops->quirkproc)
			port_ops->quirkproc(drive);
734
	}
735

736
737
	ide_port_for_each_present_dev(i, drive, hwif) {
		ide_set_max_pio(drive);
Linus Torvalds's avatar
Linus Torvalds committed
738

739
		drive->dev_flags |= IDE_DFLAG_NICE1;
Linus Torvalds's avatar
Linus Torvalds committed
740

741
742
		if (hwif->dma_ops)
			ide_set_dma(drive);
Linus Torvalds's avatar
Linus Torvalds committed
743
744
745
746
747
748
749
750
	}
}

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

764
	q = blk_init_queue_node(do_ide_request, NULL, hwif_to_node(hwif));
Linus Torvalds's avatar
Linus Torvalds committed
765
766
767
768
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
	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;
}

801
802
static DEFINE_MUTEX(ide_cfg_mtx);

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

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

823
		j++;
824
	}
825
	mutex_unlock(&ide_cfg_mtx);
826
827

	return j;
828
829
}

Linus Torvalds's avatar
Linus Torvalds committed
830
/*
831
 * This routine sets up the IRQ for an IDE interface.
Linus Torvalds's avatar
Linus Torvalds committed
832
833
834
 */
static int init_irq (ide_hwif_t *hwif)
{
835
	struct ide_io_ports *io_ports = &hwif->io_ports;
836
837
838
	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
839

840
841
842
	if (irq_handler == NULL)
		irq_handler = ide_intr;

843
	if (io_ports->ctl_addr)
844
		hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
Linus Torvalds's avatar
Linus Torvalds committed
845

846
	if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
847
		goto out_up;
Linus Torvalds's avatar
Linus Torvalds committed
848

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

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

	if ((drive->dev_flags & IDE_DFLAG_PRESENT) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
		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;
897
	return &disk_to_dev(p)->kobj;
Linus Torvalds's avatar
Linus Torvalds committed
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
}

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;
928
	unsigned int unit = drive->dn & 1;
Linus Torvalds's avatar
Linus Torvalds committed
929
930
931
932
933
934
935
936
937
938
939
940
941

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

942
943
	ide_proc_unregister_device(drive);

944
945
946
	blk_cleanup_queue(drive->queue);
	drive->queue = NULL;

947
948
	kfree(drive->id);
	drive->id = NULL;
949

950
	drive->dev_flags &= ~IDE_DFLAG_PRESENT;
951

952
	complete(&drive->gendev_rel_comp);
Linus Torvalds's avatar
Linus Torvalds committed
953
954
955
956
957
}

static int hwif_init(ide_hwif_t *hwif)
{
	if (!hwif->irq) {
958
959
		printk(KERN_ERR "%s: disabled, no IRQ\n", hwif->name);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
960
961
962
963
964
965
966
967
	}

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

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

968
	hwif->sg_table = kmalloc(sizeof(struct scatterlist)*hwif->sg_max_nents,
Linus Torvalds's avatar
Linus Torvalds committed
969
970
971
972
973
				 GFP_KERNEL);
	if (!hwif->sg_table) {
		printk(KERN_ERR "%s: unable to allocate SG table.\n", hwif->name);
		goto out;
	}
974
975

	sg_init_table(hwif->sg_table, hwif->sg_max_nents);
Linus Torvalds's avatar
Linus Torvalds committed
976
977
	
	if (init_irq(hwif)) {
978
979
		printk(KERN_ERR "%s: disabled, unable to get IRQ %d\n",
			hwif->name, hwif->irq);
Linus Torvalds's avatar
Linus Torvalds committed
980
981
982
		goto out;
	}

983
984
	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
985
986
987
988
989
990
991
	return 1;

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

992
993
static void hwif_register_devices(ide_hwif_t *hwif)
{
994
	ide_drive_t *drive;
995
996
	unsigned int i;

997
	ide_port_for_each_present_dev(i, drive, hwif) {
998
999
		struct device *dev = &drive->gendev;
		int ret;
1000

1001
		dev_set_name(dev, "%u.%u", hwif->index, i);
1002
1003
1004
1005
1006
1007
1008
1009
1010
		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);
1011
1012
1013
	}
}

1014
1015
static void ide_port_init_devices(ide_hwif_t *hwif)
{
1016
	const struct ide_port_ops *port_ops = hwif->port_ops;
1017
	ide_drive_t *drive;
1018
1019
	int i;

1020
	ide_port_for_each_dev(i, drive, hwif) {
1021
1022
		drive->dn = i + hwif->channel * 2;

1023
1024
		if (hwif->host_flags & IDE_HFLAG_IO_32BIT)
			drive->io_32bit = 1;
1025
1026
		if (hwif->host_flags & IDE_HFLAG_NO_IO_32BIT)
			drive->dev_flags |= IDE_DFLAG_NO_IO_32BIT;
1027
		if (hwif->host_flags & IDE_HFLAG_UNMASK_IRQS)
1028
			drive->dev_flags |= IDE_DFLAG_UNMASK;
1029
		if (hwif->host_flags & IDE_HFLAG_NO_UNMASK_IRQS)
1030
			drive->dev_flags |= IDE_DFLAG_NO_UNMASK;
1031

1032
1033
1034
		if (port_ops && port_ops->init_dev)
			port_ops->init_dev(drive);
	}
1035
1036
1037
1038
1039
1040
1041
1042
1043

	ide_port_for_each_dev(i, drive, hwif) {
		/*
		 * default to PIO Mode 0 before we figure out
		 * the most suited mode for the attached device
		 */
		if (port_ops && port_ops->set_pio_mode)
			port_ops->set_pio_mode(drive, 0);
	}
1044
1045
}

1046
1047
static void ide_init_port(ide_hwif_t *hwif, unsigned int port,
			  const struct ide_port_info *d)
1048
{
1049
	hwif->channel = port;
1050
1051
1052
1053
1054
1055
1056

	if (d->chipset)
		hwif->chipset = d->chipset;

	if (d->init_iops)
		d->init_iops(hwif);

1057
1058
	/* ->host_flags may be set by ->init_iops (or even earlier...) */
	hwif->host_flags |= d->host_flags;
1059
1060
	hwif->pio_mask = d->pio_mask;

1061
1062
1063
	if (d->tp_ops)
		hwif->tp_ops = d->tp_ops;

1064
	/* ->set_pio_mode for DTC2278 is currently limited to port 0 */
1065
	if ((hwif->host_flags & IDE_HFLAG_DTC2278) == 0 || hwif->channel == 0)
1066
1067
		hwif->port_ops = d->port_ops;

1068
1069
1070
1071
	hwif->swdma_mask = d->swdma_mask;
	hwif->mwdma_mask = d->mwdma_mask;
	hwif->ultra_mask = d->udma_mask;

1072
1073
1074
	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
		int rc;

1075
1076
		hwif->dma_ops = d->dma_ops;

1077
1078
1079
1080
1081
1082
1083
		if (d->init_dma)
			rc = d->init_dma(hwif, d);
		else
			rc = ide_hwif_setup_dma(hwif, d);

		if (rc < 0) {
			printk(KERN_INFO "%s: DMA disabled\n", hwif->name);
1084
1085

			hwif->dma_ops = NULL;
1086
			hwif->dma_base = 0;
1087
1088
1089
			hwif->swdma_mask = 0;
			hwif->mwdma_mask = 0;
			hwif->ultra_mask = 0;
1090
		}
1091
	}
1092

1093
	if ((d->host_flags & IDE_HFLAG_SERIALIZE) ||
1094
1095
	    ((d->host_flags & IDE_HFLAG_SERIALIZE_DMA) && hwif->dma_base))
		hwif->host->host_flags |= IDE_HFLAG_SERIALIZE;
1096

1097
1098
	if (d->max_sectors)
		hwif->rqsize = d->max_sectors;
1099
1100
1101
1102
1103
1104
1105
	else {
		if ((hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
		    (hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA))
			hwif->rqsize = 256;
		else
			hwif->rqsize = 65536;
	}
1106
1107
1108
1109

	/* call chipset specific routine for each enabled port */
	if (d->init_hwif)
		d->init_hwif(hwif);
1110
}
1111

1112
1113
static void ide_port_cable_detect(ide_hwif_t *hwif)
{
1114
1115
1116
	const struct ide_port_ops *port_ops = hwif->port_ops;

	if (port_ops && port_ops->cable_detect && (hwif->ultra_mask & 0x78)) {
1117
		if (hwif->cbl != ATA_CBL_PATA40_SHORT)
1118
			hwif->cbl = port_ops->cable_detect(hwif);
1119
	}
1120
1121
}

1122
1123
1124
1125
1126
1127
static const u8 ide_hwif_to_major[] =
	{ IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR, IDE4_MAJOR,
	  IDE5_MAJOR, IDE6_MAJOR, IDE7_MAJOR, IDE8_MAJOR, IDE9_MAJOR };

static void ide_port_init_devices_data(ide_hwif_t *hwif)
{
1128
1129
	ide_drive_t *drive;
	int i;
1130