setup-pci.c 15.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
3
4
 *  Copyright (C) 1998-2000  Andre Hedrick <andre@linux-ide.org>
 *  Copyright (C) 1995-1998  Mark Lord
 *  Copyright (C)      2007  Bartlomiej Zolnierkiewicz
5
 *
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 *  May be copied or modified under the terms of the GNU General Public License
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/timer.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/ide.h>
#include <linux/dma-mapping.h>

#include <asm/io.h>
#include <asm/irq.h>


/**
25
26
 *	ide_match_hwif	-	find free ide_hwifs[] slot
 *	@bootable: bootable flag
Linus Torvalds's avatar
Linus Torvalds committed
27
 *
28
 *	Return the new hwif.  If we are out of free slots return NULL.
Linus Torvalds's avatar
Linus Torvalds committed
29
30
 */

31
static ide_hwif_t *ide_match_hwif(u8 bootable)
Linus Torvalds's avatar
Linus Torvalds committed
32
33
{
	ide_hwif_t *hwif;
34
	int h;
Linus Torvalds's avatar
Linus Torvalds committed
35
36

	/*
37
38
	 * Claim an unassigned slot.
	 *
Linus Torvalds's avatar
Linus Torvalds committed
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
	 * Give preference to claiming other slots before claiming ide0/ide1,
	 * just in case there's another interface yet-to-be-scanned
	 * which uses ports 1f0/170 (the ide0/ide1 defaults).
	 *
	 * Unless there is a bootable card that does not use the standard
	 * ports 1f0/170 (the ide0/ide1 defaults). The (bootable) flag.
	 */
	if (bootable) {
		for (h = 0; h < MAX_HWIFS; ++h) {
			hwif = &ide_hwifs[h];
			if (hwif->chipset == ide_unknown)
				return hwif;	/* pick an unused entry */
		}
	} else {
		for (h = 2; h < MAX_HWIFS; ++h) {
			hwif = ide_hwifs + h;
			if (hwif->chipset == ide_unknown)
				return hwif;	/* pick an unused entry */
		}
	}
59
	for (h = 0; h < 2 && h < MAX_HWIFS; ++h) {
Linus Torvalds's avatar
Linus Torvalds committed
60
61
62
63
		hwif = ide_hwifs + h;
		if (hwif->chipset == ide_unknown)
			return hwif;	/* pick an unused entry */
	}
64

Linus Torvalds's avatar
Linus Torvalds committed
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
	return NULL;
}

/**
 *	ide_setup_pci_baseregs	-	place a PCI IDE controller native
 *	@dev: PCI device of interface to switch native
 *	@name: Name of interface
 *
 *	We attempt to place the PCI interface into PCI native mode. If
 *	we succeed the BARs are ok and the controller is in PCI mode.
 *	Returns 0 on success or an errno code. 
 *
 *	FIXME: if we program the interface and then fail to set the BARS
 *	we don't switch it back to legacy mode. Do we actually care ??
 */
 
static int ide_setup_pci_baseregs (struct pci_dev *dev, const char *name)
{
	u8 progif = 0;

	/*
	 * Place both IDE interfaces into PCI "native" mode:
	 */
	if (pci_read_config_byte(dev, PCI_CLASS_PROG, &progif) ||
			 (progif & 5) != 5) {
		if ((progif & 0xa) != 0xa) {
			printk(KERN_INFO "%s: device not capable of full "
				"native PCI mode\n", name);
			return -EOPNOTSUPP;
		}
		printk("%s: placing both ports into native PCI mode\n", name);
		(void) pci_write_config_byte(dev, PCI_CLASS_PROG, progif|5);
		if (pci_read_config_byte(dev, PCI_CLASS_PROG, &progif) ||
		    (progif & 5) != 5) {
			printk(KERN_ERR "%s: rewrite of PROGIF failed, wanted "
				"0x%04x, got 0x%04x\n",
				name, progif|5, progif);
			return -EOPNOTSUPP;
		}
	}
	return 0;
}

