setup-pci.c 18.6 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
30
31
32
33
34
35
36
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
64
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
 *  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_match_hwif	-	match a PCI IDE against an ide_hwif
 *	@io_base: I/O base of device
 *	@bootable: set if its bootable
 *	@name: name of device
 *
 *	Match a PCI IDE port against an entry in ide_hwifs[],
 *	based on io_base port if possible. Return the matching hwif,
 *	or a new hwif. If we find an error (clashing, out of devices, etc)
 *	return NULL
 *
 *	FIXME: we need to handle mmio matches here too
 */

static ide_hwif_t *ide_match_hwif(unsigned long io_base, u8 bootable, const char *name)
{
	int h;
	ide_hwif_t *hwif;

	/*
	 * Look for a hwif with matching io_base specified using
	 * parameters to ide_setup().
	 */
	for (h = 0; h < MAX_HWIFS; ++h) {
		hwif = &ide_hwifs[h];
		if (hwif->io_ports[IDE_DATA_OFFSET] == io_base) {
			if (hwif->chipset == ide_forced)
				return hwif; /* a perfect match */
		}
	}
	/*
	 * Look for a hwif with matching io_base default value.
	 * If chipset is "ide_unknown", then claim that hwif slot.
	 * Otherwise, some other chipset has already claimed it..  :(
	 */
	for (h = 0; h < MAX_HWIFS; ++h) {
		hwif = &ide_hwifs[h];
		if (hwif->io_ports[IDE_DATA_OFFSET] == io_base) {
			if (hwif->chipset == ide_unknown)
				return hwif; /* match */
			printk(KERN_ERR "%s: port 0x%04lx already claimed by %s\n",
				name, io_base, hwif->name);
			return NULL;	/* already claimed */
		}
	}
	/*
	 * Okay, there is no hwif matching our io_base,
	 * so we'll just claim an unassigned slot.
	 * 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 */
		}
	}
92
	for (h = 0; h < 2 && h < MAX_HWIFS; ++h) {
Linus Torvalds's avatar
Linus Torvalds committed
93
94
95
96
97
98
99
100
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
		hwif = ide_hwifs + h;
		if (hwif->chipset == ide_unknown)
			return hwif;	/* pick an unused entry */
	}
	printk(KERN_ERR "%s: too many IDE interfaces, no room in table\n", name);
	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
142
143
144
145
146
147
148
149
150
151
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
152
153
/**
 *	ide_get_or_set_dma_base		-	setup BMIBA
154
155
 *	@d: IDE port info
 *	@hwif: IDE interface
Linus Torvalds's avatar
Linus Torvalds committed
156
 *
157
158
159
 *	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
160
161
 */

162
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
163
{
164
165
	struct pci_dev *dev = to_pci_dev(hwif->dev);
	unsigned long dma_base = 0;
166
	u8 dma_stat = 0;
Linus Torvalds's avatar
Linus Torvalds committed
167
168
169
170
171
172
173

	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 {
174
175
176
177
		u8 baridx = (d->host_flags & IDE_HFLAG_CS5520) ? 2 : 4;

		dma_base = pci_resource_start(dev, baridx);

178
		if (dma_base == 0) {
179
			printk(KERN_ERR "%s: DMA base is invalid\n", d->name);
180
181
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
182
183
	}

184
185
186
	if (hwif->channel)
		dma_base += 8;

187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
	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
209
	}
210
out:
Linus Torvalds's avatar
Linus Torvalds committed
211
212
213
214
	return dma_base;
}
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI */

