diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
index 5df25c2a57a..bc5ce4c6f10 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.cc
@@ -16,6 +16,7 @@
 
 #include "src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h"
 
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
@@ -91,6 +92,21 @@ constexpr uint32_t kThreadDead = 5;
 
 constexpr int32_t kIdleWeight = std::numeric_limits<int32_t>::min();
 
+// CPU idle states (matching Linux/Android conventions: 0 is idle, 0xFFFFFFFF is
+// active/exit idle)
+constexpr double kCpuIdleState = 0.0;
+constexpr double kCpuActiveState =
+    static_cast<double>(std::numeric_limits<uint32_t>::max());
+
+// Trace contract for CPU frequency counter events emitted by Fuchsia CPU
+// drivers, aligned with the Linux ftrace "power/cpu_frequency" event: the
+// counter record carries the logical core index in the "cpu" argument and the
+// frequency in kHz in the "value" argument.
+constexpr char kCpuFrequencyCategory[] = "power";
+constexpr char kCpuFrequencyEventName[] = "cpu_frequency";
+constexpr char kCpuFrequencyCpuArg[] = "cpu";
+constexpr char kCpuFrequencyValueArg[] = "value";
+
 constexpr auto kCounterBlueprint = tracks::CounterBlueprint(
     "fuchsia_counter",
     tracks::UnknownUnitBlueprint(),
@@ -98,6 +114,65 @@ constexpr auto kCounterBlueprint = tracks::CounterBlueprint(
                                 tracks::kNameFromTraceDimensionBlueprint),
     tracks::DynamicNameBlueprint());
 
+// Returns the numeric value carried by |value| as a double, or std::nullopt if
+// the argument does not hold a numeric type. Range and finiteness checks are
+// left to the caller.
+std::optional<double> ArgValueToDouble(
+    const fuchsia_trace_utils::ArgValue& value) {
+  switch (value.Type()) {
+    case fuchsia_trace_utils::ArgValue::kInt32:
+      return static_cast<double>(value.Int32());
+    case fuchsia_trace_utils::ArgValue::kUint32:
+      return static_cast<double>(value.Uint32());
+    case fuchsia_trace_utils::ArgValue::kInt64:
+      return static_cast<double>(value.Int64());
+    case fuchsia_trace_utils::ArgValue::kUint64:
+      return static_cast<double>(value.Uint64());
+    case fuchsia_trace_utils::ArgValue::kDouble:
+      return value.Double();
+    case fuchsia_trace_utils::ArgValue::kNull:
+    case fuchsia_trace_utils::ArgValue::kString:
+    case fuchsia_trace_utils::ArgValue::kPointer:
+    case fuchsia_trace_utils::ArgValue::kKoid:
+    case fuchsia_trace_utils::ArgValue::kBool:
+    case fuchsia_trace_utils::ArgValue::kUnknown:
+      return std::nullopt;
+  }
+  PERFETTO_FATAL("For GCC");
+}
+
+// Returns the logical CPU core index carried by |value|, or std::nullopt if the
+// value is not a valid core index. Negative and out of range indices
+// (>= CpuTracker::kMaxCpusPerMachine) are rejected, as are non-integer and
+// non-numeric argument types.
+std::optional<uint32_t> ExtractCpuCoreIndex(
+    const fuchsia_trace_utils::ArgValue& value) {
+  if (value.Type() == fuchsia_trace_utils::ArgValue::kDouble) {
+    return std::nullopt;
+  }
+  // Integers up to 2^53 round-trip exactly through a double, so every value in
+  // the valid core index range is compared and converted without loss below.
+  std::optional<double> core_index = ArgValueToDouble(value);
+  if (!core_index.has_value() || *core_index < 0 ||
+      *core_index >= CpuTracker::kMaxCpusPerMachine) {
+    return std::nullopt;
+  }
+  return static_cast<uint32_t>(*core_index);
+}
+
+// Returns the frequency in kHz carried by |value|, or std::nullopt if the
+// value is not a valid frequency. Negative and non-finite (NaN, infinity)
+// frequencies are rejected, as are non-numeric argument types.
+std::optional<double> ExtractFrequencyKhz(
+    const fuchsia_trace_utils::ArgValue& value) {
+  std::optional<double> frequency_khz = ArgValueToDouble(value);
+  if (!frequency_khz.has_value() || !std::isfinite(*frequency_khz) ||
+      *frequency_khz < 0) {
+    return std::nullopt;
+  }
+  return frequency_khz;
+}
+
 }  // namespace
 
 FuchsiaTraceParser::FuchsiaTraceParser(TraceProcessorContext* context)
