stm32_it.c 21.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * Original template from ST Cube library.  See below for header.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/**
  ******************************************************************************
  * @file    Templates/Src/stm32f4xx_it.c
  * @author  MCD Application Team
  * @version V1.0.1
  * @date    26-February-2014
  * @brief   Main Interrupt Service Routines.
  *          This file provides template for all exceptions handler and
  *          peripherals interrupt service routine.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */

#include <stdio.h>

70
#include "py/mpstate.h"
71
#include "py/obj.h"
72
#include "py/mphal.h"
73
#include "stm32_it.h"
74
#include "pendsv.h"
75
#include "irq.h"
76
#include "pybthread.h"
77
#include "gccollect.h"
78
79
#include "extint.h"
#include "timer.h"
80
#include "uart.h"
81
#include "storage.h"
82
#include "can.h"
83
#include "dma.h"
84
#include "i2c.h"
85
#include "usb.h"
86
87

extern void __fatal_error(const char*);
88
89
extern PCD_HandleTypeDef pcd_fs_handle;
extern PCD_HandleTypeDef pcd_hs_handle;
90

91
92
93
94
/******************************************************************************/
/*            Cortex-M4 Processor Exceptions Handlers                         */
/******************************************************************************/

95
96
97
98
// Set the following to 1 to get some more information on the Hard Fault
// More information about decoding the fault registers can be found here:
// http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0646a/Cihdjcfc.html

99
STATIC char *fmt_hex(uint32_t val, char *buf) {
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
    const char *hexDig = "0123456789abcdef";

    buf[0] = hexDig[(val >> 28) & 0x0f];
    buf[1] = hexDig[(val >> 24) & 0x0f];
    buf[2] = hexDig[(val >> 20) & 0x0f];
    buf[3] = hexDig[(val >> 16) & 0x0f];
    buf[4] = hexDig[(val >> 12) & 0x0f];
    buf[5] = hexDig[(val >>  8) & 0x0f];
    buf[6] = hexDig[(val >>  4) & 0x0f];
    buf[7] = hexDig[(val >>  0) & 0x0f];
    buf[8] = '\0';

    return buf;
}

115
STATIC void print_reg(const char *label, uint32_t val) {
116
117
118
119
120
121
122
    char hexStr[9];

    mp_hal_stdout_tx_str(label);
    mp_hal_stdout_tx_str(fmt_hex(val, hexStr));
    mp_hal_stdout_tx_str("\r\n");
}

123
124
125
126
127
128
129
130
131
STATIC void print_hex_hex(const char *label, uint32_t val1, uint32_t val2) {
    char hex_str[9];
    mp_hal_stdout_tx_str(label);
    mp_hal_stdout_tx_str(fmt_hex(val1, hex_str));
    mp_hal_stdout_tx_str("  ");
    mp_hal_stdout_tx_str(fmt_hex(val2, hex_str));
    mp_hal_stdout_tx_str("\r\n");
}

132
133
134
135
136
137
138
139
// The ARMv7M Architecture manual (section B.1.5.6) says that upon entry
// to an exception, that the registers will be in the following order on the
// // stack: R0, R1, R2, R3, R12, LR, PC, XPSR

typedef struct {
    uint32_t    r0, r1, r2, r3, r12, lr, pc, xpsr;
} ExceptionRegisters_t;

140
141
int pyb_hard_fault_debug = 0;

