riscv_asm.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275
  1. /*
  2. * SPDX-License-Identifier: BSD-2-Clause
  3. *
  4. * Copyright (c) 2019 Western Digital Corporation or its affiliates.
  5. *
  6. * Authors:
  7. * Anup Patel <anup.patel@wdc.com>
  8. */
  9. #include <sbi/riscv_asm.h>
  10. #include <sbi/riscv_encoding.h>
  11. #include <sbi/sbi_error.h>
  12. unsigned long csr_read_num(int csr_num)
  13. {
  14. unsigned long ret = 0;
  15. switch (csr_num) {
  16. case CSR_PMPCFG0:
  17. ret = csr_read(CSR_PMPCFG0);
  18. break;
  19. case CSR_PMPCFG1:
  20. ret = csr_read(CSR_PMPCFG1);
  21. break;
  22. case CSR_PMPCFG2:
  23. ret = csr_read(CSR_PMPCFG2);
  24. break;
  25. case CSR_PMPCFG3:
  26. ret = csr_read(CSR_PMPCFG3);
  27. break;
  28. case CSR_PMPADDR0:
  29. ret = csr_read(CSR_PMPADDR0);
  30. break;
  31. case CSR_PMPADDR1:
  32. ret = csr_read(CSR_PMPADDR1);
  33. break;
  34. case CSR_PMPADDR2:
  35. ret = csr_read(CSR_PMPADDR2);
  36. break;
  37. case CSR_PMPADDR3:
  38. ret = csr_read(CSR_PMPADDR3);
  39. break;
  40. case CSR_PMPADDR4:
  41. ret = csr_read(CSR_PMPADDR4);
  42. break;
  43. case CSR_PMPADDR5:
  44. ret = csr_read(CSR_PMPADDR5);
  45. break;
  46. case CSR_PMPADDR6:
  47. ret = csr_read(CSR_PMPADDR6);
  48. break;
  49. case CSR_PMPADDR7:
  50. ret = csr_read(CSR_PMPADDR7);
  51. break;
  52. case CSR_PMPADDR8:
  53. ret = csr_read(CSR_PMPADDR8);
  54. break;
  55. case CSR_PMPADDR9:
  56. ret = csr_read(CSR_PMPADDR9);
  57. break;
  58. case CSR_PMPADDR10:
  59. ret = csr_read(CSR_PMPADDR10);
  60. break;
  61. case CSR_PMPADDR11:
  62. ret = csr_read(CSR_PMPADDR11);
  63. break;
  64. case CSR_PMPADDR12:
  65. ret = csr_read(CSR_PMPADDR12);
  66. break;
  67. case CSR_PMPADDR13:
  68. ret = csr_read(CSR_PMPADDR13);
  69. break;
  70. case CSR_PMPADDR14:
  71. ret = csr_read(CSR_PMPADDR14);
  72. break;
  73. case CSR_PMPADDR15:
  74. ret = csr_read(CSR_PMPADDR15);
  75. break;
  76. default:
  77. break;
  78. };
  79. return ret;
  80. }
  81. void csr_write_num(int csr_num, unsigned long val)
  82. {
  83. switch (csr_num) {
  84. case CSR_PMPCFG0:
  85. csr_write(CSR_PMPCFG0, val);
  86. break;
  87. case CSR_PMPCFG1:
  88. csr_write(CSR_PMPCFG1, val);
  89. break;
  90. case CSR_PMPCFG2:
  91. csr_write(CSR_PMPCFG2, val);
  92. break;
  93. case CSR_PMPCFG3:
  94. csr_write(CSR_PMPCFG3, val);
  95. break;
  96. case CSR_PMPADDR0:
  97. csr_write(CSR_PMPADDR0, val);
  98. break;
  99. case CSR_PMPADDR1:
  100. csr_write(CSR_PMPADDR1, val);
  101. break;
  102. case CSR_PMPADDR2:
  103. csr_write(CSR_PMPADDR2, val);
  104. break;
  105. case CSR_PMPADDR3:
  106. csr_write(CSR_PMPADDR3, val);
  107. break;
  108. case CSR_PMPADDR4:
  109. csr_write(CSR_PMPADDR4, val);
  110. break;
  111. case CSR_PMPADDR5:
  112. csr_write(CSR_PMPADDR5, val);
  113. break;
  114. case CSR_PMPADDR6:
  115. csr_write(CSR_PMPADDR6, val);
  116. break;
  117. case CSR_PMPADDR7:
  118. csr_write(CSR_PMPADDR7, val);
  119. break;
  120. case CSR_PMPADDR8:
  121. csr_write(CSR_PMPADDR8, val);
  122. break;
  123. case CSR_PMPADDR9:
  124. csr_write(CSR_PMPADDR9, val);
  125. break;
  126. case CSR_PMPADDR10:
  127. csr_write(CSR_PMPADDR10, val);
  128. break;
  129. case CSR_PMPADDR11:
  130. csr_write(CSR_PMPADDR11, val);
  131. break;
  132. case CSR_PMPADDR12:
  133. csr_write(CSR_PMPADDR12, val);
  134. break;
  135. case CSR_PMPADDR13:
  136. csr_write(CSR_PMPADDR13, val);
  137. break;
  138. case CSR_PMPADDR14:
  139. csr_write(CSR_PMPADDR14, val);
  140. break;
  141. case CSR_PMPADDR15:
  142. csr_write(CSR_PMPADDR15, val);
  143. break;
  144. default:
  145. break;
  146. };
  147. }
  148. static unsigned long ctz(unsigned long x)
  149. {
  150. unsigned long ret = 0;
  151. while (!(x & 1UL)) {
  152. ret++;
  153. x = x >> 1;
  154. }
  155. return ret;
  156. }
  157. int pmp_set(unsigned int n, unsigned long prot,
  158. unsigned long addr, unsigned long log2len)
  159. {
  160. int pmpcfg_csr, pmpcfg_shift, pmpaddr_csr;
  161. unsigned long cfgmask, pmpcfg;
  162. unsigned long addrmask, pmpaddr;
  163. /* check parameters */
  164. if (n >= PMP_COUNT ||
  165. log2len > __riscv_xlen ||
  166. log2len < PMP_SHIFT)
  167. return SBI_EINVAL;
  168. /* calculate PMP register and offset */
  169. #if __riscv_xlen == 32
  170. pmpcfg_csr = CSR_PMPCFG0 + (n >> 2);
  171. pmpcfg_shift = (n & 3) << 3;
  172. #elif __riscv_xlen == 64
  173. pmpcfg_csr = (CSR_PMPCFG0 + (n >> 2)) & ~1;
  174. pmpcfg_shift = (n & 7) << 3;
  175. #else
  176. pmpcfg_csr = -1;
  177. pmpcfg_shift = -1;
  178. #endif
  179. pmpaddr_csr = CSR_PMPADDR0 + n;
  180. if (pmpcfg_csr < 0 || pmpcfg_shift < 0)
  181. return SBI_ENOTSUPP;
  182. /* encode PMP config */
  183. prot |= (log2len == PMP_SHIFT) ? PMP_A_NA4 : PMP_A_NAPOT;
  184. cfgmask = ~(0xff << pmpcfg_shift);
  185. pmpcfg = (csr_read_num(pmpcfg_csr) & cfgmask);
  186. pmpcfg |= ((prot << pmpcfg_shift) & ~cfgmask);
  187. /* encode PMP address */
  188. if (log2len == PMP_SHIFT) {
  189. pmpaddr = (addr >> PMP_SHIFT);
  190. } else {
  191. if (log2len == __riscv_xlen) {
  192. pmpaddr = -1UL;
  193. } else {
  194. addrmask = (1UL << (log2len - PMP_SHIFT)) - 1;
  195. pmpaddr = ((addr >> PMP_SHIFT) & ~addrmask);
  196. pmpaddr |= (addrmask >> 1);
  197. }
  198. }
  199. /* write csrs */
  200. csr_write_num(pmpaddr_csr, pmpaddr);
  201. csr_write_num(pmpcfg_csr, pmpcfg);
  202. return 0;
  203. }
  204. int pmp_get(unsigned int n, unsigned long *prot_out,
  205. unsigned long *addr_out, unsigned long *log2len_out)
  206. {
  207. int pmpcfg_csr, pmpcfg_shift, pmpaddr_csr;
  208. unsigned long cfgmask, pmpcfg, prot;
  209. unsigned long t1, addr, log2len;
  210. /* check parameters */
  211. if (n >= PMP_COUNT || !prot_out ||
  212. !addr_out || !log2len_out)
  213. return SBI_EINVAL;
  214. *prot_out = *addr_out = *log2len_out = 0;
  215. /* calculate PMP register and offset */
  216. #if __riscv_xlen == 32
  217. pmpcfg_csr = CSR_PMPCFG0 + (n >> 2);
  218. pmpcfg_shift = (n & 3) << 3;
  219. #elif __riscv_xlen == 64
  220. pmpcfg_csr = (CSR_PMPCFG0 + (n >> 2)) & ~1;
  221. pmpcfg_shift = (n & 7) << 3;
  222. #else
  223. pmpcfg_csr = -1;
  224. pmpcfg_shift = -1;
  225. #endif
  226. pmpaddr_csr = CSR_PMPADDR0 + n;
  227. if (pmpcfg_csr < 0 || pmpcfg_shift < 0)
  228. return SBI_ENOTSUPP;
  229. /* decode PMP config */
  230. cfgmask = (0xff << pmpcfg_shift);
  231. pmpcfg = csr_read_num(pmpcfg_csr) & cfgmask;
  232. prot = pmpcfg >> pmpcfg_shift;
  233. /* decode PMP address */
  234. if ((prot & PMP_A) == PMP_A_NAPOT) {
  235. addr = csr_read_num(pmpaddr_csr);
  236. if (addr == -1UL) {
  237. addr = 0;
  238. log2len = __riscv_xlen;
  239. } else {
  240. t1 = ctz(~addr);
  241. addr = (addr & ~((1UL << t1) - 1)) << PMP_SHIFT;
  242. log2len = (t1 + PMP_SHIFT + 1);
  243. }
  244. } else {
  245. addr = csr_read_num(pmpaddr_csr) << PMP_SHIFT;
  246. log2len = PMP_SHIFT;
  247. }
  248. /* return details */
  249. *prot_out = prot;
  250. *addr_out = addr;
  251. *log2len_out = log2len;
  252. return 0;
  253. }