setup-pci.c 14.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
25
26
27
28
29
 *  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>

/**
 *	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.
30
 *	Returns 0 on success or an errno code.
Linus Torvalds's avatar
Linus Torvalds committed
31
32
33
34
 *
 *	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 ??
 */
35
36

static int ide_setup_pci_baseregs(struct pci_dev *dev, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
{
	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
64
65
66
67
68
69
70
71
72
73
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
74
75
/**
 *	ide_get_or_set_dma_base		-	setup BMIBA
76
77
 *	@d: IDE port info
 *	@hwif: IDE interface
Linus Torvalds's avatar
Linus Torvalds committed
78
 *
79
80
81
 *	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
82
83
 */

84
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
85
{
86
87
	struct pci_dev *dev = to_pci_dev(hwif->dev);
	unsigned long dma_base = 0;
88
	u8 dma_stat = 0;
Linus Torvalds's avatar
Linus Torvalds committed
89
90
91
92
93
94
95

	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 {
96
97
98
99
		u8 baridx = (d->host_flags & IDE_HFLAG_CS5520) ? 2 : 4;

		dma_base = pci_resource_start(dev, baridx);

100
		if (dma_base == 0) {
101
			printk(KERN_ERR "%s: DMA base is invalid\n", d->name);
102
103
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
104
105
	}

106
107
108
	if (hwif->channel)
		dma_base += 8;

109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
	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
131
	}
132
out:
Linus Torvalds's avatar
Linus Torvalds committed
133
134
135
136
	return dma_base;
}
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */

137
void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
138
{
139
140
141
	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
142
143
144
145
146
147
148
}
EXPORT_SYMBOL_GPL(ide_setup_pci_noise);


/**
 *	ide_pci_enable	-	do PCI enables
 *	@dev: PCI device
149
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
150
151
 *
 *	Enable the IDE PCI device. We attempt to enable the device in full
152
153
154
 *	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.
155
 *
Linus Torvalds's avatar
Linus Torvalds committed
156
157
 *	Returns zero on success or an error code
 */
158

159
static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
160
{
161
	int ret, bars;
Linus Torvalds's avatar
Linus Torvalds committed
162
163

	if (pci_enable_device(dev)) {
164
		ret = pci_enable_device_io(dev);
Linus Torvalds's avatar
Linus Torvalds committed
165
166
167
168
169
170
171
172
173
		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);
	}

	/*
174
175
176
	 * 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
177
178
179
180
181
182
183
	 */
	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;
	}

184
185
186
187
	if (d->host_flags & IDE_HFLAG_SINGLE)
		bars = (1 << 2) - 1;
	else
		bars = (1 << 4) - 1;
Linus Torvalds's avatar
Linus Torvalds committed
188

189
190
191
192
193
194
195
196
197
198
	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
		if (d->host_flags & IDE_HFLAG_CS5520)
			bars |= (1 << 2);
		else
			bars |= (1 << 4);
	}

	ret = pci_request_selected_regions(dev, bars, d->name);
	if (ret < 0)
		printk(KERN_ERR "%s: can't reserve resources\n", d->name);
Linus Torvalds's avatar
Linus Torvalds committed
199
200
201
202
203
204
205
out:
	return ret;
}

/**
 *	ide_pci_configure	-	configure an unconfigured device
 *	@dev: PCI device
206
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
207
208
209
210
 *
 *	Enable and configure the PCI device we have been passed.
 *	Returns zero on success or an error code.
 */
211

212
static int ide_pci_configure(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
213
214
215
216
217
218
219
220
221
{
	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.
	 */
222
223
	if (ide_setup_pci_baseregs(dev, d->name) ||
	    pci_write_config_word(dev, PCI_COMMAND, pcicmd | PCI_COMMAND_IO)) {
Linus Torvalds's avatar
Linus Torvalds committed
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
		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
240
241
242
 *	@dev: PCI device
 *	@d: IDE port info
 *	@bar: BAR number
Linus Torvalds's avatar
Linus Torvalds committed
243
 *
244
245
 *	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
246
 */
247

248
249
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
250
251
{
	ulong flags = pci_resource_flags(dev, bar);
252

Linus Torvalds's avatar
Linus Torvalds committed
253
254
255
256
	/* Unconfigured ? */
	if (!flags || pci_resource_len(dev, bar) == 0)
		return 0;

257
258
	/* I/O space */
	if (flags & IORESOURCE_IO)
Linus Torvalds's avatar
Linus Torvalds committed
259
		return 0;
260

Linus Torvalds's avatar
Linus Torvalds committed
261
262
263
264
265
266
267
	/* Bad */
	return -EINVAL;
}

/**
 *	ide_hwif_configure	-	configure an IDE interface
 *	@dev: PCI device holding interface
268
 *	@d: IDE port info
269
270
 *	@port: port number
 *	@irq: PCI IRQ
Linus Torvalds's avatar
Linus Torvalds committed
271
272
273
274
275
276
277
 *
 *	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
 */
278

279
280
281
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
282
283
284
{
	unsigned long ctl = 0, base = 0;
	ide_hwif_t *hwif;
285
	struct hw_regs_s hw;
Linus Torvalds's avatar
Linus Torvalds committed
286

287
	if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
288
289
290
291
292
293
		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;
		}
294

Linus Torvalds's avatar
Linus Torvalds committed
295
296
297
298
299
300
301
302
		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;
		}
	}
303
	if (!ctl) {
Linus Torvalds's avatar
Linus Torvalds committed
304
305
306
307
		/* Use default values */
		ctl = port ? 0x374 : 0x3f4;
		base = port ? 0x170 : 0x1f0;
	}
308

309
	hwif = ide_find_port_slot(d);
310
311
312
313
314
	if (hwif == NULL) {
		printk(KERN_ERR "%s: too many IDE interfaces, no room in "
				"table\n", d->name);
		return NULL;
	}
315
316

	memset(&hw, 0, sizeof(hw));
317
	hw.irq = irq;
318
319
320
321
322
323
	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);

