Linux驱动开发必备:dev_set_drvdata和dev_get_drvdata的5个实战技巧

Linux GPIO驱动开发实战与优化技巧 GPIO(通用输入输出)是嵌入式系统中最基础的硬件接口技术,通过软件控制实现引脚的可编程配置。其核心原理是通过寄存器操作控制引脚的电平状态和工作模式,在Linux内核中由GPIO子系统提供统一抽象层。从技术价值看,GPIO的灵活性使其能够模拟多种通信协议(如I2C),同时支持中断等高级功能,在嵌入式设备控制、传感器数据采集等场景广泛应用。以RK3588等主流SoC平台为例,开发者可以通过gpiolib标准接口操作GPIO,但需注意不同厂商的控制器实现差异。实际开发中涉及GPIO模式配置(输入/输出/中断)、 阅读详情

Linux驱动开发进阶:解锁设备私有数据管理的五个实战心法

在Linux内核驱动的世界里,每个设备实例都像是一个独立的生命体,它们有自己的状态、配置和运行时信息。如何优雅地为这些“生命体”管理其独有的“记忆”,是区分驱动新手与老手的一道分水岭。很多开发者初学时,可能会下意识地使用全局变量或静态变量来存储设备信息,直到遇到需要支持多个相同设备时,才发现代码变得一团糟,实例间的数据相互污染,调试起来苦不堪言。

这正是 dev_set_drvdata 和 dev_get_drvdata 这对内核API存在的核心价值。它们并非什么高深莫测的黑科技,而是内核设备模型为驱动开发者提供的一个标准化、优雅的“挂钩”。通过这个挂钩,你可以将任意一块自定义的内存数据(通常是一个结构体指针)与一个具体的 struct device 对象牢牢绑定。从此,在驱动的任何地方,只要你能拿到这个设备对象,就能随时取回属于它的那份私有数据,实现了完美的数据隔离与实例化管理。

本文将抛开基础定义的赘述,直接切入实战腹地。我们假设你已经知道这两个函数的基本签名,我们将聚焦于五个在真实项目开发中,能显著提升代码质量、避免常见陷阱的进阶技巧。这些技巧关乎内存安全、并发处理、设计模式,以及如何让代码在未来更具适应力。

1. 从内存管理开始:选择正确的分配策略

在 probe 函数中为私有数据分配内存,是使用 dev_set_drvdata 的第一步。这一步的选择,直接决定了后续资源管理的复杂度和安全性。内核提供了多种内存分配函数,我们需要根据场景做出明智决策。

1.1 资源管理分配器:devm_kzalloc 是你的首选

对于绝大多数设备驱动,devm_kzalloc 及其家族函数应是你的默认选择。它的“devm”前缀代表“设备管理资源”(Device Managed Resource)。其核心优势在于,内核会将此次分配的内存与你的设备对象(struct device *dev)的生命周期自动绑定。

static int my_driver_probe(struct platform_device *pdev)
{
    struct my_private_data *priv;

    // 使用 devm_kzalloc 分配并自动清零内存
    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    // 初始化私有数据结构
    priv->irq = platform_get_irq(pdev, 0);
    priv->reg_base = devm_platform_ioremap_resource(pdev, 0);

    // 将私有数据指针关联到设备
    platform_set_drvdata(pdev, priv); // 内部调用 dev_set_drvdata

    // ... 其他初始化操作
    return 0;
}

注意:使用 devm_kzalloc 后,在驱动的 remove 函数中,你无需也不能再调用 kfree 来释放 priv。当设备被卸载或探测失败时,内核的设备核心代码会自动释放所有通过 devm_ 系列函数为该设备分配的资源。这从根本上杜绝了因忘记释放而导致的内存泄漏。

1.2 何时使用传统的 kzalloc?

虽然 devm_kzalloc 非常方便,但在某些特定场景下,你可能仍需使用传统的 kzalloc。

  • 数据生命周期与设备不完全一致:如果你分配的数据需要在设备被移除(remove)之后继续存在一段时间,或者在设备成功探测(probe)之前就需要使用。
  • 复杂的多阶段初始化:内存分配和资源获取可能失败,你需要更精细的清理控制,而不是依赖自动回滚。

