Estás aquí: start » arm_interrupt_controllers

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Próxima revisión 		Revisión previa
arm_interrupt_controllers [2023/05/16 00:23]
cnigri Version inicial 		arm_interrupt_controllers [2024/06/03 20:16] (actual)
cnigri Fix Incorporacion de registro de control de la interfaz con el CPU
Línea 4: Línea 4:
 Antes de comenzar vale la pena recordar dos conceptos elementales: Antes de comenzar vale la pena recordar dos conceptos elementales:
   * Un controlador de interrupción es un módulo (IC, ASIC, FPGA, etc) que se encuentran entre las fuentes de interrupción (periféricos) y **los núcleos** ARM,  el cual decide cómo gestionar (priorizar, habilitar, direccionar) las interrupciones.   * Un controlador de interrupción es un módulo (IC, ASIC, FPGA, etc) que se encuentran entre las fuentes de interrupción (periféricos) y **los núcleos** ARM,  el cual decide cómo gestionar (priorizar, habilitar, direccionar) las interrupciones.
-  * El núcleo ARM acepta solo dos señales de entrada no programadas que manejan interrupciones de los sistemas externos: nIRQ y nFIQ. Como se debería saber si se recibe IRQ, el sistema ingresa al modo IRQ o FIQ, si se recibe una FIQ.+  * El núcleo ARM acepta solo **dos señales** de entrada no programadas que manejan interrupciones de los sistemas externos: **nIRQ** y nFIQ. Como se debería saber el sistema ingresa al modo IRQ si se recibe nIRQ (activación por nivel bajo 0), o en modo FIQ si se recibe nFIQ (activación por nivel bajo 0).
  
 Si bien dependiendo de las licencias ARM, es decir del fabricante de SoC, se decide el mecanismo para direccionar las señales de interrupción al núcleo, en este artículo se tratará el método estandarizado y más frecuentemente empleado, el [[https://developer.arm.com/documentation/198123/0302/What-is-a-Generic-Interrupt-Controller- | Global Interrupt Controller]]. Es importante aclarar que no se pretende brindar una explicación detallada del **//GIC//**, ya que para ello se encuentra disponible la [[https://developer.arm.com/documentation/ihi0069/h/?lang=en | especificación]] correspondiente, sino su aplicación para el caso de uso de la Cátedra. Si bien dependiendo de las licencias ARM, es decir del fabricante de SoC, se decide el mecanismo para direccionar las señales de interrupción al núcleo, en este artículo se tratará el método estandarizado y más frecuentemente empleado, el [[https://developer.arm.com/documentation/198123/0302/What-is-a-Generic-Interrupt-Controller- | Global Interrupt Controller]]. Es importante aclarar que no se pretende brindar una explicación detallada del **//GIC//**, ya que para ello se encuentra disponible la [[https://developer.arm.com/documentation/ihi0069/h/?lang=en | especificación]] correspondiente, sino su aplicación para el caso de uso de la Cátedra.
Línea 13: Línea 13:
 {{ :arm_gic_partitioning.png?800 |GIC logical partitioning}}  {{ :arm_gic_partitioning.png?800 |GIC logical partitioning}} 
  
-Si bien el diagrama presenta la arquitectura para múltiples núcleos (processors), en nuestro caso de uso (cortex A8) solo basta con reducir el esquema a un solo procesador. +Si bien el diagrama presenta la arquitectura para múltiples núcleos (processors), en nuestro caso de uso (inicialización mono procesador) solo basta con reducir el esquema a un solo procesador. 
  
 Según la fuente, hay tres tipos principales de interrupciones definidas. Según la fuente, hay tres tipos principales de interrupciones definidas.
Línea 49: Línea 49:
  
 ===== Interfaz de programación ===== ===== Interfaz de programación =====
 +[[https://developer.arm.com/documentation/ihi0048/a/Programmers-Model/About-the-programmers-model | El modelo de programación]] así como [[https://developer.arm.com/documentation/ihi0048/a/Programmers-Model/About-the-programmers-model/Distributor-register-map?lang=en | los registros del Distributor]] y la [[https://developer.arm.com/documentation/ihi0048/a/Programmers-Model/About-the-programmers-model/CPU-interface-register-map | CPU Interface ]] se encuentra ampliamente descriptos en [[https://developer.arm.com/documentation/ihi0069/h/?lang=en | la especificación de referencia]], por lo cual en este apartado se centrará en los pasos mínimos de configuración necesarios para des/habilitar una SPI.
  
 +A fin de brindar una referencia genérica agnóstica de la implementación SoC específica, se debe tener presente que el GIC es parte del denominado [[https://developer.arm.com/documentation/ddi0344/k/glossary | Advanced Peripheral Bus]] y por ende la dirección base a partir de la cual es posible acceder a los registros asociados al //Distributor// y la //CPU Interface// es la denominada //Peripheral Base//, or lo que es posible especificar
 +
 +    GIC Distributor base address DISTBASE = PERIPHBASE + 0x1000
 +    CPU Interface   base address CPUBASE = PERIPHBASE + 0x0000.
 +
 +El valor especifico de la dirección base se brinda en la documentación especifica de cada fabricante ([[https://developer.arm.com/documentation/dui0417/d/programmer-s-reference/generic-interrupt-controller--gic/generic-interrupt-controller-registers|PB-A8]], [[https://docs.amd.com/r/en-US/ug585-zynq-7000-SoC-TRM/CPU-Private-Bus-Registers|Zynq-7000]])
 +<code java>
 +#include <stddef.h>
 +/*GIC Register Definitions*/
 +#if defined(__PB_A8__)
 +#define GIC0_CPU_BASE           0x1E000000
 +#define GIC0_DISTRIBUTOR_BASE   0x1E001000
 +#elif defined(i386)
 +#define GIC0_CPU_BASE           0xF8F00100
 +#define GIC0_DISTRIBUTOR_BASE   0xF8F01000
 +#endif
 +
 +#define ICCICR      *((uint32_t *) GIC0_CPU_BASE + 0x00)         //CPU Interface Control Register
 +#define ICCPMR      *((uint32_t *) GIC0_CPU_BASE + 0x04)         //Interrupt Priority Mask Register
 +#define ICCBPR      *((uint32_t *) GIC0_CPU_BASE + 0x08)         //Binary Point Register
 +#define ICCIAR      *((uint32_t *) GIC0_CPU_BASE + 0x0C)         //Interrupt Acknowledge
 +#define ICCEOIR     *((uint32_t *) GIC0_CPU_BASE + 0x10)         //End of Interrupt Register
 +#define ICDDCR      *((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0x000)       //Distributor Control Register
 +#define ICDICTR     *((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0x004)       //Interrupt Controller Type Register
 +#define ICDISER(n)  *(((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0x100) + n) //Interrupt n Set-Enable Registers
 +#define ICDICER(n)  *(((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0x180) + n) //Interrupt Clear-Enable Registers
 +#define ICDIPR(n)   *(((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0x400) + n) //Interrupt Priority Registers
 +#define ICDIPTR(n)  *(((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0x800) + n) //Interrupt Processor Targets Registers
 +#define ICDICFR(n)  *(((uint32_t *) GIC0_DISTRIBUTOR_BASE + 0xC00) + n) //Interrupt Configuration Registers
 +</code>
 +
 +Teniendo presente las direcciones de acceso, se puede establecer una secuencia de inicialización básica compuesta de los siguientes pasos
 +  * Deshabilitar el //Distributor// y la //CPU Interface//
 +<code c>
 +void gic_init(void){
 +   ICDDCR = 0);
 +</code>
 +  * Configurar el número máximo de interrupciones que serán gestionadas por el GIC mediante el ICDICTR. Siendo el número máximo de interrupciones 32(N+1) donde N es el valor a cargar en el registro.
 +<code c>
 +   ICDICTR = 0x3;
 +</code>
 +  * Habilitar el número de interrupción asociada al periférico que se desee atender. ICDISER representa la dirección base y su rango máximo es 0x7C (127) por lo que si se quiere habilitar la IRQ36 se debe establecer en 1 el bit 4 del ICDISER(1), ya que este registro opera como ICDISERn = 0x100 + (4*M), donde M = N/32 (division entera).
 +<code c>
 +   ICDISER(1) = 0x4;
 +</code>
 +  * Configurar el procesador al cual la interrupción debe ser direccionada. El conjunto de registros ICDIPTRn debe establecer la parte baja de cada byte en 0x1 para sistemas de un único núcleo
 +<code c>
 +   for i=0; i++; i<24
 +       {ICDIPTR(i) = 0x1111;}
 +</code>
 +{{ :td3:under_construction.jpg?100 |}}
 +  * Configurar si la detección de la interrupción es por nivel o flanco. Solo es aplicable a PPI
 +{{ :td3:under_construction.jpg?100 |}}
 +  * Configurar la prioridad.
 +{{ :td3:under_construction.jpg?100 |}}
 +  * Habilitar el //Distributor// y la //CPU Interface//
 +<code c>
 +   ICDDCR = 1);
 +   }
 +</code>
 +
 +
 +===== Gestión de las interrupciones en el Core =====
 +En los párrafos precedentes se brindó una referencia básica sobre la operación y configuración del //GIC//, es decir sobre el sistema de gestión de interrupciones externo al/los núcleos, a continuación el artículo se centrará sobre la contra-parte situada en el propio núcleo.
 +En esta instancia es bien sabido que cada [[https://developer.arm.com/documentation/den0013/d/ARM-Processor-Modes-and-Registers/Registers | modo de operación]] debe contar con su propia pila, a fin de preservar el contexto de ejecución, lo cual debe realizarse en la etapa [[https://sge.frba.utn.edu.ar/wiki/td3/lib/exe/detail.php?id=inicializacion_de_procesador_cortex-a8&media=initialization_soc.png | stack_configure]] de la secuencia de inicialización del procesador
 +
 +<code asm>
 +stack_setup_irq:
 +    cps #0xd2           @Change Processor Status a IRQ
    
 +    ldr r0, #CONFIG_PILA_LIMITE_DIRECCION
 +    sub sp, r0, #(CONFIG_PILA_IRQ_LARGO + CONFIG_PILA_FIQ_LARGO)
 +
 +    cpsie if, #0x13     @Change Processor Status a SVC con IRQ habilitada
 +
 +    mov pc, lr          @retorna
 +</code>
 +
 +Una vez que el //GIC// a señalizado al núcleo respecto a una interrupción pendiente, este debe realizar una [[https://developer.arm.com/documentation/den0013/d/Interrupt-Handling/External-interrupt-requests/Simplistic-interrupt-handling | secuencia de pasos mínima (descripta en el manual)]] para gestionar la interrupción, la cual se ejemplifica mediante el siguiente código
 +
 +<code asm>
 +irq_handler:
 +    sub lr, lr, #4                      @retornar a la instruccion en ejecucion al momento de la interrupcion
 +    stmfd sp!, {r0-r12, lr}             @resguarda contexto en pila de IRQ
 +
 +    mrs r11, spsr                       @reguarda Saved Processor Status Register
 +    push {r11}
 +
 +    @bl handler_dispatch                @Gestor generico para identificar y derivar al controlador especifico
 +    bl timer0_handler                   @Nuestro caso de uso (simple) solo presenta una IRQ
 +
 +    @bl data_synchronization_barrier    @requerido en SoC multi core (dsb, dmb segun systema)
 +
 +    pop {r11}
 +    msr spsr, r11                       @reguarda Saved Processor Status Register
 +
 +    ldmfd sp!, {r0-r12, pc}^            @restaura contexto y retorna
 +</code>
 +
 ===== Caso de uso PB-A8 ===== ===== Caso de uso PB-A8 =====
 A los fines de la placa empleada, para la resolución de la guía de trabajos prácticos del primer cuatrimestre, el [[https://developer.arm.com/documentation/dui0417/d/programmer-s-reference/generic-interrupt-controller--gic?lang=en | GIC a configurar para el uso de IRQ es el 0]] el cual tiene asociado el [[https://developer.arm.com/documentation/dui0417/d/programmer-s-reference/generic-interrupt-controller--gic/interrupt-signals?lang=en | ID#36 para el Timer0]] A los fines de la placa empleada, para la resolución de la guía de trabajos prácticos del primer cuatrimestre, el [[https://developer.arm.com/documentation/dui0417/d/programmer-s-reference/generic-interrupt-controller--gic?lang=en | GIC a configurar para el uso de IRQ es el 0]] el cual tiene asociado el [[https://developer.arm.com/documentation/dui0417/d/programmer-s-reference/generic-interrupt-controller--gic/interrupt-signals?lang=en | ID#36 para el Timer0]]
  
- --- //[[cnigri@frba.utn.edu.ar|ChristiaN]] 2023/05/16 00:17//+En forma complementaría al código, en C, presentado anteriormente para la configuración del GIC, a continuación se brinda a modo de referencia básica el equivalente en ensamblador 
 +<code asm> 
 +.global GIC_CFG 
 + 
 +GIC_CFG: 
 +    push {r0-r1, lr} 
 + 
 +    mov r0, #0 
 +    ldr r1, =0x1E001000             @ICDDCR 
 +    str r0, [r1]                    @Deshabilita CPU Interface y Distributor 
 + 
 +    mov r0, #36                     @IRQ ID 36 para Timer0 
 +    mov r1, #1                      @Sistema mono procesador 
 +    bl _IRQ_CFG                     @Llamada a rutina con argumentos r0, r1 
 + 
 +    ldr r1, =0x1E000004             @Interrupt Priority Mask Register (ICCPMR) 
 +    ldr r0, [r1]                    @Carga el valor actual 
 +    orr r0, r0, #0xF 
 +    bic r0, r0, #1                  @BIt Clear -> r0 = r0 and 0xFFFF FFFE 
 +    str r0, [r1]                    @Habilita todas las prioridades 
 + 
 +    mov r0, #1 
 +    ldr r1, =0x1E000000             @ICCICR 
 +    str r0, [r1]                    @Habilita señalizar las interrupciones 
 + 
 +    mov r0, #1 
 +    ldr r1, =0x1E001000             @ICDDCR 
 +    str r0, [r1]                    @Habilita CPU Interface y Distributor 
 + 
 +    pop {r0-r1, pc} 
 + 
 +@ r0 = Interrupt ID, N 
 +@ r1 = target CPU 
 +@ Asume que los valores por defecto de los registros no configurados 
 +@ son correctos 
 +_IRQ_CFG: 
 +    push {r2-r5, lr} 
 +    mov r3, #1                      @32(N+1) maximo, solo necesito hastala 36 
 +    ldr r2, =0x1E001004             @ICDICTR 
 +    ldr [r2], r3 
 + 
 +    /*Interrupt Set-Enable Registers (ICDISERn) 
 +     * reg_offset = (integer_div(N / 32) * 4 
 +     * value = 1 << (N mod 32) */   
 +    lsr r4, r0, #3                  @ Logical Shift Right = INT(N/(2³)) = reg_offset 
 +    bic r4, r4, #3                  @ BIt Clear -> r4 and 0b1111 1100 
 +    ldr r2, =0x1E000100             @ ICDISER registro 0 
 +    add r4, r2, r4                  @ r4=ICDISER sobre el que se debe operar 
 + 
 +    and r2, r0, #0x1F               @N mod 32 
 +    mov r3, #1 
 +    lsl r2, r3, r2                  @Logical Shift Left = 1 << (N mod 32) = r2 
 + 
 +    ldr r5, [r4]                    @Carga actual valor de ICDISERn 
 +    orr r5, r5, r2                  @Modifica segun r2 
 +    str r5, [r4]                    @Carga nuevo valor a ICDISERn 
 + 
 +    /* Interrupt Processor Targets Register (ICDIPTRn) 
 +     * reg_offset = integer_div(N / 4) * 4 
 +     * index = N mod 4 */ 
 +    bic r4, r0, #3                  @ r4=r0 and 0b1111 1100=reg_offset 
 +    ldr r2, =0x1E000800             @ ICDIPTR registro 0 
 +    add r4, r2, r4                  @ r4= ICDIPTR sobre el que se debe operar 
 +    and r2, r0, #0x3                @N mod 4 
 +    add r4, r2, r4                  @Byte asociado al CPU en ICDIPTR 
 + 
 +    strb r1, [R4]                   @Solo modifica el byte asociado al CPU 
 + 
 +    pop {r2-r5, pc}                 @alternativa a mov pc, lr 
 +</code> 
 +===== Caso de uso Beagle Bone Black===== 
 +{{ :td3:nueva_seccion.jpg?400 |}} 
 + 
 + --- //[[cnigri@frba.utn.edu.ar|ChristiaN]] 2023/06/22 20:29// 
  

Traza: