[libgpiod,v3,11/14] bindings: python: add support for SET_CONFIG
diff mbox series

Message ID 20191125143157.26154-12-warthog618@gmail.com
State New
Headers show
Series
  • Add support for bias flags and SET_CONFIG
Related show

Commit Message

Kent Gibson Nov. 25, 2019, 2:31 p.m. UTC
Add methods to support setting line configuration.

Signed-off-by: Kent Gibson <warthog618@gmail.com>
---
 bindings/python/gpiodmodule.c | 381 +++++++++++++++++++++++++++++++++-
 1 file changed, 379 insertions(+), 2 deletions(-)

Comments

Bartosz Golaszewski Nov. 28, 2019, 10:29 a.m. UTC | #1
pon., 25 lis 2019 o 15:33 Kent Gibson <warthog618@gmail.com> napisaƂ(a):
>
> Add methods to support setting line configuration.
>
> Signed-off-by: Kent Gibson <warthog618@gmail.com>
> ---
>  bindings/python/gpiodmodule.c | 381 +++++++++++++++++++++++++++++++++-
>  1 file changed, 379 insertions(+), 2 deletions(-)
>
> diff --git a/bindings/python/gpiodmodule.c b/bindings/python/gpiodmodule.c
> index 4723771..4f5e117 100644
> --- a/bindings/python/gpiodmodule.c
> +++ b/bindings/python/gpiodmodule.c
> @@ -585,14 +585,149 @@ static PyObject *gpiod_Line_set_value(gpiod_LineObject *self, PyObject *args)
>         if (!bulk_obj)
>                 return NULL;
>
> -       vals = Py_BuildValue("((O))", val);
> +       vals = Py_BuildValue("(O)", val);

Please don't try to sneak in changes like this. If you think this
should be changed, make it a separate commit with proper explanation.
I vaguely remember using this because previously I didn't use
PyObject_CallMethod() but called the set_values() function directly
and it was easier to package it right away. Anyway - is it broken? Do
we gain something from changing it? If so, let's have a separate patch
for this.