使用 kzalloc 时,你必须肩负起手动管理的责任:

static int my_driver_probe(struct platform_device *pdev)
{
    struct my_private_data *priv;

    priv = kzalloc(sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    if (some_init_step_failed(priv)) {
        kfree(priv); // 手动释放
        return -EIO;
    }

    platform_set_drvdata(pdev, priv);
    return 0;
}

static int my_driver_remove(struct platform_device *pdev)
{
    struct my_private_data *priv = platform_get_drvdata(pdev);

    // 执行必要的硬件反初始化...

    kfree(priv); // 必须手动释放!
    return 0;
}

为了清晰地对比这两种策略,我们将其核心差异总结如下:

特性devm_kzallockzalloc
内存释放自动,由设备生命周期管理手动,需在 remove 或错误路径调用 kfree
优点防止内存泄漏,代码简洁提供完全的控制权,生命周期可自定义
缺点生命周期严格绑定设备易因遗忘释放导致泄漏,增加代码复杂度
推荐场景绝大多数设备私有数据分配数据生命周期特殊、需要复杂错误处理的场景

我的个人经验是,在驱动开发的早期就养成使用 devm_kzalloc 的习惯。它能让你的 remove 函数保持清爽,专注于硬件反初始化,而将内存管理的负担交给成熟的内核框架。只有在框架无法满足你的特定需求时,才退回到手动管理。

2. 应对多设备实例:私有数据是隔离的基石

驱动支持多个同类型设备实例是再常见不过的需求。dev_set_drvdata 机制天生就是为这种场景设计的,因为它将数据存储在每个设备对象内部,实现了完美的隔离。

2.1 一个典型的并发探测场景

假设我们有一个控制多个独立LED灯板的平台驱动。每个灯板在设备树中都是一个独立的节点,内核会为每个节点创建一个 platform_device,并依次调用驱动的 probe 函数。

// 私有数据结构,代表一个灯板的状态
struct led_board_data {
    void __iomem *reg_base;
    int led_count;
    struct mutex lock; // 每个实例有自己的锁
    u32 brightness[MAX_LEDS];
};

static int led_board_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct led_board_data *board;
    struct resource *res;
    int ret;

    board = devm_kzalloc(dev, sizeof(*board), GFP_KERNEL);
    if (!board)
        return -ENOMEM;

    // 获取该实例独有的硬件资源(如寄存器地址)
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    board->reg_base = devm_ioremap_resource(dev, res);
    if (IS_ERR(board->reg_base))
        return PTR_ERR(board->reg_base);

    // 从设备树读取该实例特有的属性,比如这个板子有多少个LED
    ret = device_property_read_u32(dev, "num-leds", &board->led_count);
    if (ret) {
        board->led_count = DEFAULT_LED_COUNT; // 默认值
    }

    mutex_init(&board->lock); // 初始化该实例的互斥锁

    // 关键一步:将私有数据绑定到这个特定的pdev上
    platform_set_drvdata(pdev, board);

    // 创建设备文件,sysfs节点等,这些操作会用到board数据
    // 它们现在都只影响当前这个设备实例
    dev_info(dev, "Probed LED board with %d LEDs at %pR\n",
             board->led_count, res);
    return 0;
}

当系统中有两个LED灯板时,内核会调用两次 led_board_probe,每次都会:

  1. 为新的 struct led_board_data 分配内存。
  2. 映射该灯板独有的物理地址空间。
  3. 初始化该灯板独有的互斥锁。
  4. 将这块内存的指针通过 platform_set_drvdata 存入当前正在探测的 pdev->dev 中。

这样,驱动中所有通过 platform_get_drvdata(pdev) 获取到的 board 指针,都严格指向与当前操作上下文(即 pdev)对应的那个灯板的数据。两个灯板的状态、寄存器、锁完全独立,互不干扰。

2.2 在文件操作中正确获取实例数据

当用户空间通过 /dev/ledboardX 设备文件进行操作时,驱动需要知道操作的是哪个实例。这通常通过 file->private_data 或容器宏来实现,而其源头正是设备的私有数据。

