Merge tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM SoC driver updates from Olof Johansson:
 "As we've enabled multiplatform kernels on ARM, and greatly done away
  with the contents under arch/arm/mach-*, there's still need for
  SoC-related drivers to go somewhere.

  Many of them go in through other driver trees, but we still have
  drivers/soc to hold some of the "doesn't fit anywhere" lowlevel code
  that might be shared between ARM and ARM64 (or just in general makes
  sense to not have under the architecture directory).

  This branch contains mostly such code:

   - Drivers for qualcomm SoCs for SMEM, SMD and SMD-RPM, used to
     communicate with power management blocks on these SoCs for use by
     clock, regulator and bus frequency drivers.

   - Allwinner Reduced Serial Bus driver, again used to communicate with
     PMICs.

   - Drivers for ARM's SCPI (System Control Processor).  Not to be
     confused with PSCI (Power State Coordination Interface).  SCPI is
     used to communicate with the assistant embedded cores doing power
     management, and we have yet to see how many of them will implement
     this for their hardware vs abstracting in other ways (or not at all
     like in the past).

   - To make confusion between SCPI and PSCI more likely, this release
     also includes an update of PSCI to interface version 1.0.

   - Rockchip support for power domains.

   - A driver to talk to the firmware on Raspberry Pi"

* tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (57 commits)
  soc: qcom: smd-rpm: Correct size of outgoing message
  bus: sunxi-rsb: Add driver for Allwinner Reduced Serial Bus
  bus: sunxi-rsb: Add Allwinner Reduced Serial Bus (RSB) controller bindings
  ARM: bcm2835: add mutual inclusion protection
  drivers: psci: make PSCI 1.0 functions initialization version dependent
  dt-bindings: Correct paths in Rockchip power domains binding document
  soc: rockchip: power-domain: don't try to print the clock name in error case
  soc: qcom/smem: add HWSPINLOCK dependency
  clk: berlin: add cpuclk
  ARM: berlin: dts: add CLKID_CPU for BG2Q
  ARM: bcm2835: Add the Raspberry Pi firmware driver
  soc: qcom: smem: Move RPM message ram out of smem DT node
  soc: qcom: smd-rpm: Correct the active vs sleep state flagging
  soc: qcom: smd: delete unneeded of_node_put
  firmware: qcom-scm: build for correct architecture level
  soc: qcom: smd: Correct SMEM items for upper channels
  qcom-scm: add missing prototype for qcom_scm_is_available()
  qcom-scm: fix endianess issue in __qcom_scm_is_call_available
  soc: qcom: smd: Reject send of too big packets
  soc: qcom: smd: Handle big endian CPUs
  ...

6 files changed, 1161 insertions, 14 deletions

diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 665efca59487..cf478fe6b335 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -8,6 +8,25 @@ menu "Firmware Drivers"
 config ARM_PSCI_FW
         bool
 
+config ARM_SCPI_PROTOCOL
+        tristate "ARM System Control and Power Interface (SCPI) Message Protocol"
+        depends on ARM_MHU
+        help
+          System Control and Power Interface (SCPI) Message Protocol is
+          defined for the purpose of communication between the Application
+          Cores(AP) and the System Control Processor(SCP). The MHU peripheral
+          provides a mechanism for inter-processor communication between SCP
+          and AP.
+
+          SCP controls most of the power managament on the Application
+          Processors. It offers control and management of: the core/cluster
+          power states, various power domain DVFS including the core/cluster,
+          certain system clocks configuration, thermal sensors and many
+          others.
+
+          This protocol library provides interface for all the client drivers
+          making use of the features offered by the SCP.
+
 config EDD
         tristate "BIOS Enhanced Disk Drive calls determine boot disk"
         depends on X86
@@ -135,6 +154,13 @@ config ISCSI_IBFT
           detect iSCSI boot parameters dynamically during system boot, say Y.
           Otherwise, say N.
 
+config RASPBERRYPI_FIRMWARE
+        tristate "Raspberry Pi Firmware Driver"
+        depends on BCM2835_MBOX
+        help
+          This option enables support for communicating with the firmware on the
+          Raspberry Pi.
+
 config QCOM_SCM
         bool
         depends on ARM || ARM64
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 2ee83474a3c1..48dd4175297e 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -2,6 +2,7 @@
 # Makefile for the linux kernel.
 #
 obj-$(CONFIG_ARM_PSCI_FW)       += psci.o
+obj-$(CONFIG_ARM_SCPI_PROTOCOL) += arm_scpi.o
 obj-$(CONFIG_DMI)               += dmi_scan.o
 obj-$(CONFIG_DMI_SYSFS)         += dmi-sysfs.o
 obj-$(CONFIG_EDD)               += edd.o
@@ -12,10 +13,11 @@ obj-$(CONFIG_DMIID)		+= dmi-id.o
 obj-$(CONFIG_ISCSI_IBFT_FIND)   += iscsi_ibft_find.o
 obj-$(CONFIG_ISCSI_IBFT)        += iscsi_ibft.o
 obj-$(CONFIG_FIRMWARE_MEMMAP)   += memmap.o
+obj-$(CONFIG_RASPBERRYPI_FIRMWARE) += raspberrypi.o
 obj-$(CONFIG_QCOM_SCM)          += qcom_scm.o
 obj-$(CONFIG_QCOM_SCM_64)       += qcom_scm-64.o
 obj-$(CONFIG_QCOM_SCM_32)       += qcom_scm-32.o
-CFLAGS_qcom_scm-32.o :=$(call as-instr,.arch_extension sec,-DREQUIRES_SEC=1)
+CFLAGS_qcom_scm-32.o :=$(call as-instr,.arch armv7-a\n.arch_extension sec,-DREQUIRES_SEC=1) -march=armv7-a
 
 obj-y                           += broadcom/
 obj-$(CONFIG_GOOGLE_FIRMWARE)   += google/
