pinctrl-madera-core.c 27 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Pinctrl for Cirrus Logic Madera codecs
  4. *
  5. * Copyright (C) 2016-2018 Cirrus Logic
  6. */
  7. #include <linux/err.h>
  8. #include <linux/module.h>
  9. #include <linux/platform_device.h>
  10. #include <linux/regmap.h>
  11. #include <linux/slab.h>
  12. #include <linux/pinctrl/machine.h>
  13. #include <linux/pinctrl/pinctrl.h>
  14. #include <linux/pinctrl/pinmux.h>
  15. #include <linux/pinctrl/pinconf.h>
  16. #include <linux/pinctrl/pinconf-generic.h>
  17. #include <linux/mfd/madera/core.h>
  18. #include <linux/mfd/madera/registers.h>
  19. #include "../pinctrl-utils.h"
  20. #include "pinctrl-madera.h"
  21. /*
  22. * Use pin GPIO names for consistency
  23. * NOTE: IDs are zero-indexed for coding convenience
  24. */
  25. static const struct pinctrl_pin_desc madera_pins[] = {
  26. PINCTRL_PIN(0, "gpio1"),
  27. PINCTRL_PIN(1, "gpio2"),
  28. PINCTRL_PIN(2, "gpio3"),
  29. PINCTRL_PIN(3, "gpio4"),
  30. PINCTRL_PIN(4, "gpio5"),
  31. PINCTRL_PIN(5, "gpio6"),
  32. PINCTRL_PIN(6, "gpio7"),
  33. PINCTRL_PIN(7, "gpio8"),
  34. PINCTRL_PIN(8, "gpio9"),
  35. PINCTRL_PIN(9, "gpio10"),
  36. PINCTRL_PIN(10, "gpio11"),
  37. PINCTRL_PIN(11, "gpio12"),
  38. PINCTRL_PIN(12, "gpio13"),
  39. PINCTRL_PIN(13, "gpio14"),
  40. PINCTRL_PIN(14, "gpio15"),
  41. PINCTRL_PIN(15, "gpio16"),
  42. PINCTRL_PIN(16, "gpio17"),
  43. PINCTRL_PIN(17, "gpio18"),
  44. PINCTRL_PIN(18, "gpio19"),
  45. PINCTRL_PIN(19, "gpio20"),
  46. PINCTRL_PIN(20, "gpio21"),
  47. PINCTRL_PIN(21, "gpio22"),
  48. PINCTRL_PIN(22, "gpio23"),
  49. PINCTRL_PIN(23, "gpio24"),
  50. PINCTRL_PIN(24, "gpio25"),
  51. PINCTRL_PIN(25, "gpio26"),
  52. PINCTRL_PIN(26, "gpio27"),
  53. PINCTRL_PIN(27, "gpio28"),
  54. PINCTRL_PIN(28, "gpio29"),
  55. PINCTRL_PIN(29, "gpio30"),
  56. PINCTRL_PIN(30, "gpio31"),
  57. PINCTRL_PIN(31, "gpio32"),
  58. PINCTRL_PIN(32, "gpio33"),
  59. PINCTRL_PIN(33, "gpio34"),
  60. PINCTRL_PIN(34, "gpio35"),
  61. PINCTRL_PIN(35, "gpio36"),
  62. PINCTRL_PIN(36, "gpio37"),
  63. PINCTRL_PIN(37, "gpio38"),
  64. PINCTRL_PIN(38, "gpio39"),
  65. PINCTRL_PIN(39, "gpio40"),
  66. };
  67. /*
  68. * All single-pin functions can be mapped to any GPIO, however pinmux applies
  69. * functions to pin groups and only those groups declared as supporting that
  70. * function. To make this work we must put each pin in its own dummy group so
  71. * that the functions can be described as applying to all pins.
  72. * Since these do not correspond to anything in the actual hardware - they are
  73. * merely an adaptation to pinctrl's view of the world - we use the same name
  74. * as the pin to avoid confusion when comparing with datasheet instructions
  75. */
  76. static const char * const madera_pin_single_group_names[] = {
  77. "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7",
  78. "gpio8", "gpio9", "gpio10", "gpio11", "gpio12", "gpio13", "gpio14",
  79. "gpio15", "gpio16", "gpio17", "gpio18", "gpio19", "gpio20", "gpio21",
  80. "gpio22", "gpio23", "gpio24", "gpio25", "gpio26", "gpio27", "gpio28",
  81. "gpio29", "gpio30", "gpio31", "gpio32", "gpio33", "gpio34", "gpio35",
  82. "gpio36", "gpio37", "gpio38", "gpio39", "gpio40",
  83. };
  84. /* set of pin numbers for single-pin groups, zero-indexed */
  85. static const unsigned int madera_pin_single_group_pins[] = {
  86. 0, 1, 2, 3, 4, 5, 6,
  87. 7, 8, 9, 10, 11, 12, 13,
  88. 14, 15, 16, 17, 18, 19, 20,
  89. 21, 22, 23, 24, 25, 26, 27,
  90. 28, 29, 30, 31, 32, 33, 34,
  91. 35, 36, 37, 38, 39,
  92. };
  93. static const char * const madera_aif1_group_names[] = { "aif1" };
  94. static const char * const madera_aif2_group_names[] = { "aif2" };
  95. static const char * const madera_aif3_group_names[] = { "aif3" };
  96. static const char * const madera_aif4_group_names[] = { "aif4" };
  97. static const char * const madera_mif1_group_names[] = { "mif1" };
  98. static const char * const madera_mif2_group_names[] = { "mif2" };
  99. static const char * const madera_mif3_group_names[] = { "mif3" };
  100. static const char * const madera_dmic3_group_names[] = { "dmic3" };
  101. static const char * const madera_dmic4_group_names[] = { "dmic4" };
  102. static const char * const madera_dmic5_group_names[] = { "dmic5" };
  103. static const char * const madera_dmic6_group_names[] = { "dmic6" };
  104. static const char * const madera_spk1_group_names[] = { "pdmspk1" };
  105. static const char * const madera_spk2_group_names[] = { "pdmspk2" };
  106. /*
  107. * alt-functions always apply to a single pin group, other functions always
  108. * apply to all pins
  109. */
  110. static const struct {
  111. const char *name;
  112. const char * const *group_names;
  113. u32 func;
  114. } madera_mux_funcs[] = {
  115. {
  116. .name = "aif1",
  117. .group_names = madera_aif1_group_names,
  118. .func = 0x000
  119. },
  120. {
  121. .name = "aif2",
  122. .group_names = madera_aif2_group_names,
  123. .func = 0x000
  124. },
  125. {
  126. .name = "aif3",
  127. .group_names = madera_aif3_group_names,
  128. .func = 0x000
  129. },
  130. {
  131. .name = "aif4",
  132. .group_names = madera_aif4_group_names,
  133. .func = 0x000
  134. },
  135. {
  136. .name = "mif1",
  137. .group_names = madera_mif1_group_names,
  138. .func = 0x000
  139. },
  140. {
  141. .name = "mif2",
  142. .group_names = madera_mif2_group_names,
  143. .func = 0x000
  144. },
  145. {
  146. .name = "mif3",
  147. .group_names = madera_mif3_group_names,
  148. .func = 0x000
  149. },
  150. {
  151. .name = "dmic3",
  152. .group_names = madera_dmic3_group_names,
  153. .func = 0x000
  154. },
  155. {
  156. .name = "dmic4",
  157. .group_names = madera_dmic4_group_names,
  158. .func = 0x000
  159. },
  160. {
  161. .name = "dmic5",
  162. .group_names = madera_dmic5_group_names,
  163. .func = 0x000
  164. },
  165. {
  166. .name = "dmic6",
  167. .group_names = madera_dmic6_group_names,
  168. .func = 0x000
  169. },
  170. {
  171. .name = "pdmspk1",
  172. .group_names = madera_spk1_group_names,
  173. .func = 0x000
  174. },
  175. {
  176. .name = "pdmspk2",
  177. .group_names = madera_spk2_group_names,
  178. .func = 0x000
  179. },
  180. {
  181. .name = "io",
  182. .group_names = madera_pin_single_group_names,
  183. .func = 0x001
  184. },
  185. {
  186. .name = "dsp-gpio",
  187. .group_names = madera_pin_single_group_names,
  188. .func = 0x002
  189. },
  190. {
  191. .name = "irq1",
  192. .group_names = madera_pin_single_group_names,
  193. .func = 0x003
  194. },
  195. {
  196. .name = "irq2",
  197. .group_names = madera_pin_single_group_names,
  198. .func = 0x004
  199. },
  200. {
  201. .name = "fll1-clk",
  202. .group_names = madera_pin_single_group_names,
  203. .func = 0x010
  204. },
  205. {
  206. .name = "fll2-clk",
  207. .group_names = madera_pin_single_group_names,
  208. .func = 0x011
  209. },
  210. {
  211. .name = "fll3-clk",
  212. .group_names = madera_pin_single_group_names,
  213. .func = 0x012
  214. },
  215. {
  216. .name = "fllao-clk",
  217. .group_names = madera_pin_single_group_names,
  218. .func = 0x013
  219. },
  220. {
  221. .name = "fll1-lock",
  222. .group_names = madera_pin_single_group_names,
  223. .func = 0x018
  224. },
  225. {
  226. .name = "fll2-lock",
  227. .group_names = madera_pin_single_group_names,
  228. .func = 0x019
  229. },
  230. {
  231. .name = "fll3-lock",
  232. .group_names = madera_pin_single_group_names,
  233. .func = 0x01a
  234. },
  235. {
  236. .name = "fllao-lock",
  237. .group_names = madera_pin_single_group_names,
  238. .func = 0x01b
  239. },
  240. {
  241. .name = "opclk",
  242. .group_names = madera_pin_single_group_names,
  243. .func = 0x040
  244. },
  245. {
  246. .name = "opclk-async",
  247. .group_names = madera_pin_single_group_names,
  248. .func = 0x041
  249. },
  250. {
  251. .name = "pwm1",
  252. .group_names = madera_pin_single_group_names,
  253. .func = 0x048
  254. },
  255. {
  256. .name = "pwm2",
  257. .group_names = madera_pin_single_group_names,
  258. .func = 0x049
  259. },
  260. {
  261. .name = "spdif",
  262. .group_names = madera_pin_single_group_names,
  263. .func = 0x04c
  264. },
  265. {
  266. .name = "asrc1-in1-lock",
  267. .group_names = madera_pin_single_group_names,
  268. .func = 0x088
  269. },
  270. {
  271. .name = "asrc1-in2-lock",
  272. .group_names = madera_pin_single_group_names,
  273. .func = 0x089
  274. },
  275. {
  276. .name = "asrc2-in1-lock",
  277. .group_names = madera_pin_single_group_names,
  278. .func = 0x08a
  279. },
  280. {
  281. .name = "asrc2-in2-lock",
  282. .group_names = madera_pin_single_group_names,
  283. .func = 0x08b
  284. },
  285. {
  286. .name = "spkl-short-circuit",
  287. .group_names = madera_pin_single_group_names,
  288. .func = 0x0b6
  289. },
  290. {
  291. .name = "spkr-short-circuit",
  292. .group_names = madera_pin_single_group_names,
  293. .func = 0x0b7
  294. },
  295. {
  296. .name = "spk-shutdown",
  297. .group_names = madera_pin_single_group_names,
  298. .func = 0x0e0
  299. },
  300. {
  301. .name = "spk-overheat-shutdown",
  302. .group_names = madera_pin_single_group_names,
  303. .func = 0x0e1
  304. },
  305. {
  306. .name = "spk-overheat-warn",
  307. .group_names = madera_pin_single_group_names,
  308. .func = 0x0e2
  309. },
  310. {
  311. .name = "timer1-sts",
  312. .group_names = madera_pin_single_group_names,
  313. .func = 0x140
  314. },
  315. {
  316. .name = "timer2-sts",
  317. .group_names = madera_pin_single_group_names,
  318. .func = 0x141
  319. },
  320. {
  321. .name = "timer3-sts",
  322. .group_names = madera_pin_single_group_names,
  323. .func = 0x142
  324. },
  325. {
  326. .name = "timer4-sts",
  327. .group_names = madera_pin_single_group_names,
  328. .func = 0x143
  329. },
  330. {
  331. .name = "timer5-sts",
  332. .group_names = madera_pin_single_group_names,
  333. .func = 0x144
  334. },
  335. {
  336. .name = "timer6-sts",
  337. .group_names = madera_pin_single_group_names,
  338. .func = 0x145
  339. },
  340. {
  341. .name = "timer7-sts",
  342. .group_names = madera_pin_single_group_names,
  343. .func = 0x146
  344. },
  345. {
  346. .name = "timer8-sts",
  347. .group_names = madera_pin_single_group_names,
  348. .func = 0x147
  349. },
  350. {
  351. .name = "log1-fifo-ne",
  352. .group_names = madera_pin_single_group_names,
  353. .func = 0x150
  354. },
  355. {
  356. .name = "log2-fifo-ne",
  357. .group_names = madera_pin_single_group_names,
  358. .func = 0x151
  359. },
  360. {
  361. .name = "log3-fifo-ne",
  362. .group_names = madera_pin_single_group_names,
  363. .func = 0x152
  364. },
  365. {
  366. .name = "log4-fifo-ne",
  367. .group_names = madera_pin_single_group_names,
  368. .func = 0x153
  369. },
  370. {
  371. .name = "log5-fifo-ne",
  372. .group_names = madera_pin_single_group_names,
  373. .func = 0x154
  374. },
  375. {
  376. .name = "log6-fifo-ne",
  377. .group_names = madera_pin_single_group_names,
  378. .func = 0x155
  379. },
  380. {
  381. .name = "log7-fifo-ne",
  382. .group_names = madera_pin_single_group_names,
  383. .func = 0x156
  384. },
  385. {
  386. .name = "log8-fifo-ne",
  387. .group_names = madera_pin_single_group_names,
  388. .func = 0x157
  389. },
  390. {
  391. .name = "aux-pdm-clk",
  392. .group_names = madera_pin_single_group_names,
  393. .func = 0x280
  394. },
  395. {
  396. .name = "aux-pdm-dat",
  397. .group_names = madera_pin_single_group_names,
  398. .func = 0x281
  399. },
  400. };
  401. static u16 madera_pin_make_drv_str(struct madera_pin_private *priv,
  402. unsigned int milliamps)
  403. {
  404. switch (milliamps) {
  405. case 4:
  406. return 0;
  407. case 8:
  408. return 2 << MADERA_GP1_DRV_STR_SHIFT;
  409. default:
  410. break;
  411. }
  412. dev_warn(priv->dev, "%u mA not a valid drive strength", milliamps);
  413. return 0;
  414. }
  415. static unsigned int madera_pin_unmake_drv_str(struct madera_pin_private *priv,
  416. u16 regval)
  417. {
  418. regval = (regval & MADERA_GP1_DRV_STR_MASK) >> MADERA_GP1_DRV_STR_SHIFT;
  419. switch (regval) {
  420. case 0:
  421. return 4;
  422. case 2:
  423. return 8;
  424. default:
  425. return 0;
  426. }
  427. }
  428. static int madera_get_groups_count(struct pinctrl_dev *pctldev)
  429. {
  430. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  431. /* Number of alt function groups plus number of single-pin groups */
  432. return priv->chip->n_pin_groups + priv->chip->n_pins;
  433. }
  434. static const char *madera_get_group_name(struct pinctrl_dev *pctldev,
  435. unsigned int selector)
  436. {
  437. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  438. if (selector < priv->chip->n_pin_groups)
  439. return priv->chip->pin_groups[selector].name;
  440. selector -= priv->chip->n_pin_groups;
  441. return madera_pin_single_group_names[selector];
  442. }
  443. static int madera_get_group_pins(struct pinctrl_dev *pctldev,
  444. unsigned int selector,
  445. const unsigned int **pins,
  446. unsigned int *num_pins)
  447. {
  448. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  449. if (selector < priv->chip->n_pin_groups) {
  450. *pins = priv->chip->pin_groups[selector].pins;
  451. *num_pins = priv->chip->pin_groups[selector].n_pins;
  452. } else {
  453. /* return the dummy group for a single pin */
  454. selector -= priv->chip->n_pin_groups;
  455. *pins = &madera_pin_single_group_pins[selector];
  456. *num_pins = 1;
  457. }
  458. return 0;
  459. }
  460. static void madera_pin_dbg_show_fn(struct madera_pin_private *priv,
  461. struct seq_file *s,
  462. unsigned int pin, unsigned int fn)
  463. {
  464. const struct madera_pin_chip *chip = priv->chip;
  465. int i, g_pin;
  466. if (fn != 0) {
  467. for (i = 0; i < ARRAY_SIZE(madera_mux_funcs); ++i) {
  468. if (madera_mux_funcs[i].func == fn) {
  469. seq_printf(s, " FN=%s",
  470. madera_mux_funcs[i].name);
  471. return;
  472. }
  473. }
  474. return; /* ignore unknown function values */
  475. }
  476. /* alt function */
  477. for (i = 0; i < chip->n_pin_groups; ++i) {
  478. for (g_pin = 0; g_pin < chip->pin_groups[i].n_pins; ++g_pin) {
  479. if (chip->pin_groups[i].pins[g_pin] == pin) {
  480. seq_printf(s, " FN=%s",
  481. chip->pin_groups[i].name);
  482. return;
  483. }
  484. }
  485. }
  486. }
  487. static void __maybe_unused madera_pin_dbg_show(struct pinctrl_dev *pctldev,
  488. struct seq_file *s,
  489. unsigned int pin)
  490. {
  491. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  492. unsigned int conf[2];
  493. unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * pin);
  494. unsigned int fn;
  495. int ret;
  496. ret = regmap_read(priv->madera->regmap, reg, &conf[0]);
  497. if (ret)
  498. return;
  499. ret = regmap_read(priv->madera->regmap, reg + 1, &conf[1]);
  500. if (ret)
  501. return;
  502. seq_printf(s, "%04x:%04x", conf[0], conf[1]);
  503. fn = (conf[0] & MADERA_GP1_FN_MASK) >> MADERA_GP1_FN_SHIFT;
  504. madera_pin_dbg_show_fn(priv, s, pin, fn);
  505. /* State of direction bit is only relevant if function==1 */
  506. if (fn == 1) {
  507. if (conf[1] & MADERA_GP1_DIR_MASK)
  508. seq_puts(s, " IN");
  509. else
  510. seq_puts(s, " OUT");
  511. }
  512. if (conf[1] & MADERA_GP1_PU_MASK)
  513. seq_puts(s, " PU");
  514. if (conf[1] & MADERA_GP1_PD_MASK)
  515. seq_puts(s, " PD");
  516. if (conf[0] & MADERA_GP1_DB_MASK)
  517. seq_puts(s, " DB");
  518. if (conf[0] & MADERA_GP1_OP_CFG_MASK)
  519. seq_puts(s, " OD");
  520. else
  521. seq_puts(s, " CMOS");
  522. seq_printf(s, " DRV=%umA", madera_pin_unmake_drv_str(priv, conf[1]));
  523. if (conf[0] & MADERA_GP1_IP_CFG_MASK)
  524. seq_puts(s, " SCHMITT");
  525. }
  526. static const struct pinctrl_ops madera_pin_group_ops = {
  527. .get_groups_count = madera_get_groups_count,
  528. .get_group_name = madera_get_group_name,
  529. .get_group_pins = madera_get_group_pins,
  530. #if IS_ENABLED(CONFIG_OF)
  531. .dt_node_to_map = pinconf_generic_dt_node_to_map_all,
  532. .dt_free_map = pinctrl_utils_free_map,
  533. #endif
  534. #if IS_ENABLED(CONFIG_DEBUG_FS)
  535. .pin_dbg_show = madera_pin_dbg_show,
  536. #endif
  537. };
  538. static int madera_mux_get_funcs_count(struct pinctrl_dev *pctldev)
  539. {
  540. return ARRAY_SIZE(madera_mux_funcs);
  541. }
  542. static const char *madera_mux_get_func_name(struct pinctrl_dev *pctldev,
  543. unsigned int selector)
  544. {
  545. return madera_mux_funcs[selector].name;
  546. }
  547. static int madera_mux_get_groups(struct pinctrl_dev *pctldev,
  548. unsigned int selector,
  549. const char * const **groups,
  550. unsigned int * const num_groups)
  551. {
  552. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  553. *groups = madera_mux_funcs[selector].group_names;
  554. if (madera_mux_funcs[selector].func == 0) {
  555. /* alt func always maps to a single group */
  556. *num_groups = 1;
  557. } else {
  558. /* other funcs map to all available gpio pins */
  559. *num_groups = priv->chip->n_pins;
  560. }
  561. return 0;
  562. }
  563. static int madera_mux_set_mux(struct pinctrl_dev *pctldev,
  564. unsigned int selector,
  565. unsigned int group)
  566. {
  567. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  568. struct madera *madera = priv->madera;
  569. const struct madera_pin_groups *pin_group = priv->chip->pin_groups;
  570. unsigned int n_chip_groups = priv->chip->n_pin_groups;
  571. const char *func_name = madera_mux_funcs[selector].name;
  572. unsigned int reg;
  573. int i, ret = 0;
  574. dev_dbg(priv->dev, "%s selecting %u (%s) for group %u (%s)\n",
  575. __func__, selector, func_name, group,
  576. madera_get_group_name(pctldev, group));
  577. if (madera_mux_funcs[selector].func == 0) {
  578. /* alt func pin assignments are codec-specific */
  579. for (i = 0; i < n_chip_groups; ++i) {
  580. if (strcmp(func_name, pin_group->name) == 0)
  581. break;
  582. ++pin_group;
  583. }
  584. if (i == n_chip_groups)
  585. return -EINVAL;
  586. for (i = 0; i < pin_group->n_pins; ++i) {
  587. reg = MADERA_GPIO1_CTRL_1 + (2 * pin_group->pins[i]);
  588. dev_dbg(priv->dev, "%s setting 0x%x func bits to 0\n",
  589. __func__, reg);
  590. ret = regmap_update_bits(madera->regmap, reg,
  591. MADERA_GP1_FN_MASK, 0);
  592. if (ret)
  593. break;
  594. }
  595. } else {
  596. /*
  597. * for other funcs the group will be the gpio number and will
  598. * be offset by the number of chip-specific functions at the
  599. * start of the group list
  600. */
  601. group -= n_chip_groups;
  602. reg = MADERA_GPIO1_CTRL_1 + (2 * group);
  603. dev_dbg(priv->dev, "%s setting 0x%x func bits to 0x%x\n",
  604. __func__, reg, madera_mux_funcs[selector].func);
  605. ret = regmap_update_bits(madera->regmap,
  606. reg,
  607. MADERA_GP1_FN_MASK,
  608. madera_mux_funcs[selector].func);
  609. }
  610. if (ret)
  611. dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret);
  612. return ret;
  613. }
  614. static int madera_gpio_set_direction(struct pinctrl_dev *pctldev,
  615. struct pinctrl_gpio_range *range,
  616. unsigned int offset,
  617. bool input)
  618. {
  619. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  620. struct madera *madera = priv->madera;
  621. unsigned int reg = MADERA_GPIO1_CTRL_2 + (2 * offset);
  622. unsigned int val;
  623. int ret;
  624. if (input)
  625. val = MADERA_GP1_DIR;
  626. else
  627. val = 0;
  628. ret = regmap_update_bits(madera->regmap, reg, MADERA_GP1_DIR_MASK, val);
  629. if (ret)
  630. dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret);
  631. return ret;
  632. }
  633. static int madera_gpio_request_enable(struct pinctrl_dev *pctldev,
  634. struct pinctrl_gpio_range *range,
  635. unsigned int offset)
  636. {
  637. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  638. struct madera *madera = priv->madera;
  639. unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * offset);
  640. int ret;
  641. /* put the pin into GPIO mode */
  642. ret = regmap_update_bits(madera->regmap, reg, MADERA_GP1_FN_MASK, 1);
  643. if (ret)
  644. dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret);
  645. return ret;
  646. }
  647. static void madera_gpio_disable_free(struct pinctrl_dev *pctldev,
  648. struct pinctrl_gpio_range *range,
  649. unsigned int offset)
  650. {
  651. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  652. struct madera *madera = priv->madera;
  653. unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * offset);
  654. int ret;
  655. /* disable GPIO by setting to GPIO IN */
  656. madera_gpio_set_direction(pctldev, range, offset, true);
  657. ret = regmap_update_bits(madera->regmap, reg, MADERA_GP1_FN_MASK, 1);
  658. if (ret)
  659. dev_err(priv->dev, "Failed to write to 0x%x (%d)\n", reg, ret);
  660. }
  661. static const struct pinmux_ops madera_pin_mux_ops = {
  662. .get_functions_count = madera_mux_get_funcs_count,
  663. .get_function_name = madera_mux_get_func_name,
  664. .get_function_groups = madera_mux_get_groups,
  665. .set_mux = madera_mux_set_mux,
  666. .gpio_request_enable = madera_gpio_request_enable,
  667. .gpio_disable_free = madera_gpio_disable_free,
  668. .gpio_set_direction = madera_gpio_set_direction,
  669. .strict = true, /* GPIO and other functions are exclusive */
  670. };
  671. static int madera_pin_conf_get(struct pinctrl_dev *pctldev, unsigned int pin,
  672. unsigned long *config)
  673. {
  674. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  675. unsigned int param = pinconf_to_config_param(*config);
  676. unsigned int result = 0;
  677. unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * pin);
  678. unsigned int conf[2];
  679. int ret;
  680. ret = regmap_read(priv->madera->regmap, reg, &conf[0]);
  681. if (!ret)
  682. ret = regmap_read(priv->madera->regmap, reg + 1, &conf[1]);
  683. if (ret) {
  684. dev_err(priv->dev, "Failed to read GP%d conf (%d)\n",
  685. pin + 1, ret);
  686. return ret;
  687. }
  688. switch (param) {
  689. case PIN_CONFIG_BIAS_BUS_HOLD:
  690. conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  691. if (conf[1] == (MADERA_GP1_PU | MADERA_GP1_PD))
  692. result = 1;
  693. break;
  694. case PIN_CONFIG_BIAS_DISABLE:
  695. conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  696. if (!conf[1])
  697. result = 1;
  698. break;
  699. case PIN_CONFIG_BIAS_PULL_DOWN:
  700. conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  701. if (conf[1] == MADERA_GP1_PD_MASK)
  702. result = 1;
  703. break;
  704. case PIN_CONFIG_BIAS_PULL_UP:
  705. conf[1] &= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  706. if (conf[1] == MADERA_GP1_PU_MASK)
  707. result = 1;
  708. break;
  709. case PIN_CONFIG_DRIVE_OPEN_DRAIN:
  710. if (conf[0] & MADERA_GP1_OP_CFG_MASK)
  711. result = 1;
  712. break;
  713. case PIN_CONFIG_DRIVE_PUSH_PULL:
  714. if (!(conf[0] & MADERA_GP1_OP_CFG_MASK))
  715. result = 1;
  716. break;
  717. case PIN_CONFIG_DRIVE_STRENGTH:
  718. result = madera_pin_unmake_drv_str(priv, conf[1]);
  719. break;
  720. case PIN_CONFIG_INPUT_DEBOUNCE:
  721. if (conf[0] & MADERA_GP1_DB_MASK)
  722. result = 1;
  723. break;
  724. case PIN_CONFIG_INPUT_ENABLE:
  725. if (conf[0] & MADERA_GP1_DIR_MASK)
  726. result = 1;
  727. break;
  728. case PIN_CONFIG_INPUT_SCHMITT:
  729. case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
  730. if (conf[0] & MADERA_GP1_IP_CFG_MASK)
  731. result = 1;
  732. break;
  733. case PIN_CONFIG_OUTPUT:
  734. if ((conf[1] & MADERA_GP1_DIR_MASK) &&
  735. (conf[0] & MADERA_GP1_LVL_MASK))
  736. result = 1;
  737. break;
  738. default:
  739. return -ENOTSUPP;
  740. }
  741. *config = pinconf_to_config_packed(param, result);
  742. return 0;
  743. }
  744. static int madera_pin_conf_set(struct pinctrl_dev *pctldev, unsigned int pin,
  745. unsigned long *configs, unsigned int num_configs)
  746. {
  747. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  748. u16 conf[2] = {0, 0};
  749. u16 mask[2] = {0, 0};
  750. unsigned int reg = MADERA_GPIO1_CTRL_1 + (2 * pin);
  751. unsigned int val;
  752. int ret;
  753. while (num_configs) {
  754. dev_dbg(priv->dev, "%s config 0x%lx\n", __func__, *configs);
  755. switch (pinconf_to_config_param(*configs)) {
  756. case PIN_CONFIG_BIAS_BUS_HOLD:
  757. mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  758. conf[1] |= MADERA_GP1_PU | MADERA_GP1_PD;
  759. break;
  760. case PIN_CONFIG_BIAS_DISABLE:
  761. mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  762. conf[1] &= ~(MADERA_GP1_PU | MADERA_GP1_PD);
  763. break;
  764. case PIN_CONFIG_BIAS_PULL_DOWN:
  765. mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  766. conf[1] |= MADERA_GP1_PD;
  767. conf[1] &= ~MADERA_GP1_PU;
  768. break;
  769. case PIN_CONFIG_BIAS_PULL_UP:
  770. mask[1] |= MADERA_GP1_PU_MASK | MADERA_GP1_PD_MASK;
  771. conf[1] |= MADERA_GP1_PU;
  772. conf[1] &= ~MADERA_GP1_PD;
  773. break;
  774. case PIN_CONFIG_DRIVE_OPEN_DRAIN:
  775. mask[0] |= MADERA_GP1_OP_CFG_MASK;
  776. conf[0] |= MADERA_GP1_OP_CFG;
  777. break;
  778. case PIN_CONFIG_DRIVE_PUSH_PULL:
  779. mask[0] |= MADERA_GP1_OP_CFG_MASK;
  780. conf[0] &= ~MADERA_GP1_OP_CFG;
  781. break;
  782. case PIN_CONFIG_DRIVE_STRENGTH:
  783. val = pinconf_to_config_argument(*configs);
  784. mask[1] |= MADERA_GP1_DRV_STR_MASK;
  785. conf[1] &= ~MADERA_GP1_DRV_STR_MASK;
  786. conf[1] |= madera_pin_make_drv_str(priv, val);
  787. break;
  788. case PIN_CONFIG_INPUT_DEBOUNCE:
  789. mask[0] |= MADERA_GP1_DB_MASK;
  790. /*
  791. * we can't configure debounce time per-pin so value
  792. * is just a flag
  793. */
  794. val = pinconf_to_config_argument(*configs);
  795. if (val)
  796. conf[0] |= MADERA_GP1_DB;
  797. else
  798. conf[0] &= ~MADERA_GP1_DB;
  799. break;
  800. case PIN_CONFIG_INPUT_ENABLE:
  801. val = pinconf_to_config_argument(*configs);
  802. mask[1] |= MADERA_GP1_DIR_MASK;
  803. if (val)
  804. conf[1] |= MADERA_GP1_DIR;
  805. else
  806. conf[1] &= ~MADERA_GP1_DIR;
  807. break;
  808. case PIN_CONFIG_INPUT_SCHMITT:
  809. val = pinconf_to_config_argument(*configs);
  810. mask[0] |= MADERA_GP1_IP_CFG;
  811. if (val)
  812. conf[0] |= MADERA_GP1_IP_CFG;
  813. else
  814. conf[0] &= ~MADERA_GP1_IP_CFG;
  815. mask[1] |= MADERA_GP1_DIR_MASK;
  816. conf[1] |= MADERA_GP1_DIR;
  817. break;
  818. case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
  819. mask[0] |= MADERA_GP1_IP_CFG;
  820. conf[0] |= MADERA_GP1_IP_CFG;
  821. mask[1] |= MADERA_GP1_DIR_MASK;
  822. conf[1] |= MADERA_GP1_DIR;
  823. break;
  824. case PIN_CONFIG_OUTPUT:
  825. val = pinconf_to_config_argument(*configs);
  826. mask[0] |= MADERA_GP1_LVL_MASK;
  827. if (val)
  828. conf[0] |= MADERA_GP1_LVL;
  829. else
  830. conf[0] &= ~MADERA_GP1_LVL;
  831. mask[1] |= MADERA_GP1_DIR_MASK;
  832. conf[1] &= ~MADERA_GP1_DIR;
  833. break;
  834. default:
  835. return -ENOTSUPP;
  836. }
  837. ++configs;
  838. --num_configs;
  839. }
  840. dev_dbg(priv->dev,
  841. "%s gpio%d 0x%x:0x%x 0x%x:0x%x\n",
  842. __func__, pin + 1, reg, conf[0], reg + 1, conf[1]);
  843. ret = regmap_update_bits(priv->madera->regmap, reg, mask[0], conf[0]);
  844. if (ret)
  845. goto err;
  846. ++reg;
  847. ret = regmap_update_bits(priv->madera->regmap, reg, mask[1], conf[1]);
  848. if (ret)
  849. goto err;
  850. return 0;
  851. err:
  852. dev_err(priv->dev,
  853. "Failed to write GPIO%d conf (%d) reg 0x%x\n",
  854. pin + 1, ret, reg);
  855. return ret;
  856. }
  857. static int madera_pin_conf_group_set(struct pinctrl_dev *pctldev,
  858. unsigned int selector,
  859. unsigned long *configs,
  860. unsigned int num_configs)
  861. {
  862. struct madera_pin_private *priv = pinctrl_dev_get_drvdata(pctldev);
  863. const struct madera_pin_groups *pin_group;
  864. unsigned int n_groups = priv->chip->n_pin_groups;
  865. int i, ret;
  866. dev_dbg(priv->dev, "%s setting group %s\n", __func__,
  867. madera_get_group_name(pctldev, selector));
  868. if (selector >= n_groups) {
  869. /* group is a single pin, convert to pin number and set */
  870. return madera_pin_conf_set(pctldev,
  871. selector - n_groups,
  872. configs,
  873. num_configs);
  874. } else {
  875. pin_group = &priv->chip->pin_groups[selector];
  876. for (i = 0; i < pin_group->n_pins; ++i) {
  877. ret = madera_pin_conf_set(pctldev,
  878. pin_group->pins[i],
  879. configs,
  880. num_configs);
  881. if (ret)
  882. return ret;
  883. }
  884. }
  885. return 0;
  886. }
  887. static const struct pinconf_ops madera_pin_conf_ops = {
  888. .is_generic = true,
  889. .pin_config_get = madera_pin_conf_get,
  890. .pin_config_set = madera_pin_conf_set,
  891. .pin_config_group_set = madera_pin_conf_group_set,
  892. };
  893. static struct pinctrl_desc madera_pin_desc = {
  894. .name = "madera-pinctrl",
  895. .pins = madera_pins,
  896. .pctlops = &madera_pin_group_ops,
  897. .pmxops = &madera_pin_mux_ops,
  898. .confops = &madera_pin_conf_ops,
  899. .owner = THIS_MODULE,
  900. };
  901. static int madera_pin_probe(struct platform_device *pdev)
  902. {
  903. struct madera *madera = dev_get_drvdata(pdev->dev.parent);
  904. const struct madera_pdata *pdata = &madera->pdata;
  905. struct madera_pin_private *priv;
  906. int ret;
  907. BUILD_BUG_ON(ARRAY_SIZE(madera_pin_single_group_names) !=
  908. ARRAY_SIZE(madera_pin_single_group_pins));
  909. dev_dbg(&pdev->dev, "%s\n", __func__);
  910. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  911. if (!priv)
  912. return -ENOMEM;
  913. priv->dev = &pdev->dev;
  914. priv->madera = madera;
  915. pdev->dev.of_node = madera->dev->of_node;
  916. switch (madera->type) {
  917. case CS47L15:
  918. if (IS_ENABLED(CONFIG_PINCTRL_CS47L15))
  919. priv->chip = &cs47l15_pin_chip;
  920. break;
  921. case CS47L35:
  922. if (IS_ENABLED(CONFIG_PINCTRL_CS47L35))
  923. priv->chip = &cs47l35_pin_chip;
  924. break;
  925. case CS47L85:
  926. case WM1840:
  927. if (IS_ENABLED(CONFIG_PINCTRL_CS47L85))
  928. priv->chip = &cs47l85_pin_chip;
  929. break;
  930. case CS47L90:
  931. case CS47L91:
  932. if (IS_ENABLED(CONFIG_PINCTRL_CS47L90))
  933. priv->chip = &cs47l90_pin_chip;
  934. break;
  935. case CS42L92:
  936. case CS47L92:
  937. case CS47L93:
  938. if (IS_ENABLED(CONFIG_PINCTRL_CS47L92))
  939. priv->chip = &cs47l92_pin_chip;
  940. break;
  941. default:
  942. break;
  943. }
  944. if (!priv->chip)
  945. return -ENODEV;
  946. madera_pin_desc.npins = priv->chip->n_pins;
  947. ret = devm_pinctrl_register_and_init(&pdev->dev,
  948. &madera_pin_desc,
  949. priv,
  950. &priv->pctl);
  951. if (ret) {
  952. dev_err(priv->dev, "Failed pinctrl register (%d)\n", ret);
  953. return ret;
  954. }
  955. /* if the configuration is provided through pdata, apply it */
  956. if (pdata->gpio_configs) {
  957. ret = pinctrl_register_mappings(pdata->gpio_configs,
  958. pdata->n_gpio_configs);
  959. if (ret) {
  960. dev_err(priv->dev,
  961. "Failed to register pdata mappings (%d)\n",
  962. ret);
  963. return ret;
  964. }
  965. }
  966. ret = pinctrl_enable(priv->pctl);
  967. if (ret) {
  968. dev_err(priv->dev, "Failed to enable pinctrl (%d)\n", ret);
  969. return ret;
  970. }
  971. platform_set_drvdata(pdev, priv);
  972. dev_dbg(priv->dev, "pinctrl probed ok\n");
  973. return 0;
  974. }
  975. static int madera_pin_remove(struct platform_device *pdev)
  976. {
  977. struct madera_pin_private *priv = platform_get_drvdata(pdev);
  978. if (priv->madera->pdata.gpio_configs)
  979. pinctrl_unregister_mappings(priv->madera->pdata.gpio_configs);
  980. return 0;
  981. }
  982. static struct platform_driver madera_pin_driver = {
  983. .probe = madera_pin_probe,
  984. .remove = madera_pin_remove,
  985. .driver = {
  986. .name = "madera-pinctrl",
  987. },
  988. };
  989. module_platform_driver(madera_pin_driver);
  990. MODULE_DESCRIPTION("Madera pinctrl driver");
  991. MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
  992. MODULE_LICENSE("GPL v2");