리눅스 커널에 인터럽트 기능이 있나요?

Linux 커널에는 인터럽트 기능이 있습니다. 리눅스 커널에서는 인터럽트를 사용하려면 이를 적용해야 하며, 인터럽트를 적용하려면 request_irq() 함수를 사용해야 하며, 인터럽트를 사용한 후에는 free_irq()를 통해 해당 인터럽트를 해제해야 합니다. ) 함수; 또한 활성화_irq() 및 비활성화_irq()가 있으며 지정된 인터럽트를 활성화 및 비활성화하는 데 사용됩니다.

이 튜토리얼의 운영 환경: linux7.3 시스템, Dell G3 컴퓨터.

1.Linux 인터럽트

1.1 리눅스 인터럽트 API 기능

request_irq 함수

리눅스 커널에서는 인터럽트를 사용하려면 request_irq 함수를 사용하게 됩니다. request_irq 함수는 절전 모드를 유발할 수 있으므로 절전 모드를 금지하는 인터럽트 컨텍스트나 기타 코드 섹션에서는 request_irq 함수를 사용할 수 없습니다. request_irq 함수는 인터럽트를 활성화(활성화)하므로 인터럽트를 수동으로 활성화할 필요가 없습니다. request_irq 함수의 프로토타입은 다음과 같습니다.

irq: 인터럽트를 적용할 인터럽트 번호입니다.
handler: 인터럽트 처리 기능, 이 인터럽트 처리 기능은 인터럽트가 발생할 때 실행됩니다.
flags: 인터럽트 플래그, include/linux/interrupt.h 파일에서 모든 인터럽트 플래그를 볼 수 있습니다.

name: 인터럽트 이름, 설정 후 /proc/interrupts에서 해당 인터럽트 이름을 볼 수 있습니다. 파일 .
dev: 플래그가 IRQF_SHARED로 설정된 경우 dev는 서로 다른 인터럽트를 구별하는 데 사용됩니다. 일반적으로 dev는 장치 구조로 설정되며 dev는 인터럽트 처리 함수 irq_handler_t의 두 번째 매개변수로 전달됩니다.
반환 값: 0은 인터럽트 적용이 성공했음을 의미하고, 다른 음수 값은 인터럽트 적용이 실패했음을 의미합니다. -EBUSY가 반환되면 인터럽트가 적용되었음을 의미합니다.

free_irq

인터럽트를 사용할 때에는 request_irq 함수를 통해 신청해야 하며, 사용이 완료된 후에는 free_irq 함수를 통해 해당 인터럽트를 해제해야 합니다. 인터럽트가 공유되지 않으면 free_irq는 인터럽트 핸들러를 제거하고 인터럽트를 비활성화합니다. free_irq 함수 프로토타입은 다음과 같습니다.

함수 매개변수와 반환 값의 의미는 다음과 같습니다.
irq: 해제할 인터럽트입니다.
dev: 인터럽트가 공유(IRQF_SHARED)로 설정된 경우 이 매개변수는 특정 인터럽트를 구별하는 데 사용됩니다. 공유 인터럽트는 마지막 인터럽트 핸들러가 해제될 때만 비활성화됩니다.
반환 값: 없음.

인터럽트 처리 기능

request_irq 함수를 사용하여 인터럽트를 적용할 경우 인터럽트 처리 기능을 설정해야 합니다. 인터럽트 처리 기능의 형식은 다음과 같습니다.

인터럽트 활성화 및 기능 비활성화

일반적으로 사용되는 인터럽트 사용 및 비활성화 기능은 다음과 같습니다.

enable_irq 및 비활성화_irq는 지정된 인터럽트를 활성화 및 비활성화하는 데 사용되며, irq는 비활성화할 인터럽트 번호입니다. 비활성화_irq 함수는 현재 실행 중인 인터럽트 처리 기능이 완료될 때까지 반환되지 않습니다. 따라서 사용자는 새로운 인터럽트가 생성되지 않고 실행을 시작한 모든 인터럽트 핸들러가 종료되었는지 확인해야 합니다. 이 경우 다른 인터럽트 비활성화 함수를 사용할 수 있습니다:

