// SPDX-License-Identifier: GPL-2.0-only
/*
 * IOSF-SB MailBox Interface Driver
 * Copyright (c) 2013, Intel Corporation.
 *
 * The IOSF-SB is a fabric bus available on Atom based SOC's that uses a
 * mailbox interface (MBI) to communicate with multiple devices. This
 * driver implements access to this interface for those platforms that can
 * enumerate the device using PCI.
 */

#include <linux/delay.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/pci.h>
#include <linux/debugfs.h>
#include <linux/capability.h>
#include <linux/pm_qos.h>
#include <linux/wait.h>

#include <asm/iosf_mbi.h>

#define PCI_DEVICE_ID_INTEL_BAYTRAIL  0x0F00
#define PCI_DEVICE_ID_INTEL_BRASWELL  0x2280
#define PCI_DEVICE_ID_INTEL_QUARK_X1000  0x0958
#define PCI_DEVICE_ID_INTEL_TANGIER  0x1170

static struct pci_dev *mbi_pdev;
static DEFINE_SPINLOCK(iosf_mbi_lock);

/**************** Generic iosf_mbi access helpers ****************/

static inline u32 iosf_mbi_form_mcr(u8 op, u8 port, u8 offset)
{
 return (op << 24) | (port << 16) | (offset << 8) | MBI_ENABLE;
}

static int iosf_mbi_pci_read_mdr(u32 mcrx, u32 mcr, u32 *mdr)
{
 int result;

 if (!mbi_pdev)
  return -ENODEV;

 if (mcrx) {
  result = pci_write_config_dword(mbi_pdev, MBI_MCRX_OFFSET,
      mcrx);
  if (result < 0)
   goto fail_read;
 }

 result = pci_write_config_dword(mbi_pdev, MBI_MCR_OFFSET, mcr);
 if (result < 0)
  goto fail_read;

 result = pci_read_config_dword(mbi_pdev, MBI_MDR_OFFSET, mdr);
 if (result < 0)
  goto fail_read;

 return 0;

fail_read:
 dev_err(&mbi_pdev->dev, "PCI config access failed with %d\n", result);
 return pcibios_err_to_errno(result);
}

static int iosf_mbi_pci_write_mdr(u32 mcrx, u32 mcr, u32 mdr)
{
 int result;

 if (!mbi_pdev)
  return -ENODEV;

 result = pci_write_config_dword(mbi_pdev, MBI_MDR_OFFSET, mdr);
 if (result < 0)
  goto fail_write;

 if (mcrx) {
  result = pci_write_config_dword(mbi_pdev, MBI_MCRX_OFFSET,
      mcrx);
  if (result < 0)
   goto fail_write;
 }

 result = pci_write_config_dword(mbi_pdev, MBI_MCR_OFFSET, mcr);
 if (result < 0)
  goto fail_write;

 return 0;

fail_write:
 dev_err(&mbi_pdev->dev, "PCI config access failed with %d\n", result);
 return pcibios_err_to_errno(result);
}

int iosf_mbi_read(u8 port, u8 opcode, u32 offset, u32 *mdr)
{
 u32 mcr, mcrx;
 unsigned long flags;
 int ret;

 /* Access to the GFX unit is handled by GPU code */
 if (port == BT_MBI_UNIT_GFX) {
  WARN_ON(1);
  return -EPERM;
 }

 mcr = iosf_mbi_form_mcr(opcode, port, offset & MBI_MASK_LO);
 mcrx = offset & MBI_MASK_HI;

 spin_lock_irqsave(&iosf_mbi_lock, flags);
 ret = iosf_mbi_pci_read_mdr(mcrx, mcr, mdr);
 spin_unlock_irqrestore(&iosf_mbi_lock, flags);

 return ret;
}
EXPORT_SYMBOL(iosf_mbi_read);

