qmi_device_new ()

void
qmi_device_new (GFile *file,
                GCancellable *cancellable,
                GAsyncReadyCallback callback,
                gpointer user_data);

Asynchronously creates a QmiDevice object to manage file . When the operation is finished, callback will be invoked. You can then call qmi_device_new_finish() to get the result of the operation.

Since: 1.0

qmi_device_new_finish ()

QmiDevice *
qmi_device_new_finish (GAsyncResult *res,
                       GError **error);

Finishes an operation started with qmi_device_new().

Since: 1.0

qmi_device_get_file ()

GFile *
qmi_device_get_file (QmiDevice *self);

Get the GFile associated with this QmiDevice.

Since: 1.0

qmi_device_peek_file ()

GFile *
qmi_device_peek_file (QmiDevice *self);

Get the GFile associated with this QmiDevice, without increasing the reference count on the returned object.

Since: 1.0

qmi_device_get_path ()

const gchar *
qmi_device_get_path (QmiDevice *self);

Get the system path of the underlying QMI device.

Since: 1.0

qmi_device_get_path_display ()

const gchar *
qmi_device_get_path_display (QmiDevice *self);

Get the system path of the underlying QMI device in UTF-8.

Since: 1.0

qmi_device_is_open ()

gboolean
qmi_device_is_open (QmiDevice *self);

Checks whether the QmiDevice is open for I/O.

Since: 1.0

qmi_device_get_consecutive_timeouts ()

guint
qmi_device_get_consecutive_timeouts (QmiDevice *self);

Gets the number of consecutive transaction timeouts in the device.

Since: 1.32

qmi_device_open_flags_build_string_from_mask ()

gchar *
qmi_device_open_flags_build_string_from_mask
                               (QmiDeviceOpenFlags mask);

Builds a string containing a comma-separated list of nicknames for each QmiDeviceOpenFlags in mask .

Since: 1.0

qmi_device_open ()

void
qmi_device_open (QmiDevice *self,
                 QmiDeviceOpenFlags flags,
                 guint timeout,
                 GCancellable *cancellable,
                 GAsyncReadyCallback callback,
                 gpointer user_data);

Asynchronously opens a QmiDevice for I/O.

When the operation is finished callback will be called. You can then call qmi_device_open_finish() to get the result of the operation.

Since: 1.0

qmi_device_open_finish ()

gboolean
qmi_device_open_finish (QmiDevice *self,
                        GAsyncResult *res,
                        GError **error);

Finishes an asynchronous open operation started with qmi_device_open().

Since: 1.0

qmi_device_close_async ()

