--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * QEMU GPIO device frontend.
+ *
+ * Author: 2025 Nikita Shubin <n.shubin@yadro.com>
+ *
+ */
+#include "qemu/osdep.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
+
+#include "gpiodev/gpio-fe.h"
+
+bool qemu_gpio_fe_init(GpioBackend *b, Gpiodev *s, uint32_t nlines,
+ const char *name, const char *label,
+ Error **errp)
+{
+ if (s->be) {
+ goto unavailable;
+ } else {
+ s->be = b;
+ }
+
+ qemu_gpiodev_set_info(s, nlines, name, label);
+ b->gpio = s;
+
+ return true;
+
+unavailable:
+ error_setg(errp, "chardev '%s' is already in use", s->label);
+ return false;
+}
+
+void qemu_gpio_fe_set_handlers(GpioBackend *b,
+ LineInfoHandler *line_info,
+ LineGetValueHandler *get_value,
+ LineSetValueHandler *set_value,
+ void *opaque)
+{
+ Gpiodev *s;
+
+ s = b->gpio;
+ if (!s) {
+ return;
+ }
+
+ b->line_info = line_info;
+ b->get_value = get_value;
+ b->set_value = set_value;
+ b->opaque = opaque;
+}
+
+bool qemu_gpio_fe_line_event(GpioBackend *b, uint32_t offset,
+ QEMUGpioLineEvent event)
+{
+ Gpiodev *gpio = b->gpio;
+
+ if (!gpio) {
+ return false;
+ }
+
+ qemu_gpio_line_event(gpio, offset, event);
+
+ return true;
+}
+
+bool qemu_gpio_fe_config_event(GpioBackend *b, uint32_t offset,
+ QEMUGpioConfigEvent event)
+{
+ Gpiodev *gpio = b->gpio;
+
+ if (!gpio) {
+ return false;
+ }
+
+ qemu_gpio_config_event(gpio, offset, event);
+
+ return true;
+}
+
+void qemu_gpio_fe_deinit(GpioBackend *b, bool del)
+{
+ assert(b);
+
+ if (b->gpio) {
+ qemu_gpio_fe_set_handlers(b, NULL, NULL, NULL, NULL);
+ if (b->gpio->be == b) {
+ b->gpio->be = NULL;
+ }
+
+ if (del) {
+ Object *obj = OBJECT(b->gpio);
+ if (obj->parent) {
+ object_unparent(obj);
+ } else {
+ object_unref(obj);
+ }
+ }
+
+ b->gpio = NULL;
+ }
+}
#include "qemu/osdep.h"
#include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
+#include "qemu/bitmap.h"
#include "qemu/config-file.h"
#include "qemu/option.h"
#include "qemu/qemu-print.h"
#include "qemu/help_option.h"
#include "gpiodev/gpio.h"
+#include "gpiodev/gpio-fe.h"
static Object *get_gpiodevs_root(void)
{
return object_get_container("gpiodevs");
}
+void qemu_gpiodev_set_info(Gpiodev *g, uint32_t nlines,
+ const char *name, const char *label)
+{
+ g->lines = nlines;
+ g_strlcpy(g->name, name, sizeof(g->name));
+ g_strlcpy(g->label, label, sizeof(g->label));
+
+ g->mask.risen = bitmap_new(nlines);
+ g->mask.fallen = bitmap_new(nlines);
+ g->mask.config = bitmap_new(nlines);
+}
+
+void qemu_gpio_chip_info(Gpiodev *g, uint32_t *nlines,
+ char *name, char *label)
+{
+ if (!g->be) {
+ g_strlcpy(name, "NULL", GPIO_MAX_NAME_SIZE);
+ g_strlcpy(label, "NULL", GPIO_MAX_NAME_SIZE);
+ *nlines = 0;
+ return;
+ }
+
+ g_strlcpy(name, g->name, GPIO_MAX_NAME_SIZE);
+ g_strlcpy(label, g->label, GPIO_MAX_NAME_SIZE);
+ *nlines = g->lines;
+}
+
+void qemu_gpio_line_info(Gpiodev *g, gpio_line_info *info)
+{
+ GpioBackend *be = g->be;
+
+ if (!be || !be->line_info) {
+ return;
+ }
+
+ be->line_info(be->opaque, info);
+}
+
+void qemu_gpio_set_line_value(Gpiodev *g, uint32_t offset, uint8_t value)
+{
+ GpioBackend *be = g->be;
+
+ if (!be || !be->set_value) {
+ return;
+ }
+
+ be->set_value(be->opaque, offset, value);
+}
+
+uint8_t qemu_gpio_get_line_value(Gpiodev *g, uint32_t offset)
+{
+ GpioBackend *be = g->be;
+
+ if (!be || !be->get_value) {
+ return 0;
+ }
+
+ return be->get_value(be->opaque, offset);
+}
+
+void qemu_gpio_add_event_watch(Gpiodev *g, uint32_t offset, uint64_t flags)
+{
+ if (flags & GPIO_EVENT_RISING_EDGE) {
+ set_bit(offset, g->mask.risen);
+ }
+
+ if (flags & GPIO_EVENT_FALLING_EDGE) {
+ set_bit(offset, g->mask.fallen);
+ }
+}
+
+void qemu_gpio_clear_event_watch(Gpiodev *g, uint32_t offset, uint64_t flags)
+{
+ if (flags & GPIO_EVENT_RISING_EDGE) {
+ clear_bit(offset, g->mask.risen);
+ }
+
+ if (flags & GPIO_EVENT_FALLING_EDGE) {
+ clear_bit(offset, g->mask.fallen);
+ }
+}
+
+void qemu_gpio_add_config_watch(Gpiodev *g, uint32_t offset)
+{
+ set_bit(offset, g->mask.config);
+}
+
+void qemu_gpio_clear_config_watch(Gpiodev *g, uint32_t offset)
+{
+ clear_bit(offset, g->mask.config);
+}
+
+void qemu_gpio_clear_watches(Gpiodev *g)
+{
+ bitmap_zero(g->mask.risen, g->lines);
+ bitmap_zero(g->mask.fallen, g->lines);
+ bitmap_zero(g->mask.config, g->lines);
+}
+
+void qemu_gpio_line_event(Gpiodev *g, uint32_t offset,
+ QEMUGpioLineEvent event)
+{
+ GpiodevClass *gc = GPIODEV_GET_CLASS(g);
+ bool notify = false;
+
+ if (!gc->line_event) {
+ return;
+ }
+
+ if (event & GPIO_EVENT_RISING_EDGE) {
+ if (test_bit(offset, g->mask.risen)) {
+ notify = true;
+ }
+ }
+
+ if (event & GPIO_EVENT_FALLING_EDGE) {
+ if (test_bit(offset, g->mask.fallen)) {
+ notify = true;
+ }
+ }
+
+ if (notify) {
+ gc->line_event(g, offset, event);
+ }
+}
+
+void qemu_gpio_config_event(Gpiodev *g, uint32_t offset,
+ QEMUGpioConfigEvent event)
+{
+ GpiodevClass *gc = GPIODEV_GET_CLASS(g);
+
+ if (!gc->config_event) {
+ return;
+ }
+
+ if (test_bit(offset, g->mask.config)) {
+ gc->config_event(g, offset, event);
+ }
+}
+
+static void qemu_gpio_finalize(Object *obj)
+{
+ Gpiodev *d = GPIODEV(obj);
+
+ g_free(d->mask.risen);
+ g_free(d->mask.fallen);
+ g_free(d->mask.config);
+}
+
static const TypeInfo gpiodev_types_info[] = {
{
.name = TYPE_GPIODEV,
.parent = TYPE_OBJECT,
.instance_size = sizeof(Gpiodev),
+ .instance_finalize = qemu_gpio_finalize,
.abstract = true,
+ .class_size = sizeof(GpiodevClass),
},
};
DEFINE_TYPES(gpiodev_types_info);
-static Gpiodev *gpiodev_new(const char *id,
+static void qemu_gpio_open(Gpiodev *gpio, GpiodevBackend *backend,
+ Error **errp)
+{
+ GpiodevClass *gc = GPIODEV_GET_CLASS(gpio);
+
+ if (gc->open) {
+ gc->open(gpio, backend, errp);
+ }
+}
+
+static Gpiodev *gpiodev_new(const char *id, const char *typename,
+ GpiodevBackend *backend,
GMainContext *gcontext,
Error **errp)
{
Object *obj;
Gpiodev *gpio = NULL;
+ Error *local_err = NULL;
+ assert(g_str_has_prefix(typename, "gpiodev-"));
assert(id);
- obj = object_new(TYPE_GPIODEV);
+ obj = object_new(typename);
gpio = GPIODEV(obj);
gpio->gcontext = gcontext;
+ qemu_gpio_open(gpio, backend, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ object_unref(obj);
+ return NULL;
+ }
+
return gpio;
}
-static Gpiodev *qemu_gpiodev_new(const char *id,
+static Gpiodev *qemu_gpiodev_new(const char *id, const char *typename,
+ GpiodevBackend *backend,
GMainContext *gcontext,
Error **errp)
{
Gpiodev *gpio;
- gpio = gpiodev_new(id, gcontext, errp);
+ gpio = gpiodev_new(id, typename, backend, gcontext, errp);
if (!gpio) {
return NULL;
}
g_string_append_printf(str, "\n %s", name);
}
+static const GpiodevClass *gpio_get_class(const char *driver, Error **errp)
+{
+ ObjectClass *oc;
+ char *typename = g_strdup_printf("gpiodev-%s", driver);
+
+ oc = module_object_class_by_name(typename);
+ g_free(typename);
+
+ if (!object_class_dynamic_cast(oc, TYPE_GPIODEV)) {
+ error_setg(errp, "'%s' is not a valid gpio driver name", driver);
+ return NULL;
+ }
+
+ if (object_class_is_abstract(oc)) {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
+ "a non-abstract device type");
+ return NULL;
+ }
+
+ return GPIODEV_CLASS(oc);
+}
+
+static GpiodevBackend *qemu_gpio_parse_opts(QemuOpts *opts, Error **errp)
+{
+ Error *local_err = NULL;
+ const GpiodevClass *gc;
+ GpiodevBackend *backend = NULL;
+ const char *name = qemu_opt_get(opts, "backend");
+
+ if (name == NULL) {
+ error_setg(errp, "gpiodev: \"%s\" missing backend",
+ qemu_opts_id(opts));
+ return NULL;
+ }
+
+ gc = gpio_get_class(name, errp);
+ if (gc == NULL) {
+ return NULL;
+ }
+
+ backend = g_new0(GpiodevBackend, 1);
+ if (gc->parse) {
+ gc->parse(opts, backend, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ qapi_free_GpiodevBackend(backend);
+ return NULL;
+ }
+ }
+
+ return backend;
+}
+
Gpiodev *qemu_gpiodev_add(QemuOpts *opts, GMainContext *context,
Error **errp)
{
const char *id = qemu_opts_id(opts);
const char *name = qemu_opt_get(opts, "backend");
+ const GpiodevClass *gc;
+ GpiodevBackend *backend = NULL;
+ Gpiodev *gpio = NULL;
if (name && is_help_option(name)) {
GString *str = g_string_new("");
return NULL;
}
- return qemu_gpiodev_new(id, context, errp);
+ backend = qemu_gpio_parse_opts(opts, errp);
+ if (backend == NULL) {
+ return NULL;
+ }
+
+ gc = gpio_get_class(name, errp);
+ if (gc == NULL) {
+ goto out;
+ }
+
+ gpio = qemu_gpiodev_new(id, object_class_get_name(OBJECT_CLASS(gc)),
+ backend, context, errp);
+
+out:
+ qapi_free_GpiodevBackend(backend);
+ return gpio;
}
static QemuOptsList qemu_gpiodev_opts = {
{
.name = "backend",
.type = QEMU_OPT_STRING,
+ }, {
+ .name = "chardev",
+ .type = QEMU_OPT_STRING,
+ .help = "Chardev id (for gpiodev-chardev)",
+ }, {
+ .name = "devname",
+ .type = QEMU_OPT_STRING,
+ .help = "Device name (for gpiodev-guse)",
},
{ /* end of list */ }
},
gpiodev_ss.add(files(
+ 'gpio-fe.c',
'gpio.c',
))
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * QEMU GPIO device frontend.
+ *
+ * Author: 2025 Nikita Shubin <n.shubin@yadro.com>
+ *
+ */
+#ifndef QEMU_GPIO_FE_H
+#define QEMU_GPIO_FE_H
+
+#include "qemu/main-loop.h"
+
+#include "gpiodev/gpio.h"
+
+/**
+ * LineInfoHandler: Return the gpio line info specified by offset
+ */
+typedef void LineInfoHandler(void *opaque, gpio_line_info *info);
+
+/**
+ * LineInfoHandler: Return the gpio line value specified by offset
+ */
+typedef int LineGetValueHandler(void *opaque, uint32_t offset);
+
+/**
+ * LineSetValueHandler: Set the gpio line value specified by offset
+ */
+typedef int LineSetValueHandler(void *opaque, uint32_t offset, uint8_t value);
+
+/**
+ * struct GpioBackend - back end as seen by front end
+ *
+ * The actual backend is Gpiodev
+ */
+struct GpioBackend {
+ Gpiodev *gpio;
+ LineInfoHandler *line_info;
+ LineGetValueHandler *get_value;
+ LineSetValueHandler *set_value;
+ void *opaque;
+};
+
+/**
+ * qemu_gpio_fe_deinit:
+ *
+ * @b: a GpioBackend
+ * @s: a Gpiodev
+ * @nlines: number of lines in the GPIO Port
+ * @name: name of the GPIO Port
+ * @label: label of the GPIO Port
+ * @errp: error if any
+ *
+ * Initializes a front end for the given GpioBackend and
+ * Gpiodev. Call qemu_gpio_fe_deinit() to remove the association and
+ * release the driver.
+ *
+ * nlines, name and label used for proving information
+ * via qemu_gpiodev_set_info().
+ *
+ * Returns: false on error.
+ */
+bool qemu_gpio_fe_init(GpioBackend *b, Gpiodev *s, uint32_t nlines,
+ const char *name, const char *label,
+ Error **errp);
+
+/**
+ * qemu_gpio_fe_set_handlers:
+ *
+ * @b: a GpioBackend
+ * @s: a Gpiodev
+ * @line_info: Line info handler to provide info about line
+ * @get_value: Get line value handler
+ * @set_value: Set line value handler
+ * @opaque: an opaque pointer for the callbacks
+ * @context: a main loop context or NULL for the default
+ *
+ * Set the front end gpio handlers.
+ *
+ */
+void qemu_gpio_fe_set_handlers(GpioBackend *b,
+ LineInfoHandler *line_info,
+ LineGetValueHandler *get_value,
+ LineSetValueHandler *set_value,
+ void *opaque);
+
+/**
+ * qemu_gpio_fe_deinit:
+ *
+ * @b: a GpioBackend
+ * @del: if true, delete the gpiodev backend
+ *
+ * Dissociate the GpioBackend from the Gpiodev.
+ *
+ * Safe to call without associated Gpiodev.
+ */
+void qemu_gpio_fe_deinit(GpioBackend *b, bool del);
+
+/**
+ * qemu_gpio_fe_line_event:
+ *
+ * @b: a GpioBackend
+ * @offset: line number offset
+ * @event: rising or falling edge event
+ *
+ * See enum QEMUGpioEvent.
+ */
+bool qemu_gpio_fe_line_event(GpioBackend *b, uint32_t offset,
+ QEMUGpioLineEvent event);
+
+/**
+ * qemu_gpio_fe_config_event:
+ *
+ * @b: a GpioBackend
+ * @offset: line number offset
+ * @event: requested, released or input/output toggle
+ *
+ * See enum QEMUGpioConfigEvent.
+ */
+bool qemu_gpio_fe_config_event(GpioBackend *b, uint32_t offset,
+ QEMUGpioConfigEvent event);
+
+#endif /* QEMU_GPIO_FE_H */
#ifndef QEMU_GPIO_H
#define QEMU_GPIO_H
+#include "qapi/qapi-types-gpio.h"
#include "qom/object.h"
+#include "qemu/bitops.h"
/* gpio back-end device */
typedef struct GpioBackend GpioBackend;
+#define GPIO_MAX_NAME_SIZE 32
+
+/* compatible with enum gpio_v2_line_flag */
+typedef enum QEMUGpioLineFlags {
+ GPIO_LINE_FLAG_INPUT = BIT_ULL(2),
+ GPIO_LINE_FLAG_OUTPUT = BIT_ULL(3),
+} QEMUGpioLineFlags;
+
+typedef enum QEMUGpioLineEvent {
+ GPIO_EVENT_RISING_EDGE = 1,
+ GPIO_EVENT_FALLING_EDGE = 2,
+} QEMUGpioLineEvent;
+
+typedef enum QEMUGpioConfigEvent {
+ GPIO_LINE_CHANGED_REQUESTED = 1,
+ GPIO_LINE_CHANGED_RELEASED = 2,
+ GPIO_LINE_CHANGED_CONFIG = 3,
+} QEMUGpioConfigEvent;
+
struct Gpiodev {
Object parent_obj;
GpioBackend *be;
+ uint32_t lines;
+ char name[GPIO_MAX_NAME_SIZE];
+ char label[GPIO_MAX_NAME_SIZE];
+
+ struct {
+ unsigned long *risen;
+ unsigned long *fallen;
+ unsigned long *config;
+ } mask;
+
GMainContext *gcontext;
};
+#define TYPE_GPIODEV "gpiodev"
+OBJECT_DECLARE_TYPE(Gpiodev, GpiodevClass, GPIODEV)
+
struct GpiodevClass {
ObjectClass parent_class;
+
+ /* parse command line options and populate QAPI @backend */
+ void (*parse)(QemuOpts *opts, GpiodevBackend *backend, Error **errp);
+
+ /* called after construction, open/starts the backend */
+ void (*open)(Gpiodev *gpio, GpiodevBackend *backend, Error **errp);
+
+ /* notify backend about line event */
+ void (*line_event)(Gpiodev *g, uint32_t offset,
+ QEMUGpioLineEvent event);
+
+ /* notify backend about config event */
+ void (*config_event)(Gpiodev *g, uint32_t offset,
+ QEMUGpioConfigEvent event);
};
-#define TYPE_GPIODEV "gpiodev"
-OBJECT_DECLARE_TYPE(Gpiodev, GpiodevClass, GPIODEV)
+/**
+ * qemu_gpiodev_set_info:
+ *
+ * @g: a Gpiodev
+ * @nlines: number of lines in the GPIO Port
+ * @name: name of the GPIO Port
+ * @label: label of the GPIO Port
+ *
+ * Set basic info about GPIO Port, used by backends to provide data
+ * to client applications.
+ *
+ * nlines, name and label used for proving information
+ * via qemu_gpio_chip_info().
+ */
+void qemu_gpiodev_set_info(Gpiodev *g, uint32_t nlines,
+ const char *name, const char *label);
+
+/**
+ * qemu_gpio_chip_info:
+ *
+ * @g: a Gpiodev
+ * @nlines: lines number of the GPIO Port will be set
+ * @name: name of the GPIO Port will be set
+ * @label: label of the GPIO Port will be set
+ *
+ * If GpioBackend is NULL, nlines will be set to zero and
+ * both name and label to NULL.
+ */
+void qemu_gpio_chip_info(Gpiodev *g, uint32_t *nlines,
+ char *name, char *label);
+
+typedef struct gpio_line_info {
+ char name[GPIO_MAX_NAME_SIZE];
+ char consumer[GPIO_MAX_NAME_SIZE];
+ uint32_t offset;
+ uint64_t flags;
+} gpio_line_info;
+
+/**
+ * qemu_gpio_line_info:
+ *
+ * @g: a Gpiodev
+ * @info: info about requested line
+ *
+ * info->offset should be provided see gpio_line_info.
+ */
+void qemu_gpio_line_info(Gpiodev *g, gpio_line_info *info);
+
+/**
+ * qemu_gpio_set_line_value:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ * @value: line value
+ */
+void qemu_gpio_set_line_value(Gpiodev *g, uint32_t offset, uint8_t value);
+
+/**
+ * qemu_gpio_get_line_value:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ *
+ * returns 0 or 1 line status
+ */
+uint8_t qemu_gpio_get_line_value(Gpiodev *g, uint32_t offset);
+
+/**
+ * qemu_gpio_add_event_watch:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ * @flags: event flags
+ *
+ * See QEMUGpioLineEvent.
+ *
+ * Add lines specified by mask and flags to watch, called by GpiodevBackend to subscribe
+ * desired lines and events.
+ */
+void qemu_gpio_add_event_watch(Gpiodev *g, uint32_t offset, uint64_t flags);
+
+/**
+ * qemu_gpio_clear_event_watch:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ * @flags: event flags
+ *
+ * See QEMUGpioLineEvent.
+ *
+ * Remove lines specified by mask and flags from watch, called by GpiodevBackend.
+ */
+void qemu_gpio_clear_event_watch(Gpiodev *g, uint32_t offset, uint64_t flags);
+
+/**
+ * qemu_gpio_add_config_watch:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ *
+ * See QEMUGpioConfigEvent.
+ *
+ * Add lines specified by mask to watch, called by GpiodevBackend to subscribe
+ * about desired lines config change.
+ */
+void qemu_gpio_add_config_watch(Gpiodev *g, uint32_t offset);
+
+/**
+ * qemu_gpio_clear_config_watch:
+ *
+ * @g: a Gpiodev
+ * @mask: lines mask to clear
+ *
+ * See QEMUGpioConfigEvent.
+ *
+ * Remove lines specified by mask from watch, called by GpiodevBackend.
+ */
+void qemu_gpio_clear_config_watch(Gpiodev *g, uint32_t offset);
+
+void qemu_gpio_clear_watches(Gpiodev *g);
+
+
+/**
+ * qemu_gpio_line_event:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ * @event: event
+ *
+ * See QEMUGpioLineEvent.
+ *
+ * Called by GpioBackend to notify Gpiodev about line event, i.e. line set to 0/1.
+ */
+void qemu_gpio_line_event(Gpiodev *gpio, uint32_t offset,
+ QEMUGpioLineEvent event);
+
+/**
+ * qemu_gpio_config_event:
+ *
+ * @g: a Gpiodev
+ * @offset: line offset
+ * @event: event
+ *
+ * See QEMUGpioConfigEvent.
+ *
+ * Called by GpioBackend to notify Gpiodev about line config event,
+ * i.e. input switched to output.
+ */
+void qemu_gpio_config_event(Gpiodev *g, uint32_t offset,
+ QEMUGpioConfigEvent event);
Gpiodev *qemu_gpiodev_add(QemuOpts *opts, GMainContext *context,
Error **errp);
static const char *const root_containers[] = {
"chardevs",
+ "gpiodevs",
"objects",
"backend"
};
projects / qemu.git / commitdiff