ipc/bg_glink.c - platform/vendor/opensource/audio-kernel - Gitiles

 /* Copyright (c) 2017-2018, 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.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/of.h>
 #include <linux/mutex.h>
 #include <soc/bg_glink.h>
 #include <linux/wait.h>
 #include <linux/errno.h>
 #include <linux/debugfs.h>
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <soc/qcom/glink.h>

 #define GLINK_LINK_STATE_UP_WAIT_TIMEOUT 5000
 #define APR_MAXIMUM_NUM_OF_RETRIES 2
 #define BG_RX_INTENT_REQ_TIMEOUT_MS 3000
 #define BG_GLINK_NAME "bg-cdc-glink"
 #define BG_GLINK_EDGE "bg"
 #define BG_MAX_NO_OF_INTENTS 20

 struct bg_cdc_glink_drvdata {
 	struct device *dev;
 	struct platform_device *pdev;
 	struct bg_cdc_glink_ch_info *ch_info;
 	void *handle;
 	wait_queue_head_t wait;
 	u8 num_channels;
 	u8 active_channel;
 	enum glink_link_state link_state;
 };

 struct bg_cdc_glink_ch_info {
 	void *handle;
 	struct mutex w_lock;
 	struct mutex r_lock;
 	struct mutex m_lock;
 	bg_glink_cb_fn func;
 	wait_queue_head_t wait;
 	unsigned channel_state;
 	bool if_remote_intent_ready;
 };
 static int __bg_cdc_glink_write(struct bg_cdc_glink_ch_info *ch_info,
 				void *data, char *tx_buf, int len)
 {
 	int rc = 0;

 	if (!ch_info)
 		return -EINVAL;
 	mutex_lock(&ch_info->w_lock);
 	rc = glink_tx(ch_info->handle, tx_buf, data, len, GLINK_TX_REQ_INTENT);
 	mutex_unlock(&ch_info->w_lock);

 	if (rc)
 		pr_err("%s: glink_tx failed, rc[%d]\n", __func__, rc);
 	else
 		rc = len;

 	return rc;
 }

 int bg_cdc_glink_write(void *ch_info, void *data,
 		       int len)
 {
 	int rc = 0;
 	char *tx_buf = NULL;

 	if (!((struct bg_cdc_glink_ch_info *)ch_info)->handle || !data)
 		return -EINVAL;

 	/* check if channel is connected before proceeding */
 	if (((struct bg_cdc_glink_ch_info *)ch_info)->channel_state
 						!= GLINK_CONNECTED) {
 		pr_err("%s: channel is not connected\n", __func__);
 		return -EINVAL;
 	}

 	tx_buf = kzalloc((sizeof(char) * len), GFP_KERNEL);
 	if (IS_ERR_OR_NULL(tx_buf)) {
 		rc = -EINVAL;
 		goto exit;
 	}
 	memcpy(tx_buf, data, len);

 	rc = __bg_cdc_glink_write((struct bg_cdc_glink_ch_info *)ch_info,
 				tx_buf, tx_buf, len);

 	if (rc < 0) {
 		pr_err("%s: Unable to send the packet, rc:%d\n", __func__, rc);
 		kfree(tx_buf);
 	}
 exit:
 	return rc;
 }
 EXPORT_SYMBOL(bg_cdc_glink_write);

 static void bg_cdc_glink_notify_rx(void *handle, const void *priv,
 			    const void *pkt_priv, const void *ptr,
 			    size_t size)
 {
 	struct bg_cdc_glink_ch_info *ch_info =
 				(struct bg_cdc_glink_ch_info *)priv;

 	if (!ch_info || !ptr) {
 		pr_err("%s: Invalid ch_info or ptr\n", __func__);
 		return;
 	}

 	pr_debug("%s: Rx packet received\n", __func__);

 	mutex_lock(&ch_info->r_lock);
 	if (ch_info->func)
 		ch_info->func((void *)ptr, size);
 	mutex_unlock(&ch_info->r_lock);
 	glink_rx_done(ch_info->handle, ptr, true);
 }

 static void bg_cdc_glink_notify_tx_abort(void *handle, const void *priv,
 				    const void *pkt_priv)
 {
 	pr_debug("%s: tx_abort received for pkt_priv:%pK\n",
 		 __func__, pkt_priv);
 	kfree(pkt_priv);
 }

 static void bg_cdc_glink_notify_tx_done(void *handle, const void *priv,
 			    const void *pkt_priv, const void *ptr)
 {
 	pr_debug("%s: tx_done received for pkt_priv:%pK\n",
 		 __func__, pkt_priv);
 	kfree(pkt_priv);
 }

 static bool bg_cdc_glink_notify_rx_intent_req(void *handle, const void *priv,
 				  size_t req_size)
 {
 	struct bg_cdc_glink_ch_info *ch_info =
 				(struct bg_cdc_glink_ch_info *)priv;

 	if (!ch_info) {
 		pr_err("%s: Invalid ch_info\n", __func__);
 		return false;
 	}

 	pr_debug("%s: No rx intents queued, unable to receive\n", __func__);
 	return false;
 }

 static void bg_cdc_glink_notify_remote_rx_intent(void *handle, const void *priv,
 					    size_t size)
 {
 	struct bg_cdc_glink_ch_info *ch_info =
 				(struct bg_cdc_glink_ch_info *)priv;

 	if (!ch_info) {
 		pr_err("%s: Invalid ch_info\n", __func__);
 		return;
 	}
 	/*
 	 * This is to make sure that the far end has queued at least one intent
 	 * before we attempt any IPC.
 	 */
 	pr_debug("%s: remote queued an intent\n", __func__);
 	ch_info->if_remote_intent_ready = true;
 	wake_up(&ch_info->wait);
 }

 static void bg_cdc_glink_notify_state(void *handle, const void *priv,
 				unsigned event)
 {
 	struct bg_cdc_glink_ch_info *ch_info =
 				(struct bg_cdc_glink_ch_info *)priv;

 	if (!ch_info) {
 		pr_err("%s: Invalid ch_info\n", __func__);
 		return;
 	}

 	ch_info->channel_state = event;
 	pr_debug("%s: Channel state[%d]\n", __func__, event);

 	if (event == GLINK_CONNECTED)
 		wake_up(&ch_info->wait);
 }

 static int bg_cdc_glink_rx_intents_config(struct bg_cdc_glink_ch_info *ch_info,
 				   int num_of_intents, uint32_t *size)
 {
 	int i;
 	int rc = 0;

 	if (!ch_info || !num_of_intents || !size) {
 		pr_err("%s: Invalid parameter\n", __func__);
 		return -EINVAL;
 	}
 	if (num_of_intents > BG_MAX_NO_OF_INTENTS) {
 		pr_err("%s: Invalid no_of_intents = %d\n",
 			__func__, num_of_intents);
 		return -EINVAL;
 	}

 	for (i = 0; i < num_of_intents; i++) {
 		rc = glink_queue_rx_intent(ch_info->handle, ch_info, *(size+i));
 		if (rc) {
 			pr_err("%s: Failed to queue rx intent, iteration[%d]\n",
 			       __func__, i);
 			break;
 		}
 	}

 	return rc;
 }
 /*
  * bg_cdc_channel_open - API to open Glink channel.
  * ch_cfg:    glink channel configuration
  * func:     callback function to notify client.
  */
 void  *bg_cdc_channel_open(struct platform_device *pdev,
 			struct bg_glink_ch_cfg *ch_cfg,
 			 bg_glink_cb_fn func)
 {
 	int rc;
 	struct bg_cdc_glink_drvdata *bg_cdc_glink;
 	struct glink_open_config open_cfg;
 	struct bg_cdc_glink_ch_info *ch_info;

 	if (!pdev) {
 		pr_err("%s: invalid platform device\n",__func__);
 		return NULL;
 	}
 	bg_cdc_glink = platform_get_drvdata(pdev);

 	if (!bg_cdc_glink) {
 		dev_err(&pdev->dev, "%s: driver data not found\n",
 			__func__);
 		return NULL;
 	}
 	if (bg_cdc_glink->active_channel > bg_cdc_glink->num_channels) {
 		dev_err(bg_cdc_glink->dev, "%s: invalid channel number\n",
 			__func__);
 		return NULL;
 	}

 	ch_info = &bg_cdc_glink->ch_info[bg_cdc_glink->active_channel];
 	mutex_lock(&ch_info->m_lock);
 	if (ch_info->handle) {
 		dev_err(&pdev->dev, "%s: This channel is already opened\n",
 			__func__);
 		rc = -EBUSY;
 		goto unlock;
 	}

 	if (bg_cdc_glink->link_state != GLINK_LINK_STATE_UP) {
 		rc = wait_event_timeout(bg_cdc_glink->wait,
 			bg_cdc_glink->link_state == GLINK_LINK_STATE_UP,
 			msecs_to_jiffies(GLINK_LINK_STATE_UP_WAIT_TIMEOUT));
 		if (rc == 0) {
 			dev_err(bg_cdc_glink->dev, "%s: Open timeout\n",
 				__func__);
 			rc = -ETIMEDOUT;
 			goto unlock;
 		}
 		dev_dbg(bg_cdc_glink->dev, "%s: Wakeup done\n", __func__);
 	}

 	memset(&open_cfg, 0, sizeof(struct glink_open_config));
 	open_cfg.options = GLINK_OPT_INITIAL_XPORT;
 	open_cfg.edge = BG_GLINK_EDGE;
 	open_cfg.name = ch_cfg->ch_name;
 	open_cfg.notify_rx = bg_cdc_glink_notify_rx;
 	open_cfg.notify_tx_done = bg_cdc_glink_notify_tx_done;
 	open_cfg.notify_state = bg_cdc_glink_notify_state;
 	open_cfg.notify_rx_intent_req = bg_cdc_glink_notify_rx_intent_req;
 	open_cfg.notify_remote_rx_intent = bg_cdc_glink_notify_remote_rx_intent;
 	open_cfg.notify_tx_abort = bg_cdc_glink_notify_tx_abort;
 	open_cfg.rx_intent_req_timeout_ms = BG_RX_INTENT_REQ_TIMEOUT_MS;
 	open_cfg.priv = ch_info;

 	ch_info->channel_state = GLINK_REMOTE_DISCONNECTED;
 	ch_info->handle = glink_open(&open_cfg);
 	if (IS_ERR_OR_NULL(ch_info->handle)) {
 		dev_err(bg_cdc_glink->dev, "%s: glink_open failed %s\n",
 			__func__, ch_cfg->ch_name);
 		ch_info->handle = NULL;
 		rc = -EINVAL;
 		goto unlock;
 	}
 	bg_cdc_glink->active_channel++;
 	rc = wait_event_timeout(ch_info->wait,
 		(ch_info->channel_state == GLINK_CONNECTED), 5 * HZ);
 	if (rc == 0) {
 		dev_err(bg_cdc_glink->dev, "%s: TIMEOUT for OPEN event\n",
 			__func__);
 		rc = -ETIMEDOUT;
 		goto close_link;
 	}
 	rc = bg_cdc_glink_rx_intents_config(ch_info,
 				ch_cfg->num_of_intents, ch_cfg->intents_size);
 	if (rc) {
 		dev_err(bg_cdc_glink->dev, "%s: Unable to queue intents\n",
 			__func__);
 		goto close_link;
 	}

 	ch_info->func = func;

 close_link:
 	if (rc) {
 		if (bg_cdc_glink->active_channel > 0)
 			bg_cdc_glink->active_channel--;
 		glink_close(ch_info->handle);
 		ch_info->handle = NULL;
 	}
 unlock:
 	mutex_unlock(&ch_info->m_lock);

 	return rc ? NULL : (void *)ch_info;
 }
 EXPORT_SYMBOL(bg_cdc_channel_open);


 int bg_cdc_channel_close(struct platform_device *pdev,
 			void *ch_info)
 {
 	struct bg_cdc_glink_drvdata *bg_cdc_glink;
 	int rc;
 	struct bg_cdc_glink_ch_info *channel_info
 			= (struct bg_cdc_glink_ch_info *)ch_info;
 	bg_cdc_glink = platform_get_drvdata(pdev);
 	if (!channel_info || !channel_info->handle) {
 		rc = -EINVAL;
 		goto exit;
 	}

 	mutex_lock(&channel_info->m_lock);
 	if (bg_cdc_glink->active_channel > 0)
 		bg_cdc_glink->active_channel--;
 	rc = glink_close(channel_info->handle);
 	channel_info->handle = NULL;
 	channel_info->func = NULL;
 	channel_info->if_remote_intent_ready = false;
 	mutex_unlock(&channel_info->m_lock);
 exit:
 	return rc;
 }
 EXPORT_SYMBOL(bg_cdc_channel_close);

 static void bg_cdc_glink_link_state_cb(struct glink_link_state_cb_info *cb_info,
 				  void *priv)
 {
 	struct bg_cdc_glink_drvdata *bg_cdc_glink =
 			(struct bg_cdc_glink_drvdata *) priv;

 	if (!cb_info) {
 		pr_err("%s: Invalid cb_info\n", __func__);
 		return;
 	}

 	dev_dbg(bg_cdc_glink->dev, "%s: edge[%s] link state[%d]\n", __func__,
 		  cb_info->edge, cb_info->link_state);

 	bg_cdc_glink->link_state = cb_info->link_state;
 	if (bg_cdc_glink->link_state == GLINK_LINK_STATE_UP)
 		wake_up(&bg_cdc_glink->wait);
 }

 static int bg_cdc_glink_probe(struct platform_device *pdev)
 {
 	struct bg_cdc_glink_drvdata *bg_cdc_glink;
 	struct glink_link_info link_info;
 	u32 num_channels;
 	int ret = 0;
 	int i;

 	ret = of_property_read_u32(pdev->dev.of_node, "qcom,msm-glink-channels",
 				   &num_channels);

 	if (ret) {
 		dev_err(&pdev->dev, "%s: glink channels from DT file %s\n",
 			__func__, "qcom,msm-glink-channels");
 		return -EINVAL;
 	}

 	/* Allocate BG codec Glink structure */
 	bg_cdc_glink = kzalloc(sizeof(struct bg_cdc_glink_drvdata), GFP_KERNEL);
 	if (!bg_cdc_glink)
 		return -ENOMEM;

 	bg_cdc_glink->ch_info = kzalloc((sizeof(struct bg_cdc_glink_ch_info) *
 					num_channels), GFP_KERNEL);
 	if (!bg_cdc_glink->ch_info) {
 		ret = -ENOMEM;
 		goto err_memory_fail;
 	}
 	bg_cdc_glink->dev = &pdev->dev;
 	bg_cdc_glink->pdev = pdev;
 	bg_cdc_glink->num_channels = num_channels;
 	platform_set_drvdata(pdev, bg_cdc_glink);

 	init_waitqueue_head(&bg_cdc_glink->wait);

 	/* Register glink link_state notification */
 	link_info.glink_link_state_notif_cb = bg_cdc_glink_link_state_cb;
 	link_info.transport = NULL;
 	link_info.edge = BG_GLINK_EDGE;
 	bg_cdc_glink->link_state = GLINK_LINK_STATE_DOWN;
 	bg_cdc_glink->handle =
 		glink_register_link_state_cb(&link_info, bg_cdc_glink);
 	if (!bg_cdc_glink->handle) {
 		dev_err(&pdev->dev, "%s: Unable to register link state\n",
 			 __func__);
 		ret = -EINVAL;
 		goto err_glink_register_fail;
 	}

 	for (i = 0; i < num_channels; i++) {
 		mutex_init(&bg_cdc_glink->ch_info[i].w_lock);
 		mutex_init(&bg_cdc_glink->ch_info[i].r_lock);
 		mutex_init(&bg_cdc_glink->ch_info[i].m_lock);
 		init_waitqueue_head(&bg_cdc_glink->ch_info[i].wait);
 	}
 	return ret;
 err_glink_register_fail:
 	kfree(bg_cdc_glink->ch_info);

 err_memory_fail:
 	kfree(bg_cdc_glink);

 	return ret;
 }

 static const struct of_device_id bg_cdc_glink_of_match[] = {
 	{ .compatible = "qcom,bg-cdc-glink", },
 	{},
 };

 static int bg_cdc_glink_remove(struct platform_device *pdev)
 {
 	struct bg_cdc_glink_drvdata *bg_cdc_glink = platform_get_drvdata(pdev);
 	int i;

 	if (!bg_cdc_glink) {
 		dev_err(&pdev->dev, "%s: invalid data\n",
 			__func__);
 		return -EINVAL;
 	}
 	if (bg_cdc_glink->handle)
 		glink_unregister_link_state_cb(bg_cdc_glink->handle);

 	for (i = 0; i < bg_cdc_glink->num_channels; i++) {
 		mutex_destroy(&bg_cdc_glink->ch_info[i].w_lock);
 		mutex_destroy(&bg_cdc_glink->ch_info[i].r_lock);
 		mutex_destroy(&bg_cdc_glink->ch_info[i].m_lock);
 	}
 	kfree(bg_cdc_glink->ch_info);
 	kfree(bg_cdc_glink);
 	return 0;
 }

 static struct platform_driver msm_bg_cdc_glink_driver = {
 	.driver = {
 		.owner          = THIS_MODULE,
 		.name           = BG_GLINK_NAME,
 		.of_match_table = bg_cdc_glink_of_match,
 	},
 	.probe          = bg_cdc_glink_probe,
 	.remove         = bg_cdc_glink_remove,
 };
 module_platform_driver(msm_bg_cdc_glink_driver);

 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("BG Glink driver");
	/* Copyright (c) 2017-2018, 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.
	*/
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/types.h>
	#include <linux/slab.h>
	#include <linux/uaccess.h>
	#include <linux/of.h>
	#include <linux/mutex.h>
	#include <soc/bg_glink.h>
	#include <linux/wait.h>
	#include <linux/errno.h>
	#include <linux/debugfs.h>
	#include <linux/platform_device.h>
	#include <linux/delay.h>
	#include <soc/qcom/glink.h>

	#define GLINK_LINK_STATE_UP_WAIT_TIMEOUT 5000
	#define APR_MAXIMUM_NUM_OF_RETRIES 2
	#define BG_RX_INTENT_REQ_TIMEOUT_MS 3000
	#define BG_GLINK_NAME "bg-cdc-glink"
	#define BG_GLINK_EDGE "bg"
	#define BG_MAX_NO_OF_INTENTS 20

	struct bg_cdc_glink_drvdata {
	struct device *dev;
	struct platform_device *pdev;
	struct bg_cdc_glink_ch_info *ch_info;
	void *handle;
	wait_queue_head_t wait;
	u8 num_channels;
	u8 active_channel;
	enum glink_link_state link_state;
	};

	struct bg_cdc_glink_ch_info {
	void *handle;
	struct mutex w_lock;
	struct mutex r_lock;
	struct mutex m_lock;
	bg_glink_cb_fn func;
	wait_queue_head_t wait;
	unsigned channel_state;
	bool if_remote_intent_ready;
	};
	static int __bg_cdc_glink_write(struct bg_cdc_glink_ch_info *ch_info,
	void data, char tx_buf, int len)
	{
	int rc = 0;

	if (!ch_info)
	return -EINVAL;
	mutex_lock(&ch_info->w_lock);
	rc = glink_tx(ch_info->handle, tx_buf, data, len, GLINK_TX_REQ_INTENT);
	mutex_unlock(&ch_info->w_lock);

	if (rc)
	pr_err("%s: glink_tx failed, rc[%d]\n", __func__, rc);
	else
	rc = len;

	return rc;
	}

	int bg_cdc_glink_write(void ch_info, void data,
	int len)
	{
	int rc = 0;
	char *tx_buf = NULL;

	if (!((struct bg_cdc_glink_ch_info *)ch_info)->handle \|\| !data)
	return -EINVAL;

	/* check if channel is connected before proceeding */
	if (((struct bg_cdc_glink_ch_info *)ch_info)->channel_state
	!= GLINK_CONNECTED) {
	pr_err("%s: channel is not connected\n", __func__);
	return -EINVAL;
	}

	tx_buf = kzalloc((sizeof(char) * len), GFP_KERNEL);
	if (IS_ERR_OR_NULL(tx_buf)) {
	rc = -EINVAL;
	goto exit;
	}
	memcpy(tx_buf, data, len);

	rc = __bg_cdc_glink_write((struct bg_cdc_glink_ch_info *)ch_info,
	tx_buf, tx_buf, len);

	if (rc < 0) {
	pr_err("%s: Unable to send the packet, rc:%d\n", __func__, rc);
	kfree(tx_buf);
	}
	exit:
	return rc;
	}
	EXPORT_SYMBOL(bg_cdc_glink_write);

	static void bg_cdc_glink_notify_rx(void handle, const void priv,
	const void pkt_priv, const void ptr,
	size_t size)
	{
	struct bg_cdc_glink_ch_info *ch_info =
	(struct bg_cdc_glink_ch_info *)priv;

	if (!ch_info \|\| !ptr) {
	pr_err("%s: Invalid ch_info or ptr\n", __func__);
	return;
	}

	pr_debug("%s: Rx packet received\n", __func__);

	mutex_lock(&ch_info->r_lock);
	if (ch_info->func)
	ch_info->func((void *)ptr, size);
	mutex_unlock(&ch_info->r_lock);
	glink_rx_done(ch_info->handle, ptr, true);
	}

	static void bg_cdc_glink_notify_tx_abort(void handle, const void priv,
	const void *pkt_priv)
	{
	pr_debug("%s: tx_abort received for pkt_priv:%pK\n",
	__func__, pkt_priv);
	kfree(pkt_priv);
	}

	static void bg_cdc_glink_notify_tx_done(void handle, const void priv,
	const void pkt_priv, const void ptr)
	{
	pr_debug("%s: tx_done received for pkt_priv:%pK\n",
	__func__, pkt_priv);
	kfree(pkt_priv);
	}

	static bool bg_cdc_glink_notify_rx_intent_req(void handle, const void priv,
	size_t req_size)
	{
	struct bg_cdc_glink_ch_info *ch_info =
	(struct bg_cdc_glink_ch_info *)priv;

	if (!ch_info) {
	pr_err("%s: Invalid ch_info\n", __func__);
	return false;
	}

	pr_debug("%s: No rx intents queued, unable to receive\n", __func__);
	return false;
	}

	static void bg_cdc_glink_notify_remote_rx_intent(void handle, const void priv,
	size_t size)
	{
	struct bg_cdc_glink_ch_info *ch_info =
	(struct bg_cdc_glink_ch_info *)priv;

	if (!ch_info) {
	pr_err("%s: Invalid ch_info\n", __func__);
	return;
	}
	/*
	* This is to make sure that the far end has queued at least one intent
	* before we attempt any IPC.
	*/
	pr_debug("%s: remote queued an intent\n", __func__);
	ch_info->if_remote_intent_ready = true;
	wake_up(&ch_info->wait);
	}

	static void bg_cdc_glink_notify_state(void handle, const void priv,
	unsigned event)
	{
	struct bg_cdc_glink_ch_info *ch_info =
	(struct bg_cdc_glink_ch_info *)priv;

	if (!ch_info) {
	pr_err("%s: Invalid ch_info\n", __func__);
	return;
	}

	ch_info->channel_state = event;
	pr_debug("%s: Channel state[%d]\n", __func__, event);

	if (event == GLINK_CONNECTED)
	wake_up(&ch_info->wait);
	}

	static int bg_cdc_glink_rx_intents_config(struct bg_cdc_glink_ch_info *ch_info,
	int num_of_intents, uint32_t *size)
	{
	int i;
	int rc = 0;

	if (!ch_info \|\| !num_of_intents \|\| !size) {
	pr_err("%s: Invalid parameter\n", __func__);
	return -EINVAL;
	}
	if (num_of_intents > BG_MAX_NO_OF_INTENTS) {
	pr_err("%s: Invalid no_of_intents = %d\n",
	__func__, num_of_intents);
	return -EINVAL;
	}

	for (i = 0; i < num_of_intents; i++) {
	rc = glink_queue_rx_intent(ch_info->handle, ch_info, *(size+i));
	if (rc) {
	pr_err("%s: Failed to queue rx intent, iteration[%d]\n",
	__func__, i);
	break;
	}
	}

	return rc;
	}
	/*
	* bg_cdc_channel_open - API to open Glink channel.
	* ch_cfg: glink channel configuration
	* func: callback function to notify client.
	*/
	void bg_cdc_channel_open(struct platform_device pdev,
	struct bg_glink_ch_cfg *ch_cfg,
	bg_glink_cb_fn func)
	{
	int rc;
	struct bg_cdc_glink_drvdata *bg_cdc_glink;
	struct glink_open_config open_cfg;
	struct bg_cdc_glink_ch_info *ch_info;

	if (!pdev) {
	pr_err("%s: invalid platform device\n",__func__);
	return NULL;
	}
	bg_cdc_glink = platform_get_drvdata(pdev);

	if (!bg_cdc_glink) {
	dev_err(&pdev->dev, "%s: driver data not found\n",
	__func__);
	return NULL;
	}
	if (bg_cdc_glink->active_channel > bg_cdc_glink->num_channels) {
	dev_err(bg_cdc_glink->dev, "%s: invalid channel number\n",
	__func__);
	return NULL;
	}

	ch_info = &bg_cdc_glink->ch_info[bg_cdc_glink->active_channel];
	mutex_lock(&ch_info->m_lock);
	if (ch_info->handle) {
	dev_err(&pdev->dev, "%s: This channel is already opened\n",
	__func__);
	rc = -EBUSY;
	goto unlock;
	}

	if (bg_cdc_glink->link_state != GLINK_LINK_STATE_UP) {
	rc = wait_event_timeout(bg_cdc_glink->wait,
	bg_cdc_glink->link_state == GLINK_LINK_STATE_UP,
	msecs_to_jiffies(GLINK_LINK_STATE_UP_WAIT_TIMEOUT));
	if (rc == 0) {
	dev_err(bg_cdc_glink->dev, "%s: Open timeout\n",
	__func__);
	rc = -ETIMEDOUT;
	goto unlock;
	}
	dev_dbg(bg_cdc_glink->dev, "%s: Wakeup done\n", __func__);
	}

	memset(&open_cfg, 0, sizeof(struct glink_open_config));
	open_cfg.options = GLINK_OPT_INITIAL_XPORT;
	open_cfg.edge = BG_GLINK_EDGE;
	open_cfg.name = ch_cfg->ch_name;
	open_cfg.notify_rx = bg_cdc_glink_notify_rx;
	open_cfg.notify_tx_done = bg_cdc_glink_notify_tx_done;
	open_cfg.notify_state = bg_cdc_glink_notify_state;
	open_cfg.notify_rx_intent_req = bg_cdc_glink_notify_rx_intent_req;
	open_cfg.notify_remote_rx_intent = bg_cdc_glink_notify_remote_rx_intent;
	open_cfg.notify_tx_abort = bg_cdc_glink_notify_tx_abort;
	open_cfg.rx_intent_req_timeout_ms = BG_RX_INTENT_REQ_TIMEOUT_MS;
	open_cfg.priv = ch_info;

	ch_info->channel_state = GLINK_REMOTE_DISCONNECTED;
	ch_info->handle = glink_open(&open_cfg);
	if (IS_ERR_OR_NULL(ch_info->handle)) {
	dev_err(bg_cdc_glink->dev, "%s: glink_open failed %s\n",
	__func__, ch_cfg->ch_name);
	ch_info->handle = NULL;
	rc = -EINVAL;
	goto unlock;
	}
	bg_cdc_glink->active_channel++;
	rc = wait_event_timeout(ch_info->wait,
	(ch_info->channel_state == GLINK_CONNECTED), 5 * HZ);
	if (rc == 0) {
	dev_err(bg_cdc_glink->dev, "%s: TIMEOUT for OPEN event\n",
	__func__);
	rc = -ETIMEDOUT;
	goto close_link;
	}
	rc = bg_cdc_glink_rx_intents_config(ch_info,
	ch_cfg->num_of_intents, ch_cfg->intents_size);
	if (rc) {
	dev_err(bg_cdc_glink->dev, "%s: Unable to queue intents\n",
	__func__);
	goto close_link;
	}

	ch_info->func = func;

	close_link:
	if (rc) {
	if (bg_cdc_glink->active_channel > 0)
	bg_cdc_glink->active_channel--;
	glink_close(ch_info->handle);
	ch_info->handle = NULL;
	}
	unlock:
	mutex_unlock(&ch_info->m_lock);

	return rc ? NULL : (void *)ch_info;
	}
	EXPORT_SYMBOL(bg_cdc_channel_open);


	int bg_cdc_channel_close(struct platform_device *pdev,
	void *ch_info)
	{
	struct bg_cdc_glink_drvdata *bg_cdc_glink;
	int rc;
	struct bg_cdc_glink_ch_info *channel_info
	= (struct bg_cdc_glink_ch_info *)ch_info;
	bg_cdc_glink = platform_get_drvdata(pdev);
	if (!channel_info \|\| !channel_info->handle) {
	rc = -EINVAL;
	goto exit;
	}

	mutex_lock(&channel_info->m_lock);
	if (bg_cdc_glink->active_channel > 0)
	bg_cdc_glink->active_channel--;
	rc = glink_close(channel_info->handle);
	channel_info->handle = NULL;
	channel_info->func = NULL;
	channel_info->if_remote_intent_ready = false;
	mutex_unlock(&channel_info->m_lock);
	exit:
	return rc;
	}
	EXPORT_SYMBOL(bg_cdc_channel_close);

	static void bg_cdc_glink_link_state_cb(struct glink_link_state_cb_info *cb_info,
	void *priv)
	{
	struct bg_cdc_glink_drvdata *bg_cdc_glink =
	(struct bg_cdc_glink_drvdata *) priv;

	if (!cb_info) {
	pr_err("%s: Invalid cb_info\n", __func__);
	return;
	}

	dev_dbg(bg_cdc_glink->dev, "%s: edge[%s] link state[%d]\n", __func__,
	cb_info->edge, cb_info->link_state);

	bg_cdc_glink->link_state = cb_info->link_state;
	if (bg_cdc_glink->link_state == GLINK_LINK_STATE_UP)
	wake_up(&bg_cdc_glink->wait);
	}

	static int bg_cdc_glink_probe(struct platform_device *pdev)
	{
	struct bg_cdc_glink_drvdata *bg_cdc_glink;
	struct glink_link_info link_info;
	u32 num_channels;
	int ret = 0;
	int i;

	ret = of_property_read_u32(pdev->dev.of_node, "qcom,msm-glink-channels",
	&num_channels);

	if (ret) {
	dev_err(&pdev->dev, "%s: glink channels from DT file %s\n",
	__func__, "qcom,msm-glink-channels");
	return -EINVAL;
	}

	/* Allocate BG codec Glink structure */
	bg_cdc_glink = kzalloc(sizeof(struct bg_cdc_glink_drvdata), GFP_KERNEL);
	if (!bg_cdc_glink)
	return -ENOMEM;

	bg_cdc_glink->ch_info = kzalloc((sizeof(struct bg_cdc_glink_ch_info) *
	num_channels), GFP_KERNEL);
	if (!bg_cdc_glink->ch_info) {
	ret = -ENOMEM;
	goto err_memory_fail;
	}
	bg_cdc_glink->dev = &pdev->dev;
	bg_cdc_glink->pdev = pdev;
	bg_cdc_glink->num_channels = num_channels;
	platform_set_drvdata(pdev, bg_cdc_glink);

	init_waitqueue_head(&bg_cdc_glink->wait);

	/* Register glink link_state notification */
	link_info.glink_link_state_notif_cb = bg_cdc_glink_link_state_cb;
	link_info.transport = NULL;
	link_info.edge = BG_GLINK_EDGE;
	bg_cdc_glink->link_state = GLINK_LINK_STATE_DOWN;
	bg_cdc_glink->handle =
	glink_register_link_state_cb(&link_info, bg_cdc_glink);
	if (!bg_cdc_glink->handle) {
	dev_err(&pdev->dev, "%s: Unable to register link state\n",
	__func__);
	ret = -EINVAL;
	goto err_glink_register_fail;
	}

	for (i = 0; i < num_channels; i++) {
	mutex_init(&bg_cdc_glink->ch_info[i].w_lock);
	mutex_init(&bg_cdc_glink->ch_info[i].r_lock);
	mutex_init(&bg_cdc_glink->ch_info[i].m_lock);
	init_waitqueue_head(&bg_cdc_glink->ch_info[i].wait);
	}
	return ret;
	err_glink_register_fail:
	kfree(bg_cdc_glink->ch_info);

	err_memory_fail:
	kfree(bg_cdc_glink);

	return ret;
	}

	static const struct of_device_id bg_cdc_glink_of_match[] = {
	{ .compatible = "qcom,bg-cdc-glink", },
	{},
	};

	static int bg_cdc_glink_remove(struct platform_device *pdev)
	{
	struct bg_cdc_glink_drvdata *bg_cdc_glink = platform_get_drvdata(pdev);
	int i;

	if (!bg_cdc_glink) {
	dev_err(&pdev->dev, "%s: invalid data\n",
	__func__);
	return -EINVAL;
	}
	if (bg_cdc_glink->handle)
	glink_unregister_link_state_cb(bg_cdc_glink->handle);

	for (i = 0; i < bg_cdc_glink->num_channels; i++) {
	mutex_destroy(&bg_cdc_glink->ch_info[i].w_lock);
	mutex_destroy(&bg_cdc_glink->ch_info[i].r_lock);
	mutex_destroy(&bg_cdc_glink->ch_info[i].m_lock);
	}
	kfree(bg_cdc_glink->ch_info);
	kfree(bg_cdc_glink);
	return 0;
	}

	static struct platform_driver msm_bg_cdc_glink_driver = {
	.driver = {
	.owner = THIS_MODULE,
	.name = BG_GLINK_NAME,
	.of_match_table = bg_cdc_glink_of_match,
	},
	.probe = bg_cdc_glink_probe,
	.remove = bg_cdc_glink_remove,
	};
	module_platform_driver(msm_bg_cdc_glink_driver);

	MODULE_LICENSE("GPL v2");
	MODULE_DESCRIPTION("BG Glink driver");