ACPI / CPPC: Make CPPC ACPI driver aware of PCC subspace IDs

Based on ACPI 6.2 Section 8.4.7.1.9 If the PCC register space is used,
all PCC registers, for all processors in the same performance domain
(as defined by _PSD), must be defined to be in the same subspace.

Based on Section 14.1 of ACPI specification, it is possible to have a
maximum of 256 PCC subspace IDs. Add support of multiple PCC subspace
ID instead of using a single global pcc_data structure.

While at that, fix the time_delta check in send_pcc_cmd() so that
last_mpar_reset and mpar_count are initialized properly.

Signed-off-by: George Cherian <george.cherian@cavium.com>
Reviewed-by: Prashanth Prakash <pprakash@codeaurora.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

1 files changed, 151 insertions, 89 deletions

diff --git a/drivers/acpi/cppc_acpi.c b/drivers/acpi/cppc_acpi.c
index e5b47f032d9a..21c28433c590 100644
--- a/drivers/acpi/cppc_acpi.c
+++ b/drivers/acpi/cppc_acpi.c
@@ -48,7 +48,6 @@
 struct cppc_pcc_data {
         struct mbox_chan *pcc_channel;
         void __iomem *pcc_comm_addr;
-        int pcc_subspace_idx;
         bool pcc_channel_acquired;
         ktime_t deadline;
         unsigned int pcc_mpar, pcc_mrtt, pcc_nominal;
@@ -75,13 +74,16 @@ struct cppc_pcc_data {
 
         /* Wait queue for CPUs whose requests were batched */
         wait_queue_head_t pcc_write_wait_q;
+        ktime_t last_cmd_cmpl_time;
+        ktime_t last_mpar_reset;
+        int mpar_count;
+        int refcount;
 };
 
-/* Structure to represent the single PCC channel */
-static struct cppc_pcc_data pcc_data = {
-        .pcc_subspace_idx = -1,
-        .platform_owns_pcc = true,
-};
+/* Array  to represent the PCC channel per subspace id */
+static struct cppc_pcc_data *pcc_data[MAX_PCC_SUBSPACES];
+/* The cpu_pcc_subspace_idx containsper CPU subspace id */
+static DEFINE_PER_CPU(int, cpu_pcc_subspace_idx);
 
 /*
  * The cpc_desc structure contains the ACPI register details
@@ -93,7 +95,8 @@ static struct cppc_pcc_data pcc_data = {
 static DEFINE_PER_CPU(struct cpc_desc *, cpc_desc_ptr);
 
 /* pcc mapped address + header size + offset within PCC subspace */
-#define GET_PCC_VADDR(offs) (pcc_data.pcc_comm_addr + 0x8 + (offs))
+#define GET_PCC_VADDR(offs, pcc_ss_id) (pcc_data[pcc_ss_id]->pcc_comm_addr + \
+                                                0x8 + (offs))
 
 /* Check if a CPC register is in PCC */
 #define CPC_IN_PCC(cpc) ((cpc)->type == ACPI_TYPE_BUFFER &&             \
@@ -188,13 +191,16 @@ static struct kobj_type cppc_ktype = {
         .default_attrs = cppc_attrs,
 };
 
-static int check_pcc_chan(bool chk_err_bit)
+static int check_pcc_chan(int pcc_ss_id, bool chk_err_bit)
 {
         int ret = -EIO, status = 0;
-        struct acpi_pcct_shared_memory __iomem *generic_comm_base = pcc_data.pcc_comm_addr;
-        ktime_t next_deadline = ktime_add(ktime_get(), pcc_data.deadline);
+        struct cppc_pcc_data *pcc_ss_data = pcc_data[pcc_ss_id];
+        struct acpi_pcct_shared_memory __iomem *generic_comm_base =
+                pcc_ss_data->pcc_comm_addr;
+        ktime_t next_deadline = ktime_add(ktime_get(),
+                                          pcc_ss_data->deadline);
 
-        if (!pcc_data.platform_owns_pcc)
+        if (!pcc_ss_data->platform_owns_pcc)
                 return 0;
 
         /* Retry in case the remote processor was too slow to catch up. */
@@ -219,7 +225,7 @@ static int check_pcc_chan(bool chk_err_bit)
         }
 
         if (likely(!ret))
-                pcc_data.platform_owns_pcc = false;
+                pcc_ss_data->platform_owns_pcc = false;
         else
                 pr_err("PCC check channel failed. Status=%x\n", status);
 
@@ -230,13 +236,12 @@ static int check_pcc_chan(bool chk_err_bit)
  * This function transfers the ownership of the PCC to the platform
  * So it must be called while holding write_lock(pcc_lock)
  */