int iosf_mbi_write(u8 port, u8 opcode, u32 offset, u32 mdr)
{
 u32 mcr, mcrx;
 unsigned long flags;
 int ret;

 /* Access to the GFX unit is handled by GPU code */
 if (port == BT_MBI_UNIT_GFX) {
  WARN_ON(1);
  return -EPERM;
 }

 mcr = iosf_mbi_form_mcr(opcode, port, offset & MBI_MASK_LO);
 mcrx = offset & MBI_MASK_HI;

 spin_lock_irqsave(&iosf_mbi_lock, flags);
 ret = iosf_mbi_pci_write_mdr(mcrx, mcr, mdr);
 spin_unlock_irqrestore(&iosf_mbi_lock, flags);

 return ret;
}
EXPORT_SYMBOL(iosf_mbi_write);

int iosf_mbi_modify(u8 port, u8 opcode, u32 offset, u32 mdr, u32 mask)
{
 u32 mcr, mcrx;
 u32 value;
 unsigned long flags;
 int ret;

 /* Access to the GFX unit is handled by GPU code */
 if (port == BT_MBI_UNIT_GFX) {
  WARN_ON(1);
  return -EPERM;
 }

 mcr = iosf_mbi_form_mcr(opcode, port, offset & MBI_MASK_LO);
 mcrx = offset & MBI_MASK_HI;

 spin_lock_irqsave(&iosf_mbi_lock, flags);

 /* Read current mdr value */
 ret = iosf_mbi_pci_read_mdr(mcrx, mcr & MBI_RD_MASK, &value);
 if (ret < 0) {
  spin_unlock_irqrestore(&iosf_mbi_lock, flags);
  return ret;
 }

 /* Apply mask */
 value &= ~mask;
 mdr &= mask;
 value |= mdr;

 /* Write back */
 ret = iosf_mbi_pci_write_mdr(mcrx, mcr | MBI_WR_MASK, value);

 spin_unlock_irqrestore(&iosf_mbi_lock, flags);

 return ret;
}
EXPORT_SYMBOL(iosf_mbi_modify);

bool iosf_mbi_available(void)
{
 /* Mbi isn't hot-pluggable. No remove routine is provided */
 return mbi_pdev;
}
EXPORT_SYMBOL(iosf_mbi_available);

/*
 **************** P-Unit/kernel shared I2C bus arbitration ****************
 *
 * Some Bay Trail and Cherry Trail devices have the P-Unit and us (the kernel)
 * share a single I2C bus to the PMIC. Below are helpers to arbitrate the
 * accesses between the kernel and the P-Unit.
 *
 * See arch/x86/include/asm/iosf_mbi.h for kernel-doc text for each function.
 */

#define SEMAPHORE_TIMEOUT  500
#define PUNIT_SEMAPHORE_BYT  0x7
#define PUNIT_SEMAPHORE_CHT  0x10e
#define PUNIT_SEMAPHORE_BIT  BIT(0)
#define PUNIT_SEMAPHORE_ACQUIRE  BIT(1)

static DEFINE_MUTEX(iosf_mbi_pmic_access_mutex);
static BLOCKING_NOTIFIER_HEAD(iosf_mbi_pmic_bus_access_notifier);
static DECLARE_WAIT_QUEUE_HEAD(iosf_mbi_pmic_access_waitq);
static u32 iosf_mbi_pmic_punit_access_count;
static u32 iosf_mbi_pmic_i2c_access_count;
static u32 iosf_mbi_sem_address;
static unsigned long iosf_mbi_sem_acquired;
static struct pm_qos_request iosf_mbi_pm_qos;

void iosf_mbi_punit_acquire(void)
{
 /* Wait for any I2C PMIC accesses from in kernel drivers to finish. */
 mutex_lock(&iosf_mbi_pmic_access_mutex);
 while (iosf_mbi_pmic_i2c_access_count != 0) {
  mutex_unlock(&iosf_mbi_pmic_access_mutex);
  wait_event(iosf_mbi_pmic_access_waitq,
      iosf_mbi_pmic_i2c_access_count == 0);
  mutex_lock(&iosf_mbi_pmic_access_mutex);
 }
 /*
  * We do not need to do anything to allow the PUNIT to safely access
  * the PMIC, other then block in kernel accesses to the PMIC.
 */
 iosf_mbi_pmic_punit_access_count++;
 mutex_unlock(&iosf_mbi_pmic_access_mutex);
}
EXPORT_SYMBOL(iosf_mbi_punit_acquire);