142
void HardFault_C_Handler(ExceptionRegisters_t *regs) {
143
144
145
146
    if (!pyb_hard_fault_debug) {
        NVIC_SystemReset();
    }

147
148
149
150
151
152
    // We need to disable the USB so it doesn't try to write data out on
    // the VCP and then block indefinitely waiting for the buffer to drain.
    pyb_usb_flags = 0;

    mp_hal_stdout_tx_str("HardFault\r\n");

153
154
155
156
157
    print_reg("R0    ", regs->r0);
    print_reg("R1    ", regs->r1);
    print_reg("R2    ", regs->r2);
    print_reg("R3    ", regs->r3);
    print_reg("R12   ", regs->r12);
158
    print_reg("SP    ", (uint32_t)regs);
159
160
161
    print_reg("LR    ", regs->lr);
    print_reg("PC    ", regs->pc);
    print_reg("XPSR  ", regs->xpsr);
162

163
164
165
166
167
168
169
170
171
172
    uint32_t cfsr = SCB->CFSR;

    print_reg("HFSR  ", SCB->HFSR);
    print_reg("CFSR  ", cfsr);
    if (cfsr & 0x80) {
        print_reg("MMFAR ", SCB->MMFAR);
    }
    if (cfsr & 0x8000) {
        print_reg("BFAR  ", SCB->BFAR);
    }
173
174
175
176
177
178
179
180
181
182
183
184
185

    if ((void*)&_ram_start <= (void*)regs && (void*)regs < (void*)&_ram_end) {
        mp_hal_stdout_tx_str("Stack:\r\n");
        uint32_t *stack_top = &_estack;
        if ((void*)regs < (void*)&_heap_end) {
            // stack not in static stack area so limit the amount we print
            stack_top = (uint32_t*)regs + 32;
        }
        for (uint32_t *sp = (uint32_t*)regs; sp < stack_top; ++sp) {
            print_hex_hex("  ", (uint32_t)sp, *sp);
        }
    }

186
187
188
189
190
    /* Go to infinite loop when Hard Fault exception occurs */
    while (1) {
        __fatal_error("HardFault");
    }
}
191

192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
// Naked functions have no compiler generated gunk, so are the best thing to
// use for asm functions.
__attribute__((naked))
void HardFault_Handler(void) {

    // From the ARMv7M Architecture Reference Manual, section B.1.5.6
    // on entry to the Exception, the LR register contains, amongst other
    // things, the value of CONTROL.SPSEL. This can be found in bit 3.
    //
    // If CONTROL.SPSEL is 0, then the exception was stacked up using the
    // main stack pointer (aka MSP). If CONTROL.SPSEL is 1, then the exception
    // was stacked up using the process stack pointer (aka PSP).

    __asm volatile(
    " tst lr, #4    \n"         // Test Bit 3 to see which stack pointer we should use.
    " ite eq        \n"         // Tell the assembler that the nest 2 instructions are if-then-else
    " mrseq r0, msp \n"         // Make R0 point to main stack pointer
    " mrsne r0, psp \n"         // Make R0 point to process stack pointer
    " b HardFault_C_Handler \n" // Off to C land
    );
}

/**
  * @brief   This function handles NMI exception.
  * @param  None
  * @retval None
  */
void NMI_Handler(void) {
}
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288

/**
  * @brief  This function handles Memory Manage exception.
  * @param  None
  * @retval None
  */
void MemManage_Handler(void) {
    /* Go to infinite loop when Memory Manage exception occurs */
    while (1) {
        __fatal_error("MemManage");
    }
}

/**
  * @brief  This function handles Bus Fault exception.
  * @param  None
  * @retval None
  */
void BusFault_Handler(void) {
    /* Go to infinite loop when Bus Fault exception occurs */
    while (1) {
        __fatal_error("BusFault");
    }
}

/**
  * @brief  This function handles Usage Fault exception.
  * @param  None
  * @retval None
  */
void UsageFault_Handler(void) {
    /* Go to infinite loop when Usage Fault exception occurs */
    while (1) {
        __fatal_error("UsageFault");
    }
}

/**
  * @brief  This function handles SVCall exception.
  * @param  None
  * @retval None
  */
void SVC_Handler(void) {
}

/**
  * @brief  This function handles Debug Monitor exception.
  * @param  None
  * @retval None
  */
void DebugMon_Handler(void) {
}

/**
  * @brief  This function handles PendSVC exception.
  * @param  None
  * @retval None
  */
void PendSV_Handler(void) {
    pendsv_isr_handler();
}

/**
  * @brief  This function handles SysTick Handler.
  * @param  None
  * @retval None
  */
