siox: new driver framework for eckelmann SIOX

SIOX is a bus system invented at Eckelmann AG to control their building
management and refrigeration systems. Traditionally the bus was
implemented on custom microcontrollers, today Linux based machines are
in use, too.

The topology on a SIOX bus looks as follows:

      ,------->--DCLK-->---------------+----------------------.
      ^                                v                      v
 ,--------.                ,----------------------.       ,------
 |        |                |   ,--------------.   |       |
 |        |--->--DOUT-->---|->-|shift register|->-|--->---|
 |        |                |   `--------------'   |       |
 | master |                |        device        |       |  device
 |        |                |   ,--------------.   |       |
 |        |---<--DIN---<---|-<-|shift register|-<-|---<---|
 |        |                |   `--------------'   |       |
 `--------'                `----------------------'       `------
      v                                ^                      ^
      `----------DLD-------------------+----------------------'

There are two control lines (DCLK and DLD) driven from the bus master to
all devices in parallel and two daisy chained data lines, one for input
and one for output. DCLK is the clock to shift both chains by a single
bit. On an edge of DLD the devices latch both their input and output
shift registers.

This patch adds a framework for this bus type.

Acked-by: Gavin Schenk <g.schenk@eckelmann.de>
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

4 files changed, 981 insertions, 0 deletions

diff --git a/drivers/siox/Kconfig b/drivers/siox/Kconfig
new file mode 100644
index 000000000000..bd24d9b50dc6
--- /dev/null
+++ b/drivers/siox/Kconfig
@@ -0,0 +1,9 @@
+menuconfig SIOX
+        tristate "Eckelmann SIOX Support"
+        help
+          SIOX stands for Serial Input Output eXtension and is a synchronous
+          bus system invented by Eckelmann AG. It is used in their control and
+          remote monitoring systems for commercial and industrial refrigeration
+          to drive additional I/O units.
+
+          Unless you know better, it is probably safe to say "no" here.
diff --git a/drivers/siox/Makefile b/drivers/siox/Makefile
new file mode 100644
index 000000000000..d55cb5e08868
--- /dev/null
+++ b/drivers/siox/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_SIOX) += siox-core.o
diff --git a/drivers/siox/siox-core.c b/drivers/siox/siox-core.c
new file mode 100644
index 000000000000..16585c1b2b9e
--- /dev/null
+++ b/drivers/siox/siox-core.c
@@ -0,0 +1,922 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2015-2017 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
+ */
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+
+#include "siox.h"
+
+/*
+ * The lowest bit in the SIOX status word signals if the in-device watchdog is
+ * ok. If the bit is set, the device is functional.
+ *
+ * On writing the watchdog timer is reset when this bit toggles.
+ */
+#define SIOX_STATUS_WDG                 0x01
+
+/*
+ * Bits 1 to 3 of the status word read as the bitwise negation of what was
+ * clocked in before. The value clocked in is changed in each cycle and so
+ * allows to detect transmit/receive problems.
+ */
+#define SIOX_STATUS_COUNTER             0x0e
+
+/*
+ * Each Siox-Device has a 4 bit type number that is neither 0 nor 15. This is
+ * available in the upper nibble of the read status.
+ *
+ * On write these bits are DC.
+ */
+#define SIOX_STATUS_TYPE                0xf0
+
+static bool siox_is_registered;
+
+static void siox_master_lock(struct siox_master *smaster)
+{
+        mutex_lock(&smaster->lock);
+}
+
+static void siox_master_unlock(struct siox_master *smaster)
+{
+        mutex_unlock(&smaster->lock);
+}
+
+static inline u8 siox_status_clean(u8 status_read, u8 status_written)
+{
+        /*
+         * bits 3:1 of status sample the respective bit in the status
+         * byte written in the previous cycle but inverted. So if you wrote the
+         * status word as 0xa before (counter = 0b101), it is expected to get
+         * back the counter bits as 0b010.
+         *
+         * So given the last status written this function toggles the there
+         * unset counter bits in the read value such that the counter bits in
+         * the return value are all zero iff the bits were read as expected to
+         * simplify error detection.
+         */
+
+        return status_read ^ (~status_written & 0xe);
+}
+
+static bool siox_device_counter_error(struct siox_device *sdevice,
+                                      u8 status_clean)
+{
+        return (status_clean & SIOX_STATUS_COUNTER) != 0;
+}
+
+static bool siox_device_type_error(struct siox_device *sdevice, u8 status_clean)
+{
+        u8 statustype = (status_clean & SIOX_STATUS_TYPE) >> 4;
+
+        /*
+         * If the device knows which value the type bits should have, check
+         * against this value otherwise just rule out the invalid values 0b0000
+         * and 0b1111.
+         */
+        if (sdevice->statustype) {
+                if (statustype != sdevice->statustype)
+                        return true;
+        } else {
+                switch (statustype) {
+                case 0:
+                case 0xf:
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+static bool siox_device_wdg_error(struct siox_device *sdevice, u8 status_clean)
+{
+        return (status_clean & SIOX_STATUS_WDG) == 0;
+}
+
+/*
+ * If there is a type or counter error the device is called "unsynced".
+ */
+bool siox_device_synced(struct siox_device *sdevice)
+{
+        if (siox_device_type_error(sdevice, sdevice->status_read_clean))
+                return false;
+
+        return !siox_device_counter_error(sdevice, sdevice->status_read_clean);
+
+}
+EXPORT_SYMBOL_GPL(siox_device_synced);
+
+/*
+ * A device is called "connected" if it is synced and the watchdog is not
+ * asserted.
+ */
+bool siox_device_connected(struct siox_device *sdevice)
+{
+        if (!siox_device_synced(sdevice))
+                return false;
+
+        return !siox_device_wdg_error(sdevice, sdevice->status_read_clean);
+}
+EXPORT_SYMBOL_GPL(siox_device_connected);
+
+static void siox_poll(struct siox_master *smaster)
+{
+        struct siox_device *sdevice;
+        size_t i = smaster->setbuf_len;
+        int unsync_error = 0;
+
+        smaster->last_poll = jiffies;
+
+        /*
+         * The counter bits change in each second cycle, the watchdog bit
+         * toggles each time.
+         * The counter bits hold values from [0, 6]. 7 would be possible
+         * theoretically but the protocol designer considered that a bad idea
+         * for reasons unknown today. (Maybe that's because then the status read
+         * back has only zeros in the counter bits then which might be confused
+         * with a stuck-at-0 error. But for the same reason (with s/0/1/) 0
+         * could be skipped.)
+         */
+        if (++smaster->status > 0x0d)
+                smaster->status = 0;
+
+        memset(smaster->buf, 0, smaster->setbuf_len);
+
+        /* prepare data pushed out to devices in buf[0..setbuf_len) */
+        list_for_each_entry(sdevice, &smaster->devices, node) {
+                struct siox_driver *sdriver =
+                        to_siox_driver(sdevice->dev.driver);
+                sdevice->status_written = smaster->status;
+
+                i -= sdevice->inbytes;
+
+                /*
+                 * If the device or a previous one is unsynced, don't pet the
+                 * watchdog. This is done to ensure that the device is kept in
+                 * reset when something is wrong.
+                 */
+                if (!siox_device_synced(sdevice))
+                        unsync_error = 1;
+
+                if (sdriver && !unsync_error)
+                        sdriver->set_data(sdevice, sdevice->status_written,
+                                          &smaster->buf[i + 1]);
+                else
+                        /*
+                         * Don't trigger watchdog if there is no driver or a
+                         * sync problem
+                         */
+                        sdevice->status_written &= ~SIOX_STATUS_WDG;
+
+                smaster->buf[i] = sdevice->status_written;
+        }
+
+        smaster->pushpull(smaster, smaster->setbuf_len, smaster->buf,
+                          smaster->getbuf_len,
+                          smaster->buf + smaster->setbuf_len);
+
+        unsync_error = 0;
+
+        /* interpret data pulled in from devices in buf[setbuf_len..] */
+        i = smaster->setbuf_len;
+        list_for_each_entry(sdevice, &smaster->devices, node) {
+                struct siox_driver *sdriver =
+                        to_siox_driver(sdevice->dev.driver);
+                u8 status = smaster->buf[i + sdevice->outbytes - 1];
+                u8 status_clean;
+                u8 prev_status_clean = sdevice->status_read_clean;
+                bool synced = true;
+                bool connected = true;
+
+                if (!siox_device_synced(sdevice))
+                        unsync_error = 1;
+
+                /*
+                 * If the watchdog bit wasn't toggled in this cycle, report the
+                 * watchdog as active to give a consistent view for drivers and
+                 * sysfs consumers.
+                 */
+                if (!sdriver || unsync_error)
+                        status &= ~SIOX_STATUS_WDG;
+
+                status_clean =
+                        siox_status_clean(status,
+                                          sdevice->status_written_lastcycle);
+
+                /* Check counter bits */
+                if (siox_device_counter_error(sdevice, status_clean)) {
+                        bool prev_counter_error;
+
+                        synced = false;
+
+                        /* only report a new error if the last cycle was ok */
+                        prev_counter_error =
+                                siox_device_counter_error(sdevice,
+                                                          prev_status_clean);
+                        if (!prev_counter_error) {
+                                sdevice->status_errors++;
+                                sysfs_notify_dirent(sdevice->status_errors_kn);
+                        }
+                }
+
+                /* Check type bits */
+                if (siox_device_type_error(sdevice, status_clean))
+                        synced = false;
+
+                /* If the device is unsynced report the watchdog as active */
+                if (!synced) {
+                        status &= ~SIOX_STATUS_WDG;
+                        status_clean &= ~SIOX_STATUS_WDG;
+                }
+
+                if (siox_device_wdg_error(sdevice, status_clean))
+                        connected = false;
+
+                /* The watchdog state changed just now */
+                if ((status_clean ^ prev_status_clean) & SIOX_STATUS_WDG) {
+                        sysfs_notify_dirent(sdevice->watchdog_kn);
+
+                        if (siox_device_wdg_error(sdevice, status_clean)) {
+                                struct kernfs_node *wd_errs =
+                                        sdevice->watchdog_errors_kn;
+
+                                sdevice->watchdog_errors++;
+                                sysfs_notify_dirent(wd_errs);
+                        }
+                }
+
+                if (connected != sdevice->connected)
+                        sysfs_notify_dirent(sdevice->connected_kn);
+
+                sdevice->status_read_clean = status_clean;
+                sdevice->status_written_lastcycle = sdevice->status_written;
+                sdevice->connected = connected;
+
+                /* only give data read to driver if the device is connected */
+                if (sdriver && connected)
+                        sdriver->get_data(sdevice, &smaster->buf[i]);
+
+                i += sdevice->outbytes;
+        }
+}
+
+static int siox_poll_thread(void *data)
+{
+        struct siox_master *smaster = data;
+        signed long timeout = 0;
+
+        get_device(&smaster->dev);
+
+        for (;;) {
+                if (kthread_should_stop()) {
+                        put_device(&smaster->dev);
+                        return 0;
+                }
+
+                siox_master_lock(smaster);
+
+                if (smaster->active) {
+                        unsigned long next_poll =
+                                smaster->last_poll + smaster->poll_interval;
+                        if (time_is_before_eq_jiffies(next_poll))
+                                siox_poll(smaster);
+
+                        timeout = smaster->poll_interval -
+                                (jiffies - smaster->last_poll);
+                } else {
+                        timeout = MAX_SCHEDULE_TIMEOUT;
+                }
+
+                /*
+                 * Set the task to idle while holding the lock. This makes sure
+                 * that we don't sleep too long when the bus is reenabled before
+                 * schedule_timeout is reached.
+                 */
+                if (timeout > 0)
+                        set_current_state(TASK_IDLE);
+
+                siox_master_unlock(smaster);
+
+                if (timeout > 0)
+                        schedule_timeout(timeout);
+
+                /*
+                 * I'm not clear if/why it is important to set the state to
+                 * RUNNING again, but it fixes a "do not call blocking ops when
+                 * !TASK_RUNNING;"-warning.
+                 */
+                set_current_state(TASK_RUNNING);
+        }
+}
+
+static int __siox_start(struct siox_master *smaster)
+{
+        if (!(smaster->setbuf_len + smaster->getbuf_len))
+                return -ENODEV;
+
+        if (!smaster->buf)
+                return -ENOMEM;
+
+        if (smaster->active)
+                return 0;
+
+        smaster->active = 1;
+        wake_up_process(smaster->poll_thread);
+
+        return 1;
+}
+
+static int siox_start(struct siox_master *smaster)
+{
+        int ret;
+
+        siox_master_lock(smaster);
+        ret = __siox_start(smaster);
+        siox_master_unlock(smaster);
+
+        return ret;
+}
+
+static int __siox_stop(struct siox_master *smaster)
+{
+        if (smaster->active) {
+                struct siox_device *sdevice;
+
+                smaster->active = 0;
+
+                list_for_each_entry(sdevice, &smaster->devices, node) {
+                        if (sdevice->connected)
+                                sysfs_notify_dirent(sdevice->connected_kn);
+                        sdevice->connected = false;
+                }
+
+                return 1;
+        }
+        return 0;
+}
+
+static int siox_stop(struct siox_master *smaster)
+{
+        int ret;
+
+        siox_master_lock(smaster);
+        ret = __siox_stop(smaster);
+        siox_master_unlock(smaster);
+
+        return ret;
+}
+
+static ssize_t type_show(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+
+        return sprintf(buf, "%s\n", sdev->type);
+}
+
+static DEVICE_ATTR_RO(type);
+
+static ssize_t inbytes_show(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+
+        return sprintf(buf, "%zu\n", sdev->inbytes);
+}
+
+static DEVICE_ATTR_RO(inbytes);
+
+static ssize_t outbytes_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+
+        return sprintf(buf, "%zu\n", sdev->outbytes);
+}
+
+static DEVICE_ATTR_RO(outbytes);
+
+static ssize_t status_errors_show(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+        unsigned int status_errors;
+
+        siox_master_lock(sdev->smaster);
+
+        status_errors = sdev->status_errors;
+
+        siox_master_unlock(sdev->smaster);
+
+        return sprintf(buf, "%u\n", status_errors);
+}
+
+static DEVICE_ATTR_RO(status_errors);
+
+static ssize_t connected_show(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+        bool connected;
+
+        siox_master_lock(sdev->smaster);
+
+        connected = sdev->connected;
+
+        siox_master_unlock(sdev->smaster);
+
+        return sprintf(buf, "%u\n", connected);
+}
+
+static DEVICE_ATTR_RO(connected);
+
+static ssize_t watchdog_show(struct device *dev,
+                             struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+        u8 status;
+
+        siox_master_lock(sdev->smaster);
+
+        status = sdev->status_read_clean;
+
+        siox_master_unlock(sdev->smaster);
+
+        return sprintf(buf, "%d\n", status & SIOX_STATUS_WDG);
+}
+
+static DEVICE_ATTR_RO(watchdog);
+
+static ssize_t watchdog_errors_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct siox_device *sdev = to_siox_device(dev);
+        unsigned int watchdog_errors;
+
+        siox_master_lock(sdev->smaster);
+
+        watchdog_errors = sdev->watchdog_errors;
+
+        siox_master_unlock(sdev->smaster);
+
+        return sprintf(buf, "%u\n", watchdog_errors);
+}
+
+static DEVICE_ATTR_RO(watchdog_errors);
+
+static struct attribute *siox_device_attrs[] = {
+        &dev_attr_type.attr,
+        &dev_attr_inbytes.attr,
+        &dev_attr_outbytes.attr,
+        &dev_attr_status_errors.attr,
+        &dev_attr_connected.attr,
+        &dev_attr_watchdog.attr,
+        &dev_attr_watchdog_errors.attr,
+        NULL
+};
+ATTRIBUTE_GROUPS(siox_device);
+
+static void siox_device_release(struct device *dev)
+{
+        struct siox_device *sdevice = to_siox_device(dev);
+
+        kfree(sdevice);
+}
+
+static struct device_type siox_device_type = {
+        .groups = siox_device_groups,
+        .release = siox_device_release,
+};
+
+static int siox_match(struct device *dev, struct device_driver *drv)
+{
+        if (dev->type != &siox_device_type)
+                return 0;
+
+        /* up to now there is only a single driver so keeping this simple */
+        return 1;
+}
+
+static struct bus_type siox_bus_type = {
+        .name = "siox",
+        .match = siox_match,
+};
+
+static int siox_driver_probe(struct device *dev)
+{
+        struct siox_driver *sdriver = to_siox_driver(dev->driver);
+        struct siox_device *sdevice = to_siox_device(dev);
+        int ret;
+
+        ret = sdriver->probe(sdevice);
+        return ret;
+}
+
+static int siox_driver_remove(struct device *dev)
+{
+        struct siox_driver *sdriver =
+                container_of(dev->driver, struct siox_driver, driver);
+        struct siox_device *sdevice = to_siox_device(dev);
+        int ret;
+
+        ret = sdriver->remove(sdevice);
+        return ret;
+}
+
+static void siox_driver_shutdown(struct device *dev)
+{
+        struct siox_driver *sdriver =
+                container_of(dev->driver, struct siox_driver, driver);
+        struct siox_device *sdevice = to_siox_device(dev);
+
+        sdriver->shutdown(sdevice);
+}
+
+static ssize_t active_show(struct device *dev,
+                           struct device_attribute *attr, char *buf)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+
+        return sprintf(buf, "%d\n", smaster->active);
+}
+
+static ssize_t active_store(struct device *dev,
+                            struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+        int ret;
+        int active;
+
+        ret = kstrtoint(buf, 0, &active);
+        if (ret < 0)
+                return ret;
+
+        if (active)
+                ret = siox_start(smaster);
+        else
+                ret = siox_stop(smaster);
+
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static DEVICE_ATTR_RW(active);
+
+static struct siox_device *siox_device_add(struct siox_master *smaster,
+                                           const char *type, size_t inbytes,
+                                           size_t outbytes, u8 statustype);
+
+static ssize_t device_add_store(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+        int ret;
+        char type[20] = "";
+        size_t inbytes = 0, outbytes = 0;
+        u8 statustype = 0;
+
+        ret = sscanf(buf, "%20s %zu %zu %hhu", type, &inbytes,
+                     &outbytes, &statustype);
+        if (ret != 3 && ret != 4)
+                return -EINVAL;
+
+        if (strcmp(type, "siox-12x8") || inbytes != 2 || outbytes != 4)
+                return -EINVAL;
+
+        siox_device_add(smaster, "siox-12x8", inbytes, outbytes, statustype);
+
+        return count;
+}
+
+static DEVICE_ATTR_WO(device_add);
+
+static void siox_device_remove(struct siox_master *smaster);
+
+static ssize_t device_remove_store(struct device *dev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+
+        /* XXX? require to write <type> <inbytes> <outbytes> */
+        siox_device_remove(smaster);
+
+        return count;
+}
+
+static DEVICE_ATTR_WO(device_remove);
+
+static ssize_t poll_interval_ns_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+
+        return sprintf(buf, "%lld\n", jiffies_to_nsecs(smaster->poll_interval));
+}
+
+static ssize_t poll_interval_ns_store(struct device *dev,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+        int ret;
+        u64 val;
+
+        ret = kstrtou64(buf, 0, &val);
+        if (ret < 0)
+                return ret;
+
+        siox_master_lock(smaster);
+
+        smaster->poll_interval = nsecs_to_jiffies(val);
+
+        siox_master_unlock(smaster);
+
+        return count;
+}
+
+static DEVICE_ATTR_RW(poll_interval_ns);
+
+static struct attribute *siox_master_attrs[] = {
+        &dev_attr_active.attr,
+        &dev_attr_device_add.attr,
+        &dev_attr_device_remove.attr,
+        &dev_attr_poll_interval_ns.attr,
+        NULL
+};
+ATTRIBUTE_GROUPS(siox_master);
+
+static void siox_master_release(struct device *dev)
+{
+        struct siox_master *smaster = to_siox_master(dev);
+
+        kfree(smaster);
+}
+
+static struct device_type siox_master_type = {
+        .groups = siox_master_groups,
+        .release = siox_master_release,
+};
+
+struct siox_master *siox_master_alloc(struct device *dev,
+                                      size_t size)
+{
+        struct siox_master *smaster;
+
+        if (!dev)
+                return NULL;
+
+        smaster = kzalloc(sizeof(*smaster) + size, GFP_KERNEL);
+        if (!smaster)
+                return NULL;
+
+        device_initialize(&smaster->dev);
+
+        smaster->busno = -1;
+        smaster->dev.bus = &siox_bus_type;
+        smaster->dev.type = &siox_master_type;
+        smaster->dev.parent = dev;
+        smaster->poll_interval = DIV_ROUND_UP(HZ, 40);
+
+        dev_set_drvdata(&smaster->dev, &smaster[1]);
+
+        return smaster;
+}
+EXPORT_SYMBOL_GPL(siox_master_alloc);
+
+int siox_master_register(struct siox_master *smaster)
+{
+        int ret;
+
+        if (!siox_is_registered)
+                return -EPROBE_DEFER;
+
+        if (!smaster->pushpull)
+                return -EINVAL;
+
+        dev_set_name(&smaster->dev, "siox-%d", smaster->busno);
+
+        smaster->last_poll = jiffies;
+        smaster->poll_thread = kthread_create(siox_poll_thread, smaster,
+                                              "siox-%d", smaster->busno);
+        if (IS_ERR(smaster->poll_thread)) {
+                smaster->active = 0;
+                return PTR_ERR(smaster->poll_thread);
+        }
+
+        mutex_init(&smaster->lock);
+        INIT_LIST_HEAD(&smaster->devices);
+
+        ret = device_add(&smaster->dev);
+        if (ret)
+                kthread_stop(smaster->poll_thread);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(siox_master_register);
+
+void siox_master_unregister(struct siox_master *smaster)
+{
+        /* remove device */
+        device_del(&smaster->dev);
+
+        siox_master_lock(smaster);
+
+        __siox_stop(smaster);
+
+        while (smaster->num_devices) {
+                struct siox_device *sdevice;
+
+                sdevice = container_of(smaster->devices.prev,
+                                       struct siox_device, node);
+                list_del(&sdevice->node);
+                smaster->num_devices--;
+
+                siox_master_unlock(smaster);
+
+                device_unregister(&sdevice->dev);
+
+                siox_master_lock(smaster);
+        }
+
+        siox_master_unlock(smaster);
+
+        put_device(&smaster->dev);
+}
+EXPORT_SYMBOL_GPL(siox_master_unregister);
+
+static struct siox_device *siox_device_add(struct siox_master *smaster,
+                                           const char *type, size_t inbytes,
+                                           size_t outbytes, u8 statustype)
+{
+        struct siox_device *sdevice;
+        int ret;
+        size_t buf_len;
+
+        sdevice = kzalloc(sizeof(*sdevice), GFP_KERNEL);
+        if (!sdevice)
+                return ERR_PTR(-ENOMEM);
+
+        sdevice->type = type;
+        sdevice->inbytes = inbytes;
+        sdevice->outbytes = outbytes;
+        sdevice->statustype = statustype;
+
+        sdevice->smaster = smaster;
+        sdevice->dev.parent = &smaster->dev;
+        sdevice->dev.bus = &siox_bus_type;
+        sdevice->dev.type = &siox_device_type;
+
+        siox_master_lock(smaster);
+
+        dev_set_name(&sdevice->dev, "siox-%d-%d",
+                     smaster->busno, smaster->num_devices);
+
+        buf_len = smaster->setbuf_len + inbytes +
+                smaster->getbuf_len + outbytes;
+        if (smaster->buf_len < buf_len) {
+                u8 *buf = krealloc(smaster->buf, buf_len, GFP_KERNEL);
+
+                if (!buf) {
+                        dev_err(&smaster->dev,
+                                "failed to realloc buffer to %zu\n", buf_len);
+                        ret = -ENOMEM;
+                        goto err_buf_alloc;
+                }
+
+                smaster->buf_len = buf_len;
+                smaster->buf = buf;
+        }
+
+        ret = device_register(&sdevice->dev);
+        if (ret) {
+                dev_err(&smaster->dev, "failed to register device: %d\n", ret);
+
+                goto err_device_register;
+        }
+
+        smaster->num_devices++;
+        list_add_tail(&sdevice->node, &smaster->devices);
+
+        smaster->setbuf_len += sdevice->inbytes;
+        smaster->getbuf_len += sdevice->outbytes;
+
+        sdevice->status_errors_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
+                                                     "status_errors");
+        sdevice->watchdog_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
+                                                "watchdog");
+        sdevice->watchdog_errors_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
+                                                       "watchdog_errors");
+        sdevice->connected_kn = sysfs_get_dirent(sdevice->dev.kobj.sd,
+                                                 "connected");
+
+        siox_master_unlock(smaster);
+
+        return sdevice;
+
+err_device_register:
+        /* don't care to make the buffer smaller again */
+
+err_buf_alloc:
+        siox_master_unlock(smaster);
+
+        kfree(sdevice);
+
+        return ERR_PTR(ret);
+}
+
+static void siox_device_remove(struct siox_master *smaster)
+{
+        struct siox_device *sdevice;
+
+        siox_master_lock(smaster);
+
+        if (!smaster->num_devices) {
+                siox_master_unlock(smaster);
+                return;
+        }
+
+        sdevice = container_of(smaster->devices.prev, struct siox_device, node);
+        list_del(&sdevice->node);
+        smaster->num_devices--;
+
+        smaster->setbuf_len -= sdevice->inbytes;
+        smaster->getbuf_len -= sdevice->outbytes;
+
+        if (!smaster->num_devices)
+                __siox_stop(smaster);
+
+        siox_master_unlock(smaster);
+
+        /*
+         * This must be done without holding the master lock because we're
+         * called from device_remove_store which also holds a sysfs mutex.
+         * device_unregister tries to aquire the same lock.
+         */
+        device_unregister(&sdevice->dev);
+}
+
+int __siox_driver_register(struct siox_driver *sdriver, struct module *owner)
+{
+        int ret;
+
+        if (unlikely(!siox_is_registered))
+                return -EPROBE_DEFER;
+
+        if (!sdriver->set_data && !sdriver->get_data) {
+                pr_err("Driver %s doesn't provide needed callbacks\n",
+                       sdriver->driver.name);
+                return -EINVAL;
+        }
+
+        sdriver->driver.owner = owner;
+        sdriver->driver.bus = &siox_bus_type;
+
+        if (sdriver->probe)
+                sdriver->driver.probe = siox_driver_probe;
+        if (sdriver->remove)
+                sdriver->driver.remove = siox_driver_remove;
+        if (sdriver->shutdown)
+                sdriver->driver.shutdown = siox_driver_shutdown;
+
+        ret = driver_register(&sdriver->driver);
+        if (ret)
+                pr_err("Failed to register siox driver %s (%d)\n",
+                       sdriver->driver.name, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__siox_driver_register);
+
+static int __init siox_init(void)
+{
+        int ret;
+
+        ret = bus_register(&siox_bus_type);
+        if (ret) {
+                pr_err("Registration of SIOX bus type failed: %d\n", ret);
+                return ret;
+        }
+
+        siox_is_registered = true;
+
+        return 0;
+}
+subsys_initcall(siox_init);
+
+static void __exit siox_exit(void)
+{
+        bus_unregister(&siox_bus_type);
+}
+module_exit(siox_exit);
+
+MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
+MODULE_DESCRIPTION("Eckelmann SIOX driver core");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/siox/siox.h b/drivers/siox/siox.h
new file mode 100644
index 000000000000..c674bf6fb119
--- /dev/null
+++ b/drivers/siox/siox.h
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2015-2017 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
+ */
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#include <linux/siox.h>
+
+#define to_siox_master(_dev)    container_of((_dev), struct siox_master, dev)
+struct siox_master {
+        /* these fields should be initialized by the driver */
+        int busno;
+        int (*pushpull)(struct siox_master *smaster,
+                        size_t setbuf_len, const u8 setbuf[],
+                        size_t getbuf_len, u8 getbuf[]);
+
+        /* might be initialized by the driver, if 0 it is set to HZ / 40 */
+        unsigned long poll_interval; /* in jiffies */
+
+        /* framework private stuff */
+        struct mutex lock;
+        bool active;
+        struct module *owner;
+        struct device dev;
+        unsigned int num_devices;
+        struct list_head devices;
+
+        size_t setbuf_len, getbuf_len;
+        size_t buf_len;
+        u8 *buf;
+        u8 status;
+
+        unsigned long last_poll;
+        struct task_struct *poll_thread;
+};
+
+static inline void *siox_master_get_devdata(struct siox_master *smaster)
+{
+        return dev_get_drvdata(&smaster->dev);
+}
+
+struct siox_master *siox_master_alloc(struct device *dev, size_t size);
+static inline void siox_master_put(struct siox_master *smaster)
+{
+        put_device(&smaster->dev);
+}
+
+int siox_master_register(struct siox_master *smaster);
+void siox_master_unregister(struct siox_master *smaster);