void iosf_mbi_punit_release(void)
{
 bool do_wakeup;

 mutex_lock(&iosf_mbi_pmic_access_mutex);
 iosf_mbi_pmic_punit_access_count--;
 do_wakeup = iosf_mbi_pmic_punit_access_count == 0;
 mutex_unlock(&iosf_mbi_pmic_access_mutex);

 if (do_wakeup)
  wake_up(&iosf_mbi_pmic_access_waitq);
}
EXPORT_SYMBOL(iosf_mbi_punit_release);

static int iosf_mbi_get_sem(u32 *sem)
{
 int ret;

 ret = iosf_mbi_read(BT_MBI_UNIT_PMC, MBI_REG_READ,
       iosf_mbi_sem_address, sem);
 if (ret) {
  dev_err(&mbi_pdev->dev, "Error P-Unit semaphore read failed\n");
  return ret;
 }

 *sem &= PUNIT_SEMAPHORE_BIT;
 return 0;
}

static void iosf_mbi_reset_semaphore(void)
{
 if (iosf_mbi_modify(BT_MBI_UNIT_PMC, MBI_REG_READ,
       iosf_mbi_sem_address, 0, PUNIT_SEMAPHORE_BIT))
  dev_err(&mbi_pdev->dev, "Error P-Unit semaphore reset failed\n");

 cpu_latency_qos_update_request(&iosf_mbi_pm_qos, PM_QOS_DEFAULT_VALUE);

 blocking_notifier_call_chain(&iosf_mbi_pmic_bus_access_notifier,
         MBI_PMIC_BUS_ACCESS_END, NULL);
}

/*
 * This function blocks P-Unit accesses to the PMIC I2C bus, so that kernel
 * I2C code, such as e.g. a fuel-gauge driver, can access it safely.
 *
 * This function may be called by I2C controller code while an I2C driver has
 * already blocked P-Unit accesses because it wants them blocked over multiple
 * i2c-transfers, for e.g. read-modify-write of an I2C client register.
 *
 * To allow safe PMIC i2c bus accesses this function takes the following steps:
 *
 * 1) Some code sends request to the P-Unit which make it access the PMIC
 *    I2C bus. Testing has shown that the P-Unit does not check its internal
 *    PMIC bus semaphore for these requests. Callers of these requests call
 *    iosf_mbi_punit_acquire()/_release() around their P-Unit accesses, these
 *    functions increase/decrease iosf_mbi_pmic_punit_access_count, so first
 *    we wait for iosf_mbi_pmic_punit_access_count to become 0.
 *
 * 2) Check iosf_mbi_pmic_i2c_access_count, if access has already
 *    been blocked by another caller, we only need to increment
 *    iosf_mbi_pmic_i2c_access_count and we can skip the other steps.
 *
 * 3) Some code makes such P-Unit requests from atomic contexts where it
 *    cannot call iosf_mbi_punit_acquire() as that may sleep.
 *    As the second step we call a notifier chain which allows any code
 *    needing P-Unit resources from atomic context to acquire them before
 *    we take control over the PMIC I2C bus.
 *
 * 4) When CPU cores enter C6 or C7 the P-Unit needs to talk to the PMIC
 *    if this happens while the kernel itself is accessing the PMIC I2C bus
 *    the SoC hangs.
 *    As the third step we call cpu_latency_qos_update_request() to disallow the
 *    CPU to enter C6 or C7.
 *
 * 5) The P-Unit has a PMIC bus semaphore which we can request to stop
 *    autonomous P-Unit tasks from accessing the PMIC I2C bus while we hold it.
 *    As the fourth and final step we request this semaphore and wait for our
 *    request to be acknowledged.
 */
