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

#include <linux/types.h>
#include <linux/kernel.h>
11
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/ide.h>
#include <linux/dma-mapping.h>

#include <asm/io.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.
27
 *	Returns 0 on success or an errno code.
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30 31
 *
 *	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 ??
 */
32 33

static int ide_setup_pci_baseregs(struct pci_dev *dev, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37 38 39 40 41 42
{
	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) {
43 44
			printk(KERN_INFO "%s %s: device not capable of full "
				"native PCI mode\n", name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
45 46
			return -EOPNOTSUPP;
		}
47 48
		printk(KERN_INFO "%s %s: placing both ports into native PCI "
			"mode\n", name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51
		(void) pci_write_config_byte(dev, PCI_CLASS_PROG, progif|5);
		if (pci_read_config_byte(dev, PCI_CLASS_PROG, &progif) ||
		    (progif & 5) != 5) {
52 53 54
			printk(KERN_ERR "%s %s: rewrite of PROGIF failed, "
				"wanted 0x%04x, got 0x%04x\n",
				name, pci_name(dev), progif | 5, progif);
Linus Torvalds's avatar
Linus Torvalds committed
55 56 57 58 59 60 61
			return -EOPNOTSUPP;
		}
	}
	return 0;
}

#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
62
static int ide_pci_clear_simplex(unsigned long dma_base, const char *name)
63 64 65 66 67
{
	u8 dma_stat = inb(dma_base + 2);

	outb(dma_stat & 0x60, dma_base + 2);
	dma_stat = inb(dma_base + 2);
68 69

	return (dma_stat & 0x80) ? 1 : 0;
70 71
}

Linus Torvalds's avatar
Linus Torvalds committed
72
/**
73
 *	ide_pci_dma_base	-	setup BMIBA
74
 *	@hwif: IDE interface
75
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
76
 *
77
 *	Fetch the DMA Bus-Master-I/O-Base-Address (BMIBA) from PCI space.
Linus Torvalds's avatar
Linus Torvalds committed
78 79
 */

80
unsigned long ide_pci_dma_base(ide_hwif_t *hwif, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
81
{
82 83
	struct pci_dev *dev = to_pci_dev(hwif->dev);
	unsigned long dma_base = 0;
Linus Torvalds's avatar
Linus Torvalds committed
84

85
	if (hwif->host_flags & IDE_HFLAG_MMIO)
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88 89 90
		return hwif->dma_base;

	if (hwif->mate && hwif->mate->dma_base) {
		dma_base = hwif->mate->dma_base - (hwif->channel ? 0 : 8);
	} else {
91 92 93 94
		u8 baridx = (d->host_flags & IDE_HFLAG_CS5520) ? 2 : 4;

		dma_base = pci_resource_start(dev, baridx);

95
		if (dma_base == 0) {
96 97
			printk(KERN_ERR "%s %s: DMA base is invalid\n",
				d->name, pci_name(dev));
98 99
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
100 101
	}

102 103 104
	if (hwif->channel)
		dma_base += 8;

105 106 107 108 109 110
	return dma_base;
}
EXPORT_SYMBOL_GPL(ide_pci_dma_base);

int ide_pci_check_simplex(ide_hwif_t *hwif, const struct ide_port_info *d)
{
111
	struct pci_dev *dev = to_pci_dev(hwif->dev);
112 113 114
	u8 dma_stat;

	if (d->host_flags & (IDE_HFLAG_MMIO | IDE_HFLAG_CS5520))
115 116 117
		goto out;

	if (d->host_flags & IDE_HFLAG_CLEAR_SIMPLEX) {
118 119 120
		if (ide_pci_clear_simplex(hwif->dma_base, d->name))
			printk(KERN_INFO "%s %s: simplex device: DMA forced\n",
				d->name, pci_name(dev));
121 122 123 124 125 126 127 128 129 130 131 132 133
		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.
	 */
134
	dma_stat = hwif->dma_ops->dma_sff_read_status(hwif);
135
	if ((dma_stat & 0x80) && hwif->mate && hwif->mate->dma_base) {
136 137
		printk(KERN_INFO "%s %s: simplex device: DMA disabled\n",
			d->name, pci_name(dev));
138
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
139
	}
140
out:
141
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
142
}
143
EXPORT_SYMBOL_GPL(ide_pci_check_simplex);
144 145 146 147

/*
 * Set up BM-DMA capability (PnP BIOS should have done this)
 */
148
int ide_pci_set_master(struct pci_dev *dev, const char *name)
149 150 151 152 153 154 155 156 157 158
{
	u16 pcicmd;

	pci_read_config_word(dev, PCI_COMMAND, &pcicmd);

	if ((pcicmd & PCI_COMMAND_MASTER) == 0) {
		pci_set_master(dev);

		if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd) ||
		    (pcicmd & PCI_COMMAND_MASTER) == 0) {
159 160
			printk(KERN_ERR "%s %s: error updating PCICMD\n",
				name, pci_name(dev));
161 162 163 164 165 166
			return -EIO;
		}
	}

	return 0;
}
167
EXPORT_SYMBOL_GPL(ide_pci_set_master);
Linus Torvalds's avatar
Linus Torvalds committed
168 169
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */

170
void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
171
{
172 173 174
	printk(KERN_INFO "%s %s: IDE controller (0x%04x:0x%04x rev 0x%02x)\n",
		d->name, pci_name(dev),
		dev->vendor, dev->device, dev->revision);
Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178 179 180 181
}
EXPORT_SYMBOL_GPL(ide_setup_pci_noise);


/**
 *	ide_pci_enable	-	do PCI enables
 *	@dev: PCI device
182
 *	@bars: PCI BARs mask
183
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
184 185
 *
 *	Enable the IDE PCI device. We attempt to enable the device in full
186 187 188
 *	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.
189
 *
Linus Torvalds's avatar
Linus Torvalds committed
190 191
 *	Returns zero on success or an error code
 */
192

193 194
static int ide_pci_enable(struct pci_dev *dev, int bars,
			  const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
195
{
196
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
197 198

	if (pci_enable_device(dev)) {
199
		ret = pci_enable_device_io(dev);
Linus Torvalds's avatar
Linus Torvalds committed
200
		if (ret < 0) {
201 202
			printk(KERN_WARNING "%s %s: couldn't enable device\n",
				d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
203 204
			goto out;
		}
205 206
		printk(KERN_WARNING "%s %s: BIOS configuration fixed\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209
	}

	/*
210 211 212
	 * 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
213
	 */
214
	ret = dma_set_mask(&dev->dev, DMA_BIT_MASK(32));
Linus Torvalds's avatar
Linus Torvalds committed
215
	if (ret < 0) {
216 217
		printk(KERN_ERR "%s %s: can't set DMA mask\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
218 219 220
		goto out;
	}

221 222
	ret = pci_request_selected_regions(dev, bars, d->name);
	if (ret < 0)
223 224
		printk(KERN_ERR "%s %s: can't reserve resources\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229 230 231
out:
	return ret;
}

/**
 *	ide_pci_configure	-	configure an unconfigured device
 *	@dev: PCI device
232
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236
 *
 *	Enable and configure the PCI device we have been passed.
 *	Returns zero on success or an error code.
 */
237

238
static int ide_pci_configure(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242 243 244 245 246 247
{
	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.
	 */
248 249
	if (ide_setup_pci_baseregs(dev, d->name) ||
	    pci_write_config_word(dev, PCI_COMMAND, pcicmd | PCI_COMMAND_IO)) {
250 251
		printk(KERN_INFO "%s %s: device disabled (BIOS)\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
252 253 254
		return -ENODEV;
	}
	if (pci_read_config_word(dev, PCI_COMMAND, &pcicmd)) {
255 256
		printk(KERN_ERR "%s %s: error accessing PCI regs\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
257 258 259
		return -EIO;
	}
	if (!(pcicmd & PCI_COMMAND_IO)) {
260 261
		printk(KERN_ERR "%s %s: unable to enable IDE controller\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
262 263 264 265 266 267 268
		return -ENXIO;
	}
	return 0;
}

/**
 *	ide_pci_check_iomem	-	check a register is I/O
269 270 271
 *	@dev: PCI device
 *	@d: IDE port info
 *	@bar: BAR number
Linus Torvalds's avatar
Linus Torvalds committed
272
 *
273 274
 *	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
275
 */
276

277 278
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
279 280
{
	ulong flags = pci_resource_flags(dev, bar);
281

Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285
	/* Unconfigured ? */
	if (!flags || pci_resource_len(dev, bar) == 0)
		return 0;

286 287
	/* I/O space */
	if (flags & IORESOURCE_IO)
Linus Torvalds's avatar
Linus Torvalds committed
288
		return 0;
289

Linus Torvalds's avatar
Linus Torvalds committed
290 291 292 293 294
	/* Bad */
	return -EINVAL;
}

/**
295
 *	ide_hw_configure	-	configure a struct ide_hw instance
Linus Torvalds's avatar
Linus Torvalds committed
296
 *	@dev: PCI device holding interface
297
 *	@d: IDE port info
298
 *	@port: port number
299
 *	@hw: struct ide_hw instance corresponding to this port
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302 303 304
 *
 *	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.
 *
305
 *	Returns zero on success or an error code.
Linus Torvalds's avatar
Linus Torvalds committed
306
 */
307

308
static int ide_hw_configure(struct pci_dev *dev, const struct ide_port_info *d,
309
			    unsigned int port, struct ide_hw *hw)
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312
{
	unsigned long ctl = 0, base = 0;

313
	if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
314 315
		if (ide_pci_check_iomem(dev, d, 2 * port) ||
		    ide_pci_check_iomem(dev, d, 2 * port + 1)) {
316 317 318
			printk(KERN_ERR "%s %s: I/O baseregs (BIOS) are "
				"reported as MEM for port %d!\n",
				d->name, pci_name(dev), port);
319
			return -EINVAL;
320
		}
321

Linus Torvalds's avatar
Linus Torvalds committed
322 323
		ctl  = pci_resource_start(dev, 2*port+1);
		base = pci_resource_start(dev, 2*port);
324
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
325 326 327 328
		/* Use default values */
		ctl = port ? 0x374 : 0x3f4;
		base = port ? 0x170 : 0x1f0;
	}
329

330
	if (!base || !ctl) {
331 332
		printk(KERN_ERR "%s %s: bad PCI BARs for port %d, skipping\n",
			d->name, pci_name(dev), port);
333
		return -EINVAL;
334 335
	}

336 337 338 339
	memset(hw, 0, sizeof(*hw));
	hw->dev = &dev->dev;
	ide_std_init_ports(hw, base, ctl | 2);

340
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
341 342
}

343
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
Linus Torvalds's avatar
Linus Torvalds committed
344 345
/**
 *	ide_hwif_setup_dma	-	configure DMA interface
346
 *	@hwif: IDE interface
347
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350 351 352
 *
 *	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
 */
353

354
int ide_hwif_setup_dma(ide_hwif_t *hwif, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
355
{
356
	struct pci_dev *dev = to_pci_dev(hwif->dev);
Linus Torvalds's avatar
Linus Torvalds committed
357

358
	if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 ||
Linus Torvalds's avatar
Linus Torvalds committed
359 360
	    ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
	     (dev->class & 0x80))) {
361
		unsigned long base = ide_pci_dma_base(hwif, d);
362

363 364 365 366 367
		if (base == 0)
			return -1;

		hwif->dma_base = base;

368 369 370
		if (hwif->dma_ops == NULL)
			hwif->dma_ops = &sff_dma_ops;

371 372 373 374
		if (ide_pci_check_simplex(hwif, d) < 0)
			return -1;

		if (ide_pci_set_master(dev, d->name) < 0)
375
			return -1;
376

377
		if (hwif->host_flags & IDE_HFLAG_MMIO)
378 379 380 381 382 383 384
			printk(KERN_INFO "    %s: MMIO-DMA\n", hwif->name);
		else
			printk(KERN_INFO "    %s: BM-DMA at 0x%04lx-0x%04lx\n",
					 hwif->name, base, base + 7);

		hwif->extra_base = base + (hwif->channel ? 8 : 16);

385 386 387
		if (ide_allocate_dma_engine(hwif))
			return -1;
	}
388

389
	return 0;
390
}
391
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */
Linus Torvalds's avatar
Linus Torvalds committed
392 393 394 395

/**
 *	ide_setup_pci_controller	-	set up IDE PCI
 *	@dev: PCI device
396
 *	@bars: PCI BARs mask
397
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
398 399 400 401 402 403
 *	@noisy: verbose flag
 *
 *	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
 */
404

405
static int ide_setup_pci_controller(struct pci_dev *dev, int bars,
406
				    const struct ide_port_info *d, int noisy)
Linus Torvalds's avatar
Linus Torvalds committed
407 408 409 410 411 412 413
{
	int ret;
	u16 pcicmd;

	if (noisy)
		ide_setup_pci_noise(dev, d);

414
	ret = ide_pci_enable(dev, bars, d);
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418 419
	if (ret < 0)
		goto out;

	ret = pci_read_config_word(dev, PCI_COMMAND, &pcicmd);
	if (ret < 0) {
420 421
		printk(KERN_ERR "%s %s: error accessing PCI regs\n",
			d->name, pci_name(dev));
422
		goto out_free_bars;
Linus Torvalds's avatar
Linus Torvalds committed
423 424 425 426
	}
	if (!(pcicmd & PCI_COMMAND_IO)) {	/* is device disabled? */
		ret = ide_pci_configure(dev, d);
		if (ret < 0)
427
			goto out_free_bars;
428 429
		printk(KERN_INFO "%s %s: device enabled (Linux)\n",
			d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
430 431
	}

432 433 434 435
	goto out;

out_free_bars:
	pci_release_selected_regions(dev, bars);
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442
out:
	return ret;
}

/**
 *	ide_pci_setup_ports	-	configure ports/devices on PCI IDE
 *	@dev: PCI device
443
 *	@d: IDE port info
444 445
 *	@hw: struct ide_hw instances corresponding to this PCI IDE device
 *	@hws: struct ide_hw pointers table to update
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449 450 451 452 453 454
 *
 *	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.
 */
455

456
void ide_pci_setup_ports(struct pci_dev *dev, const struct ide_port_info *d,
457
			 struct ide_hw *hw, struct ide_hw **hws)
Linus Torvalds's avatar
Linus Torvalds committed
458
{
459
	int channels = (d->host_flags & IDE_HFLAG_SINGLE) ? 1 : 2, port;
Linus Torvalds's avatar
Linus Torvalds committed
460 461 462 463 464
	u8 tmp;

	/*
	 * Set up the IDE ports
	 */
465

466
	for (port = 0; port < channels; ++port) {
467
		const struct ide_pci_enablebit *e = &d->enablebits[port];
468

Linus Torvalds's avatar
Linus Torvalds committed
469
		if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
470
		    (tmp & e->mask) != e->val)) {
471 472
			printk(KERN_INFO "%s %s: IDE port disabled\n",
				d->name, pci_name(dev));
Linus Torvalds's avatar
Linus Torvalds committed
473
			continue;	/* port not enabled */
474
		}
Linus Torvalds's avatar
Linus Torvalds committed
475

476
		if (ide_hw_configure(dev, d, port, hw + port))
Linus Torvalds's avatar
Linus Torvalds committed
477 478
			continue;

479
		*(hws + port) = hw + port;
480
	}
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483 484 485 486 487 488 489 490
}
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
491
 * we "know" about, this information is in the struct ide_port_info;
Linus Torvalds's avatar
Linus Torvalds committed
492 493
 * for all other chipsets, we just assume both interfaces are enabled.
 */
494
static int do_ide_setup_pci_device(struct pci_dev *dev,
495
				   const struct ide_port_info *d,
496
				   u8 noisy)
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499 500 501 502 503 504
{
	int pciirq, ret;

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

505 506 507 508 509 510
	/*
	 * 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.
	 */
511
	ret = d->init_chipset ? d->init_chipset(dev) : 0;
512 513 514
	if (ret < 0)
		goto out;

515
	if (ide_pci_is_in_compatibility_mode(dev)) {
Linus Torvalds's avatar
Linus Torvalds committed
516
		if (noisy)
517 518
			printk(KERN_INFO "%s %s: not 100%% native mode: will "
				"probe irqs later\n", d->name, pci_name(dev));
519
		pciirq = 0;
520 521 522 523 524 525
	} else if (!pciirq && noisy) {
		printk(KERN_WARNING "%s %s: bad irq (%d): will probe later\n",
			d->name, pci_name(dev), pciirq);
	} else if (noisy) {
		printk(KERN_INFO "%s %s: 100%% native mode on irq %d\n",
			d->name, pci_name(dev), pciirq);
Linus Torvalds's avatar
Linus Torvalds committed
526 527
	}

528
	ret = pciirq;
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531 532
out:
	return ret;
}

533 534
int ide_pci_init_two(struct pci_dev *dev1, struct pci_dev *dev2,
		     const struct ide_port_info *d, void *priv)
Linus Torvalds's avatar
Linus Torvalds committed
535 536
{
	struct pci_dev *pdev[] = { dev1, dev2 };
537
	struct ide_host *host;
538
	int ret, i, n_ports = dev2 ? 4 : 2, bars;
539
	struct ide_hw hw[4], *hws[] = { NULL, NULL, NULL, NULL };
Linus Torvalds's avatar
Linus Torvalds committed
540

541 542 543 544 545 546 547 548 549 550 551 552
	if (d->host_flags & IDE_HFLAG_SINGLE)
		bars = (1 << 2) - 1;
	else
		bars = (1 << 4) - 1;

	if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0) {
		if (d->host_flags & IDE_HFLAG_CS5520)
			bars |= (1 << 2);
		else
			bars |= (1 << 4);
	}

553
	for (i = 0; i < n_ports / 2; i++) {
554 555 556 557
		ret = ide_setup_pci_controller(pdev[i], bars, d, !i);
		if (ret < 0) {
			if (i == 1)
				pci_release_selected_regions(pdev[0], bars);
558
			goto out;
559
		}
560

561
		ide_pci_setup_ports(pdev[i], d, &hw[i*2], &hws[i*2]);
562
	}
563

564
	host = ide_host_alloc(d, hws, n_ports);
565 566
	if (host == NULL) {
		ret = -ENOMEM;
567
		goto out_free_bars;
568 569 570
	}

	host->dev[0] = &dev1->dev;
571 572
	if (dev2)
		host->dev[1] = &dev2->dev;
573 574

	host->host_priv = priv;
575 576
	host->irq_flags = IRQF_SHARED;

577
	pci_set_drvdata(pdev[0], host);
578 579
	if (dev2)
		pci_set_drvdata(pdev[1], host);
580

581
	for (i = 0; i < n_ports / 2; i++) {
582 583
		ret = do_ide_setup_pci_device(pdev[i], d, !i);

Linus Torvalds's avatar
Linus Torvalds committed
584 585 586 587 588
		/*
		 * FIXME: Mom, mom, they stole me the helper function to undo
		 * do_ide_setup_pci_device() on the first device!
		 */
		if (ret < 0)
589
			goto out_free_bars;
590

591
		/* fixup IRQ */
592
		if (ide_pci_is_in_compatibility_mode(pdev[i])) {
593 594
			hw[i*2].irq = pci_get_legacy_ide_irq(pdev[i], 0);
			hw[i*2 + 1].irq = pci_get_legacy_ide_irq(pdev[i], 1);
595 596
		} else
			hw[i*2 + 1].irq = hw[i*2].irq = ret;
Linus Torvalds's avatar
Linus Torvalds committed
597 598
	}

599 600 601
	ret = ide_host_register(host, d, hws);
	if (ret)
		ide_host_free(host);
602 603 604 605 606 607 608
	else
		goto out;

out_free_bars:
	i = n_ports / 2;
	while (i--)
		pci_release_selected_regions(pdev[i], bars);
Linus Torvalds's avatar
Linus Torvalds committed
609 610 611
out:
	return ret;
}
612
EXPORT_SYMBOL_GPL(ide_pci_init_two);
613

614 615 616 617 618 619 620
int ide_pci_init_one(struct pci_dev *dev, const struct ide_port_info *d,
		     void *priv)
{
	return ide_pci_init_two(dev, NULL, d, priv);
}
EXPORT_SYMBOL_GPL(ide_pci_init_one);

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
void ide_pci_remove(struct pci_dev *dev)
{
	struct ide_host *host = pci_get_drvdata(dev);
	struct pci_dev *dev2 = host->dev[1] ? to_pci_dev(host->dev[1]) : NULL;
	int bars;

	if (host->host_flags & IDE_HFLAG_SINGLE)
		bars = (1 << 2) - 1;
	else
		bars = (1 << 4) - 1;

	if ((host->host_flags & IDE_HFLAG_NO_DMA) == 0) {
		if (host->host_flags & IDE_HFLAG_CS5520)
			bars |= (1 << 2);
		else
			bars |= (1 << 4);
	}

	ide_host_remove(host);

	if (dev2)
		pci_release_selected_regions(dev2, bars);
	pci_release_selected_regions(dev, bars);

	if (dev2)
		pci_disable_device(dev2);
	pci_disable_device(dev);
}
EXPORT_SYMBOL_GPL(ide_pci_remove);
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682

#ifdef CONFIG_PM
int ide_pci_suspend(struct pci_dev *dev, pm_message_t state)
{
	pci_save_state(dev);
	pci_disable_device(dev);
	pci_set_power_state(dev, pci_choose_state(dev, state));

	return 0;
}
EXPORT_SYMBOL_GPL(ide_pci_suspend);

int ide_pci_resume(struct pci_dev *dev)
{
	struct ide_host *host = pci_get_drvdata(dev);
	int rc;

	pci_set_power_state(dev, PCI_D0);

	rc = pci_enable_device(dev);
	if (rc)
		return rc;

	pci_restore_state(dev);
	pci_set_master(dev);

	if (host->init_chipset)
		host->init_chipset(dev);

	return 0;
}
EXPORT_SYMBOL_GPL(ide_pci_resume);
#endif