static int led_board_open(struct inode *inode, struct file *file)
{
    struct platform_device *pdev;
    struct led_board_data *board;

    // 从inode获取对应的平台设备指针(具体方法取决于你的驱动类型)
    pdev = container_of(inode->i_cdev, struct platform_device, dev);
    // 安全地获取该设备实例的私有数据
    board = platform_get_drvdata(pdev);
    if (!board) {
        return -ENODEV; // 设备可能已被移除
    }

    // 可以将board指针存到file->private_data,方便后续read/write调用使用
    file->private_data = board;
    return 0;
}

static ssize_t led_board_write(struct file *file, const char __user *buf,
                               size_t count, loff_t *ppos)
{
    struct led_board_data *board = file->private_data;
    // 现在board指向的就是打开的那个特定灯板实例的数据
    // 操作board->reg_base只会影响那个具体的硬件
    // ...
    return count;
}

这种模式清晰地将设备实例、其私有数据以及用户空间的操作句柄关联起来,是多实例驱动设计的标准范式。

3. 确保线程安全:私有数据访问的锁策略

dev_get_drvdata 仅仅返回一个指针。如果这个指针指向的数据结构会被多个内核线程(例如,中断处理程序、工作队列、并发的系统调用)访问和修改,那么你必须引入锁机制来保护它。

3.1 将锁嵌入私有数据结构

最直接的方式是将锁作为私有数据结构的一个成员。这样,每个设备实例都拥有自己独立的锁,锁的粒度最细,并发性能最好。

struct my_concurrent_data {
    spinlock_t data_lock; // 用于保护以下数据
    int current_value;
    u32 event_count;
    wait_queue_head_t wait_queue;
    // ... 其他成员
};

static irqreturn_t my_interrupt_handler(int irq, void *dev_id)
{
    struct platform_device *pdev = dev_id;
    struct my_concurrent_data *priv = platform_get_drvdata(pdev);
    unsigned long flags;

    // 使用自旋锁保护中断上下文中的数据访问
    spin_lock_irqsave(&priv->data_lock, flags);
    priv->event_count++;
    // 可能更新 current_value
    spin_unlock_irqrestore(&priv->data_lock, flags);

    // 唤醒可能正在等待事件的进程
    wake_up_interruptible(&priv->wait_queue);
    return IRQ_HANDLED;
}

static ssize_t my_device_read(struct file *file, char __user *buf,
                              size_t count, loff_t *ppos)
{
    struct my_concurrent_data *priv = file->private_data;
    DEFINE_WAIT(wait);
    int ret;

    // 在进程上下文中,我们可以睡眠,使用互斥锁或信号量更合适
    // 但这里为了与中断共享数据,我们仍用自旋锁
    // 或者,可以设计为用原子变量来存储event_count,避免锁。
    // 这里仅为示例。
    spin_lock(&priv->data_lock);
    while (priv->event_count == 0) {
        spin_unlock(&priv->data_lock);
        prepare_to_wait(&priv->wait_queue, &wait, TASK_INTERRUPTIBLE);
        if (signal_pending(current)) {
            finish_wait(&priv->wait_queue, &wait);
            return -ERESTARTSYS;
        }
        schedule();
        finish_wait(&priv->wait_queue, &wait);
        spin_lock(&priv->data_lock);
    }
    // ... 读取数据
    spin_unlock(&priv->data_lock);
    return ret;
}

3.2 锁的选择与注意事项

  • 自旋锁 (spinlock_t):适用于保护在中断上下文或不允许睡眠的原子上下文中访问的数据。等待锁的线程会“自旋”忙等。切忌在持有自旋锁时调用任何可能引发睡眠的函数(如 kmalloc(GFP_KERNEL), copy_from_user)。
  • 互斥锁 (mutex):适用于只在进程上下文中访问的数据。如果获取不到锁,任务会睡眠。它比自旋锁开销大,但更适用于临界区执行时间较长的场景。
  • 读写信号量 (rw_semaphore):如果你的数据结构读多写少,可以考虑使用读写锁来提高并发读的性能。