#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
109
110
111
112
113
114
115
116
117
118
static void ide_pci_clear_simplex(unsigned long dma_base, const char *name)
{
	u8 dma_stat = inb(dma_base + 2);

	outb(dma_stat & 0x60, dma_base + 2);
	dma_stat = inb(dma_base + 2);
	if (dma_stat & 0x80)
		printk(KERN_INFO "%s: simplex device: DMA forced\n", name);
}

Linus Torvalds's avatar
Linus Torvalds committed
119
120
/**
 *	ide_get_or_set_dma_base		-	setup BMIBA
121
122
 *	@d: IDE port info
 *	@hwif: IDE interface
Linus Torvalds's avatar
Linus Torvalds committed
123
 *
124
125
126
 *	Fetch the DMA Bus-Master-I/O-Base-Address (BMIBA) from PCI space.
 *	Where a device has a partner that is already in DMA mode we check
 *	and enforce IDE simplex rules.
Linus Torvalds's avatar
Linus Torvalds committed
127
128
 */

129
static unsigned long ide_get_or_set_dma_base(const struct ide_port_info *d, ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
130
{
131
132
	struct pci_dev *dev = to_pci_dev(hwif->dev);
	unsigned long dma_base = 0;
133
	u8 dma_stat = 0;
Linus Torvalds's avatar
Linus Torvalds committed
134
135
136
137
138
139
140

	if (hwif->mmio)
		return hwif->dma_base;

	if (hwif->mate && hwif->mate->dma_base) {
		dma_base = hwif->mate->dma_base - (hwif->channel ? 0 : 8);
	} else {
141
142
143
144
		u8 baridx = (d->host_flags & IDE_HFLAG_CS5520) ? 2 : 4;

		dma_base = pci_resource_start(dev, baridx);

145
		if (dma_base == 0) {
146
			printk(KERN_ERR "%s: DMA base is invalid\n", d->name);
147
148
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
149
150
	}

151
152
153
	if (hwif->channel)
		dma_base += 8;

154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
	if (d->host_flags & IDE_HFLAG_CS5520)
		goto out;

	if (d->host_flags & IDE_HFLAG_CLEAR_SIMPLEX) {
		ide_pci_clear_simplex(dma_base, d->name);
		goto out;
	}

	/*
	 * If the device claims "simplex" DMA, this means that only one of
	 * the two interfaces can be trusted with DMA at any point in time
	 * (so we should enable DMA only on one of the two interfaces).
	 *
	 * FIXME: At this point we haven't probed the drives so we can't make
	 * the appropriate decision.  Really we should defer this problem until
	 * we tune the drive then try to grab DMA ownership if we want to be
	 * the DMA end.  This has to be become dynamic to handle hot-plug.
	 */
	dma_stat = hwif->INB(dma_base + 2);
	if ((dma_stat & 0x80) && hwif->mate && hwif->mate->dma_base) {
		printk(KERN_INFO "%s: simplex device: DMA disabled\n", d->name);
		dma_base = 0;
Linus Torvalds's avatar
Linus Torvalds committed
176
	}
177
out:
Linus Torvalds's avatar
Linus Torvalds committed
178
179
180
181
	return dma_base;
}
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */

182
void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
183
{
184
185
186
	printk(KERN_INFO "%s: IDE controller (0x%04x:0x%04x rev 0x%02x) at "
			 " PCI slot %s\n", d->name, dev->vendor, dev->device,
			 dev->revision, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
187
188
189
190
191
192
193
194
}

EXPORT_SYMBOL_GPL(ide_setup_pci_noise);


/**
 *	ide_pci_enable	-	do PCI enables
 *	@dev: PCI device
195
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
196
197
 *
 *	Enable the IDE PCI device. We attempt to enable the device in full
198
199
200
 *	but if that fails then we only need IO space. The PCI code should
 *	have setup the proper resources for us already for controllers in
 *	legacy mode.
Linus Torvalds's avatar
Linus Torvalds committed
201
202
203
 *	
 *	Returns zero on success or an error code
 */
204

205
static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
206
207
208
209
{
	int ret;

	if (pci_enable_device(dev)) {
210
		ret = pci_enable_device_io(dev);
Linus Torvalds's avatar
Linus Torvalds committed
211
212
213
214
215
216
217
218
219
		if (ret < 0) {
			printk(KERN_WARNING "%s: (ide_setup_pci_device:) "
				"Could not enable device.\n", d->name);
			goto out;
		}
		printk(KERN_WARNING "%s: BIOS configuration fixed.\n", d->name);
	}

	/*
220
221
222
	 * assume all devices can do 32-bit DMA for now, we can add
	 * a DMA mask field to the struct ide_port_info if we need it
	 * (or let lower level driver set the DMA mask)
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
	 */
	ret = pci_set_dma_mask(dev, DMA_32BIT_MASK);
	if (ret < 0) {
		printk(KERN_ERR "%s: can't set dma mask\n", d->name);
		goto out;
	}

	/* FIXME: Temporary - until we put in the hotplug interface logic
	   Check that the bits we want are not in use by someone else. */
	ret = pci_request_region(dev, 4, "ide_tmp");
	if (ret < 0)
		goto out;

	pci_release_region(dev, 4);
out:
	return ret;
}

/**
 *	ide_pci_configure	-	configure an unconfigured device
 *	@dev: PCI device
244
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
245
246
247
248
 *
 *	Enable and configure the PCI device we have been passed.
 *	Returns zero on success or an error code.
 */
249

250
static int ide_pci_configure(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
{
	u16 pcicmd = 0;
	/*
	 * PnP BIOS was *supposed* to have setup this device, but we
	 * can do it ourselves, so long as the BIOS has assigned an IRQ
	 * (or possibly the device is using a "legacy header" for IRQs).
	 * Maybe the user deliberately *disabled* the device,
	 * but we'll eventually ignore it again if no drives respond.
	 */
	if (ide_setup_pci_baseregs(dev, d->name) || pci_write_config_word(dev, PCI_COMMAND, pcicmd|PCI_COMMAND_IO)) 
	{
		printk(KERN_INFO "%s: device disabled (BIOS)\n", d->name);
		return -ENODEV;
	}
	if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd)) {
		printk(KERN_ERR "%s: error accessing PCI regs\n", d->name);
		return -EIO;
	}
	if (!(pcicmd & PCI_COMMAND_IO)) {
		printk(KERN_ERR "%s: unable to enable IDE controller\n", d->name);
		return -ENXIO;
	}
	return 0;
}

/**
 *	ide_pci_check_iomem	-	check a register is I/O
278
279
280
 *	@dev: PCI device
 *	@d: IDE port info
 *	@bar: BAR number
Linus Torvalds's avatar
Linus Torvalds committed
281
 *
282
283
 *	Checks if a BAR is configured and points to MMIO space. If so,
 *	return an error code. Otherwise return 0
Linus Torvalds's avatar
Linus Torvalds committed
284
 */
285

286
287
static int ide_pci_check_iomem(struct pci_dev *dev, const struct ide_port_info *d,
			       int bar)
Linus Torvalds's avatar
Linus Torvalds committed
288
289
290
291
292
293
294
{
	ulong flags = pci_resource_flags(dev, bar);
	
	/* Unconfigured ? */
	if (!flags || pci_resource_len(dev, bar) == 0)
		return 0;

295
296
	/* I/O space */
	if (flags & IORESOURCE_IO)
Linus Torvalds's avatar
Linus Torvalds committed
297
298
299
300
301
302
303
304
305
		return 0;
		
	/* Bad */
	return -EINVAL;
}

/**
 *	ide_hwif_configure	-	configure an IDE interface
 *	@dev: PCI device holding interface
306
 *	@d: IDE port info
307
308
 *	@port: port number
 *	@irq: PCI IRQ
Linus Torvalds's avatar
Linus Torvalds committed
309
310
311
312
313
314
315
 *
 *	Perform the initial set up for the hardware interface structure. This
 *	is done per interface port rather than per PCI device. There may be
 *	more than one port per device.
 *
 *	Returns the new hardware interface structure, or NULL on a failure
 */
316

317
318
319
static ide_hwif_t *ide_hwif_configure(struct pci_dev *dev,
				      const struct ide_port_info *d,
				      unsigned int port, int irq)
Linus Torvalds's avatar
Linus Torvalds committed
320
321
322
{
	unsigned long ctl = 0, base = 0;
	ide_hwif_t *hwif;
323
	u8 bootable = (d->host_flags & IDE_HFLAG_NON_BOOTABLE) ? 0 : 1;
324
	struct hw_regs_s hw;
Linus Torvalds's avatar
Linus Torvalds committed
325

326
	if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
327
328
329
330
331
332
		if (ide_pci_check_iomem(dev, d, 2 * port) ||
		    ide_pci_check_iomem(dev, d, 2 * port + 1)) {
			printk(KERN_ERR "%s: I/O baseregs (BIOS) are reported "
					"as MEM for port %d!\n", d->name, port);
			return NULL;
		}
Linus Torvalds's avatar
Linus Torvalds committed
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 
		ctl  = pci_resource_start(dev, 2*port+1);
		base = pci_resource_start(dev, 2*port);
		if ((ctl && !base) || (base && !ctl)) {
			printk(KERN_ERR "%s: inconsistent baseregs (BIOS) "
				"for port %d, skipping\n", d->name, port);
			return NULL;
		}
	}
	if (!ctl)
	{
		/* Use default values */
		ctl = port ? 0x374 : 0x3f4;
		base = port ? 0x170 : 0x1f0;
	}
348
349
350
351
352
353
354

	hwif = ide_match_hwif(bootable);
	if (hwif == NULL) {
		printk(KERN_ERR "%s: too many IDE interfaces, no room in "
				"table\n", d->name);
		return NULL;
	}
355
356

	memset(&hw, 0, sizeof(hw));
357
	hw.irq = irq;
358
359
360
361
362
363
	hw.dev = &dev->dev;
	hw.chipset = d->chipset ? d->chipset : ide_pci;
	ide_std_init_ports(&hw, base, ctl | 2);

	ide_init_port_hw(hwif, &hw);

364
	hwif->dev = &dev->dev;
365
	hwif->cds = d;
Linus Torvalds's avatar
Linus Torvalds committed
366
367
368
369

	return hwif;
}

370
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
Linus Torvalds's avatar
Linus Torvalds committed
371
372
/**
 *	ide_hwif_setup_dma	-	configure DMA interface
373
 *	@hwif: IDE interface
374
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
375
376
377
378
379
 *
 *	Set up the DMA base for the interface. Enable the master bits as
 *	necessary and attempt to bring the device DMA into a ready to use
 *	state
 */
380

381
void ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
382
{
383
	struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds's avatar
Linus Torvalds committed
384
	u16 pcicmd;
385

Linus Torvalds's avatar
Linus Torvalds committed
386
387
	pci_read_config_word(dev, PCI_COMMAND, &pcicmd);

388
	if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 ||
Linus Torvalds's avatar
Linus Torvalds committed
389
390
	    ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
	     (dev->class & 0x80))) {
391
		unsigned long dma_base = ide_get_or_set_dma_base(d, hwif);
Linus Torvalds's avatar
Linus Torvalds committed
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
		if (dma_base && !(pcicmd & PCI_COMMAND_MASTER)) {
			/*
 			 * Set up BM-DMA capability
			 * (PnP BIOS should have done this)
 			 */
			pci_set_master(dev);
			if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd) || !(pcicmd & PCI_COMMAND_MASTER)) {
				printk(KERN_ERR "%s: %s error updating PCICMD\n",
					hwif->name, d->name);
				dma_base = 0;
			}
		}
		if (dma_base) {
			if (d->init_dma) {
				d->init_dma(hwif, dma_base);
			} else {
408
				ide_setup_dma(hwif, dma_base);
Linus Torvalds's avatar
Linus Torvalds committed
409
410
411
412
413
414
			}
		} else {
			printk(KERN_INFO "%s: %s Bus-Master DMA disabled "
				"(BIOS)\n", hwif->name, d->name);
		}
	}
