1 /* 2 * Copyright (c) 2009 Wind River Systems, Inc. 3 * Tom Rix <Tom.Rix@windriver.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0 6 * 7 * This work is derived from the linux 2.6.27 kernel source 8 * To fetch, use the kernel repository 9 * git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git 10 * Use the v2.6.27 tag. 11 * 12 * Below is the original's header including its copyright 13 * 14 * linux/arch/arm/plat-omap/gpio.c 15 * 16 * Support functions for OMAP GPIO 17 * 18 * Copyright (C) 2003-2005 Nokia Corporation 19 * Written by Juha Yrjölä <juha.yrjola@nokia.com> 20 */ 21 #include <common.h> 22 #include <dm.h> 23 #include <asm/gpio.h> 24 #include <asm/io.h> 25 #include <asm/errno.h> 26 27 #define OMAP_GPIO_DIR_OUT 0 28 #define OMAP_GPIO_DIR_IN 1 29 30 #ifdef CONFIG_DM_GPIO 31 32 #define GPIO_PER_BANK 32 33 34 struct gpio_bank { 35 /* TODO(sjg@chromium.org): Can we use a struct here? */ 36 void *base; /* address of registers in physical memory */ 37 enum gpio_method method; 38 }; 39 40 #endif 41 42 static inline int get_gpio_index(int gpio) 43 { 44 return gpio & 0x1f; 45 } 46 47 int gpio_is_valid(int gpio) 48 { 49 return (gpio >= 0) && (gpio < OMAP_MAX_GPIO); 50 } 51 52 static void _set_gpio_direction(const struct gpio_bank *bank, int gpio, 53 int is_input) 54 { 55 void *reg = bank->base; 56 u32 l; 57 58 switch (bank->method) { 59 case METHOD_GPIO_24XX: 60 reg += OMAP_GPIO_OE; 61 break; 62 default: 63 return; 64 } 65 l = __raw_readl(reg); 66 if (is_input) 67 l |= 1 << gpio; 68 else 69 l &= ~(1 << gpio); 70 __raw_writel(l, reg); 71 } 72 73 /** 74 * Get the direction of the GPIO by reading the GPIO_OE register 75 * corresponding to the specified bank. 76 */ 77 static int _get_gpio_direction(const struct gpio_bank *bank, int gpio) 78 { 79 void *reg = bank->base; 80 u32 v; 81 82 switch (bank->method) { 83 case METHOD_GPIO_24XX: 84 reg += OMAP_GPIO_OE; 85 break; 86 default: 87 return -1; 88 } 89 90 v = __raw_readl(reg); 91 92 if (v & (1 << gpio)) 93 return OMAP_GPIO_DIR_IN; 94 else 95 return OMAP_GPIO_DIR_OUT; 96 } 97 98 static void _set_gpio_dataout(const struct gpio_bank *bank, int gpio, 99 int enable) 100 { 101 void *reg = bank->base; 102 u32 l = 0; 103 104 switch (bank->method) { 105 case METHOD_GPIO_24XX: 106 if (enable) 107 reg += OMAP_GPIO_SETDATAOUT; 108 else 109 reg += OMAP_GPIO_CLEARDATAOUT; 110 l = 1 << gpio; 111 break; 112 default: 113 printf("omap3-gpio unknown bank method %s %d\n", 114 __FILE__, __LINE__); 115 return; 116 } 117 __raw_writel(l, reg); 118 } 119 120 static int _get_gpio_value(const struct gpio_bank *bank, int gpio) 121 { 122 void *reg = bank->base; 123 int input; 124 125 switch (bank->method) { 126 case METHOD_GPIO_24XX: 127 input = _get_gpio_direction(bank, gpio); 128 switch (input) { 129 case OMAP_GPIO_DIR_IN: 130 reg += OMAP_GPIO_DATAIN; 131 break; 132 case OMAP_GPIO_DIR_OUT: 133 reg += OMAP_GPIO_DATAOUT; 134 break; 135 default: 136 return -1; 137 } 138 break; 139 default: 140 return -1; 141 } 142 143 return (__raw_readl(reg) & (1 << gpio)) != 0; 144 } 145 146 #ifndef CONFIG_DM_GPIO 147 148 static inline const struct gpio_bank *get_gpio_bank(int gpio) 149 { 150 return &omap_gpio_bank[gpio >> 5]; 151 } 152 153 static int check_gpio(int gpio) 154 { 155 if (!gpio_is_valid(gpio)) { 156 printf("ERROR : check_gpio: invalid GPIO %d\n", gpio); 157 return -1; 158 } 159 return 0; 160 } 161 162 /** 163 * Set value of the specified gpio 164 */ 165 int gpio_set_value(unsigned gpio, int value) 166 { 167 const struct gpio_bank *bank; 168 169 if (check_gpio(gpio) < 0) 170 return -1; 171 bank = get_gpio_bank(gpio); 172 _set_gpio_dataout(bank, get_gpio_index(gpio), value); 173 174 return 0; 175 } 176 177 /** 178 * Get value of the specified gpio 179 */ 180 int gpio_get_value(unsigned gpio) 181 { 182 const struct gpio_bank *bank; 183 184 if (check_gpio(gpio) < 0) 185 return -1; 186 bank = get_gpio_bank(gpio); 187 188 return _get_gpio_value(bank, get_gpio_index(gpio)); 189 } 190 191 /** 192 * Set gpio direction as input 193 */ 194 int gpio_direction_input(unsigned gpio) 195 { 196 const struct gpio_bank *bank; 197 198 if (check_gpio(gpio) < 0) 199 return -1; 200 201 bank = get_gpio_bank(gpio); 202 _set_gpio_direction(bank, get_gpio_index(gpio), 1); 203 204 return 0; 205 } 206 207 /** 208 * Set gpio direction as output 209 */ 210 int gpio_direction_output(unsigned gpio, int value) 211 { 212 const struct gpio_bank *bank; 213 214 if (check_gpio(gpio) < 0) 215 return -1; 216 217 bank = get_gpio_bank(gpio); 218 _set_gpio_dataout(bank, get_gpio_index(gpio), value); 219 _set_gpio_direction(bank, get_gpio_index(gpio), 0); 220 221 return 0; 222 } 223 224 /** 225 * Request a gpio before using it. 226 * 227 * NOTE: Argument 'label' is unused. 228 */ 229 int gpio_request(unsigned gpio, const char *label) 230 { 231 if (check_gpio(gpio) < 0) 232 return -1; 233 234 return 0; 235 } 236 237 /** 238 * Reset and free the gpio after using it. 239 */ 240 int gpio_free(unsigned gpio) 241 { 242 return 0; 243 } 244 245 #else /* new driver model interface CONFIG_DM_GPIO */ 246 247 /* set GPIO pin 'gpio' as an input */ 248 static int omap_gpio_direction_input(struct udevice *dev, unsigned offset) 249 { 250 struct gpio_bank *bank = dev_get_priv(dev); 251 252 /* Configure GPIO direction as input. */ 253 _set_gpio_direction(bank, offset, 1); 254 255 return 0; 256 } 257 258 /* set GPIO pin 'gpio' as an output, with polarity 'value' */ 259 static int omap_gpio_direction_output(struct udevice *dev, unsigned offset, 260 int value) 261 { 262 struct gpio_bank *bank = dev_get_priv(dev); 263 264 _set_gpio_dataout(bank, offset, value); 265 _set_gpio_direction(bank, offset, 0); 266 267 return 0; 268 } 269 270 /* read GPIO IN value of pin 'gpio' */ 271 static int omap_gpio_get_value(struct udevice *dev, unsigned offset) 272 { 273 struct gpio_bank *bank = dev_get_priv(dev); 274 275 return _get_gpio_value(bank, offset); 276 } 277 278 /* write GPIO OUT value to pin 'gpio' */ 279 static int omap_gpio_set_value(struct udevice *dev, unsigned offset, 280 int value) 281 { 282 struct gpio_bank *bank = dev_get_priv(dev); 283 284 _set_gpio_dataout(bank, offset, value); 285 286 return 0; 287 } 288 289 static int omap_gpio_get_function(struct udevice *dev, unsigned offset) 290 { 291 struct gpio_bank *bank = dev_get_priv(dev); 292 293 /* GPIOF_FUNC is not implemented yet */ 294 if (_get_gpio_direction(bank, offset) == OMAP_GPIO_DIR_OUT) 295 return GPIOF_OUTPUT; 296 else 297 return GPIOF_INPUT; 298 } 299 300 static const struct dm_gpio_ops gpio_omap_ops = { 301 .direction_input = omap_gpio_direction_input, 302 .direction_output = omap_gpio_direction_output, 303 .get_value = omap_gpio_get_value, 304 .set_value = omap_gpio_set_value, 305 .get_function = omap_gpio_get_function, 306 }; 307 308 static int omap_gpio_probe(struct udevice *dev) 309 { 310 struct gpio_bank *bank = dev_get_priv(dev); 311 struct omap_gpio_platdata *plat = dev_get_platdata(dev); 312 struct gpio_dev_priv *uc_priv = dev->uclass_priv; 313 char name[18], *str; 314 315 sprintf(name, "GPIO%d_", plat->bank_index); 316 str = strdup(name); 317 if (!str) 318 return -ENOMEM; 319 uc_priv->bank_name = str; 320 uc_priv->gpio_count = GPIO_PER_BANK; 321 bank->base = (void *)plat->base; 322 bank->method = plat->method; 323 324 return 0; 325 } 326 327 U_BOOT_DRIVER(gpio_omap) = { 328 .name = "gpio_omap", 329 .id = UCLASS_GPIO, 330 .ops = &gpio_omap_ops, 331 .probe = omap_gpio_probe, 332 .priv_auto_alloc_size = sizeof(struct gpio_bank), 333 }; 334 335 #endif /* CONFIG_DM_GPIO */ 336