关键点在于,锁的保护对象是 dev_get_drvdata 返回的指针所指向的内容,而不是获取指针这个动作本身。dev_get_drvdata 本身是原子的、安全的。

4. 超越基础封装:处理复杂设备类型与层次结构

内核为常见总线(如 platform、I2C、PCI、SPI)提供了 xxx_set_drvdata 的封装函数,这主要是为了代码的简洁性和可读性。但在面对复杂驱动,尤其是那些涉及设备树、子设备、或类设备(class)的驱动时,我们需要更深入地理解其本质。

4.1 本质:一切皆归于 struct device

无论 platform_set_drvdata 还是 i2c_set_clientdata,其底层最终调用的都是 dev_set_drvdata(struct device *dev, ...)。理解这一点,能让你在遇到非常规情况时游刃有余。

// 内核源码中的典型实现(简化)
static inline void platform_set_drvdata(struct platform_device *pdev, void *data)
{
    dev_set_drvdata(&pdev->dev, data);
}

static inline void i2c_set_clientdata(const struct i2c_client *client, void *data)
{
    dev_set_drvdata(&client->dev, data);
}

因此,如果你有一个 struct device 指针,即使你不知道它具体来自哪种总线,也可以直接使用 dev_set/get_drvdata。这在编写通用性较强的设备模型辅助函数时很有用。

4.2 场景:管理子设备的私有数据

假设你编写一个“父”驱动,它管理一个核心硬件,并动态创建多个“子”设备(例如,一个多功能芯片驱动为每个功能创建一个独立的子设备)。父驱动需要为每个子设备管理一些状态。

struct child_device_data {
    struct device *child_dev;
    int function_id;
    void *parent_priv; // 指向父设备私有数据的某部分
    // ... 子设备特有数据
};

// 在父驱动的某个函数中,创建子设备并关联数据
static int create_child_device(struct parent_data *parent, int id)
{
    struct child_device_data *child_data;
    struct device *child;

    child = device_create(parent->class, parent->dev, MKDEV(0,0),
                          NULL, "child%d", id);
    if (IS_ERR(child))
        return PTR_ERR(child);

    child_data = devm_kzalloc(parent->dev, sizeof(*child_data), GFP_KERNEL);
    if (!child_data) {
        device_destroy(parent->class, child->devt);
        return -ENOMEM;
    }

    child_data->child_dev = child;
    child_data->function_id = id;
    child_data->parent_priv = &parent->submodule[id];

    // 关键:将子设备数据直接关联到子设备的struct device
    dev_set_drvdata(child, child_data);

    return 0;
}

// 后来,在子设备触发的中断或操作中,可以通过传入的struct device*找到其数据
static void handle_child_event(struct device *child_dev)
{
    struct child_device_data *data = dev_get_drvdata(child_dev);
    // 现在你可以操作这个特定子设备的数据了
    process_function(data->function_id, data->parent_priv);
}

这种模式允许你将复杂的设备树层次关系,清晰地映射到内存中的数据结构层次上。

5. 防御性编程与调试技巧:让代码更健壮

即使理解了原理,在实际编码中,围绕 dev_set_drvdata 和 dev_get_drvdata 仍有一些细微之处需要注意,以避免空指针、生命周期错乱等顽疾。

5.1 在 remove 或 shutdown 中清空指针

这是一个好习惯,可以防止在设备被部分拆除后,某些延迟执行的代码(如定时器回调)通过陈旧的指针访问已释放的内存。

static int my_driver_remove(struct platform_device *pdev)
{
    struct my_private_data *priv = platform_get_drvdata(pdev);

    // 1. 停止所有可能访问priv的异步活动(定时器、工作队列、中断)
    del_timer_sync(&priv->watchdog_timer);
    free_irq(priv->irq, pdev);

    // 2. 执行硬件反初始化...

    // 3. 如果是devm分配,无需kfree。但建议将drvdata置NULL。
    // 如果是kzalloc分配,先kfree,再置NULL。
    // 这里以devm为例:
    platform_set_drvdata(pdev, NULL); // 清空!

    // 注意:对于devm_kzalloc,priv指针本身会在后续被内核自动释放,
    // 但将其从dev中解绑是一个清晰的标志。
    return 0;
}