415
}
416
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
Linus Torvalds's avatar
Linus Torvalds committed
417
418
419
420

/**
 *	ide_setup_pci_controller	-	set up IDE PCI
 *	@dev: PCI device
421
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
422
423
424
425
426
427
428
 *	@noisy: verbose flag
 *	@config: returned as 1 if we configured the hardware
 *
 *	Set up the PCI and controller side of the IDE interface. This brings
 *	up the PCI side of the device, checks that the device is enabled
 *	and enables it if need be
 */
429

430
static int ide_setup_pci_controller(struct pci_dev *dev, const struct ide_port_info *d, int noisy, int *config)
Linus Torvalds's avatar
Linus Torvalds committed
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
{
	int ret;
	u16 pcicmd;

	if (noisy)
		ide_setup_pci_noise(dev, d);

	ret = ide_pci_enable(dev, d);
	if (ret < 0)
		goto out;

	ret = pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
	if (ret < 0) {
		printk(KERN_ERR "%s: error accessing PCI regs\n", d->name);
		goto out;
	}
	if (!(pcicmd & PCI_COMMAND_IO)) {	/* is device disabled? */
		ret = ide_pci_configure(dev, d);
		if (ret < 0)
			goto out;
		*config = 1;
		printk(KERN_INFO "%s: device enabled (Linux)\n", d->name);
	}

out:
	return ret;
}