disable_irq_nosync 이 함수는 호출된 후 즉시 반환되며 현재 인터럽트 핸들러가 실행을 완료할 때까지 기다리지 않습니다. 위의 세 가지 기능은 모두 특정 인터럽트를 활성화하거나 비활성화합니다. 때로는 STM32를 학습할 때 전역 인터럽트를 끄는 것으로 흔히 알려져 있는 현재 프로세서의 전체 인터럽트 시스템을 꺼야 할 경우가 있습니다. 기능:

local_irq_enable은 현재 프로세서 인터럽트 시스템을 활성화하는 데 사용되고 local_irq_disable은 현재 프로세서 인터럽트 시스템을 비활성화하는 데 사용됩니다. 작업 A가 10S에 대한 전역 인터럽트를 끄기 위해 local_irq_disable을 호출하는 경우 작업 B는 2S에 대한 전역 인터럽트를 끄기 위해 local_irq_disable을 호출하여 3초 후에 local_irq_enable 함수를 호출합니다. 전역 인터럽트를 켜십시오. 이때 2+3=5초가 지나고 전역 인터럽트가 켜졌다. 이때 전역 인터럽트를 10초 동안 끄고자 하는 태스크A의 욕구가 깨졌고, 이후 태스크A는 '분노'하게 됐다. 그 결과는 심각했습니다. 아마도 작업 A로 인해 시스템이 완전히 중단될 수도 있습니다. 이 문제를 해결하기 위해 B 태스크는 local_irq_enable 함수를 통해 간단하고 거칠게 전역 인터럽트를 활성화할 수 없으며, 인터럽트 상태를 이전 상태로 복원하는 것이 아니라 다른 태스크의 느낌을 고려하여 다음 두 가지 함수를 사용해야 합니다. :

1.2 상반부와 하반부

어떤 자료에서는 상반부와 하반부를 상반부, 하반부라고도 하는데 같은 의미입니다. request_irq를 사용하여 인터럽트를 신청할 때 등록한 인터럽트 서비스 기능은 인터럽트 처리의 상위 절반에 속하며 인터럽트가 트리거되는 동안 인터럽트 처리 기능이 실행됩니다. 우리 모두는 인터럽트 처리 기능이 가능한 한 빨리 실행되어야 하고, 짧을수록 좋다는 것을 알고 있지만 현실은 종종 잔인할 때가 많습니다. 인터럽트 처리 기능. 예를 들어 정전식 터치스크린은 인터럽트를 통해 터치 이벤트가 발생했음을 SOC에 알리고, SOC는 인터럽트에 응답한 후 IIC 인터페이스를 통해 터치 좌표 값을 읽어 시스템에 보고한다. 그러나 우리 모두는 IIC의 최대 속도가 400Kbit/S에 불과하므로 인터럽트 중에 IIC를 통해 데이터를 읽는 것은 시간 낭비라는 것을 알고 있습니다. IIC를 통해 터치 데이터를 읽는 작업을 일시적으로 실행할 수 있으며, 인터럽트 처리 기능은 인터럽트에만 응답한 후 인터럽트 플래그 비트를 클리어합니다. 이때, 인터럽트 처리 과정은 두 부분으로 나누어집니다.
상반부: 상단반은 인터럽트 처리 기능으로, 더 빠르고 시간이 오래 걸리지 않는 처리 프로세스는 상단에서 완료될 수 있습니다.
하위 부분: 인터럽트 처리 프로세스에 시간이 많이 걸리는 경우 시간이 많이 걸리는 코드를 꺼내 실행을 위해 하위 부분에 넘겨주므로 인터럽트 처리 기능이 빠르게 들어오고 나가게 됩니다.
따라서 Linux 커널이 인터럽트를 상위 및 하위 절반으로 나누는 주요 목적은 인터럽트 처리 기능에서 빠른 시작 및 빠른 실행을 달성하는 것입니다. 이러한 시간에 민감한 빠른 실행 작업은 인터럽트 처리 기능에 배치될 수 있습니다. 상반부. 나머지 작업은 모두 하위 절반에서 수행될 수 있습니다. 예를 들어, 상위 절반에서는 데이터가 메모리에 복사되고 하위 절반에서는 데이터의 특정 처리가 수행될 수 있습니다. 어떤 코드가 상위 절반에 속하고 어떤 코드가 하위 절반에 속하는지에 대해서는 명확한 규정이 없습니다. 모든 판단은 실제 사용을 기반으로 합니다. 이는 드라이버 작성자의 기술을 테스트합니다. 다음은 참조로 사용할 수 있는 몇 가지 참조 지점입니다.
① 처리할 콘텐츠가 다른 중단으로 인해 중단되는 것을 원하지 않는 경우 상단 절반에 배치할 수 있습니다.
②. 처리할 작업이 시간에 민감한 경우 상단에 배치할 수 있습니다.
3. 처리할 작업이 하드웨어와 관련된 경우에는 위쪽에 배치할 수 있습니다.
4. 위의 세 가지 사항 이외의 작업은 아래쪽에 배치해야 합니다.
하반부 메커니즘:

