[PATCH v3 7/8] usb: mausb_host: MA-USB PAL events processing

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Implemented MA USB management messages processing and communication
with user-space driver via mapped memory.

MA USB PAL events are being enqueued into ring buffer from which
data is being send/received to/from user-space.

Signed-off-by: Vladimir Stankovic <vladimir.stankovic@xxxxxxxxxxxxxxx>
---
 drivers/usb/mausb_host/Makefile              |   1 +
 drivers/usb/mausb_host/hcd.c                 | 252 +++++++-
 drivers/usb/mausb_host/hpal.c                | 449 +++++++++++++-
 drivers/usb/mausb_host/hpal.h                |  44 ++
 drivers/usb/mausb_host/hpal_events.c         | 611 +++++++++++++++++++
 drivers/usb/mausb_host/hpal_events.h         |  85 +++
 drivers/usb/mausb_host/mausb_driver_status.h |  17 +
 drivers/usb/mausb_host/utils.c               | 275 +++++++++
 drivers/usb/mausb_host/utils.h               |   5 +
 9 files changed, 1729 insertions(+), 10 deletions(-)
 create mode 100644 drivers/usb/mausb_host/hpal_events.c
 create mode 100644 drivers/usb/mausb_host/hpal_events.h
 create mode 100644 drivers/usb/mausb_host/mausb_driver_status.h

diff --git a/drivers/usb/mausb_host/Makefile b/drivers/usb/mausb_host/Makefile
index 829314b15cbb..fd2a36a04ad6 100644
--- a/drivers/usb/mausb_host/Makefile
+++ b/drivers/usb/mausb_host/Makefile
@@ -11,5 +11,6 @@ mausb_host-y += utils.o
 mausb_host-y += ip_link.o
 mausb_host-y += hcd.o
 mausb_host-y += hpal.o
+mausb_host-y += hpal_events.o
  ccflags-y += -I$(srctree)/$(src)
diff --git a/drivers/usb/mausb_host/hcd.c b/drivers/usb/mausb_host/hcd.c
index 70cb633c39ba..8cf885612684 100644
--- a/drivers/usb/mausb_host/hcd.c
+++ b/drivers/usb/mausb_host/hcd.c
@@ -10,6 +10,7 @@
 #include <linux/module.h>
  #include "hpal.h"
+#include "hpal_events.h"
 #include "utils.h"
  static int mausb_open(struct inode *inode, struct file *file);
@@ -1075,6 +1076,18 @@ static void mausb_free_dev(struct usb_hcd *hcd, struct usb_device *dev)
 	}
  	if (ep_ctx) {
+		status = mausb_epinactivate_event_to_user(ma_dev, dev_handle,
+							  ep_ctx->ep_handle);
+
+ mausb_pr_info("epinactivate request ep_handle=%#x, dev_handle=%#x, status=%d",
+			      ep_ctx->ep_handle, dev_handle, status);
+
+		status = mausb_epdelete_event_to_user(ma_dev, dev_handle,
+						      ep_ctx->ep_handle);
+
+		if (status < 0)
+ mausb_pr_warn("ep_handle_del request failed for ep0: ep_handle=%#x, dev_handle=%#x",
+				      ep_ctx->ep_handle, dev_handle);
 		dev->ep0.hcpriv = NULL;
 		kfree(ep_ctx);
@@ -1082,6 +1095,14 @@ static void mausb_free_dev(struct usb_hcd *hcd, struct usb_device *dev)
 		mausb_pr_warn("ep_ctx is NULL: dev_handle=%#x", dev_handle);
 	}
 +	if (dev_handle != DEV_HANDLE_NOT_ASSIGNED) {
+		status = mausb_usbdevdisconnect_event_to_user(ma_dev,
+							      dev_handle);
+		if (status < 0)
+			mausb_pr_warn("usb_dev_disconnect req failed for dev_handle=%#x",
+				      dev_handle);
+	}
+
 free_dev:
 	if (atomic_sub_and_test(1, &ma_dev->num_of_usb_devices)) {
 		mausb_pr_info("All usb devices destroyed - proceed with disconnecting");
@@ -1096,6 +1117,21 @@ static void mausb_free_dev(struct usb_hcd *hcd, struct usb_device *dev)
 		mausb_clear_hcd_madev(port_number);
 }
 +static int mausb_device_assign_address(struct mausb_device *dev,
+				       struct mausb_usb_device_ctx *usb_dev_ctx)
+{
+	int status =
+		mausb_setusbdevaddress_event_to_user(dev,
+						     usb_dev_ctx->dev_handle,
+						     RESPONSE_TIMEOUT);
+
+	mausb_pr_info("dev_handle=%#x, status=%d", usb_dev_ctx->dev_handle,
+		      status);
+	usb_dev_ctx->addressed = (status == 0);
+
+	return status;
+}
+
 static struct mausb_usb_device_ctx *
 mausb_alloc_device_ctx(struct hub_ctx *hub, struct usb_device *dev,
 		       struct mausb_device *ma_dev, u16 port_number,
@@ -1182,6 +1218,12 @@ static int mausb_address_device(struct usb_hcd *hcd, struct usb_device *dev)
 			return status;
 	}
 +	if (!usb_device_ctx->addressed) {
+		status = mausb_device_assign_address(ma_dev, usb_device_ctx);
+		if (status < 0)
+			return status;
+	}
+
 	endpoint_ctx = dev->ep0.hcpriv;
 	if (!endpoint_ctx) {
 		mausb_pr_err("endpoint_ctx is NULL: dev_handle=%#x",
@@ -1189,7 +1231,23 @@ static int mausb_address_device(struct usb_hcd *hcd, struct usb_device *dev)
 		return -EINVAL;
 	}
 -	return 0;
+	/*
+	 * Fix to support usb 2.0 logitech camera. If endoint handle of usb 2.0
+	 * device is already modified, do not modify it again.
+	 */
+	if (dev->speed < USB_SPEED_SUPER && endpoint_ctx->ep_handle != 0)
+		return 0;
+
+	status = mausb_modifyep0_event_to_user(ma_dev,
+					       usb_device_ctx->dev_handle,
+					       &endpoint_ctx->ep_handle,
+					       dev->ep0.desc.wMaxPacketSize);
+
+ mausb_pr_info("modify ep0 response, ep_handle=%#x, dev_handle=%#x, status=%d",
+		      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle,
+		      status);
+
+	return status;
 }
static int mausb_add_endpoint(struct usb_hcd *hcd, struct usb_device *dev, @@ -1242,10 +1300,32 @@ static int mausb_add_endpoint(struct usb_hcd *hcd, struct usb_device *dev,
 		mausb_init_superspeed_ep_descriptor(&descriptor_ss,
 						    &endpoint->desc,
 						    &endpoint->ss_ep_comp);
+		status = mausb_ephandle_event_to_user(ma_dev,
+						      usb_dev_ctx->dev_handle,
+						      sizeof(descriptor_ss),
+						      &descriptor_ss,
+						      &endpoint_ctx->ep_handle);
+
 	} else {
 		mausb_init_standard_ep_descriptor(&descriptor, &endpoint->desc);
+		status = mausb_ephandle_event_to_user(ma_dev,
+						      usb_dev_ctx->dev_handle,
+						      sizeof(descriptor),
+						      &descriptor,
+						      &endpoint_ctx->ep_handle);
 	}
 +	if (status < 0) {
+		mausb_pr_err("ep_handle_request failed dev_handle=%#x",
+			     usb_dev_ctx->dev_handle);
+		endpoint->hcpriv = NULL;
+		kfree(endpoint_ctx);
+		return status;
+	}
+
+	mausb_pr_info("Endpoint added ep_handle=%#x, dev_handle=%#x",
+		      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle);
+
 	return 0;
 }
@@ -1254,6 +1334,7 @@ static int mausb_drop_endpoint(struct usb_hcd *hcd, struct usb_device *dev,
 {
 	u8	port_number;
 	int	status;
+	int	retries	    = 0;
 	struct hub_ctx		    *hub = (struct hub_ctx *)hcd->hcd_priv;
 	struct mausb_device	    *ma_dev;
 	struct mausb_usb_device_ctx *usb_dev_ctx;
@@ -1288,9 +1369,49 @@ static int mausb_drop_endpoint(struct usb_hcd *hcd, struct usb_device *dev,
 		return -ENODEV;
 	}
 +	mausb_pr_info("Start dropping ep_handle=%#x, dev_handle=%#x",
+		      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle);
+
+	if (atomic_read(&ma_dev->unresponsive_client)) {
+ mausb_pr_err("Client is not responsive anymore - drop endpoint immediately");
+		endpoint->hcpriv = NULL;
+		kfree(endpoint_ctx);
+		return -ESHUTDOWN;
+	}
+
+	status = mausb_epinactivate_event_to_user(ma_dev,
+						  usb_dev_ctx->dev_handle,
+						  endpoint_ctx->ep_handle);
+
+ mausb_pr_info("epinactivate request ep_handle=%#x, dev_handle=%#x, status=%d",
+		      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle,
+		      status);
+
+	while (true) {
+		status = mausb_epdelete_event_to_user(ma_dev,
+						      usb_dev_ctx->dev_handle,
+						      endpoint_ctx->ep_handle);
+
+ mausb_pr_info("ep_handle_delete_request, ep_handle=%#x, dev_handle=%#x, status=%d",
+			      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle,
+			      status);
+
+		if (status == -EBUSY) {
+			if (++retries < MAUSB_BUSY_RETRIES_COUNT)
+				usleep_range(10000, 10001);
+			else
+				return -EBUSY;
+		} else {
+			break;
+		}
+	}
+
+	mausb_pr_info("Endpoint dropped ep_handle=%#x, dev_handle=%#x",
+		      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle);
+
 	endpoint->hcpriv = NULL;
 	kfree(endpoint_ctx);
-	return 0;
+	return status;
 }
  static int mausb_device_assign_dev_handle(struct usb_hcd *hcd,
@@ -1343,6 +1464,20 @@ static int mausb_device_assign_dev_handle(struct usb_hcd *hcd,
 		return -EINVAL;
 	}
 +	status = mausb_usbdevhandle_event_to_user(ma_dev, (u8)dev_speed,
+						  dev->route, hub_dev_handle,
+						  parent_hs_hub_dev_handle,
+						  parent_hs_hub_port, 0,
+						  ma_dev->lse,
+						  &usb_device_ctx->dev_handle);
+
+	mausb_pr_info("mausb_usbdevhandle_event status=%d", status);
+
+	if (status < 0)
+		return status;
+
+	mausb_pr_info("Get ref dev_handle=%#x", usb_device_ctx->dev_handle);
+
 	endpoint_ctx = kzalloc(sizeof(*endpoint_ctx), GFP_ATOMIC);
 	if (!endpoint_ctx)
 		return -ENOMEM;
@@ -1354,6 +1489,22 @@ static int mausb_device_assign_dev_handle(struct usb_hcd *hcd,
  	mausb_init_standard_ep_descriptor(&descriptor, &dev->ep0.desc);
 +	status = mausb_ephandle_event_to_user(ma_dev,
+					      usb_device_ctx->dev_handle,
+					      sizeof(descriptor),
+					      &descriptor,
+					      &endpoint_ctx->ep_handle);
+
+ mausb_pr_info("mausb_ephandle_event ep_handle=%#x, dev_handle=%#x, status=%d",
+		      endpoint_ctx->ep_handle, endpoint_ctx->dev_handle,
+		      status);
+
+	if (status < 0) {
+		dev->ep0.hcpriv = NULL;
+		kfree(endpoint_ctx);
+		return status;
+	}
+
 	return 0;
 }
@@ -1396,9 +1547,21 @@ static int mausb_enable_device(struct usb_hcd *hcd, struct usb_device *dev)
 			return status;
 	}
 +	mausb_pr_info("Device assigned and addressed usb_device_ctx=%p",
+		      usb_device_ctx);
+
 	if (usb_device_ctx->dev_handle == DEV_HANDLE_NOT_ASSIGNED)
 		return mausb_device_assign_dev_handle(hcd, dev, hub, ma_dev,
 						      usb_device_ctx);
+
+	/*
+	 * Fix for usb 2.0 logitech camera
+	 */
+	if (!usb_device_ctx->addressed)
+		return mausb_device_assign_address(ma_dev, usb_device_ctx);
+
+	mausb_pr_info("Device assigned and addressed dev_handle=%#x",
+		      usb_device_ctx->dev_handle);
 	return 0;
 }
