diff --git a/audio/aidl/default/envReverb/EnvReverbSw.cpp b/audio/aidl/default/envReverb/EnvReverbSw.cpp
index 9d7159a..a107064 100644
--- a/audio/aidl/default/envReverb/EnvReverbSw.cpp
+++ b/audio/aidl/default/envReverb/EnvReverbSw.cpp
@@ -60,8 +60,7 @@
 namespace aidl::android::hardware::audio::effect {
 
 const std::string EnvReverbSw::kEffectName = "EnvReverbSw";
-const EnvironmentalReverb::Capability EnvReverbSw::kCapability = {
-        .maxDecayTimeMs = EnvironmentalReverb::MAX_DECAY_TIME_MS};
+const EnvironmentalReverb::Capability EnvReverbSw::kCapability;
 const Descriptor EnvReverbSw::kDescriptor = {
         .common = {.id = {.type = kEnvReverbTypeUUID,
                           .uuid = kEnvReverbSwImplUUID,
@@ -83,140 +82,16 @@
     RETURN_IF(Parameter::Specific::environmentalReverb != specific.getTag(), EX_ILLEGAL_ARGUMENT,
               "EffectNotSupported");
 
-    auto& erParam = specific.get<Parameter::Specific::environmentalReverb>();
-    auto tag = erParam.getTag();
-
-    switch (tag) {
-        case EnvironmentalReverb::roomLevelMb: {
-            RETURN_IF(mContext->setErRoomLevel(erParam.get<EnvironmentalReverb::roomLevelMb>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setRoomLevelFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::roomHfLevelMb: {
-            RETURN_IF(
-                    mContext->setErRoomHfLevel(erParam.get<EnvironmentalReverb::roomHfLevelMb>()) !=
-                            RetCode::SUCCESS,
-                    EX_ILLEGAL_ARGUMENT, "setRoomHfLevelFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::decayTimeMs: {
-            RETURN_IF(mContext->setErDecayTime(erParam.get<EnvironmentalReverb::decayTimeMs>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setDecayTimeFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::decayHfRatioPm: {
-            RETURN_IF(
-                    mContext->setErDecayHfRatio(
-                            erParam.get<EnvironmentalReverb::decayHfRatioPm>()) != RetCode::SUCCESS,
-                    EX_ILLEGAL_ARGUMENT, "setDecayHfRatioFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::levelMb: {
-            RETURN_IF(mContext->setErLevel(erParam.get<EnvironmentalReverb::levelMb>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setLevelFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::delayMs: {
-            RETURN_IF(mContext->setErDelay(erParam.get<EnvironmentalReverb::delayMs>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setDelayFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::diffusionPm: {
-            RETURN_IF(mContext->setErDiffusion(erParam.get<EnvironmentalReverb::diffusionPm>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setDiffusionFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::densityPm: {
-            RETURN_IF(mContext->setErDensity(erParam.get<EnvironmentalReverb::densityPm>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setDensityFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        case EnvironmentalReverb::bypass: {
-            RETURN_IF(mContext->setErBypass(erParam.get<EnvironmentalReverb::bypass>()) !=
-                              RetCode::SUCCESS,
-                      EX_ILLEGAL_ARGUMENT, "setBypassFailed");
-            return ndk::ScopedAStatus::ok();
-        }
-        default: {
-            LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
-            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
-                    EX_ILLEGAL_ARGUMENT, "EnvironmentalReverbTagNotSupported");
-        }
-    }
+    mSpecificParam = specific.get<Parameter::Specific::environmentalReverb>();
+    LOG(DEBUG) << __func__ << " success with: " << specific.toString();
+    return ndk::ScopedAStatus::ok();
 }
 
 ndk::ScopedAStatus EnvReverbSw::getParameterSpecific(const Parameter::Id& id,
                                                      Parameter::Specific* specific) {
     auto tag = id.getTag();
     RETURN_IF(Parameter::Id::environmentalReverbTag != tag, EX_ILLEGAL_ARGUMENT, "wrongIdTag");
-    auto erId = id.get<Parameter::Id::environmentalReverbTag>();
-    auto erIdTag = erId.getTag();
-    switch (erIdTag) {
-        case EnvironmentalReverb::Id::commonTag:
-            return getParameterEnvironmentalReverb(erId.get<EnvironmentalReverb::Id::commonTag>(),
-                                                   specific);
-        default:
-            LOG(ERROR) << __func__ << " unsupported tag: " << toString(erIdTag);
-            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
-                    EX_ILLEGAL_ARGUMENT, "EnvironmentalReverbTagNotSupported");
-    }
-}
-
-ndk::ScopedAStatus EnvReverbSw::getParameterEnvironmentalReverb(const EnvironmentalReverb::Tag& tag,
-                                                                Parameter::Specific* specific) {
-    RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
-    EnvironmentalReverb erParam;
-    switch (tag) {
-        case EnvironmentalReverb::roomLevelMb: {
-            erParam.set<EnvironmentalReverb::roomLevelMb>(mContext->getErRoomLevel());
-            break;
-        }
-        case EnvironmentalReverb::roomHfLevelMb: {
-            erParam.set<EnvironmentalReverb::roomHfLevelMb>(mContext->getErRoomHfLevel());
-            break;
-        }
-        case EnvironmentalReverb::decayTimeMs: {
-            erParam.set<EnvironmentalReverb::decayTimeMs>(mContext->getErDecayTime());
-            break;
-        }
-        case EnvironmentalReverb::decayHfRatioPm: {
-            erParam.set<EnvironmentalReverb::decayHfRatioPm>(mContext->getErDecayHfRatio());
-            break;
-        }
-        case EnvironmentalReverb::levelMb: {
-            erParam.set<EnvironmentalReverb::levelMb>(mContext->getErLevel());
-            break;
-        }
-        case EnvironmentalReverb::delayMs: {
-            erParam.set<EnvironmentalReverb::delayMs>(mContext->getErDelay());
-            break;
-        }
-        case EnvironmentalReverb::diffusionPm: {
-            erParam.set<EnvironmentalReverb::diffusionPm>(mContext->getErDiffusion());
-            break;
-        }
-        case EnvironmentalReverb::densityPm: {
-            erParam.set<EnvironmentalReverb::densityPm>(mContext->getErDensity());
-            break;
-        }
-        case EnvironmentalReverb::bypass: {
-            erParam.set<EnvironmentalReverb::bypass>(mContext->getErBypass());
-            break;
-        }
-        default: {
-            LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
-            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
-                    EX_ILLEGAL_ARGUMENT, "EnvironmentalReverbTagNotSupported");
-        }
-    }
-
-    specific->set<Parameter::Specific::environmentalReverb>(erParam);
+    specific->set<Parameter::Specific::environmentalReverb>(mSpecificParam);
     return ndk::ScopedAStatus::ok();
 }
 
diff --git a/audio/aidl/default/envReverb/EnvReverbSw.h b/audio/aidl/default/envReverb/EnvReverbSw.h
index f521215..b8761a6 100644
--- a/audio/aidl/default/envReverb/EnvReverbSw.h
+++ b/audio/aidl/default/envReverb/EnvReverbSw.h
@@ -32,120 +32,7 @@
         : EffectContext(statusDepth, common) {
         LOG(DEBUG) << __func__;
     }
-
-    RetCode setErRoomLevel(int roomLevel) {
-        if (roomLevel < EnvironmentalReverb::MIN_ROOM_LEVEL_MB ||
-            roomLevel > EnvironmentalReverb::MAX_ROOM_LEVEL_MB) {
-            LOG(ERROR) << __func__ << " invalid roomLevel: " << roomLevel;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new room level
-        mRoomLevel = roomLevel;
-        return RetCode::SUCCESS;
-    }
-    int getErRoomLevel() const { return mRoomLevel; }
-
-    RetCode setErRoomHfLevel(int roomHfLevel) {
-        if (roomHfLevel < EnvironmentalReverb::MIN_ROOM_HF_LEVEL_MB ||
-            roomHfLevel > EnvironmentalReverb::MAX_ROOM_HF_LEVEL_MB) {
-            LOG(ERROR) << __func__ << " invalid roomHfLevel: " << roomHfLevel;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new room HF level
-        mRoomHfLevel = roomHfLevel;
-        return RetCode::SUCCESS;
-    }
-    int getErRoomHfLevel() const { return mRoomHfLevel; }
-
-    RetCode setErDecayTime(int decayTime) {
-        if (decayTime < EnvironmentalReverb::MIN_DECAY_TIME_MS ||
-            decayTime > EnvironmentalReverb::MAX_DECAY_TIME_MS) {
-            LOG(ERROR) << __func__ << " invalid decayTime: " << decayTime;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new decay time
-        mDecayTime = decayTime;
-        return RetCode::SUCCESS;
-    }
-    int getErDecayTime() const { return mDecayTime; }
-
-    RetCode setErDecayHfRatio(int decayHfRatio) {
-        if (decayHfRatio < EnvironmentalReverb::MIN_DECAY_HF_RATIO_PM ||
-            decayHfRatio > EnvironmentalReverb::MAX_DECAY_HF_RATIO_PM) {
-            LOG(ERROR) << __func__ << " invalid decayHfRatio: " << decayHfRatio;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new decay HF ratio
-        mDecayHfRatio = decayHfRatio;
-        return RetCode::SUCCESS;
-    }
-    int getErDecayHfRatio() const { return mDecayHfRatio; }
-
-    RetCode setErLevel(int level) {
-        if (level < EnvironmentalReverb::MIN_LEVEL_MB ||
-            level > EnvironmentalReverb::MAX_LEVEL_MB) {
-            LOG(ERROR) << __func__ << " invalid level: " << level;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new level
-        mLevel = level;
-        return RetCode::SUCCESS;
-    }
-    int getErLevel() const { return mLevel; }
-
-    RetCode setErDelay(int delay) {
-        if (delay < EnvironmentalReverb::MIN_DELAY_MS ||
-            delay > EnvironmentalReverb::MAX_DELAY_MS) {
-            LOG(ERROR) << __func__ << " invalid delay: " << delay;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new delay
-        mDelay = delay;
-        return RetCode::SUCCESS;
-    }
-    int getErDelay() const { return mDelay; }
-
-    RetCode setErDiffusion(int diffusion) {
-        if (diffusion < EnvironmentalReverb::MIN_DIFFUSION_PM ||
-            diffusion > EnvironmentalReverb::MAX_DIFFUSION_PM) {
-            LOG(ERROR) << __func__ << " invalid diffusion: " << diffusion;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new diffusion
-        mDiffusion = diffusion;
-        return RetCode::SUCCESS;
-    }
-    int getErDiffusion() const { return mDiffusion; }
-
-    RetCode setErDensity(int density) {
-        if (density < EnvironmentalReverb::MIN_DENSITY_PM ||
-            density > EnvironmentalReverb::MAX_DENSITY_PM) {
-            LOG(ERROR) << __func__ << " invalid density: " << density;
-            return RetCode::ERROR_ILLEGAL_PARAMETER;
-        }
-        // TODO : Add implementation to apply new density
-        mDensity = density;
-        return RetCode::SUCCESS;
-    }
-    int getErDensity() const { return mDensity; }
-
-    RetCode setErBypass(bool bypass) {
-        // TODO : Add implementation to apply new bypass
-        mBypass = bypass;
-        return RetCode::SUCCESS;
-    }
-    bool getErBypass() const { return mBypass; }
-
-  private:
-    int mRoomLevel = EnvironmentalReverb::MIN_ROOM_LEVEL_MB;       // Default room level
-    int mRoomHfLevel = EnvironmentalReverb::MAX_ROOM_HF_LEVEL_MB;  // Default room hf level
-    int mDecayTime = 1000;                                         // Default decay time
-    int mDecayHfRatio = 500;                                       // Default decay hf ratio
-    int mLevel = EnvironmentalReverb::MIN_LEVEL_MB;                // Default level
-    int mDelay = 40;                                               // Default delay
-    int mDiffusion = EnvironmentalReverb::MAX_DIFFUSION_PM;        // Default diffusion
-    int mDensity = EnvironmentalReverb::MAX_DENSITY_PM;            // Default density
-    bool mBypass = false;                                          // Default bypass
+    // TODO: add specific context here
 };
 
 class EnvReverbSw final : public EffectImpl {
@@ -173,7 +60,7 @@
 
   private:
     std::shared_ptr<EnvReverbSwContext> mContext;
-    ndk::ScopedAStatus getParameterEnvironmentalReverb(const EnvironmentalReverb::Tag& tag,
-                                                       Parameter::Specific* specific);
+    /* parameters */
+    EnvironmentalReverb mSpecificParam;
 };
 }  // namespace aidl::android::hardware::audio::effect