5.2 在访问前检查指针有效性

任何从 dev_get_drvdata 获取的指针,在解引用前,尤其是在可能并发执行的环境中,都应进行有效性检查。

void some_deferred_work(struct work_struct *work)
{
    struct my_private_data *priv = container_of(work, struct my_private_data, work);
    // 假设这个work是priv结构体的一部分,通过container_of获得priv。

    // 但更安全的模式是,work函数通过设备指针获取priv:
    // struct platform_device *pdev = to_platform_device(some_device_ptr);
    // struct my_private_data *priv = platform_get_drvdata(pdev);

    if (!priv) {
        pr_err("Work queued for a device with no private data!\n");
        return;
    }

    // 进一步检查设备是否仍然“存活”
    if (!priv->device_active) {
        return; // 设备已下线,忽略此次工作
    }

    // ... 安全地操作 priv->...
}

5.3 利用调试工具:CONFIG_DEBUG_DRIVER_DATA

对于深度的调试,可以启用内核配置选项 CONFIG_DEBUG_DRIVER_DATA(如果内核版本支持)。它会为 driver_data 字段增加额外的调试检查,例如在设备生命周期结束后检测是否还有代码试图访问其私有数据,有助于发现生命周期管理相关的Bug。

最后,我想分享一个自己踩过的坑:曾经在一个驱动中,我将一个在模块初始化阶段分配的静态数据结构的地址设置为了 drvdata。这在该驱动只支持一个设备时工作正常。但当后来需要支持多实例时,所有设备实例的 drvdata 都指向了同一块全局内存,导致数据混乱。这个教训让我深刻理解到,dev_set_drvdata 存储的必须是每个设备实例独有的数据指针,通常是在 probe 中动态分配的结果。静态或全局变量的地址,除非经过精心设计(如作为每个实例数据的索引),否则绝不应该直接存入。

Linux内核Pin Controller驱动开发详解 GPIO(通用输入输出)是嵌入式系统中最基础的硬件接口之一,Linux内核通过GPIO子系统和Pin Controller子系统为开发者提供统一的硬件控制接口。Pin Controller驱动作为连接硬件和内核框架的桥梁,主要负责引脚复用、电气特性配置和GPIO控制三大核心功能。在嵌入式Linux开发中,合理使用设备树(Device Tree)描述硬件配置是现代内核开发的标准实践,通过pinctrl-names和pinctrl-0等属性实现多状态管理。以三星S3C2416 SoC为例,其Pin Contro 阅读详情

相关推荐

UART 驱动实战:基于虚拟设备树节点编写 Linux 5.10 虚拟串口驱动

本文详细介绍了在Linux 5.10内核中实现虚拟UART驱动的完整过程,包括设备树节点定义、驱动框架搭建、uart_ops函数集实现以及/proc文件系统交互功能。通过实战案例,开发者可以掌握UART驱动编程方法,为嵌入式系统开发提供有力支持。

ckkay800264的博客 365

关于dev_set_drvdata()和dev_get_drvdata()

