Merge "msm: synx: Porting synx driver to 5.x kernel"

drivers/media/platform/Kconfig

@@ -686,3 +686,5 @@ config VIDEO_RCAR_DRIF
 	  will be called rcar_drif.
 
 endif # SDR_PLATFORM_DRIVERS
+
+source "drivers/media/platform/msm/Kconfig"

drivers/media/platform/Makefile

@@ -101,3 +101,5 @@ obj-y					+= meson/
 obj-y					+= cros-ec-cec/
 
 obj-y					+= sunxi/
+
+obj-y					+= msm/

drivers/media/platform/msm/Kconfig

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+source "drivers/media/platform/msm/synx/Kconfig"

drivers/media/platform/msm/Makefile

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+obj-$(CONFIG_MSM_GLOBAL_SYNX) += synx/

drivers/media/platform/msm/synx/Kconfig

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+menuconfig MSM_GLOBAL_SYNX
+	tristate "Qualcomm Technologies, Inc. Global Synchronization Framework"
+	depends on ARCH_QCOM
+	help
+	  Say M here to enable global synchronization module for
+	  Qualcomm Technologies, Inc. chipsets.
+	  Enabling this adds support for global synchronization across
+	  heterogeneous cores.
+

drivers/media/platform/msm/synx/Makefile

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+obj-$(CONFIG_MSM_GLOBAL_SYNX) += synx-driver.o
+
+synx-driver-y := synx.o synx_util.o synx_debugfs.o

drivers/media/platform/msm/synx/synx_api.h

@@ -0,0 +1,344 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef __SYNX_API_H__
+#define __SYNX_API_H__
+
+#include <linux/list.h>
+#include <uapi/media/synx.h>
+
+typedef void (*synx_callback)(s32 sync_obj, int status, void *data);
+
+/**
+ * struct bind_operations - Function pointers that need to be defined
+ *    to achieve bind functionality for external fence with synx obj
+ *
+ * @register_callback   : Function to register with external sync object
+ * @deregister_callback : Function to deregister with external sync object
+ * @enable_signaling    : Function to enable the signaling on the external
+ *                        sync object (optional)
+ * @signal              : Function to signal the external sync object
+ */
+struct bind_operations {
+	int (*register_callback)(synx_callback cb_func,
+		void *userdata, s32 sync_obj);
+	int (*deregister_callback)(synx_callback cb_func,
+		void *userdata, s32 sync_obj);
+	int (*enable_signaling)(s32 sync_obj);
+	int (*signal)(s32 sync_obj, u32 status);
+};
+
+/**
+ * struct synx_register_params - External registration parameters
+ *
+ * @ops  : Bind operations struct
+ * @name : External client name
+ *         Only first 64 bytes are accepted, rest will be ignored
+ * @type : Synx external client type
+ */
+struct synx_register_params {
+	struct bind_operations ops;
+	char *name;
+	u32 type;
+};
+
+/**
+ * struct synx_session - Client session handle
+ *
+ * @client_id : Client id
+ */
+struct synx_session {
+	u32 client_id;
+};
+
+/**
+ * struct synx_initialization_params - Session params
+ *
+ * @name : Client session name
+ *         Only first 64 bytes are accepted, rest will be ignored
+ */
+struct synx_initialization_params {
+	const char *name;
+};
+
+/**
+ * struct synx_create_params - Synx creation parameters
+ *
+ * @h_synx : Pointer to synx object handle (filled by function)
+ * @name   : Optional parameter associating a name with the synx
+ *           object for debug purposes
+ *           Only first 64 bytes are accepted,
+ *           rest will be ignored
+ */
+struct synx_create_params {
+	s32 *h_synx;
+	const char *name;
+};
+
+/**
+ * struct synx_export_params - Synx export parameters
+ *
+ * @h_synx     : Synx object handle to export
+ * @secure_key : Pointer to Key generated for authentication
+ *               (filled by the function)
+ */
+struct synx_export_params {
+	s32 h_synx;
+	u32 *secure_key;
+};
+
+/**
+ * struct synx_import_params - Synx import parameters
+ *
+ * @h_synx     : Synx object handle to import
+ * @secure_key : Key to verify authenticity
+ * @new_h_synx : Pointer to newly created synx object
+ *               (filled by the function)
+ *               This handle should be used by importing
+ *               process for all synx api operations
+ */
+struct synx_import_params {
+	s32 h_synx;
+	u32 secure_key;
+	s32 *new_h_synx;
+};
+
+/* Kernel APIs */
+
+/* @brief: Register operations for external synchronization
+ *
+ * Register with synx for enabling external synchronization through bind
+ *
+ * @param params : Pointer to register params
+ *
+ * @return Status of operation. Zero in case of success.
+ * -EINVAL will be returned if params are invalid.
+ * -ENOMEM will be returned if bind ops cannot be registered due to
+ * insufficient memory.
+ * -EALREADY will be returned if type already in use
+ */
+int synx_register_ops(const struct synx_register_params *params);
+
+/**
+ * @brief: De-register external synchronization operations
+ *
+ * @param params : Pointer to register params
+ *
+ * @return Status of operation. Zero in case of success.
+ * -EINVAL will be returned if record not found.
+ */
+int synx_deregister_ops(const struct synx_register_params *params);
+
+/**
+ * @brief: Initializes a new client session
+ *
+ * Create a new client and provides access to the synx framework
+ *
+ * @param session_id : Pointer to client session id (filled by function)
+ * @param params     : Pointer to session init params
+ *
+ * @return Status of operation. Zero in case of success.
+ * -EINVAL will be returned if params is not valid.
+ * -ENOMEM will be returned if the kernel can't allocate space for
+ * new client
+ */
+int synx_initialize(struct synx_session *session_id,
+	struct synx_initialization_params *params);
+
+/**
+ * @brief: Destroys the client session
+ *
+ * The client session is destroyed and all synx objects owned
+ * by the client are cleaned up.
+ *
+ * @param session_id : Client session id
+ *
+ * @return Status of operation. Zero in case of success.
+ */
+int synx_uninitialize(struct synx_session session_id);
+
+/**
+ * @brief: Creates a synx object
+ *
+ *  Creates a new synx obj and returns the handle to client
+ *
+ * @param session_id : Client session id
+ * @param params     : Pointer to create params
+ *
+ * @return Status of operation. Zero in case of success.
+ * -EINVAL will be returned if params were invalid.
+ * -ENOMEM will be returned if the kernel can't allocate space for
+ * synx object.
+ */
+int synx_create(struct synx_session session_id,
+	struct synx_create_params *params);
+
+/**
+ * @brief: Registers a callback with a synx object
+ *
+ * @param session_id : Client session id
+ * @param h_synx     : Synx object handle
+ * @param cb_func    : Pointer to callback to be registered
+ * @param userdata   : Opaque pointer passed back with callback
+ *
+ * @return Status of operation. Zero in case of success.
+ * -EINVAL will be returned if userdata is invalid.
+ * -ENOMEM will be returned if cb_func is invalid.
+ *
+ */
+int synx_register_callback(struct synx_session session_id,
+	s32 h_synx, synx_callback cb_func, void *userdata);
+
+/**
+ * @brief: De-registers a callback with a synx object
+ *
+ * @param session_id     : Client session id
+ * @param h_synx         : Synx object handle
+ * @param cb_func        : Pointer to callback to be de-registered
+ * @param userdata       : Opaque pointer passed back with callback
+ * @param cancel_cb_func : Pointer to callback to ack de-registration
+ *
+ * @return Status of operation. Zero in case of success.
+ * -EINVAL will be returned if userdata is invalid.
+ * -ENOMEM will be returned if cb_func is invalid.
+ */
+int synx_deregister_callback(struct synx_session session_id,
+	s32 h_synx,
+	synx_callback cb_func,
+	void *userdata,
+	synx_callback cancel_cb_func);
+
+/**
+ * @brief: Signals a synx object with the status argument.
+ *
+ * This function will signal the synx object referenced by h_synx
+ * and invoke any external binding synx objs.
+ * The status parameter will indicate whether the entity
+ * performing the signaling wants to convey an error case or a success case.
+ *
+ * @param session_id : Client session id
+ * @param h_synx     : Synx object handle
+ * @param status     : Status of signaling.
+ *                     Value : SYNX_STATE_SIGNALED_SUCCESS or
+ *                     SYNX_STATE_SIGNALED_ERROR.
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_signal(struct synx_session session_id, s32 h_synx, u32 status);
+
+/**
+ * @brief: Merges multiple synx objects
+ *
+ * This function will merge multiple synx objects into a synx group.
+ *
+ * @param session_id   : Client session id
+ * @param h_synxs      : Pointer to a block of synx handles to be merged
+ * @param num_objs     : Number of synx objs in the block
+ * @param h_merged_obj : Merged synx object handle (filled by function)
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_merge(struct synx_session session_id,
+	s32 *h_synxs, u32 num_objs, s32 *h_merged_obj);
+
+/**
+ * @brief: Waits for a synx object synchronously
+ *
+ * Does a wait on the synx object identified by h_synx for a maximum
+ * of timeout_ms milliseconds. Must not be called from interrupt context as
+ * this API can sleep. Should be called from process context only.
+ *
+ * @param session_id : Client session id
+ * @param h_synx     : Synx object handle to be waited upon
+ * @param timeout_ms : Timeout in ms
+ *
+ * @return 0 upon success, -EINVAL if synx object is in bad state or arguments
+ * are invalid, -ETIMEDOUT if wait times out.
+ */
+int synx_wait(struct synx_session session_id, s32 h_synx, u64 timeout_ms);
+
+/**
+ * @brief: Binds synx object with external sync
+ *
+ * Binding synx objects with supported external sync object will unify them
+ * in a way that if one of them signals, the other ones is signaled as well
+ *
+ * @param session_id    : Client session id
+ * @param h_synx        : Synx object handle
+ * @param external_sync : External synx descriptor to bind to object
+ *
+ * @return 0 upon success, -EINVAL if synx object is in bad state or arguments
+ * are invalid.
+ */
+int synx_bind(struct synx_session session_id, s32 h_synx,
+	struct synx_external_desc external_sync);
+
+/**
+ * @brief: Returns the status of the synx object
+ *
+ * @param session_id : Client session id
+ * @param h_synx     : Synx object handle
+ *
+ * @return Status of the synx object
+ */
+int synx_get_status(struct synx_session session_id, s32 h_synx);
+
+/**
+ * @brief: Adds to the reference count of a synx object
+ *
+ * When a synx object is created, the refcount will be 1. Every
+ * additional refcount requires separate release of object handle.
+ *
+ * @param session_id : Client session id
+ * @param h_synx     : Synx object handle
+ * @param count      : Count to add to the refcount
+ *
+ * @return 0 upon success, -EINVAL if synx object is in bad state
+ */
+int synx_addrefcount(struct synx_session session_id,
+	s32 h_synx, s32 count);
+
+/**
+ * @brief: Imports (looks up) synx object from given handle and key
+ *
+ * The given ID should have been exported by another client
+ * and provided with key.
+ *
+ * @param session_id : Client session id
+ * @param params     : Pointer to import params
+ *
+ * @return 0 upon success, -EINVAL if synx object is bad state
+ */
+int synx_import(struct synx_session session_id,
+	struct synx_import_params *params);
+
+/**
+ * @brief: Exports a synx object and returns a key
+ *
+ * The synx object handle and given key may be passed to other
+ * clients to be imported.
+ *
+ * @param session_id : Client session id
+ * @param params     : Pointer to export params
+ *
+ * @return 0 upon success, -EINVAL if the ID is bad
+ */
+int synx_export(struct synx_session session_id,
+	struct synx_export_params *params);
+
+/**
+ * @brief: Release the synx object
+
+ * Decrements refcount of a synx object by 1, and destroys it
+ * if becomes 0
+ *
+ * @param session_id : Client session id
+ * @param h_synx     : Synx object handle to be destroyed
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_release(struct synx_session session_id, s32 h_synx);
+
+#endif /* __SYNX_API_H__ */

