diff --git a/audio/aidl/default/equalizer/EqualizerSw.cpp b/audio/aidl/default/equalizer/EqualizerSw.cpp
index 0a6ac34..2814322 100644
--- a/audio/aidl/default/equalizer/EqualizerSw.cpp
+++ b/audio/aidl/default/equalizer/EqualizerSw.cpp
@@ -60,6 +60,7 @@
 namespace aidl::android::hardware::audio::effect {
 
 const std::string EqualizerSw::kEffectName = "EqualizerSw";
+
 const std::vector<Equalizer::BandFrequency> EqualizerSw::kBandFrequency = {{0, 30000, 120000},
                                                                            {1, 120001, 460000},
                                                                            {2, 460001, 1800000},
@@ -69,19 +70,34 @@
         {0, "Normal"},      {1, "Classical"}, {2, "Dance"}, {3, "Flat"}, {4, "Folk"},
         {5, "Heavy Metal"}, {6, "Hip Hop"},   {7, "Jazz"},  {8, "Pop"},  {9, "Rock"}};
 
-const Equalizer::Capability EqualizerSw::kEqCap = {.bandFrequencies = kBandFrequency,
-                                                   .presets = kPresets};
+/**
+ * Use the same min and max to build a capability represented by Range.
+ */
+const std::vector<Range::EqualizerRange> EqualizerSw::kRanges = {
+        MAKE_RANGE(Equalizer, preset, 0, EqualizerSw::kPresets.size() - 1),
+        MAKE_RANGE(Equalizer, bandLevels,
+                   std::vector<Equalizer::BandLevel>{Equalizer::BandLevel(
+                           {.index = 0, .levelMb = std::numeric_limits<int>::min()})},
+                   std::vector<Equalizer::BandLevel>{
+                           Equalizer::BandLevel({.index = EqualizerSwContext::kMaxBandNumber - 1,
+                                                 .levelMb = std::numeric_limits<int>::max()})}),
+        /* capability definition */
+        MAKE_RANGE(Equalizer, bandFrequencies, EqualizerSw::kBandFrequency,
+                   EqualizerSw::kBandFrequency),
+        MAKE_RANGE(Equalizer, presets, EqualizerSw::kPresets, EqualizerSw::kPresets),
+        /* centerFreqMh is get only, set invalid range min > max */
+        MAKE_RANGE(Equalizer, centerFreqMh, std::vector<int>({1}), std::vector<int>({0}))};
 
-const Descriptor EqualizerSw::kDesc = {
-        .common = {.id = {.type = kEqualizerTypeUUID,
-                          .uuid = kEqualizerSwImplUUID,
-                          .proxy = kEqualizerProxyUUID},
-                   .flags = {.type = Flags::Type::INSERT,
-                             .insert = Flags::Insert::FIRST,
-                             .volume = Flags::Volume::CTRL},
-                   .name = EqualizerSw::kEffectName,
-                   .implementor = "The Android Open Source Project"},
-        .capability = Capability::make<Capability::equalizer>(EqualizerSw::kEqCap)};
+const Capability EqualizerSw::kEqCap = {.range = EqualizerSw::kRanges};
+const Descriptor EqualizerSw::kDesc = {.common = {.id = {.type = kEqualizerTypeUUID,
+                                                         .uuid = kEqualizerSwImplUUID,
+                                                         .proxy = kEqualizerProxyUUID},
+                                                  .flags = {.type = Flags::Type::INSERT,
+                                                            .insert = Flags::Insert::FIRST,
+                                                            .volume = Flags::Volume::CTRL},
+                                                  .name = EqualizerSw::kEffectName,
+                                                  .implementor = "The Android Open Source Project"},
+                                       .capability = EqualizerSw::kEqCap};
 
 ndk::ScopedAStatus EqualizerSw::getDescriptor(Descriptor* _aidl_return) {
     LOG(DEBUG) << __func__ << kDesc.toString();
@@ -95,6 +111,7 @@
     RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
 
     auto& eqParam = specific.get<Parameter::Specific::equalizer>();
+    RETURN_IF(!inRange(eqParam, kRanges), EX_ILLEGAL_ARGUMENT, "outOfRange");
     auto tag = eqParam.getTag();
     switch (tag) {
         case Equalizer::preset: {
diff --git a/audio/aidl/default/equalizer/EqualizerSw.h b/audio/aidl/default/equalizer/EqualizerSw.h
index fabcfeb..f8987c7 100644
--- a/audio/aidl/default/equalizer/EqualizerSw.h
+++ b/audio/aidl/default/equalizer/EqualizerSw.h
@@ -34,7 +34,7 @@
     }
 
     RetCode setEqPreset(const int& presetIdx) {
-        if (presetIdx < 0 || presetIdx >= NUM_OF_PRESETS) {
+        if (presetIdx < 0 || presetIdx >= kMaxPresetNumber) {
             return RetCode::ERROR_ILLEGAL_PARAMETER;
         }
         mPreset = presetIdx;
@@ -43,13 +43,13 @@
     int getEqPreset() { return mPreset; }
 
     RetCode setEqBandLevels(const std::vector<Equalizer::BandLevel>& bandLevels) {
-        if (bandLevels.size() > NUM_OF_BANDS) {
-            LOG(ERROR) << __func__ << " return because size exceed " << NUM_OF_BANDS;
+        if (bandLevels.size() > kMaxBandNumber) {
+            LOG(ERROR) << __func__ << " return because size exceed " << kMaxBandNumber;
             return RetCode::ERROR_ILLEGAL_PARAMETER;
         }
         RetCode ret = RetCode::SUCCESS;
         for (auto& it : bandLevels) {
-            if (it.index >= NUM_OF_BANDS || it.index < 0) {
+            if (it.index >= kMaxBandNumber || it.index < 0) {
                 LOG(ERROR) << __func__ << " index illegal, skip: " << it.index << " - "
                            << it.levelMb;
                 ret = RetCode::ERROR_ILLEGAL_PARAMETER;
@@ -62,7 +62,7 @@
 
     std::vector<Equalizer::BandLevel> getEqBandLevels() {
         std::vector<Equalizer::BandLevel> bandLevels;
-        for (int i = 0; i < NUM_OF_BANDS; i++) {
+        for (int i = 0; i < kMaxBandNumber; i++) {
             bandLevels.push_back({i, mBandLevels[i]});
         }
         return bandLevels;
@@ -71,16 +71,16 @@
     std::vector<int> getCenterFreqs() {
         return {std::begin(kPresetsFrequencies), std::end(kPresetsFrequencies)};
     }
+    static const int kMaxBandNumber = 5;
+    static const int kMaxPresetNumber = 10;
+    static const int kCustomPreset = -1;
 
   private:
-    static const int NUM_OF_BANDS = 5;
-    static const int NUM_OF_PRESETS = 10;
-    static const int PRESET_CUSTOM = -1;
-    static constexpr std::array<uint16_t, NUM_OF_BANDS> kPresetsFrequencies = {60, 230, 910, 3600,
-                                                                               14000};
+    static constexpr std::array<uint16_t, kMaxBandNumber> kPresetsFrequencies = {60, 230, 910, 3600,
+                                                                                 14000};
     // preset band level
-    int mPreset = PRESET_CUSTOM;
-    int32_t mBandLevels[NUM_OF_BANDS] = {3, 0, 0, 0, 3};
+    int mPreset = kCustomPreset;
+    int32_t mBandLevels[kMaxBandNumber] = {3, 0, 0, 0, 3};
 
     // Add equalizer specific context for processing here
 };
@@ -88,9 +88,7 @@
 class EqualizerSw final : public EffectImpl {
   public:
     static const std::string kEffectName;
-    static const std::vector<Equalizer::BandFrequency> kBandFrequency;
-    static const std::vector<Equalizer::Preset> kPresets;
-    static const Equalizer::Capability kEqCap;
+    static const Capability kEqCap;
     static const Descriptor kDesc;
 
     EqualizerSw() { LOG(DEBUG) << __func__; }
@@ -112,6 +110,9 @@
     std::string getEffectName() override { return kEffectName; }
 
   private:
+    static const std::vector<Equalizer::BandFrequency> kBandFrequency;
+    static const std::vector<Equalizer::Preset> kPresets;
+    static const std::vector<Range::EqualizerRange> kRanges;
     ndk::ScopedAStatus getParameterEqualizer(const Equalizer::Tag& tag,
                                              Parameter::Specific* specific);
     std::shared_ptr<EqualizerSwContext> mContext;