target/linux/atheros/files/include/asm-mips/mach-atheros/gpio.h

   1 #ifndef _ATHEROS_GPIO_H_
   2 #define _ATHEROS_GPIO_H_
   3
   4 #include "ar531x.h"
   5
   6 /* Common AR531X global variables */
   7 /* extern u32 ar531x_gpio_intr_Mask; */
   8
   9 /* AR5312 exported routines */
  10 #ifdef CONFIG_ATHEROS_AR5312
  11 asmlinkage void ar5312_gpio_irq_dispatch(void);
  12 #endif
  13
  14 /* AR5315 exported routines */
  15 #ifdef CONFIG_ATHEROS_AR5315
  16 asmlinkage void ar5315_gpio_irq_dispatch(void);
  17 #endif
  18
  19 /*
  20  * Wrappers for the generic GPIO layer
  21  */
  22
  23 /* Sets a gpio to input, or returns ENXIO for non-existent gpio */
  24 static inline int gpio_direction_input(unsigned gpio) {
  25         DO_AR5312(      if (gpio > AR531X_NUM_GPIO) {                   \
  26                                 return -ENXIO;                          \
  27                         } else {                                        \
  28                                 sysRegWrite(AR531X_GPIO_CR,             \
  29                                         ( sysRegRead(AR531X_GPIO_CR) &  \
  30                                           ~(AR531X_GPIO_CR_M(gpio)) ) | \
  31                                           AR531X_GPIO_CR_I(gpio) );     \
  32                                 return 0;                               \
  33                         }                                               \
  34         )
  35         DO_AR5315(      if (gpio > AR5315_NUM_GPIO) {                   \
  36                                 return -ENXIO;                          \
  37                         } else {                                        \
  38                                 sysRegWrite(AR5315_GPIO_CR,             \
  39                                         ( sysRegRead(AR5315_GPIO_CR) &  \
  40                                           ~(AR5315_GPIO_CR_M(gpio)) ) | \
  41                                           AR5315_GPIO_CR_I(gpio) );     \
  42                                 return 0;                               \
  43                         }                                               \
  44         )
  45 }
  46
  47 /* Sets a gpio to output with value, or returns ENXIO for non-existent gpio */
  48 static inline int gpio_direction_output(unsigned gpio, int value) {
  49         DO_AR5312(      if (gpio > AR531X_NUM_GPIO) {                   \
  50                                 return -ENXIO;                          \
  51                         } else {                                        \
  52                                 sysRegWrite(AR531X_GPIO_DO,             \
  53                                         ( (sysRegRead(AR531X_GPIO_DO) & \
  54                                           ~(1 << gpio) ) |              \
  55                                           ((value!=0) << gpio)) );      \
  56                                 sysRegWrite(AR531X_GPIO_CR,             \
  57                                         sysRegRead(AR531X_GPIO_CR) |    \
  58                                         AR531X_GPIO_CR_O(gpio) );       \
  59                                 return 0;                               \
  60                         }                                               \
  61         )
  62         DO_AR5315(      if (gpio > AR5315_NUM_GPIO) {                   \
  63                                 return -ENXIO;                          \
  64                         } else {                                        \
  65                                 sysRegWrite(AR5315_GPIO_DO,             \
  66                                         ( (sysRegRead(AR5315_GPIO_DO) & \
  67                                           ~(1 << gpio)) |               \
  68                                           ((value!=0) << gpio)) );      \
  69                                 sysRegWrite(AR5315_GPIO_CR,             \
  70                                         sysRegRead(AR5315_GPIO_CR) |    \
  71                                         AR5315_GPIO_CR_O(gpio) );       \
  72                                 return 0;                               \
  73                         }                                               \
  74         )
  75 }
  76
  77 /* Reads the gpio pin.  Unchecked function */
  78 static inline int gpio_get_value(unsigned gpio) {
  79         DO_AR5312(return (sysRegRead(AR531X_GPIO_DI) & (1 << gpio));)
  80         DO_AR5315(return (sysRegRead(AR5315_GPIO_DI) & (1 << gpio));)
  81 }
  82
  83 /* Writes to the gpio pin.  Unchecked function */
  84 static inline void gpio_set_value(unsigned gpio, int value) {
  85         DO_AR5312(      sysRegWrite(AR531X_GPIO_DO,     \
  86                         ( (sysRegRead(AR531X_GPIO_DO) & \
  87                           ~(1 << gpio)) |               \
  88                           ((value!=0) << gpio)) );      \
  89         )
  90         DO_AR5315(      sysRegWrite(AR5315_GPIO_DO,     \
  91                         ( (sysRegRead(AR5315_GPIO_DO) & \
  92                           ~(1 << gpio)) |               \
  93                           ((value!=0) << gpio)) );      \
  94         )
  95 }
  96
  97 static inline int gpio_request(unsigned gpio, const char *label) {
  98         return 0;
  99 }
 100
 101 static inline void gpio_free(unsigned gpio) {
 102 }
 103
 104 /* Returns IRQ to attach for gpio.  Unchecked function */
 105 static inline int gpio_to_irq(unsigned gpio) {
 106         return AR531X_GPIO_IRQ(gpio);
 107 }
 108
 109 /* Returns gpio for IRQ attached.  Unchecked function */
 110 static inline int irq_to_gpio(unsigned irq) {
 111         return (irq - (AR531X_GPIO_IRQ(0)));
 112 }
 113
 114 /* #include <asm-generic/gpio.h> */ /* cansleep wrappers */
 115 /* platforms that don't directly support access to GPIOs through I2C, SPI,
 116  * or other blocking infrastructure can use these wrappers.
 117  */
 118
 119 static inline int gpio_cansleep(unsigned gpio) {
 120         return 0;
 121 }
 122
 123 static inline int gpio_get_value_cansleep(unsigned gpio) {
 124         might_sleep();
 125         return gpio_get_value(gpio);
 126 }
 127
 128 static inline void gpio_set_value_cansleep(unsigned gpio, int value) {
 129         might_sleep();
 130         gpio_set_value(gpio, value);
 131 }
 132
 133 #endif
 134