dm: rpi: Convert GPIO driver to driver model
[karo-tx-uboot.git] / drivers / gpio / bcm2835_gpio.c
1 /*
2  * Copyright (C) 2012 Vikram Narayananan
3  * <vikram186@gmail.com>
4  *
5  * SPDX-License-Identifier:     GPL-2.0+
6  */
7
8 #include <common.h>
9 #include <dm.h>
10 #include <errno.h>
11 #include <asm/gpio.h>
12 #include <asm/io.h>
13
14 #define GPIO_NAME_SIZE          20
15
16 struct bcm2835_gpios {
17         char label[BCM2835_GPIO_COUNT][GPIO_NAME_SIZE];
18         struct bcm2835_gpio_regs *reg;
19 };
20
21 /**
22  * gpio_is_requested() - check if a GPIO has been requested
23  *
24  * @bank:       Bank to check
25  * @offset:     GPIO offset within bank to check
26  * @return true if marked as requested, false if not
27  */
28 static inline bool gpio_is_requested(struct bcm2835_gpios *gpios, int offset)
29 {
30         return *gpios->label[offset] != '\0';
31 }
32
33 static int check_requested(struct udevice *dev, unsigned offset,
34                            const char *func)
35 {
36         struct bcm2835_gpios *gpios = dev_get_priv(dev);
37         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
38
39         if (!gpio_is_requested(gpios, offset)) {
40                 printf("omap_gpio: %s: error: gpio %s%d not requested\n",
41                        func, uc_priv->bank_name, offset);
42                 return -EPERM;
43         }
44
45         return 0;
46 }
47
48 static int bcm2835_gpio_request(struct udevice *dev, unsigned offset,
49                                 const char *label)
50 {
51         struct bcm2835_gpios *gpios = dev_get_priv(dev);
52
53         if (gpio_is_requested(gpios, offset))
54                 return -EBUSY;
55
56         strncpy(gpios->label[offset], label, GPIO_NAME_SIZE);
57         gpios->label[offset][GPIO_NAME_SIZE - 1] = '\0';
58
59         return 0;
60 }
61
62 static int bcm2835_gpio_free(struct udevice *dev, unsigned offset)
63 {
64         struct bcm2835_gpios *gpios = dev_get_priv(dev);
65         int ret;
66
67         ret = check_requested(dev, offset, __func__);
68         if (ret)
69                 return ret;
70         gpios->label[offset][0] = '\0';
71
72         return 0;
73 }
74
75 static int bcm2835_gpio_direction_input(struct udevice *dev, unsigned gpio)
76 {
77         struct bcm2835_gpios *gpios = dev_get_priv(dev);
78         unsigned val;
79
80         val = readl(&gpios->reg->gpfsel[BCM2835_GPIO_FSEL_BANK(gpio)]);
81         val &= ~(BCM2835_GPIO_FSEL_MASK << BCM2835_GPIO_FSEL_SHIFT(gpio));
82         val |= (BCM2835_GPIO_INPUT << BCM2835_GPIO_FSEL_SHIFT(gpio));
83         writel(val, &gpios->reg->gpfsel[BCM2835_GPIO_FSEL_BANK(gpio)]);
84
85         return 0;
86 }
87
88 static int bcm2835_gpio_direction_output(struct udevice *dev, unsigned gpio,
89                                          int value)
90 {
91         struct bcm2835_gpios *gpios = dev_get_priv(dev);
92         unsigned val;
93
94         gpio_set_value(gpio, value);
95
96         val = readl(&gpios->reg->gpfsel[BCM2835_GPIO_FSEL_BANK(gpio)]);
97         val &= ~(BCM2835_GPIO_FSEL_MASK << BCM2835_GPIO_FSEL_SHIFT(gpio));
98         val |= (BCM2835_GPIO_OUTPUT << BCM2835_GPIO_FSEL_SHIFT(gpio));
99         writel(val, &gpios->reg->gpfsel[BCM2835_GPIO_FSEL_BANK(gpio)]);
100
101         return 0;
102 }
103
104 static bool bcm2835_gpio_is_output(const struct bcm2835_gpios *gpios, int gpio)
105 {
106         u32 val;
107
108         val = readl(&gpios->reg->gpfsel[BCM2835_GPIO_FSEL_BANK(gpio)]);
109         val &= BCM2835_GPIO_FSEL_MASK << BCM2835_GPIO_FSEL_SHIFT(gpio);
110         return val ? true : false;
111 }
112
113 static int bcm2835_get_value(const struct bcm2835_gpios *gpios, unsigned gpio)
114 {
115         unsigned val;
116
117         val = readl(&gpios->reg->gplev[BCM2835_GPIO_COMMON_BANK(gpio)]);
118
119         return (val >> BCM2835_GPIO_COMMON_SHIFT(gpio)) & 0x1;
120 }
121
122 static int bcm2835_gpio_get_value(struct udevice *dev, unsigned gpio)
123 {
124         const struct bcm2835_gpios *gpios = dev_get_priv(dev);
125
126         return bcm2835_get_value(gpios, gpio);
127 }
128
129 static int bcm2835_gpio_set_value(struct udevice *dev, unsigned gpio,
130                                   int value)
131 {
132         struct bcm2835_gpios *gpios = dev_get_priv(dev);
133         u32 *output_reg = value ? gpios->reg->gpset : gpios->reg->gpclr;
134
135         writel(1 << BCM2835_GPIO_COMMON_SHIFT(gpio),
136                                 &output_reg[BCM2835_GPIO_COMMON_BANK(gpio)]);
137
138         return 0;
139 }
140
141 static int bcm2835_gpio_get_function(struct udevice *dev, unsigned offset)
142 {
143         struct bcm2835_gpios *gpios = dev_get_priv(dev);
144
145         if (!gpio_is_requested(gpios, offset))
146                 return GPIOF_UNUSED;
147
148         /* GPIOF_FUNC is not implemented yet */
149         if (bcm2835_gpio_is_output(gpios, offset))
150                 return GPIOF_OUTPUT;
151         else
152                 return GPIOF_INPUT;
153 }
154
155 static int bcm2835_gpio_get_state(struct udevice *dev, unsigned int offset,
156                                   char *buf, int bufsize)
157 {
158         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
159         struct bcm2835_gpios *gpios = dev_get_priv(dev);
160         const char *label;
161         bool requested;
162         bool is_output;
163         int size;
164
165         label = gpios->label[offset];
166         is_output = bcm2835_gpio_is_output(gpios, offset);
167         size = snprintf(buf, bufsize, "%s%d: ",
168                         uc_priv->bank_name ? uc_priv->bank_name : "", offset);
169         buf += size;
170         bufsize -= size;
171         requested = gpio_is_requested(gpios, offset);
172         snprintf(buf, bufsize, "%s: %d [%c]%s%s",
173                  is_output ? "out" : " in",
174                  bcm2835_get_value(gpios, offset),
175                  requested ? 'x' : ' ',
176                  requested ? " " : "",
177                  label);
178
179         return 0;
180 }
181
182 static const struct dm_gpio_ops gpio_bcm2835_ops = {
183         .request                = bcm2835_gpio_request,
184         .free                   = bcm2835_gpio_free,
185         .direction_input        = bcm2835_gpio_direction_input,
186         .direction_output       = bcm2835_gpio_direction_output,
187         .get_value              = bcm2835_gpio_get_value,
188         .set_value              = bcm2835_gpio_set_value,
189         .get_function           = bcm2835_gpio_get_function,
190         .get_state              = bcm2835_gpio_get_state,
191 };
192
193 static int bcm2835_gpio_probe(struct udevice *dev)
194 {
195         struct bcm2835_gpios *gpios = dev_get_priv(dev);
196         struct bcm2835_gpio_platdata *plat = dev_get_platdata(dev);
197         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
198
199         uc_priv->bank_name = "GPIO";
200         uc_priv->gpio_count = BCM2835_GPIO_COUNT;
201         gpios->reg = (struct bcm2835_gpio_regs *)plat->base;
202
203         return 0;
204 }
205
206 U_BOOT_DRIVER(gpio_bcm2835) = {
207         .name   = "gpio_bcm2835",
208         .id     = UCLASS_GPIO,
209         .ops    = &gpio_bcm2835_ops,
210         .probe  = bcm2835_gpio_probe,
211         .priv_auto_alloc_size = sizeof(struct bcm2835_gpios),
212 };