FL2440开发板platform_led驱动及应用程序

最新推荐文章于 2024-08-06 17:07:03 发布
最新推荐文章于 2024-08-06 17:07:03 发布
阅读量577 收藏
点赞数
分类专栏： platform_led驱动及应用程序 驱动开发 文章标签： FL2440开发板 platform_led驱动及应用程序 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_x_b/article/details/52088158
版权

     FL2440开发板platform_led驱动及应用程序

驱动程序：

[luxibao@centos ~]$ mkdir platform_LED

[luxibao@centos ~]$ ls

dropbear-0.53.1          fl2440  hello.1  platform_LED  模板  图片  下载  桌面

dropbear-0.53.1.tar.bz2  hello   LED      公共的        视频  文档  音乐

[luxibao@centos ~]$ cd platform_LED

这里用了郭工的代码：

[luxibao@centos platform_LED]$ vim plat_led.c

 

 

/*********************************************************************************

 *      Copyright:  (C) 2011 Guo Wenxue<guowenxue@gmail.com>

 *                  All rights reserved.

 *

 *       Filename:  s3c_led.c

 *    Description:  This is the common LED driver runs on S3C24XX.

 *

 *        Version:  1.0.0(10/27/2011~)

 *         Author:  Guo Wenxue <guowenxue@gmail.com>

 *      ChangeLog:  1, Release initial version on "10/27/2011 11:39:10 AM"

 *

 ********************************************************************************/

#include "s3c_driver.h"

 

#define DRV_AUTHOR                "Guo Wenxue <guowenxue@gmail.com>"

#define DRV_DESC                  "S3C24XX LED driver"

 

/* Driver version*/

#define DRV_MAJOR_VER             1

#define DRV_MINOR_VER             0

#define DRV_REVER_VER             0

 

#define DEV_NAME                  DEV_LED_NAME

 

//#define DEV_MAJOR                 DEV_LED_MAJOR

#ifndef DEV_MAJOR

#define DEV_MAJOR                 0 /*  dynamic major by default */

#endif

 

#define TIMER_TIMEOUT             40

 

static int debug = DISABLE;

static int dev_major = DEV_MAJOR;

static int dev_minor = 0;

 

 

/* ============================ Platform Device part ===============================*/

/*  LED hardware informtation structure*/

struct s3c_led_info

{

    unsigned char           num;              /* The LED number  */

    unsigned int            gpio;             /* Which GPIO the LED used */

    unsigned char           active_level;     /* The GPIO pin level(HIGHLEVEL or LOWLEVEL) to turn on or off  */

    unsigned char           status;           /* Current LED status: OFF/ON */

    unsigned char           blink;            /* Blink or not */

};

 

/*  The LED platform device private data structure */

struct s3c_led_platform_data

{

    struct s3c_led_info    *leds;

    int                     nleds;

};

 

 

/*  LED hardware informtation data*/

static struct s3c_led_info  s3c_leds[] = {

    [0] = {

        .num = 1,

        .gpio = S3C2410_GPB(5),

        .active_level = LOWLEVEL,

        .status = OFF,

        .blink = ENABLE,

    },

    [1] = {

        .num = 2,

        .gpio = S3C2410_GPB(6),

        .active_level = LOWLEVEL,

        .status = OFF,

        .blink = DISABLE,

    },

    [2] = {

        .num = 3,

        .gpio = S3C2410_GPB(8),

        .active_level = LOWLEVEL,

        .status = OFF,

        .blink = DISABLE,

    },

    [3] = {

        .num = 4,

        .gpio = S3C2410_GPB(10),

        .active_level = LOWLEVEL,

        .status = OFF,

        .blink = DISABLE,

    },

};

 

/*  The LED platform device private data */

static struct s3c_led_platform_data s3c_led_data = {

    .leds = s3c_leds,

    .nleds = ARRAY_SIZE(s3c_leds),

};

 

struct led_device

{

    struct s3c_led_platform_data    *data;

    struct cdev                     cdev;

    struct class                    *dev_class;

    struct timer_list               blink_timer;

} led_device;

 

static void platform_led_release(struct device * dev)

{

    int i;

    struct s3c_led_platform_data *pdata = dev->platform_data;

 

    dbg_print("%s():%d\n", __FUNCTION__,__LINE__);

 

    /* Turn all LED off */

    for(i=0; i<pdata->nleds; i++)

    {

         s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);

    }

}

 

