CoCalc -- jh7110

GitHub Repository: freebsd/freebsd-src
Path: blob/main/sys/riscv/starfive/jh7110_gpio.c
³⁹⁵⁰⁷ views
1
/*
2
 * SPDX-License-Identifier: BSD-2-Clause
3
 *
4
 * Copyright (c) 2023 Jari Sihvola <[email protected]>
5
 */
6

7
#include <sys/cdefs.h>
8

9
#include <sys/param.h>
10
#include <sys/systm.h>
11
#include <sys/bus.h>
12

13
#include <sys/gpio.h>
14
#include <sys/kernel.h>
15
#include <sys/lock.h>
16
#include <sys/module.h>
17
#include <sys/mutex.h>
18
#include <sys/rman.h>
19

20
#include <machine/bus.h>
21
#include <machine/intr.h>
22
#include <machine/resource.h>
23

24
#include <dev/clk/clk.h>
25
#include <dev/gpio/gpiobusvar.h>
26
#include <dev/ofw/ofw_bus.h>
27
#include <dev/ofw/ofw_bus_subr.h>
28

29
#include "gpio_if.h"
30

31
#define GPIO_PINS		64
32
#define GPIO_REGS		2
33

34
#define GP0_DOEN_CFG		0x0
35
#define GP0_DOUT_CFG		0x40
36
#define GPIOEN			0xdc
37
#define GPIOE_0			0x100
38
#define GPIOE_1			0x104
39
#define GPIO_DIN_LOW		0x118
40
#define GPIO_DIN_HIGH		0x11c
41
#define IOMUX_SYSCFG_288	0x120
42

43
#define PAD_INPUT_EN		(1 << 0)
44
#define PAD_PULLUP		(1 << 3)
45
#define PAD_PULLDOWN		(1 << 4)
46
#define PAD_HYST		(1 << 6)
47

48
#define ENABLE_MASK		0x3f
49
#define DATA_OUT_MASK		0x7f
50
#define DIROUT_DISABLE		1
51

52
struct jh7110_gpio_softc {
53
	device_t		dev;
54
	device_t		busdev;
55
	struct mtx		mtx;
56
	struct resource		*res;
57
	clk_t			clk;
58
};
59

60
static struct ofw_compat_data compat_data[] = {
61
	{"starfive,jh7110-sys-pinctrl", 1},
62
	{NULL,				0}
63
};
64

65
static struct resource_spec jh7110_gpio_spec[] = {
66
	{ SYS_RES_MEMORY, 0, RF_ACTIVE },
67
	{ -1, 0 }
68
};
69

70
#define GPIO_RW_OFFSET(_val)		(_val & ~3)
71
#define GPIO_SHIFT(_val)		((_val & 3) * 8)
72
#define PAD_OFFSET(_val)		(_val * 4)
73

74
#define JH7110_GPIO_LOCK(_sc)		mtx_lock(&(_sc)->mtx)
75
#define JH7110_GPIO_UNLOCK(_sc)		mtx_unlock(&(_sc)->mtx)
76

77
#define JH7110_GPIO_READ(sc, reg)	bus_read_4((sc)->res, (reg))
78
#define JH7110_GPIO_WRITE(sc, reg, val) bus_write_4((sc)->res, (reg), (val))
79

80
static device_t
81
jh7110_gpio_get_bus(device_t dev)
82
{
83
	struct jh7110_gpio_softc *sc;
84

85
	sc = device_get_softc(dev);
86

87
	return (sc->busdev);
88
}
89

90
static int
91
jh7110_gpio_pin_max(device_t dev, int *maxpin)
92
{
93
	*maxpin = GPIO_PINS - 1;
94

95
	return (0);
96
}
97

98
static int
99
jh7110_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
100
{
101
	struct jh7110_gpio_softc *sc;
102
	uint32_t reg;
103

104
	sc = device_get_softc(dev);
105

106
	if (pin >= GPIO_PINS)
107
		return (EINVAL);
108

109
	JH7110_GPIO_LOCK(sc);
110
	if (pin < GPIO_PINS / GPIO_REGS) {
111
		reg = JH7110_GPIO_READ(sc, GPIO_DIN_LOW);
112
		*val = (reg >> pin) & 0x1;
113
	} else {
114
		reg = JH7110_GPIO_READ(sc, GPIO_DIN_HIGH);
115
		*val = (reg >> (pin - GPIO_PINS / GPIO_REGS)) & 0x1;
116
	}
117
	JH7110_GPIO_UNLOCK(sc);
118

119
	return (0);
120
}
121

