Release 4.10 arch/alpha/kernel/pci.c

/*
 *      linux/arch/alpha/kernel/pci.c
 *
 * Extruded from code written by
 *      Dave Rusling (david.rusling@reo.mts.dec.com)
 *      David Mosberger (davidm@cs.arizona.edu)
 */

/* 2.3.x PCI/resources, 1999 Andrea Arcangeli <andrea@suse.de> */

/*
 * Nov 2000, Ivan Kokshaysky <ink@jurassic.park.msu.ru>
 *           PCI-PCI bridges cleanup
 */
#include <linux/string.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/bootmem.h>
#include <linux/module.h>
#include <linux/cache.h>
#include <linux/slab.h>
#include <asm/machvec.h>

#include "proto.h"
#include "pci_impl.h"


/*
 * Some string constants used by the various core logics. 
 */


const char *const pci_io_names[] = {
  "PCI IO bus 0", "PCI IO bus 1", "PCI IO bus 2", "PCI IO bus 3",
  "PCI IO bus 4", "PCI IO bus 5", "PCI IO bus 6", "PCI IO bus 7"
};


const char *const pci_mem_names[] = {
  "PCI mem bus 0", "PCI mem bus 1", "PCI mem bus 2", "PCI mem bus 3",
  "PCI mem bus 4", "PCI mem bus 5", "PCI mem bus 6", "PCI mem bus 7"
};


const char pci_hae0_name[] = "HAE0";

/*
 * If PCI_PROBE_ONLY in pci_flags is set, we don't change any PCI resource
 * assignments.
 */

/*
 * The PCI controller list.
 */



struct pci_controller *hose_head, **hose_tail = &hose_head;

struct pci_controller *pci_isa_hose;

/*
 * Quirks.
 */



static void quirk_isa_bridge(struct pci_dev *dev)
{
	dev->class = PCI_CLASS_BRIDGE_ISA << 8;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
19
100.00%
2
100.00%
Total
19
100.00%
2
100.00%

DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82378, quirk_isa_bridge);



static void quirk_cypress(struct pci_dev *dev)
{
	/* The Notorious Cy82C693 chip.  */

	/* The generic legacy mode IDE fixup in drivers/pci/probe.c
           doesn't work correctly with the Cypress IDE controller as
           it has non-standard register layout.  Fix that.  */
	if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE) {
		dev->resource[2].start = dev->resource[3].start = 0;
		dev->resource[2].end = dev->resource[3].end = 0;
		dev->resource[2].flags = dev->resource[3].flags = 0;
		if (PCI_FUNC(dev->devfn) == 2) {
			dev->resource[0].start = 0x170;
			dev->resource[0].end = 0x177;
			dev->resource[1].start = 0x376;
			dev->resource[1].end = 0x376;
		}
	}

	/* The Cypress bridge responds on the PCI bus in the address range
           0xffff0000-0xffffffff (conventional x86 BIOS ROM).  There is no
           way to turn this off.  The bridge also supports several extended
           BIOS ranges (disabled after power-up), and some consoles do turn
           them on.  So if we use a large direct-map window, or a large SG
           window, we must avoid the entire 0xfff00000-0xffffffff region.  */
	if (dev->class >> 8 == PCI_CLASS_BRIDGE_ISA) {
		if (__direct_map_base + __direct_map_size >= 0xfff00000UL)
			__direct_map_size = 0xfff00000UL - __direct_map_base;
		else {
			struct pci_controller *hose = dev->sysdata;
			struct pci_iommu_arena *pci = hose->sg_pci;
			if (pci && pci->dma_base + pci->size >= 0xfff00000UL)
				pci->size = 0xfff00000UL - pci->dma_base;
		}
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
ivan kokshaysky
ivan kokshaysky
137
64.02%
3
42.86%
linus torvalds
linus torvalds
53
24.77%
2
28.57%
pre-git
pre-git
24
11.21%
2
28.57%
Total
214
100.00%
7
100.00%

DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693, quirk_cypress);

/* Called for each device after PCI setup is done. */


