1 /* USER CODE BEGIN Header */
2 /**
3 ******************************************************************************
4 * File Name : stm32mp1xx_hal_msp.c
5 * Description : This file provides code for the MSP Initialization
6 * and de-Initialization codes.
7 ******************************************************************************
8 * @attention
9 *
10 * <h2><center>© Copyright (c) 2020 STMicroelectronics.
11 * All rights reserved.</center></h2>
12 *
13 * This software component is licensed by ST under BSD 3-Clause license,
14 * the "License"; You may not use this file except in compliance with the
15 * License. You may obtain a copy of the License at:
16 * opensource.org/licenses/BSD-3-Clause
17 *
18 ******************************************************************************
19 */
20 /* USER CODE END Header */
21
22 /* Includes ------------------------------------------------------------------*/
23 #include "main.h"
24 /* USER CODE BEGIN Includes */
25 /* USER CODE END Includes */
26
27 /* Private typedef -----------------------------------------------------------*/
28 /* USER CODE BEGIN TD */
29 DMA_HandleTypeDef hdma_hash_in = {0};
30 DMA_HandleTypeDef hdma_cryp_in = {0};
31 DMA_HandleTypeDef hdma_cryp_out = {0};
32 /* USER CODE END TD */
33
34 /* Private define ------------------------------------------------------------*/
35 /* USER CODE BEGIN Define */
36
37 /* USER CODE END Define */
38
39 /* Private macro -------------------------------------------------------------*/
40 /* USER CODE BEGIN Macro */
41
42 /* USER CODE END Macro */
43
44 /* Private variables ---------------------------------------------------------*/
45 /* USER CODE BEGIN PV */
46
47 /* USER CODE END PV */
48
49 /* Private function prototypes -----------------------------------------------*/
50 /* USER CODE BEGIN PFP */
51
52 /* USER CODE END PFP */
53
54 /* External functions --------------------------------------------------------*/
55 /* USER CODE BEGIN ExternalFunctions */
56
57 /* USER CODE END ExternalFunctions */
58
59 /* USER CODE BEGIN 0 */
60
61 /* USER CODE END 0 */
62
63 /**
64 * Initializes the Global MSP.
65 */
HAL_MspInit(void)66 void HAL_MspInit(void)
67 {
68 /* USER CODE BEGIN MspInit 0 */
69
70 /* USER CODE END MspInit 0 */
71
72 __HAL_RCC_HSEM_CLK_ENABLE();
73
74 /* System interrupt init*/
75
76 /* USER CODE BEGIN MspInit 1 */
77 if (IS_ENGINEERING_BOOT_MODE())
78 {
79 __HAL_RCC_SYSRAM_CLK_ENABLE();
80 }
81
82 HAL_NVIC_SetPriority(RCC_WAKEUP_IRQn, 0, 0);
83 HAL_NVIC_EnableIRQ(RCC_WAKEUP_IRQn);
84 __HAL_RCC_ENABLE_IT(RCC_IT_WKUP);
85 /* USER CODE END MspInit 1 */
86 }
87
88 /**
89 * @brief ADC MSP Initialization
90 * This function configures the hardware resources used in this example
91 * @param hadc: ADC handle pointer
92 * @retval None
93 */
HAL_ADC_MspInit(ADC_HandleTypeDef * hadc)94 void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
95 {
96 GPIO_InitTypeDef GPIO_InitStruct = {0};
97 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
98 if(hadc->Instance==ADC2)
99 {
100 /* USER CODE BEGIN ADC2_MspInit 0 */
101
102 /* USER CODE END ADC2_MspInit 0 */
103 if(IS_ENGINEERING_BOOT_MODE())
104 {
105 /** Initializes the peripherals clock
106 */
107 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
108 PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_PER;
109 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
110 {
111 Error_Handler();
112 }
113
114 }
115
116 /* Peripheral clock enable */
117 __HAL_RCC_ADC12_CLK_ENABLE();
118
119 __HAL_RCC_GPIOF_CLK_ENABLE();
120 /**ADC2 GPIO Configuration
121 PF14 ------> ADC2_INP6
122 */
123 GPIO_InitStruct.Pin = GPIO_PIN_14;
124 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
125 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
126
127 /* USER CODE BEGIN ADC2_MspInit 1 */
128 /* USER CODE END ADC2_MspInit 1 */
129 }
130
131 }
132
133 /**
134 * @brief ADC MSP De-Initialization
135 * This function freeze the hardware resources used in this example
136 * @param hadc: ADC handle pointer
137 * @retval None
138 */
HAL_ADC_MspDeInit(ADC_HandleTypeDef * hadc)139 void HAL_ADC_MspDeInit(ADC_HandleTypeDef* hadc)
140 {
141 if(hadc->Instance==ADC2)
142 {
143 /* USER CODE BEGIN ADC2_MspDeInit 0 */
144
145 /* USER CODE END ADC2_MspDeInit 0 */
146 /* Peripheral clock disable */
147 __HAL_RCC_ADC12_CLK_DISABLE();
148
149 /**ADC2 GPIO Configuration
150 PF14 ------> ADC2_INP6
151 */
152 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_14);
153
154 /* USER CODE BEGIN ADC2_MspDeInit 1 */
155
156 /* USER CODE END ADC2_MspDeInit 1 */
157 }
158
159 }
160
161 /**
162 * @brief DAC MSP Initialization
163 * This function configures the hardware resources used in this example
164 * @param hdac: DAC handle pointer
165 * @retval None
166 */
HAL_DAC_MspInit(DAC_HandleTypeDef * hdac)167 void HAL_DAC_MspInit(DAC_HandleTypeDef* hdac)
168 {
169 GPIO_InitTypeDef GPIO_InitStruct = {0};
170 if(hdac->Instance==DAC1)
171 {
172 /* USER CODE BEGIN DAC1_MspInit 0 */
173
174 /* USER CODE END DAC1_MspInit 0 */
175 /* Peripheral clock enable */
176 __HAL_RCC_DAC12_CLK_ENABLE();
177
178 __HAL_RCC_GPIOA_CLK_ENABLE();
179 /**DAC1 GPIO Configuration
180 PA4 ------> DAC1_OUT1
181 */
182 GPIO_InitStruct.Pin = GPIO_PIN_4;
183 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
184 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
185
186 /* USER CODE BEGIN DAC1_MspInit 1 */
187
188 /* USER CODE END DAC1_MspInit 1 */
189 }
190
191 }
192
193 /**
194 * @brief DAC MSP De-Initialization
195 * This function freeze the hardware resources used in this example
196 * @param hdac: DAC handle pointer
197 * @retval None
198 */
HAL_DAC_MspDeInit(DAC_HandleTypeDef * hdac)199 void HAL_DAC_MspDeInit(DAC_HandleTypeDef* hdac)
200 {
201 if(hdac->Instance==DAC1)
202 {
203 /* USER CODE BEGIN DAC1_MspDeInit 0 */
204
205 /* USER CODE END DAC1_MspDeInit 0 */
206 /* Peripheral clock disable */
207 __HAL_RCC_DAC12_CLK_DISABLE();
208
209 /**DAC1 GPIO Configuration
210 PA4 ------> DAC1_OUT1
211 */
212 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_4);
213
214 /* USER CODE BEGIN DAC1_MspDeInit 1 */
215
216 /* USER CODE END DAC1_MspDeInit 1 */
217 }
218
219 }
220
221 /**
222 * @brief IPCC MSP Initialization
223 * This function configures the hardware resources used in this example
224 * @param hipcc: IPCC handle pointer
225 * @retval None
226 */
HAL_IPCC_MspInit(IPCC_HandleTypeDef * hipcc)227 void HAL_IPCC_MspInit(IPCC_HandleTypeDef* hipcc)
228 {
229 if(hipcc->Instance==IPCC)
230 {
231 /* USER CODE BEGIN IPCC_MspInit 0 */
232
233 /* USER CODE END IPCC_MspInit 0 */
234 /* Peripheral clock enable */
235 __HAL_RCC_IPCC_CLK_ENABLE();
236 /* IPCC interrupt Init */
237 HAL_NVIC_SetPriority(IPCC_RX1_IRQn, 0, 0);
238 HAL_NVIC_EnableIRQ(IPCC_RX1_IRQn);
239 HAL_NVIC_SetPriority(IPCC_TX1_IRQn, 0, 0);
240 HAL_NVIC_EnableIRQ(IPCC_TX1_IRQn);
241 /* USER CODE BEGIN IPCC_MspInit 1 */
242
243 /* USER CODE END IPCC_MspInit 1 */
244 }
245
246 }
247
248 /**
249 * @brief IPCC MSP De-Initialization
250 * This function freeze the hardware resources used in this example
251 * @param hipcc: IPCC handle pointer
252 * @retval None
253 */
HAL_IPCC_MspDeInit(IPCC_HandleTypeDef * hipcc)254 void HAL_IPCC_MspDeInit(IPCC_HandleTypeDef* hipcc)
255 {
256 if(hipcc->Instance==IPCC)
257 {
258 /* USER CODE BEGIN IPCC_MspDeInit 0 */
259
260 /* USER CODE END IPCC_MspDeInit 0 */
261 /* Peripheral clock disable */
262 __HAL_RCC_IPCC_CLK_DISABLE();
263
264 /* IPCC interrupt DeInit */
265 HAL_NVIC_DisableIRQ(IPCC_RX1_IRQn);
266 HAL_NVIC_DisableIRQ(IPCC_TX1_IRQn);
267 /* USER CODE BEGIN IPCC_MspDeInit 1 */
268
269 /* USER CODE END IPCC_MspDeInit 1 */
270 }
271
272 }
273
274 /**
275 * @brief LPTIM MSP Initialization
276 * This function configures the hardware resources used in this example
277 * @param hlptim: LPTIM handle pointer
278 * @retval None
279 */
HAL_LPTIM_MspInit(LPTIM_HandleTypeDef * hlptim)280 void HAL_LPTIM_MspInit(LPTIM_HandleTypeDef* hlptim)
281 {
282 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
283 if(hlptim->Instance==LPTIM1)
284 {
285 /* USER CODE BEGIN LPTIM1_MspInit 0 */
286
287 /* USER CODE END LPTIM1_MspInit 0 */
288 if(IS_ENGINEERING_BOOT_MODE())
289 {
290 /** Initializes the peripherals clock
291 */
292 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPTIM1;
293 PeriphClkInit.Lptim1ClockSelection = RCC_LPTIM1CLKSOURCE_LSI;
294 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
295 {
296 Error_Handler();
297 }
298
299 }
300
301 /* Peripheral clock enable */
302 __HAL_RCC_LPTIM1_CLK_ENABLE();
303 /* LPTIM1 interrupt Init */
304 HAL_NVIC_SetPriority(LPTIM1_IRQn, 0, 0);
305 HAL_NVIC_EnableIRQ(LPTIM1_IRQn);
306 /* USER CODE BEGIN LPTIM1_MspInit 1 */
307
308 /* USER CODE END LPTIM1_MspInit 1 */
309 }
310 else if(hlptim->Instance==LPTIM2)
311 {
312 /* USER CODE BEGIN LPTIM2_MspInit 0 */
313
314 /* USER CODE END LPTIM2_MspInit 0 */
315
316 if(IS_ENGINEERING_BOOT_MODE())
317 {
318 /** Initializes the peripherals clock
319 */
320 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPTIM23;
321 PeriphClkInit.Lptim23ClockSelection = RCC_LPTIM23CLKSOURCE_PCLK3;
322 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
323 {
324 Error_Handler();
325 }
326
327 }
328
329 /* Peripheral clock enable */
330 __HAL_RCC_LPTIM2_CLK_ENABLE();
331 /* LPTIM2 interrupt Init */
332 HAL_NVIC_SetPriority(LPTIM2_IRQn, 0, 0);
333 HAL_NVIC_EnableIRQ(LPTIM2_IRQn);
334 /* USER CODE BEGIN LPTIM2_MspInit 1 */
335
336 /* USER CODE END LPTIM2_MspInit 1 */
337 }
338 else if(hlptim->Instance==LPTIM3)
339 {
340 /* USER CODE BEGIN LPTIM3_MspInit 0 */
341
342 /* USER CODE END LPTIM3_MspInit 0 */
343
344 if(IS_ENGINEERING_BOOT_MODE())
345 {
346 /** Initializes the peripherals clock
347 */
348 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPTIM23;
349 PeriphClkInit.Lptim23ClockSelection = RCC_LPTIM23CLKSOURCE_PCLK3;
350 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
351 {
352 Error_Handler();
353 }
354
355 }
356
357 /* Peripheral clock enable */
358 __HAL_RCC_LPTIM3_CLK_ENABLE();
359 /* LPTIM3 interrupt Init */
360 HAL_NVIC_SetPriority(LPTIM3_IRQn, 0, 0);
361 HAL_NVIC_EnableIRQ(LPTIM3_IRQn);
362 /* USER CODE BEGIN LPTIM3_MspInit 1 */
363
364 /* USER CODE END LPTIM3_MspInit 1 */
365 }
366 else if(hlptim->Instance==LPTIM4)
367 {
368 /* USER CODE BEGIN LPTIM4_MspInit 0 */
369
370 /* USER CODE END LPTIM4_MspInit 0 */
371
372 if(IS_ENGINEERING_BOOT_MODE())
373 {
374 /** Initializes the peripherals clock
375 */
376 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPTIM45;
377 PeriphClkInit.Lptim45ClockSelection = RCC_LPTIM45CLKSOURCE_PCLK3;
378 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
379 {
380 Error_Handler();
381 }
382
383 }
384
385 /* Peripheral clock enable */
386 __HAL_RCC_LPTIM4_CLK_ENABLE();
387 /* LPTIM4 interrupt Init */
388 HAL_NVIC_SetPriority(LPTIM4_IRQn, 0, 0);
389 HAL_NVIC_EnableIRQ(LPTIM4_IRQn);
390 /* USER CODE BEGIN LPTIM4_MspInit 1 */
391
392 /* USER CODE END LPTIM4_MspInit 1 */
393 }
394 else if(hlptim->Instance==LPTIM5)
395 {
396 /* USER CODE BEGIN LPTIM5_MspInit 0 */
397
398 /* USER CODE END LPTIM5_MspInit 0 */
399
400 if(IS_ENGINEERING_BOOT_MODE())
401 {
402 /** Initializes the peripherals clock
403 */
404 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_LPTIM45;
405 PeriphClkInit.Lptim45ClockSelection = RCC_LPTIM45CLKSOURCE_PCLK3;
406 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
407 {
408 Error_Handler();
409 }
410
411 }
412
413 /* Peripheral clock enable */
414 __HAL_RCC_LPTIM5_CLK_ENABLE();
415 /* LPTIM5 interrupt Init */
416 HAL_NVIC_SetPriority(LPTIM5_IRQn, 0, 0);
417 HAL_NVIC_EnableIRQ(LPTIM5_IRQn);
418 /* USER CODE BEGIN LPTIM5_MspInit 1 */
419
420 /* USER CODE END LPTIM5_MspInit 1 */
421 }
422
423 }
424
425 /**
426 * @brief LPTIM MSP De-Initialization
427 * This function freeze the hardware resources used in this example
428 * @param hlptim: LPTIM handle pointer
429 * @retval None
430 */
HAL_LPTIM_MspDeInit(LPTIM_HandleTypeDef * hlptim)431 void HAL_LPTIM_MspDeInit(LPTIM_HandleTypeDef* hlptim)
432 {
433 if(hlptim->Instance==LPTIM1)
434 {
435 /* USER CODE BEGIN LPTIM1_MspDeInit 0 */
436
437 /* USER CODE END LPTIM1_MspDeInit 0 */
438 /* Peripheral clock disable */
439 __HAL_RCC_LPTIM1_CLK_DISABLE();
440
441 /* LPTIM1 interrupt DeInit */
442 HAL_NVIC_DisableIRQ(LPTIM1_IRQn);
443 /* USER CODE BEGIN LPTIM1_MspDeInit 1 */
444
445 /* USER CODE END LPTIM1_MspDeInit 1 */
446 }
447 else if(hlptim->Instance==LPTIM2)
448 {
449 /* USER CODE BEGIN LPTIM2_MspDeInit 0 */
450
451 /* USER CODE END LPTIM2_MspDeInit 0 */
452 /* Peripheral clock disable */
453 __HAL_RCC_LPTIM2_CLK_DISABLE();
454
455 /* LPTIM2 interrupt DeInit */
456 HAL_NVIC_DisableIRQ(LPTIM2_IRQn);
457 /* USER CODE BEGIN LPTIM2_MspDeInit 1 */
458
459 /* USER CODE END LPTIM2_MspDeInit 1 */
460 }
461 else if(hlptim->Instance==LPTIM3)
462 {
463 /* USER CODE BEGIN LPTIM3_MspDeInit 0 */
464
465 /* USER CODE END LPTIM3_MspDeInit 0 */
466 /* Peripheral clock disable */
467 __HAL_RCC_LPTIM3_CLK_DISABLE();
468
469 /* LPTIM3 interrupt DeInit */
470 HAL_NVIC_DisableIRQ(LPTIM3_IRQn);
471 /* USER CODE BEGIN LPTIM3_MspDeInit 1 */
472
473 /* USER CODE END LPTIM3_MspDeInit 1 */
474 }
475 else if(hlptim->Instance==LPTIM4)
476 {
477 /* USER CODE BEGIN LPTIM4_MspDeInit 0 */
478
479 /* USER CODE END LPTIM4_MspDeInit 0 */
480 /* Peripheral clock disable */
481 __HAL_RCC_LPTIM4_CLK_DISABLE();
482
483 /* LPTIM4 interrupt DeInit */
484 HAL_NVIC_DisableIRQ(LPTIM4_IRQn);
485 /* USER CODE BEGIN LPTIM4_MspDeInit 1 */
486
487 /* USER CODE END LPTIM4_MspDeInit 1 */
488 }
489 else if(hlptim->Instance==LPTIM5)
490 {
491 /* USER CODE BEGIN LPTIM5_MspDeInit 0 */
492
493 /* USER CODE END LPTIM5_MspDeInit 0 */
494 /* Peripheral clock disable */
495 __HAL_RCC_LPTIM5_CLK_DISABLE();
496
497 /* LPTIM5 interrupt DeInit */
498 HAL_NVIC_DisableIRQ(LPTIM5_IRQn);
499 /* USER CODE BEGIN LPTIM5_MspDeInit 1 */
500
501 /* USER CODE END LPTIM5_MspDeInit 1 */
502 }
503
504 }
505
506 /**
507 * @brief SPI MSP Initialization
508 * This function configures the hardware resources used in this example
509 * @param hspi: SPI handle pointer
510 * @retval None
511 */
HAL_SPI_MspInit(SPI_HandleTypeDef * hspi)512 void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
513 {
514 GPIO_InitTypeDef GPIO_InitStruct = {0};
515 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
516 if(hspi->Instance==SPI5)
517 {
518 /* USER CODE BEGIN SPI5_MspInit 0 */
519
520 /* USER CODE END SPI5_MspInit 0 */
521 if(IS_ENGINEERING_BOOT_MODE())
522 {
523 /** Initializes the peripherals clock
524 */
525 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_SPI45;
526 PeriphClkInit.Spi45ClockSelection = RCC_SPI45CLKSOURCE_PCLK2;
527 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
528 {
529 Error_Handler();
530 }
531
532 }
533
534 /* Peripheral clock enable */
535 __HAL_RCC_SPI5_CLK_ENABLE();
536
537 __HAL_RCC_GPIOF_CLK_ENABLE();
538 /**SPI5 GPIO Configuration
539 PF9 ------> SPI5_MOSI
540 PF8 ------> SPI5_MISO
541 PF7 ------> SPI5_SCK
542 */
543 GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_8|GPIO_PIN_7;
544 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
545 GPIO_InitStruct.Pull = GPIO_PULLUP;
546 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
547 GPIO_InitStruct.Alternate = GPIO_AF5_SPI5;
548 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
549
550 /* USER CODE BEGIN SPI5_MspInit 1 */
551
552 /* USER CODE END SPI5_MspInit 1 */
553 }
554
555 }
556
557 /**
558 * @brief SPI MSP De-Initialization
559 * This function freeze the hardware resources used in this example
560 * @param hspi: SPI handle pointer
561 * @retval None
562 */
HAL_SPI_MspDeInit(SPI_HandleTypeDef * hspi)563 void HAL_SPI_MspDeInit(SPI_HandleTypeDef* hspi)
564 {
565 if(hspi->Instance==SPI5)
566 {
567 /* USER CODE BEGIN SPI5_MspDeInit 0 */
568
569 /* USER CODE END SPI5_MspDeInit 0 */
570 /* Peripheral clock disable */
571 __HAL_RCC_SPI5_CLK_DISABLE();
572
573 /**SPI5 GPIO Configuration
574 PF9 ------> SPI5_MOSI
575 PF7 ------> SPI5_SCK
576 */
577 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_9|GPIO_PIN_7);
578
579 /* USER CODE BEGIN SPI5_MspDeInit 1 */
580
581 /* USER CODE END SPI5_MspDeInit 1 */
582 }
583
584 }
585
586 /**
587 * @brief TIM_Base MSP Initialization
588 * This function configures the hardware resources used in this example
589 * @param htim_base: TIM_Base handle pointer
590 * @retval None
591 */
HAL_TIM_Base_MspInit(TIM_HandleTypeDef * htim_base)592 void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base)
593 {
594 if(htim_base->Instance==TIM4)
595 {
596 /* USER CODE BEGIN TIM4_MspInit 0 */
597
598 /* USER CODE END TIM4_MspInit 0 */
599 /* Peripheral clock enable */
600 __HAL_RCC_TIM4_CLK_ENABLE();
601 /* USER CODE BEGIN TIM4_MspInit 1 */
602
603 /* USER CODE END TIM4_MspInit 1 */
604 }
605 else if(htim_base->Instance==TIM14)
606 {
607 /* USER CODE BEGIN TIM14_MspInit 0 */
608
609 /* USER CODE END TIM14_MspInit 0 */
610 /* Peripheral clock enable */
611 __HAL_RCC_TIM14_CLK_ENABLE();
612 /* USER CODE BEGIN TIM14_MspInit 1 */
613
614 /* USER CODE END TIM14_MspInit 1 */
615 }
616 else if(htim_base->Instance==TIM16)
617 {
618 /* USER CODE BEGIN TIM16_MspInit 0 */
619
620 /* USER CODE END TIM16_MspInit 0 */
621 /* Peripheral clock enable */
622 __HAL_RCC_TIM16_CLK_ENABLE();
623 /* USER CODE BEGIN TIM16_MspInit 1 */
624
625 /* USER CODE END TIM16_MspInit 1 */
626 }
627 else if(htim_base->Instance==TIM17)
628 {
629 /* USER CODE BEGIN TIM17_MspInit 0 */
630
631 /* USER CODE END TIM17_MspInit 0 */
632 /* Peripheral clock enable */
633 __HAL_RCC_TIM17_CLK_ENABLE();
634 /* USER CODE BEGIN TIM17_MspInit 1 */
635
636 /* USER CODE END TIM17_MspInit 1 */
637 }
638
639 }
640
HAL_TIM_MspPostInit(TIM_HandleTypeDef * htim)641 void HAL_TIM_MspPostInit(TIM_HandleTypeDef* htim)
642 {
643 GPIO_InitTypeDef GPIO_InitStruct = {0};
644 if(htim->Instance==TIM4)
645 {
646 /* USER CODE BEGIN TIM4_MspPostInit 0 */
647
648 /* USER CODE END TIM4_MspPostInit 0 */
649
650 __HAL_RCC_GPIOD_CLK_ENABLE();
651 /**TIM4 GPIO Configuration
652 PD13 ------> TIM4_CH2
653 */
654 GPIO_InitStruct.Pin = GPIO_PIN_13;
655 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
656 GPIO_InitStruct.Pull = GPIO_NOPULL;
657 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
658 GPIO_InitStruct.Alternate = GPIO_AF2_TIM4;
659 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
660
661 /* USER CODE BEGIN TIM4_MspPostInit 1 */
662
663 /* USER CODE END TIM4_MspPostInit 1 */
664 }
665
666 }
667 /**
668 * @brief TIM_Base MSP De-Initialization
669 * This function freeze the hardware resources used in this example
670 * @param htim_base: TIM_Base handle pointer
671 * @retval None
672 */
HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef * htim_base)673 void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* htim_base)
674 {
675 if(htim_base->Instance==TIM4)
676 {
677 /* USER CODE BEGIN TIM4_MspDeInit 0 */
678
679 /* USER CODE END TIM4_MspDeInit 0 */
680 /* Peripheral clock disable */
681 __HAL_RCC_TIM4_CLK_DISABLE();
682 /* USER CODE BEGIN TIM4_MspDeInit 1 */
683
684 /* USER CODE END TIM4_MspDeInit 1 */
685 }
686 else if(htim_base->Instance==TIM14)
687 {
688 /* USER CODE BEGIN TIM14_MspDeInit 0 */
689
690 /* USER CODE END TIM14_MspDeInit 0 */
691 /* Peripheral clock disable */
692 __HAL_RCC_TIM14_CLK_DISABLE();
693 /* USER CODE BEGIN TIM14_MspDeInit 1 */
694
695 /* USER CODE END TIM14_MspDeInit 1 */
696 }
697 else if(htim_base->Instance==TIM16)
698 {
699 /* USER CODE BEGIN TIM16_MspDeInit 0 */
700
701 /* USER CODE END TIM16_MspDeInit 0 */
702 /* Peripheral clock disable */
703 __HAL_RCC_TIM16_CLK_DISABLE();
704 /* USER CODE BEGIN TIM16_MspDeInit 1 */
705
706 /* USER CODE END TIM16_MspDeInit 1 */
707 }
708 else if(htim_base->Instance==TIM17)
709 {
710 /* USER CODE BEGIN TIM17_MspDeInit 0 */
711
712 /* USER CODE END TIM17_MspDeInit 0 */
713 /* Peripheral clock disable */
714 __HAL_RCC_TIM17_CLK_DISABLE();
715 /* USER CODE BEGIN TIM17_MspDeInit 1 */
716
717 /* USER CODE END TIM17_MspDeInit 1 */
718 }
719
720 }
721
722 /**
723 * @brief UART MSP Initialization
724 * This function configures the hardware resources used in this example
725 * @param huart: UART handle pointer
726 * @retval None
727 */
HAL_UART_MspInit(UART_HandleTypeDef * huart)728 void HAL_UART_MspInit(UART_HandleTypeDef* huart)
729 {
730 GPIO_InitTypeDef GPIO_InitStruct = {0};
731 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
732 if(huart->Instance==UART4)
733 {
734 /* USER CODE BEGIN UART4_MspInit 0 */
735
736 /* USER CODE END UART4_MspInit 0 */
737 if(IS_ENGINEERING_BOOT_MODE())
738 {
739 /** Initializes the peripherals clock
740 */
741 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_UART24;
742 PeriphClkInit.Uart24ClockSelection = RCC_UART24CLKSOURCE_HSI;
743 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
744 {
745 Error_Handler();
746 }
747
748 }
749
750 /* Peripheral clock enable */
751 __HAL_RCC_UART4_CLK_ENABLE();
752
753 __HAL_RCC_GPIOG_CLK_ENABLE();
754 __HAL_RCC_GPIOB_CLK_ENABLE();
755 /**UART4 GPIO Configuration
756 PG11 ------> UART4_TX
757 PB2 ------> UART4_RX
758 */
759 GPIO_InitStruct.Pin = STLINK_RX_Pin;
760 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
761 GPIO_InitStruct.Pull = GPIO_PULLUP;
762 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
763 GPIO_InitStruct.Alternate = GPIO_AF6_UART4;
764 HAL_GPIO_Init(STLINK_RX_GPIO_Port, &GPIO_InitStruct);
765
766 GPIO_InitStruct.Pin = STLINK_TX_Pin;
767 GPIO_InitStruct.Mode = GPIO_MODE_AF;
768 GPIO_InitStruct.Pull = GPIO_PULLUP;
769 GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
770 HAL_GPIO_Init(STLINK_TX_GPIO_Port, &GPIO_InitStruct);
771
772 /* USER CODE BEGIN UART4_MspInit 1 */
773
774 /* USER CODE END UART4_MspInit 1 */
775 }
776 else if(huart->Instance==USART3)
777 {
778 /* USER CODE BEGIN USART3_MspInit 0 */
779
780 /* USER CODE END USART3_MspInit 0 */
781
782 if(IS_ENGINEERING_BOOT_MODE())
783 {
784 /** Initializes the peripherals clock
785 */
786 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_UART35;
787 PeriphClkInit.Uart35ClockSelection = RCC_UART35CLKSOURCE_PCLK1;
788 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
789 {
790 Error_Handler();
791 }
792
793 }
794
795 /* Peripheral clock enable */
796 __HAL_RCC_USART3_CLK_ENABLE();
797
798 __HAL_RCC_GPIOB_CLK_ENABLE();
799 /**USART3 GPIO Configuration
800 PB10 ------> USART3_TX
801 PB12 ------> USART3_RX
802 */
803 GPIO_InitStruct.Pin = GPIO_PIN_10;
804 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
805 GPIO_InitStruct.Pull = GPIO_PULLUP;
806 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
807 GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
808 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
809
810 GPIO_InitStruct.Pin = GPIO_PIN_12;
811 GPIO_InitStruct.Mode = GPIO_MODE_AF;
812 GPIO_InitStruct.Pull = GPIO_PULLUP;
813 GPIO_InitStruct.Alternate = GPIO_AF8_USART3;
814 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
815
816 /* USER CODE BEGIN USART3_MspInit 1 */
817
818 /* USER CODE END USART3_MspInit 1 */
819 }
820
821 }
822
823 /**
824 * @brief UART MSP De-Initialization
825 * This function freeze the hardware resources used in this example
826 * @param huart: UART handle pointer
827 * @retval None
828 */
HAL_UART_MspDeInit(UART_HandleTypeDef * huart)829 void HAL_UART_MspDeInit(UART_HandleTypeDef* huart)
830 {
831 if(huart->Instance==UART4)
832 {
833 /* USER CODE BEGIN UART4_MspDeInit 0 */
834
835 /* USER CODE END UART4_MspDeInit 0 */
836 /* Peripheral clock disable */
837 __HAL_RCC_UART4_CLK_DISABLE();
838
839 /**UART4 GPIO Configuration
840 PG11 ------> UART4_TX
841 PB2 ------> UART4_RX
842 */
843 HAL_GPIO_DeInit(STLINK_RX_GPIO_Port, STLINK_RX_Pin);
844
845 HAL_GPIO_DeInit(STLINK_TX_GPIO_Port, STLINK_TX_Pin);
846
847 /* USER CODE BEGIN UART4_MspDeInit 1 */
848
849 /* USER CODE END UART4_MspDeInit 1 */
850 }
851 else if(huart->Instance==USART3)
852 {
853 /* USER CODE BEGIN USART3_MspDeInit 0 */
854
855 /* USER CODE END USART3_MspDeInit 0 */
856 /* Peripheral clock disable */
857 __HAL_RCC_USART3_CLK_DISABLE();
858
859 /**USART3 GPIO Configuration
860 PB10 ------> USART3_TX
861 PB12 ------> USART3_RX
862 */
863 HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_12);
864
865 /* USER CODE BEGIN USART3_MspDeInit 1 */
866
867 /* USER CODE END USART3_MspDeInit 1 */
868 }
869
870 }
871
872 /**
873 * @brief WWDG MSP Initialization
874 * This function configures the hardware resources used in this example
875 * @param hwwdg: WWDG handle pointer
876 * @retval None
877 */
HAL_WWDG_MspInit(WWDG_HandleTypeDef * hwwdg)878 void HAL_WWDG_MspInit(WWDG_HandleTypeDef* hwwdg)
879 {
880 if(hwwdg->Instance==WWDG1)
881 {
882 /* USER CODE BEGIN WWDG1_MspInit 0 */
883
884 /* USER CODE END WWDG1_MspInit 0 */
885 /* Peripheral clock enable */
886 __HAL_RCC_WWDG1_CLK_ENABLE();
887 /* WWDG1 interrupt Init */
888 HAL_NVIC_SetPriority(WWDG1_IRQn, 0, 0);
889 HAL_NVIC_EnableIRQ(WWDG1_IRQn);
890 /* USER CODE BEGIN WWDG1_MspInit 1 */
891
892 /* USER CODE END WWDG1_MspInit 1 */
893 }
894
895 }
896
897 /* USER CODE BEGIN 1 */
898 /**
899 * @brief Initializes I2C MSP.
900 * @param hI2c : I2C handler
901 * @retval None
902 */
HAL_I2C_MspInit(I2C_HandleTypeDef * hI2c)903 void HAL_I2C_MspInit(I2C_HandleTypeDef *hI2c)
904 {
905 GPIO_InitTypeDef GPIO_InitStruct = {0};
906 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
907
908 if(hI2c->Instance == I2C4)
909 {
910 if(IS_ENGINEERING_BOOT_MODE())
911 {
912 /*** Configure the I2C peripheral clock ***/
913 PeriphClkInit.I2c46ClockSelection = RCC_I2C46CLKSOURCE_HSI;
914 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_I2C46;
915 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
916 {
917 Error_Handler();
918 }
919 }
920
921 /* Enable GPIO clock */
922 __HAL_RCC_GPIOZ_CLK_ENABLE();
923
924 /* Configure I2C Tx/RX as alternate function */
925 GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5;
926 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
927 GPIO_InitStruct.Pull = GPIO_NOPULL;
928 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
929 GPIO_InitStruct.Alternate = GPIO_AF6_I2C4;
930 HAL_GPIO_Init(GPIOZ, &GPIO_InitStruct);
931
932 /* Enable I2C clock */
933 __HAL_RCC_I2C4_CLK_ENABLE();
934 /* Force the I2C peripheral clock reset */
935 __HAL_RCC_I2C4_FORCE_RESET();
936 /* Release the I2C peripheral clock reset */
937 __HAL_RCC_I2C4_RELEASE_RESET();
938
939 HAL_NVIC_SetPriority(I2C4_ER_IRQn, 0, 1);
940 HAL_NVIC_EnableIRQ(I2C4_ER_IRQn);
941 HAL_NVIC_SetPriority(I2C4_EV_IRQn, 0, 2);
942 HAL_NVIC_EnableIRQ(I2C4_EV_IRQn);
943 }
944 }
945
946 /**
947 * @brief SD MSP Initialization
948 * This function configures the hardware resources used in this example
949 * @param hsd: SD handle pointer
950 * @retval None
951 */
HAL_SD_MspInit(SD_HandleTypeDef * hsd)952 void HAL_SD_MspInit(SD_HandleTypeDef* hsd)
953 {
954 GPIO_InitTypeDef GPIO_InitStruct = {0};
955 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
956
957 if(hsd->Instance==SDMMC1)
958 {
959 /* USER CODE BEGIN SDMMC1_MspInit 0 */
960 if (IS_ENGINEERING_BOOT_MODE())
961 {
962 /** Initializes the peripherals clock
963 */
964 PeriphClkInit.Sdmmc12ClockSelection = RCC_SDMMC12CLKSOURCE_PLL4;
965 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_SDMMC12;
966 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
967 {
968 Error_Handler();
969 }
970 }
971 /* USER CODE END SDMMC1_MspInit 0 */
972 /* Peripheral clock enable */
973 __HAL_RCC_SDMMC1_CLK_ENABLE();
974
975 __HAL_RCC_GPIOC_CLK_ENABLE();
976 __HAL_RCC_GPIOD_CLK_ENABLE();
977 /**SDMMC1 GPIO Configuration
978 PC8 ------> SDMMC1_D0
979 PC9 ------> SDMMC1_D1
980 PC10 ------> SDMMC1_D2
981 PC11 ------> SDMMC1_D3
982 PC12 ------> SDMMC1_CK
983 PD2 ------> SDMMC1_CMD
984 */
985 GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
986 |GPIO_PIN_12;
987 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
988 GPIO_InitStruct.Pull = GPIO_NOPULL;
989 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
990 GPIO_InitStruct.Alternate = GPIO_AF12_SDIO1;
991 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
992
993 GPIO_InitStruct.Pin = GPIO_PIN_2;
994 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
995
996 __HAL_RCC_SDMMC1_FORCE_RESET();
997 __HAL_RCC_SDMMC1_RELEASE_RESET();
998
999 /* SDMMC1 interrupt Init */
1000 HAL_NVIC_SetPriority(SDMMC1_IRQn, 2, 0);
1001 HAL_NVIC_EnableIRQ(SDMMC1_IRQn);
1002 /* USER CODE BEGIN SDMMC1_MspInit 1 */
1003
1004 /* USER CODE END SDMMC1_MspInit 1 */
1005 }
1006 if(hsd->Instance==SDMMC2)
1007 {
1008 /* USER CODE BEGIN SDMMC2_MspInit 0 */
1009 if (IS_ENGINEERING_BOOT_MODE())
1010 {
1011 /** Initializes the peripherals clock
1012 */
1013 PeriphClkInit.Sdmmc12ClockSelection = RCC_SDMMC12CLKSOURCE_PLL4;
1014 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_SDMMC12;
1015 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
1016 {
1017 Error_Handler();
1018 }
1019 }
1020 /* USER CODE END SDMMC2_MspInit 0 */
1021 /* Peripheral clock enable */
1022 __HAL_RCC_SDMMC2_CLK_ENABLE();
1023
1024 __HAL_RCC_GPIOB_CLK_ENABLE();
1025 __HAL_RCC_GPIOE_CLK_ENABLE();
1026 __HAL_RCC_GPIOG_CLK_ENABLE();
1027 /**SDMMC2 GPIO Configuration
1028 PB14 ------> SDMMC2_D0
1029 PB15 ------> SDMMC2_D1
1030 PB3 ------> SDMMC2_D2
1031 PB4 ------> SDMMC2_D3
1032 PE3 ------> SDMMC2_CK
1033 PG6 ------> SDMMC2_CMD
1034 */
1035 GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_14|GPIO_PIN_15;
1036 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
1037 GPIO_InitStruct.Pull = GPIO_NOPULL;
1038 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
1039 GPIO_InitStruct.Alternate = GPIO_AF9_SDIO2;
1040 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
1041
1042 GPIO_InitStruct.Pin = GPIO_PIN_3;
1043 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
1044 GPIO_InitStruct.Pull = GPIO_NOPULL;
1045 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
1046 GPIO_InitStruct.Alternate = GPIO_AF9_SDIO2;
1047 HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
1048
1049 GPIO_InitStruct.Pin = GPIO_PIN_6;
1050 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
1051 GPIO_InitStruct.Pull = GPIO_NOPULL;
1052 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
1053 GPIO_InitStruct.Alternate = GPIO_AF10_SDIO2;
1054 HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
1055
1056 __HAL_RCC_SDMMC2_FORCE_RESET();
1057 __HAL_RCC_SDMMC2_RELEASE_RESET();
1058
1059 /* SDMMC2 interrupt Init */
1060 HAL_NVIC_SetPriority(SDMMC2_IRQn, 2, 0);
1061 HAL_NVIC_EnableIRQ(SDMMC2_IRQn);
1062 /* USER CODE BEGIN SDMMC2_MspInit 1 */
1063
1064 /* USER CODE END SDMMC2_MspInit 1 */
1065 }
1066 }
1067
1068 /**
1069 * @brief SD MSP De-Initialization
1070 * This function freeze the hardware resources used in this example
1071 * @param hsd: SD handle pointer
1072 * @retval None
1073 */
HAL_SD_MspDeInit(SD_HandleTypeDef * hsd)1074 void HAL_SD_MspDeInit(SD_HandleTypeDef* hsd)
1075 {
1076 if(hsd->Instance==SDMMC1)
1077 {
1078 /* USER CODE BEGIN SDMMC1_MspDeInit 0 */
1079
1080 /* USER CODE END SDMMC1_MspDeInit 0 */
1081 /* Peripheral clock disable */
1082 __HAL_RCC_SDMMC1_CLK_DISABLE();
1083
1084 /**SDMMC1 GPIO Configuration
1085 PC8 ------> SDMMC1_D0
1086 PC9 ------> SDMMC1_D1
1087 PC10 ------> SDMMC1_D2
1088 PC11 ------> SDMMC1_D3
1089 PC12 ------> SDMMC1_CK
1090 PD2 ------> SDMMC1_CMD
1091 */
1092 HAL_GPIO_DeInit(GPIOC, GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11
1093 |GPIO_PIN_12);
1094
1095 HAL_GPIO_DeInit(GPIOD, GPIO_PIN_2);
1096
1097 /* SDMMC1 interrupt DeInit */
1098 HAL_NVIC_DisableIRQ(SDMMC1_IRQn);
1099 /* USER CODE BEGIN SDMMC1_MspDeInit 1 */
1100
1101 /* USER CODE END SDMMC1_MspDeInit 1 */
1102 }
1103
1104 }
1105
1106 /**
1107 * @brief DeInitializes I2C MSP.
1108 * @param hI2c : I2C handler
1109 * @retval None
1110 */
HAL_I2C_MspDeInit(I2C_HandleTypeDef * hI2c)1111 void HAL_I2C_MspDeInit(I2C_HandleTypeDef *hI2c)
1112 {
1113 GPIO_InitTypeDef GPIO_InitStruct = {0};
1114
1115 if(hI2c->Instance == I2C4)
1116 {
1117 /* Configure I2C Tx, Rx as alternate function */
1118 GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5;
1119 HAL_GPIO_DeInit(GPIOZ, GPIO_InitStruct.Pin);
1120
1121 /* Disable I2C clock */
1122 __HAL_RCC_I2C4_CLK_DISABLE();
1123
1124 /* Disable NVIC for I2C */
1125 HAL_NVIC_DisableIRQ(I2C4_ER_IRQn);
1126 HAL_NVIC_DisableIRQ(I2C4_EV_IRQn);
1127 }
1128 }
1129
1130 /**
1131 * @brief CRC MSP Initialization
1132 * This function configures the hardware resources used in this example
1133 * @param hcrc: CRC handle pointer
1134 * @retval None
1135 */
HAL_CRC_MspInit(CRC_HandleTypeDef * hcrc)1136 void HAL_CRC_MspInit(CRC_HandleTypeDef* hcrc)
1137 {
1138 if(hcrc->Instance==CRC2)
1139 {
1140 /* USER CODE BEGIN CRC2_MspInit 0 */
1141
1142 /* USER CODE END CRC2_MspInit 0 */
1143 /* Peripheral clock enable */
1144 __HAL_RCC_CRC2_CLK_ENABLE();
1145 /* USER CODE BEGIN CRC2_MspInit 1 */
1146
1147 /* USER CODE END CRC2_MspInit 1 */
1148 }
1149
1150 }
1151
1152 /**
1153 * @brief CRC MSP De-Initialization
1154 * This function freeze the hardware resources used in this example
1155 * @param hcrc: CRC handle pointer
1156 * @retval None
1157 */
HAL_CRC_MspDeInit(CRC_HandleTypeDef * hcrc)1158 void HAL_CRC_MspDeInit(CRC_HandleTypeDef* hcrc)
1159 {
1160 if(hcrc->Instance==CRC2)
1161 {
1162 /* USER CODE BEGIN CRC2_MspDeInit 0 */
1163
1164 /* USER CODE END CRC2_MspDeInit 0 */
1165 /* Peripheral clock disable */
1166 __HAL_RCC_CRC2_CLK_DISABLE();
1167 /* USER CODE BEGIN CRC2_MspDeInit 1 */
1168
1169 /* USER CODE END CRC2_MspDeInit 1 */
1170 }
1171
1172 }
1173
1174 /**
1175 * @brief RNG MSP Initialization
1176 * This function configures the hardware resources used in this example
1177 * @param hrng: RNG handle pointer
1178 * @retval None
1179 */
HAL_RNG_MspInit(RNG_HandleTypeDef * hrng)1180 void HAL_RNG_MspInit(RNG_HandleTypeDef* hrng)
1181 {
1182 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
1183 if(hrng->Instance==RNG2)
1184 {
1185 /* USER CODE BEGIN RNG2_MspInit 0 */
1186
1187 /* USER CODE END RNG2_MspInit 0 */
1188 if(IS_ENGINEERING_BOOT_MODE())
1189 {
1190 /** Initializes the peripherals clock
1191 */
1192 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RNG2;
1193 PeriphClkInit.Rng2ClockSelection = RCC_RNG2CLKSOURCE_CSI;
1194 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
1195 {
1196 Error_Handler();
1197 }
1198
1199 }
1200
1201 /* Peripheral clock enable */
1202 __HAL_RCC_RNG2_CLK_ENABLE();
1203 /* USER CODE BEGIN RNG2_MspInit 1 */
1204
1205 /* USER CODE END RNG2_MspInit 1 */
1206 }
1207
1208 }
1209
1210 /**
1211 * @brief RNG MSP De-Initialization
1212 * This function freeze the hardware resources used in this example
1213 * @param hrng: RNG handle pointer
1214 * @retval None
1215 */
HAL_RNG_MspDeInit(RNG_HandleTypeDef * hrng)1216 void HAL_RNG_MspDeInit(RNG_HandleTypeDef* hrng)
1217 {
1218 if(hrng->Instance==RNG2)
1219 {
1220 /* USER CODE BEGIN RNG2_MspDeInit 0 */
1221
1222 /* USER CODE END RNG2_MspDeInit 0 */
1223 /* Peripheral clock disable */
1224 __HAL_RCC_RNG2_CLK_DISABLE();
1225 /* USER CODE BEGIN RNG2_MspDeInit 1 */
1226
1227 /* USER CODE END RNG2_MspDeInit 1 */
1228 }
1229
1230 }
1231
1232 /**
1233 * @brief HASH MSP Initialization
1234 * This function configures the hardware resources used in this example
1235 * @param hhash: HASH handle pointer
1236 * @retval None
1237 */
HAL_HASH_MspInit(HASH_HandleTypeDef * hhash)1238 void HAL_HASH_MspInit(HASH_HandleTypeDef* hhash)
1239 {
1240 /* USER CODE BEGIN HASH2_MspInit 0 */
1241 /* USER CODE END HASH2_MspInit 0 */
1242 /* Peripheral clock enable */
1243 __HAL_RCC_HASH2_CLK_ENABLE();
1244 /* USER CODE BEGIN HASH2_MspInit 1 */
1245 __HAL_RCC_DMAMUX_CLK_ENABLE();
1246
1247 /* Peripheral DMA init*/
1248 hdma_hash_in.Instance = DMA2_Stream7;
1249 hdma_hash_in.Init.Request = DMA_REQUEST_HASH2_IN;
1250 hdma_hash_in.Init.Direction = DMA_MEMORY_TO_PERIPH;
1251 hdma_hash_in.Init.PeriphInc = DMA_PINC_DISABLE;
1252 hdma_hash_in.Init.MemInc = DMA_MINC_ENABLE;
1253 hdma_hash_in.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
1254 hdma_hash_in.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
1255 hdma_hash_in.Init.Mode = DMA_NORMAL;
1256 hdma_hash_in.Init.Priority = DMA_PRIORITY_HIGH;
1257 hdma_hash_in.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
1258 hdma_hash_in.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
1259 hdma_hash_in.Init.MemBurst = DMA_MBURST_SINGLE;
1260 hdma_hash_in.Init.PeriphBurst = DMA_PBURST_SINGLE;
1261
1262 if (HAL_DMA_DeInit(&hdma_hash_in) != HAL_OK)
1263 {
1264 Error_Handler();
1265 }
1266 if (HAL_DMA_Init(&hdma_hash_in) != HAL_OK)
1267 {
1268 Error_Handler();
1269 }
1270
1271 __HAL_LINKDMA(hhash,hdmain,hdma_hash_in);
1272 /* USER CODE END HASH2_MspInit 1 */
1273
1274 }
1275
1276 /**
1277 * @brief HASH MSP De-Initialization
1278 * This function freeze the hardware resources used in this example
1279 * @param hhash: HASH handle pointer
1280 * @retval None
1281 */
HAL_HASH_MspDeInit(HASH_HandleTypeDef * hhash)1282 void HAL_HASH_MspDeInit(HASH_HandleTypeDef* hhash)
1283 {
1284 /* USER CODE BEGIN HASH2_MspDeInit 0 */
1285
1286 /* USER CODE END HASH2_MspDeInit 0 */
1287 /* Peripheral clock disable */
1288 __HAL_RCC_HASH2_CLK_DISABLE();
1289 /* USER CODE BEGIN HASH2_MspDeInit 1 */
1290
1291 /* USER CODE END HASH2_MspDeInit 1 */
1292
1293 }
1294
1295 #if defined (CRYP1) || defined (CRYP2)
HAL_CRYP_MspInit(CRYP_HandleTypeDef * hcryp)1296 void HAL_CRYP_MspInit(CRYP_HandleTypeDef* hcryp)
1297 {
1298 if(hcryp->Instance==CRYP2)
1299 {
1300 /* Peripheral clock enable */
1301 __HAL_RCC_CRYP2_CLK_ENABLE();
1302 __HAL_RCC_DMAMUX_CLK_ENABLE();
1303
1304 /* Peripheral DMA init*/
1305 hdma_cryp_in.Instance = DMA2_Stream6;
1306 hdma_cryp_in.Init.Request = DMA_REQUEST_CRYP2_IN;
1307 hdma_cryp_in.Init.Direction = DMA_MEMORY_TO_PERIPH;
1308 hdma_cryp_in.Init.PeriphInc = DMA_PINC_DISABLE;
1309 hdma_cryp_in.Init.MemInc = DMA_MINC_ENABLE;
1310 hdma_cryp_in.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
1311 hdma_cryp_in.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
1312 hdma_cryp_in.Init.Mode = DMA_NORMAL;
1313 hdma_cryp_in.Init.Priority = DMA_PRIORITY_HIGH;
1314 hdma_cryp_in.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
1315 if (HAL_DMA_DeInit(&hdma_cryp_in) != HAL_OK)
1316 {
1317 Error_Handler();
1318 }
1319 if (HAL_DMA_Init(&hdma_cryp_in) != HAL_OK)
1320 {
1321 Error_Handler();
1322 }
1323
1324 __HAL_LINKDMA(hcryp,hdmain,hdma_cryp_in);
1325
1326 hdma_cryp_out.Instance = DMA2_Stream5;
1327 hdma_cryp_out.Init.Request = DMA_REQUEST_CRYP2_OUT;
1328 hdma_cryp_out.Init.Direction = DMA_PERIPH_TO_MEMORY;
1329 hdma_cryp_out.Init.PeriphInc = DMA_PINC_DISABLE;
1330 hdma_cryp_out.Init.MemInc = DMA_MINC_ENABLE;
1331 hdma_cryp_out.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
1332 hdma_cryp_out.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
1333 hdma_cryp_out.Init.Mode = DMA_NORMAL;
1334 hdma_cryp_out.Init.Priority = DMA_PRIORITY_VERY_HIGH;
1335 hdma_cryp_out.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
1336 if (HAL_DMA_DeInit(&hdma_cryp_out) != HAL_OK)
1337 {
1338 Error_Handler();
1339 }
1340 if (HAL_DMA_Init(&hdma_cryp_out) != HAL_OK)
1341 {
1342 Error_Handler();
1343 }
1344
1345 __HAL_LINKDMA(hcryp,hdmaout,hdma_cryp_out);
1346
1347 /* USER CODE BEGIN CRYP_MspInit 1 */
1348
1349 /* USER CODE END CRYP_MspInit 1 */
1350 }
1351 }
1352
HAL_CRYP_MspDeInit(CRYP_HandleTypeDef * hcryp)1353 void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef* hcryp)
1354 {
1355
1356 if(hcryp->Instance==CRYP2)
1357 {
1358 /* USER CODE BEGIN CRYP_MspDeInit 0 */
1359
1360 /* USER CODE END CRYP_MspDeInit 0 */
1361 /* Peripheral clock disable */
1362 __HAL_RCC_CRYP2_CLK_DISABLE();
1363
1364 /* Peripheral DMA DeInit*/
1365 HAL_DMA_DeInit(hcryp->hdmain);
1366 HAL_DMA_DeInit(hcryp->hdmaout);
1367 }
1368 /* USER CODE BEGIN CRYP_MspDeInit 1 */
1369
1370 /* USER CODE END CRYP_MspDeInit 1 */
1371
1372 }
1373 #endif
1374
1375 /**
1376 * @brief RTC MSP Initialization
1377 * This function configures the hardware resources used in this example
1378 * @param hrtc: RTC handle pointer
1379 * @retval None
1380 */
HAL_RTC_MspInit(RTC_HandleTypeDef * hrtc)1381 void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc)
1382 {
1383 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
1384 if(hrtc->Instance==RTC)
1385 {
1386 /* USER CODE BEGIN SDMMC1_MspInit 0 */
1387 if (IS_ENGINEERING_BOOT_MODE())
1388 {
1389 /** Initializes the peripherals clock
1390 */
1391 PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
1392 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC;
1393 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
1394 {
1395 Error_Handler();
1396 }
1397 }
1398 /* USER CODE BEGIN RTC_MspInit 0 */
1399
1400 /* USER CODE END RTC_MspInit 0 */
1401 /* Peripheral clock enable */
1402 __HAL_RCC_RTC_ENABLE();
1403
1404 /* USER CODE BEGIN RTC_MspInit 1 */
1405
1406 /* USER CODE END RTC_MspInit 1 */
1407 }
1408
1409 }
1410
1411 /**
1412 * @brief RTC MSP De-Initialization
1413 * This function freeze the hardware resources used in this example
1414 * @param hrtc: RTC handle pointer
1415 * @retval None
1416 */
HAL_RTC_MspDeInit(RTC_HandleTypeDef * hrtc)1417 void HAL_RTC_MspDeInit(RTC_HandleTypeDef* hrtc)
1418 {
1419 if(hrtc->Instance==RTC)
1420 {
1421 /* USER CODE BEGIN RTC_MspDeInit 0 */
1422
1423 /* USER CODE END RTC_MspDeInit 0 */
1424 /* Peripheral clock disable */
1425 __HAL_RCC_RTC_DISABLE();
1426
1427 /* USER CODE BEGIN RTC_MspDeInit 1 */
1428
1429 /* USER CODE END RTC_MspDeInit 1 */
1430 }
1431
1432 }
1433 /**
1434 * @brief This function is executed in case of error occurrence.
1435 * @retval None
1436 */
Error_Handler(void)1437 void Error_Handler(void)
1438 {
1439 /* USER CODE BEGIN Error_Handler_Debug */
1440 /* User can add his own implementation to report the HAL error return state */
1441
1442 /* USER CODE END Error_Handler_Debug */
1443 }
1444 /* USER CODE END 1 */
1445
1446 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
1447