static struct platform_device s3c_led_device = {

    .name    = "s3c_led",

    .id      = 1,

    .dev     =

    {

        .platform_data = &s3c_led_data,

        .release = platform_led_release,

    },

};

 

 

 

/* ===================== led device driver part ===========================*/

 

void led_timer_handler(unsigned long data)

{

    int  i;

    struct s3c_led_platform_data *pdata = (struct s3c_led_platform_data *)data;

 

    for(i=0; i<pdata->nleds; i++)

    {

        if(ON == pdata->leds[i].status)

        {

              s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);

        }

        else

        {

              s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);

        }

 

        if(ENABLE == pdata->leds[i].blink )  /* LED should blink */

        {

            /* Switch status between 0 and 1 to turn LED ON or off */

            pdata->leds[i].status = pdata->leds[i].status ^ 0x01;

        }

 

        mod_timer(&(led_device.blink_timer), jiffies + TIMER_TIMEOUT);

    }

}

 

 

static int led_open(struct inode *inode, struct file *file)

{

    struct led_device *pdev ;

    struct s3c_led_platform_data *pdata;

 

    pdev = container_of(inode->i_cdev,struct led_device, cdev);

    pdata = pdev->data;

 

    file->private_data = pdata;

 

    return 0;

}

 

 

static int led_release(struct inode *inode, struct file *file)

{

    return 0;

}

 

static void print_led_help(void)

{

    printk("Follow is the ioctl() command for LED driver:\n");

    printk("Enable Driver debug command: %u\n", SET_DRV_DEBUG);

    printk("Get Driver verion  command : %u\n", GET_DRV_VER);

    printk("Turn LED on command        : %u\n", LED_ON);

    printk("Turn LED off command       : %u\n", LED_OFF);

    printk("Turn LED blink command     : %u\n", LED_BLINK);

}

 

/* compatible with kernel version >=2.6.38*/

static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

{

    struct s3c_led_platform_data *pdata = file->private_data;

 

    switch (cmd)

    {

        case SET_DRV_DEBUG:

            dbg_print("%s driver debug now.\n", DISABLE == arg ? "Disable" : "Enable");

            debug = (0==arg) ? DISABLE : ENABLE;

            break;

        case GET_DRV_VER:

            print_version(DRV_VERSION);

            return DRV_VERSION;

 

        case LED_OFF:

            if(pdata->nleds <= arg)

            {

               printk("LED%ld doesn't exist\n", arg);

               return -ENOTTY;

            }

            pdata->leds[arg].status = OFF;

            pdata->leds[arg].blink = DISABLE;

            break;

 

        case LED_ON:

            if(pdata->nleds <= arg)

            {

               printk("LED%ld doesn't exist\n", arg);

               return -ENOTTY;

            }

            pdata->leds[arg].status = ON;

            pdata->leds[arg].blink = DISABLE;

            break;

 

        case LED_BLINK:

            if(pdata->nleds <= arg)

            {

               printk("LED%ld doesn't exist\n", arg);

               return -ENOTTY;

            }

            pdata->leds[arg].blink = ENABLE;

            pdata->leds[arg].status = ON;

            break;

 

        default:

            dbg_print("%s driver don't support ioctl command=%d\n", DEV_NAME, cmd);

            print_led_help();

            return -EINVAL;

 

    }

    return 0;

}

 

 

static struct file_operations led_fops = {

    .owner = THIS_MODULE,

    .open = led_open,

    .release = led_release,

    .unlocked_ioctl = led_ioctl, /* compatible with kernel version >=2.6.38*/

};

 

 

static int s3c_led_probe(struct platform_device *dev)

