[Qt]拖拽图片

————————mainwindow.h————————-
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include
#include
#include
#include

QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();

private:
Ui::MainWindow *ui;
};

class DraggableLabel : public QLabel
{
Q_OBJECT

public:
explicit DraggableLabel(QWidget *parent = nullptr) : QLabel(parent), isDragging(false) {}

protected:
void mousePressEvent(QMouseEvent *event) override
{
if (event->button() == Qt::LeftButton) {
isDragging = true;
dragStartPosition = event->pos();
}
}

void mouseMoveEvent(QMouseEvent *event) override
{
if (isDragging) {
int dx = event->pos().x() – dragStartPosition.x();
int dy = event->pos().y() – dragStartPosition.y();
move(pos().x() + dx, pos().y() + dy);
}
}

void mouseReleaseEvent(QMouseEvent *event) override
{
if (event->button() == Qt::LeftButton) {
isDragging = false;
}
}

private:
bool isDragging;
QPoint dragStartPosition;
};

#endif // MAINWINDOW_H

——————————mainwindow.cpp————————————-
#include “mainwindow.h”
#include “ui_mainwindow.h”

MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);

QPixmap pixmap(“/home/orangepi/11111.jpg”);
/*
ui->label->setPixmap(pixmap);

ui->label->setGeometry(50, 50, pixmap.width(), pixmap.height());

ui->label->setObjectName(“draggableLabel”);
*/

DraggableLabel *label2 = new DraggableLabel(this);

label2->setPixmap(pixmap);

label2->setGeometry(50, 50, pixmap.width(), pixmap.height());

}

MainWindow::~MainWindow()
{
delete ui;
}

[Qt]创建线程

——–mainwindow.h———————–
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include

#include
#include
#include
#include
#include

QT_BEGIN_NAMESPACE
namespace Ui {
class MainWindow;
}
QT_END_NAMESPACE

class Work1 ;
class Work2 ;

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();

private:
Ui::MainWindow *ui;

private:
Work1 *worker1;
Work2 *worker2;

QThread workerThread1;
QThread workerThread2;
};

