*************************************************** tracking-big-LITTLE-MP-v10 has 16 conflicts -------------------------------------------------- diff --cc arch/arm/include/asm/perf_event.h index 625cd62,00416ed..0000000 --- a/arch/arm/include/asm/perf_event.h +++ b/arch/arm/include/asm/perf_event.h @@@ -20,5 -20,10 +20,13 @@@ #define HW_OP_UNSUPPORTED 0xFFFF #define C(_x) PERF_COUNT_HW_CACHE_##_x #define CACHE_OP_UNSUPPORTED 0xFFFF ++<<<<<<< HEAD ++======= + + struct pt_regs; + extern unsigned long perf_instruction_pointer(struct pt_regs *regs); + extern unsigned long perf_misc_flags(struct pt_regs *regs); + #define perf_misc_flags(regs) perf_misc_flags(regs) ++>>>>>>> tracking-big-LITTLE-MP-v10 #endif /* __ARM_PERF_EVENT_H__ */ -------------------------------------------------- diff --cc arch/arm/include/asm/pmu.h index a26170d,0cd7824..0000000 --- a/arch/arm/include/asm/pmu.h +++ b/arch/arm/include/asm/pmu.h @@@ -65,22 -74,25 +74,30 @@@ struct cpupmu_regs struct arm_pmu { struct pmu pmu; cpumask_t active_irqs; + cpumask_t valid_cpus; char *name; irqreturn_t (*handle_irq)(int irq_num, void *dev); - void (*enable)(struct hw_perf_event *evt, int idx); - void (*disable)(struct hw_perf_event *evt, int idx); + void (*enable)(struct perf_event *event); + void (*disable)(struct perf_event *event); int (*get_event_idx)(struct pmu_hw_events *hw_events, - struct hw_perf_event *hwc); + struct perf_event *event); int (*set_event_filter)(struct hw_perf_event *evt, struct perf_event_attr *attr); - u32 (*read_counter)(int idx); - void (*write_counter)(int idx, u32 val); - void (*start)(void); - void (*stop)(void); + u32 (*read_counter)(struct perf_event *event); + void (*write_counter)(struct perf_event *event, u32 val); + void (*start)(struct arm_pmu *); + void (*stop)(struct arm_pmu *); void (*reset)(void *); ++<<<<<<< HEAD + int (*request_irq)(irq_handler_t handler); + void (*free_irq)(void); ++======= + int (*request_irq)(struct arm_pmu *, irq_handler_t handler); + void (*free_irq)(struct arm_pmu *); ++>>>>>>> tracking-big-LITTLE-MP-v10 int (*map_event)(struct perf_event *event); + void (*save_regs)(struct arm_pmu *, struct cpupmu_regs *); + void (*restore_regs)(struct arm_pmu *, struct cpupmu_regs *); int num_events; atomic_t active_events; struct mutex reserve_mutex; @@@ -93,23 -105,19 +110,30 @@@ extern const struct dev_pm_ops armpmu_dev_pm_ops; ++<<<<<<< HEAD +int armpmu_register(struct arm_pmu *armpmu, char *name, int type); ++======= + int armpmu_register(struct arm_pmu *armpmu, int type); + + u64 armpmu_event_update(struct perf_event *event); ++>>>>>>> tracking-big-LITTLE-MP-v10 - u64 armpmu_event_update(struct perf_event *event, - struct hw_perf_event *hwc, - int idx); + int armpmu_event_set_period(struct perf_event *event); - int armpmu_event_set_period(struct perf_event *event, - struct hw_perf_event *hwc, - int idx); + int armpmu_map_event(struct perf_event *event, + const unsigned (*event_map)[PERF_COUNT_HW_MAX], + const unsigned (*cache_map)[PERF_COUNT_HW_CACHE_MAX] + [PERF_COUNT_HW_CACHE_OP_MAX] + [PERF_COUNT_HW_CACHE_RESULT_MAX], + u32 raw_event_mask); +int armpmu_map_event(struct perf_event *event, + const unsigned (*event_map)[PERF_COUNT_HW_MAX], + const unsigned (*cache_map)[PERF_COUNT_HW_CACHE_MAX] + [PERF_COUNT_HW_CACHE_OP_MAX] + [PERF_COUNT_HW_CACHE_RESULT_MAX], + u32 raw_event_mask); + #endif /* CONFIG_HW_PERF_EVENTS */ #endif /* __ARM_PMU_H__ */ -------------------------------------------------- diff --cc arch/arm/kernel/perf_event.c index 93971b1,e90b2a7..0000000 --- a/arch/arm/kernel/perf_event.c +++ b/arch/arm/kernel/perf_event.c @@@ -12,6 -12,7 +12,10 @@@ */ #define pr_fmt(fmt) "hw perfevents: " fmt ++<<<<<<< HEAD ++======= + #include ++>>>>>>> tracking-big-LITTLE-MP-v10 #include #include #include @@@ -169,8 -171,8 +174,13 @@@ armpmu_stop(struct perf_event *event, i * PERF_EF_UPDATE, see comments in armpmu_start(). */ if (!(hwc->state & PERF_HES_STOPPED)) { ++<<<<<<< HEAD + armpmu->disable(hwc, hwc->idx); + armpmu_event_update(event, hwc, hwc->idx); ++======= + armpmu->disable(event); + armpmu_event_update(event); ++>>>>>>> tracking-big-LITTLE-MP-v10 hwc->state |= PERF_HES_STOPPED | PERF_HES_UPTODATE; } } @@@ -312,7 -321,7 +329,11 @@@ static irqreturn_t armpmu_dispatch_irq( static void armpmu_release_hardware(struct arm_pmu *armpmu) { ++<<<<<<< HEAD + armpmu->free_irq(); ++======= + armpmu->free_irq(armpmu); ++>>>>>>> tracking-big-LITTLE-MP-v10 pm_runtime_put_sync(&armpmu->plat_device->dev); } @@@ -326,7 -335,7 +347,11 @@@ armpmu_reserve_hardware(struct arm_pmu return -ENODEV; pm_runtime_get_sync(&pmu_device->dev); ++<<<<<<< HEAD + err = armpmu->request_irq(armpmu_dispatch_irq); ++======= + err = armpmu->request_irq(armpmu, armpmu_dispatch_irq); ++>>>>>>> tracking-big-LITTLE-MP-v10 if (err) { armpmu_release_hardware(armpmu); return err; @@@ -513,12 -526,12 +542,20 @@@ static void __init armpmu_init(struct a }; } ++<<<<<<< HEAD +int armpmu_register(struct arm_pmu *armpmu, char *name, int type) ++======= + int armpmu_register(struct arm_pmu *armpmu, int type) ++>>>>>>> tracking-big-LITTLE-MP-v10 { armpmu_init(armpmu); pr_info("enabled with %s PMU driver, %d counters available\n", armpmu->name, armpmu->num_events); ++<<<<<<< HEAD + return perf_pmu_register(&armpmu->pmu, name, type); ++======= + return perf_pmu_register(&armpmu->pmu, armpmu->name, type); ++>>>>>>> tracking-big-LITTLE-MP-v10 } /* -------------------------------------------------- diff --cc arch/arm/kernel/perf_event_cpu.c index 8d7d8d4,66248ee..0000000 --- a/arch/arm/kernel/perf_event_cpu.c +++ b/arch/arm/kernel/perf_event_cpu.c @@@ -19,10 -19,12 +19,18 @@@ #define pr_fmt(fmt) "CPU PMU: " fmt #include ++<<<<<<< HEAD ++======= + #include ++>>>>>>> tracking-big-LITTLE-MP-v10 #include #include #include #include ++<<<<<<< HEAD ++======= + #include ++>>>>>>> tracking-big-LITTLE-MP-v10 #include #include @@@ -30,33 -32,36 +38,59 @@@ #include /* Set at runtime when we know what CPU type we are. */ ++<<<<<<< HEAD +static struct arm_pmu *cpu_pmu; ++======= + static DEFINE_PER_CPU(struct arm_pmu *, cpu_pmu); ++>>>>>>> tracking-big-LITTLE-MP-v10 static DEFINE_PER_CPU(struct perf_event * [ARMPMU_MAX_HWEVENTS], hw_events); static DEFINE_PER_CPU(unsigned long [BITS_TO_LONGS(ARMPMU_MAX_HWEVENTS)], used_mask); static DEFINE_PER_CPU(struct pmu_hw_events, cpu_hw_events); ++<<<<<<< HEAD ++======= + static DEFINE_PER_CPU(struct cpupmu_regs, cpu_pmu_regs); + ++>>>>>>> tracking-big-LITTLE-MP-v10 /* * Despite the names, these two functions are CPU-specific and are used * by the OProfile/perf code. */ const char *perf_pmu_name(void) { ++<<<<<<< HEAD + if (!cpu_pmu) + return NULL; + + return cpu_pmu->pmu.name; ++======= + struct arm_pmu *pmu = per_cpu(cpu_pmu, 0); + if (!pmu) + return NULL; + + return pmu->name; ++>>>>>>> tracking-big-LITTLE-MP-v10 } EXPORT_SYMBOL_GPL(perf_pmu_name); int perf_num_counters(void) { ++<<<<<<< HEAD + int max_events = 0; + + if (cpu_pmu != NULL) + max_events = cpu_pmu->num_events; + + return max_events; ++======= + struct arm_pmu *pmu = per_cpu(cpu_pmu, 0); + + if (!pmu) + return 0; + + return pmu->num_events; ++>>>>>>> tracking-big-LITTLE-MP-v10 } EXPORT_SYMBOL_GPL(perf_num_counters); @@@ -70,15 -75,17 +104,28 @@@ static struct pmu_hw_events *cpu_pmu_ge return &__get_cpu_var(cpu_hw_events); } ++<<<<<<< HEAD +static void cpu_pmu_free_irq(void) +{ + int i, irq, irqs; + struct platform_device *pmu_device = cpu_pmu->plat_device; ++======= + static void cpu_pmu_free_irq(struct arm_pmu *cpu_pmu) + { + int i, irq, irqs; + struct platform_device *pmu_device = cpu_pmu->plat_device; + int cpu = -1; ++>>>>>>> tracking-big-LITTLE-MP-v10 irqs = min(pmu_device->num_resources, num_possible_cpus()); for (i = 0; i < irqs; ++i) { ++<<<<<<< HEAD + if (!cpumask_test_and_clear_cpu(i, &cpu_pmu->active_irqs)) ++======= + cpu = cpumask_next(cpu, &cpu_pmu->valid_cpus); + if (!cpumask_test_and_clear_cpu(cpu, &cpu_pmu->active_irqs)) ++>>>>>>> tracking-big-LITTLE-MP-v10 continue; irq = platform_get_irq(pmu_device, i); if (irq >= 0) @@@ -86,10 -93,11 +133,18 @@@ } } ++<<<<<<< HEAD +static int cpu_pmu_request_irq(irq_handler_t handler) +{ + int i, err, irq, irqs; + struct platform_device *pmu_device = cpu_pmu->plat_device; ++======= + static int cpu_pmu_request_irq(struct arm_pmu *cpu_pmu, irq_handler_t handler) + { + int i, err, irq, irqs; + struct platform_device *pmu_device = cpu_pmu->plat_device; + int cpu = -1; ++>>>>>>> tracking-big-LITTLE-MP-v10 if (!pmu_device) return -ENODEV; @@@ -102,6 -110,7 +157,10 @@@ for (i = 0; i < irqs; ++i) { err = 0; ++<<<<<<< HEAD ++======= + cpu = cpumask_next(cpu, &cpu_pmu->valid_cpus); ++>>>>>>> tracking-big-LITTLE-MP-v10 irq = platform_get_irq(pmu_device, i); if (irq < 0) continue; @@@ -111,7 -120,7 +170,11 @@@ * assume that we're running on a uniprocessor machine and * continue. Otherwise, continue without this interrupt. */ ++<<<<<<< HEAD + if (irq_set_affinity(irq, cpumask_of(i)) && irqs > 1) { ++======= + if (irq_set_affinity(irq, cpumask_of(cpu)) && irqs > 1) { ++>>>>>>> tracking-big-LITTLE-MP-v10 pr_warning("unable to set irq affinity (irq=%d, cpu=%u)\n", irq, i); continue; @@@ -125,7 -134,7 +188,11 @@@ return err; } ++<<<<<<< HEAD + cpumask_set_cpu(i, &cpu_pmu->active_irqs); ++======= + cpumask_set_cpu(cpu, &cpu_pmu->active_irqs); ++>>>>>>> tracking-big-LITTLE-MP-v10 } return 0; @@@ -134,7 -143,7 +201,11 @@@ static void __devinit cpu_pmu_init(struct arm_pmu *cpu_pmu) { int cpu; ++<<<<<<< HEAD + for_each_possible_cpu(cpu) { ++======= + for_each_cpu_mask(cpu, cpu_pmu->valid_cpus) { ++>>>>>>> tracking-big-LITTLE-MP-v10 struct pmu_hw_events *events = &per_cpu(cpu_hw_events, cpu); events->events = per_cpu(hw_events, cpu); events->used_mask = per_cpu(used_mask, cpu); @@@ -147,7 -156,7 +218,11 @@@ /* Ensure the PMU has sane values out of reset. */ if (cpu_pmu && cpu_pmu->reset) ++<<<<<<< HEAD + on_each_cpu(cpu_pmu->reset, NULL, 1); ++======= + on_each_cpu_mask(&cpu_pmu->valid_cpus, cpu_pmu->reset, cpu_pmu, 1); ++>>>>>>> tracking-big-LITTLE-MP-v10 } /* @@@ -159,11 -168,34 +234,42 @@@ static int __cpuinit cpu_pmu_notify(struct notifier_block *b, unsigned long action, void *hcpu) { ++<<<<<<< HEAD + if ((action & ~CPU_TASKS_FROZEN) != CPU_STARTING) + return NOTIFY_DONE; + + if (cpu_pmu && cpu_pmu->reset) + cpu_pmu->reset(NULL); ++======= + struct arm_pmu *pmu = per_cpu(cpu_pmu, (long)hcpu); + + if ((action & ~CPU_TASKS_FROZEN) != CPU_STARTING) + return NOTIFY_DONE; + + if (pmu && pmu->reset) + pmu->reset(pmu); + else + return NOTIFY_DONE; + + return NOTIFY_OK; + } + + static int cpu_pmu_pm_notify(struct notifier_block *b, + unsigned long action, void *hcpu) + { + int cpu = smp_processor_id(); + struct arm_pmu *pmu = per_cpu(cpu_pmu, cpu); + struct cpupmu_regs *pmuregs = &per_cpu(cpu_pmu_regs, cpu); + + if (!pmu) + return NOTIFY_DONE; + + if (action == CPU_PM_ENTER && pmu->save_regs) { + pmu->save_regs(pmu, pmuregs); + } else if (action == CPU_PM_EXIT && pmu->restore_regs) { + pmu->restore_regs(pmu, pmuregs); + } ++>>>>>>> tracking-big-LITTLE-MP-v10 return NOTIFY_OK; } @@@ -172,6 -204,10 +278,13 @@@ static struct notifier_block __cpuinitd .notifier_call = cpu_pmu_notify, }; ++<<<<<<< HEAD ++======= + static struct notifier_block __cpuinitdata cpu_pmu_pm_notifier = { + .notifier_call = cpu_pmu_pm_notify, + }; + ++>>>>>>> tracking-big-LITTLE-MP-v10 /* * PMU platform driver and devicetree bindings. */ @@@ -195,13 -231,13 +308,22 @@@ static struct platform_device_id __devi /* * CPU PMU identification and probing. */ ++<<<<<<< HEAD +static struct arm_pmu *__devinit probe_current_pmu(void) +{ + struct arm_pmu *pmu = NULL; ++======= + static int __devinit probe_current_pmu(struct arm_pmu *pmu) + { ++>>>>>>> tracking-big-LITTLE-MP-v10 int cpu = get_cpu(); unsigned long cpuid = read_cpuid_id(); unsigned long implementor = (cpuid & 0xFF000000) >> 24; unsigned long part_number = (cpuid & 0xFFF0); ++<<<<<<< HEAD ++======= + int ret = -ENODEV; ++>>>>>>> tracking-big-LITTLE-MP-v10 pr_info("probing PMU on CPU %d\n", cpu); @@@ -211,25 -247,25 +333,47 @@@ case 0xB360: /* ARM1136 */ case 0xB560: /* ARM1156 */ case 0xB760: /* ARM1176 */ ++<<<<<<< HEAD + pmu = armv6pmu_init(); + break; + case 0xB020: /* ARM11mpcore */ + pmu = armv6mpcore_pmu_init(); + break; + case 0xC080: /* Cortex-A8 */ + pmu = armv7_a8_pmu_init(); + break; + case 0xC090: /* Cortex-A9 */ + pmu = armv7_a9_pmu_init(); + break; + case 0xC050: /* Cortex-A5 */ + pmu = armv7_a5_pmu_init(); + break; + case 0xC0F0: /* Cortex-A15 */ + pmu = armv7_a15_pmu_init(); + break; + case 0xC070: /* Cortex-A7 */ + pmu = armv7_a7_pmu_init(); ++======= + ret = armv6pmu_init(pmu); + break; + case 0xB020: /* ARM11mpcore */ + ret = armv6mpcore_pmu_init(pmu); + break; + case 0xC080: /* Cortex-A8 */ + ret = armv7_a8_pmu_init(pmu); + break; + case 0xC090: /* Cortex-A9 */ + ret = armv7_a9_pmu_init(pmu); + break; + case 0xC050: /* Cortex-A5 */ + ret = armv7_a5_pmu_init(pmu); + break; + case 0xC0F0: /* Cortex-A15 */ + ret = armv7_a15_pmu_init(pmu); + break; + case 0xC070: /* Cortex-A7 */ + ret = armv7_a7_pmu_init(pmu); ++>>>>>>> tracking-big-LITTLE-MP-v10 break; } /* Intel CPUs [xscale]. */ @@@ -237,43 -273,74 +381,111 @@@ part_number = (cpuid >> 13) & 0x7; switch (part_number) { case 1: ++<<<<<<< HEAD + pmu = xscale1pmu_init(); + break; + case 2: + pmu = xscale2pmu_init(); ++======= + ret = xscale1pmu_init(pmu); + break; + case 2: + ret = xscale2pmu_init(pmu); ++>>>>>>> tracking-big-LITTLE-MP-v10 break; } } ++<<<<<<< HEAD + put_cpu(); + return pmu; ++======= + /* assume PMU support all the CPUs in this case */ + cpumask_setall(&pmu->valid_cpus); + + put_cpu(); + return ret; ++>>>>>>> tracking-big-LITTLE-MP-v10 } static int __devinit cpu_pmu_device_probe(struct platform_device *pdev) { const struct of_device_id *of_id; ++<<<<<<< HEAD + struct arm_pmu *(*init_fn)(void); + struct device_node *node = pdev->dev.of_node; + + if (cpu_pmu) { + pr_info("attempt to register multiple PMU devices!"); + return -ENOSPC; + } + + if (node && (of_id = of_match_node(cpu_pmu_of_device_ids, pdev->dev.of_node))) { + init_fn = of_id->data; + cpu_pmu = init_fn(); + } else { + cpu_pmu = probe_current_pmu(); + } + + if (!cpu_pmu) + return -ENODEV; + + cpu_pmu->plat_device = pdev; + cpu_pmu_init(cpu_pmu); + register_cpu_notifier(&cpu_pmu_hotplug_notifier); + armpmu_register(cpu_pmu, cpu_pmu->name, PERF_TYPE_RAW); ++======= + struct device_node *node = pdev->dev.of_node; + struct arm_pmu *pmu; + int ret = 0; + int cpu; + + pmu = kzalloc(sizeof(struct arm_pmu), GFP_KERNEL); + if (!pmu) { + pr_info("failed to allocate PMU device!"); + return -ENOMEM; + } + + if (node && (of_id = of_match_node(cpu_pmu_of_device_ids, pdev->dev.of_node))) { + smp_call_func_t init_fn = (smp_call_func_t)of_id->data; + struct device_node *ncluster; + int cluster = -1; + cpumask_t sibling_mask; + + ncluster = of_parse_phandle(node, "cluster", 0); + if (ncluster) { + int len; + const u32 *hwid; + hwid = of_get_property(ncluster, "reg", &len); + if (hwid && len == 4) + cluster = be32_to_cpup(hwid); + } + /* set sibling mask to all cpu mask if socket is not specified */ + if (cluster == -1 || + cluster_to_logical_mask(cluster, &sibling_mask)) + cpumask_setall(&sibling_mask); + + smp_call_function_any(&sibling_mask, init_fn, pmu, 1); + + /* now set the valid_cpus after init */ + cpumask_copy(&pmu->valid_cpus, &sibling_mask); + } else { + ret = probe_current_pmu(pmu); + } + + if (ret) { + pr_info("failed to register PMU devices!"); + kfree(pmu); + return ret; + } + + for_each_cpu_mask(cpu, pmu->valid_cpus) + per_cpu(cpu_pmu, cpu) = pmu; + + pmu->plat_device = pdev; + cpu_pmu_init(pmu); + armpmu_register(pmu, -1); ++>>>>>>> tracking-big-LITTLE-MP-v10 return 0; } @@@ -290,6 -357,24 +502,28 @@@ static struct platform_driver cpu_pmu_d static int __init register_pmu_driver(void) { ++<<<<<<< HEAD + return platform_driver_register(&cpu_pmu_driver); ++======= + int err; + + err = register_cpu_notifier(&cpu_pmu_hotplug_notifier); + if (err) + return err; + + err = cpu_pm_register_notifier(&cpu_pmu_pm_notifier); + if (err) { + unregister_cpu_notifier(&cpu_pmu_hotplug_notifier); + return err; + } + + err = platform_driver_register(&cpu_pmu_driver); + if (err) { + cpu_pm_unregister_notifier(&cpu_pmu_pm_notifier); + unregister_cpu_notifier(&cpu_pmu_hotplug_notifier); + } + + return err; ++>>>>>>> tracking-big-LITTLE-MP-v10 } device_initcall(register_pmu_driver); -------------------------------------------------- diff --cc arch/arm/kernel/perf_event_v6.c index 6ccc079,b4b0c08..0000000 --- a/arch/arm/kernel/perf_event_v6.c +++ b/arch/arm/kernel/perf_event_v6.c @@@ -649,24 -653,24 +653,43 @@@ static int armv6_map_event(struct perf_ &armv6_perf_cache_map, 0xFF); } ++<<<<<<< HEAD +static struct arm_pmu armv6pmu = { + .name = "v6", + .handle_irq = armv6pmu_handle_irq, + .enable = armv6pmu_enable_event, + .disable = armv6pmu_disable_event, + .read_counter = armv6pmu_read_counter, + .write_counter = armv6pmu_write_counter, + .get_event_idx = armv6pmu_get_event_idx, + .start = armv6pmu_start, + .stop = armv6pmu_stop, + .map_event = armv6_map_event, + .num_events = 3, + .max_period = (1LLU << 32) - 1, +}; + +static struct arm_pmu *__devinit armv6pmu_init(void) ++======= + static int __devinit armv6pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return &armv6pmu; + *cpu_pmu = (struct arm_pmu) { + .name = "v6", + .handle_irq = armv6pmu_handle_irq, + .enable = armv6pmu_enable_event, + .disable = armv6pmu_disable_event, + .read_counter = armv6pmu_read_counter, + .write_counter = armv6pmu_write_counter, + .get_event_idx = armv6pmu_get_event_idx, + .start = armv6pmu_start, + .stop = armv6pmu_stop, + .map_event = armv6_map_event, + .num_events = 3, + .max_period = (1LLU << 32) - 1, + }; + + return 0; } /* @@@ -683,33 -687,33 +706,60 @@@ static int armv6mpcore_map_event(struc &armv6mpcore_perf_cache_map, 0xFF); } ++<<<<<<< HEAD +static struct arm_pmu armv6mpcore_pmu = { + .name = "v6mpcore", + .handle_irq = armv6pmu_handle_irq, + .enable = armv6pmu_enable_event, + .disable = armv6mpcore_pmu_disable_event, + .read_counter = armv6pmu_read_counter, + .write_counter = armv6pmu_write_counter, + .get_event_idx = armv6pmu_get_event_idx, + .start = armv6pmu_start, + .stop = armv6pmu_stop, + .map_event = armv6mpcore_map_event, + .num_events = 3, + .max_period = (1LLU << 32) - 1, +}; + +static struct arm_pmu *__devinit armv6mpcore_pmu_init(void) ++======= + static int __devinit armv6mpcore_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return &armv6mpcore_pmu; + *cpu_pmu = (struct arm_pmu) { + .name = "v6mpcore", + .handle_irq = armv6pmu_handle_irq, + .enable = armv6pmu_enable_event, + .disable = armv6mpcore_pmu_disable_event, + .read_counter = armv6pmu_read_counter, + .write_counter = armv6pmu_write_counter, + .get_event_idx = armv6pmu_get_event_idx, + .start = armv6pmu_start, + .stop = armv6pmu_stop, + .map_event = armv6mpcore_map_event, + .num_events = 3, + .max_period = (1LLU << 32) - 1, + }; + + return 0; } #else ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv6pmu_init(void) ++======= + static int armv6pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv6mpcore_pmu_init(void) ++======= + static int armv6mpcore_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } #endif /* CONFIG_CPU_V6 || CONFIG_CPU_V6K */ -------------------------------------------------- diff --cc arch/arm/kernel/perf_event_v7.c index bd4b090,3565d80..0000000 --- a/arch/arm/kernel/perf_event_v7.c +++ b/arch/arm/kernel/perf_event_v7.c @@@ -1256,70 -1286,75 +1286,115 @@@ static u32 __devinit armv7_read_num_pmn return nb_cnt + 1; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a8_pmu_init(void) ++======= + static int __devinit armv7_a8_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - armv7pmu.name = "ARMv7 Cortex-A8"; - armv7pmu.map_event = armv7_a8_map_event; - armv7pmu.num_events = armv7_read_num_pmnc_events(); - return &armv7pmu; + armv7pmu_init(cpu_pmu); + cpu_pmu->name = "ARMv7_Cortex_A8"; + cpu_pmu->map_event = armv7_a8_map_event; + cpu_pmu->num_events = armv7_read_num_pmnc_events(); + return 0; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a9_pmu_init(void) ++======= + static int __devinit armv7_a9_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - armv7pmu.name = "ARMv7 Cortex-A9"; - armv7pmu.map_event = armv7_a9_map_event; - armv7pmu.num_events = armv7_read_num_pmnc_events(); - return &armv7pmu; + armv7pmu_init(cpu_pmu); + cpu_pmu->name = "ARMv7_Cortex_A9"; + cpu_pmu->map_event = armv7_a9_map_event; + cpu_pmu->num_events = armv7_read_num_pmnc_events(); + return 0; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a5_pmu_init(void) ++======= + static int __devinit armv7_a5_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - armv7pmu.name = "ARMv7 Cortex-A5"; - armv7pmu.map_event = armv7_a5_map_event; - armv7pmu.num_events = armv7_read_num_pmnc_events(); - return &armv7pmu; + armv7pmu_init(cpu_pmu); + cpu_pmu->name = "ARMv7_Cortex_A5"; + cpu_pmu->map_event = armv7_a5_map_event; + cpu_pmu->num_events = armv7_read_num_pmnc_events(); + return 0; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a15_pmu_init(void) ++======= + static int __devinit armv7_a15_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - armv7pmu.name = "ARMv7 Cortex-A15"; - armv7pmu.map_event = armv7_a15_map_event; - armv7pmu.num_events = armv7_read_num_pmnc_events(); - armv7pmu.set_event_filter = armv7pmu_set_event_filter; - return &armv7pmu; + armv7pmu_init(cpu_pmu); + cpu_pmu->name = "ARMv7_Cortex_A15"; + cpu_pmu->map_event = armv7_a15_map_event; + cpu_pmu->num_events = armv7_read_num_pmnc_events(); + cpu_pmu->set_event_filter = armv7pmu_set_event_filter; + return 0; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a7_pmu_init(void) ++======= + static int __devinit armv7_a7_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - armv7pmu.name = "ARMv7 Cortex-A7"; - armv7pmu.map_event = armv7_a7_map_event; - armv7pmu.num_events = armv7_read_num_pmnc_events(); - armv7pmu.set_event_filter = armv7pmu_set_event_filter; - return &armv7pmu; + armv7pmu_init(cpu_pmu); + cpu_pmu->name = "ARMv7_Cortex_A7"; + cpu_pmu->map_event = armv7_a7_map_event; + cpu_pmu->num_events = armv7_read_num_pmnc_events(); + cpu_pmu->set_event_filter = armv7pmu_set_event_filter; + return 0; } #else ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a8_pmu_init(void) ++======= + static inline int armv7_a8_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a9_pmu_init(void) ++======= + static inline int armv7_a9_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a5_pmu_init(void) ++======= + static inline int armv7_a5_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a15_pmu_init(void) ++======= + static inline int armv7_a15_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit armv7_a7_pmu_init(void) ++======= + static inline int armv7_a7_pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } #endif /* CONFIG_CPU_V7 */ -------------------------------------------------- diff --cc arch/arm/kernel/perf_event_xscale.c index 426e19f,1d3e1bf..0000000 --- a/arch/arm/kernel/perf_event_xscale.c +++ b/arch/arm/kernel/perf_event_xscale.c @@@ -434,24 -440,24 +440,43 @@@ static int xscale_map_event(struct perf &xscale_perf_cache_map, 0xFF); } ++<<<<<<< HEAD +static struct arm_pmu xscale1pmu = { + .name = "xscale1", + .handle_irq = xscale1pmu_handle_irq, + .enable = xscale1pmu_enable_event, + .disable = xscale1pmu_disable_event, + .read_counter = xscale1pmu_read_counter, + .write_counter = xscale1pmu_write_counter, + .get_event_idx = xscale1pmu_get_event_idx, + .start = xscale1pmu_start, + .stop = xscale1pmu_stop, + .map_event = xscale_map_event, + .num_events = 3, + .max_period = (1LLU << 32) - 1, +}; + +static struct arm_pmu *__devinit xscale1pmu_init(void) - { - return &xscale1pmu; ++======= + static int __devinit xscale1pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 + { + *cpu_pmu = (struct arm_pmu) { + .name = "xscale1", + .handle_irq = xscale1pmu_handle_irq, + .enable = xscale1pmu_enable_event, + .disable = xscale1pmu_disable_event, + .read_counter = xscale1pmu_read_counter, + .write_counter = xscale1pmu_write_counter, + .get_event_idx = xscale1pmu_get_event_idx, + .start = xscale1pmu_start, + .stop = xscale1pmu_stop, + .map_event = xscale_map_event, + .num_events = 3, + .max_period = (1LLU << 32) - 1, + }; + + return 0; } #define XSCALE2_OVERFLOWED_MASK 0x01f @@@ -801,33 -812,33 +831,60 @@@ static inline void xscale2pmu_write_cou } } ++<<<<<<< HEAD +static struct arm_pmu xscale2pmu = { + .name = "xscale2", + .handle_irq = xscale2pmu_handle_irq, + .enable = xscale2pmu_enable_event, + .disable = xscale2pmu_disable_event, + .read_counter = xscale2pmu_read_counter, + .write_counter = xscale2pmu_write_counter, + .get_event_idx = xscale2pmu_get_event_idx, + .start = xscale2pmu_start, + .stop = xscale2pmu_stop, + .map_event = xscale_map_event, + .num_events = 5, + .max_period = (1LLU << 32) - 1, +}; + +static struct arm_pmu *__devinit xscale2pmu_init(void) - { - return &xscale2pmu; ++======= + static int __devinit xscale2pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 + { + *cpu_pmu = (struct arm_pmu) { + .name = "xscale2", + .handle_irq = xscale2pmu_handle_irq, + .enable = xscale2pmu_enable_event, + .disable = xscale2pmu_disable_event, + .read_counter = xscale2pmu_read_counter, + .write_counter = xscale2pmu_write_counter, + .get_event_idx = xscale2pmu_get_event_idx, + .start = xscale2pmu_start, + .stop = xscale2pmu_stop, + .map_event = xscale_map_event, + .num_events = 5, + .max_period = (1LLU << 32) - 1, + }; + + return 0; } #else ++<<<<<<< HEAD +static struct arm_pmu *__devinit xscale1pmu_init(void) ++======= + static inline int xscale1pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } ++<<<<<<< HEAD +static struct arm_pmu *__devinit xscale2pmu_init(void) ++======= + static inline int xscale2pmu_init(struct arm_pmu *cpu_pmu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - return NULL; + return -ENODEV; } #endif /* CONFIG_CPU_XSCALE */ -------------------------------------------------- diff --cc arch/arm/mach-omap2/devices.c index cba60e0,02b9478..0000000 --- a/arch/arm/mach-omap2/devices.c +++ b/arch/arm/mach-omap2/devices.c @@@ -433,24 -433,37 +433,46 @@@ static void omap_init_mcspi(void static inline void omap_init_mcspi(void) {} #endif ++<<<<<<< HEAD +/** + * omap_init_rng - bind the RNG hwmod to the RNG omap_device + * + * Bind the RNG hwmod to the RNG omap_device. No return value. + */ +static void omap_init_rng(void) ++======= + static struct resource omap2_pmu_resource = { + .start = 3, + .end = 3, + .flags = IORESOURCE_IRQ, + }; + + static struct resource omap3_pmu_resource = { + .start = INT_34XX_BENCH_MPU_EMUL, + .end = INT_34XX_BENCH_MPU_EMUL, + .flags = IORESOURCE_IRQ, + }; + + static struct platform_device omap_pmu_device = { + .name = "arm-pmu", + .id = -1, + .num_resources = 1, + }; + + static void omap_init_pmu(void) ++>>>>>>> tracking-big-LITTLE-MP-v10 { - if (cpu_is_omap24xx()) - omap_pmu_device.resource = &omap2_pmu_resource; - else if (cpu_is_omap34xx()) - omap_pmu_device.resource = &omap3_pmu_resource; - else + struct omap_hwmod *oh; + struct platform_device *pdev; + + oh = omap_hwmod_lookup("rng"); + if (!oh) return; - platform_device_register(&omap_pmu_device); + pdev = omap_device_build("omap_rng", -1, oh, NULL, 0, NULL, 0, 0); + WARN(IS_ERR(pdev), "Can't build omap_device for omap_rng\n"); } - #if defined(CONFIG_CRYPTO_DEV_OMAP_SHAM) || defined(CONFIG_CRYPTO_DEV_OMAP_SHAM_MODULE) #ifdef CONFIG_ARCH_OMAP2 -------------------------------------------------- diff --cc drivers/infiniband/hw/ehca/ehca_irq.c index 8615d7c,a4c9f9d..0000000 --- a/drivers/infiniband/hw/ehca/ehca_irq.c +++ b/drivers/infiniband/hw/ehca/ehca_irq.c @@@ -663,12 -663,15 +663,23 @@@ static int find_next_online_cpu(struct ehca_dmp(cpu_online_mask, cpumask_size(), ""); spin_lock_irqsave(&pool->last_cpu_lock, flags); ++<<<<<<< HEAD + do { ++======= + while (1) { ++>>>>>>> tracking-big-LITTLE-MP-v10 cpu = cpumask_next(pool->last_cpu, cpu_online_mask); if (cpu >= nr_cpu_ids) cpu = cpumask_first(cpu_online_mask); pool->last_cpu = cpu; ++<<<<<<< HEAD + } while (!per_cpu_ptr(pool->cpu_comp_tasks, cpu)->active); ++======= + /* Might be on the way out */ + if (per_cpu_ptr(pool->cpu_comp_tasks, cpu)->active) + break; + } ++>>>>>>> tracking-big-LITTLE-MP-v10 spin_unlock_irqrestore(&pool->last_cpu_lock, flags); return cpu; @@@ -707,7 -710,7 +718,11 @@@ static void queue_comp_task(struct ehca BUG_ON(!cpu_online(cpu_id)); cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu_id); ++<<<<<<< HEAD + thread = *per_cpu_ptr(pool->cpu_comp_threads, cpu_id); ++======= + thread = per_cpu_ptr(pool->cpu_comp_threads, cpu_id); ++>>>>>>> tracking-big-LITTLE-MP-v10 BUG_ON(!cct || !thread); spin_lock_irqsave(&cct->task_lock, flags); @@@ -716,7 -719,7 +731,11 @@@ if (cq_jobs > 0) { cpu_id = find_next_online_cpu(pool); cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu_id); ++<<<<<<< HEAD + thread = *per_cpu_ptr(pool->cpu_comp_threads, cpu_id); ++======= + thread = per_cpu_ptr(pool->cpu_comp_threads, cpu_id); ++>>>>>>> tracking-big-LITTLE-MP-v10 BUG_ON(!cct || !thread); } __queue_comp_task(__cq, cct, thread); @@@ -761,7 -764,7 +780,11 @@@ static void comp_task_park(unsigned in cpu = find_next_online_cpu(pool); target = per_cpu_ptr(pool->cpu_comp_tasks, cpu); ++<<<<<<< HEAD + thread = *per_cpu_ptr(pool->cpu_comp_threads, cpu); ++======= + thread = per_cpu_ptr(pool->cpu_comp_threads, cpu); ++>>>>>>> tracking-big-LITTLE-MP-v10 spin_lock_irq(&target->task_lock); list_for_each_entry_safe(cq, tmp, &list, entry) { list_del(&cq->entry); @@@ -788,7 -791,7 +811,11 @@@ static int comp_task_should_run(unsigne return cct->cq_jobs; } ++<<<<<<< HEAD +static void comp_task(unsigned int cpu) ++======= + static int comp_task(unsigned int cpu) ++>>>>>>> tracking-big-LITTLE-MP-v10 { struct ehca_cpu_comp_task *cct = this_cpu_ptr(pool->cpu_comp_tasks); int cql_empty; -------------------------------------------------- diff --cc kernel/rcutree.c index 74df86b,f494157..0000000 --- a/kernel/rcutree.c +++ b/kernel/rcutree.c @@@ -1746,7 -1504,6 +1746,10 @@@ static void rcu_cleanup_dead_cpu(int cp init_callback_list(rdp); /* Disallow further callbacks on this CPU. */ rdp->nxttail[RCU_NEXT_TAIL] = NULL; ++<<<<<<< HEAD + mutex_unlock(&rsp->onoff_mutex); ++======= ++>>>>>>> tracking-big-LITTLE-MP-v10 } #else /* #ifdef CONFIG_HOTPLUG_CPU */ -------------------------------------------------- diff --cc kernel/rcutree.h index a240f03,b82c88c1..0000000 --- a/kernel/rcutree.h +++ b/kernel/rcutree.h @@@ -200,7 -196,6 +200,10 @@@ struct rcu_node /* Refused to boost: not sure why, though. */ /* This can happen due to race conditions. */ #endif /* #ifdef CONFIG_RCU_BOOST */ ++<<<<<<< HEAD + raw_spinlock_t fqslock ____cacheline_internodealigned_in_smp; ++======= ++>>>>>>> tracking-big-LITTLE-MP-v10 } ____cacheline_internodealigned_in_smp; /* @@@ -394,10 -392,6 +397,13 @@@ struct rcu_state struct rcu_head **orphan_donetail; /* Tail of above. */ long qlen_lazy; /* Number of lazy callbacks. */ long qlen; /* Total number of callbacks. */ ++<<<<<<< HEAD + /* End of fields guarded by onofflock. */ + + struct mutex onoff_mutex; /* Coordinate hotplug & GPs. */ + ++======= ++>>>>>>> tracking-big-LITTLE-MP-v10 struct mutex barrier_mutex; /* Guards barrier fields. */ atomic_t barrier_cpu_count; /* # CPUs waiting on. */ struct completion barrier_completion; /* Wake at barrier end. */ -------------------------------------------------- diff --cc kernel/rcutree_plugin.h index f921154,c1961ae..0000000 --- a/kernel/rcutree_plugin.h +++ b/kernel/rcutree_plugin.h @@@ -25,7 -25,6 +25,10 @@@ */ #include ++<<<<<<< HEAD +#include ++======= ++>>>>>>> tracking-big-LITTLE-MP-v10 #include #define RCU_KTHREAD_PRIO 1 @@@ -1327,6 -1306,6 +1330,7 @@@ static void rcu_cpu_kthread_setup(unsig sp.sched_priority = RCU_KTHREAD_PRIO; sched_setscheduler_nocheck(current, SCHED_FIFO, &sp); ++<<<<<<< HEAD } static void rcu_cpu_kthread_park(unsigned int cpu) @@@ -1336,6 -1315,6 +1340,17 @@@ static int rcu_cpu_kthread_should_run(unsigned int cpu) { ++======= ++} ++ ++static void rcu_cpu_kthread_park(unsigned int cpu) ++{ ++ per_cpu(rcu_cpu_kthread_status, cpu) = RCU_KTHREAD_OFFCPU; ++} ++ ++static int rcu_cpu_kthread_should_run(unsigned int cpu) ++{ ++>>>>>>> tracking-big-LITTLE-MP-v10 return __get_cpu_var(rcu_cpu_has_work); } -------------------------------------------------- diff --cc kernel/smpboot.c index d6c5fc0,0a49ee7..0000000 --- a/kernel/smpboot.c +++ b/kernel/smpboot.c @@@ -93,7 -93,7 +93,11 @@@ enum /** * smpboot_thread_fn - percpu hotplug thread loop function ++<<<<<<< HEAD + * @data: thread data pointer ++======= + * @void: thread data pointer ++>>>>>>> tracking-big-LITTLE-MP-v10 * * Checks for thread stop and park conditions. Calls the necessary * setup, cleanup, park and unpark functions for the registered -------------------------------------------------- diff --cc kernel/softirq.c index cc96bdc,e04e5b2..0000000 --- a/kernel/softirq.c +++ b/kernel/softirq.c @@@ -827,9 -827,12 +827,16 @@@ static int __cpuinit cpu_callback(struc switch (action) { #ifdef CONFIG_HOTPLUG_CPU case CPU_DEAD: ++<<<<<<< HEAD + case CPU_DEAD_FROZEN: + takeover_tasklets((unsigned long)hcpu); ++======= + case CPU_DEAD_FROZEN: { + int hotcpu = (unsigned long)hcpu; + + takeover_tasklets(hotcpu); ++>>>>>>> tracking-big-LITTLE-MP-v10 break; - } #endif /* CONFIG_HOTPLUG_CPU */ } return NOTIFY_OK; -------------------------------------------------- * Unmerged path arch/arm/mach-bcmring/arch.c -------------------------------------------------- * Unmerged path arch/arm/mach-tegra/devices.c