Merge tag 'v3.13-rc4' into core/locking

Merge Linux 3.13-rc4, to refresh this rather old tree with the latest fixes.

Signed-off-by: Ingo Molnar <mingo@kernel.org>

8 files changed, 250 insertions, 72 deletions

diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 0362d575de7d..217c82ee3665 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -1606,6 +1606,24 @@ process_arg(struct event_format *event, struct print_arg *arg, char **tok)
 static enum event_type
 process_op(struct event_format *event, struct print_arg *arg, char **tok);
 
+/*
+ * For __print_symbolic() and __print_flags, we need to completely
+ * evaluate the first argument, which defines what to print next.
+ */
+static enum event_type
+process_field_arg(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        enum event_type type;
+
+        type = process_arg(event, arg, tok);
+
+        while (type == EVENT_OP) {
+                type = process_op(event, arg, tok);
+        }
+
+        return type;
+}
+
 static enum event_type
 process_cond(struct event_format *event, struct print_arg *top, char **tok)
 {
@@ -2371,7 +2389,7 @@ process_flags(struct event_format *event, struct print_arg *arg, char **tok)
                 goto out_free;
         }
 
-        type = process_arg(event, field, &token);
+        type = process_field_arg(event, field, &token);
 
         /* Handle operations in the first argument */
         while (type == EVENT_OP)
@@ -2424,7 +2442,8 @@ process_symbols(struct event_format *event, struct print_arg *arg, char **tok)
                 goto out_free;
         }
 
-        type = process_arg(event, field, &token);
+        type = process_field_arg(event, field, &token);
+
         if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free_field;
 
@@ -3446,7 +3465,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                  * is in the bottom half of the 32 bit field.
                  */
                 offset &= 0xffff;
