Android 尝试写一份Linux 字符设备驱动

最新推荐文章于 2021-11-16 10:19:52 发布
最新推荐文章于 2021-11-16 10:19:52 发布
阅读量361 收藏 3
点赞数 2
分类专栏： Android 文章标签： android 驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fhaitao900310/article/details/102657691
版权

       从事android工作几年时间，功底不是很深，一直围绕这android系统定制移植开发，慢慢的从应用层接触到framework层，在接触到hal,目前从事的工作wifi驱动相关工作。但是没有系统的学习过驱动知识，现在跟着阳光玻璃杯学习一份驱动的简单实现。

字符设备是指在I/O传输过程中以字符为单位进行传输的设备，如键盘，打印机
字符设备驱动主要做如下3件事：
    1，定义一个结构体static struct file_operations变量，在里面定义一些设备的打开、关闭、读、写、控制函数
    2，在结构体外分别实现结构体中定义的这些函数
    3，向内核中注册或删除驱动模块

static struct file_operations myDriver_fops = {
    .owner=THIS_MODULE,
    .write=myDriver_write,
    .read=myDriver_read,
    .ioctl=myDriver_ioctl,
    .open=myDriver_open,
    .release=myDriver_release,
};
此结构体中规定了驱动程序想应用程序提供的操作接口。
实现write, 从应用程序接收数据送到硬件
static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos){
    .....
    copy_from_user(&myDriver_Buffer[*f_pos], buf, fill_size); //用于把用户态的数据拷到内核态，实现数据的传送
    ....
}

实现read, 从硬件读取数据并交给应用程序
static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos){
    ....
    copy_to_user(buf, &myDriver_Buffer[*f_pos], read_size); //用于实现把内核态的数据拷到用户态下
    ....
}

实现ioctl, 就是为应用程序提供对硬件行为的控制
static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){
    switch(cmd){
        case MYDRV_IOCTL0:
        break;
        case MYDRV_IOCTL1:
        break;

    }
    return 0;
}

实现open, 应用程序打开设备时对设备进行初始化
static int myDriver_open(struct inode *inode, struct file *filp){
    return 0;
}

实现release， 当应用程序关闭设备时处理设备的关闭操作
static int myDriver_release(struct inode * inode, struct file *filp){
    return 0;
}

      实现一个简单的字符设备驱动，功能写一个字符串进去，然后再把他读出来。驱动创建/dev/hello节点，/sys/class/hello/hello/val 设备节点, /proc/hello/hello设备节点。/sys/class/hello/hello/val 主要用于快速测试，/dev/hello才是供我们使用的节点。

一，驱动源码

此份依据阳光玻璃杯的代码修改过，已经在电视机顶盒android 7.1.2版本上测试过。这里也是直接贴出代码，方便日后查看学习

一共含有4个文件,hello.c  hello.h  Kconfig  Makefile,此份驱动没有内置到系统源码下面，是新建了一个文件夹，采用编译链的方式

结构如下：

appkernel
├── hello.c
├── hello.h
├── Kconfig
└── Makefile

 

hello.c

#include<linux/init.h>
#include<linux/module.h>
#include<linux/types.h>
#include<linux/fs.h>
#include<linux/proc_fs.h>
#include<linux/device.h>
#include<linux/sched.h>
#include<linux/errno.h>
#include<linux/fcntl.h>
#include<linux/poll.h>
#include<linux/seq_file.h>
#include<linux/mutex.h>
#include<linux/workqueue.h>
#include<asm/uaccess.h>
#include<linux/slab.h>
#include<linux/kernel.h>

#include "hello.h"

//主设备和从设备号变量
static int hello_major = 0;
static int hello_minor = 0;

//设备类别和设备变量
static struct class* hello_class = NULL;
static struct hello_test_dev* hello_dev = NULL;


