/* Copyright (c) 2015, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */
#define PACMAN_VERSION	"1.1"
#define CLASS_NAME "msm_pacman"
#define DEVICE_NAME "msm_pacman"

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/uaccess.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/of.h>

#include <soc/qcom/scm.h>
#include "msm_pacman_qmi_interface.h"

struct pacman_control_s {
	dev_t dev_num;
	struct class *dev_class;
	struct device *dev;
};
static struct pacman_control_s pacman_ctl;

/******************************************************************************
* PACMan Configuration
******************************************************************************/
/* Number of QUPs supported */
#define NUM_QUPS 12
#define READ_BUF_SZ 256
#define WRITE_BUF_SZ 64

/* Bypass bus bind/unbind calls and return success */
/* #define DEBUG_BYPASS_BINDING */
/* Bypass TrustZone calls and return success */
/* #define DEBUG_BYPASS_TZ */
/* Bypass QMI calls and return success */
/* #define DEBUG_BYPASS_QMI */

/******************************************************************************
* Trust Zone API
******************************************************************************/
#ifdef DEBUG_BYPASS_TZ
static int tz_configure_blsp_ownership(u32 qup_id, u32 subsystem_id)
{
	return 0;
}
#else
static int tz_configure_blsp_ownership(u32 qup_id, u32 subsystem_id)
{
	int rc;
	struct scm_desc desc = {0};

	desc.arginfo = 2;
	desc.args[0] = qup_id;
	desc.args[1] = subsystem_id;

	rc = scm_call2(SCM_SIP_FNID(4, 3), &desc);
	return rc;
}
#endif

/* State Machine Input Events (edges) */
enum state_machine_input_t {
	INIT = 0,
	ENABLE = 1,
	DISABLE = 2,
	SSR = 3
};

struct state_machine_t {
	void (*curr_state)(struct state_machine_t *sm,
					enum state_machine_input_t input,
					void *arg);
	void (*next_state)(struct state_machine_t *sm,
					enum state_machine_input_t input,
					void *arg);
	char *curr_state_string;

	/* Pseudo v-table */
	void (*init)(struct state_machine_t *this);
	void (*run)(struct state_machine_t *this,
					enum state_machine_input_t input,
					void *arg);
};

/* State Machine Member Function Prototypes */
static void state_machine_init(struct state_machine_t *this);
static void state_machine_run(struct state_machine_t *this,
		enum state_machine_input_t input, void *arg);

/* State Machine States (nodes) */
/* If adding a state, be sure to also update state_machine_run() strings */
static void pacman_state_init(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg);
static void pacman_state_disabled(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg);
static void pacman_state_enabling(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg);
static void pacman_state_enabled(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg);
static void pacman_state_disabling(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg);

/* State Machine Member Functions */
static void state_machine_init(struct state_machine_t *this)
{
	pr_debug("%s\n", __func__);
	memset(this, '0', sizeof(struct state_machine_t));
	this->curr_state = pacman_state_init;
	this->next_state = pacman_state_init;
	this->curr_state_string = "INIT";

	/* Setup Pseudo V-Table */
	this->init = state_machine_init;
	this->run = state_machine_run;

	/* Run the state machine with the 'INIT' event */
	this->run(this, INIT, NULL);
}

static void state_machine_run(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	void (*tmp_state)(struct state_machine_t *sm,
					enum state_machine_input_t input,
					void *arg);

	pr_debug("%s: input %u\n", __func__, input);
	if (this == NULL || this->curr_state == NULL)
		return;

	/* Execute the current state with the given input event */
	(this->curr_state)(this, input, NULL);

	/* If the current state set this->next_state, process the transition */
	while (this->curr_state != this->next_state) {
		if (NULL == this->next_state)
			break;

		tmp_state = this->next_state;
		(this->next_state)(this, input, arg);

		/* Transition complete - update curr_state */
		this->curr_state = tmp_state;
		if (this->curr_state == pacman_state_init)
			this->curr_state_string = "STATE_INIT";
		else if (this->curr_state == pacman_state_disabled)
			this->curr_state_string = "STATE_DISABLED";
		else if (this->curr_state == pacman_state_enabling)
			this->curr_state_string = "STATE_ENABLING";
		else if (this->curr_state == pacman_state_enabled)
			this->curr_state_string = "STATE_ENABLED";
		else if (this->curr_state == pacman_state_disabling)
			this->curr_state_string = "STATE_DISABLING";
		else
			this->curr_state_string = "STATE_UNKNOWN";
	}
}

/* QUP Framework (struct qup_instance passed as argument to state machine) */
enum subsystem {
	NONE = 0,
	APSS = 1,
	ADSP = 2
};

const char *subsystem_strings[] = {
	"NONE",
	"APSS",
	"ADSP"
};

struct qup_instance {
	int id;
	enum subsystem owner;
	enum subsystem next_owner;
	struct state_machine_t state_machine;
	struct device *bus_dev;
	struct device_driver *bus_drv;
};

/******************************************************************************
* PACMan Framework
******************************************************************************/
static void pacman_framework_init(void);
static void pacman_run(char *command_string);
static void pacman_dump(char *buf, size_t length);