-                val = (unsigned long long)(data + offset);
+                val = (unsigned long long)((unsigned long)data + offset);
                 break;
         default: /* not sure what to do there */
                 return 0;
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 369c03648f88..1cd035708931 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2078,8 +2078,10 @@ static int process_group_desc(struct perf_file_section *section __maybe_unused,
                 if (evsel->idx == (int) desc[i].leader_idx) {
                         evsel->leader = evsel;
                         /* {anon_group} is a dummy name */
-                        if (strcmp(desc[i].name, "{anon_group}"))
+                        if (strcmp(desc[i].name, "{anon_group}")) {
                                 evsel->group_name = desc[i].name;
+                                desc[i].name = NULL;
+                        }
                         evsel->nr_members = desc[i].nr_members;
 
                         if (i >= nr_groups || nr > 0) {
@@ -2105,7 +2107,7 @@ static int process_group_desc(struct perf_file_section *section __maybe_unused,
 
         ret = 0;
 out_free:
-        while ((int) --i >= 0)
+        for (i = 0; i < nr_groups; i++)
                 free(desc[i].name);
         free(desc);
 
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index cd8e2f592719..49eaf1d7d89d 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -70,14 +70,13 @@ int thread__set_comm(struct thread *thread, const char *str, u64 timestamp)
         /* Override latest entry if it had no specific time coverage */
         if (!curr->start) {
                 comm__override(curr, str, timestamp);
-                return 0;
+        } else {
+                new = comm__new(str, timestamp);
+                if (!new)
+                        return -ENOMEM;
+                list_add(&new->list, &thread->comm_list);
         }
 
-        new = comm__new(str, timestamp);
-        if (!new)
-                return -ENOMEM;
-
-        list_add(&new->list, &thread->comm_list);
         thread->comm_set = true;
 
         return 0;
diff --git a/tools/power/cpupower/man/cpupower-idle-info.1 b/tools/power/cpupower/man/cpupower-idle-info.1
index 4178effd9e99..7b3646adb92f 100644
--- a/tools/power/cpupower/man/cpupower-idle-info.1
+++ b/tools/power/cpupower/man/cpupower-idle-info.1
@@ -87,4 +87,5 @@ Thomas Renninger <trenn@suse.de>
 .fi
 .SH "SEE ALSO"
 .LP
-cpupower(1), cpupower\-monitor(1), cpupower\-info(1), cpupower\-set(1)
+cpupower(1), cpupower\-monitor(1), cpupower\-info(1), cpupower\-set(1),
+cpupower\-idle\-set(1)
diff --git a/tools/power/cpupower/man/cpupower-idle-set.1 b/tools/power/cpupower/man/cpupower-idle-set.1
new file mode 100644
index 000000000000..6b1607272a5b
--- /dev/null
+++ b/tools/power/cpupower/man/cpupower-idle-set.1
@@ -0,0 +1,71 @@
+.TH "CPUPOWER-IDLE-SET" "1" "0.1" "" "cpupower Manual"
+.SH "NAME"
+.LP
+cpupower idle\-set \- Utility to set cpu idle state specific kernel options
+.SH "SYNTAX"
+.LP
+cpupower [ \-c cpulist ] idle\-info [\fIoptions\fP]
+.SH "DESCRIPTION"
+.LP
+The cpupower idle\-set subcommand allows to set cpu idle, also called cpu
+sleep state, specific options offered by the kernel. One example is disabling
+sleep states. This can be handy for power vs performance tuning.
+.SH "OPTIONS"
+.LP
+.TP
+\fB\-d\fR \fB\-\-disable\fR
+Disable a specific processor sleep state.
+.TP
+\fB\-e\fR \fB\-\-enable\fR
+Enable a specific processor sleep state.
+
+.SH "REMARKS"
+.LP
+Cpuidle Governors Policy on Disabling Sleep States
+
+.RS 4
+Depending on the used  cpuidle governor, implementing the kernel policy
+how to choose sleep states, subsequent sleep states on this core, might get
+disabled as well.
+
+There are two cpuidle governors ladder and menu. While the ladder
+governor is always available, if CONFIG_CPU_IDLE is selected, the
+menu governor additionally requires CONFIG_NO_HZ.
+
+The behavior and the effect of the disable variable depends on the
+implementation of a particular governor. In the ladder governor, for
+example, it is not coherent, i.e. if one is disabling a light state,
+then all deeper states are disabled as well. Likewise, if one enables a
+deep state but a lighter state still is disabled, then this has no effect.
+.RE
+.LP
+Disabling the Lightest Sleep State may not have any Affect
+
+.RS 4
+If criteria are not met to enter deeper sleep states and the lightest sleep
+state is chosen when idle, the kernel may still enter this sleep state,
+irrespective of whether it is disabled or not. This is also reflected in
+the usage count of the disabled sleep state when using the cpupower idle-info
+command.
+.RE
+.LP
+Selecting specific CPU Cores
+
+.RS 4
+By default processor sleep states of all CPU cores are set. Please refer
+to the cpupower(1) manpage in the \-\-cpu option section how to disable
+C-states of specific cores.
+.RE
+.SH "FILES"
+.nf
+\fI/sys/devices/system/cpu/cpu*/cpuidle/state*\fP
+\fI/sys/devices/system/cpu/cpuidle/*\fP
+.fi
+.SH "AUTHORS"
+.nf
+Thomas Renninger <trenn@suse.de>
+.fi
+.SH "SEE ALSO"
+.LP
+cpupower(1), cpupower\-monitor(1), cpupower\-info(1), cpupower\-set(1),
+cpupower\-idle\-info(1)
diff --git a/tools/power/cpupower/utils/helpers/sysfs.c b/tools/power/cpupower/utils/helpers/sysfs.c
index 5cdc600e8152..851c7a16ca49 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.c
+++ b/tools/power/cpupower/utils/helpers/sysfs.c
@@ -278,7 +278,7 @@ static char *sysfs_idlestate_get_one_string(unsigned int cpu,
 int sysfs_is_idlestate_disabled(unsigned int cpu,
                                 unsigned int idlestate)
 {
-        if (sysfs_get_idlestate_count(cpu) < idlestate)
+        if (sysfs_get_idlestate_count(cpu) <= idlestate)
                 return -1;
 
         if (!sysfs_idlestate_file_exists(cpu, idlestate,
@@ -303,7 +303,7 @@ int sysfs_idlestate_disable(unsigned int cpu,
         char value[SYSFS_PATH_MAX];
         int bytes_written;
 
-        if (sysfs_get_idlestate_count(cpu) < idlestate)
+        if (sysfs_get_idlestate_count(cpu) <= idlestate)
                 return -1;
 
         if (!sysfs_idlestate_file_exists(cpu, idlestate,
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index fe702076ca46..9d77f13c2d25 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -2,7 +2,7 @@
  * turbostat -- show CPU frequency and C-state residency
  * on modern Intel turbo-capable processors.
  *
- * Copyright (c) 2012 Intel Corporation.
+ * Copyright (c) 2013 Intel Corporation.
  * Len Brown <len.brown@intel.com>
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -47,6 +47,8 @@ unsigned int skip_c1;
 unsigned int do_nhm_cstates;
 unsigned int do_snb_cstates;
 unsigned int do_c8_c9_c10;
+unsigned int do_slm_cstates;
+unsigned int use_c1_residency_msr;
 unsigned int has_aperf;
 unsigned int has_epb;
 unsigned int units = 1000000000;        /* Ghz etc */
@@ -81,6 +83,8 @@ double rapl_joule_counter_range;
 #define RAPL_DRAM       (1 << 3)
 #define RAPL_PKG_PERF_STATUS    (1 << 4)
 #define RAPL_DRAM_PERF_STATUS   (1 << 5)
+#define RAPL_PKG_POWER_INFO     (1 << 6)
+#define RAPL_CORE_POLICY        (1 << 7)
 #define TJMAX_DEFAULT   100
 
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
@@ -96,7 +100,7 @@ struct thread_data {
         unsigned long long tsc;
         unsigned long long aperf;
         unsigned long long mperf;
-        unsigned long long c1;  /* derived */
+        unsigned long long c1;
         unsigned long long extra_msr64;
         unsigned long long extra_delta64;
         unsigned long long extra_msr32;
@@ -266,7 +270,7 @@ void print_header(void)
                 outp += sprintf(outp, "           MSR 0x%03X", extra_msr_offset64);
         if (do_nhm_cstates)
                 outp += sprintf(outp, "    %%c1");
-        if (do_nhm_cstates)
+        if (do_nhm_cstates && !do_slm_cstates)
                 outp += sprintf(outp, "    %%c3");
         if (do_nhm_cstates)
                 outp += sprintf(outp, "    %%c6");
@@ -280,9 +284,9 @@ void print_header(void)
 
         if (do_snb_cstates)
                 outp += sprintf(outp, "   %%pc2");
-        if (do_nhm_cstates)
+        if (do_nhm_cstates && !do_slm_cstates)
                 outp += sprintf(outp, "   %%pc3");
-        if (do_nhm_cstates)
+        if (do_nhm_cstates && !do_slm_cstates)
                 outp += sprintf(outp, "   %%pc6");
         if (do_snb_cstates)
                 outp += sprintf(outp, "   %%pc7");
@@ -480,7 +484,7 @@ int format_counters(struct thread_data *t, struct core_data *c,
         if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
                 goto done;
 
-        if (do_nhm_cstates)
+        if (do_nhm_cstates && !do_slm_cstates)
                 outp += sprintf(outp, " %6.2f", 100.0 * c->c3/t->tsc);
         if (do_nhm_cstates)
                 outp += sprintf(outp, " %6.2f", 100.0 * c->c6/t->tsc);
@@ -499,9 +503,9 @@ int format_counters(struct thread_data *t, struct core_data *c,
 
         if (do_snb_cstates)
                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc2/t->tsc);
-        if (do_nhm_cstates)
+        if (do_nhm_cstates && !do_slm_cstates)
                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc3/t->tsc);
-        if (do_nhm_cstates)
+        if (do_nhm_cstates && !do_slm_cstates)
                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc6/t->tsc);
         if (do_snb_cstates)
                 outp += sprintf(outp, " %6.2f", 100.0 * p->pc7/t->tsc);
@@ -648,17 +652,24 @@ delta_thread(struct thread_data *new, struct thread_data *old,
         }
 
 
-        /*
-         * As counter collection is not atomic,
-         * it is possible for mperf's non-halted cycles + idle states
-         * to exceed TSC's all cycles: show c1 = 0% in that case.
-         */
-        if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
-                old->c1 = 0;
-        else {
-                /* normal case, derive c1 */
-                old->c1 = old->tsc - old->mperf - core_delta->c3
+        if (use_c1_residency_msr) {
+                /*
+                 * Some models have a dedicated C1 residency MSR,
+                 * which should be more accurate than the derivation below.
+                 */
+        } else {
+                /*
+                 * As counter collection is not atomic,
+                 * it is possible for mperf's non-halted cycles + idle states
+                 * to exceed TSC's all cycles: show c1 = 0% in that case.
+                 */
+                if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
+                        old->c1 = 0;
+                else {
+                        /* normal case, derive c1 */
+                        old->c1 = old->tsc - old->mperf - core_delta->c3
                                 - core_delta->c6 - core_delta->c7;
+                }
         }
 
         if (old->mperf == 0) {
@@ -872,13 +883,21 @@ int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                 if (get_msr(cpu, extra_msr_offset64, &t->extra_msr64))
                         return -5;
 
+        if (use_c1_residency_msr) {
+                if (get_msr(cpu, MSR_CORE_C1_RES, &t->c1))
+                        return -6;
+        }
+
         /* collect core counters only for 1st thread in core */
         if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
                 return 0;
 
-        if (do_nhm_cstates) {
+        if (do_nhm_cstates && !do_slm_cstates) {
                 if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
                         return -6;
+        }
+
+        if (do_nhm_cstates) {
                 if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
                         return -7;
         }
@@ -898,7 +917,7 @@ int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
                 return 0;
 
-        if (do_nhm_cstates) {
+        if (do_nhm_cstates && !do_slm_cstates) {
                 if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
                         return -9;
                 if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
@@ -977,7 +996,7 @@ void print_verbose_header(void)
                 ratio, bclk, ratio * bclk);
 
         get_msr(0, MSR_IA32_POWER_CTL, &msr);
-        fprintf(stderr, "cpu0: MSR_IA32_POWER_CTL: 0x%08llx (C1E: %sabled)\n",
+        fprintf(stderr, "cpu0: MSR_IA32_POWER_CTL: 0x%08llx (C1E auto-promotion: %sabled)\n",
                 msr, msr & 0x2 ? "EN" : "DIS");
 
         if (!do_ivt_turbo_ratio_limit)
@@ -1046,25 +1065,28 @@ print_nhm_turbo_ratio_limits:
 
         switch(msr & 0x7) {
         case 0:
-                fprintf(stderr, "pc0");
+                fprintf(stderr, do_slm_cstates ? "no pkg states" : "pc0");
                 break;
         case 1:
-                fprintf(stderr, do_snb_cstates ? "pc2" : "pc0");
+                fprintf(stderr, do_slm_cstates ? "no pkg states" : do_snb_cstates ? "pc2" : "pc0");
                 break;
         case 2:
-                fprintf(stderr, do_snb_cstates ? "pc6-noret" : "pc3");
+                fprintf(stderr, do_slm_cstates ? "invalid" : do_snb_cstates ? "pc6-noret" : "pc3");
                 break;
         case 3:
-                fprintf(stderr, "pc6");
+                fprintf(stderr, do_slm_cstates ? "invalid" : "pc6");
                 break;
         case 4:
-                fprintf(stderr, "pc7");
+                fprintf(stderr, do_slm_cstates ? "pc4" : "pc7");
                 break;
         case 5:
-                fprintf(stderr, do_snb_cstates ? "pc7s" : "invalid");
+                fprintf(stderr, do_slm_cstates ? "invalid" : do_snb_cstates ? "pc7s" : "invalid");
+                break;
+        case 6:
+                fprintf(stderr, do_slm_cstates ? "pc6" : "invalid");
                 break;
         case 7:
-                fprintf(stderr, "unlimited");
+                fprintf(stderr, do_slm_cstates ? "pc7" : "unlimited");
                 break;
         default:
                 fprintf(stderr, "invalid");
@@ -1460,6 +1482,8 @@ int has_nehalem_turbo_ratio_limit(unsigned int family, unsigned int model)
         case 0x3F:      /* HSW */
         case 0x45:      /* HSW */
         case 0x46:      /* HSW */
+        case 0x37:      /* BYT */
+        case 0x4D:      /* AVN */
                 return 1;
         case 0x2E:      /* Nehalem-EX Xeon - Beckton */
         case 0x2F:      /* Westmere-EX Xeon - Eagleton */
@@ -1532,14 +1556,33 @@ int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 #define RAPL_POWER_GRANULARITY  0x7FFF  /* 15 bit power granularity */
 #define RAPL_TIME_GRANULARITY   0x3F /* 6 bit time granularity */
 
+double get_tdp(model)
+{
+        unsigned long long msr;
+
+        if (do_rapl & RAPL_PKG_POWER_INFO)
+                if (!get_msr(0, MSR_PKG_POWER_INFO, &msr))
+                        return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
+
+        switch (model) {
+        case 0x37:
+        case 0x4D:
+                return 30.0;
+        default:
+                return 135.0;
+        }
+}
+
+
 /*
  * rapl_probe()
  *
- * sets do_rapl
+ * sets do_rapl, rapl_power_units, rapl_energy_units, rapl_time_units
  */
 void rapl_probe(unsigned int family, unsigned int model)
 {
         unsigned long long msr;
+        unsigned int time_unit;
         double tdp;
 
         if (!genuine_intel)
@@ -1555,11 +1598,15 @@ void rapl_probe(unsigned int family, unsigned int model)
         case 0x3F:      /* HSW */
         case 0x45:      /* HSW */
         case 0x46:      /* HSW */
-                do_rapl = RAPL_PKG | RAPL_CORES | RAPL_GFX;
+                do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
                 break;
         case 0x2D:
         case 0x3E:
-                do_rapl = RAPL_PKG | RAPL_CORES | RAPL_DRAM | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS;
+                do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_PKG_PERF_STATUS | RAPL_DRAM_PERF_STATUS | RAPL_PKG_POWER_INFO;
+                break;
+        case 0x37:      /* BYT */
+        case 0x4D:      /* AVN */
+                do_rapl = RAPL_PKG | RAPL_CORES ;
                 break;
         default:
                 return;
@@ -1570,19 +1617,22 @@ void rapl_probe(unsigned int family, unsigned int model)
                 return;
 
         rapl_power_units = 1.0 / (1 << (msr & 0xF));
-        rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
-        rapl_time_units = 1.0 / (1 << (msr >> 16 & 0xF));
+        if (model == 0x37)
+                rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
+        else
+                rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
 
-        /* get TDP to determine energy counter range */
-        if (get_msr(0, MSR_PKG_POWER_INFO, &msr))
-                return;
+        time_unit = msr >> 16 & 0xF;
+        if (time_unit == 0)
+                time_unit = 0xA;
 
-        tdp = ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
+        rapl_time_units = 1.0 / (1 << (time_unit));
 
-        rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
+        tdp = get_tdp(model);
 
+        rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
         if (verbose)
-                fprintf(stderr, "RAPL: %.0f sec. Joule Counter Range\n", rapl_joule_counter_range);
+                fprintf(stderr, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
 
         return;
 }
@@ -1668,7 +1718,6 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 {
         unsigned long long msr;
         int cpu;
-        double local_rapl_power_units, local_rapl_energy_units, local_rapl_time_units;
 
         if (!do_rapl)
                 return 0;
@@ -1686,23 +1735,13 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
                 return -1;
 
-        local_rapl_power_units = 1.0 / (1 << (msr & 0xF));
-        local_rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
-        local_rapl_time_units = 1.0 / (1 << (msr >> 16 & 0xF));
-
-        if (local_rapl_power_units != rapl_power_units)
-                fprintf(stderr, "cpu%d, ERROR: Power units mis-match\n", cpu);
-        if (local_rapl_energy_units != rapl_energy_units)
-                fprintf(stderr, "cpu%d, ERROR: Energy units mis-match\n", cpu);
-        if (local_rapl_time_units != rapl_time_units)
-                fprintf(stderr, "cpu%d, ERROR: Time units mis-match\n", cpu);
-
         if (verbose) {
                 fprintf(stderr, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx "
                         "(%f Watts, %f Joules, %f sec.)\n", cpu, msr,
-                        local_rapl_power_units, local_rapl_energy_units, local_rapl_time_units);
+                        rapl_power_units, rapl_energy_units, rapl_time_units);
         }
-        if (do_rapl & RAPL_PKG) {
+        if (do_rapl & RAPL_PKG_POWER_INFO) {
+
                 if (get_msr(cpu, MSR_PKG_POWER_INFO, &msr))
                         return -5;
 
@@ -1714,6 +1753,9 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                         ((msr >> 32) & RAPL_POWER_GRANULARITY) * rapl_power_units,
                         ((msr >> 48) & RAPL_TIME_GRANULARITY) * rapl_time_units);
 
+        }
+        if (do_rapl & RAPL_PKG) {
+
                 if (get_msr(cpu, MSR_PKG_POWER_LIMIT, &msr))
                         return -9;
 
@@ -1749,12 +1791,16 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 
                 print_power_limit_msr(cpu, msr, "DRAM Limit");
         }
-        if (do_rapl & RAPL_CORES) {
+        if (do_rapl & RAPL_CORE_POLICY) {
                 if (verbose) {
                         if (get_msr(cpu, MSR_PP0_POLICY, &msr))
                                 return -7;
 
                         fprintf(stderr, "cpu%d: MSR_PP0_POLICY: %lld\n", cpu, msr & 0xF);
+                }
+        }
+        if (do_rapl & RAPL_CORES) {
+                if (verbose) {
 
                         if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
                                 return -9;
@@ -1813,10 +1859,48 @@ int has_c8_c9_c10(unsigned int family, unsigned int model)
 }
 
 
+int is_slm(unsigned int family, unsigned int model)
+{
+        if (!genuine_intel)
+                return 0;
+        switch (model) {
+        case 0x37:      /* BYT */
+        case 0x4D:      /* AVN */
+                return 1;
+        }
+        return 0;
+}
+
+#define SLM_BCLK_FREQS 5
+double slm_freq_table[SLM_BCLK_FREQS] = { 83.3, 100.0, 133.3, 116.7, 80.0};
+
+double slm_bclk(void)
+{
+        unsigned long long msr = 3;
+        unsigned int i;
+        double freq;
+
+        if (get_msr(0, MSR_FSB_FREQ, &msr))
+                fprintf(stderr, "SLM BCLK: unknown\n");
+
+        i = msr & 0xf;
+        if (i >= SLM_BCLK_FREQS) {
+                fprintf(stderr, "SLM BCLK[%d] invalid\n", i);
+                msr = 3;
+        }
+        freq = slm_freq_table[i];
+
+        fprintf(stderr, "SLM BCLK: %.1f Mhz\n", freq);
+
+        return freq;
+}
+
 double discover_bclk(unsigned int family, unsigned int model)
 {
         if (is_snb(family, model))
                 return 100.00;
+        else if (is_slm(family, model))
+                return slm_bclk();
         else
                 return 133.33;
 }
@@ -1873,7 +1957,7 @@ int set_temperature_target(struct thread_data *t, struct core_data *c, struct pk
                 fprintf(stderr, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
                         cpu, msr, target_c_local);
 
-        if (target_c_local < 85 || target_c_local > 120)
+        if (target_c_local < 85 || target_c_local > 127)
                 goto guess;
 
         tcc_activation_temp = target_c_local;
@@ -1970,6 +2054,7 @@ void check_cpuid()
         do_smi = do_nhm_cstates;
         do_snb_cstates = is_snb(family, model);
         do_c8_c9_c10 = has_c8_c9_c10(family, model);
+        do_slm_cstates = is_slm(family, model);
         bclk = discover_bclk(family, model);
 
         do_nehalem_turbo_ratio_limit = has_nehalem_turbo_ratio_limit(family, model);
@@ -2331,7 +2416,7 @@ int main(int argc, char **argv)
         cmdline(argc, argv);
 
         if (verbose)
-                fprintf(stderr, "turbostat v3.4 April 17, 2013"
+                fprintf(stderr, "turbostat v3.5 April 26, 2013"
                         " - Len Brown <lenb@kernel.org>\n");
 
         turbostat_init();
diff --git a/tools/usb/Makefile b/tools/usb/Makefile
index 396d6c44e9d7..acf2165c04e6 100644
--- a/tools/usb/Makefile
+++ b/tools/usb/Makefile
@@ -3,11 +3,12 @@
 CC = $(CROSS_COMPILE)gcc
 PTHREAD_LIBS = -lpthread
 WARNINGS = -Wall -Wextra
-CFLAGS = $(WARNINGS) -g $(PTHREAD_LIBS) -I../include
+CFLAGS = $(WARNINGS) -g -I../include
+LDFLAGS = $(PTHREAD_LIBS)
 
 all: testusb ffs-test
 %: %.c
-        $(CC) $(CFLAGS) -o $@ $^
+        $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
 
 clean:
         $(RM) testusb ffs-test