litmus-rt.git - The LITMUS^RT kernel.

diff options

Diffstat (limited to 'arch/sparc64/mm/init.c')

-rw-r--r--

1 files changed, 17 insertions, 6 deletions


diff --git a/arch/sparc64/mm/init.c b/arch/sparc64/mm/init.c index 8fc413cb6acd..3fbaf342a452 100644 --- a/arch/sparc64/mm/init.c +++ b/arch/sparc64/mm/init.c
@@ -121,15 +121,24 @@ __inline__ void flush_dcache_page_impl(struct page *page)
121	}	121	}
122		122
123	#define PG_dcache_dirty PG_arch_1	123	#define PG_dcache_dirty PG_arch_1
		124	#define PG_dcache_cpu_shift 24
		125	#define PG_dcache_cpu_mask (256 - 1)
		126
		127	#if NR_CPUS > 256
		128	#error D-cache dirty tracking and thread_info->cpu need fixing for > 256 cpus
		129	#endif
124		130
125	#define dcache_dirty_cpu(page) \	131	#define dcache_dirty_cpu(page) \
126	(((page)->flags >> 24) & (NR_CPUS - 1UL))	132	(((page)->flags >> PG_dcache_cpu_shift) & PG_dcache_cpu_mask)
127		133
128	static __inline__ void set_dcache_dirty(struct page *page, int this_cpu)	134	static __inline__ void set_dcache_dirty(struct page *page, int this_cpu)
129	{	135	{
130	unsigned long mask = this_cpu;	136	unsigned long mask = this_cpu;
131	unsigned long non_cpu_bits = ~((NR_CPUS - 1UL) << 24UL);	137	unsigned long non_cpu_bits;
132	mask = (mask << 24) \| (1UL << PG_dcache_dirty);	138
		139	non_cpu_bits = ~(PG_dcache_cpu_mask << PG_dcache_cpu_shift);
		140	mask = (mask << PG_dcache_cpu_shift) \| (1UL << PG_dcache_dirty);
		141
133	__asm__ __volatile__("1:\n\t"	142	__asm__ __volatile__("1:\n\t"
134	"ldx [%2], %%g7\n\t"	143	"ldx [%2], %%g7\n\t"
135	"and %%g7, %1, %%g1\n\t"	144	"and %%g7, %1, %%g1\n\t"
@@ -151,7 +160,7 @@ static __inline__ void clear_dcache_dirty_cpu(struct page *page, unsigned long c
151	__asm__ __volatile__("! test_and_clear_dcache_dirty\n"	160	__asm__ __volatile__("! test_and_clear_dcache_dirty\n"
152	"1:\n\t"	161	"1:\n\t"
153	"ldx [%2], %%g7\n\t"	162	"ldx [%2], %%g7\n\t"
154	"srlx %%g7, 24, %%g1\n\t"	163	"srlx %%g7, %4, %%g1\n\t"
155	"and %%g1, %3, %%g1\n\t"	164	"and %%g1, %3, %%g1\n\t"
156	"cmp %%g1, %0\n\t"	165	"cmp %%g1, %0\n\t"
157	"bne,pn %%icc, 2f\n\t"	166	"bne,pn %%icc, 2f\n\t"
@@ -164,7 +173,8 @@ static __inline__ void clear_dcache_dirty_cpu(struct page *page, unsigned long c
164	"2:"	173	"2:"
165	: /* no outputs */	174	: /* no outputs */
166	: "r" (cpu), "r" (mask), "r" (&page->flags),	175	: "r" (cpu), "r" (mask), "r" (&page->flags),
167	"i" (NR_CPUS - 1UL)	176	"i" (PG_dcache_cpu_mask),
		177	"i" (PG_dcache_cpu_shift)
168	: "g1", "g7");	178	: "g1", "g7");
169	}	179	}
170		180
@@ -180,7 +190,8 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t p
180	if (pfn_valid(pfn) &&	190	if (pfn_valid(pfn) &&
181	(page = pfn_to_page(pfn), page_mapping(page)) &&	191	(page = pfn_to_page(pfn), page_mapping(page)) &&
182	((pg_flags = page->flags) & (1UL << PG_dcache_dirty))) {	192	((pg_flags = page->flags) & (1UL << PG_dcache_dirty))) {
183	int cpu = ((pg_flags >> 24) & (NR_CPUS - 1UL));	193	int cpu = ((pg_flags >> PG_dcache_cpu_shift) &
		194	PG_dcache_cpu_mask);
184	int this_cpu = get_cpu();	195	int this_cpu = get_cpu();
185		196
186	/* This is just to optimize away some function calls	197	/* This is just to optimize away some function calls

/* * A hwmon driver for the IBM System Director Active Energy Manager (AEM) * temperature/power/energy sensors and capping functionality. * Copyright (C) 2008 IBM * * Author: Darrick J. Wong <djwong@us.ibm.com> * * 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 */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/ipmi.h> #include <linux/module.h> #include <linux/hwmon.h> #include <linux/hwmon-sysfs.h> #include <linux/jiffies.h> #include <linux/mutex.h> #include <linux/kdev_t.h> #include <linux/spinlock.h> #include <linux/idr.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/platform_device.h> #include <linux/math64.h> #include <linux/time.h> #define REFRESH_INTERVAL (HZ) #define IPMI_TIMEOUT (30 * HZ) #define DRVNAME "aem" #define AEM_NETFN 0x2E #define AEM_FIND_FW_CMD 0x80 #define AEM_ELEMENT_CMD 0x81 #define AEM_FW_INSTANCE_CMD 0x82 #define AEM_READ_ELEMENT_CFG 0x80 #define AEM_READ_BUFFER 0x81 #define AEM_READ_REGISTER 0x82 #define AEM_WRITE_REGISTER 0x83 #define AEM_SET_REG_MASK 0x84 #define AEM_CLEAR_REG_MASK 0x85 #define AEM_READ_ELEMENT_CFG2 0x86 #define AEM_CONTROL_ELEMENT 0 #define AEM_ENERGY_ELEMENT 1 #define AEM_CLOCK_ELEMENT 4 #define AEM_POWER_CAP_ELEMENT 7 #define AEM_EXHAUST_ELEMENT 9 #define AEM_POWER_ELEMENT 10 #define AEM_MODULE_TYPE_ID 0x0001 #define AEM2_NUM_ENERGY_REGS 2 #define AEM2_NUM_PCAP_REGS 6 #define AEM2_NUM_TEMP_REGS 2 #define AEM2_NUM_SENSORS 14 #define AEM1_NUM_ENERGY_REGS 1 #define AEM1_NUM_SENSORS 3 /* AEM 2.x has more energy registers */ #define AEM_NUM_ENERGY_REGS AEM2_NUM_ENERGY_REGS /* AEM 2.x needs more sensor files */ #define AEM_NUM_SENSORS AEM2_NUM_SENSORS #define POWER_CAP 0 #define POWER_CAP_MAX_HOTPLUG 1 #define POWER_CAP_MAX 2 #define POWER_CAP_MIN_WARNING 3 #define POWER_CAP_MIN 4 #define POWER_AUX 5 #define AEM_DEFAULT_POWER_INTERVAL 1000 #define AEM_MIN_POWER_INTERVAL 200 #define UJ_PER_MJ 1000L static DEFINE_IDR(aem_idr); static DEFINE_SPINLOCK(aem_idr_lock); static struct platform_driver aem_driver = { .driver = { .name = DRVNAME, .bus = &platform_bus_type, } }; struct aem_ipmi_data { struct completion read_complete; struct ipmi_addr address; ipmi_user_t user; int interface; struct kernel_ipmi_msg tx_message; long tx_msgid; void *rx_msg_data; unsigned short rx_msg_len; unsigned char rx_result; int rx_recv_type; struct device *bmc_device; }; struct aem_ro_sensor_template { char *label; ssize_t (*show)(struct device *dev, struct device_attribute *devattr, char *buf); int index; }; struct aem_rw_sensor_template { char *label; ssize_t (*show)(struct device *dev, struct device_attribute *devattr, char *buf); ssize_t (*set)(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count); int index; }; struct aem_data { struct list_head list; struct device *hwmon_dev; struct platform_device *pdev; struct mutex lock; char valid; unsigned long last_updated; /* In jiffies */ u8 ver_major; u8 ver_minor; u8 module_handle; int id; struct aem_ipmi_data ipmi; /* Function to update sensors */ void (*update)(struct aem_data *data); /* * AEM 1.x sensors: * Available sensors: * Energy meter * Power meter * * AEM 2.x sensors: * Two energy meters * Two power meters * Two temperature sensors * Six power cap registers */ /* sysfs attrs */ struct sensor_device_attribute sensors[AEM_NUM_SENSORS]; /* energy use in mJ */ u64 energy[AEM_NUM_ENERGY_REGS]; /* power sampling interval in ms */ unsigned long power_period[AEM_NUM_ENERGY_REGS]; /* Everything past here is for AEM2 only */ /* power caps in dW */ u16 pcap[AEM2_NUM_PCAP_REGS]; /* exhaust temperature in C */ u8 temp[AEM2_NUM_TEMP_REGS]; }; /* Data structures returned by the AEM firmware */ struct aem_iana_id { u8 bytes[3]; }; static struct aem_iana_id system_x_id = { .bytes = {0x4D, 0x4F, 0x00} }; /* These are used to find AEM1 instances */ struct aem_find_firmware_req { struct aem_iana_id id; u8 rsvd; __be16 index; __be16 module_type_id; } __packed; struct aem_find_firmware_resp { struct aem_iana_id id; u8 num_instances; } __packed; /* These are used to find AEM2 instances */ struct aem_find_instance_req { struct aem_iana_id id; u8 instance_number; __be16 module_type_id; } __packed; struct aem_find_instance_resp { struct aem_iana_id id; u8 num_instances; u8 major; u8 minor; u8 module_handle; u16 record_id; } __packed; /* These are used to query sensors */ struct aem_read_sensor_req { struct aem_iana_id id; u8 module_handle; u8 element; u8 subcommand; u8 reg; u8 rx_buf_size; } __packed; struct aem_read_sensor_resp { struct aem_iana_id id; u8 bytes[0]; } __packed; /* Data structures to talk to the IPMI layer */ struct aem_driver_data { struct list_head aem_devices; struct ipmi_smi_watcher bmc_events; struct ipmi_user_hndl ipmi_hndlrs; }; static void aem_register_bmc(int iface, struct device *dev); static void aem_bmc_gone(int iface); static void aem_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data); static void aem_remove_sensors(struct aem_data *data); static int aem_init_aem1(struct aem_ipmi_data *probe); static int aem_init_aem2(struct aem_ipmi_data *probe); static int aem1_find_sensors(struct aem_data *data); static int aem2_find_sensors(struct aem_data *data); static void update_aem1_sensors(struct aem_data *data); static void update_aem2_sensors(struct aem_data *data); static struct aem_driver_data driver_data = { .aem_devices = LIST_HEAD_INIT(driver_data.aem_devices), .bmc_events = { .owner = THIS_MODULE, .new_smi = aem_register_bmc, .smi_gone = aem_bmc_gone, }, .ipmi_hndlrs = { .ipmi_recv_hndl = aem_msg_handler, }, }; /* Functions to talk to the IPMI layer */ /* Initialize IPMI address, message buffers and user data */ static int aem_init_ipmi_data(struct aem_ipmi_data *data, int iface, struct device *bmc) { int err; init_completion(&data->read_complete); data->bmc_device = bmc; /* Initialize IPMI address */ data->address.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; data->address.channel = IPMI_BMC_CHANNEL; data->address.data[0] = 0; data->interface = iface; /* Initialize message buffers */ data->tx_msgid = 0; data->tx_message.netfn = AEM_NETFN; /* Create IPMI messaging interface user */ err = ipmi_create_user(data->interface, &driver_data.ipmi_hndlrs, data, &data->user); if (err < 0) { dev_err(bmc, "Unable to register user with IPMI " "interface %d\n", data->interface); return -EACCES; } return 0; } /* Send an IPMI command */ static int aem_send_message(struct aem_ipmi_data *data) { int err; err = ipmi_validate_addr(&data->address, sizeof(data->address)); if (err) goto out; data->tx_msgid++; err = ipmi_request_settime(data->user, &data->address, data->tx_msgid, &data->tx_message, data, 0, 0, 0); if (err) goto out1; return 0; out1: dev_err(data->bmc_device, "request_settime=%x\n", err); return err; out: dev_err(data->bmc_device, "validate_addr=%x\n", err); return err; } /* Dispatch IPMI messages to callers */ static void aem_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data) { unsigned short rx_len; struct aem_ipmi_data *data = user_msg_data; if (msg->msgid != data->tx_msgid) { dev_err(data->bmc_device, "Mismatch between received msgid " "(%02x) and transmitted msgid (%02x)!\n", (int)msg->msgid, (int)data->tx_msgid); ipmi_free_recv_msg(msg); return; } data->rx_recv_type = msg->recv_type; if (msg->msg.data_len > 0) data->rx_result = msg->msg.data[0]; else data->rx_result = IPMI_UNKNOWN_ERR_COMPLETION_CODE; if (msg->msg.data_len > 1) { rx_len = msg->msg.data_len - 1; if (data->rx_msg_len < rx_len) rx_len = data->rx_msg_len; data->rx_msg_len = rx_len; memcpy(data->rx_msg_data, msg->msg.data + 1, data->rx_msg_len); } else data->rx_msg_len = 0; ipmi_free_recv_msg(msg); complete(&data->read_complete); } /* ID functions */ /* Obtain an id */ static int aem_idr_get(int *id) { int i, err; again: if (unlikely(!idr_pre_get(&aem_idr, GFP_KERNEL))) return -ENOMEM; spin_lock(&aem_idr_lock); err = idr_get_new(&aem_idr, NULL, &i); spin_unlock(&aem_idr_lock); if (unlikely(err == -EAGAIN)) goto again; else if (unlikely(err)) return err; *id = i & MAX_ID_MASK; return 0; } /* Release an object ID */ static void aem_idr_put(int id) { spin_lock(&aem_idr_lock); idr_remove(&aem_idr, id); spin_unlock(&aem_idr_lock); } /* Sensor support functions */ /* Read a sensor value */ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg, void *buf, size_t size) { int rs_size, res; struct aem_read_sensor_req rs_req; struct aem_read_sensor_resp *rs_resp; struct aem_ipmi_data *ipmi = &data->ipmi; /* AEM registers are 1, 2, 4 or 8 bytes */ switch (size) { case 1: case 2: case 4: case 8: break; default: return -EINVAL; } rs_req.id = system_x_id; rs_req.module_handle = data->module_handle; rs_req.element = elt; rs_req.subcommand = AEM_READ_REGISTER; rs_req.reg = reg; rs_req.rx_buf_size = size; ipmi->tx_message.cmd = AEM_ELEMENT_CMD; ipmi->tx_message.data = (char *)&rs_req; ipmi->tx_message.data_len = sizeof(rs_req); rs_size = sizeof(*rs_resp) + size; rs_resp = kzalloc(rs_size, GFP_KERNEL); if (!rs_resp) return -ENOMEM; ipmi->rx_msg_data = rs_resp; ipmi->rx_msg_len = rs_size; aem_send_message(ipmi); res = wait_for_completion_timeout(&ipmi->read_complete, IPMI_TIMEOUT); if (!res) return -ETIMEDOUT; if (ipmi->rx_result || ipmi->rx_msg_len != rs_size || memcmp(&rs_resp->id, &system_x_id, sizeof(system_x_id))) { kfree(rs_resp); return -ENOENT; } switch (size) { case 1: { u8 *x = buf; *x = rs_resp->bytes[0]; break; } case 2: { u16 *x = buf; *x = be16_to_cpup((__be16 *)rs_resp->bytes); break; } case 4: { u32 *x = buf; *x = be32_to_cpup((__be32 *)rs_resp->bytes); break; } case 8: { u64 *x = buf; *x = be64_to_cpup((__be64 *)rs_resp->bytes); break; } } return 0; } /* Update AEM energy registers */ static void update_aem_energy_one(struct aem_data *data, int which) { aem_read_sensor(data, AEM_ENERGY_ELEMENT, which, &data->energy[which], 8); } static void update_aem_energy(struct aem_data *data) { update_aem_energy_one(data, 0); if (data->ver_major < 2) return; update_aem_energy_one(data, 1); } /* Update all AEM1 sensors */ static void update_aem1_sensors(struct aem_data *data) { mutex_lock(&data->lock); if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) && data->valid) goto out; update_aem_energy(data); out: mutex_unlock(&data->lock); } /* Update all AEM2 sensors */ static void update_aem2_sensors(struct aem_data *data) { int i; mutex_lock(&data->lock); if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) && data->valid) goto out; update_aem_energy(data); aem_read_sensor(data, AEM_EXHAUST_ELEMENT, 0, &data->temp[0], 1); aem_read_sensor(data, AEM_EXHAUST_ELEMENT, 1, &data->temp[1], 1); for (i = POWER_CAP; i <= POWER_AUX; i++) aem_read_sensor(data, AEM_POWER_CAP_ELEMENT, i, &data->pcap[i], 2); out: mutex_unlock(&data->lock); } /* Delete an AEM instance */ static void aem_delete(struct aem_data *data) { list_del(&data->list); aem_remove_sensors(data); hwmon_device_unregister(data->hwmon_dev); ipmi_destroy_user(data->ipmi.user); platform_set_drvdata(data->pdev, NULL); platform_device_unregister(data->pdev); aem_idr_put(data->id); kfree(data); } /* Probe functions for AEM1 devices */ /* Retrieve version and module handle for an AEM1 instance */ static int aem_find_aem1_count(struct aem_ipmi_data *data) { int res; struct aem_find_firmware_req ff_req; struct aem_find_firmware_resp ff_resp; ff_req.id = system_x_id; ff_req.index = 0; ff_req.module_type_id = cpu_to_be16(AEM_MODULE_TYPE_ID); data->tx_message.cmd = AEM_FIND_FW_CMD; data->tx_message.data = (char *)&ff_req; data->tx_message.data_len = sizeof(ff_req); data->rx_msg_data = &ff_resp;


context:
space:
mode: