if (INTEL_GEN(dev_priv) <= 7)
                sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS,
-                                      &rc6vids);
+                                      &rc6vids, NULL);
 
        seq_printf(m, "RC1e Enabled: %s\n",
                   yesno(rcctl1 & GEN6_RC_CTL_RC1e_ENABLE));
                ia_freq = gpu_freq;
                sandybridge_pcode_read(dev_priv,
                                       GEN6_PCODE_READ_MIN_FREQ_TABLE,
-                                      &ia_freq);
+                                      &ia_freq, NULL);
                seq_printf(m, "%d\t\t%d\t\t\t\t%d\n",
                           intel_gpu_freq(dev_priv, (gpu_freq *
                                                     (IS_GEN9_BC(dev_priv) ||
 
                val = 0; /* data0 to be programmed to 0 for first set */
                ret = sandybridge_pcode_read(dev_priv,
                                             GEN9_PCODE_READ_MEM_LATENCY,
-                                            &val);
+                                            &val, NULL);
 
                if (ret) {
                        DRM_ERROR("SKL Mailbox read error = %d\n", ret);
                val = 1; /* data0 to be programmed to 1 for second set */
                ret = sandybridge_pcode_read(dev_priv,
                                             GEN9_PCODE_READ_MEM_LATENCY,
-                                            &val);
+                                            &val, NULL);
                if (ret) {
                        DRM_ERROR("SKL Mailbox read error = %d\n", ret);
                        return;
 
                if (sandybridge_pcode_read(dev_priv,
                                           HSW_PCODE_DYNAMIC_DUTY_CYCLE_CONTROL,
-                                          &ddcc_status) == 0)
+                                          &ddcc_status, NULL) == 0)
                        rps->efficient_freq =
                                clamp_t(u8,
                                        ((ddcc_status >> 8) & 0xff),
                   GEN6_RC_CTL_HW_ENABLE);
 
        rc6vids = 0;
-       ret = sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS, &rc6vids);
+       ret = sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS,
+                                    &rc6vids, NULL);
        if (IS_GEN(dev_priv, 6) && ret) {
                DRM_DEBUG_DRIVER("Couldn't check for BIOS workaround\n");
        } else if (IS_GEN(dev_priv, 6) && (GEN6_DECODE_RC6_VID(rc6vids & 0xff) < 450)) {
            IS_IVYBRIDGE(dev_priv) || IS_HASWELL(dev_priv)) {
                u32 params = 0;
 
-               sandybridge_pcode_read(dev_priv, GEN6_READ_OC_PARAMS, ¶ms);
+               sandybridge_pcode_read(dev_priv, GEN6_READ_OC_PARAMS,
+                                      ¶ms, NULL);
                if (params & BIT(31)) { /* OC supported */
                        DRM_DEBUG_DRIVER("Overclocking supported, max: %dMHz, overclock: %dMHz\n",
                                         (rps->max_freq & 0xff) * 50,
 
 }
 
 static int __sandybridge_pcode_rw(struct drm_i915_private *i915,
-                                 u32 mbox, u32 *val,
+                                 u32 mbox, u32 *val, u32 *val1,
                                  int fast_timeout_us,
                                  int slow_timeout_ms,
                                  bool is_read)
                return -EAGAIN;
 
        intel_uncore_write_fw(uncore, GEN6_PCODE_DATA, *val);
-       intel_uncore_write_fw(uncore, GEN6_PCODE_DATA1, 0);
+       intel_uncore_write_fw(uncore, GEN6_PCODE_DATA1, val1 ? *val1 : 0);
        intel_uncore_write_fw(uncore,
                              GEN6_PCODE_MAILBOX, GEN6_PCODE_READY | mbox);
 
 
        if (is_read)
                *val = intel_uncore_read_fw(uncore, GEN6_PCODE_DATA);
+       if (is_read && val1)
+               *val1 = intel_uncore_read_fw(uncore, GEN6_PCODE_DATA1);
 
        if (INTEL_GEN(i915) > 6)
                return gen7_check_mailbox_status(mbox);
                return gen6_check_mailbox_status(mbox);
 }
 
-int sandybridge_pcode_read(struct drm_i915_private *i915, u32 mbox, u32 *val)
+int sandybridge_pcode_read(struct drm_i915_private *i915, u32 mbox,
+                          u32 *val, u32 *val1)
 {
        int err;
 
        mutex_lock(&i915->sb_lock);
-       err = __sandybridge_pcode_rw(i915, mbox, val,
+       err = __sandybridge_pcode_rw(i915, mbox, val, val1,
                                     500, 0,
                                     true);
        mutex_unlock(&i915->sb_lock);
        int err;
 
        mutex_lock(&i915->sb_lock);
-       err = __sandybridge_pcode_rw(i915, mbox, &val,
+       err = __sandybridge_pcode_rw(i915, mbox, &val, NULL,
                                     fast_timeout_us, slow_timeout_ms,
                                     false);
        mutex_unlock(&i915->sb_lock);
                                  u32 request, u32 reply_mask, u32 reply,
                                  u32 *status)
 {
-       *status = __sandybridge_pcode_rw(i915, mbox, &request,
+       *status = __sandybridge_pcode_rw(i915, mbox, &request, NULL,
                                         500, 0,
                                         true);
 
 
 void intel_sbi_write(struct drm_i915_private *i915, u16 reg, u32 value,
                     enum intel_sbi_destination destination);
 
-int sandybridge_pcode_read(struct drm_i915_private *i915, u32 mbox, u32 *val);
+int sandybridge_pcode_read(struct drm_i915_private *i915, u32 mbox,
+                          u32 *val, u32 *val1);
 int sandybridge_pcode_write_timeout(struct drm_i915_private *i915, u32 mbox,
                                    u32 val, int fast_timeout_us,
                                    int slow_timeout_ms);