소프트 인터럽트

처음에 Linux 커널은 "BH"라고 하는 하단 절반을 구현하기 위한 "하반부" 메커니즘을 제공했습니다. 나중에 "BH" 메커니즘을 대체하기 위해 소프트 인터럽트와 태스크렛이 도입되었습니다. Linux 커널 버전 2.5부터 소프트 인터럽트와 태스크렛을 사용할 수 있습니다. Linux 커널은 Softirq_action 구조를 사용하여 소프트 인터럽트를 나타냅니다. Softirq_action 구조는 include/linux/interrupt.h 파일에 정의되어 있으며 내용은 다음과 같습니다.

커널/에는 총 10개의 소프트 인터럽트가 정의되어 있습니다.

NR_SOFTIRQS는 열거형으로 include/linux/interrupt.h 파일에 정의되어 있으며 다음과 같이 정의됩니다.

10개의 소프트 인터럽트가 있음을 알 수 있습니다. 총합이므로 NR_SOFTIRQS는 10이므로 Softirq_vec 배열에는 10개의 요소가 있습니다. Softirq_action 구조의 작업 멤버 변수는 소프트 인터럽트의 서비스 기능입니다. Softirq_vec 배열은 전역 배열이므로 (SMP 시스템의 경우) 각 CPU는 자체 트리거링 및 제어 메커니즘을 가지며 실행만 가능합니다. 소프트 인터럽트는 자체적으로 트리거됩니다. 그러나 각 CPU가 실행하는 소프트 인터럽트 서비스 기능은 사실상 동일하며, 모두 Softirq_vec 배열에 정의된 액션 기능이다. 소프트 인터럽트를 사용하려면 먼저 open_softirq 함수를 사용하여 해당 소프트 인터럽트 처리 함수를 등록해야 합니다. open_softirq 함수의 프로토타입은 다음과 같습니다.

nr: 소프트 인터럽트를 활성화하려면 다음에서 하나를 선택합니다. 샘플 코드 51.1.2.3.
action: 소프트 인터럽트에 해당하는 처리 기능입니다.
반환 값: 반환 값이 없습니다.
소프트 인터럽트를 등록한 후 raise_softirq 함수를 통해 트리거되어야 합니다. raise_softirq 함수의 프로토타입은 다음과 같습니다.

소프트 인터럽트는 컴파일 중에 정적으로 등록되어야 합니다! Linux 커널은 Softirq_init 함수를 사용하여 Softirqs를 초기화합니다. Softirq_init 함수는 kernel/softirq.c 파일에 정의되어 있습니다. 함수 내용은 다음과 같습니다.

tasklet

tasklet은 Softirqs를 사용하여 구현된 또 다른 하위 메커니즘입니다. 소프트 인터럽트와 태스크릿 사이에는 태스크릿을 사용하는 것이 좋습니다. Linux 커널 구조

라인 489의 func 함수는 태스크릿에서 실행되는 처리 함수입니다. 사용자 정의 함수 내용은 인터럽트 처리 함수와 동일합니다. 태스크릿을 사용하려면 먼저 태스크릿을 정의한 후 tasklet_init 함수를 사용하여 태스크릿을 초기화해야 합니다. taskled_init 함수 프로토타입은 다음과 같습니다.