324
	hwif->dev = &dev->dev;
325
	hwif->cds = d;
Linus Torvalds's avatar
Linus Torvalds committed
326
327
328
329

	return hwif;
}

330
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
Linus Torvalds's avatar
Linus Torvalds committed
331
332
/**
 *	ide_hwif_setup_dma	-	configure DMA interface
333
 *	@hwif: IDE interface
334
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
335
336
337
338
339
 *
 *	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
 */
340

341
void ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
342
{
343
	struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds's avatar
Linus Torvalds committed
344
	u16 pcicmd;
345

Linus Torvalds's avatar
Linus Torvalds committed
346
347
	pci_read_config_word(dev, PCI_COMMAND, &pcicmd);

348
	if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 ||
Linus Torvalds's avatar
Linus Torvalds committed
349
350
	    ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
	     (dev->class & 0x80))) {
351
		unsigned long dma_base = ide_get_or_set_dma_base(d, hwif);
Linus Torvalds's avatar
Linus Torvalds committed
352
353
		if (dma_base && !(pcicmd & PCI_COMMAND_MASTER)) {
			/*
354
			 * Set up BM-DMA capability
Linus Torvalds's avatar
Linus Torvalds committed
355
			 * (PnP BIOS should have done this)
356
			 */
Linus Torvalds's avatar
Linus Torvalds committed
357
358
359
360
361
362
363
364
365
366
367
			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 {
368
				ide_setup_dma(hwif, dma_base);
Linus Torvalds's avatar
Linus Torvalds committed
369
370
371
372
373
374
			}
		} else {
			printk(KERN_INFO "%s: %s Bus-Master DMA disabled "
				"(BIOS)\n", hwif->name, d->name);
		}
	}
375
}
376
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
Linus Torvalds's avatar
Linus Torvalds committed
377
378
379
380

/**
 *	ide_setup_pci_controller	-	set up IDE PCI
 *	@dev: PCI device
381
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
382
383
384
385
386
387
388
 *	@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
 */
389

390
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
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
{
	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
422
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
423
 *	@pciirq: IRQ line
424
 *	@idx: ATA index table to update
Linus Torvalds's avatar
Linus Torvalds committed
425
426
427
428
429
430
431
432
433
 *
 *	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.
 */
434

435
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
436
{
437
	int channels = (d->host_flags & IDE_HFLAG_SINGLE) ? 1 : 2, port;
438
	ide_hwif_t *hwif;
Linus Torvalds's avatar
Linus Torvalds committed
439
440
441
442
443
	u8 tmp;

	/*
	 * Set up the IDE ports
	 */
444

445
	for (port = 0; port < channels; ++port) {
446
447
		const ide_pci_enablebit_t *e = &(d->enablebits[port]);

Linus Torvalds's avatar
Linus Torvalds committed
448
		if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
449
450
		    (tmp & e->mask) != e->val)) {
			printk(KERN_INFO "%s: IDE port disabled\n", d->name);
Linus Torvalds's avatar
Linus Torvalds committed
451
			continue;	/* port not enabled */
452
		}
Linus Torvalds's avatar
Linus Torvalds committed
453

454
455
		hwif = ide_hwif_configure(dev, d, port, pciirq);
		if (hwif == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
456
457
			continue;

458
		*(idx + port) = hwif->index;
459
	}
Linus Torvalds's avatar
Linus Torvalds committed
460
461
462
463
464
465
466
467
468
469
}
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
470
 * we "know" about, this information is in the struct ide_port_info;
Linus Torvalds's avatar
Linus Torvalds committed
471
472
 * for all other chipsets, we just assume both interfaces are enabled.
 */
473
static int do_ide_setup_pci_device(struct pci_dev *dev,
474
				   const struct ide_port_info *d,
475
				   u8 *idx, u8 noisy)
Linus Torvalds's avatar
Linus Torvalds committed
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
{
	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 */

526
	ide_pci_setup_ports(dev, d, pciirq, idx);
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
530
out:
	return ret;
}

531
int ide_setup_pci_device(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
532
{
533
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
534
535
	int ret;

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

538
	if (ret >= 0)
539
		ide_device_add(idx, d);
Linus Torvalds's avatar
Linus Torvalds committed
540
541
542
543
544
545

	return ret;
}
EXPORT_SYMBOL_GPL(ide_setup_pci_device);

int ide_setup_pci_devices(struct pci_dev *dev1, struct pci_dev *dev2,
546
			  const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
547
548
549
{
	struct pci_dev *pdev[] = { dev1, dev2 };
	int ret, i;
550
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
551
552

	for (i = 0; i < 2; i++) {
553
		ret = do_ide_setup_pci_device(pdev[i], d, &idx[i*2], !i);
Linus Torvalds's avatar
Linus Torvalds committed
554
555
556
557
558
559
560
561
		/*
		 * 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;
	}

562
	ide_device_add(idx, d);
Linus Torvalds's avatar
Linus Torvalds committed
563
564
565
566
out:
	return ret;
}
EXPORT_SYMBOL_GPL(ide_setup_pci_devices);