I2C_SLAVE ioctl Zweck

Gibt es drei wichtige Methoden der Kommunikation mit i2c-Geräte aus dem userspace.

1. IOCTL I2C_RDWR

Diese Methode ermöglicht eine gleichzeitige Lesen/schreiben und senden Sie eine ununterbrochene Reihenfolge der Meldung. Nicht alle i2c-Geräte unterstützen diese Methode.

Vor Durchführung von i/o mit dieser Methode sollten Sie prüfen, ob das Gerät unterstützt diese Methode mit einem ioctl I2C_FUNCS Betrieb.

Mit dieser Methode, Sie nicht Notwendigkeit der Durchführung einer ioctl I2C_SLAVE Betrieb -- es ist geschehen hinter den kulissen mit den eingebetteten Informationen in den Nachrichten.

2. IOCTL-SMBUS

Diese Methode der i/o ist mächtiger, aber der resultierende code ist Ausführlicher. Diese Methode kann verwendet werden, wenn das Gerät unterstützt nicht die I2C_RDWR Methode.

Mit dieser Methode, Sie tun Notwendigkeit der Durchführung einer ioctl I2C_SLAVE Betrieb (oder, wenn das Gerät beschäftigt ist, eine I2C_SLAVE_FORCE Betrieb).

3. SYSFS-I/O -

Diese Methode verwendet die grundlegende Datei-i/o-system fordert read() und write(). Ununterbrochene sequenzielle Operationen sind nicht möglich mit dieser Methode. Diese Methode kann verwendet werden, wenn das Gerät unterstützt nicht die I2C_RDWR Methode.

Mit dieser Methode, Sie tun Notwendigkeit der Durchführung einer ioctl I2C_SLAVE Betrieb (oder, wenn das Gerät beschäftigt ist, eine I2C_SLAVE_FORCE Betrieb).

Ich kann mir nicht vorstellen, dass es eine situation, wenn diese Methode vorzuziehen wäre, andere, es sei denn, Sie benötigen den chip behandelt zu werden wie eine Datei.

Voll IOCTL Beispiel

Habe ich noch nicht getestet, dieses Beispiel, aber es zeigt den konzeptionellen Fluss des Schreibens auf ein i2c-Gerät.-- automatische Erkennung, ob die ioctl - I2C_RDWR oder smbus-Technik.

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

#include <errno.h>
#include <string.h>

#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>

#define I2C_ADAPTER "/dev/i2c-0"
#define I2C_DEVICE  0x00

int i2c_ioctl_write (int fd, uint8_t dev, uint8_t regaddr, uint16_t *data, size_t size)
{
    int i, j = 0;
    int ret;
    uint8_t *buf;
    //the extra byte is for the regaddr
    size_t buff_size = 1 + size;

    buf = malloc(buff_size);
    if (buf == NULL) {
        return -ENOMEM;
    }

    buf[j ++] = regaddr;
    for (i = 0; i < size /sizeof(uint16_t); i ++) {
        buf[j ++] = (data[i] & 0xff00) >> 8;
        buf[j ++] = data[i] & 0xff;
    }

    struct i2c_msg messages[] = {
        {
            .addr = dev,
            .buf = buf,
            .len = buff_size,
        },
    };

    struct i2c_rdwr_ioctl_data payload = {
        .msgs = messages,
        .nmsgs = sizeof(messages) /sizeof(messages[0]),
    };

    ret = ioctl(fd, I2C_RDWR, &payload);
    if (ret < 0) {
        ret = -errno;
    }

    free (buf);
    return ret;
}

int i2c_ioctl_smbus_write (int fd, uint8_t dev, uint8_t regaddr, uint16_t *data, size_t size)
{
    int i, j = 0;
    int ret;
    uint8_t *buf;

    buf = malloc(size);
    if (buf == NULL) {
        return -ENOMEM;
    }

    for (i = 0; i < size /sizeof(uint16_t); i ++) {
        buf[j ++] = (data[i] & 0xff00) >> 8;
        buf[j ++] = data[i] & 0xff;
    }

    struct i2c_smbus_ioctl_data payload = {
        .read_write = I2C_SMBUS_WRITE,
        .size = I2C_SMBUS_WORD_DATA,
        .command = regaddr,
        .data = (void *) buf,
    };

    ret = ioctl (fd, I2C_SLAVE_FORCE, dev);
    if (ret < 0)
    {
        ret = -errno;
        goto exit;
    }

    ret = ioctl (fd, I2C_SMBUS, &payload);
    if (ret < 0)
    {
        ret = -errno;
        goto exit;
    }

exit:
    free(buf);
    return ret;
}

int i2c_write (int fd, uint8_t dev, uint8_t regaddr, uint16_t *data, size_t size)
{
    unsigned long funcs;

    if (ioctl(fd, I2C_FUNCS, &funcs) < 0) {
        return -errno;
    }

    if (funcs & I2C_FUNC_I2C) {
        return i2c_ioctl_write (fd, dev, regaddr, data, size);
    } else if (funcs & I2C_FUNC_SMBUS_WORD_DATA) {
        return i2c_ioctl_smbus_write (fd, dev, regaddr, data, size);
    } else {
        return -ENOSYS;
    }
}

int parse_args (uint8_t *regaddr, uint16_t *data, size_t size, char *argv[])
{
    char *endptr;
    int i;

    *regaddr = (uint8_t) strtol(argv[1], &endptr, 0);
    if (errno || endptr == argv[1]) {
        return -1;
    }

    for (i = 0; i < size /sizeof(uint16_t); i ++) {
        data[i] = (uint16_t) strtol(argv[i + 2], &endptr, 0);
        if (errno || endptr == argv[i + 2]) {
            return -1;
        }
    }

    return 0;
}

void usage (int argc, char *argv[])
{
    fprintf(stderr, "Usage: %s regaddr data [data]*\n", argv[0]);
    fprintf(stderr, "  regaddr   The 8-bit register address to write to.\n");
    fprintf(stderr, "  data      The 16-bit data to be written.\n");
    exit(-1);
}

int main (int argc, char *argv[])
{
    uint8_t regaddr;
    uint16_t *data;
    size_t size;
    int fd;
    int ret = 0;

    if (argc < 3) {
        usage(argc, argv);
    }

    size = (argc - 2) * sizeof(uint16_t);
    data = malloc(size);
    if (data == NULL) {
        fprintf (stderr, "%s.\n", strerror(ENOMEM));
        return -ENOMEM;
    }

    if (parse_args(&regaddr, data, size, argv) != 0) {
        free(data);
        usage(argc, argv);
    }

    fd = open(I2C_ADAPTER, O_RDWR | O_NONBLOCK);
    ret = i2c_write(fd, I2C_DEVICE, regaddr, data);
    close(fd);

    if (ret) {
        fprintf (stderr, "%s.\n", strerror(-ret));
    }

    free(data);

    return ret;
}

Wenn Sie die read() und write() Methoden aufrufen ioctl mit I2C_SLAVE einmal ist genug. Sie können auch I2C_SLAVE_FORCE wenn sich das Gerät bereits im Einsatz.

Allerdings habe ich noch nicht gefunden, eine konsistente Art und Weise zu Lesen bestimmten Registern für jedes Gerät mithilfe der read()/write() Methoden.