From: Vadim Pasternak <vad...@mellanox.com>

Enable system support for the Mellanox Technologies hotplug platform
driver, which provides support for the next Mellanox basic systems:
"msx6710", "msx6720", "msb7700", "msn2700", "msx1410", "msn2410",
"msb7800", "msn2740", "msn2100" and also various number of derivative
systems from the above basic types.
This driver handles hot-plug events for the power suppliers, power
cables and fans for the above systems.

The Kconfig currently controlling compilation of this code is:
driver/platform/x86:config MLX_CPLD_PLATFORM
                       tristate "Mellanox platform hotplug driver support"

Signed-off-by: Vadim Pasternak <vad...@mellanox.com>
---
 MAINTAINERS                                   |   7 +
 drivers/platform/x86/Kconfig                  |  10 +
 drivers/platform/x86/Makefile                 |   1 +
 drivers/platform/x86/mlxcpld-hotplug.c        | 543 ++++++++++++++++++++++++++
 include/linux/platform_data/mlxcpld-hotplug.h |  90 +++++
 5 files changed, 651 insertions(+)
 create mode 100644 drivers/platform/x86/mlxcpld-hotplug.c
 create mode 100644 include/linux/platform_data/mlxcpld-hotplug.h

diff --git a/MAINTAINERS b/MAINTAINERS
index a306795..cbfe2a8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7649,6 +7649,13 @@ W:       http://www.mellanox.com
 Q:     http://patchwork.ozlabs.org/project/netdev/list/
 F:     drivers/net/ethernet/mellanox/mlxsw/
 
+MELLANOX MLX CPLD HOTPLUG DRIVER
+M:     Vadim Pasternak <vad...@mellanox.com>
+L:     platform-driver-...@vger.kernel.org
+S:     Supported
+F:     drivers/platform/x86/mlxcpld-hotplug.c
+F:     include/linux/platform_data/mlxcpld-hotplug.h
+
 SOFT-ROCE DRIVER (rxe)
 M:     Moni Shoua <mo...@mellanox.com>
 L:     linux-r...@vger.kernel.org
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 81b8dcc..e9be541 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -1026,4 +1026,14 @@ config INTEL_TELEMETRY
          used to get various SoC events and parameters
          directly via debugfs files. Various tools may use
          this interface for SoC state monitoring.
+
+config MLX_CPLD_PLATFORM
+        tristate "Mellanox platform hotplug driver support"
+        default n
+       depends on MLX_PLATFORM
+       select I2C
+        ---help---
+         This driver handles hot-plug events for the power suppliers, power
+         cables and fans on the wide range Mellanox IB and Ethernet systems.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 2efa86d..1f06b63 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -71,3 +71,4 @@ obj-$(CONFIG_INTEL_TELEMETRY) += intel_telemetry_core.o \
                                   intel_telemetry_pltdrv.o \
                                   intel_telemetry_debugfs.o
 obj-$(CONFIG_INTEL_PMC_CORE)    += intel_pmc_core.o
