usb/aoc_usb_dev.c - kernel/google-modules/aoc - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /* Copyright 2020 Google LLC. All Rights Reserved.
  *
  * Interface to the AoC USB control service
  */

 #define pr_fmt(fmt) "aoc_usb_control: " fmt

 #include <linux/device.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/module.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>

 #include "aoc.h"
 #include "aoc-interface.h"

 #include "aoc_usb.h"

 #define AOC_USB_NAME "aoc_usb"

 enum { NONBLOCKING = 0, BLOCKING = 1 };

 enum {
 	TYPE_SCRATCH_PAD = 0,
 	TYPE_DEVICE_CONTEXT,
 	TYPE_END_OF_SETUP,
 	TYPE_DCBAA
 };

 static ssize_t aoc_usb_send_command(struct aoc_usb_drvdata *drvdata,
 				    void *in_cmd, size_t in_size, void *out_cmd,
 				    size_t out_size)
 {
 	struct aoc_service_dev *adev = drvdata->adev;
 	ssize_t ret;

 	ret = mutex_lock_interruptible(&drvdata->lock);
 	if (ret != 0)
 		return ret;

 	__pm_stay_awake(drvdata->ws);

 	if (aoc_service_flush_read_data(adev))
 		dev_err(&drvdata->adev->dev ,"Previous response left in channel\n");

 	dev_dbg(&drvdata->adev->dev, "send cmd id [%u]\n", ((struct CMD_CORE_GENERIC *)in_cmd)->parent.id);

 	ret = aoc_service_write_timeout(adev, in_cmd, in_size, drvdata->service_timeout);
 	if (ret != in_size) {
 		ret = -EIO;
 		goto out;
 	}

 	ret = aoc_service_read_timeout(adev, out_cmd, out_size, drvdata->service_timeout);
 	if (ret != out_size)
 		ret = -EIO;

 out:
 	__pm_relax(drvdata->ws);
 	mutex_unlock(&drvdata->lock);
 	return ret;
 }

 static int aoc_usb_get_dev_ctx(struct aoc_usb_drvdata *drvdata,
 			       unsigned int slot_id, size_t length, u8 *dev_ctx)
 {
 	int ret = 0;
 	struct CMD_USB_CONTROL_GET_DEVICE_CONTEXT *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_GET_DEVICE_CONTEXT), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_GET_DEVICE_CONTEXT_ID,
 		     sizeof(*cmd));

 	cmd->device_id = slot_id;
 	cmd->length = length;

 	dev_dbg(&drvdata->adev->dev, "cmd=(%u, %u)\n", cmd->device_id, cmd->length);
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	memcpy(dev_ctx, cmd->payload, length);

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_get_dcbaa_ptr(struct aoc_usb_drvdata *drvdata,
 				 u64 *aoc_dcbaa_ptr)
 {
 	int ret = 0;
 	struct CMD_USB_CONTROL_GET_DCBAA_PTR *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_GET_DCBAA_PTR), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_GET_DCBAA_PTR_ID,
 		     sizeof(*cmd));

 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	*aoc_dcbaa_ptr = cmd->aoc_dcbaa_ptr;

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_set_dcbaa_ptr(struct aoc_usb_drvdata *drvdata,
 				 u64 *aoc_dcbaa_ptr)
 {
 	int ret = 0;
 	struct CMD_USB_CONTROL_SET_DCBAA_PTR *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SET_DCBAA_PTR), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_SET_DCBAA_PTR_ID,
 		     sizeof(*cmd));

 	cmd->aoc_dcbaa_ptr = *aoc_dcbaa_ptr;
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_setup_done(struct aoc_usb_drvdata *drvdata)
 {
 	int ret;
 	struct CMD_USB_CONTROL_SETUP *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SETUP), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_SETUP_ID,
 		     sizeof(*cmd));

 	cmd->type = TYPE_END_OF_SETUP;
 	cmd->ctx_idx = 0;
 	cmd->spbuf_idx = 0;
 	cmd->length = 0;
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_notify_conn_stat(struct aoc_usb_drvdata *drvdata, void *data)
 {
 	int ret = 0;
 	struct CMD_USB_CONTROL_NOTIFY_CONN_STAT_V2 *cmd;
 	struct conn_stat_args *args = data;

 	// Don't update usb audio device counter if the notification is for xhci driver state.
 	if (args->bus_id != 0 && args->dev_num != 0 && args->slot_id != 0) {
 		if (args->conn_stat)
 			drvdata->usb_conn_state++;
 		else
 			drvdata->usb_conn_state--;

 		dev_dbg(&drvdata->adev->dev, "currently connected usb audio device count = %u\n",
 			drvdata->usb_conn_state);
 	}

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_NOTIFY_CONN_STAT_V2), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_NOTIFY_CONN_STAT_V2_ID,
 		     sizeof(*cmd));

 	cmd->bus_id = args->bus_id;
 	cmd->dev_num = args->dev_num;
 	cmd->slot_id = args->slot_id;
 	cmd->conn_state = args->conn_stat;

 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_get_isoc_tr_info(struct aoc_usb_drvdata *drvdata, void *args)
 {
 	int ret;
 	struct get_isoc_tr_info_args *tr_info_args =
 		(struct get_isoc_tr_info_args *)args;
 	struct CMD_USB_CONTROL_GET_ISOC_TR_INFO *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_GET_ISOC_TR_INFO), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_GET_ISOC_TR_INFO_ID,
 		     sizeof(*cmd));

 	cmd->ep_id = tr_info_args->ep_id;
 	cmd->dir = tr_info_args->dir;

 	dev_dbg(&drvdata->adev->dev, "ep_id=%u, dir=%u\n", cmd->ep_id, cmd->dir);
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	tr_info_args->type = cmd->type;
 	tr_info_args->num_segs = cmd->num_segs;
 	tr_info_args->seg_ptr = cmd->seg_ptr;
 	tr_info_args->max_packet = cmd->max_packet;
 	tr_info_args->cycle_state = cmd->cycle_state;
 	tr_info_args->num_trbs_free = cmd->num_trbs_free;

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_set_isoc_tr_info(struct aoc_usb_drvdata *drvdata, void *args)
 {
 	int ret;
 	struct get_isoc_tr_info_args *tr_info_args =
 		(struct get_isoc_tr_info_args *)args;
 	struct CMD_USB_CONTROL_SET_ISOC_TR_INFO *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SET_ISOC_TR_INFO), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_SET_ISOC_TR_INFO_ID,
 		     sizeof(*cmd));

 	cmd->ep_id = tr_info_args->ep_id;
 	cmd->dir = tr_info_args->dir;
 	cmd->type = tr_info_args->type;
 	cmd->num_segs = tr_info_args->num_segs;
 	cmd->seg_ptr = tr_info_args->seg_ptr;
 	cmd->max_packet = tr_info_args->max_packet;
 	cmd->cycle_state = tr_info_args->cycle_state;
 	cmd->num_trbs_free = tr_info_args->num_trbs_free;

 	dev_dbg(&drvdata->adev->dev, "%s: ep_id=%u, dir=%u\n", __func__, cmd->ep_id, cmd->dir);
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_set_offload_state(struct aoc_usb_drvdata *drvdata, bool *enabled)
 {
 	int ret = 0;
 	struct CMD_USB_CONTROL_SET_OFFLOAD_STATE *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SET_OFFLOAD_STATE), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_SET_OFFLOAD_STATE_ID,
 		     sizeof(*cmd));

 	cmd->offloading = *enabled;
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));
 	if (ret < 0) {
 		kfree(cmd);
 		return ret;
 	}

 	kfree(cmd);

 	return 0;
 }

 static int aoc_usb_send_feedback_ep_info(struct aoc_usb_drvdata *drvdata, void *args)
 {
 	int ret = 0;
 	struct feedback_ep_info_args *fb_ep_info_args =
 		(struct feedback_ep_info_args *)args;
 	struct CMD_USB_CONTROL_SEND_FEEDBACK_EP_INFO *cmd;

 	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SEND_FEEDBACK_EP_INFO), GFP_KERNEL);
 	if (!cmd)
 		return -ENOMEM;

 	AocCmdHdrSet(&cmd->parent,
 		     CMD_USB_CONTROL_SEND_FEEDBACK_EP_INFO_ID,
 		     sizeof(*cmd));

 	cmd->enabled = fb_ep_info_args->enabled;
 	cmd->bus_id = fb_ep_info_args->bus_id;
 	cmd->dev_num = fb_ep_info_args->dev_num;
 	cmd->slot_id = fb_ep_info_args->slot_id;
 	cmd->ep_num = fb_ep_info_args->ep_num;
 	cmd->max_packet = fb_ep_info_args->max_packet;
 	cmd->binterval = fb_ep_info_args->binterval;
 	cmd->brefresh = fb_ep_info_args->brefresh;
 	ret = aoc_usb_send_command(drvdata, cmd, sizeof(*cmd), cmd, sizeof(*cmd));

 	kfree(cmd);

 	return ret;
 }

 static int aoc_usb_notify(struct notifier_block *this,
 			  unsigned long code, void *data)
 {
 	struct aoc_usb_drvdata *drvdata =
 		container_of(this, struct aoc_usb_drvdata, nb);
 	int ret;
 	struct get_dev_ctx_args *dev_ctx_args;

 	switch (code) {
 	case SYNC_DEVICE_CONTEXT:
 		dev_ctx_args = data;
 		ret = aoc_usb_get_dev_ctx(drvdata, dev_ctx_args->slot_id,
 					  dev_ctx_args->length,
 					  dev_ctx_args->dev_ctx);
 		break;
 	case GET_DCBAA_PTR:
 		ret = aoc_usb_get_dcbaa_ptr(drvdata, data);
 		break;
 	case SET_DCBAA_PTR:
 		ret = aoc_usb_set_dcbaa_ptr(drvdata, data);
 		break;
 	case SETUP_DONE:
 		ret = aoc_usb_setup_done(drvdata);
 		break;
 	case GET_ISOC_TR_INFO:
 		ret = aoc_usb_get_isoc_tr_info(drvdata, data);
 		break;
 	case SET_ISOC_TR_INFO:
 		ret = aoc_usb_set_isoc_tr_info(drvdata, data);
 		break;
 	case SYNC_CONN_STAT:
 		ret = aoc_usb_notify_conn_stat(drvdata, data);
 		break;
 	case SET_OFFLOAD_STATE:
 		ret = aoc_usb_set_offload_state(drvdata, data);
 		break;
 	case SEND_FB_EP_INFO:
 		ret = aoc_usb_send_feedback_ep_info(drvdata, data);
 		break;
 	default:
 		dev_warn(&drvdata->adev->dev, "Code %lu is not supported\n", code);
 		ret = -EINVAL;
 		break;
 	}

 	if (ret < 0)
 		dev_err(&drvdata->adev->dev, "Fail to handle code %lu, ret = %d", code, ret);

 	return ret;
 }

 static enum usb_recover_state recover_state;
 static struct work_struct usb_recovery_ws;
 static void usb_recovery_work(struct work_struct *ws)
 {
 	pr_debug("%s: recover_state: %d\n", __func__, recover_state);

 	switch(recover_state) {
 	case RECOVER_HOST_OFF:
 		dwc3_otg_host_enable(false);
 		break;
 	case RECOVER_HOST_ON:
 		dwc3_otg_host_enable(true);
 		recover_state = RECOVERED;
 		break;
 	default:
 		pr_err("%s: unhandled recover_state: %d\n", __func__, recover_state);
 		break;
 	}

 	return;
 }

 static int aoc_usb_match(struct device *dev, void *data)
 {
 	if (sysfs_streq(dev_driver_string(dev), "xhci-hcd-exynos"))
 		return 1;

 	return 0;
 }

 static bool aoc_usb_is_hcd_working()
 {
 	struct device_node *np;
 	struct platform_device *pdev;
 	struct device *udev;
 	int ret;

 	np = of_find_node_by_name(NULL, "dwc3");
 	if (!np || !of_device_is_available(np)) {
 		pr_err("Cannot find dwc3 device node\n");
 		return false;
 	}

 	pdev = of_find_device_by_node(np);
 	if (!pdev)
 		return false;

 	udev = device_find_child(&pdev->dev, NULL, aoc_usb_match);
 	if (!udev)
 		return false;

 	ret = usb_host_mode_state_notify(USB_CONNECTED);
 	if (ret)
 		dev_err(udev, "Notifying AoC for xhci driver status is failed.\n");

 	return true;
 }

 static struct work_struct usb_host_mode_checking_ws;
 static void usb_host_mode_checking_work(struct work_struct *ws)
 {
 	if (aoc_usb_is_hcd_working())
 		pr_info("USB HCD is working, send notification to AoC\n");

 	return;
 }

 bool aoc_usb_probe_done;
 static int aoc_usb_probe(struct aoc_service_dev *adev)
 {
 	struct device *dev = &adev->dev;
 	struct aoc_usb_drvdata *drvdata;

 	drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
 	if (!drvdata)
 		return -ENOMEM;

 	drvdata->adev = adev;

 	mutex_init(&drvdata->lock);

 	drvdata->ws = wakeup_source_register(dev, dev_name(dev));
 	if (!drvdata->ws)
 		return -ENOMEM;

 	drvdata->usb_conn_state = 0;
 	drvdata->service_timeout = msecs_to_jiffies(100);
 	drvdata->nb.notifier_call = aoc_usb_notify;
 	register_aoc_usb_notifier(&drvdata->nb);

 	dev_set_drvdata(dev, drvdata);

 	aoc_usb_probe_done = true;

 	/* Restart host if recover_state was triggered */
 	if (recover_state == RECOVER_HOST_OFF) {
 		dev_dbg(&drvdata->adev->dev, "restart usb device\n");
 		recover_state = RECOVER_HOST_ON;
 		schedule_work(&usb_recovery_ws);
 	} else {
 		recover_state = NONE;
 	}

 	schedule_work(&usb_host_mode_checking_ws);

 	return 0;
 }

 static int aoc_usb_remove(struct aoc_service_dev *adev)
 {
 	struct aoc_usb_drvdata *drvdata = dev_get_drvdata(&adev->dev);

 	/*
 	 * Trigger recovery if usb accessory is connected.
 	 * We only disable host at this moment, it will restart host
 	 * after aoc usb probe again.
 	 */
 	if (drvdata->usb_conn_state) {
 		dev_dbg(&drvdata->adev->dev, "need to recover usb device\n");
 		recover_state = RECOVER_HOST_OFF;
 		schedule_work(&usb_recovery_ws);
 	}

 	unregister_aoc_usb_notifier(&drvdata->nb);
 	wakeup_source_unregister(drvdata->ws);
 	mutex_destroy(&drvdata->lock);

 	kfree(drvdata);

 	aoc_usb_probe_done = false;

 	return 0;
 }

 static const char *const aoc_usb_service_names[] = {
 	"usb_control",
 	NULL,
 };

 static struct aoc_driver aoc_usb_driver = {
 	.drv = {
 		.name = AOC_USB_NAME,
 	},
 	.service_names = aoc_usb_service_names,
 	.probe = aoc_usb_probe,
 	.remove = aoc_usb_remove,
 };

 static int __init aoc_usb_init(void)
 {
 	xhci_vendor_helper_init();
 	usb_vendor_helper_init();
 	snd_usb_audio_vendor_helper_init();

 	INIT_WORK(&usb_recovery_ws, usb_recovery_work);
 	INIT_WORK(&usb_host_mode_checking_ws, usb_host_mode_checking_work);

 	return aoc_driver_register(&aoc_usb_driver);
 }

 static void __exit aoc_usb_exit(void)
 {
 	aoc_driver_unregister(&aoc_usb_driver);
 }

 module_init(aoc_usb_init);
 module_exit(aoc_usb_exit);

 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Howard Yen (Google)");
 MODULE_DESCRIPTION("USB driver for AoC");
	// SPDX-License-Identifier: GPL-2.0-only
	/* Copyright 2020 Google LLC. All Rights Reserved.
	*
	* Interface to the AoC USB control service
	*/

	#define pr_fmt(fmt) "aoc_usb_control: " fmt

	#include <linux/device.h>
	#include <linux/init.h>
	#include <linux/jiffies.h>
	#include <linux/module.h>
	#include <linux/of_platform.h>
	#include <linux/platform_device.h>
	#include <linux/slab.h>

	#include "aoc.h"
	#include "aoc-interface.h"

	#include "aoc_usb.h"

	#define AOC_USB_NAME "aoc_usb"

	enum { NONBLOCKING = 0, BLOCKING = 1 };

	enum {
	TYPE_SCRATCH_PAD = 0,
	TYPE_DEVICE_CONTEXT,
	TYPE_END_OF_SETUP,
	TYPE_DCBAA
	};

	static ssize_t aoc_usb_send_command(struct aoc_usb_drvdata *drvdata,
	void in_cmd, size_t in_size, void out_cmd,
	size_t out_size)
	{
	struct aoc_service_dev *adev = drvdata->adev;
	ssize_t ret;

	ret = mutex_lock_interruptible(&drvdata->lock);
	if (ret != 0)
	return ret;

	__pm_stay_awake(drvdata->ws);

	if (aoc_service_flush_read_data(adev))
	dev_err(&drvdata->adev->dev ,"Previous response left in channel\n");

	dev_dbg(&drvdata->adev->dev, "send cmd id [%u]\n", ((struct CMD_CORE_GENERIC *)in_cmd)->parent.id);

	ret = aoc_service_write_timeout(adev, in_cmd, in_size, drvdata->service_timeout);
	if (ret != in_size) {
	ret = -EIO;
	goto out;
	}

	ret = aoc_service_read_timeout(adev, out_cmd, out_size, drvdata->service_timeout);
	if (ret != out_size)
	ret = -EIO;

	out:
	__pm_relax(drvdata->ws);
	mutex_unlock(&drvdata->lock);
	return ret;
	}

	static int aoc_usb_get_dev_ctx(struct aoc_usb_drvdata *drvdata,
	unsigned int slot_id, size_t length, u8 *dev_ctx)
	{
	int ret = 0;
	struct CMD_USB_CONTROL_GET_DEVICE_CONTEXT *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_GET_DEVICE_CONTEXT), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_GET_DEVICE_CONTEXT_ID,
	sizeof(*cmd));

	cmd->device_id = slot_id;
	cmd->length = length;

	dev_dbg(&drvdata->adev->dev, "cmd=(%u, %u)\n", cmd->device_id, cmd->length);
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	memcpy(dev_ctx, cmd->payload, length);

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_get_dcbaa_ptr(struct aoc_usb_drvdata *drvdata,
	u64 *aoc_dcbaa_ptr)
	{
	int ret = 0;
	struct CMD_USB_CONTROL_GET_DCBAA_PTR *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_GET_DCBAA_PTR), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_GET_DCBAA_PTR_ID,
	sizeof(*cmd));

	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	*aoc_dcbaa_ptr = cmd->aoc_dcbaa_ptr;

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_set_dcbaa_ptr(struct aoc_usb_drvdata *drvdata,
	u64 *aoc_dcbaa_ptr)
	{
	int ret = 0;
	struct CMD_USB_CONTROL_SET_DCBAA_PTR *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SET_DCBAA_PTR), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_SET_DCBAA_PTR_ID,
	sizeof(*cmd));

	cmd->aoc_dcbaa_ptr = *aoc_dcbaa_ptr;
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_setup_done(struct aoc_usb_drvdata *drvdata)
	{
	int ret;
	struct CMD_USB_CONTROL_SETUP *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SETUP), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_SETUP_ID,
	sizeof(*cmd));

	cmd->type = TYPE_END_OF_SETUP;
	cmd->ctx_idx = 0;
	cmd->spbuf_idx = 0;
	cmd->length = 0;
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_notify_conn_stat(struct aoc_usb_drvdata drvdata, void data)
	{
	int ret = 0;
	struct CMD_USB_CONTROL_NOTIFY_CONN_STAT_V2 *cmd;
	struct conn_stat_args *args = data;

	// Don't update usb audio device counter if the notification is for xhci driver state.
	if (args->bus_id != 0 && args->dev_num != 0 && args->slot_id != 0) {
	if (args->conn_stat)
	drvdata->usb_conn_state++;
	else
	drvdata->usb_conn_state--;

	dev_dbg(&drvdata->adev->dev, "currently connected usb audio device count = %u\n",
	drvdata->usb_conn_state);
	}

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_NOTIFY_CONN_STAT_V2), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_NOTIFY_CONN_STAT_V2_ID,
	sizeof(*cmd));

	cmd->bus_id = args->bus_id;
	cmd->dev_num = args->dev_num;
	cmd->slot_id = args->slot_id;
	cmd->conn_state = args->conn_stat;

	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_get_isoc_tr_info(struct aoc_usb_drvdata drvdata, void args)
	{
	int ret;
	struct get_isoc_tr_info_args *tr_info_args =
	(struct get_isoc_tr_info_args *)args;
	struct CMD_USB_CONTROL_GET_ISOC_TR_INFO *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_GET_ISOC_TR_INFO), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_GET_ISOC_TR_INFO_ID,
	sizeof(*cmd));

	cmd->ep_id = tr_info_args->ep_id;
	cmd->dir = tr_info_args->dir;

	dev_dbg(&drvdata->adev->dev, "ep_id=%u, dir=%u\n", cmd->ep_id, cmd->dir);
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	tr_info_args->type = cmd->type;
	tr_info_args->num_segs = cmd->num_segs;
	tr_info_args->seg_ptr = cmd->seg_ptr;
	tr_info_args->max_packet = cmd->max_packet;
	tr_info_args->cycle_state = cmd->cycle_state;
	tr_info_args->num_trbs_free = cmd->num_trbs_free;

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_set_isoc_tr_info(struct aoc_usb_drvdata drvdata, void args)
	{
	int ret;
	struct get_isoc_tr_info_args *tr_info_args =
	(struct get_isoc_tr_info_args *)args;
	struct CMD_USB_CONTROL_SET_ISOC_TR_INFO *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SET_ISOC_TR_INFO), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_SET_ISOC_TR_INFO_ID,
	sizeof(*cmd));

	cmd->ep_id = tr_info_args->ep_id;
	cmd->dir = tr_info_args->dir;
	cmd->type = tr_info_args->type;
	cmd->num_segs = tr_info_args->num_segs;
	cmd->seg_ptr = tr_info_args->seg_ptr;
	cmd->max_packet = tr_info_args->max_packet;
	cmd->cycle_state = tr_info_args->cycle_state;
	cmd->num_trbs_free = tr_info_args->num_trbs_free;

	dev_dbg(&drvdata->adev->dev, "%s: ep_id=%u, dir=%u\n", __func__, cmd->ep_id, cmd->dir);
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_set_offload_state(struct aoc_usb_drvdata drvdata, bool enabled)
	{
	int ret = 0;
	struct CMD_USB_CONTROL_SET_OFFLOAD_STATE *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SET_OFFLOAD_STATE), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_SET_OFFLOAD_STATE_ID,
	sizeof(*cmd));

	cmd->offloading = *enabled;
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));
	if (ret < 0) {
	kfree(cmd);
	return ret;
	}

	kfree(cmd);

	return 0;
	}

	static int aoc_usb_send_feedback_ep_info(struct aoc_usb_drvdata drvdata, void args)
	{
	int ret = 0;
	struct feedback_ep_info_args *fb_ep_info_args =
	(struct feedback_ep_info_args *)args;
	struct CMD_USB_CONTROL_SEND_FEEDBACK_EP_INFO *cmd;

	cmd = kzalloc(sizeof(struct CMD_USB_CONTROL_SEND_FEEDBACK_EP_INFO), GFP_KERNEL);
	if (!cmd)
	return -ENOMEM;

	AocCmdHdrSet(&cmd->parent,
	CMD_USB_CONTROL_SEND_FEEDBACK_EP_INFO_ID,
	sizeof(*cmd));

	cmd->enabled = fb_ep_info_args->enabled;
	cmd->bus_id = fb_ep_info_args->bus_id;
	cmd->dev_num = fb_ep_info_args->dev_num;
	cmd->slot_id = fb_ep_info_args->slot_id;
	cmd->ep_num = fb_ep_info_args->ep_num;
	cmd->max_packet = fb_ep_info_args->max_packet;
	cmd->binterval = fb_ep_info_args->binterval;
	cmd->brefresh = fb_ep_info_args->brefresh;
	ret = aoc_usb_send_command(drvdata, cmd, sizeof(cmd), cmd, sizeof(cmd));

	kfree(cmd);

	return ret;
	}

	static int aoc_usb_notify(struct notifier_block *this,
	unsigned long code, void *data)
	{
	struct aoc_usb_drvdata *drvdata =
	container_of(this, struct aoc_usb_drvdata, nb);
	int ret;
	struct get_dev_ctx_args *dev_ctx_args;

	switch (code) {
	case SYNC_DEVICE_CONTEXT:
	dev_ctx_args = data;
	ret = aoc_usb_get_dev_ctx(drvdata, dev_ctx_args->slot_id,
	dev_ctx_args->length,
	dev_ctx_args->dev_ctx);
	break;
	case GET_DCBAA_PTR:
	ret = aoc_usb_get_dcbaa_ptr(drvdata, data);
	break;
	case SET_DCBAA_PTR:
	ret = aoc_usb_set_dcbaa_ptr(drvdata, data);
	break;
	case SETUP_DONE:
	ret = aoc_usb_setup_done(drvdata);
	break;
	case GET_ISOC_TR_INFO:
	ret = aoc_usb_get_isoc_tr_info(drvdata, data);
	break;
	case SET_ISOC_TR_INFO:
	ret = aoc_usb_set_isoc_tr_info(drvdata, data);
	break;
	case SYNC_CONN_STAT:
	ret = aoc_usb_notify_conn_stat(drvdata, data);
	break;
	case SET_OFFLOAD_STATE:
	ret = aoc_usb_set_offload_state(drvdata, data);
	break;
	case SEND_FB_EP_INFO:
	ret = aoc_usb_send_feedback_ep_info(drvdata, data);
	break;
	default:
	dev_warn(&drvdata->adev->dev, "Code %lu is not supported\n", code);
	ret = -EINVAL;
	break;
	}

	if (ret < 0)
	dev_err(&drvdata->adev->dev, "Fail to handle code %lu, ret = %d", code, ret);

	return ret;
	}

	static enum usb_recover_state recover_state;
	static struct work_struct usb_recovery_ws;
	static void usb_recovery_work(struct work_struct *ws)
	{
	pr_debug("%s: recover_state: %d\n", __func__, recover_state);

	switch(recover_state) {
	case RECOVER_HOST_OFF:
	dwc3_otg_host_enable(false);
	break;
	case RECOVER_HOST_ON:
	dwc3_otg_host_enable(true);
	recover_state = RECOVERED;
	break;
	default:
	pr_err("%s: unhandled recover_state: %d\n", __func__, recover_state);
	break;
	}

	return;
	}

	static int aoc_usb_match(struct device dev, void data)
	{
	if (sysfs_streq(dev_driver_string(dev), "xhci-hcd-exynos"))
	return 1;

	return 0;
	}

	static bool aoc_usb_is_hcd_working()
	{
	struct device_node *np;
	struct platform_device *pdev;
	struct device *udev;
	int ret;

	np = of_find_node_by_name(NULL, "dwc3");
	if (!np \|\| !of_device_is_available(np)) {
	pr_err("Cannot find dwc3 device node\n");
	return false;
	}

	pdev = of_find_device_by_node(np);
	if (!pdev)
	return false;

	udev = device_find_child(&pdev->dev, NULL, aoc_usb_match);
	if (!udev)
	return false;

	ret = usb_host_mode_state_notify(USB_CONNECTED);
	if (ret)
	dev_err(udev, "Notifying AoC for xhci driver status is failed.\n");

	return true;
	}

	static struct work_struct usb_host_mode_checking_ws;
	static void usb_host_mode_checking_work(struct work_struct *ws)
	{
	if (aoc_usb_is_hcd_working())
	pr_info("USB HCD is working, send notification to AoC\n");

	return;
	}

	bool aoc_usb_probe_done;
	static int aoc_usb_probe(struct aoc_service_dev *adev)
	{
	struct device *dev = &adev->dev;
	struct aoc_usb_drvdata *drvdata;

	drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
	if (!drvdata)
	return -ENOMEM;

	drvdata->adev = adev;

	mutex_init(&drvdata->lock);

	drvdata->ws = wakeup_source_register(dev, dev_name(dev));
	if (!drvdata->ws)
	return -ENOMEM;

	drvdata->usb_conn_state = 0;
	drvdata->service_timeout = msecs_to_jiffies(100);
	drvdata->nb.notifier_call = aoc_usb_notify;
	register_aoc_usb_notifier(&drvdata->nb);

	dev_set_drvdata(dev, drvdata);

	aoc_usb_probe_done = true;

	/* Restart host if recover_state was triggered */
	if (recover_state == RECOVER_HOST_OFF) {
	dev_dbg(&drvdata->adev->dev, "restart usb device\n");
	recover_state = RECOVER_HOST_ON;
	schedule_work(&usb_recovery_ws);
	} else {
	recover_state = NONE;
	}

	schedule_work(&usb_host_mode_checking_ws);

	return 0;
	}

	static int aoc_usb_remove(struct aoc_service_dev *adev)
	{
	struct aoc_usb_drvdata *drvdata = dev_get_drvdata(&adev->dev);

	/*
	* Trigger recovery if usb accessory is connected.
	* We only disable host at this moment, it will restart host
	* after aoc usb probe again.
	*/
	if (drvdata->usb_conn_state) {
	dev_dbg(&drvdata->adev->dev, "need to recover usb device\n");
	recover_state = RECOVER_HOST_OFF;
	schedule_work(&usb_recovery_ws);
	}

	unregister_aoc_usb_notifier(&drvdata->nb);
	wakeup_source_unregister(drvdata->ws);
	mutex_destroy(&drvdata->lock);

	kfree(drvdata);

	aoc_usb_probe_done = false;

	return 0;
	}

	static const char *const aoc_usb_service_names[] = {
	"usb_control",
	NULL,
	};

	static struct aoc_driver aoc_usb_driver = {
	.drv = {
	.name = AOC_USB_NAME,
	},
	.service_names = aoc_usb_service_names,
	.probe = aoc_usb_probe,
	.remove = aoc_usb_remove,
	};

	static int __init aoc_usb_init(void)
	{
	xhci_vendor_helper_init();
	usb_vendor_helper_init();
	snd_usb_audio_vendor_helper_init();

	INIT_WORK(&usb_recovery_ws, usb_recovery_work);
	INIT_WORK(&usb_host_mode_checking_ws, usb_host_mode_checking_work);

	return aoc_driver_register(&aoc_usb_driver);
	}

	static void __exit aoc_usb_exit(void)
	{
	aoc_driver_unregister(&aoc_usb_driver);
	}

	module_init(aoc_usb_init);
	module_exit(aoc_usb_exit);

	MODULE_LICENSE("GPL v2");
	MODULE_AUTHOR("Howard Yen (Google)");
	MODULE_DESCRIPTION("USB driver for AoC");