drivers/media/platform/msm/synx/synx_debugfs.c

@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/io.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+
+#include "synx_api.h"
+#include "synx_debugfs.h"
+#include "synx_util.h"
+
+#define MAX_DBG_BUF_SIZE (36 * SYNX_MAX_OBJS)
+
+struct dentry *my_direc;
+static const char delim[] = ",";
+int columns = NAME_COLUMN | ID_COLUMN |
+	BOUND_COLUMN | STATE_COLUMN | ERROR_CODES;
+
+void populate_bound_rows(
+	struct synx_coredata *row,
+	char *cur,
+	char *end)
+{
+	int j;
+
+	for (j = 0; j < row->num_bound_synxs;
+		j++) {
+		cur += scnprintf(cur, end - cur,
+			"\n\tID: %d",
+			row->bound_synxs[j].external_desc.id[0]);
+	}
+}
+static ssize_t synx_table_read(struct file *file,
+		char *buf,
+		size_t count,
+		loff_t *ppos)
+{
+
+	struct synx_device *dev = file->private_data;
+	struct error_node *err_node, *err_node_tmp;
+	struct synx_client *client;
+	struct synx_coredata *row;
+	char *dbuf, *cur, *end;
+
+	int i = 0;
+	int j = 0;
+	int status = SYNX_STATE_INVALID;
+	ssize_t len = 0;
+
+	dbuf = kzalloc(MAX_DBG_BUF_SIZE, GFP_KERNEL);
+	if (!dbuf)
+		return -ENOMEM;
+
+	cur = dbuf;
+	end = cur + MAX_DBG_BUF_SIZE;
+	if (columns & NAME_COLUMN)
+		cur += scnprintf(cur, end - cur, "|   Name   |");
+	if (columns & ID_COLUMN)
+		cur += scnprintf(cur, end - cur, "|    ID    |");
+	if (columns & BOUND_COLUMN)
+		cur += scnprintf(cur, end - cur, "|   Bound   |");
+	if (columns & STATE_COLUMN)
+		cur += scnprintf(cur, end - cur, "|   Status   |");
+	cur += scnprintf(cur, end - cur, "\n");
+
+	for (j = 0; j < SYNX_MAX_CLIENTS; j++) {
+		struct synx_session session;
+
+		session.client_id = j;
+		client = synx_get_client(session);
+		if (!client)
+			continue;
+
+		cur += scnprintf(cur, end - cur,
+			"=============== session %08u ===============\n",
+			client->id);
+		for (i = 0; i < SYNX_MAX_OBJS; i++) {
+			row = synx_util_acquire_object(client, i);
+			if (!row)
+				continue;
+
+			spin_lock_bh(&row->lock);
+			if (columns & NAME_COLUMN)
+				cur += scnprintf(cur, end - cur,
+					"|%10s|", row->name);
+			if (columns & ID_COLUMN)
+				cur += scnprintf(cur, end - cur,
+					"|%10d|", i);
+			if (columns & BOUND_COLUMN)
+				cur += scnprintf(cur, end - cur,
+					"|%11d|", row->num_bound_synxs);
+			if (columns & STATE_COLUMN) {
+				status =
+					synx_util_get_object_status_locked(row);
+				cur += scnprintf(cur, end - cur,
+					"|%10d|", status);
+			}
+			if ((columns & BOUND_COLUMN) &&
+				(row->num_bound_synxs > 0)) {
+				cur += scnprintf(
+					cur, end - cur, "\nBound synx: ");
+				populate_bound_rows(row,
+					cur,
+					end);
+			}
+			spin_unlock_bh(&row->lock);
+			cur += scnprintf(cur, end - cur, "\n");
+			synx_util_release_object(client, i);
+		}
+		cur += scnprintf(cur, end - cur,
+			"\n================================================\n\n");
+		synx_put_client(client);
+	}
+
+	if (columns & ERROR_CODES && !list_empty(
+		&dev->error_list)) {
+		cur += scnprintf(
+			cur, end - cur, "\nError(s): ");
+
+		mutex_lock(&dev->error_lock);
+		list_for_each_entry_safe(
+			err_node, err_node_tmp,
+			&dev->error_list,
+			node) {
+			if (err_node->timestamp != NULL) {
+				cur += scnprintf(cur, end - cur,
+				"\n\tTime: %s - ID: %d - Code: %d",
+				err_node->timestamp,
+				err_node->h_synx,
+				err_node->error_code);
+			}
+			list_del(&err_node->node);
+			kfree(err_node);
+		}
+		mutex_unlock(&dev->error_lock);
+	}
+
+	len = simple_read_from_buffer(buf, count, ppos,
+		dbuf, cur - dbuf);
+	kfree(dbuf);
+	return len;
+}
+
+static ssize_t synx_table_write(struct file *file,
+		const char __user *buf,
+		size_t count,
+		loff_t *ppos)
+{
+	char *ptr;
+	char *kbuffer = kzalloc(48, GFP_KERNEL);
+	int stat = -1;
+
+	if (!kbuffer)
+		return -ENOMEM;
+	stat = copy_from_user(kbuffer, buf, 48);
+	if (stat != 0) {
+		kfree(kbuffer);
+		return -EFAULT;
+	}
+	while ((ptr = strsep(&kbuffer, delim)) != NULL) {
+		ptr += '\0';
+		if (strcmp(ptr, "bound\n") == 0)
+			columns = columns ^ BOUND_COLUMN;
+		else if (strcmp(ptr, "name\n") == 0)
+			columns = columns ^ NAME_COLUMN;
+		else if (strcmp(ptr, "synxid\n") == 0)
+			columns = columns ^ ID_COLUMN;
+		else if (strcmp(ptr, "status\n") == 0)
+			columns = columns ^ STATE_COLUMN;
+		else if (strcmp(ptr, "errors\n") == 0)
+			columns = columns ^ ERROR_CODES;
+	}
+	kfree(kbuffer);
+	return count;
+}
+
+static const struct file_operations synx_table_fops = {
+	.owner = THIS_MODULE,
+	.read = synx_table_read,
+	.write = synx_table_write,
+	.open = simple_open,
+};
+
+struct dentry *synx_init_debugfs_dir(struct synx_device *dev)
+{
+	struct dentry *dir = NULL;
+
+	dir = debugfs_create_dir("synx_debug", NULL);
+
+	if (!dir) {
+		pr_debug("Failed to create debugfs for synx\n");
+		return NULL;
+	}
+	if (!debugfs_create_file("synx_table",
+		0644, dir, dev, &synx_table_fops)) {
+		pr_debug("Failed to create debugfs file for synx\n");
+		return NULL;
+	}
+	mutex_init(&dev->error_lock);
+	INIT_LIST_HEAD(&dev->error_list);
+	return dir;
+}
+
+void synx_remove_debugfs_dir(struct synx_device *dev)
+{
+	debugfs_remove_recursive(dev->debugfs_root);
+}