class Work1:public QObject
{
Q_OBJECT
bool isCanRun;
public slots:
void doWork1(void)
{
isCanRun = true;
while (1)
{
if (!isCanRun)
{
break;
}
QThread::sleep(2);
qDebug() << "Work1"; } } signals: void resultemit1(); public : void stopWork() { qDebug()<< "break thread"<setupUi(this);

worker1 = new Work1;
worker2 = new Work2;

worker1->moveToThread(&workerThread1);
worker2->moveToThread(&workerThread2);

QObject::connect(&workerThread1, &QThread::started, worker1, &Work1::doWork1);
QObject::connect(&workerThread2, &QThread::started, worker2, &Work2::doWork2);

workerThread1.start();
workerThread2.start();

connect(&workerThread1, SIGNAL(finished()),worker1, SLOT(deleteLater()));
connect(&workerThread1, SIGNAL(finished()),&workerThread1, SLOT(deleteLater()));

connect(&workerThread2, SIGNAL(finished()),worker2, SLOT(deleteLater()));
connect(&workerThread2, SIGNAL(finished()),&workerThread2, SLOT(deleteLater()));
}

MainWindow::~MainWindow()
{
delete ui;

worker1->stopWork();
worker2->stopWork();
workerThread1.quit();
workerThread2.quit();

if (workerThread1.wait(5000)) {
qDebug()<<"thread end"<

[matlab]螺旋圆环

% 环形正弦曲线的参数
R = 2; % 环形的中心半径
A = 0.5; % 正弦波的振幅
k = 4; % 正弦波的频率(决定波的数量)

% 极坐标角度参数
theta = linspace(0, 20*pi, 1000); % 从0到2*pi的角度

% 计算正弦形成的半径
r = R + A * sin(k * theta);

% 将极坐标转换为笛卡尔坐标
x = r .* cos(theta);
y = r .* sin(theta);

% 绘图
figure;

% 绘制环形正弦曲线
plot(x, y, ‘r’, ‘LineWidth’, 1.5);

[orangepi]搭建Qt

1.下载源码
http://qt-mirror.dannhauer.de/archive/qt/5.15/5.15.2/single/
2.解压
tar -xvf xxxx
3.在源码根目录下放如autoconfig.h ,注意sysroot ,可能需要添加-feature-library 选项

./configure \
-prefix /opt/qt-5.15.2 \
-release \
-feature-library \
-opensource \
-skip qtwayland \
-skip qtlocation \
-skip qtscript \
-xplatform linux-aarch64-gnu-g++ \
-sysroot /opt/atk-dlrk356x-toolchain/aarch64-buildroot-linux-gnu/sysroot/ \
-make libs \
-optimized-qmake \
-no-opengl \
-no-sse2 \
-no-openssl \
-no-cups \
-no-glib \
-no-pkg-config \
-no-separate-debug-info \
-pch \
-shared \
-qt-libjpeg \
-qt-zlib \
-qt-libpng

4.修改 qtbase/mkspecs/linux-aarch64-gnu-g++/qmake.conf

QMAKE_CC = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc
QMAKE_CXX = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-g++
QMAKE_LINK = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-g++
QMAKE_LINK_SHLIB = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-g++

# modifications to linux.conf
QMAKE_AR = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-ar cqs
QMAKE_OBJCOPY = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-objcopy
QMAKE_NM = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-nm -P
QMAKE_STRIP = /opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-strip

4.1 修改
src/corelib/global/qglobal.h 里添加limits头文件
# include 一定要加在ifdef __cplusplus和endif之间才行

5.sudo make -j4
6.sudo make install
7.完成后应该在/opt/atk-dlrk356x-toolchain/aarch64-buildroot-linux-gnu/sysroot/opt下有qt5.15.2目录
8.将qt5.15.2打包传到开发板
9.将解压后的qt-5.15.2/lib目录添加到开发板的LD_LIBRARY_PATH环境量中

[orangepi]misc 检测IO输入

/节点下添加
key_irq {
compatible = “alientek,key”;
pinctrl-0 = <&key_irq_gpio>;
pinctrl-names = “alientek,key”;
misckey-gpio = <&gpio3 RK_PD2 GPIO_ACTIVE_HIGH>;
status = “okay”;
};

pinctr中添加
key-irq-gpios {
/omit-if-no-ref/
key_irq_gpio: key-irq-pin {
rockchip,pins = <3 RK_PD2 RK_FUNC_GPIO &pcfg_pull_none>;
};
};

————————驱动———————————————–
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //#include
#include
#include

#define MISCKEY_NAME “misckey_irq” /* 名字 */
#define MISCKEY_MINOR 255 /* 子设备号 */

/* miscled设备结构体 */
struct misckey_dev{
dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
int key_gpio; /* led所使用的GPIO编号 */
int keyvalue;
};

struct misckey_dev misckey; /* led设备 */

static int misckey_open(struct inode *inode, struct file *filp)
{
struct misckey_dev *dev = filp->private_data;
filp->private_data = &misckey; /* 设置私有数据 */
dev = filp->private_data;
printk(“open misckey.key_gpio=%d\n”, dev->key_gpio);

return 0;
}

static ssize_t misckey_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
return 0;
}

static ssize_t misckey_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret = 0;
int value;
struct misckey_dev *dev = filp->private_data;
printk(“misckey_read = %d\n”,dev->key_gpio);

if (gpio_get_value(dev->key_gpio) == 1)
{
printk(“misckey_read = 1\n”);
dev->keyvalue=1;
}
else
{
printk(“misckey_read = 0\n”);
dev->keyvalue=0;
}

value = dev->keyvalue;

ret = copy_to_user(buf, &value, sizeof(value));
return ret;
}

/*
* file operations
*/
/* 设备操作函数 */
static struct file_operations mykey_fops = {
.owner = THIS_MODULE,
.open = misckey_open,
.read = misckey_read,
.write = misckey_write,
};

/* MISC设备结构体 */
static struct miscdevice mykey_miscdev = {
.minor = MISCKEY_MINOR,
.name = MISCKEY_NAME,
.fops = &mykey_fops,
};

static int led_gpio_init(struct device_node *nd)
{
int ret;

/* 从设备树中获取GPIO */
misckey.key_gpio = of_get_named_gpio(nd, “misckey-gpio”, 0);

printk(“misckey.key_gpio=%d\n”,misckey.key_gpio);

if(!gpio_is_valid(misckey.key_gpio))
{
printk(“miscled:Failed to get key-gpio\n”);
return -EINVAL;
}

/* 申请使用GPIO */
ret = gpio_request(misckey.key_gpio, “key_irq”);
if(ret)
{
printk(“led: Failed to request misckey-gpio\n”);
return ret;
}

ret = gpio_direction_input(misckey.key_gpio);
if(ret < 0) { printk("can't set gpio!\r\n"); return ret; } return 0; } static int mykey_probe(struct platform_device *pdev) { int ret; printk("misc_my_key driver and device was matched!\r\n"); ret = led_gpio_init(pdev->dev.of_node);
if(ret < 0) { printk("gpio_init error!\r\n"); return ret; } else { printk("gpio_init success!\r\n"); } ret = misc_register(&mykey_miscdev); if(ret < 0){ printk("misc device register failed!\r\n"); goto free_gpio; } else { printk("misc device register success!\r\n"); } return 0; free_gpio: gpio_free(misckey.key_gpio); return -EINVAL; return 0; } /* * @description : platform驱动的remove函数 * @param - dev : platform设备 * @return : 0,成功;其他负值,失败 */ static int mykey_remove(struct platform_device *dev) { gpio_free( misckey.key_gpio); /* 注销misc设备 */ misc_deregister(&mykey_miscdev); return 0; } /* 匹配列表 */ static const struct of_device_id key_of_match[] = { { .compatible = "alientek,key" }, { /* Sentinel */ } }; /* platform驱动结构体 */ static struct platform_driver mykey_misc = { .driver = { .name = "alientek,key", /* 驱动名字,用于和设备匹配 */ .of_match_table = key_of_match, /* 设备树匹配表 */ }, .probe = mykey_probe, .remove = mykey_remove, }; static int mykey_init(void) { int ret = 0; printk(" mykey_init enter\n"); ret = platform_driver_register(&mykey_misc); if(ret != 0) printk("mykey_init register failed!"); return 0; } static void mykey_exit(void) { printk(" Hello World exit\n "); platform_driver_unregister(&mykey_misc); } module_init(mykey_init); module_exit(mykey_exit); MODULE_LICENSE("Dual BSD/GPL"); MODULE_DESCRIPTION("A simple Hello World Module"); --------------------------应用程序------------------------------------ #include "stdio.h" #include "unistd.h" #include "sys/types.h" #include "sys/stat.h" #include "fcntl.h" #include "stdlib.h" #include "string.h" /* 定义按键值 */ #define KEY0VALUE 0XF0 #define INVAKEY 0X00 /* * @description : main主程序 * @param - argc : argv数组元素个数 * @param - argv : 具体参数 * @return : 0 成功;其他 失败 */ int main(int argc, char *argv[]) { int fd, ret; char *filename; int keyvalue; if(argc != 2){ printf("Error Usage!\r\n"); return -1; } filename = argv[1]; /* 打开key驱动 */ fd = open(filename, O_RDWR); if(fd < 0){ printf("file %s open failed!\r\n", argv[1]); return -1; } /* 循环读取按键值数据! */ while(1) { read(fd, &keyvalue, sizeof(keyvalue)); if (keyvalue == KEY0VALUE) { /* KEY0 */ printf("KEY0 Press, value = %#X\r\n", keyvalue); /* 按下 */ } sleep(1); } ret= close(fd); /* 关闭文件 */ if(ret < 0){ printf("file %s close failed!\r\n", argv[1]); return -1; } return 0; }

[linux]定时器异步通知

—————————–驱动————————————
/*
*file name: misc_device.c
*/

#include #include #include #include #include #include #include #include #include #include #include #include

#include #include

#include #include

#define MISC_MINOR 255

/* imx6uirq设备结构体 */
struct imx6uirq_dev{
struct fasync_struct *async_queue; /* 异步相关结构体 */
};

struct imx6uirq_dev imx6uirq; /* irq设备 */

// 定义定时器
static struct timer_list my_timer;

void my_timer_handler(struct timer_list *t) {

if(imx6uirq.async_queue)
{
// printk(KERN_INFO “timenow =: %ld\n”, jiffies);
kill_fasync(&imx6uirq.async_queue, SIGIO, POLL_IN); /* 释放SIGIO信号 */

}

mod_timer(&my_timer, jiffies + msecs_to_jiffies(1999));
// 重新启动定时器,例如每2秒触发一次

}

static int my_timer_init(void) {
// 初始化定时器
timer_setup(&my_timer, my_timer_handler, 0);

// 设置定时器的首次触发时间,例如 1 秒后
mod_timer(&my_timer, jiffies + msecs_to_jiffies(1000));

printk(KERN_INFO “定时器模块已初始化。\n”);
return 0;
}

static void my_timer_exit(void) {
// 删除定时器,防止再次触发
del_timer(&my_timer);
printk(KERN_INFO “定时器模块已卸载。\n”);
}

static int hello_open(struct inode *inode, struct file *filp)
{
printk(“misc open!\n”);
return 0;
}

static ssize_t hello_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{
int ret = 0;
unsigned char data[16];

printk(“misc write\n”);
ret = copy_from_user(data, buf, cnt);
if(ret != 0)
printk(“hello misc write failed\n”);

return ret;
}

static ssize_t hello_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret = 0;
unsigned char data[4] = {0x12, 0x03, 0x56, 0x11};

printk(“misc read\n”);

ret = copy_to_user(buf, &data, sizeof(data));
if(ret != 0)
printk(“hello misc read failed\n”);

return ret;
}