void SysTick_Handler(void) {
289
290
291
    // Instead of calling HAL_IncTick we do the increment here of the counter.
    // This is purely for efficiency, since SysTick is called 1000 times per
    // second at the highest interrupt priority.
292
293
294
295
    // Note: we don't need uwTick to be declared volatile here because this is
    // the only place where it can be modified, and the code is more efficient
    // without the volatile specifier.
    extern uint32_t uwTick;
296
    uwTick += 1;
297
298

    // Read the systick control regster. This has the side effect of clearing
299
    // the COUNTFLAG bit, which makes the logic in mp_hal_ticks_us
300
301
    // work properly.
    SysTick->CTRL;
302

303
304
    // Right now we have the storage and DMA controllers to process during
    // this interrupt and we use custom dispatch handlers.  If this needs to
305
306
    // be generalised in the future then a dispatch table can be used as
    // follows: ((void(*)(void))(systick_dispatch[uwTick & 0xf]))();
307
308
309
310
311

    if (STORAGE_IDLE_TICK(uwTick)) {
        NVIC->STIR = FLASH_IRQn;
    }

312
    if (DMA_IDLE_ENABLED() && DMA_IDLE_TICK(uwTick)) {
313
        dma_idle_handler(uwTick);
314
    }
315

316
    #if MICROPY_PY_THREAD
317
318
319
320
321
322
323
324
    if (pyb_thread_enabled) {
        if (pyb_thread_cur->timeslice == 0) {
            if (pyb_thread_cur->run_next != pyb_thread_cur) {
                SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;
            }
        } else {
            --pyb_thread_cur->timeslice;
        }
325
    }
326
    #endif
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
}

/******************************************************************************/
/*                 STM32F4xx Peripherals Interrupt Handlers                   */
/*  Add here the Interrupt Handler for the used peripheral(s) (PPP), for the  */
/*  available peripheral interrupt handler's name please refer to the startup */
/*  file (startup_stm32f4xx.s).                                               */
/******************************************************************************/

/**
  * @brief  This function handles USB-On-The-Go FS global interrupt request.
  * @param  None
  * @retval None
  */
#if defined(USE_USB_FS)
342
void OTG_FS_IRQHandler(void) {
343
    IRQ_ENTER(OTG_FS_IRQn);
344
    HAL_PCD_IRQHandler(&pcd_fs_handle);
345
    IRQ_EXIT(OTG_FS_IRQn);
346
}
347
#endif
348
349
#if defined(USE_USB_HS)
void OTG_HS_IRQHandler(void) {
350
    IRQ_ENTER(OTG_HS_IRQn);
351
    HAL_PCD_IRQHandler(&pcd_hs_handle);
352
    IRQ_EXIT(OTG_HS_IRQn);
353
354
355
}
#endif

356
#if defined(USE_USB_FS) || defined(USE_USB_HS)
357
/**
358
359
  * @brief  This function handles USB OTG Common FS/HS Wakeup functions.
  * @param  *pcd_handle for FS or HS
360
361
  * @retval None
  */
362
STATIC void OTG_CMD_WKUP_Handler(PCD_HandleTypeDef *pcd_handle) {
363

364
  if (pcd_handle->Init.low_power_enable) {
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
    /* Reset SLEEPDEEP bit of Cortex System Control Register */
    SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));

    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select
    PLL as system clock source (HSE and PLL are disabled in STOP mode) */

    __HAL_RCC_HSE_CONFIG(RCC_HSE_ON);

    /* Wait till HSE is ready */
    while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) == RESET)
    {}

    /* Enable the main PLL. */
    __HAL_RCC_PLL_ENABLE();

    /* Wait till PLL is ready */
    while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) == RESET)
    {}

    /* Select PLL as SYSCLK */
    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_SYSCLKSOURCE_PLLCLK);

    while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL)
    {}

    /* ungate PHY clock */
391
     __HAL_PCD_UNGATE_PHYCLOCK(pcd_handle);
392
  }
393
394
395
396
397
398
399
400
401
402
403

}
#endif

#if defined(USE_USB_FS)
/**
  * @brief  This function handles USB OTG FS Wakeup IRQ Handler.
  * @param  None
  * @retval None
  */
void OTG_FS_WKUP_IRQHandler(void) {
404
    IRQ_ENTER(OTG_FS_WKUP_IRQn);
405
406
407

  OTG_CMD_WKUP_Handler(&pcd_fs_handle);

408
409
  /* Clear EXTI pending Bit*/
  __HAL_USB_FS_EXTI_CLEAR_FLAG();
410

411
    IRQ_EXIT(OTG_FS_WKUP_IRQn);
412
}
413
414
#endif