/**
 *	ide_pci_setup_ports	-	configure ports/devices on PCI IDE
 *	@dev: PCI device
462
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
463
 *	@pciirq: IRQ line
464
 *	@idx: ATA index table to update
Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
469
470
471
472
473
 *
 *	Scan the interfaces attached to this device and do any
 *	necessary per port setup. Attach the devices and ask the
 *	generic DMA layer to do its work for us.
 *
 *	Normally called automaticall from do_ide_pci_setup_device,
 *	but is also used directly as a helper function by some controllers
 *	where the chipset setup is not the default PCI IDE one.
 */
474

475
void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d, int pciirq, u8 *idx)
Linus Torvalds's avatar
Linus Torvalds committed
476
{
477
	int channels = (d->host_flags & IDE_HFLAG_SINGLE) ? 1 : 2, port;
478
	ide_hwif_t *hwif;
Linus Torvalds's avatar
Linus Torvalds committed
479
480
481
482
483
	u8 tmp;

	/*
	 * Set up the IDE ports
	 */
484

485
	for (port = 0; port < channels; ++port) {
486
487
		const ide_pci_enablebit_t *e = &(d->enablebits[port]);

Linus Torvalds's avatar
Linus Torvalds committed
488
		if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
489
490
		    (tmp & e->mask) != e->val)) {
			printk(KERN_INFO "%s: IDE port disabled\n", d->name);
Linus Torvalds's avatar
Linus Torvalds committed
491
			continue;	/* port not enabled */
492
		}
