bindings: python: add support for SET_CONFIG

Add methods to support setting line configuration.

Signed-off-by: Kent Gibson <warthog618@gmail.com>
Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>

diff --git a/bindings/python/gpiodmodule.c b/bindings/python/gpiodmodule.c
index 8369ff0298790c6dae84f014cc67a2900bc7b8b2..bb2f4aa9e31aeb07b2e77398aaefb3e6450dccde 100644 (file)
--- a/bindings/python/gpiodmodule.c
+++ b/bindings/python/gpiodmodule.c
@@ -599,6 +599,142 @@ static PyObject *gpiod_Line_set_value(gpiod_LineObject *self, PyObject *args)
        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);
+
+       return ret;
+}
+
 PyDoc_STRVAR(gpiod_Line_release_doc,
 "release() -> None\n"
 "\n"
@@ -838,6 +974,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,
@@ -1294,6 +1454,168 @@ static PyObject *gpiod_LineBulk_set_values(gpiod_LineBulkObject *self,
        Py_RETURN_NONE;
 }
 
+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 = gpiod_TupleToIntArray(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 = gpiod_TupleToIntArray(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"
@@ -1442,6 +1764,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,