함수 매개변수와 반환값의 의미 ​​
t: 초기화할 tasklet
func: Tasklet 처리 기능입니다.
data: func 함수에 전달될 매개변수
반환 값: 반환 값이 없습니다.
DECLARE_TASKLET 매크로를 사용하여 태스크릿의 정의 및 초기화를 한 번에 완료할 수도 있습니다. DECLARE_TASKLET은 include/linux/interrupt.h 파일에 정의되어 있으며 다음과 같이 정의됩니다.

여기서 이름은 태스크릿의 이름입니다. tasklet_struct 유형으로 정의되는 변수를 사용할 때 func는 tasklet의 처리 함수이고 data는 func 함수에 전달되는 매개변수입니다.
상단 즉, 인터럽트 처리 함수에서 tasklet_schedule 함수를 호출하면 tasklet_schedule 함수의 프로토타입은 다음과 같습니다.

Tasklet의 참고 사용 예는 다음과 같습니다. :

작업 대기열

작업 대기열은 프로세스 컨텍스트에서 실행되는 또 다른 하위 실행 방법입니다. 작업 대기열은 실행을 위해 연기할 작업을 커널 스레드에 넘겨줍니다. 대기열은 수면 또는 일정 변경을 허용합니다. 따라서 연기하려는 작업이 절전 모드일 수 있으면 작업 대기열을 선택할 수 있고, 그렇지 않으면 소프트 인터럽트나 태스크릿만 선택할 수 있습니다.
Linux 커널은 작업을 나타내기 위해 work_struct 구조를 사용하며 내용은 다음과 같습니다(조건부 컴파일은 생략).

이러한 작업은 작업 대기열로 구성되며 작업 대기열은 workqueue_struct 구조로 표현되며 내용은 다음과 같습니다. 다음과 같습니다(조건부 컴파일은 생략됨).

Linux 커널은 작업자 스레드를 사용하여 작업 대기열의 각 작업을 처리합니다. Linux 커널은 작업자 스레드를 나타내기 위해 작업자 구조의 내용은 다음과 같습니다.

샘플 코드 51.1.2.10에서 볼 수 있듯이, 각 작업자는 작업 대기열을 가지며 작업자 스레드는 자체 작업 대기열에서 모든 작업을 처리합니다. 실제 드라이버 개발에서는 작업(work_struct)만 정의하면 되며 기본적으로 작업 대기열 및 작업자 스레드에 대해 걱정할 필요가 없습니다. 간단히 작업을 생성하는 것은 매우 간단합니다. work_struct 구조 변수를 정의한 다음 INIT_WORK 매크로를 사용하여 작업을 초기화합니다. INIT_WORK 매크로는 다음과 같이 정의됩니다.

1.3 장치 트리 인터럽트 정보 노드

장치 트리를 사용하는 경우에는 장치 트리에서 인터럽트 속성 정보를 설정해야 합니다. Linux 커널은 장치 트리의 인터럽트 속성 정보를 읽어 인터럽트를 구성합니다. 인터럽트 컨트롤러의 경우 문서 Documentation/devicetree/bindings/arm/gic.txt에서 장치 트리 바인딩 정보를 참조하세요. imx6ull.dtsi 파일을 엽니다. intc 노드는 I.MX6ULL의 인터럽트 컨트롤러 노드입니다. 노드 내용은 다음과 같습니다.