/* Globals */
static DEFINE_MUTEX(pacman_mutex);
static struct qup_instance QUP_TABLE[NUM_QUPS];
static int pacman_adsp_in_ssr;

static void pacman_framework_init(void)
{
	int i;

	pr_debug("%s: Number of QUPs = %i\n", __func__, NUM_QUPS);

	/* Initialize Global QUP Table */
	for (i = 0; i < NUM_QUPS; i++) {
		QUP_TABLE[i].id = -1;	/* -1 Invalid */
		QUP_TABLE[i].owner = NONE;
		QUP_TABLE[i].next_owner = NONE;
		QUP_TABLE[i].bus_dev = NULL;
		QUP_TABLE[i].bus_drv = NULL;
		state_machine_init(&QUP_TABLE[i].state_machine);
	}

	mutex_init(&pacman_mutex);
}

static void pacman_run(char *command_string)
{
	char buf[32], bus_string[16], subsystem_string[8];
	char *str, *str_running;
	const char delimiters[] = "\n";
	struct device *bus_dev;
	enum subsystem subsystem;
	int qup_id;

	mutex_lock(&pacman_mutex);
	strlcpy(buf, command_string, sizeof(buf));
	buf[31] = '\0';
	str_running = (char *)&buf;

	pr_debug("%s: %s\n", __func__, (char *)&buf);

	/* Parse Bus ID */
	str = strsep(&str_running, delimiters);
	if (NULL == str) {
		pr_err("%s: ERROR strsep expected bus name\n",
				__func__);
		goto error;
	}
	strlcpy(bus_string, str, sizeof(bus_string));

	/* Parse Subsystem Name */
	str = strsep(&str_running, delimiters);
	if (NULL == str) {
		pr_err("%s: ERROR strsep expected subsystem name\n",
				__func__);
		goto error;
	}
	strlcpy(subsystem_string, str, sizeof(subsystem_string));

	/* Parse Extra Arguments */
	str = strsep(&str_running, delimiters);
	if (NULL != str) {
		if (0 != strcmp("", str))
			pr_debug("%s: Extra arguments are being ignored\n",
					__func__);
	}

	/* Validate Bus Argument*/
	bus_dev = bus_find_device_by_name(&platform_bus_type, NULL, bus_string);
	if (!bus_dev) {
		pr_err("%s: ERROR invalid bus\n", __func__);
		goto error;
	}

	/*
	 * Validate Bus to QUP ID mapping exists in device tree
	 * i.e. Device tree contains aliases{ qup5 = &i2c5; }
	 */
	qup_id = of_alias_get_id(bus_dev->of_node, "qup");
	if (qup_id < 0) {
		pr_err("%s: ERROR QUP ID not found\n", __func__);
		goto error;
	}

	/* Validate Subsystem Argument*/
	if (0 == strcmp("APSS", subsystem_string))
		subsystem = APSS;
	else if (0 == strcmp("ADSP", subsystem_string))
		subsystem = ADSP;
	else if (0 == strcmp("SSR", subsystem_string))
		subsystem = NONE;
	else {
		pr_err("%s: ERROR invalid subsystem\n", __func__);
		goto error;
	}

	pr_debug("%s: Bus=%s QUP=%i Subsystem=%s\n", __func__,
		bus_string, qup_id, subsystem_string);

	/* Flag QUP as valid upon first PACman invocation */
	QUP_TABLE[qup_id].id = qup_id;
	QUP_TABLE[qup_id].bus_dev = bus_dev;
	/* Prepare for state machine */
	QUP_TABLE[qup_id].next_owner = subsystem;

	/* Invoke state machine transition */
	switch (subsystem) {
	case APSS:
		QUP_TABLE[qup_id].state_machine.run(
				&QUP_TABLE[qup_id].state_machine,
				ENABLE, &QUP_TABLE[qup_id]);
		if (QUP_TABLE[qup_id].state_machine.curr_state ==
			pacman_state_enabled)
			QUP_TABLE[qup_id].owner = APSS;
		else
			QUP_TABLE[qup_id].owner = NONE;
		break;
	case ADSP:
		QUP_TABLE[qup_id].state_machine.run(
				&QUP_TABLE[qup_id].state_machine,
				DISABLE, &QUP_TABLE[qup_id]);
		if (QUP_TABLE[qup_id].state_machine.curr_state ==
			pacman_state_disabled)
			QUP_TABLE[qup_id].owner = ADSP;
		else
			QUP_TABLE[qup_id].owner = NONE;
		break;
	case NONE: /* SSR */
		pr_debug("%s: SSR initiated on QUP %i\n", __func__, qup_id);
		QUP_TABLE[qup_id].state_machine.run(
				&QUP_TABLE[qup_id].state_machine,
				SSR, &QUP_TABLE[qup_id]);

		/*
		 * TODO: Notify client of SSR event via poll() implementation
		 * Currently ownership is passed back after SSR
		 * Do not update the table owner for now - used to detect SSR
		 */
		break;
	default:
		pr_err("%s: ERROR owner not supported\n", __func__);
		goto error;
	}

error:
	mutex_unlock(&pacman_mutex);
}

