diff options
-rw-r--r-- | common/ratp/Kconfig | 15 | ||||
-rw-r--r-- | common/ratp/Makefile | 2 | ||||
-rw-r--r-- | common/ratp/getenv.c | 12 | ||||
-rw-r--r-- | common/ratp/gpio.c | 144 | ||||
-rw-r--r-- | common/ratp/i2c.c | 284 | ||||
-rw-r--r-- | common/ratp/md.c | 24 | ||||
-rw-r--r-- | common/ratp/mw.c | 24 | ||||
-rw-r--r-- | common/ratp/reset.c | 10 | ||||
-rw-r--r-- | include/ratp_bb.h | 10 | ||||
-rw-r--r-- | scripts/remote/controller.py | 60 | ||||
-rw-r--r-- | scripts/remote/main.py | 74 | ||||
-rw-r--r-- | scripts/remote/messages.py | 179 |
12 files changed, 806 insertions, 32 deletions
diff --git a/common/ratp/Kconfig b/common/ratp/Kconfig index 07d1f53da7..25c931b978 100644 --- a/common/ratp/Kconfig +++ b/common/ratp/Kconfig @@ -13,3 +13,18 @@ config CONSOLE_RATP this option adds a machine readable interface for controlling barebox. Say yes here if you want to control barebox from a remote host. +config RATP_CMD_I2C + bool + depends on RATP + depends on I2C + prompt "RATP i2c support" + help + This option adds support for i2c read/write commands via RATP. + +config RATP_CMD_GPIO + bool + depends on RATP + depends on GENERIC_GPIO + prompt "RATP GPIO support" + help + This option adds support for GPIO get/set/direction commands via RATP.
\ No newline at end of file diff --git a/common/ratp/Makefile b/common/ratp/Makefile index 2c6d674f61..71288bcb8c 100644 --- a/common/ratp/Makefile +++ b/common/ratp/Makefile @@ -4,3 +4,5 @@ obj-y += getenv.o obj-y += md.o obj-y += mw.o obj-y += reset.o +obj-$(CONFIG_RATP_CMD_I2C) += i2c.o +obj-$(CONFIG_RATP_CMD_GPIO) += gpio.o diff --git a/common/ratp/getenv.c b/common/ratp/getenv.c index b409634886..fdb4b0b282 100644 --- a/common/ratp/getenv.c +++ b/common/ratp/getenv.c @@ -27,20 +27,20 @@ static int ratp_cmd_getenv(const struct ratp_bb *req, int req_len, struct ratp_bb **rsp, int *rsp_len) { - int dlen = req_len - sizeof (struct ratp_bb); + int dlen = req_len - sizeof(struct ratp_bb); char *varname; const char *value; - varname = xstrndup ((const char *)req->data, dlen); - value = getenv (varname); - free (varname); + varname = xstrndup((const char *)req->data, dlen); + value = getenv(varname); + free(varname); - dlen = strlen (value); + dlen = strlen(value); *rsp_len = sizeof(struct ratp_bb) + dlen; *rsp = xzalloc(*rsp_len); (*rsp)->type = cpu_to_be16(BB_RATP_TYPE_GETENV_RETURN); - memcpy ((*rsp)->data, value, dlen); + memcpy((*rsp)->data, value, dlen); return 0; } diff --git a/common/ratp/gpio.c b/common/ratp/gpio.c new file mode 100644 index 0000000000..d2c527a40c --- /dev/null +++ b/common/ratp/gpio.c @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2018 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix + * Copyright (c) 2018 Zodiac Inflight Innovations + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#define pr_fmt(fmt) "barebox-ratp: gpio: " fmt + +#include <common.h> +#include <ratp_bb.h> +#include <malloc.h> +#include <environment.h> +#include <gpio.h> +#include <errno.h> + +struct ratp_bb_gpio_get_value_request { + struct ratp_bb header; + uint32_t gpio; +} __packed; + +struct ratp_bb_gpio_get_value_response { + struct ratp_bb header; + uint8_t value; +} __packed; + +static int ratp_cmd_gpio_get_value(const struct ratp_bb *req, int req_len, + struct ratp_bb **rsp, int *rsp_len) +{ + struct ratp_bb_gpio_get_value_request *gpio_req = (struct ratp_bb_gpio_get_value_request *)req; + struct ratp_bb_gpio_get_value_response *gpio_rsp; + int gpio_rsp_len; + + if (req_len < sizeof(*gpio_req)) { + pr_err("get value request ignored: size mismatch (%d < %zu)\n", req_len, sizeof(*gpio_req)); + return 2; + } + + gpio_rsp_len = sizeof(struct ratp_bb_gpio_get_value_response); + gpio_rsp = xzalloc(gpio_rsp_len); + gpio_rsp->header.type = cpu_to_be16(BB_RATP_TYPE_GPIO_GET_VALUE_RETURN); + gpio_rsp->value = !!gpio_get_value(be32_to_cpu(gpio_req->gpio)); + + *rsp_len = gpio_rsp_len; + *rsp = (struct ratp_bb *)gpio_rsp; + return 0; +} + +BAREBOX_RATP_CMD_START(GPIO_GET_VALUE) + .request_id = BB_RATP_TYPE_GPIO_GET_VALUE, + .response_id = BB_RATP_TYPE_GPIO_GET_VALUE_RETURN, + .cmd = ratp_cmd_gpio_get_value +BAREBOX_RATP_CMD_END + + +struct ratp_bb_gpio_set_value_request { + struct ratp_bb header; + uint32_t gpio; + uint8_t value; +} __packed; + +static int ratp_cmd_gpio_set_value(const struct ratp_bb *req, int req_len, + struct ratp_bb **rsp, int *rsp_len) +{ + struct ratp_bb_gpio_set_value_request *gpio_req = (struct ratp_bb_gpio_set_value_request *)req; + + if (req_len < sizeof(*gpio_req)) { + pr_err("set value request ignored: size mismatch (%d < %zu)\n", req_len, sizeof(*gpio_req)); + return 2; + } + + gpio_set_value(be32_to_cpu(gpio_req->gpio), gpio_req->value); + + *rsp_len = sizeof(struct ratp_bb); + *rsp = xzalloc(*rsp_len); + (*rsp)->type = cpu_to_be16(BB_RATP_TYPE_GPIO_SET_VALUE_RETURN); + return 0; +} + +BAREBOX_RATP_CMD_START(GPIO_SET_VALUE) + .request_id = BB_RATP_TYPE_GPIO_SET_VALUE, + .response_id = BB_RATP_TYPE_GPIO_SET_VALUE_RETURN, + .cmd = ratp_cmd_gpio_set_value +BAREBOX_RATP_CMD_END + + +struct ratp_bb_gpio_set_direction_request { + struct ratp_bb header; + uint32_t gpio; + uint8_t direction; /* 0: input, 1: output */ + uint8_t value; /* applicable only if direction output */ +} __packed; + +struct ratp_bb_gpio_set_direction_response { + struct ratp_bb header; + uint32_t errno; +} __packed; + +static int ratp_cmd_gpio_set_direction(const struct ratp_bb *req, int req_len, + struct ratp_bb **rsp, int *rsp_len) +{ + struct ratp_bb_gpio_set_direction_request *gpio_req = (struct ratp_bb_gpio_set_direction_request *)req; + struct ratp_bb_gpio_set_direction_response *gpio_rsp; + int gpio_rsp_len; + uint32_t gpio; + int ret; + + if (req_len < sizeof(*gpio_req)) { + pr_err("set direction request ignored: size mismatch (%d < %zu)\n", req_len, sizeof(*gpio_req)); + return 2; + } + + gpio = be32_to_cpu(gpio_req->gpio); + if (gpio_req->direction) + ret = gpio_direction_output(gpio, gpio_req->value); + else + ret = gpio_direction_input(gpio); + + gpio_rsp_len = sizeof(struct ratp_bb_gpio_set_direction_response); + gpio_rsp = xzalloc(gpio_rsp_len); + gpio_rsp->header.type = cpu_to_be16(BB_RATP_TYPE_GPIO_SET_DIRECTION_RETURN); + gpio_rsp->errno = (ret == 0 ? 0 : EIO); + + *rsp_len = gpio_rsp_len; + *rsp = (struct ratp_bb *)gpio_rsp; + return 0; +} + +BAREBOX_RATP_CMD_START(GPIO_SET_DIRECTION) + .request_id = BB_RATP_TYPE_GPIO_SET_DIRECTION, + .response_id = BB_RATP_TYPE_GPIO_SET_DIRECTION_RETURN, + .cmd = ratp_cmd_gpio_set_direction +BAREBOX_RATP_CMD_END diff --git a/common/ratp/i2c.c b/common/ratp/i2c.c new file mode 100644 index 0000000000..07097c7f4b --- /dev/null +++ b/common/ratp/i2c.c @@ -0,0 +1,284 @@ +/* + * Copyright (c) 2018 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix + * Copyright (c) 2018 Zodiac Inflight Innovations + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#define pr_fmt(fmt) "barebox-ratp: i2c: " fmt + +#include <common.h> +#include <ratp_bb.h> +#include <init.h> +#include <driver.h> +#include <malloc.h> +#include <errno.h> +#include <i2c/i2c.h> + +/* NOTE: + * - Fixed-size fields (e.g. integers) are given just after the header. + * - Variable-length fields are stored inside the buffer[] and their position + * within the buffer[] and their size are given as fixed-sized fields after + * the header. + * The message may be extended at any time keeping backwards compatibility, + * as the position of the buffer[] is given by the buffer_offset field. i.e. + * increasing the buffer_offset field we can extend the fixed-sized section + * to add more fields. + */ + +#define I2C_FLAG_WIDE_ADDRESS BIT(0) +#define I2C_FLAG_MASTER_MODE BIT(1) + +struct ratp_bb_i2c_read_request { + struct ratp_bb header; + uint16_t buffer_offset; + uint8_t bus; + uint8_t addr; + uint16_t reg; + uint8_t flags; + uint16_t size; + uint8_t buffer[]; +} __packed; + +struct ratp_bb_i2c_read_response { + struct ratp_bb header; + uint16_t buffer_offset; + uint32_t errno; + uint16_t data_size; + uint16_t data_offset; + uint8_t buffer[]; +} __packed; + +struct ratp_bb_i2c_write_request { + struct ratp_bb header; + uint16_t buffer_offset; + uint8_t bus; + uint8_t addr; + uint16_t reg; + uint8_t flags; + uint16_t data_size; + uint16_t data_offset; + uint8_t buffer[]; +} __packed; + +struct ratp_bb_i2c_write_response { + struct ratp_bb header; + uint16_t buffer_offset; + uint32_t errno; + uint16_t written; + uint8_t buffer[]; +} __packed; + +static int ratp_cmd_i2c_read(const struct ratp_bb *req, int req_len, + struct ratp_bb **rsp, int *rsp_len) +{ + struct ratp_bb_i2c_read_request *i2c_read_req = (struct ratp_bb_i2c_read_request *)req; + struct ratp_bb_i2c_read_response *i2c_read_rsp; + struct i2c_adapter *adapter; + struct i2c_client client; + uint16_t buffer_offset; + int i2c_read_rsp_len; + uint16_t reg; + uint16_t size; + uint32_t wide = 0; + int ret = 0; + + /* At least message header should be valid */ + if (req_len < sizeof(*i2c_read_req)) { + pr_err("read ignored: size mismatch (%d < %zu)\n", + req_len, sizeof(*i2c_read_req)); + ret = -EINVAL; + goto out_rsp; + } + + /* We don't require any buffer here, but just validate buffer position and size */ + buffer_offset = be16_to_cpu(i2c_read_req->buffer_offset); + if (buffer_offset != req_len) { + pr_err("read ignored: invalid buffer offset (%hu != %d)\n", + buffer_offset, req_len); + ret = -EINVAL; + goto out_rsp; + } + + reg = be16_to_cpu(i2c_read_req->reg); + size = be16_to_cpu(i2c_read_req->size); + if (i2c_read_req->flags & I2C_FLAG_WIDE_ADDRESS) + wide = I2C_ADDR_16_BIT; + +out_rsp: + /* Avoid reading anything on error */ + if (ret != 0) + size = 0; + + i2c_read_rsp_len = sizeof(*i2c_read_rsp) + size; + i2c_read_rsp = xzalloc(i2c_read_rsp_len); + i2c_read_rsp->header.type = cpu_to_be16(BB_RATP_TYPE_I2C_READ_RETURN); + i2c_read_rsp->buffer_offset = cpu_to_be16(sizeof(*i2c_read_rsp)); + i2c_read_rsp->data_offset = 0; + + /* Don't read anything on error or if 0 bytes were requested */ + if (size > 0) { + adapter = i2c_get_adapter(i2c_read_req->bus); + if (!adapter) { + pr_err("read ignored: i2c bus %u not found\n", i2c_read_req->bus); + ret = -ENODEV; + goto out; + } + + client.adapter = adapter; + client.addr = i2c_read_req->addr; + + if (i2c_read_req->flags & I2C_FLAG_MASTER_MODE) { + ret = i2c_master_recv(&client, i2c_read_rsp->buffer, size); + } else { + ret = i2c_read_reg(&client, reg | wide, i2c_read_rsp->buffer, size); + } + if (ret != size) { + pr_err("read ignored: not all bytes read (%u < %u)\n", ret, size); + ret = -EIO; + goto out; + } + ret = 0; + } + +out: + if (ret != 0) { + i2c_read_rsp->data_size = 0; + i2c_read_rsp->errno = cpu_to_be32(ret); + i2c_read_rsp_len = sizeof(*i2c_read_rsp); + } else { + i2c_read_rsp->data_size = cpu_to_be16(size); + i2c_read_rsp->errno = 0; + } + + *rsp = (struct ratp_bb *)i2c_read_rsp; + *rsp_len = i2c_read_rsp_len; + + return ret; +} + +BAREBOX_RATP_CMD_START(I2C_READ) + .request_id = BB_RATP_TYPE_I2C_READ, + .response_id = BB_RATP_TYPE_I2C_READ_RETURN, + .cmd = ratp_cmd_i2c_read +BAREBOX_RATP_CMD_END + + +static int ratp_cmd_i2c_write(const struct ratp_bb *req, int req_len, + struct ratp_bb **rsp, int *rsp_len) +{ + struct ratp_bb_i2c_write_request *i2c_write_req = (struct ratp_bb_i2c_write_request *)req; + struct ratp_bb_i2c_write_response *i2c_write_rsp; + struct i2c_adapter *adapter; + struct i2c_client client; + uint8_t *buffer; + uint16_t buffer_offset; + uint16_t buffer_size; + uint16_t reg; + uint16_t data_offset; + uint16_t data_size; + uint32_t wide = 0; + int ret = 0; + int written = 0; + + /* At least message header should be valid */ + if (req_len < sizeof(*i2c_write_req)) { + pr_err("write ignored: size mismatch (%d < %zu)\n", + req_len, sizeof(*i2c_write_req)); + ret = -EINVAL; + goto out; + } + + /* Validate buffer position and size */ + buffer_offset = be16_to_cpu(i2c_write_req->buffer_offset); + if (req_len < buffer_offset) { + pr_err("write ignored: invalid buffer offset (%d < %hu)\n", + req_len, buffer_offset); + ret = -EINVAL; + goto out; + } + buffer_size = req_len - buffer_offset; + buffer = ((uint8_t *)i2c_write_req) + buffer_offset; + + /* Validate data position and size */ + data_offset = be16_to_cpu(i2c_write_req->data_offset); + if (data_offset != 0) { + pr_err("write ignored: invalid data offset\n"); + ret = -EINVAL; + goto out; + } + data_size = be16_to_cpu(i2c_write_req->data_size); + if (!data_size) { + /* Success */ + goto out; + } + + /* Validate buffer size */ + if (buffer_size < data_size) { + pr_err("write ignored: size mismatch (%d < %hu): data not fully given\n", + buffer_size, data_size); + ret = -EINVAL; + goto out; + } + + reg = be16_to_cpu(i2c_write_req->reg); + if (i2c_write_req->flags & I2C_FLAG_WIDE_ADDRESS) + wide = I2C_ADDR_16_BIT; + + adapter = i2c_get_adapter(i2c_write_req->bus); + if (!adapter) { + pr_err("write ignored: i2c bus %u not found\n", i2c_write_req->bus); + ret = -ENODEV; + goto out; + } + + client.adapter = adapter; + client.addr = i2c_write_req->addr; + + if (i2c_write_req->flags & I2C_FLAG_MASTER_MODE) { + written = i2c_master_send(&client, &buffer[data_offset], data_size); + } else { + written = i2c_write_reg(&client, reg | wide, &buffer[data_offset], data_size); + } + + if (written != data_size) { + pr_err("write ignored: not all bytes written (%u < %u)\n", ret, data_size); + ret = -EIO; + goto out; + } + +out: + i2c_write_rsp = xzalloc(sizeof(*i2c_write_rsp)); + i2c_write_rsp->header.type = cpu_to_be16(BB_RATP_TYPE_I2C_WRITE_RETURN); + i2c_write_rsp->buffer_offset = cpu_to_be16(sizeof(*i2c_write_rsp)); /* n/a */ + + if (ret != 0) { + i2c_write_rsp->written = 0; + i2c_write_rsp->errno = cpu_to_be32(ret); + } else { + i2c_write_rsp->written = cpu_to_be16((uint16_t)written); + i2c_write_rsp->errno = 0; + } + + *rsp = (struct ratp_bb *)i2c_write_rsp; + *rsp_len = sizeof(*i2c_write_rsp); + + return ret; +} + +BAREBOX_RATP_CMD_START(I2C_WRITE) + .request_id = BB_RATP_TYPE_I2C_WRITE, + .response_id = BB_RATP_TYPE_I2C_WRITE_RETURN, + .cmd = ratp_cmd_i2c_write +BAREBOX_RATP_CMD_END diff --git a/common/ratp/md.c b/common/ratp/md.c index 9b8fc2bc50..9ce7e99dfd 100644 --- a/common/ratp/md.c +++ b/common/ratp/md.c @@ -15,6 +15,8 @@ * */ +#define pr_fmt(fmt) "barebox-ratp: md: " fmt + #include <common.h> #include <ratp_bb.h> #include <init.h> @@ -46,7 +48,7 @@ struct ratp_bb_md_request { uint16_t path_size; uint16_t path_offset; uint8_t buffer[]; -} __attribute__((packed)); +} __packed; struct ratp_bb_md_response { struct ratp_bb header; @@ -55,7 +57,7 @@ struct ratp_bb_md_response { uint16_t data_size; uint16_t data_offset; uint8_t buffer[]; -} __attribute__((packed)); +} __packed; extern char *mem_rw_buf; @@ -121,8 +123,8 @@ static int ratp_cmd_md(const struct ratp_bb *req, int req_len, /* At least message header should be valid */ if (req_len < sizeof(*md_req)) { - printf("ratp md ignored: size mismatch (%d < %zu)\n", - req_len, sizeof (*md_req)); + pr_err("ignored: size mismatch (%d < %zu)\n", + req_len, sizeof(*md_req)); ret = -EINVAL; goto out; } @@ -130,7 +132,7 @@ static int ratp_cmd_md(const struct ratp_bb *req, int req_len, /* Validate buffer position and size */ buffer_offset = be16_to_cpu(md_req->buffer_offset); if (req_len < buffer_offset) { - printf("ratp md ignored: invalid buffer offset (%d < %hu)\n", + pr_err("ignored: invalid buffer offset (%d < %hu)\n", req_len, buffer_offset); ret = -EINVAL; goto out; @@ -141,27 +143,27 @@ static int ratp_cmd_md(const struct ratp_bb *req, int req_len, /* Validate path position and size */ path_offset = be16_to_cpu(md_req->path_offset); if (path_offset != 0) { - printf("ratp md ignored: invalid path offset\n"); + pr_err("ignored: invalid path offset\n"); ret = -EINVAL; goto out; } path_size = be16_to_cpu(md_req->path_size); if (!path_size) { - printf("ratp md ignored: no filepath given\n"); + pr_err("ignored: no filepath given\n"); ret = -EINVAL; goto out; } /* Validate buffer size */ if (buffer_size < path_size) { - printf("ratp mw ignored: size mismatch (%d < %hu): path may not be fully given\n", + pr_err("ignored: size mismatch (%d < %hu): path may not be fully given\n", req_len, path_size); ret = -EINVAL; goto out; } - addr = be16_to_cpu (md_req->addr); - size = be16_to_cpu (md_req->size); + addr = be16_to_cpu(md_req->addr); + size = be16_to_cpu(md_req->size); path = xstrndup((const char *)&buffer[path_offset], path_size); out: @@ -191,7 +193,7 @@ out: *rsp = (struct ratp_bb *)md_rsp; *rsp_len = md_rsp_len; - free (path); + free(path); return ret; } diff --git a/common/ratp/mw.c b/common/ratp/mw.c index 7d6df3d0a0..55e79bbaf0 100644 --- a/common/ratp/mw.c +++ b/common/ratp/mw.c @@ -16,6 +16,8 @@ * */ +#define pr_fmt(fmt) "barebox-ratp: mw: " fmt + #include <common.h> #include <ratp_bb.h> #include <init.h> @@ -47,7 +49,7 @@ struct ratp_bb_mw_request { uint16_t data_size; uint16_t data_offset; uint8_t buffer[]; -} __attribute__((packed)); +} __packed; struct ratp_bb_mw_response { struct ratp_bb header; @@ -55,7 +57,7 @@ struct ratp_bb_mw_response { uint32_t errno; uint16_t written; uint8_t buffer[]; -} __attribute__((packed)); +} __packed; static int ratp_cmd_mw(const struct ratp_bb *req, int req_len, struct ratp_bb **rsp, int *rsp_len) @@ -77,8 +79,8 @@ static int ratp_cmd_mw(const struct ratp_bb *req, int req_len, /* At least message header should be valid */ if (req_len < sizeof(*mw_req)) { - printf("ratp mw ignored: size mismatch (%d < %zu)\n", - req_len, sizeof (*mw_req)); + pr_err("ignored: size mismatch (%d < %zu)\n", + req_len, sizeof(*mw_req)); ret = -EINVAL; goto out; } @@ -86,7 +88,7 @@ static int ratp_cmd_mw(const struct ratp_bb *req, int req_len, /* Validate buffer position and size */ buffer_offset = be16_to_cpu(mw_req->buffer_offset); if (req_len < buffer_offset) { - printf("ratp mw ignored: invalid buffer offset (%d < %hu)\n", + pr_err("ignored: invalid buffer offset (%d < %hu)\n", req_len, buffer_offset); ret = -EINVAL; goto out; @@ -97,13 +99,13 @@ static int ratp_cmd_mw(const struct ratp_bb *req, int req_len, /* Validate path position and size */ path_offset = be16_to_cpu(mw_req->path_offset); if (path_offset != 0) { - printf("ratp mw ignored: invalid path offset\n"); + pr_err("ignored: invalid path offset\n"); ret = -EINVAL; goto out; } path_size = be16_to_cpu(mw_req->path_size); if (!path_size) { - printf("ratp mw ignored: no filepath given\n"); + pr_err("ignored: no filepath given\n"); ret = -EINVAL; goto out; } @@ -111,7 +113,7 @@ static int ratp_cmd_mw(const struct ratp_bb *req, int req_len, /* Validate data position and size */ data_offset = be16_to_cpu(mw_req->data_offset); if (data_offset != (path_offset + path_size)) { - printf("ratp mw ignored: invalid path offset\n"); + pr_err("ignored: invalid path offset\n"); ret = -EINVAL; goto out; } @@ -123,13 +125,13 @@ static int ratp_cmd_mw(const struct ratp_bb *req, int req_len, /* Validate buffer size */ if (buffer_size < (path_size + data_size)) { - printf("ratp mw ignored: size mismatch (%d < %hu): path or data not be fully given\n", + pr_err("ignored: size mismatch (%d < %hu): path or data not be fully given\n", req_len, path_size + data_size); ret = -EINVAL; goto out; } - addr = be16_to_cpu (mw_req->addr); + addr = be16_to_cpu(mw_req->addr); path = xstrndup((const char *)&buffer[path_offset], path_size); fd = open_and_lseek(path, O_RWSIZE_1 | O_WRONLY, addr); @@ -162,7 +164,7 @@ out: *rsp = (struct ratp_bb *)mw_rsp; *rsp_len = sizeof(*mw_rsp); - free (path); + free(path); return ret; } diff --git a/common/ratp/reset.c b/common/ratp/reset.c index ca8be4e62f..d0229d5d6c 100644 --- a/common/ratp/reset.c +++ b/common/ratp/reset.c @@ -17,6 +17,8 @@ * */ +#define pr_fmt(fmt) "barebox-ratp: reset: " fmt + #include <common.h> #include <command.h> #include <ratp_bb.h> @@ -27,19 +29,19 @@ struct ratp_bb_reset { struct ratp_bb header; uint8_t force; -} __attribute__((packed)); +} __packed; static int ratp_cmd_reset(const struct ratp_bb *req, int req_len, struct ratp_bb **rsp, int *rsp_len) { struct ratp_bb_reset *reset_req = (struct ratp_bb_reset *)req; - if (req_len < sizeof (*reset_req)) { - printf ("ratp reset ignored: size mismatch (%d < %zu)\n", req_len, sizeof (*reset_req)); + if (req_len < sizeof(*reset_req)) { + pr_err("ignored: size mismatch (%d < %zu)\n", req_len, sizeof(*reset_req)); return 2; } - debug("running reset %s\n", reset_req->force ? "(forced)" : ""); + pr_debug("running %s\n", reset_req->force ? "(forced)" : ""); if (!reset_req->force) shutdown_barebox(); diff --git a/include/ratp_bb.h b/include/ratp_bb.h index 3a80cf6aed..b6699979b6 100644 --- a/include/ratp_bb.h +++ b/include/ratp_bb.h @@ -17,6 +17,16 @@ #define BB_RATP_TYPE_MW 12 #define BB_RATP_TYPE_MW_RETURN 13 #define BB_RATP_TYPE_RESET 14 +#define BB_RATP_TYPE_I2C_READ 15 +#define BB_RATP_TYPE_I2C_READ_RETURN 16 +#define BB_RATP_TYPE_I2C_WRITE 17 +#define BB_RATP_TYPE_I2C_WRITE_RETURN 18 +#define BB_RATP_TYPE_GPIO_GET_VALUE 19 +#define BB_RATP_TYPE_GPIO_GET_VALUE_RETURN 20 +#define BB_RATP_TYPE_GPIO_SET_VALUE 21 +#define BB_RATP_TYPE_GPIO_SET_VALUE_RETURN 22 +#define BB_RATP_TYPE_GPIO_SET_DIRECTION 23 +#define BB_RATP_TYPE_GPIO_SET_DIRECTION_RETURN 24 struct ratp_bb { uint16_t type; diff --git a/scripts/remote/controller.py b/scripts/remote/controller.py index 1a83909042..b4493591dd 100644 --- a/scripts/remote/controller.py +++ b/scripts/remote/controller.py @@ -61,6 +61,36 @@ def unpack(data): elif p_type == BBType.reset: logging.debug("received: reset") return BBPacketReset(raw=data) + elif p_type == BBType.i2c_read: + logging.debug("received: i2c_read") + return BBPacketI2cRead(raw=data) + elif p_type == BBType.i2c_read_return: + logging.debug("received: i2c_read_return") + return BBPacketI2cReadReturn(raw=data) + elif p_type == BBType.i2c_write: + logging.debug("received: i2c_write") + return BBPacketI2cWrite(raw=data) + elif p_type == BBType.i2c_write_return: + logging.debug("received: i2c_write_return") + return BBPacketI2cWriteReturn(raw=data) + elif p_type == BBType.gpio_get_value: + logging.debug("received: gpio_get_value") + return BBPacketGpioGetValue(raw=data) + elif p_type == BBType.gpio_get_value_return: + logging.debug("received: gpio_get_value_return") + return BBPacketGpioGetValueReturn(raw=data) + elif p_type == BBType.gpio_set_value: + logging.debug("received: gpio_set_value") + return BBPacketGpioSetValue(raw=data) + elif p_type == BBType.gpio_set_value_return: + logging.debug("received: gpio_set_value_return") + return BBPacketGpioSetValueReturn(raw=data) + elif p_type == BBType.gpio_set_direction: + logging.debug("received: gpio_set_direction") + return BBPacketGpioSetDirection(raw=data) + elif p_type == BBType.gpio_set_direction_return: + logging.debug("received: gpio_set_direction_return") + return BBPacketGpioSetDirectionReturn(raw=data) else: logging.debug("received: UNKNOWN") return BBPacket(raw=data) @@ -139,6 +169,36 @@ class Controller(Thread): logging.info("Mw return: %r", r) return (r.exit_code,r.written) + def i2c_read(self, bus, addr, reg, flags, size): + self._send(BBPacketI2cRead(bus=bus, addr=addr, reg=reg, flags=flags, size=size)) + r = self._expect(BBPacketI2cReadReturn) + logging.info("i2c read return: %r", r) + return (r.exit_code,r.data) + + def i2c_write(self, bus, addr, reg, flags, data): + self._send(BBPacketI2cWrite(bus=bus, addr=addr, reg=reg, flags=flags, data=data)) + r = self._expect(BBPacketI2cWriteReturn) + logging.info("i2c write return: %r", r) + return (r.exit_code,r.written) + + def gpio_get_value(self, gpio): + self._send(BBPacketGpioGetValue(gpio=gpio)) + r = self._expect(BBPacketGpioGetValueReturn) + logging.info("gpio get value return: %r", r) + return r.value + + def gpio_set_value(self, gpio, value): + self._send(BBPacketGpioSetValue(gpio=gpio, value=value)) + r = self._expect(BBPacketGpioSetValueReturn) + logging.info("gpio set value return: %r", r) + return 0 + + def gpio_set_direction(self, gpio, direction, value): + self._send(BBPacketGpioSetDirection(gpio=gpio, direction=direction, value=value)) + r = self._expect(BBPacketGpioSetDirectionReturn) + logging.info("gpio set direction return: %r", r) + return r.exit_code + def reset(self, force): self._send(BBPacketReset(force=force)) diff --git a/scripts/remote/main.py b/scripts/remote/main.py index 38d280bfee..cef5d92ee2 100644 --- a/scripts/remote/main.py +++ b/scripts/remote/main.py @@ -98,6 +98,49 @@ def handle_mw(args): return res +def handle_i2c_read(args): + ctrl = get_controller(args) + (res,data) = ctrl.i2c_read(args.bus, args.address, args.reg, args.flags, args.size) + if res == 0: + print(binascii.hexlify(data)) + ctrl.close() + return res + + +def handle_i2c_write(args): + ctrl = get_controller(args) + data=args.data + if ((len(data) % 2) != 0): + data="0"+data + (res,written) = ctrl.i2c_write(args.bus, args.address, args.reg, args.flags, binascii.unhexlify(data)) + if res == 0: + print("%i bytes written" % written) + ctrl.close() + return res + + +def handle_gpio_get_value(args): + ctrl = get_controller(args) + value = ctrl.gpio_get_value(args.gpio) + print ("%u" % value); + ctrl.close() + return 0 + + +def handle_gpio_set_value(args): + ctrl = get_controller(args) + ctrl.gpio_set_value(args.gpio, args.value) + ctrl.close() + return 0 + + +def handle_gpio_set_direction(args): + ctrl = get_controller(args) + res = ctrl.gpio_set_direction(args.gpio, args.direction, args.value) + ctrl.close() + return res + + def handle_reset(args): ctrl = get_controller(args) ctrl.reset(args.force) @@ -188,6 +231,37 @@ parser_mw.add_argument('address', type=auto_int, help="address") parser_mw.add_argument('data', help="data") parser_mw.set_defaults(func=handle_mw) +parser_i2c_read = subparsers.add_parser('i2c-read', help="run i2c read command") +parser_i2c_read.add_argument('bus', type=auto_int, help="bus") +parser_i2c_read.add_argument('address', type=auto_int, help="address") +parser_i2c_read.add_argument('reg', type=auto_int, help="reg") +parser_i2c_read.add_argument('flags', type=auto_int, help="flags") +parser_i2c_read.add_argument('size', type=auto_int, help="size") +parser_i2c_read.set_defaults(func=handle_i2c_read) + +parser_i2c_write = subparsers.add_parser('i2c-write', help="run i2c write command") +parser_i2c_write.add_argument('bus', type=auto_int, help="bus") +parser_i2c_write.add_argument('address', type=auto_int, help="address") +parser_i2c_write.add_argument('reg', type=auto_int, help="reg") +parser_i2c_write.add_argument('flags', type=auto_int, help="flags") +parser_i2c_write.add_argument('data', help="data") +parser_i2c_write.set_defaults(func=handle_i2c_write) + +parser_gpio_get_value = subparsers.add_parser('gpio-get-value', help="run gpio get value command") +parser_gpio_get_value.add_argument('gpio', type=auto_int, help="gpio") +parser_gpio_get_value.set_defaults(func=handle_gpio_get_value) + +parser_gpio_set_value = subparsers.add_parser('gpio-set-value', help="run gpio set value command") +parser_gpio_set_value.add_argument('gpio', type=auto_int, help="gpio") +parser_gpio_set_value.add_argument('value', type=auto_int, help="value") +parser_gpio_set_value.set_defaults(func=handle_gpio_set_value) + +parser_gpio_set_direction = subparsers.add_parser('gpio-set-direction', help="run gpio set direction command") +parser_gpio_set_direction.add_argument('gpio', type=auto_int, help="gpio") +parser_gpio_set_direction.add_argument('direction', type=auto_int, help="direction (0: input, 1: output)") +parser_gpio_set_direction.add_argument('value', type=auto_int, help="value (if output)") +parser_gpio_set_direction.set_defaults(func=handle_gpio_set_direction) + parser_reset = subparsers.add_parser('reset', help="run reset command") parser_reset_force = parser_reset.add_mutually_exclusive_group(required=False) parser_reset_force.add_argument('--force', dest='force', action='store_true') diff --git a/scripts/remote/messages.py b/scripts/remote/messages.py index 729f2e6177..abd331c8b6 100644 --- a/scripts/remote/messages.py +++ b/scripts/remote/messages.py @@ -22,6 +22,16 @@ class BBType(object): mw = 12 mw_return = 13 reset = 14 + i2c_read = 15 + i2c_read_return = 16 + i2c_write = 17 + i2c_write_return = 18 + gpio_get_value = 19 + gpio_get_value_return = 20 + gpio_set_value = 21 + gpio_set_value_return = 22 + gpio_set_direction = 23 + gpio_set_direction_return = 24 class BBPacket(object): @@ -257,3 +267,172 @@ class BBPacketReset(BBPacket): def _pack_payload(self): return struct.pack("?", self.force) + + +class BBPacketI2cRead(BBPacket): + def __init__(self, raw=None, bus=None, addr=None, reg=None, flags=None, size=None): + self.bus = bus + self.addr = addr + self.reg = reg + self.flags = flags + self.size = size + super(BBPacketI2cRead, self).__init__(BBType.i2c_read, raw=raw) + + def __repr__(self): + return "BBPacketI2cRead(bus=0x%x,addr=0x%x,reg=0x%x,flags=0x%x,size=%u)" % (self.bus, self.addr, self.reg, self.flags, self.size) + + def _unpack_payload(self, payload): + buffer_offset, self.bus, self.addr, self.reg, self.flags, self.size = struct.unpack("!HBBHBH", payload[:9]) + + def _pack_payload(self): + # header size is always 4 bytes (HH) and we have 9 bytes of fixed data (HBBHBH), so buffer offset is 13 + return struct.pack("!HBBHBH", 13, self.bus, self.addr, self.reg, self.flags, self.size) + + +class BBPacketI2cReadReturn(BBPacket): + def __init__(self, raw=None, exit_code=None, data=None): + self.exit_code = exit_code + self.data = data + super(BBPacketI2cReadReturn, self).__init__(BBType.i2c_read_return, raw=raw) + + def __repr__(self): + return "BBPacketI2cReadReturn(exit_code=%i, data=%s)" % (self.exit_code, binascii.hexlify(self.data)) + + def _unpack_payload(self, payload): + buffer_offset, self.exit_code, data_size, data_offset = struct.unpack("!HLHH", payload[:10]) + # header size is always 4 bytes (HH), so adjust the absolute data offset without the header size + absolute_data_offset = buffer_offset + data_offset - 4 + self.data = payload[absolute_data_offset:absolute_data_offset + data_size] + + def _pack_payload(self): + # header size is always 4 bytes (HH) and we have 10 bytes of fixed data (HLHH), so buffer offset is 14 + return struct.pack("!HLHH%ds" % len(self.data), 14, self.exit_code, len(self.data), 0, self.data) + return self.text + + +class BBPacketI2cWrite(BBPacket): + def __init__(self, raw=None, bus=None, addr=None, reg=None, flags=None, data=None): + self.bus = bus + self.addr = addr + self.reg = reg + self.flags = flags + self.data = data + super(BBPacketI2cWrite, self).__init__(BBType.i2c_write, raw=raw) + + def __repr__(self): + return "BBPacketI2cWrite(bus=0x%x,addr=0x%x,reg=0x%x,flags=0x%x,data=%r)" % (self.bus, self.addr, self.reg, self.flags, self.data) + + def _unpack_payload(self, payload): + buffer_offset, self.bus, self.addr, self.reg, self.flags, data_size, data_offset = struct.unpack("!HBBHBHH", payload[:11]) + # header size is always 4 bytes (HH), so adjust the absolute data offset without the header size + absolute_data_offset = buffer_offset + data_offset - 4 + self.data = payload[absolute_data_offset:absolute_data_offset+data_size] + + def _pack_payload(self): + # header size is always 4 bytes (HH) and we have 11 bytes of fixed data (HBBHBHH), so buffer offset is 15 + data_size = len(self.data) + return struct.pack("!HBBHBHH%ds" % data_size, 15, self.bus, self.addr, self.reg, self.flags, data_size, 0, self.data) + + +class BBPacketI2cWriteReturn(BBPacket): + def __init__(self, raw=None, exit_code=None, written=None): + self.exit_code = exit_code + self.written = written + super(BBPacketI2cWriteReturn, self).__init__(BBType.i2c_write_return, raw=raw) + + def __repr__(self): + return "BBPacketI2cWriteReturn(exit_code=%i, written=%i)" % (self.exit_code, self.written) + + def _unpack_payload(self, payload): + buffer_offset, self.exit_code, self.written = struct.unpack("!HLH", payload[:8]) + + def _pack_payload(self): + # header size is always 4 bytes (HH) and we have 8 bytes of fixed data (HLH), so buffer offset is 14 + return struct.pack("!HLH", 12, self.exit_code, self.written) + + +class BBPacketGpioGetValue(BBPacket): + def __init__(self, raw=None, gpio=None): + self.gpio = gpio + super(BBPacketGpioGetValue, self).__init__(BBType.gpio_get_value, raw=raw) + + def __repr__(self): + return "BBPacketGpioGetValue(gpio=%u)" % (self.gpio) + + def _unpack_payload(self, payload): + self.gpio = struct.unpack("!L", payload[:4]) + + def _pack_payload(self): + return struct.pack("!L", self.gpio) + + +class BBPacketGpioGetValueReturn(BBPacket): + def __init__(self, raw=None, value=None): + self.value = value + super(BBPacketGpioGetValueReturn, self).__init__(BBType.gpio_get_value_return, raw=raw) + + def __repr__(self): + return "BBPacketGpioGetValueReturn(value=%u)" % (self.value) + + def _unpack_payload(self, payload): + self.value = struct.unpack("!B", payload[:1]) + + def _pack_payload(self): + return struct.pack("!B", self.value) + + +class BBPacketGpioSetValue(BBPacket): + def __init__(self, raw=None, gpio=None, value=None): + self.gpio = gpio + self.value = value + super(BBPacketGpioSetValue, self).__init__(BBType.gpio_set_value, raw=raw) + + def __repr__(self): + return "BBPacketGpioSetValue(gpio=%u,value=%u)" % (self.gpio, self.value) + + def _unpack_payload(self, payload): + self.gpio = struct.unpack("!LB", payload[:5]) + + def _pack_payload(self): + return struct.pack("!LB", self.gpio, self.value) + + +class BBPacketGpioSetValueReturn(BBPacket): + def __init__(self, raw=None, value=None): + self.value = value + super(BBPacketGpioSetValueReturn, self).__init__(BBType.gpio_set_value_return, raw=raw) + + def __repr__(self): + return "BBPacketGpioSetValueReturn()" + + +class BBPacketGpioSetDirection(BBPacket): + def __init__(self, raw=None, gpio=None, direction=None, value=None): + self.gpio = gpio + self.direction = direction + self.value = value + super(BBPacketGpioSetDirection, self).__init__(BBType.gpio_set_direction, raw=raw) + + def __repr__(self): + return "BBPacketGpioSetDirection(gpio=%u,direction=%u,value=%u)" % (self.gpio, self.direction, self.value) + + def _unpack_payload(self, payload): + self.gpio = struct.unpack("!LBB", payload[:6]) + + def _pack_payload(self): + return struct.pack("!LBB", self.gpio, self.direction, self.value) + + +class BBPacketGpioSetDirectionReturn(BBPacket): + def __init__(self, raw=None, exit_code=None): + self.exit_code = exit_code + super(BBPacketGpioSetDirectionReturn, self).__init__(BBType.gpio_set_direction_return, raw=raw) + + def __repr__(self): + return "BBPacketGpioSetDirectionReturn(exit_code=%u)" % (self.exit_code) + + def _unpack_payload(self, payload): + self.exit_code = struct.unpack("!L", payload[:4]) + + def _pack_payload(self): + return struct.pack("!L", self.exit_code) |