drivers/media/platform/msm/synx/synx_debugfs.h

@@ -0,0 +1,29 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/debugfs.h>
+#include <linux/delay.h>
+
+#include "synx_private.h"
+
+/**
+ * @brief: Initializes debugfs
+ *
+ * @param dev : Pointer to synx device structure
+ */
+struct dentry *synx_init_debugfs_dir(struct synx_device *dev);
+
+/**
+ * @brief: Removes debugfs
+ *
+ * @param dev : Pointer to synx device structure
+ */
+void synx_remove_debugfs_dir(struct synx_device *dev);
+
+#define NAME_COLUMN 0x0001
+#define ID_COLUMN 0x0002
+#define BOUND_COLUMN 0x0004
+#define STATE_COLUMN  0x0008
+#define ERROR_CODES  0x8000

drivers/media/platform/msm/synx/synx_private.h

@@ -0,0 +1,303 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef __SYNX_PRIVATE_H__
+#define __SYNX_PRIVATE_H__
+
+#include <linux/bitmap.h>
+#include <linux/cdev.h>
+#include <linux/dma-fence.h>
+#include <linux/dma-fence-array.h>
+#include <linux/workqueue.h>
+
+#define SYNX_NAME                   "synx"
+#define SYNX_WORKQUEUE_NAME         "hiprio_synx_work_queue"
+#define SYNX_WORKQUEUE_THREADS      1
+#define SYNX_MAX_NUM_BINDINGS       8
+#define SYNX_DEVICE_NAME            "synx_device"
+
+#define SYNX_CLIENT_HANDLE_SHIFT    8
+#define SYNX_SECURE_KEY_SHIFT       16
+
+#define MAX_TIMESTAMP_SIZE          32
+#define SYNX_OBJ_NAME_LEN           64
+#define SYNX_MAX_CLIENTS            (1UL<<SYNX_CLIENT_HANDLE_SHIFT)
+#define SYNX_MAX_OBJS               1024
+#define SYNX_MAX_REF_COUNTS         2048
+#define SYNX_PAYLOAD_WORDS          4
+
+#define SYNX_SECURE_KEY_SIZE        (1UL<<SYNX_SECURE_KEY_SHIFT)
+#define SYNX_SECURE_KEY_MASK        (SYNX_SECURE_KEY_SIZE-1)
+#define SYNX_CLIENT_HANDLE_MASK     (SYNX_MAX_CLIENTS-1)
+
+#define SYNX_OBJ_TYPE_LOCAL         0x1
+#define SYNX_OBJ_TYPE_MERGED        0x2
+
+#define SYNX_STATE_FORCED_RELEASE   5
+
+/**
+ * struct synx_external_data - data passed over to external sync objects
+ * to pass on callback
+ *
+ * @session_id : Synx client id
+ * @h_synx     : Synx object handle
+ */
+struct synx_external_data {
+	struct synx_session session_id;
+	s32 h_synx;
+};
+
+/**
+ * struct synx_bind_desc - bind payload descriptor
+ *
+ * @external_desc : External bind information
+ * @external_data : Pointer to data passed over
+ */
+struct synx_bind_desc {
+	struct synx_external_desc external_desc;
+	struct synx_external_data *external_data;
+};
+
+/**
+ * struct error_node - Single error node related to a table_row
+ *
+ * @timestamp  : Time that the error occurred
+ * @client_id  : Synx client id
+ * @h_synx     : Synx object handle
+ * @error_code : Code related to the error
+ * @node       : List member used to append this node to error list
+ */
+struct error_node {
+	char timestamp[MAX_TIMESTAMP_SIZE];
+	u32 client_id;
+	s32 h_synx;
+	s32 error_code;
+	struct list_head node;
+};
+
+/**
+ * struct synx_kernel_payload - Single node of information about a kernel
+ * callback registered on a synx object
+ *
+ * @h_synx         : Synx object handle
+ * @data           : Callback data, passed by client driver
+ * @cb_func        : Callback function, registered by client driver
+ * @cancel_cb_func : Cancellation callback function
+ */
+struct synx_kernel_payload {
+	s32 h_synx;
+	void *data;
+	synx_callback cb_func;
+	synx_callback cancel_cb_func;
+};
+
+/**
+ * struct synx_user_payload - Single node of information about a callback
+ * registered from user space on a synx object
+ *
+ * @client : Synx client structure
+ * @h_synx : Synx object handle
+ * @status : Synx obj status or callback failure
+ * @data   : Payload data, opaque to kernel
+ */
+struct synx_user_payload {
+	struct synx_client *client;
+	s32 h_synx;
+	u32 status;
+	u64 data[SYNX_PAYLOAD_WORDS];
+};
+
+/**
+ * struct synx_cb_data - Single node of information about callback
+ * registered by client for the synx object
+ *
+ * @session_id  : Synx client id
+ * @idx         : Client payload table index
+ * @status      : Synx obj status or callback failure
+ * @cb_dispatch : Work representing the callback dispatch
+ * @node        : List member used to append this node to reg cb list
+ */
+struct synx_cb_data {
+	struct synx_session session_id;
+	u32 idx;
+	u32 status;
+	struct work_struct cb_dispatch;
+	struct list_head node;
+};
+
+/**
+ * struct synx_client_cb - Single node of information about cb payload
+ * registered by client
+ *
+ * @is_valid     : True if this is a valid entry
+ * @is_kernel_cb : True for kernel callback, false for user callback
+ * @idx          : Index of the client callback table
+ * @kernel_cb    : Kernel callback payload
+ * @user_cb      : Userspace callback payload
+ * @node         : List member used to append this node to event list
+ */
+struct synx_client_cb {
+	bool is_valid;
+	u32 idx;
+	struct synx_kernel_payload kernel_cb;
+	struct synx_user_payload user_cb;
+	struct list_head node;
+};
+
+/**
+ * struct synx_registered_ops - External sync clients registered for bind
+ * operations with synx driver
+ *
+ * @name  : Name of the external sync client
+ * @ops   : Bind operations struct for the client
+ * @type  : External client type
+ * @valid : Validity of the client registered bind ops
+ */
+struct synx_registered_ops {
+	char name[SYNX_OBJ_NAME_LEN];
+	struct bind_operations ops;
+	u32 type;
+	bool valid;
+};
+
+/**
+ * struct synx_coredata - Synx object, used for internal book keeping
+ * of all metadata associated with each individual synx object
+ *
+ * @name              : Optional string representation of the synx object
+ * @fence             : Dma fence backing the synx object
+ * @merged_fence      : Pointer to dma fence backing merged synx object
+ * @lock              : Spinlock
+ * @type              : Synx object type
+ * @num_bound_synxs   : Number of external bound synx objects
+ * @bound_synxs       : Array of bound external sync objects
+ * @reg_cbs_list      : List of all registered callbacks
+ */
+struct synx_coredata {
+	char name[SYNX_OBJ_NAME_LEN];
+	struct dma_fence fence;
+	struct dma_fence *merged_fence;
+	spinlock_t lock;
+	u32 type;
+	u32 num_bound_synxs;
+	struct synx_bind_desc bound_synxs[SYNX_MAX_NUM_BINDINGS];
+	struct list_head reg_cbs_list;
+};
+
+struct synx_client;
+struct synx_device;
+
+/**
+ * struct synx_handle_coredata - Internal struct to manage synx handle to
+ * synx object mapping along with tracking synx object usage by the client
+ * through reference counting
+ *
+ * @client            : Pointer to client owning the synx object
+ * @synx_obj          : Pointer to synx object
+ * @internal_refcount : References by the client
+ * @import_refcount   : References for external clients for import
+ * @id                : Synx object handle for the client
+ * @key               : Key for import authentication
+ */
+struct synx_handle_coredata {
+	struct synx_client *client;
+	struct synx_coredata *synx_obj;
+	struct kref internal_refcount;
+	struct kref import_refcount;
+	u32 id;
+	u16 key;
+};
+
+/**
+ * struct synx_client - Internal struct to book keep each client
+ * details
+ *
+ * @device          : Pointer to synx device structure
+ * @name            : Optional string representation of the client
+ * @id              : Unique client session id
+ * @event_q_lock    : Mutex for the event queue
+ * @event_q         : All the user callback payloads
+ * @event_wq        : Wait queue for the polling process
+ * @cb_bitmap       : Bitmap representation of all cb table entries
+ * @cb_table        : Table of all registered callbacks by client
+ * @bitmap          : Bitmap representation of all synx object handles
+ * @synx_table      : Table of all synx objects
+ * @synx_table_lock : Mutex array, one for each row in the synx table
+ */
+struct synx_client {
+	struct synx_device *device;
+	char name[SYNX_OBJ_NAME_LEN];
+	u32 id;
+	struct mutex event_q_lock;
+	struct list_head event_q;
+	wait_queue_head_t event_wq;
+	DECLARE_BITMAP(cb_bitmap, SYNX_MAX_OBJS);
+	struct synx_client_cb cb_table[SYNX_MAX_OBJS];
+	DECLARE_BITMAP(bitmap, SYNX_MAX_OBJS);
+	struct synx_handle_coredata synx_table[SYNX_MAX_OBJS];
+	struct mutex synx_table_lock[SYNX_MAX_OBJS];
+};
+
+/**
+ * struct synx_client_metadata - Internal struct to map client id with
+ * client data along with tracking usage through reference counting
+ *
+ * @client   : Pointer to client data
+ * @refcount : Outstanding references to client data
+ */
+struct synx_client_metadata {
+	struct synx_client *client;
+	struct kref refcount;
+};
+
+/**
+ * struct synx_device - Internal struct to book keep synx driver details
+ *
+ * @cdev          : Character device
+ * @dev           : Device type
+ * @class         : Device class
+ * @table_lock    : Mutex used to lock the table
+ * @bitmap        : Bitmap representation of all synx clients
+ * @client_table  : Table of all synx clients
+ * @work_queue    : Work queue used for dispatching callbacks
+ * @dma_context   : dma context id
+ * @vtbl_lock     : Mutex used to lock the bind table
+ * @bind_vtbl     : Table with registered bind ops for external sync
+ * @debugfs_root  : Root directory for debugfs
+ * @error_list    : List of all errors occurred
+ * @error_lock    : Mutex used to modify the error list
+ */
+struct synx_device {
+	struct cdev cdev;
+	dev_t dev;
+	struct class *class;
+	struct mutex dev_table_lock;
+	DECLARE_BITMAP(bitmap, SYNX_MAX_CLIENTS);
+	struct synx_client_metadata client_table[SYNX_MAX_CLIENTS];
+	struct workqueue_struct *work_queue;
+	u64 dma_context;
+	struct mutex vtbl_lock;
+	struct synx_registered_ops bind_vtbl[SYNX_MAX_BIND_TYPES];
+	struct dentry *debugfs_root;
+	struct list_head error_list;
+	struct mutex error_lock;
+};
+
+/**
+ * @brief: Internal function to signal the synx object
+ *
+ * @param synx_obj    : Pointer to the synx object to signal
+ * @param status      : Signaling status
+ * @param cb_signal   : If signaling invoked from external cb
+ * @param ext_sync_id : External sync id
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_signal_core(struct synx_coredata *synx_obj,
+	u32 status,
+	bool cb_signal,
+	s32 ext_sync_id);
+
+#endif /* __SYNX_PRIVATE_H__ */