static void pcibios_fixup_final(struct pci_dev *dev)
{
	unsigned int class = dev->class >> 8;

	if (class == PCI_CLASS_BRIDGE_ISA || class == PCI_CLASS_BRIDGE_EISA) {
		dev->dma_mask = MAX_ISA_DMA_ADDRESS - 1;
		isa_bridge = dev;
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
ivan kokshaysky
ivan kokshaysky
45
100.00%
2
100.00%
Total
45
100.00%
2
100.00%

DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_final);

/* Just declaring that the power-of-ten prefixes are actually the
   power-of-two ones doesn't make it true :) */

#define KB			1024

#define MB			(1024*KB)

#define GB			(1024*MB)


resource_size_t

pcibios_align_resource(void *data, const struct resource *res,
		       resource_size_t size, resource_size_t align)
{
	struct pci_dev *dev = data;
	struct pci_controller *hose = dev->sysdata;
	unsigned long alignto;
	resource_size_t start = res->start;

	if (res->flags & IORESOURCE_IO) {
		/* Make sure we start at our min on all hoses */
		if (start - hose->io_space->start < PCIBIOS_MIN_IO)
			start = PCIBIOS_MIN_IO + hose->io_space->start;

		/*
                 * Put everything into 0x00-0xff region modulo 0x400
                 */
		if (start & 0x300)
			start = (start + 0x3ff) & ~0x3ff;
	}
	else if	(res->flags & IORESOURCE_MEM) {
		/* Make sure we start at our min on all hoses */
		if (start - hose->mem_space->start < PCIBIOS_MIN_MEM)
			start = PCIBIOS_MIN_MEM + hose->mem_space->start;

		/*
                 * The following holds at least for the Low Cost
                 * Alpha implementation of the PCI interface:
                 *
                 * In sparse memory address space, the first
                 * octant (16MB) of every 128MB segment is
                 * aliased to the very first 16 MB of the
                 * address space (i.e., it aliases the ISA
                 * memory address space).  Thus, we try to
                 * avoid allocating PCI devices in that range.
                 * Can be allocated in 2nd-7th octant only.
                 * Devices that need more than 112MB of
                 * address space must be accessed through
                 * dense memory space only!
                 */

		/* Align to multiple of size of minimum base.  */
		alignto = max_t(resource_size_t, 0x1000, align);
		start = ALIGN(start, alignto);
		if (hose->sparse_mem_base && size <= 7 * 16*MB) {
			if (((start / (16*MB)) & 0x7) == 0) {
				start &= ~(128*MB - 1);
				start += 16*MB;
				start  = ALIGN(start, alignto);
			}
			if (start/(128*MB) != (start + size - 1)/(128*MB)) {
				start &= ~(128*MB - 1);
				start += (128 + 16)*MB;
				start  = ALIGN(start, alignto);
			}
		}
	}

	return start;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
254
92.03%
5
38.46%
linus torvalds
linus torvalds
8
2.90%
3
23.08%
dominik brodowski
dominik brodowski
4
1.45%
2
15.38%
randy dunlap
randy dunlap
4
1.45%
1
7.69%
ivan kokshaysky
ivan kokshaysky
3
1.09%
1
7.69%
greg kroah-hartman
greg kroah-hartman
3
1.09%
1
7.69%
Total
276
100.00%
13
100.00%


#undef KB

#undef MB

#undef GB


static int __init

pcibios_init(void)
{
	if (alpha_mv.init_pci)
		alpha_mv.init_pci();
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
18
78.26%
3
60.00%
ivan kokshaysky
ivan kokshaysky
5
21.74%
2
40.00%
Total
23
100.00%
5
100.00%


subsys_initcall(pcibios_init);

#ifdef ALPHA_RESTORE_SRM_SETUP

static struct pdev_srm_saved_conf *srm_saved_configs;



void pdev_save_srm_config(struct pci_dev *dev)
{
	struct pdev_srm_saved_conf *tmp;
	static int printed = 0;

	if (!alpha_using_srm || pci_has_flag(PCI_PROBE_ONLY))
		return;

	if (!printed) {
		printk(KERN_INFO "pci: enabling save/restore of SRM state\n");
		printed = 1;
	}

	tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
	if (!tmp) {
		printk(KERN_ERR "%s: kmalloc() failed!\n", __func__);
		return;
	}
	tmp->next = srm_saved_configs;
	tmp->dev = dev;

	pci_save_state(dev);

	srm_saved_configs = tmp;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
richard henderson
richard henderson
93
93.94%
1
25.00%
bjorn helgaas
bjorn helgaas
4
4.04%
1
25.00%
greg kroah-hartman
greg kroah-hartman
1
1.01%
1
25.00%
harvey harrison
harvey harrison
1
1.01%
1
25.00%
Total
99
100.00%
4
100.00%


void

pci_restore_srm_config(void)
{
	struct pdev_srm_saved_conf *tmp;

	/* No need to restore if probed only. */
	if (pci_has_flag(PCI_PROBE_ONLY))
		return;

	/* Restore SRM config. */
	for (tmp = srm_saved_configs; tmp; tmp = tmp->next) {
		pci_restore_state(tmp->dev);
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
richard henderson
richard henderson
41
91.11%
1
50.00%
bjorn helgaas
bjorn helgaas
4
8.89%
1
50.00%
Total
45
100.00%
2
100.00%

#endif



void pcibios_fixup_bus(struct pci_bus *bus)
{
	struct pci_dev *dev = bus->self;

	if (pci_has_flag(PCI_PROBE_ONLY) && dev &&
	    (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
		pci_read_bridge_bases(bus);
	}

	list_for_each_entry(dev, &bus->devices, bus_list) {
		pdev_save_srm_config(dev);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
bjorn helgaas
bjorn helgaas
30
50.00%
1
11.11%
pre-git
pre-git
17
28.33%
5
55.56%
maximilian attems
maximilian attems
7
11.67%
1
11.11%
richard henderson
richard henderson
5
8.33%
1
11.11%
greg kroah-hartman
greg kroah-hartman
1
1.67%
1
11.11%
Total
60
100.00%
9
100.00%

/*
 *  If we set up a device for bus mastering, we need to check the latency
 *  timer as certain firmware forgets to set it properly, as seen
 *  on SX164 and LX164 with SRM.
 */

void

pcibios_set_master(struct pci_dev *dev)
{
	u8 lat;
	pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
	if (lat >= 16) return;
	printk("PCI: Setting latency timer of device %s to 64\n",
							pci_name(dev));
	pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
46
93.88%
2
66.67%
randy dunlap
randy dunlap
3
6.12%
1
33.33%
Total
49
100.00%
3
100.00%


void __init

pcibios_claim_one_bus(struct pci_bus *b)
{
	struct pci_dev *dev;
	struct pci_bus *child_bus;

	list_for_each_entry(dev, &b->devices, bus_list) {
		int i;

		for (i = 0; i < PCI_NUM_RESOURCES; i++) {
			struct resource *r = &dev->resource[i];

			if (r->parent || !r->start || !r->flags)
				continue;
			if (pci_has_flag(PCI_PROBE_ONLY) ||
			    (r->flags & IORESOURCE_PCI_FIXED)) {
				if (pci_claim_resource(dev, i) == 0)
					continue;

				pci_claim_bridge_resource(dev, i);
			}
		}
	}

	list_for_each_entry(child_bus, &b->children, node)
		pcibios_claim_one_bus(child_bus);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ivan kokshaysky
ivan kokshaysky
101
78.91%
3
50.00%
yinghai lu
yinghai lu
14
10.94%
1
16.67%
maximilian attems
maximilian attems
9
7.03%
1
16.67%
bjorn helgaas
bjorn helgaas
4
3.12%
1
16.67%
Total
128
100.00%
6
100.00%


static void __init

pcibios_claim_console_setup(void)
{
	struct pci_bus *b;

	list_for_each_entry(b, &pci_root_buses, node)
		pcibios_claim_one_bus(b);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
ivan kokshaysky
ivan kokshaysky
20
74.07%
2
66.67%
maximilian attems
maximilian attems
7
25.93%
1
33.33%
Total
27
100.00%
3
100.00%


void __init

common_init_pci(void)
{
	struct pci_controller *hose;
	struct list_head resources;
	struct pci_bus *bus;
	int next_busno;
	int need_domain_info = 0;
	u32 pci_mem_end;
	u32 sg_base;
	unsigned long end;

	/* Scan all of the recorded PCI controllers.  */
	for (next_busno = 0, hose = hose_head; hose; hose = hose->next) {
		sg_base = hose->sg_pci ? hose->sg_pci->dma_base : ~0;

		/* Adjust hose mem_space limit to prevent PCI allocations
                   in the iommu windows. */
		pci_mem_end = min((u32)__direct_map_base, sg_base) - 1;
		end = hose->mem_space->start + pci_mem_end;
		if (hose->mem_space->end > end)
			hose->mem_space->end = end;

		INIT_LIST_HEAD(&resources);
		pci_add_resource_offset(&resources, hose->io_space,
					hose->io_space->start);
		pci_add_resource_offset(&resources, hose->mem_space,
					hose->mem_space->start);

		bus = pci_scan_root_bus(NULL, next_busno, alpha_mv.pci_ops,
					hose, &resources);
		if (!bus)
			continue;
		hose->bus = bus;
		hose->need_domain_info = need_domain_info;
		next_busno = bus->busn_res.end + 1;
		/* Don't allow 8-bit bus number overflow inside the hose -
                   reserve some space for bridges. */ 
		if (next_busno > 224) {
			next_busno = 0;
			need_domain_info = 1;
		}
	}

	pcibios_claim_console_setup();

	pci_assign_unassigned_resources();
	pci_fixup_irqs(alpha_mv.pci_swizzle, alpha_mv.pci_map_irq);
	for (hose = hose_head; hose; hose = hose->next) {
		bus = hose->bus;
		if (bus)
			pci_bus_add_devices(bus);
	}
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
bjorn helgaas
bjorn helgaas
116
43.28%
2
18.18%
pre-git
pre-git
81
30.22%
4
36.36%
wang yijing
wang yijing
37
13.81%
1
9.09%
ivan kokshaysky
ivan kokshaysky
29
10.82%
2
18.18%
yinghai lu
yinghai lu
3
1.12%
1
9.09%
linus torvalds
linus torvalds
2
0.75%
1
9.09%
Total
268
100.00%
11
100.00%


struct pci_controller * __init

alloc_pci_controller(void)
{
	struct pci_controller *hose;

	hose = alloc_bootmem(sizeof(*hose));

	*hose_tail = hose;
	hose_tail = &hose->next;

	return hose;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
38
92.68%
2
66.67%
linus torvalds
linus torvalds
3
7.32%
1
33.33%
Total
41
100.00%
3
100.00%


struct resource * __init

alloc_resource(void)
{
	struct resource *res;

	res = alloc_bootmem(sizeof(*res));

	return res;
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
29
100.00%
2
100.00%
Total
29
100.00%
2
100.00%

/* Provide information on locations of various I/O regions in physical
   memory.  Do this on a per-card basis so that we choose the right hose.  */


asmlinkage long

sys_pciconfig_iobase(long which, unsigned long bus, unsigned long dfn)
{
	struct pci_controller *hose;
	struct pci_dev *dev;

	/* from hose or from bus.devfn */
	if (which & IOBASE_FROM_HOSE) {
		for(hose = hose_head; hose; hose = hose->next) 
			if (hose->index == bus) break;
		if (!hose) return -ENODEV;
	} else {
		/* Special hook for ISA access.  */
		if (bus == 0 && dfn == 0) {
			hose = pci_isa_hose;
		} else {
			dev = pci_get_bus_and_slot(bus, dfn);
			if (!dev)
				return -ENODEV;
			hose = dev->sysdata;
			pci_dev_put(dev);
		}
	}

	switch (which & ~IOBASE_FROM_HOSE) {
	case IOBASE_HOSE:
		return hose->index;
	case IOBASE_SPARSE_MEM:
		return hose->sparse_mem_base;
	case IOBASE_DENSE_MEM:
		return hose->dense_mem_base;
	case IOBASE_SPARSE_IO:
		return hose->sparse_io_base;
	case IOBASE_DENSE_IO:
		return hose->dense_io_base;
	case IOBASE_ROOT_BUS:
		return hose->bus->number;
	}

	return -EOPNOTSUPP;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
176
96.17%
2
50.00%
alan cox
alan cox
6
3.28%
1
25.00%
linus torvalds
linus torvalds
1
0.55%
1
25.00%
Total
183
100.00%
4
100.00%

/* Destroy an __iomem token.  Not copied from lib/iomap.c.  */



void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
{
	if (__is_mmio(addr))
		iounmap(addr);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
richard henderson
richard henderson
27
100.00%
1
100.00%
Total
27
100.00%
1
100.00%


EXPORT_SYMBOL(pci_iounmap);

/* FIXME: Some boxes have multiple ISA bridges! */

struct pci_dev *isa_bridge;

EXPORT_SYMBOL(isa_bridge);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
829
47.78%
14
26.42%
ivan kokshaysky
ivan kokshaysky
349
20.12%
12
22.64%
richard henderson
richard henderson
185
10.66%
2
3.77%
bjorn helgaas
bjorn helgaas
159
9.16%
4
7.55%
linus torvalds
linus torvalds
70
4.03%
4
7.55%
wang yijing
wang yijing
37
2.13%
1
1.89%
david woodhouse
david woodhouse
25
1.44%
1
1.89%
maximilian attems
maximilian attems
23
1.33%
1
1.89%
yinghai lu
yinghai lu
17
0.98%
2
3.77%
adrian bunk
adrian bunk
11
0.63%
1
1.89%
randy dunlap
randy dunlap
7
0.40%
2
3.77%
alan cox
alan cox
6
0.35%
1
1.89%
greg kroah-hartman
greg kroah-hartman
5
0.29%
2
3.77%
dominik brodowski
dominik brodowski
4
0.23%
2
3.77%
rusty russell
rusty russell
3
0.17%
1
1.89%
matt reppert
matt reppert
3
0.17%
1
1.89%
harvey harrison
harvey harrison
1
0.06%
1
1.89%
michael s. tsirkin
michael s. tsirkin
1
0.06%
1
1.89%
sebastian andrzej siewior
sebastian andrzej siewior
0.00%
0
0.00%
Total
1735
100.00%
53
100.00%
Directory: arch/alpha/kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.