Merge branches 'acpi-processor' and 'acpi-cppc'

* acpi-processor:
  ACPI / sleep: move acpi_processor_sleep to sleep.c
  ACPI / processor : add support for ACPI0010 processor container
  ACPI / processor_idle: replace PREFIX with pr_fmt

* acpi-cppc:
  ACPI / CPPC: use MRTT/MPAR to decide if/when a req can be sent
  ACPI / CPPC: replace writeX/readX to PCC with relaxed version
  mailbox: pcc: optimized pcc_send_data
  ACPI / CPPC: optimized cpc_read and cpc_write
  ACPI / CPPC: Optimize PCC Read Write operations

diff --combined drivers/mailbox/pcc.c
index 8f779a1,8f779a1,ac11a9b..0ddf638
--- 1/drivers/mailbox/pcc.c
--- 2/drivers/mailbox/pcc.c
--- 3/drivers/mailbox/pcc.c
+++ b/drivers/mailbox/pcc.c
@@@@ -63,6 -63,6 -63,7 +63,7 @@@@
   #include <linux/platform_device.h>
   #include <linux/mailbox_controller.h>
   #include <linux/mailbox_client.h>
++ #include <linux/io-64-nonatomic-lo-hi.h>
   
   #include "mailbox.h"
   
@@@@ -70,6 -70,6 -71,9 +71,9 @@@@
   
   static struct mbox_chan *pcc_mbox_channels;
   
++ /* Array of cached virtual address for doorbell registers */
++ static void __iomem **pcc_doorbell_vaddr;
++ 
   static struct mbox_controller pcc_mbox_ctrl = {};
   /**
    * get_pcc_channel - Given a PCC subspace idx, get
@@@@ -81,10 -81,10 -85,16 +85,10 @@@@
    */
   static struct mbox_chan *get_pcc_channel(int id)
   {
  -     struct mbox_chan *pcc_chan;
  -
        if (id < 0 || id > pcc_mbox_ctrl.num_chans)
                return ERR_PTR(-ENOENT);
   
  -     pcc_chan = (struct mbox_chan *)
  -             (unsigned long) pcc_mbox_channels +
  -             (id * sizeof(*pcc_chan));
  -
  -     return pcc_chan;
  +     return &pcc_mbox_channels[id];
   }
   
   /**
@@@@ -160,6 -160,6 -170,66 +164,66 @@@@ void pcc_mbox_free_channel(struct mbox_
   }
   EXPORT_SYMBOL_GPL(pcc_mbox_free_channel);
   
++ /*
++  * PCC can be used with perf critical drivers such as CPPC
++  * So it makes sense to locally cache the virtual address and
++  * use it to read/write to PCC registers such as doorbell register
++  *
++  * The below read_register and write_registers are used to read and
++  * write from perf critical registers such as PCC doorbell register
++  */
++ static int read_register(void __iomem *vaddr, u64 *val, unsigned int bit_width)
++ {
++      int ret_val = 0;
++ 
++      switch (bit_width) {
++      case 8:
++              *val = readb(vaddr);
++              break;
++      case 16:
++              *val = readw(vaddr);
++              break;
++      case 32:
++              *val = readl(vaddr);
++              break;
++      case 64:
++              *val = readq(vaddr);
++              break;
++      default:
++              pr_debug("Error: Cannot read register of %u bit width",
++                      bit_width);
++              ret_val = -EFAULT;
++              break;
++      }
++      return ret_val;
++ }
++ 
++ static int write_register(void __iomem *vaddr, u64 val, unsigned int bit_width)
++ {
++      int ret_val = 0;
++ 
++      switch (bit_width) {
++      case 8:
++              writeb(val, vaddr);
++              break;
++      case 16:
++              writew(val, vaddr);
++              break;
++      case 32:
++              writel(val, vaddr);
++              break;
++      case 64:
++              writeq(val, vaddr);
++              break;
++      default:
++              pr_debug("Error: Cannot write register of %u bit width",
++                      bit_width);
++              ret_val = -EFAULT;
++              break;
++      }
++      return ret_val;
++ }
++ 
   /**
    * pcc_send_data - Called from Mailbox Controller code. Used
    *           here only to ring the channel doorbell. The PCC client
@@@@ -175,21 -175,21 -245,39 +239,39 @@@@
   static int pcc_send_data(struct mbox_chan *chan, void *data)
   {
        struct acpi_pcct_hw_reduced *pcct_ss = chan->con_priv;
--      struct acpi_generic_address doorbell;
++      struct acpi_generic_address *doorbell;
        u64 doorbell_preserve;
        u64 doorbell_val;
        u64 doorbell_write;
++      u32 id = chan - pcc_mbox_channels;
++      int ret = 0;
++ 
++      if (id >= pcc_mbox_ctrl.num_chans) {
++              pr_debug("pcc_send_data: Invalid mbox_chan passed\n");
++              return -ENOENT;
++      }
   
--      doorbell = pcct_ss->doorbell_register;
++      doorbell = &pcct_ss->doorbell_register;
        doorbell_preserve = pcct_ss->preserve_mask;
        doorbell_write = pcct_ss->write_mask;
   
        /* Sync notification from OS to Platform. */
--      acpi_read(&doorbell_val, &doorbell);
--      acpi_write((doorbell_val & doorbell_preserve) | doorbell_write,
--                      &doorbell);
-- 
--      return 0;
++      if (pcc_doorbell_vaddr[id]) {
++              ret = read_register(pcc_doorbell_vaddr[id], &doorbell_val,
++                      doorbell->bit_width);
++              if (ret)
++                      return ret;
++              ret = write_register(pcc_doorbell_vaddr[id],
++                      (doorbell_val & doorbell_preserve) | doorbell_write,
++                      doorbell->bit_width);
++      } else {
++              ret = acpi_read(&doorbell_val, doorbell);
++              if (ret)
++                      return ret;
++              ret = acpi_write((doorbell_val & doorbell_preserve) | doorbell_write,
++                      doorbell);
++      }
++      return ret;
   }
   
   static const struct mbox_chan_ops pcc_chan_ops = {
@@@@ -265,14 -265,14 -353,29 +347,29 @@@@ static int __init acpi_pcc_probe(void
                return -ENOMEM;
        }
   
++      pcc_doorbell_vaddr = kcalloc(count, sizeof(void *), GFP_KERNEL);
++      if (!pcc_doorbell_vaddr) {
++              kfree(pcc_mbox_channels);
++              return -ENOMEM;
++      }
++ 
        /* Point to the first PCC subspace entry */
        pcct_entry = (struct acpi_subtable_header *) (
                (unsigned long) pcct_tbl + sizeof(struct acpi_table_pcct));
   
        for (i = 0; i < count; i++) {
++              struct acpi_generic_address *db_reg;
++              struct acpi_pcct_hw_reduced *pcct_ss;
                pcc_mbox_channels[i].con_priv = pcct_entry;
                pcct_entry = (struct acpi_subtable_header *)
                        ((unsigned long) pcct_entry + pcct_entry->length);
++ 
++              /* If doorbell is in system memory cache the virt address */
++              pcct_ss = (struct acpi_pcct_hw_reduced *)pcct_entry;
++              db_reg = &pcct_ss->doorbell_register;
++              if (db_reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
++                      pcc_doorbell_vaddr[i] = acpi_os_ioremap(db_reg->address,
++                                                      db_reg->bit_width/8);
        }
   
        pcc_mbox_ctrl.num_chans = count;