//传统的设备文件操作方法
static int hello_open(struct inode* inode, struct file* filp);
static int hello_release(struct inode* inode, struct file* filp);
static ssize_t hello_read(struct file* filp, char __user* buf, size_t count, loff_t* f_pos);
static ssize_t hello_write(struct file* filp, const char __user* buf, size_t count, loff_t* f_pos);
static int hello_create_proc(void);
static void hello_remove_proc(void);
static ssize_t hello_proc_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
static ssize_t hello_proc_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
static int proc_seq_open(struct inode *inode, struct file *file);
/**
 * 设备文件操作方法表
 */
static struct file_operations hello_fops = {
    .owner = THIS_MODULE,
    .open = hello_open,
    .release = hello_release,
    .read = hello_read,
    .write = hello_write,
};


static struct file_operations hello_proc_ops={
    .owner = THIS_MODULE,
    .read = seq_read,
    .write = hello_proc_write,
    .llseek=seq_lseek,
    .release = seq_release,
    .open=proc_seq_open,
};

//访问设置属性方法
static ssize_t hello_val_show(struct device * dev, struct device_attribute* attr, char *buf);
static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char *buf, size_t count);

//定义设备属性
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, hello_val_show, hello_val_store);

/*打开设备方法*/
static int hello_open(struct inode* inode, struct file* filp){
    struct hello_test_dev* dev;

    /*将自定义设备结构体保存在文件指针的私有数据域中，以便访问设备时拿来用*/
    dev = container_of(inode->i_cdev, struct hello_test_dev, dev);
    filp->private_data = dev;

    return 0;
}

//设备文件释放时调用
static int hello_release(struct inode* inode, struct file* filp){
    return 0;
}

//读设备的寄存器val的值
static ssize_t hello_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos){
    ssize_t err = 0;
    struct hello_test_dev* dev = filp->private_data;

    //同步访问
    if(down_interruptible(&(dev->sem))){
        return -ERESTARTSYS;
    }

    if(count < sizeof(dev->val)){
        goto out;
    }

    /*将寄存器val的值拷贝到用户提供的缓冲区*/
    if(copy_to_user(buf, dev->val, sizeof(dev->val))){
        err = -EFAULT;
        goto out;
    }

    err = sizeof(dev->val);
out:
    up(&(dev->sem));

    return err;
}

//写设备的寄存器值val
static ssize_t hello_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos){
    struct hello_test_dev* dev = filp->private_data;
    ssize_t err = 0;
    //同步访问
    if(down_interruptible(&(dev->sem))){
        return -ERESTARTSYS;
    }
	/*将用户提供的缓冲区的值写到设备寄存器去*/
    if(copy_from_user(dev->val, buf, count)){
        err = -EFAULT;
        goto out;
    }

    err = sizeof(dev->val);
out:
    up(&(dev->sem));

    return err;
}

/**
 *  通过devfs文件系统访问方法，把val看成设备的一个属性，通过读写这个属性来对设备进行访问，
 *  主要是实现hello_val_show和hello_val_store两个方法，同时定义了两个内部使用的访问val值的方法__hello_get_val和__hello_set_val：
 */
//读取寄存器val的值到缓冲区buf中，内部使用
static ssize_t __hello_get_val(struct hello_test_dev* dev, char * buf){
    if(down_interruptible(&(dev->sem))){
        return -ERESTARTSYS;
    }


    up(&(dev->sem));

    return snprintf(buf, PAGE_SIZE, "%s\n",dev->val);
}

//写字符串到内存
static ssize_t __hello_set_val(struct hello_test_dev* dev, const char* buf, size_t count){
    if (down_interruptible(&(dev->sem)))
    {
        return -ERESTARTSYS;
    }

    printk(KERN_ALERT"_hello_set_val.buf: %s count:%zu\n", buf, count);
    printk(KERN_ALERT"_hello_set_val.dev->val:%s count:%zu\n",dev->val, count);
    strncpy(dev->val, buf, count);
    printk(KERN_ALERT"_hello_set_val.dev->val:%s count:%zu\n" ,dev->val, count);
    up(&(dev->sem));

    return count;
}

//读取设备属性val
static ssize_t hello_val_show(struct device* dev, struct device_attribute* attr, char * buf){
    struct hello_test_dev * hdev = (struct hello_test_dev*) dev_get_drvdata(dev);
    printk(KERN_ALERT"hello_val_show.\n");
    printk(KERN_ALERT"%s \n", hdev->val);
    return __hello_get_val(hdev,buf);
}