static void pacman_dump(char *buf, size_t length)
{
	char working_buf[32];
	int rc, i;

	pr_debug("%s\n", __func__);

	if (buf == NULL || length < 256) {
		pr_debug("%s: ERROR input buffer too small\n", __func__);
		return;
	}

	mutex_lock(&pacman_mutex);

	/* Parse QUP table and dump state*/
	buf[0] = '\0';

	for (i = 0; i < NUM_QUPS; i++) {
		/* Check if enabled for dumping */
		if (QUP_TABLE[i].id >= 0) {
			rc = snprintf((char *)(&working_buf),
				sizeof(working_buf),
				"%u %s %s\n", QUP_TABLE[i].id,
				subsystem_strings[QUP_TABLE[i].owner],
				QUP_TABLE[i].state_machine.curr_state_string);
			strlcat(buf, (char *)&working_buf, length);
			/* Check for overflow */
			if ((length - strlen(buf) - 1) <
				sizeof(working_buf)) {
				pr_debug("%s Overflow Detected\n",
						__func__);
				break;
			}
		}
	}

	mutex_unlock(&pacman_mutex);
}

/******************************************************************************
* QMI Framework
******************************************************************************/
/* Configuration */
#define PACMAN_QMI_TIMEOUT_MS 5000
#define PACMAN_QMI_ADSP_SERVICE_ID 771
#define PACMAN_QMI_ADSP_SERVICE_VERSION 1
#define PACMAN_QMI_ADSP_SERVICE_INSTANCE_ID 1

/* QMI Client Port Handles */
static struct qmi_handle *pacman_qmi_client_port_adsp;

/*
 * TODO: Scale worker threads for other subsystems by passing the QMI
 * port handle from the callback function to the worker thread
 */
/* QMI Worker Threads */
static void pacman_qmi_client_notify_arrive_worker(struct work_struct *work);
static DECLARE_DELAYED_WORK(work_qmi_client_notify_arrive,
				pacman_qmi_client_notify_arrive_worker);
static void pacman_qmi_client_notify_exit_worker(struct work_struct *work);
static DECLARE_DELAYED_WORK(work_qmi_client_notify_exit,
				pacman_qmi_client_notify_exit_worker);
static void pacman_qmi_client_port_notify_worker(struct work_struct *work);
static DECLARE_DELAYED_WORK(work_qmi_client_port_notify,
		pacman_qmi_client_port_notify_worker);
static struct workqueue_struct *pacman_qmi_notification_workqueue;
static struct workqueue_struct *pacman_qmi_rx_workqueue;

/* QMI Callbacks */
static int pacman_qmi_client_notify_cb(struct notifier_block *this,
					unsigned long code, void *cmd)
{
	int rc;

	switch (code) {
	case QMI_SERVER_ARRIVE:
		pr_debug("%s: QMI_SERVER_ARRIVE\n", __func__);
		rc = queue_delayed_work(pacman_qmi_notification_workqueue,
				&work_qmi_client_notify_arrive, 0);
		if (rc != 1)
			pr_err("%s ERROR QMI packet dropped\n", __func__);
		break;
	case QMI_SERVER_EXIT:
		pr_debug("%s: QMI_SERVER_EXIT\n", __func__);
		rc = queue_delayed_work(pacman_qmi_notification_workqueue,
				&work_qmi_client_notify_exit, 0);
		if (rc != 1)
			pr_err("%s ERROR QMI packet dropped\n", __func__);
		break;
	default:
		pr_err("%s: Unknown code %u\n", __func__, (unsigned)code);
		break;
	}

	return 0;
}

static void pacman_qmi_client_port_notify_cb(struct qmi_handle *handle,
						enum qmi_event_type event,
						void *notify_priv)
{
	int rc;

	pr_debug("%s\n", __func__);

	switch (event) {
	case QMI_RECV_MSG:
		rc = queue_delayed_work(pacman_qmi_rx_workqueue,
					&work_qmi_client_port_notify, 0);
		if (rc != 1)
			pr_err("%s ERROR QMI packet dropped\n", __func__);
		break;
	default:
		pr_err("%s: Unknown event %i\n", __func__, event);
		break;
	}
}

