diff --git a/drivers/hwmon/w83795.c b/drivers/hwmon/w83795.c
index 511bced..6464a52 100644
--- a/drivers/hwmon/w83795.c
+++ b/drivers/hwmon/w83795.c
@@ -371,6 +371,7 @@
 	u8 beeps[6];		/* Register value */
 
 	char valid;
+	char valid_limits;
 };
 
 /*
@@ -498,6 +499,8 @@
 	/* Read beep settings */
 	for (i = 0; i < ARRAY_SIZE(data->beeps); i++)
 		data->beeps[i] = w83795_read(client, W83795_REG_BEEP(i));
+
+	data->valid_limits = 1;
 }
 
 static void w83795_update_pwm_config(struct i2c_client *client)
@@ -564,6 +567,9 @@
 
 	mutex_lock(&data->update_lock);
 
+	if (!data->valid_limits)
+		w83795_update_limits(client);
+
 	if (!(time_after(jiffies, data->last_updated + HZ * 2)
 	      || !data->valid))
 		goto END;
@@ -2017,7 +2023,6 @@
 	}
 
 	data->has_gain = w83795_read(client, W83795_REG_VMIGB_CTRL) & 0x0f;
-	w83795_update_limits(client);
 
 	/* pwm and smart fan */
 	if (data->chip_type == w83795g)