int imx6uirq_fasync(int fd, struct file *filp, int on)
{
return fasync_helper(fd, filp, on, &imx6uirq.async_queue);
}

static int imx6uirq_release(struct inode *inode, struct file *filp)
{
return imx6uirq_fasync(-1, filp, 0);
}

/*
* file operations
*/
struct file_operations hello_fops = {

.owner = THIS_MODULE,
.write = hello_write,
.read = hello_read,
.open = hello_open,
.fasync = imx6uirq_fasync,
.release = imx6uirq_release,
};

/*
* misc description
*/
struct miscdevice hello_misc = {
.minor = MISC_MINOR,
.name = “my-timer”,
.fops = &hello_fops,
};

static int hello_init(void)
{
int ret = 0;

printk(” Hello World enter\n”);

ret = misc_register(&hello_misc);
if(ret != 0)
printk(“hello misc register failed!”);

my_timer_init();
return 0;
}

static void hello_exit(void)
{
my_timer_exit();
printk(” Hello World exit\n “);
misc_deregister(&hello_misc);
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE(“Dual BSD/GPL”);
MODULE_DESCRIPTION(“A simple Hello World Module”);

—————————–应用—————————————–

#include “stdio.h”
#include “unistd.h”
#include “sys/types.h”
#include “sys/stat.h”
#include “fcntl.h”
#include “stdlib.h”
#include “string.h”
#include “poll.h”
#include “sys/select.h”
#include “sys/time.h”
#include “linux/ioctl.h”
#include “signal.h”

static int fd = 0; /* 文件描述符 */

/*
* SIGIO信号处理函数
* @param – signum : 信号值
* @return : 无
*/
static void sigio_signal_func(int signum)
{
int err = 0;
unsigned int keyvalue = 0;
printf(“sigio signal!\r\n”);
}

/*
* @description : main主程序
* @param – argc : argv数组元素个数
* @param – argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int flags = 0;
char *filename;

if (argc != 2) {
printf(“Error Usage!\r\n”);
return -1;
}

filename = argv[1];
fd = open(filename, O_RDWR);
if (fd < 0) { printf("Can't open file %s\r\n", filename); return -1; } /* 设置信号SIGIO的处理函数 */ signal(SIGIO, sigio_signal_func); fcntl(fd, F_SETOWN, getpid()); /* 设置当前进程接收SIGIO信号 */ flags = fcntl(fd, F_GETFL); /* 获取当前的进程状态 */ fcntl(fd, F_SETFL, flags | FASYNC); /* 设置进程启用异步通知功能 */ while(1) { sleep(2); } close(fd); return 0; }