/* QMI Worker Threads */
static void pacman_qmi_client_notify_arrive_worker(struct work_struct *w_s)
{
	int rc, i;
	char buff[32];

	pr_debug("%s\n", __func__);

	/* Create a Local client port for QMI communication */
	pacman_qmi_client_port_adsp = qmi_handle_create(
				pacman_qmi_client_port_notify_cb, NULL);
	if (!pacman_qmi_client_port_adsp) {
		pr_err("%s: qmi_handle_create failed\n", __func__);
		return;
	}

	rc = qmi_connect_to_service(pacman_qmi_client_port_adsp,
					PACMAN_QMI_ADSP_SERVICE_ID,
					PACMAN_QMI_ADSP_SERVICE_VERSION,
					PACMAN_QMI_ADSP_SERVICE_INSTANCE_ID);

	if (rc < 0) {
		pr_err("%s: qmi_connect_to_service failed rc=%i\n",
			__func__, rc);
		qmi_handle_destroy(pacman_qmi_client_port_adsp);
		pacman_qmi_client_port_adsp = NULL;
		return;
	}

	/*
	 * Re-establish ADSP ownership if SSR occurred
	 * Note: Notification work queue serializes use of
	 * IN_SSR flag and SSR
	 */
	if (pacman_adsp_in_ssr) {
		for (i = 0; i < NUM_QUPS; i++) {
			if (QUP_TABLE[i].owner == ADSP) {
				snprintf((char *)&buff, sizeof(buff),
					"%i ADSP", i);
				msleep(2000); /* Wait for ADSP to be fully up */
				pacman_run((char *)&buff);
			}
		}

		pacman_adsp_in_ssr = 0;
	}
}

static void pacman_qmi_client_notify_exit_worker(struct work_struct *w_s)
{
	int i;
	char buff[12];

	pr_debug("%s\n", __func__);
	pacman_adsp_in_ssr = 1;

	/* Inject a SSR Event into PACMan for each registered QUP */
	for (i = 0; i < NUM_QUPS; i++) {
		if (QUP_TABLE[i].owner == ADSP) {
			snprintf((char *)&buff, sizeof(buff), "%i SSR", i);
			pacman_run((char *)&buff);
		}
	}
}

static void pacman_qmi_client_port_notify_worker(struct work_struct *work)
{
	int rc;

	pr_debug("%s\n", __func__);

	do {
		rc = qmi_recv_msg(pacman_qmi_client_port_adsp);
	} while (0 == rc);

	if (rc != -ENOMSG)
		pr_err("%s: Error receiving QMI message\n", __func__);
}

static struct notifier_block pacman_qmi_notifier_block = {
	.notifier_call = pacman_qmi_client_notify_cb,
};

static int pacman_qmi_init(void)
{
	int rc;

	pr_debug("%s\n", __func__);
	pacman_qmi_client_port_adsp = NULL;
	pacman_qmi_notification_workqueue =
		create_singlethread_workqueue("pacman_qmi_notification_wq");
	if (!pacman_qmi_notification_workqueue) {
		pr_err("%s: pacman_qmi_notification_wq creation failed\n",
			__func__);
		return -EFAULT;
	}
	pacman_qmi_rx_workqueue =
		create_singlethread_workqueue("pacman_qmi_rx_wq");
	if (!pacman_qmi_rx_workqueue) {
		pr_err("%s: pacman_qmi_rx_wq creation failed\n",
			__func__);
		destroy_workqueue(pacman_qmi_notification_workqueue);
		return -EFAULT;
	}

	/* Register for ADSP PACMan Service */
	rc = qmi_svc_event_notifier_register(PACMAN_QMI_ADSP_SERVICE_ID,
					PACMAN_QMI_ADSP_SERVICE_VERSION,
					PACMAN_QMI_ADSP_SERVICE_INSTANCE_ID,
					&pacman_qmi_notifier_block);
	if (rc < 0) {
		pr_err("%s: qmi_svc_event_notifier_register failed rc=%i\n",
				__func__, rc);
		destroy_workqueue(pacman_qmi_notification_workqueue);
		destroy_workqueue(pacman_qmi_rx_workqueue);
		return rc;
	}

	return 0;
}

static void pacman_qmi_deinit(void)
{
	pr_debug("%s\n", __func__);

	/* Unregister for ADSP PACMan Service */
	qmi_handle_destroy(pacman_qmi_client_port_adsp);
	pacman_qmi_client_port_adsp = NULL;
	qmi_svc_event_notifier_unregister(PACMAN_QMI_ADSP_SERVICE_ID,
					PACMAN_QMI_ADSP_SERVICE_VERSION,
					PACMAN_QMI_ADSP_SERVICE_INSTANCE_ID,
					&pacman_qmi_notifier_block);

	if (pacman_qmi_notification_workqueue) {
		flush_workqueue(pacman_qmi_notification_workqueue);
		destroy_workqueue(pacman_qmi_notification_workqueue);
	}
	if (pacman_qmi_rx_workqueue) {
		flush_workqueue(pacman_qmi_rx_workqueue);
		destroy_workqueue(pacman_qmi_rx_workqueue);
	}
}