@@ -1444,7 +1607,15 @@ static int mausb_update_device(struct usb_hcd *hcd, struct usb_device *dev)
 		return -ENODEV;
 	}
 -	return 0;
+	status = mausb_updatedev_event_to_user(ma_dev,
+					       usb_device_ctx->dev_handle,
+					       0, 0, 0, 0, 0, 0,
+					       &dev->descriptor);
+
+	mausb_pr_info("Finished dev_handle=%#x, status=%d",
+		      usb_device_ctx->dev_handle, status);
+
+	return status;
 }
static int mausb_hub_update_device(struct usb_hcd *hcd, struct usb_device *dev, @@ -1454,8 +1625,10 @@ static int mausb_hub_update_device(struct usb_hcd *hcd, struct usb_device *dev,
 	u8	port_number;
 	unsigned long flags;
 	u16 max_exit_latency = 0;
+	u8  number_of_ports = (u8)dev->maxchild;
 	u8  mtt = 0;
 	u8  ttt = 0;
+	u8  integrated_hub_latency = 0;
 	struct hub_ctx		    *hub = (struct hub_ctx *)hcd->hcd_priv;
 	struct mausb_device	    *ma_dev;
 	struct mausb_usb_device_ctx *usb_device_ctx;
@@ -1495,7 +1668,17 @@ static int mausb_hub_update_device(struct usb_hcd *hcd, struct usb_device *dev,
 	else if (dev->usb3_lpm_u2_enabled)
 		max_exit_latency = (u16)dev->u2_params.mel;
 -	return 0;
+	status = mausb_updatedev_event_to_user(ma_dev,
+					       usb_device_ctx->dev_handle,
+					       max_exit_latency, 1,
+					       number_of_ports, mtt, ttt,
+					       integrated_hub_latency,
+					       &dev->descriptor);
+
+	mausb_pr_info("Finished dev_handle=%#x, status=%d",
+		      usb_device_ctx->dev_handle, status);
+
+	return status;
 }
static int mausb_check_bandwidth(struct usb_hcd *hcd, struct usb_device *dev)
@@ -1531,6 +1714,8 @@ static void mausb_endpoint_reset(struct usb_hcd *hcd,
 	struct mausb_usb_device_ctx *usb_device_ctx;
 	struct usb_device	    *dev;
 	struct mausb_endpoint_ctx   *ep_ctx;
+	struct ma_usb_ephandlereq_desc_ss  descriptor_ss;
+	struct ma_usb_ephandlereq_desc_std descriptor;
  	ep_ctx = endpoint->hcpriv;
 	if (!ep_ctx) {
@@ -1565,6 +1750,15 @@ static void mausb_endpoint_reset(struct usb_hcd *hcd,
 	is_out = usb_endpoint_dir_out(&endpoint->desc);
 	tsp = (u8)(is_out ? dev->toggle[1] : dev->toggle[0]);
 +	status = mausb_epreset_event_to_user(ma_dev, dev_handle,
+					     ep_ctx->ep_handle, tsp);
+
+	mausb_pr_info("ep_reset status=%d, ep_handle=%#x, dev_handle=%#x",
+		      status, ep_ctx->ep_handle, dev_handle);
+
+	if (status < 0)
+		return;
+
 	if (status != EUCLEAN) {
 		if (!tsp) {
 			usb_settoggle(dev, epnum, is_out, 0U);
@@ -1572,12 +1766,52 @@ static void mausb_endpoint_reset(struct usb_hcd *hcd,
 				usb_settoggle(dev, epnum, !is_out, 0U);
 		}
 +		status = mausb_epactivate_event_to_user(ma_dev, dev_handle,
+							ep_ctx->ep_handle);
+
+ mausb_pr_err("ep_activate failed, status=%d, ep_handle=%#x, dev_handle=%#x",
+			     status, ep_ctx->ep_handle, dev_handle);
+
 		return;
 	}
  	if (tsp)
 		return;
 +	status = mausb_epinactivate_event_to_user(ma_dev, dev_handle,
+						  ep_ctx->ep_handle);
+
+	mausb_pr_info("ep_inactivate status=%d, ep_handle=%#x, dev_handle=%#x",
+		      status, ep_ctx->ep_handle, dev_handle);
+
+	if (status < 0)
+		return;
+
+	status = mausb_epdelete_event_to_user(ma_dev, dev_handle,
+					      ep_ctx->ep_handle);
+
+	mausb_pr_info("ep_handle_delete status=%d, ep_handle=%#x, dev_handle=%#x",
+		      status, ep_ctx->ep_handle, dev_handle);
+
+	if (status < 0)
+		return;
+
+	if (dev->speed >= USB_SPEED_SUPER) {
+		mausb_init_superspeed_ep_descriptor(&descriptor_ss,
+						    &endpoint->desc,
+						    &endpoint->ss_ep_comp);
+		status = mausb_ephandle_event_to_user(ma_dev, dev_handle,
+						      sizeof(descriptor_ss),
+						      &descriptor_ss,
+						      &ep_ctx->ep_handle);
+	} else {
+		mausb_init_standard_ep_descriptor(&descriptor, &endpoint->desc);
+		status = mausb_ephandle_event_to_user(ma_dev, dev_handle,
+						      sizeof(descriptor),
+						      &descriptor,
+						      &ep_ctx->ep_handle);
+	}
+
mausb_pr_info("ep_handle request status=%d, ep_handle=%#x, dev_handle=%#x",
 		      status, ep_ctx->ep_handle, dev_handle);
 }
@@ -1624,7 +1858,15 @@ static int mausb_reset_device(struct usb_hcd *hcd, struct usb_device *dev)
  	dev_handle = usb_device_ctx->dev_handle;
 -	return 0;
+	status = mausb_usbdevreset_event_to_user(ma_dev, dev_handle);
+
+	mausb_pr_info("usb_dev_reset dev_handle=%#x, status=%d",
+		      dev_handle, status);
+
+	if (status == 0)
+		usb_device_ctx->addressed = false;
+
+	return status;
 }
  void mausb_clear_hcd_madev(u16 port_number)
diff --git a/drivers/usb/mausb_host/hpal.c b/drivers/usb/mausb_host/hpal.c
index b8e00e6ef69c..1e7bbe3b230a 100644
--- a/drivers/usb/mausb_host/hpal.c
+++ b/drivers/usb/mausb_host/hpal.c
@@ -11,6 +11,7 @@
 #include <linux/uio.h>
  #include "hcd.h"
+#include "hpal_events.h"
 #include "utils.h"
  #define MAUSB_DELETE_MADEV_TIMEOUT_MS 3000
@@ -278,6 +279,31 @@ void mausb_release_event_resources(struct mausb_event *event)
 	kfree(receive_buffer);
 }
 +static void mausb_iterator_reset(struct mausb_device *dev,
+				 struct mausb_event *event)
+{
+	struct urb	     *urb = (struct urb *)event->data.urb;
+	struct mausb_urb_ctx *urb_ctx;
+
+	urb_ctx = mausb_find_urb_in_tree(urb);
+
+	if (urb_ctx)
+		mausb_reset_data_iterator(&urb_ctx->iterator);
+}
+
+static void mausb_iterator_seek(struct mausb_device *dev,
+				struct mausb_event *event)
+{
+	struct urb	     *urb = (struct urb *)event->data.urb;
+	struct mausb_urb_ctx *urb_ctx;
+
+	urb_ctx = mausb_find_urb_in_tree(urb);
+
+	if (urb_ctx)
+		mausb_data_iterator_seek(&urb_ctx->iterator,
+					 event->data.iterator_seek_delta);
+}
+
 void mausb_complete_urb(struct mausb_event *event)
 {
 	struct urb *urb = (struct urb *)event->data.urb;
@@ -291,6 +317,46 @@ void mausb_complete_urb(struct mausb_event *event)
 			       event->status);
 }
 +static void mausb_delete_ma_dev(struct mausb_device *dev,
+				struct mausb_event *event)
+{
+	mausb_signal_event(dev, event, event->mgmt.delete_ma_dev.event_id);
+}
+
+static void mausb_process_user_finished(struct mausb_device *dev,
+					struct mausb_event *event)
+{
+	complete(&dev->user_finished_event);
+}
+
+static int mausb_send_mgmt_msg(struct mausb_device *dev,
+			       struct mausb_event *event)
+{
+	struct mausb_kvec_data_wrapper wrapper;
+	struct kvec kvec;
+	struct ma_usb_hdr_common *hdr;
+	int status;
+
+	hdr = (struct ma_usb_hdr_common *)event->mgmt.mgmt_hdr.hdr;
+
+	mausb_pr_info("event=%d, type=%d", event->type, hdr->type);
+
+	kvec.iov_base	 = hdr;
+	kvec.iov_len	 = hdr->length;
+	wrapper.kvec	 = &kvec;
+	wrapper.kvec_num = 1;
+	wrapper.length	 = hdr->length;
+
+	status = mausb_ip_send(dev->mgmt_channel, &wrapper);
+	if (status < 0) {
+		mausb_pr_err("Send failed. Disconnecting... status=%d", status);
+		queue_work(dev->workq, &dev->socket_disconnect_work);
+		queue_work(dev->workq, &dev->hcd_disconnect_work);
+	}
+
+	return status;
+}
+
 static int mausb_get_first_free_port_number(u16 *port_number)
 {
 	(*port_number) = 0;
@@ -338,11 +404,142 @@ static inline void mausb_port_has_changed_event(struct mausb_device *dev,
 		mausb_port_has_changed(USB20HUB, HIGH_SPEED, dev);
 }
 +static void mausb_complete_timeout_event(struct mausb_device *dev,
+					 struct mausb_event *event)
+{
+	mausb_pr_debug("Event type=%d, event_id=%llu", event->type,
+		       event->mgmt.mgmt_req_timedout.event_id);
+	mausb_signal_event(dev, event, event->mgmt.mgmt_req_timedout.event_id);
+}
+
+static void mausb_process_event(struct mausb_device *dev,
+				struct mausb_event *event)
+{
+	mausb_pr_debug("Event type=%d", event->type);
+
+	switch (event->type) {
+	case MAUSB_EVENT_TYPE_USB_DEV_HANDLE:
+		mausb_usbdevhandle_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_EP_HANDLE:
+		mausb_ephandle_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_EP_HANDLE_ACTIVATE:
+		mausb_epactivate_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_EP_HANDLE_INACTIVATE:
+		mausb_epinactivate_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_EP_HANDLE_RESET:
+		mausb_epreset_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_EP_HANDLE_DELETE:
+		mausb_epdelete_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_MODIFY_EP0:
+		mausb_modifyep0_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_SET_USB_DEV_ADDRESS:
+		mausb_setusbdevaddress_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_UPDATE_DEV:
+		mausb_updatedev_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_USB_DEV_RESET:
+		mausb_usbdevreset_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_CANCEL_TRANSFER:
+		mausb_canceltransfer_event_from_user(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_PORT_CHANGED:
+		mausb_port_has_changed_event(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_PING:
+		mausb_send_mgmt_msg(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_SEND_MGMT_MSG:
+		mausb_send_mgmt_msg(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_SEND_DATA_MSG:
+		mausb_send_data_msg(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_RECEIVED_DATA_MSG:
+		mausb_receive_data_msg(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_URB_COMPLETE:
+		mausb_complete_urb(event);
+		break;
+	case MAUSB_EVENT_TYPE_SEND_ACK:
+		mausb_send_transfer_ack(dev, event);
+		mausb_release_event_resources(event);
+		break;
+	case MAUSB_EVENT_TYPE_ITERATOR_RESET:
+		mausb_iterator_reset(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_ITERATOR_SEEK:
+		mausb_iterator_seek(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_DELETE_MA_DEV:
+		mausb_delete_ma_dev(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_USER_FINISHED:
+		mausb_process_user_finished(dev, event);
+		break;
+	case MAUSB_EVENT_TYPE_RELEASE_EVENT_RESOURCES:
+		mausb_release_event_resources(event);
+		break;
+	case MAUSB_EVENT_TYPE_NONE:
+		mausb_release_event_resources(event);
+		break;
+	case MAUSB_EVENT_TYPE_MGMT_REQUEST_TIMED_OUT:
+		mausb_complete_timeout_event(dev, event);
+		break;
+	default:
+		break;
+	}
+
+	mausb_notify_completed_user_events(dev->ring_buffer);
+}
+
+static void mausb_hpal_kernel_work(struct work_struct *work)
+{
+	struct mausb_device *dev = container_of(work, struct mausb_device,
+						work);
+	struct mausb_event *event;
+	int status;
+	u16 i;
+	u16 events;
+	u16 completed_events;
+	unsigned long flags;
+	struct mausb_ring_buffer *dev_mausb_ring = dev->ring_buffer;
+
+	spin_lock_irqsave(&dev->num_of_user_events_lock, flags);
+	events = dev->num_of_user_events;
+	completed_events = dev->num_of_completed_events;
+	dev->num_of_user_events = 0;
+	dev->num_of_completed_events = 0;
+	spin_unlock_irqrestore(&dev->num_of_user_events_lock, flags);
+
+	status = mausb_ring_buffer_move_tail(dev_mausb_ring, completed_events);
+	if (status < 0) {
+		mausb_pr_err("Dequeue failed, status=%d", status);
+		kref_put(&dev->refcount, mausb_release_ma_dev_async);
+		return;
+	}
+
+	for (i = 0; i < events; ++i) {
+		event = mausb_ring_current_from_user(dev_mausb_ring);
+		mausb_ring_next_from_user(dev_mausb_ring);
+		mausb_process_event(dev, event);
+	}
+}
+
 static void mausb_socket_disconnect_event(struct work_struct *work)
 {
 	struct mausb_device *dev = container_of(work, struct mausb_device,
 						socket_disconnect_work);
 	struct mausb_event event;
+	int status;
  	mausb_pr_info("madev_addr=%d", dev->madev_addr);
@@ -363,6 +560,11 @@ static void mausb_socket_disconnect_event(struct work_struct *work)
 		event.type = MAUSB_EVENT_TYPE_NETWORK_DISCONNECTED;
 		event.data.device_id = dev->id;
 +		status = mausb_enqueue_event_to_user(dev, &event);
+
+ mausb_pr_info("Sending notification to user that network is disconnected status=%d",
+			      status);
+
 		mausb_pr_info("Releasing MAUSB device ref");
 		kref_put(&dev->refcount, mausb_release_ma_dev_async);
 	}
@@ -427,6 +629,13 @@ static void mausb_delete_madev(struct work_struct *work)
  		mausb_insert_event(dev, &mausb_completion);
 +		status = mausb_enqueue_event_to_user(dev, &event);
+		if (status < 0) {
+			mausb_remove_event(dev, &mausb_completion);
+			mausb_pr_err("Ring buffer full, enqueue failed");
+			return;
+		}
+
 		mausb_pr_debug("Deleting MAUSB device...");
  		status = wait_for_completion_interruptible_timeout(&completion,
@@ -449,10 +658,14 @@ static void mausb_delete_madev(struct work_struct *work)
  	mausb_clear_hcd_madev(dev->port_number);
 +	mausb_ring_buffer_cleanup(dev->ring_buffer);
+	mausb_ring_buffer_destroy(dev->ring_buffer);
+
 	mausb_remove_madev_from_list(dev->madev_addr);
  	put_net(dev->net_ns);
 +	kfree(dev->ring_buffer);
 	kfree(dev);
 	mausb_signal_empty_mss();
 @@ -463,6 +676,7 @@ static void mausb_ping_work(struct work_struct *work)
 {
 	struct mausb_device *dev = container_of(work, struct mausb_device,
 						ping_work);
+	int status = 0;
  	if (mausb_start_connection_timer(dev) < 0) {
mausb_pr_err("Device disconnecting due to session timeout madev_addr=%d",
@@ -471,6 +685,13 @@ static void mausb_ping_work(struct work_struct *work)
 		queue_work(dev->workq, &dev->hcd_disconnect_work);
 		return;
 	}
+
+	status = mausb_ping_event_to_user(dev);
+
+	if (status < 0) {
+		mausb_pr_err("Ring buffer full");
+		return;
+	}
 }
  static void mausb_heartbeat_work(struct work_struct *work)
@@ -576,6 +797,7 @@ mausb_create_madev(struct mausb_device_address dev_addr, u8 madev_address,
  	dev->workq = workq;
 +	INIT_WORK(&dev->work, mausb_hpal_kernel_work);
 	INIT_WORK(&dev->socket_disconnect_work, mausb_socket_disconnect_event);
 	INIT_WORK(&dev->hcd_disconnect_work, mausb_hcd_disconnect_event);
 	INIT_WORK(&dev->madev_delete_work, mausb_delete_madev);
@@ -601,6 +823,15 @@ mausb_create_madev(struct mausb_device_address dev_addr, u8 madev_address,
 	dev->madev_addr = madev_address;
 	dev->net_ns = get_net(current->nsproxy->net_ns);
 +	if (!list_empty(&mss.available_ring_buffers)) {
+		dev->ring_buffer = container_of(mss.available_ring_buffers.next,
+						struct mausb_ring_buffer,
+						list_entry);
+		list_del(mss.available_ring_buffers.next);
+	} else {
+		mausb_pr_alert("Ring buffer for mausb device is not availbale!");
+	}
+
 	list_add_tail(&dev->list_entry, &mss.madev_list);
  	reinit_completion(&mss.empty);
@@ -659,6 +890,14 @@ int mausb_initiate_dev_connection(struct mausb_device_address dev_addr,
 	return 0;
 }
 +void mausb_on_madev_connected(struct mausb_device *dev)
+{
+	struct mausb_event mausb_event;
+
+	mausb_dev_reset_req_event(&mausb_event);
+	mausb_enqueue_event_to_user(dev, &mausb_event);
+}
+
 int mausb_enqueue_event_from_user(u8 madev_addr, u16 num_of_events,
 				  u16 num_of_completed)
 {
@@ -683,9 +922,29 @@ int mausb_enqueue_event_from_user(u8 madev_addr, u16 num_of_events,
 	return 0;
 }
 +int mausb_enqueue_event_to_user(struct mausb_device *dev,
+				struct mausb_event *event)
+{
+	int status;
+
+	event->madev_addr = dev->madev_addr;
+	status = mausb_ring_buffer_put(dev->ring_buffer, event);
+	if (status < 0) {
+		mausb_pr_err("Ring buffer operation failed");
+		mausb_cleanup_ring_buffer_event(event);
+		return status;
+	}
+
+	mausb_notify_ring_events(dev->ring_buffer);
+	mausb_pr_debug("User-space notification sent.");
+
+	return 0;
+}
+
 int mausb_data_req_enqueue_event(struct mausb_device *dev, u16 ep_handle,
 				 struct urb *request)
 {
+	int status;
 	struct mausb_event mausb_event;
  	mausb_event.type   = MAUSB_EVENT_TYPE_SEND_DATA_MSG;
@@ -728,7 +987,12 @@ int mausb_data_req_enqueue_event(struct mausb_device *dev, u16 ep_handle,
 		       &request->dev->route, sizeof(request->dev->route));
 	}
 -	return 0;
+	status = mausb_enqueue_event_to_user(dev, &mausb_event);
+	if (status < 0)
+ mausb_pr_err("Failed to enqueue event to user-space ep_handle=%#x, status=%d",
+			     mausb_event.data.ep_handle, status);
+
+	return status;
 }
void mausb_complete_request(struct urb *urb, u32 actual_length, int status) @@ -841,6 +1105,17 @@ static void mausb_execute_urb_dequeue(struct work_struct *dequeue_work)
 	mausb_pr_debug("urb=%p, ep_handle=%#x, dev_handle=%#x",
 		       urb, ep_ctx->ep_handle, ep_ctx->dev_handle);
 +	if (!usb_endpoint_xfer_isoc(&urb->ep->desc)) {
+		status = mausb_canceltransfer_event_to_user(ep_ctx->ma_dev,
+							    ep_ctx->dev_handle,
+							    ep_ctx->ep_handle,
+							    (u64)urb);
+		if (status < 0) {
+			mausb_pr_err("Failed to enqueue cancel transfer to user");
+			goto complete_urb;
+		}
+	}
+
 	memset(&mausb_event, 0, sizeof(mausb_event));
  	mausb_event.type   = MAUSB_EVENT_TYPE_DELETE_DATA_TRANSFER;
@@ -855,6 +1130,13 @@ static void mausb_execute_urb_dequeue(struct work_struct *dequeue_work)
 						MAUSB_DATA_MSG_DIRECTION_IN :
 						MAUSB_DATA_MSG_DIRECTION_OUT);
 +	status = mausb_enqueue_event_to_user(ep_ctx->ma_dev, &mausb_event);
+	if (status < 0) {
+ mausb_pr_alert("Failed to enqueue event to user-space ep_handle=%#x, status=%d",
+			       mausb_event.data.ep_handle, status);
+		goto complete_urb;
+	}
+
 	if (!mausb_return_urb_ctx_to_tree(urb_ctx, false)) {
mausb_pr_alert("Failed to insert in tree urb=%p ep_handle=%#x, status=%d",
 			       urb, mausb_event.data.ep_handle, status);
@@ -916,6 +1198,7 @@ void mausb_deinitialize_mss(void)
  	wait_for_completion(&mss.empty);
 	mausb_pr_debug("Waiting for completion on disconnect_event ended");
+	mausb_stop_ring_events();
  	timeout = wait_for_completion_timeout(&mss.client_stopped, timeout);
 	mausb_pr_info("Remaining time after waiting for stopping client %ld",
@@ -1104,7 +1387,6 @@ int mausb_send_transfer_ack(struct mausb_device *dev, struct mausb_event *event) int mausb_send_data_msg(struct mausb_device *dev, struct mausb_event *event)
 {
 	struct mausb_urb_ctx *urb_ctx;
-	int status = 0;
  	if (event->status != 0) {
 		mausb_pr_err("Event %d failed with status %d",
@@ -1119,10 +1401,9 @@ int mausb_send_data_msg(struct mausb_device *dev, struct mausb_event *event)
 		/* Transfer will be deleted from dequeue task */
 		mausb_pr_warn("Urb is already cancelled for event=%d",
 			      event->type);
-		return status;
 	}
 -	return status;
+	return 0;
 }
int mausb_receive_data_msg(struct mausb_device *dev, struct mausb_event *event) @@ -1142,8 +1423,10 @@ int mausb_receive_data_msg(struct mausb_device *dev, struct mausb_event *event)
  	urb_ctx = mausb_find_urb_in_tree((struct urb *)event->data.urb);
 -	if (!urb_ctx)
+	if (!urb_ctx) {
+		/* Transfer will be deleted from dequeue task */
 		mausb_pr_warn("Urb is already cancelled");
+	}
  cleanup:
 	mausb_release_event_resources(event);
@@ -1279,6 +1562,7 @@ static void mausb_connect_callback(struct mausb_device *dev,
 	if (channel == MAUSB_ISOCH_CHANNEL) {
 		dev->channel_map[MAUSB_INTR_CHANNEL] =
 				dev->channel_map[MAUSB_CTRL_CHANNEL];
+		mausb_on_madev_connected(dev);
 	}
 }
@@ -1305,6 +1589,16 @@ static void mausb_handle_receive_event(struct mausb_device *dev,
 	}
  	mausb_reset_connection_timer(dev);
+
+	status = mausb_msg_received_event(&event,
+					  (struct ma_usb_hdr_common *)data,
+					  channel);
+
+	if (status == 0)
+		status = mausb_enqueue_event_to_user(dev, &event);
+
+	if (status < 0)
+		mausb_pr_err("Failed to enqueue, status=%d", status);
 }
  void mausb_ip_callback(void *ctx, enum mausb_channel channel,
@@ -1614,3 +1908,148 @@ u32 mausb_data_iterator_length(struct mausb_data_iter *iterator)
 {
 	return iterator->length;
 }
+
+static int mausb_ring_buffer_get(struct mausb_ring_buffer *ring,
+				 struct mausb_event *event)
+{
+	unsigned long flags = 0;
+
+	spin_lock_irqsave(&ring->lock, flags);
+	if (CIRC_CNT(ring->head, ring->tail, MAUSB_RING_BUFFER_SIZE) < 1) {
+		spin_unlock_irqrestore(&ring->lock, flags);
+		return -ENOSPC;
+	}
+	memcpy(event, ring->to_user_buffer + ring->tail, sizeof(*event));
+	mausb_pr_debug("HEAD=%d, TAIL=%d", ring->head, ring->tail);
+	ring->tail = (ring->tail + 1) & (MAUSB_RING_BUFFER_SIZE - 1);
+	mausb_pr_debug("HEAD=%d, TAIL=%d", ring->head, ring->tail);
+	spin_unlock_irqrestore(&ring->lock, flags);
+	return 0;
+}
+
+int mausb_ring_buffer_init(struct mausb_ring_buffer *ring)
+{
+	unsigned int page_order =
+		mausb_get_page_order(2 * MAUSB_RING_BUFFER_SIZE,
+				     sizeof(struct mausb_event));
+	ring->to_user_buffer =
+		(struct mausb_event *)__get_free_pages(GFP_KERNEL, page_order);
+	if (!ring->to_user_buffer)
+		return -ENOMEM;
+	ring->from_user_buffer = ring->to_user_buffer + MAUSB_RING_BUFFER_SIZE;
+	ring->head = 0;
+	ring->tail = 0;
+	ring->current_from_user = 0;
+	ring->buffer_full = false;
+	spin_lock_init(&ring->lock);
+
+	return 0;
+}
+
+int mausb_ring_buffer_put(struct mausb_ring_buffer *ring,
+			  struct mausb_event *event)
+{
+	unsigned long flags = 0;
+
+	spin_lock_irqsave(&ring->lock, flags);
+
+	if (ring->buffer_full) {
+		mausb_pr_err("Ring buffer is full");
+		spin_unlock_irqrestore(&ring->lock, flags);
+		return -ENOSPC;
+	}
+
+	if (CIRC_SPACE(ring->head, ring->tail, MAUSB_RING_BUFFER_SIZE) < 2) {
+		mausb_pr_err("Ring buffer capacity exceeded, disconnecting device");
+		ring->buffer_full = true;
+		mausb_disconect_event_unsafe(ring, event->madev_addr);
+		ring->head = (ring->head + 1) & (MAUSB_RING_BUFFER_SIZE - 1);
+		spin_unlock_irqrestore(&ring->lock, flags);
+		return -ENOSPC;
+	}
+	memcpy(ring->to_user_buffer + ring->head, event, sizeof(*event));
+	mausb_pr_debug("HEAD=%d, TAIL=%d", ring->head, ring->tail);
+	ring->head = (ring->head + 1) & (MAUSB_RING_BUFFER_SIZE - 1);
+	mausb_pr_debug("HEAD=%d, TAIL=%d", ring->head, ring->tail);
+	spin_unlock_irqrestore(&ring->lock, flags);
+	return 0;
+}
+
+int mausb_ring_buffer_move_tail(struct mausb_ring_buffer *ring, u32 count)
+{
+	unsigned long flags = 0;
+
+	spin_lock_irqsave(&ring->lock, flags);
+	if (CIRC_CNT(ring->head, ring->tail, MAUSB_RING_BUFFER_SIZE) < count) {
+		spin_unlock_irqrestore(&ring->lock, flags);
+		return -ENOSPC;
+	}
+	mausb_pr_debug("old HEAD=%d, TAIL=%d", ring->head, ring->tail);
+	ring->tail = (ring->tail + (int)count) & (MAUSB_RING_BUFFER_SIZE - 1);
+	mausb_pr_debug("new HEAD=%d, TAIL=%d", ring->head, ring->tail);
+	spin_unlock_irqrestore(&ring->lock, flags);
+	return 0;
+}
+
+void mausb_ring_buffer_cleanup(struct mausb_ring_buffer *ring)
+{
+	struct mausb_event event;
+
+	while (mausb_ring_buffer_get(ring, &event) == 0)
+		mausb_cleanup_ring_buffer_event(&event);
+}
+
+void mausb_ring_buffer_destroy(struct mausb_ring_buffer *ring)
+{
+	unsigned int page_order =
+		mausb_get_page_order(2 * MAUSB_RING_BUFFER_SIZE,
+				     sizeof(struct mausb_event));
+	if (ring && ring->to_user_buffer)
+		free_pages((unsigned long)ring->to_user_buffer, page_order);
+}
+
+void mausb_cleanup_ring_buffer_event(struct mausb_event *event)
+{
+	mausb_pr_debug("event=%d", event->type);
+	switch (event->type) {
+	case MAUSB_EVENT_TYPE_SEND_DATA_MSG:
+		mausb_cleanup_send_data_msg_event(event);
+		break;
+	case MAUSB_EVENT_TYPE_RECEIVED_DATA_MSG:
+		mausb_cleanup_received_data_msg_event(event);
+		break;
+	case MAUSB_EVENT_TYPE_DELETE_DATA_TRANSFER:
+		mausb_cleanup_delete_data_transfer_event(event);
+		break;
+	case MAUSB_EVENT_TYPE_NONE:
+		break;
+	default:
+		mausb_pr_warn("Unknown event type");
+		break;
+	}
+}
+
+void mausb_disconect_event_unsafe(struct mausb_ring_buffer *ring,
+				  uint8_t madev_addr)
+{
+	struct mausb_event disconnect_event;
+	struct mausb_device *dev = mausb_get_dev_from_addr_unsafe(madev_addr);
+
+	if (!dev) {
+		mausb_pr_err("Device not found, madev_addr=%#x", madev_addr);
+		return;
+	}
+
+	disconnect_event.type = MAUSB_EVENT_TYPE_DEV_DISCONNECT;
+	disconnect_event.status = -EINVAL;
+	disconnect_event.madev_addr = madev_addr;
+
+	memcpy(ring->to_user_buffer + ring->head, &disconnect_event,
+	       sizeof(disconnect_event));
+
+	mausb_pr_info("Disconnect event added to ring buffer for madev_addr=%#x",
+		      madev_addr);
+	mausb_pr_info("Adding hcd_disconnect_work to dev workq, madev_addr=%#x",
+		      madev_addr);
+	queue_work(dev->workq, &dev->hcd_disconnect_work);
+}
diff --git a/drivers/usb/mausb_host/hpal.h b/drivers/usb/mausb_host/hpal.h
index a04ed120ba5e..24846d4bc4a3 100644
--- a/drivers/usb/mausb_host/hpal.h
+++ b/drivers/usb/mausb_host/hpal.h
@@ -67,6 +67,7 @@ struct mss {
 struct mausb_device {
 	struct mausb_device_address dev_addr;
 	struct net		    *net_ns;
+	struct mausb_ring_buffer    *ring_buffer;
 	struct list_head	    list_entry;
  	struct mausb_ip_ctx *mgmt_channel;
@@ -133,6 +134,10 @@ static inline u64 mausb_event_id(struct mausb_device *dev) int mausb_initiate_dev_connection(struct mausb_device_address device_address,
 				  u8 madev_address);
+int mausb_enqueue_event_from_user(u8 madev_addr, u16 num_of_events,
+				  u16 num_of_completed);
+int mausb_enqueue_event_to_user(struct mausb_device *dev,
+				struct mausb_event *event);
 int mausb_data_req_enqueue_event(struct mausb_device *dev, u16 ep_handle,
 				 struct urb *request);
int mausb_signal_event(struct mausb_device *dev, struct mausb_event *event, @@ -282,6 +287,33 @@ void mausb_reset_data_iterator(struct mausb_data_iter *iterator);
 void mausb_uninit_data_iterator(struct mausb_data_iter *iterator);
void mausb_data_iterator_seek(struct mausb_data_iter *iterator, u32 seek_delta);
 +struct mausb_ring_buffer {
+	atomic_t mausb_ring_events;
+	atomic_t mausb_completed_user_events;
+
+	struct mausb_event *to_user_buffer;
+	int		head;
+	int		tail;
+	spinlock_t	lock; /* Protect ring buffer */
+	u64		id;
+
+	struct mausb_event *from_user_buffer;
+	int current_from_user;
+
+	struct list_head list_entry;
+	bool buffer_full;
+};
+
+int mausb_ring_buffer_init(struct mausb_ring_buffer *ring);
+int mausb_ring_buffer_put(struct mausb_ring_buffer *ring,
+			  struct mausb_event *event);
+int mausb_ring_buffer_move_tail(struct mausb_ring_buffer *ring, u32 count);
+void mausb_ring_buffer_cleanup(struct mausb_ring_buffer *ring);
+void mausb_ring_buffer_destroy(struct mausb_ring_buffer *ring);
+void mausb_cleanup_ring_buffer_event(struct mausb_event *event);
+void mausb_disconect_event_unsafe(struct mausb_ring_buffer *ring,
+				  uint8_t madev_addr);
+
 static inline unsigned int mausb_get_page_order(unsigned int num_of_elems,
 						unsigned int elem_size)
 {
@@ -292,4 +324,16 @@ static inline unsigned int mausb_get_page_order(unsigned int num_of_elems,
 	return order;
 }
 +static inline
+struct mausb_event *mausb_ring_current_from_user(struct mausb_ring_buffer *ring)
+{
+	return ring->from_user_buffer + ring->current_from_user;
+}
+
+static inline void mausb_ring_next_from_user(struct mausb_ring_buffer *ring)
+{
+	ring->current_from_user = (ring->current_from_user + 1) &
+				  (MAUSB_RING_BUFFER_SIZE - 1);
+}
+
 #endif /* __MAUSB_HPAL_H__ */
diff --git a/drivers/usb/mausb_host/hpal_events.c b/drivers/usb/mausb_host/hpal_events.c
new file mode 100644
index 000000000000..6bec951213ea
--- /dev/null
+++ b/drivers/usb/mausb_host/hpal_events.c
@@ -0,0 +1,611 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2019 - 2020 DisplayLink (UK) Ltd.
+ */
+#include "hpal_events.h"
+
+#include <linux/slab.h>
+
+#include "hcd.h"
+#include "utils.h"
+
+void mausb_dev_reset_req_event(struct mausb_event *event)
+{
+	event->type = MAUSB_EVENT_TYPE_DEV_RESET;
+}
+
+static int mausb_mgmt_msg_received_event(struct mausb_event *event,
+					 struct ma_usb_hdr_common *hdr,
+					 enum mausb_channel channel)
+{
+	int status = 0;
+
+	mausb_pr_info("channel=%d, type=%d", channel, hdr->type);
+	if (hdr->length <= MAUSB_MAX_MGMT_SIZE) {
+		event->type = MAUSB_EVENT_TYPE_RECEIVED_MGMT_MSG;
+		memcpy(event->mgmt.mgmt_hdr.hdr, hdr, hdr->length);
+	} else {
+		mausb_pr_err("MGMT message to long, failed to copy");
+		status = -EINVAL;
+	}
+
+	kfree(hdr);
+	return status;
+}
+
+static int mausb_data_msg_received_event(struct mausb_event *event,
+					 struct ma_usb_hdr_common *hdr,
+					 enum mausb_channel channel)
+{
+	event->type		  = MAUSB_EVENT_TYPE_RECEIVED_DATA_MSG;
+	event->data.transfer_type = mausb_transfer_type_from_hdr(hdr);
+	event->data.device_id	  = (u16)((hdr->ssid << 8) | hdr->dev_addr);
+	event->data.ep_handle	  = hdr->handle.epv;
+	event->data.recv_buf	  = (u64)hdr;
+
+	memcpy(event->data.hdr, hdr, MAUSB_TRANSFER_HDR_SIZE);
+
+	if (mausb_ctrl_transfer(hdr) &&
+	    hdr->length <= 2 * MAUSB_TRANSFER_HDR_SIZE) {
+		memcpy(event->data.hdr_ack,
+		       shift_ptr(hdr, MAUSB_TRANSFER_HDR_SIZE),
+		       (size_t)(hdr->length - MAUSB_TRANSFER_HDR_SIZE));
+	}
+
+	return 0;
+}
+
+static int mausb_isoch_msg_received_event(struct mausb_event *event,
+					  struct ma_usb_hdr_common *hdr,
+					  enum mausb_channel channel)
+{
+	event->type		  = MAUSB_EVENT_TYPE_RECEIVED_DATA_MSG;
+	event->data.transfer_type = mausb_transfer_type_from_hdr(hdr);
+	event->data.device_id	  = (u16)((hdr->ssid << 8) | hdr->dev_addr);
+	event->data.ep_handle	  = hdr->handle.epv;
+	event->data.recv_buf	  = (u64)hdr;
+
+	memcpy(event->data.hdr, hdr, MAUSB_TRANSFER_HDR_SIZE);
+
+	return 0;
+}
+
+int mausb_msg_received_event(struct mausb_event *event,
+			     struct ma_usb_hdr_common *hdr,
+			     enum mausb_channel channel)
+{
+	mausb_pr_debug("channel=%d, type=%d", channel, hdr->type);
+	if (mausb_is_management_hdr_type(hdr->type))
+		return mausb_mgmt_msg_received_event(event, hdr, channel);
+	else if (hdr->type == MA_USB_HDR_TYPE_DATA_RESP(TRANSFER))
+		return mausb_data_msg_received_event(event, hdr, channel);
+	else if (hdr->type == MA_USB_HDR_TYPE_DATA_RESP(ISOCHTRANSFER))
+		return mausb_isoch_msg_received_event(event, hdr, channel);
+
+	kfree(hdr);
+	mausb_pr_warn("Unknown event type event=%d", hdr->type);
+	return -EBADR;
+}
+
+static void mausb_prepare_completion(struct mausb_completion *mausb_completion,
+				     struct completion *completion,
+				     struct mausb_event *event, u64 event_id)
+{
+	init_completion(completion);
+
+	mausb_completion->completion_event = completion;
+	mausb_completion->event_id	   = event_id;
+	mausb_completion->mausb_event	   = event;
+}
+
+static int mausb_wait_for_completion(struct mausb_event *event, u64 event_id,
+				     struct mausb_device *dev)
+{
+	struct completion	completion;
+	struct mausb_completion mausb_completion;
+	long status;
+	unsigned long timeout;
+
+	mausb_prepare_completion(&mausb_completion, &completion, event,
+				 event_id);
+	mausb_insert_event(dev, &mausb_completion);
+
+	status = mausb_enqueue_event_to_user(dev, event);
+	if (status < 0) {
+		mausb_remove_event(dev, &mausb_completion);
+		mausb_pr_err("Ring buffer full, event_id=%lld", event_id);
+		return (int)status;
+	}
+
+	timeout = msecs_to_jiffies(MANAGEMENT_EVENT_TIMEOUT);
+	status = wait_for_completion_interruptible_timeout(&completion,
+							   timeout);
+
+	mausb_remove_event(dev, &mausb_completion);
+
+	if (status == 0) {
+		queue_work(dev->workq, &dev->socket_disconnect_work);
+		queue_work(dev->workq, &dev->hcd_disconnect_work);
+		return -ETIMEDOUT;
+	}
+
+	return 0;
+}
+
+int mausb_usbdevhandle_event_to_user(struct mausb_device *dev,
+				     u8 device_speed,
+				     u32 route_string,
+				     u16 hub_dev_handle,
+				     u16 parent_hs_hub_dev_handle,
+				     u16 parent_hs_hub_port, u16 mtt,
+				     u8 lse, s32 *usb_dev_handle)
+{
+	struct mausb_event event;
+	int status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type = MAUSB_EVENT_TYPE_USB_DEV_HANDLE;
+	event.mgmt.dev_handle.device_speed	 = device_speed;
+	event.mgmt.dev_handle.route_string	 = route_string;
+	event.mgmt.dev_handle.hub_dev_handle	 = hub_dev_handle;
+	event.mgmt.dev_handle.parent_hs_hub_port = parent_hs_hub_port;
+	event.mgmt.dev_handle.mtt		 = mtt;
+	event.mgmt.dev_handle.lse		 = lse;
+	event.mgmt.dev_handle.event_id		 = event_id;
+	event.madev_addr			 = dev->madev_addr;
+	event.mgmt.dev_handle.parent_hs_hub_dev_handle =
+						   parent_hs_hub_dev_handle;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Usbdevhandle failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	if (event.status < 0)
+		return event.status;
+
+	*usb_dev_handle = event.mgmt.dev_handle.dev_handle;
+
+	return 0;
+}
+
+int mausb_usbdevhandle_event_from_user(struct mausb_device *dev,
+				       struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event, event->mgmt.dev_handle.event_id);
+}
+
+int mausb_ephandle_event_to_user(struct mausb_device *dev,
+				 u16 device_handle,
+				 u16 descriptor_size, void *descriptor,
+				 u16 *ep_handle)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type			     = MAUSB_EVENT_TYPE_EP_HANDLE;
+	event.mgmt.ep_handle.device_handle   = device_handle;
+	event.mgmt.ep_handle.descriptor_size = descriptor_size;
+	event.mgmt.ep_handle.event_id	     = event_id;
+	event.madev_addr		     = dev->madev_addr;
+
+	memcpy(event.mgmt.ep_handle.descriptor, descriptor, descriptor_size);
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Ephandle failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	if (event.status < 0)
+		return event.status;
+
+	*ep_handle = event.mgmt.ep_handle.ep_handle;
+
+	return 0;
+}
+
+int mausb_ephandle_event_from_user(struct mausb_device *dev,
+				   struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event, event->mgmt.ep_handle.event_id);
+}
+
+int mausb_epactivate_event_to_user(struct mausb_device *dev,
+				   u16 device_handle, u16 ep_handle)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type = MAUSB_EVENT_TYPE_EP_HANDLE_ACTIVATE;
+	event.mgmt.ep_activate.device_handle = device_handle;
+	event.mgmt.ep_activate.ep_handle     = ep_handle;
+	event.mgmt.ep_activate.event_id	     = event_id;
+	event.madev_addr		     = dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Epactivate failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_epactivate_event_from_user(struct mausb_device *dev,
+				     struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event,
+		event->mgmt.ep_activate.event_id);
+}
+
+int mausb_epinactivate_event_to_user(struct mausb_device *dev,
+				     u16 device_handle, u16 ep_handle)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type = MAUSB_EVENT_TYPE_EP_HANDLE_INACTIVATE;
+	event.mgmt.ep_inactivate.device_handle	= device_handle;
+	event.mgmt.ep_inactivate.ep_handle	= ep_handle;
+	event.mgmt.ep_inactivate.event_id	= event_id;
+	event.madev_addr			= dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Epinactivate failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_epinactivate_event_from_user(struct mausb_device *dev,
+				       struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event,
+				  event->mgmt.ep_inactivate.event_id);
+}
+
+int mausb_epreset_event_to_user(struct mausb_device *dev,
+				u16 device_handle, u16 ep_handle,
+				u8 tsp_flag)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type			  = MAUSB_EVENT_TYPE_EP_HANDLE_RESET;
+	event.mgmt.ep_reset.device_handle = device_handle;
+	event.mgmt.ep_reset.ep_handle	  = ep_handle;
+	event.mgmt.ep_reset.tsp		  = tsp_flag;
+	event.mgmt.ep_reset.event_id	  = event_id;
+	event.madev_addr		  = dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Epreset failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_epreset_event_from_user(struct mausb_device *dev,
+				  struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event, event->mgmt.ep_reset.event_id);
+}
+
+int mausb_epdelete_event_to_user(struct mausb_device *dev,
+				 u16 device_handle, u16 ep_handle)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type			   = MAUSB_EVENT_TYPE_EP_HANDLE_DELETE;
+	event.mgmt.ep_delete.device_handle = device_handle;
+	event.mgmt.ep_delete.ep_handle	   = ep_handle;
+	event.mgmt.ep_delete.event_id	   = event_id;
+	event.madev_addr		   = dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Epdelete failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_epdelete_event_from_user(struct mausb_device *dev,
+				   struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event, event->mgmt.ep_delete.event_id);
+}
+
+int mausb_modifyep0_event_to_user(struct mausb_device *dev,
+				  u16 device_handle, u16 *ep_handle,
+				  __le16 max_packet_size)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type				= MAUSB_EVENT_TYPE_MODIFY_EP0;
+	event.mgmt.modify_ep0.device_handle	= device_handle;
+	event.mgmt.modify_ep0.ep_handle		= *ep_handle;
+	event.mgmt.modify_ep0.max_packet_size	= max_packet_size;
+	event.mgmt.modify_ep0.event_id		= event_id;
+	event.madev_addr			= dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Modifyep0 failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	if (event.status < 0)
+		return event.status;
+
+	*ep_handle = event.mgmt.modify_ep0.ep_handle;
+
+	return 0;
+}
+
+int mausb_modifyep0_event_from_user(struct mausb_device *dev,
+				    struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event, event->mgmt.modify_ep0.event_id);
+}
+
+int mausb_setusbdevaddress_event_to_user(struct mausb_device *dev,
+					 u16 device_handle,
+					 u16 response_timeout)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type = MAUSB_EVENT_TYPE_SET_USB_DEV_ADDRESS;
+	event.mgmt.set_usb_dev_address.device_handle	= device_handle;
+	event.mgmt.set_usb_dev_address.response_timeout	= response_timeout;
+	event.mgmt.set_usb_dev_address.event_id		= event_id;
+	event.madev_addr				= dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Setusbdevaddress failed, event_id=%lld",
+			     event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_setusbdevaddress_event_from_user(struct mausb_device *dev,
+					   struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event,
+		event->mgmt.set_usb_dev_address.event_id);
+}
+
+static void
+mausb_init_device_descriptor(struct ma_usb_updatedevreq_desc *update_descriptor,
+			     struct usb_device_descriptor *device_descriptor)
+{
+	update_descriptor->usb20.bLength = device_descriptor->bLength;
+	update_descriptor->usb20.bDescriptorType =
+					device_descriptor->bDescriptorType;
+	update_descriptor->usb20.bcdUSB = device_descriptor->bcdUSB;
+	update_descriptor->usb20.bDeviceClass =
+					device_descriptor->bDeviceClass;
+	update_descriptor->usb20.bDeviceSubClass =
+					device_descriptor->bDeviceSubClass;
+	update_descriptor->usb20.bDeviceProtocol =
+					device_descriptor->bDeviceProtocol;
+	update_descriptor->usb20.bMaxPacketSize0 =
+					device_descriptor->bMaxPacketSize0;
+	update_descriptor->usb20.idVendor  = device_descriptor->idVendor;
+	update_descriptor->usb20.idProduct = device_descriptor->idProduct;
+	update_descriptor->usb20.bcdDevice = device_descriptor->bcdDevice;
+	update_descriptor->usb20.iManufacturer =
+					device_descriptor->iManufacturer;
+	update_descriptor->usb20.iProduct  = device_descriptor->iProduct;
+	update_descriptor->usb20.iSerialNumber =
+					device_descriptor->iSerialNumber;
+	update_descriptor->usb20.bNumConfigurations =
+					device_descriptor->bNumConfigurations;
+}
+
+int mausb_updatedev_event_to_user(struct mausb_device *dev,
+				  u16 device_handle,
+				  u16 max_exit_latency, u8 hub,
+				  u8 number_of_ports, u8 mtt,
+				  u8 ttt, u8 integrated_hub_latency,
+				  struct usb_device_descriptor *dev_descriptor)
+{
+	struct mausb_event event;
+	int status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type = MAUSB_EVENT_TYPE_UPDATE_DEV;
+	event.mgmt.update_dev.device_handle	     = device_handle;
+	event.mgmt.update_dev.max_exit_latency	     = max_exit_latency;
+	event.mgmt.update_dev.hub		     = hub;
+	event.mgmt.update_dev.number_of_ports	     = number_of_ports;
+	event.mgmt.update_dev.mtt		     = mtt;
+	event.mgmt.update_dev.ttt		     = ttt;
+	event.mgmt.update_dev.integrated_hub_latency = integrated_hub_latency;
+	event.mgmt.update_dev.event_id		     = event_id;
+	event.madev_addr			     = dev->madev_addr;
+
+	mausb_init_device_descriptor(&event.mgmt.update_dev.update_descriptor,
+				     dev_descriptor);
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Updatedev failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_updatedev_event_from_user(struct mausb_device *dev,
+				    struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event, event->mgmt.update_dev.event_id);
+}
+
+int mausb_usbdevdisconnect_event_to_user(struct mausb_device *dev,
+					 u16 dev_handle)
+{
+	struct mausb_event event;
+	int status;
+
+	event.type = MAUSB_EVENT_TYPE_USB_DEV_DISCONNECT;
+	event.mgmt.usb_dev_disconnect.device_handle = dev_handle;
+	event.madev_addr			    = dev->madev_addr;
+
+	status = mausb_enqueue_event_to_user(dev, &event);
+	if (status < 0)
+		mausb_pr_err("Ring buffer full, usbdevdisconnect failed");
+
+	return status;
+}
+
+int mausb_ping_event_to_user(struct mausb_device *dev)
+{
+	struct mausb_event event;
+	int status;
+
+	event.type	 = MAUSB_EVENT_TYPE_PING;
+	event.madev_addr = dev->madev_addr;
+
+	status = mausb_enqueue_event_to_user(dev, &event);
+	if (status < 0)
+		mausb_pr_err("Ring buffer full, devdisconnect failed");
+
+	return status;
+}
+
+__attribute__((unused))
+static int mausb_devdisconnect_event_to_user(struct mausb_device *dev)
+{
+	struct mausb_event event;
+	int status;
+
+	event.type	 = MAUSB_EVENT_TYPE_DEV_DISCONNECT;
+	event.madev_addr = dev->madev_addr;
+
+	status = mausb_enqueue_event_to_user(dev, &event);
+	if (status < 0)
+		mausb_pr_err("Ring buffer full, devdisconnect failed");
+
+	return status;
+}
+
+int mausb_usbdevreset_event_to_user(struct mausb_device *dev,
+				    u16 device_handle)
+{
+	struct mausb_event event;
+	int  status;
+	u64 event_id = mausb_event_id(dev);
+
+	event.type			       = MAUSB_EVENT_TYPE_USB_DEV_RESET;
+	event.mgmt.usb_dev_reset.device_handle = device_handle;
+	event.mgmt.usb_dev_reset.event_id      = event_id;
+	event.madev_addr		       = dev->madev_addr;
+
+	status = mausb_wait_for_completion(&event, event_id, dev);
+
+	if (status < 0) {
+		mausb_pr_err("Usbdevreset failed, event_id=%lld", event_id);
+		return status;
+	}
+
+	return event.status;
+}
+
+int mausb_usbdevreset_event_from_user(struct mausb_device *dev,
+				      struct mausb_event *event)
+{
+	return mausb_signal_event(dev, event,
+				  event->mgmt.usb_dev_reset.event_id);
+}
+
+int mausb_canceltransfer_event_to_user(struct mausb_device *dev,
+				       u16 device_handle,
+				       u16 ep_handle, u64 urb)
+{
+	struct mausb_event event;
+	int status;
+
+	event.type = MAUSB_EVENT_TYPE_CANCEL_TRANSFER;
+	event.mgmt.cancel_transfer.device_handle = device_handle;
+	event.mgmt.cancel_transfer.ep_handle	 = ep_handle;
+	event.mgmt.cancel_transfer.urb		 = urb;
+	event.madev_addr			 = dev->madev_addr;
+
+	status = mausb_enqueue_event_to_user(dev, &event);
+	if (status < 0) {
+		mausb_pr_err("Ring buffer full, canceltransfer failed");
+		return status;
+	}
+
+	return status;
+}
+
+int mausb_canceltransfer_event_from_user(struct mausb_device *dev,
+					 struct mausb_event *event)
+{
+	mausb_pr_debug("");
+	return 0;
+}
+
+void mausb_cleanup_send_data_msg_event(struct mausb_event *event)
+{
+	mausb_complete_urb(event);
+}
+
+void mausb_cleanup_received_data_msg_event(struct mausb_event *event)
+{
+	mausb_release_event_resources(event);
+}
+
+void mausb_cleanup_delete_data_transfer_event(struct mausb_event *event)
+{
+	struct urb *urb = (struct urb *)event->data.urb;
+	struct mausb_urb_ctx *urb_ctx;
+	int status = 0;
+
+	urb_ctx = mausb_unlink_and_delete_urb_from_tree(urb, status);
+	if (!urb_ctx) {
+		mausb_pr_warn("Urb=%p is not in tree", urb);
+		return;
+	}
+
+	/* Deallocate urb_ctx */
+	mausb_uninit_data_iterator(&urb_ctx->iterator);
+	kfree(urb_ctx);
+
+	urb->status = -EPROTO;
+	urb->actual_length = 0;
+	atomic_dec(&urb->use_count);
+	usb_hcd_giveback_urb(urb->hcpriv, urb, urb->status);
+}
diff --git a/drivers/usb/mausb_host/hpal_events.h b/drivers/usb/mausb_host/hpal_events.h
new file mode 100644
index 000000000000..fb424d526b12
--- /dev/null
+++ b/drivers/usb/mausb_host/hpal_events.h
@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2019 - 2020 DisplayLink (UK) Ltd.
+ */
+#ifndef __MAUSB_HPAL_EVENTS_H__
+#define __MAUSB_HPAL_EVENTS_H__
+
+#include "hpal.h"
+#include "ip_link.h"
+#include "mausb_event.h"
+
+#define MANAGEMENT_EVENT_TIMEOUT 3000
+
+int mausb_msg_received_event(struct mausb_event *event,
+			     struct ma_usb_hdr_common *hdr,
+			     enum mausb_channel channel);
+int mausb_usbdevhandle_event_to_user(struct mausb_device *dev,
+				     u8 device_speed,
+				     u32 route_string,
+				     u16 hub_dev_handle,
+				     u16 parent_hs_hub_dev_handle,
+				     u16 parent_hs_hub_port, u16 mtt,
+				     u8 lse, s32 *usb_dev_handle);
+int mausb_usbdevhandle_event_from_user(struct mausb_device *dev,
+				       struct mausb_event *event);
+int mausb_ephandle_event_to_user(struct mausb_device *dev, u16 device_handle,
+				 u16 descriptor_size, void *descriptor,
+				 u16 *ep_handle);
+int mausb_ephandle_event_from_user(struct mausb_device *dev,
+				   struct mausb_event *event);
+int mausb_epactivate_event_to_user(struct mausb_device *dev,
+				   u16 device_handle, u16 ep_handle);
+int mausb_epactivate_event_from_user(struct mausb_device *dev,
+				     struct mausb_event *event);
+int mausb_epinactivate_event_to_user(struct mausb_device *dev,
+				     u16 device_handle,
+				     u16 ep_handle);
+int mausb_epinactivate_event_from_user(struct mausb_device *dev,
+				       struct mausb_event *event);
+int mausb_epreset_event_to_user(struct mausb_device *dev,
+				u16 device_handle, u16 ep_handle,
+				u8 tsp_flag);
+int mausb_epreset_event_from_user(struct mausb_device *dev,
+				  struct mausb_event *event);
+int mausb_epdelete_event_to_user(struct mausb_device *dev,
+				 u16 device_handle, u16 ep_handle);
+int mausb_epdelete_event_from_user(struct mausb_device *dev,
+				   struct mausb_event *event);
+int mausb_modifyep0_event_to_user(struct mausb_device *dev,
+				  u16 device_handle, u16 *ep_handle,
+				  __le16 max_packet_size);
+int mausb_modifyep0_event_from_user(struct mausb_device *dev,
+				    struct mausb_event *event);
+int mausb_setusbdevaddress_event_to_user(struct mausb_device *dev,
+					 u16 device_handle,
+					 u16 response_timeout);
+int mausb_setusbdevaddress_event_from_user(struct mausb_device *dev,
+					   struct mausb_event *event);
+int mausb_updatedev_event_to_user(struct mausb_device *dev,
+				  u16 device_handle,
+				  u16 max_exit_latency, u8 hub,
+				  u8 number_of_ports, u8 mtt,
+				  u8 ttt, u8 integrated_hub_latency,
+				  struct usb_device_descriptor *dev_descriptor);
+int mausb_updatedev_event_from_user(struct mausb_device *dev,
+				    struct mausb_event *event);
+int mausb_usbdevdisconnect_event_to_user(struct mausb_device *dev,
+					 u16 dev_handle);
+int mausb_ping_event_to_user(struct mausb_device *dev);
+int mausb_usbdevreset_event_to_user(struct mausb_device *dev,
+				    u16 device_handle);
+int mausb_usbdevreset_event_from_user(struct mausb_device *dev,
+				      struct mausb_event *event);
+int mausb_canceltransfer_event_to_user(struct mausb_device *dev,
+				       u16 device_handle,
+				       u16 ep_handle, u64 urb);
+int mausb_canceltransfer_event_from_user(struct mausb_device *dev,
+					 struct mausb_event *event);
+
+void mausb_dev_reset_req_event(struct mausb_event *event);
+void mausb_cleanup_send_data_msg_event(struct mausb_event *event);
+void mausb_cleanup_received_data_msg_event(struct mausb_event *event);
+void mausb_cleanup_delete_data_transfer_event(struct mausb_event *event);
+
+#endif /* __MAUSB_HPAL_EVENTS_H__ */
diff --git a/drivers/usb/mausb_host/mausb_driver_status.h b/drivers/usb/mausb_host/mausb_driver_status.h
new file mode 100644
index 000000000000..9b55befe9cae
--- /dev/null
+++ b/drivers/usb/mausb_host/mausb_driver_status.h
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2019 - 2020 DisplayLink (UK) Ltd.
+ */
+#ifndef __MAUSB_MAUSB_DRIVER_STATUS_H__
+#define __MAUSB_MAUSB_DRIVER_STATUS_H__
+
+#define MAUSB_DRIVER_BAD_READ_BUFFER_SIZE  -1
+#define MAUSB_DRIVER_RING_EVENTS_STOPPED   -2
+#define MAUSB_DRIVER_SYSTEM_SUSPENDED      -3
+#define MAUSB_DRIVER_COPY_TO_BUFFER_FAILED -4
+
+#define MAUSB_DRIVER_READ_TIMEOUT 0
+#define MAUSB_DRIVER_READ_ERROR  -1
+#define MAUSB_DRIVER_WRITE_ERROR  -2
+
+#endif /* __MAUSB_MAUSB_DRIVER_STATUS_H__ */
diff --git a/drivers/usb/mausb_host/utils.c b/drivers/usb/mausb_host/utils.c
index c055b578e402..643671821709 100644
--- a/drivers/usb/mausb_host/utils.c
+++ b/drivers/usb/mausb_host/utils.c
@@ -13,6 +13,8 @@
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 +#include "mausb_driver_status.h"
+
 #define MAUSB_KERNEL_DEV_NAME "mausb_host"
 #define MAUSB_READ_DEVICE_TIMEOUT_MS 500
 @@ -20,6 +22,47 @@ static dev_t mausb_major_kernel;
 static struct cdev  mausb_kernel_dev;
 static struct class *mausb_kernel_class;
 +static void mausb_vm_open(struct vm_area_struct *vma)
+{
+	mausb_pr_debug("");
+}
+
+static void mausb_vm_close(struct vm_area_struct *vma)
+{
+	struct mausb_ring_buffer *buffer = NULL, *next = NULL;
+	unsigned long flags = 0;
+	u64 ring_buffer_id = *(u64 *)(vma->vm_private_data);
+
+	mausb_pr_info("Releasing ring buffer with id: %llu", ring_buffer_id);
+	spin_lock_irqsave(&mss.lock, flags);
+	list_for_each_entry_safe(buffer, next, &mss.available_ring_buffers,
+				 list_entry) {
+		if (buffer->id == ring_buffer_id) {
+			list_del(&buffer->list_entry);
+			mausb_ring_buffer_destroy(buffer);
+			kfree(buffer);
+			break;
+		}
+	}
+	spin_unlock_irqrestore(&mss.lock, flags);
+}
+
+/*
+ * mausb_vm_fault is called the first time a memory area is accessed which is
+ * not in memory
+ */
+static vm_fault_t mausb_vm_fault(struct vm_fault *vmf)
+{
+	mausb_pr_debug("");
+	return 0;
+}
+
+static const struct vm_operations_struct mausb_vm_ops = {
+	.open  = mausb_vm_open,
+	.close = mausb_vm_close,
+	.fault = mausb_vm_fault,
+};
+
 static int mausb_file_open(struct inode *inode, struct file *filp)
 {
 	filp->private_data = NULL;
@@ -35,9 +78,215 @@ static int mausb_file_close(struct inode *inode, struct file *filp)
 	return 0;
 }
+static ssize_t mausb_file_read(struct file *filp, char __user *user_buffer,
+			       size_t size, loff_t *offset)
+{
+	ssize_t num_of_bytes_to_read = MAUSB_MAX_NUM_OF_MA_DEVS *
+				       sizeof(struct mausb_events_notification);
+	unsigned long num_of_bytes_not_copied;
+	int completed_events;
+	int ring_events;
+	struct mausb_ring_buffer *ring_buffer;
+	struct mausb_device	 *dev;
+	struct completion	 *ring_has_events;
+	u8 current_device = 0;
+	s8 fail_ret_val;
+	unsigned long flags;
+	unsigned long timeout;
+	long status;
+
+	/* Reset heartbeat timer events */
+	mausb_reset_heartbeat_cnt();
+
+	if ((ssize_t)size != num_of_bytes_to_read) {
+ mausb_pr_alert("Different expected bytes to read (%ld) from actual size (%ld)",
+			       num_of_bytes_to_read, size);
+		fail_ret_val = MAUSB_DRIVER_BAD_READ_BUFFER_SIZE;
+		if (copy_to_user(user_buffer, &fail_ret_val,
+				 sizeof(fail_ret_val)) != 0) {
+			mausb_pr_warn("Failed to set error code.");
+		}
+		return MAUSB_DRIVER_READ_ERROR;
+	}
+
+	/* If suspend/hibernate happened delete all devices */
+	if (atomic_xchg(&mss.num_of_transitions_to_sleep, 0)) {
+		mausb_pr_alert("Suspend system event detected");
+		fail_ret_val = MAUSB_DRIVER_SYSTEM_SUSPENDED;
+		if (copy_to_user(user_buffer, &fail_ret_val,
+				 sizeof(fail_ret_val)) != 0) {
+			mausb_pr_warn("Failed to set error code.");
+		}
+		return MAUSB_DRIVER_READ_ERROR;
+	}
+
+	ring_has_events = &mss.rings_events.mausb_ring_has_events;
+	timeout = msecs_to_jiffies(MAUSB_READ_DEVICE_TIMEOUT_MS);
+	status = wait_for_completion_interruptible_timeout(ring_has_events,
+							   timeout);
+	reinit_completion(ring_has_events);
+
+	if (atomic_read(&mss.rings_events.mausb_stop_reading_ring_events)) {
+		mausb_pr_alert("Ring events stopped");
+		fail_ret_val = MAUSB_DRIVER_RING_EVENTS_STOPPED;
+		if (copy_to_user(user_buffer, &fail_ret_val,
+				 sizeof(fail_ret_val)) != 0) {
+			mausb_pr_warn("Failed to set error code.");
+		}
+		return MAUSB_DRIVER_READ_ERROR;
+	}
+
+	/* There are no new events - waiting for events hit timeout */
+	if (status == 0)
+		return MAUSB_DRIVER_READ_TIMEOUT;
+
+	spin_lock_irqsave(&mss.lock, flags);
+
+	list_for_each_entry(dev, &mss.madev_list, list_entry) {
+		mss.events[current_device].madev_addr = dev->madev_addr;
+		ring_buffer = dev->ring_buffer;
+		ring_events = atomic_xchg(&ring_buffer->mausb_ring_events, 0);
+		completed_events =
+			atomic_xchg(&ring_buffer->mausb_completed_user_events,
+				    0);
+		mss.events[current_device].num_of_events = (u16)ring_events;
+		mss.events[current_device].num_of_completed_events =
+				(u16)completed_events;
+		if (++current_device == MAUSB_MAX_NUM_OF_MA_DEVS)
+			break;
+	}
+
+	spin_unlock_irqrestore(&mss.lock, flags);
+
+	num_of_bytes_to_read =
+		(ssize_t)(current_device *
+			  sizeof(struct mausb_events_notification));
+	num_of_bytes_not_copied =
+		copy_to_user(user_buffer, &mss.events,
+			     (unsigned long)num_of_bytes_to_read);
+
+	mausb_pr_debug("num_of_bytes_not_copied %ld, num_of_bytes_to_read %ld",
+		       num_of_bytes_not_copied, num_of_bytes_to_read);
+
+	if (num_of_bytes_not_copied) {
+		fail_ret_val = MAUSB_DRIVER_COPY_TO_BUFFER_FAILED;
+		if (copy_to_user(user_buffer, &fail_ret_val,
+				 sizeof(fail_ret_val)) != 0) {
+			mausb_pr_warn("Failed to set error code.");
+		}
+		return MAUSB_DRIVER_READ_ERROR;
+	}
+
+	return num_of_bytes_to_read;
+}
+
+static ssize_t mausb_file_write(struct file *filp, const char __user *buffer,
+				size_t size, loff_t *offset)
+{
+	ssize_t num_of_bytes_to_write =
+				sizeof(struct mausb_events_notification);
+	struct mausb_events_notification notification;
+	unsigned long flags;
+	struct mausb_device *dev;
+
+	if (size != (size_t)num_of_bytes_to_write) {
+ mausb_pr_alert("Different expected bytes to write (%ld) from actual size (%ld)",
+			       num_of_bytes_to_write, size);
+		return MAUSB_DRIVER_WRITE_ERROR;
+	}
+
+	if (copy_from_user(&notification, buffer, size))
+		return MAUSB_DRIVER_WRITE_ERROR;
+
+	spin_lock_irqsave(&mss.lock, flags);
+	dev = mausb_get_dev_from_addr_unsafe(notification.madev_addr);
+
+	if (!dev) {
+		spin_unlock_irqrestore(&mss.lock, flags);
+		return 0;
+	}
+
+	spin_lock_irqsave(&dev->num_of_user_events_lock, flags);
+	dev->num_of_user_events += notification.num_of_events;
+	dev->num_of_completed_events += notification.num_of_completed_events;
+	spin_unlock_irqrestore(&dev->num_of_user_events_lock, flags);
+
+	queue_work(dev->workq, &dev->work);
+	spin_unlock_irqrestore(&mss.lock, flags);
+
+	return num_of_bytes_to_write;
+}
+
+static inline unsigned long mausb_ring_buffer_length(void)
+{
+	int page_order = mausb_get_page_order(2 * MAUSB_RING_BUFFER_SIZE,
+					      sizeof(struct mausb_event));
+	return PAGE_SIZE << page_order;
+}
+
+static int mausb_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	unsigned long size = vma->vm_end - vma->vm_start;
+	int ret;
+	struct page *page = NULL;
+	unsigned long flags = 0;
+	struct mausb_ring_buffer *ring_buffer = kzalloc(sizeof(*ring_buffer),
+							GFP_KERNEL);
+	if (!ring_buffer)
+		return -ENOMEM;
+
+	ret = mausb_ring_buffer_init(ring_buffer);
+	if (ret < 0) {
+		mausb_pr_err("Ring buffer init failed");
+		goto release_ring_buffer;
+	}
+
+	vma->vm_private_data = kzalloc(sizeof(ring_buffer->id), GFP_KERNEL);
+	if (!vma->vm_private_data) {
+		ret = -ENOMEM;
+		goto release_ring_buffer;
+	}
+
+	filp->private_data = vma->vm_private_data;
+
+	if (size > mausb_ring_buffer_length()) {
+		mausb_pr_err("Invalid memory size to map");
+		ret = -EINVAL;
+		goto release_ring_buffer;
+	}
+
+	vma->vm_ops = &mausb_vm_ops;
+	mausb_vm_open(vma);
+
+	page = virt_to_page(ring_buffer->to_user_buffer);
+	ret = remap_pfn_range(vma, vma->vm_start, page_to_pfn(page), size,
+			      vma->vm_page_prot);
+	if (ret < 0) {
+		mausb_pr_err("Could not map the address area");
+		goto release_ring_buffer;
+	}
+
+	spin_lock_irqsave(&mss.lock, flags);
+	ring_buffer->id = mss.ring_buffer_id++;
+	*(u64 *)(vma->vm_private_data) = ring_buffer->id;
+	list_add_tail(&ring_buffer->list_entry, &mss.available_ring_buffers);
+	mausb_pr_info("Allocated ring buffer with id: %llu", ring_buffer->id);
+	spin_unlock_irqrestore(&mss.lock, flags);
+
+	return 0;
+
+release_ring_buffer:
+	mausb_ring_buffer_destroy(ring_buffer);
+	kfree(ring_buffer);
+	return ret;
+}
+
 static const struct file_operations mausb_file_ops = {
 	.open	 = mausb_file_open,
 	.release = mausb_file_close,
+	.read	 = mausb_file_read,
+	.write   = mausb_file_write,
+	.mmap	 = mausb_mmap,
 };
  int mausb_create_dev(void)
@@ -83,3 +332,29 @@ void mausb_cleanup_dev(int device_created)
  	unregister_chrdev_region(mausb_major_kernel, 1);
 }
+
+void mausb_notify_completed_user_events(struct mausb_ring_buffer *ring_buffer)
+{
+	int completed;
+
+	completed =
+		atomic_inc_return(&ring_buffer->mausb_completed_user_events);
+	mausb_pr_debug("mausb_completed_user_events INCREMENTED %d", completed);
+	if (completed > MAUSB_RING_BUFFER_SIZE / 16)
+		complete(&mss.rings_events.mausb_ring_has_events);
+}
+
+void mausb_notify_ring_events(struct mausb_ring_buffer *ring_buffer)
+{
+	int events;
+
+	events = atomic_inc_return(&ring_buffer->mausb_ring_events);
+	if (events == 1)
+		complete(&mss.rings_events.mausb_ring_has_events);
+}
+
+void mausb_stop_ring_events(void)
+{
+	atomic_set(&mss.rings_events.mausb_stop_reading_ring_events, 1);
+	complete(&mss.rings_events.mausb_ring_has_events);
+}
diff --git a/drivers/usb/mausb_host/utils.h b/drivers/usb/mausb_host/utils.h
index 699f94fcb75b..e3ddb12afadd 100644
--- a/drivers/usb/mausb_host/utils.h
+++ b/drivers/usb/mausb_host/utils.h
@@ -5,6 +5,8 @@
 #ifndef __MAUSB_UTILS_H__
 #define __MAUSB_UTILS_H__
 +#include "hpal.h"
+
 #if defined(MAUSB_NO_LOGS)
 #define mausb_pr_logs(...)
 #else
@@ -36,5 +38,8 @@
  int mausb_create_dev(void);
 void mausb_cleanup_dev(int device_created);
+void mausb_notify_completed_user_events(struct mausb_ring_buffer *ring_buffer);
+void mausb_notify_ring_events(struct mausb_ring_buffer *ring_buffer);
+void mausb_stop_ring_events(void);
  #endif /* __MAUSB_UTILS_H__ */
--
2.17.1







[Index of Archives]     [Linux Media]     [Linux Input]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Old Linux USB Devel Archive]

  Powered by Linux