diff --git a/audio/acdbdata/Handset_cal.acdb b/audio/acdbdata/Handset_cal.acdb
index 24e8b92..cdc22ed 100644
--- a/audio/acdbdata/Handset_cal.acdb
+++ b/audio/acdbdata/Handset_cal.acdb
Binary files differ
diff --git a/audio/acdbdata/workspaceFile.qwsp b/audio/acdbdata/workspaceFile.qwsp
index be2726b..794cc7e 100644
--- a/audio/acdbdata/workspaceFile.qwsp
+++ b/audio/acdbdata/workspaceFile.qwsp
Binary files differ
diff --git a/vibrator/drv2624/Vibrator.cpp b/vibrator/drv2624/Vibrator.cpp
index 823cc47..744f16e 100644
--- a/vibrator/drv2624/Vibrator.cpp
+++ b/vibrator/drv2624/Vibrator.cpp
@@ -60,7 +60,7 @@
 
 // UT team design those target G values
 static std::array<float, 5> EFFECT_TARGET_G = {0.275, 0.55, 0.6, 0.9, 1.12};
-static std::array<float, 3> STEADY_TARGET_G = {2.0, 1.145, 1.3};
+static std::array<float, 3> STEADY_TARGET_G = {2.15, 1.145, 1.3};
 
 struct SensorContext {
     ASensorEventQueue *queue;