@@ -106,6 +181,14 @@ FuchsiaTraceParser::FuchsiaTraceParser(TraceProcessorContext* context)
       waker_id_(context->storage->InternString("waker")),
       incoming_weight_id_(context->storage->InternString("incoming_weight")),
       outgoing_weight_id_(context->storage->InternString("outgoing_weight")),
+      cpu_frequency_category_id_(
+          context->storage->InternString(kCpuFrequencyCategory)),
+      cpu_frequency_name_id_(
+          context->storage->InternString(kCpuFrequencyEventName)),
+      cpu_frequency_cpu_arg_id_(
+          context->storage->InternString(kCpuFrequencyCpuArg)),
+      cpu_frequency_value_arg_id_(
+          context->storage->InternString(kCpuFrequencyValueArg)),
       running_string_id_(context->storage->InternString("Running")),
       runnable_string_id_(context->storage->InternString("R")),
       waking_string_id_(context->storage->InternString("W")),
@@ -329,69 +412,50 @@ void FuchsiaTraceParser::Parse(int64_t, FuchsiaRecord fr) {
           break;
         }
         case kCounter: {
-          UniquePid upid =
-              procs->GetOrCreateProcess(static_cast<uint32_t>(tinfo.pid));
-          std::string name_str =
-              context_->storage->GetString(name).ToStdString();
           uint64_t counter_id;
           if (!cursor.ReadUint64(&counter_id)) {
             context_->stats_tracker->IncrementStats(
                 stats::fuchsia_record_read_error);
             return;
           }
+
+          // CPU frequency counters go to the standard per-core cpufreq tracks
+          // instead of to a generic process counter track.
+          if (cat == cpu_frequency_category_id_ &&
+              name == cpu_frequency_name_id_) {
+            ParseCpuFrequencyCounter(ts, *maybe_args);
+            break;
+          }
+
+          UniquePid upid =
+              procs->GetOrCreateProcess(static_cast<uint32_t>(tinfo.pid));
+          std::string name_str =
+              context_->storage->GetString(name).ToStdString();
+
           // Note: In the Fuchsia trace format, counter values are stored
           // in the arguments for the record, with the data series defined
           // by both the record name and the argument name. In Perfetto,
           // counters only have one name, so we combine both names into
           // one here.
           for (const Arg& arg : *maybe_args) {
+            std::optional<double> counter_value = ArgValueToDouble(arg.value);
+            if (!counter_value.has_value()) {
+              context_->stats_tracker->IncrementStats(
+                  stats::fuchsia_non_numeric_counters);
+              continue;
+            }
             std::string counter_name_str = name_str + ":";
             counter_name_str +=
                 context_->storage->GetString(arg.name).ToStdString();
             counter_name_str += ":" + std::to_string(counter_id);
-            bool is_valid_value = false;
-            double counter_value = -1;
-            switch (arg.value.Type()) {
-              case fuchsia_trace_utils::ArgValue::kInt32:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Int32());
-                break;
-              case fuchsia_trace_utils::ArgValue::kUint32:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Uint32());
-                break;
-              case fuchsia_trace_utils::ArgValue::kInt64:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Int64());
-                break;
-              case fuchsia_trace_utils::ArgValue::kUint64:
-                is_valid_value = true;
-                counter_value = static_cast<double>(arg.value.Uint64());
-                break;
-              case fuchsia_trace_utils::ArgValue::kDouble:
-                is_valid_value = true;
-                counter_value = arg.value.Double();
-                break;
-              case fuchsia_trace_utils::ArgValue::kNull:
-              case fuchsia_trace_utils::ArgValue::kString:
-              case fuchsia_trace_utils::ArgValue::kPointer:
-              case fuchsia_trace_utils::ArgValue::kKoid:
-              case fuchsia_trace_utils::ArgValue::kBool:
-              case fuchsia_trace_utils::ArgValue::kUnknown:
-                context_->stats_tracker->IncrementStats(
-                    stats::fuchsia_non_numeric_counters);
-                break;
-            }
-            if (is_valid_value) {
-              base::StringView counter_name_str_view(counter_name_str);
-              StringId counter_name_id =
-                  context_->storage->InternString(counter_name_str_view);
-              TrackId track = context_->track_tracker->InternTrack(
-                  kCounterBlueprint,
-                  tracks::Dimensions(upid, counter_name_str_view),
-                  tracks::DynamicName(counter_name_id));
-              context_->event_tracker->PushCounter(ts, counter_value, track);
-            }
+            base::StringView counter_name_str_view(counter_name_str);
+            StringId counter_name_id =
+                context_->storage->InternString(counter_name_str_view);
+            TrackId track = context_->track_tracker->InternTrack(
+                kCounterBlueprint,
+                tracks::Dimensions(upid, counter_name_str_view),
+                tracks::DynamicName(counter_name_id));
+            context_->event_tracker->PushCounter(ts, *counter_value, track);
           }
           break;
         }
