1 /* 2 * ADI GPIO2 Abstraction Layer 3 * Support BF54x, BF60x and future processors. 4 * 5 * Copyright 2008-2013 Analog Devices Inc. 6 * 7 * Licensed under the GPL-2 or later 8 */ 9 10 #include <common.h> 11 #include <linux/errno.h> 12 #include <asm/gpio.h> 13 14 #define RESOURCE_LABEL_SIZE 16 15 16 static struct str_ident { 17 char name[RESOURCE_LABEL_SIZE]; 18 } str_ident[MAX_RESOURCES]; 19 20 static void gpio_error(unsigned gpio) 21 { 22 printf("adi_gpio2: GPIO %d wasn't requested!\n", gpio); 23 } 24 25 static void set_label(unsigned short ident, const char *label) 26 { 27 if (label) { 28 strncpy(str_ident[ident].name, label, 29 RESOURCE_LABEL_SIZE); 30 str_ident[ident].name[RESOURCE_LABEL_SIZE - 1] = 0; 31 } 32 } 33 34 static char *get_label(unsigned short ident) 35 { 36 return *str_ident[ident].name ? str_ident[ident].name : "UNKNOWN"; 37 } 38 39 static int cmp_label(unsigned short ident, const char *label) 40 { 41 if (label == NULL) 42 printf("adi_gpio2: please provide none-null label\n"); 43 44 if (label) 45 return strcmp(str_ident[ident].name, label); 46 else 47 return -EINVAL; 48 } 49 50 #define map_entry(m, i) reserved_##m##_map[gpio_bank(i)] 51 #define is_reserved(m, i, e) (map_entry(m, i) & gpio_bit(i)) 52 #define reserve(m, i) (map_entry(m, i) |= gpio_bit(i)) 53 #define unreserve(m, i) (map_entry(m, i) &= ~gpio_bit(i)) 54 #define DECLARE_RESERVED_MAP(m, c) unsigned short reserved_##m##_map[c] 55 56 static DECLARE_RESERVED_MAP(gpio, GPIO_BANK_NUM); 57 static DECLARE_RESERVED_MAP(peri, gpio_bank(MAX_RESOURCES)); 58 59 inline int check_gpio(unsigned gpio) 60 { 61 #if defined(CONFIG_BF54x) 62 if (gpio == GPIO_PB15 || gpio == GPIO_PC14 || gpio == GPIO_PC15 || 63 gpio == GPIO_PH14 || gpio == GPIO_PH15 || 64 gpio == GPIO_PJ14 || gpio == GPIO_PJ15) 65 return -EINVAL; 66 #endif 67 if (gpio >= MAX_GPIOS) 68 return -EINVAL; 69 return 0; 70 } 71 72 static void port_setup(unsigned gpio, unsigned short usage) 73 { 74 #if defined(CONFIG_BF54x) 75 if (usage == GPIO_USAGE) 76 gpio_array[gpio_bank(gpio)]->port_fer &= ~gpio_bit(gpio); 77 else 78 gpio_array[gpio_bank(gpio)]->port_fer |= gpio_bit(gpio); 79 #else 80 if (usage == GPIO_USAGE) 81 gpio_array[gpio_bank(gpio)]->port_fer_clear = gpio_bit(gpio); 82 else 83 gpio_array[gpio_bank(gpio)]->port_fer_set = gpio_bit(gpio); 84 #endif 85 } 86 87 inline void portmux_setup(unsigned short per) 88 { 89 u32 pmux; 90 u16 ident = P_IDENT(per); 91 u16 function = P_FUNCT2MUX(per); 92 93 pmux = gpio_array[gpio_bank(ident)]->port_mux; 94 95 pmux &= ~(0x3 << (2 * gpio_sub_n(ident))); 96 pmux |= (function & 0x3) << (2 * gpio_sub_n(ident)); 97 98 gpio_array[gpio_bank(ident)]->port_mux = pmux; 99 } 100 101 inline u16 get_portmux(unsigned short per) 102 { 103 u32 pmux; 104 u16 ident = P_IDENT(per); 105 106 pmux = gpio_array[gpio_bank(ident)]->port_mux; 107 108 return pmux >> (2 * gpio_sub_n(ident)) & 0x3; 109 } 110 111 unsigned short get_gpio_dir(unsigned gpio) 112 { 113 return 0x01 & 114 (gpio_array[gpio_bank(gpio)]->dir_clear >> gpio_sub_n(gpio)); 115 } 116 117 /*********************************************************** 118 * 119 * FUNCTIONS: Peripheral Resource Allocation 120 * and PortMux Setup 121 * 122 * INPUTS/OUTPUTS: 123 * per Peripheral Identifier 124 * label String 125 * 126 * DESCRIPTION: Peripheral Resource Allocation and Setup API 127 **************************************************************/ 128 129 int peripheral_request(unsigned short per, const char *label) 130 { 131 unsigned short ident = P_IDENT(per); 132 133 /* 134 * Don't cares are pins with only one dedicated function 135 */ 136 137 if (per & P_DONTCARE) 138 return 0; 139 140 if (!(per & P_DEFINED)) 141 return -EINVAL; 142 143 BUG_ON(ident >= MAX_RESOURCES); 144 145 /* If a pin can be muxed as either GPIO or peripheral, make 146 * sure it is not already a GPIO pin when we request it. 147 */ 148 if (unlikely(!check_gpio(ident) && is_reserved(gpio, ident, 1))) { 149 printf("%s: Peripheral %d is already reserved as GPIO by %s!\n", 150 __func__, ident, get_label(ident)); 151 return -EBUSY; 152 } 153 154 if (unlikely(is_reserved(peri, ident, 1))) { 155 /* 156 * Pin functions like AMC address strobes my 157 * be requested and used by several drivers 158 */ 159 160 if (!((per & P_MAYSHARE) && 161 get_portmux(per) == P_FUNCT2MUX(per))) { 162 /* 163 * Allow that the identical pin function can 164 * be requested from the same driver twice 165 */ 166 167 if (cmp_label(ident, label) == 0) 168 goto anyway; 169 170 printf("%s: Peripheral %d function %d is already " 171 "reserved by %s!\n", __func__, ident, 172 P_FUNCT2MUX(per), get_label(ident)); 173 return -EBUSY; 174 } 175 } 176 177 anyway: 178 reserve(peri, ident); 179 180 portmux_setup(per); 181 port_setup(ident, PERIPHERAL_USAGE); 182 183 set_label(ident, label); 184 185 return 0; 186 } 187 188 int peripheral_request_list(const unsigned short per[], const char *label) 189 { 190 u16 cnt; 191 int ret; 192 193 for (cnt = 0; per[cnt] != 0; cnt++) { 194 ret = peripheral_request(per[cnt], label); 195 196 if (ret < 0) { 197 for (; cnt > 0; cnt--) 198 peripheral_free(per[cnt - 1]); 199 200 return ret; 201 } 202 } 203 204 return 0; 205 } 206 207 void peripheral_free(unsigned short per) 208 { 209 unsigned short ident = P_IDENT(per); 210 211 if (per & P_DONTCARE) 212 return; 213 214 if (!(per & P_DEFINED)) 215 return; 216 217 if (unlikely(!is_reserved(peri, ident, 0))) 218 return; 219 220 if (!(per & P_MAYSHARE)) 221 port_setup(ident, GPIO_USAGE); 222 223 unreserve(peri, ident); 224 225 set_label(ident, "free"); 226 } 227 228 void peripheral_free_list(const unsigned short per[]) 229 { 230 u16 cnt; 231 for (cnt = 0; per[cnt] != 0; cnt++) 232 peripheral_free(per[cnt]); 233 } 234 235 /*********************************************************** 236 * 237 * FUNCTIONS: GPIO Driver 238 * 239 * INPUTS/OUTPUTS: 240 * gpio PIO Number between 0 and MAX_GPIOS 241 * label String 242 * 243 * DESCRIPTION: GPIO Driver API 244 **************************************************************/ 245 246 int gpio_request(unsigned gpio, const char *label) 247 { 248 if (check_gpio(gpio) < 0) 249 return -EINVAL; 250 251 /* 252 * Allow that the identical GPIO can 253 * be requested from the same driver twice 254 * Do nothing and return - 255 */ 256 257 if (cmp_label(gpio, label) == 0) 258 return 0; 259 260 if (unlikely(is_reserved(gpio, gpio, 1))) { 261 printf("adi_gpio2: GPIO %d is already reserved by %s!\n", 262 gpio, get_label(gpio)); 263 return -EBUSY; 264 } 265 if (unlikely(is_reserved(peri, gpio, 1))) { 266 printf("adi_gpio2: GPIO %d is already reserved as Peripheral " 267 "by %s!\n", gpio, get_label(gpio)); 268 return -EBUSY; 269 } 270 271 reserve(gpio, gpio); 272 set_label(gpio, label); 273 274 port_setup(gpio, GPIO_USAGE); 275 276 return 0; 277 } 278 279 int gpio_free(unsigned gpio) 280 { 281 if (check_gpio(gpio) < 0) 282 return -1; 283 284 if (unlikely(!is_reserved(gpio, gpio, 0))) { 285 gpio_error(gpio); 286 return -1; 287 } 288 289 unreserve(gpio, gpio); 290 291 set_label(gpio, "free"); 292 293 return 0; 294 } 295 296 #ifdef ADI_SPECIAL_GPIO_BANKS 297 static DECLARE_RESERVED_MAP(special_gpio, gpio_bank(MAX_RESOURCES)); 298 299 int special_gpio_request(unsigned gpio, const char *label) 300 { 301 /* 302 * Allow that the identical GPIO can 303 * be requested from the same driver twice 304 * Do nothing and return - 305 */ 306 307 if (cmp_label(gpio, label) == 0) 308 return 0; 309 310 if (unlikely(is_reserved(special_gpio, gpio, 1))) { 311 printf("adi_gpio2: GPIO %d is already reserved by %s!\n", 312 gpio, get_label(gpio)); 313 return -EBUSY; 314 } 315 if (unlikely(is_reserved(peri, gpio, 1))) { 316 printf("adi_gpio2: GPIO %d is already reserved as Peripheral " 317 "by %s!\n", gpio, get_label(gpio)); 318 319 return -EBUSY; 320 } 321 322 reserve(special_gpio, gpio); 323 reserve(peri, gpio); 324 325 set_label(gpio, label); 326 port_setup(gpio, GPIO_USAGE); 327 328 return 0; 329 } 330 331 void special_gpio_free(unsigned gpio) 332 { 333 if (unlikely(!is_reserved(special_gpio, gpio, 0))) { 334 gpio_error(gpio); 335 return; 336 } 337 338 unreserve(special_gpio, gpio); 339 unreserve(peri, gpio); 340 set_label(gpio, "free"); 341 } 342 #endif 343 344 static inline void __gpio_direction_input(unsigned gpio) 345 { 346 gpio_array[gpio_bank(gpio)]->dir_clear = gpio_bit(gpio); 347 #if defined(CONFIG_BF54x) 348 gpio_array[gpio_bank(gpio)]->inen |= gpio_bit(gpio); 349 #else 350 gpio_array[gpio_bank(gpio)]->inen_set = gpio_bit(gpio); 351 #endif 352 } 353 354 int gpio_direction_input(unsigned gpio) 355 { 356 unsigned long flags; 357 358 if (!is_reserved(gpio, gpio, 0)) { 359 gpio_error(gpio); 360 return -EINVAL; 361 } 362 363 local_irq_save(flags); 364 __gpio_direction_input(gpio); 365 local_irq_restore(flags); 366 367 return 0; 368 } 369 370 int gpio_set_value(unsigned gpio, int arg) 371 { 372 if (arg) 373 gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio); 374 else 375 gpio_array[gpio_bank(gpio)]->data_clear = gpio_bit(gpio); 376 377 return 0; 378 } 379 380 int gpio_direction_output(unsigned gpio, int value) 381 { 382 unsigned long flags; 383 384 if (!is_reserved(gpio, gpio, 0)) { 385 gpio_error(gpio); 386 return -EINVAL; 387 } 388 389 local_irq_save(flags); 390 391 #if defined(CONFIG_BF54x) 392 gpio_array[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio); 393 #else 394 gpio_array[gpio_bank(gpio)]->inen_clear = gpio_bit(gpio); 395 #endif 396 gpio_set_value(gpio, value); 397 gpio_array[gpio_bank(gpio)]->dir_set = gpio_bit(gpio); 398 399 local_irq_restore(flags); 400 401 return 0; 402 } 403 404 int gpio_get_value(unsigned gpio) 405 { 406 return 1 & (gpio_array[gpio_bank(gpio)]->data >> gpio_sub_n(gpio)); 407 } 408 409 void gpio_labels(void) 410 { 411 int c, gpio; 412 413 for (c = 0; c < MAX_RESOURCES; c++) { 414 gpio = is_reserved(gpio, c, 1); 415 if (!check_gpio(c) && gpio) 416 printf("GPIO_%d:\t%s\tGPIO %s\n", c, get_label(c), 417 get_gpio_dir(c) ? "OUTPUT" : "INPUT"); 418 else if (is_reserved(peri, c, 1)) 419 printf("GPIO_%d:\t%s\tPeripheral\n", c, get_label(c)); 420 else 421 continue; 422 } 423 } 424