{

    struct s3c_led_platform_data *pdata = dev->dev.platform_data;

    int result = 0;

    int i;

    dev_t devno;

 

    /* Initialize the LED status */

    for(i=0; i<pdata->nleds; i++)

    {

         s3c2410_gpio_cfgpin(pdata->leds[i].gpio, S3C2410_GPIO_OUTPUT);

         if(ON == pdata->leds[i].status)

         {

            s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);

         }

         else

         {

            s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);

         }

    }

 

    /*  Alloc the device for driver */

    if (0 != dev_major)

    {

        devno = MKDEV(dev_major, dev_minor);

        result = register_chrdev_region(devno, 1, DEV_NAME);

    }

    else

    {

        result = alloc_chrdev_region(&devno, dev_minor, 1, DEV_NAME);

        dev_major = MAJOR(devno);

    }

 

    /* Alloc for device major failure */

    if (result < 0)

    {

        printk("%s driver can't get major %d\n", DEV_NAME, dev_major);

        return result;

    }

 

    /* Initialize button structure and register cdev*/

    memset(&led_device, 0, sizeof(led_device));

    led_device.data = dev->dev.platform_data;

    cdev_init (&(led_device.cdev), &led_fops);

    led_device.cdev.owner  = THIS_MODULE;

 

    result = cdev_add (&(led_device.cdev), devno , 1);

    if (result)

    {

        printk (KERN_NOTICE "error %d add %s device", result, DEV_NAME);

        goto ERROR;

    }

 

    led_device.dev_class = class_create(THIS_MODULE, DEV_NAME);

    if(IS_ERR(led_device.dev_class))

    {

        printk("%s driver create class failture\n",DEV_NAME);

        result =  -ENOMEM;

        goto ERROR;

    }

 

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)

    device_create(led_device.dev_class, NULL, devno, NULL, DEV_NAME);

#else

    device_create (led_device.dev_class, NULL, devno, DEV_NAME);

#endif

 

    /*  Initial the LED blink timer */

    init_timer(&(led_device.blink_timer));

    led_device.blink_timer.function = led_timer_handler;

    led_device.blink_timer.data = (unsigned long)pdata;

    led_device.blink_timer.expires  = jiffies + TIMER_TIMEOUT;

    add_timer(&(led_device.blink_timer));

 

    printk("S3C %s driver version %d.%d.%d initiliazed.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);

 

    return 0;

 

 

ERROR:

    printk("S3C %s driver version %d.%d.%d install failure.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER);

    cdev_del(&(led_device.cdev));

 

    unregister_chrdev_region(devno, 1);

    return result;

 

}

 

static int s3c_led_remove(struct platform_device *dev)

{

    dev_t devno = MKDEV(dev_major, dev_minor);

 

    del_timer(&(led_device.blink_timer));

 

    cdev_del(&(led_device.cdev));

    device_destroy(led_device.dev_class, devno);

    class_destroy(led_device.dev_class);

 

    unregister_chrdev_region(devno, 1);

    printk("S3C %s driver removed\n", DEV_NAME);

 

    return 0;

}

 

 

static struct platform_driver s3c_led_driver = {

    .probe      = s3c_led_probe,

    .remove     = s3c_led_remove,

    .driver     = {

        .name       = "s3c_led",

        .owner      = THIS_MODULE,

    },

};

 

 

static int __init s3c_led_init(void)

{

   int       ret = 0;

 

   ret = platform_device_register(&s3c_led_device);

   if(ret)

   {

        printk(KERN_ERR "%s:%d: Can't register platform device %d\n", __FUNCTION__,__LINE__, ret);

        goto fail_reg_plat_dev;

   }

   dbg_print("Regist S3C LED Platform Device successfully.\n");

 

   ret = platform_driver_register(&s3c_led_driver);

   if(ret)

   {

        printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__,__LINE__, ret);

        goto fail_reg_plat_drv;

   }

   dbg_print("Regist S3C LED Platform Driver successfully.\n");

 

   return 0;

 

fail_reg_plat_drv:

   platform_driver_unregister(&s3c_led_driver);

fail_reg_plat_dev:

   return ret;

}

 

 

static void s3c_led_exit(void)

{

    dbg_print("%s():%d remove LED platform drvier\n", __FUNCTION__,__LINE__);

    platform_driver_unregister(&s3c_led_driver);

    dbg_print("%s():%d remove LED platform device\n", __FUNCTION__,__LINE__);

    platform_device_unregister(&s3c_led_device);

}

 

module_init(s3c_led_init);

module_exit(s3c_led_exit);

 

module_param(debug, int, S_IRUGO);

module_param(dev_major, int, S_IRUGO);

module_param(dev_minor, int, S_IRUGO);

 

MODULE_AUTHOR(DRV_AUTHOR);

MODULE_DESCRIPTION(DRV_DESC);

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:S3C24XX_led");

 

 

[luxibao@centos platform_LED]$ vim Makefile

