Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 6f3d5d3cc4b1447578ae8484166bbc34a64150c5

Authored by Michael Ellerman 2006-08-16 20:04:14 +0800

Committed by Paul Mackerras 2006-08-25 11:27:35 +0800

Exists in master and in 7 other branches

[POWERPC] Add a helper for calculating RTAS "config_addr" parameters

Several RTAS calls take a "config_addr" parameter, which is a particular
way of specifying a PCI busno, devfn and register number into a 32-bit word.
Currently these are open-coded, and I'll be adding another soon, replace
them with a helper that encapsulates the logic. Be more strict about masking
the busno too, just in case.

Booted on P5 LPAR.

Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Signed-off-by: Paul Mackerras <paulus@samba.org>

Showing 2 changed files with 18 additions and 4 deletions Inline Diff

arch/powerpc/kernel/rtas_pci.c
include/asm-powerpc/rtas.h

arch/powerpc/kernel/rtas_pci.c

Diff comments View file @ 6f3d5d3

 /*
  * Copyright (C) 2001 Dave Engebretsen, IBM Corporation
  * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
  *
  * RTAS specific routines for PCI.
  *
  * Based on code from pci.c, chrp_pci.c and pSeries_pci.c
  *
  * 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; either version 2 of the License, or
  * (at your option) any later version.
  *
  * 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.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 #include <linux/kernel.h>
 #include <linux/threads.h>
 #include <linux/pci.h>
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <asm/io.h>
 #include <asm/pgtable.h>
 #include <asm/irq.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/pci-bridge.h>
 #include <asm/iommu.h>
 #include <asm/rtas.h>
 #include <asm/mpic.h>
 #include <asm/ppc-pci.h>
 /* RTAS tokens */
 static int read_pci_config;
 static int write_pci_config;
 static int ibm_read_pci_config;
 static int ibm_write_pci_config;
 static inline int config_access_valid(struct pci_dn *dn, int where)
 {
 	if (where < 256)
 		return 1;
 	if (where < 4096 && dn->pci_ext_config_space)
 		return 1;
 	return 0;
 }
 static int of_device_available(struct device_node * dn)
 {
         const char *status;
         status = get_property(dn, "status", NULL);
         if (!status)
                 return 1;
         if (!strcmp(status, "okay"))
                 return 1;
         return 0;
 }
 int rtas_read_config(struct pci_dn *pdn, int where, int size, u32 *val)
 {
 	int returnval = -1;
 	unsigned long buid, addr;
 	int ret;
 	if (!pdn)
 		return PCIBIOS_DEVICE_NOT_FOUND;
 	if (!config_access_valid(pdn, where))
 		return PCIBIOS_BAD_REGISTER_NUMBER;
-	addr = ((where & 0xf00) << 20) | (pdn->busno << 16) |
+	addr = rtas_config_addr(pdn->busno, pdn->devfn, where);
-		(pdn->devfn << 8) | (where & 0xff);
 	buid = pdn->phb->buid;
 	if (buid) {
 		ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval,
 				addr, BUID_HI(buid), BUID_LO(buid), size);
 	} else {
 		ret = rtas_call(read_pci_config, 2, 2, &returnval, addr, size);
 	}
 	*val = returnval;
 	if (ret)
 		return PCIBIOS_DEVICE_NOT_FOUND;
 	if (returnval == EEH_IO_ERROR_VALUE(size) &&
 	    eeh_dn_check_failure (pdn->node, NULL))
 		return PCIBIOS_DEVICE_NOT_FOUND;
 	return PCIBIOS_SUCCESSFUL;
 }
 static int rtas_pci_read_config(struct pci_bus *bus,
 				unsigned int devfn,
 				int where, int size, u32 *val)
 {
 	struct device_node *busdn, *dn;
 	if (bus->self)
 		busdn = pci_device_to_OF_node(bus->self);
 	else
 		busdn = bus->sysdata;	/* must be a phb */
 	/* Search only direct children of the bus */
 	for (dn = busdn->child; dn; dn = dn->sibling) {
 		struct pci_dn *pdn = PCI_DN(dn);
 		if (pdn && pdn->devfn == devfn
 		    && of_device_available(dn))
 			return rtas_read_config(pdn, where, size, val);
 	}
 	return PCIBIOS_DEVICE_NOT_FOUND;
 }
 int rtas_write_config(struct pci_dn *pdn, int where, int size, u32 val)
 {
 	unsigned long buid, addr;
 	int ret;
 	if (!pdn)
 		return PCIBIOS_DEVICE_NOT_FOUND;
 	if (!config_access_valid(pdn, where))
 		return PCIBIOS_BAD_REGISTER_NUMBER;
-	addr = ((where & 0xf00) << 20) | (pdn->busno << 16) |
+	addr = rtas_config_addr(pdn->busno, pdn->devfn, where);
-		(pdn->devfn << 8) | (where & 0xff);
 	buid = pdn->phb->buid;
 	if (buid) {
 		ret = rtas_call(ibm_write_pci_config, 5, 1, NULL, addr,
 			BUID_HI(buid), BUID_LO(buid), size, (ulong) val);
 	} else {
 		ret = rtas_call(write_pci_config, 3, 1, NULL, addr, size, (ulong)val);
 	}
 	if (ret)
 		return PCIBIOS_DEVICE_NOT_FOUND;
 	return PCIBIOS_SUCCESSFUL;
 }
 static int rtas_pci_write_config(struct pci_bus *bus,
 				 unsigned int devfn,
 				 int where, int size, u32 val)
 {
 	struct device_node *busdn, *dn;
 	if (bus->self)
 		busdn = pci_device_to_OF_node(bus->self);
 	else
 		busdn = bus->sysdata;	/* must be a phb */
 	/* Search only direct children of the bus */
 	for (dn = busdn->child; dn; dn = dn->sibling) {
 		struct pci_dn *pdn = PCI_DN(dn);
 		if (pdn && pdn->devfn == devfn
 		    && of_device_available(dn))
 			return rtas_write_config(pdn, where, size, val);
 	}
 	return PCIBIOS_DEVICE_NOT_FOUND;
 }
 struct pci_ops rtas_pci_ops = {
 	rtas_pci_read_config,
 	rtas_pci_write_config
 };
 int is_python(struct device_node *dev)
 {
 	const char *model = get_property(dev, "model", NULL);
 	if (model && strstr(model, "Python"))
 		return 1;
 	return 0;
 }
 static void python_countermeasures(struct device_node *dev)
 {
 	struct resource registers;
 	void __iomem *chip_regs;
 	volatile u32 val;
 	if (of_address_to_resource(dev, 0, &registers)) {
 		printk(KERN_ERR "Can't get address for Python workarounds !\n");
 		return;
 	}
 	/* Python's register file is 1 MB in size. */
 	chip_regs = ioremap(registers.start & ~(0xfffffUL), 0x100000);
 	/*
 	 * Firmware doesn't always clear this bit which is critical
 	 * for good performance - Anton
 	 */
 #define PRG_CL_RESET_VALID 0x00010000
 	val = in_be32(chip_regs + 0xf6030);
 	if (val & PRG_CL_RESET_VALID) {
 		printk(KERN_INFO "Python workaround: ");
 		val &= ~PRG_CL_RESET_VALID;
 		out_be32(chip_regs + 0xf6030, val);
 		/*
 		 * We must read it back for changes to
 		 * take effect
 		 */
 		val = in_be32(chip_regs + 0xf6030);
 		printk("reg0: %x\n", val);
 	}
 	iounmap(chip_regs);
 }
 void __init init_pci_config_tokens (void)
 {
 	read_pci_config = rtas_token("read-pci-config");
 	write_pci_config = rtas_token("write-pci-config");
 	ibm_read_pci_config = rtas_token("ibm,read-pci-config");
 	ibm_write_pci_config = rtas_token("ibm,write-pci-config");
 }
 unsigned long __devinit get_phb_buid (struct device_node *phb)
 {
 	int addr_cells;
 	const unsigned int *buid_vals;
 	unsigned int len;
 	unsigned long buid;
 	if (ibm_read_pci_config == -1) return 0;
 	/* PHB's will always be children of the root node,
 	 * or so it is promised by the current firmware. */
 	if (phb->parent == NULL)
 		return 0;
 	if (phb->parent->parent)
 		return 0;
 	buid_vals = get_property(phb, "reg", &len);
 	if (buid_vals == NULL)
 		return 0;
 	addr_cells = prom_n_addr_cells(phb);
 	if (addr_cells == 1) {
 		buid = (unsigned long) buid_vals[0];
 	} else {
 		buid = (((unsigned long)buid_vals[0]) << 32UL) |
 			(((unsigned long)buid_vals[1]) & 0xffffffff);
 	}
 	return buid;
 }
 static int phb_set_bus_ranges(struct device_node *dev,
 			      struct pci_controller *phb)
 {
 	const int *bus_range;
 	unsigned int len;
 	bus_range = get_property(dev, "bus-range", &len);
 	if (bus_range == NULL || len < 2 * sizeof(int)) {
 		return 1;
  	}
 	phb->first_busno =  bus_range[0];
 	phb->last_busno  =  bus_range[1];
 	return 0;
 }
 int __devinit setup_phb(struct device_node *dev, struct pci_controller *phb)
 {
 	if (is_python(dev))
 		python_countermeasures(dev);
 	if (phb_set_bus_ranges(dev, phb))
 		return 1;
 	phb->ops = &rtas_pci_ops;
 	phb->buid = get_phb_buid(dev);
 	return 0;
 }
 unsigned long __init find_and_init_phbs(void)
 {
 	struct device_node *node;
 	struct pci_controller *phb;
 	unsigned int index;
 	struct device_node *root = of_find_node_by_path("/");
 	index = 0;
 	for (node = of_get_next_child(root, NULL);
 	     node != NULL;
 	     node = of_get_next_child(root, node)) {
 		if (node->type == NULL || (strcmp(node->type, "pci") != 0 &&
 					   strcmp(node->type, "pciex") != 0))
 			continue;
 		phb = pcibios_alloc_controller(node);
 		if (!phb)
 			continue;
 		setup_phb(node, phb);
 		pci_process_bridge_OF_ranges(phb, node, 0);
 		pci_setup_phb_io(phb, index == 0);
 		index++;
 	}
 	of_node_put(root);
 	pci_devs_phb_init();
 	/*
 	 * pci_probe_only and pci_assign_all_buses can be set via properties
 	 * in chosen.
 	 */
 	if (of_chosen) {
 		const int *prop;
 		prop = get_property(of_chosen,
 				"linux,pci-probe-only", NULL);
 		if (prop)
 			pci_probe_only = *prop;
 		prop = get_property(of_chosen,
 				"linux,pci-assign-all-buses", NULL);
 		if (prop)
 			pci_assign_all_buses = *prop;
 	}
 	return 0;
 }
 /* RPA-specific bits for removing PHBs */
 int pcibios_remove_root_bus(struct pci_controller *phb)
 {
 	struct pci_bus *b = phb->bus;
 	struct resource *res;
 	int rc, i;
 	res = b->resource[0];
 	if (!res->flags) {
 		printk(KERN_ERR "%s: no IO resource for PHB %s\n", __FUNCTION__,
 				b->name);
 		return 1;
 	}
 	rc = unmap_bus_range(b);
 	if (rc) {
 		printk(KERN_ERR "%s: failed to unmap IO on bus %s\n",
 			__FUNCTION__, b->name);
 		return 1;
 	}
 	if (release_resource(res)) {
 		printk(KERN_ERR "%s: failed to release IO on bus %s\n",
 				__FUNCTION__, b->name);
 		return 1;
 	}
 	for (i = 1; i < 3; ++i) {
 		res = b->resource[i];
 		if (!res->flags && i == 0) {
 			printk(KERN_ERR "%s: no MEM resource for PHB %s\n",
 				__FUNCTION__, b->name);
 			return 1;
 		}
 		if (res->flags && release_resource(res)) {
 			printk(KERN_ERR
 			       "%s: failed to release IO %d on bus %s\n",
 				__FUNCTION__, i, b->name);
 			return 1;
 		}
 	}
 	list_del(&phb->list_node);
 	pcibios_free_controller(phb);
 	return 0;
 }
 EXPORT_SYMBOL(pcibios_remove_root_bus);