415
416
417
418
419
420
421
#if defined(USE_USB_HS)
/**
  * @brief  This function handles USB OTG HS Wakeup IRQ Handler.
  * @param  None
  * @retval None
  */
void OTG_HS_WKUP_IRQHandler(void) {
422
    IRQ_ENTER(OTG_HS_WKUP_IRQn);
423
424
425
426
427
428

  OTG_CMD_WKUP_Handler(&pcd_hs_handle);

  /* Clear EXTI pending Bit*/
  __HAL_USB_HS_EXTI_CLEAR_FLAG();

429
    IRQ_EXIT(OTG_HS_WKUP_IRQn);
430
431
432
433
434
435
436
437
438
439
440
441
442
443
}
#endif

/**
  * @brief  This function handles PPP interrupt request.
  * @param  None
  * @retval None
  */
/*void PPP_IRQHandler(void)
{
}*/

// Handle a flash (erase/program) interrupt.
void FLASH_IRQHandler(void) {
444
    IRQ_ENTER(FLASH_IRQn);
445
446
447
448
449
450
451
452
453
    // This calls the real flash IRQ handler, if needed
    /*
    uint32_t flash_cr = FLASH->CR;
    if ((flash_cr & FLASH_IT_EOP) || (flash_cr & FLASH_IT_ERR)) {
        HAL_FLASH_IRQHandler();
    }
    */
    // This call the storage IRQ handler, to check if the flash cache needs flushing
    storage_irq_handler();
454
    IRQ_EXIT(FLASH_IRQn);
455
456
457
458
459
460
461
462
}

/**
  * @brief  These functions handle the EXTI interrupt requests.
  * @param  None
  * @retval None
  */
void EXTI0_IRQHandler(void) {
463
    IRQ_ENTER(EXTI0_IRQn);
464
    Handle_EXTI_Irq(0);
465
    IRQ_EXIT(EXTI0_IRQn);
466
467
468
}

void EXTI1_IRQHandler(void) {
469
    IRQ_ENTER(EXTI1_IRQn);
470
    Handle_EXTI_Irq(1);
471
    IRQ_EXIT(EXTI1_IRQn);
472
473
474
}

void EXTI2_IRQHandler(void) {
475
    IRQ_ENTER(EXTI2_IRQn);
476
    Handle_EXTI_Irq(2);
477
    IRQ_EXIT(EXTI2_IRQn);
478
479
480
}

void EXTI3_IRQHandler(void) {
481
    IRQ_ENTER(EXTI3_IRQn);
482
    Handle_EXTI_Irq(3);
483
    IRQ_EXIT(EXTI3_IRQn);
484
485
486
}

void EXTI4_IRQHandler(void) {
487
    IRQ_ENTER(EXTI4_IRQn);
488
    Handle_EXTI_Irq(4);
489
    IRQ_EXIT(EXTI4_IRQn);
490
491
492
}

void EXTI9_5_IRQHandler(void) {
493
    IRQ_ENTER(EXTI9_5_IRQn);
494
495
496
497
498
    Handle_EXTI_Irq(5);
    Handle_EXTI_Irq(6);
    Handle_EXTI_Irq(7);
    Handle_EXTI_Irq(8);
    Handle_EXTI_Irq(9);
499
    IRQ_EXIT(EXTI9_5_IRQn);
500
501
502
}

void EXTI15_10_IRQHandler(void) {
503
    IRQ_ENTER(EXTI15_10_IRQn);
504
505
506
507
508
509
    Handle_EXTI_Irq(10);
    Handle_EXTI_Irq(11);
    Handle_EXTI_Irq(12);
    Handle_EXTI_Irq(13);
    Handle_EXTI_Irq(14);
    Handle_EXTI_Irq(15);
510
    IRQ_EXIT(EXTI15_10_IRQn);
511
512
513
}

void PVD_IRQHandler(void) {
514
    IRQ_ENTER(PVD_IRQn);
515
    Handle_EXTI_Irq(EXTI_PVD_OUTPUT);
516
    IRQ_EXIT(PVD_IRQn);
517
518
}