Line 2, 호환되는 속성 값은 Linux에서 "arm, cortex-a7-gic"입니다. 커널 소스 코드 GIC 인터럽트 컨트롤러 드라이버 파일을 찾으려면 "arm,cortex-a7-gic"을 검색하십시오.
3번째 줄, #interrupt-cells는 #address-cells, #size-cells과 동일합니다. 이 인터럽트 컨트롤러 아래에 있는 장치의 셀 크기를 나타냅니다. 장치의 경우 인터럽트 정보를 설명하기 위해 인터럽트 속성이 사용됩니다. #interrupt-cells는 인터럽트 속성의 셀 크기, 즉 하나에 몇 개의 셀이 있는지 설명합니다. 메시지. 각 셀은 32비트 정수 값입니다. ARM에서 처리하는 GIC에는 총 3개의 셀이 있습니다. 이 세 셀의 의미는 다음과 같습니다.
첫 번째 셀: 인터럽트 유형, 0은 SPI 인터럽트, 1은 PPI 인터럽트를 의미합니다. .
두 번째 셀: 인터럽트 번호 SPI 인터럽트의 경우 인터럽트 번호 범위는 0~987입니다. PPI 인터럽트의 경우 인터럽트 번호 범위는 0~15입니다.
세 번째 셀: 플래그, 비트[3:0]은 인터럽트 트리거 유형을 나타냅니다. 1일 경우 상승 에지 트리거를 나타내고, 2일 경우 하강 에지 트리거를 나타냅니다. High 레벨 트리거, 8이면 Low 레벨 트리거를 나타냅니다. 비트[15:8]은 PPI 인터럽트의 CPU 마스크입니다.
라인 4에서 인터럽트 컨트롤러 노드는 비어 있으며 이는 현재 노드가 인터럽트 컨트롤러임을 나타냅니다.
gpio의 경우 gpio 노드를 인터럽트 컨트롤러로 사용할 수도 있습니다. 예를 들어 imx6ull.dtsi 파일의 gpio5 노드 내용은 다음과 같습니다.

라인 4에서는 인터럽트 소스 정보를 설명합니다. gpio5에는 총 2가지 정보가 있으며, 인터럽트 유형은 모두 SPI, 트리거 레벨은 IRQ_TYPE_LEVEL_HIGH입니다. 차이점은 인터럽트 소스에 있습니다. 하나는 74이고 다른 하나는 75입니다. "IMX6ULL 참조 설명서"의 "3장 인터럽트 및 DMA 이벤트" 장을 열고 그림 50.1.3.1에 표시된 대로 표 3-1을 찾으세요.

그림 50.1.3.1에서 볼 수 있듯이 GPIO5는 총 2개의 인터럽트 번호를 사용하는데, 하나는 74이고 다른 하나는 75입니다. 그 중 74는 GPIO5_IO00~GPIO5_IO15의 하위 16개 IO에 해당하고, 75는 GPIO5_IO16~GPIOI5_IO31의 상위 16개 IO에 해당합니다. 8행, 인터럽트 컨트롤러는 gpio5 노드가 gpio5의 모든 IO 인터럽트를 제어하는 ​​데 사용되는 인터럽트 컨트롤러이기도 함을 나타냅니다.
9번째 줄에서 #interrupt-cell을 2로 변경합니다.
imx6ull-alientek-emmc.dts 파일을 열고 다음 내용을 찾으세요.

1.4 인터럽트 번호 가져오기

드라이버를 작성할 때 인터럽트 번호를 사용해야 합니다. number, Interrupt 장치 트리에 정보가 기록되어 있으므로 irq_of_parse_and_map 함수를 통해 Interrupts 속성에서 해당 장치 번호를 추출할 수 있습니다.

함수 매개 변수와 반환 값의 의미는 다음과 같습니다.

dev: 장치 노드.
index: 인덱스 번호. 인터럽트 속성에는 인덱스를 통해 얻을 수 있는 정보가 여러 개 포함될 수 있습니다.
반환 값: 인터럽트 번호. GPIO를 사용하는 경우 gpio_to_irq 함수를 사용하여 gpio에 해당하는 인터럽트 번호를 얻을 수 있습니다. 함수 프로토타입은 다음과 같습니다.

2. 드라이버 코드

#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/ide.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/errno.h> 
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <asm/mach/map.h>
#include <linux/timer.h>
#include <linux/jiffies.h>

#define IMX6UIRQ_CNT            1               /* 设备号个数 */
#define IMX6UIRQ_NAME           "irqDev"        /* 名字 */
#define KEY0VALUE               0X01            /* KEY0 按键值 */
#define INVAKEY                 0XFF            /* 无效的按键值 */
#define KEY_NUM                 1               /* 按键数量 */

