Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2015-2017 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
4 */
5
6#include <linux/gpio/consumer.h>
7#include <linux/module.h>
8#include <linux/mod_devicetable.h>
9#include <linux/platform_device.h>
10
11#include <linux/delay.h>
12
13#include "siox.h"
14
15#define DRIVER_NAME "siox-gpio"
16
17struct siox_gpio_ddata {
18 struct gpio_desc *din;
19 struct gpio_desc *dout;
20 struct gpio_desc *dclk;
21 struct gpio_desc *dld;
22};
23
24static unsigned int siox_clkhigh_ns = 1000;
25static unsigned int siox_loadhigh_ns;
26static unsigned int siox_bytegap_ns;
27
28static int siox_gpio_pushpull(struct siox_master *smaster,
29 size_t setbuf_len, const u8 setbuf[],
30 size_t getbuf_len, u8 getbuf[])
31{
32 struct siox_gpio_ddata *ddata = siox_master_get_devdata(smaster);
33 size_t i;
34 size_t cycles = max(setbuf_len, getbuf_len);
35
36 /* reset data and clock */
37 gpiod_set_value_cansleep(ddata->dout, 0);
38 gpiod_set_value_cansleep(ddata->dclk, 0);
39
40 gpiod_set_value_cansleep(ddata->dld, 1);
41 ndelay(siox_loadhigh_ns);
42 gpiod_set_value_cansleep(ddata->dld, 0);
43
44 for (i = 0; i < cycles; ++i) {
45 u8 set = 0, get = 0;
46 size_t j;
47
48 if (i >= cycles - setbuf_len)
49 set = setbuf[i - (cycles - setbuf_len)];
50
51 for (j = 0; j < 8; ++j) {
52 get <<= 1;
53 if (gpiod_get_value_cansleep(ddata->din))
54 get |= 1;
55
56 /* DOUT is logically inverted */
57 gpiod_set_value_cansleep(ddata->dout, !(set & 0x80));
58 set <<= 1;
59
60 gpiod_set_value_cansleep(ddata->dclk, 1);
61 ndelay(siox_clkhigh_ns);
62 gpiod_set_value_cansleep(ddata->dclk, 0);
63 }
64
65 if (i < getbuf_len)
66 getbuf[i] = get;
67
68 ndelay(siox_bytegap_ns);
69 }
70
71 gpiod_set_value_cansleep(ddata->dld, 1);
72 ndelay(siox_loadhigh_ns);
73 gpiod_set_value_cansleep(ddata->dld, 0);
74
75 /*
76 * Resetting dout isn't necessary protocol wise, but it makes the
77 * signals more pretty because the dout level is deterministic between
78 * cycles. Note that this only affects dout between the master and the
79 * first siox device. dout for the later devices depend on the output of
80 * the previous siox device.
81 */
82 gpiod_set_value_cansleep(ddata->dout, 0);
83
84 return 0;
85}
86
87static int siox_gpio_probe(struct platform_device *pdev)
88{
89 struct device *dev = &pdev->dev;
90 struct siox_gpio_ddata *ddata;
91 int ret;
92 struct siox_master *smaster;
93
94 smaster = siox_master_alloc(&pdev->dev, sizeof(*ddata));
95 if (!smaster) {
96 dev_err(dev, "failed to allocate siox master\n");
97 return -ENOMEM;
98 }
99
100 platform_set_drvdata(pdev, smaster);
101 ddata = siox_master_get_devdata(smaster);
102
103 ddata->din = devm_gpiod_get(dev, "din", GPIOD_IN);
104 if (IS_ERR(ddata->din)) {
105 ret = dev_err_probe(dev, PTR_ERR(ddata->din),
106 "Failed to get din GPIO\n");
107 goto err;
108 }
109
110 ddata->dout = devm_gpiod_get(dev, "dout", GPIOD_OUT_LOW);
111 if (IS_ERR(ddata->dout)) {
112 ret = dev_err_probe(dev, PTR_ERR(ddata->dout),
113 "Failed to get dout GPIO\n");
114 goto err;
115 }
116
117 ddata->dclk = devm_gpiod_get(dev, "dclk", GPIOD_OUT_LOW);
118 if (IS_ERR(ddata->dclk)) {
119 ret = dev_err_probe(dev, PTR_ERR(ddata->dclk),
120 "Failed to get dclk GPIO\n");
121 goto err;
122 }
123
124 ddata->dld = devm_gpiod_get(dev, "dld", GPIOD_OUT_LOW);
125 if (IS_ERR(ddata->dld)) {
126 ret = dev_err_probe(dev, PTR_ERR(ddata->dld),
127 "Failed to get dld GPIO\n");
128 goto err;
129 }
130
131 smaster->pushpull = siox_gpio_pushpull;
132 /* XXX: determine automatically like spi does */
133 smaster->busno = 0;
134
135 ret = siox_master_register(smaster);
136 if (ret) {
137 dev_err_probe(dev, ret,
138 "Failed to register siox master\n");
139err:
140 siox_master_put(smaster);
141 }
142
143 return ret;
144}
145
146static int siox_gpio_remove(struct platform_device *pdev)
147{
148 struct siox_master *master = platform_get_drvdata(pdev);
149
150 siox_master_unregister(master);
151
152 return 0;
153}
154
155static const struct of_device_id siox_gpio_dt_ids[] = {
156 { .compatible = "eckelmann,siox-gpio", },
157 { /* sentinel */ }
158};
159MODULE_DEVICE_TABLE(of, siox_gpio_dt_ids);
160
161static struct platform_driver siox_gpio_driver = {
162 .probe = siox_gpio_probe,
163 .remove = siox_gpio_remove,
164
165 .driver = {
166 .name = DRIVER_NAME,
167 .of_match_table = siox_gpio_dt_ids,
168 },
169};
170module_platform_driver(siox_gpio_driver);
171
172MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
173MODULE_LICENSE("GPL v2");
174MODULE_ALIAS("platform:" DRIVER_NAME);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2015-2017 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
4 */
5
6#include <linux/gpio/consumer.h>
7#include <linux/module.h>
8#include <linux/platform_device.h>
9
10#include <linux/delay.h>
11
12#include "siox.h"
13
14#define DRIVER_NAME "siox-gpio"
15
16struct siox_gpio_ddata {
17 struct gpio_desc *din;
18 struct gpio_desc *dout;
19 struct gpio_desc *dclk;
20 struct gpio_desc *dld;
21};
22
23static unsigned int siox_clkhigh_ns = 1000;
24static unsigned int siox_loadhigh_ns;
25static unsigned int siox_bytegap_ns;
26
27static int siox_gpio_pushpull(struct siox_master *smaster,
28 size_t setbuf_len, const u8 setbuf[],
29 size_t getbuf_len, u8 getbuf[])
30{
31 struct siox_gpio_ddata *ddata = siox_master_get_devdata(smaster);
32 size_t i;
33 size_t cycles = max(setbuf_len, getbuf_len);
34
35 /* reset data and clock */
36 gpiod_set_value_cansleep(ddata->dout, 0);
37 gpiod_set_value_cansleep(ddata->dclk, 0);
38
39 gpiod_set_value_cansleep(ddata->dld, 1);
40 ndelay(siox_loadhigh_ns);
41 gpiod_set_value_cansleep(ddata->dld, 0);
42
43 for (i = 0; i < cycles; ++i) {
44 u8 set = 0, get = 0;
45 size_t j;
46
47 if (i >= cycles - setbuf_len)
48 set = setbuf[i - (cycles - setbuf_len)];
49
50 for (j = 0; j < 8; ++j) {
51 get <<= 1;
52 if (gpiod_get_value_cansleep(ddata->din))
53 get |= 1;
54
55 /* DOUT is logically inverted */
56 gpiod_set_value_cansleep(ddata->dout, !(set & 0x80));
57 set <<= 1;
58
59 gpiod_set_value_cansleep(ddata->dclk, 1);
60 ndelay(siox_clkhigh_ns);
61 gpiod_set_value_cansleep(ddata->dclk, 0);
62 }
63
64 if (i < getbuf_len)
65 getbuf[i] = get;
66
67 ndelay(siox_bytegap_ns);
68 }
69
70 gpiod_set_value_cansleep(ddata->dld, 1);
71 ndelay(siox_loadhigh_ns);
72 gpiod_set_value_cansleep(ddata->dld, 0);
73
74 /*
75 * Resetting dout isn't necessary protocol wise, but it makes the
76 * signals more pretty because the dout level is deterministic between
77 * cycles. Note that this only affects dout between the master and the
78 * first siox device. dout for the later devices depend on the output of
79 * the previous siox device.
80 */
81 gpiod_set_value_cansleep(ddata->dout, 0);
82
83 return 0;
84}
85
86static int siox_gpio_probe(struct platform_device *pdev)
87{
88 struct device *dev = &pdev->dev;
89 struct siox_gpio_ddata *ddata;
90 int ret;
91 struct siox_master *smaster;
92
93 smaster = siox_master_alloc(&pdev->dev, sizeof(*ddata));
94 if (!smaster) {
95 dev_err(dev, "failed to allocate siox master\n");
96 return -ENOMEM;
97 }
98
99 platform_set_drvdata(pdev, smaster);
100 ddata = siox_master_get_devdata(smaster);
101
102 ddata->din = devm_gpiod_get(dev, "din", GPIOD_IN);
103 if (IS_ERR(ddata->din)) {
104 ret = PTR_ERR(ddata->din);
105 dev_err(dev, "Failed to get %s GPIO: %d\n", "din", ret);
106 goto err;
107 }
108
109 ddata->dout = devm_gpiod_get(dev, "dout", GPIOD_OUT_LOW);
110 if (IS_ERR(ddata->dout)) {
111 ret = PTR_ERR(ddata->dout);
112 dev_err(dev, "Failed to get %s GPIO: %d\n", "dout", ret);
113 goto err;
114 }
115
116 ddata->dclk = devm_gpiod_get(dev, "dclk", GPIOD_OUT_LOW);
117 if (IS_ERR(ddata->dclk)) {
118 ret = PTR_ERR(ddata->dclk);
119 dev_err(dev, "Failed to get %s GPIO: %d\n", "dclk", ret);
120 goto err;
121 }
122
123 ddata->dld = devm_gpiod_get(dev, "dld", GPIOD_OUT_LOW);
124 if (IS_ERR(ddata->dld)) {
125 ret = PTR_ERR(ddata->dld);
126 dev_err(dev, "Failed to get %s GPIO: %d\n", "dld", ret);
127 goto err;
128 }
129
130 smaster->pushpull = siox_gpio_pushpull;
131 /* XXX: determine automatically like spi does */
132 smaster->busno = 0;
133
134 ret = siox_master_register(smaster);
135 if (ret) {
136 dev_err(dev, "Failed to register siox master: %d\n", ret);
137err:
138 siox_master_put(smaster);
139 }
140
141 return ret;
142}
143
144static int siox_gpio_remove(struct platform_device *pdev)
145{
146 struct siox_master *master = platform_get_drvdata(pdev);
147
148 siox_master_unregister(master);
149
150 return 0;
151}
152
153static const struct of_device_id siox_gpio_dt_ids[] = {
154 { .compatible = "eckelmann,siox-gpio", },
155 { /* sentinel */ }
156};
157MODULE_DEVICE_TABLE(of, siox_gpio_dt_ids);
158
159static struct platform_driver siox_gpio_driver = {
160 .probe = siox_gpio_probe,
161 .remove = siox_gpio_remove,
162
163 .driver = {
164 .name = DRIVER_NAME,
165 .of_match_table = siox_gpio_dt_ids,
166 },
167};
168module_platform_driver(siox_gpio_driver);
169
170MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
171MODULE_LICENSE("GPL v2");
172MODULE_ALIAS("platform:" DRIVER_NAME);