int iosf_mbi_block_punit_i2c_access(void)
{
 unsigned long start, end;
 int ret = 0;
 u32 sem;

 if (WARN_ON(!mbi_pdev || !iosf_mbi_sem_address))
  return -ENXIO;

 mutex_lock(&iosf_mbi_pmic_access_mutex);

 while (iosf_mbi_pmic_punit_access_count != 0) {
  mutex_unlock(&iosf_mbi_pmic_access_mutex);
  wait_event(iosf_mbi_pmic_access_waitq,
      iosf_mbi_pmic_punit_access_count == 0);
  mutex_lock(&iosf_mbi_pmic_access_mutex);
 }

 if (iosf_mbi_pmic_i2c_access_count > 0)
  goto success;

 blocking_notifier_call_chain(&iosf_mbi_pmic_bus_access_notifier,
         MBI_PMIC_BUS_ACCESS_BEGIN, NULL);

 /*
  * Disallow the CPU to enter C6 or C7 state, entering these states
  * requires the P-Unit to talk to the PMIC and if this happens while
  * we're holding the semaphore, the SoC hangs.
 */
 cpu_latency_qos_update_request(&iosf_mbi_pm_qos, 0);

 /* host driver writes to side band semaphore register */
 ret = iosf_mbi_write(BT_MBI_UNIT_PMC, MBI_REG_WRITE,
        iosf_mbi_sem_address, PUNIT_SEMAPHORE_ACQUIRE);
 if (ret) {
  dev_err(&mbi_pdev->dev, "Error P-Unit semaphore request failed\n");
  goto error;
 }

 /* host driver waits for bit 0 to be set in semaphore register */
 start = jiffies;
 end = start + msecs_to_jiffies(SEMAPHORE_TIMEOUT);
 do {
  ret = iosf_mbi_get_sem(&sem);
  if (!ret && sem) {
   iosf_mbi_sem_acquired = jiffies;
   dev_dbg(&mbi_pdev->dev, "P-Unit semaphore acquired after %ums\n",
    jiffies_to_msecs(jiffies - start));
   goto success;
  }

  usleep_range(1000, 2000);
 } while (time_before(jiffies, end));

 ret = -ETIMEDOUT;
 dev_err(&mbi_pdev->dev, "Error P-Unit semaphore timed out, resetting\n");
error:
 iosf_mbi_reset_semaphore();
 if (!iosf_mbi_get_sem(&sem))
  dev_err(&mbi_pdev->dev, "P-Unit semaphore: %d\n", sem);
success:
 if (!WARN_ON(ret))
  iosf_mbi_pmic_i2c_access_count++;

 mutex_unlock(&iosf_mbi_pmic_access_mutex);

 return ret;
}
EXPORT_SYMBOL(iosf_mbi_block_punit_i2c_access);

void iosf_mbi_unblock_punit_i2c_access(void)
{
 bool do_wakeup = false;

 mutex_lock(&iosf_mbi_pmic_access_mutex);
 iosf_mbi_pmic_i2c_access_count--;
 if (iosf_mbi_pmic_i2c_access_count == 0) {
  iosf_mbi_reset_semaphore();
  dev_dbg(&mbi_pdev->dev, "punit semaphore held for %ums\n",
   jiffies_to_msecs(jiffies - iosf_mbi_sem_acquired));
  do_wakeup = true;
 }
 mutex_unlock(&iosf_mbi_pmic_access_mutex);

 if (do_wakeup)
  wake_up(&iosf_mbi_pmic_access_waitq);
}
EXPORT_SYMBOL(iosf_mbi_unblock_punit_i2c_access);

int iosf_mbi_register_pmic_bus_access_notifier(struct notifier_block *nb)
{
 int ret;

 /* Wait for the bus to go inactive before registering */
 iosf_mbi_punit_acquire();
 ret = blocking_notifier_chain_register(
    &iosf_mbi_pmic_bus_access_notifier, nb);
 iosf_mbi_punit_release();

 return ret;
}
EXPORT_SYMBOL(iosf_mbi_register_pmic_bus_access_notifier);

int iosf_mbi_unregister_pmic_bus_access_notifier_unlocked(
 struct notifier_block *nb)
{
 iosf_mbi_assert_punit_acquired();

 return blocking_notifier_chain_unregister(
    &iosf_mbi_pmic_bus_access_notifier, nb);
}
EXPORT_SYMBOL(iosf_mbi_unregister_pmic_bus_access_notifier_unlocked);

void iosf_mbi_assert_punit_acquired(void)
{
 WARN_ON(iosf_mbi_pmic_punit_access_count == 0);
}
EXPORT_SYMBOL(iosf_mbi_assert_punit_acquired);