/* 可能会有好多按键，通过结构体数组来描述按键 */
/* 中断 IO 描述结构体 */
struct irq_keydesc {
    int gpio;                               /* gpio */
    int irqnum;                             /* 中断号 */
    unsigned char value;                    /* 按键对应的键值 */
    char name[10];                          /* 名字 */
    irqreturn_t (*handler)(int, void *);    /* 中断服务函数 */
};

/* irq设备结构体 */
struct imx6uirq_dev {
    dev_t               devid;          /* 设备号 */
    struct cdev         cdev;           /* 字符设备 */
    struct class        *class;         /* 类 */
    struct device       *device;        /* 设备 */
    int                 major;          /* 注设备号 */
    int                 minor;          /* 次设备号 */
    struct device_node  *nd;            /* 设备节点 */

    atomic_t            keyvalue;       /* 有效的按键键值 */
    atomic_t            releasekey;     /* 标记是否完成一次完成的按键*/
    struct timer_list   timer;          /* 定义一个定时器*/
    struct irq_keydesc  irqkeydesc[KEY_NUM]; /* 按键描述数组 */
    unsigned char       curkeynum;      /* 当前的按键号 */
};

struct imx6uirq_dev  irqDev; /* 定义LED结构体 */

/* @description : 中断服务函数，开启定时器，延时 10ms，
* 定时器用于按键消抖。
* 两个参数是中断处理函数的必须写法
* @param - irq : 中断号
* @param - dev_id : 设备结构。
* @return : 中断执行结果
*/
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;

    /* 采用定时器削抖，如果再定时器时间内还是这个值，说明是真的按下了，在定时器中断中处理 */
    /* 这里设置为0是简易处理，因为只有一个按键 */
    /* 有其他按键要再建一个中断处理函数，并把curkeynum改成相应的按键值 */
    /* 注意不能所有按键用一个中断函数，第一是一起按的时候会出错 */
    /* 第二，无法用curkeynum判断使用的是第几个按键 */
    dev->curkeynum = 0;
    /* 传递给定时器的参数，注意要强转，在中断处理函数里面再转回来 */
    dev->timer.data = (volatile long)dev_id;
    /* mod_timer会启动定时器，第二个参数是要修改的超时时间 */
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));
    return IRQ_RETVAL(IRQ_HANDLED);
}

 /* @description : 定时器服务函数，用于按键消抖，定时器到了以后
* 再次读取按键值，如果按键还是处于按下状态就表示按键有效。
* @param – arg : 设备结构变量
* @return : 无
*/
void timer_function(unsigned long arg)
{
    unsigned char value;
    unsigned char num;
    struct irq_keydesc *keydesc;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg; 

    /* 因为只有一个按键，这里是0 */
    num = dev->curkeynum;
    keydesc = &dev->irqkeydesc[num]; 
    value = gpio_get_value(keydesc->gpio); /* 读取 IO 值 */

    if(value == 0){ /* 按下按键 */
        atomic_set(&dev->keyvalue, keydesc->value);
    }
    else{ /* 按键松开 */
        /* 这种情况是按下再松开的松开，使用keyValue加上releaseKey */
        /* 没按下的话， releasekey一直为0*/
        atomic_set(&dev->keyvalue, 0x80 | keydesc->value);
        atomic_set(&dev->releasekey, 1); /* 标记松开按键 */ 
    } 
}