obj-m:=plat_led.c

C=/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc

KDIR?=/home/luxibao/fl2440/kernel/linux-3.0

obj-m:=plat_led.o

 

default:

        $(MAKE) -C $(KDIR) M=`pwd` modules

        make clean

 

clean:

        rm -f *.o *mod.c *.order *.symvers

 

[luxibao@centos platform_LED]$ ls

Makefile  plat_ioctl.h  plat_led.c  s3c_driver.h

[luxibao@centos platform_LED]$ make

make -C /home/luxibao/fl2440/kernel/linux-3.0 M=`pwd` modules

make[1]: Entering directory `/home/luxibao/fl2440/kernel/linux-3.0'

  CC [M]  /home/luxibao/platform_LED/plat_led.o

  Building modules, stage 2.

  MODPOST 1 modules

  CC      /home/luxibao/platform_LED/plat_led.mod.o

  LD [M]  /home/luxibao/platform_LED/plat_led.ko

make[1]: Leaving directory `/home/luxibao/fl2440/kernel/linux-3.0'

make clean

make[1]: Entering directory `/home/luxibao/platform_LED'

rm -f *.o *mod.c *.order *.symvers

make[1]: Leaving directory `/home/luxibao/platform_LED'

[luxibao@centos platform_LED]$ ls

Makefile  plat_ioctl.h  plat_led.c  plat_led.ko  s3c_driver.h

应用程序：

 

[luxibao@centos platform_LED]$ mkdir platform_led_test

[luxibao@centos platform_LED]$ ls

Makefile  platform_led_test  plat_ioctl.h  plat_led.c

[luxibao@centos platform_LED]$ cd platform_led_test/

[luxibao@centos platform_led_test]$ vim plat_ioctl.c

 

*********************************************************************************

*       Copyright: (C) 2016 luxibao <864809344@qq.com>

*               All rights reserved.

*

*       Filename: plat_icotl.c

*       Description: This file

*

*       Version: 1.0.0(08/01/2016)

*       Author: luxibao <864809344@qq.com>

*       ChangeLog: 1, Release initial version on "08/01/2016 17:35:23 "

*

********************************************************************************/

#include <stdio.h>

#include <stdarg.h>

#include <fcntl.h>

#include <sys/types.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include <unistd.h>

#include <stdlib.h>

#define PLATDRV_MAGIC   0x60

#define LED_OFF         _IO (PLATDRV_MAGIC, 0x18)

#define LED_ON          _IO (PLATDRV_MAGIC, 0x19)

#define LED_BLINK       _IO (PLATDRV_MAGIC, 0x1A)

#define DEVNAMELEN 10

int main (int argc,char **argv)

{

        int fd;

        fd=open("dev/led",O_RDWR);

        ioctl(fd,LED_ON,0);

        ioctl(fd,LED_ON,1);

        ioctl(fd,LED_BLINK,2);

        ioctl(fd,LED_BLINK,3);

        close(fd);

        return 0;

}

 

[luxibao@centos platform_led_test]$ /opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-gcc plat_ioctl.c

[luxibao@centos platform_led_test]$ ls

a.out  plat_ioctl.c

 

 

 

在开发板上的操作：

>: tftp -gr plat_led.ko 192.168.1.2

plat_led.ko          100% |*******************************|  8827   0:00:00 ETA

>: tftp -gr a.out 192.168.1.2

a.out                100% |*******************************|  5137   0:00:00 ETA

>: chmod 777 a.out

>: chmod 777 plat_led.ko

>: insmod plat_led.ko

S3C led driver version 1.0.0 initiliazed.

>: mknod /dev/led0 c 251 0

>: mknod /dev/led1 c 251 1

>: mknod /dev/led2 c 251 2

>: mknod /dev/led3 c 251 3

>: ls -l dev/led*

crw-rw----    1 root     root      251,   0 Dec 31 17:02 dev/led

crw-r--r--    1 root     root      251,   0 Dec 31 17:02 dev/led0

crw-r--r--    1 root     root      251,   1 Dec 31 17:02 dev/led1

crw-r--r--    1 root     root      251,   2 Dec 31 17:02 dev/led2

crw-r--r--    1 root     root      251,   3 Dec 31 17:02 dev/led3

>: ll a.out

-rwxrwxrwx    1 root     root          5137 Dec 31 17:00 a.out

