blob: 1356f89ac2f080e3c5a8adc94bcac4d5e3ad1d52 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Marek Vasut6b6440d2011-11-08 23:18:13 +00002/*
3 * Freescale i.MX28 GPIO control code
4 *
5 * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
6 * on behalf of DENX Software Engineering GmbH
Marek Vasut6b6440d2011-11-08 23:18:13 +00007 */
8
9#include <common.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060010#include <log.h>
Simon Glass336d4612020-02-03 07:36:16 -070011#include <malloc.h>
Simon Glass401d1c42020-10-30 21:38:53 -060012#include <asm/global_data.h>
Simon Glasscd93d622020-05-10 11:40:13 -060013#include <linux/bitops.h>
Masahiro Yamada1221ce42016-09-21 11:28:55 +090014#include <linux/errno.h>
Marek Vasut6b6440d2011-11-08 23:18:13 +000015#include <asm/io.h>
16#include <asm/arch/iomux.h>
17#include <asm/arch/imx-regs.h>
18
19#if defined(CONFIG_MX23)
20#define PINCTRL_BANKS 3
21#define PINCTRL_DOUT(n) (0x0500 + ((n) * 0x10))
22#define PINCTRL_DIN(n) (0x0600 + ((n) * 0x10))
23#define PINCTRL_DOE(n) (0x0700 + ((n) * 0x10))
24#define PINCTRL_PIN2IRQ(n) (0x0800 + ((n) * 0x10))
25#define PINCTRL_IRQEN(n) (0x0900 + ((n) * 0x10))
26#define PINCTRL_IRQSTAT(n) (0x0c00 + ((n) * 0x10))
27#elif defined(CONFIG_MX28)
28#define PINCTRL_BANKS 5
29#define PINCTRL_DOUT(n) (0x0700 + ((n) * 0x10))
30#define PINCTRL_DIN(n) (0x0900 + ((n) * 0x10))
31#define PINCTRL_DOE(n) (0x0b00 + ((n) * 0x10))
32#define PINCTRL_PIN2IRQ(n) (0x1000 + ((n) * 0x10))
33#define PINCTRL_IRQEN(n) (0x1100 + ((n) * 0x10))
34#define PINCTRL_IRQSTAT(n) (0x1400 + ((n) * 0x10))
35#else
36#error "Please select CONFIG_MX23 or CONFIG_MX28"
37#endif
38
39#define GPIO_INT_FALL_EDGE 0x0
40#define GPIO_INT_LOW_LEV 0x1
41#define GPIO_INT_RISE_EDGE 0x2
42#define GPIO_INT_HIGH_LEV 0x3
43#define GPIO_INT_LEV_MASK (1 << 0)
44#define GPIO_INT_POL_MASK (1 << 1)
45
46void mxs_gpio_init(void)
47{
48 int i;
49
50 for (i = 0; i < PINCTRL_BANKS; i++) {
51 writel(0, MXS_PINCTRL_BASE + PINCTRL_PIN2IRQ(i));
52 writel(0, MXS_PINCTRL_BASE + PINCTRL_IRQEN(i));
53 /* Use SCT address here to clear the IRQSTAT bits */
54 writel(0xffffffff, MXS_PINCTRL_BASE + PINCTRL_IRQSTAT(i) + 8);
55 }
56}
57
Lukasz Majewski397af352019-06-19 17:31:05 +020058#if !CONFIG_IS_ENABLED(DM_GPIO)
Joe Hershberger365d6072011-11-11 15:55:36 -060059int gpio_get_value(unsigned gpio)
Marek Vasut6b6440d2011-11-08 23:18:13 +000060{
Joe Hershberger365d6072011-11-11 15:55:36 -060061 uint32_t bank = PAD_BANK(gpio);
Marek Vasut6b6440d2011-11-08 23:18:13 +000062 uint32_t offset = PINCTRL_DIN(bank);
Otavio Salvadorddcf13b2012-08-05 09:05:30 +000063 struct mxs_register_32 *reg =
64 (struct mxs_register_32 *)(MXS_PINCTRL_BASE + offset);
Marek Vasut6b6440d2011-11-08 23:18:13 +000065
Joe Hershberger365d6072011-11-11 15:55:36 -060066 return (readl(&reg->reg) >> PAD_PIN(gpio)) & 1;
Marek Vasut6b6440d2011-11-08 23:18:13 +000067}
68
Joe Hershberger365d6072011-11-11 15:55:36 -060069void gpio_set_value(unsigned gpio, int value)
Marek Vasut6b6440d2011-11-08 23:18:13 +000070{
Joe Hershberger365d6072011-11-11 15:55:36 -060071 uint32_t bank = PAD_BANK(gpio);
Marek Vasut6b6440d2011-11-08 23:18:13 +000072 uint32_t offset = PINCTRL_DOUT(bank);
Otavio Salvadorddcf13b2012-08-05 09:05:30 +000073 struct mxs_register_32 *reg =
74 (struct mxs_register_32 *)(MXS_PINCTRL_BASE + offset);
Marek Vasut6b6440d2011-11-08 23:18:13 +000075
76 if (value)
Joe Hershberger365d6072011-11-11 15:55:36 -060077 writel(1 << PAD_PIN(gpio), &reg->reg_set);
Marek Vasut6b6440d2011-11-08 23:18:13 +000078 else
Joe Hershberger365d6072011-11-11 15:55:36 -060079 writel(1 << PAD_PIN(gpio), &reg->reg_clr);
Marek Vasut6b6440d2011-11-08 23:18:13 +000080}
81
Joe Hershberger365d6072011-11-11 15:55:36 -060082int gpio_direction_input(unsigned gpio)
Marek Vasut6b6440d2011-11-08 23:18:13 +000083{
Joe Hershberger365d6072011-11-11 15:55:36 -060084 uint32_t bank = PAD_BANK(gpio);
Marek Vasut6b6440d2011-11-08 23:18:13 +000085 uint32_t offset = PINCTRL_DOE(bank);
Otavio Salvadorddcf13b2012-08-05 09:05:30 +000086 struct mxs_register_32 *reg =
87 (struct mxs_register_32 *)(MXS_PINCTRL_BASE + offset);
Marek Vasut6b6440d2011-11-08 23:18:13 +000088
Joe Hershberger365d6072011-11-11 15:55:36 -060089 writel(1 << PAD_PIN(gpio), &reg->reg_clr);
Marek Vasut6b6440d2011-11-08 23:18:13 +000090
91 return 0;
92}
93
Joe Hershberger365d6072011-11-11 15:55:36 -060094int gpio_direction_output(unsigned gpio, int value)
Marek Vasut6b6440d2011-11-08 23:18:13 +000095{
Joe Hershberger365d6072011-11-11 15:55:36 -060096 uint32_t bank = PAD_BANK(gpio);
Marek Vasut6b6440d2011-11-08 23:18:13 +000097 uint32_t offset = PINCTRL_DOE(bank);
Otavio Salvadorddcf13b2012-08-05 09:05:30 +000098 struct mxs_register_32 *reg =
99 (struct mxs_register_32 *)(MXS_PINCTRL_BASE + offset);
Marek Vasut6b6440d2011-11-08 23:18:13 +0000100
Joe Hershberger365d6072011-11-11 15:55:36 -0600101 gpio_set_value(gpio, value);
Marek Vasut6b6440d2011-11-08 23:18:13 +0000102
Michael Heimpoldac135f62013-11-03 22:59:26 +0100103 writel(1 << PAD_PIN(gpio), &reg->reg_set);
104
Marek Vasut6b6440d2011-11-08 23:18:13 +0000105 return 0;
106}
107
Joe Hershberger365d6072011-11-11 15:55:36 -0600108int gpio_request(unsigned gpio, const char *label)
Marek Vasut6b6440d2011-11-08 23:18:13 +0000109{
Joe Hershberger365d6072011-11-11 15:55:36 -0600110 if (PAD_BANK(gpio) >= PINCTRL_BANKS)
111 return -1;
Marek Vasut6b6440d2011-11-08 23:18:13 +0000112
113 return 0;
114}
115
Joe Hershberger365d6072011-11-11 15:55:36 -0600116int gpio_free(unsigned gpio)
Marek Vasut6b6440d2011-11-08 23:18:13 +0000117{
Joe Hershberger365d6072011-11-11 15:55:36 -0600118 return 0;
Marek Vasut6b6440d2011-11-08 23:18:13 +0000119}
Måns Rullgård88f91d12015-12-15 22:27:57 +0000120
121int name_to_gpio(const char *name)
122{
123 unsigned bank, pin;
124 char *end;
125
Simon Glass0b1284e2021-07-24 09:03:30 -0600126 bank = dectoul(name, &end);
Måns Rullgård88f91d12015-12-15 22:27:57 +0000127
128 if (!*end || *end != ':')
129 return bank;
130
Simon Glass0b1284e2021-07-24 09:03:30 -0600131 pin = dectoul(end + 1, NULL);
Måns Rullgård88f91d12015-12-15 22:27:57 +0000132
133 return (bank << MXS_PAD_BANK_SHIFT) | (pin << MXS_PAD_PIN_SHIFT);
134}
Simon Glassbcee8d62019-12-06 21:41:35 -0700135#else /* DM_GPIO */
Lukasz Majewski397af352019-06-19 17:31:05 +0200136#include <dm.h>
137#include <asm/gpio.h>
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200138#include <dt-structs.h>
Lukasz Majewski397af352019-06-19 17:31:05 +0200139#include <asm/arch/gpio.h>
140#define MXS_MAX_GPIO_PER_BANK 32
141
142DECLARE_GLOBAL_DATA_PTR;
143/*
144 * According to i.MX28 Reference Manual:
145 * 'i.MX28 Applications Processor Reference Manual, Rev. 1, 2010'
146 * The i.MX28 has following number of GPIOs available:
147 * Bank 0: 0-28 -> 29 PINS
148 * Bank 1: 0-31 -> 32 PINS
149 * Bank 2: 0-27 -> 28 PINS
150 * Bank 3: 0-30 -> 31 PINS
151 * Bank 4: 0-20 -> 21 PINS
152 */
153
Simon Glass8a8d24b2020-12-03 16:55:23 -0700154struct mxs_gpio_plat {
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200155#if CONFIG_IS_ENABLED(OF_PLATDATA)
Walter Lozanodf17cdc2020-07-23 00:22:04 -0300156 struct dtd_fsl_imx23_gpio dtplat;
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200157#endif
158 unsigned int bank;
159 int gpio_ranges;
160};
161
Lukasz Majewski397af352019-06-19 17:31:05 +0200162struct mxs_gpio_priv {
163 unsigned int bank;
164};
165
166static int mxs_gpio_get_value(struct udevice *dev, unsigned offset)
167{
168 struct mxs_gpio_priv *priv = dev_get_priv(dev);
169 struct mxs_register_32 *reg =
170 (struct mxs_register_32 *)(MXS_PINCTRL_BASE +
171 PINCTRL_DIN(priv->bank));
172
173 return (readl(&reg->reg) >> offset) & 1;
174}
175
176static int mxs_gpio_set_value(struct udevice *dev, unsigned offset,
177 int value)
178{
179 struct mxs_gpio_priv *priv = dev_get_priv(dev);
180 struct mxs_register_32 *reg =
181 (struct mxs_register_32 *)(MXS_PINCTRL_BASE +
182 PINCTRL_DOUT(priv->bank));
183 if (value)
184 writel(BIT(offset), &reg->reg_set);
185 else
186 writel(BIT(offset), &reg->reg_clr);
187
188 return 0;
189}
190
191static int mxs_gpio_direction_input(struct udevice *dev, unsigned offset)
192{
193 struct mxs_gpio_priv *priv = dev_get_priv(dev);
194 struct mxs_register_32 *reg =
195 (struct mxs_register_32 *)(MXS_PINCTRL_BASE +
196 PINCTRL_DOE(priv->bank));
197
198 writel(BIT(offset), &reg->reg_clr);
199
200 return 0;
201}
202
203static int mxs_gpio_direction_output(struct udevice *dev, unsigned offset,
204 int value)
205{
206 struct mxs_gpio_priv *priv = dev_get_priv(dev);
207 struct mxs_register_32 *reg =
208 (struct mxs_register_32 *)(MXS_PINCTRL_BASE +
209 PINCTRL_DOE(priv->bank));
210
211 mxs_gpio_set_value(dev, offset, value);
212
213 writel(BIT(offset), &reg->reg_set);
214
215 return 0;
216}
217
218static int mxs_gpio_get_function(struct udevice *dev, unsigned offset)
219{
220 struct mxs_gpio_priv *priv = dev_get_priv(dev);
221 struct mxs_register_32 *reg =
222 (struct mxs_register_32 *)(MXS_PINCTRL_BASE +
223 PINCTRL_DOE(priv->bank));
224 bool is_output = !!(readl(&reg->reg) >> offset);
225
226 return is_output ? GPIOF_OUTPUT : GPIOF_INPUT;
227}
228
229static const struct dm_gpio_ops gpio_mxs_ops = {
230 .direction_input = mxs_gpio_direction_input,
231 .direction_output = mxs_gpio_direction_output,
232 .get_value = mxs_gpio_get_value,
233 .set_value = mxs_gpio_set_value,
234 .get_function = mxs_gpio_get_function,
235};
236
237static int mxs_gpio_probe(struct udevice *dev)
238{
Simon Glass8a8d24b2020-12-03 16:55:23 -0700239 struct mxs_gpio_plat *plat = dev_get_plat(dev);
Lukasz Majewski397af352019-06-19 17:31:05 +0200240 struct mxs_gpio_priv *priv = dev_get_priv(dev);
241 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
Lukasz Majewski397af352019-06-19 17:31:05 +0200242 char name[16], *str;
Lukasz Majewski397af352019-06-19 17:31:05 +0200243
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200244#if CONFIG_IS_ENABLED(OF_PLATDATA)
Walter Lozanodf17cdc2020-07-23 00:22:04 -0300245 struct dtd_fsl_imx23_gpio *dtplat = &plat->dtplat;
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200246 priv->bank = (unsigned int)dtplat->reg[0];
247 uc_priv->gpio_count = dtplat->gpio_ranges[3];
248#else
249 priv->bank = (unsigned int)plat->bank;
250 uc_priv->gpio_count = plat->gpio_ranges;
251#endif
Lukasz Majewski397af352019-06-19 17:31:05 +0200252 snprintf(name, sizeof(name), "GPIO%d_", priv->bank);
253 str = strdup(name);
254 if (!str)
255 return -ENOMEM;
256
257 uc_priv->bank_name = str;
258
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200259 debug("%s: %s: %d pins base: 0x%x\n", __func__, uc_priv->bank_name,
260 uc_priv->gpio_count, priv->bank);
261
262 return 0;
263}
264
Simon Glass414cc152021-08-07 07:24:03 -0600265#if CONFIG_IS_ENABLED(OF_REAL)
Simon Glassd1998a92020-12-03 16:55:21 -0700266static int mxs_of_to_plat(struct udevice *dev)
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200267{
Simon Glass0fd3d912020-12-22 19:30:28 -0700268 struct mxs_gpio_plat *plat = dev_get_plat(dev);
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200269 struct fdtdec_phandle_args args;
270 int node = dev_of_offset(dev);
271 int ret;
272
Masahiro Yamada25484932020-07-17 14:36:48 +0900273 plat->bank = dev_read_addr(dev);
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200274 if (plat->bank == FDT_ADDR_T_NONE) {
275 printf("%s: No 'reg' property defined!\n", __func__);
276 return -EINVAL;
277 }
278
Lukasz Majewski397af352019-06-19 17:31:05 +0200279 ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, node, "gpio-ranges",
280 NULL, 3, 0, &args);
281 if (ret)
282 printf("%s: 'gpio-ranges' not defined - using default!\n",
283 __func__);
284
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200285 plat->gpio_ranges = ret == 0 ? args.args[2] : MXS_MAX_GPIO_PER_BANK;
Lukasz Majewski397af352019-06-19 17:31:05 +0200286
287 return 0;
288}
289
290static const struct udevice_id mxs_gpio_ids[] = {
291 { .compatible = "fsl,imx23-gpio" },
292 { .compatible = "fsl,imx28-gpio" },
293 { }
294};
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200295#endif
Lukasz Majewski397af352019-06-19 17:31:05 +0200296
Walter Lozanoe3e24702020-06-25 01:10:04 -0300297U_BOOT_DRIVER(fsl_imx23_gpio) = {
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200298 .name = "fsl_imx23_gpio",
Lukasz Majewski397af352019-06-19 17:31:05 +0200299 .id = UCLASS_GPIO,
300 .ops = &gpio_mxs_ops,
301 .probe = mxs_gpio_probe,
Simon Glass41575d82020-12-03 16:55:17 -0700302 .priv_auto = sizeof(struct mxs_gpio_priv),
Simon Glass8a8d24b2020-12-03 16:55:23 -0700303 .plat_auto = sizeof(struct mxs_gpio_plat),
Simon Glass414cc152021-08-07 07:24:03 -0600304#if CONFIG_IS_ENABLED(OF_REAL)
Lukasz Majewski397af352019-06-19 17:31:05 +0200305 .of_match = mxs_gpio_ids,
Simon Glassd1998a92020-12-03 16:55:21 -0700306 .of_to_plat = mxs_of_to_plat,
Lukasz Majewskic883d6a2019-09-05 09:55:01 +0200307#endif
Lukasz Majewski397af352019-06-19 17:31:05 +0200308};
Walter Lozanoaddf3582020-06-25 01:10:06 -0300309
Simon Glassbdf8fd72020-12-28 20:34:57 -0700310DM_DRIVER_ALIAS(fsl_imx23_gpio, fsl_imx28_gpio)
Simon Glassbcee8d62019-12-06 21:41:35 -0700311#endif /* DM_GPIO */