122
static int
123
jh7110_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
124
{
125
	struct jh7110_gpio_softc *sc;
126
	uint32_t reg;
127

128
	sc = device_get_softc(dev);
129

130
	if (pin >= GPIO_PINS)
131
		return (EINVAL);
132

133
	JH7110_GPIO_LOCK(sc);
134
	reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin));
135
	reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin));
136
	if (value)
137
		reg |= 0x1 << GPIO_SHIFT(pin);
138
	JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg);
139
	JH7110_GPIO_UNLOCK(sc);
140

141
	return (0);
142
}
143

144
static int
145
jh7110_gpio_pin_toggle(device_t dev, uint32_t pin)
146
{
147
	struct jh7110_gpio_softc *sc;
148
	uint32_t reg;
149

150
	sc = device_get_softc(dev);
151

152
	if (pin >= GPIO_PINS)
153
		return (EINVAL);
154

155
	JH7110_GPIO_LOCK(sc);
156
	reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin));
157
	if (reg & 0x1 << GPIO_SHIFT(pin)) {
158
		reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin));
159
	} else {
160
		reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin));
161
		reg |= 0x1 << GPIO_SHIFT(pin);
162
	}
163
	JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg);
164
	JH7110_GPIO_UNLOCK(sc);
165

166
	return (0);
167
}
168

169
static int
170
jh7110_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
171
{
172
	if (pin >= GPIO_PINS)
173
		return (EINVAL);
174

175
	*caps = (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT);
176

177
	return (0);
178
}
179

180
static int
181
jh7110_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
182
{
183
	if (pin >= GPIO_PINS)
184
		return (EINVAL);
185

186
	snprintf(name, GPIOMAXNAME, "GPIO%d", pin);
187

188
	return (0);
189
}
190

191
static int
192
jh7110_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
193
{
194
	struct jh7110_gpio_softc *sc;
195
	uint32_t reg;
196

197
	sc = device_get_softc(dev);
198

199
	if (pin >= GPIO_PINS)
200
		return (EINVAL);
201

202
	/* Reading the direction */
203
	JH7110_GPIO_LOCK(sc);
204
	reg = JH7110_GPIO_READ(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin));
205
	if ((reg & ENABLE_MASK << GPIO_SHIFT(pin)) == 0)
206
		*flags |= GPIO_PIN_OUTPUT;
207
	else
208
		*flags |= GPIO_PIN_INPUT;
209
	JH7110_GPIO_UNLOCK(sc);
210

211
	return (0);
212
}
213

214
static int
215
jh7110_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
216
{
217
	struct jh7110_gpio_softc *sc;
218
	uint32_t reg;
219

220
	sc = device_get_softc(dev);
221

222
	if (pin >= GPIO_PINS)
223
		return (EINVAL);
224

225
	/* Setting the direction, enable or disable output, configuring pads */
226

227
	JH7110_GPIO_LOCK(sc);
228

229
	if (flags & GPIO_PIN_INPUT) {
230
		reg = JH7110_GPIO_READ(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin));
231
		reg |= (PAD_INPUT_EN | PAD_HYST);
232
		JH7110_GPIO_WRITE(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin), reg);
233
	}
234

235
	reg = JH7110_GPIO_READ(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin));
236
	reg &= ~(ENABLE_MASK << GPIO_SHIFT(pin));
237
	if (flags & GPIO_PIN_INPUT) {
238
		reg |= DIROUT_DISABLE << GPIO_SHIFT(pin);
239
	}
240
	JH7110_GPIO_WRITE(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin), reg);
241

242
	if (flags & GPIO_PIN_OUTPUT) {
243
		reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin));
244
		reg &= ~(ENABLE_MASK << GPIO_SHIFT(pin));
245
		reg |= 0x1 << GPIO_SHIFT(pin);
246
		JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg);
247

248
		reg = JH7110_GPIO_READ(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin));
249
		reg &= ~(PAD_INPUT_EN | PAD_PULLUP | PAD_PULLDOWN | PAD_HYST);
250
		JH7110_GPIO_WRITE(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin), reg);
251
	}
252

253
	JH7110_GPIO_UNLOCK(sc);
254

255
	return (0);
256
}
257

258
static int
259
jh7110_gpio_probe(device_t dev)
260
{
261
	if (!ofw_bus_status_okay(dev))
262
		return (ENXIO);
263

264
	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
265
		return (ENXIO);
266

267
	device_set_desc(dev, "StarFive JH7110 GPIO controller");
268

269
	return (BUS_PROBE_DEFAULT);
270
}
271