//写设备属性val
static ssize_t hello_val_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count){
    struct hello_test_dev* hdev = (struct hello_test_dev*) dev_get_drvdata(dev);
    printk(KERN_ALERT"hello_val_store.buf:%s count:%zu\n", buf, count);
    
    return __hello_set_val(hdev, buf, count);
}



/**
 * 定义通过proc文件系统访问方法，主要实现了hello_proc_read和hello_proc_write两个方法，
 * 同时定义了在proc文件系统创建和删除文件的方法hello_create_proc和hello_remove_proc
 */
static char *str = NULL;
static void *my_seq_start(struct seq_file *m, loff_t *pos)
{
    if(0== *pos){
        ++*pos;
        return (void *)1;
    }
    return NULL;
}

static void *my_seq_next(struct seq_file *m, void *v, loff_t *pos)
{
    return NULL;
}

static void my_seq_stop(struct seq_file *m, void *v)
{

}

static int my_seq_show(struct seq_file *m, void *v)
{
    seq_printf(m, "current kernel time is %llu\n", (unsigned long long )get_jiffies_64());
    seq_printf(m, "str is %s\n", str);
    return 0;
}

static struct seq_operations my_seq_fops =
{
    .start = my_seq_start,
    .next = my_seq_next,
    .stop = my_seq_stop,
    .show = my_seq_show,
};

static int proc_seq_open(struct inode *inode, struct file *file)
{
    return seq_open(file, &my_seq_fops);
}



//读取设备寄存器val的值，保存在page缓冲区中
static ssize_t hello_proc_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos){
    char * ptr = PDE_DATA(file_inode(filp));
    printk(KERN_ALERT"ptr=%s\n",ptr);
    printk("proc read\n");
    return 0;
}

//把缓冲区的值buff保存到设备寄存器val中去
static ssize_t hello_proc_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos){
    char *temp = kzalloc((len+1), GFP_KERNEL);
    if(!temp) return -ENOMEM;
    printk(KERN_ALERT"proc write\n");

    if(copy_from_user(temp,buf, len)){
        kfree(temp);
        return -EFAULT;
    }

    kfree(str);
    str = temp;

    return len;
}

struct proc_dir_entry *entry = NULL;
struct proc_dir_entry *proc_root = NULL;

//创建 /proc/hello文件
static int hello_create_proc(void){
    char temp[] = "hello test\0";

    proc_root = proc_mkdir("hello", NULL);
    if(proc_root == NULL){
        printk(KERN_ERR"Can't create /proc/hello directory\n");
        return -EFAULT;
    }
    entry = proc_create_data(HELLO_DEVICE_PROC_NAME, S_IRUGO | S_IWUSR | S_IWGRP, proc_root, &hello_proc_ops, &temp);
    if(entry == NULL){
        printk(KERN_ERR"Can't create /proc/hello_dir/hello file\n");
        return -EFAULT;
    }
    return 0;
}

//删除 /proc/hello文件
static void hello_remove_proc(void){
    remove_proc_entry(HELLO_DEVICE_PROC_NAME, proc_root);
}


//初始化设备
static int __hello_setup_dev(struct hello_test_dev* dev){
    int err;
    dev_t devno = MKDEV(hello_major, hello_minor);

    memset(dev, 0, sizeof(struct hello_test_dev));

    cdev_init(&(dev->dev), &hello_fops);
    dev->dev.owner = THIS_MODULE;
    dev->dev.ops = &hello_fops;

    err = cdev_add(&(dev->dev), devno, 1);
    if (err)
    {
        return err;
    }
    
    sema_init(&(dev->sem),10);

    dev->val = kmalloc(20, GFP_KERNEL);
    strncpy(dev->val, "hello", sizeof("hello"));

    return 0;
}


