diff --git a/sys/compat/linuxkpi/common/include/linux/i2c.h b/sys/compat/linuxkpi/common/include/linux/i2c.h index 0bb8b470edd7..365ab893fdfd 100644 --- a/sys/compat/linuxkpi/common/include/linux/i2c.h +++ b/sys/compat/linuxkpi/common/include/linux/i2c.h @@ -1,152 +1,152 @@ /*- * Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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_I2C_H_ #define _LINUX_I2C_H_ #include #include #include #include #define I2C_MAX_ADAPTER_NAME_LENGTH 32 #define I2C_M_RD 0x0001 #define I2C_M_NOSTART 0x0002 #define I2C_M_STOP 0x0004 /* No need for us */ #define I2C_FUNC_I2C 0 #define I2C_FUNC_SMBUS_EMUL 0 #define I2C_FUNC_SMBUS_READ_BLOCK_DATA 0 #define I2C_FUNC_SMBUS_BLOCK_PROC_CALL 0 #define I2C_FUNC_10BIT_ADDR 0 #define I2C_CLASS_DDC 0x8 #define I2C_CLASS_SPD 0x80 struct i2c_adapter { struct module *owner; unsigned int class; char name[I2C_MAX_ADAPTER_NAME_LENGTH]; struct device dev; const struct i2c_lock_operations *lock_ops; const struct i2c_algorithm *algo; void *algo_data; int retries; void *data; }; struct i2c_msg { uint16_t addr; uint16_t flags; uint16_t len; uint8_t *buf; }; struct i2c_algorithm { int (*master_xfer)(struct i2c_adapter *, struct i2c_msg *, int); uint32_t (*functionality)(struct i2c_adapter *); }; struct i2c_lock_operations { void (*lock_bus)(struct i2c_adapter *, unsigned int); int (*trylock_bus)(struct i2c_adapter *, unsigned int); void (*unlock_bus)(struct i2c_adapter *, unsigned int); }; int lkpi_i2c_add_adapter(struct i2c_adapter *adapter); int lkpi_i2c_del_adapter(struct i2c_adapter *adapter); int lkpi_i2cbb_transfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int nmsgs); #define i2c_add_adapter(adapter) lkpi_i2c_add_adapter(adapter) #define i2c_del_adapter(adapter) lkpi_i2c_del_adapter(adapter) #define i2c_get_adapter(x) NULL #define i2c_put_adapter(x) static inline int do_i2c_transfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int nmsgs) { int ret, retries; retries = adapter->retries == 0 ? 1 : adapter->retries; for (; retries != 0; retries--) { - if (adapter->algo->master_xfer != NULL) + if (adapter->algo != NULL && adapter->algo->master_xfer != NULL) ret = adapter->algo->master_xfer(adapter, msgs, nmsgs); else ret = lkpi_i2cbb_transfer(adapter, msgs, nmsgs); if (ret != -EAGAIN) break; } return (ret); } static inline int i2c_transfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int nmsgs) { int ret; - if (!adapter->algo) + if (adapter->algo == NULL && adapter->algo_data == NULL) return (-EOPNOTSUPP); if (adapter->lock_ops) adapter->lock_ops->lock_bus(adapter, 0); ret = do_i2c_transfer(adapter, msgs, nmsgs); if (adapter->lock_ops) adapter->lock_ops->unlock_bus(adapter, 0); return (ret); } /* Unlocked version of i2c_transfer */ static inline int __i2c_transfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int nmsgs) { return (do_i2c_transfer(adapter, msgs, nmsgs)); } static inline void i2c_set_adapdata(struct i2c_adapter *adapter, void *data) { adapter->data = data; } static inline void * i2c_get_adapdata(struct i2c_adapter *adapter) { return (adapter->data); } #endif /* _LINUX_I2C_H_ */ diff --git a/sys/compat/linuxkpi/common/src/linux_i2cbb.c b/sys/compat/linuxkpi/common/src/linux_i2cbb.c index c4bfdf32e562..4020cd91d8c5 100644 --- a/sys/compat/linuxkpi/common/src/linux_i2cbb.c +++ b/sys/compat/linuxkpi/common/src/linux_i2cbb.c @@ -1,257 +1,334 @@ /*- * Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include +#include "iicbus_if.h" #include "iicbb_if.h" #include "lkpi_iic_if.h" static void lkpi_iicbb_setsda(device_t dev, int val); static void lkpi_iicbb_setscl(device_t dev, int val); static int lkpi_iicbb_getscl(device_t dev); static int lkpi_iicbb_getsda(device_t dev); static int lkpi_iicbb_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr); +static int lkpi_iicbb_pre_xfer(device_t dev); +static void lkpi_iicbb_post_xfer(device_t dev); struct lkpi_iicbb_softc { device_t iicbb; struct i2c_adapter *adapter; }; +static struct sx lkpi_sx_i2cbb; + +static void +lkpi_sysinit_i2cbb(void *arg __unused) +{ + + sx_init(&lkpi_sx_i2cbb, "lkpi-i2cbb"); +} + +static void +lkpi_sysuninit_i2cbb(void *arg __unused) +{ + + sx_destroy(&lkpi_sx_i2cbb); +} + +SYSINIT(lkpi_i2cbb, SI_SUB_DRIVERS, SI_ORDER_ANY, + lkpi_sysinit_i2cbb, NULL); +SYSUNINIT(lkpi_i2cbb, SI_SUB_DRIVERS, SI_ORDER_ANY, + lkpi_sysuninit_i2cbb, NULL); + static int lkpi_iicbb_probe(device_t dev) { device_set_desc(dev, "LinuxKPI I2CBB"); return (BUS_PROBE_NOWILDCARD); } static int lkpi_iicbb_attach(device_t dev) { struct lkpi_iicbb_softc *sc; sc = device_get_softc(dev); sc->iicbb = device_add_child(dev, "iicbb", -1); if (sc->iicbb == NULL) { device_printf(dev, "Couldn't add iicbb child, aborting\n"); return (ENXIO); } bus_generic_attach(dev); return (0); } static int lkpi_iicbb_detach(device_t dev) { struct lkpi_iicbb_softc *sc; sc = device_get_softc(dev); if (sc->iicbb) device_delete_child(dev, sc->iicbb); return (0); } static int lkpi_iicbb_add_adapter(device_t dev, struct i2c_adapter *adapter) { struct lkpi_iicbb_softc *sc; + struct i2c_algo_bit_data *algo_data; sc = device_get_softc(dev); sc->adapter = adapter; + /* + * Set iicbb timing parameters deriving speed from the protocol delay. + */ + algo_data = adapter->algo_data; + if (algo_data->udelay != 0) + IICBUS_RESET(sc->iicbb, 1000000 / algo_data->udelay, 0, NULL); return (0); } static struct i2c_adapter * lkpi_iicbb_get_adapter(device_t dev) { struct lkpi_iicbb_softc *sc; sc = device_get_softc(dev); return (sc->adapter); } static device_method_t lkpi_iicbb_methods[] = { /* device interface */ DEVMETHOD(device_probe, lkpi_iicbb_probe), DEVMETHOD(device_attach, lkpi_iicbb_attach), DEVMETHOD(device_detach, lkpi_iicbb_detach), DEVMETHOD(device_suspend, bus_generic_suspend), DEVMETHOD(device_resume, bus_generic_resume), /* iicbb interface */ DEVMETHOD(iicbb_setsda, lkpi_iicbb_setsda), DEVMETHOD(iicbb_setscl, lkpi_iicbb_setscl), DEVMETHOD(iicbb_getsda, lkpi_iicbb_getsda), DEVMETHOD(iicbb_getscl, lkpi_iicbb_getscl), DEVMETHOD(iicbb_reset, lkpi_iicbb_reset), + DEVMETHOD(iicbb_pre_xfer, lkpi_iicbb_pre_xfer), + DEVMETHOD(iicbb_post_xfer, lkpi_iicbb_post_xfer), /* lkpi_iicbb interface */ DEVMETHOD(lkpi_iic_add_adapter, lkpi_iicbb_add_adapter), DEVMETHOD(lkpi_iic_get_adapter, lkpi_iicbb_get_adapter), DEVMETHOD_END }; driver_t lkpi_iicbb_driver = { "lkpi_iicbb", lkpi_iicbb_methods, sizeof(struct lkpi_iicbb_softc), }; -DRIVER_MODULE(lkpi_iicbb, lkpi_iic, lkpi_iicbb_driver, 0, 0); +DRIVER_MODULE(lkpi_iicbb, drmn, lkpi_iicbb_driver, 0, 0); +DRIVER_MODULE(lkpi_iicbb, drm, lkpi_iicbb_driver, 0, 0); DRIVER_MODULE(iicbb, lkpi_iicbb, iicbb_driver, 0, 0); -MODULE_DEPEND(lkpi_iicbb, iicbb, IICBB_MINVER, IICBB_PREFVER, IICBB_MAXVER); +MODULE_DEPEND(linuxkpi, iicbb, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER); static void lkpi_iicbb_setsda(device_t dev, int val) { struct lkpi_iicbb_softc *sc; struct i2c_algo_bit_data *algo_data; sc = device_get_softc(dev); - algo_data = (struct i2c_algo_bit_data *)sc->adapter->algo_data; + algo_data = sc->adapter->algo_data; algo_data->setsda(algo_data->data, val); - cpu_spinwait(); - DELAY(algo_data->udelay); } static void lkpi_iicbb_setscl(device_t dev, int val) { struct lkpi_iicbb_softc *sc; struct i2c_algo_bit_data *algo_data; sc = device_get_softc(dev); - - algo_data = (struct i2c_algo_bit_data *)sc->adapter->algo_data; + algo_data = sc->adapter->algo_data; algo_data->setscl(algo_data->data, val); - cpu_spinwait(); - DELAY(algo_data->udelay); } static int lkpi_iicbb_getscl(device_t dev) { struct lkpi_iicbb_softc *sc; struct i2c_algo_bit_data *algo_data; - unsigned long orig_ticks; - int ret = 0; + int ret; sc = device_get_softc(dev); - - algo_data = (struct i2c_algo_bit_data *)sc->adapter->algo_data; - - orig_ticks = ticks; - while (!ret) { - ret = algo_data->getscl(algo_data->data); - - if (ret) - break; - - if (ticks > orig_ticks + algo_data->timeout) - return (ETIMEDOUT); - - cpu_spinwait(); - DELAY(algo_data->udelay); - } - DELAY(algo_data->udelay); + algo_data = sc->adapter->algo_data; + ret = algo_data->getscl(algo_data->data); return (ret); } static int lkpi_iicbb_getsda(device_t dev) { struct lkpi_iicbb_softc *sc; struct i2c_algo_bit_data *algo_data; - int ret = 0; + int ret; sc = device_get_softc(dev); - algo_data = (struct i2c_algo_bit_data *)sc->adapter->algo_data; - - cpu_spinwait(); - DELAY(algo_data->udelay); + algo_data = sc->adapter->algo_data; ret = algo_data->getsda(algo_data->data); - cpu_spinwait(); - DELAY(algo_data->udelay); return (ret); } static int lkpi_iicbb_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr) { + /* That doesn't seems to be supported in linux */ return (0); } +static int +lkpi_iicbb_pre_xfer(device_t dev) +{ + struct lkpi_iicbb_softc *sc; + struct i2c_algo_bit_data *algo_data; + int rc = 0; + + sc = device_get_softc(dev); + algo_data = sc->adapter->algo_data; + if (algo_data->pre_xfer != 0) + rc = algo_data->pre_xfer(sc->adapter); + return (rc); +} + +static void +lkpi_iicbb_post_xfer(device_t dev) +{ + struct lkpi_iicbb_softc *sc; + struct i2c_algo_bit_data *algo_data; + + sc = device_get_softc(dev); + algo_data = sc->adapter->algo_data; + if (algo_data->post_xfer != NULL) + algo_data->post_xfer(sc->adapter); +} + int -lkpi_i2cbb_transfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, int nmsgs) +lkpi_i2cbb_transfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, + int nmsgs) { + struct iic_msg *bsd_msgs; + int ret = ENXIO; + + linux_set_current(curthread); + + bsd_msgs = malloc(sizeof(struct iic_msg) * nmsgs, + M_DEVBUF, M_WAITOK | M_ZERO); + + for (int i = 0; i < nmsgs; i++) { + bsd_msgs[i].slave = msgs[i].addr << 1; + bsd_msgs[i].len = msgs[i].len; + bsd_msgs[i].buf = msgs[i].buf; + if (msgs[i].flags & I2C_M_RD) + bsd_msgs[i].flags |= IIC_M_RD; + if (msgs[i].flags & I2C_M_NOSTART) + bsd_msgs[i].flags |= IIC_M_NOSTART; + } - /* TODO: convert from i2c_msg to iic_msg and call IICBUS_TRANFER */ - return (0); + for (int unit = 0; ; unit++) { + device_t child; + struct lkpi_iicbb_softc *sc; + + child = device_find_child(adapter->dev.parent->bsddev, + "lkpi_iicbb", unit); + if (child == NULL) + break; + if (adapter == LKPI_IIC_GET_ADAPTER(child)) { + sc = device_get_softc(child); + ret = IICBUS_TRANSFER(sc->iicbb, bsd_msgs, nmsgs); + ret = iic2errno(ret); + break; + } + } + + free(bsd_msgs, M_DEVBUF); + + if (ret != 0) + return (-ret); + return (nmsgs); } int lkpi_i2c_bit_add_bus(struct i2c_adapter *adapter) { device_t lkpi_iicbb; int error; if (bootverbose) device_printf(adapter->dev.parent->bsddev, "Adding i2c adapter %s\n", adapter->name); + sx_xlock(&lkpi_sx_i2cbb); lkpi_iicbb = device_add_child(adapter->dev.parent->bsddev, "lkpi_iicbb", -1); if (lkpi_iicbb == NULL) { device_printf(adapter->dev.parent->bsddev, "Couldn't add lkpi_iicbb\n"); + sx_xunlock(&lkpi_sx_i2cbb); return (ENXIO); } + bus_topo_lock(); error = bus_generic_attach(adapter->dev.parent->bsddev); + bus_topo_unlock(); if (error) { device_printf(adapter->dev.parent->bsddev, "failed to attach child: error %d\n", error); + sx_xunlock(&lkpi_sx_i2cbb); return (ENXIO); } LKPI_IIC_ADD_ADAPTER(lkpi_iicbb, adapter); + sx_xunlock(&lkpi_sx_i2cbb); return (0); } -