#ifdef DEBUG_BYPASS_QMI
static int pacman_qmi_send_sync_ready_msg(struct qmi_handle *qmi_port_handle,
						int qup_id)
{
	return 0;
}
#else
static int pacman_qmi_send_sync_ready_msg(struct qmi_handle *qmi_port_handle,
						int qup_id)
{
	struct qupm_ready_req_msg_v01 req_msg;
	struct qupm_ready_resp_msg_v01 resp_msg;
	struct msg_desc req_desc, resp_desc;
	int rc;

	pr_debug("%s\n", __func__);

	if (qmi_port_handle == NULL || qup_id < 0 || qup_id >= NUM_QUPS) {
		pr_err("%s: invalid arguments\n", __func__);
		return -EINVAL;
	}

	req_desc.max_msg_len = QUPM_READY_REQ_MSG_V01_MAX_MSG_LEN;
	req_desc.msg_id = QMI_QUPM_READY_REQ_V01;
	req_desc.ei_array = qupm_ready_req_msg_v01_ei;
	req_msg.qup_id = qup_id;
	req_msg.flags_valid = 0;
	req_msg.flags = 0;

	resp_desc.max_msg_len = QUPM_READY_RESP_MSG_V01_MAX_MSG_LEN;
	resp_desc.msg_id = QMI_QUPM_READY_RESP_V01;
	resp_desc.ei_array = qupm_ready_resp_msg_v01_ei;

	rc = qmi_send_req_wait(qmi_port_handle, &req_desc,
				&req_msg, sizeof(req_msg),
				&resp_desc, &resp_msg, sizeof(resp_msg),
				PACMAN_QMI_TIMEOUT_MS);
	if (rc < 0) {
		pr_err("%s: qmi_send_req_wait failed rc=%i\n", __func__, rc);
		goto error;
	}

	pr_debug("%s: QMI Response result=%hu error=%hu\n",
			__func__, resp_msg.resp.result, resp_msg.resp.error);

	return (uint16_t)resp_msg.resp.result;

error:
	return rc;
}
#endif

#ifdef DEBUG_BYPASS_QMI
static int pacman_qmi_send_sync_take_ownership_msg(
					struct qmi_handle *qmi_port_handle,
					int qup_id)
{
	return 0;
}
#else
static int pacman_qmi_send_sync_take_ownership_msg(
					struct qmi_handle *qmi_port_handle,
					int qup_id)
{
	struct qupm_take_ownership_req_msg_v01 req_msg;
	struct qupm_take_ownership_resp_msg_v01 resp_msg;
	struct msg_desc req_desc, resp_desc;
	int rc;

	pr_debug("%s\n", __func__);

	if (NULL == qmi_port_handle || qup_id < 0 || qup_id >= NUM_QUPS) {
		pr_err("%s: invalid arguments\n", __func__);
		return -EINVAL;
	}

	req_desc.max_msg_len = QUPM_TAKE_OWNERSHIP_REQ_MSG_V01_MAX_MSG_LEN;
	req_desc.msg_id = QMI_QUPM_TAKE_OWNERSHIP_REQ_V01;
	req_desc.ei_array = qupm_take_ownership_req_msg_v01_ei;
	req_msg.qup_id = qup_id;
	req_msg.flags_valid = 0;
	req_msg.flags = 0;

	resp_desc.max_msg_len = QUPM_TAKE_OWNERSHIP_RESP_MSG_V01_MAX_MSG_LEN;
	resp_desc.msg_id = QMI_QUPM_TAKE_OWNERSHIP_RESP_V01;
	resp_desc.ei_array = qupm_take_ownership_resp_msg_v01_ei;

	rc = qmi_send_req_wait(qmi_port_handle, &req_desc,
				&req_msg, sizeof(req_msg),
				&resp_desc, &resp_msg, sizeof(resp_msg),
				PACMAN_QMI_TIMEOUT_MS);
	if (rc < 0) {
		pr_err("%s: qmi_send_req_wait failed rc=%i\n", __func__, rc);
		goto error;
	}

	pr_debug("%s: QMI Response result=%hu error=%hu\n",
			__func__, resp_msg.resp.result, resp_msg.resp.error);

	return (uint16_t)resp_msg.resp.result;

error:
	return rc;
}
#endif


#ifdef DEBUG_BYPASS_QMI
static int pacman_qmi_send_sync_give_ownership_msg(
					struct qmi_handle *qmi_port_handle,
					int qup_id)
{
	return 0;
}
#else
static int pacman_qmi_send_sync_give_ownership_msg(
					struct qmi_handle *qmi_port_handle,
					int qup_id)
{
	struct qupm_give_ownership_req_msg_v01 req_msg;
	struct qupm_give_ownership_resp_msg_v01 resp_msg;
	struct msg_desc req_desc, resp_desc;
	int rc;

	pr_debug("%s\n", __func__);

	if (NULL == qmi_port_handle || qup_id < 0 || qup_id >= NUM_QUPS) {
		pr_err("%s: invalid arguments\n", __func__);
		return -EINVAL;
	}

	req_desc.max_msg_len = QUPM_GIVE_OWNERSHIP_REQ_MSG_V01_MAX_MSG_LEN;
	req_desc.msg_id = QMI_QUPM_GIVE_OWNERSHIP_REQ_V01;
	req_desc.ei_array = qupm_give_ownership_req_msg_v01_ei;
	req_msg.qup_id = qup_id;
	req_msg.flags_valid = 0;
	req_msg.flags = 0;

	resp_desc.max_msg_len = QUPM_GIVE_OWNERSHIP_RESP_MSG_V01_MAX_MSG_LEN;
	resp_desc.msg_id = QMI_QUPM_GIVE_OWNERSHIP_RESP_V01;
	resp_desc.ei_array = qupm_give_ownership_resp_msg_v01_ei;

	rc = qmi_send_req_wait(qmi_port_handle, &req_desc,
				&req_msg, sizeof(req_msg),
				&resp_desc, &resp_msg, sizeof(resp_msg),
				PACMAN_QMI_TIMEOUT_MS);
	if (rc < 0) {
		pr_err("%s: qmi_send_req_wait failed rc=%i\n", __func__, rc);
		goto error;
	}

	pr_debug("%s: QMI Response result=%hu error=%hu\n",
			__func__, resp_msg.resp.result, resp_msg.resp.error);

	return (uint16_t)resp_msg.resp.result;

error:
	return rc;
}
#endif