519
520
521
522
523
524
525
526
#if defined(MCU_SERIES_L4)
void PVD_PVM_IRQHandler(void) {
    IRQ_ENTER(PVD_PVM_IRQn);
    Handle_EXTI_Irq(EXTI_PVD_OUTPUT);
    IRQ_EXIT(PVD_PVM_IRQn);
}
#endif

527
void RTC_Alarm_IRQHandler(void) {
528
    IRQ_ENTER(RTC_Alarm_IRQn);
529
    Handle_EXTI_Irq(EXTI_RTC_ALARM);
530
    IRQ_EXIT(RTC_Alarm_IRQn);
531
532
533
534
}

#if defined(ETH)    // The 407 has ETH, the 405 doesn't
void ETH_WKUP_IRQHandler(void)  {
535
    IRQ_ENTER(ETH_WKUP_IRQn);
536
    Handle_EXTI_Irq(EXTI_ETH_WAKEUP);
537
    IRQ_EXIT(ETH_WKUP_IRQn);
538
539
540
541
}
#endif

void TAMP_STAMP_IRQHandler(void) {
542
    IRQ_ENTER(TAMP_STAMP_IRQn);
543
    Handle_EXTI_Irq(EXTI_RTC_TIMESTAMP);
544
    IRQ_EXIT(TAMP_STAMP_IRQn);
545
546
547
}

void RTC_WKUP_IRQHandler(void) {
548
    IRQ_ENTER(RTC_WKUP_IRQn);
549
550
    RTC->ISR &= ~(1 << 10); // clear wakeup interrupt flag
    Handle_EXTI_Irq(EXTI_RTC_WAKEUP); // clear EXTI flag and execute optional callback
551
    IRQ_EXIT(RTC_WKUP_IRQn);
552
553
554
}

void TIM1_BRK_TIM9_IRQHandler(void) {
555
    IRQ_ENTER(TIM1_BRK_TIM9_IRQn);
556
    timer_irq_handler(9);
557
    IRQ_EXIT(TIM1_BRK_TIM9_IRQn);
558
559
}

560
561
562
563
564
565
566
567
#if defined(MCU_SERIES_L4)
void TIM1_BRK_TIM15_IRQHandler(void) {
    IRQ_ENTER(TIM1_BRK_TIM15_IRQn);
    timer_irq_handler(15);
    IRQ_EXIT(TIM1_BRK_TIM15_IRQn);
}
#endif

568
void TIM1_UP_TIM10_IRQHandler(void) {
569
    IRQ_ENTER(TIM1_UP_TIM10_IRQn);
570
571
    timer_irq_handler(1);
    timer_irq_handler(10);
572
    IRQ_EXIT(TIM1_UP_TIM10_IRQn);
573
574
}

575
576
577
578
579
580
581
582
583
#if defined(MCU_SERIES_L4)
void TIM1_UP_TIM16_IRQHandler(void) {
    IRQ_ENTER(TIM1_UP_TIM16_IRQn);
    timer_irq_handler(1);
    timer_irq_handler(16);
    IRQ_EXIT(TIM1_UP_TIM16_IRQn);
}
#endif

584
void TIM1_TRG_COM_TIM11_IRQHandler(void) {
585
    IRQ_ENTER(TIM1_TRG_COM_TIM11_IRQn);
586
    timer_irq_handler(11);
587
    IRQ_EXIT(TIM1_TRG_COM_TIM11_IRQn);
588
589
}

590
591
592
593
594
595
596
597
#if defined(MCU_SERIES_L4)
void TIM1_TRG_COM_TIM17_IRQHandler(void) {
    IRQ_ENTER(TIM1_TRG_COM_TIM17_IRQn);
    timer_irq_handler(17);
    IRQ_EXIT(TIM1_TRG_COM_TIM17_IRQn);
}
#endif

598
599
600
601
602
603
void TIM1_CC_IRQHandler(void) {
    IRQ_ENTER(TIM1_CC_IRQn);
    timer_irq_handler(1);
    IRQ_EXIT(TIM1_CC_IRQn);
}

