1 /*
2 * NBUS driver for TS-4600 based boards
3 *
4 * Copyright (c) 2016 - Savoir-faire Linux
5 * Author: Sebastien Bourdelin <sebastien.bourdelin@savoirfairelinux.com>
6 *
7 * This file is licensed under the terms of the GNU General Public
8 * License version 2. This program is licensed "as is" without any
9 * warranty of any kind, whether express or implied.
10 *
11 * This driver implements a GPIOs bit-banged bus, called the NBUS by Technologic
12 * Systems. It is used to communicate with the peripherals in the FPGA on the
13 * TS-4600 SoM.
14 */
15
16 #include <linux/bitops.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/mutex.h>
21 #include <linux/of_platform.h>
22 #include <linux/platform_device.h>
23 #include <linux/pwm.h>
24 #include <linux/ts-nbus.h>
25
26 #define TS_NBUS_DIRECTION_IN 0
27 #define TS_NBUS_DIRECTION_OUT 1
28 #define TS_NBUS_WRITE_ADR 0
29 #define TS_NBUS_WRITE_VAL 1
30
31 struct ts_nbus {
32 struct pwm_device *pwm;
33 struct gpio_descs *data;
34 struct gpio_desc *csn;
35 struct gpio_desc *txrx;
36 struct gpio_desc *strobe;
37 struct gpio_desc *ale;
38 struct gpio_desc *rdy;
39 struct mutex lock;
40 };
41
42 /*
43 * request all gpios required by the bus.
44 */
ts_nbus_init_pdata(struct platform_device * pdev,struct ts_nbus * ts_nbus)45 static int ts_nbus_init_pdata(struct platform_device *pdev, struct ts_nbus
46 *ts_nbus)
47 {
48 ts_nbus->data = devm_gpiod_get_array(&pdev->dev, "ts,data",
49 GPIOD_OUT_HIGH);
50 if (IS_ERR(ts_nbus->data)) {
51 dev_err(&pdev->dev, "failed to retrieve ts,data-gpio from dts\n");
52 return PTR_ERR(ts_nbus->data);
53 }
54
55 ts_nbus->csn = devm_gpiod_get(&pdev->dev, "ts,csn", GPIOD_OUT_HIGH);
56 if (IS_ERR(ts_nbus->csn)) {
57 dev_err(&pdev->dev, "failed to retrieve ts,csn-gpio from dts\n");
58 return PTR_ERR(ts_nbus->csn);
59 }
60
61 ts_nbus->txrx = devm_gpiod_get(&pdev->dev, "ts,txrx", GPIOD_OUT_HIGH);
62 if (IS_ERR(ts_nbus->txrx)) {
63 dev_err(&pdev->dev, "failed to retrieve ts,txrx-gpio from dts\n");
64 return PTR_ERR(ts_nbus->txrx);
65 }
66
67 ts_nbus->strobe = devm_gpiod_get(&pdev->dev, "ts,strobe", GPIOD_OUT_HIGH);
68 if (IS_ERR(ts_nbus->strobe)) {
69 dev_err(&pdev->dev, "failed to retrieve ts,strobe-gpio from dts\n");
70 return PTR_ERR(ts_nbus->strobe);
71 }
72
73 ts_nbus->ale = devm_gpiod_get(&pdev->dev, "ts,ale", GPIOD_OUT_HIGH);
74 if (IS_ERR(ts_nbus->ale)) {
75 dev_err(&pdev->dev, "failed to retrieve ts,ale-gpio from dts\n");
76 return PTR_ERR(ts_nbus->ale);
77 }
78
79 ts_nbus->rdy = devm_gpiod_get(&pdev->dev, "ts,rdy", GPIOD_IN);
80 if (IS_ERR(ts_nbus->rdy)) {
81 dev_err(&pdev->dev, "failed to retrieve ts,rdy-gpio from dts\n");
82 return PTR_ERR(ts_nbus->rdy);
83 }
84
85 return 0;
86 }
87
88 /*
89 * the data gpios are used for reading and writing values, their directions
90 * should be adjusted accordingly.
91 */
ts_nbus_set_direction(struct ts_nbus * ts_nbus,int direction)92 static void ts_nbus_set_direction(struct ts_nbus *ts_nbus, int direction)
93 {
94 int i;
95
96 for (i = 0; i < 8; i++) {
97 if (direction == TS_NBUS_DIRECTION_IN)
98 gpiod_direction_input(ts_nbus->data->desc[i]);
99 else
100 /* when used as output the default state of the data
101 * lines are set to high */
102 gpiod_direction_output(ts_nbus->data->desc[i], 1);
103 }
104 }
105
106 /*
107 * reset the bus in its initial state.
108 * The data, csn, strobe and ale lines must be zero'ed to let the FPGA knows a
109 * new transaction can be process.
110 */
ts_nbus_reset_bus(struct ts_nbus * ts_nbus)111 static void ts_nbus_reset_bus(struct ts_nbus *ts_nbus)
112 {
113 DECLARE_BITMAP(values, 8);
114
115 values[0] = 0;
116
117 gpiod_set_array_value_cansleep(8, ts_nbus->data->desc,
118 ts_nbus->data->info, values);
119 gpiod_set_value_cansleep(ts_nbus->csn, 0);
120 gpiod_set_value_cansleep(ts_nbus->strobe, 0);
121 gpiod_set_value_cansleep(ts_nbus->ale, 0);
122 }
123
124 /*
125 * let the FPGA knows it can process.
126 */
ts_nbus_start_transaction(struct ts_nbus * ts_nbus)127 static void ts_nbus_start_transaction(struct ts_nbus *ts_nbus)
128 {
129 gpiod_set_value_cansleep(ts_nbus->strobe, 1);
130 }
131
132 /*
133 * read a byte value from the data gpios.
134 * return 0 on success or negative errno on failure.
135 */
ts_nbus_read_byte(struct ts_nbus * ts_nbus,u8 * val)136 static int ts_nbus_read_byte(struct ts_nbus *ts_nbus, u8 *val)
137 {
138 struct gpio_descs *gpios = ts_nbus->data;
139 int ret, i;
140
141 *val = 0;
142 for (i = 0; i < 8; i++) {
143 ret = gpiod_get_value_cansleep(gpios->desc[i]);
144 if (ret < 0)
145 return ret;
146 if (ret)
147 *val |= BIT(i);
148 }
149
150 return 0;
151 }
152
153 /*
154 * set the data gpios accordingly to the byte value.
155 */
ts_nbus_write_byte(struct ts_nbus * ts_nbus,u8 byte)156 static void ts_nbus_write_byte(struct ts_nbus *ts_nbus, u8 byte)
157 {
158 struct gpio_descs *gpios = ts_nbus->data;
159 DECLARE_BITMAP(values, 8);
160
161 values[0] = byte;
162
163 gpiod_set_array_value_cansleep(8, gpios->desc, gpios->info, values);
164 }
165
166 /*
167 * reading the bus consists of resetting the bus, then notifying the FPGA to
168 * send the data in the data gpios and return the read value.
169 * return 0 on success or negative errno on failure.
170 */
ts_nbus_read_bus(struct ts_nbus * ts_nbus,u8 * val)171 static int ts_nbus_read_bus(struct ts_nbus *ts_nbus, u8 *val)
172 {
173 ts_nbus_reset_bus(ts_nbus);
174 ts_nbus_start_transaction(ts_nbus);
175
176 return ts_nbus_read_byte(ts_nbus, val);
177 }
178
179 /*
180 * writing to the bus consists of resetting the bus, then define the type of
181 * command (address/value), write the data and notify the FPGA to retrieve the
182 * value in the data gpios.
183 */
ts_nbus_write_bus(struct ts_nbus * ts_nbus,int cmd,u8 val)184 static void ts_nbus_write_bus(struct ts_nbus *ts_nbus, int cmd, u8 val)
185 {
186 ts_nbus_reset_bus(ts_nbus);
187
188 if (cmd == TS_NBUS_WRITE_ADR)
189 gpiod_set_value_cansleep(ts_nbus->ale, 1);
190
191 ts_nbus_write_byte(ts_nbus, val);
192 ts_nbus_start_transaction(ts_nbus);
193 }
194
195 /*
196 * read the value in the FPGA register at the given address.
197 * return 0 on success or negative errno on failure.
198 */
ts_nbus_read(struct ts_nbus * ts_nbus,u8 adr,u16 * val)199 int ts_nbus_read(struct ts_nbus *ts_nbus, u8 adr, u16 *val)
200 {
201 int ret, i;
202 u8 byte;
203
204 /* bus access must be atomic */
205 mutex_lock(&ts_nbus->lock);
206
207 /* set the bus in read mode */
208 gpiod_set_value_cansleep(ts_nbus->txrx, 0);
209
210 /* write address */
211 ts_nbus_write_bus(ts_nbus, TS_NBUS_WRITE_ADR, adr);
212
213 /* set the data gpios direction as input before reading */
214 ts_nbus_set_direction(ts_nbus, TS_NBUS_DIRECTION_IN);
215
216 /* reading value MSB first */
217 do {
218 *val = 0;
219 byte = 0;
220 for (i = 1; i >= 0; i--) {
221 /* read a byte from the bus, leave on error */
222 ret = ts_nbus_read_bus(ts_nbus, &byte);
223 if (ret < 0)
224 goto err;
225
226 /* append the byte read to the final value */
227 *val |= byte << (i * 8);
228 }
229 gpiod_set_value_cansleep(ts_nbus->csn, 1);
230 ret = gpiod_get_value_cansleep(ts_nbus->rdy);
231 } while (ret);
232
233 err:
234 /* restore the data gpios direction as output after reading */
235 ts_nbus_set_direction(ts_nbus, TS_NBUS_DIRECTION_OUT);
236
237 mutex_unlock(&ts_nbus->lock);
238
239 return ret;
240 }
241 EXPORT_SYMBOL_GPL(ts_nbus_read);
242
243 /*
244 * write the desired value in the FPGA register at the given address.
245 */
ts_nbus_write(struct ts_nbus * ts_nbus,u8 adr,u16 val)246 int ts_nbus_write(struct ts_nbus *ts_nbus, u8 adr, u16 val)
247 {
248 int i;
249
250 /* bus access must be atomic */
251 mutex_lock(&ts_nbus->lock);
252
253 /* set the bus in write mode */
254 gpiod_set_value_cansleep(ts_nbus->txrx, 1);
255
256 /* write address */
257 ts_nbus_write_bus(ts_nbus, TS_NBUS_WRITE_ADR, adr);
258
259 /* writing value MSB first */
260 for (i = 1; i >= 0; i--)
261 ts_nbus_write_bus(ts_nbus, TS_NBUS_WRITE_VAL, (u8)(val >> (i * 8)));
262
263 /* wait for completion */
264 gpiod_set_value_cansleep(ts_nbus->csn, 1);
265 while (gpiod_get_value_cansleep(ts_nbus->rdy) != 0) {
266 gpiod_set_value_cansleep(ts_nbus->csn, 0);
267 gpiod_set_value_cansleep(ts_nbus->csn, 1);
268 }
269
270 mutex_unlock(&ts_nbus->lock);
271
272 return 0;
273 }
274 EXPORT_SYMBOL_GPL(ts_nbus_write);
275
ts_nbus_probe(struct platform_device * pdev)276 static int ts_nbus_probe(struct platform_device *pdev)
277 {
278 struct pwm_device *pwm;
279 struct pwm_args pargs;
280 struct device *dev = &pdev->dev;
281 struct ts_nbus *ts_nbus;
282 int ret;
283
284 ts_nbus = devm_kzalloc(dev, sizeof(*ts_nbus), GFP_KERNEL);
285 if (!ts_nbus)
286 return -ENOMEM;
287
288 mutex_init(&ts_nbus->lock);
289
290 ret = ts_nbus_init_pdata(pdev, ts_nbus);
291 if (ret < 0)
292 return ret;
293
294 pwm = devm_pwm_get(dev, NULL);
295 if (IS_ERR(pwm)) {
296 ret = PTR_ERR(pwm);
297 if (ret != -EPROBE_DEFER)
298 dev_err(dev, "unable to request PWM\n");
299 return ret;
300 }
301
302 pwm_get_args(pwm, &pargs);
303 if (!pargs.period) {
304 dev_err(&pdev->dev, "invalid PWM period\n");
305 return -EINVAL;
306 }
307
308 /*
309 * FIXME: pwm_apply_args() should be removed when switching to
310 * the atomic PWM API.
311 */
312 pwm_apply_args(pwm);
313 ret = pwm_config(pwm, pargs.period, pargs.period);
314 if (ret < 0)
315 return ret;
316
317 /*
318 * we can now start the FPGA and populate the peripherals.
319 */
320 pwm_enable(pwm);
321 ts_nbus->pwm = pwm;
322
323 /*
324 * let the child nodes retrieve this instance of the ts-nbus.
325 */
326 dev_set_drvdata(dev, ts_nbus);
327
328 ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
329 if (ret < 0)
330 return ret;
331
332 dev_info(dev, "initialized\n");
333
334 return 0;
335 }
336
ts_nbus_remove(struct platform_device * pdev)337 static int ts_nbus_remove(struct platform_device *pdev)
338 {
339 struct ts_nbus *ts_nbus = dev_get_drvdata(&pdev->dev);
340
341 /* shutdown the FPGA */
342 mutex_lock(&ts_nbus->lock);
343 pwm_disable(ts_nbus->pwm);
344 mutex_unlock(&ts_nbus->lock);
345
346 return 0;
347 }
348
349 static const struct of_device_id ts_nbus_of_match[] = {
350 { .compatible = "technologic,ts-nbus", },
351 { },
352 };
353 MODULE_DEVICE_TABLE(of, ts_nbus_of_match);
354
355 static struct platform_driver ts_nbus_driver = {
356 .probe = ts_nbus_probe,
357 .remove = ts_nbus_remove,
358 .driver = {
359 .name = "ts_nbus",
360 .of_match_table = ts_nbus_of_match,
361 },
362 };
363
364 module_platform_driver(ts_nbus_driver);
365
366 MODULE_ALIAS("platform:ts_nbus");
367 MODULE_AUTHOR("Sebastien Bourdelin <sebastien.bourdelin@savoirfairelinux.com>");
368 MODULE_DESCRIPTION("Technologic Systems NBUS");
369 MODULE_LICENSE("GPL v2");
370