/**************** iosf_mbi debug code ****************/

#ifdef CONFIG_IOSF_MBI_DEBUG
static u32 dbg_mdr;
static u32 dbg_mcr;
static u32 dbg_mcrx;

static int mcr_get(void *data, u64 *val)
{
 *val = *(u32 *)data;
 return 0;
}

static int mcr_set(void *data, u64 val)
{
 u8 command = ((u32)val & 0xFF000000) >> 24,
    port    = ((u32)val & 0x00FF0000) >> 16,
    offset  = ((u32)val & 0x0000FF00) >> 8;
 int err;

 *(u32 *)data = val;

 if (!capable(CAP_SYS_RAWIO))
  return -EACCES;

 if (command & 1u)
  err = iosf_mbi_write(port,
          command,
          dbg_mcrx | offset,
          dbg_mdr);
 else
  err = iosf_mbi_read(port,
         command,
         dbg_mcrx | offset,
         &dbg_mdr);

 return err;
}
DEFINE_SIMPLE_ATTRIBUTE(iosf_mcr_fops, mcr_get, mcr_set , "%llx\n");

static struct dentry *iosf_dbg;

static void iosf_sideband_debug_init(void)
{
 iosf_dbg = debugfs_create_dir("iosf_sb", NULL);

 /* mdr */
 debugfs_create_x32("mdr", 0660, iosf_dbg, &dbg_mdr);

 /* mcrx */
 debugfs_create_x32("mcrx", 0660, iosf_dbg, &dbg_mcrx);

 /* mcr - initiates mailbox transaction */
 debugfs_create_file("mcr", 0660, iosf_dbg, &dbg_mcr, &iosf_mcr_fops);
}

static void iosf_debugfs_init(void)
{
 iosf_sideband_debug_init();
}

static void iosf_debugfs_remove(void)
{
 debugfs_remove_recursive(iosf_dbg);
}
#else
static inline void iosf_debugfs_init(void) { }
static inline void iosf_debugfs_remove(void) { }
#endif /* CONFIG_IOSF_MBI_DEBUG */

static int iosf_mbi_probe(struct pci_dev *pdev,
     const struct pci_device_id *dev_id)
{
 int ret;

 ret = pci_enable_device(pdev);
 if (ret < 0) {
  dev_err(&pdev->dev, "error: could not enable device\n");
  return ret;
 }

 mbi_pdev = pci_dev_get(pdev);
 iosf_mbi_sem_address = dev_id->driver_data;

 return 0;
}

static const struct pci_device_id iosf_mbi_pci_ids[] = {
 { PCI_DEVICE_DATA(INTEL, BAYTRAIL, PUNIT_SEMAPHORE_BYT) },
 { PCI_DEVICE_DATA(INTEL, BRASWELL, PUNIT_SEMAPHORE_CHT) },
 { PCI_DEVICE_DATA(INTEL, QUARK_X1000, 0) },
 { PCI_DEVICE_DATA(INTEL, TANGIER, 0) },
 { 0, },
};
MODULE_DEVICE_TABLE(pci, iosf_mbi_pci_ids);

static struct pci_driver iosf_mbi_pci_driver = {
 .name  = "iosf_mbi_pci",
 .probe  = iosf_mbi_probe,
 .id_table = iosf_mbi_pci_ids,
};

static int __init iosf_mbi_init(void)
{
 iosf_debugfs_init();

 cpu_latency_qos_add_request(&iosf_mbi_pm_qos, PM_QOS_DEFAULT_VALUE);

 return pci_register_driver(&iosf_mbi_pci_driver);
}

static void __exit iosf_mbi_exit(void)
{
 iosf_debugfs_remove();

 pci_unregister_driver(&iosf_mbi_pci_driver);
 pci_dev_put(mbi_pdev);
 mbi_pdev = NULL;

 cpu_latency_qos_remove_request(&iosf_mbi_pm_qos);
}

module_init(iosf_mbi_init);
module_exit(iosf_mbi_exit);

MODULE_AUTHOR("David E. Box <david.e.box@linux.intel.com>");
MODULE_DESCRIPTION("IOSF Mailbox Interface accessor");
MODULE_LICENSE("GPL v2");