[linux]misc简单驱动

/*
*file name: misc_device.c
*/

#include #include #include #include #include #include #include #include #include #include #include #include

#define MISC_MINOR 255

static int hello_open(struct inode *inode, struct file *filp)
{
printk(“misc open!\n”);
return 0;
}

static ssize_t hello_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{
int ret = 0;
unsigned char data[16];

printk(“misc write\n”);
ret = copy_from_user(data, buf, cnt);
if(ret != 0)
printk(“hello misc write failed\n”);

return ret;
}

static ssize_t hello_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret = 0;
unsigned char data[4] = {0x12, 0x03, 0x56, 0x11};

printk(“misc read\n”);

ret = copy_to_user(buf, &data, sizeof(data));
if(ret != 0)
printk(“hello misc read failed\n”);

return ret;
}

/*
* file operations
*/
struct file_operations hello_fops = {

.owner = THIS_MODULE,
.write = hello_write,
.read = hello_read,
.open = hello_open,
};

/*
* misc description
*/
struct miscdevice hello_misc = {
.minor = MISC_MINOR,
.name = “hello-misc”,
.fops = &hello_fops,
};

static int hello_init(void)
{
int ret = 0;

printk(” Hello World enter\n”);

ret = misc_register(&hello_misc);
if(ret != 0)
printk(“hello misc register failed!”);

return 0;
}