272
static int
273
jh7110_gpio_detach(device_t dev)
274
{
275
	struct jh7110_gpio_softc *sc;
276

277
	sc = device_get_softc(dev);
278

279
	bus_release_resources(dev, jh7110_gpio_spec, &sc->res);
280
	if (sc->busdev != NULL)
281
		gpiobus_detach_bus(dev);
282
	if (sc->clk != NULL)
283
		clk_release(sc->clk);
284
	mtx_destroy(&sc->mtx);
285

286
	return (0);
287
}
288

289
static int
290
jh7110_gpio_attach(device_t dev)
291
{
292
	struct jh7110_gpio_softc *sc;
293

294
	sc = device_get_softc(dev);
295
	sc->dev = dev;
296

297
	mtx_init(&sc->mtx, device_get_nameunit(sc->dev), NULL, MTX_DEF);
298

299
	if (bus_alloc_resources(dev, jh7110_gpio_spec, &sc->res) != 0) {
300
		device_printf(dev, "Could not allocate resources\n");
301
		bus_release_resources(dev, jh7110_gpio_spec, &sc->res);
302
		mtx_destroy(&sc->mtx);
303
		return (ENXIO);
304
	}
305

306
	if (clk_get_by_ofw_index(dev, 0, 0, &sc->clk) != 0) {
307
		device_printf(dev, "Cannot get clock\n");
308
		jh7110_gpio_detach(dev);
309
		return (ENXIO);
310
	}
311

312
	if (clk_enable(sc->clk) != 0) {
313
		device_printf(dev, "Could not enable clock %s\n",
314
		    clk_get_name(sc->clk));
315
		jh7110_gpio_detach(dev);
316
		return (ENXIO);
317
	}
318

319
	/* Reseting GPIO interrupts */
320
	JH7110_GPIO_WRITE(sc, GPIOE_0, 0);
321
	JH7110_GPIO_WRITE(sc, GPIOE_1, 0);
322
	JH7110_GPIO_WRITE(sc, GPIOEN, 1);
323

324
	sc->busdev = gpiobus_add_bus(dev);
325
	if (sc->busdev == NULL) {
326
		device_printf(dev, "Cannot attach gpiobus\n");
327
		jh7110_gpio_detach(dev);
328
		return (ENXIO);
329
	}
330

331
	bus_attach_children(dev);
332
	return (0);
333
}
334

335
static phandle_t
336
jh7110_gpio_get_node(device_t bus, device_t dev)
337
{
338
	return (ofw_bus_get_node(bus));
339
}
340

341
static device_method_t jh7110_gpio_methods[] = {
342
	/* Device interface */
343
	DEVMETHOD(device_probe,		jh7110_gpio_probe),
344
	DEVMETHOD(device_attach,	jh7110_gpio_attach),
345
	DEVMETHOD(device_detach,	jh7110_gpio_detach),
346

347
	/* GPIO protocol */
348
	DEVMETHOD(gpio_get_bus,		jh7110_gpio_get_bus),
349
	DEVMETHOD(gpio_pin_max,		jh7110_gpio_pin_max),
350
	DEVMETHOD(gpio_pin_get,		jh7110_gpio_pin_get),
351
	DEVMETHOD(gpio_pin_set,		jh7110_gpio_pin_set),
352
	DEVMETHOD(gpio_pin_toggle,	jh7110_gpio_pin_toggle),
353
	DEVMETHOD(gpio_pin_getflags,	jh7110_gpio_pin_getflags),
354
	DEVMETHOD(gpio_pin_setflags,	jh7110_gpio_pin_setflags),
355
	DEVMETHOD(gpio_pin_getcaps,	jh7110_gpio_pin_getcaps),
356
	DEVMETHOD(gpio_pin_getname,	jh7110_gpio_pin_getname),
357

358
	/* ofw_bus interface */
359
	DEVMETHOD(ofw_bus_get_node,	jh7110_gpio_get_node),
360

361
	DEVMETHOD_END
362
};
363

364
DEFINE_CLASS_0(gpio, jh7110_gpio_driver, jh7110_gpio_methods,
365
    sizeof(struct jh7110_gpio_softc));
366
EARLY_DRIVER_MODULE(jh7110_gpio, simplebus, jh7110_gpio_driver, 0, 0,
367
    BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE);
368
MODULE_DEPEND(jh7110_gpio, gpiobus, 1, 1, 1);
369

370
Product

Resources

Company