/******************************************************************************
* State Machine States
******************************************************************************/
static void pacman_state_init(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != INIT || NULL == this->curr_state) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		return;
	}

	/* For PACMan running on APSS, we want the default
	 * state to be enabled
	 */
	if (input == INIT) {
		this->next_state = pacman_state_enabled;
		return;
	}

	this->next_state = pacman_state_disabled;
}

static void pacman_state_disabled(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != INIT && input != DISABLE && input != ENABLE &&
		input != SSR) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		return;
	}

	/* Check what state we transitioned from */
	if (this->curr_state == pacman_state_enabling) {
		pr_err("%s: pacman_state_enabling failed to execute\n",
					__func__);
		return;
	}

	if (input == ENABLE || input == SSR)
		this->next_state = pacman_state_enabling;
}

static void pacman_state_enabled(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != INIT && input != DISABLE && input != ENABLE &&
		input != SSR) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		return;
	}

	/* Check what state we transitioned from */
	if (this->curr_state == pacman_state_disabling) {
		pr_err("%s: pacman_state_disabling failed to execute\n",
				__func__);
		return;
	}

	if (input == DISABLE)
		this->next_state = pacman_state_disabling;
}

#ifndef DEBUG_BYPASS_BINDING
static void pacman_state_enabling(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	int rc;
	struct qup_instance *qup_instance = arg;

	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != ENABLE && input != SSR) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		goto general_error;
	}

	/* Verify inputs */
	if (NULL == qup_instance) {
		pr_err("%s: ERROR QUP configuration invalid\n",
				__func__);
		goto general_error;
	}

	pr_debug("%s: QUP ID=%i Subsystem=%s\n", __func__,
		qup_instance->id,
		subsystem_strings[qup_instance->next_owner]);

	/* Do not attempt to communicate with ADSP if we have a SSR event */
	if (input == SSR)
		goto ssr_event;

	/* APSS should be the requested owner */
	if (qup_instance->next_owner != APSS) {
		pr_err("%s: ERROR support for APSS Only\n", __func__);
		goto general_error;
	}
	/* Check if ADSP is OK to release ownership */
	rc = pacman_qmi_send_sync_ready_msg(pacman_qmi_client_port_adsp,
					qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR pacman_qmi_send_sync_ready_msg %i\n",
				__func__, rc);
		goto general_error;
	}
	/* APSS needs to be given ownership */
	rc = pacman_qmi_send_sync_give_ownership_msg(
						pacman_qmi_client_port_adsp,
						qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR send_sync_give_ownership_msg %i\n",
				__func__, rc);
		goto general_error;
	}
ssr_event:
	/* Call into TrustZone */
	rc = tz_configure_blsp_ownership(qup_instance->id, APSS);
	if (rc) {
		pr_err("%s: ERROR calling into TZ %i\n", __func__, rc);
		goto ownership_cleanup;
	}
	/* Enable the bus and all its peripherals by binding the bus driver */

	rc = driver_attach(qup_instance->bus_drv);
	if (rc) {
		pr_err("%s: ERROR calling driver_enable %i\n",
				__func__, rc);
		goto tz_cleanup;
	}
	/* State transition successful */
	this->next_state = pacman_state_enabled;
	return;

	/* APSS is master, so the following is a true critical error */
tz_cleanup:
ownership_cleanup:
general_error:
	pr_err("%s: CRITICAL ERROR\n", __func__);
}

static void pacman_state_disabling(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	int rc;
	struct qup_instance *qup_instance = arg;

	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != DISABLE) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		goto general_error;
	}

	/* Verify inputs */
	if (NULL == qup_instance) {
		pr_err("%s: ERROR - QUP configuration invalid\n",
				__func__);
		goto general_error;
	}

	pr_debug("%s: QUP ID=%i Subsystem=%s\n", __func__,
				qup_instance->id,
				subsystem_strings[qup_instance->next_owner]);

	/* ADSP should be the owner */
	if (qup_instance->next_owner != ADSP) {
		pr_err("%s: ERROR Support for ADSP Only\n", __func__);
		goto general_error;
	}
	/* Check if ADSP is OK to take ownership */
	rc = pacman_qmi_send_sync_ready_msg(pacman_qmi_client_port_adsp,
						qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR pacman_qmi_send_sync_ready_msg %i\n",
				__func__, rc);
		goto general_error;
	}
	/* Save the current bus device->device_driver for restoring later */
	qup_instance->bus_drv = qup_instance->bus_dev->driver;
	/* Disable the bus and peripherals by unbindng the bus */

	pr_debug("%s: Unbinding the bus\n", __func__);
	device_release_driver(qup_instance->bus_dev);
	/*
	 * Unfortunately no return code to check here for a successful unbind.
	 * If a peripheral does not unbind successfully, it may hang here
	 */
	pr_debug("%s: Unbinding the bus complete\n", __func__);

	/* Call into TrustZone */
	rc = tz_configure_blsp_ownership(qup_instance->id,
					qup_instance->next_owner);
	if (rc) {
		pr_err("%s: ERROR calling into TZ %i\n", __func__, rc);
		goto driver_disable_cleanup;
	}
	/* Transfer ownership to subsystem */
	rc = pacman_qmi_send_sync_take_ownership_msg(
						pacman_qmi_client_port_adsp,
						qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR send_sync_take_ownership_msg %i\n",
				__func__, rc);
		goto tz_cleanup;
	}
	/* State transition successful */
	this->next_state = pacman_state_disabled;
	return;

