linux-yocto - Yocto Linux Embedded kernel

Age	Commit message (Collapse)	Author
2014-06-02	drm/radeon: use NULL instead of zero in clearstate headers	Michele CURTI
	Signed-off-by: Michele Curti <michele.curti@gmail.com> Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
2013-08-30	drm/radeon: convert SI,CIK to use sumo_rlc functions	Alex Deucher
	and remove duplicate si_rlc functions. Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
2013-06-27	drm/radeon: properly set up the RLC on ON/LN/TN (v3)	Alex Deucher
	This is required for certain advanced functionality. v2: save/restore list takes dword offsets v3: rebase on gpu reset changes Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

// SPDX-License-Identifier: GPL-2.0 /* * Copyright 2010 ARM Ltd. * Copyright 2012 Advanced Micro Devices, Inc., Robert Richter * * Perf-events backend for OProfile. */ #include <linux/perf_event.h> #include <linux/platform_device.h> #include <linux/oprofile.h> #include <linux/slab.h> /* * Per performance monitor configuration as set via oprofilefs. */ struct op_counter_config { unsigned long count; unsigned long enabled; unsigned long event; unsigned long unit_mask; unsigned long kernel; unsigned long user; struct perf_event_attr attr; }; static int oprofile_perf_enabled; static DEFINE_MUTEX(oprofile_perf_mutex); static struct op_counter_config *counter_config; static DEFINE_PER_CPU(struct perf_event **, perf_events); static int num_counters; /* * Overflow callback for oprofile. */ static void op_overflow_handler(struct perf_event *event, struct perf_sample_data *data, struct pt_regs *regs) { int id; u32 cpu = smp_processor_id(); for (id = 0; id < num_counters; ++id) if (per_cpu(perf_events, cpu)[id] == event) break; if (id != num_counters) oprofile_add_sample(regs, id); else pr_warning("oprofile: ignoring spurious overflow " "on cpu %u\n", cpu); } /* * Called by oprofile_perf_setup to create perf attributes to mirror the oprofile * settings in counter_config. Attributes are created as `pinned' events and * so are permanently scheduled on the PMU. */ static void op_perf_setup(void) { int i; u32 size = sizeof(struct perf_event_attr); struct perf_event_attr *attr; for (i = 0; i < num_counters; ++i) { attr = &counter_config[i].attr; memset(attr, 0, size); attr->type = PERF_TYPE_RAW; attr->size = size; attr->config = counter_config[i].event; attr->sample_period = counter_config[i].count; attr->pinned = 1; } } static int op_create_counter(int cpu, int event) { struct perf_event *pevent; if (!counter_config[event].enabled || per_cpu(perf_events, cpu)[event]) return 0; pevent = perf_event_create_kernel_counter(&counter_config[event].attr, cpu, NULL, op_overflow_handler, NULL); if (IS_ERR(pevent)) return PTR_ERR(pevent); if (pevent->state != PERF_EVENT_STATE_ACTIVE) { perf_event_release_kernel(pevent); pr_warning("oprofile: failed to enable event %d " "on CPU %d\n", event, cpu); return -EBUSY; } per_cpu(perf_events, cpu)[event] = pevent; return 0; } static void op_destroy_counter(int cpu, int event) { struct perf_event *pevent = per_cpu(perf_events, cpu)[event]; if (pevent) { perf_event_release_kernel(pevent); per_cpu(perf_events, cpu)[event] = NULL; } } /* * Called by oprofile_perf_start to create active perf events based on the * perviously configured attributes. */ static int op_perf_start(void) { int cpu, event, ret = 0; for_each_online_cpu(cpu) { for (event = 0; event < num_counters; ++event) { ret = op_create_counter(cpu, event); if (ret) return ret; } } return ret; } /* * Called by oprofile_perf_stop at the end of a profiling run. */ static void op_perf_stop(void) { int cpu, event; for_each_online_cpu(cpu) for (event = 0; event < num_counters; ++event) op_destroy_counter(cpu, event); } static int oprofile_perf_create_files(struct dentry *root) { unsigned int i; for (i = 0; i < num_counters; i++) { struct dentry *dir; char buf[4]; snprintf(buf, sizeof buf, "%d", i); dir = oprofilefs_mkdir(root, buf); oprofilefs_create_ulong(dir, "enabled", &counter_config[i].enabled); oprofilefs_create_ulong(dir, "event", &counter_config[i].event); oprofilefs_create_ulong(dir, "count", &counter_config[i].count); oprofilefs_create_ulong(dir, "unit_mask", &counter_config[i].unit_mask); oprofilefs_create_ulong(dir, "kernel", &counter_config[i].kernel); oprofilefs_create_ulong(dir, "user", &counter_config[i].user); } return 0; } static int oprofile_perf_setup(void) { raw_spin_lock(&oprofilefs_lock); op_perf_setup(); raw_spin_unlock(&oprofilefs_lock); return 0; } static int oprofile_perf_start(void) { int ret = -EBUSY; mutex_lock(&oprofile_perf_mutex); if (!oprofile_perf_enabled) { ret = 0; op_perf_start(); oprofile_perf_enabled = 1; } mutex_unlock(&oprofile_perf_mutex); return ret; } static void oprofile_perf_stop(void) { mutex_lock(&oprofile_perf_mutex); if (oprofile_perf_enabled) op_perf_stop(); oprofile_perf_enabled = 0; mutex_unlock(&oprofile_perf_mutex); } #ifdef CONFIG_PM static int oprofile_perf_suspend(struct platform_device *dev, pm_message_t state) { mutex_lock(&oprofile_perf_mutex); if (oprofile_perf_enabled) op_perf_stop(); mutex_unlock(&oprofile_perf_mutex); return 0; } static int oprofile_perf_resume(struct platform_device *dev) { mutex_lock(&oprofile_perf_mutex); if (oprofile_perf_enabled && op_perf_start()) oprofile_perf_enabled = 0; mutex_unlock(&oprofile_perf_mutex); return 0; } static struct platform_driver oprofile_driver = { .driver = { .name = "oprofile-perf", }, .resume = oprofile_perf_resume, .suspend = oprofile_perf_suspend, }; static struct platform_device *oprofile_pdev; static int __init init_driverfs(void) { int ret; ret = platform_driver_register(&oprofile_driver); if (ret) return ret; oprofile_pdev = platform_device_register_simple( oprofile_driver.driver.name, 0, NULL, 0); if (IS_ERR(oprofile_pdev)) { ret = PTR_ERR(oprofile_pdev); platform_driver_unregister(&oprofile_driver); } return ret; } static void exit_driverfs(void) { platform_device_unregister(oprofile_pdev); platform_driver_unregister(&oprofile_driver); } #else static inline int init_driverfs(void) { return 0; } static inline void exit_driverfs(void) { } #endif /* CONFIG_PM */ void oprofile_perf_exit(void) { int cpu, id; struct perf_event *event; for_each_possible_cpu(cpu) { for (id = 0; id < num_counters; ++id) { event = per_cpu(perf_events, cpu)[id]; if (event) perf_event_release_kernel(event); } kfree(per_cpu(perf_events, cpu)); } kfree(counter_config); exit_driverfs(); } int __init oprofile_perf_init(struct oprofile_operations *ops) { int cpu, ret = 0; ret = init_driverfs(); if (ret) return ret; num_counters = perf_num_counters(); if (num_counters <= 0) { pr_info("oprofile: no performance counters\n"); ret = -ENODEV; goto out; } counter_config = kcalloc(num_counters, sizeof(struct op_counter_config), GFP_KERNEL); if (!counter_config) { pr_info("oprofile: failed to allocate %d " "counters\n", num_counters); ret = -ENOMEM; num_counters = 0; goto out; } for_each_possible_cpu(cpu) { per_cpu(perf_events, cpu) = kcalloc(num_counters, sizeof(struct perf_event *), GFP_KERNEL); if (!per_cpu(perf_events, cpu)) { pr_info("oprofile: failed to allocate %d perf events " "for cpu %d\n", num_counters, cpu); ret = -ENOMEM; goto out; } } ops->create_files = oprofile_perf_create_files; ops->setup = oprofile_perf_setup; ops->start = oprofile_perf_start; ops->stop = oprofile_perf_stop; ops->shutdown = oprofile_perf_stop; ops->cpu_type = op_name_from_perf_id(); if (!ops->cpu_type) ret = -ENODEV; else pr_info("oprofile: using %s\n", ops->cpu_type); out: if (ret) oprofile_perf_exit(); return ret; }