spidev imx8 spi flash

已于 2022-10-09 15:39:52 修改
阅读量652 收藏 3
点赞数
分类专栏： linux 文章标签： arm linux spidev
于 2022-10-09 10:55:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wowocpp/article/details/127222825
版权

spidev
spidev

1

https://blog.youkuaiyun.com/weixin_44498318/article/details/126563975

linux/spi/spidev.h
#include <linux/spi/spidev.h>
static const char *device = “/dev/spidev1.0”;

        puts("  -D --device   device to use (default /dev/spidev1.0)\n"
                        "  -s --speed    max speed (Hz)\n"
                        "  -d --delay    delay (usec)\n"
                        "  -b --bpw      bits per word \n"
                        "  -l --loop     loopback\n"
                        "  -H --cpha     clock phase\n"
                        "  -O --cpol     clock polarity\n"
                        "  -L --lsb      least significant bit first\n"
                        "  -C --cs-high  chip select active high\n"
                        "  -3 --3wire    SI/SO signals shared\n");

11

forlinx@ubuntu:~/work/OK8MP-linux-sdk$ find . -name "*spidev*"
./rootfs_ext/usr/include/linux/spi/spidev.h
./OK8MP-linux-fs/small_rootfs/usr/bin/fltest_spidev_test
./OK8MP-linux-fs/rootfs/usr/bin/fltest_spidev_test
./OK8MP-linux-kernel/include/uapi/linux/spi/spidev.h
./OK8MP-linux-kernel/include/config/spi/spidev.h
./OK8MP-linux-kernel/drivers/spi/.spidev.o.cmd
./OK8MP-linux-kernel/drivers/spi/spidev.c
./OK8MP-linux-kernel/drivers/spi/spidev.o
./OK8MP-linux-kernel/arch/x86/platform/intel-mid/device_libs/platform_mrfld_spidev.c
./OK8MP-linux-kernel/tools/spi/spidev_test.c
./OK8MP-linux-kernel/tools/spi/spidev_fdx.c
./OK8MP-linux-kernel/Documentation/spi/spidev.rst
./appsrc/forlinx-cmd/spitest/spidev_test.c
./appsrc/forlinx-cmd/spitest/spidev_test.o
./appsrc/forlinx-cmd/spitest/fltest_spidev_test
./appsrc/forlinx-cmd/spitestA/fltest_spidev_spiflash
./appsrc/forlinx-cmd/spitestA/spidev_test.c
./appsrc/forlinx-cmd/spitestA/spidev_test.o

mode
spi的四种工作模式
Mode 0 CPOL=0, CPHA=0 —>对应到这里 0b00
Mode 1 CPOL=0, CPHA=1 —>对应到这里 0b01
Mode 2 CPOL=1, CPHA=0 —>对应到这里 0b10
Mode 3 CPOL=1, CPHA=1 —>对应到这里 0b11
https://blog.youkuaiyun.com/weixin_34382392/article/details/106597462

2、spidev驱动已定义参数(arg)

SPI_MODE_0//SCLK空闲时为低电平，第一个时间沿采样

SPI_MODE_1//SCLK空闲时为高电平，第一个时间沿采样

SPI_MODE_2//SCLK空闲时为低电平，第二个时间沿采样

SPI_MODE_3//SCLK空闲时为高电平，第二个时间沿采样

SPI_CS_HIGH//片选为高

SPI_LSB_FIRST//低位数据先传输

SPI_3WIRE//三线式，输入输出数据线为一条线

SPI_LOOP//回环模式

SPI_NO_CS//没有片选信号

3、常用端口参数设置

A、设置或读取SPI工作模式：

cmd：SPI_IOC_RD_MODE / SPI_IOC_WR_MODE

arg: uint32_t *mode

eg:

mode = mode | SPI_MODE_0 | SPI_LSB_FIRST | SPI_LOOP;

ioctl(fd, SPI_IOC_RD_MODE, &mode);

ioctl(fd, SPI_IOC_WR_MODE, &mode);

B、设置或读取SPI字节读写方向：从低到高 or 从高到低

cmd：SPI_IOC_RD_LSB_FIRST / SPI_IOC_WR_LSB_FIRST

arg：uint32_t *mode = SPI_LSB_FIRST

eg：

ioctl(fd, SPI_IOC_RD_LSB_FIRST, &mode);

ioctl(fd, SPI_IOC_WR_LSB_FIRST, &mode);

C、设置或读写SPI每字节读写的位数

cmd：SPI_IOC_RD_BITS_PER_WORD / SPI_IOC_WR_BITS_PER_WORD

arg：uint8_t bits = 8;

eg：

ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);

ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);

D、设置或读取SPI速率