>: chmod 777 a.out

>:./a.out

此时你就会看到led0,led1,led2是稳定红灯，led3是一闪一闪的红灯.

 

 遇到的问题：


1.make时缺少文件：

 


 解决：加载文件：



 

 

 

 

L_x_b
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
控制fl2440开发板led灯亮灭，蜂鸣器发声
lj627889343的专栏
03-27 3714
led灯亮灭，蜂鸣器发声是通过设置相应寄存器的值来控制的，主要有GPBCON、GPBDAT、GPBUP等，GPBCON有GPB0-10，每一个GPBi设置不同的值来表示输入输出等，设置GPBDAT的每一位表示高低电平，GPBUP设置GPBi是否有效，通过对这三个寄存器的设置则可实现led灯和蜂鸣器。 下面有一个简单的程序： 实现led灯轮流亮灭，led.c： #define GPBCON (
FL2440开发板 platform_led驱动及应用程序
LYX_WIN
07-28 904
FL2440开发板 platform_led驱动及应用程序 驱动程序： [leiyuxing@centos6 platform_led]$ ls plat_led.c [leiyuxing@centos6 platform_led]$ vim plat_led.c /*********************************************************
Linux下基于fl2440开发板platform按键驱动详解（一）
qicheng777的博客
04-18 519
=============================================== 操作系统：center os 64位 平台：fl2440 内核版本：Linux 3.0.54 交叉编译器版本：2012.08 =============================================== #include "s3c_driver.h"
linux驱动开发fl2440开发板按键驱动
LYX_WIN
07-30 959
linux驱动开发fl2440开发板按键驱动 [leiyuxing@centos6 input_kbd]$ ls kbd_device.c kbd_driver.c event_button.c kbd_driver.h Makefile 驱动相关头文件kbd_driver.h: /************************************************
platform_led驱动
hongfuhaocomon的博客
10-27 223
驱动程序： [hongfuhao@centos6 platform_led]$ ls plat_led. [hongfuhao@centos6 platform_led]$ vim plat_led.c [cpp] view plain copy  print? /*************************************
linuxfl2440开发板驱动开发之按键驱动
L_x_b的博客
08-02 695
linuxfl2440开发板驱动开发之按键驱动 [luxibao@centos ~]$ mkdir input_kbd [luxibao@centos input_kbd]$ ls event_button.c  kbd_device.c  kbd_driver.c  kbd_driver.h  Makefile 驱动相关头文件kbd_driver.h:   /**********
Linux下基于Platform总线led驱动学习（一）
qicheng777的博客
04-07 830
=============================================== 操作系统：center os 64位 平台：fl2440 内核版本：Linux 3.0.54 交叉编译器版本：2012.08 ===============================================        通常情况下，Linux设备和驱动通常
platform之led驱动分析及测试程序
樊茂林的博客
04-07 1127
什么是paltform总线： 一个现实的linux设备和驱动通常都需要挂接在一种总线上，比较常见的总线有USB、PCI总线等。但是，在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设却不依附与此类总线。基于这样的背景下，2.6内核加入了platform虚拟总线。platform机制将设备本身的资源注册进内核，有内核统一管理，在驱动程序使用这些资源时使用统一的接口，这
fl2440 platform 按键驱动的制作和测试
luliteng的博客
05-07 335
在led驱动的基础上，继续学习按键驱动 Makefile   1   2 obj-m := s3c_button.o   3 KERNEL_DIR := ~/fl2440/kernel/linux-3.0.54/    4 PWD := $(shell pwd)   5 all:   6     make -C $(KERNEL_DIR) SUBDIRS=$(PWD) modules
触摸屏驱动_触摸屏驱动程序_S3C2440开发板_percentd1d_pick68y_
09-28
5. **事件报告**：最后，驱动程序将解析后的触摸事件报告给操作系统，例如Linux内核的input子系统，以便应用程序可以响应用户的触摸操作。 在学习和开发S3C2440触摸屏驱动时，开发者可能会遇到各种挑战，比如兼容性...
adc_driver.tar.gz_2440 远程控制_2440开发板_远程控制
09-24
标签"2440_远程控制 2440开发板 远程控制"进一步强调了主题的重点，即2440开发板上的远程控制功能。 在压缩包的文件名称列表中，只有一个条目"adc_driver"，这可能是一个包含ADC驱动源代码、编译脚本或者其他相关...
led_6818开发板led_6818_嵌入式led点灯_
10-01
6818开发板是一个专门为初学者和专业人士设计的平台，用于学习和实现嵌入式系统控制，特别是与LED显示相关的应用。通过这次实践，你将了解基本的硬件接口、编程概念以及如何将源代码编译和烧录到开发板上。 首先，...
s3c2440开发板-led灯驱动程序编写过程图文演示
09-28
在本文中，我们将深入探讨如何为S3C2440开发板编写LED灯驱动程序。S3C2440是一款广泛应用的ARM9处理器，常用于嵌入式系统设计，而LED驱动则是嵌入式系统中最基础且重要的部分之一。通过图文教程，初学者可以清晰地...
开发板USB转串口CH340驱动_ch341ser开发板_开发板驱动_
10-03
4. **调试工具**：例如串口终端软件，帮助用户查看和发送串行数据，这对于调试硬件和应用程序非常有用。 总的来说，这个压缩包对单片机开发者，尤其是初学者来说，是一个宝贵的资源。它提供了实现USB到串口通信的...
RK3568笔记四十九：W25Q64驱动开发（硬件SPI1)
07-31 1462
串行外设接口 (Serial Peripheral interface) 简称 SPI，是一种高速的，全双工，同步的通信总线，并 且在芯片的管脚上只占用四根线，节约了芯片的管脚。而W25Q64是常见的串行闪存器件，W25Q64将8M字节的容量分为128个块，每个块大小为64K字节，每个块又分为16个扇区，每个扇区4K个字节。W25Q64的最小擦除单位为一个扇区，也就是每次必须擦除4K个字节。所以，这需要给W25Q64开辟一个至少4K的缓存区，这样必须要求芯片有4K以上的SRAM才能有很好的操作。
Linux驱动开发—设备树分析：GPIO，中断，时钟信息，CPU信息
weixin_46999174的博客
08-06 620
这段设备树描述了一个含有两个簇（Cluster）的多核系统，其中第一个簇包含四个Cortex-A53 CPU核心，第二个簇包含两个Cortex-A72 CPU核心。每个CPU节点包含兼容性、寄存器地址、启用方法、时钟、操作点等属性。还定义了两个二级缓存节点，并描述了系统的空闲状态。这样，操作系统可以根据设备树信息正确地初始化和管理各个CPU核心及其相关硬件。在驱动开发过程中，不需要过多关注如何在设备树中编写时钟信息，而是更应该关注如何在驱动代码中获取和解析这些时钟信息。
深入Linux设备驱动开发：字符设备与块设备编程
ddcajdkdl的博客
08-06 296
•块设备（Block Devices）：数据传输以固定大小的数据块进行，如硬盘、SSD等存储设备。块设备驱动主要涉及请求队列处理、I/O调度等，通常需要实现queue_command(在较旧的内核中) 或request_queue(新内核中)相关的函数，以及支持缓冲和DMA传输。深入Linux设备驱动开发，特别是字符设备与块设备的编程，是一个技术性很强的领域。•利用Linux设备模型框架，通过platform_device、PCI或USB等总线接口注册设备，增强驱动的通用性和可移植性。
Linux驱动开发—设备树描述引脚复用 Pinmux 与Pinctrl
最新发布
weixin_46999174的博客
08-06 684
Pinmux，或 Pin Multiplexer，是一种在电子电路设计中使用的技术，用于在一个芯片上多路复用（共享）引脚的功能。通过 pinmux，可以将一个引脚配置为多种功能，例如 GPIO（通用输入输出）、UART（通用异步收发传输器）、I2C（集成电路间总线）、SPI（串行外设接口）等。这样可以在有限的引脚资源下实现更多的功能，增加芯片的灵活性和可扩展性。pinmux 广泛应用于嵌入式系统设计、微控制器、系统级芯片（SoC）等领域，特别是在需要实现多种外设功能且引脚资源有限的情况下。
飞凌FL2440开发板使用指南V4.0
"FL2440使用手册是飞凌嵌入式技术有限公司为用户提供的一份详尽的开发板操作指南，涵盖了硬件介绍、基础使用方法、Linux和WinCE系统的说明，以及如何更新开发板程序等内容。该手册适用于基于三星S3C2440A ARM9处理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值