xilinx_gpio.c 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364
  1. /*
  2. * Copyright (c) 2013 Xilinx, Michal Simek
  3. *
  4. * See file CREDITS for list of people who contributed to this
  5. * project.
  6. *
  7. * This program is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License as
  9. * published by the Free Software Foundation; either version 2 of
  10. * the License, or (at your option) any later version.
  11. *
  12. * This program is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20. * MA 02111-1307 USA
  21. */
  22. #include <common.h>
  23. #include <errno.h>
  24. #include <malloc.h>
  25. #include <linux/list.h>
  26. #include <asm/io.h>
  27. #include <asm/gpio.h>
  28. static LIST_HEAD(gpio_list);
  29. enum gpio_direction {
  30. GPIO_DIRECTION_OUT = 0,
  31. GPIO_DIRECTION_IN = 1,
  32. };
  33. /* Gpio simple map */
  34. struct gpio_regs {
  35. u32 gpiodata;
  36. u32 gpiodir;
  37. };
  38. #define GPIO_NAME_SIZE 10
  39. struct gpio_names {
  40. char name[GPIO_NAME_SIZE];
  41. };
  42. /* Initialized, rxbd_current, rx_first_buf must be 0 after init */
  43. struct xilinx_gpio_priv {
  44. struct gpio_regs *regs;
  45. u32 gpio_min;
  46. u32 gpio_max;
  47. u32 gpiodata_store;
  48. char name[GPIO_NAME_SIZE];
  49. struct list_head list;
  50. struct gpio_names *gpio_name;
  51. };
  52. /* Store number of allocated gpio pins */
  53. static u32 xilinx_gpio_max;
  54. /* Get associated gpio controller */
  55. static struct xilinx_gpio_priv *gpio_get_controller(unsigned gpio)
  56. {
  57. struct list_head *entry;
  58. struct xilinx_gpio_priv *priv = NULL;
  59. list_for_each(entry, &gpio_list) {
  60. priv = list_entry(entry, struct xilinx_gpio_priv, list);
  61. if (gpio >= priv->gpio_min && gpio <= priv->gpio_max) {
  62. debug("%s: reg: %x, min-max: %d-%d\n", __func__,
  63. (u32)priv->regs, priv->gpio_min, priv->gpio_max);
  64. return priv;
  65. }
  66. }
  67. puts("!!!Can't get gpio controller!!!\n");
  68. return NULL;
  69. }
  70. /* Get gpio pin name if used/setup */
  71. static char *get_name(unsigned gpio)
  72. {
  73. u32 gpio_priv;
  74. struct xilinx_gpio_priv *priv;
  75. debug("%s\n", __func__);
  76. priv = gpio_get_controller(gpio);
  77. if (priv) {
  78. gpio_priv = gpio - priv->gpio_min;
  79. return *priv->gpio_name[gpio_priv].name ?
  80. priv->gpio_name[gpio_priv].name : "UNKNOWN";
  81. }
  82. return "UNKNOWN";
  83. }
  84. /* Get output value */
  85. static int gpio_get_output_value(unsigned gpio)
  86. {
  87. u32 val, gpio_priv;
  88. struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
  89. if (priv) {
  90. gpio_priv = gpio - priv->gpio_min;
  91. val = !!(priv->gpiodata_store & (1 << gpio_priv));
  92. debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
  93. (u32)priv->regs, gpio_priv, val);
  94. return val;
  95. }
  96. return -1;
  97. }
  98. /* Get input value */
  99. static int gpio_get_input_value(unsigned gpio)
  100. {
  101. u32 val, gpio_priv;
  102. struct gpio_regs *regs;
  103. struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
  104. if (priv) {
  105. regs = priv->regs;
  106. gpio_priv = gpio - priv->gpio_min;
  107. val = readl(&regs->gpiodata);
  108. val = !!(val & (1 << gpio_priv));
  109. debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
  110. (u32)priv->regs, gpio_priv, val);
  111. return val;
  112. }
  113. return -1;
  114. }
  115. /* Set gpio direction */
  116. static int gpio_set_direction(unsigned gpio, enum gpio_direction direction)
  117. {
  118. u32 val, gpio_priv;
  119. struct gpio_regs *regs;
  120. struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
  121. if (priv) {
  122. regs = priv->regs;
  123. val = readl(&regs->gpiodir);
  124. gpio_priv = gpio - priv->gpio_min;
  125. if (direction == GPIO_DIRECTION_OUT)
  126. val &= ~(1 << gpio_priv);
  127. else
  128. val |= 1 << gpio_priv;
  129. writel(val, &regs->gpiodir);
  130. debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
  131. (u32)priv->regs, gpio_priv, val);
  132. return 0;
  133. }
  134. return -1;
  135. }
  136. /* Get gpio direction */
  137. static int gpio_get_direction(unsigned gpio)
  138. {
  139. u32 val, gpio_priv;
  140. struct gpio_regs *regs;
  141. struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
  142. if (priv) {
  143. regs = priv->regs;
  144. gpio_priv = gpio - priv->gpio_min;
  145. val = readl(&regs->gpiodir);
  146. val = !!(val & (1 << gpio_priv));
  147. debug("%s: reg: %x, gpio_no: %d, dir: %d\n", __func__,
  148. (u32)priv->regs, gpio_priv, val);
  149. return val;
  150. }
  151. return -1;
  152. }
  153. /*
  154. * Get input value
  155. * for example gpio setup to output only can't get input value
  156. * which is breaking gpio toggle command
  157. */
  158. int gpio_get_value(unsigned gpio)
  159. {
  160. u32 val;
  161. if (gpio_get_direction(gpio) == GPIO_DIRECTION_OUT)
  162. val = gpio_get_output_value(gpio);
  163. else
  164. val = gpio_get_input_value(gpio);
  165. return val;
  166. }
  167. /* Set output value */
  168. static int gpio_set_output_value(unsigned gpio, int value)
  169. {
  170. u32 val, gpio_priv;
  171. struct gpio_regs *regs;
  172. struct xilinx_gpio_priv *priv = gpio_get_controller(gpio);
  173. if (priv) {
  174. regs = priv->regs;
  175. gpio_priv = gpio - priv->gpio_min;
  176. val = priv->gpiodata_store;
  177. if (value)
  178. val |= 1 << gpio_priv;
  179. else
  180. val &= ~(1 << gpio_priv);
  181. writel(val, &regs->gpiodata);
  182. debug("%s: reg: %x, gpio_no: %d, output_val: %d\n", __func__,
  183. (u32)priv->regs, gpio_priv, val);
  184. priv->gpiodata_store = val;
  185. return 0;
  186. }
  187. return -1;
  188. }
  189. int gpio_set_value(unsigned gpio, int value)
  190. {
  191. if (gpio_get_direction(gpio) == GPIO_DIRECTION_OUT)
  192. return gpio_set_output_value(gpio, value);
  193. return -1;
  194. }
  195. /* Set GPIO as input */
  196. int gpio_direction_input(unsigned gpio)
  197. {
  198. debug("%s\n", __func__);
  199. return gpio_set_direction(gpio, GPIO_DIRECTION_IN);
  200. }
  201. /* Setup GPIO as output and set output value */
  202. int gpio_direction_output(unsigned gpio, int value)
  203. {
  204. int ret = gpio_set_direction(gpio, GPIO_DIRECTION_OUT);
  205. debug("%s\n", __func__);
  206. if (ret < 0)
  207. return ret;
  208. return gpio_set_output_value(gpio, value);
  209. }
  210. /* Show gpio status */
  211. void gpio_info(void)
  212. {
  213. unsigned gpio;
  214. struct list_head *entry;
  215. struct xilinx_gpio_priv *priv = NULL;
  216. list_for_each(entry, &gpio_list) {
  217. priv = list_entry(entry, struct xilinx_gpio_priv, list);
  218. printf("\n%s: %s/%x (%d-%d)\n", __func__, priv->name,
  219. (u32)priv->regs, priv->gpio_min, priv->gpio_max);
  220. for (gpio = priv->gpio_min; gpio <= priv->gpio_max; gpio++) {
  221. printf("GPIO_%d:\t%s is an ", gpio, get_name(gpio));
  222. if (gpio_get_direction(gpio) == GPIO_DIRECTION_OUT)
  223. printf("OUTPUT value = %d\n",
  224. gpio_get_output_value(gpio));
  225. else
  226. printf("INPUT value = %d\n",
  227. gpio_get_input_value(gpio));
  228. }
  229. }
  230. }
  231. int gpio_request(unsigned gpio, const char *label)
  232. {
  233. u32 gpio_priv;
  234. struct xilinx_gpio_priv *priv;
  235. if (gpio >= xilinx_gpio_max)
  236. return -EINVAL;
  237. priv = gpio_get_controller(gpio);
  238. if (priv) {
  239. gpio_priv = gpio - priv->gpio_min;
  240. if (label != NULL) {
  241. strncpy(priv->gpio_name[gpio_priv].name, label,
  242. GPIO_NAME_SIZE);
  243. priv->gpio_name[gpio_priv].name[GPIO_NAME_SIZE - 1] =
  244. '\0';
  245. }
  246. return 0;
  247. }
  248. return -1;
  249. }
  250. int gpio_free(unsigned gpio)
  251. {
  252. u32 gpio_priv;
  253. struct xilinx_gpio_priv *priv;
  254. if (gpio >= xilinx_gpio_max)
  255. return -EINVAL;
  256. priv = gpio_get_controller(gpio);
  257. if (priv) {
  258. gpio_priv = gpio - priv->gpio_min;
  259. priv->gpio_name[gpio_priv].name[0] = '\0';
  260. /* Do nothing here */
  261. return 0;
  262. }
  263. return -1;
  264. }
  265. int gpio_alloc(u32 baseaddr, const char *name, u32 gpio_no)
  266. {
  267. struct xilinx_gpio_priv *priv;
  268. priv = calloc(1, sizeof(struct xilinx_gpio_priv));
  269. /* Setup gpio name */
  270. if (name != NULL) {
  271. strncpy(priv->name, name, GPIO_NAME_SIZE);
  272. priv->name[GPIO_NAME_SIZE - 1] = '\0';
  273. }
  274. priv->regs = (struct gpio_regs *)baseaddr;
  275. priv->gpio_min = xilinx_gpio_max;
  276. xilinx_gpio_max = priv->gpio_min + gpio_no;
  277. priv->gpio_max = xilinx_gpio_max - 1;
  278. priv->gpio_name = calloc(gpio_no, sizeof(struct gpio_names));
  279. INIT_LIST_HEAD(&priv->list);
  280. list_add_tail(&priv->list, &gpio_list);
  281. printf("%s: Add %s (%d-%d)\n", __func__, name,
  282. priv->gpio_min, priv->gpio_max);
  283. /* Return the first gpio allocated for this device */
  284. return priv->gpio_min;
  285. }
  286. /* Dual channel gpio is one IP with two independent channels */
  287. int gpio_alloc_dual(u32 baseaddr, const char *name, u32 gpio_no0, u32 gpio_no1)
  288. {
  289. int ret;
  290. ret = gpio_alloc(baseaddr, name, gpio_no0);
  291. gpio_alloc(baseaddr + 8, strcat((char *)name, "_1"), gpio_no1);
  292. /* Return the first gpio allocated for this device */
  293. return ret;
  294. }