void
qmi_device_close_async (QmiDevice *self,
                        guint timeout,
                        GCancellable *cancellable,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

Asynchronously closes a QmiDevice, preventing any further I/O.

If this device was opened with QMI_DEVICE_OPEN_FLAGS_MBIM , this operation will wait for the response of the underlying MBIM close sequence.

Closing a QmiDevice multiple times will not return an error.

When the operation is finished callback will be called. You can then call qmi_device_close_finish() to get the result of the operation.

Since: 1.18

qmi_device_close_finish ()

gboolean
qmi_device_close_finish (QmiDevice *self,
                         GAsyncResult *res,
                         GError **error);

Finishes an operation started with qmi_device_close_async().

Since: 1.18

qmi_device_allocate_client ()

void
qmi_device_allocate_client (QmiDevice *self,
                            QmiService service,
                            guint8 cid,
                            guint timeout,
                            GCancellable *cancellable,
                            GAsyncReadyCallback callback,
                            gpointer user_data);

Asynchronously allocates a new QmiClient in self .

If QMI_CID_NONE is given in cid , a new client ID will be allocated; otherwise a client with the given cid will be generated.

When the operation is finished callback will be called. You can then call qmi_device_allocate_client_finish() to get the result of the operation.

Note: Clients for the QMI_SERVICE_CTL cannot be created with this method; instead get/peek the implicit one from self .

Since: 1.0

qmi_device_allocate_client_finish ()

QmiClient *
qmi_device_allocate_client_finish (QmiDevice *self,
                                   GAsyncResult *res,
                                   GError **error);

Finishes an operation started with qmi_device_allocate_client().

Since: 1.0

qmi_device_release_client_flags_build_string_from_mask ()

gchar *
qmi_device_release_client_flags_build_string_from_mask
                               (QmiDeviceReleaseClientFlags mask);

Builds a string containing a comma-separated list of nicknames for each QmiDeviceReleaseClientFlags in mask .

Since: 1.0

qmi_device_release_client ()

void
qmi_device_release_client (QmiDevice *self,
                           QmiClient *client,
                           QmiDeviceReleaseClientFlags flags,
                           guint timeout,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Asynchronously releases the QmiClient from the QmiDevice.

Once the QmiClient has been released, it cannot be used any more to perform operations.

When the operation is finished callback will be called. You can then call qmi_device_release_client_finish() to get the result of the operation.

Since: 1.0

qmi_device_release_client_finish ()

gboolean
qmi_device_release_client_finish (QmiDevice *self,
                                  GAsyncResult *res,
                                  GError **error);

Finishes an operation started with qmi_device_release_client().

Note that even if the release operation returns an error, the client should anyway be considered released, and shouldn't be used afterwards.

Since: 1.0

qmi_device_set_instance_id ()

void
qmi_device_set_instance_id (QmiDevice *self,
                            guint8 instance_id,
                            guint timeout,
                            GCancellable *cancellable,
                            GAsyncReadyCallback callback,
                            gpointer user_data);

Sets the instance ID of the QmiDevice.

When the operation is finished callback will be called. You can then call qmi_device_set_instance_id_finish() to get the result of the operation.

Since: 1.0

qmi_device_set_instance_id_finish ()

gboolean
qmi_device_set_instance_id_finish (QmiDevice *self,
                                   GAsyncResult *res,
                                   guint16 *link_id,
                                   GError **error);

Finishes an operation started with qmi_device_set_instance_id().

Since: 1.0

qmi_device_get_service_version_info ()

void
qmi_device_get_service_version_info (QmiDevice *self,
                                     guint timeout,
                                     GCancellable *cancellable,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data);

Asynchronously requests the service version information of the device.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from.

You can then call qmi_device_get_service_version_info_finish() to get the result of the operation.

Since: 1.6

qmi_device_get_service_version_info_finish ()

GArray *
qmi_device_get_service_version_info_finish
                               (QmiDevice *self,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with qmi_device_get_service_version_info().

Since: 1.6

qmi_device_command_full ()

void
qmi_device_command_full (QmiDevice *self,
                         QmiMessage *message,
                         QmiMessageContext *message_context,
                         guint timeout,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

Asynchronously sends a QmiMessage to the device.

The message will be processed according to the specific message_context given. If no context given, the behavior is the same as qmi_device_command().

If the operation is cancelled via cancellable , a QMI_PROTOCOL_ERROR_ABORTED error will be returned always. If the QMI method may be aborted, there is no guarantee that the operation is truly aborted before the error is returned so it may really happen that the operation really succeeded and the method would still return QMI_PROTOCOL_ERROR_ABORTED. In order to use abortable methods and make sure the response is the correct one, use qmi_device_command_abortable().

When the operation is finished callback will be called. You can then call qmi_device_command_full_finish() to get the result of the operation.

Since: 1.18

qmi_device_command_full_finish ()

QmiMessage *
qmi_device_command_full_finish (QmiDevice *self,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with qmi_device_command_full().

Since: 1.18

QmiDeviceCommandAbortableBuildRequestFn ()

QmiMessage *
(*QmiDeviceCommandAbortableBuildRequestFn)
                               (QmiDevice *self,
                                QmiMessage *message,
                                gpointer user_data,
                                GError **error);

Callback to run when processing the command abortion. This callback should create a service-specific and client-specific abort request to be passed to the device.

Since: 1.24

QmiDeviceCommandAbortableParseResponseFn ()

gboolean
(*QmiDeviceCommandAbortableParseResponseFn)
                               (QmiDevice *self,
                                QmiMessage *abort_response,
                                gpointer user_data,
                                GError **error);

Callback to run when processing the command abortion. This callback should parse the abort response provided by the device, and build an appropriate output.

Since: 1.24

qmi_device_command_abortable ()

void
qmi_device_command_abortable (QmiDevice *self,
                              QmiMessage *message,
                              QmiMessageContext *message_context,
                              guint timeout,
                              QmiDeviceCommandAbortableBuildRequestFn abort_build_request_fn,
                              QmiDeviceCommandAbortableParseResponseFn abort_parse_response_fn,
                              gpointer abort_user_data,
                              GDestroyNotify abort_user_data_free,
                              GCancellable *cancellable,
                              GAsyncReadyCallback callback,
                              gpointer user_data);

Asynchronously sends a QmiMessage to the device.

The message will be processed according to the specific message_context given.

If the operation is cancelled via cancellable , an abort message will be sent to the device in order to really abort the ongoing operation. The qmi_device_command_abortable() method will not finish until either a successful reply is received from the device or otherwise the command abortion is confirmed.

If a successful command response arrives before the abort is processed by the device, the operation will succeed even if cancellable has been set, so that upper layers can do whatever they need to do to properly tear down the operation.

If an error command reponse arrives before the abort is processed by the device, the operation will fail with the error returned by the device.

The QMI_PROTOCOL_ERROR_ABORTED error will only be returned as a result of this operation if the command request was truly aborted by the device, and so, the user of the method should not assume that cancelling the cancellable will always make the method return a QMI_PROTOCOL_ERROR_ABORTED error.

The build_request_fn and parse_response_fn callbacks are required in order to build the abort requests and parse the abort responses, because these are both service and client specific.

When the operation is finished callback will be called. You can then call qmi_device_command_abortable_finish() to get the result of the operation.

Since: 1.24

qmi_device_command_abortable_finish ()

QmiMessage *
qmi_device_command_abortable_finish (QmiDevice *self,
                                     GAsyncResult *res,
                                     GError **error);

Finishes an operation started with qmi_device_command_abortable().

Since: 1.24

qmi_device_list_links ()

gboolean
qmi_device_list_links (QmiDevice *self,
                       const gchar *base_ifname,
                       GPtrArray **out_links,
                       GError **error);

Synchronously lists all virtual network interfaces that have been previously created with qmi_device_add_link() in base_ifname .

Since: 1.28

qmi_device_add_link ()

void
qmi_device_add_link (QmiDevice *self,
                     guint mux_id,
                     const gchar *base_ifname,
                     const gchar *ifname_prefix,
                     GCancellable *cancellable,
                     GAsyncReadyCallback callback,
                     gpointer user_data);

Asynchronously creates a new virtual network device node with a custom prefix on top of base_ifname . This allows having multiple net interfaces running on top of another using multiplexing.

If the kernel driver doesn't allow this functionality, a QMI_CORE_ERROR_UNSUPPORTED error will be returned.

The operation may fail if the given interface name is not associated to the QMI control port managed by the QmiDevice.

Depending on the kernel driver in use and the multiplexing method, the given ifname_prefix may be ignored. The user should not assume that the returned link interface name is prefixed with ifname_prefix as it may not be the case.

When the operation is finished callback will be called. You can then call qmi_device_add_link_finish() to get the result of the operation.

Since: 1.28

qmi_device_add_link_finish ()

gchar *
qmi_device_add_link_finish (QmiDevice *self,
                            GAsyncResult *res,
                            guint *mux_id,
                            GError **error);

Finishes an operation started with qmi_device_add_link().

Since: 1.28

qmi_device_add_link_flags_build_string_from_mask ()

gchar *
qmi_device_add_link_flags_build_string_from_mask
                               (QmiDeviceAddLinkFlags mask);

Builds a string containing a comma-separated list of nicknames for each QmiDeviceAddLinkFlags in mask .

Since: 1.30

qmi_device_add_link_with_flags ()

void
qmi_device_add_link_with_flags (QmiDevice *self,
                                guint mux_id,
                                const gchar *base_ifname,
                                const gchar *ifname_prefix,
                                QmiDeviceAddLinkFlags flags,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously creates a new virtual network device in the same way as qmi_device_add_link() does, but passing the additional flags to the kernel during the operation.

Using QMI_DEVICE_ADD_LINK_FLAGS_NONE as flags is equivalent to calling qmi_device_add_link() directly.

If the link creation with the given set of flags is unsupported by the backend, the operation may fail.

Since: 1.30

qmi_device_add_link_with_flags_finish ()

gchar *
qmi_device_add_link_with_flags_finish (QmiDevice *self,
                                       GAsyncResult *res,
                                       guint *mux_id,
                                       GError **error);

Finishes an operation started with qmi_device_add_link_finish().

Since: 1.30

qmi_device_delete_link ()

void
qmi_device_delete_link (QmiDevice *self,
                        const gchar *ifname,
                        guint mux_id,
                        GCancellable *cancellable,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

Asynchronously deletes a virtual network interface that has been previously created with qmi_device_add_link().

If the kernel driver doesn't allow this functionality, a QMI_CORE_ERROR_UNSUPPORTED error will be returned.

When the operation is finished callback will be called. You can then call qmi_device_delete_link_finish() to get the result of the operation.

Since: 1.28

qmi_device_delete_link_finish ()

gboolean
qmi_device_delete_link_finish (QmiDevice *self,
                               GAsyncResult *res,
                               GError **error);

Finishes an operation started with qmi_device_delete_link().

Since: 1.28

qmi_device_delete_all_links ()

void
qmi_device_delete_all_links (QmiDevice *self,
                             const gchar *base_ifname,
                             GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data);

Asynchronously deletes all virtual network interfaces that have been previously created with qmi_device_add_link() in base_ifname .

When the operation is finished callback will be called. You can then call qmi_device_delete_link_finish() to get the result of the operation.

Since: 1.28

qmi_device_delete_all_links_finish ()

gboolean
qmi_device_delete_all_links_finish (QmiDevice *self,
                                    GAsyncResult *res,
                                    GError **error);

Finishes an operation started with qmi_device_delete_all_links().

Since: 1.28

qmi_device_check_link_supported ()

gboolean
qmi_device_check_link_supported (QmiDevice *self,
                                 GError **error);

Checks whether link management is supported by the kernel.

Since: 1.28

qmi_device_get_wwan_iface ()

const gchar *
qmi_device_get_wwan_iface (QmiDevice *self);

Get the WWAN interface name associated with the QMI control port. This value will be loaded every time it's asked for it.

Since: 1.14

qmi_device_expected_data_format_get_string ()

const gchar *
qmi_device_expected_data_format_get_string
                               (QmiDeviceExpectedDataFormat val);

Gets the nickname string for the QmiDeviceExpectedDataFormat specified at val .

Since: 1.14

qmi_device_get_expected_data_format ()

QmiDeviceExpectedDataFormat
qmi_device_get_expected_data_format (QmiDevice *self,
                                     GError **error);

Retrieves the data format currently expected by the kernel in the network interface.

If QMI_DEVICE_EXPECTED_DATA_FORMAT_UNKNOWN is returned, the user should assume that 802.3 is the expected format, as that is what the qmi_wwan driver expected by default before kernel 4.5.

Since: 1.14

qmi_device_set_expected_data_format ()

gboolean
qmi_device_set_expected_data_format (QmiDevice *self,
                                     QmiDeviceExpectedDataFormat format,
                                     GError **error);

Configures the data format currently expected by the kernel in the network interface.

Since: 1.14

qmi_device_check_expected_data_format_supported ()

gboolean
qmi_device_check_expected_data_format_supported
                               (QmiDevice *self,
                                QmiDeviceExpectedDataFormat format,
                                GError **error);

Checks whether the given data format is supported by the kernel. interface.

Since: 1.28

qmi_device_new_from_node ()

void
qmi_device_new_from_node (QrtrNode *node,
                          GCancellable *cancellable,
                          GAsyncReadyCallback callback,
                          gpointer user_data);

Asynchronously creates a QmiDevice object to manage node . When the operation is finished, callback will be invoked. You can then call qmi_device_new_finish() to get the result of the operation.

Since: 1.28

qmi_device_new_from_node_finish ()

QmiDevice *
qmi_device_new_from_node_finish (GAsyncResult *res,
                                 GError **error);

Finishes an operation started with qmi_device_new_from_node().

Since: 1.28

qmi_device_get_node ()

QrtrNode *
qmi_device_get_node (QmiDevice *self);

Get the QrtrNode associated with this QmiDevice.

Since: 1.28

qmi_device_peek_node ()

QrtrNode *
qmi_device_peek_node (QmiDevice *self);

Get the QrtrNode associated with this QmiDevice, without increasing the reference count on the returned object.

Since: 1.28

QMI_DEVICE_FILE

#define QMI_DEVICE_FILE "device-file"

Symbol defining the “device-file” property.

Since: 1.0

QMI_DEVICE_NO_FILE_CHECK

#define QMI_DEVICE_NO_FILE_CHECK "device-no-file-check"

Symbol defining the “device-no-file-check” property.

Since: 1.12

QMI_DEVICE_PROXY_PATH

#define QMI_DEVICE_PROXY_PATH "device-proxy-path"

Symbol defining the “device-proxy-path” property.

Since: 1.12

QMI_DEVICE_WWAN_IFACE

#define QMI_DEVICE_WWAN_IFACE "device-wwan-iface"

Symbol defining the “device-wwan-iface” property.

Since: 1.14

QMI_DEVICE_CONSECUTIVE_TIMEOUTS

#define QMI_DEVICE_CONSECUTIVE_TIMEOUTS "device-consecutive-timeouts"

Symbol defining the “device-consecutive-timeouts” property.

Since: 1.32

QMI_DEVICE_SIGNAL_INDICATION

#define QMI_DEVICE_SIGNAL_INDICATION "indication"

Symbol defining the “indication” signal.

Since: 1.8

QMI_DEVICE_SIGNAL_REMOVED

#define QMI_DEVICE_SIGNAL_REMOVED "device-removed"

Symbol defining the “device-removed” signal.

Since: 1.20

struct QmiDevice

struct QmiDevice;

The QmiDevice structure contains private data and should only be accessed using the provided API.

Since: 1.0

enum QmiDeviceOpenFlags

Flags to specify which actions to be performed when the device is open.

Since: 1.0

enum QmiDeviceReleaseClientFlags

Flags to specify which actions to be performed when releasing the client.

Since: 1.0

QmiDeviceServiceVersionInfo

typedef struct {
    QmiService service;
    guint16    major_version;
    guint16    minor_version;
} QmiDeviceServiceVersionInfo;

Version information for a service.

Since: 1.6

QMI_DEVICE_MUX_ID_AUTOMATIC

#define QMI_DEVICE_MUX_ID_AUTOMATIC G_MAXUINT

Symbol defining a mux id that will be automatically allocated during runtime when creating net links.

Since: 1.28

QMI_DEVICE_MUX_ID_UNBOUND

#define QMI_DEVICE_MUX_ID_UNBOUND 0

Symbol defining the mux id for an unbound interface. This value is also used to indicate an invalid mux id.

Since: 1.28

QMI_DEVICE_MUX_ID_MIN

#define QMI_DEVICE_MUX_ID_MIN 1

Symbol defining the minimum supported mux id.

Since: 1.28

QMI_DEVICE_MUX_ID_MAX

#define QMI_DEVICE_MUX_ID_MAX 0xFE

Symbol defining the maximum supported mux id.

Since: 1.28

enum QmiDeviceAddLinkFlags

Flags specifying the behavior of the new link.

Since: 1.30

enum QmiDeviceExpectedDataFormat

Data format expected by the kernel.

Since: 1.14

QMI_DEVICE_NODE

#define QMI_DEVICE_NODE "device-node"

Symbol defining the “device-node” property.

Since: 1.28

The “device-consecutive-timeouts” property

  “device-consecutive-timeouts” guint

Number of consecutive timeouts detected in requests sent to the device.

Owner: QmiDevice

Flags: Read

Default value: 0

Since: 1.32

The “device-file” property

  “device-file”              GFile *

File to the underlying QMI device.

Owner: QmiDevice

Flags: Read / Write / Construct Only

Since: 1.0

The “device-no-file-check” property

  “device-no-file-check”     gboolean

Don't check for file existence when creating the Qmi device.

Owner: QmiDevice

Flags: Write / Construct Only

Default value: FALSE

Since: 1.12

The “device-node” property

  “device-node”              QrtrNode *

Remote node on the QRTR bus.

Owner: QmiDevice

Flags: Read / Write / Construct Only

Since: 1.24

The “device-proxy-path” property

  “device-proxy-path”        char *

Path of the abstract socket where the proxy is available.

Owner: QmiDevice

Flags: Write / Construct Only

Default value: "qmi-proxy"

Since: 1.12

The “device-wwan-iface” property

  “device-wwan-iface”        char *

Name of the WWAN network interface associated with the control port.

Owner: QmiDevice

Flags: Read

Default value: NULL

Since: 1.14

The “device-removed” signal

void
user_function (QmiDevice *object,
               gpointer   user_data)

The ::device-removed signal is emitted when an unexpected port hang-up is received.

Flags: Run Last

Since: 1.20

The “indication” signal

void
user_function (QmiDevice  *object,
               GByteArray *output,
               gpointer    user_data)

The ::indication signal gets emitted when a QMI indication is received.

Flags: Run Last

Since: 1.8