pinctrl-kendryte.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2020 Sean Anderson <seanga2@gmail.com>
  4. */
  5. #include <common.h>
  6. #include <clk.h>
  7. #include <dm.h>
  8. #include <dm/pinctrl.h>
  9. #include <dt-bindings/pinctrl/k210-pinctrl.h>
  10. #include <mapmem.h>
  11. #include <regmap.h>
  12. #include <syscon.h>
  13. #include <asm/io.h>
  14. #include <linux/err.h>
  15. #include <linux/bitfield.h>
  16. #include <linux/bitops.h>
  17. /*
  18. * The K210 only implements 8 drive levels, even though there is register space
  19. * for 16
  20. */
  21. #define K210_PC_DRIVE_MASK GENMASK(11, 8)
  22. #define K210_PC_DRIVE_SHIFT 8
  23. #define K210_PC_DRIVE_0 (0 << K210_PC_DRIVE_SHIFT)
  24. #define K210_PC_DRIVE_1 (1 << K210_PC_DRIVE_SHIFT)
  25. #define K210_PC_DRIVE_2 (2 << K210_PC_DRIVE_SHIFT)
  26. #define K210_PC_DRIVE_3 (3 << K210_PC_DRIVE_SHIFT)
  27. #define K210_PC_DRIVE_4 (4 << K210_PC_DRIVE_SHIFT)
  28. #define K210_PC_DRIVE_5 (5 << K210_PC_DRIVE_SHIFT)
  29. #define K210_PC_DRIVE_6 (6 << K210_PC_DRIVE_SHIFT)
  30. #define K210_PC_DRIVE_7 (7 << K210_PC_DRIVE_SHIFT)
  31. #define K210_PC_DRIVE_MAX 7
  32. #define K210_PC_MODE_MASK GENMASK(23, 12)
  33. /*
  34. * output enabled == PC_OE & (PC_OE_INV ^ FUNCTION_OE) where FUNCTION_OE is a
  35. * physical signal from the function
  36. */
  37. #define K210_PC_OE BIT(12) /* Output Enable */
  38. #define K210_PC_OE_INV BIT(13) /* INVert function-controlled Output Enable */
  39. #define K210_PC_DO_OE BIT(14) /* set Data Out to the Output Enable signal */
  40. #define K210_PC_DO_INV BIT(15) /* INVert final Data Output */
  41. #define K210_PC_PU BIT(16) /* Pull Up */
  42. #define K210_PC_PD BIT(17) /* Pull Down */
  43. /* Strong pull up not implemented on K210 */
  44. #define K210_PC_SL BIT(19) /* reduce SLew rate to prevent overshoot */
  45. /* Same semantics as OE above */
  46. #define K210_PC_IE BIT(20) /* Input Enable */
  47. #define K210_PC_IE_INV BIT(21) /* INVert function-controlled Input Enable */
  48. #define K210_PC_DI_INV BIT(22) /* INVert Data Input */
  49. #define K210_PC_ST BIT(23) /* Schmitt Trigger */
  50. #define K210_PC_DI BIT(31) /* raw Data Input */
  51. #define K210_PC_BIAS_MASK (K210_PC_PU & K210_PC_PD)
  52. #define K210_PC_MODE_IN (K210_PC_IE | K210_PC_ST)
  53. #define K210_PC_MODE_OUT (K210_PC_DRIVE_7 | K210_PC_OE)
  54. #define K210_PC_MODE_I2C (K210_PC_MODE_IN | K210_PC_SL | K210_PC_OE | \
  55. K210_PC_PU)
  56. #define K210_PC_MODE_SCCB (K210_PC_MODE_I2C | K210_PC_OE_INV | K210_PC_IE_INV)
  57. #define K210_PC_MODE_SPI (K210_PC_MODE_IN | K210_PC_IE_INV | \
  58. K210_PC_MODE_OUT | K210_PC_OE_INV)
  59. #define K210_PC_MODE_GPIO (K210_PC_MODE_IN | K210_PC_MODE_OUT)
  60. #define K210_PG_FUNC GENMASK(7, 0)
  61. #define K210_PG_DO BIT(8)
  62. #define K210_PG_PIN GENMASK(22, 16)
  63. #define PIN_CONFIG_OUTPUT_INVERT (PIN_CONFIG_END + 1)
  64. #define PIN_CONFIG_INPUT_INVERT (PIN_CONFIG_END + 2)
  65. struct k210_fpioa {
  66. u32 pins[48];
  67. u32 tie_en[8];
  68. u32 tie_val[8];
  69. };
  70. struct k210_pc_priv {
  71. struct clk clk;
  72. struct k210_fpioa __iomem *fpioa; /* FPIOA register */
  73. struct regmap *sysctl; /* Sysctl regmap */
  74. u32 power_offset; /* Power bank register offset */
  75. };
  76. #ifdef CONFIG_CMD_PINMUX
  77. static const char k210_pc_pin_names[][6] = {
  78. #define PIN(i) \
  79. [i] = "IO_" #i
  80. PIN(0),
  81. PIN(1),
  82. PIN(2),
  83. PIN(3),
  84. PIN(4),
  85. PIN(5),
  86. PIN(6),
  87. PIN(7),
  88. PIN(8),
  89. PIN(9),
  90. PIN(10),
  91. PIN(11),
  92. PIN(12),
  93. PIN(13),
  94. PIN(14),
  95. PIN(15),
  96. PIN(16),
  97. PIN(17),
  98. PIN(18),
  99. PIN(19),
  100. PIN(20),
  101. PIN(21),
  102. PIN(22),
  103. PIN(23),
  104. PIN(24),
  105. PIN(25),
  106. PIN(26),
  107. PIN(27),
  108. PIN(28),
  109. PIN(29),
  110. PIN(30),
  111. PIN(31),
  112. PIN(32),
  113. PIN(33),
  114. PIN(34),
  115. PIN(35),
  116. PIN(36),
  117. PIN(37),
  118. PIN(38),
  119. PIN(39),
  120. PIN(40),
  121. PIN(41),
  122. PIN(42),
  123. PIN(43),
  124. PIN(44),
  125. PIN(45),
  126. PIN(46),
  127. PIN(47),
  128. #undef PIN
  129. };
  130. static int k210_pc_get_pins_count(struct udevice *dev)
  131. {
  132. return ARRAY_SIZE(k210_pc_pin_names);
  133. };
  134. static const char *k210_pc_get_pin_name(struct udevice *dev, unsigned selector)
  135. {
  136. return k210_pc_pin_names[selector];
  137. }
  138. #endif /* CONFIG_CMD_PINMUX */
  139. /* These are just power domains */
  140. static const char k210_pc_group_names[][3] = {
  141. [0] = "A0",
  142. [1] = "A1",
  143. [2] = "A2",
  144. [3] = "B3",
  145. [4] = "B4",
  146. [5] = "B5",
  147. [6] = "C6",
  148. [7] = "C7",
  149. };
  150. static int k210_pc_get_groups_count(struct udevice *dev)
  151. {
  152. return ARRAY_SIZE(k210_pc_group_names);
  153. }
  154. static const char *k210_pc_get_group_name(struct udevice *dev,
  155. unsigned selector)
  156. {
  157. return k210_pc_group_names[selector];
  158. }
  159. enum k210_pc_mode_id {
  160. K210_PC_DEFAULT_DISABLED,
  161. K210_PC_DEFAULT_IN,
  162. K210_PC_DEFAULT_IN_TIE,
  163. K210_PC_DEFAULT_OUT,
  164. K210_PC_DEFAULT_I2C,
  165. K210_PC_DEFAULT_SCCB,
  166. K210_PC_DEFAULT_SPI,
  167. K210_PC_DEFAULT_GPIO,
  168. K210_PC_DEFAULT_INT13,
  169. };
  170. static const u32 k210_pc_mode_id_to_mode[] = {
  171. #define DEFAULT(mode) \
  172. [K210_PC_DEFAULT_##mode] = K210_PC_MODE_##mode
  173. [K210_PC_DEFAULT_DISABLED] = 0,
  174. DEFAULT(IN),
  175. [K210_PC_DEFAULT_IN_TIE] = K210_PC_MODE_IN,
  176. DEFAULT(OUT),
  177. DEFAULT(I2C),
  178. DEFAULT(SCCB),
  179. DEFAULT(SPI),
  180. DEFAULT(GPIO),
  181. [K210_PC_DEFAULT_INT13] = K210_PC_MODE_IN | K210_PC_PU,
  182. #undef DEFAULT
  183. };
  184. /* This saves around 2K vs having a pointer+mode */
  185. struct k210_pcf_info {
  186. #ifdef CONFIG_CMD_PINMUX
  187. char name[15];
  188. #endif
  189. u8 mode_id;
  190. };
  191. static const struct k210_pcf_info k210_pcf_infos[] = {
  192. #ifdef CONFIG_CMD_PINMUX
  193. #define FUNC(id, mode) \
  194. [K210_PCF_##id] = { \
  195. .name = #id, \
  196. .mode_id = K210_PC_DEFAULT_##mode \
  197. }
  198. #else
  199. #define FUNC(id, mode) \
  200. [K210_PCF_##id] = { \
  201. .mode_id = K210_PC_DEFAULT_##mode \
  202. }
  203. #endif
  204. FUNC(JTAG_TCLK, IN),
  205. FUNC(JTAG_TDI, IN),
  206. FUNC(JTAG_TMS, IN),
  207. FUNC(JTAG_TDO, OUT),
  208. FUNC(SPI0_D0, SPI),
  209. FUNC(SPI0_D1, SPI),
  210. FUNC(SPI0_D2, SPI),
  211. FUNC(SPI0_D3, SPI),
  212. FUNC(SPI0_D4, SPI),
  213. FUNC(SPI0_D5, SPI),
  214. FUNC(SPI0_D6, SPI),
  215. FUNC(SPI0_D7, SPI),
  216. FUNC(SPI0_SS0, OUT),
  217. FUNC(SPI0_SS1, OUT),
  218. FUNC(SPI0_SS2, OUT),
  219. FUNC(SPI0_SS3, OUT),
  220. FUNC(SPI0_ARB, IN_TIE),
  221. FUNC(SPI0_SCLK, OUT),
  222. FUNC(UARTHS_RX, IN),
  223. FUNC(UARTHS_TX, OUT),
  224. FUNC(RESV6, IN),
  225. FUNC(RESV7, IN),
  226. FUNC(CLK_SPI1, OUT),
  227. FUNC(CLK_I2C1, OUT),
  228. FUNC(GPIOHS0, GPIO),
  229. FUNC(GPIOHS1, GPIO),
  230. FUNC(GPIOHS2, GPIO),
  231. FUNC(GPIOHS3, GPIO),
  232. FUNC(GPIOHS4, GPIO),
  233. FUNC(GPIOHS5, GPIO),
  234. FUNC(GPIOHS6, GPIO),
  235. FUNC(GPIOHS7, GPIO),
  236. FUNC(GPIOHS8, GPIO),
  237. FUNC(GPIOHS9, GPIO),
  238. FUNC(GPIOHS10, GPIO),
  239. FUNC(GPIOHS11, GPIO),
  240. FUNC(GPIOHS12, GPIO),
  241. FUNC(GPIOHS13, GPIO),
  242. FUNC(GPIOHS14, GPIO),
  243. FUNC(GPIOHS15, GPIO),
  244. FUNC(GPIOHS16, GPIO),
  245. FUNC(GPIOHS17, GPIO),
  246. FUNC(GPIOHS18, GPIO),
  247. FUNC(GPIOHS19, GPIO),
  248. FUNC(GPIOHS20, GPIO),
  249. FUNC(GPIOHS21, GPIO),
  250. FUNC(GPIOHS22, GPIO),
  251. FUNC(GPIOHS23, GPIO),
  252. FUNC(GPIOHS24, GPIO),
  253. FUNC(GPIOHS25, GPIO),
  254. FUNC(GPIOHS26, GPIO),
  255. FUNC(GPIOHS27, GPIO),
  256. FUNC(GPIOHS28, GPIO),
  257. FUNC(GPIOHS29, GPIO),
  258. FUNC(GPIOHS30, GPIO),
  259. FUNC(GPIOHS31, GPIO),
  260. FUNC(GPIO0, GPIO),
  261. FUNC(GPIO1, GPIO),
  262. FUNC(GPIO2, GPIO),
  263. FUNC(GPIO3, GPIO),
  264. FUNC(GPIO4, GPIO),
  265. FUNC(GPIO5, GPIO),
  266. FUNC(GPIO6, GPIO),
  267. FUNC(GPIO7, GPIO),
  268. FUNC(UART1_RX, IN),
  269. FUNC(UART1_TX, OUT),
  270. FUNC(UART2_RX, IN),
  271. FUNC(UART2_TX, OUT),
  272. FUNC(UART3_RX, IN),
  273. FUNC(UART3_TX, OUT),
  274. FUNC(SPI1_D0, SPI),
  275. FUNC(SPI1_D1, SPI),
  276. FUNC(SPI1_D2, SPI),
  277. FUNC(SPI1_D3, SPI),
  278. FUNC(SPI1_D4, SPI),
  279. FUNC(SPI1_D5, SPI),
  280. FUNC(SPI1_D6, SPI),
  281. FUNC(SPI1_D7, SPI),
  282. FUNC(SPI1_SS0, OUT),
  283. FUNC(SPI1_SS1, OUT),
  284. FUNC(SPI1_SS2, OUT),
  285. FUNC(SPI1_SS3, OUT),
  286. FUNC(SPI1_ARB, IN_TIE),
  287. FUNC(SPI1_SCLK, OUT),
  288. FUNC(SPI2_D0, SPI),
  289. FUNC(SPI2_SS, IN),
  290. FUNC(SPI2_SCLK, IN),
  291. FUNC(I2S0_MCLK, OUT),
  292. FUNC(I2S0_SCLK, OUT),
  293. FUNC(I2S0_WS, OUT),
  294. FUNC(I2S0_IN_D0, IN),
  295. FUNC(I2S0_IN_D1, IN),
  296. FUNC(I2S0_IN_D2, IN),
  297. FUNC(I2S0_IN_D3, IN),
  298. FUNC(I2S0_OUT_D0, OUT),
  299. FUNC(I2S0_OUT_D1, OUT),
  300. FUNC(I2S0_OUT_D2, OUT),
  301. FUNC(I2S0_OUT_D3, OUT),
  302. FUNC(I2S1_MCLK, OUT),
  303. FUNC(I2S1_SCLK, OUT),
  304. FUNC(I2S1_WS, OUT),
  305. FUNC(I2S1_IN_D0, IN),
  306. FUNC(I2S1_IN_D1, IN),
  307. FUNC(I2S1_IN_D2, IN),
  308. FUNC(I2S1_IN_D3, IN),
  309. FUNC(I2S1_OUT_D0, OUT),
  310. FUNC(I2S1_OUT_D1, OUT),
  311. FUNC(I2S1_OUT_D2, OUT),
  312. FUNC(I2S1_OUT_D3, OUT),
  313. FUNC(I2S2_MCLK, OUT),
  314. FUNC(I2S2_SCLK, OUT),
  315. FUNC(I2S2_WS, OUT),
  316. FUNC(I2S2_IN_D0, IN),
  317. FUNC(I2S2_IN_D1, IN),
  318. FUNC(I2S2_IN_D2, IN),
  319. FUNC(I2S2_IN_D3, IN),
  320. FUNC(I2S2_OUT_D0, OUT),
  321. FUNC(I2S2_OUT_D1, OUT),
  322. FUNC(I2S2_OUT_D2, OUT),
  323. FUNC(I2S2_OUT_D3, OUT),
  324. FUNC(RESV0, DISABLED),
  325. FUNC(RESV1, DISABLED),
  326. FUNC(RESV2, DISABLED),
  327. FUNC(RESV3, DISABLED),
  328. FUNC(RESV4, DISABLED),
  329. FUNC(RESV5, DISABLED),
  330. FUNC(I2C0_SCLK, I2C),
  331. FUNC(I2C0_SDA, I2C),
  332. FUNC(I2C1_SCLK, I2C),
  333. FUNC(I2C1_SDA, I2C),
  334. FUNC(I2C2_SCLK, I2C),
  335. FUNC(I2C2_SDA, I2C),
  336. FUNC(DVP_XCLK, OUT),
  337. FUNC(DVP_RST, OUT),
  338. FUNC(DVP_PWDN, OUT),
  339. FUNC(DVP_VSYNC, IN),
  340. FUNC(DVP_HSYNC, IN),
  341. FUNC(DVP_PCLK, IN),
  342. FUNC(DVP_D0, IN),
  343. FUNC(DVP_D1, IN),
  344. FUNC(DVP_D2, IN),
  345. FUNC(DVP_D3, IN),
  346. FUNC(DVP_D4, IN),
  347. FUNC(DVP_D5, IN),
  348. FUNC(DVP_D6, IN),
  349. FUNC(DVP_D7, IN),
  350. FUNC(SCCB_SCLK, SCCB),
  351. FUNC(SCCB_SDA, SCCB),
  352. FUNC(UART1_CTS, IN),
  353. FUNC(UART1_DSR, IN),
  354. FUNC(UART1_DCD, IN),
  355. FUNC(UART1_RI, IN),
  356. FUNC(UART1_SIR_IN, IN),
  357. FUNC(UART1_DTR, OUT),
  358. FUNC(UART1_RTS, OUT),
  359. FUNC(UART1_OUT2, OUT),
  360. FUNC(UART1_OUT1, OUT),
  361. FUNC(UART1_SIR_OUT, OUT),
  362. FUNC(UART1_BAUD, OUT),
  363. FUNC(UART1_RE, OUT),
  364. FUNC(UART1_DE, OUT),
  365. FUNC(UART1_RS485_EN, OUT),
  366. FUNC(UART2_CTS, IN),
  367. FUNC(UART2_DSR, IN),
  368. FUNC(UART2_DCD, IN),
  369. FUNC(UART2_RI, IN),
  370. FUNC(UART2_SIR_IN, IN),
  371. FUNC(UART2_DTR, OUT),
  372. FUNC(UART2_RTS, OUT),
  373. FUNC(UART2_OUT2, OUT),
  374. FUNC(UART2_OUT1, OUT),
  375. FUNC(UART2_SIR_OUT, OUT),
  376. FUNC(UART2_BAUD, OUT),
  377. FUNC(UART2_RE, OUT),
  378. FUNC(UART2_DE, OUT),
  379. FUNC(UART2_RS485_EN, OUT),
  380. FUNC(UART3_CTS, IN),
  381. FUNC(UART3_DSR, IN),
  382. FUNC(UART3_DCD, IN),
  383. FUNC(UART3_RI, IN),
  384. FUNC(UART3_SIR_IN, IN),
  385. FUNC(UART3_DTR, OUT),
  386. FUNC(UART3_RTS, OUT),
  387. FUNC(UART3_OUT2, OUT),
  388. FUNC(UART3_OUT1, OUT),
  389. FUNC(UART3_SIR_OUT, OUT),
  390. FUNC(UART3_BAUD, OUT),
  391. FUNC(UART3_RE, OUT),
  392. FUNC(UART3_DE, OUT),
  393. FUNC(UART3_RS485_EN, OUT),
  394. FUNC(TIMER0_TOGGLE1, OUT),
  395. FUNC(TIMER0_TOGGLE2, OUT),
  396. FUNC(TIMER0_TOGGLE3, OUT),
  397. FUNC(TIMER0_TOGGLE4, OUT),
  398. FUNC(TIMER1_TOGGLE1, OUT),
  399. FUNC(TIMER1_TOGGLE2, OUT),
  400. FUNC(TIMER1_TOGGLE3, OUT),
  401. FUNC(TIMER1_TOGGLE4, OUT),
  402. FUNC(TIMER2_TOGGLE1, OUT),
  403. FUNC(TIMER2_TOGGLE2, OUT),
  404. FUNC(TIMER2_TOGGLE3, OUT),
  405. FUNC(TIMER2_TOGGLE4, OUT),
  406. FUNC(CLK_SPI2, OUT),
  407. FUNC(CLK_I2C2, OUT),
  408. FUNC(INTERNAL0, OUT),
  409. FUNC(INTERNAL1, OUT),
  410. FUNC(INTERNAL2, OUT),
  411. FUNC(INTERNAL3, OUT),
  412. FUNC(INTERNAL4, OUT),
  413. FUNC(INTERNAL5, OUT),
  414. FUNC(INTERNAL6, OUT),
  415. FUNC(INTERNAL7, OUT),
  416. FUNC(INTERNAL8, OUT),
  417. FUNC(INTERNAL9, IN),
  418. FUNC(INTERNAL10, IN),
  419. FUNC(INTERNAL11, IN),
  420. FUNC(INTERNAL12, IN),
  421. FUNC(INTERNAL13, INT13),
  422. FUNC(INTERNAL14, I2C),
  423. FUNC(INTERNAL15, IN),
  424. FUNC(INTERNAL16, IN),
  425. FUNC(INTERNAL17, IN),
  426. FUNC(CONSTANT, DISABLED),
  427. FUNC(INTERNAL18, IN),
  428. FUNC(DEBUG0, OUT),
  429. FUNC(DEBUG1, OUT),
  430. FUNC(DEBUG2, OUT),
  431. FUNC(DEBUG3, OUT),
  432. FUNC(DEBUG4, OUT),
  433. FUNC(DEBUG5, OUT),
  434. FUNC(DEBUG6, OUT),
  435. FUNC(DEBUG7, OUT),
  436. FUNC(DEBUG8, OUT),
  437. FUNC(DEBUG9, OUT),
  438. FUNC(DEBUG10, OUT),
  439. FUNC(DEBUG11, OUT),
  440. FUNC(DEBUG12, OUT),
  441. FUNC(DEBUG13, OUT),
  442. FUNC(DEBUG14, OUT),
  443. FUNC(DEBUG15, OUT),
  444. FUNC(DEBUG16, OUT),
  445. FUNC(DEBUG17, OUT),
  446. FUNC(DEBUG18, OUT),
  447. FUNC(DEBUG19, OUT),
  448. FUNC(DEBUG20, OUT),
  449. FUNC(DEBUG21, OUT),
  450. FUNC(DEBUG22, OUT),
  451. FUNC(DEBUG23, OUT),
  452. FUNC(DEBUG24, OUT),
  453. FUNC(DEBUG25, OUT),
  454. FUNC(DEBUG26, OUT),
  455. FUNC(DEBUG27, OUT),
  456. FUNC(DEBUG28, OUT),
  457. FUNC(DEBUG29, OUT),
  458. FUNC(DEBUG30, OUT),
  459. FUNC(DEBUG31, OUT),
  460. #undef FUNC
  461. };
  462. static int k210_pc_pinmux_set(struct udevice *dev, u32 pinmux_group)
  463. {
  464. unsigned pin = FIELD_GET(K210_PG_PIN, pinmux_group);
  465. bool do_oe = FIELD_GET(K210_PG_DO, pinmux_group);
  466. unsigned func = FIELD_GET(K210_PG_FUNC, pinmux_group);
  467. struct k210_pc_priv *priv = dev_get_priv(dev);
  468. const struct k210_pcf_info *info = &k210_pcf_infos[func];
  469. u32 mode = k210_pc_mode_id_to_mode[info->mode_id];
  470. u32 val = func | mode | (do_oe ? K210_PC_DO_OE : 0);
  471. debug("%s(%.8x): IO_%.2u = %3u | %.8x\n", __func__, pinmux_group, pin,
  472. func, mode);
  473. writel(val, &priv->fpioa->pins[pin]);
  474. return pin;
  475. }
  476. /* Max drive strength in uA */
  477. static const int k210_pc_drive_strength[] = {
  478. [0] = 11200,
  479. [1] = 16800,
  480. [2] = 22300,
  481. [3] = 27800,
  482. [4] = 33300,
  483. [5] = 38700,
  484. [6] = 44100,
  485. [7] = 49500,
  486. };
  487. static int k210_pc_get_drive(unsigned max_strength_ua)
  488. {
  489. int i;
  490. for (i = K210_PC_DRIVE_MAX; i; i--)
  491. if (k210_pc_drive_strength[i] < max_strength_ua)
  492. return i;
  493. return -EINVAL;
  494. }
  495. static int k210_pc_pinconf_set(struct udevice *dev, unsigned pin_selector,
  496. unsigned param, unsigned argument)
  497. {
  498. struct k210_pc_priv *priv = dev_get_priv(dev);
  499. u32 val = readl(&priv->fpioa->pins[pin_selector]);
  500. switch (param) {
  501. case PIN_CONFIG_BIAS_DISABLE:
  502. val &= ~K210_PC_BIAS_MASK;
  503. break;
  504. case PIN_CONFIG_BIAS_PULL_DOWN:
  505. if (argument)
  506. val |= K210_PC_PD;
  507. else
  508. return -EINVAL;
  509. break;
  510. case PIN_CONFIG_BIAS_PULL_UP:
  511. if (argument)
  512. val |= K210_PC_PD;
  513. else
  514. return -EINVAL;
  515. break;
  516. case PIN_CONFIG_DRIVE_STRENGTH:
  517. argument *= 1000;
  518. case PIN_CONFIG_DRIVE_STRENGTH_UA: {
  519. int drive = k210_pc_get_drive(argument);
  520. if (IS_ERR_VALUE(drive))
  521. return drive;
  522. val &= ~K210_PC_DRIVE_MASK;
  523. val |= FIELD_PREP(K210_PC_DRIVE_MASK, drive);
  524. break;
  525. }
  526. case PIN_CONFIG_INPUT_ENABLE:
  527. if (argument)
  528. val |= K210_PC_IE;
  529. else
  530. val &= ~K210_PC_IE;
  531. break;
  532. case PIN_CONFIG_INPUT_SCHMITT:
  533. argument = 1;
  534. case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
  535. if (argument)
  536. val |= K210_PC_ST;
  537. else
  538. val &= ~K210_PC_ST;
  539. break;
  540. case PIN_CONFIG_OUTPUT:
  541. k210_pc_pinmux_set(dev,
  542. K210_FPIOA(pin_selector, K210_PCF_CONSTANT));
  543. val = readl(&priv->fpioa->pins[pin_selector]);
  544. val |= K210_PC_MODE_OUT;
  545. if (!argument)
  546. val |= K210_PC_DO_INV;
  547. break;
  548. case PIN_CONFIG_OUTPUT_ENABLE:
  549. if (argument)
  550. val |= K210_PC_OE;
  551. else
  552. val &= ~K210_PC_OE;
  553. break;
  554. case PIN_CONFIG_SLEW_RATE:
  555. if (argument)
  556. val |= K210_PC_SL;
  557. else
  558. val &= ~K210_PC_SL;
  559. break;
  560. case PIN_CONFIG_OUTPUT_INVERT:
  561. if (argument)
  562. val |= K210_PC_DO_INV;
  563. else
  564. val &= ~K210_PC_DO_INV;
  565. break;
  566. case PIN_CONFIG_INPUT_INVERT:
  567. if (argument)
  568. val |= K210_PC_DI_INV;
  569. else
  570. val &= ~K210_PC_DI_INV;
  571. break;
  572. default:
  573. return -EINVAL;
  574. }
  575. writel(val, &priv->fpioa->pins[pin_selector]);
  576. return 0;
  577. }
  578. static int k210_pc_pinconf_group_set(struct udevice *dev,
  579. unsigned group_selector, unsigned param,
  580. unsigned argument)
  581. {
  582. struct k210_pc_priv *priv = dev_get_priv(dev);
  583. if (param == PIN_CONFIG_POWER_SOURCE) {
  584. u32 bit = BIT(group_selector);
  585. regmap_update_bits(priv->sysctl, priv->power_offset, bit,
  586. argument ? bit : 0);
  587. } else {
  588. return -EINVAL;
  589. }
  590. return 0;
  591. }
  592. #ifdef CONFIG_CMD_PINMUX
  593. static int k210_pc_get_pin_muxing(struct udevice *dev, unsigned int selector,
  594. char *buf, int size)
  595. {
  596. struct k210_pc_priv *priv = dev_get_priv(dev);
  597. u32 val = readl(&priv->fpioa->pins[selector]);
  598. const struct k210_pcf_info *info = &k210_pcf_infos[val & K210_PCF_MASK];
  599. strncpy(buf, info->name, min((size_t)size, sizeof(info->name)));
  600. return 0;
  601. }
  602. #endif
  603. static const struct pinconf_param k210_pc_pinconf_params[] = {
  604. { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 },
  605. { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 1 },
  606. { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 1 },
  607. { "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, U32_MAX },
  608. { "drive-strength-ua", PIN_CONFIG_DRIVE_STRENGTH_UA, U32_MAX },
  609. { "input-enable", PIN_CONFIG_INPUT_ENABLE, 1 },
  610. { "input-disable", PIN_CONFIG_INPUT_ENABLE, 0 },
  611. { "input-schmitt-enable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 1 },
  612. { "input-schmitt-disable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 0 },
  613. { "power-source", PIN_CONFIG_POWER_SOURCE, K210_PC_POWER_1V8 },
  614. { "output-low", PIN_CONFIG_OUTPUT, 0 },
  615. { "output-high", PIN_CONFIG_OUTPUT, 1 },
  616. { "output-enable", PIN_CONFIG_OUTPUT_ENABLE, 1 },
  617. { "output-disable", PIN_CONFIG_OUTPUT_ENABLE, 0 },
  618. { "slew-rate", PIN_CONFIG_SLEW_RATE, 1 },
  619. { "output-polarity-invert", PIN_CONFIG_OUTPUT_INVERT, 1},
  620. { "input-polarity-invert", PIN_CONFIG_INPUT_INVERT, 1},
  621. };
  622. static const struct pinctrl_ops k210_pc_pinctrl_ops = {
  623. #ifdef CONFIG_CMD_PINMUX
  624. .get_pins_count = k210_pc_get_pins_count,
  625. .get_pin_name = k210_pc_get_pin_name,
  626. #endif
  627. .get_groups_count = k210_pc_get_groups_count,
  628. .get_group_name = k210_pc_get_group_name,
  629. .pinmux_property_set = k210_pc_pinmux_set,
  630. .pinconf_num_params = ARRAY_SIZE(k210_pc_pinconf_params),
  631. .pinconf_params = k210_pc_pinconf_params,
  632. .pinconf_set = k210_pc_pinconf_set,
  633. .pinconf_group_set = k210_pc_pinconf_group_set,
  634. .set_state = pinctrl_generic_set_state,
  635. #ifdef CONFIG_CMD_PINMUX
  636. .get_pin_muxing = k210_pc_get_pin_muxing,
  637. #endif
  638. };
  639. static int k210_pc_probe(struct udevice *dev)
  640. {
  641. int ret, i, j;
  642. struct k210_pc_priv *priv = dev_get_priv(dev);
  643. priv->fpioa = dev_read_addr_ptr(dev);
  644. if (!priv->fpioa)
  645. return -EINVAL;
  646. ret = clk_get_by_index(dev, 0, &priv->clk);
  647. if (ret)
  648. return ret;
  649. ret = clk_enable(&priv->clk);
  650. if (ret && ret != -ENOSYS && ret != -ENOTSUPP)
  651. goto err;
  652. priv->sysctl = syscon_regmap_lookup_by_phandle(dev, "kendryte,sysctl");
  653. if (IS_ERR(priv->sysctl)) {
  654. ret = -ENODEV;
  655. goto err;
  656. }
  657. ret = dev_read_u32(dev, "kendryte,power-offset", &priv->power_offset);
  658. if (ret)
  659. goto err;
  660. debug("%s: fpioa = %p sysctl = %p power offset = %x\n", __func__,
  661. priv->fpioa, (void *)priv->sysctl->ranges[0].start,
  662. priv->power_offset);
  663. /* Init input ties */
  664. for (i = 0; i < ARRAY_SIZE(priv->fpioa->tie_en); i++) {
  665. u32 val = 0;
  666. for (j = 0; j < 32; j++)
  667. if (k210_pcf_infos[i * 32 + j].mode_id ==
  668. K210_PC_DEFAULT_IN_TIE)
  669. val |= BIT(j);
  670. writel(val, &priv->fpioa->tie_en[i]);
  671. writel(val, &priv->fpioa->tie_val[i]);
  672. }
  673. return 0;
  674. err:
  675. clk_free(&priv->clk);
  676. return ret;
  677. }
  678. static const struct udevice_id k210_pc_ids[] = {
  679. { .compatible = "kendryte,k210-fpioa" },
  680. { }
  681. };
  682. U_BOOT_DRIVER(pinctrl_k210) = {
  683. .name = "pinctrl_k210",
  684. .id = UCLASS_PINCTRL,
  685. .of_match = k210_pc_ids,
  686. .probe = k210_pc_probe,
  687. .priv_auto = sizeof(struct k210_pc_priv),
  688. .ops = &k210_pc_pinctrl_ops,
  689. };