da8xx_gpio.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * GPIO driver for TI DaVinci DA8xx SOCs.
  4. *
  5. * (C) Copyright 2011 Guralp Systems Ltd.
  6. * Laurence Withers <lwithers@guralp.com>
  7. */
  8. #include <common.h>
  9. #include <dm.h>
  10. #include <fdtdec.h>
  11. #include <malloc.h>
  12. #include <asm/io.h>
  13. #include <asm/gpio.h>
  14. #include <dt-bindings/gpio/gpio.h>
  15. #include "da8xx_gpio.h"
  16. #if !CONFIG_IS_ENABLED(DM_GPIO)
  17. #include <asm/arch/hardware.h>
  18. #include <asm/arch/davinci_misc.h>
  19. static struct gpio_registry {
  20. int is_registered;
  21. char name[GPIO_NAME_SIZE];
  22. } gpio_registry[MAX_NUM_GPIOS];
  23. #if defined(CONFIG_SOC_DA8XX)
  24. #define pinmux(x) (&davinci_syscfg_regs->pinmux[x])
  25. #if defined(CONFIG_SOC_DA8XX) && !defined(CONFIG_SOC_DA850)
  26. static const struct pinmux_config gpio_pinmux[] = {
  27. { pinmux(13), 8, 6 }, /* GP0[0] */
  28. { pinmux(13), 8, 7 },
  29. { pinmux(14), 8, 0 },
  30. { pinmux(14), 8, 1 },
  31. { pinmux(14), 8, 2 },
  32. { pinmux(14), 8, 3 },
  33. { pinmux(14), 8, 4 },
  34. { pinmux(14), 8, 5 },
  35. { pinmux(14), 8, 6 },
  36. { pinmux(14), 8, 7 },
  37. { pinmux(15), 8, 0 },
  38. { pinmux(15), 8, 1 },
  39. { pinmux(15), 8, 2 },
  40. { pinmux(15), 8, 3 },
  41. { pinmux(15), 8, 4 },
  42. { pinmux(15), 8, 5 },
  43. { pinmux(15), 8, 6 }, /* GP1[0] */
  44. { pinmux(15), 8, 7 },
  45. { pinmux(16), 8, 0 },
  46. { pinmux(16), 8, 1 },
  47. { pinmux(16), 8, 2 },
  48. { pinmux(16), 8, 3 },
  49. { pinmux(16), 8, 4 },
  50. { pinmux(16), 8, 5 },
  51. { pinmux(16), 8, 6 },
  52. { pinmux(16), 8, 7 },
  53. { pinmux(17), 8, 0 },
  54. { pinmux(17), 8, 1 },
  55. { pinmux(17), 8, 2 },
  56. { pinmux(17), 8, 3 },
  57. { pinmux(17), 8, 4 },
  58. { pinmux(17), 8, 5 },
  59. { pinmux(17), 8, 6 }, /* GP2[0] */
  60. { pinmux(17), 8, 7 },
  61. { pinmux(18), 8, 0 },
  62. { pinmux(18), 8, 1 },
  63. { pinmux(18), 8, 2 },
  64. { pinmux(18), 8, 3 },
  65. { pinmux(18), 8, 4 },
  66. { pinmux(18), 8, 5 },
  67. { pinmux(18), 8, 6 },
  68. { pinmux(18), 8, 7 },
  69. { pinmux(19), 8, 0 },
  70. { pinmux(9), 8, 2 },
  71. { pinmux(9), 8, 3 },
  72. { pinmux(9), 8, 4 },
  73. { pinmux(9), 8, 5 },
  74. { pinmux(9), 8, 6 },
  75. { pinmux(10), 8, 1 }, /* GP3[0] */
  76. { pinmux(10), 8, 2 },
  77. { pinmux(10), 8, 3 },
  78. { pinmux(10), 8, 4 },
  79. { pinmux(10), 8, 5 },
  80. { pinmux(10), 8, 6 },
  81. { pinmux(10), 8, 7 },
  82. { pinmux(11), 8, 0 },
  83. { pinmux(11), 8, 1 },
  84. { pinmux(11), 8, 2 },
  85. { pinmux(11), 8, 3 },
  86. { pinmux(11), 8, 4 },
  87. { pinmux(9), 8, 7 },
  88. { pinmux(2), 8, 6 },
  89. { pinmux(11), 8, 5 },
  90. { pinmux(11), 8, 6 },
  91. { pinmux(12), 8, 4 }, /* GP4[0] */
  92. { pinmux(12), 8, 5 },
  93. { pinmux(12), 8, 6 },
  94. { pinmux(12), 8, 7 },
  95. { pinmux(13), 8, 0 },
  96. { pinmux(13), 8, 1 },
  97. { pinmux(13), 8, 2 },
  98. { pinmux(13), 8, 3 },
  99. { pinmux(13), 8, 4 },
  100. { pinmux(13), 8, 5 },
  101. { pinmux(11), 8, 7 },
  102. { pinmux(12), 8, 0 },
  103. { pinmux(12), 8, 1 },
  104. { pinmux(12), 8, 2 },
  105. { pinmux(12), 8, 3 },
  106. { pinmux(9), 8, 1 },
  107. { pinmux(7), 8, 3 }, /* GP5[0] */
  108. { pinmux(7), 8, 4 },
  109. { pinmux(7), 8, 5 },
  110. { pinmux(7), 8, 6 },
  111. { pinmux(7), 8, 7 },
  112. { pinmux(8), 8, 0 },
  113. { pinmux(8), 8, 1 },
  114. { pinmux(8), 8, 2 },
  115. { pinmux(8), 8, 3 },
  116. { pinmux(8), 8, 4 },
  117. { pinmux(8), 8, 5 },
  118. { pinmux(8), 8, 6 },
  119. { pinmux(8), 8, 7 },
  120. { pinmux(9), 8, 0 },
  121. { pinmux(7), 8, 1 },
  122. { pinmux(7), 8, 2 },
  123. { pinmux(5), 8, 1 }, /* GP6[0] */
  124. { pinmux(5), 8, 2 },
  125. { pinmux(5), 8, 3 },
  126. { pinmux(5), 8, 4 },
  127. { pinmux(5), 8, 5 },
  128. { pinmux(5), 8, 6 },
  129. { pinmux(5), 8, 7 },
  130. { pinmux(6), 8, 0 },
  131. { pinmux(6), 8, 1 },
  132. { pinmux(6), 8, 2 },
  133. { pinmux(6), 8, 3 },
  134. { pinmux(6), 8, 4 },
  135. { pinmux(6), 8, 5 },
  136. { pinmux(6), 8, 6 },
  137. { pinmux(6), 8, 7 },
  138. { pinmux(7), 8, 0 },
  139. { pinmux(1), 8, 0 }, /* GP7[0] */
  140. { pinmux(1), 8, 1 },
  141. { pinmux(1), 8, 2 },
  142. { pinmux(1), 8, 3 },
  143. { pinmux(1), 8, 4 },
  144. { pinmux(1), 8, 5 },
  145. { pinmux(1), 8, 6 },
  146. { pinmux(1), 8, 7 },
  147. { pinmux(2), 8, 0 },
  148. { pinmux(2), 8, 1 },
  149. { pinmux(2), 8, 2 },
  150. { pinmux(2), 8, 3 },
  151. { pinmux(2), 8, 4 },
  152. { pinmux(2), 8, 5 },
  153. { pinmux(0), 1, 0 },
  154. { pinmux(0), 1, 1 },
  155. };
  156. #else /* CONFIG_SOC_DA8XX && CONFIG_SOC_DA850 */
  157. static const struct pinmux_config gpio_pinmux[] = {
  158. { pinmux(1), 8, 7 }, /* GP0[0] */
  159. { pinmux(1), 8, 6 },
  160. { pinmux(1), 8, 5 },
  161. { pinmux(1), 8, 4 },
  162. { pinmux(1), 8, 3 },
  163. { pinmux(1), 8, 2 },
  164. { pinmux(1), 8, 1 },
  165. { pinmux(1), 8, 0 },
  166. { pinmux(0), 8, 7 },
  167. { pinmux(0), 8, 6 },
  168. { pinmux(0), 8, 5 },
  169. { pinmux(0), 8, 4 },
  170. { pinmux(0), 8, 3 },
  171. { pinmux(0), 8, 2 },
  172. { pinmux(0), 8, 1 },
  173. { pinmux(0), 8, 0 },
  174. { pinmux(4), 8, 7 }, /* GP1[0] */
  175. { pinmux(4), 8, 6 },
  176. { pinmux(4), 8, 5 },
  177. { pinmux(4), 8, 4 },
  178. { pinmux(4), 8, 3 },
  179. { pinmux(4), 8, 2 },
  180. { pinmux(4), 4, 1 },
  181. { pinmux(4), 4, 0 },
  182. { pinmux(3), 4, 0 },
  183. { pinmux(2), 4, 6 },
  184. { pinmux(2), 4, 5 },
  185. { pinmux(2), 4, 4 },
  186. { pinmux(2), 4, 3 },
  187. { pinmux(2), 4, 2 },
  188. { pinmux(2), 4, 1 },
  189. { pinmux(2), 8, 0 },
  190. { pinmux(6), 8, 7 }, /* GP2[0] */
  191. { pinmux(6), 8, 6 },
  192. { pinmux(6), 8, 5 },
  193. { pinmux(6), 8, 4 },
  194. { pinmux(6), 8, 3 },
  195. { pinmux(6), 8, 2 },
  196. { pinmux(6), 8, 1 },
  197. { pinmux(6), 8, 0 },
  198. { pinmux(5), 8, 7 },
  199. { pinmux(5), 8, 6 },
  200. { pinmux(5), 8, 5 },
  201. { pinmux(5), 8, 4 },
  202. { pinmux(5), 8, 3 },
  203. { pinmux(5), 8, 2 },
  204. { pinmux(5), 8, 1 },
  205. { pinmux(5), 8, 0 },
  206. { pinmux(8), 8, 7 }, /* GP3[0] */
  207. { pinmux(8), 8, 6 },
  208. { pinmux(8), 8, 5 },
  209. { pinmux(8), 8, 4 },
  210. { pinmux(8), 8, 3 },
  211. { pinmux(8), 8, 2 },
  212. { pinmux(8), 8, 1 },
  213. { pinmux(8), 8, 0 },
  214. { pinmux(7), 8, 7 },
  215. { pinmux(7), 8, 6 },
  216. { pinmux(7), 8, 5 },
  217. { pinmux(7), 8, 4 },
  218. { pinmux(7), 8, 3 },
  219. { pinmux(7), 8, 2 },
  220. { pinmux(7), 8, 1 },
  221. { pinmux(7), 8, 0 },
  222. { pinmux(10), 8, 7 }, /* GP4[0] */
  223. { pinmux(10), 8, 6 },
  224. { pinmux(10), 8, 5 },
  225. { pinmux(10), 8, 4 },
  226. { pinmux(10), 8, 3 },
  227. { pinmux(10), 8, 2 },
  228. { pinmux(10), 8, 1 },
  229. { pinmux(10), 8, 0 },
  230. { pinmux(9), 8, 7 },
  231. { pinmux(9), 8, 6 },
  232. { pinmux(9), 8, 5 },
  233. { pinmux(9), 8, 4 },
  234. { pinmux(9), 8, 3 },
  235. { pinmux(9), 8, 2 },
  236. { pinmux(9), 8, 1 },
  237. { pinmux(9), 8, 0 },
  238. { pinmux(12), 8, 7 }, /* GP5[0] */
  239. { pinmux(12), 8, 6 },
  240. { pinmux(12), 8, 5 },
  241. { pinmux(12), 8, 4 },
  242. { pinmux(12), 8, 3 },
  243. { pinmux(12), 8, 2 },
  244. { pinmux(12), 8, 1 },
  245. { pinmux(12), 8, 0 },
  246. { pinmux(11), 8, 7 },
  247. { pinmux(11), 8, 6 },
  248. { pinmux(11), 8, 5 },
  249. { pinmux(11), 8, 4 },
  250. { pinmux(11), 8, 3 },
  251. { pinmux(11), 8, 2 },
  252. { pinmux(11), 8, 1 },
  253. { pinmux(11), 8, 0 },
  254. { pinmux(19), 8, 6 }, /* GP6[0] */
  255. { pinmux(19), 8, 5 },
  256. { pinmux(19), 8, 4 },
  257. { pinmux(19), 8, 3 },
  258. { pinmux(19), 8, 2 },
  259. { pinmux(16), 8, 1 },
  260. { pinmux(14), 8, 1 },
  261. { pinmux(14), 8, 0 },
  262. { pinmux(13), 8, 7 },
  263. { pinmux(13), 8, 6 },
  264. { pinmux(13), 8, 5 },
  265. { pinmux(13), 8, 4 },
  266. { pinmux(13), 8, 3 },
  267. { pinmux(13), 8, 2 },
  268. { pinmux(13), 8, 1 },
  269. { pinmux(13), 8, 0 },
  270. { pinmux(18), 8, 1 }, /* GP7[0] */
  271. { pinmux(18), 8, 0 },
  272. { pinmux(17), 8, 7 },
  273. { pinmux(17), 8, 6 },
  274. { pinmux(17), 8, 5 },
  275. { pinmux(17), 8, 4 },
  276. { pinmux(17), 8, 3 },
  277. { pinmux(17), 8, 2 },
  278. { pinmux(17), 8, 1 },
  279. { pinmux(17), 8, 0 },
  280. { pinmux(16), 8, 7 },
  281. { pinmux(16), 8, 6 },
  282. { pinmux(16), 8, 5 },
  283. { pinmux(16), 8, 4 },
  284. { pinmux(16), 8, 3 },
  285. { pinmux(16), 8, 2 },
  286. { pinmux(19), 8, 0 }, /* GP8[0] */
  287. { pinmux(3), 4, 7 },
  288. { pinmux(3), 4, 6 },
  289. { pinmux(3), 4, 5 },
  290. { pinmux(3), 4, 4 },
  291. { pinmux(3), 4, 3 },
  292. { pinmux(3), 4, 2 },
  293. { pinmux(2), 4, 7 },
  294. { pinmux(19), 8, 1 },
  295. { pinmux(19), 8, 0 },
  296. { pinmux(18), 8, 7 },
  297. { pinmux(18), 8, 6 },
  298. { pinmux(18), 8, 5 },
  299. { pinmux(18), 8, 4 },
  300. { pinmux(18), 8, 3 },
  301. { pinmux(18), 8, 2 },
  302. };
  303. #endif /* CONFIG_SOC_DA8XX && !CONFIG_SOC_DA850 */
  304. #else /* !CONFIG_SOC_DA8XX */
  305. #define davinci_configure_pin_mux(a, b)
  306. #endif /* CONFIG_SOC_DA8XX */
  307. int gpio_request(unsigned int gpio, const char *label)
  308. {
  309. if (gpio >= MAX_NUM_GPIOS)
  310. return -1;
  311. if (gpio_registry[gpio].is_registered)
  312. return -1;
  313. gpio_registry[gpio].is_registered = 1;
  314. strncpy(gpio_registry[gpio].name, label, GPIO_NAME_SIZE);
  315. gpio_registry[gpio].name[GPIO_NAME_SIZE - 1] = 0;
  316. davinci_configure_pin_mux(&gpio_pinmux[gpio], 1);
  317. return 0;
  318. }
  319. int gpio_free(unsigned int gpio)
  320. {
  321. if (gpio >= MAX_NUM_GPIOS)
  322. return -1;
  323. if (!gpio_registry[gpio].is_registered)
  324. return -1;
  325. gpio_registry[gpio].is_registered = 0;
  326. gpio_registry[gpio].name[0] = '\0';
  327. /* Do not configure as input or change pin mux here */
  328. return 0;
  329. }
  330. #endif
  331. static int _gpio_direction_input(struct davinci_gpio *bank, unsigned int gpio)
  332. {
  333. setbits_le32(&bank->dir, 1U << GPIO_BIT(gpio));
  334. return 0;
  335. }
  336. static int _gpio_get_value(struct davinci_gpio *bank, unsigned int gpio)
  337. {
  338. unsigned int ip;
  339. ip = in_le32(&bank->in_data) & (1U << GPIO_BIT(gpio));
  340. return ip ? 1 : 0;
  341. }
  342. static int _gpio_set_value(struct davinci_gpio *bank, unsigned int gpio, int value)
  343. {
  344. if (value)
  345. bank->set_data = 1U << GPIO_BIT(gpio);
  346. else
  347. bank->clr_data = 1U << GPIO_BIT(gpio);
  348. return 0;
  349. }
  350. static int _gpio_get_dir(struct davinci_gpio *bank, unsigned int gpio)
  351. {
  352. return in_le32(&bank->dir) & (1U << GPIO_BIT(gpio));
  353. }
  354. static int _gpio_direction_output(struct davinci_gpio *bank, unsigned int gpio,
  355. int value)
  356. {
  357. clrbits_le32(&bank->dir, 1U << GPIO_BIT(gpio));
  358. _gpio_set_value(bank, gpio, value);
  359. return 0;
  360. }
  361. #if !CONFIG_IS_ENABLED(DM_GPIO)
  362. void gpio_info(void)
  363. {
  364. unsigned int gpio, dir, val;
  365. struct davinci_gpio *bank;
  366. for (gpio = 0; gpio < MAX_NUM_GPIOS; ++gpio) {
  367. bank = GPIO_BANK(gpio);
  368. dir = _gpio_get_dir(bank, gpio);
  369. val = gpio_get_value(gpio);
  370. printf("% 4d: %s: %d [%c] %s\n",
  371. gpio, dir ? " in" : "out", val,
  372. gpio_registry[gpio].is_registered ? 'x' : ' ',
  373. gpio_registry[gpio].name);
  374. }
  375. }
  376. int gpio_direction_input(unsigned int gpio)
  377. {
  378. struct davinci_gpio *bank;
  379. bank = GPIO_BANK(gpio);
  380. return _gpio_direction_input(bank, gpio);
  381. }
  382. int gpio_direction_output(unsigned int gpio, int value)
  383. {
  384. struct davinci_gpio *bank;
  385. bank = GPIO_BANK(gpio);
  386. return _gpio_direction_output(bank, gpio, value);
  387. }
  388. int gpio_get_value(unsigned int gpio)
  389. {
  390. struct davinci_gpio *bank;
  391. bank = GPIO_BANK(gpio);
  392. return _gpio_get_value(bank, gpio);
  393. }
  394. int gpio_set_value(unsigned int gpio, int value)
  395. {
  396. struct davinci_gpio *bank;
  397. bank = GPIO_BANK(gpio);
  398. return _gpio_set_value(bank, gpio, value);
  399. }
  400. #else /* DM_GPIO */
  401. static struct davinci_gpio *davinci_get_gpio_bank(struct udevice *dev, unsigned int offset)
  402. {
  403. struct davinci_gpio_bank *bank = dev_get_priv(dev);
  404. unsigned long addr;
  405. /*
  406. * The device tree is not broken into banks but the infrastructure is
  407. * expecting it this way, so we'll first include the 0x10 offset, then
  408. * calculate the bank manually based on the offset.
  409. * Casting 'addr' as Unsigned long is needed to make the math work.
  410. */
  411. addr = ((unsigned long)(struct davinci_gpio *)bank->base) +
  412. 0x10 + (0x28 * (offset >> 5));
  413. return (struct davinci_gpio *)addr;
  414. }
  415. static int davinci_gpio_direction_input(struct udevice *dev, unsigned int offset)
  416. {
  417. struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset);
  418. /*
  419. * Fetch the address based on GPIO, but only pass the masked low 32-bits
  420. */
  421. _gpio_direction_input(base, (offset & 0x1f));
  422. return 0;
  423. }
  424. static int davinci_gpio_direction_output(struct udevice *dev, unsigned int offset,
  425. int value)
  426. {
  427. struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset);
  428. _gpio_direction_output(base, (offset & 0x1f), value);
  429. return 0;
  430. }
  431. static int davinci_gpio_get_value(struct udevice *dev, unsigned int offset)
  432. {
  433. struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset);
  434. return _gpio_get_value(base, (offset & 0x1f));
  435. }
  436. static int davinci_gpio_set_value(struct udevice *dev, unsigned int offset,
  437. int value)
  438. {
  439. struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset);
  440. _gpio_set_value(base, (offset & 0x1f), value);
  441. return 0;
  442. }
  443. static int davinci_gpio_get_function(struct udevice *dev, unsigned int offset)
  444. {
  445. unsigned int dir;
  446. struct davinci_gpio *base = davinci_get_gpio_bank(dev, offset);
  447. dir = _gpio_get_dir(base, offset);
  448. if (dir)
  449. return GPIOF_INPUT;
  450. return GPIOF_OUTPUT;
  451. }
  452. static int davinci_gpio_xlate(struct udevice *dev, struct gpio_desc *desc,
  453. struct ofnode_phandle_args *args)
  454. {
  455. desc->offset = args->args[0];
  456. if (args->args[1] & GPIO_ACTIVE_LOW)
  457. desc->flags = GPIOD_ACTIVE_LOW;
  458. else
  459. desc->flags = 0;
  460. return 0;
  461. }
  462. static const struct dm_gpio_ops gpio_davinci_ops = {
  463. .direction_input = davinci_gpio_direction_input,
  464. .direction_output = davinci_gpio_direction_output,
  465. .get_value = davinci_gpio_get_value,
  466. .set_value = davinci_gpio_set_value,
  467. .get_function = davinci_gpio_get_function,
  468. .xlate = davinci_gpio_xlate,
  469. };
  470. static int davinci_gpio_probe(struct udevice *dev)
  471. {
  472. struct davinci_gpio_bank *bank = dev_get_priv(dev);
  473. struct davinci_gpio_platdata *plat = dev_get_platdata(dev);
  474. struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
  475. const void *fdt = gd->fdt_blob;
  476. int node = dev_of_offset(dev);
  477. uc_priv->bank_name = plat->port_name;
  478. uc_priv->gpio_count = fdtdec_get_int(fdt, node, "ti,ngpio", -1);
  479. bank->base = (struct davinci_gpio *)plat->base;
  480. return 0;
  481. }
  482. static const struct udevice_id davinci_gpio_ids[] = {
  483. { .compatible = "ti,dm6441-gpio" },
  484. { .compatible = "ti,k2g-gpio" },
  485. { .compatible = "ti,keystone-gpio" },
  486. { }
  487. };
  488. static int davinci_gpio_ofdata_to_platdata(struct udevice *dev)
  489. {
  490. struct davinci_gpio_platdata *plat = dev_get_platdata(dev);
  491. fdt_addr_t addr;
  492. addr = dev_read_addr(dev);
  493. if (addr == FDT_ADDR_T_NONE)
  494. return -EINVAL;
  495. plat->base = addr;
  496. return 0;
  497. }
  498. U_BOOT_DRIVER(ti_dm6441_gpio) = {
  499. .name = "ti_dm6441_gpio",
  500. .id = UCLASS_GPIO,
  501. .ops = &gpio_davinci_ops,
  502. .ofdata_to_platdata = of_match_ptr(davinci_gpio_ofdata_to_platdata),
  503. .of_match = davinci_gpio_ids,
  504. .bind = dm_scan_fdt_dev,
  505. .platdata_auto_alloc_size = sizeof(struct davinci_gpio_platdata),
  506. .probe = davinci_gpio_probe,
  507. .priv_auto_alloc_size = sizeof(struct davinci_gpio_bank),
  508. };
  509. #endif