include/asm-powerpc/rtas.h

Diff comments View file @ 6f3d5d3

 #ifndef _POWERPC_RTAS_H
 #define _POWERPC_RTAS_H
 #ifdef __KERNEL__
 #include <linux/spinlock.h>
 #include <asm/page.h>
 /*
  * Definitions for talking to the RTAS on CHRP machines.
  *
  * Copyright (C) 2001 Peter Bergner
  * Copyright (C) 2001 PPC 64 Team, IBM Corp
  *
  * 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; either version
  * 2 of the License, or (at your option) any later version.
  */
 #define RTAS_UNKNOWN_SERVICE (-1)
 #define RTAS_INSTANTIATE_MAX (1UL<<30) /* Don't instantiate rtas at/above this value */
 /* Buffer size for ppc_rtas system call. */
 #define RTAS_RMOBUF_MAX (64 * 1024)
 /* RTAS return status codes */
 #define RTAS_NOT_SUSPENDABLE	-9004
 #define RTAS_BUSY		-2    /* RTAS Busy */
 #define RTAS_EXTENDED_DELAY_MIN	9900
 #define RTAS_EXTENDED_DELAY_MAX	9905
 /*
  * In general to call RTAS use rtas_token("string") to lookup
  * an RTAS token for the given string (e.g. "event-scan").
  * To actually perform the call use
  *    ret = rtas_call(token, n_in, n_out, ...)
  * Where n_in is the number of input parameters and
  *       n_out is the number of output parameters
  *
  * If the "string" is invalid on this system, RTAS_UNKNOWN_SERVICE
  * will be returned as a token.  rtas_call() does look for this
  * token and error out gracefully so rtas_call(rtas_token("str"), ...)
  * may be safely used for one-shot calls to RTAS.
  *
  */
 typedef u32 rtas_arg_t;
 struct rtas_args {
 	u32 token;
 	u32 nargs;
 	u32 nret;
 	rtas_arg_t args[16];
 	rtas_arg_t *rets;     /* Pointer to return values in args[]. */
 };
 extern struct rtas_args rtas_stop_self_args;
 struct rtas_t {
 	unsigned long entry;		/* physical address pointer */
 	unsigned long base;		/* physical address pointer */
 	unsigned long size;
 	spinlock_t lock;
 	struct rtas_args args;
 	struct device_node *dev;	/* virtual address pointer */
 };
 /* RTAS event classes */
 #define RTAS_INTERNAL_ERROR		0x80000000 /* set bit 0 */
 #define RTAS_EPOW_WARNING		0x40000000 /* set bit 1 */
 #define RTAS_POWERMGM_EVENTS		0x20000000 /* set bit 2 */
 #define RTAS_HOTPLUG_EVENTS		0x10000000 /* set bit 3 */
 #define RTAS_EVENT_SCAN_ALL_EVENTS	0xf0000000
 /* RTAS event severity */
 #define RTAS_SEVERITY_FATAL		0x5
 #define RTAS_SEVERITY_ERROR		0x4
 #define RTAS_SEVERITY_ERROR_SYNC	0x3
 #define RTAS_SEVERITY_WARNING		0x2
 #define RTAS_SEVERITY_EVENT		0x1
 #define RTAS_SEVERITY_NO_ERROR		0x0
 /* RTAS event disposition */
 #define RTAS_DISP_FULLY_RECOVERED	0x0
 #define RTAS_DISP_LIMITED_RECOVERY	0x1
 #define RTAS_DISP_NOT_RECOVERED		0x2
 /* RTAS event initiator */
 #define RTAS_INITIATOR_UNKNOWN		0x0
 #define RTAS_INITIATOR_CPU		0x1
 #define RTAS_INITIATOR_PCI		0x2
 #define RTAS_INITIATOR_ISA		0x3
 #define RTAS_INITIATOR_MEMORY		0x4
 #define RTAS_INITIATOR_POWERMGM		0x5
 /* RTAS event target */
 #define RTAS_TARGET_UNKNOWN		0x0
 #define RTAS_TARGET_CPU			0x1
 #define RTAS_TARGET_PCI			0x2
 #define RTAS_TARGET_ISA			0x3
 #define RTAS_TARGET_MEMORY		0x4
 #define RTAS_TARGET_POWERMGM		0x5
 /* RTAS event type */
 #define RTAS_TYPE_RETRY			0x01
 #define RTAS_TYPE_TCE_ERR		0x02
 #define RTAS_TYPE_INTERN_DEV_FAIL	0x03
 #define RTAS_TYPE_TIMEOUT		0x04
 #define RTAS_TYPE_DATA_PARITY		0x05
 #define RTAS_TYPE_ADDR_PARITY		0x06
 #define RTAS_TYPE_CACHE_PARITY		0x07
 #define RTAS_TYPE_ADDR_INVALID		0x08
 #define RTAS_TYPE_ECC_UNCORR		0x09
 #define RTAS_TYPE_ECC_CORR		0x0a
 #define RTAS_TYPE_EPOW			0x40
 #define RTAS_TYPE_PLATFORM		0xE0
 #define RTAS_TYPE_IO			0xE1
 #define RTAS_TYPE_INFO			0xE2
 #define RTAS_TYPE_DEALLOC		0xE3
 #define RTAS_TYPE_DUMP			0xE4
 /* I don't add PowerMGM events right now, this is a different topic */
 #define RTAS_TYPE_PMGM_POWER_SW_ON	0x60
 #define RTAS_TYPE_PMGM_POWER_SW_OFF	0x61
 #define RTAS_TYPE_PMGM_LID_OPEN		0x62
 #define RTAS_TYPE_PMGM_LID_CLOSE	0x63
 #define RTAS_TYPE_PMGM_SLEEP_BTN	0x64
 #define RTAS_TYPE_PMGM_WAKE_BTN		0x65
 #define RTAS_TYPE_PMGM_BATTERY_WARN	0x66
 #define RTAS_TYPE_PMGM_BATTERY_CRIT	0x67
 #define RTAS_TYPE_PMGM_SWITCH_TO_BAT	0x68
 #define RTAS_TYPE_PMGM_SWITCH_TO_AC	0x69
 #define RTAS_TYPE_PMGM_KBD_OR_MOUSE	0x6a
 #define RTAS_TYPE_PMGM_ENCLOS_OPEN	0x6b
 #define RTAS_TYPE_PMGM_ENCLOS_CLOSED	0x6c
 #define RTAS_TYPE_PMGM_RING_INDICATE	0x6d
 #define RTAS_TYPE_PMGM_LAN_ATTENTION	0x6e
 #define RTAS_TYPE_PMGM_TIME_ALARM	0x6f
 #define RTAS_TYPE_PMGM_CONFIG_CHANGE	0x70
 #define RTAS_TYPE_PMGM_SERVICE_PROC	0x71
 struct rtas_error_log {
 	unsigned long version:8;		/* Architectural version */
 	unsigned long severity:3;		/* Severity level of error */
 	unsigned long disposition:2;		/* Degree of recovery */
 	unsigned long extended:1;		/* extended log present? */
 	unsigned long /* reserved */ :2;	/* Reserved for future use */
 	unsigned long initiator:4;		/* Initiator of event */
 	unsigned long target:4;			/* Target of failed operation */
 	unsigned long type:8;			/* General event or error*/
 	unsigned long extended_log_length:32;	/* length in bytes */
 	unsigned char buffer[1];
 };
 /*
  * This can be set by the rtas_flash module so that it can get called
  * as the absolutely last thing before the kernel terminates.
  */
 extern void (*rtas_flash_term_hook)(int);
 extern struct rtas_t rtas;
 extern void enter_rtas(unsigned long);
 extern int rtas_token(const char *service);
 extern int rtas_call(int token, int, int, int *, ...);
 extern void rtas_restart(char *cmd);
 extern void rtas_power_off(void);
 extern void rtas_halt(void);
 extern void rtas_os_term(char *str);
 extern int rtas_get_sensor(int sensor, int index, int *state);
 extern int rtas_get_power_level(int powerdomain, int *level);
 extern int rtas_set_power_level(int powerdomain, int level, int *setlevel);
 extern int rtas_set_indicator(int indicator, int index, int new_value);
 extern int rtas_set_indicator_fast(int indicator, int index, int new_value);
 extern void rtas_progress(char *s, unsigned short hex);
 extern void rtas_initialize(void);
 struct rtc_time;
 extern unsigned long rtas_get_boot_time(void);
 extern void rtas_get_rtc_time(struct rtc_time *rtc_time);
 extern int rtas_set_rtc_time(struct rtc_time *rtc_time);
 extern unsigned int rtas_busy_delay_time(int status);
 extern unsigned int rtas_busy_delay(int status);
 extern int early_init_dt_scan_rtas(unsigned long node,
 		const char *uname, int depth, void *data);
 extern void pSeries_log_error(char *buf, unsigned int err_type, int fatal);
 /* Error types logged.  */
 #define ERR_FLAG_ALREADY_LOGGED	0x0
 #define ERR_FLAG_BOOT		0x1 	/* log was pulled from NVRAM on boot */
 #define ERR_TYPE_RTAS_LOG	0x2	/* from rtas event-scan */
 #define ERR_TYPE_KERNEL_PANIC	0x4	/* from panic() */
 /* All the types and not flags */
 #define ERR_TYPE_MASK	(ERR_TYPE_RTAS_LOG | ERR_TYPE_KERNEL_PANIC)
 #define RTAS_DEBUG KERN_DEBUG "RTAS: "
 #define RTAS_ERROR_LOG_MAX 2048
 /*
  * Return the firmware-specified size of the error log buffer
  *  for all rtas calls that require an error buffer argument.
  *  This includes 'check-exception' and 'rtas-last-error'.
  */
 extern int rtas_get_error_log_max(void);
 /* Event Scan Parameters */
 #define EVENT_SCAN_ALL_EVENTS	0xf0000000
 #define SURVEILLANCE_TOKEN	9000
 #define LOG_NUMBER		64		/* must be a power of two */
 #define LOG_NUMBER_MASK		(LOG_NUMBER-1)
 /* Some RTAS ops require a data buffer and that buffer must be < 4G.
  * Rather than having a memory allocator, just use this buffer
  * (get the lock first), make the RTAS call.  Copy the data instead
  * of holding the buffer for long.
  */
 #define RTAS_DATA_BUF_SIZE 4096
 extern spinlock_t rtas_data_buf_lock;
 extern char rtas_data_buf[RTAS_DATA_BUF_SIZE];
 extern void rtas_stop_self(void);
 /* RMO buffer reserved for user-space RTAS use */
 extern unsigned long rtas_rmo_buf;
 #define GLOBAL_INTERRUPT_QUEUE 9005
+/**
+ * rtas_config_addr - Format a busno, devfn and reg for RTAS.
+ * @busno: The bus number.
+ * @devfn: The device and function number as encoded by PCI_DEVFN().
+ * @reg: The register number.
+ *
+ * This function encodes the given busno, devfn and register number as
+ * required for RTAS calls that take a "config_addr" parameter.
+ * See PAPR requirement 7.3.4-1 for more info.
+ */
+static inline u32 rtas_config_addr(int busno, int devfn, int reg)
+{
+	return ((reg & 0xf00) << 20) | ((busno & 0xff) << 16) |
+			(devfn << 8) | (reg & 0xff);
+}
 #endif /* __KERNEL__ */
 #endif /* _POWERPC_RTAS_H */