drivers/media/platform/msm/synx/synx_util.c

@@ -0,0 +1,992 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+#define pr_fmt(fmt) "synx: " fmt
+
+#include <linux/slab.h>
+#include <linux/random.h>
+
+#include "synx_api.h"
+#include "synx_util.h"
+
+extern void synx_external_callback(s32 sync_obj, int status, void *data);
+
+bool synx_util_is_valid_bind_type(u32 type)
+{
+	if (type < SYNX_MAX_BIND_TYPES)
+		return true;
+
+	return false;
+}
+
+u32 synx_util_get_object_type(struct synx_coredata *synx_obj)
+{
+	if (!synx_obj)
+		return 0;
+
+	return synx_obj->type;
+}
+
+bool synx_util_is_merged_object(struct synx_coredata *synx_obj)
+{
+	if (synx_util_get_object_type(synx_obj)
+		& SYNX_OBJ_TYPE_MERGED)
+		return true;
+	return false;
+}
+
+struct dma_fence *synx_util_get_fence(struct synx_coredata *synx_obj)
+{
+	if (!synx_obj)
+		return NULL;
+
+	if (synx_util_is_merged_object(synx_obj))
+		return synx_obj->merged_fence;
+
+	return &synx_obj->fence;
+}
+
+void synx_util_get_object(struct synx_coredata *synx_obj)
+{
+	struct dma_fence *fence;
+
+	if (!synx_obj)
+		return;
+
+	fence = synx_util_get_fence(synx_obj);
+	dma_fence_get(fence);
+}
+
+void synx_util_put_object(struct synx_coredata *synx_obj)
+{
+	struct dma_fence *fence;
+
+	if (!synx_obj)
+		return;
+
+	fence = synx_util_get_fence(synx_obj);
+	dma_fence_put(fence);
+}
+
+int synx_util_init_coredata(struct synx_coredata *synx_obj,
+	struct synx_create_params *params,
+	struct dma_fence_ops *ops)
+{
+	if (!synx_obj || !params || !ops) {
+		pr_err("invalid arguments\n");
+		return -EINVAL;
+	}
+
+	spin_lock_init(&synx_obj->lock);
+	dma_fence_init(&synx_obj->fence, ops,
+		&synx_obj->lock, synx_dev->dma_context, 1);
+
+	synx_obj->type = SYNX_OBJ_TYPE_LOCAL;
+	INIT_LIST_HEAD(&synx_obj->reg_cbs_list);
+	if (params->name)
+		strlcpy(synx_obj->name, params->name, sizeof(synx_obj->name));
+
+	return 0;
+}
+
+int synx_util_init_group_coredata(struct synx_coredata *synx_obj,
+	struct dma_fence **fences,
+	u32 num_objs)
+{
+	struct dma_fence_array *array;
+
+	if (!synx_obj)
+		return -EINVAL;
+
+	array = dma_fence_array_create(num_objs, fences,
+				synx_dev->dma_context, 1, false);
+	if (!array)
+		return -EINVAL;
+
+	synx_obj->merged_fence = &array->base;
+	synx_obj->type = SYNX_OBJ_TYPE_LOCAL | SYNX_OBJ_TYPE_MERGED;
+	INIT_LIST_HEAD(&synx_obj->reg_cbs_list);
+
+	return 0;
+}
+
+void synx_util_object_destroy(struct synx_coredata *synx_obj)
+{
+	int rc;
+	u32 i;
+	s32 sync_id;
+	u32 type;
+	struct synx_cb_data *synx_cb, *synx_cb_temp;
+	struct synx_bind_desc *bind_desc;
+	struct bind_operations *bind_ops;
+	struct synx_external_data *data;
+
+	/* clear all the undispatched callbacks */
+	list_for_each_entry_safe(synx_cb,
+		synx_cb_temp, &synx_obj->reg_cbs_list, node) {
+		pr_err("[sess: %u] cleaning up callback\n",
+			synx_cb->session_id.client_id);
+		list_del_init(&synx_cb->node);
+		kfree(synx_cb);
+	}
+
+	for (i = 0; i < synx_obj->num_bound_synxs; i++) {
+		bind_desc = &synx_obj->bound_synxs[i];
+		sync_id = bind_desc->external_desc.id[0];
+		type = bind_desc->external_desc.type;
+		data = bind_desc->external_data;
+		bind_ops = synx_util_get_bind_ops(type);
+		rc = bind_ops->deregister_callback(
+				synx_external_callback, data, sync_id);
+		if (rc < 0)
+			pr_err("de-registration fail id: %d, type: %u, err: %d\n",
+				sync_id, type, rc);
+		/*
+		 * release the memory allocated for external data.
+		 * It is safe to release this memory as external cb
+		 * has been already deregistered before this.
+		 * even if deregistration fails, it implies the
+		 * external fence might have been cleaned up already
+		 * or in some bad state. Have to release cb data
+		 * at this point or else will lead to memory leak.
+		 */
+		kfree(data);
+	}
+
+	kfree(synx_obj);
+	pr_debug("cleaned up synx object fence\n");
+}
+
+int synx_util_init_handle(struct synx_client *client,
+	struct synx_coredata *synx_obj,
+	long *h_synx)
+{
+	bool bit;
+	long idx;
+	struct synx_handle_coredata *synx_data;
+
+	if (!client || !synx_obj)
+		return -EINVAL;
+
+	do {
+		idx = find_first_zero_bit(client->bitmap, SYNX_MAX_OBJS);
+		if (idx >= SYNX_MAX_OBJS) {
+			pr_err("[sess: %u] free index not available\n",
+				client->id);
+			return -ENOMEM;
+		}
+		bit = test_and_set_bit(idx, client->bitmap);
+	} while (bit);
+
+	synx_data = &client->synx_table[idx];
+	synx_data->client = client;
+	synx_data->id = idx;
+	synx_data->synx_obj = synx_obj;
+	kref_init(&synx_data->internal_refcount);
+
+	*h_synx = idx;
+	return 0;
+}
+
+int synx_util_activate(struct synx_coredata *synx_obj)
+{
+	struct dma_fence *fence;
+
+	if (!synx_obj)
+		return -EINVAL;
+
+	fence = synx_util_get_fence(synx_obj);
+	/* move synx to ACTIVE state and register cb for merged object */
+	dma_fence_enable_sw_signaling(fence);
+	return 0;
+}
+
+static u32 synx_util_get_references(struct synx_coredata *synx_obj)
+{
+	u32 count = 0;
+	u32 i = 0;
+	struct dma_fence *fence;
+	struct dma_fence_array *array = NULL;
+
+	fence = synx_util_get_fence(synx_obj);
+	/* obtain dma fence reference */
+	if (dma_fence_is_array(fence)) {
+		array = to_dma_fence_array(fence);
+		if (!array)
+			return 0;
+
+		for (i = 0; i < array->num_fences; i++)
+			dma_fence_get(array->fences[i]);
+
+		count = array->num_fences;
+	} else {
+		dma_fence_get(fence);
+		count = 1;
+	}
+
+	return count;
+}
+
+static void synx_util_put_references(struct synx_coredata *synx_obj)
+{
+	u32 i = 0;
+	struct dma_fence *fence;
+	struct dma_fence_array *array = NULL;
+
+	fence = synx_util_get_fence(synx_obj);
+	if (dma_fence_is_array(fence)) {
+		array = to_dma_fence_array(fence);
+		if (!array)
+			return;
+
+		for (i = 0; i < array->num_fences; i++)
+			dma_fence_put(array->fences[i]);
+	} else {
+		dma_fence_put(fence);
+	}
+}
+
+static u32 synx_util_add_fence(struct synx_coredata *synx_obj,
+	struct dma_fence **fences,
+	u32 idx)
+{
+	struct dma_fence *fence;
+	struct dma_fence_array *array = NULL;
+	u32 i = 0;
+
+	fence = synx_util_get_fence(synx_obj);
+	if (dma_fence_is_array(fence)) {
+		array = to_dma_fence_array(fence);
+		if (!array)
+			return 0;
+
+		for (i = 0; i < array->num_fences; i++)
+			fences[idx+i] = array->fences[i];
+
+		return array->num_fences;
+	}
+
+	fences[idx] = fence;
+	return 1;
+}
+
+static u32 synx_util_remove_duplicates(struct dma_fence **arr, u32 num)
+{
+	int i, j;
+	u32 wr_idx = 1;
+
+	if (!arr) {
+		pr_err("invalid input array\n");
+		return 0;
+	}
+
+	for (i = 1; i < num; i++) {
+		for (j = 0; j < wr_idx ; j++) {
+			if (arr[i] == arr[j]) {
+				/* release reference obtained for duplicate */
+				pr_debug("releasing duplicate reference\n");
+				dma_fence_put(arr[i]);
+				break;
+			}
+		}
+		if (j == wr_idx)
+			arr[wr_idx++] = arr[i];
+	}
+
+	return wr_idx;
+}
+
+s32 synx_util_merge_error(struct synx_client *client,
+	s32 *h_synxs,
+	u32 num_objs)
+{
+	u32 i = 0;
+	struct synx_coredata *synx_obj;
+
+	if (!client || !h_synxs)
+		return -EINVAL;
+
+	for (i = 0; i < num_objs; i++) {
+		synx_obj = synx_util_acquire_object(client, h_synxs[i]);
+		if (!synx_obj) {
+			pr_err("[sess: %u] invalid handle %d in merge cleanup\n",
+				client->id, h_synxs[i]);
+			continue;
+		}
+		/* release all references obtained during merge validatation */
+		synx_util_put_references(synx_obj);
+		synx_util_release_object(client, h_synxs[i]);
+	}
+
+	return 0;
+}
+
+int synx_util_validate_merge(struct synx_client *client,
+	s32 *h_synxs,
+	u32 num_objs,
+	struct dma_fence ***fence_list,
+	u32 *fence_cnt)
+{
+	u32 count = 0;
+	u32 i = 0;
+	struct synx_coredata **synx_objs = NULL;
+	struct dma_fence **fences = NULL;
+
+	if (num_objs <= 1) {
+		pr_err("single object merge is not allowed\n");
+		return -EINVAL;
+	}
+
+	synx_objs = kcalloc(num_objs, sizeof(*synx_objs), GFP_KERNEL);
+	if (!synx_objs)
+		return -ENOMEM;
+
+	for (i = 0; i < num_objs; i++) {
+		synx_objs[i] = synx_util_acquire_object(client, h_synxs[i]);
+		if (!synx_objs) {
+			pr_err("[sess: %u] invalid handle %d in merge list\n",
+				client->id, h_synxs[i]);
+			*fence_cnt = i;
+			return -EINVAL;
+		}
+		count += synx_util_get_references(synx_objs[i]);
+	}
+
+	fences = kcalloc(count, sizeof(*fences), GFP_KERNEL);
+	if (!fences) {
+		*fence_cnt = num_objs;
+		return -ENOMEM;
+	}
+
+	/* memory will be released later in the invoking function */
+	*fence_list = fences;
+	count = 0;
+
+	for (i = 0; i < num_objs; i++) {
+		count += synx_util_add_fence(synx_objs[i], fences, count);
+		/* release the reference obtained earlier in the function */
+		synx_util_release_object(client, h_synxs[i]);
+	}
+
+	*fence_cnt = synx_util_remove_duplicates(fences, count);
+	kfree(synx_objs);
+	return 0;
+}
+
+static u32 __fence_state(struct dma_fence *fence, bool locked)
+{
+	s32 status;
+	u32 state = SYNX_STATE_INVALID;
+
+	if (!fence) {
+		pr_err("invalid dma fence addr\n");
+		return SYNX_STATE_INVALID;
+	}
+
+	if (locked)
+		status = dma_fence_get_status_locked(fence);
+	else
+		status = dma_fence_get_status(fence);
+
+	/* convert fence status to synx state */
+	switch (status) {
+	case 0:
+		state = SYNX_STATE_ACTIVE;
+		break;
+	case 1:
+		state = SYNX_STATE_SIGNALED_SUCCESS;
+		break;
+	case -SYNX_STATE_SIGNALED_CANCEL:
+		state = SYNX_STATE_SIGNALED_CANCEL;
+		break;
+	case -SYNX_STATE_FORCED_RELEASE:
+		state = SYNX_STATE_FORCED_RELEASE;
+		break;
+	case -SYNX_STATE_SIGNALED_ERROR:
+	default:
+		state = SYNX_STATE_SIGNALED_ERROR;
+	}
+
+	return state;
+}
+
+static u32 __fence_group_state(struct dma_fence *fence, bool locked)
+{
+	u32 i = 0;
+	u32 state = SYNX_STATE_INVALID;
+	struct dma_fence_array *array = NULL;
+	u32 intr, actv_cnt, sig_cnt, err_cnt;
+
+	if (!fence) {
+		pr_err("invalid dma fence addr\n");
+		return SYNX_STATE_INVALID;
+	}
+
+	actv_cnt = sig_cnt = err_cnt = 0;
+	array = to_dma_fence_array(fence);
+	if (!array)
+		return SYNX_STATE_INVALID;
+
+	for (i = 0; i < array->num_fences; i++) {
+		intr = __fence_state(array->fences[i], locked);
+		switch (intr) {
+		case SYNX_STATE_ACTIVE:
+			actv_cnt++;
+			break;
+		case SYNX_STATE_SIGNALED_SUCCESS:
+			sig_cnt++;
+			break;
+		default:
+			err_cnt++;
+		}
+	}
+
+	pr_debug("group cnt stats act:%u, sig: %u, err: %u\n",
+		actv_cnt, sig_cnt, err_cnt);
+
+	if (err_cnt)
+		state = SYNX_STATE_SIGNALED_ERROR;
+	else if (actv_cnt)
+		state = SYNX_STATE_ACTIVE;
+	else if (sig_cnt == array->num_fences)
+		state = SYNX_STATE_SIGNALED_SUCCESS;
+
+	return state;
+}
+
+/*
+ * WARN: Should not hold the synx spinlock when invoking
+ * this function. Use synx_fence_state_locked instead
+ */
+u32 synx_util_get_object_status(struct synx_coredata *synx_obj)
+{
+	u32 state;
+	struct dma_fence *fence;
+
+	if (!synx_obj)
+		return SYNX_STATE_INVALID;
+
+	fence = synx_util_get_fence(synx_obj);
+	if (synx_util_is_merged_object(synx_obj))
+		state = __fence_group_state(fence, false);
+	else
+		state = __fence_state(fence, false);
+
+	return state;
+}
+
+/* use this for status check when holding on to metadata spinlock */
+u32 synx_util_get_object_status_locked(struct synx_coredata *synx_obj)
+{
+	u32 state;
+	struct dma_fence *fence;
+
+	if (!synx_obj)
+		return SYNX_STATE_INVALID;
+
+	fence = synx_util_get_fence(synx_obj);
+	if (synx_util_is_merged_object(synx_obj))
+		state = __fence_group_state(fence, true);
+	else
+		state = __fence_state(fence, true);
+
+	return state;
+}
+
+struct synx_handle_coredata *synx_util_obtain_handle(
+	struct synx_client *client,
+	s32 h_synx)
+{
+	if (!client) {
+		pr_err("invalid session argument\n");
+		return NULL;
+	}
+
+	if (h_synx < 0 || h_synx >= SYNX_MAX_OBJS) {
+		pr_err("[sess: %u] invalid handle %d access\n",
+			client->id, h_synx);
+		return NULL;
+	}
+
+	return &client->synx_table[h_synx];
+}
+
+struct synx_coredata *synx_util_acquire_object(
+	struct synx_client *client, s32 h_synx)
+{
+	struct synx_coredata *synx_obj = NULL;
+	struct synx_handle_coredata *synx_data =
+		synx_util_obtain_handle(client, h_synx);
+
+	if (!synx_data)
+		return NULL;
+
+	mutex_lock(&client->synx_table_lock[h_synx]);
+	synx_obj = synx_data->synx_obj;
+	if (synx_obj) {
+		synx_util_get_object(synx_obj);
+		kref_get(&synx_data->internal_refcount);
+		pr_debug("[sess: %u] acquired synx object for handle %d\n",
+			client->id, h_synx);
+	}
+	mutex_unlock(&client->synx_table_lock[h_synx]);
+
+	return synx_obj;
+}
+
+static void synx_util_destroy_handle(struct synx_handle_coredata *synx_data)
+{
+	long idx = synx_data->id;
+	struct synx_client *client = synx_data->client;
+
+	if (synx_util_is_merged_object(synx_data->synx_obj)) {
+		pr_debug("cleaned up synx object fence\n");
+		kfree(synx_data->synx_obj);
+	}
+
+	memset(synx_data, 0, sizeof(*synx_data));
+	clear_bit(idx, client->bitmap);
+	pr_debug("[sess: %u] handle %d destroyed\n",
+		client->id, idx);
+}
+
+void synx_util_destroy_import_handle(struct kref *kref)
+{
+	struct synx_handle_coredata *synx_data =
+		container_of(kref, struct synx_handle_coredata,
+		import_refcount);
+
+	pr_debug("[sess: %u] import handle cleanup for %d\n",
+		synx_data->client->id, synx_data->id);
+
+	/* in case of pending internal references, abort clean up */
+	if (kref_read(&synx_data->internal_refcount))
+		return;
+
+	synx_util_destroy_handle(synx_data);
+}
+
+void synx_util_destroy_internal_handle(struct kref *kref)
+{
+	struct synx_handle_coredata *synx_data =
+		container_of(kref, struct synx_handle_coredata,
+		internal_refcount);
+
+	pr_debug("[sess: %u] internal handle cleanup for %d\n",
+		synx_data->client->id, synx_data->id);
+
+	/* in case of pending imports, abort clean up */
+	if (kref_read(&synx_data->import_refcount))
+		return;
+
+	synx_util_destroy_handle(synx_data);
+}
+
+void synx_util_release_object(struct synx_client *client, s32 h_synx)
+{
+	struct synx_handle_coredata *synx_data =
+		synx_util_obtain_handle(client, h_synx);
+	struct synx_coredata *synx_obj;
+	struct dma_fence *fence;
+
+	if (!synx_data)
+		return;
+
+	mutex_lock(&client->synx_table_lock[h_synx]);
+	synx_obj = synx_data->synx_obj;
+	if (synx_obj) {
+		fence = synx_util_get_fence(synx_obj);
+		kref_put(&synx_data->internal_refcount,
+			synx_util_destroy_internal_handle);
+		dma_fence_put(fence);
+	}
+	mutex_unlock(&client->synx_table_lock[h_synx]);
+}
+
+struct bind_operations *synx_util_get_bind_ops(u32 type)
+{
+	struct synx_registered_ops *client_ops;
+
+	if (!synx_util_is_valid_bind_type(type))
+		return NULL;
+
+	mutex_lock(&synx_dev->vtbl_lock);
+	client_ops = &synx_dev->bind_vtbl[type];
+	if (!client_ops->valid) {
+		mutex_unlock(&synx_dev->vtbl_lock);
+		return NULL;
+	}
+	mutex_unlock(&synx_dev->vtbl_lock);
+
+	return &client_ops->ops;
+}
+
+int synx_util_alloc_cb_entry(struct synx_client *client,
+	u32 *cb_idx)
+{
+	bool bit;
+	long idx;
+	struct synx_client_cb *cb;
+
+	if (!client || !cb_idx)
+		return -EINVAL;
+
+	do {
+		idx = find_first_zero_bit(client->cb_bitmap, SYNX_MAX_OBJS);
+		if (idx >= SYNX_MAX_OBJS) {
+			pr_err("[sess: %u] free cb index not available\n",
+				client->id);
+			return -ENOMEM;
+		}
+		bit = test_and_set_bit(idx, client->cb_bitmap);
+	} while (bit);
+
+	cb = &client->cb_table[idx];
+	memset(cb, 0, sizeof(*cb));
+	cb->idx = idx;
+	*cb_idx = idx;
+	pr_debug("[sess: %u] allocated cb index %u\n", client->id, idx);
+	return 0;
+}
+
+int synx_util_update_cb_entry(struct synx_client *client,
+	void *data,
+	u32 cb_idx)
+{
+	struct synx_client_cb *cb;
+
+	if (!client || !data || (cb_idx >= SYNX_MAX_OBJS))
+		return -EINVAL;
+
+	cb = &client->cb_table[cb_idx];
+	cb->is_valid = true;
+	memcpy(&cb->kernel_cb, data,
+		sizeof(cb->kernel_cb));
+
+	pr_debug("[sess: %u] updated cb index %u\n", client->id, cb_idx);
+	return 0;
+}
+
+void synx_util_callback_dispatch(struct synx_coredata *synx_obj, u32 status)
+{
+	struct synx_cb_data *synx_cb, *synx_cb_temp;
+
+	if (!synx_obj) {
+		pr_err("invalid arguments\n");
+		return;
+	}
+
+	list_for_each_entry_safe(synx_cb,
+		synx_cb_temp, &synx_obj->reg_cbs_list, node) {
+		synx_cb->status = status;
+		list_del_init(&synx_cb->node);
+		queue_work(synx_dev->work_queue,
+			&synx_cb->cb_dispatch);
+		pr_debug("dispatched callback\n");
+	}
+}
+
+void synx_util_cb_dispatch(struct work_struct *cb_dispatch)
+{
+	struct synx_cb_data *synx_cb =
+		container_of(cb_dispatch, struct synx_cb_data, cb_dispatch);
+	struct synx_client *client;
+	struct synx_client_cb *cb;
+	struct synx_kernel_payload *payload;
+
+	client = synx_get_client(synx_cb->session_id);
+	if (!client) {
+		pr_err("invalid session data %u in cb payload\n",
+			synx_cb->session_id);
+		goto free;
+	}
+
+	if (synx_cb->idx >= SYNX_MAX_OBJS) {
+		pr_err("[sess: %u] invalid cb index\n",
+			client->id);
+		goto fail;
+	}
+
+	cb = &client->cb_table[synx_cb->idx];
+	if (!cb->is_valid) {
+		pr_err("invalid cb payload\n");
+		goto fail;
+	}
+
+	payload = &cb->kernel_cb;
+	pr_debug("[sess: %u] kernel cb dispatch for handle %d\n",
+		client->id, payload->h_synx);
+
+	/* dispatch kernel callback */
+	payload->cb_func(payload->h_synx,
+		synx_cb->status,
+		payload->data);
+
+fail:
+	synx_put_client(client);
+free:
+	pr_debug("released synx_cb_data memory\n");
+	kfree(synx_cb);
+}
+
+struct synx_coredata *synx_util_import_object(struct synx_import_params *params)
+{
+	u16 key;
+	s32 h_synx;
+	u32 secure_key;
+	struct synx_session ex_session_id;
+	struct synx_client *ex_client;
+	struct synx_handle_coredata *synx_data;
+	struct synx_coredata *synx_obj = NULL;
+
+	if (!params)
+		return NULL;
+
+	h_synx = params->h_synx;
+	secure_key = params->secure_key;
+
+	ex_session_id.client_id = secure_key & SYNX_CLIENT_HANDLE_MASK;
+	key = (secure_key >> SYNX_CLIENT_HANDLE_SHIFT) & SYNX_SECURE_KEY_MASK;
+
+	/* get the client exporting the synx handle */
+	ex_client = synx_get_client(ex_session_id);
+	if (!ex_client) {
+		pr_err("sess: %u invalid import handle %d and/or key %u\n",
+			ex_session_id.client_id, h_synx, secure_key);
+		return NULL;
+	}
+
+	synx_data = synx_util_obtain_handle(ex_client, h_synx);
+	if (!synx_data) {
+		pr_err("[sess: %u] invalid import handle %d\n",
+			ex_client->id, h_synx);
+		goto fail;
+	}
+
+	mutex_lock(&ex_client->synx_table_lock[h_synx]);
+	/* need to check whether import is accounted for in import_refcount */
+	if (synx_data->synx_obj &&
+		key && (key == synx_data->key) &&
+		kref_read(&synx_data->import_refcount)) {
+		if (synx_util_is_merged_object(synx_data->synx_obj)) {
+			/*
+			 * need to copy the synx coredata for merged object
+			 * as we need to clean up the coredata on release
+			 * since fence array cannot be registered with
+			 * synx_fence_release function.
+			 */
+			synx_obj = kzalloc(sizeof(*synx_obj), GFP_KERNEL);
+			if (synx_obj)
+				memcpy(synx_obj, synx_data->synx_obj,
+					sizeof(*synx_obj));
+		} else {
+			synx_obj = synx_data->synx_obj;
+		}
+		/* release the reference obtained during export */
+		kref_put(&synx_data->import_refcount,
+			synx_util_destroy_import_handle);
+		pr_debug("sess: %u handle %d import successful\n",
+			ex_client->id, h_synx);
+	}
+	mutex_unlock(&ex_client->synx_table_lock[h_synx]);
+
+fail:
+	synx_put_client(ex_client);
+	return synx_obj;
+}
+
+int synx_util_export_object(struct synx_client *client,
+	struct synx_export_params *params)
+{
+	int rc = 0;
+	u16 key = 0;
+	s32 h_synx;
+	struct synx_handle_coredata *synx_data;
+
+	if (!params || !params->secure_key)
+		return -EINVAL;
+
+	h_synx = params->h_synx;
+	synx_data = synx_util_obtain_handle(client, h_synx);
+	if (!synx_data) {
+		pr_err("[sess: %u] invalid export handle %d\n",
+			client->id, h_synx);
+		rc = -EINVAL;
+		goto fail;
+	}
+
+	mutex_lock(&client->synx_table_lock[h_synx]);
+	/* need to check whether import is accounted for in import_refcount */
+	if (synx_data->synx_obj) {
+		/* generate the key on the first export of the handle */
+		if (!synx_data->key) {
+			kref_init(&synx_data->import_refcount);
+			while (!key)
+				get_random_bytes(&key, sizeof(key));
+			synx_data->key = key;
+			pr_debug("[sess: %u] import refcount initialized\n",
+				client->id);
+		} else {
+			kref_get(&synx_data->import_refcount);
+			key = synx_data->key;
+		}
+		/*
+		 * to make sure the synx is not lost if the process
+		 * dies or synx is released before any other process
+		 * gets a chance to import it.
+		 * The assumption is that an import will match this
+		 * and account for the extra reference. Otherwise,
+		 * this will be released upon client uninit.
+		 */
+		synx_util_get_object(synx_data->synx_obj);
+
+		/* encode the key and the client id to user provided variable */
+		*params->secure_key = key;
+		*params->secure_key <<= SYNX_CLIENT_HANDLE_SHIFT;
+		*params->secure_key |= client->id;
+
+		pr_debug("[sess: %u] handle %d export successful with key %u\n",
+			client->id, params->h_synx, *params->secure_key);
+	} else {
+		pr_err("[sess: %u] invalid export object %d\n",
+			client->id, h_synx);
+		rc = -EINVAL;
+	}
+	mutex_unlock(&client->synx_table_lock[h_synx]);
+
+fail:
+	return rc;
+}
+
+struct synx_client *synx_get_client(struct synx_session session_id)
+{
+	struct synx_client_metadata *client_metadata;
+	struct synx_client *client;
+	u32 id = session_id.client_id;
+
+	if (id >= SYNX_MAX_CLIENTS) {
+		pr_err("%s: invalid session handle %u from pid: %d\n",
+			__func__, id, current->pid);
+		return NULL;
+	}
+
+	mutex_lock(&synx_dev->dev_table_lock);
+	client_metadata = &synx_dev->client_table[id];
+	client = client_metadata->client;
+	if (client)
+		kref_get(&client_metadata->refcount);
+	else
+		pr_err("session %u not available, pid: %d\n",
+			id, current->pid);
+	mutex_unlock(&synx_dev->dev_table_lock);
+
+	return client;
+}
+
+static void synx_client_destroy(struct kref *kref)
+{
+	u32 i;
+	struct synx_client_metadata *client_metadata =
+		container_of(kref, struct synx_client_metadata, refcount);
+	struct synx_client *client = client_metadata->client;
+	struct synx_handle_coredata *synx_data;
+	struct synx_coredata *synx_obj;
+	struct dma_fence *fence;
+
+	/* TODO:can create a thread and handle it */
+
+	/* go over all the remaining synx obj handles and clear them */
+	for (i = 0; i < SYNX_MAX_OBJS; i++) {
+		synx_data = &client->synx_table[i];
+		synx_obj = synx_data->synx_obj;
+		/*
+		 * cleanup unreleased references by the client
+		 * Note: it is only safe to access synx_obj if
+		 * there are refcounts (internal, import)
+		 * remaining in the current handle, as it
+		 * gurantees corresponding reference to fence.
+		 */
+		if (synx_obj) {
+			fence = synx_util_get_fence(synx_obj);
+			while (kref_read(&synx_data->internal_refcount)) {
+				kref_put(&synx_data->internal_refcount,
+					synx_util_destroy_internal_handle);
+				dma_fence_put(fence);
+			}
+			while (kref_read(&synx_data->import_refcount)) {
+				kref_put(&synx_data->import_refcount,
+					synx_util_destroy_import_handle);
+				dma_fence_put(fence);
+			}
+		}
+		mutex_destroy(&client->synx_table_lock[i]);
+	}
+	mutex_destroy(&client->event_q_lock);
+	memset(client_metadata, 0, sizeof(*client_metadata));
+	clear_bit(client->id, synx_dev->bitmap);
+
+	pr_debug("[sess: %u] session destroyed %s\n",
+		client->id, client->name);
+	kfree(client);
+}
+
+void synx_put_client(struct synx_client *client)
+{
+	struct synx_client_metadata *client_metadata;
+
+	if (!client) {
+		pr_err("%s: invalid client ptr\n", __func__);
+		return;
+	}
+
+	if (client->id >= SYNX_MAX_CLIENTS) {
+		pr_err("%s: session id %u invalid from pid: %d\n",
+			__func__, client->id, current->pid);
+		return;
+	}
+
+	mutex_lock(&synx_dev->dev_table_lock);
+	client_metadata = &synx_dev->client_table[client->id];
+	if (client_metadata->client == client)
+		/* should not reference client after this call */
+		kref_put(&client_metadata->refcount, synx_client_destroy);
+	else
+		pr_err("%s: invalid session %u from pid: %d\n",
+			__func__, client->id, current->pid);
+	mutex_unlock(&synx_dev->dev_table_lock);
+}
+
+void synx_util_generate_timestamp(char *timestamp, size_t size)
+{
+	struct timespec64 tv;
+	struct tm tm;
+
+	ktime_get_real_ts64(&tv);
+	time64_to_tm(tv.tv_sec, 0, &tm);
+	snprintf(timestamp, size, "%02d-%02d %02d:%02d:%02d",
+		tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,
+		tm.tm_min, tm.tm_sec);
+}
+
+void synx_util_log_error(u32 client_id, s32 h_synx, s32 err)
+{
+	struct error_node *err_node;
+
+	if (!synx_dev->debugfs_root)
+		return;
+
+	err_node = kzalloc(sizeof(*err_node), GFP_KERNEL);
+	if (!err_node)
+		return;
+
+	err_node->client_id = client_id;
+	err_node->error_code = err;
+	err_node->h_synx = h_synx;
+	synx_util_generate_timestamp(err_node->timestamp,
+		sizeof(err_node->timestamp));
+	mutex_lock(&synx_dev->error_lock);
+	list_add(&err_node->node,
+		&synx_dev->error_list);
+	mutex_unlock(&synx_dev->error_lock);
+}

