cpm-serial.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * CPM serial console support.
  4. *
  5. * Copyright 2007 Freescale Semiconductor, Inc.
  6. * Author: Scott Wood <scottwood@freescale.com>
  7. *
  8. * It is assumed that the firmware (or the platform file) has already set
  9. * up the port.
  10. */
  11. #include "types.h"
  12. #include "io.h"
  13. #include "ops.h"
  14. #include "page.h"
  15. struct cpm_scc {
  16. u32 gsmrl;
  17. u32 gsmrh;
  18. u16 psmr;
  19. u8 res1[2];
  20. u16 todr;
  21. u16 dsr;
  22. u16 scce;
  23. u8 res2[2];
  24. u16 sccm;
  25. u8 res3;
  26. u8 sccs;
  27. u8 res4[8];
  28. };
  29. struct cpm_smc {
  30. u8 res1[2];
  31. u16 smcmr;
  32. u8 res2[2];
  33. u8 smce;
  34. u8 res3[3];
  35. u8 smcm;
  36. u8 res4[5];
  37. };
  38. struct cpm_param {
  39. u16 rbase;
  40. u16 tbase;
  41. u8 rfcr;
  42. u8 tfcr;
  43. u16 mrblr;
  44. u32 rstate;
  45. u8 res1[4];
  46. u16 rbptr;
  47. u8 res2[6];
  48. u32 tstate;
  49. u8 res3[4];
  50. u16 tbptr;
  51. u8 res4[6];
  52. u16 maxidl;
  53. u16 idlc;
  54. u16 brkln;
  55. u16 brkec;
  56. u16 brkcr;
  57. u16 rmask;
  58. u8 res5[4];
  59. };
  60. struct cpm_bd {
  61. u16 sc; /* Status and Control */
  62. u16 len; /* Data length in buffer */
  63. u8 *addr; /* Buffer address in host memory */
  64. };
  65. static void *cpcr;
  66. static struct cpm_param *param;
  67. static struct cpm_smc *smc;
  68. static struct cpm_scc *scc;
  69. static struct cpm_bd *tbdf, *rbdf;
  70. static u32 cpm_cmd;
  71. static void *cbd_addr;
  72. static u32 cbd_offset;
  73. static void (*do_cmd)(int op);
  74. static void (*enable_port)(void);
  75. static void (*disable_port)(void);
  76. #define CPM_CMD_STOP_TX 4
  77. #define CPM_CMD_RESTART_TX 6
  78. #define CPM_CMD_INIT_RX_TX 0
  79. static void cpm1_cmd(int op)
  80. {
  81. while (in_be16(cpcr) & 1)
  82. ;
  83. out_be16(cpcr, (op << 8) | cpm_cmd | 1);
  84. while (in_be16(cpcr) & 1)
  85. ;
  86. }
  87. static void cpm2_cmd(int op)
  88. {
  89. while (in_be32(cpcr) & 0x10000)
  90. ;
  91. out_be32(cpcr, op | cpm_cmd | 0x10000);
  92. while (in_be32(cpcr) & 0x10000)
  93. ;
  94. }
  95. static void smc_disable_port(void)
  96. {
  97. do_cmd(CPM_CMD_STOP_TX);
  98. out_be16(&smc->smcmr, in_be16(&smc->smcmr) & ~3);
  99. }
  100. static void scc_disable_port(void)
  101. {
  102. do_cmd(CPM_CMD_STOP_TX);
  103. out_be32(&scc->gsmrl, in_be32(&scc->gsmrl) & ~0x30);
  104. }
  105. static void smc_enable_port(void)
  106. {
  107. out_be16(&smc->smcmr, in_be16(&smc->smcmr) | 3);
  108. do_cmd(CPM_CMD_RESTART_TX);
  109. }
  110. static void scc_enable_port(void)
  111. {
  112. out_be32(&scc->gsmrl, in_be32(&scc->gsmrl) | 0x30);
  113. do_cmd(CPM_CMD_RESTART_TX);
  114. }
  115. static int cpm_serial_open(void)
  116. {
  117. disable_port();
  118. out_8(&param->rfcr, 0x10);
  119. out_8(&param->tfcr, 0x10);
  120. out_be16(&param->mrblr, 1);
  121. out_be16(&param->maxidl, 0);
  122. out_be16(&param->brkec, 0);
  123. out_be16(&param->brkln, 0);
  124. out_be16(&param->brkcr, 0);
  125. rbdf = cbd_addr;
  126. rbdf->addr = (u8 *)rbdf - 1;
  127. rbdf->sc = 0xa000;
  128. rbdf->len = 1;
  129. tbdf = rbdf + 1;
  130. tbdf->addr = (u8 *)rbdf - 2;
  131. tbdf->sc = 0x2000;
  132. tbdf->len = 1;
  133. sync();
  134. out_be16(&param->rbase, cbd_offset);
  135. out_be16(&param->tbase, cbd_offset + sizeof(struct cpm_bd));
  136. do_cmd(CPM_CMD_INIT_RX_TX);
  137. enable_port();
  138. return 0;
  139. }
  140. static void cpm_serial_putc(unsigned char c)
  141. {
  142. while (tbdf->sc & 0x8000)
  143. barrier();
  144. sync();
  145. tbdf->addr[0] = c;
  146. eieio();
  147. tbdf->sc |= 0x8000;
  148. }
  149. static unsigned char cpm_serial_tstc(void)
  150. {
  151. barrier();
  152. return !(rbdf->sc & 0x8000);
  153. }
  154. static unsigned char cpm_serial_getc(void)
  155. {
  156. unsigned char c;
  157. while (!cpm_serial_tstc())
  158. ;
  159. sync();
  160. c = rbdf->addr[0];
  161. eieio();
  162. rbdf->sc |= 0x8000;
  163. return c;
  164. }
  165. int cpm_console_init(void *devp, struct serial_console_data *scdp)
  166. {
  167. void *vreg[2];
  168. u32 reg[2];
  169. int is_smc = 0, is_cpm2 = 0;
  170. void *parent, *muram;
  171. void *muram_addr;
  172. unsigned long muram_offset, muram_size;
  173. if (dt_is_compatible(devp, "fsl,cpm1-smc-uart")) {
  174. is_smc = 1;
  175. } else if (dt_is_compatible(devp, "fsl,cpm2-scc-uart")) {
  176. is_cpm2 = 1;
  177. } else if (dt_is_compatible(devp, "fsl,cpm2-smc-uart")) {
  178. is_cpm2 = 1;
  179. is_smc = 1;
  180. }
  181. if (is_smc) {
  182. enable_port = smc_enable_port;
  183. disable_port = smc_disable_port;
  184. } else {
  185. enable_port = scc_enable_port;
  186. disable_port = scc_disable_port;
  187. }
  188. if (is_cpm2)
  189. do_cmd = cpm2_cmd;
  190. else
  191. do_cmd = cpm1_cmd;
  192. if (getprop(devp, "fsl,cpm-command", &cpm_cmd, 4) < 4)
  193. return -1;
  194. if (dt_get_virtual_reg(devp, vreg, 2) < 2)
  195. return -1;
  196. if (is_smc)
  197. smc = vreg[0];
  198. else
  199. scc = vreg[0];
  200. param = vreg[1];
  201. parent = get_parent(devp);
  202. if (!parent)
  203. return -1;
  204. if (dt_get_virtual_reg(parent, &cpcr, 1) < 1)
  205. return -1;
  206. muram = finddevice("/soc/cpm/muram/data");
  207. if (!muram)
  208. return -1;
  209. /* For bootwrapper-compatible device trees, we assume that the first
  210. * entry has at least 128 bytes, and that #address-cells/#data-cells
  211. * is one for both parent and child.
  212. */
  213. if (dt_get_virtual_reg(muram, &muram_addr, 1) < 1)
  214. return -1;
  215. if (getprop(muram, "reg", reg, 8) < 8)
  216. return -1;
  217. muram_offset = reg[0];
  218. muram_size = reg[1];
  219. /* Store the buffer descriptors at the end of the first muram chunk.
  220. * For SMC ports on CPM2-based platforms, relocate the parameter RAM
  221. * just before the buffer descriptors.
  222. */
  223. cbd_offset = muram_offset + muram_size - 2 * sizeof(struct cpm_bd);
  224. if (is_cpm2 && is_smc) {
  225. u16 *smc_base = (u16 *)param;
  226. u16 pram_offset;
  227. pram_offset = cbd_offset - 64;
  228. pram_offset = _ALIGN_DOWN(pram_offset, 64);
  229. disable_port();
  230. out_be16(smc_base, pram_offset);
  231. param = muram_addr - muram_offset + pram_offset;
  232. }
  233. cbd_addr = muram_addr - muram_offset + cbd_offset;
  234. scdp->open = cpm_serial_open;
  235. scdp->putc = cpm_serial_putc;
  236. scdp->getc = cpm_serial_getc;
  237. scdp->tstc = cpm_serial_tstc;
  238. return 0;
  239. }