diff --git a/drivers/firmware/arm_scpi.c b/drivers/firmware/arm_scpi.c
new file mode 100644
index 000000000000..6174db80c663
--- /dev/null
+++ b/drivers/firmware/arm_scpi.c
@@ -0,0 +1,771 @@
+/*
+ * System Control and Power Interface (SCPI) Message Protocol driver
+ *
+ * SCPI Message Protocol is used between the System Control Processor(SCP)
+ * and the Application Processors(AP). The Message Handling Unit(MHU)
+ * provides a mechanism for inter-processor communication between SCP's
+ * Cortex M3 and AP.
+ *
+ * SCP offers control and management of the core/cluster power states,
+ * various power domain DVFS including the core/cluster, certain system
+ * clocks configuration, thermal sensors and many others.
+ *
+ * Copyright (C) 2015 ARM Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/bitmap.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/mailbox_client.h>
+#include <linux/module.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/printk.h>
+#include <linux/scpi_protocol.h>
+#include <linux/slab.h>
+#include <linux/sort.h>
+#include <linux/spinlock.h>
+
+#define CMD_ID_SHIFT            0
+#define CMD_ID_MASK             0x7f
+#define CMD_TOKEN_ID_SHIFT      8
+#define CMD_TOKEN_ID_MASK       0xff
+#define CMD_DATA_SIZE_SHIFT     16
+#define CMD_DATA_SIZE_MASK      0x1ff
+#define PACK_SCPI_CMD(cmd_id, tx_sz)                    \
+        ((((cmd_id) & CMD_ID_MASK) << CMD_ID_SHIFT) |   \
+        (((tx_sz) & CMD_DATA_SIZE_MASK) << CMD_DATA_SIZE_SHIFT))
+#define ADD_SCPI_TOKEN(cmd, token)                      \
+        ((cmd) |= (((token) & CMD_TOKEN_ID_MASK) << CMD_TOKEN_ID_SHIFT))
+
+#define CMD_SIZE(cmd)   (((cmd) >> CMD_DATA_SIZE_SHIFT) & CMD_DATA_SIZE_MASK)
+#define CMD_UNIQ_MASK   (CMD_TOKEN_ID_MASK << CMD_TOKEN_ID_SHIFT | CMD_ID_MASK)
+#define CMD_XTRACT_UNIQ(cmd)    ((cmd) & CMD_UNIQ_MASK)
+
+#define SCPI_SLOT               0
+
+#define MAX_DVFS_DOMAINS        8
+#define MAX_DVFS_OPPS           8
+#define DVFS_LATENCY(hdr)       (le32_to_cpu(hdr) >> 16)
+#define DVFS_OPP_COUNT(hdr)     ((le32_to_cpu(hdr) >> 8) & 0xff)
+
+#define PROTOCOL_REV_MINOR_BITS 16
+#define PROTOCOL_REV_MINOR_MASK ((1U << PROTOCOL_REV_MINOR_BITS) - 1)
+#define PROTOCOL_REV_MAJOR(x)   ((x) >> PROTOCOL_REV_MINOR_BITS)
+#define PROTOCOL_REV_MINOR(x)   ((x) & PROTOCOL_REV_MINOR_MASK)
+
+#define FW_REV_MAJOR_BITS       24
+#define FW_REV_MINOR_BITS       16
+#define FW_REV_PATCH_MASK       ((1U << FW_REV_MINOR_BITS) - 1)
+#define FW_REV_MINOR_MASK       ((1U << FW_REV_MAJOR_BITS) - 1)
+#define FW_REV_MAJOR(x)         ((x) >> FW_REV_MAJOR_BITS)
+#define FW_REV_MINOR(x)         (((x) & FW_REV_MINOR_MASK) >> FW_REV_MINOR_BITS)
+#define FW_REV_PATCH(x)         ((x) & FW_REV_PATCH_MASK)
+
+#define MAX_RX_TIMEOUT          (msecs_to_jiffies(20))
+
+enum scpi_error_codes {
+        SCPI_SUCCESS = 0, /* Success */
+        SCPI_ERR_PARAM = 1, /* Invalid parameter(s) */
+        SCPI_ERR_ALIGN = 2, /* Invalid alignment */
+        SCPI_ERR_SIZE = 3, /* Invalid size */
+        SCPI_ERR_HANDLER = 4, /* Invalid handler/callback */
+        SCPI_ERR_ACCESS = 5, /* Invalid access/permission denied */
+        SCPI_ERR_RANGE = 6, /* Value out of range */
+        SCPI_ERR_TIMEOUT = 7, /* Timeout has occurred */
+        SCPI_ERR_NOMEM = 8, /* Invalid memory area or pointer */
+        SCPI_ERR_PWRSTATE = 9, /* Invalid power state */
+        SCPI_ERR_SUPPORT = 10, /* Not supported or disabled */
+        SCPI_ERR_DEVICE = 11, /* Device error */
+        SCPI_ERR_BUSY = 12, /* Device busy */
+        SCPI_ERR_MAX
+};
+
+enum scpi_std_cmd {
+        SCPI_CMD_INVALID                = 0x00,
+        SCPI_CMD_SCPI_READY             = 0x01,
+        SCPI_CMD_SCPI_CAPABILITIES      = 0x02,
+        SCPI_CMD_SET_CSS_PWR_STATE      = 0x03,
+        SCPI_CMD_GET_CSS_PWR_STATE      = 0x04,
+        SCPI_CMD_SET_SYS_PWR_STATE      = 0x05,
+        SCPI_CMD_SET_CPU_TIMER          = 0x06,
+        SCPI_CMD_CANCEL_CPU_TIMER       = 0x07,
+        SCPI_CMD_DVFS_CAPABILITIES      = 0x08,
+        SCPI_CMD_GET_DVFS_INFO          = 0x09,
+        SCPI_CMD_SET_DVFS               = 0x0a,
+        SCPI_CMD_GET_DVFS               = 0x0b,
+        SCPI_CMD_GET_DVFS_STAT          = 0x0c,
+        SCPI_CMD_CLOCK_CAPABILITIES     = 0x0d,
+        SCPI_CMD_GET_CLOCK_INFO         = 0x0e,
+        SCPI_CMD_SET_CLOCK_VALUE        = 0x0f,
+        SCPI_CMD_GET_CLOCK_VALUE        = 0x10,
+        SCPI_CMD_PSU_CAPABILITIES       = 0x11,
+        SCPI_CMD_GET_PSU_INFO           = 0x12,
+        SCPI_CMD_SET_PSU                = 0x13,
+        SCPI_CMD_GET_PSU                = 0x14,
+        SCPI_CMD_SENSOR_CAPABILITIES    = 0x15,
+        SCPI_CMD_SENSOR_INFO            = 0x16,
+        SCPI_CMD_SENSOR_VALUE           = 0x17,
+        SCPI_CMD_SENSOR_CFG_PERIODIC    = 0x18,
+        SCPI_CMD_SENSOR_CFG_BOUNDS      = 0x19,
+        SCPI_CMD_SENSOR_ASYNC_VALUE     = 0x1a,
+        SCPI_CMD_SET_DEVICE_PWR_STATE   = 0x1b,
+        SCPI_CMD_GET_DEVICE_PWR_STATE   = 0x1c,
+        SCPI_CMD_COUNT
+};
+
+struct scpi_xfer {
+        u32 slot; /* has to be first element */
+        u32 cmd;
+        u32 status;
+        const void *tx_buf;
+        void *rx_buf;
+        unsigned int tx_len;
+        unsigned int rx_len;
+        struct list_head node;
+        struct completion done;
+};
+
+struct scpi_chan {
+        struct mbox_client cl;
+        struct mbox_chan *chan;
+        void __iomem *tx_payload;
+        void __iomem *rx_payload;
+        struct list_head rx_pending;
+        struct list_head xfers_list;
+        struct scpi_xfer *xfers;
+        spinlock_t rx_lock; /* locking for the rx pending list */
+        struct mutex xfers_lock;
+        u8 token;
+};
+
+struct scpi_drvinfo {
+        u32 protocol_version;
+        u32 firmware_version;
+        int num_chans;
+        atomic_t next_chan;
+        struct scpi_ops *scpi_ops;
+        struct scpi_chan *channels;
+        struct scpi_dvfs_info *dvfs[MAX_DVFS_DOMAINS];
+};
+
+/*
+ * The SCP firmware only executes in little-endian mode, so any buffers
+ * shared through SCPI should have their contents converted to little-endian
+ */
+struct scpi_shared_mem {
+        __le32 command;
+        __le32 status;
+        u8 payload[0];
+} __packed;
+
+struct scp_capabilities {
+        __le32 protocol_version;
+        __le32 event_version;
+        __le32 platform_version;
+        __le32 commands[4];
+} __packed;
+
+struct clk_get_info {
+        __le16 id;
+        __le16 flags;
+        __le32 min_rate;
+        __le32 max_rate;
+        u8 name[20];
+} __packed;
+
+struct clk_get_value {
+        __le32 rate;
+} __packed;
+
+struct clk_set_value {
+        __le16 id;
+        __le16 reserved;
+        __le32 rate;
+} __packed;
+
+struct dvfs_info {
+        __le32 header;
+        struct {
+                __le32 freq;
+                __le32 m_volt;
+        } opps[MAX_DVFS_OPPS];
+} __packed;
+
+struct dvfs_get {
+        u8 index;
+} __packed;
+
+struct dvfs_set {
+        u8 domain;
+        u8 index;
+} __packed;
+
+struct sensor_capabilities {
+        __le16 sensors;
+} __packed;
+
+struct _scpi_sensor_info {
+        __le16 sensor_id;
+        u8 class;
+        u8 trigger_type;
+        char name[20];
+};
+
+struct sensor_value {
+        __le32 val;
+} __packed;
+
+static struct scpi_drvinfo *scpi_info;
+
+static int scpi_linux_errmap[SCPI_ERR_MAX] = {
+        /* better than switch case as long as return value is continuous */
+        0, /* SCPI_SUCCESS */
+        -EINVAL, /* SCPI_ERR_PARAM */
+        -ENOEXEC, /* SCPI_ERR_ALIGN */
+        -EMSGSIZE, /* SCPI_ERR_SIZE */
+        -EINVAL, /* SCPI_ERR_HANDLER */
+        -EACCES, /* SCPI_ERR_ACCESS */
+        -ERANGE, /* SCPI_ERR_RANGE */
+        -ETIMEDOUT, /* SCPI_ERR_TIMEOUT */
+        -ENOMEM, /* SCPI_ERR_NOMEM */
+        -EINVAL, /* SCPI_ERR_PWRSTATE */
+        -EOPNOTSUPP, /* SCPI_ERR_SUPPORT */
+        -EIO, /* SCPI_ERR_DEVICE */
+        -EBUSY, /* SCPI_ERR_BUSY */
+};
+
+static inline int scpi_to_linux_errno(int errno)
+{
+        if (errno >= SCPI_SUCCESS && errno < SCPI_ERR_MAX)
+                return scpi_linux_errmap[errno];
+        return -EIO;
+}
+
+static void scpi_process_cmd(struct scpi_chan *ch, u32 cmd)
+{
+        unsigned long flags;
+        struct scpi_xfer *t, *match = NULL;
+
+        spin_lock_irqsave(&ch->rx_lock, flags);
+        if (list_empty(&ch->rx_pending)) {
+                spin_unlock_irqrestore(&ch->rx_lock, flags);
+                return;
+        }
+
+        list_for_each_entry(t, &ch->rx_pending, node)
+                if (CMD_XTRACT_UNIQ(t->cmd) == CMD_XTRACT_UNIQ(cmd)) {
+                        list_del(&t->node);
+                        match = t;
+                        break;
+                }
+        /* check if wait_for_completion is in progress or timed-out */
+        if (match && !completion_done(&match->done)) {
+                struct scpi_shared_mem *mem = ch->rx_payload;
+                unsigned int len = min(match->rx_len, CMD_SIZE(cmd));
+
+                match->status = le32_to_cpu(mem->status);
+                memcpy_fromio(match->rx_buf, mem->payload, len);
+                if (match->rx_len > len)
+                        memset(match->rx_buf + len, 0, match->rx_len - len);
+                complete(&match->done);
+        }
+        spin_unlock_irqrestore(&ch->rx_lock, flags);
+}
+
+static void scpi_handle_remote_msg(struct mbox_client *c, void *msg)
+{
+        struct scpi_chan *ch = container_of(c, struct scpi_chan, cl);
+        struct scpi_shared_mem *mem = ch->rx_payload;
+        u32 cmd = le32_to_cpu(mem->command);
+
+        scpi_process_cmd(ch, cmd);
+}
+
+static void scpi_tx_prepare(struct mbox_client *c, void *msg)
+{
+        unsigned long flags;
+        struct scpi_xfer *t = msg;
+        struct scpi_chan *ch = container_of(c, struct scpi_chan, cl);
+        struct scpi_shared_mem *mem = (struct scpi_shared_mem *)ch->tx_payload;
+
+        if (t->tx_buf)
+                memcpy_toio(mem->payload, t->tx_buf, t->tx_len);
+        if (t->rx_buf) {
+                if (!(++ch->token))
+                        ++ch->token;
+                ADD_SCPI_TOKEN(t->cmd, ch->token);
+                spin_lock_irqsave(&ch->rx_lock, flags);
+                list_add_tail(&t->node, &ch->rx_pending);
+                spin_unlock_irqrestore(&ch->rx_lock, flags);
+        }
+        mem->command = cpu_to_le32(t->cmd);
+}
+
+static struct scpi_xfer *get_scpi_xfer(struct scpi_chan *ch)
+{
+        struct scpi_xfer *t;
+
+        mutex_lock(&ch->xfers_lock);
+        if (list_empty(&ch->xfers_list)) {
+                mutex_unlock(&ch->xfers_lock);
+                return NULL;
+        }
+        t = list_first_entry(&ch->xfers_list, struct scpi_xfer, node);
+        list_del(&t->node);
+        mutex_unlock(&ch->xfers_lock);
+        return t;
+}
+
+static void put_scpi_xfer(struct scpi_xfer *t, struct scpi_chan *ch)
+{
+        mutex_lock(&ch->xfers_lock);
+        list_add_tail(&t->node, &ch->xfers_list);
+        mutex_unlock(&ch->xfers_lock);
+}
+
+static int scpi_send_message(u8 cmd, void *tx_buf, unsigned int tx_len,
+                             void *rx_buf, unsigned int rx_len)
+{
+        int ret;
+        u8 chan;
+        struct scpi_xfer *msg;
+        struct scpi_chan *scpi_chan;
+
+        chan = atomic_inc_return(&scpi_info->next_chan) % scpi_info->num_chans;
+        scpi_chan = scpi_info->channels + chan;
+
+        msg = get_scpi_xfer(scpi_chan);
+        if (!msg)
+                return -ENOMEM;
+
+        msg->slot = BIT(SCPI_SLOT);
+        msg->cmd = PACK_SCPI_CMD(cmd, tx_len);
+        msg->tx_buf = tx_buf;
+        msg->tx_len = tx_len;
+        msg->rx_buf = rx_buf;
+        msg->rx_len = rx_len;
+        init_completion(&msg->done);
+
+        ret = mbox_send_message(scpi_chan->chan, msg);
+        if (ret < 0 || !rx_buf)
+                goto out;
+
+        if (!wait_for_completion_timeout(&msg->done, MAX_RX_TIMEOUT))
+                ret = -ETIMEDOUT;
+        else
+                /* first status word */
+                ret = le32_to_cpu(msg->status);
+out:
+        if (ret < 0 && rx_buf) /* remove entry from the list if timed-out */
+                scpi_process_cmd(scpi_chan, msg->cmd);
+
+        put_scpi_xfer(msg, scpi_chan);
+        /* SCPI error codes > 0, translate them to Linux scale*/
+        return ret > 0 ? scpi_to_linux_errno(ret) : ret;
+}
+
+static u32 scpi_get_version(void)
+{
+        return scpi_info->protocol_version;
+}
+
+static int
+scpi_clk_get_range(u16 clk_id, unsigned long *min, unsigned long *max)
+{
+        int ret;
+        struct clk_get_info clk;
+        __le16 le_clk_id = cpu_to_le16(clk_id);
+
+        ret = scpi_send_message(SCPI_CMD_GET_CLOCK_INFO, &le_clk_id,
+                                sizeof(le_clk_id), &clk, sizeof(clk));
+        if (!ret) {
+                *min = le32_to_cpu(clk.min_rate);
+                *max = le32_to_cpu(clk.max_rate);
+        }
+        return ret;
+}
+
+static unsigned long scpi_clk_get_val(u16 clk_id)
+{
+        int ret;
+        struct clk_get_value clk;
+        __le16 le_clk_id = cpu_to_le16(clk_id);
+
+        ret = scpi_send_message(SCPI_CMD_GET_CLOCK_VALUE, &le_clk_id,
+                                sizeof(le_clk_id), &clk, sizeof(clk));
+        return ret ? ret : le32_to_cpu(clk.rate);
+}
+
+static int scpi_clk_set_val(u16 clk_id, unsigned long rate)
+{
+        int stat;
+        struct clk_set_value clk = {
+                .id = cpu_to_le16(clk_id),
+                .rate = cpu_to_le32(rate)
+        };
+
+        return scpi_send_message(SCPI_CMD_SET_CLOCK_VALUE, &clk, sizeof(clk),
+                                 &stat, sizeof(stat));
+}
+
+static int scpi_dvfs_get_idx(u8 domain)
+{
+        int ret;
+        struct dvfs_get dvfs;
+
+        ret = scpi_send_message(SCPI_CMD_GET_DVFS, &domain, sizeof(domain),
+                                &dvfs, sizeof(dvfs));
+        return ret ? ret : dvfs.index;
+}
+
+static int scpi_dvfs_set_idx(u8 domain, u8 index)
+{
+        int stat;
+        struct dvfs_set dvfs = {domain, index};
+
+        return scpi_send_message(SCPI_CMD_SET_DVFS, &dvfs, sizeof(dvfs),
+                                 &stat, sizeof(stat));
+}
+
+static int opp_cmp_func(const void *opp1, const void *opp2)
+{
+        const struct scpi_opp *t1 = opp1, *t2 = opp2;
+
+        return t1->freq - t2->freq;
+}
+
+static struct scpi_dvfs_info *scpi_dvfs_get_info(u8 domain)
+{
+        struct scpi_dvfs_info *info;
+        struct scpi_opp *opp;
+        struct dvfs_info buf;
+        int ret, i;
+
+        if (domain >= MAX_DVFS_DOMAINS)
+                return ERR_PTR(-EINVAL);
+
+        if (scpi_info->dvfs[domain])    /* data already populated */
+                return scpi_info->dvfs[domain];
+
+        ret = scpi_send_message(SCPI_CMD_GET_DVFS_INFO, &domain, sizeof(domain),
+                                &buf, sizeof(buf));
+
+        if (ret)
+                return ERR_PTR(ret);
+
+        info = kmalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return ERR_PTR(-ENOMEM);
+
+        info->count = DVFS_OPP_COUNT(buf.header);
+        info->latency = DVFS_LATENCY(buf.header) * 1000; /* uS to nS */
+
+        info->opps = kcalloc(info->count, sizeof(*opp), GFP_KERNEL);
+        if (!info->opps) {
+                kfree(info);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        for (i = 0, opp = info->opps; i < info->count; i++, opp++) {
+                opp->freq = le32_to_cpu(buf.opps[i].freq);
+                opp->m_volt = le32_to_cpu(buf.opps[i].m_volt);
+        }
+
+        sort(info->opps, info->count, sizeof(*opp), opp_cmp_func, NULL);
+
+        scpi_info->dvfs[domain] = info;
+        return info;
+}
+
+static int scpi_sensor_get_capability(u16 *sensors)
+{
+        struct sensor_capabilities cap_buf;
+        int ret;
+
+        ret = scpi_send_message(SCPI_CMD_SENSOR_CAPABILITIES, NULL, 0, &cap_buf,
+                                sizeof(cap_buf));
+        if (!ret)
+                *sensors = le16_to_cpu(cap_buf.sensors);
+
+        return ret;
+}
+
+static int scpi_sensor_get_info(u16 sensor_id, struct scpi_sensor_info *info)
+{
+        __le16 id = cpu_to_le16(sensor_id);
+        struct _scpi_sensor_info _info;
+        int ret;
+
+        ret = scpi_send_message(SCPI_CMD_SENSOR_INFO, &id, sizeof(id),
+                                &_info, sizeof(_info));
+        if (!ret) {
+                memcpy(info, &_info, sizeof(*info));
+                info->sensor_id = le16_to_cpu(_info.sensor_id);
+        }
+
+        return ret;
+}
+
+int scpi_sensor_get_value(u16 sensor, u32 *val)
+{
+        struct sensor_value buf;
+        int ret;
+
+        ret = scpi_send_message(SCPI_CMD_SENSOR_VALUE, &sensor, sizeof(sensor),
+                                &buf, sizeof(buf));
+        if (!ret)
+                *val = le32_to_cpu(buf.val);
+
+        return ret;
+}
+
+static struct scpi_ops scpi_ops = {
+        .get_version = scpi_get_version,
+        .clk_get_range = scpi_clk_get_range,
+        .clk_get_val = scpi_clk_get_val,
+        .clk_set_val = scpi_clk_set_val,
+        .dvfs_get_idx = scpi_dvfs_get_idx,
+        .dvfs_set_idx = scpi_dvfs_set_idx,
+        .dvfs_get_info = scpi_dvfs_get_info,
+        .sensor_get_capability = scpi_sensor_get_capability,
+        .sensor_get_info = scpi_sensor_get_info,
+        .sensor_get_value = scpi_sensor_get_value,
+};
+
+struct scpi_ops *get_scpi_ops(void)
+{
+        return scpi_info ? scpi_info->scpi_ops : NULL;
+}
+EXPORT_SYMBOL_GPL(get_scpi_ops);
+
+static int scpi_init_versions(struct scpi_drvinfo *info)
+{
+        int ret;
+        struct scp_capabilities caps;
+
+        ret = scpi_send_message(SCPI_CMD_SCPI_CAPABILITIES, NULL, 0,
+                                &caps, sizeof(caps));
+        if (!ret) {
+                info->protocol_version = le32_to_cpu(caps.protocol_version);
+                info->firmware_version = le32_to_cpu(caps.platform_version);
+        }
+        return ret;
+}
+
+static ssize_t protocol_version_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct scpi_drvinfo *scpi_info = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d.%d\n",
+                       PROTOCOL_REV_MAJOR(scpi_info->protocol_version),
+                       PROTOCOL_REV_MINOR(scpi_info->protocol_version));
+}
+static DEVICE_ATTR_RO(protocol_version);
+
+static ssize_t firmware_version_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct scpi_drvinfo *scpi_info = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d.%d.%d\n",
+                       FW_REV_MAJOR(scpi_info->firmware_version),
+                       FW_REV_MINOR(scpi_info->firmware_version),
+                       FW_REV_PATCH(scpi_info->firmware_version));
+}
+static DEVICE_ATTR_RO(firmware_version);
+
+static struct attribute *versions_attrs[] = {
+        &dev_attr_firmware_version.attr,
+        &dev_attr_protocol_version.attr,
+        NULL,
+};
+ATTRIBUTE_GROUPS(versions);
+
+static void
+scpi_free_channels(struct device *dev, struct scpi_chan *pchan, int count)
+{
+        int i;
+
+        for (i = 0; i < count && pchan->chan; i++, pchan++) {
+                mbox_free_channel(pchan->chan);
+                devm_kfree(dev, pchan->xfers);
+                devm_iounmap(dev, pchan->rx_payload);
+        }
+}
+
+static int scpi_remove(struct platform_device *pdev)
+{
+        int i;
+        struct device *dev = &pdev->dev;
+        struct scpi_drvinfo *info = platform_get_drvdata(pdev);
+
+        scpi_info = NULL; /* stop exporting SCPI ops through get_scpi_ops */
+
+        of_platform_depopulate(dev);
+        sysfs_remove_groups(&dev->kobj, versions_groups);
+        scpi_free_channels(dev, info->channels, info->num_chans);
+        platform_set_drvdata(pdev, NULL);
+
+        for (i = 0; i < MAX_DVFS_DOMAINS && info->dvfs[i]; i++) {
+                kfree(info->dvfs[i]->opps);
+                kfree(info->dvfs[i]);
+        }
+        devm_kfree(dev, info->channels);
+        devm_kfree(dev, info);
+
+        return 0;
+}
+
+#define MAX_SCPI_XFERS          10
+static int scpi_alloc_xfer_list(struct device *dev, struct scpi_chan *ch)
+{
+        int i;
+        struct scpi_xfer *xfers;
+
+        xfers = devm_kzalloc(dev, MAX_SCPI_XFERS * sizeof(*xfers), GFP_KERNEL);
+        if (!xfers)
+                return -ENOMEM;
+
+        ch->xfers = xfers;
+        for (i = 0; i < MAX_SCPI_XFERS; i++, xfers++)
+                list_add_tail(&xfers->node, &ch->xfers_list);
+        return 0;
+}
+
+static int scpi_probe(struct platform_device *pdev)
+{
+        int count, idx, ret;
+        struct resource res;
+        struct scpi_chan *scpi_chan;
+        struct device *dev = &pdev->dev;
+        struct device_node *np = dev->of_node;
+
+        scpi_info = devm_kzalloc(dev, sizeof(*scpi_info), GFP_KERNEL);
+        if (!scpi_info)
+                return -ENOMEM;
+
+        count = of_count_phandle_with_args(np, "mboxes", "#mbox-cells");
+        if (count < 0) {
+                dev_err(dev, "no mboxes property in '%s'\n", np->full_name);
+                return -ENODEV;
+        }
+
+        scpi_chan = devm_kcalloc(dev, count, sizeof(*scpi_chan), GFP_KERNEL);
+        if (!scpi_chan)
+                return -ENOMEM;
+
+        for (idx = 0; idx < count; idx++) {
+                resource_size_t size;
+                struct scpi_chan *pchan = scpi_chan + idx;
+                struct mbox_client *cl = &pchan->cl;
+                struct device_node *shmem = of_parse_phandle(np, "shmem", idx);
+
+                if (of_address_to_resource(shmem, 0, &res)) {
+                        dev_err(dev, "failed to get SCPI payload mem resource\n");
+                        ret = -EINVAL;
+                        goto err;
+                }
+
+                size = resource_size(&res);
+                pchan->rx_payload = devm_ioremap(dev, res.start, size);
+                if (!pchan->rx_payload) {
+                        dev_err(dev, "failed to ioremap SCPI payload\n");
+                        ret = -EADDRNOTAVAIL;
+                        goto err;
+                }
+                pchan->tx_payload = pchan->rx_payload + (size >> 1);
+
+                cl->dev = dev;
+                cl->rx_callback = scpi_handle_remote_msg;
+                cl->tx_prepare = scpi_tx_prepare;
+                cl->tx_block = true;
+                cl->tx_tout = 50;
+                cl->knows_txdone = false; /* controller can't ack */
+
+                INIT_LIST_HEAD(&pchan->rx_pending);
+                INIT_LIST_HEAD(&pchan->xfers_list);
+                spin_lock_init(&pchan->rx_lock);
+                mutex_init(&pchan->xfers_lock);
+
+                ret = scpi_alloc_xfer_list(dev, pchan);
+                if (!ret) {
+                        pchan->chan = mbox_request_channel(cl, idx);
+                        if (!IS_ERR(pchan->chan))
+                                continue;
+                        ret = PTR_ERR(pchan->chan);
+                        if (ret != -EPROBE_DEFER)
+                                dev_err(dev, "failed to get channel%d err %d\n",
+                                        idx, ret);
+                }
+err:
+                scpi_free_channels(dev, scpi_chan, idx);
+                scpi_info = NULL;
+                return ret;
+        }
+
+        scpi_info->channels = scpi_chan;
+        scpi_info->num_chans = count;
+        platform_set_drvdata(pdev, scpi_info);
+
+        ret = scpi_init_versions(scpi_info);
+        if (ret) {
+                dev_err(dev, "incorrect or no SCP firmware found\n");
+                scpi_remove(pdev);
+                return ret;
+        }
+
+        _dev_info(dev, "SCP Protocol %d.%d Firmware %d.%d.%d version\n",
+                  PROTOCOL_REV_MAJOR(scpi_info->protocol_version),
+                  PROTOCOL_REV_MINOR(scpi_info->protocol_version),
+                  FW_REV_MAJOR(scpi_info->firmware_version),
+                  FW_REV_MINOR(scpi_info->firmware_version),
+                  FW_REV_PATCH(scpi_info->firmware_version));
+        scpi_info->scpi_ops = &scpi_ops;
+
+        ret = sysfs_create_groups(&dev->kobj, versions_groups);
+        if (ret)
+                dev_err(dev, "unable to create sysfs version group\n");
+
+        return of_platform_populate(dev->of_node, NULL, NULL, dev);
+}
+
+static const struct of_device_id scpi_of_match[] = {
+        {.compatible = "arm,scpi"},
+        {},
+};
+
+MODULE_DEVICE_TABLE(of, scpi_of_match);
+
+static struct platform_driver scpi_driver = {
+        .driver = {
+                .name = "scpi_protocol",
+                .of_match_table = scpi_of_match,
+        },
+        .probe = scpi_probe,
+        .remove = scpi_remove,
+};
+module_platform_driver(scpi_driver);
+
+MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
+MODULE_DESCRIPTION("ARM SCPI mailbox protocol driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/firmware/psci.c b/drivers/firmware/psci.c
index 42700f09a8c5..d24f35d74b27 100644
--- a/drivers/firmware/psci.c
+++ b/drivers/firmware/psci.c
@@ -20,23 +20,25 @@
 #include <linux/printk.h>
 #include <linux/psci.h>
 #include <linux/reboot.h>
+#include <linux/suspend.h>
 
 #include <uapi/linux/psci.h>
 
 #include <asm/cputype.h>
 #include <asm/system_misc.h>
 #include <asm/smp_plat.h>
+#include <asm/suspend.h>
 
 /*
  * While a 64-bit OS can make calls with SMC32 calling conventions, for some
- * calls it is necessary to use SMC64 to pass or return 64-bit values. For such
- * calls PSCI_0_2_FN_NATIVE(x) will choose the appropriate (native-width)
- * function ID.
+ * calls it is necessary to use SMC64 to pass or return 64-bit values.
+ * For such calls PSCI_FN_NATIVE(version, name) will choose the appropriate
+ * (native-width) function ID.
  */
 #ifdef CONFIG_64BIT
-#define PSCI_0_2_FN_NATIVE(name)        PSCI_0_2_FN64_##name
+#define PSCI_FN_NATIVE(version, name)   PSCI_##version##_FN64_##name
 #else
-#define PSCI_0_2_FN_NATIVE(name)        PSCI_0_2_FN_##name
+#define PSCI_FN_NATIVE(version, name)   PSCI_##version##_FN_##name
 #endif
 
 /*
@@ -70,6 +72,41 @@ enum psci_function {
 
 static u32 psci_function_id[PSCI_FN_MAX];
 
+#define PSCI_0_2_POWER_STATE_MASK               \
+                                (PSCI_0_2_POWER_STATE_ID_MASK | \
+                                PSCI_0_2_POWER_STATE_TYPE_MASK | \
+                                PSCI_0_2_POWER_STATE_AFFL_MASK)
+
+#define PSCI_1_0_EXT_POWER_STATE_MASK           \
+                                (PSCI_1_0_EXT_POWER_STATE_ID_MASK | \
+                                PSCI_1_0_EXT_POWER_STATE_TYPE_MASK)
+
+static u32 psci_cpu_suspend_feature;
+
+static inline bool psci_has_ext_power_state(void)
+{
+        return psci_cpu_suspend_feature &
+                                PSCI_1_0_FEATURES_CPU_SUSPEND_PF_MASK;
+}
+
+bool psci_power_state_loses_context(u32 state)
+{
+        const u32 mask = psci_has_ext_power_state() ?
+                                        PSCI_1_0_EXT_POWER_STATE_TYPE_MASK :
+                                        PSCI_0_2_POWER_STATE_TYPE_MASK;
+
+        return state & mask;
+}
+
+bool psci_power_state_is_valid(u32 state)
+{
+        const u32 valid_mask = psci_has_ext_power_state() ?
+                               PSCI_1_0_EXT_POWER_STATE_MASK :
+                               PSCI_0_2_POWER_STATE_MASK;
+
+        return !(state & ~valid_mask);
+}
+
 static int psci_to_linux_errno(int errno)
 {
         switch (errno) {
@@ -78,6 +115,7 @@ static int psci_to_linux_errno(int errno)
         case PSCI_RET_NOT_SUPPORTED:
                 return -EOPNOTSUPP;
         case PSCI_RET_INVALID_PARAMS:
+        case PSCI_RET_INVALID_ADDRESS:
                 return -EINVAL;
         case PSCI_RET_DENIED:
                 return -EPERM;
@@ -134,7 +172,7 @@ static int psci_migrate(unsigned long cpuid)
 static int psci_affinity_info(unsigned long target_affinity,
                 unsigned long lowest_affinity_level)
 {
-        return invoke_psci_fn(PSCI_0_2_FN_NATIVE(AFFINITY_INFO),
+        return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO),
                               target_affinity, lowest_affinity_level, 0);
 }
 
@@ -145,7 +183,7 @@ static int psci_migrate_info_type(void)
 
 static unsigned long psci_migrate_info_up_cpu(void)
 {
-        return invoke_psci_fn(PSCI_0_2_FN_NATIVE(MIGRATE_INFO_UP_CPU),
+        return invoke_psci_fn(PSCI_FN_NATIVE(0_2, MIGRATE_INFO_UP_CPU),
                               0, 0, 0);
 }
 
@@ -181,6 +219,49 @@ static void psci_sys_poweroff(void)
         invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
 }
 
+static int __init psci_features(u32 psci_func_id)
+{
+        return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES,
+                              psci_func_id, 0, 0);
+}
+
+static int psci_system_suspend(unsigned long unused)
+{
+        return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
+                              virt_to_phys(cpu_resume), 0, 0);
+}
+
+static int psci_system_suspend_enter(suspend_state_t state)
+{
+        return cpu_suspend(0, psci_system_suspend);
+}
+
+static const struct platform_suspend_ops psci_suspend_ops = {
+        .valid          = suspend_valid_only_mem,
+        .enter          = psci_system_suspend_enter,
+};
+
+static void __init psci_init_system_suspend(void)
+{
+        int ret;
+
+        if (!IS_ENABLED(CONFIG_SUSPEND))
+                return;
+
+        ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND));
+
+        if (ret != PSCI_RET_NOT_SUPPORTED)
+                suspend_set_ops(&psci_suspend_ops);
+}
+
+static void __init psci_init_cpu_suspend(void)
+{
+        int feature = psci_features(psci_function_id[PSCI_FN_CPU_SUSPEND]);
+
+        if (feature != PSCI_RET_NOT_SUPPORTED)
+                psci_cpu_suspend_feature = feature;
+}
+
 /*
  * Detect the presence of a resident Trusted OS which may cause CPU_OFF to
  * return DENIED (which would be fatal).
@@ -224,16 +305,17 @@ static void __init psci_init_migrate(void)
 static void __init psci_0_2_set_functions(void)
 {
         pr_info("Using standard PSCI v0.2 function IDs\n");
-        psci_function_id[PSCI_FN_CPU_SUSPEND] = PSCI_0_2_FN_NATIVE(CPU_SUSPEND);
+        psci_function_id[PSCI_FN_CPU_SUSPEND] =
+                                        PSCI_FN_NATIVE(0_2, CPU_SUSPEND);
         psci_ops.cpu_suspend = psci_cpu_suspend;
 
         psci_function_id[PSCI_FN_CPU_OFF] = PSCI_0_2_FN_CPU_OFF;
         psci_ops.cpu_off = psci_cpu_off;
 
-        psci_function_id[PSCI_FN_CPU_ON] = PSCI_0_2_FN_NATIVE(CPU_ON);
+        psci_function_id[PSCI_FN_CPU_ON] = PSCI_FN_NATIVE(0_2, CPU_ON);
         psci_ops.cpu_on = psci_cpu_on;
 
-        psci_function_id[PSCI_FN_MIGRATE] = PSCI_0_2_FN_NATIVE(MIGRATE);
+        psci_function_id[PSCI_FN_MIGRATE] = PSCI_FN_NATIVE(0_2, MIGRATE);
         psci_ops.migrate = psci_migrate;
 
         psci_ops.affinity_info = psci_affinity_info;
@@ -265,6 +347,11 @@ static int __init psci_probe(void)
 
         psci_init_migrate();
 
+        if (PSCI_VERSION_MAJOR(ver) >= 1) {
+                psci_init_cpu_suspend();
+                psci_init_system_suspend();
+        }
+
         return 0;
 }
 
@@ -340,6 +427,7 @@ out_put_node:
 static const struct of_device_id const psci_of_match[] __initconst = {
         { .compatible = "arm,psci",     .data = psci_0_1_init},
         { .compatible = "arm,psci-0.2", .data = psci_0_2_init},
+        { .compatible = "arm,psci-1.0", .data = psci_0_2_init},
         {},
 };
 
diff --git a/drivers/firmware/qcom_scm-32.c b/drivers/firmware/qcom_scm-32.c
index 29e6850665eb..0883292f640f 100644
--- a/drivers/firmware/qcom_scm-32.c
+++ b/drivers/firmware/qcom_scm-32.c
@@ -480,15 +480,15 @@ void __qcom_scm_cpu_power_down(u32 flags)
 int __qcom_scm_is_call_available(u32 svc_id, u32 cmd_id)
 {
         int ret;
-        u32 svc_cmd = (svc_id << 10) | cmd_id;
-        u32 ret_val = 0;
+        __le32 svc_cmd = cpu_to_le32((svc_id << 10) | cmd_id);
+        __le32 ret_val = 0;
 
         ret = qcom_scm_call(QCOM_SCM_SVC_INFO, QCOM_IS_CALL_AVAIL_CMD, &svc_cmd,
                         sizeof(svc_cmd), &ret_val, sizeof(ret_val));
         if (ret)
                 return ret;
 
-        return ret_val;
+        return le32_to_cpu(ret_val);
 }
 
 int __qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp)
diff --git a/drivers/firmware/raspberrypi.c b/drivers/firmware/raspberrypi.c
new file mode 100644
index 000000000000..dd506cd3a5b8
--- /dev/null
+++ b/drivers/firmware/raspberrypi.c
@@ -0,0 +1,260 @@
+/*
+ * Defines interfaces for interacting wtih the Raspberry Pi firmware's
+ * property channel.
+ *
+ * Copyright © 2015 Broadcom
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/mailbox_client.h>
+#include <linux/module.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <soc/bcm2835/raspberrypi-firmware.h>
+
+#define MBOX_MSG(chan, data28)          (((data28) & ~0xf) | ((chan) & 0xf))
+#define MBOX_CHAN(msg)                  ((msg) & 0xf)
+#define MBOX_DATA28(msg)                ((msg) & ~0xf)
+#define MBOX_CHAN_PROPERTY              8
+
+struct rpi_firmware {
+        struct mbox_client cl;
+        struct mbox_chan *chan; /* The property channel. */
+        struct completion c;
+        u32 enabled;
+};
+
+static DEFINE_MUTEX(transaction_lock);
+
+static void response_callback(struct mbox_client *cl, void *msg)
+{
+        struct rpi_firmware *fw = container_of(cl, struct rpi_firmware, cl);
+        complete(&fw->c);
+}
+
+/*
+ * Sends a request to the firmware through the BCM2835 mailbox driver,
+ * and synchronously waits for the reply.
+ */
+static int
+rpi_firmware_transaction(struct rpi_firmware *fw, u32 chan, u32 data)
+{
+        u32 message = MBOX_MSG(chan, data);
+        int ret;
+
+        WARN_ON(data & 0xf);
+
+        mutex_lock(&transaction_lock);
+        reinit_completion(&fw->c);
+        ret = mbox_send_message(fw->chan, &message);
+        if (ret >= 0) {
+                wait_for_completion(&fw->c);
+                ret = 0;
+        } else {
+                dev_err(fw->cl.dev, "mbox_send_message returned %d\n", ret);
+        }
+        mutex_unlock(&transaction_lock);
+
+        return ret;
+}
+
+/**
+ * rpi_firmware_property_list - Submit firmware property list
+ * @fw:         Pointer to firmware structure from rpi_firmware_get().
+ * @data:       Buffer holding tags.
+ * @tag_size:   Size of tags buffer.
+ *
+ * Submits a set of concatenated tags to the VPU firmware through the
+ * mailbox property interface.
+ *
+ * The buffer header and the ending tag are added by this function and
+ * don't need to be supplied, just the actual tags for your operation.
+ * See struct rpi_firmware_property_tag_header for the per-tag
+ * structure.
+ */
+int rpi_firmware_property_list(struct rpi_firmware *fw,
+                               void *data, size_t tag_size)
+{
+        size_t size = tag_size + 12;
+        u32 *buf;
+        dma_addr_t bus_addr;
+        int ret;
+
+        /* Packets are processed a dword at a time. */
+        if (size & 3)
+                return -EINVAL;
+
+        buf = dma_alloc_coherent(fw->cl.dev, PAGE_ALIGN(size), &bus_addr,
+                                 GFP_ATOMIC);
+        if (!buf)
+                return -ENOMEM;
+
+        /* The firmware will error out without parsing in this case. */
+        WARN_ON(size >= 1024 * 1024);
+
+        buf[0] = size;
+        buf[1] = RPI_FIRMWARE_STATUS_REQUEST;
+        memcpy(&buf[2], data, tag_size);
+        buf[size / 4 - 1] = RPI_FIRMWARE_PROPERTY_END;
+        wmb();
+
+        ret = rpi_firmware_transaction(fw, MBOX_CHAN_PROPERTY, bus_addr);
+
+        rmb();
+        memcpy(data, &buf[2], tag_size);
+        if (ret == 0 && buf[1] != RPI_FIRMWARE_STATUS_SUCCESS) {
+                /*
+                 * The tag name here might not be the one causing the
+                 * error, if there were multiple tags in the request.
+                 * But single-tag is the most common, so go with it.
+                 */
+                dev_err(fw->cl.dev, "Request 0x%08x returned status 0x%08x\n",
+                        buf[2], buf[1]);
+                ret = -EINVAL;
+        }
+
+        dma_free_coherent(fw->cl.dev, PAGE_ALIGN(size), buf, bus_addr);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(rpi_firmware_property_list);
+
+/**
+ * rpi_firmware_property - Submit single firmware property
+ * @fw:         Pointer to firmware structure from rpi_firmware_get().
+ * @tag:        One of enum_mbox_property_tag.
+ * @tag_data:   Tag data buffer.
+ * @buf_size:   Buffer size.
+ *
+ * Submits a single tag to the VPU firmware through the mailbox
+ * property interface.
+ *
+ * This is a convenience wrapper around
+ * rpi_firmware_property_list() to avoid some of the
+ * boilerplate in property calls.
+ */
+int rpi_firmware_property(struct rpi_firmware *fw,
+                          u32 tag, void *tag_data, size_t buf_size)
+{
+        /* Single tags are very small (generally 8 bytes), so the
+         * stack should be safe.
+         */
+        u8 data[buf_size + sizeof(struct rpi_firmware_property_tag_header)];
+        struct rpi_firmware_property_tag_header *header =
+                (struct rpi_firmware_property_tag_header *)data;
+        int ret;
+
+        header->tag = tag;
+        header->buf_size = buf_size;
+        header->req_resp_size = 0;
+        memcpy(data + sizeof(struct rpi_firmware_property_tag_header),
+               tag_data, buf_size);
+
+        ret = rpi_firmware_property_list(fw, &data, sizeof(data));
+        memcpy(tag_data,
+               data + sizeof(struct rpi_firmware_property_tag_header),
+               buf_size);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(rpi_firmware_property);
+
+static void
+rpi_firmware_print_firmware_revision(struct rpi_firmware *fw)
+{
+        u32 packet;
+        int ret = rpi_firmware_property(fw,
+                                        RPI_FIRMWARE_GET_FIRMWARE_REVISION,
+                                        &packet, sizeof(packet));
+
+        if (ret == 0) {
+                struct tm tm;
+
+                time_to_tm(packet, 0, &tm);
+
+                dev_info(fw->cl.dev,
+                         "Attached to firmware from %04ld-%02d-%02d %02d:%02d\n",
+                         tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                         tm.tm_hour, tm.tm_min);
+        }
+}
+
+static int rpi_firmware_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct rpi_firmware *fw;
+
+        fw = devm_kzalloc(dev, sizeof(*fw), GFP_KERNEL);
+        if (!fw)
+                return -ENOMEM;
+
+        fw->cl.dev = dev;
+        fw->cl.rx_callback = response_callback;
+        fw->cl.tx_block = true;
+
+        fw->chan = mbox_request_channel(&fw->cl, 0);
+        if (IS_ERR(fw->chan)) {
+                int ret = PTR_ERR(fw->chan);
+                if (ret != -EPROBE_DEFER)
+                        dev_err(dev, "Failed to get mbox channel: %d\n", ret);
+                return ret;
+        }
+
+        init_completion(&fw->c);
+
+        platform_set_drvdata(pdev, fw);
+
+        rpi_firmware_print_firmware_revision(fw);
+
+        return 0;
+}
+
+static int rpi_firmware_remove(struct platform_device *pdev)
+{
+        struct rpi_firmware *fw = platform_get_drvdata(pdev);
+
+        mbox_free_channel(fw->chan);
+
+        return 0;
+}
+
+/**
+ * rpi_firmware_get - Get pointer to rpi_firmware structure.
+ * @firmware_node:    Pointer to the firmware Device Tree node.
+ *
+ * Returns NULL is the firmware device is not ready.
+ */
+struct rpi_firmware *rpi_firmware_get(struct device_node *firmware_node)
+{
+        struct platform_device *pdev = of_find_device_by_node(firmware_node);
+
+        if (!pdev)
+                return NULL;
+
+        return platform_get_drvdata(pdev);
+}
+EXPORT_SYMBOL_GPL(rpi_firmware_get);
+
+static const struct of_device_id rpi_firmware_of_match[] = {
+        { .compatible = "raspberrypi,bcm2835-firmware", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, rpi_firmware_of_match);
+
+static struct platform_driver rpi_firmware_driver = {
+        .driver = {
+                .name = "raspberrypi-firmware",
+                .of_match_table = rpi_firmware_of_match,
+        },
+        .probe          = rpi_firmware_probe,
+        .remove         = rpi_firmware_remove,
+};
+module_platform_driver(rpi_firmware_driver);
+
+MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
+MODULE_DESCRIPTION("Raspberry Pi firmware driver");
+MODULE_LICENSE("GPL v2");