604
void TIM2_IRQHandler(void) {
605
    IRQ_ENTER(TIM2_IRQn);
606
    timer_irq_handler(2);
607
    IRQ_EXIT(TIM2_IRQn);
608
609
610
}

void TIM3_IRQHandler(void) {
611
    IRQ_ENTER(TIM3_IRQn);
612
    timer_irq_handler(3);
613
    IRQ_EXIT(TIM3_IRQn);
614
615
616
}

void TIM4_IRQHandler(void) {
617
    IRQ_ENTER(TIM4_IRQn);
618
    timer_irq_handler(4);
619
    IRQ_EXIT(TIM4_IRQn);
620
621
622
}

void TIM5_IRQHandler(void) {
623
    IRQ_ENTER(TIM5_IRQn);
624
625
    timer_irq_handler(5);
    HAL_TIM_IRQHandler(&TIM5_Handle);
626
    IRQ_EXIT(TIM5_IRQn);
627
628
}

629
#if defined(TIM6) // STM32F401 doesn't have TIM6
630
void TIM6_DAC_IRQHandler(void) {
631
    IRQ_ENTER(TIM6_DAC_IRQn);
632
    timer_irq_handler(6);
633
    IRQ_EXIT(TIM6_DAC_IRQn);
634
}
635
#endif
636

637
#if defined(TIM7) // STM32F401 doesn't have TIM7
638
void TIM7_IRQHandler(void) {
639
    IRQ_ENTER(TIM7_IRQn);
640
    timer_irq_handler(7);
641
    IRQ_EXIT(TIM7_IRQn);
642
}
643
#endif
644

645
#if defined(TIM8) // STM32F401 doesn't have TIM8
646
void TIM8_BRK_TIM12_IRQHandler(void) {
647
    IRQ_ENTER(TIM8_BRK_TIM12_IRQn);
648
    timer_irq_handler(12);
649
    IRQ_EXIT(TIM8_BRK_TIM12_IRQn);
650
651
652
}

void TIM8_UP_TIM13_IRQHandler(void) {
653
    IRQ_ENTER(TIM8_UP_TIM13_IRQn);
654
655
    timer_irq_handler(8);
    timer_irq_handler(13);
656
    IRQ_EXIT(TIM8_UP_TIM13_IRQn);
657
658
}

659
660
661
662
663
664
665
666
#if defined(MCU_SERIES_L4)
void TIM8_UP_IRQHandler(void) {
    IRQ_ENTER(TIM8_UP_IRQn);
    timer_irq_handler(8);
    IRQ_EXIT(TIM8_UP_IRQn);
}
#endif

667
668
669
670
671
672
void TIM8_CC_IRQHandler(void) {
    IRQ_ENTER(TIM8_CC_IRQn);
    timer_irq_handler(8);
    IRQ_EXIT(TIM8_CC_IRQn);
}

673
void TIM8_TRG_COM_TIM14_IRQHandler(void) {
674
    IRQ_ENTER(TIM8_TRG_COM_TIM14_IRQn);
675
    timer_irq_handler(14);
676
    IRQ_EXIT(TIM8_TRG_COM_TIM14_IRQn);
677
}
678
#endif
679
680
681

// UART/USART IRQ handlers
void USART1_IRQHandler(void) {
682
    IRQ_ENTER(USART1_IRQn);
683
    uart_irq_handler(1);
684
    IRQ_EXIT(USART1_IRQn);
685
686
687
}

void USART2_IRQHandler(void) {
688
    IRQ_ENTER(USART2_IRQn);
689
    uart_irq_handler(2);
690
    IRQ_EXIT(USART2_IRQn);
691
692
693
}

void USART3_IRQHandler(void) {
694
    IRQ_ENTER(USART3_IRQn);
695
    uart_irq_handler(3);
696
    IRQ_EXIT(USART3_IRQn);
697
698
699
}

void UART4_IRQHandler(void) {
700
    IRQ_ENTER(UART4_IRQn);
701
    uart_irq_handler(4);
702
    IRQ_EXIT(UART4_IRQn);
703
704
}