cmd：SPI_IOC_RD_MAX_SPEED_HZ / SPI_IOC_WR_MAX_SPEED_HZ

arg：uint32_t speed = 500000;//单位：Hz

eg：

ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);

ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);复杂的数据通信：

cmd：SPI_IOC_MESSAGE

在这里插入图片描述

1

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

static void pabort(const char *s)
{
        perror(s);
        abort();
}

static const char *device = "/dev/spidev1.0";
static uint8_t mode;
static uint8_t transfer_mode;
static uint8_t bits = 8;
static uint32_t speed = 500000;
static uint16_t delay;

static void transfer(int fd)
{
        int ret;
        uint8_t tx[] = {
                0x90, 0x00, 0x00, 0x00,0x00,0x00
        };
        uint8_t rx[ARRAY_SIZE(tx)] = {0, };
        struct spi_ioc_transfer tr = {
                .tx_buf = (unsigned long)tx,
                .rx_buf = (unsigned long)rx,
                .len = ARRAY_SIZE(tx),
                .delay_usecs = delay,
                .speed_hz = speed,
                .bits_per_word = bits,
        };

        ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
        if (ret < 1)
                pabort("can't send spi message");

        for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {
                if (!(ret % 6))
                        puts("");
                printf("%.2X ", rx[ret]);
        }
        puts("");
}

static void print_usage(const char *prog)
{
        printf("Usage: %s [-DsbdlHOLC3]\n", prog);
        puts("  -D --device   device to use (default /dev/spidev1.0)\n"
                        "  -s --speed    max speed (Hz)\n"
                        "  -d --delay    delay (usec)\n"
                        "  -b --bpw      bits per word \n"
                        "  -l --loop     loopback\n"
                        "  -H --cpha     clock phase\n"
                        "  -O --cpol     clock polarity\n"
                        "  -L --lsb      least significant bit first\n"
                        "  -C --cs-high  chip select active high\n"
                        "  -3 --3wire    SI/SO signals shared\n");
        exit(1);
}

static void parse_opts(int argc, char *argv[])
{
        while (1) {
                static const struct option lopts[] = {
                        { "device",  1, 0, 'D' },
                        { "speed",   1, 0, 's' },
                        { "delay",   1, 0, 'd' },
                        { "bpw",     1, 0, 'b' },
                        { "loop",    0, 0, 'l' },
                        { "cpha",    0, 0, 'H' },
                        { "cpol",    0, 0, 'O' },
                        { "lsb",     0, 0, 'L' },
                        { "cs-high", 0, 0, 'C' },
                        { "3wire",   0, 0, '3' },
                        { "no-cs",   0, 0, 'N' },
                        { "ready",   0, 0, 'R' },
                        { NULL, 0, 0, 0 },
                };
                int c;

                c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);

                if (c == -1)
                        break;

                switch (c) {
                        case 'D':
                                device = optarg;
                                break;
                        case 's':
                                speed = atoi(optarg);
                                break;
                        case 'd':
                                delay = atoi(optarg);
                                break;
                        case 'b':
                                bits = atoi(optarg);
                                break;
                        case 'l':
                                mode |= SPI_LOOP;
                                break;
                        case 'H':
                                mode |= SPI_CPHA;
                                break;
                        case 'O':
                                mode |= SPI_CPOL;
                                break;
                        case 'L':
                                mode |= SPI_LSB_FIRST;
                                break;
                        case 'C':
                                mode |= SPI_CS_HIGH;
                                break;
                        case '3':
                                mode |= SPI_3WIRE;
                                break;
                        case 'N':
                                mode |= SPI_NO_CS;
                                break;
                        case 'R':
                                mode |= SPI_READY;
                                break;
                        default:
                                print_usage(argv[0]);
                                break;
                }
        }
}

int main(int argc, char *argv[])
{
        int ret = 0;
        int fd;

        printf("begin to test the dock of the spi flash\n");

        if ((argc == 2) && ((strstr(argv[1], "help") != NULL) || argv[1] == '?')) {
        print_usage(argv[0]);
    }

        parse_opts(argc, argv);

        fd = open(device, O_RDWR);
        if (fd < 0)
                pabort("can't open device");

        printf("spi flash SPI_IOC_WR_MODE mode=%d\n",mode);

        /*
         * spi mode
         */
        ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
        if (ret == -1)
                pabort("can't set spi mode");




        ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
        if (ret == -1)
                pabort("can't get spi mode");



        printf("spi flash SPI_IOC_RD_MODE mode=%d\n",mode);
        /*
         * bits per word
         */

        printf("spi flash SPI_IOC_WR_BITS_PER_WORD bits=%d\n",bits);

        ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
        if (ret == -1)
                pabort("can't set bits per word");



        ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
        if (ret == -1)
                pabort("can't get bits per word");

        printf("spi flash SPI_IOC_RD_BITS_PER_WORD bits=%d\n",bits);
        /*
         * max speed hz
         */

        printf("spi flash SPI_IOC_WR_MAX_SPEED_HZ speed=%d\n",speed);

        ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
        if (ret == -1)
                pabort("can't set max speed hz");



        ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
        if (ret == -1)
                pabort("can't get max speed hz");

        printf("spi flash SPI_IOC_RD_MAX_SPEED_HZ speed=%d\n",speed);



        ret = ioctl(fd, SPI_IOC_RD_LSB_FIRST, &transfer_mode);
        if (ret == -1)
                pabort("can't get transfer mode lsb or msb ");

        printf("spi transfer_mode lsb or msb: %d\n", transfer_mode);



        printf("spi mode: %d\n", mode);
        printf("bits per word: %d\n", bits);
        printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);

        transfer(fd);

        close(fd);

        return ret;
}