//模块加载方法
static int __init hello_init(void){
    int err = -1;
    dev_t dev = 0;
    struct device* temp = NULL;

    printk(KERN_ALERT"hello_init.\n");


    //动态分配主设备和从设备号
    err = alloc_chrdev_region(&dev, 0, 1, HELLO_DEVICE_NODE_NAME);

    if(err < 0){
        printk(KERN_ALERT"Failed to alloc char dev region.\n");
        goto fail;
    }

    hello_major = MAJOR(dev);
    hello_minor = MINOR(dev);

    //分配hello设备结构体变量
    hello_dev = kmalloc(sizeof(struct hello_test_dev), GFP_KERNEL);
    if(!hello_dev){
        err = -ENOMEM;
        printk(KERN_ALERT"Failed to alloc hello_dev.\n");
        goto unregister;
    }

    //初始化设备
    err = __hello_setup_dev(hello_dev);
    if(err){
        printk(KERN_ALERT"Failed to setup dev:%d\n",err);
        goto cleanup;
    }

    //在/sys/class/目录下创建设备类别目录hello
    hello_class = class_create(THIS_MODULE, HELLO_DEVICE_CLASS_NAME);
    if(IS_ERR(hello_class)){
        err = PTR_ERR(hello_class);
        printk(KERN_ALERT"Failed to create hello class.\n");
        goto destroy_cdev;
    }

    //在/dev 目录和 /sys/cleass/hello 目录下分别创建设备文件hello
    temp = device_create(hello_class, NULL, dev, "%s", HELLO_DEVICE_FILE_NAME);
    if(IS_ERR(temp)){
        err = PTR_ERR(temp);
        printk(KERN_ALERT"Failed to create hello device.\n");
        goto destroy_class;
    }

    //在 /sys/class/hello/hello 目录下创建属性文件val
    err = device_create_file(temp, &dev_attr_val);
    if(err < 0){
        printk(KERN_ALERT"Failed to create attribute val.\n");
        goto destroy_device;
    }

    dev_set_drvdata(temp, hello_dev);

    //创建/proc/hello文件
    hello_create_proc();

    printk(KERN_ALERT"Succedded to initialize hello device.\n");
    return 0;

destroy_device:
    device_destroy(hello_class, dev);
destroy_class:
    class_destroy(hello_class);
destroy_cdev:
    cdev_del(&(hello_dev->dev));
cleanup:
    kfree(hello_dev);
unregister:
    unregister_chrdev_region(MKDEV(hello_major, hello_minor), 1);
fail:
    return err;
}


//模块卸载方法
static void __exit hello_exit(void) {
    dev_t devno = MKDEV(hello_major, hello_minor);
    printk(KERN_ALERT"hello_exit.\n");

    //删除/proc/hello文件
    hello_remove_proc();

    //销毁设备类别和设备
    if(hello_class){
        device_destroy(hello_class, MKDEV(hello_major, hello_minor));
        class_destroy(hello_class);
    }

    //删除字符设备和释放设备内存
    if(hello_dev){
        cdev_del(&(hello_dev->dev));
        kfree(hello_dev);
    }

    if(hello_dev->val != NULL){
        kfree(hello_dev->val);
    }

    //释放设备号
    unregister_chrdev_region(devno, 1);
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Test Driver");

module_init(hello_init);
module_exit(hello_exit);

hello.h

#ifndef _HELLO_TEST_H_
#define _HELLO_ANDROID_H_

#include <linux/cdev.h>
#include <linux/semaphore.h>

#define HELLO_DEVICE_NODE_NAME "hello"
#define HELLO_DEVICE_FILE_NAME "hello"
#define HELLO_DEVICE_CLASS_NAME "hello"
#define HELLO_DEVICE_PROC_NAME "hello"
/*
*定义字符设备结构体
*/
struct hello_test_dev {
    char * val;
    struct semaphore sem; //信号量
    struct cdev dev; //内嵌的字符设备
};

#endif

Kconfig

config HELLO
    tristate "Test Driver"
    default n
    help
    This is the test driver.

Makefile

EXTRA_CFLAGS += -Werror -Wno-unused
EXTRA_CFLAGS += -O1
ARCH:=arm64
CROSS_COMPILE:=aarch64-linux-gnu-
KSRC:=/home/fht/work/chengshi/n-amlogic/out/target/product/p281/obj/KERNEL_OBJ

obj-$(CONFIG_HELLO)+= hello.o
export CONFIG_HELLO = m

all:modules

modules:
	$(MAKE) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) -C $(KSRC) M=$(shell pwd) modules


