Re: [PATCH 2/8] barebox remote control

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Discovered some build problems after I was done testing this code:

On Fri, Jan 8, 2016 at 3:13 AM, Sascha Hauer <s.hauer@xxxxxxxxxxxxxx> wrote:
> This adds the ability to control barebox over serial lines. The regular
> console is designed for human input and is unsuitable for controlling
> barebox from scripts since characters can be lost on both ends, the data
> stream contains escape sequences and the prompt cannot be easily matched
> upon.
> This approach is based on the RATP protocol. RATP packages start with a
> binary 0x01 which does not occur in normal console data. Whenever a
> 0x01 character is detected in the console barebox goes into RATP mode.
> The RATP packets contain a simple structure with a command/respone
> type and data for that type. Currently defined types are:
>
> BB_RATP_TYPE_COMMAND (host->barebox):
>         Execute a command in the shell
> BB_RATP_TYPE_COMMAND_RETURN (barebox->host)
>         Sends return value of the command back to the host, also means
>         barebox is ready for the next command
> BB_RATP_TYPE_CONSOLEMSG (barebox->host)
>         Console message from barebox
>
> Planned but not yet implemented are:
>
> BB_RATP_TYPE_PING (host->barebox)
> BB_RATP_TYPE_PONG (barebox->host)
>         For testing purposes
> BB_RATP_TYPE_GETENV (host->barebox)
> BB_RATP_TYPE_GETENV_RETURN (barebox->host)
>         Get values of environment variables
>
> Signed-off-by: Sascha Hauer <s.hauer@xxxxxxxxxxxxxx>
> ---
>  common/Kconfig   |  10 ++
>  common/Makefile  |   2 +
>  common/console.c |  26 ++-
>  common/ratp.c    | 511 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  crypto/Kconfig   |   1 +
>  fs/Makefile      |   1 +
>  include/ratp.h   |   2 +-
>  lib/readline.c   |   7 +
>  8 files changed, 556 insertions(+), 4 deletions(-)
>  create mode 100644 common/ratp.c
>
> diff --git a/common/Kconfig b/common/Kconfig
> index 8e79509..2b5943b 100644
> --- a/common/Kconfig
> +++ b/common/Kconfig
> @@ -611,6 +611,16 @@ config PBL_CONSOLE
>           must be running at the address it's linked at and bss must
>           be cleared. On ARM that would be after setup_c().
>
> +config CONSOLE_RATP
> +       bool
> +       select RATP
> +       prompt "RATP console support"
> +       help
> +         This option adds support for remote controlling barebox via serial
> +         port. The regular console is designed for human interaction whereas
> +         this option adds a machine readable interface for controlling barebox.
> +         Say yes here if you want to control barebox from a remote host.
> +
>  config PARTITION
>         bool
>         prompt "Enable Partitions"
> diff --git a/common/Makefile b/common/Makefile
> index 56e6bec..5eb3c96 100644
> --- a/common/Makefile
> +++ b/common/Makefile
> @@ -45,6 +45,7 @@ obj-$(CONFIG_RESET_SOURCE)    += reset_source.o
>  obj-$(CONFIG_SHELL_HUSH)       += hush.o
>  obj-$(CONFIG_SHELL_SIMPLE)     += parser.o
>  obj-$(CONFIG_STATE)            += state.o
> +obj-$(CONFIG_RATP)             += ratp.o
>  obj-$(CONFIG_UIMAGE)           += image.o uimage.o
>  obj-$(CONFIG_MENUTREE)         += menutree.o
>  obj-$(CONFIG_EFI_GUID)         += efi-guid.o
> @@ -54,6 +55,7 @@ obj-$(CONFIG_IMD)             += imd.o
>  obj-$(CONFIG_FILE_LIST)                += file-list.o
>  obj-$(CONFIG_FIRMWARE)         += firmware.o
>  obj-$(CONFIG_BAREBOX_UPDATE_IMX_NAND_FCB) += imx-bbu-nand-fcb.o
> +obj-$(CONFIG_CONSOLE_RATP)     += ratp.o
>
>  quiet_cmd_pwd_h = PWDH    $@
>  ifdef CONFIG_PASSWORD
> diff --git a/common/console.c b/common/console.c
> index 4a1d257..9924964 100644
> --- a/common/console.c
> +++ b/common/console.c
> @@ -303,6 +303,8 @@ int console_unregister(struct console_device *cdev)
>  }
>  EXPORT_SYMBOL(console_unregister);
>
> +int barebox_ratp(struct console_device *cdev);

