linux sysfs

probe:
ret = sysfs_create_group(&client->dev.kobj, &adv7180_group);
adv7180_dev_class = class_create(THIS_MODULE, "adv7180-dev");

    struct device *dev;
    dev = device_create(adv7180_dev_class, NULL,
        MKDEV(ADV7180_MAJOR, 0),
        NULL,
        "adv7180fs");

static struct class *adv7180_dev_class;

enum {
    MMA_REG_R = 0,
    MMA_REG_W,
    MMA_CMD_MAX
};

static char *command[MMA_CMD_MAX] = {
    [MMA_REG_R] = "readreg",
    [MMA_REG_W] = "writereg",
};

static void parse_arg(const char *arg, int *reg, int *value)
{
    const char *p;

    for (p = arg;; p++) {
        if (*p == ' ' || *p == '\0')
            break;
    }

    p++;

    *reg = simple_strtoul(arg, NULL, 16);
    *value = simple_strtoul(p, NULL, 16);
}

static void cmd_read_reg(const char *arg)
{
    int reg, value, ret;

    parse_arg(arg, &reg, &value);
    ret = adv7180_read(reg);
    dev_info(&adv7180_data.i2c_client->dev, "read reg 0x%x = 0x%x\n", reg, ret);
}

static void cmd_write_reg(const char *arg)
{
    int reg, value, ret;

    parse_arg(arg, &reg, &value);
    ret = adv7180_write_reg(reg, value);
    dev_info(&adv7180_data.i2c_client->dev, "write reg 0x%x = 0x%x result %s\n", reg, value, ret ? "failed" : "success");
}

static int exec_command(const char *buf, size_t count)
{
    const char *p, *s;
    const char *arg;
    int i, value = 0;

    for (p = buf;; p++) {
        if (*p == ' ' || *p == '\0' || p - buf >= count)
            break;
    }
    arg = p + 1;

    for (i = MMA_REG_R; i < MMA_CMD_MAX; i++) {
        s = command[i];
        if (s && !strncmp(buf, s, p - buf)) {
            dev_info(&adv7180_data.i2c_client->dev, "command %s\n", s);
            goto mma_exec_command;
        }
    }

    dev_err(&adv7180_data.i2c_client->dev, "command is not found\n");
    return -1;

mma_exec_command:
    switch (i) {
    case MMA_REG_R:
        cmd_read_reg(arg);
        break;
    case MMA_REG_W:
        cmd_write_reg(arg);
        break;
    default:
        dev_err(&adv7180_data.i2c_client->dev, "command is not found\n");
        break;
    }

    return 0;
}

void adv7180_print_reg(u8 reg)
{
    int val = adv7180_read(reg);
    printk("reg:0x%x   val:0x%x\n", reg, val);
}

static ssize_t show_adv7180regs(struct device *dev,
                struct device_attribute *attr, char *buf)
{
    int ret, reg;

    adv7180_print_reg(0x31);
    adv7180_print_reg(0x32);
    adv7180_print_reg(0x33);
    adv7180_print_reg(0x34);
    adv7180_print_reg(0x35);
    adv7180_print_reg(0x36);
    adv7180_print_reg(0x37);
    adv7180_print_reg(0xe8);
    adv7180_print_reg(0xe9);
    adv7180_print_reg(0xea);

    return 0;
}

static ssize_t write_adv7180regs(struct device *dev,
                 struct device_attribute *attr, const char *buf,
                 size_t count)
{
    exec_command(buf, count);

    return count;
}

static DEVICE_ATTR(adv7180_regs, S_IWUSR | S_IRUGO, show_adv7180regs, write_adv7180regs);

static struct attribute *adv7180_attributes[] = {
    &dev_attr_adv7180_regs.attr,
    NULL
};

static const struct attribute_group adv7180_group = {
    .attrs = adv7180_attributes,
};