在正点原子imx6ull开发板，移植ov5640到busybox文件系统上

实验平台：正点原子的imx6ull-mini开发板

摄像头：ov5640

屏幕：正点原子的1024*600-rgb-lcd

开发环境：正点原子提供搭建好环境ubuntu镜像

获取驱动

获取正点原子移植好的ov5640驱动，路径：正点原子出厂linux源码/drivers/media/platform/mxc/subdev目录下

新建一个文件夹存放来存放ov5640.c、mx6s_capture.c、ov5640af.h

简单说明一下：ov5640.c用于初始化摄像头配置，mx6s_capture.c用于捕捉画面,ov5640af.h用于配置摄像头自动对焦相关。

修改设备树，在设备树下添加5640相关节点

在imx6ull-alientek-emmc.dts设备树&i2c2下添加5640的设备节点

&i2c2 {
    clock_frequency = <100000>;
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_i2c2>;
    status = "okay";

    codec: wm8960@1a {
        compatible = "wlf,wm8960";
        reg = <0x1a>;
        clocks = <&clks IMX6UL_CLK_SAI2>;
        clock-names = "mclk";
        wlf,shared-lrclk;
    };
    //触摸
    gt9147:gt9147@14 {
    compatible = "goodix,gt9147", "goodix,gt9xx";
    reg = <0x14>;
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_tsc
            &pinctrl_tsc_reset>;
    interrupt-parent = <&gpio1>;
    interrupts = <9 0>;
    reset-gpios = <&gpio5 9 GPIO_ACTIVE_LOW>;
    interrupt-gpios = <&gpio1 9 GPIO_ACTIVE_LOW>;
    status = "okay";
    };
    //5640摄像头
    ov5640: ov5640@3c {
        compatible = "ovti,ov5640";
        reg = <0x3c>;
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_csi1
                        &csi_pwn_rst>;
        clocks = <&clks IMX6UL_CLK_CSI>;
        clock-names = "csi_mclk";
        pwn-gpios = <&gpio1 4 1>;
        rst-gpios = <&gpio1 2 0>;
        csi_id = <0>;
        mclk = <24000000>;
        mclk_source = <0>;
        status = "okay";
        port {
            ov5640_ep: endpoint {
                remote-endpoint = <&csi1_ep>;
            };
        };
    };
}

查看CSI节点，默认是配置了的，没配置的话检查看看

&csi {
    status = "okay";
 
    port {
        csi1_ep: endpoint {
            remote-endpoint = <&ov5640_ep>;
        };
    };
};

添加iomux

      

 pinctrl_csi1: csi1grp { //CSI引脚设置
            fsl,pins = <
                MX6UL_PAD_CSI_MCLK__CSI_MCLK        0x1b088
                MX6UL_PAD_CSI_PIXCLK__CSI_PIXCLK    0x1b088
                MX6UL_PAD_CSI_VSYNC__CSI_VSYNC        0x1b088
                MX6UL_PAD_CSI_HSYNC__CSI_HSYNC        0x1b088
                MX6UL_PAD_CSI_DATA00__CSI_DATA02    0x1b088
                MX6UL_PAD_CSI_DATA01__CSI_DATA03    0x1b088
                MX6UL_PAD_CSI_DATA02__CSI_DATA04    0x1b088
                MX6UL_PAD_CSI_DATA03__CSI_DATA05    0x1b088
                MX6UL_PAD_CSI_DATA04__CSI_DATA06    0x1b088
                MX6UL_PAD_CSI_DATA05__CSI_DATA07    0x1b088
                MX6UL_PAD_CSI_DATA06__CSI_DATA08    0x1b088
                MX6UL_PAD_CSI_DATA07__CSI_DATA09    0x1b088
            >;
        };

 //OV5640电源引脚和reset引脚
 csi_pwn_rst: csi_pwn_rstgrp {
            fsl,pins = <
                MX6UL_PAD_GPIO1_IO02__GPIO1_IO02    0x10b0     /*reset引脚*/
                MX6UL_PAD_GPIO1_IO04__GPIO1_IO04    0x10b0    /*//电源引脚*/
            >;
  };

值得注意的是lcd设备树节点要改成16位的。

至此设备树添加完成。

编译模块

在ov5640的文件夹下新建Makefile，然后输入下面内容准备编译模块，内核路径以自己的实际为准

KERNELDIR := /home/alientek/lzp/tmp/linux-imx-rel_imx_4.1.15_2.1.0_ga
             
CURRENR_PATH := $(shell pwd)
 
obj-m :=ov5640.o mx6s_capture.o
 
build: kernel_modules
 
kernel_modules:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENR_PATH) modules
 
clean:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENR_PATH) clean

应用程序