tz_cleanup:
	rc = tz_configure_blsp_ownership(qup_instance->id, APSS);
	if (rc)
		pr_err("%s: CRITICAL ERROR calling into TZ %i\n",
				__func__, rc);
driver_disable_cleanup:
	rc = driver_attach(qup_instance->bus_drv);
	if (rc)
		pr_err("%s: CRITICAL ERROR driver_enable %i\n",
				__func__, rc);
general_error:
	this->next_state = pacman_state_enabled;
}
#else
static void pacman_state_enabling(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	int rc;
	struct qup_instance *qup_instance = arg;

	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != ENABLE && input != SSR) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		goto general_error;
	}

	/* Verify inputs */
	if (NULL == qup_instance) {
		pr_err("%s: ERROR QUP configuration invalid\n",
				__func__);
		goto general_error;
	}

	pr_debug("%s: QUP ID=%i Subsystem=%s\n", __func__,
		qup_instance->id,
		subsystem_strings[qup_instance->next_owner]);

	/* Do not attempt to communicate with ADSP if we have a SSR event */
	if (input == SSR)
		goto ssr_event;

	/* APSS should be the requested owner */
	if (qup_instance->next_owner != APSS) {
		pr_err("%s: ERROR support for APSS Only\n", __func__);
		goto general_error;
	}
	/* Check if ADSP is OK to release ownership */
	rc = pacman_qmi_send_sync_ready_msg(pacman_qmi_client_port_adsp,
					qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR pacman_qmi_send_sync_ready_msg %i\n",
				__func__, rc);
		goto general_error;
	}
	/* APSS needs to be given ownership */
	rc = pacman_qmi_send_sync_give_ownership_msg(
						pacman_qmi_client_port_adsp,
						qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR send_sync_give_ownership_msg %i\n",
				__func__, rc);
		goto general_error;
	}
ssr_event:
	/* Call into TrustZone */
	rc = tz_configure_blsp_ownership(qup_instance->id, APSS);
	if (rc) {
		pr_err("%s: ERROR calling into TZ %i\n", __func__, rc);
		goto ownership_cleanup;
	}

	/* State transition successful */
	this->next_state = pacman_state_enabled;
	return;

	/* APSS is master, so the following is a true critical error */
tz_cleanup:
ownership_cleanup:
general_error:
	pr_err("%s: CRITICAL ERROR\n", __func__);
}

static void pacman_state_disabling(struct state_machine_t *this,
			enum state_machine_input_t input, void *arg)
{
	int rc;
	struct qup_instance *qup_instance = arg;

	pr_debug("%s: input %u\n", __func__, input);

	/* Verify expected events while in state */
	if (input != DISABLE) {
		pr_err("%s: ERROR with input %u\n", __func__, input);
		goto general_error;
	}

	/* Verify inputs */
	if (NULL == qup_instance) {
		pr_err("%s: ERROR - QUP configuration invalid\n",
				__func__);
		goto general_error;
	}

	pr_debug("%s: QUP ID=%i Subsystem=%s\n", __func__,
				qup_instance->id,
				subsystem_strings[qup_instance->next_owner]);

	/* ADSP should be the owner */
	if (qup_instance->next_owner != ADSP) {
		pr_err("%s: ERROR Support for ADSP Only\n", __func__);
		goto general_error;
	}
	/* Check if ADSP is OK to take ownership */
	rc = pacman_qmi_send_sync_ready_msg(pacman_qmi_client_port_adsp,
						qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR pacman_qmi_send_sync_ready_msg %i\n",
				__func__, rc);
		goto general_error;
	}
	/* Save the current bus device->device_driver for restoring later */
	qup_instance->bus_drv = qup_instance->bus_dev->driver;

	/* Call into TrustZone */
	rc = tz_configure_blsp_ownership(qup_instance->id,
					qup_instance->next_owner);
	if (rc) {
		pr_err("%s: ERROR calling into TZ %i\n", __func__, rc);
		goto driver_disable_cleanup;
	}
	/* Transfer ownership to subsystem */
	rc = pacman_qmi_send_sync_take_ownership_msg(
						pacman_qmi_client_port_adsp,
						qup_instance->id);
	if (rc) {
		pr_err("%s: ERROR send_sync_take_ownership_msg %i\n",
				__func__, rc);
		goto tz_cleanup;
	}
	/* State transition successful */
	this->next_state = pacman_state_disabled;
	return;