Linus Torvalds's avatar
Linus Torvalds committed
493

494
495
		hwif = ide_hwif_configure(dev, d, port, pciirq);
		if (hwif == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
496
497
			continue;

498
		*(idx + port) = hwif->index;
499
	}
Linus Torvalds's avatar
Linus Torvalds committed
500
501
502
503
504
505
506
507
508
509
510
}

EXPORT_SYMBOL_GPL(ide_pci_setup_ports);

/*
 * ide_setup_pci_device() looks at the primary/secondary interfaces
 * on a PCI IDE device and, if they are enabled, prepares the IDE driver
 * for use with them.  This generic code works for most PCI chipsets.
 *
 * One thing that is not standardized is the location of the
 * primary/secondary interface "enable/disable" bits.  For chipsets that
511
 * we "know" about, this information is in the struct ide_port_info;
Linus Torvalds's avatar
Linus Torvalds committed
512
513
 * for all other chipsets, we just assume both interfaces are enabled.
 */
514
static int do_ide_setup_pci_device(struct pci_dev *dev,
515
				   const struct ide_port_info *d,
516
				   u8 *idx, u8 noisy)
Linus Torvalds's avatar
Linus Torvalds committed
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
{
	int tried_config = 0;
	int pciirq, ret;

	ret = ide_setup_pci_controller(dev, d, noisy, &tried_config);
	if (ret < 0)
		goto out;

	/*
	 * Can we trust the reported IRQ?
	 */
	pciirq = dev->irq;

	/* Is it an "IDE storage" device in non-PCI mode? */
	if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE && (dev->class & 5) != 5) {
		if (noisy)
			printk(KERN_INFO "%s: not 100%% native mode: "
				"will probe irqs later\n", d->name);
		/*
		 * This allows offboard ide-pci cards the enable a BIOS,
		 * verify interrupt settings of split-mirror pci-config
		 * space, place chipset into init-mode, and/or preserve
		 * an interrupt if the card is not native ide support.
		 */
		ret = d->init_chipset ? d->init_chipset(dev, d->name) : 0;
		if (ret < 0)
			goto out;
		pciirq = ret;
	} else if (tried_config) {
		if (noisy)
			printk(KERN_INFO "%s: will probe irqs later\n", d->name);
		pciirq = 0;
	} else if (!pciirq) {
		if (noisy)
			printk(KERN_WARNING "%s: bad irq (%d): will probe later\n",
				d->name, pciirq);
		pciirq = 0;
	} else {
		if (d->init_chipset) {
			ret = d->init_chipset(dev, d->name);
			if (ret < 0)
				goto out;
		}
		if (noisy)
			printk(KERN_INFO "%s: 100%% native mode on irq %d\n",
				d->name, pciirq);
	}

	/* FIXME: silent failure can happen */