内核版本:Linux-4.5 dev_set_drvdata()和dev_get_drvdata()代码如下:static inline void *dev_get_drvdata(const struct device *dev) { return dev->driver_data; } static inline void dev_set_drvdata(struct device

Tracy Mcgrady的专栏 9866

Linux GPIO子系统详解:从设备树配置到驱动开发实战

GPIO(通用输入输出)是嵌入式系统与外部世界交互的基础接口,其核心原理在于通过数字信号控制硬件引脚的电平状态。在复杂的Linux系统中,GPIO子系统通过统一的管理和抽象层,将物理引脚转化为内核可安全调度的标准资源,实现了驱动与硬件的解耦,提升了代码的可移植性和系统的稳定性。这一机制的技术价值在于支持引脚功能动态复用、避免资源冲突,并为调试提供了统一视图。其典型应用场景包括控制LED、读取按键、管理风扇等基础外设。本文聚焦于Linux GPIO子系统的架构解析,深入探讨了基于设备树的现代配置方法、推荐使用

weixin_33824363的博客 408

12.Linux驱动-关于dev_set_drvdata()和dev_get_drvdata()

内核版本:Linux-4.5 dev_set_drvdata()和dev_get_drvdata()代码如下: static inline void *dev_get_drvdata(const struct device *dev) { return dev->driver_data; } static inline void dev_set_drvdata(struct device *dev, void *data) { dev->driver_data = data; } 那么

weixin_43824344的博客 1673

数控弯管机xyz转换ybc的算法_花了一年时间开发的三维弯管机交互式转档软件(三维管子模型UG,SOLIDWORK,PRO/E文件转成YBC)...

在弯管机加工中,由管子模型生成可直接进行弯管加工的YBC数据可以大大提高弯管编程过程.传统的做法是先用dxf数据文件(用autocad绘制管子的轴心线数据)转出XYZ数据,然后由XYZ数据转成YBC数据,而且大部分厂家对文件版本以及软件做管方式都有不少限制,这大大花费了用户的时间跟精力.随着企业的信息化管理以及不断的技术升级,传统用autocad线条模式来描述管子的方式正在被用户用PRO/E,UG...

weixin_29065959的博客 1971

别再一个个BAPI调了!用CVI_EI_INBOUND_MAIN一次性搞定SAP BP主数据(附完整ABAP代码)

本文详细介绍了如何使用SAP标准函数CVI_EI_INBOUND_MAIN高效维护业务伙伴(BP)主数据,替代传统的多BAPI调用方式。通过完整ABAP代码示例,展示了如何一站式处理供应商、客户、公司代码等所有视图的创建与更新,提升数据一致性和开发效率。

weixin_29204205的博客 302

dev_get_drvdata()函数

在Linux Driver的代码中,我们经常看到标题中的函数。那么这个函数究竟如何使用,它的工作原理又是什么?下面,我们来详细看一下这个函数的实现。 driver/base/dd.c  1. void *dev_get_drvdata(const struct device *dev) 2. { 3.      if (dev && dev->p) { 4.          

LinuxEngineer的专栏 1万+

版图提取的spice网表中参数含义及二级效应STI/WPE

寄生电阻、寄生电容可以从版图提出的.sp文件中看, ad area of drain 面积 as area of source pd perimeter of drain 周长,PS PD周长都不计算与栅极接触的部分 ps perimeter of source nrd 漏扩散区等效方块数 nrs 源扩散区等效方块数 sa ...

qq_40007892的博客 6558

dev_get_drvdata()函数解析

dev_get_drvdata()函数解析

weixin_45977113的博客 1020

别再死记硬背了!用MaxDEA软件实操SBM、DDF、NDDF模型,手把手教你测算绿色全要素生产率

本文深度解析如何使用MaxDEA软件实操SBM、DDF、NDDF模型,手把手教你测算绿色全要素生产率(GTFP)。通过详细的模型选择对比、数据准备策略和MaxDEA操作流程,帮助研究者科学构建指标体系并准确解读结果,提升环境管理研究的实证分析能力。

weixin_28731231的博客 318

Ubuntu视频播放器怎么选?VLC、mpv、SMPlayer硬解与字幕配置指南

在Linux系统中,视频播放体验取决于播放器、解码器与显卡驱动的协同。硬件解码通过VA-API或VDPAU将解码任务交给GPU,能显著降低CPU占用,解决4K高码率视频卡顿问题。对于Ubuntu用户,合理配置解码环境与播放器,可流畅播放HEVC、多音轨及ASS特效字幕视频。无论是日常观影、番剧追更还是家庭影院场景,选择合适的播放器并正确启用硬解,都是提升体验的关键。本文围绕Ubuntu平台,详解VLC、mpv、SMPlayer等播放器的安装、硬解配置与常见问题排查,帮助你在Linux上获得流畅的本地视频播放

weixin_33801856的博客 515

Linux驱动开发中的常用接口总结(一)

qq_28576837的博客 496

【C2000系列DSP的Bootloader详解】如何打包源文件为库文件且加密仅授权使用,一步步教你如何实现

如果想要在 TI 的 CCS 开发环境中为 C2000 系列 MCU 生成 lib 库文件,并对这些库文件进行加密保护,确保只有授权方(持有密钥)才能调用和使用,以此保护源代码的知识产权。

昔时扬尘处 178

Linux设备树与platform_driver驱动开发实战:从硬件解耦到可移植设计

在嵌入式Linux开发中,硬件与软件的解耦是提升驱动可移植性和维护性的核心挑战。传统驱动开发常将GPIO编号、中断号等硬件信息硬编码在代码中,导致每更换硬件平台就需修改驱动,效率低下且容易出错。设备树(Device Tree)作为一种硬件描述机制,通过将硬件配置信息从内核代码中剥离,以结构化数据形式在启动时传递给内核,实现了硬件描述的标准化和动态化。结合platform_driver框架,驱动可通过compatible属性与设备树节点自动匹配,并在probe函数中动态解析GPIO等资源,从而构建出与具体硬件

weixin_30642869的博客 491

【AI产品与商业航图】Flux.1 完全开源 AI 绘图模型:本地部署与 ComfyUI 实战指南

Flux.1是一个开源项目,用户可以自由使用和修改,完全免除使用费用。🖥️本地部署支持:与一些依赖云端计算的工具不同,Flux.1支持本地部署,确保用户可以离线使用并自主控制数据隐私。🔄兼容ComfyUI框架:Flux.1可以无缝集成到ComfyUI中,用户可以享受更加简便和直观的操作界面。🎨卓越的图像生成能力:Flux.1能够生成高质量、细腻的图像,支持多种风格与创作主题的切换。💾低硬件要求。

高校图书馆高级系统架构师/研究馆员,推动高校AI从概念演示到可评审、可交付、可运维:路线图与立项评审、PoC交付、评测回归与上线运维(Baseline/Eval/Ops)。 1739

【硬件】LT3763中文手册

1)精确控制输入和输出电流;2) 3000:1真彩色PWM™调光;3) ±1.5%电压调节精度;4) ±6%电流调节精度;5)6V至60 V输入电压范围;6)宽输出范围最高可达55V;7)<2µA关断电流;8)用于负载电流热控制的控制引脚;9)输入和输出电流监控和限制;10)开路、短路和C/10故障检测;11)适用于LED应用的PWM驱动器输出;12)热增强型28引脚FE封装。