/*
* @description : 按键 IO 初始化
* @param : 无
* @return : 无
*/
static int keyio_init(void)
{
    unsigned char i = 0;

    int ret = 0;

    /* 1.获取key节点 */
    irqDev.nd = of_find_node_by_path("/key");
    if (irqDev.nd== NULL){
        printk("key node not find!\r\n");
        return -EINVAL;
    }
    /* 对每个按键都提取 GPIO */
    for (i = 0; i < KEY_NUM; i++) {
        irqDev.irqkeydesc[i].gpio = of_get_named_gpio(irqDev.nd, "key-gpios", i);
        if (irqDev.irqkeydesc[i].gpio < 0) {
            printk("can&#39;t get key%d\r\n", i);
        }
    }

    /* 初始化 key 所使用的 IO，并且设置成中断模式 */
    for (i = 0; i < KEY_NUM; i++) {
        /* 先对每一个IO命名 */
        /* 先对命名清0 */
        memset(irqDev.irqkeydesc[i].name, 0, sizeof(irqDev.irqkeydesc[i].name)); 
        /* 给IO命名 */
        sprintf(irqDev.irqkeydesc[i].name, "KEY%d", i); 
        /* 请求GPIO */
        gpio_request(irqDev.irqkeydesc[i].gpio, irqDev.irqkeydesc[i].name);
        
        /* 设置GPIO为输入 */
        gpio_direction_input(irqDev.irqkeydesc[i].gpio); 

        /* 获取中断号，以下为两个方法，都可以获取到 */
        /* 从interrupts属性里面获取 */
        /* 注意i是根据设备树里面设置了多少个就是多少个，都会获取到 */
        /* 下面的方法是通用的获取中断号的函数 */
        irqDev.irqkeydesc[i].irqnum = irq_of_parse_and_map(irqDev.nd, i);
#if 0
        /* 此方法是gpio获取中断号的方法 */
        irqDev.irqkeydesc[i].irqnum = gpio_to_irq(irqDev.irqkeydesc[i].gpio);
#endif
        printk("key%d:gpio=%d, irqnum=%d\r\n", i, irqDev.irqkeydesc[i].gpio,
                                                  irqDev.irqkeydesc[i].irqnum);
    }

    /* 2. 按键中断初始化 */
    /* 设置中断处理函数和按键初始值 */
    /* 因为只有一个key0.，所以这里也没用循环 */
    irqDev.irqkeydesc[0].handler = key0_handler;
    irqDev.irqkeydesc[0].value = KEY0VALUE;
     /* 申请中断 */
    for (i = 0; i < KEY_NUM; i++) {
        /* request_irq参数
         * 中断号，中断函数，中断触发类型，中断名字，传递给中断处理函数的参数（第二个），这里传的结构体
         * */
        ret = request_irq(irqDev.irqkeydesc[i].irqnum, irqDev.irqkeydesc[i].handler,
                        IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
                        irqDev.irqkeydesc[i].name, &irqDev);
        if(ret < 0){
            printk("irq %d request failed!\r\n", irqDev.irqkeydesc[i].irqnum);
            return -EFAULT;
        }
    }

    /* 3. 创建定时器 */
    init_timer(&irqDev.timer);
    irqDev.timer.function = timer_function;
    /* 注意下面不能让定时器运行，因为要按下按键之后再运行 */
    /* 启动定时器通过mod_timer启动，通常在初始化阶段的定时器用的是add_timer */
    return 0;
}


static int imx6uirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &irqDev;
    return 0;
}

static int imx6uirq_release(struct inode *inode, struct file *filp)
{
    //struct imx6uirq_dev  *dev = (struct imx6uirq_dev  *)filp->private_data;
    return 0;
}

 /*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param – buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue = 0;     /* 按键值 */
    unsigned char releasekey = 0;   /* 标记是否一次完成 */
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;

    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);

    if (releasekey) { /* 有按键按下 */
        if (keyvalue & 0x80) {
            keyvalue &= ~0x80; /* 因为中断中或了一个0x80,这里面去掉0x80 */
            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
        } else {
            goto data_error;
        }
        atomic_set(&dev->releasekey, 0); /* 按下标志清零 */
    } else { /* 没有按下 */
        goto data_error;
    }
    return 0;

data_error:
    return -EINVAL;
}

/* 字符设备操作集 */
static const struct file_operations imx6uirq_fops = {
    .owner = THIS_MODULE,
    .open = imx6uirq_open,
    .release = imx6uirq_release,
    .read = imx6uirq_read
};