使用的是正点原子c应用教程里面的v4l2的例程代码

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

 Copyright © ALIENTEK Co., Ltd. 1998-2021. All rights reserved.

 文件名 : v4l2_camera.c

 作者 : 邓涛

 版本 : V1.0

 描述 : V4L2摄像头应用编程实战

 其他 : 无

 论坛 : www.openedv.com

 日志 : 初版 V1.0 2021/7/09 邓涛创建

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



#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/ioctl.h>

#include <string.h>

#include <errno.h>

#include <sys/mman.h>

#include <linux/videodev2.h>

#include <linux/fb.h>



#define FB_DEV              "/dev/fb0"      //LCD设备节点

#define FRAMEBUFFER_COUNT   3               //帧缓冲数量



/*** 摄像头像素格式及其描述信息 ***/

typedef struct camera_format {

    unsigned char description[32];  //字符串描述信息

    unsigned int pixelformat;       //像素格式

} cam_fmt;



/*** 描述一个帧缓冲的信息 ***/

typedef struct cam_buf_info {

    unsigned short *start;      //帧缓冲起始地址

    unsigned long length;       //帧缓冲长度

} cam_buf_info;



static int width;                       //LCD宽度

static int height;                      //LCD高度

static unsigned short *screen_base = NULL;//LCD显存基地址

static int fb_fd = -1;                  //LCD设备文件描述符

static int v4l2_fd = -1;                //摄像头设备文件描述符



static cam_buf_info buf_infos[FRAMEBUFFER_COUNT];

static cam_fmt cam_fmts[10];            

static int frm_width, frm_height;   //视频帧宽度和高度



static int fb_dev_init(void)

{

    struct fb_var_screeninfo fb_var = {0};//分辨率

    struct fb_fix_screeninfo fb_fix = {0};//固定的屏幕信息

    unsigned long screen_size;



    /* 打开framebuffer设备 */

    fb_fd = open(FB_DEV, O_RDWR);

    if (0 > fb_fd) {

        fprintf(stderr, "open error: %s: %s\n", FB_DEV, strerror(errno));

        return -1;

    }



    /* 获取framebuffer设备信息 */

    ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_var);

    ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_fix);



    screen_size = fb_fix.line_length * fb_var.yres;

    width = fb_var.xres;

    height = fb_var.yres;



    /* 内存映射 */

    screen_base = mmap(NULL, screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);

    if (MAP_FAILED == (void *)screen_base) {

        perror("mmap error");

        close(fb_fd);

        return -1;

    }



    /* LCD背景刷白 */

    memset(screen_base, 0xFF, screen_size);

    return 0;

}



static int v4l2_dev_init(const char *device)

{

    struct v4l2_capability cap = {0};



    /* 打开摄像头 */

    v4l2_fd = open(device, O_RDWR);

    if (0 > v4l2_fd) {

        fprintf(stderr, "open error: %s: %s\n", device, strerror(errno));

        return -1;

    }



    /* 查询设备功能 */

    ioctl(v4l2_fd, VIDIOC_QUERYCAP, &cap);



    /* 判断是否是视频采集设备 */

    if (!(V4L2_CAP_VIDEO_CAPTURE & cap.capabilities)) {

        fprintf(stderr, "Error: %s: No capture video device!\n", device);

        close(v4l2_fd);

        return -1;

    }



    return 0;

}



static void v4l2_enum_formats(void)

{

    struct v4l2_fmtdesc fmtdesc = {0};



    /* 枚举摄像头所支持的所有像素格式以及描述信息 */

    fmtdesc.index = 0;

    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FMT, &fmtdesc)) {



        // 将枚举出来的格式以及描述信息存放在数组中

        cam_fmts[fmtdesc.index].pixelformat = fmtdesc.pixelformat;

        strcpy(cam_fmts[fmtdesc.index].description, fmtdesc.description);

        fmtdesc.index++;

    }

}



static void v4l2_print_formats(void)

{

    struct v4l2_frmsizeenum frmsize = {0};

    struct v4l2_frmivalenum frmival = {0};

    int i;



    frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    for (i = 0; cam_fmts[i].pixelformat; i++) {



        printf("format<0x%x>, description<%s>\n", cam_fmts[i].pixelformat,

                    cam_fmts[i].description);



        /* 枚举出摄像头所支持的所有视频采集分辨率 */

        frmsize.index = 0;

        frmsize.pixel_format = cam_fmts[i].pixelformat;

        frmival.pixel_format = cam_fmts[i].pixelformat;

        while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {



            printf("size<%d*%d> ",

                    frmsize.discrete.width,

                    frmsize.discrete.height);

            frmsize.index++;



            /* 获取摄像头视频采集帧率 */

            frmival.index = 0;

            frmival.width = frmsize.discrete.width;

            frmival.height = frmsize.discrete.height;

            while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {



                printf("<%dfps>", frmival.discrete.denominator /

                        frmival.discrete.numerator);

                frmival.index++;

            }

            printf("\n");

        }

        printf("\n");

    }

}



static int v4l2_set_format(void)

