serial.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431
  1. /*
  2. * (C) Copyright 2000 - 2010
  3. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  4. *
  5. * SPDX-License-Identifier: GPL-2.0+
  6. *
  7. * Based ont the MPC5200 PSC driver.
  8. * Adapted for MPC512x by Jan Wrobel <wrr@semihalf.com>
  9. */
  10. /*
  11. * Minimal serial functions needed to use one of the PSC ports
  12. * as serial console interface.
  13. */
  14. #include <common.h>
  15. #include <linux/compiler.h>
  16. #include <asm/io.h>
  17. #include <asm/processor.h>
  18. #include <serial.h>
  19. DECLARE_GLOBAL_DATA_PTR;
  20. #if defined(CONFIG_PSC_CONSOLE)
  21. static void fifo_init (volatile psc512x_t *psc)
  22. {
  23. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  24. u32 tfsize, rfsize;
  25. /* reset Rx & Tx fifo slice */
  26. out_be32(&psc->rfcmd, PSC_FIFO_RESET_SLICE);
  27. out_be32(&psc->tfcmd, PSC_FIFO_RESET_SLICE);
  28. /* disable Tx & Rx FIFO interrupts */
  29. out_be32(&psc->rfintmask, 0);
  30. out_be32(&psc->tfintmask, 0);
  31. switch (((u32)psc & 0xf00) >> 8) {
  32. case 0:
  33. tfsize = FIFOC_PSC0_TX_SIZE | (FIFOC_PSC0_TX_ADDR << 16);
  34. rfsize = FIFOC_PSC0_RX_SIZE | (FIFOC_PSC0_RX_ADDR << 16);
  35. break;
  36. case 1:
  37. tfsize = FIFOC_PSC1_TX_SIZE | (FIFOC_PSC1_TX_ADDR << 16);
  38. rfsize = FIFOC_PSC1_RX_SIZE | (FIFOC_PSC1_RX_ADDR << 16);
  39. break;
  40. case 2:
  41. tfsize = FIFOC_PSC2_TX_SIZE | (FIFOC_PSC2_TX_ADDR << 16);
  42. rfsize = FIFOC_PSC2_RX_SIZE | (FIFOC_PSC2_RX_ADDR << 16);
  43. break;
  44. case 3:
  45. tfsize = FIFOC_PSC3_TX_SIZE | (FIFOC_PSC3_TX_ADDR << 16);
  46. rfsize = FIFOC_PSC3_RX_SIZE | (FIFOC_PSC3_RX_ADDR << 16);
  47. break;
  48. case 4:
  49. tfsize = FIFOC_PSC4_TX_SIZE | (FIFOC_PSC4_TX_ADDR << 16);
  50. rfsize = FIFOC_PSC4_RX_SIZE | (FIFOC_PSC4_RX_ADDR << 16);
  51. break;
  52. case 5:
  53. tfsize = FIFOC_PSC5_TX_SIZE | (FIFOC_PSC5_TX_ADDR << 16);
  54. rfsize = FIFOC_PSC5_RX_SIZE | (FIFOC_PSC5_RX_ADDR << 16);
  55. break;
  56. case 6:
  57. tfsize = FIFOC_PSC6_TX_SIZE | (FIFOC_PSC6_TX_ADDR << 16);
  58. rfsize = FIFOC_PSC6_RX_SIZE | (FIFOC_PSC6_RX_ADDR << 16);
  59. break;
  60. case 7:
  61. tfsize = FIFOC_PSC7_TX_SIZE | (FIFOC_PSC7_TX_ADDR << 16);
  62. rfsize = FIFOC_PSC7_RX_SIZE | (FIFOC_PSC7_RX_ADDR << 16);
  63. break;
  64. case 8:
  65. tfsize = FIFOC_PSC8_TX_SIZE | (FIFOC_PSC8_TX_ADDR << 16);
  66. rfsize = FIFOC_PSC8_RX_SIZE | (FIFOC_PSC8_RX_ADDR << 16);
  67. break;
  68. case 9:
  69. tfsize = FIFOC_PSC9_TX_SIZE | (FIFOC_PSC9_TX_ADDR << 16);
  70. rfsize = FIFOC_PSC9_RX_SIZE | (FIFOC_PSC9_RX_ADDR << 16);
  71. break;
  72. case 10:
  73. tfsize = FIFOC_PSC10_TX_SIZE | (FIFOC_PSC10_TX_ADDR << 16);
  74. rfsize = FIFOC_PSC10_RX_SIZE | (FIFOC_PSC10_RX_ADDR << 16);
  75. break;
  76. case 11:
  77. tfsize = FIFOC_PSC11_TX_SIZE | (FIFOC_PSC11_TX_ADDR << 16);
  78. rfsize = FIFOC_PSC11_RX_SIZE | (FIFOC_PSC11_RX_ADDR << 16);
  79. break;
  80. default:
  81. return;
  82. }
  83. out_be32(&psc->tfsize, tfsize);
  84. out_be32(&psc->rfsize, rfsize);
  85. /* enable Tx & Rx FIFO slice */
  86. out_be32(&psc->rfcmd, PSC_FIFO_ENABLE_SLICE);
  87. out_be32(&psc->tfcmd, PSC_FIFO_ENABLE_SLICE);
  88. out_be32(&im->fifoc.fifoc_cmd, FIFOC_DISABLE_CLOCK_GATE);
  89. __asm__ volatile ("sync");
  90. }
  91. void serial_setbrg_dev(unsigned int idx)
  92. {
  93. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  94. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  95. unsigned long baseclk, div;
  96. unsigned long baudrate;
  97. char buf[16];
  98. char *br_env;
  99. baudrate = gd->baudrate;
  100. if (idx != CONFIG_PSC_CONSOLE) {
  101. /* Allows setting baudrate for other serial devices
  102. * on PSCx using environment. If not specified, use
  103. * the same baudrate as for console.
  104. */
  105. sprintf(buf, "psc%d_baudrate", idx);
  106. br_env = getenv(buf);
  107. if (br_env)
  108. baudrate = simple_strtoul(br_env, NULL, 10);
  109. debug("%s: idx %d, baudrate %ld\n", __func__, idx, baudrate);
  110. }
  111. /* calculate divisor for setting PSC CTUR and CTLR registers */
  112. baseclk = (gd->arch.ips_clk + 8) / 16;
  113. div = (baseclk + (baudrate / 2)) / baudrate;
  114. out_8(&psc->ctur, (div >> 8) & 0xff);
  115. out_8(&psc->ctlr, div & 0xff); /* set baudrate */
  116. }
  117. int serial_init_dev(unsigned int idx)
  118. {
  119. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  120. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  121. u32 reg;
  122. reg = in_be32(&im->clk.sccr[0]);
  123. out_be32(&im->clk.sccr[0], reg | CLOCK_SCCR1_PSC_EN(idx));
  124. fifo_init (psc);
  125. /* set MR register to point to MR1 */
  126. out_8(&psc->command, PSC_SEL_MODE_REG_1);
  127. /* disable Tx/Rx */
  128. out_8(&psc->command, PSC_TX_DISABLE | PSC_RX_DISABLE);
  129. /* choose the prescaler by 16 for the Tx/Rx clock generation */
  130. out_be16(&psc->psc_clock_select, 0xdd00);
  131. /* switch to UART mode */
  132. out_be32(&psc->sicr, 0);
  133. /* mode register points to mr1 */
  134. /* configure parity, bit length and so on in mode register 1*/
  135. out_8(&psc->mode, PSC_MODE_8_BITS | PSC_MODE_PARNONE);
  136. /* now, mode register points to mr2 */
  137. out_8(&psc->mode, PSC_MODE_1_STOPBIT);
  138. /* set baudrate */
  139. serial_setbrg_dev(idx);
  140. /* disable all interrupts */
  141. out_be16(&psc->psc_imr, 0);
  142. /* reset and enable Rx/Tx */
  143. out_8(&psc->command, PSC_RST_RX);
  144. out_8(&psc->command, PSC_RST_TX);
  145. out_8(&psc->command, PSC_RX_ENABLE | PSC_TX_ENABLE);
  146. return 0;
  147. }
  148. int serial_uninit_dev(unsigned int idx)
  149. {
  150. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  151. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  152. u32 reg;
  153. out_8(&psc->command, PSC_RX_DISABLE | PSC_TX_DISABLE);
  154. reg = in_be32(&im->clk.sccr[0]);
  155. reg &= ~CLOCK_SCCR1_PSC_EN(idx);
  156. out_be32(&im->clk.sccr[0], reg);
  157. return 0;
  158. }
  159. void serial_putc_dev(unsigned int idx, const char c)
  160. {
  161. volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
  162. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  163. if (c == '\n')
  164. serial_putc_dev(idx, '\r');
  165. /* Wait for last character to go. */
  166. while (!(in_be16(&psc->psc_status) & PSC_SR_TXEMP))
  167. ;
  168. out_8(&psc->tfdata_8, c);
  169. }
  170. void serial_puts_dev(unsigned int idx, const char *s)
  171. {
  172. while (*s)
  173. serial_putc_dev(idx, *s++);
  174. }
  175. int serial_getc_dev(unsigned int idx)
  176. {
  177. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  178. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  179. /* Wait for a character to arrive. */
  180. while (in_be32(&psc->rfstat) & PSC_FIFO_EMPTY)
  181. ;
  182. return in_8(&psc->rfdata_8);
  183. }
  184. int serial_tstc_dev(unsigned int idx)
  185. {
  186. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  187. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  188. return !(in_be32(&psc->rfstat) & PSC_FIFO_EMPTY);
  189. }
  190. void serial_setrts_dev(unsigned int idx, int s)
  191. {
  192. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  193. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  194. if (s) {
  195. /* Assert RTS (become LOW) */
  196. out_8(&psc->op1, 0x1);
  197. }
  198. else {
  199. /* Negate RTS (become HIGH) */
  200. out_8(&psc->op0, 0x1);
  201. }
  202. }
  203. int serial_getcts_dev(unsigned int idx)
  204. {
  205. volatile immap_t *im = (immap_t *) CONFIG_SYS_IMMR;
  206. volatile psc512x_t *psc = (psc512x_t *) &im->psc[idx];
  207. return (in_8(&psc->ip) & 0x1) ? 0 : 1;
  208. }
  209. #endif /* CONFIG_PSC_CONSOLE */
  210. #define DECLARE_PSC_SERIAL_FUNCTIONS(port) \
  211. int serial##port##_init(void) \
  212. { \
  213. return serial_init_dev(port); \
  214. } \
  215. int serial##port##_uninit(void) \
  216. { \
  217. return serial_uninit_dev(port); \
  218. } \
  219. void serial##port##_setbrg(void) \
  220. { \
  221. serial_setbrg_dev(port); \
  222. } \
  223. int serial##port##_getc(void) \
  224. { \
  225. return serial_getc_dev(port); \
  226. } \
  227. int serial##port##_tstc(void) \
  228. { \
  229. return serial_tstc_dev(port); \
  230. } \
  231. void serial##port##_putc(const char c) \
  232. { \
  233. serial_putc_dev(port, c); \
  234. } \
  235. void serial##port##_puts(const char *s) \
  236. { \
  237. serial_puts_dev(port, s); \
  238. }
  239. #define INIT_PSC_SERIAL_STRUCTURE(port, __name) { \
  240. .name = __name, \
  241. .start = serial##port##_init, \
  242. .stop = serial##port##_uninit, \
  243. .setbrg = serial##port##_setbrg, \
  244. .getc = serial##port##_getc, \
  245. .tstc = serial##port##_tstc, \
  246. .putc = serial##port##_putc, \
  247. .puts = serial##port##_puts, \
  248. }
  249. #if defined(CONFIG_SYS_PSC1)
  250. DECLARE_PSC_SERIAL_FUNCTIONS(1);
  251. struct serial_device serial1_device =
  252. INIT_PSC_SERIAL_STRUCTURE(1, "psc1");
  253. #endif
  254. #if defined(CONFIG_SYS_PSC3)
  255. DECLARE_PSC_SERIAL_FUNCTIONS(3);
  256. struct serial_device serial3_device =
  257. INIT_PSC_SERIAL_STRUCTURE(3, "psc3");
  258. #endif
  259. #if defined(CONFIG_SYS_PSC4)
  260. DECLARE_PSC_SERIAL_FUNCTIONS(4);
  261. struct serial_device serial4_device =
  262. INIT_PSC_SERIAL_STRUCTURE(4, "psc4");
  263. #endif
  264. #if defined(CONFIG_SYS_PSC6)
  265. DECLARE_PSC_SERIAL_FUNCTIONS(6);
  266. struct serial_device serial6_device =
  267. INIT_PSC_SERIAL_STRUCTURE(6, "psc6");
  268. #endif
  269. __weak struct serial_device *default_serial_console(void)
  270. {
  271. #if (CONFIG_PSC_CONSOLE == 3)
  272. return &serial3_device;
  273. #elif (CONFIG_PSC_CONSOLE == 6)
  274. return &serial6_device;
  275. #else
  276. #error "invalid CONFIG_PSC_CONSOLE"
  277. #endif
  278. }
  279. void mpc512x_serial_initialize(void)
  280. {
  281. #if defined(CONFIG_SYS_PSC1)
  282. serial_register(&serial1_device);
  283. #endif
  284. #if defined(CONFIG_SYS_PSC3)
  285. serial_register(&serial3_device);
  286. #endif
  287. #if defined(CONFIG_SYS_PSC4)
  288. serial_register(&serial4_device);
  289. #endif
  290. #if defined(CONFIG_SYS_PSC6)
  291. serial_register(&serial6_device);
  292. #endif
  293. }
  294. #include <stdio_dev.h>
  295. /*
  296. * Routines for communication with serial devices over PSC
  297. */
  298. /* Bitfield for initialized PSCs */
  299. static unsigned int initialized;
  300. struct stdio_dev *open_port(int num, int baudrate)
  301. {
  302. struct stdio_dev *port;
  303. char env_var[16];
  304. char env_val[10];
  305. char name[7];
  306. if (num < 0 || num > 11)
  307. return NULL;
  308. sprintf(name, "psc%d", num);
  309. port = stdio_get_by_name(name);
  310. if (!port)
  311. return NULL;
  312. if (!test_bit(num, &initialized)) {
  313. sprintf(env_var, "psc%d_baudrate", num);
  314. sprintf(env_val, "%d", baudrate);
  315. setenv(env_var, env_val);
  316. if (port->start(port))
  317. return NULL;
  318. set_bit(num, &initialized);
  319. }
  320. return port;
  321. }
  322. int close_port(int num)
  323. {
  324. struct stdio_dev *port;
  325. int ret;
  326. char name[7];
  327. if (num < 0 || num > 11)
  328. return -1;
  329. sprintf(name, "psc%d", num);
  330. port = stdio_get_by_name(name);
  331. if (!port)
  332. return -1;
  333. ret = port->stop(port);
  334. clear_bit(num, &initialized);
  335. return ret;
  336. }
  337. int write_port(struct stdio_dev *port, char *buf)
  338. {
  339. if (!port || !buf)
  340. return -1;
  341. port->puts(port, buf);
  342. return 0;
  343. }
  344. int read_port(struct stdio_dev *port, char *buf, int size)
  345. {
  346. int cnt = 0;
  347. if (!port || !buf)
  348. return -1;
  349. if (!size)
  350. return 0;
  351. while (port->tstc(port)) {
  352. buf[cnt++] = port->getc(port);
  353. if (cnt > size)
  354. break;
  355. }
  356. return cnt;
  357. }