diff options
author | Antony Pavlov <antonynpavlov@gmail.com> | 2014-07-04 01:27:02 +0400 |
---|---|---|
committer | Sascha Hauer <s.hauer@pengutronix.de> | 2014-07-04 07:35:47 +0200 |
commit | 7420866543da43a72ef81d5e03b12d9df752d99b (patch) | |
tree | 77a2824274543fa20b17b07b2f637b4ce8cb2481 /drivers | |
parent | eb062ecbdf77e3fa10e8ea64414c4e1a12fecf5e (diff) | |
download | barebox-7420866543da43a72ef81d5e03b12d9df752d99b.tar.gz barebox-7420866543da43a72ef81d5e03b12d9df752d99b.tar.xz |
PCI: initial commit
used shorten version of linux-2.6.39 pci_ids.h
Signed-off-by: Antony Pavlov <antonynpavlov@gmail.com>
Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/Kconfig | 1 | ||||
-rw-r--r-- | drivers/Makefile | 1 | ||||
-rw-r--r-- | drivers/pci/Kconfig | 29 | ||||
-rw-r--r-- | drivers/pci/Makefile | 8 | ||||
-rw-r--r-- | drivers/pci/bus.c | 110 | ||||
-rw-r--r-- | drivers/pci/pci.c | 292 | ||||
-rw-r--r-- | drivers/pci/pci_iomap.c | 29 |
7 files changed, 470 insertions, 0 deletions
diff --git a/drivers/Kconfig b/drivers/Kconfig index 53e1e97560..12a9d8c7d8 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -27,5 +27,6 @@ source "drivers/pinctrl/Kconfig" source "drivers/bus/Kconfig" source "drivers/regulator/Kconfig" source "drivers/reset/Kconfig" +source "drivers/pci/Kconfig" endmenu diff --git a/drivers/Makefile b/drivers/Makefile index ef3604f56c..1990e86bd9 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -26,3 +26,4 @@ obj-y += pinctrl/ obj-y += bus/ obj-$(CONFIG_REGULATOR) += regulator/ obj-$(CONFIG_RESET_CONTROLLER) += reset/ +obj-$(CONFIG_PCI) += pci/ diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig new file mode 100644 index 0000000000..9e4659270d --- /dev/null +++ b/drivers/pci/Kconfig @@ -0,0 +1,29 @@ +config HW_HAS_PCI + bool + +if HW_HAS_PCI + +menu "PCI bus options" + +config PCI + bool "Support for PCI controller" + depends on HW_HAS_PCI + help + Find out whether you have a PCI motherboard. PCI is the name of a + bus system, i.e. the way the CPU talks to the other stuff inside + your box. If you have PCI, say Y, otherwise N. + + +config PCI_DEBUG + bool "PCI Debugging" + depends on PCI + help + Say Y here if you want the PCI core to produce a bunch of debug + messages to the system log. Select this if you are having a + problem with PCI support and want to see more of what is going on. + + When in doubt, say N. + +endmenu + +endif diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile new file mode 100644 index 0000000000..edac1a53de --- /dev/null +++ b/drivers/pci/Makefile @@ -0,0 +1,8 @@ +# +# Makefile for the PCI bus specific drivers. +# +obj-y += pci.o bus.o pci_iomap.o + +ccflags-$(CONFIG_PCI_DEBUG) := -DDEBUG + +CPPFLAGS += $(ccflags-y) diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c new file mode 100644 index 0000000000..8215ee5638 --- /dev/null +++ b/drivers/pci/bus.c @@ -0,0 +1,110 @@ +#include <common.h> +#include <init.h> +#include <driver.h> +#include <linux/pci.h> + +/** + * pci_match_one_device - Tell if a PCI device structure has a matching + * PCI device id structure + * @id: single PCI device id structure to match + * @dev: the PCI device structure to match against + * + * Returns the matching pci_device_id structure or %NULL if there is no match. + */ +static inline const struct pci_device_id * +pci_match_one_device(const struct pci_device_id *id, const struct pci_dev *dev) +{ + if ((id->vendor == PCI_ANY_ID || id->vendor == dev->vendor) && + (id->device == PCI_ANY_ID || id->device == dev->device) && + (id->subvendor == PCI_ANY_ID || id->subvendor == dev->subsystem_vendor) && + (id->subdevice == PCI_ANY_ID || id->subdevice == dev->subsystem_device) && + !((id->class ^ dev->class) & id->class_mask)) + return id; + return NULL; +} + +static int pci_match(struct device_d *dev, struct driver_d *drv) +{ + struct pci_dev *pdev = to_pci_dev(dev); + struct pci_driver *pdrv = to_pci_driver(drv); + struct pci_device_id *id; + + for (id = (struct pci_device_id *)pdrv->id_table; id->vendor; id++) + if (pci_match_one_device(id, pdev)) { + dev->priv = id; + return 0; + } + + return -1; +} + +static int pci_probe(struct device_d *dev) +{ + struct pci_dev *pdev = to_pci_dev(dev); + struct pci_driver *pdrv = to_pci_driver(dev->driver); + + return pdrv->probe(pdev, dev->priv); +} + +static void pci_remove(struct device_d *dev) +{ + struct pci_dev *pdev = to_pci_dev(dev); + struct pci_driver *pdrv = to_pci_driver(dev->driver); + + pdrv->remove(pdev); +} + +struct bus_type pci_bus = { + .name = "pci", + .match = pci_match, + .probe = pci_probe, + .remove = pci_remove, +}; + +static int pci_bus_init(void) +{ + return bus_register(&pci_bus); +} +pure_initcall(pci_bus_init); + +int pci_register_driver(struct pci_driver *pdrv) +{ + struct driver_d *drv = &pdrv->driver; + + if (!pdrv->id_table) + return -EIO; + + drv->name = pdrv->name; + drv->bus = &pci_bus; + + return register_driver(drv); +} + +int pci_register_device(struct pci_dev *pdev) +{ + char str[6]; + struct device_d *dev = &pdev->dev; + int ret; + + strcpy(dev->name, "pci"); + dev->bus = &pci_bus; + dev->id = DEVICE_ID_DYNAMIC; + + ret = register_device(dev); + + if (ret) + return ret; + + sprintf(str, "%02x", pdev->devfn); + dev_add_param_fixed(dev, "devfn", str); + sprintf(str, "%04x", (pdev->class >> 8) & 0xffff); + dev_add_param_fixed(dev, "class", str); + sprintf(str, "%04x", pdev->vendor); + dev_add_param_fixed(dev, "vendor", str); + sprintf(str, "%04x", pdev->device); + dev_add_param_fixed(dev, "device", str); + sprintf(str, "%04x", pdev->revision); + dev_add_param_fixed(dev, "revision", str); + + return 0; +} diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c new file mode 100644 index 0000000000..ad9350feee --- /dev/null +++ b/drivers/pci/pci.c @@ -0,0 +1,292 @@ +#include <common.h> +#include <linux/pci.h> + +#ifdef DEBUG +#define DBG(x...) printk(x) +#else +#define DBG(x...) +#endif + +static struct pci_controller *hose_head, **hose_tail = &hose_head; + +LIST_HEAD(pci_root_buses); +EXPORT_SYMBOL(pci_root_buses); + +static struct pci_bus *pci_alloc_bus(void) +{ + struct pci_bus *b; + + b = kzalloc(sizeof(*b), GFP_KERNEL); + if (b) { + INIT_LIST_HEAD(&b->node); + INIT_LIST_HEAD(&b->children); + INIT_LIST_HEAD(&b->devices); + INIT_LIST_HEAD(&b->slots); + INIT_LIST_HEAD(&b->resources); + } + return b; +} + +void register_pci_controller(struct pci_controller *hose) +{ + struct pci_bus *bus; + + *hose_tail = hose; + hose_tail = &hose->next; + + bus = pci_alloc_bus(); + hose->bus = bus; + bus->ops = hose->pci_ops; + bus->resource[0] = hose->mem_resource; + bus->resource[1] = hose->io_resource; + + pci_scan_bus(bus); + + list_add_tail(&bus->node, &pci_root_buses); + + return; +} + +/* + * Wrappers for all PCI configuration access functions. They just check + * alignment, do locking and call the low-level functions pointed to + * by pci_dev->ops. + */ + +#define PCI_byte_BAD 0 +#define PCI_word_BAD (pos & 1) +#define PCI_dword_BAD (pos & 3) + +#define PCI_OP_READ(size,type,len) \ +int pci_bus_read_config_##size \ + (struct pci_bus *bus, unsigned int devfn, int pos, type *value) \ +{ \ + int res; \ + u32 data = 0; \ + if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \ + res = bus->ops->read(bus, devfn, pos, len, &data); \ + *value = (type)data; \ + return res; \ +} + +#define PCI_OP_WRITE(size,type,len) \ +int pci_bus_write_config_##size \ + (struct pci_bus *bus, unsigned int devfn, int pos, type value) \ +{ \ + int res; \ + if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \ + res = bus->ops->write(bus, devfn, pos, len, value); \ + return res; \ +} + +PCI_OP_READ(byte, u8, 1) +PCI_OP_READ(word, u16, 2) +PCI_OP_READ(dword, u32, 4) +PCI_OP_WRITE(byte, u8, 1) +PCI_OP_WRITE(word, u16, 2) +PCI_OP_WRITE(dword, u32, 4) + +EXPORT_SYMBOL(pci_bus_read_config_byte); +EXPORT_SYMBOL(pci_bus_read_config_word); +EXPORT_SYMBOL(pci_bus_read_config_dword); +EXPORT_SYMBOL(pci_bus_write_config_byte); +EXPORT_SYMBOL(pci_bus_write_config_word); +EXPORT_SYMBOL(pci_bus_write_config_dword); + +static struct pci_dev *alloc_pci_dev(void) +{ + struct pci_dev *dev; + + dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL); + if (!dev) + return NULL; + + INIT_LIST_HEAD(&dev->bus_list); + + return dev; +} + +unsigned int pci_scan_bus(struct pci_bus *bus) +{ + unsigned int devfn, l, max, class; + unsigned char cmd, tmp, hdr_type, is_multi = 0; + struct pci_dev *dev; + resource_size_t last_mem; + resource_size_t last_io; + + /* FIXME: use res_start() */ + last_mem = bus->resource[0]->start; + last_io = bus->resource[1]->start; + + DBG("pci_scan_bus for bus %d\n", bus->number); + DBG(" last_io = 0x%08x, last_mem = 0x%08x\n", last_io, last_mem); + max = bus->secondary; + + for (devfn = 0; devfn < 0xff; ++devfn) { + int bar; + u32 old_bar, mask; + int size; + + if (PCI_FUNC(devfn) && !is_multi) { + /* not a multi-function device */ + continue; + } + if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type)) + continue; + if (!PCI_FUNC(devfn)) + is_multi = hdr_type & 0x80; + + if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l) || + /* some broken boards return 0 if a slot is empty: */ + l == 0xffffffff || l == 0x00000000 || l == 0x0000ffff || l == 0xffff0000) + continue; + + dev = alloc_pci_dev(); + if (!dev) + return 0; + + dev->bus = bus; + dev->devfn = devfn; + dev->vendor = l & 0xffff; + dev->device = (l >> 16) & 0xffff; + + /* non-destructively determine if device can be a master: */ + pci_read_config_byte(dev, PCI_COMMAND, &cmd); + pci_write_config_byte(dev, PCI_COMMAND, cmd | PCI_COMMAND_MASTER); + pci_read_config_byte(dev, PCI_COMMAND, &tmp); + pci_write_config_byte(dev, PCI_COMMAND, cmd); + + pci_read_config_dword(dev, PCI_CLASS_REVISION, &class); + dev->revision = class & 0xff; + class >>= 8; /* upper 3 bytes */ + dev->class = class; + class >>= 8; + dev->hdr_type = hdr_type; + + DBG("PCI: class = %08x, hdr_type = %08x\n", class, hdr_type); + + switch (hdr_type & 0x7f) { /* header type */ + case PCI_HEADER_TYPE_NORMAL: /* standard header */ + if (class == PCI_CLASS_BRIDGE_PCI) + goto bad; + + /* + * read base address registers, again pcibios_fixup() can + * tweak these + */ + pci_read_config_dword(dev, PCI_ROM_ADDRESS, &l); + dev->rom_address = (l == 0xffffffff) ? 0 : l; + break; + default: /* unknown header */ + bad: + printk(KERN_ERR "PCI: %02x:%02x [%04x/%04x/%06x] has unknown header type %02x, ignoring.\n", + bus->number, dev->devfn, dev->vendor, dev->device, class, hdr_type); + continue; + } + + DBG("PCI: %02x:%02x [%04x/%04x]\n", bus->number, dev->devfn, dev->vendor, dev->device); + + list_add_tail(&dev->bus_list, &bus->devices); + pci_register_device(dev); + + if (class == PCI_CLASS_BRIDGE_HOST) { + DBG("PCI: skip pci host bridge\n"); + continue; + } + + for (bar = 0; bar < 6; bar++) { + resource_size_t last_addr; + + pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + bar * 4, &old_bar); + pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + bar * 4, 0xfffffffe); + pci_read_config_dword(dev, PCI_BASE_ADDRESS_0 + bar * 4, &mask); + pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + bar * 4, old_bar); + + if (mask == 0 || mask == 0xffffffff) { + DBG(" PCI: pbar%d set bad mask\n", bar); + continue; + } + + if (mask & 0x01) { /* IO */ + size = -(mask & 0xfffffffe); + DBG(" PCI: pbar%d: mask=%08x io %d bytes\n", bar, mask, size); + pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + bar * 4, last_io); + last_addr = last_io; + last_io += size; + + } else { /* MEM */ + size = -(mask & 0xfffffff0); + DBG(" PCI: pbar%d: mask=%08x memory %d bytes\n", bar, mask, size); + pci_write_config_dword(dev, PCI_BASE_ADDRESS_0 + bar * 4, last_mem); + last_addr = last_mem; + last_mem += size; + } + + dev->resource[bar].start = last_addr; + dev->resource[bar].end = last_addr + size - 1; + } + } + + /* + * We've scanned the bus and so we know all about what's on + * the other side of any bridges that may be on this bus plus + * any devices. + * + * Return how far we've got finding sub-buses. + */ + DBG("PCI: pci_scan_bus returning with max=%02x\n", max); + + return max; +} + +static void __pci_set_master(struct pci_dev *dev, bool enable) +{ + u16 old_cmd, cmd; + + pci_read_config_word(dev, PCI_COMMAND, &old_cmd); + if (enable) + cmd = old_cmd | PCI_COMMAND_MASTER; + else + cmd = old_cmd & ~PCI_COMMAND_MASTER; + if (cmd != old_cmd) { + dev_dbg(&dev->dev, "%s bus mastering\n", + enable ? "enabling" : "disabling"); + pci_write_config_word(dev, PCI_COMMAND, cmd); + } +} + +/** + * pci_set_master - enables bus-mastering for device dev + * @dev: the PCI device to enable + */ +void pci_set_master(struct pci_dev *dev) +{ + __pci_set_master(dev, true); +} +EXPORT_SYMBOL(pci_set_master); + +/** + * pci_clear_master - disables bus-mastering for device dev + * @dev: the PCI device to disable + */ +void pci_clear_master(struct pci_dev *dev) +{ + __pci_set_master(dev, false); +} +EXPORT_SYMBOL(pci_clear_master); + +/** + * pci_enable_device - Initialize device before it's used by a driver. + * @dev: PCI device to be initialized + */ +int pci_enable_device(struct pci_dev *dev) +{ + u32 t; + + pci_read_config_dword(dev, PCI_COMMAND, &t); + return pci_write_config_dword(dev, PCI_COMMAND, t + | PCI_COMMAND_IO + | PCI_COMMAND_MEMORY + ); +} +EXPORT_SYMBOL(pci_enable_device); diff --git a/drivers/pci/pci_iomap.c b/drivers/pci/pci_iomap.c new file mode 100644 index 0000000000..a56f61dc1a --- /dev/null +++ b/drivers/pci/pci_iomap.c @@ -0,0 +1,29 @@ +/* + * Implement the default iomap interfaces + * + * (C) Copyright 2004 Linus Torvalds + */ +#include <linux/pci.h> +#include <io.h> + +#include <module.h> + +/** + * pci_iomap - create a virtual mapping cookie for a PCI BAR + * @dev: PCI device that owns the BAR + * @bar: BAR number + * + * Using this function you will get a __iomem address to your device BAR. + * You can access it using ioread*() and iowrite*(). These functions hide + * the details if this is a MMIO or PIO address space and will just do what + * you expect from them in the correct way. + * + */ +void __iomem *pci_iomap(struct pci_dev *dev, int bar) +{ + struct pci_bus *bus = dev->bus; + resource_size_t start = pci_resource_start(dev, bar); + + return (void *)bus->ops->res_start(bus, start); +} +EXPORT_SYMBOL(pci_iomap); |