Dave Hylands's avatar
Dave Hylands committed
705
void UART5_IRQHandler(void) {
706
    IRQ_ENTER(UART5_IRQn);
Dave Hylands's avatar
Dave Hylands committed
707
    uart_irq_handler(5);
708
    IRQ_EXIT(UART5_IRQn);
Dave Hylands's avatar
Dave Hylands committed
709
710
}

711
void USART6_IRQHandler(void) {
712
    IRQ_ENTER(USART6_IRQn);
713
    uart_irq_handler(6);
714
    IRQ_EXIT(USART6_IRQn);
715
}
716

717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
#if defined(MICROPY_HW_UART7_TX)
void UART7_IRQHandler(void) {
    IRQ_ENTER(UART7_IRQn);
    uart_irq_handler(7);
    IRQ_EXIT(UART7_IRQn);
}
#endif

#if defined(MICROPY_HW_UART8_TX)
void UART8_IRQHandler(void) {
    IRQ_ENTER(UART8_IRQn);
    uart_irq_handler(8);
    IRQ_EXIT(UART8_IRQn);
}
#endif

733
734
#if MICROPY_HW_ENABLE_CAN
void CAN1_RX0_IRQHandler(void) {
735
    IRQ_ENTER(CAN1_RX0_IRQn);
736
    can_rx_irq_handler(PYB_CAN_1, CAN_FIFO0);
737
    IRQ_EXIT(CAN1_RX0_IRQn);
738
739
740
}

void CAN1_RX1_IRQHandler(void) {
741
    IRQ_ENTER(CAN1_RX1_IRQn);
742
    can_rx_irq_handler(PYB_CAN_1, CAN_FIFO1);
743
    IRQ_EXIT(CAN1_RX1_IRQn);
744
745
746
}

void CAN2_RX0_IRQHandler(void) {
747
    IRQ_ENTER(CAN2_RX0_IRQn);
748
    can_rx_irq_handler(PYB_CAN_2, CAN_FIFO0);
749
    IRQ_EXIT(CAN2_RX0_IRQn);
750
751
752
}

void CAN2_RX1_IRQHandler(void) {
753
    IRQ_ENTER(CAN2_RX1_IRQn);
754
    can_rx_irq_handler(PYB_CAN_2, CAN_FIFO1);
755
    IRQ_EXIT(CAN2_RX1_IRQn);
756
757
}
#endif // MICROPY_HW_ENABLE_CAN
758
759
760
761

#if defined(MICROPY_HW_I2C1_SCL)
void I2C1_EV_IRQHandler(void) {
    IRQ_ENTER(I2C1_EV_IRQn);
762
    i2c_ev_irq_handler(1);
763
764
765
766
767
    IRQ_EXIT(I2C1_EV_IRQn);
}

void I2C1_ER_IRQHandler(void) {
    IRQ_ENTER(I2C1_ER_IRQn);
768
    i2c_er_irq_handler(1);
769
770
771
772
773
774
775
    IRQ_EXIT(I2C1_ER_IRQn);
}
#endif // defined(MICROPY_HW_I2C1_SCL)

#if defined(MICROPY_HW_I2C2_SCL)
void I2C2_EV_IRQHandler(void) {
    IRQ_ENTER(I2C2_EV_IRQn);
776
    i2c_ev_irq_handler(2);
777
778
779
780
781
    IRQ_EXIT(I2C2_EV_IRQn);
}

void I2C2_ER_IRQHandler(void) {
    IRQ_ENTER(I2C2_ER_IRQn);
782
    i2c_er_irq_handler(2);
783
784
785
786
787
788
789
    IRQ_EXIT(I2C2_ER_IRQn);
}
#endif // defined(MICROPY_HW_I2C2_SCL)

#if defined(MICROPY_HW_I2C3_SCL)
void I2C3_EV_IRQHandler(void) {
    IRQ_ENTER(I2C3_EV_IRQn);
790
    i2c_ev_irq_handler(3);
791
792
793
794
795
    IRQ_EXIT(I2C3_EV_IRQn);
}

void I2C3_ER_IRQHandler(void) {
    IRQ_ENTER(I2C3_ER_IRQn);
796
    i2c_er_irq_handler(3);
797
798
799
    IRQ_EXIT(I2C3_ER_IRQn);
}
#endif // defined(MICROPY_HW_I2C3_SCL)