567
	ide_pci_setup_ports(dev, d, pciirq, idx);
Linus Torvalds's avatar
Linus Torvalds committed
568
569
570
571
out:
	return ret;
}

572
int ide_setup_pci_device(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
573
{
574
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
575
576
	int ret;

577
	ret = do_ide_setup_pci_device(dev, d, &idx[0], 1);
Linus Torvalds's avatar
Linus Torvalds committed
578

579
	if (ret >= 0)
580
		ide_device_add(idx, d);
Linus Torvalds's avatar
Linus Torvalds committed
581
582
583
584
585
586
587

	return ret;
}

EXPORT_SYMBOL_GPL(ide_setup_pci_device);

int ide_setup_pci_devices(struct pci_dev *dev1, struct pci_dev *dev2,
588
			  const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
589
590
591
{
	struct pci_dev *pdev[] = { dev1, dev2 };
	int ret, i;
592
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
593
594

	for (i = 0; i < 2; i++) {
595
		ret = do_ide_setup_pci_device(pdev[i], d, &idx[i*2], !i);
Linus Torvalds's avatar
Linus Torvalds committed
596
597
598
599
600
601
602
603
		/*
		 * FIXME: Mom, mom, they stole me the helper function to undo
		 * do_ide_setup_pci_device() on the first device!
		 */
		if (ret < 0)
			goto out;
	}

604
	ide_device_add(idx, d);
Linus Torvalds's avatar
Linus Torvalds committed
605
606
607
608
609
out:
	return ret;
}

EXPORT_SYMBOL_GPL(ide_setup_pci_devices);