+obj-$(CONFIG_MLX_CPLD_PLATFORM)        += mlxcpld-hotplug.o
diff --git a/drivers/platform/x86/mlxcpld-hotplug.c 
b/drivers/platform/x86/mlxcpld-hotplug.c
new file mode 100644
index 0000000..d53d845
--- /dev/null
+++ b/drivers/platform/x86/mlxcpld-hotplug.c
@@ -0,0 +1,543 @@
+/*
+ * drivers/platform/x86/mlxcpld-hotplug.c
+ * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2016 Vadim Pasternak <vad...@mellanox.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <linux/bitops.h>
+#include <linux/device.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_data/mlxcpld-hotplug.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/module.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
+
+/* Offset of event and mask registers from status register */
+#define MLXCPLD_HOTPLUG_EVENT_OFF      1
+#define MLXCPLD_HOTPLUG_MASK_OFF       2
+#define MLXCPLD_HOTPLUG_AGGR_MASK_OFF  1
+
+#define MLXCPLD_HOTPLUG_ATTRS_NUM      8
+
+enum mlxcpld_hotplug_attr_type {
+       MLXCPLD_HOTPLUG_ATTR_TYPE_PSU,
+       MLXCPLD_HOTPLUG_ATTR_TYPE_PWR,
+       MLXCPLD_HOTPLUG_ATTR_TYPE_FAN,
+};
+
+/* mlxcpld_hotplug_priv_data - platform private data:
+ * @irq - platform interrupt number;
+ * @pdev - platform device;
+ * @plat - platform data;
+ * @hwmon - hwmon device;
+ * @mlxcpld_hotplug_attr - sysfs attributes array;
+ * @mlxcpld_hotplug_dev_attr - sysfs sensor device attribute array;
+ * @group - sysfs attribute group;
+ * @groups - list of sysfs attribute group for hwmon registration;
+ * @dwork - delayed work template;
+ * @lock - spin lock;
+ * @aggr_cache - last value of aggregation register status;
+ * @psu_cache - last value of PSU register status;
+ * @pwr_cache - last value of power register status;
+ * @fan_cache - last value of FAN register status;
+ */
+struct mlxcpld_hotplug_priv_data {
+       int irq;
+       struct platform_device *pdev;
+       struct mlxcpld_hotplug_platform_data *plat;
+       struct device *hwmon;
+       struct attribute *mlxcpld_hotplug_attr[MLXCPLD_HOTPLUG_ATTRS_NUM + 1];
+       struct sensor_device_attribute_2
+                       mlxcpld_hotplug_dev_attr[MLXCPLD_HOTPLUG_ATTRS_NUM];
+       struct attribute_group group;
+       const struct attribute_group *groups[2];
+       struct delayed_work dwork;
+       spinlock_t lock;
+       u8 aggr_cache;
+       u8 psu_cache;
+       u8 pwr_cache;
+       u8 fan_cache;
+};
+
+static ssize_t mlxcpld_hotplug_attr_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct mlxcpld_hotplug_priv_data *priv = platform_get_drvdata(pdev);
+       int index = to_sensor_dev_attr_2(attr)->index;
+       int nr = to_sensor_dev_attr_2(attr)->nr;
+       u8 reg_val = 0;
+
+       switch (nr) {
+       case MLXCPLD_HOTPLUG_ATTR_TYPE_PSU:
+               reg_val = inb(priv->plat->psu_reg_offset);
+               reg_val &= BIT_MASK(index);
+               reg_val = !!!reg_val; /* Bit = 0 : PSU is present. */
+               break;
+
+       case MLXCPLD_HOTPLUG_ATTR_TYPE_PWR:
+               reg_val = inb(priv->plat->pwr_reg_offset);
+               reg_val &= BIT_MASK(index % priv->plat->pwr_count);
+               reg_val = !!reg_val; /* Bit = 1 : power cable is attached. */
+               break;
+
+       case MLXCPLD_HOTPLUG_ATTR_TYPE_FAN:
+               reg_val = inb(priv->plat->fan_reg_offset);
+               reg_val &= BIT_MASK(index % priv->plat->fan_count);
+               reg_val = !!!reg_val; /* Bit = 0 : FAN is present. */
+               break;
+       }
+
+       return sprintf(buf, "%u\n", reg_val);
+}
+
+static int mlxcpld_hotplug_attr_init(struct mlxcpld_hotplug_priv_data *priv)
+{
+       int num_attrs = priv->plat->psu_count + priv->plat->pwr_count +
+                       priv->plat->fan_count;
+       int i;
+
+       priv->group.attrs = devm_kzalloc(&priv->pdev->dev, num_attrs *
+                                        sizeof(struct attribute *),
+                                        GFP_KERNEL);
+       if (!priv->group.attrs)
+               return -ENOMEM;
+
+       for (i = 0; i < num_attrs; i++) {
+               priv->mlxcpld_hotplug_attr[i] =
+                       &priv->mlxcpld_hotplug_dev_attr[i].dev_attr.attr;
+
+               if (i < priv->plat->psu_count) {
+                       priv->mlxcpld_hotplug_attr[i]->name =
+                               devm_kasprintf(&priv->pdev->dev, GFP_KERNEL,
+                                              "psu%u", i + 1);
+                       priv->mlxcpld_hotplug_dev_attr[i].nr =
+                                               MLXCPLD_HOTPLUG_ATTR_TYPE_PSU;
+               } else if (i < priv->plat->psu_count + priv->plat->pwr_count) {
+                       priv->mlxcpld_hotplug_attr[i]->name =
+                               devm_kasprintf(&priv->pdev->dev, GFP_KERNEL,
+                                              "pwr%u", i %
+                                               priv->plat->pwr_count + 1);
+                       priv->mlxcpld_hotplug_dev_attr[i].nr =
+                                               MLXCPLD_HOTPLUG_ATTR_TYPE_PWR;
+               } else {
+                       priv->mlxcpld_hotplug_attr[i]->name =
+                               devm_kasprintf(&priv->pdev->dev, GFP_KERNEL,
+                                              "fan%u", i %
+                                               priv->plat->fan_count + 1);
+                       priv->mlxcpld_hotplug_dev_attr[i].nr =
+                                               MLXCPLD_HOTPLUG_ATTR_TYPE_FAN;
+               }
+
+               if (!priv->mlxcpld_hotplug_attr[i]->name) {
+                       dev_err(&priv->pdev->dev, "Memory allocation failed for 
sysfs attribute %d.\n",
+                               i + 1);
+                       return -ENOMEM;
+               }
+
+               priv->mlxcpld_hotplug_dev_attr[i].dev_attr.attr.name =
+                       priv->mlxcpld_hotplug_attr[i]->name;
+               priv->mlxcpld_hotplug_dev_attr[i].dev_attr.attr.mode =
+                                                               S_IRUGO;
+               priv->mlxcpld_hotplug_dev_attr[i].dev_attr.show =
+                                               mlxcpld_hotplug_attr_show;
+               priv->mlxcpld_hotplug_dev_attr[i].index = i;
+               sysfs_attr_init(
+               &priv->mlxcpld_hotplug_dev_attr[i].dev_attr.attr);
+       }
+
+       priv->group.attrs = priv->mlxcpld_hotplug_attr;
+       priv->groups[0] = &priv->group;
+       priv->groups[1] = NULL;
+
+       return 0;
+}
+
+static int mlxcpld_hotplug_device_create(struct device *dev,
+                                        struct mlxcpld_hotplug_device *item)
+{
+       item->adapter = i2c_get_adapter(item->bus);
+       if (!item->adapter) {
+               dev_err(dev, "Failed to get adapter for bus %d\n",
+                       item->bus);
+               return -EFAULT;
+       }
+
+       item->client = i2c_new_device(item->adapter, &item->brdinfo);
+       if (!item->client) {
+               dev_err(dev, "Failed to create client %s at bus %d at addr 
0x%02x\n",
+                       item->brdinfo.type, item->bus, item->brdinfo.addr);
+               i2c_put_adapter(item->adapter);
+               item->adapter = NULL;
+               return -EFAULT;
+       }
+
+       return 0;
+}
+
+static void mlxcpld_hotplug_device_destroy(struct mlxcpld_hotplug_device *item)
+{
+       if (item->client) {
+               i2c_unregister_device(item->client);
+               item->client = NULL;
+       }
+
+       if (item->adapter) {
+               i2c_put_adapter(item->adapter);
+               item->adapter = NULL;
+       }
+}
+
+/* mlxcpld_hotplug_work_handler - performs traversing of CPLD interrupt
+ * registers according to the below hierarchy schema:
+ *
+ *                   Aggregation registers (status/mask)
+ * PSU registers:           *---*
+ * *-----------------*      |   |
+ * |status/event/mask|----->| * |
+ * *-----------------*      |   |
+ * Power registers:         |   |
+ * *-----------------*      |   |
+ * |status/event/mask|----->| * |---> CPU
+ * *-----------------*      |   |
+ * FAN registers:
+ * *-----------------*      |   |
+ * |status/event/mask|----->| * |
+ * *-----------------*      |   |
+ *                          *---*
+ * In case some system changed are detected: FAN in/out, PSU in/out, power
+ * cable attached/detached, relevant device is created or destroyed.
+ */
+static void mlxcpld_hotplug_work_handler(struct work_struct *work)
+{
+       struct mlxcpld_hotplug_priv_data *priv = container_of(work,
+                               struct mlxcpld_hotplug_priv_data, dwork.work);
+       u8 val, aggr_asserted, asserted;
+       unsigned long flags;
+       int bit;
+
+       /* Mask aggregation event. */
+       outb(0, priv->plat->top_aggr_offset + MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
+       /* Read aggregation status. */
+       val = inb(priv->plat->top_aggr_offset);
+       val &= priv->plat->top_aggr_mask;
+       aggr_asserted = priv->aggr_cache ^ val;
+       priv->aggr_cache = val;
+
+       if (aggr_asserted & priv->plat->top_aggr_psu_mask) {
+               /* Mask psu presense event. */
+               outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
+               /* Read psu presense status. */
+               val = inb(priv->plat->psu_reg_offset);
+               val &= priv->plat->psu_mask;
+               asserted = priv->psu_cache ^ val;
+               priv->psu_cache = val;
+
+               if (priv->plat->psu) {
+                       for_each_set_bit(bit, (unsigned long *)&asserted, 8) {
+                               if (val & BIT(bit))
+                                       mlxcpld_hotplug_device_destroy(
+                                                       priv->plat->psu + bit);
+                               else
+                                       mlxcpld_hotplug_device_create(
+                                                       &priv->pdev->dev,
+                                                       priv->plat->psu + bit);
+                       }
+               }
+
+               /* Acknowledge psu presense event. */
+               outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+               /* Unmask psu presense event. */
+               outb(priv->plat->psu_mask, priv->plat->psu_reg_offset +
+                                               MLXCPLD_HOTPLUG_MASK_OFF);
+
+       }
+
+       if (aggr_asserted & priv->plat->top_aggr_pwr_mask) {
+               /* Mask power cable event. */
+               outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
+               /* Read power cable status. */
+               val = inb(priv->plat->pwr_reg_offset);
+               val &= priv->plat->pwr_mask;
+               asserted = priv->pwr_cache ^ val;
+               priv->pwr_cache = val;
+
+               if (priv->plat->pwr) {
+                       for_each_set_bit(bit, (unsigned long *)&asserted, 8) {
+                               if (val & BIT(bit))
+                                       mlxcpld_hotplug_device_create(
+                                                       &priv->pdev->dev,
+                                                       priv->plat->pwr + bit);
+                               else
+                                       mlxcpld_hotplug_device_destroy(
+                                                       priv->plat->pwr + bit);
+                       }
+               }
+
+               /* Acknowledge power cable event. */
+               outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+               /* Unmask power cable event */
+               outb(priv->plat->pwr_mask, priv->plat->pwr_reg_offset +
+                                               MLXCPLD_HOTPLUG_MASK_OFF);
+
+       }
+
+       if (aggr_asserted & priv->plat->top_aggr_fan_mask) {
+               /* Mask fan presense event. */
+               outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
+               /* Read fan presense status. */
+               val = inb(priv->plat->fan_reg_offset);
+               val &= priv->plat->fan_mask;
+               asserted = priv->fan_cache ^ val;
+               priv->fan_cache = val;
+
+               if (priv->plat->fan) {
+                       for_each_set_bit(bit, (unsigned long *)&asserted, 8) {
+                               if (val & BIT(bit))
+                                       mlxcpld_hotplug_device_destroy(
+                                                       priv->plat->fan + bit);
+                               else
+                                       mlxcpld_hotplug_device_create(
+                                                       &priv->pdev->dev,
+                                                       priv->plat->fan + bit);
+                       }
+               }
+
+               /* Acknowledge fan presense event. */
+               outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+               /* Unmask fan presense event. */
+               outb(priv->plat->fan_mask, priv->plat->fan_reg_offset +
+                                               MLXCPLD_HOTPLUG_MASK_OFF);
+
+               /* Unmask aggregation event (no need acknowledge). */
+               outb(priv->plat->top_aggr_mask, priv->plat->top_aggr_offset +
+                                               MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
+
+
+               spin_lock_irqsave(&priv->lock, flags);
+
+               /*
+                * It is possible, that some signals have been inserted, while
+                * interrupt has been masked by mlxcpld_hotplug_work_handler.
+                * In this case such signals will be missed. In order to handle
+                * these signals delayed work is canceled and work task
+                * re-scheduled for immediate execution. It allows to handle
+                * missed signals, if any. In other case work handler just
+                * validates that no new signals have been received during
+                * masking.
+                */
+               cancel_delayed_work(&priv->dwork);
+               schedule_delayed_work(&priv->dwork, 0);
+
+               spin_unlock_irqrestore(&priv->lock, flags);
+
+               return;
+       }
+
+       /* Unmask aggregation event (no need acknowledge). */
+       outb(priv->plat->top_aggr_mask, priv->plat->top_aggr_offset +
+                                               MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
+}
+
+static void mlxcpld_hotplug_set_irq(struct mlxcpld_hotplug_priv_data *priv)
+{
+       /* Clear psu presense event. */
+       outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+       /* Set psu initial status as mask and unmask psu event. */
+       priv->psu_cache = priv->plat->psu_mask;
+       outb(priv->plat->psu_mask, priv->plat->psu_reg_offset +
+                                               MLXCPLD_HOTPLUG_MASK_OFF);
+
+       /* Clear power cable event. */
+       outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+       /* Keep power initial status as zero and unmask power event. */
+       outb(priv->plat->pwr_mask, priv->plat->pwr_reg_offset +
+                                               MLXCPLD_HOTPLUG_MASK_OFF);
+
+       /* Clear fan presense event. */
+       outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+       /* Set fan initial status as mask and unmask fan event. */
+       priv->fan_cache = priv->plat->fan_mask;
+       outb(priv->plat->fan_mask, priv->plat->fan_reg_offset +
+                                               MLXCPLD_HOTPLUG_MASK_OFF);
+
+       /* Keep aggregation initial status as zero and unmask events. */
+       outb(priv->plat->top_aggr_mask, priv->plat->top_aggr_offset +
+                                               MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
+
+       /* Invoke work handler for initializing hot plug devices setting. */
+       mlxcpld_hotplug_work_handler(&priv->dwork.work);
+
+       enable_irq(priv->irq);
+}
+
+static void mlxcpld_hotplug_unset_irq(struct mlxcpld_hotplug_priv_data *priv)
+{
+       int i;
+
+       disable_irq(priv->irq);
+       cancel_delayed_work_sync(&priv->dwork);
+
+       /* Mask aggregation event. */
+       outb(0, priv->plat->top_aggr_offset + MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
+
+       /* Mask psu presense event. */
+       outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
+       /* Clear psu presense event. */
+       outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+
+       /* Mask power cable event. */
+       outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
+       /* Clear power cable event. */
+       outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+
+       /* Mask fan presense event. */
+       outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
+       /* Clear fan presense event. */
+       outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
+
+       /* Remove all the attached devices. */
+       for (i = 0; i < priv->plat->psu_count; i++)
+               mlxcpld_hotplug_device_destroy(priv->plat->psu + i);
+
+       for (i = 0; i < priv->plat->pwr_count; i++)
+               mlxcpld_hotplug_device_destroy(priv->plat->pwr + i);
+
+       for (i = 0; i < priv->plat->fan_count; i++)
+               mlxcpld_hotplug_device_destroy(priv->plat->fan + i);
+}
+
+static irqreturn_t mlxcpld_hotplug_irq_handler(int irq, void *dev)
+{
+       struct mlxcpld_hotplug_priv_data *priv =
+                               (struct mlxcpld_hotplug_priv_data *)dev;
+
+       /* Schedule work task for immediate execution.*/
+       schedule_delayed_work(&priv->dwork, 0);
+
+       return IRQ_HANDLED;
+}
+
+static int mlxcpld_hotplug_probe(struct platform_device *pdev)
+{
+       struct mlxcpld_hotplug_platform_data *pdata;
+       struct mlxcpld_hotplug_priv_data *priv;
+       int err;
+
+       pdata = dev_get_platdata(&pdev->dev);
+       if (!pdata) {
+               dev_err(&pdev->dev, "Failed to get platform data.\n");
+               return -EINVAL;
+       }
+
+       priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+       if (!priv)
+               return -ENOMEM;
+
+       priv->pdev = pdev;
+       priv->plat = pdata;
+
+       priv->irq = platform_get_irq(pdev, 0);
+       if (priv->irq < 0) {
+               dev_err(&pdev->dev, "Failed to get platform irq: %d\n",
+                       priv->irq);
+               return priv->irq;
+       }
+
+       err = devm_request_irq(&pdev->dev, priv->irq,
+                               mlxcpld_hotplug_irq_handler, 0, pdev->name,
+                               priv);
+       if (err) {
+               dev_err(&pdev->dev, "Failed to request irq: %d\n", err);
+               return err;
+       }
+       disable_irq(priv->irq);
+
+       INIT_DELAYED_WORK(&priv->dwork, mlxcpld_hotplug_work_handler);
+       spin_lock_init(&priv->lock);
+
+       err = mlxcpld_hotplug_attr_init(priv);
+       if (err) {
+               dev_err(&pdev->dev, "Failed to allocate attributes: %d\n", err);
+               return err;
+       }
+
+       priv->hwmon = devm_hwmon_device_register_with_groups(&pdev->dev,
+                                       "mlxcpld_hotplug", priv, priv->groups);
+       if (IS_ERR(priv->hwmon)) {
+               dev_err(&pdev->dev, "Failed to register hwmon device %ld\n",
+                       PTR_ERR(priv->hwmon));
+               return PTR_ERR(priv->hwmon);
+       }
+
+       platform_set_drvdata(pdev, priv);
+
+       /* Perform initial interrupts setup. */
+       mlxcpld_hotplug_set_irq(priv);
+
+       return 0;
+}
+
+static int mlxcpld_hotplug_remove(struct platform_device *pdev)
+{
+       struct mlxcpld_hotplug_priv_data *priv = platform_get_drvdata(pdev);
+
+       /* Clean interrupts setup. */
+       mlxcpld_hotplug_unset_irq(priv);
+
+       return 0;
+}
+
+static struct platform_driver mlxcpld_hotplug_driver = {
+       .driver = {
+               .name = "mlxcpld-hotplug",
+       },
+       .probe = mlxcpld_hotplug_probe,
+       .remove = mlxcpld_hotplug_remove,
+};
+
+module_platform_driver(mlxcpld_hotplug_driver);
+
+MODULE_AUTHOR("Vadim Pasternak <vad...@mellanox.com>");
+MODULE_DESCRIPTION("Mellanox CPLD hotplug platform driver");
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_ALIAS("platform:mlxcpld-hotplug");
diff --git a/include/linux/platform_data/mlxcpld-hotplug.h 
b/include/linux/platform_data/mlxcpld-hotplug.h
new file mode 100644
index 0000000..ebb942c
--- /dev/null
+++ b/include/linux/platform_data/mlxcpld-hotplug.h
@@ -0,0 +1,90 @@
+/*
+ * include/linux/platform_data/mlxcpld-hotplug.h
+ * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2016 Vadim Pasternak <vad...@mellanox.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_MLXCPLD_HOTPLUG_H
+#define __LINUX_PLATFORM_DATA_MLXCPLD_HOTPLUG_H
+
+/* mlxcpld_hotplug_device - I2C device data:
+ * @adapter - ;
+ * @client - ;
+ * @brdinfo - ;
+ * @bus - ;
+ */
+struct mlxcpld_hotplug_device {
+       struct i2c_adapter *adapter;
+       struct i2c_client *client;
+       struct i2c_board_info brdinfo;
+       u16 bus;
+};
+
+/* mlxcpld_hotplug_platform_data - device platform data:
+ * @top_aggr_offset - offset of top aggregation interrupt register;
+ * @top_aggr_mask - top aggregation interrupt common mask;
+ * @top_aggr_psu_mask - top aggregation interrupt PSU mask;
+ * @psu_reg_offset - offset of PSU interrupt register;
+ * @psu_mask - PSU interrupt mask;
+ * @psu_count - number of equipped replaceable PSUs;
+ * @psu - pointer to PSU devices data array;
+ * @top_aggr_pwr_mask - top aggregation interrupt power mask;
+ * @pwr_reg_offset - offset of power interrupt register
+ * @pwr_mask - power interrupt mask;
+ * @pwr_count - number of power sources;
+ * @pwr - pointer to power devices data array;
+ * @top_aggr_fan_mask - top aggregation interrupt FAN mask;
+ * @fan_reg_offset - offset of FAN interrupt register;
+ * @fan_mask - FAN interrupt mask;
+ * @fan_count - number of equipped replaceable FANs;
+ * @fan - pointer to FAN devices data array;
+ */
+struct mlxcpld_hotplug_platform_data {
+       u16 top_aggr_offset;
+       u8 top_aggr_mask;
+       u8 top_aggr_psu_mask;
+       u16 psu_reg_offset;
+       u8 psu_mask;
+       u8 psu_count;
+       struct mlxcpld_hotplug_device *psu;
+       u8 top_aggr_pwr_mask;
+       u16 pwr_reg_offset;
+       u8 pwr_mask;
+       u8 pwr_count;
+       struct mlxcpld_hotplug_device *pwr;
+       u8 top_aggr_fan_mask;
+       u16 fan_reg_offset;
+       u8 fan_mask;
+       u8 fan_count;
+       struct mlxcpld_hotplug_device *fan;
+};
+
+#endif /* __LINUX_PLATFORM_DATA_MLXCPLD_HOTPLUG_H */
-- 
2.1.4

Reply via email to