.PHONY: modules clean

clean:
	$(MAKE) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) -C $(KSRC) M=$(shell pwd) clean

其中 ARCH，CROSS_COMPILE, KSRC 需要根据系统的编译链修改，否则编译出来的ko文件可能导致insmod失败

CROSS_COMPILE 可以使用AOSP/prebuilts/gcc/linux-x86下gcc, KSRC需要先把AOSP整编，然后才能使用对应.config文件

如果有已知kernel的.config文件，可以修改为已知文件的绝对路径

二，编译

以上文件写好后，我们就可以在当前目录下执行make, 编译驱动文件了

hello.c  hello.ko       hello.mod.c  .hello.mod.o.cmd  .hello.o.cmd  Makefile       Module.symvers
hello.h  .hello.ko.cmd  hello.mod.o  hello.o           Kconfig       modules.order  .tmp_versions

hello.ko文件就是我们需要的驱动文件了

三，应用/测试

使用adb push 将hello.ko文件放置到system/lib/modules下，最好是能有已经root过的设备上测试。

adb push hello.ko  system/lib/modules

加载刚刚放置进来的hello.ko

adb shell; cd system/lib/modules;

insmod hello.ko 如果没有报错说明加载没问题，我们可以使用lsmod查看已经加载的驱动列表，Module列是否有名称为hello，有，即说明加载成功

可以看到/dev/hello  /sys/class/hello/hello/val  /proc/hello/hello 文件已经生成

我们进入/sys/class/hello/hello目录下 输入：echo hah > val 看串口打印是否有输出

[230352.249030@2] hello_val_store.buf:haha                                                                     
[230352.249030@2]  count:5                                                                                     
[230352.249803@2] _hello_set_val.buf: haha                                                                     
[230352.249803@2]  count:5                                                                                     
[230352.256572@2] _hello_set_val.dev->val:123                                                                  
[230352.256572@2] oworld count:5                                                                               
[230352.263440@2] _hello_set_val.dev->val:haha                                                                 
[230352.263440@2] world count:5    

以上输出说明已经写入成功，使用命令 cat val 读取刚刚写入的字符串

[230510.445927@0] hello_val_show.                                                                              
[230510.446117@0] haha                                                                                         
[230510.446117@0] world 

看看haha打印出来说明写入是成功的

 四，使用/dev/hello节点写简单程序调用测试

在驱动的同级目录下新建hellotest目录，在目录下新建jni目录,在jni目录下新建Android.mk  Application.mk  hellotest.c 三个文件

hellotest.c  这个文件是用来打开访问/dev/hello文件节点，读写字符串操作

/*#include<stdio.h>

int main(){

    return 0;
}*/

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>

#define HELLO_DEVICE "/dev/hello"

int main(){
    int fd = -1;
    char * str = malloc(20);

    fd = open(HELLO_DEVICE, O_RDWR);
    if (fd == -1)
    {
        printf("Failed to open device %s.\n", HELLO_DEVICE);
        return -1;
    }

    printf("Read original value:\n");

    read(fd, str, 20);

    printf("read data: %s\n", str);
    strncpy(str, "nihao", sizeof("nihao"));
    printf("write %s\n", str);

    write(fd, str, sizeof(str));

    printf("Read the value again:\n");
    read(fd, str, 20);
    printf("read data: %s\n", str);
    close(fd);

    return 0;
}

Android.mk

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CFLAGS := -Wall -Wextra -Werror -Wunused
LOCAL_SRC_FILES := \
    hellotest.c
LOCAL_MODULE := hellotest
include $(BUILD_EXECUTABLE)

Application.mk

APP_ABI := armeabi

