xref: /openbmc/u-boot/drivers/gpio/atmel_pio4.c (revision 9ed00b07) 
1 /*
2  * Atmel PIO4 device driver
3  *
4  * Copyright (C) 2015 Atmel Corporation
5  *		 Wenyou.Yang <wenyou.yang@atmel.com>
6  *
7  * SPDX-License-Identifier:	GPL-2.0+
8  */
9 #include <common.h>
10 #include <clk.h>
11 #include <dm.h>
12 #include <fdtdec.h>
13 #include <dm/root.h>
14 #include <asm/arch/hardware.h>
15 #include <asm/gpio.h>
16 #include <mach/gpio.h>
17 #include <mach/atmel_pio4.h>
18 
19 DECLARE_GLOBAL_DATA_PTR;
20 
21 static struct atmel_pio4_port *atmel_pio4_port_base(u32 port)
22 {
23 	struct atmel_pio4_port *base = NULL;
24 
25 	switch (port) {
26 	case AT91_PIO_PORTA:
27 		base = (struct atmel_pio4_port *)ATMEL_BASE_PIOA;
28 		break;
29 	case AT91_PIO_PORTB:
30 		base = (struct atmel_pio4_port *)ATMEL_BASE_PIOB;
31 		break;
32 	case AT91_PIO_PORTC:
33 		base = (struct atmel_pio4_port *)ATMEL_BASE_PIOC;
34 		break;
35 	case AT91_PIO_PORTD:
36 		base = (struct atmel_pio4_port *)ATMEL_BASE_PIOD;
37 		break;
38 	default:
39 		printf("Error: Atmel PIO4: Failed to get PIO base of port#%d!\n",
40 		       port);
41 		break;
42 	}
43 
44 	return base;
45 }
46 
47 static int atmel_pio4_config_io_func(u32 port, u32 pin,
48 				     u32 func, u32 use_pullup)
49 {
50 	struct atmel_pio4_port *port_base;
51 	u32 reg, mask;
52 
53 	if (pin >= ATMEL_PIO_NPINS_PER_BANK)
54 		return -ENODEV;
55 
56 	port_base = atmel_pio4_port_base(port);
57 	if (!port_base)
58 		return -ENODEV;
59 
60 	mask = 1 << pin;
61 	reg = func;
62 	reg |= use_pullup ? ATMEL_PIO_PUEN_MASK : 0;
63 
64 	writel(mask, &port_base->mskr);
65 	writel(reg, &port_base->cfgr);
66 
67 	return 0;
68 }
69 
70 int atmel_pio4_set_gpio(u32 port, u32 pin, u32 use_pullup)
71 {
72 	return atmel_pio4_config_io_func(port, pin,
73 					 ATMEL_PIO_CFGR_FUNC_GPIO,
74 					 use_pullup);
75 }
76 
77 int atmel_pio4_set_a_periph(u32 port, u32 pin, u32 use_pullup)
78 {
79 	return atmel_pio4_config_io_func(port, pin,
80 					 ATMEL_PIO_CFGR_FUNC_PERIPH_A,
81 					 use_pullup);
82 }
83 
84 int atmel_pio4_set_b_periph(u32 port, u32 pin, u32 use_pullup)
85 {
86 	return atmel_pio4_config_io_func(port, pin,
87 					 ATMEL_PIO_CFGR_FUNC_PERIPH_B,
88 					 use_pullup);
89 }
90 
91 int atmel_pio4_set_c_periph(u32 port, u32 pin, u32 use_pullup)
92 {
93 	return atmel_pio4_config_io_func(port, pin,
94 					 ATMEL_PIO_CFGR_FUNC_PERIPH_C,
95 					 use_pullup);
96 }
97 
98 int atmel_pio4_set_d_periph(u32 port, u32 pin, u32 use_pullup)
99 {
100 	return atmel_pio4_config_io_func(port, pin,
101 					 ATMEL_PIO_CFGR_FUNC_PERIPH_D,
102 					 use_pullup);
103 }
104 
105 int atmel_pio4_set_e_periph(u32 port, u32 pin, u32 use_pullup)
106 {
107 	return atmel_pio4_config_io_func(port, pin,
108 					 ATMEL_PIO_CFGR_FUNC_PERIPH_E,
109 					 use_pullup);
110 }
111 
112 int atmel_pio4_set_f_periph(u32 port, u32 pin, u32 use_pullup)
113 {
114 	return atmel_pio4_config_io_func(port, pin,
115 					 ATMEL_PIO_CFGR_FUNC_PERIPH_F,
116 					 use_pullup);
117 }
118 
119 int atmel_pio4_set_g_periph(u32 port, u32 pin, u32 use_pullup)
120 {
121 	return atmel_pio4_config_io_func(port, pin,
122 					 ATMEL_PIO_CFGR_FUNC_PERIPH_G,
123 					 use_pullup);
124 }
125 
126 int atmel_pio4_set_pio_output(u32 port, u32 pin, u32 value)
127 {
128 	struct atmel_pio4_port *port_base;
129 	u32 reg, mask;
130 
131 	if (pin >= ATMEL_PIO_NPINS_PER_BANK)
132 		return -ENODEV;
133 
134 	port_base = atmel_pio4_port_base(port);
135 	if (!port_base)
136 		return -ENODEV;
137 
138 	mask = 0x01 << pin;
139 	reg = ATMEL_PIO_CFGR_FUNC_GPIO | ATMEL_PIO_DIR_MASK;
140 
141 	writel(mask, &port_base->mskr);
142 	writel(reg, &port_base->cfgr);
143 
144 	if (value)
145 		writel(mask, &port_base->sodr);
146 	else
147 		writel(mask, &port_base->codr);
148 
149 	return 0;
150 }
151 
152 int atmel_pio4_get_pio_input(u32 port, u32 pin)
153 {
154 	struct atmel_pio4_port *port_base;
155 	u32 reg, mask;
156 
157 	if (pin >= ATMEL_PIO_NPINS_PER_BANK)
158 		return -ENODEV;
159 
160 	port_base = atmel_pio4_port_base(port);
161 	if (!port_base)
162 		return -ENODEV;
163 
164 	mask = 0x01 << pin;
165 	reg = ATMEL_PIO_CFGR_FUNC_GPIO;
166 
167 	writel(mask, &port_base->mskr);
168 	writel(reg, &port_base->cfgr);
169 
170 	return (readl(&port_base->pdsr) & mask) ? 1 : 0;
171 }
172 
173 #ifdef CONFIG_DM_GPIO
174 
175 struct atmel_pioctrl_data {
176 	u32 nbanks;
177 };
178 
179 struct atmel_pio4_platdata {
180 	struct atmel_pio4_port *reg_base;
181 };
182 
183 static struct atmel_pio4_port *atmel_pio4_bank_base(struct udevice *dev,
184 						    u32 bank)
185 {
186 	struct atmel_pio4_platdata *plat = dev_get_platdata(dev);
187 	struct atmel_pio4_port *port_base =
188 			(struct atmel_pio4_port *)((u32)plat->reg_base +
189 			ATMEL_PIO_BANK_OFFSET * bank);
190 
191 	return port_base;
192 }
193 
194 static int atmel_pio4_direction_input(struct udevice *dev, unsigned offset)
195 {
196 	u32 bank = ATMEL_PIO_BANK(offset);
197 	u32 line = ATMEL_PIO_LINE(offset);
198 	struct atmel_pio4_port *port_base = atmel_pio4_bank_base(dev, bank);
199 	u32 mask = BIT(line);
200 
201 	writel(mask, &port_base->mskr);
202 
203 	clrbits_le32(&port_base->cfgr,
204 		     ATMEL_PIO_CFGR_FUNC_MASK | ATMEL_PIO_DIR_MASK);
205 
206 	return 0;
207 }
208 
209 static int atmel_pio4_direction_output(struct udevice *dev,
210 				       unsigned offset, int value)
211 {
212 	u32 bank = ATMEL_PIO_BANK(offset);
213 	u32 line = ATMEL_PIO_LINE(offset);
214 	struct atmel_pio4_port *port_base = atmel_pio4_bank_base(dev, bank);
215 	u32 mask = BIT(line);
216 
217 	writel(mask, &port_base->mskr);
218 
219 	clrsetbits_le32(&port_base->cfgr,
220 			ATMEL_PIO_CFGR_FUNC_MASK, ATMEL_PIO_DIR_MASK);
221 
222 	if (value)
223 		writel(mask, &port_base->sodr);
224 	else
225 		writel(mask, &port_base->codr);
226 
227 	return 0;
228 }
229 
230 static int atmel_pio4_get_value(struct udevice *dev, unsigned offset)
231 {
232 	u32 bank = ATMEL_PIO_BANK(offset);
233 	u32 line = ATMEL_PIO_LINE(offset);
234 	struct atmel_pio4_port *port_base = atmel_pio4_bank_base(dev, bank);
235 	u32 mask = BIT(line);
236 
237 	return (readl(&port_base->pdsr) & mask) ? 1 : 0;
238 }
239 
240 static int atmel_pio4_set_value(struct udevice *dev,
241 				unsigned offset, int value)
242 {
243 	u32 bank = ATMEL_PIO_BANK(offset);
244 	u32 line = ATMEL_PIO_LINE(offset);
245 	struct atmel_pio4_port *port_base = atmel_pio4_bank_base(dev, bank);
246 	u32 mask = BIT(line);
247 
248 	if (value)
249 		writel(mask, &port_base->sodr);
250 	else
251 		writel(mask, &port_base->codr);
252 
253 	return 0;
254 }
255 
256 static int atmel_pio4_get_function(struct udevice *dev, unsigned offset)
257 {
258 	u32 bank = ATMEL_PIO_BANK(offset);
259 	u32 line = ATMEL_PIO_LINE(offset);
260 	struct atmel_pio4_port *port_base = atmel_pio4_bank_base(dev, bank);
261 	u32 mask = BIT(line);
262 
263 	writel(mask, &port_base->mskr);
264 
265 	return (readl(&port_base->cfgr) &
266 		ATMEL_PIO_DIR_MASK) ? GPIOF_OUTPUT : GPIOF_INPUT;
267 }
268 
269 static const struct dm_gpio_ops atmel_pio4_ops = {
270 	.direction_input	= atmel_pio4_direction_input,
271 	.direction_output	= atmel_pio4_direction_output,
272 	.get_value		= atmel_pio4_get_value,
273 	.set_value		= atmel_pio4_set_value,
274 	.get_function		= atmel_pio4_get_function,
275 };
276 
277 static int atmel_pio4_bind(struct udevice *dev)
278 {
279 	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
280 }
281 
282 static int atmel_pio4_probe(struct udevice *dev)
283 {
284 	struct atmel_pio4_platdata *plat = dev_get_platdata(dev);
285 	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
286 	struct atmel_pioctrl_data *pioctrl_data;
287 	struct udevice *dev_clk;
288 	struct clk clk;
289 	fdt_addr_t addr_base;
290 	u32 nbanks;
291 	int periph;
292 	int ret;
293 
294 	ret = clk_get_by_index(dev, 0, &clk);
295 	if (ret)
296 		return ret;
297 
298 	periph = fdtdec_get_uint(gd->fdt_blob, clk.dev->of_offset, "reg", -1);
299 	if (periph < 0)
300 		return -EINVAL;
301 
302 	dev_clk = dev_get_parent(clk.dev);
303 	ret = clk_request(dev_clk, &clk);
304 	if (ret)
305 		return ret;
306 
307 	clk.id = periph;
308 	ret = clk_enable(&clk);
309 	if (ret)
310 		return ret;
311 
312 	clk_free(&clk);
313 
314 	addr_base = dev_get_addr(dev);
315 	if (addr_base == FDT_ADDR_T_NONE)
316 		return -EINVAL;
317 
318 	plat->reg_base = (struct atmel_pio4_port *)addr_base;
319 
320 	pioctrl_data = (struct atmel_pioctrl_data *)dev_get_driver_data(dev);
321 	nbanks = pioctrl_data->nbanks;
322 
323 	uc_priv->bank_name = fdt_get_name(gd->fdt_blob, dev->of_offset, NULL);
324 	uc_priv->gpio_count = nbanks * ATMEL_PIO_NPINS_PER_BANK;
325 
326 	return 0;
327 }
328 
329 /*
330  * The number of banks can be different from a SoC to another one.
331  * We can have up to 16 banks.
332  */
333 static const struct atmel_pioctrl_data atmel_sama5d2_pioctrl_data = {
334 	.nbanks	= 4,
335 };
336 
337 static const struct udevice_id atmel_pio4_ids[] = {
338 	{
339 		.compatible = "atmel,sama5d2-gpio",
340 		.data = (ulong)&atmel_sama5d2_pioctrl_data,
341 	},
342 	{}
343 };
344 
345 U_BOOT_DRIVER(gpio_atmel_pio4) = {
346 	.name	= "gpio_atmel_pio4",
347 	.id	= UCLASS_GPIO,
348 	.ops	= &atmel_pio4_ops,
349 	.probe	= atmel_pio4_probe,
350 	.bind	= atmel_pio4_bind,
351 	.of_match = atmel_pio4_ids,
352 	.platdata_auto_alloc_size = sizeof(struct atmel_pio4_platdata),
353 };
354 
355 #endif
356