qq_39200110的博客 492

Linux VPU驱动开发:从V4L2框架到实战优化

在嵌入式多媒体系统中,视频处理单元(VPU)作为专用协处理器,负责高效的视频编解码与图像处理任务。其核心原理是通过硬件加速卸载CPU负载,实现低功耗、高性能的视频处理。VPU驱动的技术价值在于构建用户空间与硬件间的可靠数据通道,并标准化接口以融入Linux多媒体生态。典型应用场景包括智能摄像头、电视盒子、行车记录仪等需要实时视频处理的设备。本文以Linux V4L2框架为基础,深入解析VPU驱动的架构设计与实现,涵盖DMA-BUF零拷贝、中断处理、状态机管理等关键机制,并通过实战代码展示如何构建稳定高效的编

weixin_34392435的博客 749

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

树莓派Linux驱动开发实战:从GPIO到PWM与红外通信

Linux设备驱动是操作系统内核的核心组件,充当硬件与软件之间的桥梁。其工作原理基于模块化设计,允许动态加载和卸载,无需重新编译内核。在嵌入式开发中,驱动技术的价值在于实现对GPIO、I2C、SPI等硬件接口的精准控制。树莓派作为ARM架构的典型平台,结合设备树机制,为学习Linux驱动开发提供了理想环境。通过GPIO控制LED、按键中断处理、PWM调光以及红外通信等实战案例,开发者可以掌握驱动开发的全流程。这些技能在物联网、智能家居、工业控制等领域具有广泛应用,特别是在树莓派项目开发中,能够有效解决硬件识

weixin_34408717的博客 424

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

Linux GPIO子系统与Pin Controller驱动开发指南

