Khadas Docs

Amazing Khadas, always amazes you!

User Tools

Site Tools

Home / products / sbc / edge2 / applications / gpio / spi
products:sbc:edge2:applications:gpio:spi

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
products:sbc:edge2:applications:gpio:spi [2022/12/01 22:28]
ivan 		products:sbc:edge2:applications:gpio:spi [2023/08/13 23:31] (current)
jacobe [Demo Source Code]
Line 3: Line 3:
 ====== Edge2 SPI ====== ====== Edge2 SPI ======
  
 +SPI interface can be founded on [[products:sbc:edge2:applications:gpio:40pin-header|Edge2 16-pin Header]].
  
-{{page>products:sbc:common:applications:gpio:SPI&noheader}}+/* WHY this information was there ????  
 +<WRAP important > 
 +For Edge2, in order to use the UART , you need to attach the IO extension board. 
 +</WRAP> 
 +*/ 
 +===== Reference table ===== 
 + 
 +|           ^  SPI    ^ Pin ^ Pin name ^  GPIO name  ^  GPIO num  ^  DT overlay node  ^  Device node     ^ 
 +^  Edge2    |  SPI1   |  11  |SPI1_MOSI  |  GPIO3_B7  |  111         |    edge2-io-spi    |  /dev/spidev1.0  | 
 +| :::       | :::     |  12  |SPIB_MISO  |  GPIO3_C0  |  112         | :::                | :::              | 
 +| :::       | :::     |  13  |SPIB_CSO   |  GPIO3_C1  |  113         | :::                | :::              | 
 +| :::       | :::     |  14  |SPIB_CLK   |  GPIO3_C2  |  114         | :::                | :::              | 
 + 
 +===== Enable SPI ===== 
 + 
 +In order to use the SPI, you need to enable the SPI function via [[products:sbc:common:configurations:device-tree-overlay|Device Tree Overlay]] 
 + 
 +Edit ''/boot/dtb/rockchip/rk3588s-khadas-edge2.dtb.overlay.env'' to add the SPI node to ''overlays'' node if it doesn't exist. 
 + 
 +To enable ''SPI1'', you need to add ''edge2-io-spi'' node to ''overlays'' node if it doesn't exist. 
 + 
 +```shell 
 +fdt_overlays=edge2-io-spi 
 +``` 
 +<WRAP important > 
 +As SPI pins are also can used for other function, e.g. ''UART7'', ''PWM14'', so that you also need to remove node ''uart7'' and ''pwm14''. 
 +</WRAP> 
 + 
 + 
 +After reboot, you will see the spi device node. 
 +```shell 
 +$ ls /dev/spidev1.0 
 +/dev/spidev1.0 
 +``` 
 + 
 +===== Disable SPI ===== 
 + 
 +If you want to use normal GPIO instead of SPI, you can remove the SPI node in [[products:sbc:common:configurations:device-tree-overlay|Device Tree Overlay]].  
 + 
 + 
 +===== Demo Source Code ===== 
 + 
 +```c spidev_test.c 
 +// SPDX-License-Identifier: GPL-2.0-only 
 +/* 
 + * SPI testing utility (using spidev driver) 
 + * 
 + * Copyright (c) 2007  MontaVista Software, Inc. 
 + * Copyright (c) 2007  Anton Vorontsov <avorontsov@ru.mvista.com> 
 + * 
 + * Cross-compile with cross-gcc -I/path/to/cross-kernel/include 
 + */ 
 + 
 +#include <stdint.h> 
 +#include <unistd.h> 
 +#include <stdio.h> 
 +#include <stdlib.h> 
 +#include <string.h> 
 +#include <getopt.h> 
 +#include <fcntl.h> 
 +#include <time.h> 
 +#include <sys/ioctl.h> 
 +#include <linux/ioctl.h> 
 +#include <sys/stat.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 uint32_t mode; 
 +static uint8_t bits = 8; 
 +static char *input_file; 
 +static char *output_file; 
 +static uint32_t speed = 500000; 
 +static uint16_t delay; 
 +static int verbose; 
 +static int transfer_size; 
 +static int iterations; 
 +static int interval = 5; /* interval in seconds for showing transfer rate */ 
 + 
 +uint8_t default_tx[] = { 
 +    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
 +    0x40, 0x00, 0x00, 0x00, 0x00, 0x95, 
 +    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
 +    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
 +    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
 +    0xF0, 0x0D, 
 +}; 
 + 
 +uint8_t default_rx[ARRAY_SIZE(default_tx)] = {0, }; 
 +char *input_tx; 
 + 
 +static void hex_dump(const void *src, size_t length, size_t line_size, 
 +             char *prefix) 
 +{ 
 +    int i = 0; 
 +    const unsigned char *address = src; 
 +    const unsigned char *line = address; 
 +    unsigned char c; 
 + 
 +    printf("%s | ", prefix); 
 +    while (length-- > 0) { 
 +        printf("%02X ", *address++); 
 +        if (!(++i % line_size) || (length == 0 && i % line_size)) { 
 +            if (length == 0) { 
 +                while (i++ % line_size) 
 +                    printf("__ "); 
 +            } 
 +            printf(" |"); 
 +            while (line < address) { 
 +                c = *line++; 
 +                printf("%c", (c < 32 || c > 126) ? '.' : c); 
 +            } 
 +            printf("|\n"); 
 +            if (length > 0) 
 +                printf("%s | ", prefix); 
 +        } 
 +    } 
 +} 
 + 
 +/* 
 + *  Unescape - process hexadecimal escape character 
 + *      converts shell input "\x23" -> 0x23 
 + */ 
 +static int unescape(char *_dst, char *_src, size_t len) 
 +{ 
 +    int ret = 0; 
 +    int match; 
 +    char *src = _src; 
 +    char *dst = _dst; 
 +    unsigned int ch; 
 + 
 +    while (*src) { 
 +        if (*src == '\\' && *(src+1) == 'x') { 
 +            match = sscanf(src + 2, "%2x", &ch); 
 +            if (!match) 
 +                pabort("malformed input string"); 
 + 
 +            src += 4; 
 +            *dst++ = (unsigned char)ch; 
 +        } else { 
 +            *dst++ = *src++; 
 +        } 
 +        ret++; 
 +    } 
 +    return ret; 
 +} 
 + 
 +static void transfer(int fd, uint8_t const *tx, uint8_t const *rx, size_t len) 
 +{ 
 +    int ret; 
 +    int out_fd; 
 +    struct spi_ioc_transfer tr = { 
 +        .tx_buf = (unsigned long)tx, 
 +        .rx_buf = (unsigned long)rx, 
 +        .len = len, 
 +        .delay_usecs = delay, 
 +        .speed_hz = speed, 
 +        .bits_per_word = bits, 
 +    }; 
 + 
 +    if (mode & SPI_TX_QUAD) 
 +        tr.tx_nbits = 4; 
 +    else if (mode & SPI_TX_DUAL) 
 +        tr.tx_nbits = 2; 
 +    if (mode & SPI_RX_QUAD) 
 +        tr.rx_nbits = 4; 
 +    else if (mode & SPI_RX_DUAL) 
 +        tr.rx_nbits = 2; 
 +    if (!(mode & SPI_LOOP)) { 
 +        if (mode & (SPI_TX_QUAD | SPI_TX_DUAL)) 
 +            tr.rx_buf = 0; 
 +        else if (mode & (SPI_RX_QUAD | SPI_RX_DUAL)) 
 +            tr.tx_buf = 0; 
 +    } 
 + 
 +    ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr); 
 +    if (ret < 1) 
 +        pabort("can't send spi message"); 
 + 
 +    if (verbose) 
 +        hex_dump(tx, len, 32, "TX"); 
 + 
 +    if (output_file) { 
 +        out_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666); 
 +        if (out_fd < 0) 
 +            pabort("could not open output file"); 
 + 
 +        ret = write(out_fd, rx, len); 
 +        if (ret != len) 
 +            pabort("not all bytes written to output file"); 
 + 
 +        close(out_fd); 
 +    } 
 + 
 +    if (verbose) 
 +        hex_dump(rx, len, 32, "RX"); 
 +} 
 +static void print_usage(const char *prog) 
 +{ 
 +    printf("Usage: %s [-DsbdlHOLC3vpNR24SI]\n", prog); 
 +    puts("  -D --device   device to use (default /dev/spidev1.1)\n" 
 +         "  -s --speed    max speed (Hz)\n" 
 +         "  -d --delay    delay (usec)\n" 
 +         "  -b --bpw      bits per word\n" 
 +         "  -i --input    input data from a file (e.g. \"test.bin\")\n" 
 +         "  -o --output   output data to a file (e.g. \"results.bin\")\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" 
 +         "  -v --verbose  Verbose (show tx buffer)\n" 
 +         "  -p            Send data (e.g. \"1234\\xde\\xad\")\n" 
 +         "  -N --no-cs    no chip select\n" 
 +         "  -R --ready    slave pulls low to pause\n" 
 +         "  -2 --dual     dual transfer\n" 
 +         "  -4 --quad     quad transfer\n" 
 +         "  -S --size     transfer size\n" 
 +         "  -I --iter     iterations\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' }, 
 +            { "input",   1, 0, 'i' }, 
 +            { "output",  1, 0, 'o' }, 
 +            { "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' }, 
 +            { "dual",    0, 0, '2' }, 
 +            { "verbose", 0, 0, 'v' }, 
 +            { "quad",    0, 0, '4' }, 
 +            { "size",    1, 0, 'S' }, 
 +            { "iter",    1, 0, 'I' }, 
 +            { NULL, 0, 0, 0 }, 
 +        }; 
 +        int c; 
 + 
 +        c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3NR24p:vS:I:", 
 +                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 'i': 
 +            input_file = optarg; 
 +            break; 
 +        case 'o': 
 +            output_file = 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 'v': 
 +             verbose = 1; 
 +             break; 
 +         case 'R': 
 +             mode |= SPI_READY; 
 +             break; 
 +         case 'p': 
 +             input_tx = optarg; 
 +             break; 
 +         case '2': 
 +             mode |= SPI_TX_DUAL; 
 +             break; 
 +         case '4': 
 +             mode |= SPI_TX_QUAD; 
 +             break; 
 +         case 'S': 
 +             transfer_size = atoi(optarg); 
 +             break; 
 +         case 'I': 
 +             iterations = atoi(optarg); 
 +             break; 
 +         default: 
 +             print_usage(argv[0]); 
 +             break; 
 +         } 
 +     } 
 +     if (mode & SPI_LOOP) { 
 +         if (mode & SPI_TX_DUAL) 
 +             mode |= SPI_RX_DUAL; 
 +         if (mode & SPI_TX_QUAD) 
 +             mode |= SPI_RX_QUAD; 
 +     } 
 + } 
 +  
 + static void transfer_escaped_string(int fd, char *str) 
 + { 
 +     size_t size = strlen(str); 
 +     uint8_t *tx; 
 +     uint8_t *rx; 
 +  
 +     tx = malloc(size); 
 +     if (!tx) 
 +         pabort("can't allocate tx buffer"); 
 +  
 +     rx = malloc(size); 
 +     if (!rx) 
 +         pabort("can't allocate rx buffer"); 
 +  
 +     size = unescape((char *)tx, str, size); 
 +     transfer(fd, tx, rx, size); 
 +     free(rx); 
 +     free(tx); 
 + } 
 + 
 +static void transfer_file(int fd, char *filename) 
 +{ 
 +    ssize_t bytes; 
 +    struct stat sb; 
 +    int tx_fd; 
 +    uint8_t *tx; 
 +    uint8_t *rx; 
 + 
 +    if (stat(filename, &sb) == -1) 
 +        pabort("can't stat input file"); 
 + 
 +    tx_fd = open(filename, O_RDONLY); 
 +    if (tx_fd < 0) 
 +        pabort("can't open input file"); 
 + 
 +    tx = malloc(sb.st_size); 
 +    if (!tx) 
 +        pabort("can't allocate tx buffer"); 
 + 
 +    rx = malloc(sb.st_size); 
 +    if (!rx) 
 +        pabort("can't allocate rx buffer"); 
 + 
 +    bytes = read(tx_fd, tx, sb.st_size); 
 +    if (bytes != sb.st_size) 
 +        pabort("failed to read input file"); 
 + 
 +    transfer(fd, tx, rx, sb.st_size); 
 +    free(rx); 
 +    free(tx); 
 +    close(tx_fd); 
 +} 
 + 
 +static uint64_t _read_count; 
 +static uint64_t _write_count; 
 + 
 +static void show_transfer_rate(void) 
 +{ 
 +    static uint64_t prev_read_count, prev_write_count; 
 +    double rx_rate, tx_rate; 
 + 
 +    rx_rate = ((_read_count - prev_read_count) * 8) / (interval*1000.0); 
 +    tx_rate = ((_write_count - prev_write_count) * 8) / (interval*1000.0); 
 + 
 +    printf("rate: tx %.1fkbps, rx %.1fkbps\n", rx_rate, tx_rate); 
 + 
 +    prev_read_count = _read_count; 
 +    prev_write_count = _write_count; 
 +} 
 + 
 +static void transfer_buf(int fd, int len) 
 +{ 
 +    uint8_t *tx; 
 +    uint8_t *rx; 
 +    int i; 
 + 
 +    tx = malloc(len); 
 +    if (!tx) 
 +        pabort("can't allocate tx buffer"); 
 +    for (i = 0; i < len; i++) 
 +        tx[i] = random(); 
 + 
 +    rx = malloc(len); 
 +    if (!rx) 
 +        pabort("can't allocate rx buffer"); 
 + 
 +    transfer(fd, tx, rx, len); 
 + 
 +    _write_count += len; 
 +    _read_count += len; 
 + 
 +    if (mode & SPI_LOOP) { 
 +        if (memcmp(tx, rx, len)) { 
 +            fprintf(stderr, "transfer error !\n"); 
 +            hex_dump(tx, len, 32, "TX"); 
 +            hex_dump(rx, len, 32, "RX"); 
 +            exit(1); 
 +        } 
 +    } 
 + 
 +    free(rx); 
 +    free(tx); 
 +} 
 +int main(int argc, char *argv[]) 
 +{ 
 +    int ret = 0; 
 +    int fd; 
 + 
 +    parse_opts(argc, argv); 
 + 
 +    fd = open(device, O_RDWR); 
 +    if (fd < 0) 
 +        pabort("can't open device"); 
 + 
 +    /* 
 +     * spi mode 
 +     */ 
 +    ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode); 
 +    if (ret == -1) 
 +        pabort("can't set spi mode"); 
 + 
 +    ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode); 
 +    if (ret == -1) 
 +        pabort("can't get spi mode"); 
 + 
 +    /* 
 +     * bits per word 
 +     */ 
 +    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"); 
 + 
 +    /* 
 +     * max speed hz 
 +     */ 
 +    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 mode: 0x%x\n", mode); 
 +    printf("bits per word: %d\n", bits); 
 +    printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000); 
 + 
 +    if (input_tx && input_file) 
 +        pabort("only one of -p and --input may be selected"); 
 + 
 +    if (input_tx) 
 +        transfer_escaped_string(fd, input_tx); 
 +    else if (input_file) 
 +        transfer_file(fd, input_file); 
 +    else if (transfer_size) { 
 +        struct timespec last_stat; 
 + 
 +        clock_gettime(CLOCK_MONOTONIC, &last_stat); 
 + 
 +        while (iterations-- > 0) { 
 +            struct timespec current; 
 + 
 +            transfer_buf(fd, transfer_size); 
 + 
 +            clock_gettime(CLOCK_MONOTONIC, &current); 
 +            if (current.tv_sec - last_stat.tv_sec > interval) { 
 +                show_transfer_rate(); 
 +                last_stat = current; 
 +            } 
 +        } 
 +        printf("total: tx %.1fKB, rx %.1fKB\n", 
 +               _write_count/1024.0, _read_count/1024.0); 
 +    } else 
 +        transfer(fd, default_tx, default_rx, sizeof(default_tx)); 
 + 
 +    close(fd); 
 + 
 +    return ret; 
 +} 
 + 
 +``` 
 + 
 +Compile test code: 
 + 
 +```shell 
 +$ gcc -o spidev_test spidev_test.c 
 +``` 
 + 
 +===== Test demonstration ===== 
 + 
 +Prepare input text file: 
 + 
 +```shell 
 +$ echo "Amazing Khadas!" > ./spi_in.txt 
 +``` 
 + 
 +Connect PIN11, PIN12 then run ''spidev_test'': 
 + 
 +```shell 
 +$ ./spidev_test -i spi_in.txt -o ./spi_out.txt 
 +spi mode: 0x0 
 +bits per word: 8 
 +max speed: 500000 Hz (500 KHz) 
 +``` 
 + 
 +Check output data: 
 + 
 +```shell 
 +$ cat ./spi_out.txt 
 +Amazing Khadas! 
 +```
Last modified: 2022/12/01 22:28 by ivan

Page Tools

Khadas Site

Khadas Community

Khadas GitHub

Khadas Downloads