clk_stm32h7.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
  4. * Author(s): Patrice Chotard, <patrice.chotard@st.com> for STMicroelectronics.
  5. */
  6. #include <common.h>
  7. #include <clk-uclass.h>
  8. #include <dm.h>
  9. #include <log.h>
  10. #include <regmap.h>
  11. #include <syscon.h>
  12. #include <asm/io.h>
  13. #include <dm/root.h>
  14. #include <linux/bitops.h>
  15. #include <dt-bindings/clock/stm32h7-clks.h>
  16. /* RCC CR specific definitions */
  17. #define RCC_CR_HSION BIT(0)
  18. #define RCC_CR_HSIRDY BIT(2)
  19. #define RCC_CR_HSEON BIT(16)
  20. #define RCC_CR_HSERDY BIT(17)
  21. #define RCC_CR_HSEBYP BIT(18)
  22. #define RCC_CR_PLL1ON BIT(24)
  23. #define RCC_CR_PLL1RDY BIT(25)
  24. #define RCC_CR_HSIDIV_MASK GENMASK(4, 3)
  25. #define RCC_CR_HSIDIV_SHIFT 3
  26. #define RCC_CFGR_SW_MASK GENMASK(2, 0)
  27. #define RCC_CFGR_SW_HSI 0
  28. #define RCC_CFGR_SW_CSI 1
  29. #define RCC_CFGR_SW_HSE 2
  30. #define RCC_CFGR_SW_PLL1 3
  31. #define RCC_CFGR_TIMPRE BIT(15)
  32. #define RCC_PLLCKSELR_PLLSRC_HSI 0
  33. #define RCC_PLLCKSELR_PLLSRC_CSI 1
  34. #define RCC_PLLCKSELR_PLLSRC_HSE 2
  35. #define RCC_PLLCKSELR_PLLSRC_NO_CLK 3
  36. #define RCC_PLLCKSELR_PLLSRC_MASK GENMASK(1, 0)
  37. #define RCC_PLLCKSELR_DIVM1_SHIFT 4
  38. #define RCC_PLLCKSELR_DIVM1_MASK GENMASK(9, 4)
  39. #define RCC_PLL1DIVR_DIVN1_MASK GENMASK(8, 0)
  40. #define RCC_PLL1DIVR_DIVP1_SHIFT 9
  41. #define RCC_PLL1DIVR_DIVP1_MASK GENMASK(15, 9)
  42. #define RCC_PLL1DIVR_DIVQ1_SHIFT 16
  43. #define RCC_PLL1DIVR_DIVQ1_MASK GENMASK(22, 16)
  44. #define RCC_PLL1DIVR_DIVR1_SHIFT 24
  45. #define RCC_PLL1DIVR_DIVR1_MASK GENMASK(30, 24)
  46. #define RCC_PLL1FRACR_FRACN1_SHIFT 3
  47. #define RCC_PLL1FRACR_FRACN1_MASK GENMASK(15, 3)
  48. #define RCC_PLLCFGR_PLL1RGE_SHIFT 2
  49. #define PLL1RGE_1_2_MHZ 0
  50. #define PLL1RGE_2_4_MHZ 1
  51. #define PLL1RGE_4_8_MHZ 2
  52. #define PLL1RGE_8_16_MHZ 3
  53. #define RCC_PLLCFGR_DIVP1EN BIT(16)
  54. #define RCC_PLLCFGR_DIVQ1EN BIT(17)
  55. #define RCC_PLLCFGR_DIVR1EN BIT(18)
  56. #define RCC_D1CFGR_HPRE_MASK GENMASK(3, 0)
  57. #define RCC_D1CFGR_HPRE_DIVIDED BIT(3)
  58. #define RCC_D1CFGR_HPRE_DIVIDER GENMASK(2, 0)
  59. #define RCC_D1CFGR_HPRE_DIV2 8
  60. #define RCC_D1CFGR_D1PPRE_SHIFT 4
  61. #define RCC_D1CFGR_D1PPRE_DIVIDED BIT(6)
  62. #define RCC_D1CFGR_D1PPRE_DIVIDER GENMASK(5, 4)
  63. #define RCC_D1CFGR_D1CPRE_SHIFT 8
  64. #define RCC_D1CFGR_D1CPRE_DIVIDER GENMASK(10, 8)
  65. #define RCC_D1CFGR_D1CPRE_DIVIDED BIT(11)
  66. #define RCC_D2CFGR_D2PPRE1_SHIFT 4
  67. #define RCC_D2CFGR_D2PPRE1_DIVIDED BIT(6)
  68. #define RCC_D2CFGR_D2PPRE1_DIVIDER GENMASK(5, 4)
  69. #define RCC_D2CFGR_D2PPRE2_SHIFT 8
  70. #define RCC_D2CFGR_D2PPRE2_DIVIDED BIT(10)
  71. #define RCC_D2CFGR_D2PPRE2_DIVIDER GENMASK(9, 8)
  72. #define RCC_D3CFGR_D3PPRE_SHIFT 4
  73. #define RCC_D3CFGR_D3PPRE_DIVIDED BIT(6)
  74. #define RCC_D3CFGR_D3PPRE_DIVIDER GENMASK(5, 4)
  75. #define RCC_D1CCIPR_FMCSRC_MASK GENMASK(1, 0)
  76. #define FMCSRC_HCLKD1 0
  77. #define FMCSRC_PLL1_Q_CK 1
  78. #define FMCSRC_PLL2_R_CK 2
  79. #define FMCSRC_PER_CK 3
  80. #define RCC_D1CCIPR_QSPISRC_MASK GENMASK(5, 4)
  81. #define RCC_D1CCIPR_QSPISRC_SHIFT 4
  82. #define QSPISRC_HCLKD1 0
  83. #define QSPISRC_PLL1_Q_CK 1
  84. #define QSPISRC_PLL2_R_CK 2
  85. #define QSPISRC_PER_CK 3
  86. #define PWR_CR3 0x0c
  87. #define PWR_CR3_SCUEN BIT(2)
  88. #define PWR_D3CR 0x18
  89. #define PWR_D3CR_VOS_MASK GENMASK(15, 14)
  90. #define PWR_D3CR_VOS_SHIFT 14
  91. #define VOS_SCALE_3 1
  92. #define VOS_SCALE_2 2
  93. #define VOS_SCALE_1 3
  94. #define PWR_D3CR_VOSREADY BIT(13)
  95. struct stm32_rcc_regs {
  96. u32 cr; /* 0x00 Source Control Register */
  97. u32 icscr; /* 0x04 Internal Clock Source Calibration Register */
  98. u32 crrcr; /* 0x08 Clock Recovery RC Register */
  99. u32 reserved1; /* 0x0c reserved */
  100. u32 cfgr; /* 0x10 Clock Configuration Register */
  101. u32 reserved2; /* 0x14 reserved */
  102. u32 d1cfgr; /* 0x18 Domain 1 Clock Configuration Register */
  103. u32 d2cfgr; /* 0x1c Domain 2 Clock Configuration Register */
  104. u32 d3cfgr; /* 0x20 Domain 3 Clock Configuration Register */
  105. u32 reserved3; /* 0x24 reserved */
  106. u32 pllckselr; /* 0x28 PLLs Clock Source Selection Register */
  107. u32 pllcfgr; /* 0x2c PLLs Configuration Register */
  108. u32 pll1divr; /* 0x30 PLL1 Dividers Configuration Register */
  109. u32 pll1fracr; /* 0x34 PLL1 Fractional Divider Register */
  110. u32 pll2divr; /* 0x38 PLL2 Dividers Configuration Register */
  111. u32 pll2fracr; /* 0x3c PLL2 Fractional Divider Register */
  112. u32 pll3divr; /* 0x40 PLL3 Dividers Configuration Register */
  113. u32 pll3fracr; /* 0x44 PLL3 Fractional Divider Register */
  114. u32 reserved4; /* 0x48 reserved */
  115. u32 d1ccipr; /* 0x4c Domain 1 Kernel Clock Configuration Register */
  116. u32 d2ccip1r; /* 0x50 Domain 2 Kernel Clock Configuration Register */
  117. u32 d2ccip2r; /* 0x54 Domain 2 Kernel Clock Configuration Register */
  118. u32 d3ccipr; /* 0x58 Domain 3 Kernel Clock Configuration Register */
  119. u32 reserved5; /* 0x5c reserved */
  120. u32 cier; /* 0x60 Clock Source Interrupt Enable Register */
  121. u32 cifr; /* 0x64 Clock Source Interrupt Flag Register */
  122. u32 cicr; /* 0x68 Clock Source Interrupt Clear Register */
  123. u32 reserved6; /* 0x6c reserved */
  124. u32 bdcr; /* 0x70 Backup Domain Control Register */
  125. u32 csr; /* 0x74 Clock Control and Status Register */
  126. u32 reserved7; /* 0x78 reserved */
  127. u32 ahb3rstr; /* 0x7c AHB3 Peripheral Reset Register */
  128. u32 ahb1rstr; /* 0x80 AHB1 Peripheral Reset Register */
  129. u32 ahb2rstr; /* 0x84 AHB2 Peripheral Reset Register */
  130. u32 ahb4rstr; /* 0x88 AHB4 Peripheral Reset Register */
  131. u32 apb3rstr; /* 0x8c APB3 Peripheral Reset Register */
  132. u32 apb1lrstr; /* 0x90 APB1 low Peripheral Reset Register */
  133. u32 apb1hrstr; /* 0x94 APB1 high Peripheral Reset Register */
  134. u32 apb2rstr; /* 0x98 APB2 Clock Register */
  135. u32 apb4rstr; /* 0x9c APB4 Clock Register */
  136. u32 gcr; /* 0xa0 Global Control Register */
  137. u32 reserved8; /* 0xa4 reserved */
  138. u32 d3amr; /* 0xa8 D3 Autonomous mode Register */
  139. u32 reserved9[9];/* 0xac to 0xcc reserved */
  140. u32 rsr; /* 0xd0 Reset Status Register */
  141. u32 ahb3enr; /* 0xd4 AHB3 Clock Register */
  142. u32 ahb1enr; /* 0xd8 AHB1 Clock Register */
  143. u32 ahb2enr; /* 0xdc AHB2 Clock Register */
  144. u32 ahb4enr; /* 0xe0 AHB4 Clock Register */
  145. u32 apb3enr; /* 0xe4 APB3 Clock Register */
  146. u32 apb1lenr; /* 0xe8 APB1 low Clock Register */
  147. u32 apb1henr; /* 0xec APB1 high Clock Register */
  148. u32 apb2enr; /* 0xf0 APB2 Clock Register */
  149. u32 apb4enr; /* 0xf4 APB4 Clock Register */
  150. };
  151. #define RCC_AHB3ENR offsetof(struct stm32_rcc_regs, ahb3enr)
  152. #define RCC_AHB1ENR offsetof(struct stm32_rcc_regs, ahb1enr)
  153. #define RCC_AHB2ENR offsetof(struct stm32_rcc_regs, ahb2enr)
  154. #define RCC_AHB4ENR offsetof(struct stm32_rcc_regs, ahb4enr)
  155. #define RCC_APB3ENR offsetof(struct stm32_rcc_regs, apb3enr)
  156. #define RCC_APB1LENR offsetof(struct stm32_rcc_regs, apb1lenr)
  157. #define RCC_APB1HENR offsetof(struct stm32_rcc_regs, apb1henr)
  158. #define RCC_APB2ENR offsetof(struct stm32_rcc_regs, apb2enr)
  159. #define RCC_APB4ENR offsetof(struct stm32_rcc_regs, apb4enr)
  160. struct clk_cfg {
  161. u32 gate_offset;
  162. u8 gate_bit_idx;
  163. const char *name;
  164. };
  165. /*
  166. * the way all these entries are sorted in this array could seem
  167. * unlogical, but we are dependant of kernel DT_bindings,
  168. * where clocks are separate in 2 banks, peripheral clocks and
  169. * kernel clocks.
  170. */
  171. static const struct clk_cfg clk_map[] = {
  172. {RCC_AHB3ENR, 31, "d1sram1"}, /* peripheral clocks */
  173. {RCC_AHB3ENR, 30, "itcm"},
  174. {RCC_AHB3ENR, 29, "dtcm2"},
  175. {RCC_AHB3ENR, 28, "dtcm1"},
  176. {RCC_AHB3ENR, 8, "flitf"},
  177. {RCC_AHB3ENR, 5, "jpgdec"},
  178. {RCC_AHB3ENR, 4, "dma2d"},
  179. {RCC_AHB3ENR, 0, "mdma"},
  180. {RCC_AHB1ENR, 28, "usb2ulpi"},
  181. {RCC_AHB1ENR, 17, "eth1rx"},
  182. {RCC_AHB1ENR, 16, "eth1tx"},
  183. {RCC_AHB1ENR, 15, "eth1mac"},
  184. {RCC_AHB1ENR, 14, "art"},
  185. {RCC_AHB1ENR, 26, "usb1ulpi"},
  186. {RCC_AHB1ENR, 1, "dma2"},
  187. {RCC_AHB1ENR, 0, "dma1"},
  188. {RCC_AHB2ENR, 31, "d2sram3"},
  189. {RCC_AHB2ENR, 30, "d2sram2"},
  190. {RCC_AHB2ENR, 29, "d2sram1"},
  191. {RCC_AHB2ENR, 5, "hash"},
  192. {RCC_AHB2ENR, 4, "crypt"},
  193. {RCC_AHB2ENR, 0, "camitf"},
  194. {RCC_AHB4ENR, 28, "bkpram"},
  195. {RCC_AHB4ENR, 25, "hsem"},
  196. {RCC_AHB4ENR, 21, "bdma"},
  197. {RCC_AHB4ENR, 19, "crc"},
  198. {RCC_AHB4ENR, 10, "gpiok"},
  199. {RCC_AHB4ENR, 9, "gpioj"},
  200. {RCC_AHB4ENR, 8, "gpioi"},
  201. {RCC_AHB4ENR, 7, "gpioh"},
  202. {RCC_AHB4ENR, 6, "gpiog"},
  203. {RCC_AHB4ENR, 5, "gpiof"},
  204. {RCC_AHB4ENR, 4, "gpioe"},
  205. {RCC_AHB4ENR, 3, "gpiod"},
  206. {RCC_AHB4ENR, 2, "gpioc"},
  207. {RCC_AHB4ENR, 1, "gpiob"},
  208. {RCC_AHB4ENR, 0, "gpioa"},
  209. {RCC_APB3ENR, 6, "wwdg1"},
  210. {RCC_APB1LENR, 29, "dac12"},
  211. {RCC_APB1LENR, 11, "wwdg2"},
  212. {RCC_APB1LENR, 8, "tim14"},
  213. {RCC_APB1LENR, 7, "tim13"},
  214. {RCC_APB1LENR, 6, "tim12"},
  215. {RCC_APB1LENR, 5, "tim7"},
  216. {RCC_APB1LENR, 4, "tim6"},
  217. {RCC_APB1LENR, 3, "tim5"},
  218. {RCC_APB1LENR, 2, "tim4"},
  219. {RCC_APB1LENR, 1, "tim3"},
  220. {RCC_APB1LENR, 0, "tim2"},
  221. {RCC_APB1HENR, 5, "mdios"},
  222. {RCC_APB1HENR, 4, "opamp"},
  223. {RCC_APB1HENR, 1, "crs"},
  224. {RCC_APB2ENR, 18, "tim17"},
  225. {RCC_APB2ENR, 17, "tim16"},
  226. {RCC_APB2ENR, 16, "tim15"},
  227. {RCC_APB2ENR, 1, "tim8"},
  228. {RCC_APB2ENR, 0, "tim1"},
  229. {RCC_APB4ENR, 26, "tmpsens"},
  230. {RCC_APB4ENR, 16, "rtcapb"},
  231. {RCC_APB4ENR, 15, "vref"},
  232. {RCC_APB4ENR, 14, "comp12"},
  233. {RCC_APB4ENR, 1, "syscfg"},
  234. {RCC_AHB3ENR, 16, "sdmmc1"}, /* kernel clocks */
  235. {RCC_AHB3ENR, 14, "quadspi"},
  236. {RCC_AHB3ENR, 12, "fmc"},
  237. {RCC_AHB1ENR, 27, "usb2otg"},
  238. {RCC_AHB1ENR, 25, "usb1otg"},
  239. {RCC_AHB1ENR, 5, "adc12"},
  240. {RCC_AHB2ENR, 9, "sdmmc2"},
  241. {RCC_AHB2ENR, 6, "rng"},
  242. {RCC_AHB4ENR, 24, "adc3"},
  243. {RCC_APB3ENR, 4, "dsi"},
  244. {RCC_APB3ENR, 3, "ltdc"},
  245. {RCC_APB1LENR, 31, "usart8"},
  246. {RCC_APB1LENR, 30, "usart7"},
  247. {RCC_APB1LENR, 27, "hdmicec"},
  248. {RCC_APB1LENR, 23, "i2c3"},
  249. {RCC_APB1LENR, 22, "i2c2"},
  250. {RCC_APB1LENR, 21, "i2c1"},
  251. {RCC_APB1LENR, 20, "uart5"},
  252. {RCC_APB1LENR, 19, "uart4"},
  253. {RCC_APB1LENR, 18, "usart3"},
  254. {RCC_APB1LENR, 17, "usart2"},
  255. {RCC_APB1LENR, 16, "spdifrx"},
  256. {RCC_APB1LENR, 15, "spi3"},
  257. {RCC_APB1LENR, 14, "spi2"},
  258. {RCC_APB1LENR, 9, "lptim1"},
  259. {RCC_APB1HENR, 8, "fdcan"},
  260. {RCC_APB1HENR, 2, "swp"},
  261. {RCC_APB2ENR, 29, "hrtim"},
  262. {RCC_APB2ENR, 28, "dfsdm1"},
  263. {RCC_APB2ENR, 24, "sai3"},
  264. {RCC_APB2ENR, 23, "sai2"},
  265. {RCC_APB2ENR, 22, "sai1"},
  266. {RCC_APB2ENR, 20, "spi5"},
  267. {RCC_APB2ENR, 13, "spi4"},
  268. {RCC_APB2ENR, 12, "spi1"},
  269. {RCC_APB2ENR, 5, "usart6"},
  270. {RCC_APB2ENR, 4, "usart1"},
  271. {RCC_APB4ENR, 21, "sai4a"},
  272. {RCC_APB4ENR, 21, "sai4b"},
  273. {RCC_APB4ENR, 12, "lptim5"},
  274. {RCC_APB4ENR, 11, "lptim4"},
  275. {RCC_APB4ENR, 10, "lptim3"},
  276. {RCC_APB4ENR, 9, "lptim2"},
  277. {RCC_APB4ENR, 7, "i2c4"},
  278. {RCC_APB4ENR, 5, "spi6"},
  279. {RCC_APB4ENR, 3, "lpuart1"},
  280. };
  281. struct stm32_clk {
  282. struct stm32_rcc_regs *rcc_base;
  283. struct regmap *pwr_regmap;
  284. };
  285. struct pll_psc {
  286. u8 divm;
  287. u16 divn;
  288. u8 divp;
  289. u8 divq;
  290. u8 divr;
  291. };
  292. /*
  293. * OSC_HSE = 25 MHz
  294. * VCO = 500MHz
  295. * pll1_p = 250MHz / pll1_q = 250MHz pll1_r = 250Mhz
  296. */
  297. struct pll_psc sys_pll_psc = {
  298. .divm = 4,
  299. .divn = 80,
  300. .divp = 2,
  301. .divq = 2,
  302. .divr = 2,
  303. };
  304. enum apb {
  305. APB1,
  306. APB2,
  307. };
  308. int configure_clocks(struct udevice *dev)
  309. {
  310. struct stm32_clk *priv = dev_get_priv(dev);
  311. struct stm32_rcc_regs *regs = priv->rcc_base;
  312. uint8_t *pwr_base = (uint8_t *)regmap_get_range(priv->pwr_regmap, 0);
  313. uint32_t pllckselr = 0;
  314. uint32_t pll1divr = 0;
  315. uint32_t pllcfgr = 0;
  316. /* Switch on HSI */
  317. setbits_le32(&regs->cr, RCC_CR_HSION);
  318. while (!(readl(&regs->cr) & RCC_CR_HSIRDY))
  319. ;
  320. /* Reset CFGR, now HSI is the default system clock */
  321. writel(0, &regs->cfgr);
  322. /* Set all kernel domain clock registers to reset value*/
  323. writel(0x0, &regs->d1ccipr);
  324. writel(0x0, &regs->d2ccip1r);
  325. writel(0x0, &regs->d2ccip2r);
  326. /* Set voltage scaling at scale 1 (1,15 - 1,26 Volts) */
  327. clrsetbits_le32(pwr_base + PWR_D3CR, PWR_D3CR_VOS_MASK,
  328. VOS_SCALE_1 << PWR_D3CR_VOS_SHIFT);
  329. /* Lock supply configuration update */
  330. clrbits_le32(pwr_base + PWR_CR3, PWR_CR3_SCUEN);
  331. while (!(readl(pwr_base + PWR_D3CR) & PWR_D3CR_VOSREADY))
  332. ;
  333. /* disable HSE to configure it */
  334. clrbits_le32(&regs->cr, RCC_CR_HSEON);
  335. while ((readl(&regs->cr) & RCC_CR_HSERDY))
  336. ;
  337. /* clear HSE bypass and set it ON */
  338. clrbits_le32(&regs->cr, RCC_CR_HSEBYP);
  339. /* Switch on HSE */
  340. setbits_le32(&regs->cr, RCC_CR_HSEON);
  341. while (!(readl(&regs->cr) & RCC_CR_HSERDY))
  342. ;
  343. /* pll setup, disable it */
  344. clrbits_le32(&regs->cr, RCC_CR_PLL1ON);
  345. while ((readl(&regs->cr) & RCC_CR_PLL1RDY))
  346. ;
  347. /* Select HSE as PLL clock source */
  348. pllckselr |= RCC_PLLCKSELR_PLLSRC_HSE;
  349. pllckselr |= sys_pll_psc.divm << RCC_PLLCKSELR_DIVM1_SHIFT;
  350. writel(pllckselr, &regs->pllckselr);
  351. pll1divr |= (sys_pll_psc.divr - 1) << RCC_PLL1DIVR_DIVR1_SHIFT;
  352. pll1divr |= (sys_pll_psc.divq - 1) << RCC_PLL1DIVR_DIVQ1_SHIFT;
  353. pll1divr |= (sys_pll_psc.divp - 1) << RCC_PLL1DIVR_DIVP1_SHIFT;
  354. pll1divr |= (sys_pll_psc.divn - 1);
  355. writel(pll1divr, &regs->pll1divr);
  356. pllcfgr |= PLL1RGE_4_8_MHZ << RCC_PLLCFGR_PLL1RGE_SHIFT;
  357. pllcfgr |= RCC_PLLCFGR_DIVP1EN;
  358. pllcfgr |= RCC_PLLCFGR_DIVQ1EN;
  359. pllcfgr |= RCC_PLLCFGR_DIVR1EN;
  360. writel(pllcfgr, &regs->pllcfgr);
  361. /* pll setup, enable it */
  362. setbits_le32(&regs->cr, RCC_CR_PLL1ON);
  363. /* set HPRE (/2) DI clk --> 125MHz */
  364. clrsetbits_le32(&regs->d1cfgr, RCC_D1CFGR_HPRE_MASK,
  365. RCC_D1CFGR_HPRE_DIV2);
  366. /* select PLL1 as system clock source (sys_ck)*/
  367. clrsetbits_le32(&regs->cfgr, RCC_CFGR_SW_MASK, RCC_CFGR_SW_PLL1);
  368. while ((readl(&regs->cfgr) & RCC_CFGR_SW_MASK) != RCC_CFGR_SW_PLL1)
  369. ;
  370. /* sdram: use pll1_q as fmc_k clk */
  371. clrsetbits_le32(&regs->d1ccipr, RCC_D1CCIPR_FMCSRC_MASK,
  372. FMCSRC_PLL1_Q_CK);
  373. return 0;
  374. }
  375. static u32 stm32_get_HSI_divider(struct stm32_rcc_regs *regs)
  376. {
  377. u32 divider;
  378. /* get HSI divider value */
  379. divider = readl(&regs->cr) & RCC_CR_HSIDIV_MASK;
  380. divider = divider >> RCC_CR_HSIDIV_SHIFT;
  381. return divider;
  382. };
  383. enum pllsrc {
  384. HSE,
  385. LSE,
  386. HSI,
  387. CSI,
  388. I2S,
  389. TIMER,
  390. PLLSRC_NB,
  391. };
  392. static const char * const pllsrc_name[PLLSRC_NB] = {
  393. [HSE] = "clk-hse",
  394. [LSE] = "clk-lse",
  395. [HSI] = "clk-hsi",
  396. [CSI] = "clk-csi",
  397. [I2S] = "clk-i2s",
  398. [TIMER] = "timer-clk"
  399. };
  400. static ulong stm32_get_rate(struct stm32_rcc_regs *regs, enum pllsrc pllsrc)
  401. {
  402. struct clk clk;
  403. struct udevice *fixed_clock_dev = NULL;
  404. u32 divider;
  405. int ret;
  406. const char *name = pllsrc_name[pllsrc];
  407. debug("%s name %s\n", __func__, name);
  408. clk.id = 0;
  409. ret = uclass_get_device_by_name(UCLASS_CLK, name, &fixed_clock_dev);
  410. if (ret) {
  411. pr_err("Can't find clk %s (%d)", name, ret);
  412. return 0;
  413. }
  414. ret = clk_request(fixed_clock_dev, &clk);
  415. if (ret) {
  416. pr_err("Can't request %s clk (%d)", name, ret);
  417. return 0;
  418. }
  419. divider = 0;
  420. if (pllsrc == HSI)
  421. divider = stm32_get_HSI_divider(regs);
  422. debug("%s divider %d rate %ld\n", __func__,
  423. divider, clk_get_rate(&clk));
  424. return clk_get_rate(&clk) >> divider;
  425. };
  426. enum pll1_output {
  427. PLL1_P_CK,
  428. PLL1_Q_CK,
  429. PLL1_R_CK,
  430. };
  431. static u32 stm32_get_PLL1_rate(struct stm32_rcc_regs *regs,
  432. enum pll1_output output)
  433. {
  434. ulong pllsrc = 0;
  435. u32 divm1, divn1, divp1, divq1, divr1, fracn1;
  436. ulong vco, rate;
  437. /* get the PLLSRC */
  438. switch (readl(&regs->pllckselr) & RCC_PLLCKSELR_PLLSRC_MASK) {
  439. case RCC_PLLCKSELR_PLLSRC_HSI:
  440. pllsrc = stm32_get_rate(regs, HSI);
  441. break;
  442. case RCC_PLLCKSELR_PLLSRC_CSI:
  443. pllsrc = stm32_get_rate(regs, CSI);
  444. break;
  445. case RCC_PLLCKSELR_PLLSRC_HSE:
  446. pllsrc = stm32_get_rate(regs, HSE);
  447. break;
  448. case RCC_PLLCKSELR_PLLSRC_NO_CLK:
  449. /* shouldn't happen */
  450. pr_err("wrong value for RCC_PLLCKSELR register\n");
  451. pllsrc = 0;
  452. break;
  453. }
  454. /* pllsrc = 0 ? no need to go ahead */
  455. if (!pllsrc)
  456. return pllsrc;
  457. /* get divm1, divp1, divn1 and divr1 */
  458. divm1 = readl(&regs->pllckselr) & RCC_PLLCKSELR_DIVM1_MASK;
  459. divm1 = divm1 >> RCC_PLLCKSELR_DIVM1_SHIFT;
  460. divn1 = (readl(&regs->pll1divr) & RCC_PLL1DIVR_DIVN1_MASK) + 1;
  461. divp1 = readl(&regs->pll1divr) & RCC_PLL1DIVR_DIVP1_MASK;
  462. divp1 = (divp1 >> RCC_PLL1DIVR_DIVP1_SHIFT) + 1;
  463. divq1 = readl(&regs->pll1divr) & RCC_PLL1DIVR_DIVQ1_MASK;
  464. divq1 = (divq1 >> RCC_PLL1DIVR_DIVQ1_SHIFT) + 1;
  465. divr1 = readl(&regs->pll1divr) & RCC_PLL1DIVR_DIVR1_MASK;
  466. divr1 = (divr1 >> RCC_PLL1DIVR_DIVR1_SHIFT) + 1;
  467. fracn1 = readl(&regs->pll1fracr) & RCC_PLL1DIVR_DIVR1_MASK;
  468. fracn1 = fracn1 & RCC_PLL1DIVR_DIVR1_SHIFT;
  469. vco = (pllsrc / divm1) * divn1;
  470. rate = (pllsrc * fracn1) / (divm1 * 8192);
  471. debug("%s divm1 = %d divn1 = %d divp1 = %d divq1 = %d divr1 = %d\n",
  472. __func__, divm1, divn1, divp1, divq1, divr1);
  473. debug("%s fracn1 = %d vco = %ld rate = %ld\n",
  474. __func__, fracn1, vco, rate);
  475. switch (output) {
  476. case PLL1_P_CK:
  477. return (vco + rate) / divp1;
  478. break;
  479. case PLL1_Q_CK:
  480. return (vco + rate) / divq1;
  481. break;
  482. case PLL1_R_CK:
  483. return (vco + rate) / divr1;
  484. break;
  485. }
  486. return -EINVAL;
  487. }
  488. static u32 stm32_get_apb_psc(struct stm32_rcc_regs *regs, enum apb apb)
  489. {
  490. u16 prescaler_table[8] = {2, 4, 8, 16, 64, 128, 256, 512};
  491. u32 d2cfgr = readl(&regs->d2cfgr);
  492. if (apb == APB1) {
  493. if (d2cfgr & RCC_D2CFGR_D2PPRE1_DIVIDED)
  494. /* get D2 domain APB1 prescaler */
  495. return prescaler_table[
  496. ((d2cfgr & RCC_D2CFGR_D2PPRE1_DIVIDER)
  497. >> RCC_D2CFGR_D2PPRE1_SHIFT)];
  498. } else { /* APB2 */
  499. if (d2cfgr & RCC_D2CFGR_D2PPRE2_DIVIDED)
  500. /* get D2 domain APB2 prescaler */
  501. return prescaler_table[
  502. ((d2cfgr & RCC_D2CFGR_D2PPRE2_DIVIDER)
  503. >> RCC_D2CFGR_D2PPRE2_SHIFT)];
  504. }
  505. return 1;
  506. };
  507. static u32 stm32_get_timer_rate(struct stm32_clk *priv, u32 sysclk,
  508. enum apb apb)
  509. {
  510. struct stm32_rcc_regs *regs = priv->rcc_base;
  511. u32 psc = stm32_get_apb_psc(regs, apb);
  512. if (readl(&regs->cfgr) & RCC_CFGR_TIMPRE)
  513. /*
  514. * if APB prescaler is configured to a
  515. * division factor of 1, 2 or 4
  516. */
  517. switch (psc) {
  518. case 1:
  519. case 2:
  520. case 4:
  521. return sysclk;
  522. case 8:
  523. return sysclk / 2;
  524. case 16:
  525. return sysclk / 4;
  526. default:
  527. pr_err("unexpected prescaler value (%d)\n", psc);
  528. return 0;
  529. }
  530. else
  531. switch (psc) {
  532. case 1:
  533. return sysclk;
  534. case 2:
  535. case 4:
  536. case 8:
  537. case 16:
  538. return sysclk / psc;
  539. default:
  540. pr_err("unexpected prescaler value (%d)\n", psc);
  541. return 0;
  542. }
  543. };
  544. static ulong stm32_clk_get_rate(struct clk *clk)
  545. {
  546. struct stm32_clk *priv = dev_get_priv(clk->dev);
  547. struct stm32_rcc_regs *regs = priv->rcc_base;
  548. ulong sysclk = 0;
  549. u32 gate_offset;
  550. u32 d1cfgr, d3cfgr;
  551. /* prescaler table lookups for clock computation */
  552. u16 prescaler_table[8] = {2, 4, 8, 16, 64, 128, 256, 512};
  553. u8 source, idx;
  554. /*
  555. * get system clock (sys_ck) source
  556. * can be HSI_CK, CSI_CK, HSE_CK or pll1_p_ck
  557. */
  558. source = readl(&regs->cfgr) & RCC_CFGR_SW_MASK;
  559. switch (source) {
  560. case RCC_CFGR_SW_PLL1:
  561. sysclk = stm32_get_PLL1_rate(regs, PLL1_P_CK);
  562. break;
  563. case RCC_CFGR_SW_HSE:
  564. sysclk = stm32_get_rate(regs, HSE);
  565. break;
  566. case RCC_CFGR_SW_CSI:
  567. sysclk = stm32_get_rate(regs, CSI);
  568. break;
  569. case RCC_CFGR_SW_HSI:
  570. sysclk = stm32_get_rate(regs, HSI);
  571. break;
  572. }
  573. /* sysclk = 0 ? no need to go ahead */
  574. if (!sysclk)
  575. return sysclk;
  576. debug("%s system clock: source = %d freq = %ld\n",
  577. __func__, source, sysclk);
  578. d1cfgr = readl(&regs->d1cfgr);
  579. if (d1cfgr & RCC_D1CFGR_D1CPRE_DIVIDED) {
  580. /* get D1 domain Core prescaler */
  581. idx = (d1cfgr & RCC_D1CFGR_D1CPRE_DIVIDER) >>
  582. RCC_D1CFGR_D1CPRE_SHIFT;
  583. sysclk = sysclk / prescaler_table[idx];
  584. }
  585. if (d1cfgr & RCC_D1CFGR_HPRE_DIVIDED) {
  586. /* get D1 domain AHB prescaler */
  587. idx = d1cfgr & RCC_D1CFGR_HPRE_DIVIDER;
  588. sysclk = sysclk / prescaler_table[idx];
  589. }
  590. gate_offset = clk_map[clk->id].gate_offset;
  591. debug("%s clk->id=%ld gate_offset=0x%x sysclk=%ld\n",
  592. __func__, clk->id, gate_offset, sysclk);
  593. switch (gate_offset) {
  594. case RCC_AHB3ENR:
  595. case RCC_AHB1ENR:
  596. case RCC_AHB2ENR:
  597. case RCC_AHB4ENR:
  598. return sysclk;
  599. break;
  600. case RCC_APB3ENR:
  601. if (d1cfgr & RCC_D1CFGR_D1PPRE_DIVIDED) {
  602. /* get D1 domain APB3 prescaler */
  603. idx = (d1cfgr & RCC_D1CFGR_D1PPRE_DIVIDER) >>
  604. RCC_D1CFGR_D1PPRE_SHIFT;
  605. sysclk = sysclk / prescaler_table[idx];
  606. }
  607. debug("%s system clock: freq after APB3 prescaler = %ld\n",
  608. __func__, sysclk);
  609. return sysclk;
  610. break;
  611. case RCC_APB4ENR:
  612. d3cfgr = readl(&regs->d3cfgr);
  613. if (d3cfgr & RCC_D3CFGR_D3PPRE_DIVIDED) {
  614. /* get D3 domain APB4 prescaler */
  615. idx = (d3cfgr & RCC_D3CFGR_D3PPRE_DIVIDER) >>
  616. RCC_D3CFGR_D3PPRE_SHIFT;
  617. sysclk = sysclk / prescaler_table[idx];
  618. }
  619. debug("%s system clock: freq after APB4 prescaler = %ld\n",
  620. __func__, sysclk);
  621. return sysclk;
  622. break;
  623. case RCC_APB1LENR:
  624. case RCC_APB1HENR:
  625. /* special case for GPT timers */
  626. switch (clk->id) {
  627. case TIM14_CK:
  628. case TIM13_CK:
  629. case TIM12_CK:
  630. case TIM7_CK:
  631. case TIM6_CK:
  632. case TIM5_CK:
  633. case TIM4_CK:
  634. case TIM3_CK:
  635. case TIM2_CK:
  636. return stm32_get_timer_rate(priv, sysclk, APB1);
  637. }
  638. debug("%s system clock: freq after APB1 prescaler = %ld\n",
  639. __func__, sysclk);
  640. return (sysclk / stm32_get_apb_psc(regs, APB1));
  641. break;
  642. case RCC_APB2ENR:
  643. /* special case for timers */
  644. switch (clk->id) {
  645. case TIM17_CK:
  646. case TIM16_CK:
  647. case TIM15_CK:
  648. case TIM8_CK:
  649. case TIM1_CK:
  650. return stm32_get_timer_rate(priv, sysclk, APB2);
  651. }
  652. debug("%s system clock: freq after APB2 prescaler = %ld\n",
  653. __func__, sysclk);
  654. return (sysclk / stm32_get_apb_psc(regs, APB2));
  655. break;
  656. default:
  657. pr_err("unexpected gate_offset value (0x%x)\n", gate_offset);
  658. return -EINVAL;
  659. break;
  660. }
  661. }
  662. static int stm32_clk_enable(struct clk *clk)
  663. {
  664. struct stm32_clk *priv = dev_get_priv(clk->dev);
  665. struct stm32_rcc_regs *regs = priv->rcc_base;
  666. u32 gate_offset;
  667. u32 gate_bit_index;
  668. unsigned long clk_id = clk->id;
  669. gate_offset = clk_map[clk_id].gate_offset;
  670. gate_bit_index = clk_map[clk_id].gate_bit_idx;
  671. debug("%s: clkid=%ld gate offset=0x%x bit_index=%d name=%s\n",
  672. __func__, clk->id, gate_offset, gate_bit_index,
  673. clk_map[clk_id].name);
  674. setbits_le32(&regs->cr + (gate_offset / 4), BIT(gate_bit_index));
  675. return 0;
  676. }
  677. static int stm32_clk_probe(struct udevice *dev)
  678. {
  679. struct stm32_clk *priv = dev_get_priv(dev);
  680. struct udevice *syscon;
  681. fdt_addr_t addr;
  682. int err;
  683. addr = dev_read_addr(dev);
  684. if (addr == FDT_ADDR_T_NONE)
  685. return -EINVAL;
  686. priv->rcc_base = (struct stm32_rcc_regs *)addr;
  687. /* get corresponding syscon phandle */
  688. err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
  689. "st,syscfg", &syscon);
  690. if (err) {
  691. pr_err("unable to find syscon device\n");
  692. return err;
  693. }
  694. priv->pwr_regmap = syscon_get_regmap(syscon);
  695. if (!priv->pwr_regmap) {
  696. pr_err("unable to find regmap\n");
  697. return -ENODEV;
  698. }
  699. configure_clocks(dev);
  700. return 0;
  701. }
  702. static int stm32_clk_of_xlate(struct clk *clk,
  703. struct ofnode_phandle_args *args)
  704. {
  705. if (args->args_count != 1) {
  706. debug("Invaild args_count: %d\n", args->args_count);
  707. return -EINVAL;
  708. }
  709. if (args->args_count) {
  710. clk->id = args->args[0];
  711. /*
  712. * this computation convert DT clock index which is used to
  713. * point into 2 separate clock arrays (peripheral and kernel
  714. * clocks bank) (see include/dt-bindings/clock/stm32h7-clks.h)
  715. * into index to point into only one array where peripheral
  716. * and kernel clocks are consecutive
  717. */
  718. if (clk->id >= KERN_BANK) {
  719. clk->id -= KERN_BANK;
  720. clk->id += LAST_PERIF_BANK - PERIF_BANK + 1;
  721. } else {
  722. clk->id -= PERIF_BANK;
  723. }
  724. } else {
  725. clk->id = 0;
  726. }
  727. debug("%s clk->id %ld\n", __func__, clk->id);
  728. return 0;
  729. }
  730. static struct clk_ops stm32_clk_ops = {
  731. .of_xlate = stm32_clk_of_xlate,
  732. .enable = stm32_clk_enable,
  733. .get_rate = stm32_clk_get_rate,
  734. };
  735. U_BOOT_DRIVER(stm32h7_clk) = {
  736. .name = "stm32h7_rcc_clock",
  737. .id = UCLASS_CLK,
  738. .ops = &stm32_clk_ops,
  739. .probe = stm32_clk_probe,
  740. .priv_auto_alloc_size = sizeof(struct stm32_clk),
  741. .flags = DM_FLAG_PRE_RELOC,
  742. };