This will break when RATP is not enabled in Kconfig

> +
>  static int getc_raw(void)
>  {
>         struct console_device *cdev;
> @@ -313,8 +315,16 @@ static int getc_raw(void)
>                         if (!(cdev->f_active & CONSOLE_STDIN))
>                                 continue;
>                         active = 1;
> -                       if (cdev->tstc(cdev))
> -                               return cdev->getc(cdev);
> +                       if (cdev->tstc(cdev)) {
> +                               int ch = cdev->getc(cdev);
> +
> +                               if (ch == 0x01) {
> +                                       barebox_ratp(cdev);
> +                                       return -1;
> +                               }
> +
> +                               return ch;
> +                       }
>                 }
>                 if (!active)
>                         /* no active console found. bail out */
> @@ -349,16 +359,26 @@ int getc(void)
>         start = get_time_ns();
>         while (1) {
>                 if (tstc_raw()) {
> -                       kfifo_putc(console_input_fifo, getc_raw());
> +                       int c = getc_raw();
> +
> +                       if (c < 0)
> +                               break;
> +
> +                       kfifo_putc(console_input_fifo, c);
>
>                         start = get_time_ns();
>                 }
> +
>                 if (is_timeout(start, 100 * USECOND) &&
>                                 kfifo_len(console_input_fifo))
>                         break;
>         }
>
> +       if (!kfifo_len(console_input_fifo))
> +               return -1;
> +
>         kfifo_getc(console_input_fifo, &ch);
> +
>         return ch;
>  }
>  EXPORT_SYMBOL(getc);
> diff --git a/common/ratp.c b/common/ratp.c
> new file mode 100644
> index 0000000..2fef3cc
> --- /dev/null
> +++ b/common/ratp.c
> @@ -0,0 +1,511 @@
> +/*
> + * Copyright (c) 2015 Sascha Hauer <s.hauer@xxxxxxxxxxxxxx>, Pengutronix
> + *
> + * 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: " fmt
> +
> +#include <common.h>
> +#include <command.h>
> +#include <kfifo.h>
> +#include <malloc.h>
> +#include <init.h>
> +#include <ratp.h>
> +#include <command.h>
> +#include <byteorder.h>
> +#include <environment.h>
> +#include <kfifo.h>
> +#include <poller.h>
> +#include <linux/sizes.h>
> +#include <ratp_bb.h>
> +#include <fs.h>
> +
> +#define BB_RATP_TYPE_COMMAND           1
> +#define BB_RATP_TYPE_COMMAND_RETURN    2
> +#define BB_RATP_TYPE_CONSOLEMSG                3
> +#define BB_RATP_TYPE_PING              4
> +#define BB_RATP_TYPE_PONG              5
> +#define BB_RATP_TYPE_GETENV            6
> +#define BB_RATP_TYPE_GETENV_RETURN     7
> +#define BB_RATP_TYPE_FS                        8
> +#define BB_RATP_TYPE_FS_RETURN         9
> +
> +struct ratp_bb {
> +       uint16_t type;
> +       uint16_t flags;
> +       uint8_t data[];
> +};
> +
> +struct ratp_bb_command_return {
> +       uint32_t errno;
> +};
> +
> +struct ratp_ctx {
> +       struct console_device *cdev;
> +       struct ratp ratp;
> +       int ratp_status;
> +       struct console_device ratp_console;
> +       int have_synch;
> +       int in_ratp_console;
> +
> +       u8 sendbuf[256];
> +       u8 sendbuf_len;
> +
> +       int old_active;
> +
> +       struct kfifo *console_recv_fifo;
> +       struct kfifo *console_transmit_fifo;
> +
> +       struct ratp_bb_pkt *fs_rx;
> +
> +       struct poller_struct poller;
> +};
> +
> +static int console_recv(struct ratp *r, uint8_t *data)
> +{
> +       struct ratp_ctx *ctx = container_of(r, struct ratp_ctx, ratp);
> +       struct console_device *cdev = ctx->cdev;
> +
> +       if (ctx->have_synch) {
> +               ctx->have_synch = 0;
> +               *data = 0x01;
> +               return 0;
> +       }
> +
> +       if (!cdev->tstc(cdev))
> +               return -EAGAIN;
> +
> +       *data = cdev->getc(cdev);
> +
> +       return 0;
> +}
> +
> +static int console_send(struct ratp *r, void *pkt, int len)
> +{
> +       struct ratp_ctx *ctx = container_of(r, struct ratp_ctx, ratp);
> +       struct console_device *cdev = ctx->cdev;
> +       const uint8_t *buf = pkt;
> +       int i;
> +
> +       for (i = 0; i < len; i++)
> +               cdev->putc(cdev, buf[i]);
> +
> +       return 0;
> +}
> +
> +static void *xmemdup_add_zero(const void *buf, int len)
> +{
> +       void *ret;
> +
> +       ret = xzalloc(len + 1);
> +       *(uint8_t *)(ret + len) = 0;
> +       memcpy(ret, buf, len);
> +
> +       return ret;
> +}
> +
> +static void ratp_queue_console_tx(struct ratp_ctx *ctx)
> +{
> +       u8 buf[255];
> +       struct ratp_bb *rbb = (void *)buf;
> +       unsigned int now, maxlen = 255 - sizeof(*rbb);
> +       int ret;
> +
> +       rbb->type = cpu_to_be16(BB_RATP_TYPE_CONSOLEMSG);
> +
> +       while (1) {
> +               now = min(maxlen, kfifo_len(ctx->console_transmit_fifo));
> +               if (!now)
> +                       break;
> +
> +               kfifo_get(ctx->console_transmit_fifo, rbb->data, now);
> +
> +               ret = ratp_send(&ctx->ratp, rbb, now + sizeof(*rbb));
> +               if (ret)
> +                       return;
> +       }
> +}
> +
> +static int ratp_bb_send_command_return(struct ratp_ctx *ctx, uint32_t errno)
> +{
> +       void *buf;
> +       struct ratp_bb *rbb;
> +       struct ratp_bb_command_return *rbb_ret;
> +       int len = sizeof(*rbb) + sizeof(*rbb_ret);
> +       int ret;
> +
> +       ratp_queue_console_tx(ctx);
> +
> +       buf = xzalloc(len);
> +       rbb = buf;
> +       rbb_ret = buf + sizeof(*rbb);
> +
> +       rbb->type = cpu_to_be16(BB_RATP_TYPE_COMMAND_RETURN);
> +       rbb_ret->errno = cpu_to_be32(errno);
> +
> +       ret = ratp_send(&ctx->ratp, buf, len);
> +
> +       free(buf);
> +
> +       return ret;
> +}
> +
> +static int ratp_bb_send_pong(struct ratp_ctx *ctx)
> +{
> +       void *buf;
> +       struct ratp_bb *rbb;
> +       int len = sizeof(*rbb);
> +       int ret;
> +
> +       buf = xzalloc(len);
> +       rbb = buf;
> +
> +       rbb->type = cpu_to_be16(BB_RATP_TYPE_PONG);
> +
> +       ret = ratp_send(&ctx->ratp, buf, len);
> +
> +       free(buf);
> +
> +       return ret;
> +}
> +
> +static int ratp_bb_send_getenv_return(struct ratp_ctx *ctx, const char *val)
> +{
> +       void *buf;
> +       struct ratp_bb *rbb;
> +       int len, ret;
> +
> +       if (!val)
> +           val = "";
> +
> +       len = sizeof(*rbb) + strlen(val);
> +       buf = xzalloc(len);
> +       rbb = buf;
> +       strcpy(rbb->data, val);
> +
> +       rbb->type = cpu_to_be16(BB_RATP_TYPE_GETENV_RETURN);
> +
> +       ret = ratp_send(&ctx->ratp, buf, len);
> +
> +       free(buf);
> +
> +       return ret;
> +}
> +
> +static char *ratp_command;
> +static struct ratp_ctx *ratp_command_ctx;
> +
> +static int ratp_bb_dispatch(struct ratp_ctx *ctx, const void *buf, int len)
> +{
> +       const struct ratp_bb *rbb = buf;
> +       struct ratp_bb_pkt *pkt;
> +       int dlen = len - sizeof(struct ratp_bb);
> +       char *varname;
> +       int ret = 0;
> +
> +       switch (be16_to_cpu(rbb->type)) {
> +       case BB_RATP_TYPE_COMMAND:
> +               if (ratp_command)
> +                       return 0;
> +
> +               ratp_command = xmemdup_add_zero(&rbb->data, dlen);
> +               ratp_command_ctx = ctx;
> +               pr_debug("got command: %s\n", ratp_command);
> +
> +               break;
> +
> +       case BB_RATP_TYPE_COMMAND_RETURN:
> +       case BB_RATP_TYPE_PONG:
> +               break;
> +
> +       case BB_RATP_TYPE_CONSOLEMSG:
> +
> +               kfifo_put(ctx->console_recv_fifo, rbb->data, dlen);
> +               break;
> +
> +       case BB_RATP_TYPE_PING:
> +               ret = ratp_bb_send_pong(ctx);
> +               break;
> +
> +       case BB_RATP_TYPE_GETENV:
> +               varname = xmemdup_add_zero(&rbb->data, dlen);
> +
> +               ret = ratp_bb_send_getenv_return(ctx, getenv(varname));
> +               break;
> +
> +       case BB_RATP_TYPE_FS_RETURN:
> +               pkt = xzalloc(sizeof(*pkt) + dlen);
> +               pkt->len = dlen;
> +               memcpy(pkt->data, &rbb->data, dlen);
> +               ctx->fs_rx = pkt;
> +               break;
> +       default:
> +               printf("%s: unhandled packet type 0x%04x\n", __func__, be16_to_cpu(rbb->type));
> +               break;
> +       }
> +
> +       return ret;
> +}
> +
> +static int ratp_console_getc(struct console_device *cdev)
> +{
> +       struct ratp_ctx *ctx = container_of(cdev, struct ratp_ctx, ratp_console);
> +       unsigned char c;
> +
> +       if (!kfifo_len(ctx->console_recv_fifo))
> +               return -1;
> +
> +       kfifo_getc(ctx->console_recv_fifo, &c);
> +
> +       return c;
> +}
> +
> +static int ratp_console_tstc(struct console_device *cdev)
> +{
> +       struct ratp_ctx *ctx = container_of(cdev, struct ratp_ctx, ratp_console);
> +
> +       return kfifo_len(ctx->console_recv_fifo) ? 1 : 0;
> +}
> +
> +static int ratp_console_puts(struct console_device *cdev, const char *s)
> +{
> +       struct ratp_ctx *ctx = container_of(cdev, struct ratp_ctx, ratp_console);
> +       int len = 0;
> +
> +       len = strlen(s);
> +
> +       if (ratp_busy(&ctx->ratp))
> +               return len;
> +
> +       kfifo_put(ctx->console_transmit_fifo, s, len);
> +
> +       return len;
> +}
> +
> +static void ratp_console_putc(struct console_device *cdev, char c)
> +{
> +       struct ratp_ctx *ctx = container_of(cdev, struct ratp_ctx, ratp_console);
> +
> +       if (ratp_busy(&ctx->ratp))
> +               return;
> +
> +       kfifo_putc(ctx->console_transmit_fifo, c);
> +}
> +
> +static int ratp_console_register(struct ratp_ctx *ctx)
> +{
> +       int ret;
> +
> +       ctx->ratp_console.tstc = ratp_console_tstc;
> +       ctx->ratp_console.puts = ratp_console_puts;
> +       ctx->ratp_console.putc = ratp_console_putc;
> +       ctx->ratp_console.getc = ratp_console_getc;
> +       ctx->ratp_console.devname = "ratpconsole";
> +       ctx->ratp_console.devid = DEVICE_ID_SINGLE;
> +
> +       ret = console_register(&ctx->ratp_console);
> +       if (ret) {
> +               pr_err("registering failed with %s\n", strerror(-ret));
> +               return ret;
> +       }
> +
> +       return 0;
> +}
> +
> +void ratp_run_command(void)
> +{
> +       int ret;
> +
> +       if (!ratp_command)
> +               return;
> +
> +       pr_debug("running command: %s\n", ratp_command);
> +
> +       ret = run_command(ratp_command);
> +
> +       free(ratp_command);
> +       ratp_command = NULL;
> +
> +       ratp_bb_send_command_return(ratp_command_ctx, ret);
> +}
> +
> +static const char *ratpfs_mount_path;
> +
> +int barebox_ratp_fs_mount(const char *path)
> +{
> +       if (path && ratpfs_mount_path)
> +               return -EBUSY;
> +
> +       ratpfs_mount_path = path;
> +
> +       return 0;
> +}
> +
> +static void ratp_console_unregister(struct ratp_ctx *ctx)
> +{
> +       int ret;
> +
> +       console_set_active(&ctx->ratp_console, 0);
> +       poller_unregister(&ctx->poller);
> +       ratp_close(&ctx->ratp);
> +       console_set_active(ctx->cdev, ctx->old_active);
> +       ctx->cdev = NULL;
> +
> +       if (ratpfs_mount_path) {
> +               ret = umount(ratpfs_mount_path);
> +               if (!ret)
> +                       ratpfs_mount_path = NULL;
> +       }
> +}
> +
> +static void ratp_poller(struct poller_struct *poller)
> +{
> +       struct ratp_ctx *ctx = container_of(poller, struct ratp_ctx, poller);
> +       int ret;
> +       size_t len;
> +       void *buf;
> +
> +       ratp_queue_console_tx(ctx);
> +
> +       ret = ratp_poll(&ctx->ratp);
> +       if (ret == -EINTR)
> +               goto out;
> +       if (ratp_closed(&ctx->ratp))
> +               goto out;
> +
> +       ret = ratp_recv(&ctx->ratp, &buf, &len);
> +       if (ret < 0)
> +               return;
> +
> +       ratp_bb_dispatch(ctx, buf, len);
> +
> +       free(buf);
> +
> +       return;
> +
> +out:
> +       ratp_console_unregister(ctx);
> +}
> +
> +static int do_ratp_close(int argc, char *argv[])
> +{
> +       if (ratp_command_ctx && ratp_command_ctx->cdev)
> +               ratp_console_unregister(ratp_command_ctx);
> +       else
> +               printf("ratp is not active\n");
> +
> +       return 0;
> +}
> +
> +BAREBOX_CMD_START(ratp_close)
> +       .cmd    = do_ratp_close,
> +};
> +
> +int barebox_ratp_fs_call(struct ratp_bb_pkt *tx, struct ratp_bb_pkt **rx)
> +{
> +       struct ratp_ctx *ctx = ratp_command_ctx;
> +       struct ratp_bb *rbb;
> +       int len;
> +       u64 start;
> +
> +       if (!ctx)
> +               return -EINVAL;
> +
> +       ctx->fs_rx = NULL;
> +
> +       len = sizeof(*rbb) + tx->len;
> +       rbb = xzalloc(len);
> +       rbb->type = cpu_to_be16(BB_RATP_TYPE_FS);
> +       memcpy(rbb->data, tx->data, tx->len);
> +
> +       if (ratp_send(&ctx->ratp, rbb, len) != 0)
> +               pr_debug("failed to send port pkt\n");
> +
> +       free(rbb);
> +
> +       start = get_time_ns();
> +
> +       while (!ctx->fs_rx) {
> +               poller_call();
> +               if (ratp_closed(&ctx->ratp))
> +                       return -EIO;
> +               if (is_timeout(start, 10 * SECOND))
> +                       return -ETIMEDOUT;
> +       }
> +
> +       *rx = ctx->fs_rx;
> +
> +       pr_debug("%s: len %i\n", __func__, ctx->fs_rx->len);
> +
> +       return 0;
> +}
> +
> +int barebox_ratp(struct console_device *cdev)
> +{
> +       int ret;
> +       struct ratp_ctx *ctx;
> +       struct ratp *ratp;
> +
> +       if (ratp_command_ctx) {
> +               ctx = ratp_command_ctx;
> +       } else {
> +               ctx = xzalloc(sizeof(*ctx));
> +               ratp_command_ctx = ctx;
> +               ctx->ratp.send = console_send;
> +               ctx->ratp.recv = console_recv;
> +               ctx->console_recv_fifo = kfifo_alloc(512);
> +               ctx->console_transmit_fifo = kfifo_alloc(SZ_128K);
> +               ctx->poller.func = ratp_poller;
> +               ratp_console_register(ctx);
> +       }
> +
> +       if (ctx->cdev)
> +               return -EBUSY;
> +
> +       ratp = &ctx->ratp;
> +
> +       ctx->old_active = console_get_active(cdev);
> +       console_set_active(cdev, 0);
> +
> +       ctx->cdev = cdev;
> +       ctx->have_synch = 1;
> +
> +       ret = ratp_establish(ratp, false, 100);
> +       if (ret < 0)
> +               goto out;
> +
> +       ret = poller_register(&ctx->poller);
> +       if (ret)
> +               goto out1;
> +
> +       console_set_active(&ctx->ratp_console, CONSOLE_STDOUT | CONSOLE_STDERR |
> +                       CONSOLE_STDIN);
> +
> +       return 0;
> +
> +out1:
> +       ratp_close(ratp);
> +out:
> +       console_set_active(ctx->cdev, ctx->old_active);
> +       ctx->cdev = NULL;
> +
> +       return ret;
> +}
> +
> +static void barebox_ratp_close(void)
> +{
> +       if (ratp_command_ctx && ratp_command_ctx->cdev)
> +               ratp_console_unregister(ratp_command_ctx);
> +}
> +predevshutdown_exitcall(barebox_ratp_close);
> \ No newline at end of file
> diff --git a/crypto/Kconfig b/crypto/Kconfig
> index 41145a3..fcf92c9 100644
> --- a/crypto/Kconfig
> +++ b/crypto/Kconfig
> @@ -4,6 +4,7 @@ config CRC32
>         bool
>
>  config CRC16
> +       default y
>         bool
>
>  config CRC7
> diff --git a/fs/Makefile b/fs/Makefile
> index 4693205..befbdf2 100644
> --- a/fs/Makefile
> +++ b/fs/Makefile
> @@ -14,3 +14,4 @@ obj-$(CONFIG_FS_UIMAGEFS)     += uimagefs.o
>  obj-$(CONFIG_FS_EFI)    += efi.o
>  obj-$(CONFIG_FS_EFIVARFS) += efivarfs.o
>  obj-$(CONFIG_FS_SMHFS) += smhfs.o
> +obj-$(CONFIG_RATP)     += ratpfs.o
> diff --git a/include/ratp.h b/include/ratp.h
> index b91d305..94fd004 100644
> --- a/include/ratp.h
> +++ b/include/ratp.h
> @@ -19,4 +19,4 @@ bool ratp_busy(struct ratp *ratp);
>
>  void ratp_run_command(void);
>
> -#endif /* __RATP_H */
> +#endif /* __RATP_H */
> \ No newline at end of file
> diff --git a/lib/readline.c b/lib/readline.c
> index c007e10..681f125 100644
> --- a/lib/readline.c
> +++ b/lib/readline.c
> @@ -1,6 +1,8 @@
>  #include <common.h>
>  #include <readkey.h>
>  #include <init.h>
> +#include <poller.h>
> +#include <ratp.h>
>  #include <xfuncs.h>
>  #include <complete.h>
>  #include <linux/ctype.h>
> @@ -197,6 +199,11 @@ int readline(const char *prompt, char *buf, int len)
>         puts (prompt);
>
>         while (1) {
> +               while (!tstc()) {
> +                       poller_call();
> +                       ratp_run_command();

ratp_run_command() is not stubed out in <ratp.h> so this would break
linkage when RATP is not selected in Kconfig


> +               }
> +
>                 ichar = read_key();
>
>                 if ((ichar == '\n') || (ichar == '\r')) {
> --
> 2.6.4
>
>
> _______________________________________________
> barebox mailing list
> barebox@xxxxxxxxxxxxxxxxxxx
> http://lists.infradead.org/mailman/listinfo/barebox

_______________________________________________
barebox mailing list
barebox@xxxxxxxxxxxxxxxxxxx
http://lists.infradead.org/mailman/listinfo/barebox



[Index of Archives]     [Linux Embedded]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [XFree86]

  Powered by Linux