215
void ide_setup_pci_noise(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
216
{
217
218
219
	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
220
221
222
223
224
225
226
227
}

EXPORT_SYMBOL_GPL(ide_setup_pci_noise);


/**
 *	ide_pci_enable	-	do PCI enables
 *	@dev: PCI device
228
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
229
230
 *
 *	Enable the IDE PCI device. We attempt to enable the device in full
231
232
233
 *	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
234
235
236
 *	
 *	Returns zero on success or an error code
 */
237

238
static int ide_pci_enable(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
239
240
241
242
{
	int ret;

	if (pci_enable_device(dev)) {
243
		ret = pci_enable_device_io(dev);
Linus Torvalds's avatar
Linus Torvalds committed
244
245
246
247
248
249
250
251
252
		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);
	}

	/*
253
254
255
	 * 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
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
	 */
	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
277
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
278
279
280
281
 *
 *	Enable and configure the PCI device we have been passed.
 *	Returns zero on success or an error code.
 */
282

283
static int ide_pci_configure(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
{
	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
311
312
313
 *	@dev: PCI device
 *	@d: IDE port info
 *	@bar: BAR number
Linus Torvalds's avatar
Linus Torvalds committed
314
315
316
317
 *
 *	Checks if a BAR is configured and points to MMIO space. If so
 *	print an error and return an error code. Otherwise return 0
 */
318

319
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
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
{
	ulong flags = pci_resource_flags(dev, bar);
	
	/* Unconfigured ? */
	if (!flags || pci_resource_len(dev, bar) == 0)
		return 0;

	/* I/O space */		
	if(flags & PCI_BASE_ADDRESS_IO_MASK)
		return 0;
		
	/* Bad */
	printk(KERN_ERR "%s: IO baseregs (BIOS) are reported "
			"as MEM, report to "
			"<andre@linux-ide.org>.\n", d->name);
	return -EINVAL;
}

/**
 *	ide_hwif_configure	-	configure an IDE interface
 *	@dev: PCI device holding interface
341
 *	@d: IDE port info
342
343
 *	@port: port number
 *	@irq: PCI IRQ
Linus Torvalds's avatar
Linus Torvalds committed
344
345
346
347
348
349
350
 *
 *	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
 */
351

352
353
354
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
355
356
357
{
	unsigned long ctl = 0, base = 0;
	ide_hwif_t *hwif;
358
	u8 bootable = (d->host_flags & IDE_HFLAG_BOOTABLE) ? 1 : 0;
359
360
	u8 oldnoprobe = 0;
	struct hw_regs_s hw;
Linus Torvalds's avatar
Linus Torvalds committed
361

362
	if ((d->host_flags & IDE_HFLAG_ISA_PORTS) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
		/*  Possibly we should fail if these checks report true */
		ide_pci_check_iomem(dev, d, 2*port);
		ide_pci_check_iomem(dev, d, 2*port+1);
 
		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;
	}
381
	if ((hwif = ide_match_hwif(base, bootable, d->name)) == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
382
		return NULL;	/* no room in ide_hwifs[] */
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397

	memset(&hw, 0, sizeof(hw));
	hw.irq = hwif->irq ? hwif->irq : irq;
	hw.dev = &dev->dev;
	hw.chipset = d->chipset ? d->chipset : ide_pci;
	ide_std_init_ports(&hw, base, ctl | 2);

	if (hwif->io_ports[IDE_DATA_OFFSET] == base &&
	    hwif->io_ports[IDE_CONTROL_OFFSET] == (ctl | 2))
		oldnoprobe = hwif->noprobe;

	ide_init_port_hw(hwif, &hw);

	hwif->noprobe = oldnoprobe;

398
	hwif->dev = &dev->dev;
399
	hwif->cds = d;
Linus Torvalds's avatar
Linus Torvalds committed
400
401
402
403
404
405
406

	return hwif;
}

/**
 *	ide_hwif_setup_dma	-	configure DMA interface
 *	@dev: PCI device
407
408
 *	@d: IDE port info
 *	@hwif: IDE interface
Linus Torvalds's avatar
Linus Torvalds committed
409
410
411
412
413
 *
 *	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
 */
414

415
static void ide_hwif_setup_dma(struct pci_dev *dev, const struct ide_port_info *d, ide_hwif_t *hwif)
Linus Torvalds's avatar
Linus Torvalds committed
416
{
417
#ifdef CONFIG_BLK_DEV_IDEDMA_PCI
Linus Torvalds's avatar
Linus Torvalds committed
418
	u16 pcicmd;
419

Linus Torvalds's avatar
Linus Torvalds committed
420
421
	pci_read_config_word(dev, PCI_COMMAND, &pcicmd);

422
	if ((d->host_flags & IDE_HFLAG_NO_AUTODMA) == 0 ||
Linus Torvalds's avatar
Linus Torvalds committed
423
424
	    ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE &&
	     (dev->class & 0x80))) {
425
		unsigned long dma_base = ide_get_or_set_dma_base(d, hwif);
Linus Torvalds's avatar
Linus Torvalds committed
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
		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 {
442
				ide_setup_dma(hwif, dma_base);
Linus Torvalds's avatar
Linus Torvalds committed
443
444
445
446
447
448
449
			}
		} else {
			printk(KERN_INFO "%s: %s Bus-Master DMA disabled "
				"(BIOS)\n", hwif->name, d->name);
		}
	}
#endif /* CONFIG_BLK_DEV_IDEDMA_PCI*/
450
}
Linus Torvalds's avatar
Linus Torvalds committed
451
452
453
454

/**
 *	ide_setup_pci_controller	-	set up IDE PCI
 *	@dev: PCI device
455
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
456
457
458
459
460
461
462
 *	@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
 */
463

464
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
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
{
	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
496
 *	@d: IDE port info
Linus Torvalds's avatar
Linus Torvalds committed
497
 *	@pciirq: IRQ line
498
 *	@idx: ATA index table to update
Linus Torvalds's avatar
Linus Torvalds committed
499
500
501
502
503
504
505
506
507
 *
 *	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.
 */
508

509
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
510
{
511
	int channels = (d->host_flags & IDE_HFLAG_SINGLE) ? 1 : 2, port;
Linus Torvalds's avatar
Linus Torvalds committed
512
513
514
515
516
517
	ide_hwif_t *hwif, *mate = NULL;
	u8 tmp;

	/*
	 * Set up the IDE ports
	 */
518

519
	for (port = 0; port < channels; ++port) {
520
521
		const ide_pci_enablebit_t *e = &(d->enablebits[port]);

Linus Torvalds's avatar
Linus Torvalds committed
522
		if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
523
524
		    (tmp & e->mask) != e->val)) {
			printk(KERN_INFO "%s: IDE port disabled\n", d->name);
Linus Torvalds's avatar
Linus Torvalds committed
525
			continue;	/* port not enabled */
526
		}
Linus Torvalds's avatar
Linus Torvalds committed
527

528
529
		hwif = ide_hwif_configure(dev, d, port, pciirq);
		if (hwif == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
530
531
			continue;

532
		*(idx + port) = hwif->index;
533
534
535
536
537
538
539
540
541
542
543
544
545
546
	}

	for (port = 0; port < channels; ++port) {
		if (*(idx + port) == 0xff)
			continue;

		hwif = &ide_hwifs[*(idx + port)];

		if (mate) {
			hwif->mate = mate;
			mate->mate = hwif;
		}

		hwif->channel = port;
Linus Torvalds's avatar
Linus Torvalds committed
547
548
549
550

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

551
		if ((d->host_flags & IDE_HFLAG_NO_DMA) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
552
			ide_hwif_setup_dma(dev, d, hwif);
553

554
555
		if ((!hwif->irq && (d->host_flags & IDE_HFLAG_LEGACY_IRQS)) ||
		    (d->host_flags & IDE_HFLAG_FORCE_LEGACY_IRQS))
556
557
			hwif->irq = port ? 15 : 14;

558
		hwif->host_flags = d->host_flags;
Bartlomiej Zolnierkiewicz's avatar
Bartlomiej Zolnierkiewicz committed
559
		hwif->pio_mask = d->pio_mask;
560

561
562
563
		if ((d->host_flags & IDE_HFLAG_SERIALIZE) && hwif->mate)
			hwif->mate->serialized = hwif->serialized = 1;

564
565
566
567
568
569
570
571
572
573
		if (d->host_flags & IDE_HFLAG_IO_32BIT) {
			hwif->drives[0].io_32bit = 1;
			hwif->drives[1].io_32bit = 1;
		}

		if (d->host_flags & IDE_HFLAG_UNMASK_IRQS) {
			hwif->drives[0].unmask = 1;
			hwif->drives[1].unmask = 1;
		}

574
575
576
577
578
579
580
581
582
		hwif->swdma_mask = d->swdma_mask;
		hwif->mwdma_mask = d->mwdma_mask;
		hwif->ultra_mask = d->udma_mask;

		if ((d->host_flags && IDE_HFLAG_NO_DMA) == 0 &&
		    hwif->dma_base == 0) {
			hwif->swdma_mask = 0;
			hwif->mwdma_mask = 0;
			hwif->ultra_mask = 0;
583
584
		}

585
586
587
		hwif->drives[0].autotune = 1;
		hwif->drives[1].autotune = 1;

588
589
590
		if (d->host_flags & IDE_HFLAG_RQSIZE_256)
			hwif->rqsize = 256;

Linus Torvalds's avatar
Linus Torvalds committed
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
		if (d->init_hwif)
			/* Call chipset-specific routine
			 * for each enabled hwif
			 */
			d->init_hwif(hwif);

		mate = hwif;
	}
}

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
610
 * we "know" about, this information is in the struct ide_port_info;
Linus Torvalds's avatar
Linus Torvalds committed
611
612
 * for all other chipsets, we just assume both interfaces are enabled.
 */
613
static int do_ide_setup_pci_device(struct pci_dev *dev,
614
				   const struct ide_port_info *d,
615
				   u8 *idx, u8 noisy)
Linus Torvalds's avatar
Linus Torvalds committed
616
617
618
619
620
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
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
{
	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 */

666
	ide_pci_setup_ports(dev, d, pciirq, idx);
Linus Torvalds's avatar
Linus Torvalds committed
667
668
669
670
out:
	return ret;
}

671
int ide_setup_pci_device(struct pci_dev *dev, const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
672
{
673
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
674
675
	int ret;

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

678
679
	if (ret >= 0)
		ide_device_add(idx);
Linus Torvalds's avatar
Linus Torvalds committed
680
681
682
683
684
685
686

	return ret;
}

EXPORT_SYMBOL_GPL(ide_setup_pci_device);

int ide_setup_pci_devices(struct pci_dev *dev1, struct pci_dev *dev2,
687
			  const struct ide_port_info *d)
Linus Torvalds's avatar
Linus Torvalds committed
688
689
690
{
	struct pci_dev *pdev[] = { dev1, dev2 };
	int ret, i;
691
	u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
Linus Torvalds's avatar
Linus Torvalds committed
692
693

	for (i = 0; i < 2; i++) {
694
		ret = do_ide_setup_pci_device(pdev[i], d, &idx[i*2], !i);
Linus Torvalds's avatar
Linus Torvalds committed
695
696
697
698
699
700
701
702
		/*
		 * 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;
	}

703
	ide_device_add(idx);
Linus Torvalds's avatar
Linus Torvalds committed
704
705
706
707
708
out:
	return ret;
}

EXPORT_SYMBOL_GPL(ide_setup_pci_devices);