运行代码：

root@OK8MP:~# ./fltest_spidev_spiflash
begin to test the dock of the spi flash
spi flash SPI_IOC_WR_MODE mode=0
spi flash SPI_IOC_RD_MODE mode=0
spi flash SPI_IOC_WR_BITS_PER_WORD bits=8
spi flash SPI_IOC_RD_BITS_PER_WORD bits=8
spi flash SPI_IOC_WR_MAX_SPEED_HZ speed=500000
spi flash SPI_IOC_RD_MAX_SPEED_HZ speed=500000
spi transfer_mode lsb or msb: 0
spi mode: 0
bits per word: 8
max speed: 500000 Hz (500 KHz)

00 00 00 00 51 14

参考链接:
https://blog.youkuaiyun.com/wowocpp/article/details/79786309
在这里插入图片描述

代码位置:
/home/forlinx/work/OK8MP-linux-sdk/appsrc/forlinx-cmd/spitestA

imx8mqevk （yocto）检验spi接口（ecspi2）。入行linux不久，要验证板卡预留的spi接口是否可用，检验完成后记录。
m0_65236130的博客
12-17 914
imx8mqevk （yocto）检验spi接口（ecspi2）。
【IMX6ULL驱动开发学习】11.Linux之SPI驱动
阿龙的博客
08-25 1534
Linux之SPI驱动
Linux spi驱动分析(三)----spiddev分析
辉辉308
03-18 6454
本文作为SPI驱动分析的第三部分，主要讲述了spiddev，包括： 1、驱动分析。 2、应用层测试程序分析。
SPI驱动(四) -- 万能驱动spidev.c分析
最新发布
zpz979994367的博客
03-08 639
本文介绍分析了万能驱动spidev.c。
NXP iMX8X M4核心SPI开发
toradexsh的博客
09-09 1298
By Toradex胡珊逢 Colibri iMX8X计算机模块上的处理器具有Cortex-A35和Cortex-M4F。在 A35上运行Linux操作系统，M4F通常运行一个实时擦操作系统例如FreeRTOS。NXP的MCUxpresso SDK提供了Cortex-M4F例程，能够帮助用户进行开发。但在MCUxpresso SDK中只提供了少量的外设操作演示，本文将介绍如何修改配置文件，并调用FreeRTOS API创建一个SPI例程，驱动SPI接口的...
linux驱动 8. SPI驱动
StevenYang2008的博客
06-11 865
0.简介 SPI也是嵌入式设备经常用到的一种总线，它采用主从架构，也可以全双工通讯。今天我们来分析一下SPI在linux中的驱动。 software：linux 4.14.98 hardware: imx8 和I2C驱动有些类似。SPI的驱动大致可以分为三部分。 1.SPI设备驱动部分 2.SPI核心层部分 3.SPI控制器驱动部分 摘录网络上面一张图，如下图所示 1.SPI控制器驱动 在这里先分析一下SPI控制器驱动给，下面看代码。 FILE:drivers/spi/spi-imx.c static S
spidev
夏中伟的博客
11-01 2996
参考：spidev官网一、安装下载安装包tar –zxvf spidev-3.2.tar.gz cd spidev-3.2 sudo python3 setup.py install 二、api介绍1.打开spi设备bus=0 device=0 spi=SPI.SpiDev(bus,device) 打开spi设备， 设备名/dev/spidev-bus.device此处设备为/dev/spi-de
linux 下标准spi操作程序
11-13
在给定的文件中，我们看到了`imx6ull_mtd_flash_test.c`，这可能是一个针对IMX6ULL处理器的SPI Flash测试程序，它会利用spidev进行读写操作。 描述中提到"通过linux的spidev方式进行spi通信"，这是Linux SPI编程的...
Linux标准SPI操作与SPI Flash读写测试程序详解
它通过spidev接口实现对SPI Flash的读写测试。 - 包括初始化Flash、擦除、编程、读取等操作的实现。 #### 3. imx6ull_mtd_block_api.c - 此文件提供了针对块设备操作的API，因为SPI Flash通常作为块设备使用。 - ...
linux spidev 应用_Linux系统自带spi驱动加载及应用程序编写方法详解
weixin_31004409的博客
01-27 2315
硬件平台：飞思卡尔IMX6，内核版本：kernel3.0.35Linux系统中，和I2C一样，SPI也有系统自带的设备驱动程序，位于源码目录下drivers/spi/spidev.c，以下为驱动的移植和对应应用程序编写方法驱动代码移植要将此设备驱动加入到内核中，要做两件事情第一：将此驱动编译进内核步骤：make menuconfigDevice Drivers ->SPI support -...
imx6 nand Flash 启动
辉为科技
05-21 6190
U-Boot 2014.04 (May 04 2016 - 09:00:06) CPU:   Freescale i.MX6DL rev1.2 at 792 MHz CPU:   Temperature 28 C, calibration data: 0x59250469 Reset cause: POR Board: MX6-SabreSD I2C:   ready DRAM:
spidev-test 程序
06-05
SPI测试程序，包含修改过编译bug的源码，以及相关头文件。博客：https://blog.youkuaiyun.com/wxxgoodjob/article/details/80583566
SPI FLASH测试程序
11-03
SPI FLASH 测试程序 ，可以测试spi flash SPI FLASH test program
spidev_test代码
06-14
嵌入式开发板spidev测试程序，源码经过测试，欢迎下载
IMX8QXP SPI CS片选连续传输模式
TSZ0000的博客
07-01 1118
在开发项目中，换了一个spi安全芯片，发现不能进行通信，查看spi信号波形，时钟，发送数据，片选都是正常的，但没有回复数据。安全芯片技术正常通过查看CS片选波形信号，提出CS片选信号不能在每个字节数据传输完成后拉高，需要整个数据传输完成后才能拉高。查看之前的spi驱动，是安全芯片模块厂商提供的，说明spi驱动有改动过，没有使用IMX8QXP的LPSPI驱动。
IMX8QM使能LPSPI驱动
weixin_43186792的博客
12-16 1456
目录前言开发环境开始移植添加device节点信息添加spi的pinctrl节点信息使能lpspi2节点与linux自带驱动验证完 前言 对于NXP的IMX系列处理器，IIC、SPI等驱动是由设备树进行控制的。用户可以通过手动修改设备树的方式，添加自己的SPI设备驱动，然后编写设备驱动程序，当驱动加载时，其会匹配设备树中的驱动节点，如果与设备树中节点的“compatible”相符，则加载，并且在“/dev”路径下，生成对应的用户设备驱动节点。 当然，这里说明的只是标准情况下的开发方式，用户明确知道SPI设备的
SPI 访问 FLASH (w25q128fv)
热门推荐
菜鸟程序猿
09-14 1万+
2018.9.14 本篇是关于SPI 访问 FLASH的         SPI 访问 FLASH的代码写完了很久一直没有去写这篇笔记，今天简单记录一下以免以后忘记。         我这里用到了 SPI的控制器 来进行数据的通信 然后观看FLASH的数据手册发现SPI对FLASH进行访问大致分这样一些步骤：         在读FLASH的情况下 如图所示是读的操作 command这...
imx8mm QSPI烧录及启动
Tim.Wang的博客
06-28 1113
1.https://community.nxp.com/docs/DOC-343777 0110xxxxxx 0010000010 2. FB: ucmd echo “start flash spi by tim” FB: ucmd sf probe ${spi_bus} FB[-t 60000]: ucmd sf erase 0 +0x100000 FB: ucmd setenv fastboot_buffer ${loadaddr} FB: ucmd setenv spi_uboot 0x0 FB
spidev相关
DD'Notes
04-23 210
spidev相关背景有时候会发现，一些外挂的spi的flash或者外设用了spidev这个驱动，没有适配特定的驱动，到底spidev是个啥呢？链接: https://notes.z-dd.online/2023/04/17/spidev%E7%9B%B8%E5%85%B3/有时候会发现，一些外挂的spi的flash或者外设用了spidev这个驱动，没有适配特定的驱动，到底spidev是个啥呢？商业转载请联系作者获得授权，非商业转载请注明出处。spidev相关 | DD'Notes。
IMX8芯片GPIO配置教程
- **imx8**：首先需要了解的是“imx8”指的是NXP半导体公司生产的一系列高性能、低功耗的应用处理器，属于i.MX系列中的高端产品。i.MX8系列芯片采用了先进的64位多核架构，具有良好的图像和视频处理能力，适合于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值