tz_cleanup:
	rc = tz_configure_blsp_ownership(qup_instance->id, APSS);
	if (rc)
		pr_err("%s: CRITICAL ERROR calling into TZ %i\n",
				__func__, rc);
driver_disable_cleanup:
general_error:
	this->next_state = pacman_state_enabled;
}
#endif

static int pacman_open(struct inode *ip, struct file *fp)
{
	pr_debug("%s\n", __func__);
	return 0;
}

static int pacman_close(struct inode *ip, struct file *fp)
{
	pr_debug("%s\n", __func__);
	return 0;
}

static ssize_t pacman_read(struct file *fp, char __user *buffer,
				size_t length, loff_t *offset)
{
	char buf[READ_BUF_SZ];
	int rc;

	pr_debug("%s\n", __func__);
	if (*offset == 0) {
		*offset = 1;
		pacman_dump((char *)&buf, sizeof(buf));
		if (strlen(buf) < length) {
			rc = copy_to_user(buffer, buf, strlen(buf));
			pr_debug("%s:\n%s\n", __func__, (char *)&buf);
		}
		return strlen(buf);
	} else {
		return 0;
	}
}

static ssize_t pacman_write(struct file *fp, const char *buffer,
				size_t length, loff_t *offset)
{
	char buf[WRITE_BUF_SZ];

	pr_debug("%s\n", __func__);
	if (copy_from_user(buf, buffer, min(length, sizeof(buf))))
		return -EFAULT;
	buf[WRITE_BUF_SZ-1] = '\0';
	pacman_run((char *)&buf);
	return length;
}

const struct file_operations pacman_fops = {
	.owner = THIS_MODULE,
	.open = pacman_open,
	.release = pacman_close,
	.read = pacman_read,
	.write = pacman_write
};

static int pacman_probe(struct platform_device *pdev)
{
	pr_debug("%s: %s version %s\n", __func__, DEVICE_NAME, PACMAN_VERSION);

	pacman_ctl.dev_num = register_chrdev(0, DEVICE_NAME, &pacman_fops);
	if (pacman_ctl.dev_num < 0) {
		pr_err("%s: register_chrdev failed\n", __func__);
		goto register_chrdev_err;
	}

	pacman_ctl.dev_class = class_create(THIS_MODULE, CLASS_NAME);
	if (IS_ERR(pacman_ctl.dev_class)) {
		pr_err("%s: class_create failed\n", __func__);
		goto class_create_err;
	}

	pacman_ctl.dev = device_create(pacman_ctl.dev_class, NULL,
					MKDEV(pacman_ctl.dev_num, 0),
					&pacman_ctl, DEVICE_NAME);
	if (IS_ERR(pacman_ctl.dev)) {
		pr_err("%s: device_create failed\n", __func__);
		goto device_create_err;
	}

	return 0;

device_create_err:
	class_destroy(pacman_ctl.dev_class);
class_create_err:
	unregister_chrdev(pacman_ctl.dev_num, DEVICE_NAME);
register_chrdev_err:
	return -ENODEV;
}

static int pacman_remove(struct platform_device *pdev)
{
	pr_debug("%s\n", __func__);
	device_unregister(pacman_ctl.dev);
	device_destroy(pacman_ctl.dev_class, MKDEV(pacman_ctl.dev_num, 0));
	class_destroy(pacman_ctl.dev_class);
	unregister_chrdev(pacman_ctl.dev_num, DEVICE_NAME);
	return 0;
}

static const struct of_device_id pacman_dt_match[] = {
	{.compatible = "qcom,msm-pacman"},
	{},
};
MODULE_DEVICE_TABLE(of, pacman_dt_match);

static struct platform_driver pacman_driver = {
	.driver = {
		.name = DEVICE_NAME,
		.owner = THIS_MODULE,
		.of_match_table = pacman_dt_match,
	},
	.probe = pacman_probe,
	.remove = pacman_remove,
};

static int __init pacman_init(void)
{
	int rc = 0;

	pr_debug("%s\n", __func__);

	rc = platform_driver_register(&pacman_driver);
	if (rc) {
		pr_err("%s: ERROR Failed to register driver\n", __func__);
		return rc;
	}
	pacman_framework_init();
	rc = pacman_qmi_init();
	if (rc) {
		pr_err("%s: ERROR pacman_qmi_init failed\n", __func__);
		return rc;
	}

	return 0;
}

static void __exit pacman_exit(void)
{
	pr_debug("%s\n", __func__);
	pacman_qmi_deinit();
	platform_driver_unregister(&pacman_driver);
}

MODULE_DESCRIPTION("Peripheral Access Control Manager (PACMan)");
MODULE_LICENSE("GPL v2");
module_init(pacman_init);
module_exit(pacman_exit);