clk.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. *
  4. * Copyright (C) 2010 John Crispin <[email protected]>
  5. * Copyright (C) 2013-2015 Lantiq Beteiligungs-GmbH & Co.KG
  6. */
  7. #include <linux/io.h>
  8. #include <linux/export.h>
  9. #include <linux/clk.h>
  10. #include <asm/time.h>
  11. #include <asm/irq.h>
  12. #include <asm/div64.h>
  13. #include <lantiq_soc.h>
  14. #include "../clk.h"
  15. static unsigned int ram_clocks[] = {
  16. CLOCK_167M, CLOCK_133M, CLOCK_111M, CLOCK_83M };
  17. #define DDR_HZ ram_clocks[ltq_cgu_r32(CGU_SYS) & 0x3]
  18. /* legacy xway clock */
  19. #define CGU_SYS 0x10
  20. /* vr9, ar10/grx390 clock */
  21. #define CGU_SYS_XRX 0x0c
  22. #define CGU_IF_CLK_AR10 0x24
  23. unsigned long ltq_danube_fpi_hz(void)
  24. {
  25. unsigned long ddr_clock = DDR_HZ;
  26. if (ltq_cgu_r32(CGU_SYS) & 0x40)
  27. return ddr_clock >> 1;
  28. return ddr_clock;
  29. }
  30. unsigned long ltq_danube_cpu_hz(void)
  31. {
  32. switch (ltq_cgu_r32(CGU_SYS) & 0xc) {
  33. case 0:
  34. return CLOCK_333M;
  35. case 4:
  36. return DDR_HZ;
  37. case 8:
  38. return DDR_HZ << 1;
  39. default:
  40. return DDR_HZ >> 1;
  41. }
  42. }
  43. unsigned long ltq_danube_pp32_hz(void)
  44. {
  45. unsigned int clksys = (ltq_cgu_r32(CGU_SYS) >> 7) & 3;
  46. unsigned long clk;
  47. switch (clksys) {
  48. case 1:
  49. clk = CLOCK_240M;
  50. break;
  51. case 2:
  52. clk = CLOCK_222M;
  53. break;
  54. case 3:
  55. clk = CLOCK_133M;
  56. break;
  57. default:
  58. clk = CLOCK_266M;
  59. break;
  60. }
  61. return clk;
  62. }
  63. unsigned long ltq_ar9_sys_hz(void)
  64. {
  65. if (((ltq_cgu_r32(CGU_SYS) >> 3) & 0x3) == 0x2)
  66. return CLOCK_393M;
  67. return CLOCK_333M;
  68. }
  69. unsigned long ltq_ar9_fpi_hz(void)
  70. {
  71. unsigned long sys = ltq_ar9_sys_hz();
  72. if (ltq_cgu_r32(CGU_SYS) & BIT(0))
  73. return sys / 3;
  74. else
  75. return sys / 2;
  76. }
  77. unsigned long ltq_ar9_cpu_hz(void)
  78. {
  79. if (ltq_cgu_r32(CGU_SYS) & BIT(2))
  80. return ltq_ar9_fpi_hz();
  81. else
  82. return ltq_ar9_sys_hz();
  83. }
  84. unsigned long ltq_vr9_cpu_hz(void)
  85. {
  86. unsigned int cpu_sel;
  87. unsigned long clk;
  88. cpu_sel = (ltq_cgu_r32(CGU_SYS_XRX) >> 4) & 0xf;
  89. switch (cpu_sel) {
  90. case 0:
  91. clk = CLOCK_600M;
  92. break;
  93. case 1:
  94. clk = CLOCK_500M;
  95. break;
  96. case 2:
  97. clk = CLOCK_393M;
  98. break;
  99. case 3:
  100. clk = CLOCK_333M;
  101. break;
  102. case 5:
  103. case 6:
  104. clk = CLOCK_196_608M;
  105. break;
  106. case 7:
  107. clk = CLOCK_167M;
  108. break;
  109. case 4:
  110. case 8:
  111. case 9:
  112. clk = CLOCK_125M;
  113. break;
  114. default:
  115. clk = 0;
  116. break;
  117. }
  118. return clk;
  119. }
  120. unsigned long ltq_vr9_fpi_hz(void)
  121. {
  122. unsigned int ocp_sel, cpu_clk;
  123. unsigned long clk;
  124. cpu_clk = ltq_vr9_cpu_hz();
  125. ocp_sel = ltq_cgu_r32(CGU_SYS_XRX) & 0x3;
  126. switch (ocp_sel) {
  127. case 0:
  128. /* OCP ratio 1 */
  129. clk = cpu_clk;
  130. break;
  131. case 2:
  132. /* OCP ratio 2 */
  133. clk = cpu_clk / 2;
  134. break;
  135. case 3:
  136. /* OCP ratio 2.5 */
  137. clk = (cpu_clk * 2) / 5;
  138. break;
  139. case 4:
  140. /* OCP ratio 3 */
  141. clk = cpu_clk / 3;
  142. break;
  143. default:
  144. clk = 0;
  145. break;
  146. }
  147. return clk;
  148. }
  149. unsigned long ltq_vr9_pp32_hz(void)
  150. {
  151. unsigned int clksys = (ltq_cgu_r32(CGU_SYS) >> 16) & 0x7;
  152. unsigned long clk;
  153. switch (clksys) {
  154. case 0:
  155. clk = CLOCK_500M;
  156. break;
  157. case 1:
  158. clk = CLOCK_432M;
  159. break;
  160. case 2:
  161. clk = CLOCK_288M;
  162. break;
  163. default:
  164. clk = CLOCK_500M;
  165. break;
  166. }
  167. return clk;
  168. }
  169. unsigned long ltq_ar10_cpu_hz(void)
  170. {
  171. unsigned int clksys;
  172. int cpu_fs = (ltq_cgu_r32(CGU_SYS_XRX) >> 8) & 0x1;
  173. int freq_div = (ltq_cgu_r32(CGU_SYS_XRX) >> 4) & 0x7;
  174. switch (cpu_fs) {
  175. case 0:
  176. clksys = CLOCK_500M;
  177. break;
  178. case 1:
  179. clksys = CLOCK_600M;
  180. break;
  181. default:
  182. clksys = CLOCK_500M;
  183. break;
  184. }
  185. switch (freq_div) {
  186. case 0:
  187. return clksys;
  188. case 1:
  189. return clksys >> 1;
  190. case 2:
  191. return clksys >> 2;
  192. default:
  193. return clksys;
  194. }
  195. }
  196. unsigned long ltq_ar10_fpi_hz(void)
  197. {
  198. int freq_fpi = (ltq_cgu_r32(CGU_IF_CLK_AR10) >> 25) & 0xf;
  199. switch (freq_fpi) {
  200. case 1:
  201. return CLOCK_300M;
  202. case 5:
  203. return CLOCK_250M;
  204. case 2:
  205. return CLOCK_150M;
  206. case 6:
  207. return CLOCK_125M;
  208. default:
  209. return CLOCK_125M;
  210. }
  211. }
  212. unsigned long ltq_ar10_pp32_hz(void)
  213. {
  214. unsigned int clksys = (ltq_cgu_r32(CGU_SYS) >> 16) & 0x7;
  215. unsigned long clk;
  216. switch (clksys) {
  217. case 1:
  218. clk = CLOCK_250M;
  219. break;
  220. case 4:
  221. clk = CLOCK_400M;
  222. break;
  223. default:
  224. clk = CLOCK_250M;
  225. break;
  226. }
  227. return clk;
  228. }
  229. unsigned long ltq_grx390_cpu_hz(void)
  230. {
  231. unsigned int clksys;
  232. int cpu_fs = ((ltq_cgu_r32(CGU_SYS_XRX) >> 9) & 0x3);
  233. int freq_div = ((ltq_cgu_r32(CGU_SYS_XRX) >> 4) & 0x7);
  234. switch (cpu_fs) {
  235. case 0:
  236. clksys = CLOCK_600M;
  237. break;
  238. case 1:
  239. clksys = CLOCK_666M;
  240. break;
  241. case 2:
  242. clksys = CLOCK_720M;
  243. break;
  244. default:
  245. clksys = CLOCK_600M;
  246. break;
  247. }
  248. switch (freq_div) {
  249. case 0:
  250. return clksys;
  251. case 1:
  252. return clksys >> 1;
  253. case 2:
  254. return clksys >> 2;
  255. default:
  256. return clksys;
  257. }
  258. }
  259. unsigned long ltq_grx390_fpi_hz(void)
  260. {
  261. /* fpi clock is derived from ddr_clk */
  262. unsigned int clksys;
  263. int cpu_fs = ((ltq_cgu_r32(CGU_SYS_XRX) >> 9) & 0x3);
  264. int freq_div = ((ltq_cgu_r32(CGU_SYS_XRX)) & 0x7);
  265. switch (cpu_fs) {
  266. case 0:
  267. clksys = CLOCK_600M;
  268. break;
  269. case 1:
  270. clksys = CLOCK_666M;
  271. break;
  272. case 2:
  273. clksys = CLOCK_720M;
  274. break;
  275. default:
  276. clksys = CLOCK_600M;
  277. break;
  278. }
  279. switch (freq_div) {
  280. case 1:
  281. return clksys >> 1;
  282. case 2:
  283. return clksys >> 2;
  284. default:
  285. return clksys >> 1;
  286. }
  287. }
  288. unsigned long ltq_grx390_pp32_hz(void)
  289. {
  290. unsigned int clksys = (ltq_cgu_r32(CGU_SYS) >> 16) & 0x7;
  291. unsigned long clk;
  292. switch (clksys) {
  293. case 1:
  294. clk = CLOCK_250M;
  295. break;
  296. case 2:
  297. clk = CLOCK_432M;
  298. break;
  299. case 4:
  300. clk = CLOCK_400M;
  301. break;
  302. default:
  303. clk = CLOCK_250M;
  304. break;
  305. }
  306. return clk;
  307. }