static void hello_exit(void)
{
printk(” Hello World exit\n “);
misc_deregister(&hello_misc);
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE(“Dual BSD/GPL”);
MODULE_DESCRIPTION(“A simple Hello World Module”);

[orangepi]GPIO-pinctr 操作多个IO

dts
—————————————————————
gpioled{
compatible = “alientek,led”;
pinctrl-names = “alientek,led”;
pinctrl-0 = <&led_gpio>;
ledac = <&gpio3 RK_PD1 GPIO_ACTIVE_LOW>;
ledbc = <&gpio3 RK_PD2 GPIO_ACTIVE_LOW>;
};

pinctr:

led-gpios{
led_gpio: led-pin {
rockchip,pins =
<3 RK_PD1 RK_FUNC_GPIO &pcfg_pull_none>,
<3 RK_PD2 RK_FUNC_GPIO &pcfg_pull_none>;
};
};

—————————————————————————————
驱动
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //#include
#include
#include

#define LEDDEV_CNT 1 /* 设备号长度 */
#define LEDDEV_NAME “dtsplatleda” /* 设备名字 */
#define LEDOFF 0
#define LEDON 1

/* leddev设备结构体 */
struct leddev_dev{
dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
struct device_node *node; /* LED设备节点 */
int gpio_led; /* LED灯GPIO标号 */
};

struct leddev_dev leddev; /* led设备 */

/*
* @description : LED打开/关闭
* @param – sta : LEDON(0) 打开LED,LEDOFF(1) 关闭LED
* @return : 无
*/
void led_switch(u8 sta)
{
if (sta == LEDON )
gpio_set_value(leddev.gpio_led, 1);
else if (sta == LEDOFF)
gpio_set_value(leddev.gpio_led, 0);
}

static int led_gpio_init(struct device_node *nd)
{
int ret;

/* 从设备树中获取GPIO */
leddev.gpio_led = of_get_named_gpio(nd, “ledac”, 0);
printk(“leddev.gpio_led =%d\n”,leddev.gpio_led);

if(!gpio_is_valid(leddev.gpio_led)) {
printk(KERN_ERR “leddev: Failed to get led-gpio\n”);
return -EINVAL;
}

/* 申请使用GPIO */
ret = gpio_request(leddev.gpio_led, “LED”);
if (ret) {
printk(KERN_ERR “led: Failed to request led-gpio\n”);
return ret;
}

/* 将GPIO设置为输出模式并设置GPIO初始电平状态 */
gpio_direction_output(leddev.gpio_led,0);

return 0;
}

/*
* @description : 打开设备
* @param – inode : 传递给驱动的inode
* @param – filp : 设备文件,file结构体有个叫做private_data的成员变量
* 一般在open的时候将private_data指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int led_open(struct inode *inode, struct file *filp)
{
return 0;
}

/*
* @description : 向设备写数据
* @param – filp : 设备文件,表示打开的文件描述符
* @param – buf : 要写给设备写入的数据
* @param – cnt : 要写入的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 写入的字节数,如果为负值,表示写入失败
*/
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
int retvalue;
unsigned char databuf[1];
unsigned char ledstat;

retvalue = copy_from_user(databuf, buf, cnt);
if(retvalue < 0) { printk("kernel write failed!\r\n"); return -EFAULT; } ledstat = databuf[0]; if (ledstat == LEDON) { led_switch(LEDON); } else if (ledstat == LEDOFF) { led_switch(LEDOFF); } return 0; } /* 设备操作函数 */ static struct file_operations led_fops = { .owner = THIS_MODULE, .open = led_open, .write = led_write, }; /* * @description : flatform驱动的probe函数,当驱动与 * 设备匹配以后此函数就会执行 * @param - dev : platform设备 * @return : 0,成功;其他负值,失败 */ static int led_probe(struct platform_device *pdev) { int ret; printk("led driver and device was matched!\r\n"); /* 初始化 LED */ ret = led_gpio_init(pdev->dev.of_node);
if(ret < 0) return ret; /* 1、设置设备号 */ ret = alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME); if(ret < 0) { pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", LEDDEV_NAME, ret); goto free_gpio; } /* 2、初始化cdev */ leddev.cdev.owner = THIS_MODULE; cdev_init(&leddev.cdev, &led_fops); /* 3、添加一个cdev */ ret = cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT); if(ret < 0) goto del_unregister; /* 4、创建类 */ leddev.class = class_create(THIS_MODULE, LEDDEV_NAME); if (IS_ERR(leddev.class)) { goto del_cdev; } /* 5、创建设备 */ leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME); if (IS_ERR(leddev.device)) { goto destroy_class; } return 0; destroy_class: class_destroy(leddev.class); del_cdev: cdev_del(&leddev.cdev); del_unregister: unregister_chrdev_region(leddev.devid, LEDDEV_CNT); free_gpio: gpio_free(leddev.gpio_led); return -EIO; } /* * @description : platform驱动的remove函数 * @param - dev : platform设备 * @return : 0,成功;其他负值,失败 */ static int led_remove(struct platform_device *dev) { gpio_set_value(leddev.gpio_led, 0);/* 卸载驱动的时候关闭LED */ gpio_free(leddev.gpio_led); /* 注销GPIO */ cdev_del(&leddev.cdev); /* 删除cdev */ unregister_chrdev_region(leddev.devid, LEDDEV_CNT); device_destroy(leddev.class, leddev.devid); /* 注销设备 */ class_destroy(leddev.class); /* 注销类 */ return 0; } /* 匹配列表 */ static const struct of_device_id led_of_match[] = { { .compatible = "alientek,led" }, { /* Sentinel */ } }; MODULE_DEVICE_TABLE(of, led_of_match); /* platform驱动结构体 */ static struct platform_driver led_driver = { .driver = { .name = "rk3568-led", /* 驱动名字,用于和设备匹配 */ .of_match_table = led_of_match, /* 设备树匹配表 */ }, .probe = led_probe, .remove = led_remove, }; /* * @description : 驱动模块加载函数 * @param : 无 * @return : 无 */ static int __init leddriver_init(void) { return platform_driver_register(&led_driver); } /* * @description : 驱动模块卸载函数 * @param : 无 * @return : 无 */ static void __exit leddriver_exit(void) { platform_driver_unregister(&led_driver); } module_init(leddriver_init); module_exit(leddriver_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("ALIENTEK"); MODULE_INFO(intree, "Y");