src/device/device_const.c - mirrors/cros/chromiumos/third_party/coreboot - Git at Google

 /*
  * This file is part of the coreboot project.
  *
  * Copyright (C) 2003-2004 Linux Networx
  * (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx)
  * Copyright (C) 2003 Greg Watson <jarrah@users.sourceforge.net>
  * Copyright (C) 2004 Li-Ta Lo <ollie@lanl.gov>
  * Copyright (C) 2005-2006 Tyan
  * (Written by Yinghai Lu <yhlu@tyan.com> for Tyan)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2 of the License.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <console/console.h>
 #include <device/device.h>
 #include <device/path.h>
 #include <device/pci.h>
 #include <device/pci_def.h>
 #include <device/resource.h>

 /** Linked list of ALL devices */
 DEVTREE_CONST struct device * DEVTREE_CONST all_devices = &dev_root;

 /**
  * Given a PCI bus and a devfn number, find the device structure.
  *
  * @param bus The bus number.
  * @param devfn A device/function number.
  * @return Pointer to the device structure (if found), 0 otherwise.
  */
 DEVTREE_CONST struct device *dev_find_slot(unsigned int bus,
 						unsigned int devfn)
 {
 	DEVTREE_CONST struct device *dev, *result;

 	result = 0;
 	for (dev = all_devices; dev; dev = dev->next) {
 		if ((dev->path.type == DEVICE_PATH_PCI) &&
 		    (dev->bus->secondary == bus) &&
 		    (dev->path.pci.devfn == devfn)) {
 			result = dev;
 			break;
 		}
 	}
 	return result;
 }

 /**
  * Given a Device Path Type, find the device structure.
  *
  * @param prev_match The previously matched device instance.
  * @param path_type The Device Path Type.
  * @return Pointer to the device structure (if found), 0 otherwise.
  */
 DEVTREE_CONST struct device *dev_find_path(
 		DEVTREE_CONST struct device *prev_match,
 		enum device_path_type path_type)
 {
 	DEVTREE_CONST struct device *dev, *result = NULL;

 	if (prev_match == NULL)
 		prev_match = all_devices;
 	else
 		prev_match = prev_match->next;

 	for (dev = prev_match; dev; dev = dev->next) {
 		if (dev->path.type == path_type) {
 			result = dev;
 			break;
 		}
 	}
 	return result;
 }

 /**
  * Given a device pointer, find the next PCI device.
  *
  * @param previous_dev A pointer to a PCI device structure.
  * @return Pointer to the next device structure (if found), 0 otherwise.
  */
 DEVTREE_CONST struct device *dev_find_next_pci_device(
 		DEVTREE_CONST struct device *previous_dev)
 {
 	return dev_find_path(previous_dev, DEVICE_PATH_PCI);
 }

 static int path_eq(const struct device_path *path1,
 		const struct device_path *path2)
 {
 	int equal = 0;

 	if (path1->type != path2->type)
 		return 0;

 	switch (path1->type) {
 	case DEVICE_PATH_NONE:
 		break;
 	case DEVICE_PATH_ROOT:
 		equal = 1;
 		break;
 	case DEVICE_PATH_PCI:
 		equal = (path1->pci.devfn == path2->pci.devfn);
 		break;
 	case DEVICE_PATH_PNP:
 		equal = (path1->pnp.port == path2->pnp.port) &&
 			(path1->pnp.device == path2->pnp.device);
 		break;
 	case DEVICE_PATH_I2C:
 		equal = (path1->i2c.device == path2->i2c.device) &&
 			(path1->i2c.mode_10bit == path2->i2c.mode_10bit);
 		break;
 	case DEVICE_PATH_APIC:
 		equal = (path1->apic.apic_id == path2->apic.apic_id);
 		break;
 	case DEVICE_PATH_DOMAIN:
 		equal = (path1->domain.domain == path2->domain.domain);
 		break;
 	case DEVICE_PATH_CPU_CLUSTER:
 		equal = (path1->cpu_cluster.cluster
 			 == path2->cpu_cluster.cluster);
 		break;
 	case DEVICE_PATH_CPU:
 		equal = (path1->cpu.id == path2->cpu.id);
 		break;
 	case DEVICE_PATH_CPU_BUS:
 		equal = (path1->cpu_bus.id == path2->cpu_bus.id);
 		break;
 	case DEVICE_PATH_GENERIC:
 		equal = (path1->generic.id == path2->generic.id) &&
 			(path1->generic.subid == path2->generic.subid);
 		break;
 	case DEVICE_PATH_SPI:
 		equal = (path1->spi.cs == path2->spi.cs);
 		break;
 	case DEVICE_PATH_USB:
 		equal = (path1->usb.port_type == path2->usb.port_type) &&
 			(path1->usb.port_id == path2->usb.port_id);
 		break;
 	case DEVICE_PATH_MMIO:
 		equal = (path1->mmio.addr == path2->mmio.addr);
 		break;
 	default:
 		printk(BIOS_ERR, "Unknown device type: %d\n", path1->type);
 		break;
 	}

 	return equal;
 }

 /**
  * See if a device structure exists for path.
  *
  * @param parent The bus to find the device on.
  * @param path The relative path from the bus to the appropriate device.
  * @return Pointer to a device structure for the device on bus at path
  *         or 0/NULL if no device is found.
  */
 DEVTREE_CONST struct device *find_dev_path(
 	const struct bus *parent, const struct device_path *path)
 {
 	DEVTREE_CONST struct device *child;
 	for (child = parent->children; child; child = child->sibling) {
 		if (path_eq(path, &child->path))
 			break;
 	}
 	return child;
 }

 DEVTREE_CONST struct device *pcidev_path_behind(
 	const struct bus *parent, pci_devfn_t devfn)
 {
 	const struct device_path path = {
 		.type = DEVICE_PATH_PCI,
 		.pci.devfn = devfn,
 	};
 	return find_dev_path(parent, &path);
 }

 DEVTREE_CONST struct device *pcidev_path_on_bus(unsigned int bus, pci_devfn_t devfn)
 {
 	DEVTREE_CONST struct bus *parent = pci_root_bus();
 	DEVTREE_CONST struct device *dev = parent->children;

 	/* FIXME: Write the loop with topology links. */
 	while (dev) {
 		if (dev->path.type != DEVICE_PATH_PCI) {
 			dev = dev->next;
 			continue;
 		}
 		if (dev->bus->secondary == bus)
 			return pcidev_path_behind(dev->bus, devfn);
 		dev = dev->next;
 	}
 	return NULL;
 }

 DEVTREE_CONST struct bus *pci_root_bus(void)
 {
 	DEVTREE_CONST struct device *pci_domain;
 	MAYBE_STATIC_BSS DEVTREE_CONST struct bus *pci_root = NULL;

 	if (pci_root)
 		return pci_root;

 	pci_domain = dev_find_path(NULL, DEVICE_PATH_DOMAIN);
 	if (!pci_domain)
 		return NULL;

 	pci_root = pci_domain->link_list;
 	return pci_root;
 }

 DEVTREE_CONST struct device *pcidev_path_on_root(pci_devfn_t devfn)
 {
 	/* Work around pcidev_path_behind() below failing
 	 * due tue complicated devicetree with topology
 	 * being manipulated on-the-fly.
 	 */
 	if (CONFIG(NORTHBRIDGE_AMD_AMDFAM10))
 		return dev_find_slot(0, devfn);

 	return pcidev_path_behind(pci_root_bus(), devfn);
 }

 DEVTREE_CONST struct device *pcidev_on_root(uint8_t dev, uint8_t fn)
 {
 	return pcidev_path_on_root(PCI_DEVFN(dev, fn));
 }

 DEVTREE_CONST struct device *pcidev_path_on_root_debug(pci_devfn_t devfn, const char *func)
 {
 	DEVTREE_CONST struct device *dev = pcidev_path_on_root(devfn);
 	if (dev)
 		return dev;

 	devtree_bug(func, devfn);

 	/* FIXME: This can return wrong device. */
 	return dev_find_slot(0, devfn);
 }

 void devtree_bug(const char *func, pci_devfn_t devfn)
 {
 	printk(BIOS_ERR, "BUG: %s requests hidden 00:%02x.%u\n", func, devfn >> 3, devfn & 7);
 }

 void __noreturn devtree_die(void)
 {
 	die("DEVTREE: dev or chip_info is NULL\n");
 }

 /**
  * Given an SMBus bus and a device number, find the device structure.
  *
  * @param bus The bus number.
  * @param addr A device number.
  * @return Pointer to the device structure (if found), 0 otherwise.
  */
 DEVTREE_CONST struct device *dev_find_slot_on_smbus(unsigned int bus,
 							unsigned int addr)
 {
 	DEVTREE_CONST struct device *dev, *result;

 	result = 0;
 	for (dev = all_devices; dev; dev = dev->next) {
 		if ((dev->path.type == DEVICE_PATH_I2C) &&
 		    (dev->bus->secondary == bus) &&
 		    (dev->path.i2c.device == addr)) {
 			result = dev;
 			break;
 		}
 	}
 	return result;
 }

 /**
  * Given a PnP port and a device number, find the device structure.
  *
  * @param port The I/O port.
  * @param device Logical device number.
  * @return Pointer to the device structure (if found), 0 otherwise.
  */
 DEVTREE_CONST struct device *dev_find_slot_pnp(u16 port, u16 device)
 {
 	DEVTREE_CONST struct device *dev;

 	for (dev = all_devices; dev; dev = dev->next) {
 		if ((dev->path.type == DEVICE_PATH_PNP) &&
 		    (dev->path.pnp.port == port) &&
 		    (dev->path.pnp.device == device)) {
 			return dev;
 		}
 	}
 	return 0;
 }

 /**
  * Given a device and previous match iterate through all the children.
  *
  * @param bus parent device's bus holding all the children
  * @param prev_child previous child already traversed, if NULL start at
  *        children of parent bus.
  * @return pointer to child or NULL when no more children
  */
 DEVTREE_CONST struct device *dev_bus_each_child(const struct bus *parent,
 					DEVTREE_CONST struct device *prev_child)
 {
 	DEVTREE_CONST struct device *dev;

 	if (parent == NULL)
 		return NULL;

 	if (prev_child == NULL)
 		dev = parent->children;
 	else
 		dev = prev_child->sibling;

 	return dev;
 }
	/*
	* This file is part of the coreboot project.
	*
	* Copyright (C) 2003-2004 Linux Networx
	* (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx)
	* Copyright (C) 2003 Greg Watson <jarrah@users.sourceforge.net>
	* Copyright (C) 2004 Li-Ta Lo <ollie@lanl.gov>
	* Copyright (C) 2005-2006 Tyan
	* (Written by Yinghai Lu <yhlu@tyan.com> for Tyan)
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; version 2 of the License.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <console/console.h>
	#include <device/device.h>
	#include <device/path.h>
	#include <device/pci.h>
	#include <device/pci_def.h>
	#include <device/resource.h>

	/** Linked list of ALL devices */
	DEVTREE_CONST struct device * DEVTREE_CONST all_devices = &dev_root;

	/**
	* Given a PCI bus and a devfn number, find the device structure.
	*
	* @param bus The bus number.
	* @param devfn A device/function number.
	* @return Pointer to the device structure (if found), 0 otherwise.
	*/
	DEVTREE_CONST struct device *dev_find_slot(unsigned int bus,
	unsigned int devfn)
	{
	DEVTREE_CONST struct device dev, result;

	result = 0;
	for (dev = all_devices; dev; dev = dev->next) {
	if ((dev->path.type == DEVICE_PATH_PCI) &&
	(dev->bus->secondary == bus) &&
	(dev->path.pci.devfn == devfn)) {
	result = dev;
	break;
	}
	}
	return result;
	}

	/**
	* Given a Device Path Type, find the device structure.
	*
	* @param prev_match The previously matched device instance.
	* @param path_type The Device Path Type.
	* @return Pointer to the device structure (if found), 0 otherwise.
	*/
	DEVTREE_CONST struct device *dev_find_path(
	DEVTREE_CONST struct device *prev_match,
	enum device_path_type path_type)
	{
	DEVTREE_CONST struct device dev, result = NULL;

	if (prev_match == NULL)
	prev_match = all_devices;
	else
	prev_match = prev_match->next;

	for (dev = prev_match; dev; dev = dev->next) {
	if (dev->path.type == path_type) {
	result = dev;
	break;
	}
	}
	return result;
	}

	/**
	* Given a device pointer, find the next PCI device.
	*
	* @param previous_dev A pointer to a PCI device structure.
	* @return Pointer to the next device structure (if found), 0 otherwise.
	*/
	DEVTREE_CONST struct device *dev_find_next_pci_device(
	DEVTREE_CONST struct device *previous_dev)
	{
	return dev_find_path(previous_dev, DEVICE_PATH_PCI);
	}

	static int path_eq(const struct device_path *path1,
	const struct device_path *path2)
	{
	int equal = 0;

	if (path1->type != path2->type)
	return 0;

	switch (path1->type) {
	case DEVICE_PATH_NONE:
	break;
	case DEVICE_PATH_ROOT:
	equal = 1;
	break;
	case DEVICE_PATH_PCI:
	equal = (path1->pci.devfn == path2->pci.devfn);
	break;
	case DEVICE_PATH_PNP:
	equal = (path1->pnp.port == path2->pnp.port) &&
	(path1->pnp.device == path2->pnp.device);
	break;
	case DEVICE_PATH_I2C:
	equal = (path1->i2c.device == path2->i2c.device) &&
	(path1->i2c.mode_10bit == path2->i2c.mode_10bit);
	break;
	case DEVICE_PATH_APIC:
	equal = (path1->apic.apic_id == path2->apic.apic_id);
	break;
	case DEVICE_PATH_DOMAIN:
	equal = (path1->domain.domain == path2->domain.domain);
	break;
	case DEVICE_PATH_CPU_CLUSTER:
	equal = (path1->cpu_cluster.cluster
	== path2->cpu_cluster.cluster);
	break;
	case DEVICE_PATH_CPU:
	equal = (path1->cpu.id == path2->cpu.id);
	break;
	case DEVICE_PATH_CPU_BUS:
	equal = (path1->cpu_bus.id == path2->cpu_bus.id);
	break;
	case DEVICE_PATH_GENERIC:
	equal = (path1->generic.id == path2->generic.id) &&
	(path1->generic.subid == path2->generic.subid);
	break;
	case DEVICE_PATH_SPI:
	equal = (path1->spi.cs == path2->spi.cs);
	break;
	case DEVICE_PATH_USB:
	equal = (path1->usb.port_type == path2->usb.port_type) &&
	(path1->usb.port_id == path2->usb.port_id);
	break;
	case DEVICE_PATH_MMIO:
	equal = (path1->mmio.addr == path2->mmio.addr);
	break;
	default:
	printk(BIOS_ERR, "Unknown device type: %d\n", path1->type);
	break;
	}

	return equal;
	}

	/**
	* See if a device structure exists for path.
	*
	* @param parent The bus to find the device on.
	* @param path The relative path from the bus to the appropriate device.
	* @return Pointer to a device structure for the device on bus at path
	* or 0/NULL if no device is found.
	*/
	DEVTREE_CONST struct device *find_dev_path(
	const struct bus parent, const struct device_path path)
	{
	DEVTREE_CONST struct device *child;
	for (child = parent->children; child; child = child->sibling) {
	if (path_eq(path, &child->path))
	break;
	}
	return child;
	}

	DEVTREE_CONST struct device *pcidev_path_behind(
	const struct bus *parent, pci_devfn_t devfn)
	{
	const struct device_path path = {
	.type = DEVICE_PATH_PCI,
	.pci.devfn = devfn,
	};
	return find_dev_path(parent, &path);
	}

	DEVTREE_CONST struct device *pcidev_path_on_bus(unsigned int bus, pci_devfn_t devfn)
	{
	DEVTREE_CONST struct bus *parent = pci_root_bus();
	DEVTREE_CONST struct device *dev = parent->children;

	/* FIXME: Write the loop with topology links. */
	while (dev) {
	if (dev->path.type != DEVICE_PATH_PCI) {
	dev = dev->next;
	continue;
	}
	if (dev->bus->secondary == bus)
	return pcidev_path_behind(dev->bus, devfn);
	dev = dev->next;
	}
	return NULL;
	}

	DEVTREE_CONST struct bus *pci_root_bus(void)
	{
	DEVTREE_CONST struct device *pci_domain;
	MAYBE_STATIC_BSS DEVTREE_CONST struct bus *pci_root = NULL;

	if (pci_root)
	return pci_root;

	pci_domain = dev_find_path(NULL, DEVICE_PATH_DOMAIN);
	if (!pci_domain)
	return NULL;

	pci_root = pci_domain->link_list;
	return pci_root;
	}

	DEVTREE_CONST struct device *pcidev_path_on_root(pci_devfn_t devfn)
	{
	/* Work around pcidev_path_behind() below failing
	* due tue complicated devicetree with topology
	* being manipulated on-the-fly.
	*/
	if (CONFIG(NORTHBRIDGE_AMD_AMDFAM10))
	return dev_find_slot(0, devfn);

	return pcidev_path_behind(pci_root_bus(), devfn);
	}

	DEVTREE_CONST struct device *pcidev_on_root(uint8_t dev, uint8_t fn)
	{
	return pcidev_path_on_root(PCI_DEVFN(dev, fn));
	}

	DEVTREE_CONST struct device pcidev_path_on_root_debug(pci_devfn_t devfn, const char func)
	{
	DEVTREE_CONST struct device *dev = pcidev_path_on_root(devfn);
	if (dev)
	return dev;

	devtree_bug(func, devfn);

	/* FIXME: This can return wrong device. */
	return dev_find_slot(0, devfn);
	}

	void devtree_bug(const char *func, pci_devfn_t devfn)
	{
	printk(BIOS_ERR, "BUG: %s requests hidden 00:%02x.%u\n", func, devfn >> 3, devfn & 7);
	}

	void __noreturn devtree_die(void)
	{
	die("DEVTREE: dev or chip_info is NULL\n");
	}

	/**
	* Given an SMBus bus and a device number, find the device structure.
	*
	* @param bus The bus number.
	* @param addr A device number.
	* @return Pointer to the device structure (if found), 0 otherwise.
	*/
	DEVTREE_CONST struct device *dev_find_slot_on_smbus(unsigned int bus,
	unsigned int addr)
	{
	DEVTREE_CONST struct device dev, result;

	result = 0;
	for (dev = all_devices; dev; dev = dev->next) {
	if ((dev->path.type == DEVICE_PATH_I2C) &&
	(dev->bus->secondary == bus) &&
	(dev->path.i2c.device == addr)) {
	result = dev;
	break;
	}
	}
	return result;
	}

	/**
	* Given a PnP port and a device number, find the device structure.
	*
	* @param port The I/O port.
	* @param device Logical device number.
	* @return Pointer to the device structure (if found), 0 otherwise.
	*/
	DEVTREE_CONST struct device *dev_find_slot_pnp(u16 port, u16 device)
	{
	DEVTREE_CONST struct device *dev;

	for (dev = all_devices; dev; dev = dev->next) {
	if ((dev->path.type == DEVICE_PATH_PNP) &&
	(dev->path.pnp.port == port) &&
	(dev->path.pnp.device == device)) {
	return dev;
	}
	}
	return 0;
	}

	/**
	* Given a device and previous match iterate through all the children.
	*
	* @param bus parent device's bus holding all the children
	* @param prev_child previous child already traversed, if NULL start at
	* children of parent bus.
	* @return pointer to child or NULL when no more children
	*/
	DEVTREE_CONST struct device dev_bus_each_child(const struct bus parent,
	DEVTREE_CONST struct device *prev_child)
	{
	DEVTREE_CONST struct device *dev;

	if (parent == NULL)
	return NULL;

	if (prev_child == NULL)
	dev = parent->children;
	else
	dev = prev_child->sibling;

	return dev;
	}