{

    struct v4l2_format fmt = {0};

    struct v4l2_streamparm streamparm = {0};



    /* 设置帧格式 */

    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type类型

    fmt.fmt.pix.width = width;  //视频帧宽度

    fmt.fmt.pix.height = height;//视频帧高度

    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;  //像素格式

    if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {

        fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));

        return -1;

    }



    /*** 判断是否已经设置为我们要求的RGB565像素格式

    如果没有设置成功表示该设备不支持RGB565像素格式 */

    if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {

        fprintf(stderr, "Error: the device does not support RGB565 format!\n");

        return -1;

    }



    frm_width = fmt.fmt.pix.width;  //获取实际的帧宽度

    frm_height = fmt.fmt.pix.height;//获取实际的帧高度

    printf("视频帧大小<%d * %d>\n", frm_width, frm_height);



    /* 获取streamparm */

    streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);



    /** 判断是否支持帧率设置 **/

    if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) {

        streamparm.parm.capture.timeperframe.numerator = 1;

        streamparm.parm.capture.timeperframe.denominator = 30;//30fps

        if (0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {

            fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));

            return -1;

        }

    }



    return 0;

}



static int v4l2_init_buffer(void)

{

    struct v4l2_requestbuffers reqbuf = {0};

    struct v4l2_buffer buf = {0};



    /* 申请帧缓冲 */

    reqbuf.count = FRAMEBUFFER_COUNT;       //帧缓冲的数量

    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    reqbuf.memory = V4L2_MEMORY_MMAP;

    if (0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf)) {

        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));

        return -1;

    }



    /* 建立内存映射 */

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    buf.memory = V4L2_MEMORY_MMAP;

    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {



        ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);

        buf_infos[buf.index].length = buf.length;

        buf_infos[buf.index].start = mmap(NULL, buf.length,

                PROT_READ | PROT_WRITE, MAP_SHARED,

                v4l2_fd, buf.m.offset);

        if (MAP_FAILED == buf_infos[buf.index].start) {

            perror("mmap error");

            return -1;

        }

    }



    /* 入队 */

    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {



        if (0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf)) {

            fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));

            return -1;

        }

    }



    return 0;

}



static int v4l2_stream_on(void)

{

    /* 打开摄像头、摄像头开始采集数据 */

    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;



    if (0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type)) {

        fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));

        return -1;

    }



    return 0;

}



static void v4l2_read_data(void)

{

    struct v4l2_buffer buf = {0};

    unsigned short *base;

    unsigned short *start;

    int min_w, min_h;

    int j;



    if (width > frm_width)

        min_w = frm_width;

    else

        min_w = width;

    if (height > frm_height)

        min_h = frm_height;

    else

        min_h = height;



    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    buf.memory = V4L2_MEMORY_MMAP;

    for ( ; ; ) {



        for(buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {



            ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);     //出队

            for (j = 0, base=screen_base, start=buf_infos[buf.index].start;

                        j < min_h; j++) {



                memcpy(base, start, min_w * 2); //RGB565 一个像素占2个字节

                base += width;  //LCD显示指向下一行

                start += frm_width;//指向下一行数据

            }



            // 数据处理完之后、再入队、往复

            ioctl(v4l2_fd, VIDIOC_QBUF, &buf);

        }

    }

}



int main(int argc, char *argv[])

{

    if (2 != argc) {

        fprintf(stderr, "Usage: %s <video_dev>\n", argv[0]);

        exit(EXIT_FAILURE);

    }



    /* 初始化LCD */

    if (fb_dev_init())

        exit(EXIT_FAILURE);



    /* 初始化摄像头 */

    if (v4l2_dev_init(argv[1]))

        exit(EXIT_FAILURE);



    /* 枚举所有格式并打印摄像头支持的分辨率及帧率 */

    v4l2_enum_formats();

    v4l2_print_formats();



    /* 设置格式 */

    if (v4l2_set_format())

        exit(EXIT_FAILURE);



    /* 初始化帧缓冲：申请、内存映射、入队 */

    if (v4l2_init_buffer())

        exit(EXIT_FAILURE);



    /* 开启视频采集 */

    if (v4l2_stream_on())

        exit(EXIT_FAILURE);



    /* 读取数据：出队 */

    v4l2_read_data();       //在函数内循环采集数据、将其显示到LCD屏



    exit(EXIT_SUCCESS);

}

交叉编译成可执行文件，将.ko文件和可执行文件复制到开发板

编译与复制

加载驱动，加载会报1-003c supply DOVDD not found, using dummy regulator供电的警告，这个是正常，不必理会，摄像头是直接用开发板供电。

现象

5640驱动源码链接：ov5640: 简单移植ov5640

大家想了解ov5640驱动里面深层原理，可以参考这个大佬的链接：移植ov5640摄像头到imx6ull开发板（一）_6ull的摄像头驱动-优快云博客