/* 模块入口函数 */
static int __init imx6uirq_init(void)
{
    /* 定义一些所需变量 */
    int ret = 0;

    /* 1. 注册字符设备驱动 */
    irqDev.major = 0;
    if(irqDev.major) {
        irqDev.devid = MKDEV(irqDev.major, 0);
        ret = register_chrdev_region(irqDev.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME );  
    } else {
        alloc_chrdev_region(&irqDev.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME );
        irqDev.major = MAJOR(irqDev.devid);
        irqDev.minor = MINOR(irqDev.devid);
    }
    if(ret < 0){
        goto fail_devid;
    }
    printk("Make devid success! \r\n");
    printk("major = %d, minor = %d \r\n", irqDev.major, irqDev.minor);

    /* 2. 初始化cdev */
    irqDev.cdev.owner = THIS_MODULE;
    cdev_init(&irqDev.cdev, &imx6uirq_fops);
    ret = cdev_add(&irqDev.cdev, irqDev.devid, IMX6UIRQ_CNT);
    if (ret < 0){
        goto fail_cdev;
    } else {
        printk("Cdev add sucess! \r\n");
    }

    /* 3. 自动创建设备节点 */
    irqDev.class = class_create(THIS_MODULE, IMX6UIRQ_NAME );
    if(IS_ERR(irqDev.class)) {
        ret = PTR_ERR(irqDev.class);
        goto fail_class;
    } else {
        printk("Class create sucess! \r\n");
    }

    irqDev.device = device_create(irqDev.class, NULL, irqDev.devid, NULL, IMX6UIRQ_NAME );
    if(IS_ERR(irqDev.device)) {
        ret = PTR_ERR(irqDev.device);
        goto fail_device;
    } else {
        printk("Device create sucess! \r\n");
    }

    /* 4.初始化按键 */
    atomic_set(&irqDev.keyvalue, INVAKEY);
    atomic_set(&irqDev.releasekey, 0);
    keyio_init();

    printk("irqDev init! \r\n");
    return 0;

/* 错误处理 */
fail_device:
    class_destroy(irqDev.class);
fail_class:
    cdev_del(&irqDev.cdev);
fail_cdev:
    unregister_chrdev_region(irqDev.devid, IMX6UIRQ_CNT);
fail_devid:
    return ret;
}

/* 模块出口函数 */
static void __exit imx6uirq_exit(void)
{
    unsigned int i = 0;
    /* 删除定时器 */
    del_timer_sync(&irqDev.timer); 

    /* 释放中断 */
    for (i = 0; i < KEY_NUM; i++) {
        free_irq(irqDev.irqkeydesc[i].irqnum, &irqDev);
    }

    /* 1. 释放设备号 */
    cdev_del(&irqDev.cdev);
    /* 2. 注销设备号 */
    unregister_chrdev_region(irqDev.devid, IMX6UIRQ_CNT);
    /* 3. 摧毁设备 */
    device_destroy(irqDev.class, irqDev.devid);
    /* 4.摧毁类 */
    class_destroy(irqDev.class);


    printk("irqDev exit! \r\n");
}

/* 模块入口和出口注册 */
module_init(imx6uirq_init);
module_exit(imx6uirq_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Shao Zheming");

3. 4. 태스크릿 처리를 사용하여 하위 절반을 인터럽트합니다

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "linux/ioctl.h"

/* 
 * argc: 应用程序参数个数
 * argv[]: 参数是什么，具体的参数，说明参数是字符串的形式
 * .chrdevbaseApp <filename> <0:1> 0表示关灯，1表示开灯
 * .chrdevbaseApp /dev/led 0 关灯
 * .chrdevbaseApp /dev/led 1 开灯
 * */


int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("Error Usage!\r\n");
        return -1;
    }
    
    int fd, ret;
    char *filename;
    unsigned char data;

    filename = argv[1];
    fd = open(filename, O_RDWR);
    if(fd < 0)
    {
        printf("file %s open failed! \r\n", filename);
        return -1;
    }

    while (1) {
        ret = read(fd, &data, sizeof(data));
        if (ret < 0) { /* 数据读取错误或者无效 */
        
        } else { /* 数据读取正确 */
            if (data) /* 读取到数据 */
                printf("key value = %#X\r\n", data);
        }
    }

    close(fd);
    return 0;
}

5. 작업 대기열이 하위 절반을 처리합니다

개발 방법은 태스크릿과 동일합니다 작업은 장치 개발 구조를 추론할 수 있으므로 일반적으로 개발 구조에서 작업

관련 권장 사항: "Linux 비디오 튜토리얼"

위 내용은 리눅스 커널에 인터럽트 기능이 있나요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!