diff --git a/libril/ril_service.cpp b/libril/ril_service.cpp
index f67fe2b..51deb16 100644
--- a/libril/ril_service.cpp
+++ b/libril/ril_service.cpp
@@ -100,6 +100,19 @@
 #endif
 #endif
 
+namespace {
+
+int clampWarn(const char* name, const int value, const int min, const int max) {
+    const int clamped = (value < min) ? min : (value > max) ? max : value;
+    if (clamped != value) {
+        RLOGW("Clamping value %s (%i) into valid range [%i, %i]", name, value, min, max);
+    }
+    return clamped;
+}
+
+}
+
+
 void convertRilHardwareConfigListToHal(void *response, size_t responseLen,
         hidl_vec<HardwareConfig>& records);
 
@@ -7953,8 +7966,8 @@
                         rillCellInfo->CellInfo.lte.cellIdentityLte.earfcn;
                 cellInfoLte->signalStrengthLte.signalStrength =
                         rillCellInfo->CellInfo.lte.signalStrengthLte.signalStrength;
-                cellInfoLte->signalStrengthLte.rsrp =
-                        rillCellInfo->CellInfo.lte.signalStrengthLte.rsrp;
+                cellInfoLte->signalStrengthLte.rsrp = clampWarn("rsrp",
+                        rillCellInfo->CellInfo.lte.signalStrengthLte.rsrp, 44, 140);
                 cellInfoLte->signalStrengthLte.rsrq =
                         rillCellInfo->CellInfo.lte.signalStrengthLte.rsrq;
                 cellInfoLte->signalStrengthLte.rssnr =