>         if (!vals) {
>                 Py_DECREF(bulk_obj);
>                 return NULL;
>         }
>
>         ret = PyObject_CallMethod((PyObject *)bulk_obj,
> -                                 "set_values", "O", vals);
> +                                 "set_values", "(O)", vals);
> +       Py_DECREF(bulk_obj);
> +       Py_DECREF(vals);
> +
> +       return ret;
> +}
> +
> +PyDoc_STRVAR(gpiod_Line_set_config_doc,
> +"set_config(direction,flags,value) -> None\n"
> +"\n"
> +"Set the configuration of this GPIO line.\n"
> +"\n"
> +"  direction\n"
> +"    New direction (integer)\n"
> +"  flags\n"
> +"    New flags (integer)\n"
> +"  value\n"
> +"    New value (integer)");
> +
> +static PyObject *gpiod_Line_set_config(gpiod_LineObject *self, PyObject *args)
> +{
> +       gpiod_LineBulkObject *bulk_obj;
> +       PyObject *dirn, *flags, *val, *vals, *ret;
> +       int rv;
> +
> +       val = NULL;
> +       rv = PyArg_ParseTuple(args, "OO|O", &dirn, &flags, &val);
> +       if (!rv)
> +               return NULL;
> +
> +       bulk_obj = gpiod_LineToLineBulk(self);
> +       if (!bulk_obj)
> +               return NULL;
> +
> +       if (val) {
> +               vals = Py_BuildValue("(O)", val);
> +               if (!vals) {
> +                       Py_DECREF(bulk_obj);
> +                       return NULL;
> +               }
> +               ret = PyObject_CallMethod((PyObject *)bulk_obj,
> +                               "set_config", "OO(O)", dirn, flags, vals);
> +               Py_DECREF(vals);
> +       } else
> +               ret = PyObject_CallMethod((PyObject *)bulk_obj,
> +                               "set_config", "OO", dirn, flags);

Please use brackets here even if it's a single line after you used it
in the first branch. Same elsewhere if needed.

> +
> +       Py_DECREF(bulk_obj);
> +
> +       return ret;
> +}
> +
> +PyDoc_STRVAR(gpiod_Line_set_flags_doc,
> +"set_flags(flags) -> None\n"
> +"\n"
> +"Set the flags of this GPIO line.\n"
> +"\n"
> +"  flags\n"
> +"    New flags (integer)");
> +
> +static PyObject *gpiod_Line_set_flags(gpiod_LineObject *self, PyObject *args)
> +{
> +       gpiod_LineBulkObject *bulk_obj;
> +       PyObject *ret;
> +
> +       bulk_obj = gpiod_LineToLineBulk(self);
> +       if (!bulk_obj)
> +               return NULL;
> +
> +       ret = PyObject_CallMethod((PyObject *)bulk_obj,
> +                                 "set_flags", "O", args);
> +       Py_DECREF(bulk_obj);
> +
> +       return ret;
> +}
> +
> +PyDoc_STRVAR(gpiod_Line_set_direction_input_doc,
> +"set_direction_input() -> None\n"
> +"\n"
> +"Set the direction of this GPIO line to input.\n");
> +
> +static PyObject *gpiod_Line_set_direction_input(gpiod_LineObject *self,
> +                                               PyObject *Py_UNUSED(ignored))
> +{
> +       gpiod_LineBulkObject *bulk_obj;
> +       PyObject *ret;
> +
> +       bulk_obj = gpiod_LineToLineBulk(self);
> +       if (!bulk_obj)
> +               return NULL;
> +
> +       ret = PyObject_CallMethod((PyObject *)bulk_obj,
> +                                 "set_direction_input", "");
> +       Py_DECREF(bulk_obj);
> +
> +       return ret;
> +}
> +
> +PyDoc_STRVAR(gpiod_Line_set_direction_output_doc,
> +"set_direction_output(value) -> None\n"
> +"\n"
> +"Set the direction of this GPIO line to output.\n"
> +"\n"
> +"  value\n"
> +"    New value (integer)");
> +
> +static PyObject *gpiod_Line_set_direction_output(gpiod_LineObject *self,
> +                                                PyObject *args)
> +{
> +       gpiod_LineBulkObject *bulk_obj;
> +       PyObject *val, *vals, *ret;
> +       int rv;
> +       const char *fmt;
> +
> +       val = NULL;
> +       rv = PyArg_ParseTuple(args, "|O", &val);
> +       if (!rv)
> +               return NULL;
> +
> +       if (val) {
> +               fmt = "(O)";
> +               vals = Py_BuildValue(fmt, val);
> +       } else {
> +               vals = Py_BuildValue("()");
> +               fmt = "O"; /* pass empty args to bulk */
> +       }
> +       if (!vals)
> +               return NULL;
> +
> +       bulk_obj = gpiod_LineToLineBulk(self);
> +       if (!bulk_obj)
> +               return NULL;
> +
> +       ret = PyObject_CallMethod((PyObject *)bulk_obj,
> +                                 "set_direction_output", fmt, vals);
> +
>         Py_DECREF(bulk_obj);
>         Py_DECREF(vals);
>
> @@ -838,6 +973,30 @@ static PyMethodDef gpiod_Line_methods[] = {
>                 .ml_flags = METH_VARARGS,
>                 .ml_doc = gpiod_Line_set_value_doc,
>         },
> +       {
> +               .ml_name = "set_config",
> +               .ml_meth = (PyCFunction)gpiod_Line_set_config,
> +               .ml_flags = METH_VARARGS,
> +               .ml_doc = gpiod_Line_set_config_doc,
> +       },
> +       {
> +               .ml_name = "set_flags",
> +               .ml_meth = (PyCFunction)gpiod_Line_set_flags,
> +               .ml_flags = METH_VARARGS,
> +               .ml_doc = gpiod_Line_set_flags_doc,
> +       },
> +       {
> +               .ml_name = "set_direction_input",
> +               .ml_meth = (PyCFunction)gpiod_Line_set_direction_input,
> +               .ml_flags = METH_NOARGS,
> +               .ml_doc = gpiod_Line_set_direction_input_doc,
> +       },
> +       {
> +               .ml_name = "set_direction_output",
> +               .ml_meth = (PyCFunction)gpiod_Line_set_direction_output,
> +               .ml_flags = METH_VARARGS,
> +               .ml_doc = gpiod_Line_set_direction_output_doc,
> +       },
>         {
>                 .ml_name = "release",
>                 .ml_meth = (PyCFunction)gpiod_Line_release,
> @@ -1283,6 +1442,200 @@ static PyObject *gpiod_LineBulk_set_values(gpiod_LineBulkObject *self,
>         Py_RETURN_NONE;
>  }
>
> +static int convert_values(PyObject *src, int *dst, Py_ssize_t n)

Coding convention and readability: this module is a bit different as I
tried to stay consistent with Python C code when naming symbols.
Please use the common 'gpiod_' prefix even for non-exported functions
and maybe name this routine something else as "convert_values" doesn't
really indicate concrete functionality. I'm still not sure what it
does.


> +{
> +       int val;
> +       Py_ssize_t num_vals, i;
> +       PyObject *iter, *next;
> +
> +       num_vals = PyObject_Size(src);
> +       if (num_vals != n) {
> +               PyErr_SetString(PyExc_TypeError,
> +                       "Number of values must correspond to the number of lines");
> +               return -1;
> +       }
> +       iter = PyObject_GetIter(src);
> +       if (!iter)
> +               return -1;
> +       for (i = 0;; i++) {
> +               next = PyIter_Next(iter);
> +               if (!next) {
> +                       Py_DECREF(iter);
> +                       break;
> +               }
> +               val = PyLong_AsLong(next);
> +               Py_DECREF(next);
> +               if (PyErr_Occurred()) {
> +                       Py_DECREF(iter);
> +                       return -1;
> +               }
> +               dst[i] = (int)val;
> +       }
> +       return 0;
> +}
> +
> +PyDoc_STRVAR(gpiod_LineBulk_set_config_doc,
> +"set_config(direction,flags,values) -> None\n"
> +"\n"
> +"Set the configuration of all the lines held by this LineBulk object.\n"
> +"\n"
> +"  direction\n"
> +"    New direction (integer)\n"
> +"  flags\n"
> +"    New flags (integer)\n"
> +"  values\n"
> +"    List of values (integers) to set when direction is output.\n"
> +"\n"
> +"The number of values in the list passed as argument must be the same as\n"
> +"the number of lines held by this gpiod.LineBulk object. The index of each\n"
> +"value corresponds to the index of each line in the object.\n");
> +
> +static PyObject *gpiod_LineBulk_set_config(gpiod_LineBulkObject *self,
> +                                          PyObject *args)
> +{
> +       int rv, vals[GPIOD_LINE_BULK_MAX_LINES];
> +       PyObject *val_list;
> +       struct gpiod_line_bulk bulk;
> +       const int *valp;
> +       int dirn, flags;
> +
> +       if (gpiod_LineBulkOwnerIsClosed(self))
> +               return NULL;
> +
> +       gpiod_LineBulkObjToCLineBulk(self, &bulk);
> +
> +       val_list = NULL;
> +       rv = PyArg_ParseTuple(args, "ii|(O)", &dirn, &flags, &val_list);
> +       if (!rv)
> +               return NULL;
> +
> +       if (val_list == NULL)
> +               valp = NULL;
> +       else {
> +               memset(vals, 0, sizeof(vals));
> +               rv = convert_values(val_list, vals, self->num_lines);
> +               if (rv)
> +                       return NULL;
> +               valp = vals;
> +       }
> +
> +       Py_BEGIN_ALLOW_THREADS;
> +       rv = gpiod_line_set_config_bulk(&bulk, dirn, flags, valp);
> +       Py_END_ALLOW_THREADS;
> +       if (rv)
> +               return PyErr_SetFromErrno(PyExc_OSError);
> +
> +       Py_RETURN_NONE;
> +}
> +
> +PyDoc_STRVAR(gpiod_LineBulk_set_flags_doc,
> +"set_flags(flags) -> None\n"
> +"\n"
> +"Set the flags of all the lines held by this LineBulk object.\n"
> +"\n"
> +"  flags\n"
> +"    New flags (integer)");
> +
> +static PyObject *gpiod_LineBulk_set_flags(gpiod_LineBulkObject *self,
> +                                         PyObject *args)
> +{
> +       int rv;
> +       struct gpiod_line_bulk bulk;
> +       int flags;
> +
> +       if (gpiod_LineBulkOwnerIsClosed(self))
> +               return NULL;
> +
> +       gpiod_LineBulkObjToCLineBulk(self, &bulk);
> +
> +       rv = PyArg_ParseTuple(args, "i", &flags);
> +       if (!rv)
> +               return NULL;
> +
> +       Py_BEGIN_ALLOW_THREADS;
> +       rv = gpiod_line_set_flags_bulk(&bulk, flags);
> +       Py_END_ALLOW_THREADS;
> +       if (rv)
> +               return PyErr_SetFromErrno(PyExc_OSError);
> +
> +       Py_RETURN_NONE;
> +}
> +
> +PyDoc_STRVAR(gpiod_LineBulk_set_direction_input_doc,
> +"set_direction_input() -> None\n"
> +"\n"
> +"Set the direction of all the lines held by this LineBulk object to input.\n");
> +
> +static PyObject *gpiod_LineBulk_set_direction_input(gpiod_LineBulkObject *self,
> +                                               PyObject *Py_UNUSED(ignored))
> +{
> +       struct gpiod_line_bulk bulk;
> +       int rv;
> +
> +       if (gpiod_LineBulkOwnerIsClosed(self))
> +               return NULL;
> +
> +       gpiod_LineBulkObjToCLineBulk(self, &bulk);
> +
> +       Py_BEGIN_ALLOW_THREADS;
> +       rv = gpiod_line_set_direction_input_bulk(&bulk);
> +       Py_END_ALLOW_THREADS;
> +       if (rv)
> +               return PyErr_SetFromErrno(PyExc_OSError);
> +
> +       Py_RETURN_NONE;
> +}
> +
> +PyDoc_STRVAR(gpiod_LineBulk_set_direction_output_doc,
> +"set_direction_output(value) -> None\n"
> +"\n"
> +"Set the direction of all the lines held by this LineBulk object to output.\n"
> +"\n"
> +"  values\n"
> +"    List of values (integers) to set when direction is output.\n"
> +"\n"
> +"The number of values in the list passed as argument must be the same as\n"
> +"the number of lines held by this gpiod.LineBulk object. The index of each\n"
> +"value corresponds to the index of each line in the object.\n");
> +
> +static PyObject *gpiod_LineBulk_set_direction_output(
> +                               gpiod_LineBulkObject *self,
> +                               PyObject *args)
> +{
> +       int rv, vals[GPIOD_LINE_BULK_MAX_LINES];
> +       PyObject *val_list;
> +       struct gpiod_line_bulk bulk;
> +       const int *valp;
> +
> +       if (gpiod_LineBulkOwnerIsClosed(self))
> +               return NULL;
> +
> +       gpiod_LineBulkObjToCLineBulk(self, &bulk);
> +
> +       val_list = NULL;
> +       rv = PyArg_ParseTuple(args, "|O", &val_list);
> +       if (!rv)
> +               return NULL;
> +
> +       if (val_list == NULL)
> +               valp = NULL;
> +       else {
> +               memset(vals, 0, sizeof(vals));
> +               rv = convert_values(val_list, vals, self->num_lines);
> +               if (rv)
> +                       return NULL;
> +               valp = vals;
> +       }
> +
> +       Py_BEGIN_ALLOW_THREADS;
> +       rv = gpiod_line_set_direction_output_bulk(&bulk, valp);
> +       Py_END_ALLOW_THREADS;
> +       if (rv)
> +               return PyErr_SetFromErrno(PyExc_OSError);
> +
> +       Py_RETURN_NONE;
> +}
> +
>  PyDoc_STRVAR(gpiod_LineBulk_release_doc,
>  "release() -> None\n"
>  "\n"
> @@ -1431,6 +1784,30 @@ static PyMethodDef gpiod_LineBulk_methods[] = {
>                 .ml_doc = gpiod_LineBulk_set_values_doc,
>                 .ml_flags = METH_VARARGS,
>         },
> +       {
> +               .ml_name = "set_config",
> +               .ml_meth = (PyCFunction)gpiod_LineBulk_set_config,
> +               .ml_flags = METH_VARARGS,
> +               .ml_doc = gpiod_LineBulk_set_config_doc,
> +       },
> +       {
> +               .ml_name = "set_flags",
> +               .ml_meth = (PyCFunction)gpiod_LineBulk_set_flags,
> +               .ml_flags = METH_VARARGS,
> +               .ml_doc = gpiod_LineBulk_set_flags_doc,
> +       },
> +       {
> +               .ml_name = "set_direction_input",
> +               .ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_input,
> +               .ml_flags = METH_NOARGS,
> +               .ml_doc = gpiod_LineBulk_set_direction_input_doc,
> +       },
> +       {
> +               .ml_name = "set_direction_output",
> +               .ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_output,
> +               .ml_flags = METH_VARARGS,
> +               .ml_doc = gpiod_LineBulk_set_direction_output_doc,
> +       },
>         {
>                 .ml_name = "release",
>                 .ml_meth = (PyCFunction)gpiod_LineBulk_release,
> --
> 2.24.0
>

Patch
diff mbox series

diff --git a/bindings/python/gpiodmodule.c b/bindings/python/gpiodmodule.c
index 4723771..4f5e117 100644
--- a/bindings/python/gpiodmodule.c
+++ b/bindings/python/gpiodmodule.c
@@ -585,14 +585,149 @@  static PyObject *gpiod_Line_set_value(gpiod_LineObject *self, PyObject *args)
 	if (!bulk_obj)
 		return NULL;
 
-	vals = Py_BuildValue("((O))", val);
+	vals = Py_BuildValue("(O)", val);
 	if (!vals) {
 		Py_DECREF(bulk_obj);
 		return NULL;
 	}
 
 	ret = PyObject_CallMethod((PyObject *)bulk_obj,
-				  "set_values", "O", vals);
+				  "set_values", "(O)", vals);
+	Py_DECREF(bulk_obj);
+	Py_DECREF(vals);
+
+	return ret;
+}
+
+PyDoc_STRVAR(gpiod_Line_set_config_doc,
+"set_config(direction,flags,value) -> None\n"
+"\n"
+"Set the configuration of this GPIO line.\n"
+"\n"
+"  direction\n"
+"    New direction (integer)\n"
+"  flags\n"
+"    New flags (integer)\n"
+"  value\n"
+"    New value (integer)");
+
+static PyObject *gpiod_Line_set_config(gpiod_LineObject *self, PyObject *args)
+{
+	gpiod_LineBulkObject *bulk_obj;
+	PyObject *dirn, *flags, *val, *vals, *ret;
+	int rv;
+
+	val = NULL;
+	rv = PyArg_ParseTuple(args, "OO|O", &dirn, &flags, &val);
+	if (!rv)
+		return NULL;
+
+	bulk_obj = gpiod_LineToLineBulk(self);
+	if (!bulk_obj)
+		return NULL;
+
+	if (val) {
+		vals = Py_BuildValue("(O)", val);
+		if (!vals) {
+			Py_DECREF(bulk_obj);
+			return NULL;
+		}
+		ret = PyObject_CallMethod((PyObject *)bulk_obj,
+				"set_config", "OO(O)", dirn, flags, vals);
+		Py_DECREF(vals);
+	} else
+		ret = PyObject_CallMethod((PyObject *)bulk_obj,
+				"set_config", "OO", dirn, flags);
+
+	Py_DECREF(bulk_obj);
+
+	return ret;
+}
+
+PyDoc_STRVAR(gpiod_Line_set_flags_doc,
+"set_flags(flags) -> None\n"
+"\n"
+"Set the flags of this GPIO line.\n"
+"\n"
+"  flags\n"
+"    New flags (integer)");
+
+static PyObject *gpiod_Line_set_flags(gpiod_LineObject *self, PyObject *args)
+{
+	gpiod_LineBulkObject *bulk_obj;
+	PyObject *ret;
+
+	bulk_obj = gpiod_LineToLineBulk(self);
+	if (!bulk_obj)
+		return NULL;
+
+	ret = PyObject_CallMethod((PyObject *)bulk_obj,
+				  "set_flags", "O", args);
+	Py_DECREF(bulk_obj);
+
+	return ret;
+}
+
+PyDoc_STRVAR(gpiod_Line_set_direction_input_doc,
+"set_direction_input() -> None\n"
+"\n"
+"Set the direction of this GPIO line to input.\n");
+
+static PyObject *gpiod_Line_set_direction_input(gpiod_LineObject *self,
+						PyObject *Py_UNUSED(ignored))
+{
+	gpiod_LineBulkObject *bulk_obj;
+	PyObject *ret;
+
+	bulk_obj = gpiod_LineToLineBulk(self);
+	if (!bulk_obj)
+		return NULL;
+
+	ret = PyObject_CallMethod((PyObject *)bulk_obj,
+				  "set_direction_input", "");
+	Py_DECREF(bulk_obj);
+
+	return ret;
+}
+
+PyDoc_STRVAR(gpiod_Line_set_direction_output_doc,
+"set_direction_output(value) -> None\n"
+"\n"
+"Set the direction of this GPIO line to output.\n"
+"\n"
+"  value\n"
+"    New value (integer)");
+
+static PyObject *gpiod_Line_set_direction_output(gpiod_LineObject *self,
+						 PyObject *args)
+{
+	gpiod_LineBulkObject *bulk_obj;
+	PyObject *val, *vals, *ret;
+	int rv;
+	const char *fmt;
+
+	val = NULL;
+	rv = PyArg_ParseTuple(args, "|O", &val);
+	if (!rv)
+		return NULL;
+
+	if (val) {
+		fmt = "(O)";
+		vals = Py_BuildValue(fmt, val);
+	} else {
+		vals = Py_BuildValue("()");
+		fmt = "O"; /* pass empty args to bulk */
+	}
+	if (!vals)
+		return NULL;
+
+	bulk_obj = gpiod_LineToLineBulk(self);
+	if (!bulk_obj)
+		return NULL;
+
+	ret = PyObject_CallMethod((PyObject *)bulk_obj,
+				  "set_direction_output", fmt, vals);
+
 	Py_DECREF(bulk_obj);
 	Py_DECREF(vals);
 
@@ -838,6 +973,30 @@  static PyMethodDef gpiod_Line_methods[] = {
 		.ml_flags = METH_VARARGS,
 		.ml_doc = gpiod_Line_set_value_doc,
 	},
+	{
+		.ml_name = "set_config",
+		.ml_meth = (PyCFunction)gpiod_Line_set_config,
+		.ml_flags = METH_VARARGS,
+		.ml_doc = gpiod_Line_set_config_doc,
+	},
+	{
+		.ml_name = "set_flags",
+		.ml_meth = (PyCFunction)gpiod_Line_set_flags,
+		.ml_flags = METH_VARARGS,
+		.ml_doc = gpiod_Line_set_flags_doc,
+	},
+	{
+		.ml_name = "set_direction_input",
+		.ml_meth = (PyCFunction)gpiod_Line_set_direction_input,
+		.ml_flags = METH_NOARGS,
+		.ml_doc = gpiod_Line_set_direction_input_doc,
+	},
+	{
+		.ml_name = "set_direction_output",
+		.ml_meth = (PyCFunction)gpiod_Line_set_direction_output,
+		.ml_flags = METH_VARARGS,
+		.ml_doc = gpiod_Line_set_direction_output_doc,
+	},
 	{
 		.ml_name = "release",
 		.ml_meth = (PyCFunction)gpiod_Line_release,
@@ -1283,6 +1442,200 @@  static PyObject *gpiod_LineBulk_set_values(gpiod_LineBulkObject *self,
 	Py_RETURN_NONE;
 }
 
+static int convert_values(PyObject *src, int *dst, Py_ssize_t n)
+{
+	int val;
+	Py_ssize_t num_vals, i;
+	PyObject *iter, *next;
+
+	num_vals = PyObject_Size(src);
+	if (num_vals != n) {
+		PyErr_SetString(PyExc_TypeError,
+			"Number of values must correspond to the number of lines");
+		return -1;
+	}
+	iter = PyObject_GetIter(src);
+	if (!iter)
+		return -1;
+	for (i = 0;; i++) {
+		next = PyIter_Next(iter);
+		if (!next) {
+			Py_DECREF(iter);
+			break;
+		}
+		val = PyLong_AsLong(next);
+		Py_DECREF(next);
+		if (PyErr_Occurred()) {
+			Py_DECREF(iter);
+			return -1;
+		}
+		dst[i] = (int)val;
+	}
+	return 0;
+}
+
+PyDoc_STRVAR(gpiod_LineBulk_set_config_doc,
+"set_config(direction,flags,values) -> None\n"
+"\n"
+"Set the configuration of all the lines held by this LineBulk object.\n"
+"\n"
+"  direction\n"
+"    New direction (integer)\n"
+"  flags\n"
+"    New flags (integer)\n"
+"  values\n"
+"    List of values (integers) to set when direction is output.\n"
+"\n"
+"The number of values in the list passed as argument must be the same as\n"
+"the number of lines held by this gpiod.LineBulk object. The index of each\n"
+"value corresponds to the index of each line in the object.\n");
+
+static PyObject *gpiod_LineBulk_set_config(gpiod_LineBulkObject *self,
+					   PyObject *args)
+{
+	int rv, vals[GPIOD_LINE_BULK_MAX_LINES];
+	PyObject *val_list;
+	struct gpiod_line_bulk bulk;
+	const int *valp;
+	int dirn, flags;
+
+	if (gpiod_LineBulkOwnerIsClosed(self))
+		return NULL;
+
+	gpiod_LineBulkObjToCLineBulk(self, &bulk);
+
+	val_list = NULL;
+	rv = PyArg_ParseTuple(args, "ii|(O)", &dirn, &flags, &val_list);
+	if (!rv)
+		return NULL;
+
+	if (val_list == NULL)
+		valp = NULL;
+	else {
+		memset(vals, 0, sizeof(vals));
+		rv = convert_values(val_list, vals, self->num_lines);
+		if (rv)
+			return NULL;
+		valp = vals;
+	}
+
+	Py_BEGIN_ALLOW_THREADS;
+	rv = gpiod_line_set_config_bulk(&bulk, dirn, flags, valp);
+	Py_END_ALLOW_THREADS;
+	if (rv)
+		return PyErr_SetFromErrno(PyExc_OSError);
+
+	Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(gpiod_LineBulk_set_flags_doc,
+"set_flags(flags) -> None\n"
+"\n"
+"Set the flags of all the lines held by this LineBulk object.\n"
+"\n"
+"  flags\n"
+"    New flags (integer)");
+
+static PyObject *gpiod_LineBulk_set_flags(gpiod_LineBulkObject *self,
+					  PyObject *args)
+{
+	int rv;
+	struct gpiod_line_bulk bulk;
+	int flags;
+
+	if (gpiod_LineBulkOwnerIsClosed(self))
+		return NULL;
+
+	gpiod_LineBulkObjToCLineBulk(self, &bulk);
+
+	rv = PyArg_ParseTuple(args, "i", &flags);
+	if (!rv)
+		return NULL;
+
+	Py_BEGIN_ALLOW_THREADS;
+	rv = gpiod_line_set_flags_bulk(&bulk, flags);
+	Py_END_ALLOW_THREADS;
+	if (rv)
+		return PyErr_SetFromErrno(PyExc_OSError);
+
+	Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(gpiod_LineBulk_set_direction_input_doc,
+"set_direction_input() -> None\n"
+"\n"
+"Set the direction of all the lines held by this LineBulk object to input.\n");
+
+static PyObject *gpiod_LineBulk_set_direction_input(gpiod_LineBulkObject *self,
+						PyObject *Py_UNUSED(ignored))
+{
+	struct gpiod_line_bulk bulk;
+	int rv;
+
+	if (gpiod_LineBulkOwnerIsClosed(self))
+		return NULL;
+
+	gpiod_LineBulkObjToCLineBulk(self, &bulk);
+
+	Py_BEGIN_ALLOW_THREADS;
+	rv = gpiod_line_set_direction_input_bulk(&bulk);
+	Py_END_ALLOW_THREADS;
+	if (rv)
+		return PyErr_SetFromErrno(PyExc_OSError);
+
+	Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(gpiod_LineBulk_set_direction_output_doc,
+"set_direction_output(value) -> None\n"
+"\n"
+"Set the direction of all the lines held by this LineBulk object to output.\n"
+"\n"
+"  values\n"
+"    List of values (integers) to set when direction is output.\n"
+"\n"
+"The number of values in the list passed as argument must be the same as\n"
+"the number of lines held by this gpiod.LineBulk object. The index of each\n"
+"value corresponds to the index of each line in the object.\n");
+
+static PyObject *gpiod_LineBulk_set_direction_output(
+				gpiod_LineBulkObject *self,
+				PyObject *args)
+{
+	int rv, vals[GPIOD_LINE_BULK_MAX_LINES];
+	PyObject *val_list;
+	struct gpiod_line_bulk bulk;
+	const int *valp;
+
+	if (gpiod_LineBulkOwnerIsClosed(self))
+		return NULL;
+
+	gpiod_LineBulkObjToCLineBulk(self, &bulk);
+
+	val_list = NULL;
+	rv = PyArg_ParseTuple(args, "|O", &val_list);
+	if (!rv)
+		return NULL;
+
+	if (val_list == NULL)
+		valp = NULL;
+	else {
+		memset(vals, 0, sizeof(vals));
+		rv = convert_values(val_list, vals, self->num_lines);
+		if (rv)
+			return NULL;
+		valp = vals;
+	}
+
+	Py_BEGIN_ALLOW_THREADS;
+	rv = gpiod_line_set_direction_output_bulk(&bulk, valp);
+	Py_END_ALLOW_THREADS;
+	if (rv)
+		return PyErr_SetFromErrno(PyExc_OSError);
+
+	Py_RETURN_NONE;
+}
+
 PyDoc_STRVAR(gpiod_LineBulk_release_doc,
 "release() -> None\n"
 "\n"
@@ -1431,6 +1784,30 @@  static PyMethodDef gpiod_LineBulk_methods[] = {
 		.ml_doc = gpiod_LineBulk_set_values_doc,
 		.ml_flags = METH_VARARGS,
 	},
+	{
+		.ml_name = "set_config",
+		.ml_meth = (PyCFunction)gpiod_LineBulk_set_config,
+		.ml_flags = METH_VARARGS,
+		.ml_doc = gpiod_LineBulk_set_config_doc,
+	},
+	{
+		.ml_name = "set_flags",
+		.ml_meth = (PyCFunction)gpiod_LineBulk_set_flags,
+		.ml_flags = METH_VARARGS,
+		.ml_doc = gpiod_LineBulk_set_flags_doc,
+	},
+	{
+		.ml_name = "set_direction_input",
+		.ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_input,
+		.ml_flags = METH_NOARGS,
+		.ml_doc = gpiod_LineBulk_set_direction_input_doc,
+	},
+	{
+		.ml_name = "set_direction_output",
+		.ml_meth = (PyCFunction)gpiod_LineBulk_set_direction_output,
+		.ml_flags = METH_VARARGS,
+		.ml_doc = gpiod_LineBulk_set_direction_output_doc,
+	},
 	{
 		.ml_name = "release",
 		.ml_meth = (PyCFunction)gpiod_LineBulk_release,