以上三个文件创建成功,在该路径下执行ndk-build -B ,编译可执行测试程序

[armeabi] Compile thumb  : hellotest <= hellotest.c
[armeabi] Executable     : hellotest
[armeabi] Install        : hellotest => libs/armeabi/hellotest

将编译出来的libs/armeabi/hellotest可执行程序push到开发板内,

adb push hellotest  /data

修改权限 adb shell ;  chmod 777 /data/hellotest

执行./hellotest

输出

Read original value:
read data: hello
write nihao
Read the value again:
read data: nihao

开始读出hello字串，后面写入nihao ，读出nihao，可见我们测试驱动成功

 

感谢 阳光玻璃杯 https://blog.csdn.net/u011913612/article/details/52516303

冯疯子
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android系统Linux内核与设备驱动
qingfeng5452820的博客
07-05 1693
1.Android系统中Linux内核与设备驱动 2.Android系统上的设备驱动 基本图形用户界面(GUI)部分：包括显示部分、用户输入部分和硬件相关的加速部分，还包括媒体编解码和OpenGL等。 音视频输入输出部分：包括音频、视频输出和摄像头等。 连接部分：包括无线局域网、蓝牙、GPS等。 电话部分：包括通话、GSM等。 附属部件：包括传感器、背光、振动器等。 具体如下： Disp...
Android实现简单字符驱动程序及测试
Javen.tang的专栏
03-05 1145
这看来老罗的Androidzhilv
linux驱动开发之字符设备--自动创建设备节点
Android 系统开发
05-26 1430
mdev在/dev下创建设备的方法有两种，一种是手动的使用 mknod 进行创建。另外一种是使用 mdev 进行自动的创建设备。 mdev集成在busybox中，mdev 会自动检测 /sys/class 和 /sys/block 的所有类设备目录；如果在目录中含有名为“dev”的文件，同时如果内容是设备号的话，mdev 就会利用这些信息，在/dev下创建这个设备节点。
android字符驱动,深入浅出Linux设备驱动之字符设备驱动程序
weixin_39788386的博客
05-25 105
字符设备驱动程序Linux下的设备驱动程序被组织为一组完成不同任务的函数的集合，通过这些函数使得linux的设备操作犹如文件一般。在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作，如open()、close()、read()、write() 等。Linux主要将设备分为二类：字符设备和块设备。字符设备是指设备发送和接收数据以字符的形式进行；而块设备则以整个...
Android自定义设备驱动,Android 6.0中在/dev下添加新设备驱动下Selinux相关设置
weixin_29408705的博客
05-28 200
错误1：07-23 13:06:57.617 117 117 I SystemServer: Freg Service07-23 13:06:57.618 117 117 I FregServiceJNI: Initializing HAL stub freg.....07-23 13:06:57.633 117 117 I FregServiceJNI: Device f...
LINUX设备驱动程序
10-08
在Linux中，设备驱动通常分为字符设备驱动、块设备驱动和网络设备驱动等类型。这些驱动程序允许操作系统执行如读写数据、配置设备参数等操作。 二、ARM架构与6410处理器 ARM（Advanced RISC Machines）架构是一种...
Android底层开发技术实战详解_replied12k_android驱动_android驱动_android_
10-03
"Android底层开发技术实战详解 内核、移植和驱动 (1).pdf"这本书可能涵盖了以上所述的各个方面，通过实例讲解了Android驱动开发的具体步骤和技巧，对于想要深入理解Android系统的工程师来说，是一份宝贵的参考资料。...
金典的老罗的android之旅
05-28
**金典的老罗的android之旅**是一段深入探索Android世界的精彩...无论是入门学习还是进阶提升，都是一份不可多得的宝贵资源。通过深入学习并实践这些知识点，你将能更好地驾驭Android开发，开启属于你的Android之旅。
Android-Development.rar_android
最新发布
09-23
Android 是一款开源的操作系统，由Google公司主导开发并推广，主要用于移动设备，如智能手机和平板电脑。这篇文档旨在为初学者提供一个全面的Android开发入门指南，帮助开发者理解Android的历史、现状以及其核心系统...
Android--kaifa.rar_android
09-20
这个压缩包包含了一份名为"Android应用程序开发宝典.pdf"的详细教程，对于想要深入理解Android系统在硬件层面上的实现以及如何在嵌入式设备上构建和调试应用的开发者来说，是非常有价值的参考资料。 Android作为...
初入android驱动开发之字符设备(一)
mortree
08-04 7803
字符设备的简单心得
基于android8.1(kernel4.4)添加字符设备驱动
yuzhenrong的博客
06-10 690
本文是基于android8.1的rockchip平台添加一个字符型设备驱动，此设备有四个可读写的寄存器，将其命名为virtualio，详细添加步骤如下，具体代码见最后网盘分享 1.kernel drivers目录新建virtualio目录 2.在virtualio目录新建virtualio.h和virtualio.c以及编译需要用到的Kconfig和Makefile文件； 3.在virtualio.h中定义需要用到的数据结构 4.在virtualio中添加设备驱动的相关函数 4.1：定义设备操作函数集
android自启动创建设备节点,android驱动下生成设备节点的方法
weixin_34337678的博客
05-31 675
echo 1 > /sys/devices/platform/s3c2440-i2c.2/i2c-2/2-0055/bqfs_updatestatic ssize_t set_bqfs_update(struct device *dev,struct device_attribute *attr, const char *buf,size_t count){struct bq27410_de...
Android字符设备驱动及应用层从jni控制GPIO实战
qf0727的专栏
10-19 9471
本文主要讲述从实际项目中一个GPIO口控制一个加密芯片上下电的功能，提供动态库给客户，并有Android应用层apk调用.so库文件的例子，希望能为大家入门带来帮助！ 以下描述参考摘录了别人的话：http://koliy.iteye.com/blog/1424304 android应用层要访问驱动，一般有三种方法。  1.应用层 ---> framwork层JNI ---> 驱动c  2.
Android从驱动到应用(2)_添加驱动
业精于勤毁于嬉
08-07 451
上节简单介绍了如何实现一个简单的应用程序，为了更好的理解底层到上层的实现机制，先从第一个驱动开始。 平台: Android o go + kernel 3.18 + MTK android/kernel-3.18/drivers/ ----demo ----demo.c ----demo.h ----Kconfig ----Makefile demo.c实现一个典型的字符设备驱动，及proc节点，...
为android编写linux内核驱动
weixin_39050354的博客
06-16 166
驱动程序的功能主要是向上层提供访问设备的寄存器的值，包括读和写。这里，提供了三种访问设备寄存器的方法，一是通过proc文件系统来访问，二是通过传统的设备文件的方法来访问，三是通过devfs文件系统来访问。 #include #include #include #include #include #include #include #include #i
android 非系统APP访问字符设备
Evan_Lo的专栏
03-16 2129
在默认的selinux规则中, 非系统APP无权访问很多类型的字符设备.         以访问串行设备为例,  修改android/external/sepolicy/device.te。 diff --git a/device.te b/device.te --- a/device.te +++ b/device.te @@ -33,7 +33,7 @@ ty
Android 载入模块驱动文件（装入ko文件）
Android之旅
11-02 3219
1.把文件push到 sdcard/ （也可以u盘拷入系统根目录下）； 2.执行adb shell命令进入目标设备的Linux Shell环境； 3.输入 su 进入root权限； 4.载入模块： insmod sdcard/filename.ko 5.完成 提示：not root ，执行 su 进入root权限； ...
android 驱动移植方法
wr1998的博客
11-16 3892
相信很多驱动初学者对于安卓平台的驱动移植有一些搞不懂。最开始我也是一头雾水。今天就来以一个初学者的角度，讲解一下android驱动移植的方法。 步骤相对比较简单： 1：增加源代码 2：在Kconfig中增加内容 3：在makefile中增加内容 具体来说定义一个虚拟的字符硬件设备该设备名为freg 这个是我们本次进行移植的程序： 首先准备好需要移植驱动的源文件 freg.c 以及freg.h文件。 找到该驱动的归类。比如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值