GPIO(通用输入输出)是嵌入式系统中的基础接口,通过引脚复用(Pin Multiplexing)可配置为I2C、SPI等多种外设功能。Linux内核通过GPIO子系统和Pin Control子系统管理硬件资源,其中Pin Controller驱动负责引脚复用配置、电气特性设置等核心功能。在设备树(Device Tree)中,需要明确定义寄存器地址、兼容性字符串等关键属性。开发过程中需关注中断处理、电源管理等进阶主题,通过debugfs可有效排查引脚冲突等问题。以Samsung S3C2416为例,其GPI

weixin_33966095的博客 369

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

深入RK3568 GPIO:从硬件架构到Linux驱动实战

GPIO(通用输入输出)是嵌入式系统与外部世界交互的基础接口,其核心原理是通过控制微控制器引脚的电压电平来实现数字信号的输入与输出。在Linux系统中,GPIO子系统通过gpiolib等抽象层,将硬件差异统一为标准的设备树配置与驱动API,极大地提升了驱动开发的效率与可移植性。对于RK3568这类高性能AIoT SoC,深入理解其GPIO的硬件架构(如Bank/Port划分、复用功能)与内核驱动模型(如gpio_chip、GPIO描述符),是进行可靠外设控制、实现高效中断处理以及优化系统功耗管理的技术基石。

weixin_34174105的博客 389

iMX6Q设备树驱动开发实战指南

设备树(Device Tree)是Linux内核描述硬件配置的核心机制,通过.dts文本文件定义处理器外设、寄存器地址等硬件信息,经编译生成二进制.dtb供内核加载。这种设计实现了硬件描述与内核代码解耦,使同一内核镜像可适配不同硬件平台。在ARM架构特别是iMX6Q等嵌入式处理器中,设备树显著提升了驱动开发效率。开发流程涉及设备树语法解析、驱动匹配机制、资源获取API等关键技术点,典型应用场景包括传感器接入、GPIO控制等嵌入式开发。通过iMX6Q开发板的LED驱动实例,展示了从设备树节点定义到platfo

weixin_30587927的博客 341

Linux驱动开发实战:从内核模块到设备树,手把手编写字符设备驱动

设备驱动程序是操作系统内核与硬件设备之间的核心桥梁,负责将内核的标准操作指令翻译为硬件能识别的具体信号,并管理硬件资源。其核心原理在于通过硬件抽象,为上层应用提供统一的编程接口,同时确保系统的稳定与高效。在嵌入式开发领域,掌握驱动开发技术对于定制硬件适配、性能优化及功能扩展具有极高的工程价值。典型的应用场景包括为定制传感器、通信接口编写驱动,或为新芯片进行内核适配。本文聚焦于Linux字符设备驱动开发,通过实战案例详细拆解了内核模块编译、file_operations结构体使用以及用户空间数据交换等关键环节

weixin_33847182的博客 414

Linux RTC驱动框架深度解析:以RX8025为例,看内核如何抽象硬件时钟操作

本文深入解析Linux RTC驱动框架,以RX8025芯片为例,详细讲解内核如何通过抽象硬件操作实现统一接口。从RTC核心架构到具体驱动实现,涵盖I2C通信、中断处理、温度补偿等关键技术,揭示Linux设备模型的精髓与硬件抽象艺术。

weixin_30565327的博客 426

Linux设备驱动开发实战:从内核模块到字符设备驱动

设备驱动程序是操作系统与硬件之间的核心桥梁,负责将内核的通用操作指令翻译为硬件能识别的具体命令。其核心原理在于通过实现特定的接口(如file_operations)来管理硬件资源,并为上层应用提供统一的访问抽象。这项技术的价值在于实现硬件抽象、资源管理以及功耗性能优化,是嵌入式系统、IoT设备及智能硬件等领域不可或缺的底层技术。在Linux系统中,字符设备驱动是入门的关键,它以内核模块形式存在,通过注册设备号、关联操作集来完成数据流的控制。本文聚焦于Linux设备驱动开发,通过从“Hello World”内

weixin_34238633的博客 322
上一篇: MA5616双模配置指南:如何在同一设备上灵活切换VDSL与ADSL业务模式
下一篇: 智能车竞赛电子证书制作全流程解析:从模板设计到批量生成
gitlab7runner
博客等级 码龄4年 78粉丝 1747原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值