drivers/siox/siox-bus-gpio.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2015-2017 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
0004  */
0005
0006 #include <linux/gpio/consumer.h>
0007 #include <linux/module.h>
0008 #include <linux/mod_devicetable.h>
0009 #include <linux/platform_device.h>
0010
0011 #include <linux/delay.h>
0012
0013 #include "siox.h"
0014
0015 #define DRIVER_NAME "siox-gpio"
0016
0017 struct siox_gpio_ddata {
0018     struct gpio_desc *din;
0019     struct gpio_desc *dout;
0020     struct gpio_desc *dclk;
0021     struct gpio_desc *dld;
0022 };
0023
0024 static unsigned int siox_clkhigh_ns = 1000;
0025 static unsigned int siox_loadhigh_ns;
0026 static unsigned int siox_bytegap_ns;
0027
0028 static int siox_gpio_pushpull(struct siox_master *smaster,
0029                   size_t setbuf_len, const u8 setbuf[],
0030                   size_t getbuf_len, u8 getbuf[])
0031 {
0032     struct siox_gpio_ddata *ddata = siox_master_get_devdata(smaster);
0033     size_t i;
0034     size_t cycles = max(setbuf_len, getbuf_len);
0035
0036     /* reset data and clock */
0037     gpiod_set_value_cansleep(ddata->dout, 0);
0038     gpiod_set_value_cansleep(ddata->dclk, 0);
0039
0040     gpiod_set_value_cansleep(ddata->dld, 1);
0041     ndelay(siox_loadhigh_ns);
0042     gpiod_set_value_cansleep(ddata->dld, 0);
0043
0044     for (i = 0; i < cycles; ++i) {
0045         u8 set = 0, get = 0;
0046         size_t j;
0047
0048         if (i >= cycles - setbuf_len)
0049             set = setbuf[i - (cycles - setbuf_len)];
0050
0051         for (j = 0; j < 8; ++j) {
0052             get <<= 1;
0053             if (gpiod_get_value_cansleep(ddata->din))
0054                 get |= 1;
0055
0056             /* DOUT is logically inverted */
0057             gpiod_set_value_cansleep(ddata->dout, !(set & 0x80));
0058             set <<= 1;
0059
0060             gpiod_set_value_cansleep(ddata->dclk, 1);
0061             ndelay(siox_clkhigh_ns);
0062             gpiod_set_value_cansleep(ddata->dclk, 0);
0063         }
0064
0065         if (i < getbuf_len)
0066             getbuf[i] = get;
0067
0068         ndelay(siox_bytegap_ns);
0069     }
0070
0071     gpiod_set_value_cansleep(ddata->dld, 1);
0072     ndelay(siox_loadhigh_ns);
0073     gpiod_set_value_cansleep(ddata->dld, 0);
0074
0075     /*
0076      * Resetting dout isn't necessary protocol wise, but it makes the
0077      * signals more pretty because the dout level is deterministic between
0078      * cycles. Note that this only affects dout between the master and the
0079      * first siox device. dout for the later devices depend on the output of
0080      * the previous siox device.
0081      */
0082     gpiod_set_value_cansleep(ddata->dout, 0);
0083
0084     return 0;
0085 }
0086
0087 static int siox_gpio_probe(struct platform_device *pdev)
0088 {
0089     struct device *dev = &pdev->dev;
0090     struct siox_gpio_ddata *ddata;
0091     int ret;
0092     struct siox_master *smaster;
0093
0094     smaster = siox_master_alloc(&pdev->dev, sizeof(*ddata));
0095     if (!smaster) {
0096         dev_err(dev, "failed to allocate siox master\n");
0097         return -ENOMEM;
0098     }
0099
0100     platform_set_drvdata(pdev, smaster);
0101     ddata = siox_master_get_devdata(smaster);
0102
0103     ddata->din = devm_gpiod_get(dev, "din", GPIOD_IN);
0104     if (IS_ERR(ddata->din)) {
0105         ret = dev_err_probe(dev, PTR_ERR(ddata->din),
0106                     "Failed to get din GPIO\n");
0107         goto err;
0108     }
0109
0110     ddata->dout = devm_gpiod_get(dev, "dout", GPIOD_OUT_LOW);
0111     if (IS_ERR(ddata->dout)) {
0112         ret = dev_err_probe(dev, PTR_ERR(ddata->dout),
0113                     "Failed to get dout GPIO\n");
0114         goto err;
0115     }
0116
0117     ddata->dclk = devm_gpiod_get(dev, "dclk", GPIOD_OUT_LOW);
0118     if (IS_ERR(ddata->dclk)) {
0119         ret = dev_err_probe(dev, PTR_ERR(ddata->dclk),
0120                     "Failed to get dclk GPIO\n");
0121         goto err;
0122     }
0123
0124     ddata->dld = devm_gpiod_get(dev, "dld", GPIOD_OUT_LOW);
0125     if (IS_ERR(ddata->dld)) {
0126         ret = dev_err_probe(dev, PTR_ERR(ddata->dld),
0127                     "Failed to get dld GPIO\n");
0128         goto err;
0129     }
0130
0131     smaster->pushpull = siox_gpio_pushpull;
0132     /* XXX: determine automatically like spi does */
0133     smaster->busno = 0;
0134
0135     ret = siox_master_register(smaster);
0136     if (ret) {
0137         dev_err_probe(dev, ret,
0138                   "Failed to register siox master\n");
0139 err:
0140         siox_master_put(smaster);
0141     }
0142
0143     return ret;
0144 }
0145
0146 static int siox_gpio_remove(struct platform_device *pdev)
0147 {
0148     struct siox_master *master = platform_get_drvdata(pdev);
0149
0150     siox_master_unregister(master);
0151
0152     return 0;
0153 }
0154
0155 static const struct of_device_id siox_gpio_dt_ids[] = {
0156     { .compatible = "eckelmann,siox-gpio", },
0157     { /* sentinel */ }
0158 };
0159 MODULE_DEVICE_TABLE(of, siox_gpio_dt_ids);
0160
0161 static struct platform_driver siox_gpio_driver = {
0162     .probe = siox_gpio_probe,
0163     .remove = siox_gpio_remove,
0164
0165     .driver = {
0166         .name = DRIVER_NAME,
0167         .of_match_table = siox_gpio_dt_ids,
0168     },
0169 };
0170 module_platform_driver(siox_gpio_driver);
0171
0172 MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
0173 MODULE_LICENSE("GPL v2");
0174 MODULE_ALIAS("platform:" DRIVER_NAME);