drivers/media/platform/msm/synx/synx_util.h

@@ -0,0 +1,365 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef __SYNX_UTIL_H__
+#define __SYNX_UTIL_H__
+
+#include "synx_private.h"
+
+extern struct synx_device *synx_dev;
+
+/**
+ * @brief: Function to check if the external obj type is valid
+ *
+ * @param type : External sync object type
+ *
+ * @return True if valid. False otherwise
+ */
+bool synx_util_is_valid_bind_type(u32 type);
+
+/**
+ * @brief: Function to get the synx object type
+ *
+ * @param synx_obj : Pointer to synx object
+ *
+ * @return Synx object type. Zero if invalid
+ */
+u32 synx_util_get_object_type(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to check if the synx object is a composite (merged)
+ *
+ * @param synx_obj : Pointer to synx object
+ *
+ * @return True if merged object. False otherwise
+ */
+bool synx_util_is_merged_object(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to get the dma fence backing the synx object
+ *
+ * @param synx_obj : Pointer to synx object
+ *
+ * @return Dma fence. NULL if synx_obj is invalid
+ */
+struct dma_fence *synx_util_get_fence(
+	struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to acquire reference to synx object
+ *
+ * This acquires additional reference to the synx object and should be
+ * released using synx_util_put_object
+ *
+ * @param synx_obj : Pointer to synx object
+ */
+void synx_util_get_object(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to release reference to synx object
+ *
+ * This releases reference to the synx object and should be
+ * matched with synx_util_get_object
+ *
+ * @param synx_obj : Pointer to synx object
+ */
+void synx_util_put_object(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to initialize synx object
+ *
+ * It also initializes the dma fence. This should be called only
+ * for individual objects.
+ *
+ * @param synx_obj : Pointer to synx object
+ * @param params   : Pointer to create params
+ * @param ops      : Dma fence ops required for fence initialization
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_init_coredata(struct synx_coredata *synx_obj,
+	struct synx_create_params *params,
+	struct dma_fence_ops *ops);
+
+/**
+ * @brief: Function to initialize a merged synx object.
+ *
+ * It also initializes dma fence array.
+ *
+ * @param synx_obj : Pointer to synx object
+ * @param fences   : Array of fence objects which will merged
+ *                   or grouped together to a fence array
+ * @param num_objs : Number of fence objects in the array
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_init_group_coredata(struct synx_coredata *synx_obj,
+	struct dma_fence **fences,
+	u32 num_objs);
+
+/**
+ * @brief: Function to cleanup the synx object
+ *
+ * This function will be invoked when the dma fence ref count reaches 0.
+ *
+ * @param synx_obj : Pointer to synx object
+ */
+void synx_util_object_destroy(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to allocate synx_client_cb entry from cb table
+ *
+ * @param client : Pointer to client session info
+ * @param cb_idx : Allocated index (filled by function)
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_alloc_cb_entry(struct synx_client *client,
+	u32 *cb_idx);
+
+/**
+ * @brief: Function to allocate synx_client_cb entry from cb table
+ *
+ * @param client : Pointer to client session info
+ * @param data   : Opaque payload data
+ * @param cb_idx : Callback table index
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_update_cb_entry(struct synx_client *client,
+	void *data,
+	u32 cb_idx);
+
+/**
+ * @brief: Function to initialize synx object handle for the client
+ *
+ * @param client   : Pointer to client session info
+ * @param synx_obj : Pointer to synx object
+ * @param h_synx   : Pointer to synx object handle (filled by function)
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_init_handle(struct synx_client *client,
+	struct synx_coredata *synx_obj,
+	long *h_synx);
+
+/**
+ * @brief: Function to activate the synx object. Moves the synx from INVALID
+ * state to ACTIVE state.
+ *
+ * @param synx_obj : Pointer to synx object
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_activate(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to queue all the registered callbacks by clients for
+ * the synx object
+ *
+ * @param synx_obj : Pointer to synx object
+ * @param state    : State of the object
+ */
+void synx_util_callback_dispatch(struct synx_coredata *synx_obj, u32 state);
+
+/**
+ * @brief: Function to dispatch client registered callback
+ *
+ * @param cb_dispatch : Pointer to work_struct that needs to be dispatched
+ */
+void synx_util_cb_dispatch(struct work_struct *cb_dispatch);
+
+/**
+ * @brief: Function to handle error during merging of synx objects
+ *
+ * Removes the references added on the dma fence objects
+ *
+ * @param client   : Pointer to client session
+ * @param h_synxs  : Array of synx object handles to merge
+ * @param num_objs : Number of synx obects in the array
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+s32 synx_util_merge_error(struct synx_client *client,
+	s32 *h_synxs,
+	u32 num_objs);
+
+/**
+ * @brief: Function to validate synx merge arguments.
+ *
+ * It obtains the necessary references to the fence objects
+ * and also removes duplicates (if any).
+ *
+ * @param client    : Pointer to client session
+ * @param h_synxs   : Array of synx object handles to merge
+ * @param num_objs  : Number of synx objects in the array
+ * @param fences    : Address to a list of dma fence* array
+ * @param fence_cnt : Number of fence objects in the fences array
+ *                    (filled by the function)
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_validate_merge(struct synx_client *client,
+	s32 *h_synxs,
+	u32 num_objs,
+	struct dma_fence ***fences,
+	u32 *fence_cnt);
+
+/**
+ * @brief: Function to obtain the state of synx object
+ *
+ * The lock associated with the synx obj should not be
+ * held when invoking this function.
+ * Use synx_util_get_object_status_locked for state enquiry
+ * when holding lock
+ *
+ * @param synx_obj : Pointer to synx object
+ *
+ * @return Status of the synx object.
+ */
+u32 synx_util_get_object_status(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to obtain the state of synx object
+ *
+ * The lock associated with the synx obj should be held
+ * when invoking this function.
+ * Use synx_util_get_object_status for state enquiry
+ * when not holding lock
+ *
+ * @param synx_obj : Pointer to synx object
+ *
+ * @return Status of the synx object.
+ */
+u32 synx_util_get_object_status_locked(struct synx_coredata *synx_obj);
+
+/**
+ * @brief: Function to obtain the synx object metadata for the client
+ *
+ * @param client : Pointer to client session
+ * @param h_synx : Synx object handle
+ *
+ * @return Pointer to synx object metadata for the client.
+ * NULL if invalid synx handle.
+ */
+struct synx_handle_coredata *synx_util_obtain_handle(
+	struct synx_client *client, s32 h_synx);
+
+/**
+ * @brief: Function to acquire the synx object
+ *
+ * This function increments the reference count of the dma fence.
+ *
+ * @param client : Pointer to client session
+ * @param h_synx : Synx object handle
+ *
+ * @return Pointer to synx object. NULL if invalid synx handle.
+ */
+struct synx_coredata *synx_util_acquire_object(
+	struct synx_client *client, s32 h_synx);
+
+/**
+ * @brief: Function to release the synx object
+ *
+ * This function decrements the reference count of the dma fence and
+ * implicitly calls up the synx object cleanup if count reaches 0.
+ * Synx object should not be derefrenced in the function after
+ * calling this.
+ *
+ * @param client : Pointer to client session
+ * @param h_synx : Synx object handle
+ */
+void synx_util_release_object(struct synx_client *client, s32 h_synx);
+
+/**
+ * @brief: Function called implicitly when import refcount reaches zero
+ *
+ * @param kref : &synx_handle_coredata.import_refcount
+ */
+void synx_util_destroy_import_handle(struct kref *kref);
+
+/**
+ * @brief: Function called implicitly when internal refcount reaches zero
+ *
+ * @param kref : &synx_handle_coredata.internal_refcount
+ */
+void synx_util_destroy_internal_handle(struct kref *kref);
+
+/**
+ * @brief: Function to get the bind operations registered by external driver
+ *
+ * @param type : External sync type
+ *
+ * @return Bind operations. NULL if type is invalid
+ */
+struct bind_operations *synx_util_get_bind_ops(u32 type);
+
+/**
+ * @brief: Function to share the synx object to use by other clients
+ *
+ * Shares the synx object by acquiring additional reference to dma fence
+ *
+ * @param client : Pointer to client session
+ * @param params : Pointer to export params struct
+ *
+ * @return Status of operation. Negative in case of error. Zero otherwise.
+ */
+int synx_util_export_object(struct synx_client *client,
+	struct synx_export_params *params);
+
+/**
+ * @brief: Function to import the synx object for use by the client
+ *
+ * Obtains the synx object corresponding to the importing synx handle
+ *
+ * @param params : Pointer to import params struct
+ *
+ * @return Synx object pointer on success. NULL if import failed or invalid
+ */
+struct synx_coredata *synx_util_import_object(
+	struct synx_import_params *params);
+
+/**
+ * @brief: Function to acquire the synx client session
+ *
+ * This increments the reference count of the client in device client_table
+ *
+ * @param session_id : Client session id
+ *
+ * @return Pointer to synx client. NULL if invalid session id.
+ */
+struct synx_client *synx_get_client(struct synx_session session_id);
+
+/**
+ * @brief: Function to release the synx client session
+ *
+ * This decrements the reference count of the client in device client_table and
+ * invokes the client session cleanup if reference reaches zero.
+ *
+ * @param client : Pointer to client session structure
+ */
+void synx_put_client(struct synx_client *client);
+
+/**
+ * @brief: Function to generate timestamp
+ *
+ * @param timestamp : Timestamp string (filled by function)
+ * @param size      : Timestamp string size
+ */
+void synx_util_generate_timestamp(char *timestamp, size_t size);
+
+/**
+ * @brief: Function to log framework errors
+ *
+ * This saves the error in a global list and can be accessed using debugfs.
+ * Needs to be added where we wish to trace the error.
+ *
+ * @param id     : Client session id
+ * @param h_synx : Synx object handle
+ * @param err    : Error code
+ */
+void synx_util_log_error(u32 id, s32 h_synx, s32 err);
+
+#endif /* __SYNX_UTIL_H__ */