@@ -614,6 +678,9 @@ void FuchsiaTraceParser::Parse(int64_t, FuchsiaRecord fr) {
           if (!incoming_is_idle) {
             SwitchTo(&incoming_thread, ts, cpu, incoming_priority);
           }
+
+          MaybePushCpuIdleTransition(ts, cpu, outgoing_is_idle,
+                                     incoming_is_idle);
           break;
         }
         case kSchedulerEventContextSwitch: {
@@ -695,6 +762,9 @@ void FuchsiaTraceParser::Parse(int64_t, FuchsiaRecord fr) {
           if (!incoming_is_idle) {
             SwitchTo(&incoming_thread, ts, cpu, incoming_weight);
           }
+
+          MaybePushCpuIdleTransition(ts, cpu, outgoing_is_idle,
+                                     incoming_is_idle);
           break;
         }
         case kSchedulerEventThreadWakeup: {
@@ -922,6 +992,51 @@ void FuchsiaTraceParser::Wake(Thread* thread,
   thread->last_state_row = state_row_number;
 }
 
+void FuchsiaTraceParser::ParseCpuFrequencyCounter(
+    int64_t ts,
+    const std::vector<Arg>& args) {
+  std::optional<uint32_t> cpu;
+  std::optional<double> frequency_khz;
+  // A record which repeats "cpu" or "value", or which carries an unusable core
+  // index or frequency, does not honour the contract and is dropped whole.
+  bool is_valid_event = true;
+  for (const Arg& arg : args) {
+    if (arg.name == cpu_frequency_cpu_arg_id_) {
+      is_valid_event = is_valid_event && !cpu.has_value();
+      cpu = ExtractCpuCoreIndex(arg.value);
+      is_valid_event = is_valid_event && cpu.has_value();
+    } else if (arg.name == cpu_frequency_value_arg_id_) {
+      is_valid_event = is_valid_event && !frequency_khz.has_value();
+      frequency_khz = ExtractFrequencyKhz(arg.value);
+      is_valid_event = is_valid_event && frequency_khz.has_value();
+    }
+  }
+
+  if (!is_valid_event || !cpu.has_value() || !frequency_khz.has_value()) {
+    context_->stats_tracker->IncrementStats(stats::fuchsia_invalid_event);
+    return;
+  }
+
+  context_->cpu_tracker->GetOrCreateCpu(*cpu);
+  TrackId track = context_->track_tracker->InternTrack(
+      tracks::kCpuFrequencyBlueprint, tracks::Dimensions(*cpu));
+  context_->event_tracker->PushCounter(ts, *frequency_khz, track);
+}
+
+void FuchsiaTraceParser::MaybePushCpuIdleTransition(int64_t ts,
+                                                    uint32_t cpu,
+                                                    bool outgoing_is_idle,
+                                                    bool incoming_is_idle) {
+  if (outgoing_is_idle == incoming_is_idle) {
+    return;
+  }
+  context_->cpu_tracker->GetOrCreateCpu(cpu);
+  TrackId idle_track = context_->track_tracker->InternTrack(
+      tracks::kCpuIdleBlueprint, tracks::Dimensions(cpu));
+  double value = incoming_is_idle ? kCpuIdleState : kCpuActiveState;
+  context_->event_tracker->PushCounter(ts, value, idle_track);
+}
+
 StringId FuchsiaTraceParser::IdForOutgoingThreadState(uint32_t state) {
   switch (state) {
     case kThreadNew:
diff --git a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h
index f75241ff90c..84d93aa7090 100644
--- a/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h
+++ b/src/trace_processor/importers/fuchsia/fuchsia_trace_parser.h
@@ -91,6 +91,19 @@ class FuchsiaTraceParser
             uint32_t cpu,
             std::optional<UniqueTid> waker_utid = std::nullopt,
             std::optional<uint64_t> waker_tid = std::nullopt);
+  // Routes a "power" / "cpu_frequency" counter record to the per-core cpufreq
+  // track named by its "cpu" argument, using the kHz frequency carried in its
+  // "value" argument. Records violating that contract are dropped and counted
+  // in stats::fuchsia_invalid_event.
+  void ParseCpuFrequencyCounter(int64_t ts, const std::vector<Arg>& args);
+  // Synthesizes a CPU idle counter event for the given CPU core matching
+  // Linux/Android cpuidle conventions: entering idle pushes the idle state,
+  // leaving idle pushes the exit-idle active state. Context switches which do
+  // not change the idle state of the core push nothing.
+  void MaybePushCpuIdleTransition(int64_t ts,
+                                  uint32_t cpu,
+                                  bool outgoing_is_idle,
+                                  bool incoming_is_idle);
 
   StringId IdForOutgoingThreadState(uint32_t state);
 
@@ -102,6 +115,12 @@ class FuchsiaTraceParser
   const StringId incoming_weight_id_;
   const StringId outgoing_weight_id_;
 
+  // Interned string ids for the CPU frequency counter trace contract.
+  const StringId cpu_frequency_category_id_;
+  const StringId cpu_frequency_name_id_;
+  const StringId cpu_frequency_cpu_arg_id_;
+  const StringId cpu_frequency_value_arg_id_;
+
   // Interned string ids for the relevant thread states.
   const StringId running_string_id_;
   const StringId runnable_string_id_;
diff --git a/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py
new file mode 100755
index 00000000000..00e0b76ed72
--- /dev/null
+++ b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_frequency.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# Copyright 2026 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Emits a Fuchsia trace holding "power" / "cpu_frequency" counter records, both
+# well formed ones and ones violating the trace contract.
+
+import math
+import struct
+import sys
+
+# String indices interned below.
+POWER = 1
+CPU_FREQUENCY = 2
+CPU = 3
+VALUE = 4
+CLUSTER = 5
+NOT_A_NUMBER = 6
+
+
+def push_word(w):
+  sys.stdout.buffer.write(struct.pack('<Q', w))
+
+
+def push_string(index, s):
+  s_bytes = s.encode('utf-8')
+  s_len = len(s_bytes)
+  num_words = 1 + (s_len + 7) // 8
+  header = (s_len << 32) | (index << 16) | (num_words << 4) | 2
+  push_word(header)
+  padded = s_bytes.ljust((num_words - 1) * 8, b'\x00')
+  for i in range(0, len(padded), 8):
+    push_word(struct.unpack('<Q', padded[i:i + 8])[0])
+
+
+# Argument builders. Each returns the words encoding one record argument.
+def int32_arg(name_ref, value):
+  return [((value & 0xffffffff) << 32) | (name_ref << 16) | (1 << 4) | 1]
+
+
+def uint32_arg(name_ref, value):
+  return [(value << 32) | (name_ref << 16) | (1 << 4) | 2]
+
+
+def int64_arg(name_ref, value):
+  return [(name_ref << 16) | (2 << 4) | 3, value & 0xffffffffffffffff]
+
+
+def uint64_arg(name_ref, value):
+  return [(name_ref << 16) | (2 << 4) | 4, value]
+
+
+def double_arg(name_ref, value):
+  bits = struct.unpack('<Q', struct.pack('<d', value))[0]
+  return [(name_ref << 16) | (2 << 4) | 5, bits]
+
+
+def string_arg(name_ref, value_ref):
+  return [(value_ref << 32) | (name_ref << 16) | (1 << 4) | 6]
+
+
+def push_counter_event(ts, args, counter_id=0):
+  arg_words = [w for arg in args for w in arg]
+  # Words: header, timestamp, arguments and counter id.
+  num_words = 3 + len(arg_words)
+  # record_type = 4 (event), event_type = 1 (counter), thread_ref = 1.
+  header = (CPU_FREQUENCY << 48) | (POWER << 32) | (1 << 24) | (
+      len(args) << 20) | (1 << 16) | (num_words << 4) | 4
+  push_word(header)
+  push_word(ts)
+  for word in arg_words:
+    push_word(word)
+  push_word(counter_id)
+
+
+def main():
+  # Fuchsia trace magic word: 0x0016547846040010
+  sys.stdout.buffer.write(b'\x10\x00\x04\x46\x78\x54\x16\x00')
+
+  push_string(POWER, 'power')
+  push_string(CPU_FREQUENCY, 'cpu_frequency')
+  push_string(CPU, 'cpu')
+  push_string(VALUE, 'value')
+  push_string(CLUSTER, 'cluster')
+  push_string(NOT_A_NUMBER, 'not_a_number')
+
+  # Thread record: pid=100, tid=200.
+  push_word((1 << 16) | (3 << 4) | 3)
+  push_word(100)
+  push_word(200)
+
+  # Frequencies emitted as integers are ingested as kHz.
+  push_counter_event(
+      1000, [uint32_arg(CPU, 0), uint64_arg(VALUE, 1996800)], counter_id=0)
+  push_counter_event(
+      2000, [uint32_arg(CPU, 3), uint64_arg(VALUE, 2688000)], counter_id=3)
+  # CPU 0 DVFS transition.
+  push_counter_event(
+      3000, [uint32_arg(CPU, 0), uint64_arg(VALUE, 1190400)], counter_id=0)
+
+  # Arguments beyond "cpu" and "value" are not part of the contract and are
+  # ignored rather than rejected.
+  push_counter_event(
+      4000,
+      [uint32_arg(CPU, 5),
+       uint32_arg(CLUSTER, 1),
+       uint64_arg(VALUE, 2800000)],
+      counter_id=5)
+
+  # Frequencies emitted as finite, non-negative doubles are also ingested.
+  push_counter_event(
+      5000,
+      [uint32_arg(CPU, 4), double_arg(VALUE, 1804800.0)], counter_id=4)
+
+  # Negative, non-finite, non-numeric and ambiguous records violate the
+  # contract: they are dropped and counted in the fuchsia_invalid_event stat, so
+  # no track is created for CPUs 1, 2, 6, 7 and 8.
+  push_counter_event(6000, [uint32_arg(CPU, 1), int32_arg(VALUE, -500)])
+  push_counter_event(7000, [uint32_arg(CPU, 2), int64_arg(VALUE, -1000)])
+  push_counter_event(8000, [uint32_arg(CPU, 6), double_arg(VALUE, math.nan)])
+  push_counter_event(9000, [uint32_arg(CPU, 6), double_arg(VALUE, math.inf)])
+  push_counter_event(10000, [uint32_arg(CPU, 6), double_arg(VALUE, -1500.0)])
+  # A frequency which is not a number at all.
+  push_counter_event(
+      11000,
+      [uint32_arg(CPU, 7), string_arg(VALUE, NOT_A_NUMBER)])
+  # Repeating "value" leaves the frequency ambiguous.
+  push_counter_event(12000, [
+      uint32_arg(CPU, 7),
+      uint64_arg(VALUE, 1000000),
+      uint64_arg(VALUE, 2000000)
+  ])
+  # A record without a "cpu" argument names no core.
+  push_counter_event(13000, [uint64_arg(VALUE, 1000000)])
+  # Core indices are integers in the [0, kMaxCpusPerMachine) range.
+  push_counter_event(14000, [double_arg(CPU, 8.0), uint64_arg(VALUE, 1000000)])
+  push_counter_event(14500, [uint32_arg(CPU, 4096), uint64_arg(VALUE, 1000000)])
+  push_counter_event(15000,
+                     [uint64_arg(CPU, 2**32),
+                      uint64_arg(VALUE, 1000000)])
+
+
+if __name__ == '__main__':
+  main()
diff --git a/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py
new file mode 100755
index 00000000000..2d327c08111
--- /dev/null
+++ b/test/trace_processor/diff_tests/parser/fuchsia/fuchsia_cpu_idle.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# Copyright 2026 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# Emits a Fuchsia trace holding kernel:sched context switches to and from the
+# idle thread, in both the weighted and the legacy encoding.
+
+import struct
+import sys
+from typing import NamedTuple
+
+# String indices interned below.
+INCOMING_WEIGHT = 1
+OUTGOING_WEIGHT = 2
+
+# Weight identifying the idle thread in weighted context switches.
+IDLE_WEIGHT = -2**31
+
+WEIGHTED_CPU = 2
+LEGACY_CPU = 5
+
+
+class WeightedThread(NamedTuple):
+  tid: int
+  weight: int
+
+
+class LegacyThread(NamedTuple):
+  pid: int
+  tid: int
+  priority: int
+
+
+IDLE_WEIGHTED_THREAD = WeightedThread(tid=0, weight=IDLE_WEIGHT)
+IDLE_LEGACY_THREAD = LegacyThread(pid=0, tid=0, priority=0)
+
+
+def push_word(w):
+  sys.stdout.buffer.write(struct.pack('<Q', w))
+
+
+def push_string(index, s):
+  s_bytes = s.encode('utf-8')
+  s_len = len(s_bytes)
+  num_words = 1 + (s_len + 7) // 8
+  header = (s_len << 32) | (index << 16) | (num_words << 4) | 2
+  push_word(header)
+  padded = s_bytes.ljust((num_words - 1) * 8, b'\x00')
+  for i in range(0, len(padded), 8):
+    push_word(struct.unpack('<Q', padded[i:i + 8])[0])
+
+
+def int32_arg(name_ref, value):
+  return ((value & 0xffffffff) << 32) | (name_ref << 16) | (1 << 4) | 1
+
+
+def push_context_switch(ts, cpu, outgoing: WeightedThread,
+                        incoming: WeightedThread):
+  # record_type = 8 (scheduler), event_type = 1 (context switch),
+  # outgoing_state = 2, argument_count = 2, 6 words.
+  push_word((1 << 60) | (2 << 36) | (cpu << 20) | (2 << 16) | (6 << 4) | 8)
+  push_word(ts)
+  push_word(outgoing.tid)
+  push_word(incoming.tid)
+  push_word(int32_arg(INCOMING_WEIGHT, incoming.weight))
+  push_word(int32_arg(OUTGOING_WEIGHT, outgoing.weight))
+
+
+def push_legacy_context_switch(ts, cpu, outgoing: LegacyThread,
+                               incoming: LegacyThread):
+  # record_type = 8 (scheduler), event_type = 0 (legacy context switch),
+  # outgoing_state = 2, inline thread refs, 6 words.
+  push_word((0 << 60) | (incoming.priority << 52) | (outgoing.priority << 44)
+            | (2 << 24) | (cpu << 16) | (6 << 4) | 8)
+  push_word(ts)
+  push_word(outgoing.pid)
+  push_word(outgoing.tid)
+  push_word(incoming.pid)
+  push_word(incoming.tid)
+
+
+def main():
+  # Fuchsia trace magic word: 0x0016547846040010
+  sys.stdout.buffer.write(b'\x10\x00\x04\x46\x78\x54\x16\x00')
+
+  push_string(INCOMING_WEIGHT, 'incoming_weight')
+  push_string(OUTGOING_WEIGHT, 'outgoing_weight')
+
+  # Weighted context switches: the idle thread carries the idle weight.
+  # Leaving idle marks the core active.
+  push_context_switch(
+      1000,
+      WEIGHTED_CPU,
+      outgoing=IDLE_WEIGHTED_THREAD,
+      incoming=WeightedThread(tid=101, weight=0))
+  # Switching between two running threads leaves the idle state untouched.
+  push_context_switch(
+      2000,
+      WEIGHTED_CPU,
+      outgoing=WeightedThread(tid=101, weight=0),
+      incoming=WeightedThread(tid=102, weight=10))
+  # Entering idle marks the core idle.
+  push_context_switch(
+      3000,
+      WEIGHTED_CPU,
+      outgoing=WeightedThread(tid=102, weight=10),
+      incoming=IDLE_WEIGHTED_THREAD)
+  # Switching from idle to idle emits nothing.
+  push_context_switch(
+      3500,
+      WEIGHTED_CPU,
+      outgoing=IDLE_WEIGHTED_THREAD,
+      incoming=IDLE_WEIGHTED_THREAD)
+
+  # Legacy context switches: the idle thread is identified by pid 0 and
+  # priority 0.
+  push_legacy_context_switch(
+      4000,
+      LEGACY_CPU,
+      outgoing=IDLE_LEGACY_THREAD,
+      incoming=LegacyThread(pid=1, tid=501, priority=1))
+  # Switching between two running threads leaves the idle state untouched.
+  push_legacy_context_switch(
+      4500,
+      LEGACY_CPU,
+      outgoing=LegacyThread(pid=1, tid=501, priority=1),
+      incoming=LegacyThread(pid=1, tid=502, priority=1))
+  push_legacy_context_switch(
+      5000,
+      LEGACY_CPU,
+      outgoing=LegacyThread(pid=1, tid=502, priority=1),
+      incoming=IDLE_LEGACY_THREAD)
+  push_legacy_context_switch(
+      5500,
+      LEGACY_CPU,
+      outgoing=IDLE_LEGACY_THREAD,
+      incoming=IDLE_LEGACY_THREAD)
+
+
+if __name__ == '__main__':
+  main()
diff --git a/test/trace_processor/diff_tests/parser/fuchsia/tests.py b/test/trace_processor/diff_tests/parser/fuchsia/tests.py
index 749e89d9a3c..d2880bff5de 100644
--- a/test/trace_processor/diff_tests/parser/fuchsia/tests.py
+++ b/test/trace_processor/diff_tests/parser/fuchsia/tests.py
@@ -133,6 +133,7 @@ def test_fuchsia_smoke_counters(self):
           value,
           name
         FROM counters
+        WHERE name = 'cpu_usage:average_cpu_percentage:0'
         LIMIT 10;
         """,
         out=Csv("""
@@ -174,23 +175,18 @@ def test_fuchsia_smoke_type(self):
         trace=DataPath('fuchsia_trace.fxt'),
         query="""
         SELECT
-          id,
-          name
+          type,
+          name,
+          count(*) AS count
         FROM track
-        LIMIT 10;
+        GROUP BY type, name
+        ORDER BY type, name;
         """,
         out=Csv("""
-        "id","name"
-        0,"[NULL]"
-        1,"[NULL]"
-        2,"[NULL]"
-        3,"[NULL]"
-        4,"[NULL]"
-        5,"cpu_usage:average_cpu_percentage:0"
-        6,"[NULL]"
-        7,"[NULL]"
-        8,"[NULL]"
-        9,"[NULL]"
+        "type","name","count"
+        "cpu_idle","cpuidle",4
+        "fuchsia_counter","cpu_usage:average_cpu_percentage:0",1
+        "thread_execution","[NULL]",16
         """))
 
   # Smoke test a high-CPU trace.
@@ -291,3 +287,100 @@ def test_fuchsia_critical_path(self):
         trace=DataPath('fuchsia_trace_sched_with_waker.fxt'),
         query=Path('fuchsia_critical_path.sql'),
         out=Path('fuchsia_critical_path.out'))
+
+  # Every core emitting a valid "power" / "cpu_frequency" event gets a standard
+  # cpufreq track. Cores 1, 2 and 6 only emit events violating the contract, so
+  # they get no track.
+  def test_fuchsia_cpu_frequency_tracks(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_frequency.py'),
+        query="""
+        SELECT cpu, name, type
+        FROM cpu_counter_track
+        WHERE type = 'cpu_frequency'
+        ORDER BY cpu;
+        """,
+        out=Csv("""
+        "cpu","name","type"
+        0,"cpufreq","cpu_frequency"
+        3,"cpufreq","cpu_frequency"
+        4,"cpufreq","cpu_frequency"
+        5,"cpufreq","cpu_frequency"
+        """))
+
+  # The counters on a cpufreq track carry the emitted kHz values, whether the
+  # driver encoded them as an integer or as a double.
+  def test_fuchsia_cpu_frequency_counter_values(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_frequency.py'),
+        query="""
+        SELECT t.cpu, c.ts, c.value
+        FROM counter AS c
+        JOIN cpu_counter_track AS t ON c.track_id = t.id
+        WHERE t.type = 'cpu_frequency'
+        ORDER BY t.cpu, c.ts;
+        """,
+        out=Csv("""
+        "cpu","ts","value"
+        0,1000,1996800.000000
+        0,3000,1190400.000000
+        3,2000,2688000.000000
+        4,5000,1804800.000000
+        5,4000,2800000.000000
+        """))
+
+  # Frequencies which are negative, non-finite or not numbers, and records
+  # naming no core, an out of range core or repeating an argument, are dropped
+  # and counted rather than silently disappearing.
+  def test_fuchsia_cpu_frequency_invalid_events(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_frequency.py'),
+        query="""
+        SELECT name, value
+        FROM stats
+        WHERE name = 'fuchsia_invalid_event';
+        """,
+        out=Csv("""
+        "name","value"
+        "fuchsia_invalid_event",11
+        """))
+
+  # Every core context-switching to and from the idle thread gets a standard
+  # cpuidle track.
+  def test_fuchsia_cpu_idle_tracks(self):
+    return DiffTestBlueprint(
+        trace=DataPath('fuchsia_trace_sched.fxt'),
+        query="""
+        SELECT cpu, name, type
+        FROM cpu_counter_track
+        WHERE type = 'cpu_idle'
+        ORDER BY cpu;
+        """,
+        out=Csv("""
+        "cpu","name","type"
+        0,"cpuidle","cpu_idle"
+        1,"cpuidle","cpu_idle"
+        2,"cpuidle","cpu_idle"
+        3,"cpuidle","cpu_idle"
+        """))
+
+  # Entering idle pushes 0 and leaving idle pushes 0xFFFFFFFF, for both the
+  # weighted (CPU 2) and the legacy (CPU 5) context switch encoding. Switches
+  # which do not change the idle state of the core push nothing.
+  def test_fuchsia_cpu_idle_counter_values(self):
+    return DiffTestBlueprint(
+        trace=Path('fuchsia_cpu_idle.py'),
+        query="""
+        SELECT t.cpu, c.ts, c.value
+        FROM counter AS c
+        JOIN cpu_counter_track AS t ON c.track_id = t.id
+        WHERE t.type = 'cpu_idle'
+        ORDER BY t.cpu, c.ts;
+        """,
+        out=Csv("""
+        "cpu","ts","value"
+        2,1000,4294967295.000000
+        2,3000,0.000000
+        5,4000,4294967295.000000
+        5,5000,0.000000
+        """))