-static int send_pcc_cmd(u16 cmd)
+static int send_pcc_cmd(int pcc_ss_id, u16 cmd)
 {
         int ret = -EIO, i;
+        struct cppc_pcc_data *pcc_ss_data = pcc_data[pcc_ss_id];
         struct acpi_pcct_shared_memory *generic_comm_base =
-                (struct acpi_pcct_shared_memory *) pcc_data.pcc_comm_addr;
-        static ktime_t last_cmd_cmpl_time, last_mpar_reset;
-        static int mpar_count;
+                (struct acpi_pcct_shared_memory *)pcc_ss_data->pcc_comm_addr;
         unsigned int time_delta;
 
         /*
@@ -249,24 +254,25 @@ static int send_pcc_cmd(u16 cmd)
                  * before write completion, so first send a WRITE command to
                  * platform
                  */
-                if (pcc_data.pending_pcc_write_cmd)
-                        send_pcc_cmd(CMD_WRITE);
+                if (pcc_ss_data->pending_pcc_write_cmd)
+                        send_pcc_cmd(pcc_ss_id, CMD_WRITE);
 
-                ret = check_pcc_chan(false);
+                ret = check_pcc_chan(pcc_ss_id, false);
                 if (ret)
                         goto end;
         } else /* CMD_WRITE */
-                pcc_data.pending_pcc_write_cmd = FALSE;
+                pcc_ss_data->pending_pcc_write_cmd = FALSE;
 
         /*
          * Handle the Minimum Request Turnaround Time(MRTT)
          * "The minimum amount of time that OSPM must wait after the completion
          * of a command before issuing the next command, in microseconds"
          */
-        if (pcc_data.pcc_mrtt) {
-                time_delta = ktime_us_delta(ktime_get(), last_cmd_cmpl_time);
-                if (pcc_data.pcc_mrtt > time_delta)
-                        udelay(pcc_data.pcc_mrtt - time_delta);
+        if (pcc_ss_data->pcc_mrtt) {
+                time_delta = ktime_us_delta(ktime_get(),
+                                            pcc_ss_data->last_cmd_cmpl_time);
+                if (pcc_ss_data->pcc_mrtt > time_delta)
+                        udelay(pcc_ss_data->pcc_mrtt - time_delta);
         }
 
         /*
@@ -280,18 +286,19 @@ static int send_pcc_cmd(u16 cmd)
          * not send the request to the platform after hitting the MPAR limit in
          * any 60s window
          */
-        if (pcc_data.pcc_mpar) {
-                if (mpar_count == 0) {
-                        time_delta = ktime_ms_delta(ktime_get(), last_mpar_reset);
-                        if (time_delta < 60 * MSEC_PER_SEC) {
+        if (pcc_ss_data->pcc_mpar) {
+                if (pcc_ss_data->mpar_count == 0) {
+                        time_delta = ktime_ms_delta(ktime_get(),
+                                                    pcc_ss_data->last_mpar_reset);
+                        if ((time_delta < 60 * MSEC_PER_SEC) && pcc_ss_data->last_mpar_reset) {
                                 pr_debug("PCC cmd not sent due to MPAR limit");
                                 ret = -EIO;
                                 goto end;
                         }
-                        last_mpar_reset = ktime_get();
-                        mpar_count = pcc_data.pcc_mpar;
+                        pcc_ss_data->last_mpar_reset = ktime_get();
+                        pcc_ss_data->mpar_count = pcc_ss_data->pcc_mpar;
                 }
-                mpar_count--;
+                pcc_ss_data->mpar_count--;
         }
 
         /* Write to the shared comm region. */
@@ -300,10 +307,10 @@ static int send_pcc_cmd(u16 cmd)
         /* Flip CMD COMPLETE bit */
         writew_relaxed(0, &generic_comm_base->status);
 
-        pcc_data.platform_owns_pcc = true;
+        pcc_ss_data->platform_owns_pcc = true;
 
         /* Ring doorbell */
-        ret = mbox_send_message(pcc_data.pcc_channel, &cmd);
+        ret = mbox_send_message(pcc_ss_data->pcc_channel, &cmd);
         if (ret < 0) {
                 pr_err("Err sending PCC mbox message. cmd:%d, ret:%d\n",
                                 cmd, ret);
@@ -311,15 +318,15 @@ static int send_pcc_cmd(u16 cmd)
         }
 
         /* wait for completion and check for PCC errro bit */
-        ret = check_pcc_chan(true);
+        ret = check_pcc_chan(pcc_ss_id, true);
 
-        if (pcc_data.pcc_mrtt)
-                last_cmd_cmpl_time = ktime_get();
+        if (pcc_ss_data->pcc_mrtt)
+                pcc_ss_data->last_cmd_cmpl_time = ktime_get();
 
-        if (pcc_data.pcc_channel->mbox->txdone_irq)
+        if (pcc